permission.ts 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307
  1. export * as PermissionV2 from "./permission"
  2. import { Context, Deferred, Effect as EffectRuntime, Layer, Schema } from "effect"
  3. import { EventV2 } from "./event"
  4. import { Location } from "./location"
  5. import { AgentV2 } from "./agent"
  6. import { SessionV2 } from "./session"
  7. import { withStatics } from "./schema"
  8. import { Identifier } from "./util/identifier"
  9. import { Wildcard } from "./util/wildcard"
  10. import { PermissionSchema } from "./permission/schema"
  11. import { PermissionSaved } from "./permission/saved"
  12. export { Effect, Rule, Ruleset } from "./permission/schema"
  13. type Effect = PermissionSchema.Effect
  14. type Rule = PermissionSchema.Rule
  15. type Ruleset = PermissionSchema.Ruleset
  16. export const ID = Schema.String.check(Schema.isStartsWith("per")).pipe(
  17. Schema.brand("PermissionV2.ID"),
  18. withStatics((schema) => ({ create: (id?: string) => schema.make(id ?? "per_" + Identifier.ascending()) })),
  19. )
  20. export type ID = typeof ID.Type
  21. export const Source = Schema.Union([
  22. Schema.Struct({
  23. type: Schema.Literal("tool"),
  24. messageID: Schema.String,
  25. callID: Schema.String,
  26. }),
  27. ]).annotate({ identifier: "PermissionV2.Source" })
  28. export type Source = typeof Source.Type
  29. export const Request = Schema.Struct({
  30. id: ID,
  31. sessionID: SessionV2.ID,
  32. action: Schema.String,
  33. resources: Schema.Array(Schema.String),
  34. save: Schema.Array(Schema.String).pipe(Schema.optional),
  35. metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
  36. source: Source.pipe(Schema.optional),
  37. }).annotate({ identifier: "PermissionV2.Request" })
  38. export type Request = typeof Request.Type
  39. export const Reply = Schema.Literals(["once", "always", "reject"]).annotate({ identifier: "PermissionV2.Reply" })
  40. export type Reply = typeof Reply.Type
  41. export const AssertInput = Schema.Struct({
  42. id: ID.pipe(Schema.optional),
  43. sessionID: SessionV2.ID,
  44. action: Schema.String,
  45. resources: Schema.Array(Schema.String),
  46. save: Schema.Array(Schema.String).pipe(Schema.optional),
  47. metadata: Schema.Record(Schema.String, Schema.Unknown).pipe(Schema.optional),
  48. source: Source.pipe(Schema.optional),
  49. }).annotate({ identifier: "PermissionV2.AssertInput" })
  50. export type AssertInput = typeof AssertInput.Type
  51. export const ReplyInput = Schema.Struct({
  52. requestID: ID,
  53. reply: Reply,
  54. message: Schema.String.pipe(Schema.optional),
  55. }).annotate({ identifier: "PermissionV2.ReplyInput" })
  56. export type ReplyInput = typeof ReplyInput.Type
  57. export const AskResult = Schema.Struct({
  58. id: ID,
  59. effect: PermissionSchema.Effect,
  60. }).annotate({ identifier: "PermissionV2.AskResult" })
  61. export type AskResult = typeof AskResult.Type
  62. export const Event = {
  63. Asked: EventV2.define({ type: "permission.v2.asked", schema: Request.fields }),
  64. Replied: EventV2.define({
  65. type: "permission.v2.replied",
  66. schema: {
  67. sessionID: SessionV2.ID,
  68. requestID: ID,
  69. reply: Reply,
  70. },
  71. }),
  72. }
  73. export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionV2.RejectedError", {}) {}
  74. export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("PermissionV2.CorrectedError", {
  75. feedback: Schema.String,
  76. }) {}
  77. export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionV2.DeniedError", {
  78. rules: PermissionSchema.Ruleset,
  79. }) {}
  80. export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("PermissionV2.NotFoundError", {
  81. requestID: ID,
  82. }) {}
  83. export type Error = DeniedError | RejectedError | CorrectedError
  84. export function evaluate(action: string, resource: string, ...rulesets: Ruleset[]): Rule {
  85. return (
  86. rulesets
  87. .flat()
  88. .findLast((rule) => Wildcard.match(action, rule.action) && Wildcard.match(resource, rule.resource)) ?? {
  89. action,
  90. resource: "*",
  91. effect: "ask",
  92. }
  93. )
  94. }
  95. export function merge(...rulesets: Ruleset[]): Ruleset {
  96. return rulesets.flat()
  97. }
  98. export interface Interface {
  99. readonly ask: (input: AssertInput) => EffectRuntime.Effect<AskResult, SessionV2.NotFoundError>
  100. readonly assert: (input: AssertInput) => EffectRuntime.Effect<void, Error | SessionV2.NotFoundError>
  101. readonly reply: (input: ReplyInput) => EffectRuntime.Effect<void, NotFoundError>
  102. readonly get: (id: ID) => EffectRuntime.Effect<Request | undefined>
  103. readonly forSession: (sessionID: SessionV2.ID) => EffectRuntime.Effect<ReadonlyArray<Request>>
  104. readonly list: () => EffectRuntime.Effect<ReadonlyArray<Request>>
  105. }
  106. export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Permission") {}
  107. interface Pending {
  108. readonly request: Request
  109. readonly deferred: Deferred.Deferred<void, RejectedError | CorrectedError>
  110. }
  111. export const layer = Layer.effect(
  112. Service,
  113. EffectRuntime.gen(function* () {
  114. const events = yield* EventV2.Service
  115. const location = yield* Location.Service
  116. const agents = yield* AgentV2.Service
  117. const sessions = yield* SessionV2.Service
  118. const saved = yield* PermissionSaved.Service
  119. const pending = new Map<ID, Pending>()
  120. yield* EffectRuntime.addFinalizer(() =>
  121. EffectRuntime.forEach(pending.values(), (item) => Deferred.fail(item.deferred, new RejectedError()), {
  122. discard: true,
  123. }).pipe(
  124. EffectRuntime.ensuring(
  125. EffectRuntime.sync(() => {
  126. pending.clear()
  127. }),
  128. ),
  129. ),
  130. )
  131. const savedRules = EffectRuntime.fnUntraced(function* () {
  132. return (yield* saved.list({ projectID: location.project.id })).map(
  133. (item): Rule => ({ action: item.action, resource: item.resource, effect: "allow" }),
  134. )
  135. })
  136. const configured = EffectRuntime.fn("PermissionV2.configured")(function* (sessionID: SessionV2.ID) {
  137. const session = yield* sessions.get(sessionID)
  138. if (!session.agent) return []
  139. return (yield* agents.get(AgentV2.ID.make(session.agent)))?.permissions ?? []
  140. })
  141. function denied(input: AssertInput, rules: Ruleset) {
  142. return input.resources.some((resource) => evaluate(input.action, resource, rules).effect === "deny")
  143. }
  144. function relevant(input: AssertInput, rules: Ruleset) {
  145. return rules.filter((rule) => Wildcard.match(input.action, rule.action))
  146. }
  147. const evaluateInput = EffectRuntime.fnUntraced(function* (input: AssertInput) {
  148. const rules = yield* configured(input.sessionID)
  149. if (denied(input, rules)) return { effect: "deny" as const, rules }
  150. const all = [...rules, ...(yield* savedRules())]
  151. const effects = input.resources.map((resource) => evaluate(input.action, resource, all).effect)
  152. const effect: Effect = effects.includes("deny") ? "deny" : effects.includes("ask") ? "ask" : "allow"
  153. return { effect, rules: all }
  154. })
  155. function request(input: AssertInput): Request {
  156. return {
  157. id: input.id ?? ID.create(),
  158. sessionID: input.sessionID,
  159. action: input.action,
  160. resources: input.resources,
  161. save: input.save,
  162. metadata: input.metadata,
  163. source: input.source,
  164. }
  165. }
  166. const create = EffectRuntime.fnUntraced(function* (request: Request) {
  167. const deferred = yield* Deferred.make<void, RejectedError | CorrectedError>()
  168. const item = { request, deferred }
  169. pending.set(request.id, item)
  170. yield* events.publish(Event.Asked, request)
  171. return item
  172. })
  173. const ask = EffectRuntime.fn("PermissionV2.ask")(function* (input: AssertInput) {
  174. const result = yield* evaluateInput(input)
  175. const value = request(input)
  176. if (result.effect === "ask") yield* create(value)
  177. return { id: value.id, effect: result.effect }
  178. })
  179. const assert = EffectRuntime.fn("PermissionV2.assert")(function* (input: AssertInput) {
  180. const result = yield* evaluateInput(input)
  181. if (result.effect === "deny") {
  182. return yield* new DeniedError({
  183. rules: relevant(input, result.rules),
  184. })
  185. }
  186. if (result.effect === "allow") return
  187. const item = yield* create(request(input))
  188. return yield* Deferred.await(item.deferred).pipe(
  189. EffectRuntime.ensuring(
  190. EffectRuntime.sync(() => {
  191. pending.delete(item.request.id)
  192. }),
  193. ),
  194. )
  195. })
  196. const reply = EffectRuntime.fn("PermissionV2.reply")(function* (input: ReplyInput) {
  197. const existing = pending.get(input.requestID)
  198. if (!existing) return yield* new NotFoundError({ requestID: input.requestID })
  199. pending.delete(input.requestID)
  200. yield* events.publish(Event.Replied, {
  201. sessionID: existing.request.sessionID,
  202. requestID: existing.request.id,
  203. reply: input.reply,
  204. })
  205. if (input.reply === "reject") {
  206. yield* Deferred.fail(
  207. existing.deferred,
  208. input.message ? new CorrectedError({ feedback: input.message }) : new RejectedError(),
  209. )
  210. for (const [id, item] of pending) {
  211. if (item.request.sessionID !== existing.request.sessionID) continue
  212. pending.delete(id)
  213. yield* events.publish(Event.Replied, {
  214. sessionID: item.request.sessionID,
  215. requestID: item.request.id,
  216. reply: "reject",
  217. })
  218. yield* Deferred.fail(item.deferred, new RejectedError())
  219. }
  220. return
  221. }
  222. if (input.reply === "always" && existing.request.save?.length) {
  223. yield* saved.add({
  224. projectID: location.project.id,
  225. action: existing.request.action,
  226. resources: existing.request.save,
  227. })
  228. }
  229. yield* Deferred.succeed(existing.deferred, undefined)
  230. if (input.reply !== "always" || !existing.request.save?.length) return
  231. const rememberedRules = yield* savedRules()
  232. for (const [id, item] of pending) {
  233. const input = { ...item.request }
  234. const rules = yield* configured(item.request.sessionID).pipe(
  235. EffectRuntime.catchTag("Session.NotFoundError", () => EffectRuntime.succeed(undefined)),
  236. )
  237. if (!rules) continue
  238. if (denied(input, rules)) continue
  239. const effective = [...rules, ...rememberedRules]
  240. if (
  241. !item.request.resources.every(
  242. (resource) => evaluate(item.request.action, resource, effective).effect === "allow",
  243. )
  244. )
  245. continue
  246. pending.delete(id)
  247. yield* events.publish(Event.Replied, {
  248. sessionID: item.request.sessionID,
  249. requestID: item.request.id,
  250. reply: "always",
  251. })
  252. yield* Deferred.succeed(item.deferred, undefined)
  253. }
  254. })
  255. const list = EffectRuntime.fn("PermissionV2.list")(function* () {
  256. return Array.from(pending.values(), (item) => item.request)
  257. })
  258. const get = EffectRuntime.fn("PermissionV2.get")(function* (id: ID) {
  259. return pending.get(id)?.request
  260. })
  261. const forSession = EffectRuntime.fn("PermissionV2.forSession")(function* (sessionID: SessionV2.ID) {
  262. return Array.from(pending.values(), (item) => item.request).filter((request) => request.sessionID === sessionID)
  263. })
  264. return Service.of({ ask, assert, reply, get, forSession, list })
  265. }),
  266. )
  267. export const locationLayer = layer.pipe(Layer.provideMerge(AgentV2.locationLayer))