refactor(opencode): replace Bun shell in core flows (#16286)

packages/opencode/src/installation/index.ts

@@ -1,11 +1,12 @@
 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"
+import { Process } from "@/util/process"
+import { buffer } from "node:stream/consumers"
 
 declare global {
   const OPENCODE_VERSION: string
@@ -15,6 +16,38 @@ declare global {
 export namespace Installation {
   const log = Log.create({ service: "installation" })
 
+  async function text(cmd: string[], opts: { cwd?: string; env?: NodeJS.ProcessEnv } = {}) {
+    return Process.text(cmd, {
+      cwd: opts.cwd,
+      env: opts.env,
+      nothrow: true,
+    }).then((x) => x.text)
+  }
+
+  async function upgradeCurl(target: string) {
+    const body = await fetch("https://opencode.ai/install").then((res) => {
+      if (!res.ok) throw new Error(res.statusText)
+      return res.text()
+    })
+    const proc = Process.spawn(["bash"], {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+      env: {
+        ...process.env,
+        VERSION: target,
+      },
+    })
+    if (!proc.stdin || !proc.stdout || !proc.stderr) throw new Error("Process output not available")
+    proc.stdin.end(body)
+    const [code, stdout, stderr] = await Promise.all([proc.exited, buffer(proc.stdout), buffer(proc.stderr)])
+    return {
+      code,
+      stdout,
+      stderr,
+    }
+  }
+
   export type Method = Awaited<ReturnType<typeof method>>
 
   export const Event = {
@@ -65,31 +98,31 @@ export namespace Installation {
     const checks = [
       {
         name: "npm" as const,
-        command: () => $`npm list -g --depth=0`.throws(false).quiet().text(),
+        command: () => text(["npm", "list", "-g", "--depth=0"]),
       },
       {
         name: "yarn" as const,
-        command: () => $`yarn global list`.throws(false).quiet().text(),
+        command: () => text(["yarn", "global", "list"]),
       },
       {
         name: "pnpm" as const,
-        command: () => $`pnpm list -g --depth=0`.throws(false).quiet().text(),
+        command: () => text(["pnpm", "list", "-g", "--depth=0"]),
       },
       {
         name: "bun" as const,
-        command: () => $`bun pm ls -g`.throws(false).quiet().text(),
+        command: () => text(["bun", "pm", "ls", "-g"]),
       },
       {
         name: "brew" as const,
-        command: () => $`brew list --formula opencode`.throws(false).quiet().text(),
+        command: () => text(["brew", "list", "--formula", "opencode"]),
       },
       {
         name: "scoop" as const,
-        command: () => $`scoop list opencode`.throws(false).quiet().text(),
+        command: () => text(["scoop", "list", "opencode"]),
       },
       {
         name: "choco" as const,
-        command: () => $`choco list --limit-output opencode`.throws(false).quiet().text(),
+        command: () => text(["choco", "list", "--limit-output", "opencode"]),
       },
     ]
 
@@ -121,61 +154,70 @@ export namespace Installation {
   )
 
   async function getBrewFormula() {
-    const tapFormula = await $`brew list --formula anomalyco/tap/opencode`.throws(false).quiet().text()
+    const tapFormula = await text(["brew", "list", "--formula", "anomalyco/tap/opencode"])
     if (tapFormula.includes("opencode")) return "anomalyco/tap/opencode"
-    const coreFormula = await $`brew list --formula opencode`.throws(false).quiet().text()
+    const coreFormula = await text(["brew", "list", "--formula", "opencode"])
     if (coreFormula.includes("opencode")) return "opencode"
     return "opencode"
   }
 
   export async function upgrade(method: Method, target: string) {
-    let cmd
+    let result: Awaited<ReturnType<typeof upgradeCurl>> | undefined
     switch (method) {
       case "curl":
-        cmd = $`curl -fsSL https://opencode.ai/install | bash`.env({
-          ...process.env,
-          VERSION: target,
-        })
+        result = await upgradeCurl(target)
         break
       case "npm":
-        cmd = $`npm install -g opencode-ai@${target}`
+        result = await Process.run(["npm", "install", "-g", `opencode-ai@${target}`], { nothrow: true })
         break
       case "pnpm":
-        cmd = $`pnpm install -g opencode-ai@${target}`
+        result = await Process.run(["pnpm", "install", "-g", `opencode-ai@${target}`], { nothrow: true })
         break
       case "bun":
-        cmd = $`bun install -g opencode-ai@${target}`
+        result = await Process.run(["bun", "install", "-g", `opencode-ai@${target}`], { nothrow: true })
         break
       case "brew": {
         const formula = await getBrewFormula()
-        if (formula.includes("/")) {
-          cmd =
-            $`brew tap anomalyco/tap && cd "$(brew --repo anomalyco/tap)" && git pull --ff-only && brew upgrade ${formula}`.env(
-              {
-                HOMEBREW_NO_AUTO_UPDATE: "1",
-                ...process.env,
-              },
-            )
-          break
-        }
-        cmd = $`brew upgrade ${formula}`.env({
+        const env = {
           HOMEBREW_NO_AUTO_UPDATE: "1",
           ...process.env,
-        })
+        }
+        if (formula.includes("/")) {
+          const tap = await Process.run(["brew", "tap", "anomalyco/tap"], { env, nothrow: true })
+          if (tap.code !== 0) {
+            result = tap
+            break
+          }
+          const repo = await Process.text(["brew", "--repo", "anomalyco/tap"], { env, nothrow: true })
+          if (repo.code !== 0) {
+            result = repo
+            break
+          }
+          const dir = repo.text.trim()
+          if (dir) {
+            const pull = await Process.run(["git", "pull", "--ff-only"], { cwd: dir, env, nothrow: true })
+            if (pull.code !== 0) {
+              result = pull
+              break
+            }
+          }
+        }
+        result = await Process.run(["brew", "upgrade", formula], { env, nothrow: true })
         break
       }
+
       case "choco":
-        cmd = $`echo Y | choco upgrade opencode --version=${target}`
+        result = await Process.run(["choco", "upgrade", "opencode", `--version=${target}`, "-y"], { nothrow: true })
         break
       case "scoop":
-        cmd = $`scoop install opencode@${target}`
+        result = await Process.run(["scoop", "install", `opencode@${target}`], { nothrow: true })
         break
       default:
         throw new Error(`Unknown method: ${method}`)
     }
-    const result = await cmd.quiet().throws(false)
-    if (result.exitCode !== 0) {
-      const stderr = method === "choco" ? "not running from an elevated command shell" : result.stderr.toString("utf8")
+    if (!result || result.code !== 0) {
+      const stderr =
+        method === "choco" ? "not running from an elevated command shell" : result?.stderr.toString("utf8") || ""
       throw new UpgradeFailedError({
         stderr: stderr,
       })
@@ -186,7 +228,7 @@ export namespace Installation {
       stdout: result.stdout.toString(),
       stderr: result.stderr.toString(),
     })
-    await $`${process.execPath} --version`.nothrow().quiet().text()
+    await Process.text([process.execPath, "--version"], { nothrow: true })
   }
 
   export const VERSION = typeof OPENCODE_VERSION === "string" ? OPENCODE_VERSION : "local"
@@ -199,7 +241,7 @@ export namespace Installation {
     if (detectedMethod === "brew") {
       const formula = await getBrewFormula()
       if (formula.includes("/")) {
-        const infoJson = await $`brew info --json=v2 ${formula}`.quiet().text()
+        const infoJson = await text(["brew", "info", "--json=v2", formula])
         const info = JSON.parse(infoJson)
         const version = info.formulae?.[0]?.versions?.stable
         if (!version) throw new Error(`Could not detect version for tap formula: ${formula}`)
@@ -215,7 +257,7 @@ export namespace Installation {
 
     if (detectedMethod === "npm" || detectedMethod === "bun" || detectedMethod === "pnpm") {
       const registry = await iife(async () => {
-        const r = (await $`npm config get registry`.quiet().nothrow().text()).trim()
+        const r = (await text(["npm", "config", "get", "registry"])).trim()
         const reg = r || "https://registry.npmjs.org"
         return reg.endsWith("/") ? reg.slice(0, -1) : reg
       })