feat(core): add location-based permission service (#30287)

packages/opencode/src/permission/evaluate.ts

@@ -1 +1 @@
-export { evaluate } from "@opencode-ai/core/permission"
+export { evaluate } from "."

packages/opencode/src/permission/index.ts

@@ -1,142 +1,53 @@
 import { ConfigPermission } from "@/config/permission"
 import { InstanceState } from "@/effect/instance-state"
-import { ProjectV2 } from "@opencode-ai/core/project"
-import { MessageID, SessionID } from "@/session/schema"
-import { PermissionTable } from "@opencode-ai/core/session/sql"
-import { Database } from "@opencode-ai/core/database/database"
-import { eq } from "drizzle-orm"
 import * as Log from "@opencode-ai/core/util/log"
 import { Wildcard } from "@opencode-ai/core/util/wildcard"
-import { Deferred, Effect, Layer, Schema, Context } from "effect"
+import { Deferred, Effect, Layer, Context } from "effect"
 import os from "os"
-import { PermissionV2 } from "@opencode-ai/core/permission"
-import { PermissionID } from "./schema"
+import { PermissionLegacy } from "@opencode-ai/core/permission/legacy"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { EventV2 } from "@opencode-ai/core/event"
 
 const log = Log.create({ service: "permission" })
 
-export const Action = PermissionV2.Action.annotate({ identifier: "PermissionAction" })
-export type Action = Schema.Schema.Type<typeof Action>
-
-export const Rule = Schema.Struct({
-  permission: Schema.String,
-  pattern: Schema.String,
-  action: Action,
-}).annotate({ identifier: "PermissionRule" })
-export type Rule = Schema.Schema.Type<typeof Rule>
-
-export const Ruleset = Schema.Array(Rule).annotate({ identifier: "PermissionRuleset" })
-export type Ruleset = Schema.Schema.Type<typeof Ruleset>
-
-// Pure data; nothing checks class identity. As `Schema.Struct` + type alias,
-// `Permission.ask` can trust its already-typed input and skip the inner
-// `decodeUnknownSync` that would otherwise throw uncaught on any structural
-// mismatch. Same pattern as `Question.Request` in PR #28570.
-export const Request = Schema.Struct({
-  id: PermissionID,
-  sessionID: SessionID,
-  permission: Schema.String,
-  patterns: Schema.Array(Schema.String),
-  metadata: Schema.Record(Schema.String, Schema.Unknown),
-  always: Schema.Array(Schema.String),
-  tool: Schema.optional(
-    Schema.Struct({
-      messageID: MessageID,
-      callID: Schema.String,
-    }),
-  ),
-}).annotate({ identifier: "PermissionRequest" })
-export type Request = Schema.Schema.Type<typeof Request>
-
-export const Reply = Schema.Literals(["once", "always", "reject"])
-export type Reply = Schema.Schema.Type<typeof Reply>
-
-const reply = {
-  reply: Reply,
-  message: Schema.optional(Schema.String),
-}
-
-export const ReplyBody = Schema.Struct(reply).annotate({ identifier: "PermissionReplyBody" })
-export type ReplyBody = Schema.Schema.Type<typeof ReplyBody>
-
-export const Approval = Schema.Struct({
-  projectID: ProjectV2.ID,
-  patterns: Schema.Array(Schema.String),
-}).annotate({ identifier: "PermissionApproval" })
-export type Approval = Schema.Schema.Type<typeof Approval>
-
 export const Event = {
-  Asked: EventV2.define({ type: "permission.asked", schema: Request.fields }),
+  Asked: EventV2.define({ type: "permission.asked", schema: PermissionLegacy.Request.fields }),
   Replied: EventV2.define({
     type: "permission.replied",
     schema: {
-      sessionID: SessionID,
-      requestID: PermissionID,
-      reply: Reply,
+      sessionID: PermissionLegacy.Request.fields.sessionID,
+      requestID: PermissionLegacy.ID,
+      reply: PermissionLegacy.Reply,
     },
   }),
 }
 
-export class RejectedError extends Schema.TaggedErrorClass<RejectedError>()("PermissionRejectedError", {}) {
-  override get message() {
-    return "The user rejected permission to use this specific tool call."
-  }
-}
-
-export class CorrectedError extends Schema.TaggedErrorClass<CorrectedError>()("PermissionCorrectedError", {
-  feedback: Schema.String,
-}) {
-  override get message() {
-    return `The user rejected permission to use this specific tool call with the following feedback: ${this.feedback}`
-  }
-}
-
-export class DeniedError extends Schema.TaggedErrorClass<DeniedError>()("PermissionDeniedError", {
-  ruleset: Schema.Any,
-}) {
-  override get message() {
-    return `The user has specified a rule which prevents you from using this specific tool call. Here are some of the relevant rules ${JSON.stringify(this.ruleset)}`
-  }
-}
-
-export class NotFoundError extends Schema.TaggedErrorClass<NotFoundError>()("Permission.NotFoundError", {
-  requestID: PermissionID,
-}) {}
-
-export type Error = DeniedError | RejectedError | CorrectedError
-
-export const AskInput = Schema.Struct({
-  ...Request.fields,
-  id: Schema.optional(PermissionID),
-  ruleset: Ruleset,
-}).annotate({ identifier: "PermissionAskInput" })
-export type AskInput = Schema.Schema.Type<typeof AskInput>
-
-export const ReplyInput = Schema.Struct({
-  requestID: PermissionID,
-  ...reply,
-}).annotate({ identifier: "PermissionReplyInput" })
-export type ReplyInput = Schema.Schema.Type<typeof ReplyInput>
-
 export interface Interface {
-  readonly ask: (input: AskInput) => Effect.Effect<void, Error>
-  readonly reply: (input: ReplyInput) => Effect.Effect<void, NotFoundError>
-  readonly list: () => Effect.Effect<ReadonlyArray<Request>>
+  readonly ask: (input: PermissionLegacy.AskInput) => Effect.Effect<void, PermissionLegacy.Error>
+  readonly reply: (input: PermissionLegacy.ReplyInput) => Effect.Effect<void, PermissionLegacy.NotFoundError>
+  readonly list: () => Effect.Effect<ReadonlyArray<PermissionLegacy.Request>>
 }
 
 interface PendingEntry {
-  info: Request
-  deferred: Deferred.Deferred<void, RejectedError | CorrectedError>
+  info: PermissionLegacy.Request
+  deferred: Deferred.Deferred<void, PermissionLegacy.RejectedError | PermissionLegacy.CorrectedError>
 }
 
 interface State {
-  pending: Map<PermissionID, PendingEntry>
-  approved: Rule[]
+  pending: Map<PermissionLegacy.ID, PendingEntry>
+  approved: PermissionLegacy.Rule[]
 }
 
-export function evaluate(permission: string, pattern: string, ...rulesets: Ruleset[]): Rule {
-  return PermissionV2.evaluate(permission, pattern, ...rulesets)
+export function evaluate(permission: string, pattern: string, ...rulesets: PermissionLegacy.Ruleset[]): PermissionLegacy.Rule {
+  return (
+    rulesets
+      .flat()
+      .findLast((rule) => Wildcard.match(permission, rule.permission) && Wildcard.match(pattern, rule.pattern)) ?? {
+      action: "ask",
+      permission,
+      pattern: "*",
+    }
+  )
 }
 
 export class Service extends Context.Service<Service, Interface>()("@opencode/Permission") {}
@@ -145,24 +56,18 @@ export const layer = Layer.effect(
   Service,
   Effect.gen(function* () {
     const events = yield* EventV2Bridge.Service
-    const { db } = yield* Database.Service
     const state = yield* InstanceState.make<State>(
       Effect.fn("Permission.state")(function* (ctx) {
-        const row = yield* db
-          .select()
-          .from(PermissionTable)
-          .where(eq(PermissionTable.project_id, ctx.project.id))
-          .get()
-          .pipe(Effect.orDie)
+        void ctx
         const state = {
-          pending: new Map<PermissionID, PendingEntry>(),
-          approved: [...(row?.data ?? [])],
+          pending: new Map<PermissionLegacy.ID, PendingEntry>(),
+          approved: [],
         }
 
         yield* Effect.addFinalizer(() =>
           Effect.gen(function* () {
             for (const item of state.pending.values()) {
-              yield* Deferred.fail(item.deferred, new RejectedError())
+              yield* Deferred.fail(item.deferred, new PermissionLegacy.RejectedError())
             }
             state.pending.clear()
           }),
@@ -172,7 +77,7 @@ export const layer = Layer.effect(
       }),
     )
 
-    const ask = Effect.fn("Permission.ask")(function* (input: AskInput) {
+    const ask = Effect.fn("Permission.ask")(function* (input: PermissionLegacy.AskInput) {
       const { approved, pending } = yield* InstanceState.get(state)
       const { ruleset, ...request } = input
       let needsAsk = false
@@ -181,7 +86,7 @@ export const layer = Layer.effect(
         const rule = evaluate(request.permission, pattern, ruleset, approved)
         log.info("evaluated", { permission: request.permission, pattern, action: rule })
         if (rule.action === "deny") {
-          return yield* new DeniedError({
+          return yield* new PermissionLegacy.DeniedError({
             ruleset: ruleset.filter((rule) => Wildcard.match(request.permission, rule.permission)),
           })
         }
@@ -191,8 +96,8 @@ export const layer = Layer.effect(
 
       if (!needsAsk) return
 
-      const id = request.id ?? PermissionID.ascending()
-      const info: Request = {
+      const id = request.id ?? PermissionLegacy.ID.ascending()
+      const info: PermissionLegacy.Request = {
         id,
         sessionID: request.sessionID,
         permission: request.permission,
@@ -203,7 +108,7 @@ export const layer = Layer.effect(
       }
       log.info("asking", { id, permission: info.permission, patterns: info.patterns })
 
-      const deferred = yield* Deferred.make<void, RejectedError | CorrectedError>()
+      const deferred = yield* Deferred.make<void, PermissionLegacy.RejectedError | PermissionLegacy.CorrectedError>()
       pending.set(id, { info, deferred })
       yield* events.publish(Event.Asked, info)
       return yield* Effect.ensuring(
@@ -214,10 +119,10 @@ export const layer = Layer.effect(
       )
     })
 
-    const reply = Effect.fn("Permission.reply")(function* (input: ReplyInput) {
+    const reply = Effect.fn("Permission.reply")(function* (input: PermissionLegacy.ReplyInput) {
       const { approved, pending } = yield* InstanceState.get(state)
       const existing = pending.get(input.requestID)
-      if (!existing) return yield* new NotFoundError({ requestID: input.requestID })
+      if (!existing) return yield* new PermissionLegacy.NotFoundError({ requestID: input.requestID })
 
       pending.delete(input.requestID)
       yield* events.publish(Event.Replied, {
@@ -229,7 +134,7 @@ export const layer = Layer.effect(
       if (input.reply === "reject") {
         yield* Deferred.fail(
           existing.deferred,
-          input.message ? new CorrectedError({ feedback: input.message }) : new RejectedError(),
+          input.message ? new PermissionLegacy.CorrectedError({ feedback: input.message }) : new PermissionLegacy.RejectedError(),
         )
 
         for (const [id, item] of pending.entries()) {
@@ -240,7 +145,7 @@ export const layer = Layer.effect(
             requestID: item.info.id,
             reply: "reject",
           })
-          yield* Deferred.fail(item.deferred, new RejectedError())
+          yield* Deferred.fail(item.deferred, new PermissionLegacy.RejectedError())
         }
         return
       }
@@ -290,7 +195,7 @@ function expand(pattern: string): string {
 }
 
 export function fromConfig(permission: ConfigPermission.Info) {
-  const ruleset: Rule[] = []
+  const ruleset: PermissionLegacy.Rule[] = []
   for (const [key, value] of Object.entries(permission)) {
     if (typeof value === "string") {
       ruleset.push({ permission: key, action: value, pattern: "*" })
@@ -303,14 +208,21 @@ export function fromConfig(permission: ConfigPermission.Info) {
   return ruleset
 }
 
-export function merge(...rulesets: Ruleset[]): Rule[] {
-  return [...PermissionV2.merge(...rulesets)]
+export function merge(...rulesets: PermissionLegacy.Ruleset[]): PermissionLegacy.Rule[] {
+  return rulesets.flat()
 }
 
-export function disabled(tools: string[], ruleset: Ruleset): Set<string> {
-  return PermissionV2.disabled(tools, ruleset)
+export function disabled(tools: string[], ruleset: PermissionLegacy.Ruleset): Set<string> {
+  const edits = ["edit", "write", "apply_patch"]
+  return new Set(
+    tools.filter((tool) => {
+      const permission = edits.includes(tool) ? "edit" : tool
+      const rule = ruleset.findLast((rule) => Wildcard.match(permission, rule.permission))
+      return rule?.pattern === "*" && rule.action === "deny"
+    }),
+  )
 }
 
-export const defaultLayer = layer.pipe(Layer.provide(Database.defaultLayer), Layer.provide(EventV2Bridge.defaultLayer))
+export const defaultLayer = layer.pipe(Layer.provide(EventV2Bridge.defaultLayer))
 
 export * as Permission from "."

packages/opencode/src/permission/schema.ts

@@ -1,13 +0,0 @@
-import { Schema } from "effect"
-
-import { Identifier } from "@/id/id"
-import { Newtype } from "@opencode-ai/core/schema"
-
-export class PermissionID extends Newtype<PermissionID>()(
-  "PermissionID",
-  Schema.String.check(Schema.isStartsWith("per")),
-) {
-  static ascending(id?: string): PermissionID {
-    return this.make(Identifier.ascending("permission", id))
-  }
-}