codepro-ia 1.0.0

package/src/cli/cmd/uninstall.ts

@@ -0,0 +1,344 @@
+import type { Argv } from "yargs"
+import { UI } from "../ui"
+import * as prompts from "@clack/prompts"
+import { Installation } from "../../installation"
+import { Global } from "../../global"
+import { $ } from "bun"
+import fs from "fs/promises"
+import path from "path"
+import os from "os"
+
+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 opencode 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 OpenCode")
+
+    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 opencode-ai",
+      pnpm: "pnpm uninstall -g opencode-ai",
+      bun: "bun remove -g opencode-ai",
+      yarn: "yarn global remove opencode-ai",
+      brew: "brew uninstall opencode",
+    }
+    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", "opencode-ai"],
+      pnpm: ["pnpm", "uninstall", "-g", "opencode-ai"],
+      bun: ["bun", "remove", "-g", "opencode-ai"],
+      yarn: ["yarn", "global", "remove", "opencode-ai"],
+      brew: ["brew", "uninstall", "opencode"],
+    }
+
+    const cmd = cmds[method]
+    if (cmd) {
+      spinner.start(`Running ${cmd.join(" ")}...`)
+      const result = await $`${cmd}`.quiet().nothrow()
+      if (result.exitCode !== 0) {
+        spinner.stop(`Package manager uninstall failed`, 1)
+        prompts.log.warn(`You may need to run manually: ${cmd.join(" ")}`)
+        errors.push(`Package manager: exit code ${result.exitCode}`)
+      } 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(".opencode")) {
+      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 OpenCode!")
+}
+
+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 Bun.file(file)
+      .text()
+      .catch(() => "")
+    if (content.includes("# opencode") || content.includes(".opencode/bin")) {
+      return file
+    }
+  }
+
+  return null
+}
+
+async function cleanShellConfig(file: string) {
+  const content = await Bun.file(file).text()
+  const lines = content.split("\n")
+
+  const filtered: string[] = []
+  let skip = false
+
+  for (const line of lines) {
+    const trimmed = line.trim()
+
+    if (trimmed === "# opencode") {
+      skip = true
+      continue
+    }
+
+    if (skip) {
+      skip = false
+      if (trimmed.includes(".opencode/bin") || trimmed.includes("fish_add_path")) {
+        continue
+      }
+    }
+
+    if (
+      (trimmed.startsWith("export PATH=") && trimmed.includes(".opencode/bin")) ||
+      (trimmed.startsWith("fish_add_path") && trimmed.includes(".opencode"))
+    ) {
+      continue
+    }
+
+    filtered.push(line)
+  }
+
+  while (filtered.length > 0 && filtered[filtered.length - 1].trim() === "") {
+    filtered.pop()
+  }
+
+  const output = filtered.join("\n") + "\n"
+  await Bun.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,73 @@
+import type { Argv } from "yargs"
+import { UI } from "../ui"
+import * as prompts from "@clack/prompts"
+import { Installation } from "../../installation"
+
+export const UpgradeCommand = {
+  command: "upgrade [target]",
+  describe: "upgrade opencode 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(`opencode 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 (Installation.VERSION === target) {
+      prompts.log.warn(`opencode upgrade skipped: ${target} is already installed`)
+      prompts.outro("Done")
+      return
+    }
+
+    prompts.log.info(`From ${Installation.VERSION} → ${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.data.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.data.stderr)
+        }
+      } else if (err instanceof Error) prompts.log.error(err.message)
+      prompts.outro("Done")
+      return
+    }
+    spinner.stop("Upgrade complete")
+    prompts.outro("Done")
+  },
+}

package/src/cli/cmd/web.ts

@@ -0,0 +1,81 @@
+import { Server } from "../../server/server"
+import { UI } from "../ui"
+import { cmd } from "./cmd"
+import { withNetworkOptions, resolveNetworkOptions } from "../network"
+import { Flag } from "../../flag/flag"
+import open from "open"
+import { networkInterfaces } from "os"
+
+function getNetworkIPs() {
+  const nets = networkInterfaces()
+  const results: string[] = []
+
+  for (const name of Object.keys(nets)) {
+    const net = nets[name]
+    if (!net) continue
+
+    for (const netInfo of net) {
+      // Skip internal and non-IPv4 addresses
+      if (netInfo.internal || netInfo.family !== "IPv4") continue
+
+      // Skip Docker bridge networks (typically 172.x.x.x)
+      if (netInfo.address.startsWith("172.")) continue
+
+      results.push(netInfo.address)
+    }
+  }
+
+  return results
+}
+
+export const WebCommand = cmd({
+  command: "web",
+  builder: (yargs) => withNetworkOptions(yargs),
+  describe: "start opencode server and open web interface",
+  handler: async (args) => {
+    if (!Flag.OPENCODE_SERVER_PASSWORD) {
+      UI.println(UI.Style.TEXT_WARNING_BOLD + "!  " + "OPENCODE_SERVER_PASSWORD is not set; server is unsecured.")
+    }
+    const opts = await resolveNetworkOptions(args)
+    const server = Server.listen(opts)
+    UI.empty()
+    UI.println(UI.logo("  "))
+    UI.empty()
+
+    if (opts.hostname === "0.0.0.0") {
+      // Show localhost for local access
+      const localhostUrl = `http://localhost:${server.port}`
+      UI.println(UI.Style.TEXT_INFO_BOLD + "  Local access:      ", UI.Style.TEXT_NORMAL, localhostUrl)
+
+      // Show network IPs for remote access
+      const networkIPs = getNetworkIPs()
+      if (networkIPs.length > 0) {
+        for (const ip of networkIPs) {
+          UI.println(
+            UI.Style.TEXT_INFO_BOLD + "  Network access:    ",
+            UI.Style.TEXT_NORMAL,
+            `http://${ip}:${server.port}`,
+          )
+        }
+      }
+
+      if (opts.mdns) {
+        UI.println(
+          UI.Style.TEXT_INFO_BOLD + "  mDNS:              ",
+          UI.Style.TEXT_NORMAL,
+          `opencode.local:${server.port}`,
+        )
+      }
+
+      // Open localhost in browser
+      open(localhostUrl.toString()).catch(() => {})
+    } else {
+      const displayUrl = server.url.toString()
+      UI.println(UI.Style.TEXT_INFO_BOLD + "  Web interface:    ", UI.Style.TEXT_NORMAL, displayUrl)
+      open(displayUrl).catch(() => {})
+    }
+
+    await new Promise(() => {})
+    await server.stop()
+  },
+})

