rird 2.1.231 → 2.3.0

package/src/cli/cmd/models.ts

@@ -0,0 +1,68 @@
+import type { Argv } from "yargs"
+import { Instance } from "../../project/instance"
+import { Provider } from "../../provider/provider"
+import { cmd } from "./cmd"
+import { UI } from "../ui"
+import { EOL } from "os"
+
+export const ModelsCommand = cmd({
+  command: "models [provider]",
+  describe: "list all available models",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("provider", {
+        describe: "provider ID to filter models by",
+        type: "string",
+        array: false,
+      })
+      .option("verbose", {
+        describe: "use more verbose model output (includes metadata like costs)",
+        type: "boolean",
+      })
+  },
+  handler: async (args) => {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        const providers = await Provider.list()
+
+        function printModels(providerID: string, verbose?: boolean) {
+          const provider = providers[providerID]
+          const sortedModels = Object.entries(provider.models).sort(([a], [b]) => a.localeCompare(b))
+          for (const [modelID, model] of sortedModels) {
+            process.stdout.write(`${providerID}/${modelID}`)
+            process.stdout.write(EOL)
+            if (verbose) {
+              process.stdout.write(JSON.stringify(model, null, 2))
+              process.stdout.write(EOL)
+            }
+          }
+        }
+
+        if (args.provider) {
+          const providerID = args.provider
+          const provider = providers[providerID]
+          if (!provider) {
+            UI.error(`Provider not found: ${args.provider}`)
+            return
+          }
+
+          printModels(providerID, args.verbose)
+          return
+        }
+
+        const providerIDs = Object.keys(providers).sort((a, b) => {
+          const aIsRird = a.startsWith("rird")
+          const bIsRird = b.startsWith("rird")
+          if (aIsRird && !bIsRird) return -1
+          if (!aIsRird && bIsRird) return 1
+          return a.localeCompare(b)
+        })
+
+        for (const providerID of providerIDs) {
+          printModels(providerID, args.verbose)
+        }
+      },
+    })
+  },
+})

package/src/cli/cmd/pr.ts

