orynacode-ai 1.16.2

package/src/cli/cmd/acp.ts

@@ -0,0 +1,76 @@
+import * as Log from "@opencode-ai/core/util/log"
+import { Effect } from "effect"
+import { effectCmd } from "../effect-cmd"
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk"
+import { ServerAuth } from "@/server/auth"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2"
+import { withNetworkOptions, resolveNetworkOptions } from "../network"
+import { ACPProfile } from "@/acp/profile"
+
+const log = Log.create({ service: "acp-command" })
+
+export const AcpCommand = effectCmd({
+  command: "acp",
+  describe: "start ACP (Agent Client Protocol) server",
+  builder: (yargs) => {
+    return withNetworkOptions(yargs).option("cwd", {
+      describe: "working directory",
+      type: "string",
+      default: process.cwd(),
+    })
+  },
+  handler: Effect.fn("Cli.acp")(function* (args) {
+    const { Server } = yield* Effect.promise(() => import("@/server/server"))
+    const { ACP } = yield* Effect.promise(() => import("@/acp/agent"))
+    ACPProfile.mark("cli.acp.handler")
+    process.env.OPENCODE_CLIENT = "acp"
+    const opts = yield* resolveNetworkOptions(args)
+    const server = yield* Effect.promise(() => ACPProfile.measure("cli.acp.server.listen", () => Server.listen(opts)))
+
+    const sdk = createOpencodeClient({
+      baseUrl: `http://${server.hostname}:${server.port}`,
+      headers: ServerAuth.headers(),
+    })
+
+    const input = new WritableStream<Uint8Array>({
+      write(chunk) {
+        return new Promise<void>((resolve, reject) => {
+          process.stdout.write(chunk, (err) => {
+            if (err) {
+              reject(err)
+            } else {
+              resolve()
+            }
+          })
+        })
+      },
+    })
+    const output = new ReadableStream<Uint8Array>({
+      start(controller) {
+        process.stdin.on("data", (chunk: Buffer) => {
+          controller.enqueue(new Uint8Array(chunk))
+        })
+        process.stdin.on("end", () => controller.close())
+        process.stdin.on("error", (err) => controller.error(err))
+      },
+    })
+
+    const stream = ndJsonStream(input, output)
+    const agent = ACP.init({ sdk })
+
+    new AgentSideConnection((conn) => {
+      ACPProfile.mark("cli.acp.connection.create")
+      return agent.create(conn)
+    }, stream)
+
+    log.info("setup connection")
+    process.stdin.resume()
+    yield* Effect.promise(
+      () =>
+        new Promise<void>((resolve, reject) => {
+          process.stdin.on("end", () => resolve())
+          process.stdin.on("error", reject)
+        }),
+    )
+  }),
+})

package/src/cli/cmd/agent.ts

