add permission system

packages/opencode/src/permission/index.ts

@@ -0,0 +1,135 @@
+import { App } from "../app/app"
+import { z } from "zod"
+import { Bus } from "../bus"
+import { Log } from "../util/log"
+
+export namespace Permission {
+  const log = Log.create({ service: "permission" })
+
+  export const Info = z
+    .object({
+      id: z.string(),
+      sessionID: z.string(),
+      title: z.string(),
+      metadata: z.record(z.any()),
+      time: z.object({
+        created: z.number(),
+      }),
+    })
+    .openapi({
+      ref: "permission.info",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export const Event = {
+    Updated: Bus.event("permission.updated", Info),
+  }
+
+  const state = App.state(
+    "permission",
+    () => {
+      const pending: {
+        [sessionID: string]: {
+          [permissionID: string]: {
+            info: Info
+            resolve: () => void
+            reject: (e: any) => void
+          }
+        }
+      } = {}
+
+      const approved: {
+        [sessionID: string]: {
+          [permissionID: string]: Info
+        }
+      } = {}
+
+      return {
+        pending,
+        approved,
+      }
+    },
+    async (state) => {
+      for (const pending of Object.values(state.pending)) {
+        for (const item of Object.values(pending)) {
+          item.reject(new RejectedError(item.info.sessionID, item.info.id))
+        }
+      }
+    },
+  )
+
+  export function ask(input: {
+    id: Info["id"]
+    sessionID: Info["sessionID"]
+    title: Info["title"]
+    metadata: Info["metadata"]
+  }) {
+    const { pending, approved } = state()
+    log.info("asking", {
+      sessionID: input.sessionID,
+      permissionID: input.id,
+    })
+    if (approved[input.sessionID]?.[input.id]) {
+      log.info("previously approved", {
+        sessionID: input.sessionID,
+        permissionID: input.id,
+      })
+      return
+    }
+    const info: Info = {
+      id: input.id,
+      sessionID: input.sessionID,
+      title: input.title,
+      metadata: input.metadata,
+      time: {
+        created: Date.now(),
+      },
+    }
+    pending[input.sessionID] = pending[input.sessionID] || {}
+    return new Promise<void>((resolve, reject) => {
+      pending[input.sessionID][input.id] = {
+        info,
+        resolve,
+        reject,
+      }
+      setTimeout(() => {
+        respond({
+          sessionID: input.sessionID,
+          permissionID: input.id,
+          response: "always",
+        })
+      }, 1000)
+      Bus.publish(Event.Updated, info)
+    })
+  }
+
+  export function respond(input: {
+    sessionID: Info["sessionID"]
+    permissionID: Info["id"]
+    response: "once" | "always" | "reject"
+  }) {
+    log.info("response", input)
+    const { pending, approved } = state()
+    const match = pending[input.sessionID]?.[input.permissionID]
+    if (!match) return
+    delete pending[input.sessionID][input.permissionID]
+    if (input.response === "reject") {
+      match.reject(new RejectedError(input.sessionID, input.permissionID))
+      return
+    }
+    match.resolve()
+    if (input.response === "always") {
+      approved[input.sessionID] = approved[input.sessionID] || {}
+      approved[input.sessionID][input.permissionID] = match.info
+    }
+  }
+
+  export class RejectedError extends Error {
+    constructor(
+      public readonly sessionID: string,
+      public readonly permissionID: string,
+    ) {
+      super(`The user rejected permission to use this functionality`)
+    }
+  }
+}

packages/opencode/src/session/session.ts

@@ -300,7 +300,9 @@ export namespace Session {
         async execute(args, opts) {
           const start = Date.now()
           try {
-            const result = await item.execute(args)
+            const result = await item.execute(args, {
+              sessionID: input.sessionID,
+            })
             next.metadata!.tool![opts.toolCallId] = {
               ...result.metadata,
               time: {

packages/opencode/src/tool/edit.ts

@@ -4,6 +4,7 @@ import { Tool } from "./tool"
 import { FileTimes } from "./util/file-times"
 import { LSP } from "../lsp"
 import { diffLines } from "diff"
+import { Permission } from "../permission"
 
 const DESCRIPTION = `Edits files by replacing text, creating new files, or deleting content. For moving or renaming files, use the Bash tool with the 'mv' command instead. For larger file edits, use the FileWrite tool to overwrite files.
 
@@ -61,7 +62,7 @@ export const EditTool = Tool.define({
     oldString: z.string().describe("The text to replace"),
     newString: z.string().describe("The text to replace it with"),
   }),
-  async execute(params) {
+  async execute(params, ctx) {
     if (!params.filePath) {
       throw new Error("filePath is required")
     }
@@ -71,6 +72,17 @@ export const EditTool = Tool.define({
       filePath = path.join(process.cwd(), filePath)
     }
 
+    await Permission.ask({
+      id: "opencode.edit",
+      sessionID: ctx.sessionID,
+      title: "Edit this file: " + filePath,
+      metadata: {
+        filePath,
+        oldString: params.oldString,
+        newString: params.newString,
+      },
+    })
+
     let contentOld = ""
     let contentNew = ""
     await (async () => {

packages/opencode/src/tool/tool.ts

@@ -1,6 +1,9 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec"
 
 export namespace Tool {
+  export type Context = {
+    sessionID: string
+  }
   export interface Info<
     Parameters extends StandardSchemaV1 = StandardSchemaV1,
     Metadata extends Record<string, any> = Record<string, any>,
@@ -8,7 +11,10 @@ export namespace Tool {
     id: string
     description: string
     parameters: Parameters
-    execute(args: StandardSchemaV1.InferOutput<Parameters>): Promise<{
+    execute(
+      args: StandardSchemaV1.InferOutput<Parameters>,
+      ctx: Context,
+    ): Promise<{
       metadata: Metadata
       output: string
     }>