@@ -0,0 +1,112 @@
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { Instance } from "@/project/instance"
+import { $ } from "bun"
+
+export const PrCommand = cmd({
+  command: "pr <number>",
+  describe: "fetch and checkout a GitHub PR branch, then run RIRD",
+  builder: (yargs) =>
+    yargs.positional("number", {
+      type: "number",
+      describe: "PR number to checkout",
+      demandOption: true,
+    }),
+  async handler(args) {
+    await Instance.provide({
+      directory: process.cwd(),
+      async fn() {
+        const project = Instance.project
+        if (project.vcs !== "git") {
+          UI.error("Could not find git repository. Please run this command from a git repository.")
+          process.exit(1)
+        }
+
+        const prNumber = args.number
+        const localBranchName = `pr/${prNumber}`
+        UI.println(`Fetching and checking out PR #${prNumber}...`)
+
+        // Use gh pr checkout with custom branch name
+        const result = await $`gh pr checkout ${prNumber} --branch ${localBranchName} --force`.nothrow()
+
+        if (result.exitCode !== 0) {
+          UI.error(`Failed to checkout PR #${prNumber}. Make sure you have gh CLI installed and authenticated.`)
+          process.exit(1)
+        }
+
+        // Fetch PR info for fork handling and session link detection
+        const prInfoResult =
+          await $`gh pr view ${prNumber} --json headRepository,headRepositoryOwner,isCrossRepository,headRefName,body`.nothrow()
+
+        let sessionId: string | undefined
+
+        if (prInfoResult.exitCode === 0) {
+          const prInfoText = prInfoResult.text()
+          if (prInfoText.trim()) {
+            const prInfo = JSON.parse(prInfoText)
+
+            // Handle fork PRs
+            if (prInfo && prInfo.isCrossRepository && prInfo.headRepository && prInfo.headRepositoryOwner) {
+              const forkOwner = prInfo.headRepositoryOwner.login
+              const forkName = prInfo.headRepository.name
+              const remoteName = forkOwner
+
+              // Check if remote already exists
+              const remotes = (await $`git remote`.nothrow().text()).trim()
+              if (!remotes.split("\n").includes(remoteName)) {
+                await $`git remote add ${remoteName} https://github.com/${forkOwner}/${forkName}.git`.nothrow()
+                UI.println(`Added fork remote: ${remoteName}`)
+              }
+
+              // Set upstream to the fork so pushes go there
+              const headRefName = prInfo.headRefName
+              await $`git branch --set-upstream-to=${remoteName}/${headRefName} ${localBranchName}`.nothrow()
+            }
+
+            // Check for RIRD session link in PR body
+            if (prInfo && prInfo.body) {
+              const sessionMatch = prInfo.body.match(/https:\/\/opncd\.ai\/s\/([a-zA-Z0-9_-]+)/)
+              if (sessionMatch) {
+                const sessionUrl = sessionMatch[0]
+                UI.println(`Found RIRD session: ${sessionUrl}`)
+                UI.println(`Importing session...`)
+
+                const importResult = await $`rird import ${sessionUrl}`.nothrow()
+                if (importResult.exitCode === 0) {
+                  const importOutput = importResult.text().trim()
+                  // Extract session ID from the output (format: "Imported session: <session-id>")
+                  const sessionIdMatch = importOutput.match(/Imported session: ([a-zA-Z0-9_-]+)/)
+                  if (sessionIdMatch) {
+                    sessionId = sessionIdMatch[1]
+                    UI.println(`Session imported: ${sessionId}`)
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        UI.println(`Successfully checked out PR #${prNumber} as branch '${localBranchName}'`)
+        UI.println()
+        UI.println("Starting RIRD...")
+        UI.println()
+
+        // Launch RIRD TUI with session ID if available
+        const { spawn } = await import("child_process")
+        const rirdArgs = sessionId ? ["-s", sessionId] : []
+        const rirdProcess = spawn("rird", rirdArgs, {
+          stdio: "inherit",
+          cwd: process.cwd(),
+        })
+
+        await new Promise<void>((resolve, reject) => {
+          rirdProcess.on("exit", (code) => {
+            if (code === 0) resolve()
+            else reject(new Error(`RIRD exited with code ${code}`))
+          })
+          rirdProcess.on("error", reject)
+        })
+      },
+    })
+  },
+})

package/src/cli/cmd/run.ts

@@ -0,0 +1,434 @@
+import type { Argv } from "yargs"
+import path from "path"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { Flag } from "../../flag/flag"
+import { bootstrap } from "../bootstrap"
+import { Command } from "../../command"
+import { EOL } from "os"
+import { select } from "@clack/prompts"
+import { createOpencodeClient, type OpencodeClient } from "@opencode-ai/sdk/v2"
+import { Server } from "../../server/server"
+import { Provider } from "../../provider/provider"
+import { Agent } from "../../agent/agent"
+import { Log } from "../../util/log"
+import { ValidationError, NetworkError, ProviderError, FileSystemError } from "../../lib/errors"
+import { handleError } from "../../lib/error-handler"
+
+const log = Log.create({ service: "run-command" })
+
+const FALLBACK_MODEL = "rird/qwen3:8b"
+
+const TOOL: Record<string, [string, string]> = {
+  todowrite: ["Todo", UI.Style.TEXT_WARNING_BOLD],
+  todoread: ["Todo", UI.Style.TEXT_WARNING_BOLD],
+  bash: ["Bash", UI.Style.TEXT_DANGER_BOLD],
+  edit: ["Edit", UI.Style.TEXT_SUCCESS_BOLD],
+  glob: ["Glob", UI.Style.TEXT_INFO_BOLD],
+  grep: ["Grep", UI.Style.TEXT_INFO_BOLD],
+  list: ["List", UI.Style.TEXT_INFO_BOLD],
+  read: ["Read", UI.Style.TEXT_HIGHLIGHT_BOLD],
+  write: ["Write", UI.Style.TEXT_SUCCESS_BOLD],
+  web_search_rird: ["Search", UI.Style.TEXT_DIM_BOLD],
+}
+
+function toolLabel(tool: string): [string, string] {
+  if (tool.startsWith("chrome_")) return ["Chrome", UI.Style.TEXT_INFO_BOLD]
+  return TOOL[tool] ?? [tool, UI.Style.TEXT_INFO_BOLD]
+}
+
+export const RunCommand = cmd({
+  command: "run [message..]",
+  describe: "run rird with a message",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("message", {
+        describe: "message to send",
+        type: "string",
+        array: true,
+        default: [],
+      })
+      .option("command", {
+        describe: "the command to run, use message for args",
+        type: "string",
+      })
+      .option("continue", {
+        alias: ["c"],
+        describe: "continue the last session",
+        type: "boolean",
+      })
+      .option("session", {
+        alias: ["s"],
+        describe: "session id to continue",
+        type: "string",
+      })
+      .option("share", {
+        type: "boolean",
+        describe: "share the session",
+      })
+      .option("model", {
+        type: "string",
+        alias: ["m"],
+        describe: "model to use in the format of provider/model",
+      })
+      .option("agent", {
+        type: "string",
+        describe: "agent to use",
+      })
+      .option("format", {
+        type: "string",
+        choices: ["default", "json"],
+        default: "default",
+        describe: "format: default (formatted) or json (raw JSON events)",
+      })
+      .option("file", {
+        alias: ["f"],
+        type: "string",
+        array: true,
+        describe: "file(s) to attach to message",
+      })
+      .option("title", {
+        type: "string",
+        describe: "title for the session (uses truncated prompt if no value provided)",
+      })
+      .option("attach", {
+        type: "string",
+        describe: "attach to a running rird server (e.g., http://localhost:4096)",
+      })
+      .option("port", {
+        type: "number",
+        describe: "port for the local server (defaults to random port if no value provided)",
+      })
+  },
+  handler: async (args) => {
+    try {
+      let message = [...args.message, ...(args["--"] || [])]
+        .map((arg) => (arg.includes(" ") ? `"${arg.replace(/"/g, '\\"')}"` : arg))
+        .join(" ")
+
+      const fileParts: any[] = []
+      if (args.file) {
+        const files = Array.isArray(args.file) ? args.file : [args.file]
+
+        for (const filePath of files) {
+          try {
+            const resolvedPath = path.resolve(process.cwd(), filePath)
+            const file = Bun.file(resolvedPath)
+            const stats = await file.stat().catch(() => {})
+            if (!stats || !(await file.exists())) {
+              throw new FileSystemError(`File not found: ${filePath}`, {
+                code: "FILE_NOT_FOUND",
+                details: { filePath, resolvedPath },
+              })
+            }
+
+            const stat = await file.stat()
+            const mime = stat.isDirectory() ? "application/x-directory" : "text/plain"
+
+            fileParts.push({
+              type: "file",
+              url: `file://${resolvedPath}`,
+              filename: path.basename(resolvedPath),
+              mime,
+            })
+          } catch (error) {
+            if (error instanceof FileSystemError) throw error
+            throw new FileSystemError(`Failed to access file: ${filePath}`, {
+              code: "FILE_ACCESS_ERROR",
+              originalError: error as Error,
+            })
+          }
+        }
+      }
+
+      if (!process.stdin.isTTY) message += "\n" + (await Bun.stdin.text())
+
+      if (message.trim().length === 0 && !args.command) {
+        throw new ValidationError("You must provide a message or a command", {
+          code: "EMPTY_INPUT",
+          details: { hasCommand: !!args.command, messageLength: message.length },
+        })
+      }
+
+    const isUnauthorizedError = (props: any, err: string) => {
+      const statusCode = (() => {
+        if (!props?.error) return undefined
+        if (!("data" in props.error)) return undefined
+        const data = (props.error as any).data
+        if (!data || typeof data !== "object") return undefined
+        const code = (data as any).statusCode
+        return typeof code === "number" ? code : undefined
+      })()
+      if (statusCode === 401 || statusCode === 403) return true
+      const lower = err.toLowerCase()
+      if (lower.includes("unauthorized")) return true
+      if (lower.includes("invalid api key")) return true
+      if (lower.includes("invalid token")) return true
+      return false
+    }
+
+    const execute = async (sdk: OpencodeClient, sessionID: string, modelOverride?: string) => {
+      const printEvent = (color: string, type: string, title: string) => {
+        UI.println(
+          color + `|`,
+          UI.Style.TEXT_NORMAL + UI.Style.TEXT_DIM + ` ${type.padEnd(7, " ")}`,
+          "",
+          UI.Style.TEXT_NORMAL + title,
+        )
+      }
+
+      const outputJsonEvent = (type: string, data: any) => {
+        if (args.format === "json") {
+          process.stdout.write(JSON.stringify({ type, timestamp: Date.now(), sessionID, ...data }) + EOL)
+          return true
+        }
+        return false
+      }
+
+      const events = await sdk.event.subscribe()
+      let errorMsg: string | undefined
+      let hitUnauthorized = false
+
+      const eventProcessor = (async () => {
+        for await (const event of events.stream) {
+          if (event.type === "message.part.updated") {
+            const part = event.properties.part
+            if (part.sessionID !== sessionID) continue
+
+            if (part.type === "tool" && part.state.status === "completed") {
+              if (outputJsonEvent("tool_use", { part })) continue
+              const [tool, color] = toolLabel(part.tool)
+              const title =
+                part.state.title ||
+                (Object.keys(part.state.input).length > 0 ? JSON.stringify(part.state.input) : "Unknown")
+              printEvent(color, tool, title)
+              if (part.tool === "bash" && part.state.output?.trim()) {
+                UI.println()
+                UI.println(part.state.output)
+              }
+            }
+
+            if (part.type === "step-start") {
+              if (outputJsonEvent("step_start", { part })) continue
+            }
+
+            if (part.type === "step-finish") {
+              if (outputJsonEvent("step_finish", { part })) continue
+            }
+
+            if (part.type === "text" && part.time?.end) {
+              if (outputJsonEvent("text", { part })) continue
+              const isPiped = !process.stdout.isTTY
+              if (!isPiped) UI.println()
+              process.stdout.write((isPiped ? part.text : UI.markdown(part.text)) + EOL)
+              if (!isPiped) UI.println()
+            }
+          }
+
+          if (event.type === "session.error") {
+            const props = event.properties
+            if (props.sessionID !== sessionID || !props.error) continue
+            let err = String(props.error.name)
+            if ("data" in props.error && props.error.data && "message" in props.error.data) {
+              err = String(props.error.data.message)
+            }
+            if (!args.model && !modelOverride && isUnauthorizedError(props, err)) {
+              hitUnauthorized = true
+              errorMsg = errorMsg ? errorMsg + EOL + err : err
+              if (outputJsonEvent("error", { error: props.error })) continue
+              continue
+            }
+            errorMsg = errorMsg ? errorMsg + EOL + err : err
+            if (outputJsonEvent("error", { error: props.error })) continue
+            UI.error(err)
+          }
+
+          if (event.type === "session.idle" && event.properties.sessionID === sessionID) {
+            break
+          }
+
+          if (event.type === "permission.updated") {
+            const permission = event.properties
+            if (permission.sessionID !== sessionID) continue
+            const result = await select({
+              message: `Permission required to run: ${permission.title}`,
+              options: [
+                { value: "once", label: "Allow once" },
+                { value: "always", label: "Always allow" },
+                { value: "reject", label: "Reject" },
+              ],
+              initialValue: "once",
+            }).catch(() => "reject")
+            const response = (result.toString().includes("cancel") ? "reject" : result) as "once" | "always" | "reject"
+            await sdk.permission.respond({
+              sessionID,
+              permissionID: permission.id,
+              response,
+            })
+          }
+        }
+      })()
+
+      // Validate agent if specified
+      const resolvedAgent = await (async () => {
+        if (!args.agent) return undefined
+        const agent = await Agent.get(args.agent)
+        if (!agent) {
+          UI.println(
+            UI.Style.TEXT_WARNING_BOLD + "!",
+            UI.Style.TEXT_NORMAL,
+            `agent "${args.agent}" not found. Falling back to default agent`,
+          )
+          return undefined
+        }
+        if (agent.mode === "subagent") {
+          UI.println(
+            UI.Style.TEXT_WARNING_BOLD + "!",
+            UI.Style.TEXT_NORMAL,
+            `agent "${args.agent}" is a subagent, not a primary agent. Falling back to default agent`,
+          )
+          return undefined
+        }
+        return args.agent
+      })()
+
+      if (args.command) {
+        await sdk.session.command({
+          sessionID,
+          agent: resolvedAgent,
+          model: modelOverride ?? args.model,
+          command: args.command,
+          arguments: message,
+        })
+      } else {
+        const modelParam = modelOverride
+          ? Provider.parseModel(modelOverride)
+          : args.model
+            ? Provider.parseModel(args.model)
+            : undefined
+        await sdk.session.prompt({
+          sessionID,
+          agent: resolvedAgent,
+          model: modelParam,
+          parts: [...fileParts, { type: "text", text: message }],
+        })
+      }
+
+      await eventProcessor
+      return { errorMsg, hitUnauthorized }
+    }
+
+    if (args.attach) {
+      const sdk = createOpencodeClient({ baseUrl: args.attach })
+
+      const sessionID = await (async () => {
+        if (args.continue) {
+          const result = await sdk.session.list()
+          return result.data?.find((s) => !s.parentID)?.id
+        }
+        if (args.session) return args.session
+
+        const title =
+          args.title !== undefined
+            ? args.title === ""
+              ? message.slice(0, 50) + (message.length > 50 ? "..." : "")
+              : args.title
+            : undefined
+
+        const result = await sdk.session.create(title ? { title } : {})
+        return result.data?.id
+      })()
+
+      if (!sessionID) {
+        UI.error("Session not found")
+        process.exit(1)
+      }
+
+      const cfgResult = await sdk.config.get()
+      if (cfgResult.data && (cfgResult.data.share === "auto" || Flag.OPENCODE_AUTO_SHARE || args.share)) {
+        const shareResult = await sdk.session.share({ sessionID }).catch((error) => {
+          if (error instanceof Error && error.message.includes("disabled")) {
+            UI.println(UI.Style.TEXT_DANGER_BOLD + "!  " + error.message)
+          }
+          return { error }
+        })
+        if (!shareResult.error && "data" in shareResult && shareResult.data?.share?.url) {
+          UI.println(UI.Style.TEXT_INFO_BOLD + "~  " + shareResult.data.share.url)
+        }
+      }
+
+      const result = await execute(sdk, sessionID)
+      if (!args.model && result.hitUnauthorized) {
+        const retry = await execute(sdk, sessionID, FALLBACK_MODEL)
+        if (retry.errorMsg) process.exit(1)
+        return
+      }
+      if (result.errorMsg) process.exit(1)
+      return
+    }
+
+    await bootstrap(process.cwd(), async () => {
+      const server = Server.listen({ port: args.port ?? 0, hostname: "127.0.0.1" })
+      const sdk = createOpencodeClient({ baseUrl: `http://${server.hostname}:${server.port}` })
+
+      try {
+        if (args.command) {
+          const exists = await Command.get(args.command)
+          if (!exists) {
+            UI.error(`Command "${args.command}" not found`)
+            process.exit(1)
+          }
+        }
+
+        const sessionID = await (async () => {
+          if (args.continue) {
+            const result = await sdk.session.list()
+            return result.data?.find((s) => !s.parentID)?.id
+          }
+          if (args.session) return args.session
+
+          const title =
+            args.title !== undefined
+              ? args.title === ""
+                ? message.slice(0, 50) + (message.length > 50 ? "..." : "")
+                : args.title
+              : undefined
+
+          const result = await sdk.session.create(title ? { title } : {})
+          return result.data?.id
+        })()
+
+        if (!sessionID) {
+          UI.error("Session not found")
+          process.exit(1)
+        }
+
+        const cfgResult = await sdk.config.get()
+        if (cfgResult.data && (cfgResult.data.share === "auto" || Flag.OPENCODE_AUTO_SHARE || args.share)) {
+          const shareResult = await sdk.session.share({ sessionID }).catch((error) => {
+            if (error instanceof Error && error.message.includes("disabled")) {
+              UI.println(UI.Style.TEXT_DANGER_BOLD + "!  " + error.message)
+            }
+            return { error }
+          })
+          if (!shareResult.error && "data" in shareResult && shareResult.data?.share?.url) {
+            UI.println(UI.Style.TEXT_INFO_BOLD + "~  " + shareResult.data.share.url)
+          }
+        }
+
+        const result = await execute(sdk, sessionID)
+        if (!args.model && result.hitUnauthorized) {
+          const retry = await execute(sdk, sessionID, FALLBACK_MODEL)
+          if (retry.errorMsg) process.exit(1)
+          return
+        }
+        if (result.errorMsg) process.exit(1)
+      } finally {
+        server.stop()
+      }
+    })
+    } catch (error) {
+      await handleError(error, "run-command", { exitOnError: true })
+    }
+  },
+})

package/src/cli/cmd/serve.ts

@@ -0,0 +1,31 @@
+import { Server } from "../../server/server"
+import { cmd } from "./cmd"
+
+export const ServeCommand = cmd({
+  command: "serve",
+  builder: (yargs) =>
+    yargs
+      .option("port", {
+        alias: ["p"],
+        type: "number",
+        describe: "port to listen on",
+        default: 0,
+      })
+      .option("hostname", {
+        type: "string",
+        describe: "hostname to listen on",
+        default: "127.0.0.1",
+      }),
+  describe: "starts a headless rird server",
+  handler: async (args) => {
+    const hostname = args.hostname
+    const port = args.port
+    const server = Server.listen({
+      port,
+      hostname,
+    })
+    console.log(`rird server listening on http://${server.hostname}:${server.port}`)
+    await new Promise(() => {})
+    await server.stop()
+  },
+})