@@ -0,0 +1,259 @@
+import { cmd } from "./cmd"
+import * as prompts from "@clack/prompts"
+import { UI } from "../ui"
+import { Global } from "@opencode-ai/core/global"
+import path from "path"
+import fs from "fs/promises"
+import { Filesystem } from "@/util/filesystem"
+import matter from "gray-matter"
+import { EOL } from "os"
+import type { Argv } from "yargs"
+import { Effect } from "effect"
+import { effectCmd } from "../effect-cmd"
+
+type AgentMode = "all" | "primary" | "subagent"
+
+// Permission keys (not raw tool names). Multiple tools can map to a single
+// permission — e.g. write/edit/apply_patch all gate on `edit` — so we configure
+// agents at the permission level to match how the runtime actually enforces it.
+const AVAILABLE_PERMISSIONS = [
+  "bash",
+  "read",
+  "edit",
+  "glob",
+  "grep",
+  "webfetch",
+  "task",
+  "todowrite",
+  "websearch",
+  "lsp",
+  "skill",
+]
+
+const AgentCreateCommand = effectCmd({
+  command: "create",
+  describe: "create a new agent",
+  builder: (yargs: Argv) =>
+    yargs
+      .option("path", {
+        type: "string",
+        describe: "directory path to generate the agent file",
+      })
+      .option("description", {
+        type: "string",
+        describe: "what the agent should do",
+      })
+      .option("mode", {
+        type: "string",
+        describe: "agent mode",
+        choices: ["all", "primary", "subagent"] as const,
+      })
+      .option("permissions", {
+        type: "string",
+        alias: ["tools"],
+        describe: `comma-separated list of permissions to allow (default: all). Available: "${AVAILABLE_PERMISSIONS.join(", ")}"`,
+      })
+      .option("model", {
+        type: "string",
+        alias: ["m"],
+        describe: "model to use in the format of provider/model",
+      }),
+  handler: Effect.fn("Cli.agent.create")(function* (args) {
+    const { InstanceRef } = yield* Effect.promise(() => import("@/effect/instance-ref"))
+    const { Agent } = yield* Effect.promise(() => import("../../agent/agent"))
+    const { Provider } = yield* Effect.promise(() => import("@/provider/provider"))
+    const maybeCtx = yield* InstanceRef
+    if (!maybeCtx) return yield* Effect.die("InstanceRef not provided")
+    const ctx = maybeCtx
+    const agentSvc = yield* Agent.Service
+    const runLocalEffect = <A, E>(effect: Effect.Effect<A, E>) =>
+      Effect.runPromise(effect.pipe(Effect.provideService(InstanceRef, ctx)))
+    yield* Effect.promise(async () => {
+      const cliPath = args.path
+      const cliDescription = args.description
+      const cliMode = args.mode as AgentMode | undefined
+      const perms = args.permissions
+
+      const isFullyNonInteractive = cliPath && cliDescription && cliMode && perms !== undefined
+
+      if (!isFullyNonInteractive) {
+        UI.empty()
+        prompts.intro("Create agent")
+      }
+
+      const project = ctx.project
+
+      // Determine scope/path
+      let targetPath: string
+      if (cliPath) {
+        targetPath = path.join(cliPath, "agents")
+      } else {
+        let scope: "global" | "project" = "global"
+        if (project.vcs === "git") {
+          const scopeResult = await prompts.select({
+            message: "Location",
+            options: [
+              {
+                label: "Current project",
+                value: "project" as const,
+                hint: ctx.worktree,
+              },
+              {
+                label: "Global",
+                value: "global" as const,
+                hint: Global.Path.config,
+              },
+            ],
+          })
+          if (prompts.isCancel(scopeResult)) throw new UI.CancelledError()
+          scope = scopeResult
+        }
+        targetPath = path.join(scope === "global" ? Global.Path.config : path.join(ctx.worktree, ".opencode"), "agents")
+      }
+
+      // Get description
+      let description: string
+      if (cliDescription) {
+        description = cliDescription
+      } else {
+        const query = await prompts.text({
+          message: "Description",
+          placeholder: "What should this agent do?",
+          validate: (x) => (x && x.length > 0 ? undefined : "Required"),
+        })
+        if (prompts.isCancel(query)) throw new UI.CancelledError()
+        description = query
+      }
+
+      // Generate agent
+      const spinner = prompts.spinner()
+      spinner.start("Generating agent configuration...")
+      const model = args.model ? Provider.parseModel(args.model) : undefined
+      const generated = await runLocalEffect(agentSvc.generate({ description, model })).catch((error) => {
+        spinner.stop(`LLM failed to generate agent: ${error.message}`, 1)
+        if (isFullyNonInteractive) process.exit(1)
+        throw new UI.CancelledError()
+      })
+      spinner.stop(`Agent ${generated.identifier} generated`)
+
+      // Select permissions to allow
+      let selected: string[]
+      if (perms !== undefined) {
+        selected = perms ? perms.split(",").map((t) => t.trim()) : AVAILABLE_PERMISSIONS
+      } else {
+        const result = await prompts.multiselect({
+          message: "Select permissions to allow (Space to toggle)",
+          options: AVAILABLE_PERMISSIONS.map((permission) => ({
+            label: permission,
+            value: permission,
+          })),
+          initialValues: AVAILABLE_PERMISSIONS,
+        })
+        if (prompts.isCancel(result)) throw new UI.CancelledError()
+        selected = result
+      }
+
+      // Get mode
+      let mode: AgentMode
+      if (cliMode) {
+        mode = cliMode
+      } else {
+        const modeResult = await prompts.select({
+          message: "Agent mode",
+          options: [
+            {
+              label: "All",
+              value: "all" as const,
+              hint: "Can function in both primary and subagent roles",
+            },
+            {
+              label: "Primary",
+              value: "primary" as const,
+              hint: "Acts as a primary/main agent",
+            },
+            {
+              label: "Subagent",
+              value: "subagent" as const,
+              hint: "Can be used as a subagent by other agents",
+            },
+          ],
+          initialValue: "all" as const,
+        })
+        if (prompts.isCancel(modeResult)) throw new UI.CancelledError()
+        mode = modeResult
+      }
+
+      // Build permissions config — deny anything not explicitly selected.
+      const permissions: Record<string, "deny"> = {}
+      for (const permission of AVAILABLE_PERMISSIONS) {
+        if (!selected.includes(permission)) {
+          permissions[permission] = "deny"
+        }
+      }
+
+      // Build frontmatter
+      const frontmatter: {
+        description: string
+        mode: AgentMode
+        permission?: Record<string, "deny">
+      } = {
+        description: generated.whenToUse,
+        mode,
+      }
+      if (Object.keys(permissions).length > 0) {
+        frontmatter.permission = permissions
+      }
+
+      // Write file
+      const content = matter.stringify(generated.systemPrompt, frontmatter)
+      const filePath = path.join(targetPath, `${generated.identifier}.md`)
+
+      await fs.mkdir(targetPath, { recursive: true })
+
+      if (await Filesystem.exists(filePath)) {
+        if (isFullyNonInteractive) {
+          console.error(`Error: Agent file already exists: ${filePath}`)
+          process.exit(1)
+        }
+        prompts.log.error(`Agent file already exists: ${filePath}`)
+        throw new UI.CancelledError()
+      }
+
+      await Filesystem.write(filePath, content)
+
+      if (isFullyNonInteractive) {
+        console.log(filePath)
+      } else {
+        prompts.log.success(`Agent created: ${filePath}`)
+        prompts.outro("Done")
+      }
+    })
+  }),
+})
+
+const AgentListCommand = effectCmd({
+  command: "list",
+  describe: "list all available agents",
+  handler: Effect.fn("Cli.agent.list")(function* () {
+    const { Agent } = yield* Effect.promise(() => import("../../agent/agent"))
+    const agents = yield* Agent.Service.use((svc) => svc.list())
+    const sortedAgents = agents.sort((a, b) => {
+      if (a.native !== b.native) {
+        return a.native ? -1 : 1
+      }
+      return a.name.localeCompare(b.name)
+    })
+
+    for (const agent of sortedAgents) {
+      process.stdout.write(`${agent.name} (${agent.mode})` + EOL)
+      process.stdout.write(`  ${JSON.stringify(agent.permission, null, 2)}` + EOL)
+    }
+  }),
+})
+
+export const AgentCommand = cmd({
+  command: "agent",
+  describe: "manage agents",
+  builder: (yargs) => yargs.command(AgentCreateCommand).command(AgentListCommand).demandCommand(),
+  async handler() {},
+})

