rimuru-ai 1.19.0

package/src/cli/cmd/tui.ts

@@ -0,0 +1,224 @@
+import { cmd } from "@/cli/cmd/cmd"
+import { Rpc } from "@/util/rpc"
+import { type rpc } from "../tui/worker"
+import path from "path"
+import { fileURLToPath } from "url"
+import { UI } from "@/cli/ui"
+import { errorMessage } from "@rimurucode-ai/tui/util/error"
+import { withTimeout } from "@/util/timeout"
+import { withNetworkOptions, resolveNetworkOptionsNoConfig } from "@/cli/network"
+import { Filesystem } from "@/util/filesystem"
+import type { GlobalEvent } from "@rimurucode-ai/sdk/v2"
+import type { EventSource } from "@rimurucode-ai/tui/context/sdk"
+import { writeHeapSnapshot } from "v8"
+import { validateSession } from "../tui/validate-session"
+import { win32InstallCtrlCGuard } from "@rimurucode-ai/tui/terminal-win32"
+
+declare global {
+  const OPENCODE_WORKER_PATH: string
+}
+
+type RpcClient = ReturnType<typeof Rpc.client<typeof rpc>>
+
+function createWorkerFetch(client: RpcClient): typeof fetch {
+  const fn = async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
+    const request = new Request(input, init)
+    const body = request.body ? await request.text() : undefined
+    const result = await client.call("fetch", {
+      url: request.url,
+      method: request.method,
+      headers: Object.fromEntries(request.headers.entries()),
+      body,
+    })
+    return new Response(result.body, {
+      status: result.status,
+      headers: result.headers,
+    })
+  }
+  return fn as typeof fetch
+}
+
+function createEventSource(client: RpcClient): EventSource {
+  return {
+    subscribe: async (handler) => {
+      return client.on<GlobalEvent>("global.event", (e) => {
+        handler(e)
+      })
+    },
+  }
+}
+
+async function target() {
+  if (typeof OPENCODE_WORKER_PATH !== "undefined") return OPENCODE_WORKER_PATH
+  const dist = new URL("./cli/tui/worker.js", import.meta.url)
+  if (await Filesystem.exists(fileURLToPath(dist))) return dist
+  return new URL("../tui/worker.ts", import.meta.url)
+}
+
+async function input(value?: string) {
+  const piped = process.stdin.isTTY ? undefined : await Bun.stdin.text()
+  if (!value) return piped
+  if (!piped) return value
+  return piped + "\n" + value
+}
+
+export function resolveThreadDirectory(project?: string, envPWD = process.env.PWD, cwd = process.cwd()) {
+  const root = Filesystem.resolve(envPWD ?? cwd)
+  if (project) return Filesystem.resolve(path.isAbsolute(project) ? project : path.join(root, project))
+  return Filesystem.resolve(cwd)
+}
+
+export const TuiThreadCommand = cmd({
+  command: "$0 [project]",
+  describe: "start rimuru-ai tui",
+  builder: (yargs) =>
+    withNetworkOptions(yargs)
+      .positional("project", {
+        type: "string",
+        describe: "path to start rimuru-ai in",
+      })
+      .option("model", {
+        type: "string",
+        alias: ["m"],
+        describe: "model to use in the format of provider/model",
+      })
+      .option("continue", {
+        alias: ["c"],
+        describe: "continue the last session",
+        type: "boolean",
+      })
+      .option("session", {
+        alias: ["s"],
+        type: "string",
+        describe: "session id to continue",
+      })
+      .option("fork", {
+        type: "boolean",
+        describe: "fork the session when continuing (use with --continue or --session)",
+      })
+      .option("prompt", {
+        type: "string",
+        describe: "prompt to use",
+      })
+      .option("agent", {
+        type: "string",
+        describe: "agent to use",
+      }),
+  handler: async (args) => {
+    const unguard = win32InstallCtrlCGuard()
+    try {
+      const { TuiConfig } = await import("@/config/tui")
+      if (args.fork && !args.continue && !args.session) {
+        UI.error("--fork requires --continue or --session")
+        process.exitCode = 1
+        return
+      }
+
+      // Resolve relative --project paths from PWD, then use the real cwd after
+      // chdir so the thread and worker share the same directory key.
+      const next = resolveThreadDirectory(args.project)
+      const file = await target()
+      try {
+        process.chdir(next)
+      } catch {
+        UI.error("Failed to change directory to " + next)
+        return
+      }
+      const cwd = Filesystem.resolve(process.cwd())
+
+      const worker = new Worker(file)
+      const client = Rpc.client<typeof rpc>(worker)
+      const reload = () => {
+        client.call("reload", undefined).catch(() => {})
+      }
+      process.on("SIGUSR2", reload)
+
+      let stopped = false
+      const stop = async () => {
+        if (stopped) return
+        stopped = true
+        process.off("SIGUSR2", reload)
+        await withTimeout(client.call("shutdown", undefined), 5000).catch(() => {})
+        worker.terminate()
+      }
+
+      const prompt = await input(args.prompt)
+      const config = await TuiConfig.get()
+
+      const network = resolveNetworkOptionsNoConfig(args)
+      const external =
+        process.argv.includes("--port") ||
+        process.argv.includes("--hostname") ||
+        process.argv.includes("--mdns") ||
+        network.mdns ||
+        network.port !== 0 ||
+        network.hostname !== "127.0.0.1"
+
+      const transport = external
+        ? {
+            url: (await client.call("server", network)).url,
+            fetch: undefined,
+            events: undefined,
+          }
+        : {
+            url: "http://rimuru-ai.internal",
+            fetch: createWorkerFetch(client),
+            events: createEventSource(client),
+          }
+
+      try {
+        await validateSession({
+          url: transport.url,
+          sessionID: args.session,
+          directory: cwd,
+          fetch: transport.fetch,
+        })
+      } catch (error) {
+        UI.error(errorMessage(error))
+        process.exitCode = 1
+        return
+      }
+
+      setTimeout(() => {
+        client.call("checkUpgrade", { directory: cwd }).catch(() => {})
+      }, 1000).unref?.()
+
+      try {
+        const { Effect } = await import("effect")
+        const { run } = await import("../tui/layer")
+        const { createLegacyTuiPluginHost } = await import("@/plugin/tui/runtime")
+        await Effect.runPromise(
+          run({
+            url: transport.url,
+            async onSnapshot() {
+              const tui = writeHeapSnapshot("tui.heapsnapshot")
+              const server = await client.call("snapshot", undefined)
+              return [tui, server]
+            },
+            config,
+            pluginHost: createLegacyTuiPluginHost(),
+            directory: cwd,
+            fetch: transport.fetch,
+            events: transport.events,
+            args: {
+              continue: args.continue,
+              sessionID: args.session,
+              agent: args.agent,
+              model: args.model,
+              prompt,
+              fork: args.fork,
+            },
+          }),
+        )
+      } finally {
+        await stop()
+      }
+    } finally {
+      try {
+        unguard?.()
+      } catch {}
+    }
+    process.exit(0)
+  },
+})
+// scratch

