synabun 2.0.10 → 2.2.0

package/neural-interface/lib/cli-install.js

@@ -3,10 +3,12 @@
 // ═══════════════════════════════════════════
 //
 // What the side panels' Install button runs (POST /api/cli/install/:tool,
-// lib/cli-install-api.js) when Claude Code, Codex or OpenCode is not installed.
-// Each tool is installed the way its vendor documents for the system, from the
-// vendor's own source, with nothing else needed (no Node, npm, Homebrew or
-// Scoop). The sources are fixed here; a request only names the tool.
+// lib/cli-install-api.js) when Claude Code, Codex, OpenCode or the Antigravity
+// CLI is not installed. Each tool is installed the way its vendor documents for
+// the system, from the vendor's own source, with nothing else needed (no Node,
+// npm or Scoop; Homebrew only where it is installed already, for the
+// Antigravity CLI's cask on macOS). The sources are fixed here; a request only
+// names the tool.
 //
 //   Claude Code  Anthropic's native installer: https://claude.ai/install.sh
 //                (bash) on macOS and Linux, https://claude.ai/install.ps1
@@ -19,34 +21,40 @@
 //                checked against the SHA-256 GitHub publishes for it, or, when
 //                GitHub's API does not answer, from https://chatgpt.com/codex/
 //                (the same file). The installer checks the package it fetches.
-//   OpenCode     the install script https://opencode.ai/install (bash) on
-//                macOS and Linux. On Windows, where that script does not run:
-//                the newest OpenCode 1 release archive for the processor
-//                (opencode-windows-x64-baseline.zip, which runs on every x64
-//                CPU, or opencode-windows-arm64.zip) from the anomalyco/opencode
-//                GitHub releases, checked against its published SHA-256, its
-//                opencode.exe read out without an unzip program (the backups'
-//                streaming reader) and put in %USERPROFILE%\.opencode\bin, the
-//                folder the official installer uses (and the resolver looks in).
+//   OpenCode     OpenCode 2's install script https://opencode.ai/v2/install
+//                (bash) on macOS and Linux, the one `opencode upgrade` itself
+//                runs (it puts opencode in ~/.opencode/bin). Windows has no
+//                one-click install: OpenCode 2 comes from WinGet there
+//                (Anomaly.OpenCode), and the banner shows that command.
+//   Antigravity  Google's Antigravity CLI (agy). On a Mac with Homebrew, the
+//                cask antigravity-cli (Google's signed binary, linked as agy):
+//                `brew install --cask antigravity-cli`. Otherwise Google's
+//                installer https://antigravity.google/cli/install.sh (bash) on
+//                macOS and Linux, https://antigravity.google/cli/install.ps1
+//                (powershell.exe -NoProfile -ExecutionPolicy Bypass -File) on
+//                Windows, from antigravity.google only. The script checks the
+//                binary against the SHA-512 of Google's release manifest and
+//                puts agy in ~/.local/bin (%LOCALAPPDATA%\agy\bin on Windows).
 //
 // Every download is HTTPS, every redirect too, and only to the vendor's own
-// hosts. Nothing runs as administrator; everything lands in the user's own
+// hosts (Homebrew downloads a cask itself and checks it against the cask's
+// SHA-256). Nothing runs as administrator; everything lands in the user's own
 // folders. Install consents to adding the resolved CLI's folder to persistent
 // PATH when the vendor did not do so. That is a visible final step, using the
 // same writer as Add to PATH; a failed PATH write leaves the CLI installed and
 // reports a warning. Installers run without a terminal and without questions
-// (CODEX_NON_INTERACTIVE=1, PowerShell -NonInteractive).
+// (CODEX_NON_INTERACTIVE=1, PowerShell -NonInteractive; NONINTERACTIVE=1 and
+// no auto-update for Homebrew).
 //
 // One install per tool at a time. Every failure is a CliInstallError with a
 // `code` the page has words for. Nothing here throws to a caller of start().
 
 import { spawn } from 'node:child_process';
