diff --git a/packages/core/src/codemode/execution.ts b/packages/core/src/codemode/execution.ts new file mode 100644 index 000000000000..b41e0de4e85a --- /dev/null +++ b/packages/core/src/codemode/execution.ts @@ -0,0 +1,7 @@ +export * as CodeModeExecution from "./execution.js" + +import type { Context as ToolContext } from "@opencode/schema/tool" +import { Context } from "effect" + +/** The `execute` call a Code Mode program runs under, so extensions can act for its session like a tool does. */ +export class Service extends Context.Service()("@opencode/CodeModeExecution") {} diff --git a/packages/core/src/codemode/fetch.ts b/packages/core/src/codemode/fetch.ts new file mode 100644 index 000000000000..06d163012f8e --- /dev/null +++ b/packages/core/src/codemode/fetch.ts @@ -0,0 +1,78 @@ +export * as CodeModeFetch from "./fetch.js" + +import { Extension } from "@opencode/codemode" +import { isRecord } from "@opencode/util/record" +import { Effect } from "effect" +import { Permission } from "../permission.js" +import { CodeModeExecution } from "./execution.js" + +const TIMEOUT_MS = 30_000 + +type Init = { + readonly method?: string + readonly headers?: Record | Array<[string, string]> + readonly body?: string | Uint8Array | URLSearchParams +} + +const fetch = (input: string | URL, init: Init = {}) => + Effect.gen(function* () { + const url = String(input) + if (URL.parse(url)?.protocol === "file:") + return yield* Effect.fail(new Error("fetch cannot be used for filesystem access.")) + const execution = yield* CodeModeExecution.Service + const permission = yield* Permission.Service + // The same rules as the webfetch tool, so a URL denied there is denied here. + yield* permission + .assert({ + action: "webfetch", + resources: [url], + save: ["*"], + metadata: display([input, init]), + sessionID: execution.sessionID, + agent: execution.agent, + source: { type: "tool", messageID: execution.messageID, id: execution.id }, + }) + .pipe( + // The feedback is the user talking to the model, so it must reach the program as the error's message. + Effect.catchTag("Permission.CorrectedError", (error) => + Effect.fail(new Error(`The user rejected fetching ${url}: ${error.feedback}`)), + ), + ) + return yield* Effect.tryPromise({ try: () => send(input, init), catch: (error) => error }) + }) + +const send = async (input: string | URL, init: Init) => { + const response = await globalThis.fetch(input, { + method: init.method, + headers: init.headers, + body: init.body, + signal: AbortSignal.timeout(TIMEOUT_MS), + }) + const bytes = await response.bytes() + const headers = Object.fromEntries(response.headers) + const text = () => new TextDecoder().decode(bytes) + return { + url: response.url, + status: response.status, + statusText: response.statusText, + ok: response.ok, + redirected: response.redirected, + headers: { + get: (name: string) => headers[name.toLowerCase()] ?? null, + has: (name: string) => name.toLowerCase() in headers, + entries: () => Object.entries(headers), + }, + text: async () => text(), + json: async () => JSON.parse(text()) as unknown, + bytes: async () => bytes, + } +} + +export const extension = Extension.make({ name: "fetch", globals: { fetch: Extension.async(fetch) } }) + +/** What to show for a fetch call: its method and URL. */ +export const display = (args: ReadonlyArray) => { + const [input, init] = args + const method = isRecord(init) && typeof init.method === "string" ? init.method.toUpperCase() : "GET" + return { method, url: String(input) } +} diff --git a/packages/core/src/codemode/tool.ts b/packages/core/src/codemode/tool.ts index 80ed4e6c90b3..1fd67439350a 100644 --- a/packages/core/src/codemode/tool.ts +++ b/packages/core/src/codemode/tool.ts @@ -14,8 +14,10 @@ import type { import { Clock, Context, Effect, Ref, Schema, Semaphore } from "effect" import { toSessionError } from "../session/to-session-error.js" import { definition, normalizedName } from "../tool/runtime.js" +import { Permission } from "../permission.js" import { CodeModeCatalog } from "./catalog.js" -import { CodeModeWeb } from "./web.js" +import { CodeModeExecution } from "./execution.js" +import { CodeModeFetch } from "./fetch.js" const ExecuteFile = Schema.Struct({ data: Schema.String, @@ -82,6 +84,7 @@ const description = [ export const create = ( inventory: Inventory, executeTool: (name: string, tool: Info, input: unknown, context: ToolContext) => Effect.Effect, + permission: Permission.Interface, ) => { return { name: "execute", @@ -142,6 +145,8 @@ export const create = ( Effect.onError(() => lock.withPermit(Ref.get(trailing).pipe(Effect.flatMap((pending) => (pending ? publish : Effect.void)))), ), + Effect.provideService(CodeModeExecution.Service, context), + Effect.provideService(Permission.Service, permission), ) const toolCalls = yield* Ref.get(calls) const collected = (yield* Ref.get(files)) @@ -203,7 +208,7 @@ function progressHooks(record: (update: (items: Array) => Array { switch (call.name) { case "fetch": - return start(call, { tool: call.name, status: "running", input: CodeModeWeb.display(call.args) }) + return start(call, { tool: call.name, status: "running", input: CodeModeFetch.display(call.args) }) default: return Effect.void } @@ -257,15 +262,15 @@ function renderCatalog(root: CatalogNode): ReadonlyArray>() +const runtimes = new WeakMap>() function runtime(inventory: Inventory) { const cached = runtimes.get(inventory) if (cached) return cached const tools = inventoryTools(inventory) - const created = CodeMode.make({ + const created = CodeMode.make({ tools, - extensions: [CodeModeWeb.extension], + extensions: [CodeModeFetch.extension], hooks: runHooks, }) runtimes.set(inventory, created) diff --git a/packages/core/src/codemode/web.ts b/packages/core/src/codemode/web.ts deleted file mode 100644 index 5dba1df38f90..000000000000 --- a/packages/core/src/codemode/web.ts +++ /dev/null @@ -1,50 +0,0 @@ -export * as CodeModeWeb from "./web.js" - -import { Extension } from "@opencode/codemode" -import { isRecord } from "@opencode/util/record" - -const TIMEOUT_MS = 30_000 - -type Init = { - readonly method?: string - readonly headers?: Record | Array<[string, string]> - readonly body?: string | Uint8Array | URLSearchParams -} - -const fetch = async (input: string | URL, init: Init = {}) => { - if (URL.parse(String(input))?.protocol === "file:") - throw new Error("fetch cannot be used for filesystem access.") - const response = await globalThis.fetch(input, { - method: init.method, - headers: init.headers, - body: init.body, - signal: AbortSignal.timeout(TIMEOUT_MS), - }) - const bytes = await response.bytes() - const headers = Object.fromEntries(response.headers) - const text = () => new TextDecoder().decode(bytes) - return { - url: response.url, - status: response.status, - statusText: response.statusText, - ok: response.ok, - redirected: response.redirected, - headers: { - get: (name: string) => headers[name.toLowerCase()] ?? null, - has: (name: string) => name.toLowerCase() in headers, - entries: () => Object.entries(headers), - }, - text: async () => text(), - json: async () => JSON.parse(text()) as unknown, - bytes: async () => bytes, - } -} - -export const extension = Extension.make({ name: "web", globals: { fetch } }) - -/** What to show for a fetch call: its method and URL. */ -export const display = (args: ReadonlyArray) => { - const [input, init] = args - const method = isRecord(init) && typeof init.method === "string" ? init.method.toUpperCase() : "GET" - return { method, url: String(input) } -} diff --git a/packages/core/src/tool.ts b/packages/core/src/tool.ts index 201c19f5e459..156a05bcef1c 100644 --- a/packages/core/src/tool.ts +++ b/packages/core/src/tool.ts @@ -86,6 +86,7 @@ const layer = Layer.effect( Effect.gen(function* () { const hooks = yield* PluginHooks.Service const image = yield* Image.Service + const permission = yield* Permission.Service type NormalizedItem = Tool.Content | "decode" | "size" const normalizeImages = Effect.fnUntraced(function* (content: ReadonlyArray) { @@ -283,10 +284,13 @@ const layer = Layer.effect( const cached = catalog?.data === data && catalog.names === names ? catalog : undefined const codeModeInventory = cached?.inventory ?? { tools: codeModeTools, namespaces: data.namespaces } const codeModeTool = codeModeEnabled - ? CodeModeTool.create(codeModeInventory, (name, tool, input, context) => - beforeExecute(name, input, context).pipe( - Effect.flatMap((event) => executeTool(tool, name, event.input, context)), - ), + ? CodeModeTool.create( + codeModeInventory, + (name, tool, input, context) => + beforeExecute(name, input, context).pipe( + Effect.flatMap((event) => executeTool(tool, name, event.input, context)), + ), + permission, ) : undefined const codeModeCatalog = !codeModeEnabled @@ -413,5 +417,5 @@ function namespaceError(name: string) { export const node = makeLocationNode({ service: Service, layer, - deps: [PluginHooks.node, Image.node], + deps: [PluginHooks.node, Image.node, Permission.node], }) diff --git a/packages/core/test/lib/permission.ts b/packages/core/test/lib/permission.ts index d44f32d0e1a1..447c778da8be 100644 --- a/packages/core/test/lib/permission.ts +++ b/packages/core/test/lib/permission.ts @@ -3,3 +3,10 @@ import { Effect, Layer } from "effect" export const permissionLayer = (overrides: Partial = {}) => Layer.mock(Permission.Service, { close: Effect.void, ...overrides }) + +export const permissionService = (overrides: Partial = {}) => + Effect.runSync( + Effect.gen(function* () { + return yield* Permission.Service + }).pipe(Effect.provide(permissionLayer(overrides))), + ) diff --git a/packages/core/test/tool-execute.test.ts b/packages/core/test/tool-execute.test.ts index d65c55587ea4..932d953f5159 100644 --- a/packages/core/test/tool-execute.test.ts +++ b/packages/core/test/tool-execute.test.ts @@ -1,5 +1,6 @@ -import { expect, test } from "bun:test" +import { afterAll, beforeAll, describe, expect, test } from "bun:test" import { CodeModeTool } from "@opencode/core/codemode/tool" +import { Permission } from "@opencode/core/permission" import { Tool } from "@opencode/core/tool" import { execute } from "@opencode/core/tool/runtime" import { Agent } from "@opencode/schema/agent" @@ -9,6 +10,7 @@ import type { Info } from "@opencode/schema/tool" import { Deferred, Effect, Fiber, Schema } from "effect" import { TestClock } from "effect/testing" import { it } from "./lib/effect" +import { permissionService } from "./lib/permission" const context = { sessionID: Session.ID.make("ses_execute"), @@ -18,8 +20,10 @@ const context = { progress: () => Effect.void, } -const createCodeMode = (tools: ReadonlyMap) => - CodeModeTool.create({ tools }, (_, tool, input, context) => execute(tool, input, context)) +const allowAll = permissionService({ assert: () => Effect.void }) + +const createCodeMode = (tools: ReadonlyMap, permission = allowAll) => + CodeModeTool.create({ tools }, (_, tool, input, context) => execute(tool, input, context), permission) test("execute describes invariant Code Mode behavior", () => { expect(createCodeMode(new Map()).description).toBe( @@ -43,6 +47,82 @@ test("execute rejects filesystem fetches", async () => { expect(result.output.output).toContain("fetch cannot be used for filesystem access.") }) +describe("fetch permissions", () => { + const hits: Array = [] + let server: ReturnType + beforeAll(() => { + server = Bun.serve({ + port: 0, + fetch: (request) => { + hits.push(`${request.method} ${new URL(request.url).pathname}`) + return new Response("ok") + }, + }) + }) + afterAll(() => server.stop(true)) + + test("fetch asks the webfetch permission for its URL as the execute call", async () => { + hits.length = 0 + const asked: Array = [] + const url = `${server.url.origin}/allowed` + const result = await Effect.runPromise( + createCodeMode( + new Map(), + permissionService({ assert: (input) => Effect.sync(() => void asked.push(input)) }), + ).execute({ code: `return await (await fetch("${url}", { method: "POST" })).text()` }, context), + ) + + expect(result.output.output).toBe("ok") + expect(hits).toEqual(["POST /allowed"]) + expect(asked).toEqual([ + { + action: "webfetch", + resources: [url], + save: ["*"], + metadata: { method: "POST", url }, + sessionID: context.sessionID, + agent: context.agent, + source: { type: "tool", messageID: context.messageID, id: context.id }, + }, + ]) + }) + + test("a rejection with feedback reaches the program as the error message", async () => { + hits.length = 0 + const url = `${server.url.origin}/corrected` + const corrected = permissionService({ + assert: () => Effect.fail(new Permission.CorrectedError({ feedback: "use the docs site instead" })), + }) + const result = await Effect.runPromise( + createCodeMode(new Map(), corrected).execute( + { code: `try { await fetch("${url}") } catch (e) { return e.message }` }, + context, + ), + ) + + expect(result.output.output).toBe(`The user rejected fetching ${url}: use the docs site instead`) + expect(hits).toEqual([]) + }) + + test("a URL denied for webfetch is never requested and rejects like a failed fetch", async () => { + hits.length = 0 + const url = `${server.url.origin}/denied` + const denied = permissionService({ + assert: (input) => + Effect.fail(new Permission.BlockedError({ rules: [], permission: input.action, resources: input.resources })), + }) + const result = await Effect.runPromise( + createCodeMode(new Map(), denied).execute( + { code: `const [denied] = await Promise.allSettled([fetch("${url}")]); return denied.status` }, + context, + ), + ) + + expect(result.output.output).toBe("rejected") + expect(hits).toEqual([]) + }) +}) + test("canonical execution distinguishes declared, model-only, and raw schema outputs", async () => { const declared: Info = { name: "declared", @@ -179,10 +259,10 @@ test("executions share the prepared runtime of an inventory while keeping per-ca execute: (input, context) => Effect.succeed({ content: `${context.id}:${(input as { value: string }).value}` }), } const inventory = { tools: new Map([["echo", echo]]) } - const codeMode = CodeModeTool.create(inventory, (_, tool, input, context) => execute(tool, input, context)) + const codeMode = CodeModeTool.create(inventory, (_, tool, input, context) => execute(tool, input, context), allowAll) const run = (id: string) => { const progress: Array = [] - return CodeModeTool.create(inventory, (_, tool, input, context) => execute(tool, input, context)) + return CodeModeTool.create(inventory, (_, tool, input, context) => execute(tool, input, context), allowAll) .execute( { code: `return await tools.echo({ value: "${id}" })` }, { ...context, id: Tool.CallID.make(id), progress: (update) => Effect.sync(() => progress.push(update)) }, diff --git a/packages/core/test/tool-registry.test.ts b/packages/core/test/tool-registry.test.ts index 40ac3d001b9f..3e68b22c4e9a 100644 --- a/packages/core/test/tool-registry.test.ts +++ b/packages/core/test/tool-registry.test.ts @@ -1,6 +1,6 @@ import { describe, expect } from "bun:test" import { Agent } from "@opencode/core/agent" -import type { Permission } from "@opencode/core/permission" +import { Permission } from "@opencode/core/permission" import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder" import { Image } from "@opencode/core/image" import { PluginHooks } from "@opencode/core/plugin/hooks" @@ -14,6 +14,7 @@ import { codeModeListings, executeTool, toolDefinitions } from "./lib/tool" import { Deferred, Effect, Exit, Fiber, Layer, Logger, Schema, SchemaGetter, SchemaIssue, Scope } from "effect" import { z } from "zod" import { testEffect } from "./lib/effect" +import { permissionLayer } from "./lib/permission" const imageStore = Layer.mock(Image.Service, { normalize: (resource, content) => { @@ -39,6 +40,7 @@ const imageStore = Layer.mock(Image.Service, { }) const registryLayer = AppNodeBuilder.build(LayerNode.group([Tool.node, PluginHooks.node]), [ Image.node.replace(imageStore), + Permission.node.replace(permissionLayer()), ]) const it = testEffect(registryLayer) const identity = { @@ -719,10 +721,7 @@ describe("Tool", () => { expect(snapshot.codeModeCatalog).toBeUndefined() expect((yield* snapshot.execute(call("mcp_lookup"))).output).toEqual({ text: "mcp_lookup" }) - const hidden = yield* service.snapshot([ - ...denyExecute, - { action: "mcp_lookup", resource: "*", effect: "deny" }, - ]) + const hidden = yield* service.snapshot([...denyExecute, { action: "mcp_lookup", resource: "*", effect: "deny" }]) expect(hidden.definitions.map((tool) => tool.name)).toEqual(["bash"]) expect(yield* hidden.execute(call("mcp_lookup")).pipe(Effect.flip)).toBeInstanceOf(Tool.Error) }), diff --git a/packages/core/test/tool-schedule.test.ts b/packages/core/test/tool-schedule.test.ts index cf62a2584890..63b7dd83e5ad 100644 --- a/packages/core/test/tool-schedule.test.ts +++ b/packages/core/test/tool-schedule.test.ts @@ -3,6 +3,7 @@ import { DateTime, Effect, Layer, Stream } from "effect" import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder" import { Config } from "@opencode/core/config" import { Image } from "@opencode/core/image" +import { Permission } from "@opencode/core/permission" import { Schedule } from "@opencode/core/schedule" import { Session } from "@opencode/core/session" import { Tool } from "@opencode/core/tool" @@ -22,7 +23,9 @@ const names = ["schedule_create", "schedule_list", "schedule_pause", "schedule_r (name) => `opencode.${name}`, ) -const it = testEffect(AppNodeBuilder.build(Tool.node, [Image.node.replace(imagePassthrough)])) +const it = testEffect( + AppNodeBuilder.build(Tool.node, [Image.node.replace(imagePassthrough), Permission.node.replace(permissionLayer())]), +) /** An in-memory Schedule service. The real one is covered in schedule.test.ts; this exercises the tool layer. */ const memory = () => { diff --git a/packages/core/test/tool-todo.test.ts b/packages/core/test/tool-todo.test.ts index de1ce56e54fd..01162831ae97 100644 --- a/packages/core/test/tool-todo.test.ts +++ b/packages/core/test/tool-todo.test.ts @@ -3,6 +3,7 @@ import { Effect, Layer, Stream } from "effect" import { AppNodeBuilder } from "@opencode/core/effect/app-node-builder" import { Config } from "@opencode/core/config" import { Image } from "@opencode/core/image" +import { Permission } from "@opencode/core/permission" import { Session } from "@opencode/core/session" import { Tool } from "@opencode/core/tool" import { TodoTool } from "@opencode/core/tool/plugin/todo" @@ -22,7 +23,9 @@ const todos = [ { content: "Rewrite everything", status: "cancelled" }, ] as const -const it = testEffect(AppNodeBuilder.build(Tool.node, [Image.node.replace(imagePassthrough)])) +const it = testEffect( + AppNodeBuilder.build(Tool.node, [Image.node.replace(imagePassthrough), Permission.node.replace(permissionLayer())]), +) const setup = (experimental: ConfigExperimental.Info | undefined) => Effect.gen(function* () {