feat: 品牌替换 + 启动优化 + AGENTS.md 模板定制

- 品牌替换：OpenCode/opencode → AirCoding/aircoding（16+ 文件）
- Logo ASCII art：修复 left/right 行数不匹配导致的启动崩溃
- 启动诊断：添加 OPENCODE_PRINT_TIMING 计时探针
- dev 模式默认 --pure 跳过外部插件加载
- AGENTS.md 模板：追加 AirCoding 多 Agent 专项段落
- architect prompt + plugin：强化 AGENTS.md 产出验证

packages/cli/src/commands/commands.ts

@@ -0,0 +1,36 @@
+import { Argument, Flag } from "effect/unstable/cli"
+import { Spec } from "../framework/spec"
+
+declare const OPENCODE_CLI_NAME: string | undefined
+
+export const Commands = Spec.make(typeof OPENCODE_CLI_NAME === "string" ? OPENCODE_CLI_NAME : "opencode", {
+  description: "OpenCode 2.0 preview command line interface",
+  commands: [
+    Spec.make("debug", {
+      description: "Debugging and troubleshooting tools",
+      commands: [Spec.make("agents", { description: "List all agents" })],
+    }),
+    Spec.make("migrate", { description: "Migrate v1 data to v2" }),
+    Spec.make("service", {
+      description: "Manage the background server",
+      commands: [
+        Spec.make("start", { description: "Start the background server" }),
+        Spec.make("restart", { description: "Restart the background server" }),
+        Spec.make("status", { description: "Show background server status" }),
+        Spec.make("stop", { description: "Stop the background server" }),
+        Spec.make("password", {
+          description: "Get or set the server password",
+          params: { value: Argument.string("value").pipe(Argument.optional) },
+        }),
+      ],
+    }),
+    Spec.make("serve", {
+      description: "Start the v2 API server",
+      params: {
+        hostname: Flag.string("hostname").pipe(Flag.withDefault("127.0.0.1")),
+        port: Flag.integer("port").pipe(Flag.optional),
+        register: Flag.boolean("register").pipe(Flag.withDefault(false)),
+      },
+    }),
+  ],
+})

packages/cli/src/commands/handlers/debug/agents.ts

@@ -0,0 +1,21 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.debug.commands.agents,
+  Effect.fn("cli.debug.agents")(function* () {
+    const daemon = yield* Daemon.Service
+    const client = yield* daemon.client()
+    const response = yield* Effect.promise(() => client.v2.agent.list({ location: { directory: process.cwd() } }))
+    process.stdout.write(
+      JSON.stringify(
+        response.data?.data.toSorted((a, b) => a.id.localeCompare(b.id)),
+        null,
+        2,
+      ) + EOL,
+    )
+  }),
+)

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* runTui(transport)
+  }),
+)

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

@@ -0,0 +1,5 @@
+import * as Effect from "effect/Effect"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+
+export default Runtime.handler(Commands.commands.migrate, (_input) => Effect.log("No migrations to run."))

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

@@ -0,0 +1,41 @@
+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"
+import { createServer } from "node:http"
+import { createRoutes } from "@opencode-ai/server/routes"
+import { Commands } from "../commands"
+import { Runtime } from "../../framework/runtime"
+import { Daemon } from "../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.serve,
+  Effect.fn("cli.serve")(function* (input) {
+    return yield* Effect.scoped(
+      Effect.gen(function* () {
+        const daemon = yield* Daemon.Service
+        const address = yield* listen(input.hostname, input.port, yield* daemon.password())
+        if (input.register) yield* daemon.register(address)
+        console.log(`server listening on ${HttpServer.formatAddress(address)}`)
+        return yield* Effect.never
+      }),
+    )
+  }),
+)
+
+function listen(hostname: string, port: Option.Option<number>, password: string) {
+  if (Option.isSome(port)) return bind(hostname, port.value, password)
+  // Preserve the familiar default when available, but let the OS choose a free
+  // port when another local server already owns 4096.
+  return bind(hostname, 4096, password).pipe(Effect.catch(() => bind(hostname, 0, password)))
+}
+
+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/commands/handlers/service/password.ts

