alchemylab-opencode 1.0.7 → 1.0.8

package/packages/opencode/src/run.ts

@@ -1,28 +0,0 @@
-/**
- * Minimal Node.js-compatible entry point for `opencode run --attach`.
- * Only imports the run command path — avoids TUI .tsx imports.
- *
- * Usage:
- *   node --experimental-strip-types --experimental-transform-types \
- *        --import ./src/node-preload.mjs \
- *        src/run.ts --attach http://127.0.0.1:PORT --session SESSION_ID --agent AGENT [prompt]
- */
-
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-
-// Set data directory before any module imports Global.Path
-const defaultDataDir = join(homedir(), '.alchemy_lab', 'opencode')
-process.env.OPENCODE_DATA_DIR = process.env.OPENCODE_DATA_DIR || defaultDataDir
-
-const { RunCommand } = await import('./cli/cmd/run')
-
-// RunCommand is a yargs command module — invoke it directly
-const yargs = (await import('yargs')).default
-const { hideBin } = await import('yargs/helpers')
-
-yargs(hideBin(process.argv))
-  .command(RunCommand as any)
-  .strict()
-  .help()
-  .parse()

package/packages/opencode/src/serve.ts

@@ -1,45 +0,0 @@
-/**
- * Minimal Node.js-compatible entry point for `opencode serve`.
- * Only imports the serve path — avoids TUI/CLI dependencies that require Bun.
- *
- * Usage:
- *   node --experimental-strip-types --experimental-transform-types \
- *        --import ./src/node-preload.mjs \
- *        src/serve.ts --port 4096 [--hostname 127.0.0.1] [--data-dir /path/to/.alchemy_lab]
- */
-
-function arg(name: string, fallback: string): string {
-  const idx = process.argv.indexOf(`--${name}`)
-  return idx !== -1 && process.argv[idx + 1] ? process.argv[idx + 1] : fallback
-}
-
-// Set data directory before any module imports Global.Path
-import { homedir } from 'node:os'
-import { join } from 'node:path'
-const defaultDataDir = join(homedir(), '.alchemy_lab', 'opencode')
-const dataDir = arg('data-dir', defaultDataDir)
-process.env.OPENCODE_DATA_DIR = dataDir
-
-// Now safe to import the server
-const { Server } = await import("./server/server")
-
-const port = parseInt(arg('port', '4096'), 10)
-const hostname = arg('hostname', '127.0.0.1')
-
-try {
-  const server = await Server.listen({ port, hostname })
-  console.log(`opencode server listening on http://${server.hostname}:${server.port}`)
-
-  const shutdown = async () => {
-    await server.stop(true)
-    process.exit(0)
-  }
-  process.on('SIGINT', shutdown)
-  process.on('SIGTERM', shutdown)
-
-  // Keep process alive
-  await new Promise(() => {})
-} catch (err) {
-  console.error('Failed to start server:', err)
-  process.exit(1)
-}

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

@@ -1,36 +0,0 @@
-import { resolver } from "hono-openapi"
-import z from "zod"
-import { NotFoundError } from "../storage/db"
-
-export const ERRORS = {
-  400: {
-    description: "Bad request",
-    content: {
-      "application/json": {
-        schema: resolver(
-          z
-            .object({
-              data: z.any(),
-              errors: z.array(z.record(z.string(), z.any())),
-              success: z.literal(false),
-            })
-            .meta({
-              ref: "BadRequestError",
-            }),
-        ),
-      },
-    },
-  },
-  404: {
-    description: "Not found",
-    content: {
-      "application/json": {
-        schema: resolver(NotFoundError.Schema),
-      },
-    },
-  },
-} as const
-
-export function errors(...codes: number[]) {
-  return Object.fromEntries(codes.map((code) => [code, ERRORS[code as keyof typeof ERRORS]]))
-}

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

@@ -1,7 +0,0 @@
-import { BusEvent } from "@/bus/bus-event"
-import z from "zod"
-
-export const Event = {
-  Connected: BusEvent.define("server.connected", z.object({})),
-  Disposed: BusEvent.define("global.disposed", z.object({})),
-}

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