package/src/cli/error.ts

@@ -0,0 +1,57 @@
+import { ConfigMarkdown } from "@/config/markdown"
+import { Config } from "../config/config"
+import { MCP } from "../mcp"
+import { Provider } from "../provider/provider"
+import { UI } from "./ui"
+
+export function FormatError(input: unknown) {
+  if (MCP.Failed.isInstance(input))
+    return `MCP server "${input.data.name}" failed. Note, opencode does not support MCP authentication yet.`
+  if (Provider.ModelNotFoundError.isInstance(input)) {
+    const { providerID, modelID, suggestions } = input.data
+    return [
+      `Model not found: ${providerID}/${modelID}`,
+      ...(Array.isArray(suggestions) && suggestions.length ? ["Did you mean: " + suggestions.join(", ")] : []),
+      `Try: \`opencode models\` to list available models`,
+      `Or check your config (opencode.json) provider/model names`,
+    ].join("\n")
+  }
+  if (Provider.InitError.isInstance(input)) {
+    return `Failed to initialize provider "${input.data.providerID}". Check credentials and configuration.`
+  }
+  if (Config.JsonError.isInstance(input)) {
+    return (
+      `Config file at ${input.data.path} is not valid JSON(C)` + (input.data.message ? `: ${input.data.message}` : "")
+    )
+  }
+  if (Config.ConfigDirectoryTypoError.isInstance(input)) {
+    return `Directory "${input.data.dir}" in ${input.data.path} is not valid. Rename the directory to "${input.data.suggestion}" or remove it. This is a common typo.`
+  }
+  if (ConfigMarkdown.FrontmatterError.isInstance(input)) {
+    return input.data.message
+  }
+  if (Config.InvalidError.isInstance(input))
+    return [
+      `Configuration is invalid${input.data.path && input.data.path !== "config" ? ` at ${input.data.path}` : ""}` +
+        (input.data.message ? `: ${input.data.message}` : ""),
+      ...(input.data.issues?.map((issue) => "↳ " + issue.message + " " + issue.path.join(".")) ?? []),
+    ].join("\n")
+
+  if (UI.CancelledError.isInstance(input)) return ""
+}
+
+export function FormatUnknownError(input: unknown): string {
+  if (input instanceof Error) {
+    return input.stack ?? `${input.name}: ${input.message}`
+  }
+
+  if (typeof input === "object" && input !== null) {
+    try {
+      return JSON.stringify(input, null, 2)
+    } catch {
+      return "Unexpected error (unserializable)"
+    }
+  }
+
+  return String(input)
+}

package/src/cli/network.ts

