rird 1.0.200

package/src/index.ts

@@ -0,0 +1,240 @@
+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"
+import { validateLicense } from "./util/license"
+
+// Auto-update: Check and upgrade on every run
+async function autoUpdate(): Promise<boolean> {
+  // Skip auto-update for certain commands
+  const args = process.argv.slice(2)
+  const skipCommands = ["upgrade", "uninstall", "--version", "-v", "--help", "-h"]
+  if (args.some(arg => skipCommands.includes(arg))) {
+    return false
+  }
+
+  // Skip if running in local/dev mode
+  if (Installation.isLocal()) {
+    return false
+  }
+
+  try {
+    // Timeout the version check after 3 seconds to not slow down startup
+    const latestPromise = Installation.latest()
+    const timeoutPromise = new Promise<string>((_, reject) =>
+      setTimeout(() => reject(new Error("timeout")), 3000)
+    )
+    const latest = await Promise.race([latestPromise, timeoutPromise])
+    const current = Installation.VERSION
+
+    // Skip if already on latest
+    if (current === latest) {
+      return false
+    }
+
+    // Detect installation method
+    const method = await Installation.method()
+    if (method === "unknown") {
+      // Cannot auto-update unknown installations
+      return false
+    }
+
+    // Perform silent upgrade
+    console.log(`[RIRD] Updating ${current} -> ${latest}...`)
+    await Installation.upgrade(method, latest)
+    console.log(`[RIRD] Updated to ${latest}. Restarting...`)
+
+    // Re-exec with same arguments
+    const { spawn } = await import("child_process")
+    const child = spawn(process.execPath, process.argv.slice(1), {
+      stdio: "inherit",
+      env: { ...process.env, RIRD_SKIP_AUTO_UPDATE: "1" }
+    })
+    child.on("exit", (code) => process.exit(code ?? 0))
+    return true // Signal that we're restarting
+  } catch (err) {
+    // Silent failure - don't block user from running their command
+    // Note: Log not initialized yet, so we just silently fail
+    if (process.env.DEBUG) {
+      console.error("[RIRD] Auto-update check failed:", err instanceof Error ? err.message : err)
+    }
+    return false
+  }
+}
+
+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,
+  })
+})
+
+// Run auto-update before anything else (unless already restarted)
+if (!process.env.RIRD_SKIP_AUTO_UPDATE) {
+  const shouldRestart = await autoUpdate()
+  if (shouldRestart) {
+    // Wait for child process - don't proceed with this instance
+    await new Promise(() => {})
+  }
+}
+
+const cli = yargs(hideBin(process.argv))
+  .parserConfiguration({ "populate--": true })
+  .scriptName("rird")
+  .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.RIRD = "1"
+    process.env.OPENCODE = "1"
+
+    Log.Default.info("rird", {
+      version: Installation.VERSION,
+      args: process.argv.slice(2),
+    })
+
+    // License validation - skip for certain commands that must work without a license
+    const args = process.argv.slice(2)
+    const skipLicenseCommands = ["auth", "activate", "upgrade", "uninstall", "--version", "-v", "--help", "-h"]
+    const shouldSkipLicense = args.length === 0 || args.some(arg => skipLicenseCommands.includes(arg))
+
+    if (!shouldSkipLicense) {
+      const license = await validateLicense()
+      if (!license.valid) {
+        UI.error(license.message)
+        process.exit(1)
+      }
+    }
+  })
+  .usage("\n" + UI.logo())
+  .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,239 @@
+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(".opencode", "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 opencode`.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" ? "opencode" : "rird-cli")) {
+        return check.name
+      }
+    }
+
+    return "unknown"
+  }
+
+  export const UpgradeFailedError = NamedError.create(
+    "UpgradeFailedError",
+    z.object({
+      stderr: z.string(),
+    }),
+  )
+
+  async function getBrewFormula() {
+    const tapFormula = await $`brew list --formula sst/tap/opencode`.throws(false).quiet().text()
+    if (tapFormula.includes("opencode")) return "sst/tap/opencode"
+    const coreFormula = await $`brew list --formula opencode`.throws(false).quiet().text()
+    if (coreFormula.includes("opencode")) return "opencode"
+    return "opencode"
+  }
+
+  export async function upgrade(method: Method, target: string) {
+    let cmd
+    switch (method) {
+      case "curl":
+        cmd = $`curl -fsSL https://rird.ai/install | bash`.env({
+          ...process.env,
+          VERSION: target,
+        })
+        break
+      case "npm":
+        cmd = $`npm install -g rird-cli@${target}`
+        break
+      case "pnpm":
+        cmd = $`pnpm install -g rird-cli@${target}`
+        break
+      case "bun":
+        cmd = $`bun install -g rird-cli@${target}`
+        break
+      case "brew": {
+        const formula = await getBrewFormula()
+        cmd = $`brew install ${formula}`.env({
+          HOMEBREW_NO_AUTO_UPDATE: "1",
+          ...process.env,
+        })
+        break
+      }
+      case "unknown":
+        // Unknown install method - try force reinstall with multiple package managers
+        log.info("unknown install method, attempting force reinstall")
+        return forceReinstall()
+      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"),
+      })
+  }
+
+  export const VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local"
+  export const CHANNEL = typeof OPENCODE_CHANNEL === "string" ? OPENCODE_CHANNEL : "local"
+  export const USER_AGENT = `opencode/${CHANNEL}/${VERSION}/${Flag.RIRD_CLIENT}`
+
+  // Package names to try in order (handles legacy installs with wrong package name)
+  const NPM_PACKAGE_NAMES = ["rird-cli", "rird", "eversale-cli"]
+
+  async function fetchLatestFromNpm(registry: string, channel: string): Promise<string> {
+    for (const pkgName of NPM_PACKAGE_NAMES) {
+      try {
+        const res = await fetch(`${registry}/${pkgName}`)
+        if (res.ok) {
+          const data = await res.json()
+          return data["dist-tags"][channel] || data["dist-tags"].latest
+        }
+      } catch {
+        // Try next package name
+      }
+    }
+    throw new Error(`Could not find package on npm registry. Tried: ${NPM_PACKAGE_NAMES.join(", ")}`)
+  }
+
+  export async function latest(installMethod?: Method) {
+    const detectedMethod = installMethod || (await method())
+    if (detectedMethod === "brew") {
+      const formula = await getBrewFormula()
+      if (formula === "opencode") {
+        return fetch("https://formulae.brew.sh/api/formula/opencode.json")
+          .then((res) => {
+            if (!res.ok) throw new Error(res.statusText)
+            return res.json()
+          })
+          .then((data: any) => data.versions.stable)
+      }
+    }
+
+    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 === "local" ? "latest" : CHANNEL
+    return fetchLatestFromNpm(registry, channel)
+  }
+
+  // Force reinstall when normal upgrade fails (handles broken legacy installs)
+  export async function forceReinstall(): Promise<void> {
+    log.info("attempting force reinstall")
+
+    // Try multiple package managers in order of preference
+    const attempts = [
+      { name: "bun", cmd: () => $`bun install -g rird-cli@latest` },
+      { name: "npm", cmd: () => $`npm install -g rird-cli@latest` },
+      { name: "pnpm", cmd: () => $`pnpm install -g rird-cli@latest` },
+    ]
+
+    for (const attempt of attempts) {
+      try {
+        const result = await attempt.cmd().quiet().throws(false)
+        if (result.exitCode === 0) {
+          log.info("force reinstall succeeded", { method: attempt.name })
+          return
+        }
+      } catch {
+        // Try next method
+      }
+    }
+
+    throw new UpgradeFailedError({
+      stderr: "Force reinstall failed. Please run manually: npm install -g rird-cli@latest",
+    })
+  }
+}

package/src/lsp/client.ts

@@ -0,0 +1,229 @@
+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,
+          },
+          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) {
+            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("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
+  }
+}