package/src/cli/cmd/cmd.ts

@@ -0,0 +1,7 @@
+import type { CommandModule } from "yargs"
+
+export type WithDoubleDash<T> = T & { "--"?: string[] }
+
+export function cmd<T, U>(input: CommandModule<T, WithDoubleDash<U>>) {
+  return input
+}

package/src/cli/cmd/db.ts

@@ -0,0 +1,62 @@
+import type { Argv } from "yargs"
+import { spawn } from "child_process"
+import { Database } from "@opencode-ai/core/database/database"
+import { Effect } from "effect"
+import { sql } from "drizzle-orm"
+import { effectCmd } from "../effect-cmd"
+
+const QueryCommand = effectCmd({
+  command: "$0 [query]",
+  describe: "open an interactive sqlite3 shell or run a query",
+  instance: false,
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("query", {
+        type: "string",
+        describe: "SQL query to execute",
+      })
+      .option("format", {
+        type: "string",
+        choices: ["json", "tsv"],
+        default: "tsv",
+        describe: "Output format",
+      })
+  },
+  handler: Effect.fn("Cli.db.query")(function* (args: { query?: string; format: string }) {
+    const query = args.query as string | undefined
+    if (query) {
+      const { db } = yield* Database.Service
+      const result = yield* db.all<Record<string, unknown>>(sql.raw(query)).pipe(Effect.orDie)
+      if (args.format === "json") console.log(JSON.stringify(result, null, 2))
+      else if (result.length > 0) {
+        const keys = Object.keys(result[0])
+        console.log(keys.join("\t"))
+        for (const row of result) console.log(keys.map((key) => row[key]).join("\t"))
+      }
+      return
+    }
+    const child = spawn("sqlite3", [Database.path()], {
+      stdio: "inherit",
+    })
+    yield* Effect.promise(() => new Promise((resolve) => child.on("close", resolve)))
+  }),
+})
+
+const PathCommand = effectCmd({
+  command: "path",
+  describe: "print the database path",
+  instance: false,
+  handler: Effect.fn("Cli.db.path")(function* () {
+    console.log(Database.path())
+  }),
+})
+
+export const DbCommand = effectCmd({
+  command: "db",
+  describe: "database tools",
+  instance: false,
+  builder: (yargs: Argv) => {
+    return yargs.command(QueryCommand).command(PathCommand).demandCommand()
+  },
+  handler: Effect.fn("Cli.db")(function* () {}),
+})

