openAgent

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