@@ -0,0 +1,16 @@
+import { EOL } from "os"
+import { Option } from "effect"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.password,
+  Effect.fn("cli.service.password")(function* (input) {
+    const daemon = yield* Daemon.Service
+    const value = Option.getOrUndefined(input.value)
+    if (value !== undefined) yield* daemon.stop()
+    process.stdout.write((yield* daemon.password(value)) + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/restart.ts

@@ -0,0 +1,14 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.restart,
+  Effect.fn("cli.service.restart")(function* () {
+    const daemon = yield* Daemon.Service
+    yield* daemon.stop()
+    process.stdout.write((yield* daemon.start()) + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/start.ts

@@ -0,0 +1,12 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.start,
+  Effect.fn("cli.service.start")(function* () {
+    process.stdout.write((yield* (yield* Daemon.Service).start()) + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/status.ts

@@ -0,0 +1,13 @@
+import { EOL } from "os"
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.status,
+  Effect.fn("cli.service.status")(function* () {
+    const url = yield* (yield* Daemon.Service).status()
+    process.stdout.write((url ? `running ${url}` : "stopped") + EOL)
+  }),
+)

packages/cli/src/commands/handlers/service/stop.ts

@@ -0,0 +1,11 @@
+import * as Effect from "effect/Effect"
+import { Commands } from "../../commands"
+import { Runtime } from "../../../framework/runtime"
+import { Daemon } from "../../../services/daemon"
+
+export default Runtime.handler(
+  Commands.commands.service.commands.stop,
+  Effect.fn("cli.service.stop")(function* () {
+    yield* (yield* Daemon.Service).stop()
+  }),
+)

packages/cli/src/framework/runtime.ts

@@ -0,0 +1,79 @@
+import * as Effect from "effect/Effect"
+import * as Command from "effect/unstable/cli/Command"
+import { Spec } from "./spec"
+import { Daemon } from "../services/daemon"
+
+export type Input<Value> =
+  Value extends Spec.Node<infer _Name, infer Command, infer _Commands>
+    ? Input<Command>
+    : Value extends Command.Command<infer _Name, infer Input, infer _Context, infer _Error, infer _Requirements>
+      ? Input
+      : never
+
+type RuntimeHandler = (input: unknown) => Effect.Effect<void, unknown, Daemon.Service>
+type Loader<Node extends Spec.Any> = () => Promise<{
+  default: (input: Input<Node>) => Effect.Effect<void, any, Daemon.Service>
+}>
+type ProvidedCommand = Command.Command<string, unknown, unknown, unknown, Daemon.Service>
+
+export type Handlers<Node extends Spec.Any> = keyof Node["commands"] extends never
+  ? Loader<Node>
+  : { readonly $?: Loader<Node> } & { readonly [Key in keyof Node["commands"]]: Handlers<Node["commands"][Key]> }
+
+interface LazyHandler {
+  readonly spec: Command.Command.Any
+  readonly load: () => Promise<{ default: RuntimeHandler }>
+}
+
+type RuntimeHandlers =
+  | (() => Promise<{ default: RuntimeHandler }>)
+  | {
+      readonly $?: () => Promise<{ default: RuntimeHandler }>
+      readonly [key: string]: RuntimeHandlers | (() => Promise<{ default: RuntimeHandler }>) | undefined
+    }
+
+export function handler<const Node extends Spec.Any, Error, Requirements>(
+  _node: Node,
+  run: (input: Input<Node>) => Effect.Effect<void, Error, Requirements>,
+) {
+  return run
+}
+
+export function handlers<const Root extends Spec.Any>(root: Root, handlers: Handlers<Root>) {
+  const result: LazyHandler[] = []
+
+  function add(node: Spec.Any, value: RuntimeHandlers) {
+    if (typeof value === "function") {
+      result.push({ spec: node.spec, load: value as () => Promise<{ default: RuntimeHandler }> })
+      return
+    }
+    if (value.$) result.push({ spec: node.spec, load: value.$ as () => Promise<{ default: RuntimeHandler }> })
+    for (const [name, child] of Object.entries(node.commands)) add(child, value[name] as RuntimeHandlers)
+  }
+
+  add(root, handlers as RuntimeHandlers)
+  return result
+}
+
+export function run(commands: Spec.Any, handlers: ReadonlyArray<LazyHandler>, options: { readonly version: string }) {
+  return Command.run(provide(commands, handlers), options) as Effect.Effect<void, unknown, Command.Environment>
+}
+
+function provide(node: Spec.Any, handlers: ReadonlyArray<LazyHandler>): ProvidedCommand {
+  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
+  if (!Object.keys(node.commands).length) return spec as ProvidedCommand
+  return spec.pipe(
+    Command.withSubcommands(Object.values(node.commands).map((child) => provide(child, handlers))),
+  ) as ProvidedCommand
+}
+
+export * as Runtime from "./runtime"

packages/cli/src/framework/spec.ts

@@ -0,0 +1,42 @@
+import * as Command from "effect/unstable/cli/Command"
+
+type Options<Config extends Command.Command.Config, Commands extends ReadonlyArray<Any>> = {
+  readonly description?: string
+  readonly params?: Config
+  readonly commands?: Commands
+}
+
+export interface Node<
+  Name extends string,
+  Spec extends Command.Command<Name, any, any, any, any>,
+  Commands extends Children,
+> {
+  readonly name: Name
+  readonly spec: Spec
+  readonly commands: Commands
+}
+
+export type Any = Node<string, Command.Command<any, any, any, any, any>, Children>
+export type Children = Readonly<Record<string, Any>>
+
+export function make<
+  const Name extends string,
+  const Config extends Command.Command.Config = {},
+  const Commands extends ReadonlyArray<Any> = [],
+>(name: Name, options: Options<Config, Commands> = {}) {
+  const command = Command.make(name, options.params ?? ({} as Config))
+  const spec = options.description ? command.pipe(Command.withDescription(options.description)) : command
+  return {
+    name,
+    spec,
+    commands: Object.fromEntries(
+      (options.commands ?? []).map((command) => [command.name, command]),
+    ) as ChildrenOf<Commands>,
+  }
+}
+
+type ChildrenOf<Commands extends ReadonlyArray<Any>> = {
+  readonly [Node in Commands[number] as Node["name"]]: Node
+}
+
+export * as Spec from "./spec"

packages/cli/src/index.ts

@@ -0,0 +1,31 @@
+#!/usr/bin/env bun
+
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime"
+import * as NodeServices from "@effect/platform-node/NodeServices"
+import * as Effect from "effect/Effect"
+import { Commands } from "./commands/commands"
+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"),
+  },
+  migrate: () => import("./commands/handlers/migrate"),
+  service: {
+    start: () => import("./commands/handlers/service/start"),
+    restart: () => import("./commands/handlers/service/restart"),
+    status: () => import("./commands/handlers/service/status"),
+    stop: () => import("./commands/handlers/service/stop"),
+    password: () => import("./commands/handlers/service/password"),
+  },
+  serve: () => import("./commands/handlers/serve"),
+})
+
+Runtime.run(Commands, Handlers, { version: "local" }).pipe(
+  Effect.provide(Daemon.defaultLayer),
+  Effect.provide(NodeServices.layer),
+  Effect.scoped,
+  NodeRuntime.runMain,
+)

packages/cli/src/services/daemon.ts

@@ -0,0 +1,194 @@
+import { Global } from "@opencode-ai/core/global"
+import { InstallationVersion } from "@opencode-ai/core/installation/version"
+import { createOpencodeClient } from "@opencode-ai/sdk/v2/client"
+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>
+  readonly password: (value?: string) => Effect.Effect<string, unknown>
+  readonly register: (address: HttpServer.Address) => Effect.Effect<void, unknown, Scope.Scope>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@opencode/cli/Daemon") {}
+
+const Registration = Schema.Struct({
+  id: Schema.optional(Schema.String),
+  version: Schema.optional(Schema.String),
+  url: Schema.String,
+  pid: Schema.Int.check(Schema.isGreaterThan(0)),
+})
+type Registration = typeof Registration.Type
+
+function sameRegistration(left: Registration, right: Registration) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid
+}
+
+export const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem
+    const directory = Global.Path.state
+    const file = path.join(directory, "server.json")
+    const passwordFile = path.join(directory, "password")
+    const decodeRegistration = Schema.decodeUnknownEffect(Schema.fromJsonString(Registration))
+
+    const password = Effect.fn("cli.daemon.password")(function* (value?: string) {
+      const existing = yield* fs.readFileString(passwordFile).pipe(Effect.catch(() => Effect.succeed(undefined)))
+      if (value === undefined && existing) return existing
+
+      // Keep one private credential across server restarts so discovered clients
+      // can reconnect without exposing a password flag or environment variable.
+      const generated = value ?? randomBytes(32).toString("base64url")
+      const temp = passwordFile + ".tmp"
+      yield* fs.makeDirectory(directory, { recursive: true })
+      yield* fs.writeFileString(temp, generated, { mode: 0o600 })
+      yield* fs.rename(temp, passwordFile)
+      return generated
+    })
+
+    const registration = Effect.fnUntraced(function* () {
+      return yield* fs.readFileString(file).pipe(Effect.flatMap(decodeRegistration))
+    })
+
+    const createClient = Effect.fnUntraced(function* (url: string) {
+      return createOpencodeClient({ baseUrl: url, headers: ServerAuth.headers({ password: yield* password() }) })
+    })
+
+    const healthy = Effect.fnUntraced(function* () {
+      const info = yield* registration()
+      const client = yield* createClient(info.url)
+      const response = yield* Effect.tryPromise(() => client.v2.health.get({ signal: AbortSignal.timeout(2_000) }))
+      if (response.data?.healthy === true) return info
+      return yield* Effect.fail(new Error("Registered server is not healthy"))
+    })
+
+    const compatible = Effect.fnUntraced(function* () {
+      const info = yield* healthy()
+      if (info.version === InstallationVersion) return info
+      return yield* Effect.fail(new Error("Registered server version does not match the client"))
+    })
+
+    const signal = (pid: number, signal: NodeJS.Signals) =>
+      Effect.try({ try: () => process.kill(pid, signal), catch: (cause) => cause }).pipe(Effect.ignore)
+
+    const awaitStopped = Effect.fnUntraced(function* (pid: number) {
+      const running = yield* Effect.try({ try: () => process.kill(pid, 0), catch: () => false }).pipe(
+        Effect.orElseSucceed(() => false),
+      )
+      if (!running) return true
+      return yield* Effect.fail(new Error(`Server process ${pid} is still running`))
+    })
+
+    const stopProcess = Effect.fnUntraced(function* (info: Registration) {
+      const current = yield* healthy().pipe(Effect.option)
+      if (Option.isNone(current) || !sameRegistration(current.value, info)) return
+
+      yield* signal(info.pid, "SIGTERM")
+      const stopped = yield* awaitStopped(info.pid).pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+        Effect.option,
+      )
+      if (Option.isSome(stopped)) return
+
+      const latest = yield* healthy().pipe(Effect.option)
+      if (Option.isNone(latest) || !sameRegistration(latest.value, info)) return
+      yield* signal(info.pid, "SIGKILL")
+      yield* awaitStopped(info.pid).pipe(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+      )
+    })
+
+    const start = Effect.fn("cli.daemon.start")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      const found = Option.getOrUndefined(existing)
+      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)
+
+      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(
+        Effect.retry(Schedule.spaced("50 millis").pipe(Schedule.both(Schedule.recurs(100)))),
+        Effect.map((info) => info.url),
+        Effect.mapError(() => new Error("Failed to start server")),
+      )
+    })
+
+    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* () {
+      const connection = yield* transport()
+      return createOpencodeClient({ baseUrl: connection.url, headers: connection.headers })
+    })
+
+    const status = Effect.fn("cli.daemon.status")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      const found = Option.getOrUndefined(existing)
+      if (found?.version === InstallationVersion) return found.url
+      if (found) return undefined
+      yield* fs.remove(file).pipe(Effect.ignore)
+      return undefined
+    })
+
+    const stop = Effect.fn("cli.daemon.stop")(function* () {
+      const existing = yield* healthy().pipe(Effect.option)
+      // A stale registration may point at a PID that has since been reused by
+      // another process. Only signal the PID after authenticating the server.
+      if (Option.isNone(existing)) return yield* fs.remove(file).pipe(Effect.ignore)
+      yield* stopProcess(existing.value)
+      yield* fs.remove(file).pipe(Effect.ignore)
+    })
+
+    const register = Effect.fn("cli.daemon.register")(function* (address: HttpServer.Address) {
+      const id = randomUUID()
+      const temp = file + "." + id + ".tmp"
+      yield* fs.makeDirectory(directory, { recursive: true })
+      yield* fs.writeFileString(
+        temp,
+        JSON.stringify({ id, version: InstallationVersion, url: HttpServer.formatAddress(address), pid: process.pid }),
+        { mode: 0o600 },
+      )
+      yield* fs.rename(temp, file)
+      yield* registration().pipe(
+        Effect.flatMap((info) => (info.id === id ? Effect.void : signal(process.pid, "SIGTERM"))),
+        Effect.catch(() => signal(process.pid, "SIGTERM")),
+        Effect.repeat(Schedule.spaced("10 seconds")),
+        Effect.forkScoped,
+      )
+      yield* Effect.addFinalizer(() =>
+        registration().pipe(
+          Effect.flatMap((info) => (info.id === id ? fs.remove(file) : Effect.void)),
+          Effect.ignore,
+        ),
+      )
+    })
+
+    return Service.of({ client, transport, start, status, stop, password, register })
+  }),
+)
+
+export const defaultLayer = layer
+
+export * as Daemon from "./daemon"

packages/cli/src/tui.ts

@@ -0,0 +1,36 @@
+import { run } from "@opencode-ai/tui"
+import { TuiConfig } from "@opencode-ai/tui/config"
+import { Effect } from "effect"
+import { Global } from "@opencode-ai/core/global"
+
+export function runTui(transport: { url: string; headers: RequestInit["headers"] }) {
+  const config = TuiConfig.resolve({}, { terminalSuspend: false })
+  return run({
+    ...transport,
+    args: {},
+    config,
+    fetch: gracefulFetch,
+    pluginHost: {
+      async start() {},
+      async dispose() {},
+    },
+  }).pipe(Effect.provide(Global.defaultLayer))
+}
+
+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 },
+)