package/src/cli/cmd/debug/agent.handler.ts

@@ -0,0 +1,193 @@
+import { PermissionV1 } from "@opencode-ai/core/v1/permission"
+import { EOL } from "os"
+import { SessionV1 } from "@opencode-ai/core/v1/session"
+import { basename } from "path"
+import { Cause, Effect } from "effect"
+import { Agent } from "../../../agent/agent"
+import { Provider } from "@/provider/provider"
+import { Session } from "@/session/session"
+import type { MessageV2 } from "../../../session/message-v2"
+import { MessageID, PartID } from "../../../session/schema"
+import { ToolRegistry } from "@/tool/registry"
+import { Permission } from "../../../permission"
+import { iife } from "../../../util/iife"
+import { fail } from "../../effect-cmd"
+import { InstanceRef } from "@/effect/instance-ref"
+import type { InstanceContext } from "@/project/instance-context"
+
+export const debugAgent = Effect.fn("Cli.debug.agent")(function* (args: {
+  name: string
+  tool?: string
+  params?: string
+}) {
+  const ctx = yield* InstanceRef
+  if (!ctx) return
+  return yield* run(args, ctx)
+})
+
+const run = Effect.fn("Cli.debug.agent.body")(function* (
+  args: { name: string; tool?: string; params?: string },
+  ctx: InstanceContext,
+) {
+  const agentName = args.name
+  const agent = yield* Agent.Service.use((svc) => svc.get(agentName))
+  if (!agent) {
+    process.stderr.write(
+      `Agent ${agentName} not found, run '${basename(process.execPath)} agent list' to get an agent list` + EOL,
+    )
+    return yield* fail("", 1)
+  }
+  const availableTools = yield* getAvailableTools(agent)
+  const resolvedTools = resolveTools(agent, availableTools)
+  const toolID = args.tool
+  if (toolID) {
+    const tool = availableTools.find((item) => item.id === toolID)
+    if (!tool) {
+      process.stderr.write(`Tool ${toolID} not found for agent ${agentName}` + EOL)
+      return yield* fail("", 1)
+    }
+    if (resolvedTools[toolID] === false) {
+      process.stderr.write(`Tool ${toolID} is disabled for agent ${agentName}` + EOL)
+      return yield* fail("", 1)
+    }
+    const params = parseToolParams(args.params)
+    const toolCtx = yield* createToolContext(agent, ctx)
+    const result = yield* tool.execute(params, toolCtx)
+    process.stdout.write(JSON.stringify({ tool: toolID, input: params, result }, null, 2) + EOL)
+    return
+  }
+
+  const output = {
+    ...agent,
+    tools: resolvedTools,
+  }
+  process.stdout.write(JSON.stringify(output, null, 2) + EOL)
+})
+
+const getAvailableTools = Effect.fn("Cli.debug.agent.getAvailableTools")(function* (agent: Agent.Info) {
+  const provider = yield* Provider.Service
+  const registry = yield* ToolRegistry.Service
+  const model =
+    agent.model ??
+    (yield* provider.defaultModel().pipe(
+      Effect.matchCauseEffect({
+        onSuccess: Effect.succeed,
+        onFailure: (cause) => {
+          const error = Cause.squash(cause) as Provider.DefaultModelError
+          if (error instanceof Provider.ModelNotFoundError) {
+            return fail(`Model not found: ${error.providerID}/${error.modelID}`)
+          }
+          if (error instanceof Provider.NoModelsError) return fail(`No models found for provider ${error.providerID}`)
+          return fail("No providers found")
+        },
+      }),
+    ))
+  return yield* registry.tools({ ...model, agent })
+})
+
+function resolveTools(agent: Agent.Info, availableTools: { id: string }[]) {
+  const disabled = Permission.disabled(
+    availableTools.map((tool) => tool.id),
+    agent.permission,
+  )
+  const resolved: Record<string, boolean> = {}
+  for (const tool of availableTools) {
+    resolved[tool.id] = !disabled.has(tool.id)
+  }
+  return resolved
+}
+
+function parseToolParams(input?: string) {
+  if (!input) return {}
+  const trimmed = input.trim()
+  if (trimmed.length === 0) return {}
+
+  const parsed = iife(() => {
+    try {
+      return JSON.parse(trimmed)
+    } catch (jsonError) {
+      try {
+        return new Function(`return (${trimmed})`)()
+      } catch (evalError) {
+        throw new Error(
+          `Failed to parse --params. Use JSON or a JS object literal. JSON error: ${jsonError}. Eval error: ${evalError}.`,
+          { cause: evalError },
+        )
+      }
+    }
+  })
+
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Tool params must be an object.")
+  }
+  return parsed as Record<string, unknown>
+}
+
+const createToolContext = Effect.fn("Cli.debug.agent.createToolContext")(function* (
+  agent: Agent.Info,
+  ctx: InstanceContext,
+) {
+  const sessionSvc = yield* Session.Service
+  const session = yield* sessionSvc.create({ title: `Debug tool run (${agent.name})` })
+  const messageID = MessageID.ascending()
+  const model = agent.model
+    ? agent.model
+    : yield* Effect.gen(function* () {
+        const provider = yield* Provider.Service
+        return yield* provider.defaultModel().pipe(
+          Effect.matchCauseEffect({
+            onSuccess: Effect.succeed,
+            onFailure: (cause) => {
+              const error = Cause.squash(cause) as Provider.DefaultModelError
+              if (error instanceof Provider.ModelNotFoundError) {
+                return fail(`Model not found: ${error.providerID}/${error.modelID}`)
+              }
+              if (error instanceof Provider.NoModelsError)
+                return fail(`No models found for provider ${error.providerID}`)
+              return fail("No providers found")
+            },
+          }),
+        )
+      })
+  const now = Date.now()
+  const message: SessionV1.Assistant = {
+    id: messageID,
+    sessionID: session.id,
+    role: "assistant",
+    time: { created: now },
+    parentID: messageID,
+    modelID: model.modelID,
+    providerID: model.providerID,
+    mode: "debug",
+    agent: agent.name,
+    path: {
+      cwd: ctx.directory,
+      root: ctx.worktree,
+    },
+    cost: 0,
+    tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+  }
+  yield* sessionSvc.updateMessage(message)
+
+  const ruleset = Permission.merge(agent.permission, session.permission ?? [])
+
+  return {
+    sessionID: session.id,
+    messageID,
+    callID: PartID.ascending(),
+    agent: agent.name,
+    abort: new AbortController().signal,
+    messages: [],
+    metadata: () => Effect.void,
+    ask(req: Omit<PermissionV1.Request, "id" | "sessionID" | "tool">) {
+      return Effect.sync(() => {
+        for (const pattern of req.patterns) {
+          const rule = Permission.evaluate(req.permission, pattern, ruleset)
+          if (rule.action === "deny") {
+            throw new PermissionV1.DeniedError({ ruleset })
+          }
+        }
+      })
+    },
+  }
+})

