@toolkit-cli/toolkode 1.3.8 → 1.3.10

package/src/server/instance.ts

@@ -1,285 +0,0 @@
-import { describeRoute, resolver } from "hono-openapi"
-import { Hono } from "hono"
-import { proxy } from "hono/proxy"
-import z from "zod"
-import { createHash } from "node:crypto"
-import { Log } from "../util/log"
-import { Format } from "../format"
-import { TuiRoutes } from "./routes/tui"
-import { Instance } from "../project/instance"
-import { Vcs } from "../project/vcs"
-import { Agent } from "../agent/agent"
-import { Skill } from "../skill"
-import { Global } from "../global"
-import { LSP } from "../lsp"
-import { Command } from "../command"
-import { Flag } from "../flag/flag"
-import { QuestionRoutes } from "./routes/question"
-import { PermissionRoutes } from "./routes/permission"
-import { ProjectRoutes } from "./routes/project"
-import { SessionRoutes } from "./routes/session"
-import { PtyRoutes } from "./routes/pty"
-import { McpRoutes } from "./routes/mcp"
-import { FileRoutes } from "./routes/file"
-import { ConfigRoutes } from "./routes/config"
-import { ExperimentalRoutes } from "./routes/experimental"
-import { ProviderRoutes } from "./routes/provider"
-import { EventRoutes } from "./routes/event"
-import { errorHandler } from "./middleware"
-
-const log = Log.create({ service: "server" })
-
-const 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 as Record<string, string>).catch(() => null)
-
-const 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:"
-
-const 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:`
-
-export const InstanceRoutes = (app?: Hono) =>
-  (app ?? new Hono())
-    .onError(errorHandler(log))
-    .route("/project", ProjectRoutes())
-    .route("/pty", PtyRoutes())
-    .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",
-      describeRoute({
-        summary: "Dispose instance",
-        description: "Clean up and dispose the current Toolkode instance, releasing all resources.",
-        operationId: "instance.dispose",
-        responses: {
-          200: {
-            description: "Instance disposed",
-            content: {
-              "application/json": {
-                schema: resolver(z.boolean()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        await Instance.dispose()
-        return c.json(true)
-      },
-    )
-    .get(
-      "/path",
-      describeRoute({
-        summary: "Get paths",
-        description: "Retrieve the current working directory and related path information for the Toolkode instance.",
-        operationId: "path.get",
-        responses: {
-          200: {
-            description: "Path",
-            content: {
-              "application/json": {
-                schema: resolver(
-                  z
-                    .object({
-                      home: z.string(),
-                      state: z.string(),
-                      config: z.string(),
-                      worktree: z.string(),
-                      directory: z.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",
-      describeRoute({
-        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: resolver(Vcs.Info),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const branch = await Vcs.branch()
-        return c.json({
-          branch,
-        })
-      },
-    )
-    .get(
-      "/command",
-      describeRoute({
-        summary: "List commands",
-        description: "Get a list of all available commands in the Toolkode system.",
-        operationId: "command.list",
-        responses: {
-          200: {
-            description: "List of commands",
-            content: {
-              "application/json": {
-                schema: resolver(Command.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const commands = await Command.list()
-        return c.json(commands)
-      },
-    )
-    .get(
-      "/agent",
-      describeRoute({
-        summary: "List agents",
-        description: "Get a list of all available AI agents in the Toolkode system.",
-        operationId: "app.agents",
-        responses: {
-          200: {
-            description: "List of agents",
-            content: {
-              "application/json": {
-                schema: resolver(Agent.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const modes = await Agent.list()
-        return c.json(modes)
-      },
-    )
-    .get(
-      "/skill",
-      describeRoute({
-        summary: "List skills",
-        description: "Get a list of all available skills in the Toolkode system.",
-        operationId: "app.skills",
-        responses: {
-          200: {
-            description: "List of skills",
-            content: {
-              "application/json": {
-                schema: resolver(Skill.Info.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        const skills = await Skill.all()
-        return c.json(skills)
-      },
-    )
-    .get(
-      "/lsp",
-      describeRoute({
-        summary: "Get LSP status",
-        description: "Get LSP server status",
-        operationId: "lsp.status",
-        responses: {
-          200: {
-            description: "LSP server status",
-            content: {
-              "application/json": {
-                schema: resolver(LSP.Status.array()),
-              },
-            },
-          },
-        },
-      }),
-      async (c) => {
-        return c.json(await LSP.status())
-      },
-    )
-    .get(
-      "/formatter",
-      describeRoute({
-        summary: "Get formatter status",
-        description: "Get formatter status",
-        operationId: "formatter.status",
-        responses: {
-          200: {
-            description: "Formatter status",
-            content: {
-              "application/json": {
-                schema: resolver(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 file = Bun.file(match)
-        if (await file.exists()) {
-          c.header("Content-Type", file.type)
-          if (file.type.startsWith("text/html")) {
-            c.header("Content-Security-Policy", DEFAULT_CSP)
-          }
-          return c.body(await file.arrayBuffer())
-        } else {
-          return c.json({ error: "Not Found" }, 404)
-        }
-      } else {
-        const response = await proxy(`https://app.toolkode.com${path}`, {
-          ...c.req,
-          headers: {
-            ...c.req.raw.headers,
-            host: "app.toolkode.com",
-          },
-        })
-        const match = response.headers.get("content-type")?.includes("text/html")
-          ? (await response.clone().text()).match(
-              /<script\b(?![^>]*\bsrc\s*=)[^>]*\bid=(['"])oc-theme-preload-script\1[^>]*>([\s\S]*?)<\/script>/i,
-            )
-          : undefined
-        const hash = match ? createHash("sha256").update(match[2]).digest("base64") : ""
-        response.headers.set("Content-Security-Policy", csp(hash))
-        return response
-      }
-    })

