alchemylab-opencode 1.0.7 → 1.0.9

package/packages/opencode/src/server/router.ts

@@ -1,105 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-import type { UpgradeWebSocket } from "hono/ws"
-import { getAdaptor } from "@/control-plane/adaptors"
-import { WorkspaceID } from "@/control-plane/schema"
-import { Workspace } from "@/control-plane/workspace"
-import { ServerProxy } from "./proxy"
-import { lazy } from "@/util/lazy"
-import { Filesystem } from "@/util/filesystem"
-import { Instance } from "@/project/instance"
-import { InstanceBootstrap } from "@/project/bootstrap"
-import { InstanceRoutes } from "./instance"
-
-type Rule = { method?: string; path: string; exact?: boolean; action: "local" | "forward" }
-
-const RULES: Array<Rule> = [
-  { path: "/session/status", action: "forward" },
-  { method: "GET", path: "/session", action: "local" },
-]
-
-function local(method: string, path: string) {
-  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
-}
-
-export function WorkspaceRouterMiddleware(upgrade: UpgradeWebSocket): MiddlewareHandler {
-  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")
-
-    // TODO: If session is being routed, force it to lookup the
-    // project/workspace
-
-    // If no workspace is provided we use the "project" 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)) {
-      // No instance provided because we are serving cached data; there
-      // is no instance to work with
-      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 headers = new Headers(c.req.raw.headers)
-    headers.delete("x-opencode-workspace")
-
-    return ServerProxy.http(
-      target,
-      new Request(c.req.raw, {
-        headers,
-      }),
-    )
-  }
-}

package/packages/opencode/src/server/routes/config.ts

