alchemylab-opencode 1.0.3 → 1.0.5

package/dist/chunk-UWZSRZHA.js

@@ -0,0 +1,5025 @@
+// Built by esbuild from opencode-server source
+if (typeof globalThis.Bun === 'undefined') {
+  globalThis.Bun = {
+    version: '0.0.0-node-compat',
+    stdin: { async text() { const chunks = []; for await (const c of process.stdin) chunks.push(c); return Buffer.concat(chunks).toString(); } },
+    which(cmd) { try { return require('child_process').execFileSync('which', [cmd], { encoding: 'utf8' }).trim(); } catch { return null; } },
+  };
+}
+if (typeof globalThis.__name === 'undefined') { globalThis.__name = (t, n) => { Object.defineProperty(t, 'name', { value: n, configurable: true }); return t; }; }
+if (typeof globalThis.__export === 'undefined') { globalThis.__export = (t, a) => { for (const k in a) Object.defineProperty(t, k, { get: a[k], enumerable: true }); }; }
+
+import {
+  InstanceBootstrap,
+  Vcs,
+  WorkspaceInfo,
+  Worktree
+} from "./chunk-MCWTARFP.js";
+import {
+  Agent,
+  Command,
+  File,
+  Format,
+  LSP,
+  MessageV2,
+  ModelID,
+  Permission,
+  PermissionID,
+  Plugin,
+  Provider,
+  ProviderID,
+  Question,
+  QuestionID,
+  Ripgrep,
+  Session,
+  SessionCompaction,
+  SessionPrompt,
+  SessionRevert,
+  SessionStatus,
+  SessionSummary,
+  Shell,
+  Skill,
+  Snapshot,
+  SyncEvent,
+  Todo,
+  ToolRegistry,
+  WorkspaceID,
+  fn
+} from "./chunk-DSPC5QIG.js";
+import {
+  Account,
+  AccountID,
+  Auth,
+  Bus,
+  Config,
+  Installation,
+  MCP,
+  ModelsDev,
+  OrgID,
+  TuiEvent
+} from "./chunk-CYXMV3J3.js";
+import {
+  BusEvent,
+  Database,
+  Filesystem,
+  Flag,
+  Global,
+  GlobalBus,
+  Instance,
+  InstanceState,
+  Log,
+  MessageTable,
+  NamedError,
+  NotFoundError,
+  PartTable,
+  Project,
+  ProjectID,
+  ProjectTable,
+  SessionTable,
+  db_exports,
+  lazy,
+  makeRuntime
+} from "./chunk-B3FN2B2N.js";
+import {
+  Identifier,
+  MessageID,
+  PartID,
+  SessionID
+} from "./chunk-CR6IREZA.js";
+import {
+  withStatics
+} from "./chunk-BI5OUHTQ.js";
+import {
+  __callDispose,
+  __using
+} from "./chunk-HORZKFCR.js";
+
+// packages/opencode/src/server/server.ts
+import { describeRoute as describeRoute16, generateSpecs, validator as validator15, resolver as resolver17, openAPIRouteHandler } from "hono-openapi";
+import { Hono as Hono17 } from "hono";
+import { compress } from "hono/compress";
+import { cors } from "hono/cors";
+import { basicAuth } from "hono/basic-auth";
+import z21 from "zod";
+import { createAdaptorServer } from "@hono/node-server";
+import { createNodeWebSocket as createNodeWebSocket2 } from "@hono/node-ws";
+
+// packages/opencode/src/control-plane/adaptors/index.ts
+var ADAPTORS = {
+  worktree: lazy(async () => (await import("./worktree-6GGDLADY.js")).WorktreeAdaptor)
+};
+function getAdaptor(type) {
+  return ADAPTORS[type]();
+}
+
+// packages/opencode/src/control-plane/workspace.ts
+import z from "zod";
+import { setTimeout as sleep } from "node:timers/promises";
+
+// packages/opencode/src/control-plane/workspace.sql.ts
+import { sqliteTable, text } from "drizzle-orm/sqlite-core";
+var WorkspaceTable = sqliteTable("workspace", {
+  id: text().$type().primaryKey(),
+  type: text().notNull(),
+  branch: text(),
+  name: text(),
+  directory: text(),
+  extra: text({ mode: "json" }),
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" })
+});
+
+// packages/opencode/src/control-plane/sse.ts
+async function parseSSE(body, signal, onEvent) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buf = "";
+  let last = "";
+  let retry = 1e3;
+  const abort = () => {
+    void reader.cancel().catch(() => void 0);
+  };
+  signal.addEventListener("abort", abort);
+  try {
+    while (!signal.aborted) {
+      const chunk = await reader.read().catch(() => ({ done: true, value: void 0 }));
+      if (chunk.done) break;
+      buf += decoder.decode(chunk.value, { stream: true });
+      buf = buf.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+      const chunks = buf.split("\n\n");
+      buf = chunks.pop() ?? "";
+      chunks.forEach((chunk2) => {
+        const data = [];
+        chunk2.split("\n").forEach((line) => {
+          if (line.startsWith("data:")) {
+            data.push(line.replace(/^data:\s*/, ""));
+            return;
+          }
+          if (line.startsWith("id:")) {
+            last = line.replace(/^id:\s*/, "");
+            return;
+          }
+          if (line.startsWith("retry:")) {
+            const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+            if (!Number.isNaN(parsed)) retry = parsed;
+          }
+        });
+        if (!data.length) return;
+        const raw = data.join("\n");
+        try {
+          onEvent(JSON.parse(raw));
+        } catch {
+          onEvent({
+            type: "sse.message",
+            properties: {
+              data: raw,
+              id: last || void 0,
+              retry
+            }
+          });
+        }
+      });
+    }
+  } finally {
+    signal.removeEventListener("abort", abort);
+    reader.releaseLock();
+  }
+}
+
+// packages/opencode/src/control-plane/workspace.ts
+var Workspace;
+((Workspace2) => {
+  Workspace2.Event = {
+    Ready: BusEvent.define(
+      "workspace.ready",
+      z.object({
+        name: z.string()
+      })
+    ),
+    Failed: BusEvent.define(
+      "workspace.failed",
+      z.object({
+        message: z.string()
+      })
+    )
+  };
+  Workspace2.Info = WorkspaceInfo.meta({
+    ref: "Workspace"
+  });
+  function fromRow(row) {
+    return {
+      id: row.id,
+      type: row.type,
+      branch: row.branch,
+      name: row.name,
+      directory: row.directory,
+      extra: row.extra,
+      projectID: row.project_id
+    };
+  }
+  const CreateInput = z.object({
+    id: WorkspaceID.zod.optional(),
+    type: Workspace2.Info.shape.type,
+    branch: Workspace2.Info.shape.branch,
+    projectID: ProjectID.zod,
+    extra: Workspace2.Info.shape.extra
+  });
+  Workspace2.create = fn(CreateInput, async (input) => {
+    const id = WorkspaceID.ascending(input.id);
+    const adaptor = await getAdaptor(input.type);
+    const config = await adaptor.configure({ ...input, id, name: null, directory: null });
+    const info = {
+      id,
+      type: config.type,
+      branch: config.branch ?? null,
+      name: config.name ?? null,
+      directory: config.directory ?? null,
+      extra: config.extra ?? null,
+      projectID: input.projectID
+    };
+    Database.use((db) => {
+      db.insert(WorkspaceTable).values({
+        id: info.id,
+        type: info.type,
+        branch: info.branch,
+        name: info.name,
+        directory: info.directory,
+        extra: info.extra,
+        project_id: info.projectID
+      }).run();
+    });
+    await adaptor.create(config);
+    return info;
+  });
+  function list(project) {
+    const rows = Database.use(
+      (db) => db.select().from(WorkspaceTable).where((0, db_exports.eq)(WorkspaceTable.project_id, project.id)).all()
+    );
+    return rows.map(fromRow).sort((a, b) => a.id.localeCompare(b.id));
+  }
+  Workspace2.list = list;
+  Workspace2.get = fn(WorkspaceID.zod, async (id) => {
+    const row = Database.use((db) => db.select().from(WorkspaceTable).where((0, db_exports.eq)(WorkspaceTable.id, id)).get());
+    if (!row) return;
+    return fromRow(row);
+  });
+  Workspace2.remove = fn(WorkspaceID.zod, async (id) => {
+    const row = Database.use((db) => db.select().from(WorkspaceTable).where((0, db_exports.eq)(WorkspaceTable.id, id)).get());
+    if (row) {
+      const info = fromRow(row);
+      const adaptor = await getAdaptor(row.type);
+      adaptor.remove(info);
+      Database.use((db) => db.delete(WorkspaceTable).where((0, db_exports.eq)(WorkspaceTable.id, id)).run());
+      return info;
+    }
+  });
+  const log9 = Log.create({ service: "workspace-sync" });
+  async function workspaceEventLoop(space, stop) {
+    while (!stop.aborted) {
+      const adaptor = await getAdaptor(space.type);
+      const target = await Promise.resolve(adaptor.target(space));
+      if (target.type === "local") {
+        return;
+      }
+      const baseURL = String(target.url).replace(/\/?$/, "/");
+      const res = await fetch(new URL(baseURL + "/event"), {
+        method: "GET",
+        signal: stop
+      });
+      if (!res.ok || !res.body) {
+        await sleep(1e3);
+        continue;
+      }
+      await parseSSE(res.body, stop, (event) => {
+        GlobalBus.emit("event", {
+          directory: space.id,
+          payload: event
+        });
+      });
+      await sleep(250);
+    }
+  }
+  function startSyncing(project) {
+    const stop = new AbortController();
+    const spaces = list(project).filter((space) => space.type !== "worktree");
+    spaces.forEach((space) => {
+      void workspaceEventLoop(space, stop.signal).catch((error) => {
+        log9.warn("workspace sync listener failed", {
+          workspaceID: space.id,
+          error
+        });
+      });
+    });
+    return {
+      async stop() {
+        stop.abort();
+      }
+    };
+  }
+  Workspace2.startSyncing = startSyncing;
+})(Workspace || (Workspace = {}));
+
+// packages/opencode/src/server/proxy.ts
+import { Hono } from "hono";
+import { createNodeWebSocket } from "@hono/node-ws";
+var { upgradeWebSocket } = createNodeWebSocket({ app: new Hono() });
+var hop = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "proxy-connection",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host"
+]);
+function headers(req, extra) {
+  const out = new Headers(req.headers);
+  for (const key of hop) out.delete(key);
+  out.delete("x-opencode-directory");
+  out.delete("x-opencode-workspace");
+  if (!extra) return out;
+  for (const [key, value] of new Headers(extra).entries()) {
+    out.set(key, value);
+  }
+  return out;
+}
+function protocols(req) {
+  const value = req.headers.get("sec-websocket-protocol");
+  if (!value) return [];
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function socket(url) {
+  const next = new URL(url);
+  if (next.protocol === "http:") next.protocol = "ws:";
+  if (next.protocol === "https:") next.protocol = "wss:";
+  return next.toString();
+}
+function send(ws, data) {
+  if (data instanceof Blob) {
+    return data.arrayBuffer().then((x) => ws.send(x));
+  }
+  return ws.send(data);
+}
+var app = lazy(
+  () => new Hono().get(
+    "/__workspace_ws",
+    upgradeWebSocket((c) => {
+      const url = c.req.header("x-opencode-proxy-url");
+      const queue = [];
+      let remote;
+      return {
+        onOpen(_, ws) {
+          if (!url) {
+            ws.close(1011, "missing proxy target");
+            return;
+          }
+          remote = new WebSocket(url, protocols(c.req.raw));
+          remote.binaryType = "arraybuffer";
+          remote.onopen = () => {
+            for (const item of queue) remote?.send(item);
+            queue.length = 0;
+          };
+          remote.onmessage = (event) => {
+            send(ws, event.data);
+          };
+          remote.onerror = () => {
+            ws.close(1011, "proxy error");
+          };
+          remote.onclose = (event) => {
+            ws.close(event.code, event.reason);
+          };
+        },
+        onMessage(event) {
+          const data = event.data;
+          if (typeof data !== "string" && !(data instanceof Uint8Array) && !(data instanceof ArrayBuffer)) return;
+          if (remote?.readyState === WebSocket.OPEN) {
+            remote.send(data);
+            return;
+          }
+          queue.push(data);
+        },
+        onClose(event) {
+          remote?.close(event.code, event.reason);
+        }
+      };
+    })
+  )
+);
+var ServerProxy;
+((ServerProxy2) => {
+  function http(target, req) {
+    return fetch(
+      new Request(target.url, {
+        method: req.method,
+        headers: headers(req, target.headers),
+        body: req.method === "GET" || req.method === "HEAD" ? void 0 : req.body,
+        redirect: "manual",
+        signal: req.signal
+      })
+    );
+  }
+  ServerProxy2.http = http;
+  function websocket(target, req, env) {
+    const url = new URL(req.url);
+    url.pathname = "/__workspace_ws";
+    url.search = "";
+    const next = new Headers(req.headers);
+    next.set("x-opencode-proxy-url", socket(target.url));
+    return app().fetch(
+      new Request(url, {
+        method: req.method,
+        headers: next,
+        signal: req.signal
+      }),
+      env
+    );
+  }
+  ServerProxy2.websocket = websocket;
+})(ServerProxy || (ServerProxy = {}));
+
+// packages/opencode/src/server/instance.ts
+import { describeRoute as describeRoute14, resolver as resolver15, validator as validator13 } from "hono-openapi";
+import { Hono as Hono15 } from "hono";
+import { proxy } from "hono/proxy";
+import z19 from "zod";
+import { createHash } from "node:crypto";
+
+// packages/opencode/src/server/routes/tui.ts
+import { Hono as Hono2 } from "hono";
+import { describeRoute, validator, resolver as resolver2 } from "hono-openapi";
+import z3 from "zod";
+
+// packages/opencode/src/util/queue.ts
+var AsyncQueue = class {
+  queue = [];
+  resolvers = [];
+  push(item) {
+    const resolve = this.resolvers.shift();
+    if (resolve) resolve(item);
+    else this.queue.push(item);
+  }
+  async next() {
+    if (this.queue.length > 0) return this.queue.shift();
+    return new Promise((resolve) => this.resolvers.push(resolve));
+  }
+  async *[Symbol.asyncIterator]() {
+    while (true) yield await this.next();
+  }
+};
+
+// packages/opencode/src/server/error.ts
+import { resolver } from "hono-openapi";
+import z2 from "zod";
+var ERRORS = {
+  400: {
+    description: "Bad request",
+    content: {
+      "application/json": {
+        schema: resolver(
+          z2.object({
+            data: z2.any(),
+            errors: z2.array(z2.record(z2.string(), z2.any())),
+            success: z2.literal(false)
+          }).meta({
+            ref: "BadRequestError"
+          })
+        )
+      }
+    }
+  },
+  404: {
+    description: "Not found",
+    content: {
+      "application/json": {
+        schema: resolver(NotFoundError.Schema)
+      }
+    }
+  }
+};
+function errors(...codes) {
+  return Object.fromEntries(codes.map((code) => [code, ERRORS[code]]));
+}
+
+// packages/opencode/src/server/routes/tui.ts
+var TuiRequest = z3.object({
+  path: z3.string(),
+  body: z3.any()
+});
+var request = new AsyncQueue();
+var response = new AsyncQueue();
+var TuiControlRoutes = new Hono2().get(
+  "/next",
+  describeRoute({
+    summary: "Get next TUI request",
+    description: "Retrieve the next TUI (Terminal User Interface) request from the queue for processing.",
+    operationId: "tui.control.next",
+    responses: {
+      200: {
+        description: "Next TUI request",
+        content: {
+          "application/json": {
+            schema: resolver2(TuiRequest)
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    const req = await request.next();
+    return c.json(req);
+  }
+).post(
+  "/response",
+  describeRoute({
+    summary: "Submit TUI response",
+    description: "Submit a response to the TUI request queue to complete a pending request.",
+    operationId: "tui.control.response",
+    responses: {
+      200: {
+        description: "Response submitted successfully",
+        content: {
+          "application/json": {
+            schema: resolver2(z3.boolean())
+          }
+        }
+      }
+    }
+  }),
+  validator("json", z3.any()),
+  async (c) => {
+    const body = c.req.valid("json");
+    response.push(body);
+    return c.json(true);
+  }
+);
+var TuiRoutes = lazy(
+  () => new Hono2().post(
+    "/append-prompt",
+    describeRoute({
+      summary: "Append TUI prompt",
+      description: "Append prompt to the TUI",
+      operationId: "tui.appendPrompt",
+      responses: {
+        200: {
+          description: "Prompt processed successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator("json", TuiEvent.PromptAppend.properties),
+    async (c) => {
+      await Bus.publish(TuiEvent.PromptAppend, c.req.valid("json"));
+      return c.json(true);
+    }
+  ).post(
+    "/open-help",
+    describeRoute({
+      summary: "Open help dialog",
+      description: "Open the help dialog in the TUI to display user assistance information.",
+      operationId: "tui.openHelp",
+      responses: {
+        200: {
+          description: "Help dialog opened successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Bus.publish(TuiEvent.CommandExecute, {
+        command: "help.show"
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/open-sessions",
+    describeRoute({
+      summary: "Open sessions dialog",
+      description: "Open the session dialog",
+      operationId: "tui.openSessions",
+      responses: {
+        200: {
+          description: "Session dialog opened successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Bus.publish(TuiEvent.CommandExecute, {
+        command: "session.list"
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/open-themes",
+    describeRoute({
+      summary: "Open themes dialog",
+      description: "Open the theme dialog",
+      operationId: "tui.openThemes",
+      responses: {
+        200: {
+          description: "Theme dialog opened successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Bus.publish(TuiEvent.CommandExecute, {
+        command: "session.list"
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/open-models",
+    describeRoute({
+      summary: "Open models dialog",
+      description: "Open the model dialog",
+      operationId: "tui.openModels",
+      responses: {
+        200: {
+          description: "Model dialog opened successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Bus.publish(TuiEvent.CommandExecute, {
+        command: "model.list"
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/submit-prompt",
+    describeRoute({
+      summary: "Submit TUI prompt",
+      description: "Submit the prompt",
+      operationId: "tui.submitPrompt",
+      responses: {
+        200: {
+          description: "Prompt submitted successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Bus.publish(TuiEvent.CommandExecute, {
+        command: "prompt.submit"
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/clear-prompt",
+    describeRoute({
+      summary: "Clear TUI prompt",
+      description: "Clear the prompt",
+      operationId: "tui.clearPrompt",
+      responses: {
+        200: {
+          description: "Prompt cleared successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Bus.publish(TuiEvent.CommandExecute, {
+        command: "prompt.clear"
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/execute-command",
+    describeRoute({
+      summary: "Execute TUI command",
+      description: "Execute a TUI command (e.g. agent_cycle)",
+      operationId: "tui.executeCommand",
+      responses: {
+        200: {
+          description: "Command executed successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator("json", z3.object({ command: z3.string() })),
+    async (c) => {
+      const command = c.req.valid("json").command;
+      await Bus.publish(TuiEvent.CommandExecute, {
+        // @ts-expect-error
+        command: {
+          session_new: "session.new",
+          session_share: "session.share",
+          session_interrupt: "session.interrupt",
+          session_compact: "session.compact",
+          messages_page_up: "session.page.up",
+          messages_page_down: "session.page.down",
+          messages_line_up: "session.line.up",
+          messages_line_down: "session.line.down",
+          messages_half_page_up: "session.half.page.up",
+          messages_half_page_down: "session.half.page.down",
+          messages_first: "session.first",
+          messages_last: "session.last",
+          agent_cycle: "agent.cycle"
+        }[command]
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/show-toast",
+    describeRoute({
+      summary: "Show TUI toast",
+      description: "Show a toast notification in the TUI",
+      operationId: "tui.showToast",
+      responses: {
+        200: {
+          description: "Toast notification shown successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        }
+      }
+    }),
+    validator("json", TuiEvent.ToastShow.properties),
+    async (c) => {
+      await Bus.publish(TuiEvent.ToastShow, c.req.valid("json"));
+      return c.json(true);
+    }
+  ).post(
+    "/publish",
+    describeRoute({
+      summary: "Publish TUI event",
+      description: "Publish a TUI event",
+      operationId: "tui.publish",
+      responses: {
+        200: {
+          description: "Event published successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator(
+      "json",
+      z3.union(
+        Object.values(TuiEvent).map((def) => {
+          return z3.object({
+            type: z3.literal(def.type),
+            properties: def.properties
+          }).meta({
+            ref: "Event." + def.type
+          });
+        })
+      )
+    ),
+    async (c) => {
+      const evt = c.req.valid("json");
+      await Bus.publish(Object.values(TuiEvent).find((def) => def.type === evt.type), evt.properties);
+      return c.json(true);
+    }
+  ).post(
+    "/select-session",
+    describeRoute({
+      summary: "Select session",
+      description: "Navigate the TUI to display the specified session.",
+      operationId: "tui.selectSession",
+      responses: {
+        200: {
+          description: "Session selected successfully",
+          content: {
+            "application/json": {
+              schema: resolver2(z3.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator("json", TuiEvent.SessionSelect.properties),
+    async (c) => {
+      const { sessionID } = c.req.valid("json");
+      await Session.get(sessionID);
+      await Bus.publish(TuiEvent.SessionSelect, { sessionID });
+      return c.json(true);
+    }
+  ).route("/control", TuiControlRoutes)
+);
+
+// packages/opencode/src/server/routes/question.ts
+import { Hono as Hono3 } from "hono";
+import { describeRoute as describeRoute2, validator as validator2 } from "hono-openapi";
+import { resolver as resolver3 } from "hono-openapi";
+import z4 from "zod";
+var QuestionRoutes = lazy(
+  () => new Hono3().get(
+    "/",
+    describeRoute2({
+      summary: "List pending questions",
+      description: "Get all pending question requests across all sessions.",
+      operationId: "question.list",
+      responses: {
+        200: {
+          description: "List of pending questions",
+          content: {
+            "application/json": {
+              schema: resolver3(Question.Request.array())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const questions = await Question.list();
+      return c.json(questions);
+    }
+  ).post(
+    "/:requestID/reply",
+    describeRoute2({
+      summary: "Reply to question request",
+      description: "Provide answers to a question request from the AI assistant.",
+      operationId: "question.reply",
+      responses: {
+        200: {
+          description: "Question answered successfully",
+          content: {
+            "application/json": {
+              schema: resolver3(z4.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator2(
+      "param",
+      z4.object({
+        requestID: QuestionID.zod
+      })
+    ),
+    validator2("json", Question.Reply),
+    async (c) => {
+      const params = c.req.valid("param");
+      const json = c.req.valid("json");
+      await Question.reply({
+        requestID: params.requestID,
+        answers: json.answers
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/:requestID/reject",
+    describeRoute2({
+      summary: "Reject question request",
+      description: "Reject a question request from the AI assistant.",
+      operationId: "question.reject",
+      responses: {
+        200: {
+          description: "Question rejected successfully",
+          content: {
+            "application/json": {
+              schema: resolver3(z4.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator2(
+      "param",
+      z4.object({
+        requestID: QuestionID.zod
+      })
+    ),
+    async (c) => {
+      const params = c.req.valid("param");
+      await Question.reject(params.requestID);
+      return c.json(true);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/permission.ts
+import { Hono as Hono4 } from "hono";
+import { describeRoute as describeRoute3, validator as validator3, resolver as resolver4 } from "hono-openapi";
+import z5 from "zod";
+var PermissionRoutes = lazy(
+  () => new Hono4().post(
+    "/:requestID/reply",
+    describeRoute3({
+      summary: "Respond to permission request",
+      description: "Approve or deny a permission request from the AI assistant.",
+      operationId: "permission.reply",
+      responses: {
+        200: {
+          description: "Permission processed successfully",
+          content: {
+            "application/json": {
+              schema: resolver4(z5.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator3(
+      "param",
+      z5.object({
+        requestID: PermissionID.zod
+      })
+    ),
+    validator3("json", z5.object({ reply: Permission.Reply, message: z5.string().optional() })),
+    async (c) => {
+      const params = c.req.valid("param");
+      const json = c.req.valid("json");
+      await Permission.reply({
+        requestID: params.requestID,
+        reply: json.reply,
+        message: json.message
+      });
+      return c.json(true);
+    }
+  ).get(
+    "/",
+    describeRoute3({
+      summary: "List pending permissions",
+      description: "Get all pending permission requests across all sessions.",
+      operationId: "permission.list",
+      responses: {
+        200: {
+          description: "List of pending permissions",
+          content: {
+            "application/json": {
+              schema: resolver4(Permission.Request.array())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const permissions = await Permission.list();
+      return c.json(permissions);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/project.ts
+import { Hono as Hono5 } from "hono";
+import { describeRoute as describeRoute4, validator as validator4 } from "hono-openapi";
+import { resolver as resolver5 } from "hono-openapi";
+import z6 from "zod";
+var ProjectRoutes = lazy(
+  () => new Hono5().get(
+    "/",
+    describeRoute4({
+      summary: "List all projects",
+      description: "Get a list of projects that have been opened with OpenCode.",
+      operationId: "project.list",
+      responses: {
+        200: {
+          description: "List of projects",
+          content: {
+            "application/json": {
+              schema: resolver5(Project.Info.array())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const projects = Project.list();
+      return c.json(projects);
+    }
+  ).get(
+    "/current",
+    describeRoute4({
+      summary: "Get current project",
+      description: "Retrieve the currently active project that OpenCode is working with.",
+      operationId: "project.current",
+      responses: {
+        200: {
+          description: "Current project information",
+          content: {
+            "application/json": {
+              schema: resolver5(Project.Info)
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(Instance.project);
+    }
+  ).post(
+    "/git/init",
+    describeRoute4({
+      summary: "Initialize git repository",
+      description: "Create a git repository for the current project and return the refreshed project info.",
+      operationId: "project.initGit",
+      responses: {
+        200: {
+          description: "Project information after git initialization",
+          content: {
+            "application/json": {
+              schema: resolver5(Project.Info)
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const dir = Instance.directory;
+      const prev = Instance.project;
+      const next = await Project.initGit({
+        directory: dir,
+        project: prev
+      });
+      if (next.id === prev.id && next.vcs === prev.vcs && next.worktree === prev.worktree) return c.json(next);
+      await Instance.reload({
+        directory: dir,
+        worktree: dir,
+        project: next,
+        init: InstanceBootstrap
+      });
+      return c.json(next);
+    }
+  ).patch(
+    "/:projectID",
+    describeRoute4({
+      summary: "Update project",
+      description: "Update project properties such as name, icon, and commands.",
+      operationId: "project.update",
+      responses: {
+        200: {
+          description: "Updated project information",
+          content: {
+            "application/json": {
+              schema: resolver5(Project.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator4("param", z6.object({ projectID: ProjectID.zod })),
+    validator4("json", Project.UpdateInput.omit({ projectID: true })),
+    async (c) => {
+      const projectID = c.req.valid("param").projectID;
+      const body = c.req.valid("json");
+      const project = await Project.update({ ...body, projectID });
+      return c.json(project);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/session.ts
+import { Hono as Hono6 } from "hono";
+import { stream } from "hono/streaming";
+import { describeRoute as describeRoute5, validator as validator5, resolver as resolver6 } from "hono-openapi";
+import z7 from "zod";
+var log = Log.create({ service: "server" });
+var SessionRoutes = lazy(
+  () => new Hono6().get(
+    "/",
+    describeRoute5({
+      summary: "List sessions",
+      description: "Get a list of all OpenCode sessions, sorted by most recently updated.",
+      operationId: "session.list",
+      responses: {
+        200: {
+          description: "List of sessions",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info.array())
+            }
+          }
+        }
+      }
+    }),
+    validator5(
+      "query",
+      z7.object({
+        directory: z7.string().optional().meta({ description: "Filter sessions by project directory" }),
+        roots: z7.coerce.boolean().optional().meta({ description: "Only return root sessions (no parentID)" }),
+        start: z7.coerce.number().optional().meta({ description: "Filter sessions updated on or after this timestamp (milliseconds since epoch)" }),
+        search: z7.string().optional().meta({ description: "Filter sessions by title (case-insensitive)" }),
+        limit: z7.coerce.number().optional().meta({ description: "Maximum number of sessions to return" })
+      })
+    ),
+    async (c) => {
+      const query = c.req.valid("query");
+      const sessions = [];
+      for await (const session of Session.list({
+        directory: query.directory,
+        roots: query.roots,
+        start: query.start,
+        search: query.search,
+        limit: query.limit
+      })) {
+        sessions.push(session);
+      }
+      return c.json(sessions);
+    }
+  ).get(
+    "/status",
+    describeRoute5({
+      summary: "Get session status",
+      description: "Retrieve the current status of all sessions, including active, idle, and completed states.",
+      operationId: "session.status",
+      responses: {
+        200: {
+          description: "Get session status",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.record(z7.string(), SessionStatus.Info))
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    async (c) => {
+      const result = await SessionStatus.list();
+      return c.json(Object.fromEntries(result));
+    }
+  ).get(
+    "/:sessionID",
+    describeRoute5({
+      summary: "Get session",
+      description: "Retrieve detailed information about a specific OpenCode session.",
+      tags: ["Session"],
+      operationId: "session.get",
+      responses: {
+        200: {
+          description: "Get session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: Session.get.schema
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      log.info("SEARCH", { url: c.req.url });
+      const session = await Session.get(sessionID);
+      return c.json(session);
+    }
+  ).get(
+    "/:sessionID/children",
+    describeRoute5({
+      summary: "Get session children",
+      tags: ["Session"],
+      description: "Retrieve all child sessions that were forked from the specified parent session.",
+      operationId: "session.children",
+      responses: {
+        200: {
+          description: "List of children",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info.array())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: Session.children.schema
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const session = await Session.children(sessionID);
+      return c.json(session);
+    }
+  ).get(
+    "/:sessionID/todo",
+    describeRoute5({
+      summary: "Get session todos",
+      description: "Retrieve the todo list associated with a specific session, showing tasks and action items.",
+      operationId: "session.todo",
+      responses: {
+        200: {
+          description: "Todo list",
+          content: {
+            "application/json": {
+              schema: resolver6(Todo.Info.array())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const todos = await Todo.get(sessionID);
+      return c.json(todos);
+    }
+  ).post(
+    "/",
+    describeRoute5({
+      summary: "Create session",
+      description: "Create a new OpenCode session for interacting with AI assistants and managing conversations.",
+      operationId: "session.create",
+      responses: {
+        ...errors(400),
+        200: {
+          description: "Successfully created session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        }
+      }
+    }),
+    validator5("json", Session.create.schema.optional()),
+    async (c) => {
+      const body = c.req.valid("json") ?? {};
+      const session = await Session.create(body);
+      return c.json(session);
+    }
+  ).delete(
+    "/:sessionID",
+    describeRoute5({
+      summary: "Delete session",
+      description: "Delete a session and permanently remove all associated data, including messages and history.",
+      operationId: "session.delete",
+      responses: {
+        200: {
+          description: "Successfully deleted session",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: Session.remove.schema
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      await Session.remove(sessionID);
+      return c.json(true);
+    }
+  ).patch(
+    "/:sessionID",
+    describeRoute5({
+      summary: "Update session",
+      description: "Update properties of an existing session, such as title or other metadata.",
+      operationId: "session.update",
+      responses: {
+        200: {
+          description: "Successfully updated session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5(
+      "json",
+      z7.object({
+        title: z7.string().optional(),
+        time: z7.object({
+          archived: z7.number().optional()
+        }).optional()
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const updates = c.req.valid("json");
+      if (updates.title !== void 0) {
+        await Session.setTitle({ sessionID, title: updates.title });
+      }
+      if (updates.time?.archived !== void 0) {
+        await Session.setArchived({ sessionID, time: updates.time.archived });
+      }
+      const session = await Session.get(sessionID);
+      return c.json(session);
+    }
+  ).post(
+    "/:sessionID/init",
+    describeRoute5({
+      summary: "Initialize session",
+      description: "Analyze the current application and create an AGENTS.md file with project-specific agent configurations.",
+      operationId: "session.init",
+      responses: {
+        200: {
+          description: "200",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5("json", Session.initialize.schema.omit({ sessionID: true })),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const body = c.req.valid("json");
+      await Session.initialize({ ...body, sessionID });
+      return c.json(true);
+    }
+  ).post(
+    "/:sessionID/fork",
+    describeRoute5({
+      summary: "Fork session",
+      description: "Create a new session by forking an existing session at a specific message point.",
+      operationId: "session.fork",
+      responses: {
+        200: {
+          description: "200",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        }
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: Session.fork.schema.shape.sessionID
+      })
+    ),
+    validator5("json", Session.fork.schema.omit({ sessionID: true })),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const body = c.req.valid("json");
+      const result = await Session.fork({ ...body, sessionID });
+      return c.json(result);
+    }
+  ).post(
+    "/:sessionID/abort",
+    describeRoute5({
+      summary: "Abort session",
+      description: "Abort an active session and stop any ongoing AI processing or command execution.",
+      operationId: "session.abort",
+      responses: {
+        200: {
+          description: "Aborted session",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    async (c) => {
+      await SessionPrompt.cancel(c.req.valid("param").sessionID);
+      return c.json(true);
+    }
+  ).post(
+    "/:sessionID/share",
+    describeRoute5({
+      summary: "Share session",
+      description: "Create a shareable link for a session, allowing others to view the conversation.",
+      operationId: "session.share",
+      responses: {
+        200: {
+          description: "Successfully shared session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      await Session.share(sessionID);
+      const session = await Session.get(sessionID);
+      return c.json(session);
+    }
+  ).get(
+    "/:sessionID/diff",
+    describeRoute5({
+      summary: "Get message diff",
+      description: "Get the file changes (diff) that resulted from a specific user message in the session.",
+      operationId: "session.diff",
+      responses: {
+        200: {
+          description: "Successfully retrieved diff",
+          content: {
+            "application/json": {
+              schema: resolver6(Snapshot.FileDiff.array())
+            }
+          }
+        }
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionSummary.DiffInput.shape.sessionID
+      })
+    ),
+    validator5(
+      "query",
+      z7.object({
+        messageID: SessionSummary.DiffInput.shape.messageID
+      })
+    ),
+    async (c) => {
+      const query = c.req.valid("query");
+      const params = c.req.valid("param");
+      const result = await SessionSummary.diff({
+        sessionID: params.sessionID,
+        messageID: query.messageID
+      });
+      return c.json(result);
+    }
+  ).delete(
+    "/:sessionID/share",
+    describeRoute5({
+      summary: "Unshare session",
+      description: "Remove the shareable link for a session, making it private again.",
+      operationId: "session.unshare",
+      responses: {
+        200: {
+          description: "Successfully unshared session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: Session.unshare.schema
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      await Session.unshare(sessionID);
+      const session = await Session.get(sessionID);
+      return c.json(session);
+    }
+  ).post(
+    "/:sessionID/summarize",
+    describeRoute5({
+      summary: "Summarize session",
+      description: "Generate a concise summary of the session using AI compaction to preserve key information.",
+      operationId: "session.summarize",
+      responses: {
+        200: {
+          description: "Summarized session",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5(
+      "json",
+      z7.object({
+        providerID: ProviderID.zod,
+        modelID: ModelID.zod,
+        auto: z7.boolean().optional().default(false)
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const body = c.req.valid("json");
+      const session = await Session.get(sessionID);
+      await SessionRevert.cleanup(session);
+      const msgs = await Session.messages({ sessionID });
+      let currentAgent = await Agent.defaultAgent();
+      for (let i = msgs.length - 1; i >= 0; i--) {
+        const info = msgs[i].info;
+        if (info.role === "user") {
+          currentAgent = info.agent || await Agent.defaultAgent();
+          break;
+        }
+      }
+      await SessionCompaction.create({
+        sessionID,
+        agent: currentAgent,
+        model: {
+          providerID: body.providerID,
+          modelID: body.modelID
+        },
+        auto: body.auto
+      });
+      await SessionPrompt.loop({ sessionID });
+      return c.json(true);
+    }
+  ).get(
+    "/:sessionID/message",
+    describeRoute5({
+      summary: "Get session messages",
+      description: "Retrieve all messages in a session, including user prompts and AI responses.",
+      operationId: "session.messages",
+      responses: {
+        200: {
+          description: "List of messages",
+          content: {
+            "application/json": {
+              schema: resolver6(MessageV2.WithParts.array())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5(
+      "query",
+      z7.object({
+        limit: z7.coerce.number().int().min(0).optional().meta({ description: "Maximum number of messages to return" }),
+        before: z7.string().optional().meta({ description: "Opaque cursor for loading older messages" }).refine(
+          (value) => {
+            if (!value) return true;
+            try {
+              MessageV2.cursor.decode(value);
+              return true;
+            } catch {
+              return false;
+            }
+          },
+          { message: "Invalid cursor" }
+        )
+      }).refine((value) => !value.before || value.limit !== void 0, {
+        message: "before requires limit",
+        path: ["before"]
+      })
+    ),
+    async (c) => {
+      const query = c.req.valid("query");
+      const sessionID = c.req.valid("param").sessionID;
+      if (query.limit === void 0) {
+        await Session.get(sessionID);
+        const messages = await Session.messages({ sessionID });
+        return c.json(messages);
+      }
+      if (query.limit === 0) {
+        await Session.get(sessionID);
+        const messages = await Session.messages({ sessionID });
+        return c.json(messages);
+      }
+      const page = await MessageV2.page({
+        sessionID,
+        limit: query.limit,
+        before: query.before
+      });
+      if (page.cursor) {
+        const url = new URL(c.req.url);
+        url.searchParams.set("limit", query.limit.toString());
+        url.searchParams.set("before", page.cursor);
+        c.header("Access-Control-Expose-Headers", "Link, X-Next-Cursor");
+        c.header("Link", `<${url.toString()}>; rel="next"`);
+        c.header("X-Next-Cursor", page.cursor);
+      }
+      return c.json(page.items);
+    }
+  ).get(
+    "/:sessionID/message/:messageID",
+    describeRoute5({
+      summary: "Get message",
+      description: "Retrieve a specific message from a session by its message ID.",
+      operationId: "session.message",
+      responses: {
+        200: {
+          description: "Message",
+          content: {
+            "application/json": {
+              schema: resolver6(
+                z7.object({
+                  info: MessageV2.Info,
+                  parts: MessageV2.Part.array()
+                })
+              )
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod,
+        messageID: MessageID.zod
+      })
+    ),
+    async (c) => {
+      const params = c.req.valid("param");
+      const message = await MessageV2.get({
+        sessionID: params.sessionID,
+        messageID: params.messageID
+      });
+      return c.json(message);
+    }
+  ).delete(
+    "/:sessionID/message/:messageID",
+    describeRoute5({
+      summary: "Delete message",
+      description: "Permanently delete a specific message (and all of its parts) from a session. This does not revert any file changes that may have been made while processing the message.",
+      operationId: "session.deleteMessage",
+      responses: {
+        200: {
+          description: "Successfully deleted message",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod,
+        messageID: MessageID.zod
+      })
+    ),
+    async (c) => {
+      const params = c.req.valid("param");
+      await SessionPrompt.assertNotBusy(params.sessionID);
+      await Session.removeMessage({
+        sessionID: params.sessionID,
+        messageID: params.messageID
+      });
+      return c.json(true);
+    }
+  ).delete(
+    "/:sessionID/message/:messageID/part/:partID",
+    describeRoute5({
+      description: "Delete a part from a message",
+      operationId: "part.delete",
+      responses: {
+        200: {
+          description: "Successfully deleted part",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod,
+        messageID: MessageID.zod,
+        partID: PartID.zod
+      })
+    ),
+    async (c) => {
+      const params = c.req.valid("param");
+      await Session.removePart({
+        sessionID: params.sessionID,
+        messageID: params.messageID,
+        partID: params.partID
+      });
+      return c.json(true);
+    }
+  ).patch(
+    "/:sessionID/message/:messageID/part/:partID",
+    describeRoute5({
+      description: "Update a part in a message",
+      operationId: "part.update",
+      responses: {
+        200: {
+          description: "Successfully updated part",
+          content: {
+            "application/json": {
+              schema: resolver6(MessageV2.Part)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod,
+        messageID: MessageID.zod,
+        partID: PartID.zod
+      })
+    ),
+    validator5("json", MessageV2.Part),
+    async (c) => {
+      const params = c.req.valid("param");
+      const body = c.req.valid("json");
+      if (body.id !== params.partID || body.messageID !== params.messageID || body.sessionID !== params.sessionID) {
+        throw new Error(
+          `Part mismatch: body.id='${body.id}' vs partID='${params.partID}', body.messageID='${body.messageID}' vs messageID='${params.messageID}', body.sessionID='${body.sessionID}' vs sessionID='${params.sessionID}'`
+        );
+      }
+      const part = await Session.updatePart(body);
+      return c.json(part);
+    }
+  ).post(
+    "/:sessionID/message",
+    describeRoute5({
+      summary: "Send message",
+      description: "Create and send a new message to a session, streaming the AI response.",
+      operationId: "session.prompt",
+      responses: {
+        200: {
+          description: "Created message",
+          content: {
+            "application/json": {
+              schema: resolver6(
+                z7.object({
+                  info: MessageV2.Assistant,
+                  parts: MessageV2.Part.array()
+                })
+              )
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
+    async (c) => {
+      c.status(200);
+      c.header("Content-Type", "application/json");
+      return stream(c, async (stream2) => {
+        const sessionID = c.req.valid("param").sessionID;
+        const body = c.req.valid("json");
+        const msg = await SessionPrompt.prompt({ ...body, sessionID });
+        stream2.write(JSON.stringify(msg));
+      });
+    }
+  ).post(
+    "/:sessionID/prompt_async",
+    describeRoute5({
+      summary: "Send async message",
+      description: "Create and send a new message to a session asynchronously, starting the session if needed and returning immediately.",
+      operationId: "session.prompt_async",
+      responses: {
+        202: {
+          description: "Prompt accepted"
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5("json", SessionPrompt.PromptInput.omit({ sessionID: true })),
+    async (c) => {
+      c.status(202);
+      return stream(c, async () => {
+        const sessionID = c.req.valid("param").sessionID;
+        const body = c.req.valid("json");
+        SessionPrompt.prompt({ ...body, sessionID }).catch((err) => {
+          log.error("prompt_async failed", { sessionID, error: err });
+          Bus.publish(Session.Event.Error, {
+            sessionID,
+            error: new NamedError.Unknown({ message: err instanceof Error ? err.message : String(err) }).toObject()
+          });
+        });
+      });
+    }
+  ).post(
+    "/:sessionID/command",
+    describeRoute5({
+      summary: "Send command",
+      description: "Send a new command to a session for execution by the AI assistant.",
+      operationId: "session.command",
+      responses: {
+        200: {
+          description: "Created message",
+          content: {
+            "application/json": {
+              schema: resolver6(
+                z7.object({
+                  info: MessageV2.Assistant,
+                  parts: MessageV2.Part.array()
+                })
+              )
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5("json", SessionPrompt.CommandInput.omit({ sessionID: true })),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const body = c.req.valid("json");
+      const msg = await SessionPrompt.command({ ...body, sessionID });
+      return c.json(msg);
+    }
+  ).post(
+    "/:sessionID/shell",
+    describeRoute5({
+      summary: "Run shell command",
+      description: "Execute a shell command within the session context and return the AI's response.",
+      operationId: "session.shell",
+      responses: {
+        200: {
+          description: "Created message",
+          content: {
+            "application/json": {
+              schema: resolver6(MessageV2.Assistant)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5("json", SessionPrompt.ShellInput.omit({ sessionID: true })),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const body = c.req.valid("json");
+      const msg = await SessionPrompt.shell({ ...body, sessionID });
+      return c.json(msg);
+    }
+  ).post(
+    "/:sessionID/revert",
+    describeRoute5({
+      summary: "Revert message",
+      description: "Revert a specific message in a session, undoing its effects and restoring the previous state.",
+      operationId: "session.revert",
+      responses: {
+        200: {
+          description: "Updated session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    validator5("json", SessionRevert.RevertInput.omit({ sessionID: true })),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      log.info("revert", c.req.valid("json"));
+      const session = await SessionRevert.revert({
+        sessionID,
+        ...c.req.valid("json")
+      });
+      return c.json(session);
+    }
+  ).post(
+    "/:sessionID/unrevert",
+    describeRoute5({
+      summary: "Restore reverted messages",
+      description: "Restore all previously reverted messages in a session.",
+      operationId: "session.unrevert",
+      responses: {
+        200: {
+          description: "Updated session",
+          content: {
+            "application/json": {
+              schema: resolver6(Session.Info)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod
+      })
+    ),
+    async (c) => {
+      const sessionID = c.req.valid("param").sessionID;
+      const session = await SessionRevert.unrevert({ sessionID });
+      return c.json(session);
+    }
+  ).post(
+    "/:sessionID/permissions/:permissionID",
+    describeRoute5({
+      summary: "Respond to permission",
+      deprecated: true,
+      description: "Approve or deny a permission request from the AI assistant.",
+      operationId: "permission.respond",
+      responses: {
+        200: {
+          description: "Permission processed successfully",
+          content: {
+            "application/json": {
+              schema: resolver6(z7.boolean())
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator5(
+      "param",
+      z7.object({
+        sessionID: SessionID.zod,
+        permissionID: PermissionID.zod
+      })
+    ),
+    validator5("json", z7.object({ response: Permission.Reply })),
+    async (c) => {
+      const params = c.req.valid("param");
+      Permission.reply({
+        requestID: params.permissionID,
+        reply: c.req.valid("json").response
+      });
+      return c.json(true);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/pty.ts
+import { Hono as Hono7 } from "hono";
+import { describeRoute as describeRoute6, validator as validator6, resolver as resolver7 } from "hono-openapi";
+import z10 from "zod";
+
+// packages/opencode/src/pty/index.ts
+import z9 from "zod";
+
+// packages/util/src/lazy.ts
+function lazy2(fn2) {
+  let value;
+  let loaded = false;
+  return () => {
+    if (loaded) return value;
+    loaded = true;
+    value = fn2();
+    return value;
+  };
+}
+
+// packages/opencode/src/pty/schema.ts
+import { Schema } from "effect";
+import z8 from "zod";
+var ptyIdSchema = Schema.String.pipe(Schema.brand("PtyID"));
+var PtyID = ptyIdSchema.pipe(
+  withStatics((schema) => ({
+    make: (id) => schema.makeUnsafe(id),
+    ascending: (id) => schema.makeUnsafe(Identifier.ascending("pty", id)),
+    zod: Identifier.schema("pty").pipe(z8.custom())
+  }))
+);
+
+// packages/opencode/src/pty/index.ts
+import { Effect, Layer, ServiceMap } from "effect";
+var Pty;
+((Pty2) => {
+  const log9 = Log.create({ service: "pty" });
+  const BUFFER_LIMIT = 1024 * 1024 * 2;
+  const BUFFER_CHUNK = 64 * 1024;
+  const encoder = new TextEncoder();
+  const sock = (ws) => ws.data && typeof ws.data === "object" ? ws.data : ws;
+  const meta = (cursor) => {
+    const json = JSON.stringify({ cursor });
+    const bytes = encoder.encode(json);
+    const out = new Uint8Array(bytes.length + 1);
+    out[0] = 0;
+    out.set(bytes, 1);
+    return out;
+  };
+  const pty = lazy2(() => import("./pty.node-RHOAUGH6.js"));
+  Pty2.Info = z9.object({
+    id: PtyID.zod,
+    title: z9.string(),
+    command: z9.string(),
+    args: z9.array(z9.string()),
+    cwd: z9.string(),
+    status: z9.enum(["running", "exited"]),
+    pid: z9.number()
+  }).meta({ ref: "Pty" });
+  Pty2.CreateInput = z9.object({
+    command: z9.string().optional(),
+    args: z9.array(z9.string()).optional(),
+    cwd: z9.string().optional(),
+    title: z9.string().optional(),
+    env: z9.record(z9.string(), z9.string()).optional()
+  });
+  Pty2.UpdateInput = z9.object({
+    title: z9.string().optional(),
+    size: z9.object({
+      rows: z9.number(),
+      cols: z9.number()
+    }).optional()
+  });
+  Pty2.Event = {
+    Created: BusEvent.define("pty.created", z9.object({ info: Pty2.Info })),
+    Updated: BusEvent.define("pty.updated", z9.object({ info: Pty2.Info })),
+    Exited: BusEvent.define("pty.exited", z9.object({ id: PtyID.zod, exitCode: z9.number() })),
+    Deleted: BusEvent.define("pty.deleted", z9.object({ id: PtyID.zod }))
+  };
+  class Service extends ServiceMap.Service()("@opencode/Pty") {
+  }
+  Pty2.Service = Service;
+  Pty2.layer = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const bus = yield* Bus.Service;
+      const plugin = yield* Plugin.Service;
+      function teardown(session) {
+        try {
+          session.process.kill();
+        } catch {
+        }
+        for (const [sub, ws] of session.subscribers.entries()) {
+          try {
+            if (sock(ws) === sub) ws.close();
+          } catch {
+          }
+        }
+        session.subscribers.clear();
+      }
+      const state = yield* InstanceState.make(
+        Effect.fn("Pty.state")(function* (ctx) {
+          const state2 = {
+            dir: ctx.directory,
+            sessions: /* @__PURE__ */ new Map()
+          };
+          yield* Effect.addFinalizer(
+            () => Effect.sync(() => {
+              for (const session of state2.sessions.values()) {
+                teardown(session);
+              }
+              state2.sessions.clear();
+            })
+          );
+          return state2;
+        })
+      );
+      const remove2 = Effect.fn("Pty.remove")(function* (id) {
+        const s = yield* InstanceState.get(state);
+        const session = s.sessions.get(id);
+        if (!session) return;
+        s.sessions.delete(id);
+        log9.info("removing session", { id });
+        teardown(session);
+        yield* bus.publish(Pty2.Event.Deleted, { id: session.info.id });
+      });
+      const list2 = Effect.fn("Pty.list")(function* () {
+        const s = yield* InstanceState.get(state);
+        return Array.from(s.sessions.values()).map((session) => session.info);
+      });
+      const get2 = Effect.fn("Pty.get")(function* (id) {
+        const s = yield* InstanceState.get(state);
+        return s.sessions.get(id)?.info;
+      });
+      const create2 = Effect.fn("Pty.create")(function* (input) {
+        const s = yield* InstanceState.get(state);
+        const id = PtyID.ascending();
+        const command = input.command || Shell.preferred();
+        const args = input.args || [];
+        if (Shell.login(command)) {
+          args.push("-l");
+        }
+        const cwd = input.cwd || s.dir;
+        const shell = yield* plugin.trigger("shell.env", { cwd }, { env: {} });
+        const env = {
+          ...process.env,
+          ...input.env,
+          ...shell.env,
+          TERM: "xterm-256color",
+          OPENCODE_TERMINAL: "1"
+        };
+        if (process.platform === "win32") {
+          env.LC_ALL = "C.UTF-8";
+          env.LC_CTYPE = "C.UTF-8";
+          env.LANG = "C.UTF-8";
+        }
+        log9.info("creating session", { id, cmd: command, args, cwd });
+        const { spawn } = yield* Effect.promise(() => pty());
+        const proc = yield* Effect.sync(
+          () => spawn(command, args, {
+            name: "xterm-256color",
+            cwd,
+            env
+          })
+        );
+        const info = {
+          id,
+          title: input.title || `Terminal ${id.slice(-4)}`,
+          command,
+          args,
+          cwd,
+          status: "running",
+          pid: proc.pid
+        };
+        const session = {
+          info,
+          process: proc,
+          buffer: "",
+          bufferCursor: 0,
+          cursor: 0,
+          subscribers: /* @__PURE__ */ new Map()
+        };
+        s.sessions.set(id, session);
+        proc.onData(
+          Instance.bind((chunk) => {
+            session.cursor += chunk.length;
+            for (const [key, ws] of session.subscribers.entries()) {
+              if (ws.readyState !== 1) {
+                session.subscribers.delete(key);
+                continue;
+              }
+              if (sock(ws) !== key) {
+                session.subscribers.delete(key);
+                continue;
+              }
+              try {
+                ws.send(chunk);
+              } catch {
+                session.subscribers.delete(key);
+              }
+            }
+            session.buffer += chunk;
+            if (session.buffer.length <= BUFFER_LIMIT) return;
+            const excess = session.buffer.length - BUFFER_LIMIT;
+            session.buffer = session.buffer.slice(excess);
+            session.bufferCursor += excess;
+          })
+        );
+        proc.onExit(
+          Instance.bind(({ exitCode }) => {
+            if (session.info.status === "exited") return;
+            log9.info("session exited", { id, exitCode });
+            session.info.status = "exited";
+            Effect.runFork(bus.publish(Pty2.Event.Exited, { id, exitCode }));
+            Effect.runFork(remove2(id));
+          })
+        );
+        yield* bus.publish(Pty2.Event.Created, { info });
+        return info;
+      });
+      const update2 = Effect.fn("Pty.update")(function* (id, input) {
+        const s = yield* InstanceState.get(state);
+        const session = s.sessions.get(id);
+        if (!session) return;
+        if (input.title) {
+          session.info.title = input.title;
+        }
+        if (input.size) {
+          session.process.resize(input.size.cols, input.size.rows);
+        }
+        yield* bus.publish(Pty2.Event.Updated, { info: session.info });
+        return session.info;
+      });
+      const resize2 = Effect.fn("Pty.resize")(function* (id, cols, rows) {
+        const s = yield* InstanceState.get(state);
+        const session = s.sessions.get(id);
+        if (session && session.info.status === "running") {
+          session.process.resize(cols, rows);
+        }
+      });
+      const write2 = Effect.fn("Pty.write")(function* (id, data) {
+        const s = yield* InstanceState.get(state);
+        const session = s.sessions.get(id);
+        if (session && session.info.status === "running") {
+          session.process.write(data);
+        }
+      });
+      const connect2 = Effect.fn("Pty.connect")(function* (id, ws, cursor) {
+        const s = yield* InstanceState.get(state);
+        const session = s.sessions.get(id);
+        if (!session) {
+          ws.close();
+          return;
+        }
+        log9.info("client connected to session", { id });
+        const sub = sock(ws);
+        session.subscribers.delete(sub);
+        session.subscribers.set(sub, ws);
+        const cleanup = () => {
+          session.subscribers.delete(sub);
+        };
+        const start = session.bufferCursor;
+        const end = session.cursor;
+        const from = cursor === -1 ? end : typeof cursor === "number" && Number.isSafeInteger(cursor) ? Math.max(0, cursor) : 0;
+        const data = (() => {
+          if (!session.buffer) return "";
+          if (from >= end) return "";
+          const offset = Math.max(0, from - start);
+          if (offset >= session.buffer.length) return "";
+          return session.buffer.slice(offset);
+        })();
+        if (data) {
+          try {
+            for (let i = 0; i < data.length; i += BUFFER_CHUNK) {
+              ws.send(data.slice(i, i + BUFFER_CHUNK));
+            }
+          } catch {
+            cleanup();
+            ws.close();
+            return;
+          }
+        }
+        try {
+          ws.send(meta(end));
+        } catch {
+          cleanup();
+          ws.close();
+          return;
+        }
+        return {
+          onMessage: (message) => {
+            session.process.write(String(message));
+          },
+          onClose: () => {
+            log9.info("client disconnected from session", { id });
+            cleanup();
+          }
+        };
+      });
+      return Service.of({ list: list2, get: get2, create: create2, update: update2, remove: remove2, resize: resize2, write: write2, connect: connect2 });
+    })
+  );
+  const defaultLayer = Pty2.layer.pipe(Layer.provide(Bus.layer), Layer.provide(Plugin.defaultLayer));
+  const { runPromise } = makeRuntime(Service, defaultLayer);
+  async function list() {
+    return runPromise((svc) => svc.list());
+  }
+  Pty2.list = list;
+  async function get(id) {
+    return runPromise((svc) => svc.get(id));
+  }
+  Pty2.get = get;
+  async function resize(id, cols, rows) {
+    return runPromise((svc) => svc.resize(id, cols, rows));
+  }
+  Pty2.resize = resize;
+  async function write(id, data) {
+    return runPromise((svc) => svc.write(id, data));
+  }
+  Pty2.write = write;
+  async function connect(id, ws, cursor) {
+    return runPromise((svc) => svc.connect(id, ws, cursor));
+  }
+  Pty2.connect = connect;
+  async function create(input) {
+    return runPromise((svc) => svc.create(input));
+  }
+  Pty2.create = create;
+  async function update(id, input) {
+    return runPromise((svc) => svc.update(id, input));
+  }
+  Pty2.update = update;
+  async function remove(id) {
+    return runPromise((svc) => svc.remove(id));
+  }
+  Pty2.remove = remove;
+})(Pty || (Pty = {}));
+
+// packages/opencode/src/server/routes/pty.ts
+function PtyRoutes(upgradeWebSocket2) {
+  return new Hono7().get(
+    "/",
+    describeRoute6({
+      summary: "List PTY sessions",
+      description: "Get a list of all active pseudo-terminal (PTY) sessions managed by OpenCode.",
+      operationId: "pty.list",
+      responses: {
+        200: {
+          description: "List of sessions",
+          content: {
+            "application/json": {
+              schema: resolver7(Pty.Info.array())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(await Pty.list());
+    }
+  ).post(
+    "/",
+    describeRoute6({
+      summary: "Create PTY session",
+      description: "Create a new pseudo-terminal (PTY) session for running shell commands and processes.",
+      operationId: "pty.create",
+      responses: {
+        200: {
+          description: "Created session",
+          content: {
+            "application/json": {
+              schema: resolver7(Pty.Info)
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator6("json", Pty.CreateInput),
+    async (c) => {
+      const info = await Pty.create(c.req.valid("json"));
+      return c.json(info);
+    }
+  ).get(
+    "/:ptyID",
+    describeRoute6({
+      summary: "Get PTY session",
+      description: "Retrieve detailed information about a specific pseudo-terminal (PTY) session.",
+      operationId: "pty.get",
+      responses: {
+        200: {
+          description: "Session info",
+          content: {
+            "application/json": {
+              schema: resolver7(Pty.Info)
+            }
+          }
+        },
+        ...errors(404)
+      }
+    }),
+    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    async (c) => {
+      const info = await Pty.get(c.req.valid("param").ptyID);
+      if (!info) {
+        throw new NotFoundError({ message: "Session not found" });
+      }
+      return c.json(info);
+    }
+  ).put(
+    "/:ptyID",
+    describeRoute6({
+      summary: "Update PTY session",
+      description: "Update properties of an existing pseudo-terminal (PTY) session.",
+      operationId: "pty.update",
+      responses: {
+        200: {
+          description: "Updated session",
+          content: {
+            "application/json": {
+              schema: resolver7(Pty.Info)
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    validator6("json", Pty.UpdateInput),
+    async (c) => {
+      const info = await Pty.update(c.req.valid("param").ptyID, c.req.valid("json"));
+      return c.json(info);
+    }
+  ).delete(
+    "/:ptyID",
+    describeRoute6({
+      summary: "Remove PTY session",
+      description: "Remove and terminate a specific pseudo-terminal (PTY) session.",
+      operationId: "pty.remove",
+      responses: {
+        200: {
+          description: "Session removed",
+          content: {
+            "application/json": {
+              schema: resolver7(z10.boolean())
+            }
+          }
+        },
+        ...errors(404)
+      }
+    }),
+    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    async (c) => {
+      await Pty.remove(c.req.valid("param").ptyID);
+      return c.json(true);
+    }
+  ).get(
+    "/:ptyID/connect",
+    describeRoute6({
+      summary: "Connect to PTY session",
+      description: "Establish a WebSocket connection to interact with a pseudo-terminal (PTY) session in real-time.",
+      operationId: "pty.connect",
+      responses: {
+        200: {
+          description: "Connected session",
+          content: {
+            "application/json": {
+              schema: resolver7(z10.boolean())
+            }
+          }
+        },
+        ...errors(404)
+      }
+    }),
+    validator6("param", z10.object({ ptyID: PtyID.zod })),
+    upgradeWebSocket2(async (c) => {
+      const id = PtyID.zod.parse(c.req.param("ptyID"));
+      const cursor = (() => {
+        const value = c.req.query("cursor");
+        if (!value) return;
+        const parsed = Number(value);
+        if (!Number.isSafeInteger(parsed) || parsed < -1) return;
+        return parsed;
+      })();
+      let handler;
+      if (!await Pty.get(id)) throw new Error("Session not found");
+      const isSocket = (value) => {
+        if (!value || typeof value !== "object") return false;
+        if (!("readyState" in value)) return false;
+        if (!("send" in value) || typeof value.send !== "function") return false;
+        if (!("close" in value) || typeof value.close !== "function") return false;
+        return typeof value.readyState === "number";
+      };
+      const pending = [];
+      let ready = false;
+      return {
+        async onOpen(_event, ws) {
+          const socket2 = ws.raw;
+          if (!isSocket(socket2)) {
+            ws.close();
+            return;
+          }
+          handler = await Pty.connect(id, socket2, cursor);
+          ready = true;
+          for (const msg of pending) handler?.onMessage(msg);
+          pending.length = 0;
+        },
+        onMessage(event) {
+          if (typeof event.data !== "string") return;
+          if (!ready) {
+            pending.push(event.data);
+            return;
+          }
+          handler?.onMessage(event.data);
+        },
+        onClose() {
+          handler?.onClose();
+        },
+        onError() {
+          handler?.onClose();
+        }
+      };
+    })
+  );
+}
+
+// packages/opencode/src/server/routes/mcp.ts
+import { Hono as Hono8 } from "hono";
+import { describeRoute as describeRoute7, validator as validator7, resolver as resolver8 } from "hono-openapi";
+import z11 from "zod";
+var McpRoutes = lazy(
+  () => new Hono8().get(
+    "/",
+    describeRoute7({
+      summary: "Get MCP status",
+      description: "Get the status of all Model Context Protocol (MCP) servers.",
+      operationId: "mcp.status",
+      responses: {
+        200: {
+          description: "MCP server status",
+          content: {
+            "application/json": {
+              schema: resolver8(z11.record(z11.string(), MCP.Status))
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(await MCP.status());
+    }
+  ).post(
+    "/",
+    describeRoute7({
+      summary: "Add MCP server",
+      description: "Dynamically add a new Model Context Protocol (MCP) server to the system.",
+      operationId: "mcp.add",
+      responses: {
+        200: {
+          description: "MCP server added successfully",
+          content: {
+            "application/json": {
+              schema: resolver8(z11.record(z11.string(), MCP.Status))
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator7(
+      "json",
+      z11.object({
+        name: z11.string(),
+        config: Config.Mcp
+      })
+    ),
+    async (c) => {
+      const { name, config } = c.req.valid("json");
+      const result = await MCP.add(name, config);
+      return c.json(result.status);
+    }
+  ).post(
+    "/:name/auth",
+    describeRoute7({
+      summary: "Start MCP OAuth",
+      description: "Start OAuth authentication flow for a Model Context Protocol (MCP) server.",
+      operationId: "mcp.auth.start",
+      responses: {
+        200: {
+          description: "OAuth flow started",
+          content: {
+            "application/json": {
+              schema: resolver8(
+                z11.object({
+                  authorizationUrl: z11.string().describe("URL to open in browser for authorization")
+                })
+              )
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    async (c) => {
+      const name = c.req.param("name");
+      const supportsOAuth = await MCP.supportsOAuth(name);
+      if (!supportsOAuth) {
+        return c.json({ error: `MCP server ${name} does not support OAuth` }, 400);
+      }
+      const result = await MCP.startAuth(name);
+      return c.json(result);
+    }
+  ).post(
+    "/:name/auth/callback",
+    describeRoute7({
+      summary: "Complete MCP OAuth",
+      description: "Complete OAuth authentication for a Model Context Protocol (MCP) server using the authorization code.",
+      operationId: "mcp.auth.callback",
+      responses: {
+        200: {
+          description: "OAuth authentication completed",
+          content: {
+            "application/json": {
+              schema: resolver8(MCP.Status)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    validator7(
+      "json",
+      z11.object({
+        code: z11.string().describe("Authorization code from OAuth callback")
+      })
+    ),
+    async (c) => {
+      const name = c.req.param("name");
+      const { code } = c.req.valid("json");
+      const status = await MCP.finishAuth(name, code);
+      return c.json(status);
+    }
+  ).post(
+    "/:name/auth/authenticate",
+    describeRoute7({
+      summary: "Authenticate MCP OAuth",
+      description: "Start OAuth flow and wait for callback (opens browser)",
+      operationId: "mcp.auth.authenticate",
+      responses: {
+        200: {
+          description: "OAuth authentication completed",
+          content: {
+            "application/json": {
+              schema: resolver8(MCP.Status)
+            }
+          }
+        },
+        ...errors(400, 404)
+      }
+    }),
+    async (c) => {
+      const name = c.req.param("name");
+      const supportsOAuth = await MCP.supportsOAuth(name);
+      if (!supportsOAuth) {
+        return c.json({ error: `MCP server ${name} does not support OAuth` }, 400);
+      }
+      const status = await MCP.authenticate(name);
+      return c.json(status);
+    }
+  ).delete(
+    "/:name/auth",
+    describeRoute7({
+      summary: "Remove MCP OAuth",
+      description: "Remove OAuth credentials for an MCP server",
+      operationId: "mcp.auth.remove",
+      responses: {
+        200: {
+          description: "OAuth credentials removed",
+          content: {
+            "application/json": {
+              schema: resolver8(z11.object({ success: z11.literal(true) }))
+            }
+          }
+        },
+        ...errors(404)
+      }
+    }),
+    async (c) => {
+      const name = c.req.param("name");
+      await MCP.removeAuth(name);
+      return c.json({ success: true });
+    }
+  ).post(
+    "/:name/connect",
+    describeRoute7({
+      description: "Connect an MCP server",
+      operationId: "mcp.connect",
+      responses: {
+        200: {
+          description: "MCP server connected successfully",
+          content: {
+            "application/json": {
+              schema: resolver8(z11.boolean())
+            }
+          }
+        }
+      }
+    }),
+    validator7("param", z11.object({ name: z11.string() })),
+    async (c) => {
+      const { name } = c.req.valid("param");
+      await MCP.connect(name);
+      return c.json(true);
+    }
+  ).post(
+    "/:name/disconnect",
+    describeRoute7({
+      description: "Disconnect an MCP server",
+      operationId: "mcp.disconnect",
+      responses: {
+        200: {
+          description: "MCP server disconnected successfully",
+          content: {
+            "application/json": {
+              schema: resolver8(z11.boolean())
+            }
+          }
+        }
+      }
+    }),
+    validator7("param", z11.object({ name: z11.string() })),
+    async (c) => {
+      const { name } = c.req.valid("param");
+      await MCP.disconnect(name);
+      return c.json(true);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/file.ts
+import { Hono as Hono9 } from "hono";
+import { describeRoute as describeRoute8, validator as validator8, resolver as resolver9 } from "hono-openapi";
+import z12 from "zod";
+var FileRoutes = lazy(
+  () => new Hono9().get(
+    "/find",
+    describeRoute8({
+      summary: "Find text",
+      description: "Search for text patterns across files in the project using ripgrep.",
+      operationId: "find.text",
+      responses: {
+        200: {
+          description: "Matches",
+          content: {
+            "application/json": {
+              schema: resolver9(Ripgrep.Match.shape.data.array())
+            }
+          }
+        }
+      }
+    }),
+    validator8(
+      "query",
+      z12.object({
+        pattern: z12.string()
+      })
+    ),
+    async (c) => {
+      const pattern = c.req.valid("query").pattern;
+      const result = await Ripgrep.search({
+        cwd: Instance.directory,
+        pattern,
+        limit: 10
+      });
+      return c.json(result);
+    }
+  ).get(
+    "/find/file",
+    describeRoute8({
+      summary: "Find files",
+      description: "Search for files or directories by name or pattern in the project directory.",
+      operationId: "find.files",
+      responses: {
+        200: {
+          description: "File paths",
+          content: {
+            "application/json": {
+              schema: resolver9(z12.string().array())
+            }
+          }
+        }
+      }
+    }),
+    validator8(
+      "query",
+      z12.object({
+        query: z12.string(),
+        dirs: z12.enum(["true", "false"]).optional(),
+        type: z12.enum(["file", "directory"]).optional(),
+        limit: z12.coerce.number().int().min(1).max(200).optional()
+      })
+    ),
+    async (c) => {
+      const query = c.req.valid("query").query;
+      const dirs = c.req.valid("query").dirs;
+      const type = c.req.valid("query").type;
+      const limit = c.req.valid("query").limit;
+      const results = await File.search({
+        query,
+        limit: limit ?? 10,
+        dirs: dirs !== "false",
+        type
+      });
+      return c.json(results);
+    }
+  ).get(
+    "/find/symbol",
+    describeRoute8({
+      summary: "Find symbols",
+      description: "Search for workspace symbols like functions, classes, and variables using LSP.",
+      operationId: "find.symbols",
+      responses: {
+        200: {
+          description: "Symbols",
+          content: {
+            "application/json": {
+              schema: resolver9(LSP.Symbol.array())
+            }
+          }
+        }
+      }
+    }),
+    validator8(
+      "query",
+      z12.object({
+        query: z12.string()
+      })
+    ),
+    async (c) => {
+      return c.json([]);
+    }
+  ).get(
+    "/file",
+    describeRoute8({
+      summary: "List files",
+      description: "List files and directories in a specified path.",
+      operationId: "file.list",
+      responses: {
+        200: {
+          description: "Files and directories",
+          content: {
+            "application/json": {
+              schema: resolver9(File.Node.array())
+            }
+          }
+        }
+      }
+    }),
+    validator8(
+      "query",
+      z12.object({
+        path: z12.string()
+      })
+    ),
+    async (c) => {
+      const path = c.req.valid("query").path;
+      const content = await File.list(path);
+      return c.json(content);
+    }
+  ).get(
+    "/file/content",
+    describeRoute8({
+      summary: "Read file",
+      description: "Read the content of a specified file.",
+      operationId: "file.read",
+      responses: {
+        200: {
+          description: "File content",
+          content: {
+            "application/json": {
+              schema: resolver9(File.Content)
+            }
+          }
+        }
+      }
+    }),
+    validator8(
+      "query",
+      z12.object({
+        path: z12.string()
+      })
+    ),
+    async (c) => {
+      const path = c.req.valid("query").path;
+      const content = await File.read(path);
+      return c.json(content);
+    }
+  ).get(
+    "/file/status",
+    describeRoute8({
+      summary: "Get file status",
+      description: "Get the git status of all files in the project.",
+      operationId: "file.status",
+      responses: {
+        200: {
+          description: "File status",
+          content: {
+            "application/json": {
+              schema: resolver9(File.Info.array())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const content = await File.status();
+      return c.json(content);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/config.ts
+import { Hono as Hono10 } from "hono";
+import { describeRoute as describeRoute9, validator as validator9, resolver as resolver10 } from "hono-openapi";
+import z13 from "zod";
+import { mapValues } from "remeda";
+var log2 = Log.create({ service: "server" });
+var ConfigRoutes = lazy(
+  () => new Hono10().get(
+    "/",
+    describeRoute9({
+      summary: "Get configuration",
+      description: "Retrieve the current OpenCode configuration settings and preferences.",
+      operationId: "config.get",
+      responses: {
+        200: {
+          description: "Get config info",
+          content: {
+            "application/json": {
+              schema: resolver10(Config.Info)
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(await Config.get());
+    }
+  ).patch(
+    "/",
+    describeRoute9({
+      summary: "Update configuration",
+      description: "Update OpenCode configuration settings and preferences.",
+      operationId: "config.update",
+      responses: {
+        200: {
+          description: "Successfully updated config",
+          content: {
+            "application/json": {
+              schema: resolver10(Config.Info)
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator9("json", Config.Info),
+    async (c) => {
+      const config = c.req.valid("json");
+      await Config.update(config);
+      return c.json(config);
+    }
+  ).get(
+    "/providers",
+    describeRoute9({
+      summary: "List config providers",
+      description: "Get a list of all configured AI providers and their default models.",
+      operationId: "config.providers",
+      responses: {
+        200: {
+          description: "List of providers",
+          content: {
+            "application/json": {
+              schema: resolver10(
+                z13.object({
+                  providers: Provider.Info.array(),
+                  default: z13.record(z13.string(), z13.string())
+                })
+              )
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      var _stack = [];
+      try {
+        const _ = __using(_stack, log2.time("providers"));
+        const providers = await Provider.list().then((x) => mapValues(x, (item) => item));
+        return c.json({
+          providers: Object.values(providers),
+          default: mapValues(providers, (item) => Provider.sort(Object.values(item.models))[0].id)
+        });
+      } catch (_2) {
+        var _error = _2, _hasError = true;
+      } finally {
+        __callDispose(_stack, _error, _hasError);
+      }
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/experimental.ts
+import { Hono as Hono12 } from "hono";
+import { describeRoute as describeRoute11, validator as validator11, resolver as resolver12 } from "hono-openapi";
+import z16 from "zod";
+
+// packages/opencode/src/config/console-state.ts
+import z14 from "zod";
+var ConsoleState = z14.object({
+  consoleManagedProviders: z14.array(z14.string()),
+  activeOrgName: z14.string().optional(),
+  switchableOrgCount: z14.number().int().nonnegative()
+});
+
+// packages/opencode/src/server/routes/experimental.ts
+import { zodToJsonSchema } from "zod-to-json-schema";
+
+// packages/opencode/src/server/routes/workspace.ts
+import { Hono as Hono11 } from "hono";
+import { describeRoute as describeRoute10, resolver as resolver11, validator as validator10 } from "hono-openapi";
+import z15 from "zod";
+var WorkspaceRoutes = lazy(
+  () => new Hono11().post(
+    "/",
+    describeRoute10({
+      summary: "Create workspace",
+      description: "Create a workspace for the current project.",
+      operationId: "experimental.workspace.create",
+      responses: {
+        200: {
+          description: "Workspace created",
+          content: {
+            "application/json": {
+              schema: resolver11(Workspace.Info)
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator10(
+      "json",
+      Workspace.create.schema.omit({
+        projectID: true
+      })
+    ),
+    async (c) => {
+      const body = c.req.valid("json");
+      const workspace = await Workspace.create({
+        projectID: Instance.project.id,
+        ...body
+      });
+      return c.json(workspace);
+    }
+  ).get(
+    "/",
+    describeRoute10({
+      summary: "List workspaces",
+      description: "List all workspaces.",
+      operationId: "experimental.workspace.list",
+      responses: {
+        200: {
+          description: "Workspaces",
+          content: {
+            "application/json": {
+              schema: resolver11(z15.array(Workspace.Info))
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(Workspace.list(Instance.project));
+    }
+  ).delete(
+    "/:id",
+    describeRoute10({
+      summary: "Remove workspace",
+      description: "Remove an existing workspace.",
+      operationId: "experimental.workspace.remove",
+      responses: {
+        200: {
+          description: "Workspace removed",
+          content: {
+            "application/json": {
+              schema: resolver11(Workspace.Info.optional())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator10(
+      "param",
+      z15.object({
+        id: Workspace.Info.shape.id
+      })
+    ),
+    async (c) => {
+      const { id } = c.req.valid("param");
+      return c.json(await Workspace.remove(id));
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/experimental.ts
+var ConsoleOrgOption = z16.object({
+  accountID: z16.string(),
+  accountEmail: z16.string(),
+  accountUrl: z16.string(),
+  orgID: z16.string(),
+  orgName: z16.string(),
+  active: z16.boolean()
+});
+var ConsoleOrgList = z16.object({
+  orgs: z16.array(ConsoleOrgOption)
+});
+var ConsoleSwitchBody = z16.object({
+  accountID: z16.string(),
+  orgID: z16.string()
+});
+var ExperimentalRoutes = lazy(
+  () => new Hono12().get(
+    "/console",
+    describeRoute11({
+      summary: "Get active Console provider metadata",
+      description: "Get the active Console org name and the set of provider IDs managed by that Console org.",
+      operationId: "experimental.console.get",
+      responses: {
+        200: {
+          description: "Active Console provider metadata",
+          content: {
+            "application/json": {
+              schema: resolver12(ConsoleState)
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const [consoleState, groups] = await Promise.all([Config.getConsoleState(), Account.orgsByAccount()]);
+      return c.json({
+        ...consoleState,
+        switchableOrgCount: groups.reduce((count, group) => count + group.orgs.length, 0)
+      });
+    }
+  ).get(
+    "/console/orgs",
+    describeRoute11({
+      summary: "List switchable Console orgs",
+      description: "Get the available Console orgs across logged-in accounts, including the current active org.",
+      operationId: "experimental.console.listOrgs",
+      responses: {
+        200: {
+          description: "Switchable Console orgs",
+          content: {
+            "application/json": {
+              schema: resolver12(ConsoleOrgList)
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const [groups, active] = await Promise.all([Account.orgsByAccount(), Account.active()]);
+      const orgs = groups.flatMap(
+        (group) => group.orgs.map((org) => ({
+          accountID: group.account.id,
+          accountEmail: group.account.email,
+          accountUrl: group.account.url,
+          orgID: org.id,
+          orgName: org.name,
+          active: !!active && active.id === group.account.id && active.active_org_id === org.id
+        }))
+      );
+      return c.json({ orgs });
+    }
+  ).post(
+    "/console/switch",
+    describeRoute11({
+      summary: "Switch active Console org",
+      description: "Persist a new active Console account/org selection for the current local OpenCode state.",
+      operationId: "experimental.console.switchOrg",
+      responses: {
+        200: {
+          description: "Switch success",
+          content: {
+            "application/json": {
+              schema: resolver12(z16.boolean())
+            }
+          }
+        }
+      }
+    }),
+    validator11("json", ConsoleSwitchBody),
+    async (c) => {
+      const body = c.req.valid("json");
+      await Account.switchOrg(AccountID.make(body.accountID), OrgID.make(body.orgID));
+      return c.json(true);
+    }
+  ).get(
+    "/tool/ids",
+    describeRoute11({
+      summary: "List tool IDs",
+      description: "Get a list of all available tool IDs, including both built-in tools and dynamically registered tools.",
+      operationId: "tool.ids",
+      responses: {
+        200: {
+          description: "Tool IDs",
+          content: {
+            "application/json": {
+              schema: resolver12(z16.array(z16.string()).meta({ ref: "ToolIDs" }))
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    async (c) => {
+      return c.json(await ToolRegistry.ids());
+    }
+  ).get(
+    "/tool",
+    describeRoute11({
+      summary: "List tools",
+      description: "Get a list of available tools with their JSON schema parameters for a specific provider and model combination.",
+      operationId: "tool.list",
+      responses: {
+        200: {
+          description: "Tools",
+          content: {
+            "application/json": {
+              schema: resolver12(
+                z16.array(
+                  z16.object({
+                    id: z16.string(),
+                    description: z16.string(),
+                    parameters: z16.any()
+                  }).meta({ ref: "ToolListItem" })
+                ).meta({ ref: "ToolList" })
+              )
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator11(
+      "query",
+      z16.object({
+        provider: z16.string(),
+        model: z16.string()
+      })
+    ),
+    async (c) => {
+      const { provider, model } = c.req.valid("query");
+      const tools = await ToolRegistry.tools({ providerID: ProviderID.make(provider), modelID: ModelID.make(model) });
+      return c.json(
+        tools.map((t) => ({
+          id: t.id,
+          description: t.description,
+          // Handle both Zod schemas and plain JSON schemas
+          parameters: t.parameters?._def ? zodToJsonSchema(t.parameters) : t.parameters
+        }))
+      );
+    }
+  ).route("/workspace", WorkspaceRoutes()).post(
+    "/worktree",
+    describeRoute11({
+      summary: "Create worktree",
+      description: "Create a new git worktree for the current project and run any configured startup scripts.",
+      operationId: "worktree.create",
+      responses: {
+        200: {
+          description: "Worktree created",
+          content: {
+            "application/json": {
+              schema: resolver12(Worktree.Info)
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator11("json", Worktree.CreateInput.optional()),
+    async (c) => {
+      const body = c.req.valid("json");
+      const worktree = await Worktree.create(body);
+      return c.json(worktree);
+    }
+  ).get(
+    "/worktree",
+    describeRoute11({
+      summary: "List worktrees",
+      description: "List all sandbox worktrees for the current project.",
+      operationId: "worktree.list",
+      responses: {
+        200: {
+          description: "List of worktree directories",
+          content: {
+            "application/json": {
+              schema: resolver12(z16.array(z16.string()))
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const sandboxes = await Project.sandboxes(Instance.project.id);
+      return c.json(sandboxes);
+    }
+  ).delete(
+    "/worktree",
+    describeRoute11({
+      summary: "Remove worktree",
+      description: "Remove a git worktree and delete its branch.",
+      operationId: "worktree.remove",
+      responses: {
+        200: {
+          description: "Worktree removed",
+          content: {
+            "application/json": {
+              schema: resolver12(z16.boolean())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator11("json", Worktree.RemoveInput),
+    async (c) => {
+      const body = c.req.valid("json");
+      await Worktree.remove(body);
+      await Project.removeSandbox(Instance.project.id, body.directory);
+      return c.json(true);
+    }
+  ).post(
+    "/worktree/reset",
+    describeRoute11({
+      summary: "Reset worktree",
+      description: "Reset a worktree branch to the primary default branch.",
+      operationId: "worktree.reset",
+      responses: {
+        200: {
+          description: "Worktree reset",
+          content: {
+            "application/json": {
+              schema: resolver12(z16.boolean())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator11("json", Worktree.ResetInput),
+    async (c) => {
+      const body = c.req.valid("json");
+      await Worktree.reset(body);
+      return c.json(true);
+    }
+  ).get(
+    "/session",
+    describeRoute11({
+      summary: "List sessions",
+      description: "Get a list of all OpenCode sessions across projects, sorted by most recently updated. Archived sessions are excluded by default.",
+      operationId: "experimental.session.list",
+      responses: {
+        200: {
+          description: "List of sessions",
+          content: {
+            "application/json": {
+              schema: resolver12(Session.GlobalInfo.array())
+            }
+          }
+        }
+      }
+    }),
+    validator11(
+      "query",
+      z16.object({
+        directory: z16.string().optional().meta({ description: "Filter sessions by project directory" }),
+        roots: z16.coerce.boolean().optional().meta({ description: "Only return root sessions (no parentID)" }),
+        start: z16.coerce.number().optional().meta({ description: "Filter sessions updated on or after this timestamp (milliseconds since epoch)" }),
+        cursor: z16.coerce.number().optional().meta({ description: "Return sessions updated before this timestamp (milliseconds since epoch)" }),
+        search: z16.string().optional().meta({ description: "Filter sessions by title (case-insensitive)" }),
+        limit: z16.coerce.number().optional().meta({ description: "Maximum number of sessions to return" }),
+        archived: z16.coerce.boolean().optional().meta({ description: "Include archived sessions (default false)" })
+      })
+    ),
+    async (c) => {
+      const query = c.req.valid("query");
+      const limit = query.limit ?? 100;
+      const sessions = [];
+      for await (const session of Session.listGlobal({
+        directory: query.directory,
+        roots: query.roots,
+        start: query.start,
+        cursor: query.cursor,
+        search: query.search,
+        limit: limit + 1,
+        archived: query.archived
+      })) {
+        sessions.push(session);
+      }
+      const hasMore = sessions.length > limit;
+      const list = hasMore ? sessions.slice(0, limit) : sessions;
+      if (hasMore && list.length > 0) {
+        c.header("x-next-cursor", String(list[list.length - 1].time.updated));
+      }
+      return c.json(list);
+    }
+  ).get(
+    "/resource",
+    describeRoute11({
+      summary: "Get MCP resources",
+      description: "Get all available MCP resources from connected servers. Optionally filter by name.",
+      operationId: "experimental.resource.list",
+      responses: {
+        200: {
+          description: "MCP resources",
+          content: {
+            "application/json": {
+              schema: resolver12(z16.record(z16.string(), MCP.Resource))
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(await MCP.resources());
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/provider.ts
+import { Hono as Hono13 } from "hono";
+import { describeRoute as describeRoute12, validator as validator12, resolver as resolver13 } from "hono-openapi";
+import z18 from "zod";
+
+// packages/opencode/src/provider/auth.ts
+import { Array as Arr, Effect as Effect2, Layer as Layer2, Record, Result, ServiceMap as ServiceMap2 } from "effect";
+import z17 from "zod";
+var ProviderAuth;
+((ProviderAuth2) => {
+  ProviderAuth2.Method = z17.object({
+    type: z17.union([z17.literal("oauth"), z17.literal("api")]),
+    label: z17.string(),
+    prompts: z17.array(
+      z17.union([
+        z17.object({
+          type: z17.literal("text"),
+          key: z17.string(),
+          message: z17.string(),
+          placeholder: z17.string().optional(),
+          when: z17.object({
+            key: z17.string(),
+            op: z17.union([z17.literal("eq"), z17.literal("neq")]),
+            value: z17.string()
+          }).optional()
+        }),
+        z17.object({
+          type: z17.literal("select"),
+          key: z17.string(),
+          message: z17.string(),
+          options: z17.array(
+            z17.object({
+              label: z17.string(),
+              value: z17.string(),
+              hint: z17.string().optional()
+            })
+          ),
+          when: z17.object({
+            key: z17.string(),
+            op: z17.union([z17.literal("eq"), z17.literal("neq")]),
+            value: z17.string()
+          }).optional()
+        })
+      ])
+    ).optional()
+  }).meta({
+    ref: "ProviderAuthMethod"
+  });
+  ProviderAuth2.Authorization = z17.object({
+    url: z17.string(),
+    method: z17.union([z17.literal("auto"), z17.literal("code")]),
+    instructions: z17.string()
+  }).meta({
+    ref: "ProviderAuthAuthorization"
+  });
+  ProviderAuth2.OauthMissing = NamedError.create("ProviderAuthOauthMissing", z17.object({ providerID: ProviderID.zod }));
+  ProviderAuth2.OauthCodeMissing = NamedError.create(
+    "ProviderAuthOauthCodeMissing",
+    z17.object({ providerID: ProviderID.zod })
+  );
+  ProviderAuth2.OauthCallbackFailed = NamedError.create("ProviderAuthOauthCallbackFailed", z17.object({}));
+  ProviderAuth2.ValidationFailed = NamedError.create(
+    "ProviderAuthValidationFailed",
+    z17.object({
+      field: z17.string(),
+      message: z17.string()
+    })
+  );
+  class Service extends ServiceMap2.Service()("@opencode/ProviderAuth") {
+  }
+  ProviderAuth2.Service = Service;
+  ProviderAuth2.layer = Layer2.effect(
+    Service,
+    Effect2.gen(function* () {
+      const auth = yield* Auth.Service;
+      const plugin = yield* Plugin.Service;
+      const state = yield* InstanceState.make(
+        Effect2.fn("ProviderAuth.state")(function* () {
+          const plugins = yield* plugin.list();
+          return {
+            hooks: Record.fromEntries(
+              Arr.filterMap(
+                plugins,
+                (x) => x.auth?.provider !== void 0 ? Result.succeed([ProviderID.make(x.auth.provider), x.auth]) : Result.failVoid
+              )
+            ),
+            pending: /* @__PURE__ */ new Map()
+          };
+        })
+      );
+      const methods2 = Effect2.fn("ProviderAuth.methods")(function* () {
+        const hooks = (yield* InstanceState.get(state)).hooks;
+        return Record.map(
+          hooks,
+          (item) => item.methods.map(
+            (method) => ({
+              type: method.type,
+              label: method.label,
+              prompts: method.prompts?.map((prompt) => {
+                if (prompt.type === "select") {
+                  return {
+                    type: "select",
+                    key: prompt.key,
+                    message: prompt.message,
+                    options: prompt.options,
+                    when: prompt.when
+                  };
+                }
+                return {
+                  type: "text",
+                  key: prompt.key,
+                  message: prompt.message,
+                  placeholder: prompt.placeholder,
+                  when: prompt.when
+                };
+              })
+            })
+          )
+        );
+      });
+      const authorize2 = Effect2.fn("ProviderAuth.authorize")(function* (input) {
+        const { hooks, pending } = yield* InstanceState.get(state);
+        const method = hooks[input.providerID].methods[input.method];
+        if (method.type !== "oauth") return;
+        if (method.prompts && input.inputs) {
+          for (const prompt of method.prompts) {
+            if (prompt.type === "text" && prompt.validate && input.inputs[prompt.key] !== void 0) {
+              const error = prompt.validate(input.inputs[prompt.key]);
+              if (error) return yield* Effect2.fail(new ProviderAuth2.ValidationFailed({ field: prompt.key, message: error }));
+            }
+          }
+        }
+        const result = yield* Effect2.promise(() => method.authorize(input.inputs));
+        pending.set(input.providerID, result);
+        return {
+          url: result.url,
+          method: result.method,
+          instructions: result.instructions
+        };
+      });
+      const callback2 = Effect2.fn("ProviderAuth.callback")(function* (input) {
+        const pending = (yield* InstanceState.get(state)).pending;
+        const match = pending.get(input.providerID);
+        if (!match) return yield* Effect2.fail(new ProviderAuth2.OauthMissing({ providerID: input.providerID }));
+        if (match.method === "code" && !input.code) {
+          return yield* Effect2.fail(new ProviderAuth2.OauthCodeMissing({ providerID: input.providerID }));
+        }
+        const result = yield* Effect2.promise(
+          () => match.method === "code" ? match.callback(input.code) : match.callback()
+        );
+        if (!result || result.type !== "success") return yield* Effect2.fail(new ProviderAuth2.OauthCallbackFailed({}));
+        if ("key" in result) {
+          yield* auth.set(input.providerID, {
+            type: "api",
+            key: result.key
+          });
+        }
+        if ("refresh" in result) {
+          const { type: _, provider: __, refresh, access, expires, ...extra } = result;
+          yield* auth.set(input.providerID, {
+            type: "oauth",
+            access,
+            refresh,
+            expires,
+            ...extra
+          });
+        }
+      });
+      return Service.of({ methods: methods2, authorize: authorize2, callback: callback2 });
+    })
+  );
+  ProviderAuth2.defaultLayer = Layer2.suspend(
+    () => ProviderAuth2.layer.pipe(Layer2.provide(Auth.defaultLayer), Layer2.provide(Plugin.defaultLayer))
+  );
+  const { runPromise } = makeRuntime(Service, ProviderAuth2.defaultLayer);
+  async function methods() {
+    return runPromise((svc) => svc.methods());
+  }
+  ProviderAuth2.methods = methods;
+  async function authorize(input) {
+    return runPromise((svc) => svc.authorize(input));
+  }
+  ProviderAuth2.authorize = authorize;
+  async function callback(input) {
+    return runPromise((svc) => svc.callback(input));
+  }
+  ProviderAuth2.callback = callback;
+})(ProviderAuth || (ProviderAuth = {}));
+
+// packages/opencode/src/server/routes/provider.ts
+import { mapValues as mapValues2 } from "remeda";
+var log3 = Log.create({ service: "server" });
+var ProviderRoutes = lazy(
+  () => new Hono13().get(
+    "/",
+    describeRoute12({
+      summary: "List providers",
+      description: "Get a list of all available AI providers, including both available and connected ones.",
+      operationId: "provider.list",
+      responses: {
+        200: {
+          description: "List of providers",
+          content: {
+            "application/json": {
+              schema: resolver13(
+                z18.object({
+                  all: ModelsDev.Provider.array(),
+                  default: z18.record(z18.string(), z18.string()),
+                  connected: z18.array(z18.string())
+                })
+              )
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      const config = await Config.get();
+      const disabled = new Set(config.disabled_providers ?? []);
+      const enabled = config.enabled_providers ? new Set(config.enabled_providers) : void 0;
+      const allProviders = await ModelsDev.get();
+      const filteredProviders = {};
+      for (const [key, value] of Object.entries(allProviders)) {
+        if ((enabled ? enabled.has(key) : true) && !disabled.has(key)) {
+          filteredProviders[key] = value;
+        }
+      }
+      const connected = await Provider.list();
+      const providers = Object.assign(
+        mapValues2(filteredProviders, (x) => Provider.fromModelsDevProvider(x)),
+        connected
+      );
+      return c.json({
+        all: Object.values(providers),
+        default: mapValues2(providers, (item) => Provider.sort(Object.values(item.models))[0].id),
+        connected: Object.keys(connected)
+      });
+    }
+  ).get(
+    "/auth",
+    describeRoute12({
+      summary: "Get provider auth methods",
+      description: "Retrieve available authentication methods for all AI providers.",
+      operationId: "provider.auth",
+      responses: {
+        200: {
+          description: "Provider auth methods",
+          content: {
+            "application/json": {
+              schema: resolver13(z18.record(z18.string(), z18.array(ProviderAuth.Method)))
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(await ProviderAuth.methods());
+    }
+  ).post(
+    "/:providerID/oauth/authorize",
+    describeRoute12({
+      summary: "OAuth authorize",
+      description: "Initiate OAuth authorization for a specific AI provider to get an authorization URL.",
+      operationId: "provider.oauth.authorize",
+      responses: {
+        200: {
+          description: "Authorization URL and method",
+          content: {
+            "application/json": {
+              schema: resolver13(ProviderAuth.Authorization.optional())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator12(
+      "param",
+      z18.object({
+        providerID: ProviderID.zod.meta({ description: "Provider ID" })
+      })
+    ),
+    validator12(
+      "json",
+      z18.object({
+        method: z18.number().meta({ description: "Auth method index" }),
+        inputs: z18.record(z18.string(), z18.string()).optional().meta({ description: "Prompt inputs" })
+      })
+    ),
+    async (c) => {
+      const providerID = c.req.valid("param").providerID;
+      const { method, inputs } = c.req.valid("json");
+      const result = await ProviderAuth.authorize({
+        providerID,
+        method,
+        inputs
+      });
+      return c.json(result);
+    }
+  ).post(
+    "/:providerID/oauth/callback",
+    describeRoute12({
+      summary: "OAuth callback",
+      description: "Handle the OAuth callback from a provider after user authorization.",
+      operationId: "provider.oauth.callback",
+      responses: {
+        200: {
+          description: "OAuth callback processed successfully",
+          content: {
+            "application/json": {
+              schema: resolver13(z18.boolean())
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator12(
+      "param",
+      z18.object({
+        providerID: ProviderID.zod.meta({ description: "Provider ID" })
+      })
+    ),
+    validator12(
+      "json",
+      z18.object({
+        method: z18.number().meta({ description: "Auth method index" }),
+        code: z18.string().optional().meta({ description: "OAuth authorization code" })
+      })
+    ),
+    async (c) => {
+      const providerID = c.req.valid("param").providerID;
+      const { method, code } = c.req.valid("json");
+      await ProviderAuth.callback({
+        providerID,
+        method,
+        code
+      });
+      return c.json(true);
+    }
+  )
+);
+
+// packages/opencode/src/server/routes/event.ts
+import { Hono as Hono14 } from "hono";
+import { describeRoute as describeRoute13, resolver as resolver14 } from "hono-openapi";
+import { streamSSE } from "hono/streaming";
+var log4 = Log.create({ service: "server" });
+var EventRoutes = () => new Hono14().get(
+  "/event",
+  describeRoute13({
+    summary: "Subscribe to events",
+    description: "Get events",
+    operationId: "event.subscribe",
+    responses: {
+      200: {
+        description: "Event stream",
+        content: {
+          "text/event-stream": {
+            schema: resolver14(BusEvent.payloads())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    log4.info("event connected");
+    c.header("Cache-Control", "no-cache, no-transform");
+    c.header("X-Accel-Buffering", "no");
+    c.header("X-Content-Type-Options", "nosniff");
+    return streamSSE(c, async (stream2) => {
+      const q = new AsyncQueue();
+      let done = false;
+      q.push(
+        JSON.stringify({
+          type: "server.connected",
+          properties: {}
+        })
+      );
+      const heartbeat = setInterval(() => {
+        q.push(
+          JSON.stringify({
+            type: "server.heartbeat",
+            properties: {}
+          })
+        );
+      }, 1e4);
+      const stop = () => {
+        if (done) return;
+        done = true;
+        clearInterval(heartbeat);
+        unsub();
+        q.push(null);
+        log4.info("event disconnected");
+      };
+      const unsub = Bus.subscribeAll((event) => {
+        q.push(JSON.stringify(event));
+        if (event.type === Bus.InstanceDisposed.type) {
+          stop();
+        }
+      });
+      stream2.onAbort(stop);
+      try {
+        for await (const data of q) {
+          if (data === null) return;
+          await stream2.writeSSE({ data });
+        }
+      } finally {
+        stop();
+      }
+    });
+  }
+);
+
+// packages/opencode/src/server/middleware.ts
+import { HTTPException } from "hono/http-exception";
+function errorHandler(log9) {
+  return (err, c) => {
+    log9.error("failed", {
+      error: err
+    });
+    if (err instanceof NamedError) {
+      let status;
+      if (err instanceof NotFoundError) status = 404;
+      else if (err instanceof Provider.ModelNotFoundError) status = 400;
+      else if (err.name === "ProviderAuthValidationFailed") status = 400;
+      else if (err.name.startsWith("Worktree")) status = 400;
+      else status = 500;
+      return c.json(err.toObject(), { status });
+    }
+    if (err instanceof Session.BusyError) {
+      return c.json(new NamedError.Unknown({ message: err.message }).toObject(), { status: 400 });
+    }
+    if (err instanceof HTTPException) return err.getResponse();
+    const message = err instanceof Error && err.stack ? err.stack : err.toString();
+    return c.json(new NamedError.Unknown({ message }).toObject(), {
+      status: 500
+    });
+  };
+}
+
+// packages/opencode/src/server/instance.ts
+var log5 = Log.create({ service: "server" });
+var embeddedUIPromise = Flag.OPENCODE_DISABLE_EMBEDDED_WEB_UI ? Promise.resolve(null) : (
+  // @ts-expect-error - generated file at build time
+  import("opencode-web-ui.gen.ts").then((module) => module.default).catch(() => null)
+);
+var DEFAULT_CSP = "default-src 'self'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:";
+var csp = (hash = "") => `default-src 'self'; script-src 'self' 'wasm-unsafe-eval'${hash ? ` 'sha256-${hash}'` : ""}; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; media-src 'self' data:; connect-src 'self' data:`;
+var InstanceRoutes = (upgrade, app2 = new Hono15()) => app2.onError(errorHandler(log5)).route("/project", ProjectRoutes()).route("/pty", PtyRoutes(upgrade)).route("/config", ConfigRoutes()).route("/experimental", ExperimentalRoutes()).route("/session", SessionRoutes()).route("/permission", PermissionRoutes()).route("/question", QuestionRoutes()).route("/provider", ProviderRoutes()).route("/", FileRoutes()).route("/", EventRoutes()).route("/mcp", McpRoutes()).route("/tui", TuiRoutes()).post(
+  "/instance/dispose",
+  describeRoute14({
+    summary: "Dispose instance",
+    description: "Clean up and dispose the current OpenCode instance, releasing all resources.",
+    operationId: "instance.dispose",
+    responses: {
+      200: {
+        description: "Instance disposed",
+        content: {
+          "application/json": {
+            schema: resolver15(z19.boolean())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    await Instance.dispose();
+    return c.json(true);
+  }
+).get(
+  "/path",
+  describeRoute14({
+    summary: "Get paths",
+    description: "Retrieve the current working directory and related path information for the OpenCode instance.",
+    operationId: "path.get",
+    responses: {
+      200: {
+        description: "Path",
+        content: {
+          "application/json": {
+            schema: resolver15(
+              z19.object({
+                home: z19.string(),
+                state: z19.string(),
+                config: z19.string(),
+                worktree: z19.string(),
+                directory: z19.string()
+              }).meta({
+                ref: "Path"
+              })
+            )
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    return c.json({
+      home: Global.Path.home,
+      state: Global.Path.state,
+      config: Global.Path.config,
+      worktree: Instance.worktree,
+      directory: Instance.directory
+    });
+  }
+).get(
+  "/vcs",
+  describeRoute14({
+    summary: "Get VCS info",
+    description: "Retrieve version control system (VCS) information for the current project, such as git branch.",
+    operationId: "vcs.get",
+    responses: {
+      200: {
+        description: "VCS info",
+        content: {
+          "application/json": {
+            schema: resolver15(Vcs.Info)
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    const [branch, default_branch] = await Promise.all([Vcs.branch(), Vcs.defaultBranch()]);
+    return c.json({
+      branch,
+      default_branch
+    });
+  }
+).get(
+  "/vcs/diff",
+  describeRoute14({
+    summary: "Get VCS diff",
+    description: "Retrieve the current git diff for the working tree or against the default branch.",
+    operationId: "vcs.diff",
+    responses: {
+      200: {
+        description: "VCS diff",
+        content: {
+          "application/json": {
+            schema: resolver15(Snapshot.FileDiff.array())
+          }
+        }
+      }
+    }
+  }),
+  validator13(
+    "query",
+    z19.object({
+      mode: Vcs.Mode
+    })
+  ),
+  async (c) => {
+    return c.json(await Vcs.diff(c.req.valid("query").mode));
+  }
+).get(
+  "/command",
+  describeRoute14({
+    summary: "List commands",
+    description: "Get a list of all available commands in the OpenCode system.",
+    operationId: "command.list",
+    responses: {
+      200: {
+        description: "List of commands",
+        content: {
+          "application/json": {
+            schema: resolver15(Command.Info.array())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    const commands = await Command.list();
+    return c.json(commands);
+  }
+).get(
+  "/agent",
+  describeRoute14({
+    summary: "List agents",
+    description: "Get a list of all available AI agents in the OpenCode system.",
+    operationId: "app.agents",
+    responses: {
+      200: {
+        description: "List of agents",
+        content: {
+          "application/json": {
+            schema: resolver15(Agent.Info.array())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    const modes = await Agent.list();
+    return c.json(modes);
+  }
+).get(
+  "/skill",
+  describeRoute14({
+    summary: "List skills",
+    description: "Get a list of all available skills in the OpenCode system.",
+    operationId: "app.skills",
+    responses: {
+      200: {
+        description: "List of skills",
+        content: {
+          "application/json": {
+            schema: resolver15(Skill.Info.array())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    const skills = await Skill.all();
+    return c.json(skills);
+  }
+).get(
+  "/lsp",
+  describeRoute14({
+    summary: "Get LSP status",
+    description: "Get LSP server status",
+    operationId: "lsp.status",
+    responses: {
+      200: {
+        description: "LSP server status",
+        content: {
+          "application/json": {
+            schema: resolver15(LSP.Status.array())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    return c.json(await LSP.status());
+  }
+).get(
+  "/formatter",
+  describeRoute14({
+    summary: "Get formatter status",
+    description: "Get formatter status",
+    operationId: "formatter.status",
+    responses: {
+      200: {
+        description: "Formatter status",
+        content: {
+          "application/json": {
+            schema: resolver15(Format.Status.array())
+          }
+        }
+      }
+    }
+  }),
+  async (c) => {
+    return c.json(await Format.status());
+  }
+).all("/*", async (c) => {
+  const embeddedWebUI = await embeddedUIPromise;
+  const path = c.req.path;
+  if (embeddedWebUI) {
+    const match = embeddedWebUI[path.replace(/^\//, "")] ?? embeddedWebUI["index.html"] ?? null;
+    if (!match) return c.json({ error: "Not Found" }, 404);
+    const fs = await import("fs");
+    const pathMod = await import("path");
+    try {
+      const content = fs.readFileSync(match);
+      const ext = pathMod.extname(match).toLowerCase();
+      const mimeTypes = {
+        ".html": "text/html",
+        ".js": "application/javascript",
+        ".css": "text/css",
+        ".json": "application/json",
+        ".png": "image/png",
+        ".svg": "image/svg+xml",
+        ".ico": "image/x-icon",
+        ".woff": "font/woff",
+        ".woff2": "font/woff2"
+      };
+      const contentType = mimeTypes[ext] || "application/octet-stream";
+      c.header("Content-Type", contentType);
+      if (contentType.startsWith("text/html")) {
+        c.header("Content-Security-Policy", DEFAULT_CSP);
+      }
+      return c.body(content);
+    } catch {
+      return c.json({ error: "Not Found" }, 404);
+    }
+  } else {
+    const response2 = await proxy(`https://app.opencode.ai${path}`, {
+      ...c.req,
+      headers: {
+        ...c.req.raw.headers,
+        host: "app.opencode.ai"
+      }
+    });
+    const match = response2.headers.get("content-type")?.includes("text/html") ? (await response2.clone().text()).match(
+      /<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i
+    ) : void 0;
+    const hash = match ? createHash("sha256").update(match[2]).digest("base64") : "";
+    response2.headers.set("Content-Security-Policy", csp(hash));
+    return response2;
+  }
+});
+
+// packages/opencode/src/server/router.ts
+var RULES = [
+  { path: "/session/status", action: "forward" },
+  { method: "GET", path: "/session", action: "local" }
+];
+function local(method, path) {
+  for (const rule of RULES) {
+    if (rule.method && rule.method !== method) continue;
+    const match = rule.exact ? path === rule.path : path === rule.path || path.startsWith(rule.path + "/");
+    if (match) return rule.action === "local";
+  }
+  return false;
+}
+function WorkspaceRouterMiddleware(upgrade) {
+  const routes = lazy(() => InstanceRoutes(upgrade));
+  return async (c) => {
+    const raw = c.req.query("directory") || c.req.header("x-opencode-directory") || process.cwd();
+    const directory = Filesystem.resolve(
+      (() => {
+        try {
+          return decodeURIComponent(raw);
+        } catch {
+          return raw;
+        }
+      })()
+    );
+    const url = new URL(c.req.url);
+    const workspaceParam = url.searchParams.get("workspace") || c.req.header("x-opencode-workspace");
+    if (!workspaceParam) {
+      return Instance.provide({
+        directory,
+        init: InstanceBootstrap,
+        async fn() {
+          return routes().fetch(c.req.raw, c.env);
+        }
+      });
+    }
+    const workspaceID = WorkspaceID.make(workspaceParam);
+    const workspace = await Workspace.get(workspaceID);
+    if (!workspace) {
+      return new Response(`Workspace not found: ${workspaceID}`, {
+        status: 500,
+        headers: {
+          "content-type": "text/plain; charset=utf-8"
+        }
+      });
+    }
+    const adaptor = await getAdaptor(workspace.type);
+    const target = await adaptor.target(workspace);
+    if (target.type === "local") {
+      return Instance.provide({
+        directory: target.directory,
+        init: InstanceBootstrap,
+        async fn() {
+          return routes().fetch(c.req.raw, c.env);
+        }
+      });
+    }
+    if (local(c.req.method, url.pathname)) {
+      return routes().fetch(c.req.raw, c.env);
+    }
+    if (c.req.header("upgrade")?.toLowerCase() === "websocket") {
+      return ServerProxy.websocket(target, c.req.raw, c.env);
+    }
+    const headers2 = new Headers(c.req.raw.headers);
+    headers2.delete("x-opencode-workspace");
+    return ServerProxy.http(
+      target,
+      new Request(c.req.raw, {
+        headers: headers2
+      })
+    );
+  };
+}
+
+// packages/opencode/src/server/routes/global.ts
+import { Hono as Hono16 } from "hono";
+import { describeRoute as describeRoute15, resolver as resolver16, validator as validator14 } from "hono-openapi";
+import { streamSSE as streamSSE2 } from "hono/streaming";
+import z20 from "zod";
+var log6 = Log.create({ service: "server" });
+var GlobalDisposedEvent = BusEvent.define("global.disposed", z20.object({}));
+async function streamEvents(c, subscribe) {
+  return streamSSE2(c, async (stream2) => {
+    const q = new AsyncQueue();
+    let done = false;
+    q.push(
+      JSON.stringify({
+        payload: {
+          type: "server.connected",
+          properties: {}
+        }
+      })
+    );
+    const heartbeat = setInterval(() => {
+      q.push(
+        JSON.stringify({
+          payload: {
+            type: "server.heartbeat",
+            properties: {}
+          }
+        })
+      );
+    }, 1e4);
+    const stop = () => {
+      if (done) return;
+      done = true;
+      clearInterval(heartbeat);
+      unsub();
+      q.push(null);
+      log6.info("global event disconnected");
+    };
+    const unsub = subscribe(q);
+    stream2.onAbort(stop);
+    try {
+      for await (const data of q) {
+        if (data === null) return;
+        await stream2.writeSSE({ data });
+      }
+    } finally {
+      stop();
+    }
+  });
+}
+var GlobalRoutes = lazy(
+  () => new Hono16().get(
+    "/health",
+    describeRoute15({
+      summary: "Get health",
+      description: "Get health information about the OpenCode server.",
+      operationId: "global.health",
+      responses: {
+        200: {
+          description: "Health information",
+          content: {
+            "application/json": {
+              schema: resolver16(z20.object({ healthy: z20.literal(true), version: z20.string() }))
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json({ healthy: true, version: Installation.VERSION });
+    }
+  ).get(
+    "/event",
+    describeRoute15({
+      summary: "Get global events",
+      description: "Subscribe to global events from the OpenCode system using server-sent events.",
+      operationId: "global.event",
+      responses: {
+        200: {
+          description: "Event stream",
+          content: {
+            "text/event-stream": {
+              schema: resolver16(
+                z20.object({
+                  directory: z20.string(),
+                  payload: BusEvent.payloads()
+                }).meta({
+                  ref: "GlobalEvent"
+                })
+              )
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      log6.info("global event connected");
+      c.header("Cache-Control", "no-cache, no-transform");
+      c.header("X-Accel-Buffering", "no");
+      c.header("X-Content-Type-Options", "nosniff");
+      return streamEvents(c, (q) => {
+        async function handler(event) {
+          q.push(JSON.stringify(event));
+        }
+        GlobalBus.on("event", handler);
+        return () => GlobalBus.off("event", handler);
+      });
+    }
+  ).get(
+    "/sync-event",
+    describeRoute15({
+      summary: "Subscribe to global sync events",
+      description: "Get global sync events",
+      operationId: "global.sync-event.subscribe",
+      responses: {
+        200: {
+          description: "Event stream",
+          content: {
+            "text/event-stream": {
+              schema: resolver16(
+                z20.object({
+                  payload: SyncEvent.payloads()
+                }).meta({
+                  ref: "SyncEvent"
+                })
+              )
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      log6.info("global sync event connected");
+      c.header("Cache-Control", "no-cache, no-transform");
+      c.header("X-Accel-Buffering", "no");
+      c.header("X-Content-Type-Options", "nosniff");
+      return streamEvents(c, (q) => {
+        return SyncEvent.subscribeAll(({ def, event }) => {
+          q.push(
+            JSON.stringify({
+              payload: {
+                ...event,
+                type: SyncEvent.versionedType(def.type, def.version)
+              }
+            })
+          );
+        });
+      });
+    }
+  ).get(
+    "/config",
+    describeRoute15({
+      summary: "Get global configuration",
+      description: "Retrieve the current global OpenCode configuration settings and preferences.",
+      operationId: "global.config.get",
+      responses: {
+        200: {
+          description: "Get global config info",
+          content: {
+            "application/json": {
+              schema: resolver16(Config.Info)
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      return c.json(await Config.getGlobal());
+    }
+  ).patch(
+    "/config",
+    describeRoute15({
+      summary: "Update global configuration",
+      description: "Update global OpenCode configuration settings and preferences.",
+      operationId: "global.config.update",
+      responses: {
+        200: {
+          description: "Successfully updated global config",
+          content: {
+            "application/json": {
+              schema: resolver16(Config.Info)
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator14("json", Config.Info),
+    async (c) => {
+      const config = c.req.valid("json");
+      const next = await Config.updateGlobal(config);
+      return c.json(next);
+    }
+  ).post(
+    "/dispose",
+    describeRoute15({
+      summary: "Dispose instance",
+      description: "Clean up and dispose all OpenCode instances, releasing all resources.",
+      operationId: "global.dispose",
+      responses: {
+        200: {
+          description: "Global disposed",
+          content: {
+            "application/json": {
+              schema: resolver16(z20.boolean())
+            }
+          }
+        }
+      }
+    }),
+    async (c) => {
+      await Instance.disposeAll();
+      GlobalBus.emit("event", {
+        directory: "global",
+        payload: {
+          type: GlobalDisposedEvent.type,
+          properties: {}
+        }
+      });
+      return c.json(true);
+    }
+  ).post(
+    "/upgrade",
+    describeRoute15({
+      summary: "Upgrade opencode",
+      description: "Upgrade opencode to the specified version or latest if not specified.",
+      operationId: "global.upgrade",
+      responses: {
+        200: {
+          description: "Upgrade result",
+          content: {
+            "application/json": {
+              schema: resolver16(
+                z20.union([
+                  z20.object({
+                    success: z20.literal(true),
+                    version: z20.string()
+                  }),
+                  z20.object({
+                    success: z20.literal(false),
+                    error: z20.string()
+                  })
+                ])
+              )
+            }
+          }
+        },
+        ...errors(400)
+      }
+    }),
+    validator14(
+      "json",
+      z20.object({
+        target: z20.string().optional()
+      })
+    ),
+    async (c) => {
+      const method = await Installation.method();
+      if (method === "unknown") {
+        return c.json({ success: false, error: "Unknown installation method" }, 400);
+      }
+      const target = c.req.valid("json").target || await Installation.latest(method);
+      const result = await Installation.upgrade(method, target).then(() => ({ success: true, version: target })).catch((e) => ({ success: false, error: e instanceof Error ? e.message : String(e) }));
+      if (result.success) {
+        GlobalBus.emit("event", {
+          directory: "global",
+          payload: {
+            type: Installation.Event.Updated.type,
+            properties: { version: target }
+          }
+        });
+        return c.json(result);
+      }
+      return c.json(result, 500);
+    }
+  )
+);
+
+// packages/opencode/src/server/mdns.ts
+import { Bonjour } from "bonjour-service";
+var log7 = Log.create({ service: "mdns" });
+var MDNS;
+((MDNS2) => {
+  let bonjour;
+  let currentPort;
+  function publish(port, domain) {
+    if (currentPort === port) return;
+    if (bonjour) unpublish();
+    try {
+      const host = domain ?? "opencode.local";
+      const name = `opencode-${port}`;
+      bonjour = new Bonjour();
+      const service = bonjour.publish({
+        name,
+        type: "http",
+        host,
+        port,
+        txt: { path: "/" }
+      });
+      service.on("up", () => {
+        log7.info("mDNS service published", { name, port });
+      });
+      service.on("error", (err) => {
+        log7.error("mDNS service error", { error: err });
+      });
+      currentPort = port;
+    } catch (err) {
+      log7.error("mDNS publish failed", { error: err });
+      if (bonjour) {
+        try {
+          bonjour.destroy();
+        } catch {
+        }
+      }
+      bonjour = void 0;
+      currentPort = void 0;
+    }
+  }
+  MDNS2.publish = publish;
+  function unpublish() {
+    if (bonjour) {
+      try {
+        bonjour.unpublishAll();
+        bonjour.destroy();
+      } catch (err) {
+        log7.error("mDNS unpublish failed", { error: err });
+      }
+      bonjour = void 0;
+      currentPort = void 0;
+      log7.info("mDNS service unpublished");
+    }
+  }
+  MDNS2.unpublish = unpublish;
+})(MDNS || (MDNS = {}));
+
+// packages/opencode/src/session/projectors.ts
+var log8 = Log.create({ service: "session.projector" });
+function foreign(err) {
+  if (typeof err !== "object" || err === null) return false;
+  if ("code" in err && err.code === "SQLITE_CONSTRAINT_FOREIGNKEY") return true;
+  return "message" in err && typeof err.message === "string" && err.message.includes("FOREIGN KEY constraint failed");
+}
+function grab(obj, field1, cb) {
+  if (obj == void 0 || !(field1 in obj)) return void 0;
+  const val = obj[field1];
+  if (val && typeof val === "object" && cb) {
+    return cb(val);
+  }
+  if (val === void 0) {
+    throw new Error(
+      "Session update failure: pass `null` to clear a field instead of `undefined`: " + JSON.stringify(obj)
+    );
+  }
+  return val;
+}
+function toPartialRow(info) {
+  const obj = {
+    id: grab(info, "id"),
+    project_id: grab(info, "projectID"),
+    workspace_id: grab(info, "workspaceID"),
+    parent_id: grab(info, "parentID"),
+    slug: grab(info, "slug"),
+    directory: grab(info, "directory"),
+    title: grab(info, "title"),
+    version: grab(info, "version"),
+    share_url: grab(info, "share", (v) => grab(v, "url")),
+    summary_additions: grab(info, "summary", (v) => grab(v, "additions")),
+    summary_deletions: grab(info, "summary", (v) => grab(v, "deletions")),
+    summary_files: grab(info, "summary", (v) => grab(v, "files")),
+    summary_diffs: grab(info, "summary", (v) => grab(v, "diffs")),
+    revert: grab(info, "revert"),
+    permission: grab(info, "permission"),
+    time_created: grab(info, "time", (v) => grab(v, "created")),
+    time_updated: grab(info, "time", (v) => grab(v, "updated")),
+    time_compacting: grab(info, "time", (v) => grab(v, "compacting")),
+    time_archived: grab(info, "time", (v) => grab(v, "archived"))
+  };
+  return Object.fromEntries(Object.entries(obj).filter(([_, val]) => val !== void 0));
+}
+var projectors_default = [
+  SyncEvent.project(Session.Event.Created, (db, data) => {
+    db.insert(SessionTable).values(Session.toRow(data.info)).run();
+  }),
+  SyncEvent.project(Session.Event.Updated, (db, data) => {
+    const info = data.info;
+    const row = db.update(SessionTable).set(toPartialRow(info)).where((0, db_exports.eq)(SessionTable.id, data.sessionID)).returning().get();
+    if (!row) throw new NotFoundError({ message: `Session not found: ${data.sessionID}` });
+  }),
+  SyncEvent.project(Session.Event.Deleted, (db, data) => {
+    db.delete(SessionTable).where((0, db_exports.eq)(SessionTable.id, data.sessionID)).run();
+  }),
+  SyncEvent.project(MessageV2.Event.Updated, (db, data) => {
+    const time_created = data.info.time.created;
+    const { id, sessionID, ...rest } = data.info;
+    try {
+      db.insert(MessageTable).values({
+        id,
+        session_id: sessionID,
+        time_created,
+        data: rest
+      }).onConflictDoUpdate({ target: MessageTable.id, set: { data: rest } }).run();
+    } catch (err) {
+      if (!foreign(err)) throw err;
+      log8.warn("ignored late message update", { messageID: id, sessionID });
+    }
+  }),
+  SyncEvent.project(MessageV2.Event.Removed, (db, data) => {
+    db.delete(MessageTable).where((0, db_exports.and)((0, db_exports.eq)(MessageTable.id, data.messageID), (0, db_exports.eq)(MessageTable.session_id, data.sessionID))).run();
+  }),
+  SyncEvent.project(MessageV2.Event.PartRemoved, (db, data) => {
+    db.delete(PartTable).where((0, db_exports.and)((0, db_exports.eq)(PartTable.id, data.partID), (0, db_exports.eq)(PartTable.session_id, data.sessionID))).run();
+  }),
+  SyncEvent.project(MessageV2.Event.PartUpdated, (db, data) => {
+    const { id, messageID, sessionID, ...rest } = data.part;
+    try {
+      db.insert(PartTable).values({
+        id,
+        message_id: messageID,
+        session_id: sessionID,
+        time_created: data.time,
+        data: rest
+      }).onConflictDoUpdate({ target: PartTable.id, set: { data: rest } }).run();
+    } catch (err) {
+      if (!foreign(err)) throw err;
+      log8.warn("ignored late part update", { partID: id, messageID, sessionID });
+    }
+  })
+];
+
+// packages/opencode/src/server/projectors.ts
+function initProjectors() {
+  SyncEvent.init({
+    projectors: projectors_default,
+    convertEvent: (type, data) => {
+      if (type === "session.updated") {
+        const id = data.sessionID;
+        const row = Database.use((db) => db.select().from(SessionTable).where((0, db_exports.eq)(SessionTable.id, id)).get());
+        if (!row) return data;
+        return {
+          sessionID: id,
+          info: Session.fromRow(row)
+        };
+      }
+      return data;
+    }
+  });
+}
+initProjectors();
+
+// packages/opencode/src/server/server.ts
+globalThis.AI_SDK_LOG_WARNINGS = false;
+initProjectors();
+var Server;
+((Server2) => {
+  const log9 = Log.create({ service: "server" });
+  const zipped = compress();
+  const skipCompress = (path, method) => {
+    if (path === "/event" || path === "/global/event" || path === "/global/sync-event") return true;
+    if (method === "POST" && /\/session\/[^/]+\/(message|prompt_async)$/.test(path)) return true;
+    return false;
+  };
+  Server2.Default = lazy(() => create({}).app);
+  function ControlPlaneRoutes(upgrade, app2 = new Hono17(), opts) {
+    return app2.onError(errorHandler(log9)).use((c, next) => {
+      if (c.req.method === "OPTIONS") return next();
+      const password = Flag.OPENCODE_SERVER_PASSWORD;
+      if (!password) return next();
+      const username = Flag.OPENCODE_SERVER_USERNAME ?? "opencode";
+      return basicAuth({ username, password })(c, next);
+    }).use(async (c, next) => {
+      const skip = c.req.path === "/log";
+      if (!skip) {
+        log9.info("request", {
+          method: c.req.method,
+          path: c.req.path
+        });
+      }
+      const timer = log9.time("request", {
+        method: c.req.method,
+        path: c.req.path
+      });
+      await next();
+      if (!skip) timer.stop();
+    }).use(
+      cors({
+        maxAge: 86400,
+        origin(input) {
+          if (!input) return;
+          if (input.startsWith("http://localhost:")) return input;
+          if (input.startsWith("http://127.0.0.1:")) return input;
+          if (input === "tauri://localhost" || input === "http://tauri.localhost" || input === "https://tauri.localhost")
+            return input;
+          if (/^https:\/\/([a-z0-9-]+\.)*opencode\.ai$/.test(input)) return input;
+          if (opts?.cors?.includes(input)) return input;
+        }
+      })
+    ).use((c, next) => {
+      if (skipCompress(c.req.path, c.req.method)) return next();
+      return zipped(c, next);
+    }).route("/global", GlobalRoutes()).put(
+      "/auth/:providerID",
+      describeRoute16({
+        summary: "Set auth credentials",
+        description: "Set authentication credentials",
+        operationId: "auth.set",
+        responses: {
+          200: {
+            description: "Successfully set authentication credentials",
+            content: {
+              "application/json": {
+                schema: resolver17(z21.boolean())
+              }
+            }
+          },
+          ...errors(400)
+        }
+      }),
+      validator15(
+        "param",
+        z21.object({
+          providerID: ProviderID.zod
+        })
+      ),
+      validator15("json", Auth.Info.zod),
+      async (c) => {
+        const providerID = c.req.valid("param").providerID;
+        const info = c.req.valid("json");
+        await Auth.set(providerID, info);
+        return c.json(true);
+      }
+    ).delete(
+      "/auth/:providerID",
+      describeRoute16({
+        summary: "Remove auth credentials",
+        description: "Remove authentication credentials",
+        operationId: "auth.remove",
+        responses: {
+          200: {
+            description: "Successfully removed authentication credentials",
+            content: {
+              "application/json": {
+                schema: resolver17(z21.boolean())
+              }
+            }
+          },
+          ...errors(400)
+        }
+      }),
+      validator15(
+        "param",
+        z21.object({
+          providerID: ProviderID.zod
+        })
+      ),
+      async (c) => {
+        const providerID = c.req.valid("param").providerID;
+        await Auth.remove(providerID);
+        return c.json(true);
+      }
+    ).get(
+      "/doc",
+      openAPIRouteHandler(app2, {
+        documentation: {
+          info: {
+            title: "opencode",
+            version: "0.0.3",
+            description: "opencode api"
+          },
+          openapi: "3.1.1"
+        }
+      })
+    ).use(
+      validator15(
+        "query",
+        z21.object({
+          directory: z21.string().optional(),
+          workspace: z21.string().optional()
+        })
+      )
+    ).post(
+      "/log",
+      describeRoute16({
+        summary: "Write log",
+        description: "Write a log entry to the server logs with specified level and metadata.",
+        operationId: "app.log",
+        responses: {
+          200: {
+            description: "Log entry written successfully",
+            content: {
+              "application/json": {
+                schema: resolver17(z21.boolean())
+              }
+            }
+          },
+          ...errors(400)
+        }
+      }),
+      validator15(
+        "json",
+        z21.object({
+          service: z21.string().meta({ description: "Service name for the log entry" }),
+          level: z21.enum(["debug", "info", "error", "warn"]).meta({ description: "Log level" }),
+          message: z21.string().meta({ description: "Log message" }),
+          extra: z21.record(z21.string(), z21.any()).optional().meta({ description: "Additional metadata for the log entry" })
+        })
+      ),
+      async (c) => {
+        const { service, level, message, extra } = c.req.valid("json");
+        const logger = Log.create({ service });
+        switch (level) {
+          case "debug":
+            logger.debug(message, extra);
+            break;
+          case "info":
+            logger.info(message, extra);
+            break;
+          case "error":
+            logger.error(message, extra);
+            break;
+          case "warn":
+            logger.warn(message, extra);
+            break;
+        }
+        return c.json(true);
+      }
+    ).use(WorkspaceRouterMiddleware(upgrade));
+  }
+  Server2.ControlPlaneRoutes = ControlPlaneRoutes;
+  function create(opts) {
+    const app2 = new Hono17();
+    const ws = createNodeWebSocket2({ app: app2 });
+    return {
+      app: ControlPlaneRoutes(ws.upgradeWebSocket, app2, opts),
+      ws
+    };
+  }
+  function createApp(opts) {
+    return create(opts).app;
+  }
+  Server2.createApp = createApp;
+  async function openapi() {
+    const { app: app2, ws } = create({});
+    InstanceRoutes(ws.upgradeWebSocket, app2);
+    const result = await generateSpecs(app2, {
+      documentation: {
+        info: {
+          title: "opencode",
+          version: "1.0.0",
+          description: "opencode api"
+        },
+        openapi: "3.1.1"
+      }
+    });
+    return result;
+  }
+  Server2.openapi = openapi;
+  async function listen(opts) {
+    const built = create(opts);
+    const start = (port) => new Promise((resolve, reject) => {
+      const server2 = createAdaptorServer({ fetch: built.app.fetch });
+      built.ws.injectWebSocket(server2);
+      const fail = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const ready = () => {
+        cleanup();
+        resolve(server2);
+      };
+      const cleanup = () => {
+        server2.off("error", fail);
+        server2.off("listening", ready);
+      };
+      server2.once("error", fail);
+      server2.once("listening", ready);
+      server2.listen(port, opts.hostname);
+    });
+    const server = opts.port === 0 ? await start(4096).catch(() => start(0)) : await start(opts.port);
+    const addr = server.address();
+    if (!addr || typeof addr === "string") {
+      throw new Error(`Failed to resolve server address for port ${opts.port}`);
+    }
+    const next = new URL("http://localhost");
+    next.hostname = opts.hostname;
+    next.port = String(addr.port);
+    Server2.url = next;
+    const mdns = opts.mdns && addr.port && opts.hostname !== "127.0.0.1" && opts.hostname !== "localhost" && opts.hostname !== "::1";
+    if (mdns) {
+      MDNS.publish(addr.port, opts.mdnsDomain);
+    } else if (opts.mdns) {
+      log9.warn("mDNS enabled but hostname is loopback; skipping mDNS publish");
+    }
+    let closing;
+    return {
+      hostname: opts.hostname,
+      port: addr.port,
+      url: next,
+      stop(close) {
+        closing ??= new Promise((resolve, reject) => {
+          if (mdns) MDNS.unpublish();
+          server.close((err) => {
+            if (err) {
+              reject(err);
+              return;
+            }
+            resolve();
+          });
+          if (close) {
+            if ("closeAllConnections" in server && typeof server.closeAllConnections === "function") {
+              server.closeAllConnections();
+            }
+            if ("closeIdleConnections" in server && typeof server.closeIdleConnections === "function") {
+              server.closeIdleConnections();
+            }
+          }
+        });
+        return closing;
+      }
+    };
+  }
+  Server2.listen = listen;
+})(Server || (Server = {}));
+
+export {
+  Server
+};
+//# sourceMappingURL=chunk-UWZSRZHA.js.map