package/src/server/mdns.ts

@@ -1,60 +0,0 @@
-import { Log } from "@/util/log"
-import { Bonjour } from "bonjour-service"
-
-const log = Log.create({ service: "mdns" })
-
-export namespace MDNS {
-  let bonjour: Bonjour | undefined
-  let currentPort: number | undefined
-
-  export function publish(port: number, domain?: string) {
-    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", () => {
-        log.info("mDNS service published", { name, port })
-      })
-
-      service.on("error", (err) => {
-        log.error("mDNS service error", { error: err })
-      })
-
-      currentPort = port
-    } catch (err) {
-      log.error("mDNS publish failed", { error: err })
-      if (bonjour) {
-        try {
-          bonjour.destroy()
-        } catch {}
-      }
-      bonjour = undefined
-      currentPort = undefined
-    }
-  }
-
-  export function unpublish() {
-    if (bonjour) {
-      try {
-        bonjour.unpublishAll()
-        bonjour.destroy()
-      } catch (err) {
-        log.error("mDNS unpublish failed", { error: err })
-      }
-      bonjour = undefined
-      currentPort = undefined
-      log.info("mDNS service unpublished")
-    }
-  }
-}

package/src/server/middleware.ts

@@ -1,29 +0,0 @@
-import { Provider } from "../provider/provider"
-import { NamedError } from "@toolkit-cli/util/error"
-import { NotFoundError } from "../storage/db"
-import type { ContentfulStatusCode } from "hono/utils/http-status"
-import type { ErrorHandler } from "hono"
-import { HTTPException } from "hono/http-exception"
-import type { Log } from "../util/log"
-
-export function errorHandler(log: Log.Logger): ErrorHandler {
-  return (err, c) => {
-    log.error("failed", {
-      error: err,
-    })
-    if (err instanceof NamedError) {
-      let status: ContentfulStatusCode
-      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 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,
-    })
-  }
-}

package/src/server/projectors.ts

@@ -1,28 +0,0 @@
-import z from "zod"
-import sessionProjectors from "../session/projectors"
-import { SyncEvent } from "@/sync"
-import { Session } from "@/session"
-import { SessionTable } from "@/session/session.sql"
-import { Database, eq } from "@/storage/db"
-
-export function initProjectors() {
-  SyncEvent.init({
-    projectors: sessionProjectors,
-    convertEvent: (type, data) => {
-      if (type === "session.updated") {
-        const id = (data as z.infer<typeof Session.Event.Updated.schema>).sessionID
-        const row = Database.use((db) => db.select().from(SessionTable).where(eq(SessionTable.id, id)).get())
-
-        if (!row) return data
-
-        return {
-          sessionID: id,
-          info: Session.fromRow(row),
-        }
-      }
-      return data
-    },
-  })
-}
-
-initProjectors()

package/src/server/router.ts

@@ -1,99 +0,0 @@
-import type { MiddlewareHandler } from "hono"
-import { getAdaptor } from "@/control-plane/adaptors"
-import { WorkspaceID } from "@/control-plane/schema"
-import { Workspace } from "@/control-plane/workspace"
-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
-}
-
-const routes = lazy(() => InstanceRoutes())
-
-export const WorkspaceRouterMiddleware: MiddlewareHandler = 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")
-
-  // 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",
-      },
-    })
-  }
-
-  // Handle local workspaces directly so we can pass env to `fetch`,
-  // necessary for websocket upgrades
-  if (workspace.type === "worktree") {
-    return Instance.provide({
-      directory: workspace.directory!,
-      init: InstanceBootstrap,
-      async fn() {
-        return routes().fetch(c.req.raw, c.env)
-      },
-    })
-  }
-
-  // Remote workspaces
-
-  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)
-  }
-
-  const adaptor = await getAdaptor(workspace.type)
-  const headers = new Headers(c.req.raw.headers)
-  headers.delete("x-opencode-workspace")
-
-  return adaptor.fetch(workspace, `${url.pathname}${url.search}`, {
-    method: c.req.method,
-    body: c.req.method === "GET" || c.req.method === "HEAD" ? undefined : await c.req.raw.arrayBuffer(),
-    signal: c.req.raw.signal,
-    headers,
-  })
-}

package/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 Toolkode 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 Toolkode 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/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()
-        }
-      })
-    },
-  )