refactor(server): canonicalize service API (#31049)

packages/cli/bunfig.toml

@@ -0,0 +1 @@
+preload = ["@opentui/solid/preload"]

packages/cli/package.json

@@ -20,8 +20,12 @@
     "@opencode-ai/core": "workspace:*",
     "@opencode-ai/sdk": "workspace:*",
     "@opencode-ai/server": "workspace:*",
+    "@opencode-ai/tui": "workspace:*",
+    "@opentui/core": "catalog:",
+    "@opentui/solid": "catalog:",
     "@parcel/watcher": "2.5.1",
-    "effect": "catalog:"
+    "effect": "catalog:",
+    "solid-js": "catalog:"
   },
   "devDependencies": {
     "@opencode-ai/script": "workspace:*",

packages/cli/script/build.ts

@@ -1,8 +1,12 @@
 #!/usr/bin/env bun
 
+import { $ } from "bun"
+import fs from "fs"
 import { rm } from "fs/promises"
 import path from "path"
 import { Script } from "@opencode-ai/script"
+import { createSolidTransformPlugin } from "@opentui/solid/bun-plugin"
+import pkg from "../package.json"
 import { modelsData } from "./generate"
 
 const dir = path.resolve(import.meta.dirname, "..")
@@ -13,7 +17,9 @@ await rm("dist", { recursive: true, force: true })
 
 const singleFlag = process.argv.includes("--single")
 const baselineFlag = process.argv.includes("--baseline")
+const skipInstall = process.argv.includes("--skip-install")
 const sourcemapsFlag = process.argv.includes("--sourcemaps")
+const plugin = createSolidTransformPlugin()
 
 const allTargets: {
   os: string
@@ -43,6 +49,12 @@ const targets = singleFlag
     })
   : allTargets
 