@@ -1,324 +0,0 @@
-import { describeRoute, resolver, validator } from "hono-openapi"
-import { Hono } from "hono"
-import { proxy } from "hono/proxy"
-import type { UpgradeWebSocket } from "hono/ws"
-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 { Snapshot } from "@/snapshot"
-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 = (upgrade: UpgradeWebSocket, app: Hono = new Hono()) =>
-  app
-    .onError(errorHandler(log))
-    .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",
-      describeRoute({
-        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: 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 OpenCode 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, default_branch] = await Promise.all([Vcs.branch(), Vcs.defaultBranch()])
-        return c.json({
-          branch,
-          default_branch,
-        })
-      },
-    )
-    .get(
-      "/vcs/diff",
-      describeRoute({
-        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: resolver(Snapshot.FileDiff.array()),
-              },
-            },
-          },
-        },
-      }),
-      validator(
-        "query",
-        z.object({
-          mode: Vcs.Mode,
-        }),
-      ),
-      async (c) => {
-        return c.json(await Vcs.diff(c.req.valid("query").mode))
-      },
-    )
-    .get(
-      "/command",
-      describeRoute({
-        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: 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 OpenCode 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 OpenCode 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 fs = await import("fs")
-        const pathMod = await import("path")
-        try {
-          const content = fs.readFileSync(match)
-          const ext = pathMod.extname(match).toLowerCase()
-          const mimeTypes: Record<string, string> = {
-            '.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 as any)
-        } catch {
-          return c.json({ error: "Not Found" }, 404)
-        }
-      } else {
-        const response = await proxy(`https://app.opencode.ai${path}`, {
-          ...c.req,
-          headers: {
-            ...c.req.raw.headers,
-            host: "app.opencode.ai",
-          },
-        })
-        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/packages/opencode/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/packages/opencode/src/server/middleware.ts

@@ -1,33 +0,0 @@
-import { Provider } from "../provider/provider"
-import { NamedError } from "@opencode-ai/util/error"
-import { NotFoundError } from "../storage/db"
-import { Session } from "../session"
-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 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,
-    })
-  }
-}

package/packages/opencode/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/packages/opencode/src/server/proxy.ts

@@ -1,131 +0,0 @@
-import type { Target } from "@/control-plane/types"
-import { lazy } from "@/util/lazy"
-import { Hono } from "hono"
-import { createNodeWebSocket } from "@hono/node-ws"
-const { upgradeWebSocket } = createNodeWebSocket({ app: new Hono() as any })
-
-const hop = new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "proxy-connection",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "host",
-])
-
-type Msg = string | ArrayBuffer | Uint8Array
-
-function headers(req: Request, extra?: HeadersInit) {
-  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: Request) {
-  const value = req.headers.get("sec-websocket-protocol")
-  if (!value) return []
-  return value
-    .split(",")
-    .map((item) => item.trim())
-    .filter(Boolean)
-}
-
-function socket(url: string | 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: { send(data: string | ArrayBuffer | Uint8Array): void }, data: any) {
-  if (data instanceof Blob) {
-    return data.arrayBuffer().then((x) => ws.send(x))
-  }
-  return ws.send(data)
-}
-
-const app = lazy(() =>
-  new Hono().get(
-    "/__workspace_ws",
-    upgradeWebSocket((c) => {
-      const url = c.req.header("x-opencode-proxy-url")
-      const queue: Msg[] = []
-      let remote: WebSocket | undefined
-      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)
-        },
-      }
-    }),
-  ),
-)
-
-export namespace ServerProxy {
-  export function http(target: Extract<Target, { type: "remote" }>, req: Request) {
-    return fetch(
-      new Request(target.url, {
-        method: req.method,
-        headers: headers(req, target.headers),
-        body: req.method === "GET" || req.method === "HEAD" ? undefined : req.body,
-        redirect: "manual",
-        signal: req.signal,
-      }),
-    )
-  }
-
-  export function websocket(target: Extract<Target, { type: "remote" }>, req: Request, env: unknown) {
-    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 as never,
-    )
-  }
-}