chad-code 1.3.1

package/src/index.ts

@@ -0,0 +1,159 @@
+import yargs from "yargs"
+import { hideBin } from "yargs/helpers"
+import { RunCommand } from "./cli/cmd/run"
+import { GenerateCommand } from "./cli/cmd/generate"
+import { Log } from "./util/log"
+import { AuthCommand } from "./cli/cmd/auth"
+import { AgentCommand } from "./cli/cmd/agent"
+import { UpgradeCommand } from "./cli/cmd/upgrade"
+import { UninstallCommand } from "./cli/cmd/uninstall"
+import { ModelsCommand } from "./cli/cmd/models"
+import { UI } from "./cli/ui"
+import { Installation } from "./installation"
+import { NamedError } from "@opencode-ai/util/error"
+import { FormatError } from "./cli/error"
+import { ServeCommand } from "./cli/cmd/serve"
+import { DebugCommand } from "./cli/cmd/debug"
+import { StatsCommand } from "./cli/cmd/stats"
+import { McpCommand } from "./cli/cmd/mcp"
+import { GithubCommand } from "./cli/cmd/github"
+import { ExportCommand } from "./cli/cmd/export"
+import { ImportCommand } from "./cli/cmd/import"
+import { AttachCommand } from "./cli/cmd/tui/attach"
+import { TuiThreadCommand } from "./cli/cmd/tui/thread"
+import { TuiSpawnCommand } from "./cli/cmd/tui/spawn"
+import { AcpCommand } from "./cli/cmd/acp"
+import { EOL } from "os"
+import { WebCommand } from "./cli/cmd/web"
+import { PrCommand } from "./cli/cmd/pr"
+import { SessionCommand } from "./cli/cmd/session"
+
+process.on("unhandledRejection", (e) => {
+  Log.Default.error("rejection", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+process.on("uncaughtException", (e) => {
+  Log.Default.error("exception", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+const cli = yargs(hideBin(process.argv))
+  .parserConfiguration({ "populate--": true })
+  .scriptName("chad-code")
+  .wrap(100)
+  .help("help", "show help")
+  .alias("help", "h")
+  .version("version", "show version number", Installation.VERSION)
+  .alias("version", "v")
+  .option("print-logs", {
+    describe: "print logs to stderr",
+    type: "boolean",
+  })
+  .option("log-level", {
+    describe: "log level",
+    type: "string",
+    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
+  })
+  .middleware(async (opts) => {
+    await Log.init({
+      print: process.argv.includes("--print-logs"),
+      dev: Installation.isLocal(),
+      level: (() => {
+        if (opts.logLevel) return opts.logLevel as Log.Level
+        if (Installation.isLocal()) return "DEBUG"
+        return "INFO"
+      })(),
+    })
+
+    process.env.AGENT = "1"
+    process.env.CHAD_CODE = "1"
+
+    Log.Default.info("chad-code", {
+      version: Installation.VERSION,
+      args: process.argv.slice(2),
+    })
+  })
+  .usage("\n" + UI.logo())
+  .completion("completion", "generate shell completion script")
+  .command(AcpCommand)
+  .command(McpCommand)
+  .command(TuiThreadCommand)
+  .command(TuiSpawnCommand)
+  .command(AttachCommand)
+  .command(RunCommand)
+  .command(GenerateCommand)
+  .command(DebugCommand)
+  .command(AuthCommand)
+  .command(AgentCommand)
+  .command(UpgradeCommand)
+  .command(UninstallCommand)
+  .command(ServeCommand)
+  .command(WebCommand)
+  .command(ModelsCommand)
+  .command(StatsCommand)
+  .command(ExportCommand)
+  .command(ImportCommand)
+  .command(GithubCommand)
+  .command(PrCommand)
+  .command(SessionCommand)
+  .fail((msg) => {
+    if (
+      msg.startsWith("Unknown argument") ||
+      msg.startsWith("Not enough non-option arguments") ||
+      msg.startsWith("Invalid values:")
+    ) {
+      cli.showHelp("log")
+    }
+    process.exit(1)
+  })
+  .strict()
+
+try {
+  await cli.parse()
+} catch (e) {
+  let data: Record<string, any> = {}
+  if (e instanceof NamedError) {
+    const obj = e.toObject()
+    Object.assign(data, {
+      ...obj.data,
+    })
+  }
+
+  if (e instanceof Error) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      cause: e.cause?.toString(),
+      stack: e.stack,
+    })
+  }
+
+  if (e instanceof ResolveMessage) {
+    Object.assign(data, {
+      name: e.name,
+      message: e.message,
+      code: e.code,
+      specifier: e.specifier,
+      referrer: e.referrer,
+      position: e.position,
+      importKind: e.importKind,
+    })
+  }
+  Log.Default.error("fatal", data)
+  const formatted = FormatError(e)
+  if (formatted) UI.error(formatted)
+  if (formatted === undefined) {
+    UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
+    console.error(e)
+  }
+  process.exitCode = 1
+} finally {
+  // Some subprocesses don't react properly to SIGTERM and similar signals.
+  // Most notably, some docker-container-based MCP servers don't handle such signals unless
+  // run using `docker run --init`.
+  // Explicitly exit to avoid any hanging subprocesses.
+  process.exit()
+}

package/src/installation/index.ts

@@ -0,0 +1,198 @@
+import { BusEvent } from "@/bus/bus-event"
+import path from "path"
+import { $ } from "bun"
+import z from "zod"
+import { NamedError } from "@opencode-ai/util/error"
+import { Log } from "../util/log"
+import { iife } from "@/util/iife"
+import { Flag } from "../flag/flag"
+
+declare global {
+  const OPENCODE_VERSION: string
+  const OPENCODE_CHANNEL: string
+}
+
+export namespace Installation {
+  const log = Log.create({ service: "installation" })
+
+  export type Method = Awaited<ReturnType<typeof method>>
+
+  export const Event = {
+    Updated: BusEvent.define(
+      "installation.updated",
+      z.object({
+        version: z.string(),
+      }),
+    ),
+    UpdateAvailable: BusEvent.define(
+      "installation.update-available",
+      z.object({
+        version: z.string(),
+      }),
+    ),
+  }
+
+  export const Info = z
+    .object({
+      version: z.string(),
+      latest: z.string(),
+    })
+    .meta({
+      ref: "InstallationInfo",
+    })
+  export type Info = z.infer<typeof Info>
+
+  export async function info() {
+    return {
+      version: VERSION,
+      latest: await latest(),
+    }
+  }
+
+  export function isPreview() {
+    return CHANNEL !== "latest"
+  }
+
+  export function isLocal() {
+    return CHANNEL === "local"
+  }
+
+  export async function method() {
+    if (process.execPath.includes(path.join(".chad-code", "bin"))) return "curl"
+    if (process.execPath.includes(path.join(".local", "bin"))) return "curl"
+    const exec = process.execPath.toLowerCase()
+
+    const checks = [
+      {
+        name: "npm" as const,
+        command: () => $`npm list -g --depth=0`.throws(false).quiet().text(),
+      },
+      {
+        name: "yarn" as const,
+        command: () => $`yarn global list`.throws(false).quiet().text(),
+      },
+      {
+        name: "pnpm" as const,
+        command: () => $`pnpm list -g --depth=0`.throws(false).quiet().text(),
+      },
+      {
+        name: "bun" as const,
+        command: () => $`bun pm ls -g`.throws(false).quiet().text(),
+      },
+      {
+        name: "brew" as const,
+        command: () => $`brew list --formula chad-code`.throws(false).quiet().text(),
+      },
+    ]
+
+    checks.sort((a, b) => {
+      const aMatches = exec.includes(a.name)
+      const bMatches = exec.includes(b.name)
+      if (aMatches && !bMatches) return -1
+      if (!aMatches && bMatches) return 1
+      return 0
+    })
+
+    for (const check of checks) {
+      const output = await check.command()
+      if (output.includes(check.name === "brew" ? "chad-code" : "chad-code")) {
+        return check.name
+      }
+    }
+
+    return "unknown"
+  }
+
+  export const UpgradeFailedError = NamedError.create(
+    "UpgradeFailedError",
+    z.object({
+      stderr: z.string(),
+    }),
+  )
+
+  async function getBrewFormula() {
+    const coreFormula = await $`brew list --formula chad-code`.throws(false).quiet().text()
+    if (coreFormula.includes("chad-code")) return "chad-code"
+    return "chad-code"
+  }
+
+  export async function upgrade(method: Method, target: string) {
+    let cmd
+    switch (method) {
+      case "curl":
+        // curl install not available for Chad Code
+        throw new Error("curl install method not available for Chad Code. Use npm, pnpm, bun, or brew.")
+      case "npm":
+        cmd = $`npm install -g chad-code@${target}`
+        break
+      case "pnpm":
+        cmd = $`pnpm install -g chad-code@${target}`
+        break
+      case "bun":
+        cmd = $`bun install -g chad-code@${target}`
+        break
+      case "brew": {
+        const formula = await getBrewFormula()
+        cmd = $`brew install ${formula}`.env({
+          HOMEBREW_NO_AUTO_UPDATE: "1",
+          ...process.env,
+        })
+        break
+      }
+      default:
+        throw new Error(`Unknown method: ${method}`)
+    }
+    const result = await cmd.quiet().throws(false)
+    log.info("upgraded", {
+      method,
+      target,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString(),
+    })
+    if (result.exitCode !== 0)
+      throw new UpgradeFailedError({
+        stderr: result.stderr.toString("utf8"),
+      })
+    await $`${process.execPath} --version`.nothrow().quiet().text()
+  }
+
+  export const VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local"
+  export const CHANNEL = typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local"
+  export const USER_AGENT = `chad-code/${CHANNEL}/${VERSION}/${Flag.OPENCODE_CLIENT}`
+
+  export async function latest(installMethod?: Method) {
+    const detectedMethod = installMethod || (await method())
+
+    if (detectedMethod === "brew") {
+      const formula = await getBrewFormula()
+      if (formula === "chad-code") {
+        return fetch("https://formulae.brew.sh/api/formula/chad-code.json")
+          .then((res) => {
+            if (!res.ok) throw new Error(res.statusText)
+            return res.json()
+          })
+          .then((data: any) => data.versions.stable)
+          .catch(() => VERSION) // Fall back to current version if brew formula not available
+      }
+    }
+
+    if (detectedMethod === "npm" || detectedMethod === "bun" || detectedMethod === "pnpm") {
+      const registry = await iife(async () => {
+        const r = (await $`npm config get registry`.quiet().nothrow().text()).trim()
+        const reg = r || "https://registry.npmjs.org"
+        return reg.endsWith("/") ? reg.slice(0, -1) : reg
+      })
+      const channel = CHANNEL
+      return fetch(`${registry}/chad-code/${channel}`)
+        .then((res) => {
+          if (!res.ok) throw new Error(res.statusText)
+          return res.json()
+        })
+        .then((data: any) => data.version)
+        .catch(() => VERSION) // Fall back to current version if npm package not available
+    }
+
+    // No GitHub releases for Chad Code, return current version
+    return VERSION
+  }
+}

package/src/lsp/client.ts

@@ -0,0 +1,252 @@
+import { BusEvent } from "@/bus/bus-event"
+import { Bus } from "@/bus"
+import path from "path"
+import { pathToFileURL, fileURLToPath } from "url"
+import { createMessageConnection, StreamMessageReader, StreamMessageWriter } from "vscode-jsonrpc/node"
+import type { Diagnostic as VSCodeDiagnostic } from "vscode-languageserver-types"
+import { Log } from "../util/log"
+import { LANGUAGE_EXTENSIONS } from "./language"
+import z from "zod"
+import type { LSPServer } from "./server"
+import { NamedError } from "@opencode-ai/util/error"
+import { withTimeout } from "../util/timeout"
+import { Instance } from "../project/instance"
+import { Filesystem } from "../util/filesystem"
+
+const DIAGNOSTICS_DEBOUNCE_MS = 150
+
+export namespace LSPClient {
+  const log = Log.create({ service: "lsp.client" })
+
+  export type Info = NonNullable<Awaited<ReturnType<typeof create>>>
+
+  export type Diagnostic = VSCodeDiagnostic
+
+  export const InitializeError = NamedError.create(
+    "LSPInitializeError",
+    z.object({
+      serverID: z.string(),
+    }),
+  )
+
+  export const Event = {
+    Diagnostics: BusEvent.define(
+      "lsp.client.diagnostics",
+      z.object({
+        serverID: z.string(),
+        path: z.string(),
+      }),
+    ),
+  }
+
+  export async function create(input: { serverID: string; server: LSPServer.Handle; root: string }) {
+    const l = log.clone().tag("serverID", input.serverID)
+    l.info("starting client")
+
+    const connection = createMessageConnection(
+      new StreamMessageReader(input.server.process.stdout as any),
+      new StreamMessageWriter(input.server.process.stdin as any),
+    )
+
+    const diagnostics = new Map<string, Diagnostic[]>()
+    connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      const filePath = Filesystem.normalizePath(fileURLToPath(params.uri))
+      l.info("textDocument/publishDiagnostics", {
+        path: filePath,
+        count: params.diagnostics.length,
+      })
+      const exists = diagnostics.has(filePath)
+      diagnostics.set(filePath, params.diagnostics)
+      if (!exists && input.serverID === "typescript") return
+      Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
+    })
+    connection.onRequest("window/workDoneProgress/create", (params) => {
+      l.info("window/workDoneProgress/create", params)
+      return null
+    })
+    connection.onRequest("workspace/configuration", async () => {
+      // Return server initialization options
+      return [input.server.initialization ?? {}]
+    })
+    connection.onRequest("client/registerCapability", async () => {})
+    connection.onRequest("client/unregisterCapability", async () => {})
+    connection.onRequest("workspace/workspaceFolders", async () => [
+      {
+        name: "workspace",
+        uri: pathToFileURL(input.root).href,
+      },
+    ])
+    connection.listen()
+
+    l.info("sending initialize")
+    await withTimeout(
+      connection.sendRequest("initialize", {
+        rootUri: pathToFileURL(input.root).href,
+        processId: input.server.process.pid,
+        workspaceFolders: [
+          {
+            name: "workspace",
+            uri: pathToFileURL(input.root).href,
+          },
+        ],
+        initializationOptions: {
+          ...input.server.initialization,
+        },
+        capabilities: {
+          window: {
+            workDoneProgress: true,
+          },
+          workspace: {
+            configuration: true,
+            didChangeWatchedFiles: {
+              dynamicRegistration: true,
+            },
+          },
+          textDocument: {
+            synchronization: {
+              didOpen: true,
+              didChange: true,
+            },
+            publishDiagnostics: {
+              versionSupport: true,
+            },
+          },
+        },
+      }),
+      45_000,
+    ).catch((err) => {
+      l.error("initialize error", { error: err })
+      throw new InitializeError(
+        { serverID: input.serverID },
+        {
+          cause: err,
+        },
+      )
+    })
+
+    await connection.sendNotification("initialized", {})
+
+    if (input.server.initialization) {
+      await connection.sendNotification("workspace/didChangeConfiguration", {
+        settings: input.server.initialization,
+      })
+    }
+
+    const files: {
+      [path: string]: number
+    } = {}
+
+    const result = {
+      root: input.root,
+      get serverID() {
+        return input.serverID
+      },
+      get connection() {
+        return connection
+      },
+      notify: {
+        async open(input: { path: string }) {
+          input.path = path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path)
+          const file = Bun.file(input.path)
+          const text = await file.text()
+          const extension = path.extname(input.path)
+          const languageId = LANGUAGE_EXTENSIONS[extension] ?? "plaintext"
+
+          const version = files[input.path]
+          if (version !== undefined) {
+            log.info("workspace/didChangeWatchedFiles", input)
+            await connection.sendNotification("workspace/didChangeWatchedFiles", {
+              changes: [
+                {
+                  uri: pathToFileURL(input.path).href,
+                  type: 2, // Changed
+                },
+              ],
+            })
+
+            const next = version + 1
+            files[input.path] = next
+            log.info("textDocument/didChange", {
+              path: input.path,
+              version: next,
+            })
+            await connection.sendNotification("textDocument/didChange", {
+              textDocument: {
+                uri: pathToFileURL(input.path).href,
+                version: next,
+              },
+              contentChanges: [{ text }],
+            })
+            return
+          }
+
+          log.info("workspace/didChangeWatchedFiles", input)
+          await connection.sendNotification("workspace/didChangeWatchedFiles", {
+            changes: [
+              {
+                uri: pathToFileURL(input.path).href,
+                type: 1, // Created
+              },
+            ],
+          })
+
+          log.info("textDocument/didOpen", input)
+          diagnostics.delete(input.path)
+          await connection.sendNotification("textDocument/didOpen", {
+            textDocument: {
+              uri: pathToFileURL(input.path).href,
+              languageId,
+              version: 0,
+              text,
+            },
+          })
+          files[input.path] = 0
+          return
+        },
+      },
+      get diagnostics() {
+        return diagnostics
+      },
+      async waitForDiagnostics(input: { path: string }) {
+        const normalizedPath = Filesystem.normalizePath(
+          path.isAbsolute(input.path) ? input.path : path.resolve(Instance.directory, input.path),
+        )
+        log.info("waiting for diagnostics", { path: normalizedPath })
+        let unsub: () => void
+        let debounceTimer: ReturnType<typeof setTimeout> | undefined
+        return await withTimeout(
+          new Promise<void>((resolve) => {
+            unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+              if (event.properties.path === normalizedPath && event.properties.serverID === result.serverID) {
+                // Debounce to allow LSP to send follow-up diagnostics (e.g., semantic after syntax)
+                if (debounceTimer) clearTimeout(debounceTimer)
+                debounceTimer = setTimeout(() => {
+                  log.info("got diagnostics", { path: normalizedPath })
+                  unsub?.()
+                  resolve()
+                }, DIAGNOSTICS_DEBOUNCE_MS)
+              }
+            })
+          }),
+          3000,
+        )
+          .catch(() => {})
+          .finally(() => {
+            if (debounceTimer) clearTimeout(debounceTimer)
+            unsub?.()
+          })
+      },
+      async shutdown() {
+        l.info("shutting down")
+        connection.end()
+        connection.dispose()
+        input.server.process.kill()
+        l.info("shutdown")
+      },
+    }
+
+    l.info("initialized")
+
+    return result
+  }
+}