@@ -1,92 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { Config } from "../../config/config"
-import { Provider } from "../../provider/provider"
-import { mapValues } from "remeda"
-import { errors } from "../error"
-import { Log } from "../../util/log"
-import { lazy } from "../../util/lazy"
-
-const log = Log.create({ service: "server" })
-
-export const ConfigRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/",
-      describeRoute({
-        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: resolver(Config.Info),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await Config.get())
-      },
-    )
-    .patch(
-      "/",
-      describeRoute({
-        summary: "Update configuration",
-        description: "Update OpenCode configuration settings and preferences.",
-        operationId: "config.update",
-        responses: {
-          200: {
-            description: "Successfully updated config",
-            content: {
-              "application/json": {
-                schema: resolver(Config.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Config.Info),
-      async (c) => {
-        const config = c.req.valid("json")
-        await Config.update(config)
-        return c.json(config)
-      },
-    )
-    .get(
-      "/providers",
-      describeRoute({
-        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: resolver(
-                  z.object({
-                    providers: Provider.Info.array(),
-                    default: z.record(z.string(), z.string()),
-                  }),
-                ),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        using _ = log.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),
-        })
-      },
-    ),
-)

package/packages/opencode/src/server/routes/event.ts

@@ -1,83 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, resolver } from "hono-openapi"
-import { streamSSE } from "hono/streaming"
-import { Log } from "@/util/log"
-import { BusEvent } from "@/bus/bus-event"
-import { Bus } from "@/bus"
-import { AsyncQueue } from "../../util/queue"
-
-const log = Log.create({ service: "server" })
-
-export const EventRoutes = () =>
-  new Hono().get(
-    "/event",
-    describeRoute({
-      summary: "Subscribe to events",
-      description: "Get events",
-      operationId: "event.subscribe",
-      responses: {
-        200: {
-          description: "Event stream",
-          content: {
-            "text/event-stream": {
-              schema: resolver(BusEvent.payloads()),
-            },
-          },
-        },
-      },
-    }),
-    async (c) => {
-      log.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 (stream) => {
-        const q = new AsyncQueue<string | null>()
-        let done = false
-
-        q.push(
-          JSON.stringify({
-            type: "server.connected",
-            properties: {},
-          }),
-        )
-
-        // Send heartbeat every 10s to prevent stalled proxy streams.
-        const heartbeat = setInterval(() => {
-          q.push(
-            JSON.stringify({
-              type: "server.heartbeat",
-              properties: {},
-            }),
-          )
-        }, 10_000)
-
-        const stop = () => {
-          if (done) return
-          done = true
-          clearInterval(heartbeat)
-          unsub()
-          q.push(null)
-          log.info("event disconnected")
-        }
-
-        const unsub = Bus.subscribeAll((event) => {
-          q.push(JSON.stringify(event))
-          if (event.type === Bus.InstanceDisposed.type) {
-            stop()
-          }
-        })
-
-        stream.onAbort(stop)
-
-        try {
-          for await (const data of q) {
-            if (data === null) return
-            await stream.writeSSE({ data })
-          }
-        } finally {
-          stop()
-        }
-      })
-    },
-  )

package/packages/opencode/src/server/routes/experimental.ts

@@ -1,374 +0,0 @@
-import { Hono } from "hono"
-import { describeRoute, validator, resolver } from "hono-openapi"
-import z from "zod"
-import { ProviderID, ModelID } from "../../provider/schema"
-import { ToolRegistry } from "../../tool/registry"
-import { Worktree } from "../../worktree"
-import { Instance } from "../../project/instance"
-import { Project } from "../../project/project"
-import { MCP } from "../../mcp"
-import { Session } from "../../session"
-import { Config } from "../../config/config"
-import { ConsoleState } from "../../config/console-state"
-import { Account, AccountID, OrgID } from "../../account"
-import { zodToJsonSchema } from "zod-to-json-schema"
-import { errors } from "../error"
-import { lazy } from "../../util/lazy"
-import { WorkspaceRoutes } from "./workspace"
-
-const ConsoleOrgOption = z.object({
-  accountID: z.string(),
-  accountEmail: z.string(),
-  accountUrl: z.string(),
-  orgID: z.string(),
-  orgName: z.string(),
-  active: z.boolean(),
-})
-
-const ConsoleOrgList = z.object({
-  orgs: z.array(ConsoleOrgOption),
-})
-
-const ConsoleSwitchBody = z.object({
-  accountID: z.string(),
-  orgID: z.string(),
-})
-
-export const ExperimentalRoutes = lazy(() =>
-  new Hono()
-    .get(
-      "/console",
-      describeRoute({
-        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: resolver(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",
-      describeRoute({
-        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: resolver(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",
-      describeRoute({
-        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: resolver(z.boolean()),
-              },
-            },
-          },
-        },
-      }),
-      validator("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",
-      describeRoute({
-        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: resolver(z.array(z.string()).meta({ ref: "ToolIDs" })),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      async (c) => {
-        return c.json(await ToolRegistry.ids())
-      },
-    )
-    .get(
-      "/tool",
-      describeRoute({
-        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: resolver(
-                  z
-                    .array(
-                      z
-                        .object({
-                          id: z.string(),
-                          description: z.string(),
-                          parameters: z.any(),
-                        })
-                        .meta({ ref: "ToolListItem" }),
-                    )
-                    .meta({ ref: "ToolList" }),
-                ),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          provider: z.string(),
-          model: z.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 as any)?._def ? zodToJsonSchema(t.parameters as any) : t.parameters,
-          })),
-        )
-      },
-    )
-    .route("/workspace", WorkspaceRoutes())
-    .post(
-      "/worktree",
-      describeRoute({
-        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: resolver(Worktree.Info),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Worktree.CreateInput.optional()),
-      async (c) => {
-        const body = c.req.valid("json")
-        const worktree = await Worktree.create(body)
-        return c.json(worktree)
-      },
-    )
-    .get(
-      "/worktree",
-      describeRoute({
-        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: resolver(z.array(z.string())),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const sandboxes = await Project.sandboxes(Instance.project.id)
-        return c.json(sandboxes)
-      },
-    )
-    .delete(
-      "/worktree",
-      describeRoute({
-        summary: "Remove worktree",
-        description: "Remove a git worktree and delete its branch.",
-        operationId: "worktree.remove",
-        responses: {
-          200: {
-            description: "Worktree removed",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("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",
-      describeRoute({
-        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: resolver(z.boolean()),
-              },
-            },
-          },
-          ...errors(400),
-        },
-      }),
-      validator("json", Worktree.ResetInput),
-      async (c) => {
-        const body = c.req.valid("json")
-        await Worktree.reset(body)
-        return c.json(true)
-      },
-    )
-    .get(
-      "/session",
-      describeRoute({
-        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: resolver(Session.GlobalInfo.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          directory: z.string().optional().meta({ description: "Filter sessions by project directory" }),
-          roots: z.coerce.boolean().optional().meta({ description: "Only return root sessions (no parentID)" }),
-          start: z.coerce
-            .number()
-            .optional()
-            .meta({ description: "Filter sessions updated on or after this timestamp (milliseconds since epoch)" }),
-          cursor: z.coerce
-            .number()
-            .optional()
-            .meta({ description: "Return sessions updated before this timestamp (milliseconds since epoch)" }),
-          search: z.string().optional().meta({ description: "Filter sessions by title (case-insensitive)" }),
-          limit: z.coerce.number().optional().meta({ description: "Maximum number of sessions to return" }),
-          archived: z.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: Session.GlobalInfo[] = []
-        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",
-      describeRoute({
-        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: resolver(z.record(z.string(), MCP.Resource)),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await MCP.resources())
-      },
-    ),
-)