@@ -0,0 +1,53 @@
+import type { Argv, InferredOptionTypes } from "yargs"
+import { Config } from "../config/config"
+
+const options = {
+  port: {
+    type: "number" as const,
+    describe: "port to listen on",
+    default: 0,
+  },
+  hostname: {
+    type: "string" as const,
+    describe: "hostname to listen on",
+    default: "127.0.0.1",
+  },
+  mdns: {
+    type: "boolean" as const,
+    describe: "enable mDNS service discovery (defaults hostname to 0.0.0.0)",
+    default: false,
+  },
+  cors: {
+    type: "string" as const,
+    array: true,
+    describe: "additional domains to allow for CORS",
+    default: [] as string[],
+  },
+}
+
+export type NetworkOptions = InferredOptionTypes<typeof options>
+
+export function withNetworkOptions<T>(yargs: Argv<T>) {
+  return yargs.options(options)
+}
+
+export async function resolveNetworkOptions(args: NetworkOptions) {
+  const config = await Config.global()
+  const portExplicitlySet = process.argv.includes("--port")
+  const hostnameExplicitlySet = process.argv.includes("--hostname")
+  const mdnsExplicitlySet = process.argv.includes("--mdns")
+  const corsExplicitlySet = process.argv.includes("--cors")
+
+  const mdns = mdnsExplicitlySet ? args.mdns : (config?.server?.mdns ?? args.mdns)
+  const port = portExplicitlySet ? args.port : (config?.server?.port ?? args.port)
+  const hostname = hostnameExplicitlySet
+    ? args.hostname
+    : mdns && !config?.server?.hostname
+      ? "0.0.0.0"
+      : (config?.server?.hostname ?? args.hostname)
+  const configCors = config?.server?.cors ?? []
+  const argsCors = Array.isArray(args.cors) ? args.cors : args.cors ? [args.cors] : []
+  const cors = [...configCors, ...argsCors]
+
+  return { hostname, port, mdns, cors }
+}

package/src/cli/ui.ts

@@ -0,0 +1,88 @@
+import z from "zod"
+import { EOL } from "os"
+import { NamedError } from "@codepro-ai/util/error"
+
+export namespace UI {
+  const LOGO = [
+    [`      o   o    `, ` .d8888b.   .d88b.  8888888b.  8888888888 8888888b.  8888888b.   .d88b.  `],
+    [`       \\_/     `, `d88P  Y88b d88""88b 888  "Y88b 888        888   Y88b 888   Y88b d88""88b `],
+    [`      (o o)    `, `888    888 888  888 888    888 888        888    888 888    888 888  888 `],
+    [`     (  v  )   `, `888        888  888 888    888 8888888    888   d88P 888   d88P 888  888 `],
+    [`      \\   /    `, `888        888  888 888    888 888        8888888P"  8888888P"  888  888 `],
+    [`      |   |    `, `888    888 888  888 888    888 888        888        888 T88b   888  888 `],
+    [`      | O |    `, `Y88b  d88P Y88..88P 888  .d88P 888        888        888  T88b  Y88..88P `],
+    [`      |   |    `, ` "Y8888P"   "Y88P"  8888888P"  8888888888 888        888   T88b  "Y88P"  `],
+  ]
+
+  export const CancelledError = NamedError.create("UICancelledError", z.void())
+
+  export const Style = {
+    TEXT_HIGHLIGHT: "\x1b[96m",
+    TEXT_HIGHLIGHT_BOLD: "\x1b[96m\x1b[1m",
+    TEXT_DIM: "\x1b[90m",
+    TEXT_DIM_BOLD: "\x1b[90m\x1b[1m",
+    TEXT_NORMAL: "\x1b[0m",
+    TEXT_NORMAL_BOLD: "\x1b[1m",
+    TEXT_WARNING: "\x1b[93m",
+    TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
+    TEXT_DANGER: "\x1b[91m",
+    TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
+    TEXT_SUCCESS: "\x1b[92m",
+    TEXT_SUCCESS_BOLD: "\x1b[92m\x1b[1m",
+    TEXT_INFO: "\x1b[94m",
+    TEXT_INFO_BOLD: "\x1b[94m\x1b[1m",
+  }
+
+  export function println(...message: string[]) {
+    print(...message)
+    Bun.stderr.write(EOL)
+  }
+
+  export function print(...message: string[]) {
+    blank = false
+    Bun.stderr.write(message.join(" "))
+  }
+
+  let blank = false
+  export function empty() {
+    if (blank) return
+    println("" + Style.TEXT_NORMAL)
+    blank = true
+  }
+
+  export function logo(pad?: string) {
+    const result = []
+    for (const row of LOGO) {
+      if (pad) result.push(pad)
+      result.push(Bun.color("gray", "ansi"))
+      result.push(row[0])
+      result.push("\x1b[0m")
+      result.push(row[1])
+      result.push(EOL)
+    }
+    return result.join("").trimEnd()
+  }
+
+  export async function input(prompt: string): Promise<string> {
+    const readline = require("readline")
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    })
+
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer: string) => {
+        rl.close()
+        resolve(answer.trim())
+      })
+    })
+  }
+
+  export function error(message: string) {
+    println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
+  }
+
+  export function markdown(text: string): string {
+    return text
+  }
+}