package/src/cli/cmd/uninstall.ts

@@ -0,0 +1,353 @@
+import type { Argv } from "yargs"
+import { UI } from "../ui"
+import * as prompts from "@clack/prompts"
+import { Installation } from "../../installation"
+import { Global } from "@rimurucode-ai/core/global"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+import { Filesystem } from "@/util/filesystem"
+import { Process } from "@/util/process"
+
+interface UninstallArgs {
+  keepConfig: boolean
+  keepData: boolean
+  dryRun: boolean
+  force: boolean
+}
+
+interface RemovalTargets {
+  directories: Array<{ path: string; label: string; keep: boolean }>
+  shellConfig: string | null
+  binary: string | null
+}
+
+export const UninstallCommand = {
+  command: "uninstall",
+  describe: "uninstall rimuru-ai and remove all related files",
+  builder: (yargs: Argv) =>
+    yargs
+      .option("keep-config", {
+        alias: "c",
+        type: "boolean",
+        describe: "keep configuration files",
+        default: false,
+      })
+      .option("keep-data", {
+        alias: "d",
+        type: "boolean",
+        describe: "keep session data and snapshots",
+        default: false,
+      })
+      .option("dry-run", {
+        type: "boolean",
+        describe: "show what would be removed without removing",
+        default: false,
+      })
+      .option("force", {
+        alias: "f",
+        type: "boolean",
+        describe: "skip confirmation prompts",
+        default: false,
+      }),
+
+  handler: async (args: UninstallArgs) => {
+    UI.empty()
+    UI.println(UI.logo("  "))
+    UI.empty()
+    prompts.intro("Uninstall Rimuru")
+
+    const method = await Installation.method()
+    prompts.log.info(`Installation method: ${method}`)
+
+    const targets = await collectRemovalTargets(args, method)
+
+    await showRemovalSummary(targets, method)
+
+    if (!args.force && !args.dryRun) {
+      const confirm = await prompts.confirm({
+        message: "Are you sure you want to uninstall?",
+        initialValue: false,
+      })
+      if (!confirm || prompts.isCancel(confirm)) {
+        prompts.outro("Cancelled")
+        return
+      }
+    }
+
+    if (args.dryRun) {
+      prompts.log.warn("Dry run - no changes made")
+      prompts.outro("Done")
+      return
+    }
+
+    await executeUninstall(method, targets)
+
+    prompts.outro("Done")
+  },
+}
+
+async function collectRemovalTargets(args: UninstallArgs, method: Installation.Method): Promise<RemovalTargets> {
+  const directories: RemovalTargets["directories"] = [
+    { path: Global.Path.data, label: "Data", keep: args.keepData },
+    { path: Global.Path.cache, label: "Cache", keep: false },
+    { path: Global.Path.config, label: "Config", keep: args.keepConfig },
+    { path: Global.Path.state, label: "State", keep: false },
+  ]
+
+  const shellConfig = method === "curl" ? await getShellConfigFile() : null
+  const binary = method === "curl" ? process.execPath : null
+
+  return { directories, shellConfig, binary }
+}
+
+async function showRemovalSummary(targets: RemovalTargets, method: Installation.Method) {
+  prompts.log.message("The following will be removed:")
+
+  for (const dir of targets.directories) {
+    const exists = await fs
+      .access(dir.path)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) continue
+
+    const size = await getDirectorySize(dir.path)
+    const sizeStr = formatSize(size)
+    const status = dir.keep ? UI.Style.TEXT_DIM + "(keeping)" : ""
+    const prefix = dir.keep ? "○" : "✓"
+
+    prompts.log.info(`  ${prefix} ${dir.label}: ${shortenPath(dir.path)} ${UI.Style.TEXT_DIM}(${sizeStr})${status}`)
+  }
+
+  if (targets.binary) {
+    prompts.log.info(`  ✓ Binary: ${shortenPath(targets.binary)}`)
+  }
+
+  if (targets.shellConfig) {
+    prompts.log.info(`  ✓ Shell PATH in ${shortenPath(targets.shellConfig)}`)
+  }
+
+  if (method !== "curl" && method !== "unknown") {
+    const cmds: Record<string, string> = {
+      npm: "npm uninstall -g rimuru-ai",
+      pnpm: "pnpm uninstall -g rimuru-ai",
+      bun: "bun remove -g rimuru-ai",
+      yarn: "yarn global remove rimuru-ai",
+      brew: "brew uninstall rimuru-ai",
+      choco: "choco uninstall rimuru-ai",
+      scoop: "scoop uninstall rimuru-ai",
+    }
+    prompts.log.info(`  ✓ Package: ${cmds[method] || method}`)
+  }
+}
+
+async function executeUninstall(method: Installation.Method, targets: RemovalTargets) {
+  const spinner = prompts.spinner()
+  const errors: string[] = []
+
+  for (const dir of targets.directories) {
+    if (dir.keep) {
+      prompts.log.step(`Skipping ${dir.label} (--keep-${dir.label.toLowerCase()})`)
+      continue
+    }
+
+    const exists = await fs
+      .access(dir.path)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) continue
+
+    spinner.start(`Removing ${dir.label}...`)
+    const err = await fs.rm(dir.path, { recursive: true, force: true }).catch((e) => e)
+    if (err) {
+      spinner.stop(`Failed to remove ${dir.label}`, 1)
+      errors.push(`${dir.label}: ${err.message}`)
+      continue
+    }
+    spinner.stop(`Removed ${dir.label}`)
+  }
+
+  if (targets.shellConfig) {
+    spinner.start("Cleaning shell config...")
+    const err = await cleanShellConfig(targets.shellConfig).catch((e) => e)
+    if (err) {
+      spinner.stop("Failed to clean shell config", 1)
+      errors.push(`Shell config: ${err.message}`)
+    } else {
+      spinner.stop("Cleaned shell config")
+    }
+  }
+
+  if (method !== "curl" && method !== "unknown") {
+    const cmds: Record<string, string[]> = {
+      npm: ["npm", "uninstall", "-g", "rimuru-ai"],
+      pnpm: ["pnpm", "uninstall", "-g", "rimuru-ai"],
+      bun: ["bun", "remove", "-g", "rimuru-ai"],
+      yarn: ["yarn", "global", "remove", "rimuru-ai"],
+      brew: ["brew", "uninstall", "rimuru-ai"],
+      choco: ["choco", "uninstall", "rimuru-ai"],
+      scoop: ["scoop", "uninstall", "rimuru-ai"],
+    }
+
+    const cmd = cmds[method]
+    if (cmd) {
+      spinner.start(`Running ${cmd.join(" ")}...`)
+      const result = await Process.run(method === "choco" ? ["choco", "uninstall", "rimuru-ai", "-y", "-r"] : cmd, {
+        nothrow: true,
+      })
+      if (result.code !== 0) {
+        spinner.stop(`Package manager uninstall failed: exit code ${result.code}`, 1)
+        const text = `${result.stdout.toString("utf8")}\n${result.stderr.toString("utf8")}`
+        if (method === "choco" && text.includes("not running from an elevated command shell")) {
+          prompts.log.warn(`You may need to run '${cmd.join(" ")}' from an elevated command shell`)
+        } else {
+          prompts.log.warn(`You may need to run manually: ${cmd.join(" ")}`)
+        }
+      } else {
+        spinner.stop("Package removed")
+      }
+    }
+  }
+
+  if (method === "curl" && targets.binary) {
+    UI.empty()
+    prompts.log.message("To finish removing the binary, run:")
+    prompts.log.info(`  rm "${targets.binary}"`)
+
+    const binDir = path.dirname(targets.binary)
+    if (binDir.includes(".rimuru")) {
+      prompts.log.info(`  rmdir "${binDir}" 2>/dev/null`)
+    }
+  }
+
+  if (errors.length > 0) {
+    UI.empty()
+    prompts.log.warn("Some operations failed:")
+    for (const err of errors) {
+      prompts.log.error(`  ${err}`)
+    }
+  }
+
+  UI.empty()
+  prompts.log.success("Thank you for using Rimuru!")
+}
+
+async function getShellConfigFile(): Promise<string | null> {
+  const shell = path.basename(process.env.SHELL || "bash")
+  const home = os.homedir()
+  const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(home, ".config")
+
+  const configFiles: Record<string, string[]> = {
+    fish: [path.join(xdgConfig, "fish", "config.fish")],
+    zsh: [
+      path.join(home, ".zshrc"),
+      path.join(home, ".zshenv"),
+      path.join(xdgConfig, "zsh", ".zshrc"),
+      path.join(xdgConfig, "zsh", ".zshenv"),
+    ],
+    bash: [
+      path.join(home, ".bashrc"),
+      path.join(home, ".bash_profile"),
+      path.join(home, ".profile"),
+      path.join(xdgConfig, "bash", ".bashrc"),
+      path.join(xdgConfig, "bash", ".bash_profile"),
+    ],
+    ash: [path.join(home, ".ashrc"), path.join(home, ".profile")],
+    sh: [path.join(home, ".profile")],
+  }
+
+  const candidates = configFiles[shell] || configFiles.bash
+
+  for (const file of candidates) {
+    const exists = await fs
+      .access(file)
+      .then(() => true)
+      .catch(() => false)
+    if (!exists) continue
+
+    const content = await Filesystem.readText(file).catch(() => "")
+    if (content.includes("# rimuru-ai") || content.includes(".rimuru/bin")) {
+      return file
+    }
+  }
+
+  return null
+}
+
+async function cleanShellConfig(file: string) {
+  const content = await Filesystem.readText(file)
+  const lines = content.split("\n")
+
+  const filtered: string[] = []
+  let skip = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    if (trimmed === "# rimuru-ai") {
+      skip = true
+      continue
+    }
+
+    if (skip) {
+      skip = false
+      if (trimmed.includes(".rimuru/bin") || trimmed.includes("fish_add_path")) {
+        continue
+      }
+    }
+
+    if (
+      (trimmed.startsWith("export PATH=") && trimmed.includes(".rimuru/bin")) ||
+      (trimmed.startsWith("fish_add_path") && trimmed.includes(".rimuru"))
+    ) {
+      continue
+    }
+
+    filtered.push(line)
+  }
+
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+    filtered.pop()
+  }
+
+  const output = filtered.join("\n") + "\n"
+  await Filesystem.write(file, output)
+}
+
+async function getDirectorySize(dir: string): Promise<number> {
+  let total = 0
+
+  const walk = async (current: string) => {
+    const entries = await fs.readdir(current, { withFileTypes: true }).catch(() => [])
+
+    for (const entry of entries) {
+      const full = path.join(current, entry.name)
+      if (entry.isDirectory()) {
+        await walk(full)
+        continue
+      }
+      if (entry.isFile()) {
+        const stat = await fs.stat(full).catch(() => null)
+        if (stat) total += stat.size
+      }
+    }
+  }
+
+  await walk(dir)
+  return total
+}
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`
+}
+
+function shortenPath(p: string): string {
+  const home = os.homedir()
+  if (p.startsWith(home)) {
+    return p.replace(home, "~")
+  }
+  return p
+}

package/src/cli/cmd/upgrade.ts

@@ -0,0 +1,74 @@
+import type { Argv } from "yargs"
+import { UI } from "../ui"
+import * as prompts from "@clack/prompts"
+import { Installation } from "../../installation"
+import { InstallationVersion } from "@rimurucode-ai/core/installation/version"
+
+export const UpgradeCommand = {
+  command: "upgrade [target]",
+  describe: "upgrade rimuru-ai to the latest or a specific version",
+  builder: (yargs: Argv) => {
+    return yargs
+      .positional("target", {
+        describe: "version to upgrade to, for ex '0.1.48' or 'v0.1.48'",
+        type: "string",
+      })
+      .option("method", {
+        alias: "m",
+        describe: "installation method to use",
+        type: "string",
+        choices: ["curl", "npm", "pnpm", "bun", "brew", "choco", "scoop"],
+      })
+  },
+  handler: async (args: { target?: string; method?: string }) => {
+    UI.empty()
+    UI.println(UI.logo("  "))
+    UI.empty()
+    prompts.intro("Upgrade")
+    const detectedMethod = await Installation.method()
+    const method = (args.method as Installation.Method) ?? detectedMethod
+    if (method === "unknown") {
+      prompts.log.error(`rimuru-ai is installed to ${process.execPath} and may be managed by a package manager`)
+      const install = await prompts.select({
+        message: "Install anyways?",
+        options: [
+          { label: "Yes", value: true },
+          { label: "No", value: false },
+        ],
+        initialValue: false,
+      })
+      if (!install) {
+        prompts.outro("Done")
+        return
+      }
+    }
+    prompts.log.info("Using method: " + method)
+    const target = args.target ? args.target.replace(/^v/, "") : await Installation.latest()
+
+    if (InstallationVersion === target) {
+      prompts.log.warn(`rimuru-ai upgrade skipped: ${target} is already installed`)
+      prompts.outro("Done")
+      return
+    }
+
+    prompts.log.info(`From ${InstallationVersion} → ${target}`)
+    const spinner = prompts.spinner()
+    spinner.start("Upgrading...")
+    const err = await Installation.upgrade(method, target).catch((err) => err)
+    if (err) {
+      spinner.stop("Upgrade failed", 1)
+      if (err instanceof Installation.UpgradeFailedError) {
+        // necessary because choco only allows install/upgrade in elevated terminals
+        if (method === "choco" && err.stderr.includes("not running from an elevated command shell")) {
+          prompts.log.error("Please run the terminal as Administrator and try again")
+        } else {
+          prompts.log.error(err.stderr)
+        }
+      } else if (err instanceof Error) prompts.log.error(err.message)
+      prompts.outro("Done")
+      return
+    }
+    spinner.stop("Upgrade complete")
+    prompts.outro("Done")
+  },
+}