+if (!skipInstall) await $`bun install --os="*" --cpu="*" @opentui/core@${pkg.dependencies["@opentui/core"]}`
+
+const localParserWorker = path.resolve(dir, "node_modules/@opentui/core/parser.worker.js")
+const rootParserWorker = path.resolve(dir, "../../node_modules/@opentui/core/parser.worker.js")
+const parserWorker = fs.realpathSync(fs.existsSync(localParserWorker) ? localParserWorker : rootParserWorker)
+
 for (const item of targets) {
   const target = [
     binary,
@@ -56,8 +68,9 @@ for (const item of targets) {
   const name = target.replace(binary, "cli")
   console.log(`building ${name}`)
   const result = await Bun.build({
-    entrypoints: ["./src/index.ts"],
+    entrypoints: ["./src/index.ts", parserWorker],
     tsconfig: "./tsconfig.json",
+    plugins: [plugin],
     external: ["node-gyp"],
     format: "esm",
     minify: true,
@@ -79,6 +92,11 @@ for (const item of targets) {
       OPENCODE_MODELS_DEV: modelsData,
       OPENCODE_CHANNEL: `'${Script.channel}'`,
       OPENCODE_LIBC: item.os === "linux" ? `'${item.abi ?? "glibc"}'` : "undefined",
+      OTUI_TREE_SITTER_WORKER_PATH:
+        (item.os === "win32" ? '"B:/~BUN/root/' : '"/$bunfs/root/') +
+        path.relative(dir, parserWorker).replaceAll("\\", "/") +
+        '"',
+      ...(item.os === "linux" ? { "process.env.OPENTUI_LIBC": JSON.stringify(item.abi ?? "glibc") } : {}),
     },
   })
 

packages/cli/src/commands/handlers/default.ts

@@ -0,0 +1,13 @@
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { Effect } from "effect"
+import { Daemon } from "../../services/daemon"
+
+export default Runtime.handler(Commands, () =>
+  Effect.gen(function* () {
+    const daemon = yield* Daemon.Service
+    const transport = yield* daemon.transport()
+    const { runTui } = yield* Effect.promise(() => import("../../tui"))
+    yield* Effect.promise(() => runTui(transport))
+  }),
+)

packages/cli/src/commands/handlers/serve.ts

@@ -1,4 +1,5 @@
 import { NodeHttpServer } from "@effect/platform-node"
+import { PermissionSaved } from "@opencode-ai/core/permission/saved"
 import { Context, Layer, Option } from "effect"
 import * as Effect from "effect/Effect"
 import { HttpRouter, HttpServer } from "effect/unstable/http"
@@ -34,6 +35,7 @@ function bind(hostname: string, port: number, password: string) {
   return Layer.build(
     HttpRouter.serve(createRoutes(password), { disableListenLog: true, disableLogger: true }).pipe(
       Layer.provideMerge(NodeHttpServer.layer(() => createServer(), { port, host: hostname })),
+      Layer.provide(PermissionSaved.defaultLayer),
     ),
   ).pipe(Effect.map((context) => Context.get(context, HttpServer.HttpServer).address))
 }

packages/cli/src/framework/runtime.ts

@@ -60,19 +60,19 @@ export function run(commands: Spec.Any, handlers: ReadonlyArray<LazyHandler>, op
 }
 
 function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): ProvidedCommand {
-  const spec: Command.Command.Any = Object.keys(node.commands).length
-    ? (node.spec as Command.Command<string, unknown>).pipe(
-        Command.withSubcommands(Object.values(node.commands).map((child) => provide(child, handlers))),
+  const handler = handlers.find((handler) => handler.spec === node.spec)
+  const spec = handler
+    ? node.spec.pipe(
+        Command.withHandler((input) =>
+          Effect.gen(function* () {
+            yield* Effect.flatMap(Effect.promise(handler.load), (module) => module.default(input))
+          }),
+        ),
       )
     : node.spec
-  const handler = handlers.find((handler) => handler.spec === node.spec)
-  if (!handler) return spec as ProvidedCommand
+  if (!Object.keys(node.commands).length) return spec as ProvidedCommand
   return spec.pipe(
-    Command.withHandler((input) =>
-      Effect.gen(function* () {
-        yield* Effect.flatMap(Effect.promise(handler.load), (module) => module.default(input))
-      }),
-    ),
+    Command.withSubcommands(Object.values(node.commands).map((child) => provide(child, handlers))),
   ) as ProvidedCommand
 }
 

packages/cli/src/index.ts

@@ -8,6 +8,7 @@ import { Runtime } from "./framework/runtime"
 import { Daemon } from "./services/daemon"
 
 const Handlers = Runtime.handlers(Commands, {
+  $: () => import("./commands/handlers/default"),
   debug: {
     agents: () => import("./commands/handlers/debug/agents"),
   },

packages/cli/src/services/daemon.ts

@@ -5,10 +5,12 @@ import { ServerAuth } from "@opencode-ai/server/auth"
 import { Context, Effect, FileSystem, Layer, Option, Schedule, Schema, Scope } from "effect"
 import { HttpServer } from "effect/unstable/http"
 import { randomBytes, randomUUID } from "crypto"
+import { spawn } from "node:child_process"
 import path from "path"
 
 export interface Interface {
   readonly client: () => Effect.Effect<ReturnType<typeof createOpencodeClient>, unknown>
+  readonly transport: () => Effect.Effect<{ url: string; headers: RequestInit["headers"] }, unknown>
   readonly start: () => Effect.Effect<string, Error>
   readonly status: () => Effect.Effect<string | undefined>
   readonly stop: () => Effect.Effect<void, unknown>
@@ -108,16 +110,20 @@ export const layer = Layer.effect(
     const start = Effect.fn("cli.daemon.start")(function* () {
       const existing = yield* healthy().pipe(Effect.option)
       const found = Option.getOrUndefined(existing)
-      if (found?.version === InstallationVersion) return found.url
+      const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
+      if (found?.version === InstallationVersion && compiled) return found.url
       if (found) yield* stopProcess(found).pipe(Effect.ignore)
 
-      yield* Effect.sync(() => {
-        const compiled = path.basename(process.execPath).replace(/\.exe$/, "") !== "bun"
-        Bun.spawn([process.execPath, ...(compiled ? [] : [Bun.main]), "serve", "--register"], {
-          stdin: "ignore",
-          stdout: "ignore",
-          stderr: "ignore",
-        }).unref()
+      const entrypoint = compiled ? undefined : process.argv[1]
+      if (!compiled && entrypoint === undefined) return yield* Effect.fail(new Error("Failed to resolve CLI entrypoint"))
+      yield* Effect.try({
+        try: () => {
+          spawn(process.execPath, [...(entrypoint ? [entrypoint] : []), "serve", "--register"], {
+            detached: true,
+            stdio: "ignore",
+          }).unref()
+        },
+        catch: (cause) => new Error("Failed to start server", { cause }),
       })
 
       return yield* compatible().pipe(
@@ -127,8 +133,13 @@ export const layer = Layer.effect(
       )
     })
 
+    const transport = Effect.fn("cli.daemon.transport")(function* () {
+      return { url: yield* start(), headers: ServerAuth.headers({ password: yield* password() }) }
+    })
+
     const client = Effect.fn("cli.daemon.client")(function* () {
-      return yield* createClient(yield* start())
+      const connection = yield* transport()
+      return createOpencodeClient({ baseUrl: connection.url, headers: connection.headers })
     })
 
     const status = Effect.fn("cli.daemon.status")(function* () {
@@ -173,7 +184,7 @@ export const layer = Layer.effect(
       )
     })
 
-    return Service.of({ client, start, status, stop, password, register })
+    return Service.of({ client, transport, start, status, stop, password, register })
   }),
 )
 

packages/cli/src/tui.ts

@@ -0,0 +1,115 @@
+import { createTuiBuildInfo, createTuiEnvironment, createTuiRenderer, run, type TuiHost } from "@opencode-ai/tui"
+import { TuiConfig } from "@opencode-ai/tui/config"
+import type { TuiPlatform } from "@opencode-ai/tui/platform"
+import os from "node:os"
+import path from "node:path"
+
+declare const OPENCODE_VERSION: string | undefined
+declare const OPENCODE_CHANNEL: string | undefined
+
+export async function runTui(transport: { url: string; headers: RequestInit["headers"] }) {
+  const config = TuiConfig.resolve({}, { terminalSuspend: false })
+  const state = path.join(os.homedir(), ".local", "state", "opencode")
+  const environment = createTuiEnvironment({
+    cwd: process.cwd(),
+    platform: process.platform,
+    paths: {
+      home: os.homedir(),
+      state,
+      worktree: path.join(state, "worktree"),
+    },
+    capabilities: {
+      mouse: config.mouse,
+      copyOnSelect: true,
+      terminalTitle: true,
+      terminalSuspend: false,
+      workspaces: false,
+      showTimeToFirstDraw: false,
+    },
+    terminal: {
+      multiplexer: process.env.TMUX ? "tmux" : process.env.STY ? "screen" : undefined,
+      displayServer: process.env.WAYLAND_DISPLAY ? "wayland" : process.env.DISPLAY ? "x11" : undefined,
+    },
+    editor: { zedTerminal: false },
+    skipInitialLoading: false,
+  })
+  const build = createTuiBuildInfo({
+    version: typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local",
+    channel: typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local",
+  })
+  const renderer = await createTuiRenderer(config, { environment, build })
+  const handle = run({
+    ...transport,
+    args: {},
+    config,
+    environment,
+    build,
+    renderer,
+    fetch: gracefulFetch,
+    pluginHost: {
+      async start() {},
+      async dispose() {},
+    },
+    host: createHost(),
+  })
+  await handle.done
+}
+
+function createHost(): TuiHost {
+  return {
+    platform,
+    attention() {
+      return {
+        async notify() {
+          return { ok: false, notification: false, sound: false, skipped: "attention_disabled" }
+        },
+        soundboard: {
+          registerPack: () => () => {},
+          activate: () => false,
+          current: () => "",
+          list: () => [],
+        },
+        dispose() {},
+      }
+    },
+    logger: { error: (message, extra) => console.error(message, extra ?? "") },
+    lifecycle: {
+      onSighup(handler) {
+        process.on("SIGHUP", handler)
+        return () => process.off("SIGHUP", handler)
+      },
+      writeStdout: (text) => process.stdout.write(text),
+      writeStderr: (text) => process.stderr.write(text),
+    },
+    formatError: () => undefined,
+    formatUnknownError(error) {
+      if (error instanceof Error) return error.message
+      return String(error)
+    },
+  }
+}
+
+const platform: TuiPlatform = {
+  files: {
+    readText: (file) => Bun.file(file).text(),
+    readBytes: async (file) => new Uint8Array(await Bun.file(file).arrayBuffer()),
+    async mime(file) {
+      return Bun.file(file).type || "application/octet-stream"
+    },
+  },
+}
+
+const legacyDefaults: Record<string, unknown> = {
+  "/config/providers": { providers: [], default: {} },
+  "/provider": { all: [], default: {}, connected: [] },
+  "/agent": [],
+  "/config": {},
+}
+
+const gracefulFetch = Object.assign(async (input: RequestInfo | URL, init?: RequestInit) => {
+  const response = await fetch(input, init)
+  if (response.status !== 404) return response
+  const fallback = legacyDefaults[new URL(input instanceof Request ? input.url : input).pathname]
+  if (fallback === undefined) return response
+  return Response.json(fallback)
+}, { preconnect: fetch.preconnect })

packages/cli/tsconfig.json

@@ -2,6 +2,8 @@
   "$schema": "https://json.schemastore.org/tsconfig",
   "extends": "@tsconfig/bun/tsconfig.json",
   "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "@opentui/solid",
     "lib": ["ESNext", "DOM", "DOM.Iterable"],
     "noUncheckedIndexedAccess": false
   }