-import { createHash, randomBytes } from 'node:crypto';
-import { createWriteStream, existsSync, mkdirSync, rmSync, renameSync, unlinkSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { accessSync, constants as fsConstants, existsSync, rmSync, statSync } from 'node:fs';
 import { mkdtemp, open } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { openZipArchive } from './backup-zip-reader.js';
 import { buildInstallCommand } from './cli-update-planner.js';
 import { packagedPathLast, rememberedPackagedPath, withPathEnv } from './augmented-path.js';
 
@@ -60,7 +68,6 @@ export const CLI_INSTALL_ERROR_CODES = Object.freeze([
   'timeout',                 // nothing arrived for too long, or the installer ran too long
   'installer-failed',        // the vendor's installer exited with an error
   'not-found-after-install', // it finished, but no working CLI is found
-  'unpack',                  // the archive did not hold the program
   'disk',                    // a file could not be written
   'cancelled',               // stopped (SynaBun shutting down)
   'internal',                // anything else
@@ -79,13 +86,12 @@ export class CliInstallError extends Error {
 export const CLI_INSTALL_GUIDES = Object.freeze({
   'claude-code': 'https://code.claude.com/docs/en/setup',
   codex: 'https://learn.chatgpt.com/docs/codex/cli',
-  opencode: 'https://opencode.ai/docs/',
-  gemini: 'https://github.com/google-gemini/gemini-cli',
+  opencode: 'https://opencode.ai/v2/docs',
+  antigravity: 'https://antigravity.google/docs/getting-started',
 });
 
 const GITHUB_DOWNLOAD_HOSTS = ['github.com', 'objects.githubusercontent.com', 'release-assets.githubusercontent.com', 'github-releases.githubusercontent.com'];
 const MAX_SCRIPT_BYTES = 2 * 1024 * 1024;
-const MAX_ARCHIVE_BYTES = 600 * 1024 * 1024;
 const MAX_JSON_BYTES = 8 * 1024 * 1024;
 const MAX_REDIRECTS = 6;
 const LOG_KEEP = 200;
@@ -95,12 +101,15 @@ const hostIs = (...hosts) => (url) => hosts.includes(url.hostname);
 
 /**
  * The one-click method for a tool on this system, or null when there is none
- * (Gemini CLI, a 32-bit or other system). Pure: tests ask it for every OS.
+ * (OpenCode on Windows, a 32-bit or other system). `brew` is the path of a
+ * Homebrew this process can run (findBrew), or null: on macOS the Antigravity
+ * CLI is installed through it (its cask), else with Google's installer.
+ * `manualCommand`, when a plan has one, is what to type for the same install.
+ * Pure: tests ask it for every OS.
  */
-export function installPlanFor(toolKey, { platform = process.platform, arch = process.arch, env = process.env, home } = {}) {
+export function installPlanFor(toolKey, { platform = process.platform, arch = process.arch, env = process.env, home, brew = null } = {}) {
   if (!(SUPPORTED[platform] || []).includes(arch)) return null;
   const windows = platform === 'win32';
-  const homeDir = home || (windows ? env.USERPROFILE : env.HOME) || os.homedir();
   switch (toolKey) {
     case 'claude-code':
       return {
@@ -126,30 +135,41 @@ export function installPlanFor(toolKey, { platform = process.platform, arch = pr
         env: { CODEX_NON_INTERACTIVE: '1' },
       };
     case 'opencode':
-      if (windows) {
+      // OpenCode 2's own installer is a bash script; on Windows it comes from WinGet (no one-click install).
+      if (windows) return null;
+      return {
+        tool: toolKey,
+        kind: 'script',
+        interpreter: 'bash',
+        url: 'https://opencode.ai/v2/install',
+        allow: (url) => url.hostname === 'opencode.ai' || (url.hostname === 'raw.githubusercontent.com' && url.pathname.startsWith('/anomalyco/opencode/')),
+        source: 'https://opencode.ai/v2/install',
+        label: 'OpenCode 2 install script',
+        env: {},
+      };
+    case 'antigravity':
+      // Homebrew's cask on a Mac that has Homebrew: the CLI then updates with the user's other casks.
+      if (platform === 'darwin' && brew) {
         return {
           tool: toolKey,
-          kind: 'archive',
-          interpreter: null,
-          repo: 'anomalyco/opencode',
-          tag: /^v1\.\d+\.\d+$/,
-          assets: arch === 'arm64' ? ['opencode-windows-arm64.zip'] : ['opencode-windows-x64-baseline.zip', 'opencode-windows-x64.zip'],
-          member: 'opencode.exe',
-          // The official installer's folder; $OPENCODE_INSTALL_DIR, which older installers honoured, when set.
-          dir: env.OPENCODE_INSTALL_DIR || path.win32.join(homeDir, '.opencode', 'bin'),
-          source: 'https://github.com/anomalyco/opencode/releases',
-          label: 'OpenCode release archive',
-          env: {},
+          kind: 'brew',
+          brew,
+          args: ['install', '--cask', 'antigravity-cli'],
+          source: 'https://formulae.brew.sh/cask/antigravity-cli',
+          label: 'Homebrew cask antigravity-cli',
+          manualCommand: 'brew install --cask antigravity-cli',
+          env: { HOMEBREW_NO_AUTO_UPDATE: '1', HOMEBREW_NO_ENV_HINTS: '1', NONINTERACTIVE: '1' },
         };
       }
       return {
         tool: toolKey,
         kind: 'script',
-        interpreter: 'bash',
-        url: 'https://opencode.ai/install',
-        allow: (url) => url.hostname === 'opencode.ai' || (url.hostname === 'raw.githubusercontent.com' && url.pathname.startsWith('/anomalyco/opencode/')),
-        source: 'https://opencode.ai/install',
-        label: 'OpenCode install script',
+        interpreter: windows ? 'powershell' : 'bash',
+        url: windows ? 'https://antigravity.google/cli/install.ps1' : 'https://antigravity.google/cli/install.sh',
+        allow: hostIs('antigravity.google'),
+        source: windows ? 'https://antigravity.google/cli/install.ps1' : 'https://antigravity.google/cli/install.sh',
+        label: 'Google Antigravity CLI installer',
+        manualCommand: windows ? 'irm https://antigravity.google/cli/install.ps1 | iex' : 'curl -fsSL https://antigravity.google/cli/install.sh | bash',
         env: {},
       };
     default:
@@ -157,14 +177,47 @@ export function installPlanFor(toolKey, { platform = process.platform, arch = pr
   }
 }
 
-/** What the status of a tool says about its one-click install. */
-export function describeInstall(toolKey, options) {
-  const plan = installPlanFor(toolKey, options);
+/** A file this process may run (a link is followed). */
+function isExecutableFile(file) {
+  try {
+    if (!statSync(file).isFile()) return false;
+    accessSync(file, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Homebrew's brew on macOS: /opt/homebrew/bin (Apple silicon), /usr/local/bin
+ * (Intel), then each folder of PATH; the first executable file. A relative
+ * PATH folder is never looked in. Null on any other system, and on a Mac
+ * without Homebrew.
+ */
+export function findBrew({ platform = process.platform, env = process.env, isExecutable = isExecutableFile } = {}) {
+  if (platform !== 'darwin') return null;
+  const asked = new Set();
+  for (const folder of ['/opt/homebrew/bin', '/usr/local/bin', ...String(env.PATH || '').split(':')]) {
+    if (!folder || !path.posix.isAbsolute(folder)) continue;
+    const file = path.posix.join(folder, 'brew');
+    if (asked.has(file)) continue;
+    asked.add(file);
+    if (isExecutable(file)) return file;
+  }
+  return null;
+}
+
+function describePlan(plan) {
   return plan
-    ? { available: true, method: plan.kind, source: plan.source, interpreter: plan.interpreter, label: plan.label }
+    ? { available: true, method: plan.kind, source: plan.source, interpreter: plan.interpreter || null, label: plan.label }
     : { available: false, method: null, source: null, interpreter: null, label: null };
 }
 
+/** What the status of a tool says about its one-click install. */
+export function describeInstall(toolKey, options) {
+  return describePlan(installPlanFor(toolKey, options));
+}
+
 // ── Transfers ───────────────────────────────────────────────────────────────
 
 function errorCode(error) {
@@ -340,55 +393,6 @@ export function releaseAsset(release, name, repo) {
   return { name, url, size: Number(asset.size) || null, sha256: sha256OfDigest(asset.digest) };
 }
 
-/**
- * The newest OpenCode 1 release (not a draft, not a prerelease; OpenCode 2 is
- * a different program SynaBun's panel does not drive) that carries one of
- * `assets`, the first listed preferred.
- */
-export function pickOpencodeRelease(releases, { assets, repo = 'anomalyco/opencode', tag = /^v1\.\d+\.\d+$/ } = {}) {
-  for (const release of Array.isArray(releases) ? releases : []) {
-    if (!release || release.draft || release.prerelease || !tag.test(String(release.tag_name || ''))) continue;
-    for (const name of assets || []) {
-      const asset = releaseAsset(release, name, repo);
-      if (asset) return { tag: release.tag_name, version: String(release.tag_name).replace(/^v/, ''), asset };
-    }
-  }
-  return null;
-}
-
-// ── Zip ─────────────────────────────────────────────────────────────────────
-
-const unpack = (message) => new CliInstallError('unpack', message);
-
-/**
- * Read one member out of a zip archive into `destination` (a new file),
- * without an unzip program and without using a name of the archive as a path:
- * only the entry called exactly `member` is read, through the streaming
- * reader of backups (backup-zip-reader.js: ZIP64, stored or deflated, checked
- * against its size and CRC-32).
- */
-export async function extractZipMember({ archive, member, destination, maxSize = 1024 ** 3, mode = 0o755 }) {
-  let zip;
-  try { zip = await openZipArchive(archive); } catch (error) { throw unpack(`The download is not a readable zip archive (${error?.message || error}).`); }
-  let opened = false;
-  try {
-    const entry = zip.getEntry(member);
-    if (!entry) throw unpack(`The archive holds no ${member}.`);
-    if (entry.uncompressedSize > maxSize) throw unpack(`The archive's ${member} is larger than expected.`);
-    const out = createWriteStream(destination, { flags: 'wx', mode });
-    out.on('open', () => { opened = true; });
-    await zip.pipeEntry(entry, out);
-    return { size: entry.uncompressedSize };
-  } catch (error) {
-    if (opened) rmSync(destination, { force: true });
-    if (error instanceof CliInstallError) throw error;
-    if (DISK_CODES.has(errorCode(error))) throw asInstallError(error, 'disk', `The program could not be written (${errorCode(error)}).`);
-    throw unpack(`The archive's ${member} could not be read (${error?.message || error}).`);
-  } finally {
-    try { await zip.close(); } catch { /* closed */ }
-  }
-}
-
 // ── Output ──────────────────────────────────────────────────────────────────
 
 const ANSI = /\x1b\[[0-9;?]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\x1b[()][A-Za-z0-9]|\x1b[=>78DEHMNOZc]/g;
@@ -423,6 +427,19 @@ export function createLineSplitter(onLine) {
   };
 }
 
+/**
+ * The step a line of Homebrew's output begins, or null: its download (and its
+ * download queue's "Fetching"), the check of what it downloaded against the
+ * cask's checksum, and the install itself (moving and linking the binary).
+ */
+export function brewStepOf(line) {
+  const text = String(line ?? '').trim();
+  if (/^==> (?:Downloading|Fetching)\b/.test(text)) return 'download';
+  if (/^==> Verifying\b/.test(text) || /checksum|sha-?256/i.test(text)) return 'verify';
+  if (/^==> (?:Installing|Moving|Linking)\b/.test(text)) return 'run';
+  return null;
+}
+
 function sameDir(a, b, platform) {
   const clean = (value) => {
     const text = String(value || '').replace(/[\\/]+$/, '');
@@ -442,6 +459,7 @@ export function onPathList(dir, entries, platform = process.platform) {
  * @param {object} deps
  * @param {{ resolve: Function }} deps.resolver  cli-resolver.js: the final check (force)
  * @param {() => Promise<string[]>} [deps.readOsPath]  the OS PATH a new terminal gets, read afresh
+ * @param {(o: { platform: string, env: object }) => string|null} [deps.findBrew]  Homebrew's brew, or null (findBrew)
  * @param {(tool: string, ok: boolean, status: object|null) => void} [deps.onFinished]
  */
 export function createCliInstaller({
@@ -453,6 +471,7 @@ export function createCliInstaller({
   tmpRoot = os.tmpdir(),
   fetchImpl = fetch,
   spawnImpl = spawn,
+  findBrew: lookForBrew = findBrew,
   readOsPath = async () => [],
   addToPath = null,
   installerPath = null,
@@ -464,9 +483,12 @@ export function createCliInstaller({
   if (!resolver?.resolve) throw new Error('createCliInstaller needs the CLI resolver');
   const jobs = new Map();
   const windows = platform === 'win32';
-  const planFor = (toolKey) => installPlanFor(toolKey, { platform, arch, env, home });
+  // Homebrew is looked for at every ask: one installed meanwhile counts from the next check on.
+  const brewOf = () => { try { return lookForBrew({ platform, env }) || null; } catch { return null; } };
+  const planFor = (toolKey) => installPlanFor(toolKey, { platform, arch, env, home, brew: brewOf() });
   const guideOf = (toolKey) => CLI_INSTALL_GUIDES[toolKey] || null;
-  const manualOf = (toolKey) => buildInstallCommand(toolKey, 'unknown', { platform });
+  // The command for the very install the button runs here, when its plan names one; else the vendor's for this system.
+  const manualOf = (toolKey) => planFor(toolKey)?.manualCommand || buildInstallCommand(toolKey, 'unknown', { platform });
 
   function publicJob(job) {
     return {
@@ -580,15 +602,19 @@ export function createCliInstaller({
     return file;
   }
 
-  function runScript(job, plan, scriptFile, workDir, osEntries, { line }) {
-    const interpreter = interpreterFor(plan);
+  /**
+   * Run an installer to its end: no stdin, every line of its output to `onLine`, stopped with everything it
+   * started when it runs longer than timeoutMs or the job is stopped. Resolves on exit code 0. `name` is what
+   * the sentence of a failure calls it (`slowName`, the one of a timeout).
+   */
+  function runChild(job, plan, { file, args, cwd, osEntries, onLine, name, slowName = name }) {
     const childEnv = { ...withPathEnv({ ...env, ...plan.env }, installerPathValue(osEntries), platform), TERM: 'dumb', NO_COLOR: '1' };
     delete childEnv.FORCE_COLOR;
     return new Promise((resolve, reject) => {
       let child;
       try {
-        child = spawnImpl(interpreter.file, interpreter.args(scriptFile), {
-          cwd: workDir,
+        child = spawnImpl(file, args, {
+          cwd,
           env: childEnv,
           stdio: ['ignore', 'pipe', 'pipe'],
           windowsHide: true,
@@ -597,18 +623,18 @@ export function createCliInstaller({
           detached: !windows,
         });
       } catch (error) {
-        reject(asInstallError(error, 'installer-failed', `${interpreter.file} could not be started.`));
+        reject(asInstallError(error, 'installer-failed', `${file} could not be started.`));
         return;
       }
       job.child = child;
-      const out = createLineSplitter(line);
-      const err = createLineSplitter(line);
+      const out = createLineSplitter(onLine);
+      const err = createLineSplitter(onLine);
       child.stdout?.on('data', chunk => out.push(chunk.toString('utf8')));
       child.stderr?.on('data', chunk => err.push(chunk.toString('utf8')));
       let settled = false;
       const timer = setTimeout(() => {
         stopChild(child, windows, spawnImpl);
-        finish(new CliInstallError('timeout', `The installer was still running after ${Math.round(timeoutMs / 60_000)} minutes and was stopped.`));
+        finish(new CliInstallError('timeout', `${slowName} was still running after ${Math.round(timeoutMs / 60_000)} minutes and was stopped.`));
       }, timeoutMs);
       timer.unref?.();
       const onAbort = () => { stopChild(child, windows, spawnImpl); finish(new CliInstallError('cancelled', 'The install was stopped.')); };
@@ -622,58 +648,41 @@ export function createCliInstaller({
         err.end();
         job.child = null;
         if (error) reject(error);
-        else if (code !== 0) reject(new CliInstallError('installer-failed', `The ${plan.label} stopped with exit code ${code}.`, { detail: code }));
+        else if (code !== 0) reject(new CliInstallError('installer-failed', `${name} stopped with exit code ${code}.`, { detail: code }));
         else resolve();
       }
-      child.on('error', error => finish(asInstallError(error, 'installer-failed', `${interpreter.file} could not be started (${errorCode(error) || error?.message}).`)));
+      child.on('error', error => finish(asInstallError(error, 'installer-failed', `${file} could not be started (${errorCode(error) || error?.message}).`)));
       child.on('close', (code, signal) => finish(null, code ?? (signal ? 128 : 1)));
     });
   }
 
-  async function installArchive(job, plan, workDir, { step, line, progress }) {
-    step('download');
-    const releases = await fetchGithubJson(`https://api.github.com/repos/${plan.repo}/releases?per_page=20`, { fetchImpl, signal: job.abort.signal });
-    const picked = pickOpencodeRelease(releases, { assets: plan.assets, repo: plan.repo, tag: plan.tag });
-    if (!picked) throw new CliInstallError('http', `No OpenCode 1 release of ${plan.repo} carries ${plan.assets.join(' or ')}.`);
-    job.source = picked.asset.url;
-    line(`OpenCode ${picked.version}: ${picked.asset.name}`);
-    const archive = path.join(workDir, picked.asset.name);
-    const got = await downloadFile({
-      url: picked.asset.url,
-      allow: (url) => GITHUB_DOWNLOAD_HOSTS.includes(url.hostname),
-      destination: archive,
-      maxBytes: MAX_ARCHIVE_BYTES,
-      expectedSize: picked.asset.size,
-      sha256: picked.asset.sha256,
-      fetchImpl,
-      signal: job.abort.signal,
-      onProgress: progress,
-      stallMs,
+  function runScript(job, plan, scriptFile, workDir, osEntries, { line }) {
+    const interpreter = interpreterFor(plan);
+    return runChild(job, plan, {
+      file: interpreter.file, args: interpreter.args(scriptFile), cwd: workDir, osEntries, onLine: line,
+      name: `The ${plan.label}`, slowName: 'The installer',
+    });
+  }
+
+  /**
+   * Homebrew installs the cask (`brew install --cask …`, never auto-updating first). It downloads and checks the
+   * cask itself: its own lines move the steps (brewStepOf), from 'run' on.
+   */
+  function runBrew(job, plan, workDir, osEntries, { step, line }) {
+    let at = 'run';
+    step(at);
+    return runChild(job, plan, {
+      file: plan.brew, args: plan.args, cwd: workDir, osEntries,
+      onLine: (text) => {
+        const next = brewStepOf(text);
+        if (next && next !== at) {
+          at = next;
+          step(next);
+        }
+        line(text);
+      },
+      name: `brew ${plan.args.join(' ')}`,
     });
-    step('verify');
-    line(picked.asset.sha256 ? `SHA-256 matches the published one (${got.sha256.slice(0, 12)}…).` : 'GitHub publishes no SHA-256 for this file; its size matches.');
-    step('extract');
-    try { mkdirSync(plan.dir, { recursive: true }); } catch (error) { throw asInstallError(error, 'disk', `${plan.dir} could not be created (${errorCode(error)}).`); }
-    const part = path.join(plan.dir, `.${plan.member}.${randomBytes(4).toString('hex')}.part`);
-    await extractZipMember({ archive, member: plan.member, destination: part });
-    step('place');
-    const head = Buffer.alloc(2);
-    const handle = await open(part, 'r');
-    try { await handle.read(head, 0, 2, 0); } finally { await handle.close(); }
-    if (head[0] !== 0x4d || head[1] !== 0x5a) {
-      rmSync(part, { force: true });
-      throw new CliInstallError('unpack', `The archive's ${plan.member} is not a Windows program.`);
-    }
-    const target = path.join(plan.dir, plan.member);
-    try {
-      renameSync(part, target);
-    } catch (error) {
-      rmSync(part, { force: true });
-      throw asInstallError(error, 'disk', `${target} could not be written (${errorCode(error)}: is an OpenCode still running from there?).`);
-    }
-    // Files SynaBun writes carry no Mark of the Web; a copy that does (a mirror, an antivirus) is cleared so it can start.
-    try { unlinkSync(`${target}:Zone.Identifier`); } catch { /* none */ }
-    line(`Placed ${target}`);
   }
 
   async function run(job) {
@@ -685,12 +694,12 @@ export function createCliInstaller({
       emit(job, { type: 'start', tool, method: plan.kind, source: plan.source, label: plan.label, platform, arch });
       try { before = await readOsPath(); } catch { before = []; }
       workDir = await mkdtemp(path.join(tmpRoot, `synabun-cli-install-${tool}-`));
-      if (plan.kind === 'script') {
+      if (plan.kind === 'brew') {
+        await runBrew(job, plan, workDir, before, io);
+      } else {
         const script = await fetchScript(job, plan, workDir, io);
         io.step('run');
         await runScript(job, plan, script, workDir, before, io);
-      } else {
-        await installArchive(job, plan, workDir, io);
       }
       io.step('check');
       const status = await resolver.resolve(tool, { force: true });
@@ -738,7 +747,7 @@ export function createCliInstaller({
   }
 
   return {
-    describe: (toolKey) => describeInstall(toolKey, { platform, arch, env, home }),
+    describe: (toolKey) => describePlan(planFor(toolKey)),
     guideUrl: guideOf,
     manualCommand: manualOf,
     jobs() {

package/neural-interface/lib/cli-resolver.js

@@ -1,5 +1,5 @@
 // ═══════════════════════════════════════════
-// SynaBun — where the user's Claude Code, Codex and OpenCode are
+// SynaBun — where the user's Claude Code, Codex, OpenCode and Antigravity (agy) are
 // ═══════════════════════════════════════════
 //
 // One answer for every place that looks for one of these CLIs: the version
@@ -55,7 +55,7 @@ export const CLI_TOOLS = Object.freeze({
   'claude-code': Object.freeze({ key: 'claude-code', command: 'claude', label: 'Claude Code' }),
   codex: Object.freeze({ key: 'codex', command: 'codex', label: 'Codex' }),
   opencode: Object.freeze({ key: 'opencode', command: 'opencode', label: 'OpenCode' }),
-  gemini: Object.freeze({ key: 'gemini', command: 'gemini', label: 'Gemini CLI' }),
+  antigravity: Object.freeze({ key: 'antigravity', command: 'agy', label: 'Antigravity CLI' }),
 });
 
 const PROBE_TIMEOUT_MS = 15_000;
@@ -134,6 +134,10 @@ function wingetPackageFiles({ localAppData, prefixes, exe, readdir, pathImpl })
  *   OpenCode      install script: ~/.opencode/bin/opencode (older scripts:
  *                 $OPENCODE_INSTALL_DIR, $XDG_BIN_DIR); on Windows the folder
  *                 SynaBun's own install uses, %USERPROFILE%\.opencode\bin
+ *   Antigravity   Google's installer (antigravity.google/cli/install.sh, checked
+ *                 2026-10-30): ~/.local/bin/agy; install.ps1 on Windows:
+ *                 %LOCALAPPDATA%\agy\bin\agy.exe. Homebrew's cask links agy
+ *                 into Homebrew's bin, which the package-manager folders cover.
  */
 export function toolSpecificFiles(toolKey, {
   platform = process.platform,
@@ -168,6 +172,9 @@ export function toolSpecificFiles(toolKey, {
       if (env.XDG_BIN_DIR) add(join(env.XDG_BIN_DIR, exe('opencode')), 'standalone');
       if (windows) for (const file of wingetPackageFiles({ localAppData, prefixes: ['sst.opencode', 'anomalyco.opencode', 'opencode.'], exe: 'opencode.exe', readdir, pathImpl })) add(file, 'winget');
       break;
+    case 'antigravity':
+      add(windows ? join(localAppData, 'agy', 'bin', 'agy.exe') : join(home, '.local', 'bin', 'agy'), 'standalone');
+      break;
     default:
       break;
   }
@@ -198,7 +205,10 @@ export function describeConfigured(value, toolKey, {
   return { value: raw, kind: 'command', name: text };
 }
 
-/** OpenCode's npm package: its command file runs node_modules\opencode-ai\bin\opencode.exe, the platform build its postinstall put there. */
+/**
+ * npm's opencode-ai (OpenCode 1): its command file runs node_modules\opencode-ai\bin\opencode.exe, the platform build
+ * its postinstall put there. Still found, so that SynaBun can say which version it is when it refuses it.
+ */
 export function windowsOpencodeTargets(launcher, arch = process.arch) {
   const pathImpl = path.win32;
   const folder = pathImpl.dirname(String(launcher || ''));