package/src/cli/cmd/debug/agent.ts

@@ -0,0 +1,27 @@
+import { Effect } from "effect"
+import { effectCmd } from "../../effect-cmd"
+
+export const AgentCommand = effectCmd({
+  command: "agent <name>",
+  describe: "show agent configuration details",
+  builder: (yargs) =>
+    yargs
+      .positional("name", {
+        type: "string",
+        demandOption: true,
+        description: "Agent name",
+      })
+      .option("tool", {
+        type: "string",
+        description: "Tool id to execute",
+      })
+      .option("params", {
+        type: "string",
+        description: "Tool params as JSON or a JS object literal",
+      }),
+  handler: (args) =>
+    Effect.gen(function* () {
+      const { debugAgent } = yield* Effect.promise(() => import("./agent.handler"))
+      return yield* debugAgent(args)
+    }),
+})

package/src/cli/cmd/debug/config.ts

@@ -0,0 +1,14 @@
+import { EOL } from "os"
+import { Effect } from "effect"
+import { effectCmd } from "../../effect-cmd"
+
+export const ConfigCommand = effectCmd({
+  command: "config",
+  describe: "show resolved configuration",
+  builder: (yargs) => yargs,
+  handler: Effect.fn("Cli.debug.config")(function* () {
+    const { Config } = yield* Effect.promise(() => import("@/config/config"))
+    const config = yield* Config.Service.use((cfg) => cfg.get())
+    process.stdout.write(JSON.stringify(config, null, 2) + EOL)
+  }),
+})