@chatpanel/bridge 0.3.3 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "type": "module",
   "description": "Local bridge that exposes the AI coding agents installed on your machine — Claude Code (CLI), Codex (CLI), and Gemini CLI — to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
   "keywords": [

package/src/engines/antigravity.js

@@ -0,0 +1,167 @@
+// Antigravity engine — drives the Antigravity CLI (`agy -p`) using your local
+// login. This replaces Gemini CLI as the default Google-model agent (the Gemini
+// CLI is being deprecated for individual users).
+//
+//   agy -p "<prompt>"   → run one prompt non-interactively, print the answer, exit
+//   agy --model <id>    → pick the model      agy models → list models
+//
+// Images: Antigravity has no image flag, but it READS image files referenced by
+// path in the prompt (vision) — same approach as Claude Code. We write the image
+// into the workspace (cwd), grant read access with --add-dir, and reference the
+// path so the model opens it.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { mkdirSync, writeFileSync, unlinkSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { findAgentBin } from '../env.js';
+
+const IDLE_MS = Number(process.env.CHATPANEL_AGY_TIMEOUT_MS) || 180_000;
+const SCRATCH = path.join(os.tmpdir(), 'chatpanel-agy-scratch');
+
+// `agy models` lists available models. Parse ids best-effort; free text is still
+// accepted by the picker, and [] just means "type a model or use the default".
+export async function listModels() {
+  try {
+    const bin = findAgentBin('agy') || 'agy';
+    const r = spawnSync(bin, ['models'], { encoding: 'utf8', timeout: 15000 });
+    const ids = [];
+    const seen = new Set();
+    for (const line of String(r.stdout || '').split('\n')) {
+      const tok = line.trim().split(/\s+/)[0] || '';
+      if (!/^[A-Za-z0-9][\w./:-]{1,79}$/.test(tok)) continue;
+      if (/^(name|model|models|id|provider|available)$/i.test(tok)) continue;
+      if (seen.has(tok)) continue;
+      seen.add(tok);
+      ids.push(tok);
+      if (ids.length >= 100) break;
+    }
+    return ids;
+  } catch {
+    return [];
+  }
+}
+
+let installed = false;
+let lastProbe = 0;
+export async function available() {
+  // Cache a positive result; keep re-probing (throttled) while not found so it
+  // self-heals once agy appears on PATH — never cache a negative forever.
+  if (!installed && Date.now() - lastProbe > 4000) {
+    lastProbe = Date.now();
+    try {
+      installed = !!findAgentBin('agy');
+    } catch {
+      installed = false;
+    }
+  }
+  return installed
+    ? { ok: true }
+    : { ok: false, reason: 'agy not found on PATH. Install Antigravity, then run `agy` once to sign in.' };
+}
+
+function writeImages(images, dir) {
+  const files = [];
+  for (let i = 0; i < (images?.length || 0); i++) {
+    const m = /^data:([^;]+);base64,(.+)$/s.exec(images[i]?.dataUrl || '');
+    if (!m) continue;
+    const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '').slice(0, 5) || 'png';
+    const file = path.join(dir, `chatpanel-img-${Date.now()}-${i}.${ext}`);
+    try {
+      writeFileSync(file, Buffer.from(m[2], 'base64'));
+      files.push(file);
+    } catch {
+      /* skip unwritable */
+    }
+  }
+  return files;
+}
+
+// The bridge is stateless, so replay the conversation as a single prompt.
+function buildPrompt(messages, system) {
+  let p = system ? `${system}\n\n` : '';
+  const history = messages.slice(0, -1);
+  const last = messages[messages.length - 1];
+  if (history.length) {
+    p += 'Conversation so far:\n';
+    for (const m of history) p += `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}\n\n`;
+    p += '---\n\n';
+  }
+  p += last ? last.content : '';
+  return p;
+}
+
+export async function chat({ messages, system, options, images }, emit) {
+  try {
+    mkdirSync(SCRATCH, { recursive: true });
+  } catch {
+    /* best effort */
+  }
+  const cwd = options.workingDir ? path.resolve(options.workingDir) : SCRATCH;
+
+  // Images: write into the cwd (workspace) and reference with `@<file>` — agy
+  // reads @-referenced files (incl. images) inline as multimodal input, so no
+  // read-tool approval is needed in headless `-p` mode. (Confirmed working.)
+  const imageFiles = writeImages(images, cwd);
+  const cleanup = () => imageFiles.forEach((f) => { try { unlinkSync(f); } catch { /* gone */ } });
+  let prompt = buildPrompt(messages, system);
+  if (imageFiles.length) {
+    prompt += `\n\nThe user attached image(s): ${imageFiles.map((f) => '@' + path.basename(f)).join(' ')}`;
+  }
+
+  // `-p` runs one prompt non-interactively. --model picks the model.
+  // --dangerously-skip-permissions auto-approves tool use (headless has no human
+  // approver) only when the user opted into bypassPermissions.
+  const args = ['-p', prompt];
+  if (options.model) args.push('--model', options.model);
+  if (options.permissionMode === 'bypassPermissions') args.push('--dangerously-skip-permissions');
+
+  await new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn('agy', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
+    } catch (e) {
+      cleanup();
+      return reject(new Error(`Failed to start agy: ${e.message}`));
+    }
+
+    let out = '';
+    let err = '';
+    let streamed = false;
+    let idleTimer;
+    const armIdle = () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        child.kill('SIGKILL');
+        cleanup();
+        reject(new Error(`Antigravity timed out — no output for ${Math.round(IDLE_MS / 1000)}s.`));
+      }, IDLE_MS);
+    };
+    armIdle();
+
+    child.stdout.on('data', (d) => {
+      armIdle();
+      const s = d.toString();
+      out += s;
+      streamed = true;
+      emit({ type: 'delta', text: s });
+    });
+    child.stderr.on('data', (d) => { armIdle(); err += d.toString(); });
+    child.on('error', (e) => {
+      clearTimeout(idleTimer);
+      cleanup();
+      reject(new Error(`Failed to start agy: ${e.message}`));
+    });
+    child.on('close', (code) => {
+      clearTimeout(idleTimer);
+      cleanup();
+      if (code === 0) {
+        if (!streamed) emit({ type: 'delta', text: out.trim() || '(no output)' });
+        emit({ type: 'done', text: '' });
+        resolve();
+      } else {
+        reject(new Error(`Antigravity exited ${code}: ${err.trim() || out.trim() || 'failed'}`));
+      }
+    });
+  });
+}

package/src/engines/claude.js

@@ -14,10 +14,27 @@
 // permissionMode is 'acceptEdits'/'bypassPermissions' in ChatPanel Settings.
 
 import { spawn } from 'node:child_process';
+import { writeFile, unlink } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { resolveClaude, buildSpawnSpec, isCompiledBinary } from '../env.js';
 
+// Write base64 data-URL images to temp files. Claude Code reads them with its
+// Read tool (which feeds images to the model as vision), so we just reference the
+// paths in the prompt — no custom image flag needed. Returns paths (caller cleans).
+async function writeImages(images, tag) {
+  const files = [];
+  for (let i = 0; i < (images?.length || 0); i++) {
+    const m = /^data:([^;]+);base64,(.+)$/s.exec(images[i]?.dataUrl || '');
+    if (!m) continue;
+    const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '').slice(0, 5) || 'png';
+    const file = path.join(os.tmpdir(), `chatpanel-claude-img-${tag}-${i}.${ext}`);
+    await writeFile(file, Buffer.from(m[2], 'base64'));
+    files.push(file);
+  }
+  return files;
+}
+
 // Idle timeout: kill the run only after this long with NO output. The timer
 // re-arms on every stdout/stderr chunk, so a task that keeps streaming can run
 // indefinitely — only a truly stuck/silent process is killed. Override with
@@ -173,7 +190,7 @@ export function handleMessage(msg, emit, alreadyStreamed) {
   return out;
 }
 
-export async function chat({ messages, system, options }, emit) {
+export async function chat({ messages, system, options, images }, emit) {
   const permissionMode = options.permissionMode || 'default';
   // Explicit project dir, else null → CLI runs in home (or WSL home).
   const cwd = options.workingDir ? path.resolve(options.workingDir) : null;
@@ -194,10 +211,29 @@ export async function chat({ messages, system, options }, emit) {
   // "Use my local skills & config" off → run clean.
   if (options.useLocalConfig === false) args.push('--setting-sources', '');
 
-  const run = runClaude({ prompt: buildPrompt(messages), args, cwd, emit });
-  if (run === null) return sdkChat({ messages, system, options }, emit); // no CLI → SDK
-  const { streamedAny, resultText } = await run;
-  emit({ type: 'done', text: streamedAny ? '' : resultText });
+  // Attach images by writing them to temp files and asking Claude Code to Read
+  // them — its Read tool loads images as vision (no special flag needed).
+  const tag = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const imageFiles = await writeImages(images, tag);
+  const cleanup = () => imageFiles.forEach((f) => unlink(f).catch(() => {}));
+  let prompt = buildPrompt(messages);
+  if (imageFiles.length) {
+    prompt += `\n\nThe user attached ${imageFiles.length} image file(s). Use the Read tool to view ${
+      imageFiles.length === 1 ? 'it' : 'them'
+    }: ${imageFiles.join(', ')}`;
+  }
+
+  const run = runClaude({ prompt, args, cwd, emit });
+  if (run === null) {
+    cleanup(); // SDK fallback doesn't take images yet
+    return sdkChat({ messages, system, options }, emit);
+  }
+  try {
+    const { streamedAny, resultText } = await run;
+    emit({ type: 'done', text: streamedAny ? '' : resultText });
+  } finally {
+    cleanup();
+  }
 }
 
 // A fast, tool-free single-shot completion — used for prompt autocomplete. No

package/src/engines/cli-agents.js

@@ -0,0 +1,77 @@
+// Built-in CLI agents — pi, opencode, kiro — that reuse the shared custom-engine
+// runner (runSpec) with a FIXED spec each. Unlike the Pro "custom" engine, these
+// are NOT entitlement-gated: they ship as built-ins, and the extension bounds
+// free users to a single usable agent (FREE_LIMITS.bridgeAgents). Bring-your-own
+// arbitrary CLIs stay Pro via custom.js.
+//
+// Specs come from each CLI's actual flags:
+//   pi       — pi -p "<prompt>"        · --model · @{path} images · --list-models
+//   opencode — opencode run "<prompt>" · -m provider/model · -f {path} images · models
+//   kiro     — kiro-cli chat --no-interactive "<prompt>" · --model · --list-models
+
+import { runSpec, listSpecModels } from './custom.js';
+import { findAgentBin } from '../env.js';
+
+function makeCliAgent(command, spec, notFoundHint) {
+  let installed = false;
+  let lastProbe = 0;
+  return {
+    async available() {
+      // Cache a positive result; re-probe (throttled) while not found so it
+      // self-heals once the CLI appears on PATH.
+      if (!installed && Date.now() - lastProbe > 4000) {
+        lastProbe = Date.now();
+        try {
+          installed = !!findAgentBin(command);
+        } catch {
+          installed = false;
+        }
+      }
+      return installed ? { ok: true } : { ok: false, reason: notFoundHint };
+    },
+    listModels(options = {}) {
+      return listSpecModels(command, spec.listModelsArgs, options.workingDir);
+    },
+    chat(input, emit) {
+      return runSpec({ ...spec, command }, input, emit);
+    },
+  };
+}
+
+export const pi = makeCliAgent(
+  'pi',
+  {
+    args: '-p',
+    promptVia: 'arg',
+    modelArg: '--model {model}',
+    imageArg: '@{path}',
+    listModelsArgs: '--list-models',
+    label: 'Pi',
+  },
+  'pi not found on PATH. Install Pi, then run `pi` once to sign in.',
+);
+
+export const opencode = makeCliAgent(
+  'opencode',
+  {
+    args: 'run',
+    promptVia: 'arg',
+    modelArg: '-m {model}',
+    imageArg: '-f {path}',
+    listModelsArgs: 'models',
+    label: 'OpenCode',
+  },
+  'opencode not found on PATH. Install opencode, then sign in.',
+);
+
+export const kiro = makeCliAgent(
+  'kiro-cli',
+  {
+    args: 'chat --no-interactive',
+    promptVia: 'arg',
+    modelArg: '--model {model}',
+    listModelsArgs: '--list-models',
+    label: 'Kiro',
+  },
+  'kiro-cli not found on PATH. Install Kiro CLI, then sign in.',
+);

package/src/engines/codex.js

@@ -15,7 +15,7 @@
 // the agent to point it at a real project.
 
 import { spawn, spawnSync } from 'node:child_process';
-import { readFile, unlink } from 'node:fs/promises';
+import { readFile, unlink, writeFile } from 'node:fs/promises';
 import { existsSync, mkdirSync, symlinkSync, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -110,10 +110,27 @@ function buildPrompt(messages, system) {
   return p;
 }
 
-export async function chat({ messages, system, options }, emit) {
+// Write base64 data-URL images to temp files so `codex exec -i <file>` can
+// attach them to the prompt as vision input. Returns the paths (caller cleans up).
+async function writeImages(images, tag) {
+  const files = [];
+  for (let i = 0; i < (images?.length || 0); i++) {
+    const m = /^data:([^;]+);base64,(.+)$/s.exec(images[i]?.dataUrl || '');
+    if (!m) continue;
+    const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '').slice(0, 5) || 'png';
+    const file = path.join(os.tmpdir(), `chatpanel-codex-img-${tag}-${i}.${ext}`);
+    await writeFile(file, Buffer.from(m[2], 'base64'));
+    files.push(file);
+  }
+  return files;
+}
+
+export async function chat({ messages, system, options, images }, emit) {
   ensureScratch();
   const tag = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const outFile = path.join(os.tmpdir(), `chatpanel-codex-${tag}.txt`);
+  const imageFiles = await writeImages(images, tag);
+  const cleanupImages = () => imageFiles.forEach((f) => unlink(f).catch(() => {}));
 
   const cwd = options.workingDir ? path.resolve(options.workingDir) : SCRATCH;
   const sandbox =
@@ -130,6 +147,7 @@ export async function chat({ messages, system, options }, emit) {
   args.push('-c', 'approval_policy=never');
   if (REASONING) args.push('-c', `model_reasoning_effort=${REASONING}`);
   if (options.model) args.push('-m', options.model);
+  for (const f of imageFiles) args.push('-i', f); // attach images to the initial prompt
   args.push('-');
 
   // Default: use the user's skills/config. Opt-out → isolated home.
@@ -145,6 +163,7 @@ export async function chat({ messages, system, options }, emit) {
     try {
       child = spawn('codex', args, { cwd, stdio: ['pipe', 'pipe', 'pipe'], env });
     } catch (e) {
+      cleanupImages();
       return reject(new Error(`Failed to start codex: ${e.message}`));
     }
 
@@ -178,6 +197,7 @@ export async function chat({ messages, system, options }, emit) {
     child.stderr.on('data', (d) => { armIdle(); stderr += d.toString(); });
     child.on('error', (e) => {
       clearTimeout(idleTimer);
+      cleanupImages();
       reject(e);
     });
     child.on('close', async (code) => {
@@ -189,6 +209,7 @@ export async function chat({ messages, system, options }, emit) {
         /* no message file */
       }
       unlink(outFile).catch(() => {});
+      cleanupImages();
       if (code === 0) {
         emit({ type: 'delta', text: text || '(no output)' });
         emit({ type: 'done', text: '' });

package/src/engines/custom.js

@@ -16,16 +16,55 @@
 //                      speak it), reusing the Claude engine's parser.
 
 import { spawn } from 'node:child_process';
+import { writeFile, unlink } from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
 import { resolveCommand, buildSpawnSpec } from '../env.js';
 import { isProEntitled } from '../entitlement.js';
 import { handleMessage } from './claude.js';
 
+// Write base64 data-URL images to temp files so a custom CLI can take them via
+// its configured `imageArg` template (e.g. "-i {path}", "@{path}"). Returns paths.
+async function writeImages(images, tag) {
+  const files = [];
+  for (let i = 0; i < (images?.length || 0); i++) {
+    const m = /^data:([^;]+);base64,(.+)$/s.exec(images[i]?.dataUrl || '');
+    if (!m) continue;
+    const ext = (m[1].split('/')[1] || 'png').replace(/[^a-z0-9]/gi, '').slice(0, 5) || 'png';
+    const file = path.join(os.tmpdir(), `chatpanel-custom-img-${tag}-${i}.${ext}`);
+    await writeFile(file, Buffer.from(m[2], 'base64'));
+    files.push(file);
+  }
+  return files;
+}
+
+// Expand the user's `imageArg` template across the image files into argv tokens.
+// "{path}" is substituted per image; a template without it appends the path.
+function imageTokensFor(imageArg, files) {
+  const tmpl = String(imageArg || '').trim();
+  if (!tmpl || !files.length) return [];
+  const tokens = [];
+  for (const f of files) {
+    tokens.push(
+      ...(tmpl.includes('{path}')
+        ? tmpl.replaceAll('{path}', f).split(/\s+/).filter(Boolean)
+        : [...tmpl.split(/\s+/).filter(Boolean), f]),
+    );
+  }
+  return tokens;
+}
+
 // Idle timeout: re-armed on every stdout/stderr chunk, so a long run that keeps
 // streaming never trips it — only true silence does. Override with
 // CHATPANEL_CUSTOM_TIMEOUT_MS (ms).
 const IDLE_MS = Number(process.env.CHATPANEL_CUSTOM_TIMEOUT_MS) || 180_000;
 
+// Many CLIs emit ANSI colour/escape codes even when piped (kiro-cli does), which
+// leak into the answer as `\x1b[38;5;141m…`. Strip them from text output. (We
+// also set NO_COLOR on the child env, but this is the robust backstop.)
+const ANSI_RE = /\u001b\[[0-9;?]*[ -/]*[@-~]/g;
+const stripAnsi = (s) => s.replace(ANSI_RE, '');
+
 export async function available() {
   // The engine ships in every bridge; individual custom agents are user-defined
   // (Pro) and validated per request and via /agent-check.
@@ -59,19 +98,26 @@ export async function listModels(options = {}) {
     throw new Error('Custom agents require ChatPanel Pro.');
   }
   const spec = options.custom || {};
-  const listArgs = String(spec.listModelsArgs || '').trim();
-  if (!spec.command || !listArgs) return [];
-  const resolved = resolveCommand(spec.command);
-  if (!resolved) throw new Error(`Couldn't find "${spec.command}".`);
-  const cwd = options.workingDir ? path.resolve(options.workingDir) : null;
+  return listSpecModels(spec.command, spec.listModelsArgs, options.workingDir);
+}
+
+// Shared model listing (no Pro gate): run a CLI's list-models invocation and
+// parse it. Used by the Pro custom engine (gated above) AND built-in CLI agents.
+export async function listSpecModels(command, listModelsArgs, workingDir) {
+  const listArgs = String(listModelsArgs || '').trim();
+  if (!command || !listArgs) return [];
+  const resolved = resolveCommand(command);
+  if (!resolved) throw new Error(`Couldn't find "${command}".`);
+  const cwd = workingDir ? path.resolve(workingDir) : null;
   const [bin, argv, opts] = buildSpawnSpec(resolved, listArgs.split(/\s+/).filter(Boolean), cwd);
+  opts.env = { ...(opts.env || process.env), NO_COLOR: '1', CLICOLOR: '0' };
   const stdout = await new Promise((resolve, reject) => {
     let child;
-    try { child = spawn(bin, argv, opts); } catch (e) { return reject(new Error(`Failed to start ${spec.command}: ${e.message}`)); }
+    try { child = spawn(bin, argv, opts); } catch (e) { return reject(new Error(`Failed to start ${command}: ${e.message}`)); }
     let out = '';
     const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('Listing models timed out.')); }, 20000);
     child.stdout.on('data', (d) => (out += d.toString()));
-    child.on('error', (e) => { clearTimeout(timer); reject(new Error(`Failed to start ${spec.command}: ${e.message}`)); });
+    child.on('error', (e) => { clearTimeout(timer); reject(new Error(`Failed to start ${command}: ${e.message}`)); });
     child.on('close', () => { clearTimeout(timer); resolve(out); });
     try { child.stdin.end(); } catch { /* some CLIs don't read stdin */ }
   });
@@ -92,14 +138,19 @@ function buildPrompt(messages, system) {
   return p;
 }
 
-export async function chat({ messages, system, options }, emit) {
+export async function chat({ messages, system, options, images }, emit) {
   // Pro gate — verified, not just UI. No valid signed entitlement → no run.
   if (!(await isProEntitled(options.entitlement))) {
     throw new Error('Custom agents require ChatPanel Pro. Upgrade in Settings to bring your own CLI agent.');
   }
+  return runSpec(options.custom || {}, { messages, system, options, images }, emit);
+}
 
-  const spec = options.custom || {};
-  if (!spec.command) throw new Error('This custom agent has no command configured.');
+// Run a CLI agent from a spec — SHARED by the Pro custom engine (gated in chat()
+// above) and the built-in CLI engines (pi/opencode/kiro). This never gates; the
+// built-in agents are bounded instead by the extension's free 1-agent limit.
+export async function runSpec(spec, { messages, system, options = {}, images }, emit) {
+  if (!spec.command) throw new Error('This agent has no command configured.');
 
   const resolved = resolveCommand(spec.command);
   if (!resolved) {
@@ -131,6 +182,24 @@ export async function chat({ messages, system, options }, emit) {
       : [...tmpl.split(/\s+/).filter(Boolean), options.model];
     args = [...injected, ...args];
   }
+  // Images: write to temp files, expand the agent's imageArg template, then place
+  // the tokens. An explicit {images} placeholder in args wins; otherwise they go
+  // just before the prompt (arg mode) or get appended (stdin mode).
+  const tag = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  const imageFiles = spec.imageArg ? await writeImages(images, tag) : [];
+  const cleanup = () => imageFiles.forEach((f) => unlink(f).catch(() => {}));
+  const imageTokens = imageTokensFor(spec.imageArg, imageFiles);
+  let placedImages = false;
+  if (imageTokens.length) {
+    args = args.flatMap((a) => {
+      if (a === '{images}') {
+        placedImages = true;
+        return imageTokens;
+      }
+      return [a];
+    });
+  }
+
   if (promptVia === 'arg') {
     let placed = false;
     args = args.map((a) => {
@@ -140,16 +209,24 @@ export async function chat({ messages, system, options }, emit) {
       }
       return a;
     });
-    if (!placed) args.push(prompt);
+    if (!placed) {
+      if (imageTokens.length && !placedImages) args.push(...imageTokens); // images, then prompt
+      args.push(prompt);
+    }
+  } else if (imageTokens.length && !placedImages) {
+    args.push(...imageTokens); // stdin prompt: image tokens go on argv
   }
 
   const [bin, argv, opts] = buildSpawnSpec(resolved, args, cwd);
+  // Discourage CLIs from colourizing output (kiro-cli etc.) when piped.
+  opts.env = { ...(opts.env || process.env), NO_COLOR: '1', FORCE_COLOR: '0', CLICOLOR: '0', TERM: 'dumb' };
 
   await new Promise((resolve, reject) => {
     let child;
     try {
       child = spawn(bin, argv, opts);
     } catch (e) {
+      cleanup();
       return reject(new Error(`Failed to start ${label}: ${e.message}`));
     }
 
@@ -163,6 +240,7 @@ export async function chat({ messages, system, options }, emit) {
       clearTimeout(idleTimer);
       idleTimer = setTimeout(() => {
         child.kill('SIGKILL');
+        cleanup();
         reject(new Error(`${label} timed out — no output for ${Math.round(IDLE_MS / 1000)}s.`));
       }, IDLE_MS);
     };
@@ -190,16 +268,18 @@ export async function chat({ messages, system, options }, emit) {
         }
       } else {
         streamedAny = true;
-        emit({ type: 'delta', text: s });
+        emit({ type: 'delta', text: stripAnsi(s) });
       }
     });
     child.stderr.on('data', (d) => { armIdle(); stderr += d.toString(); });
     child.on('error', (e) => {
       clearTimeout(idleTimer);
+      cleanup();
       reject(new Error(`Failed to start ${label}: ${e.message}`));
     });
     child.on('close', (code) => {
       clearTimeout(idleTimer);
+      cleanup();
       if (code === 0) {
         emit({ type: 'done', text: streamedAny ? '' : resultText });
         resolve();

package/src/env.js

@@ -1,4 +1,4 @@
-// Resolve a usable PATH for spawning the agent CLIs (codex, gemini).
+// Resolve a usable PATH for spawning the agent CLIs (codex, agy).
 //
 // When the bridge runs as a login service (LaunchAgent / Scheduled Task) — or as
 // a double-clicked app — it inherits a MINIMAL PATH, not your interactive shell's.
@@ -14,7 +14,7 @@ let enriched = false;
 
 // The agent CLIs the bridge shells out to. Claude has its own richer resolution
 // (resolveClaude: native / cli.js / WSL / SDK) below.
-const AGENT_CLIS = ['codex', 'gemini', 'claude'];
+const AGENT_CLIS = ['codex', 'claude', 'agy', 'pi', 'opencode', 'kiro-cli'];
 
 // Is `name` executable somewhere on the current PATH?
 function onPath(name) {

package/src/server.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 // ChatPanel Bridge — a tiny localhost server that exposes the coding agents
-// running on this machine (Claude Code, Codex and Gemini, each via its CLI) to
+// running on this machine (Claude Code, Codex and Antigravity, each via its CLI) to
 // the ChatPanel Chrome extension. Zero runtime dependencies.
 //
 //   GET  /health  → { ok, version, agents: [...], update: {current,latest,…} }
@@ -18,7 +18,8 @@ import { createServer } from 'node:http';
 import os from 'node:os';
 import * as claude from './engines/claude.js';
 import * as codex from './engines/codex.js';
-import * as gemini from './engines/gemini.js';
+import * as antigravity from './engines/antigravity.js';
+import { pi, opencode, kiro } from './engines/cli-agents.js';
 import * as custom from './engines/custom.js';
 import { installService, uninstallService, serviceStatus, restartService } from './service.js';
 import { enrichPath, findAgentBin, resolveCommand } from './env.js';
@@ -27,14 +28,17 @@ import { checkForUpdate, selfUpdate } from './update.js';
 // Hardcoded (not read from package.json) so it survives Bun's single-file
 // --compile, where package.json isn't on a readable FS. CI fails the publish if
 // this drifts from package.json, so the two can't silently diverge.
-const VERSION = '0.3.3';
+const VERSION = '0.5.0';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
 const ENGINES = {
   claude: { engine: claude, label: 'Claude Code' },
   codex: { engine: codex, label: 'Codex' },
-  gemini: { engine: gemini, label: 'Gemini CLI' },
+  antigravity: { engine: antigravity, label: 'Antigravity' },
+  pi: { engine: pi, label: 'Pi' },
+  opencode: { engine: opencode, label: 'OpenCode' },
+  kiro: { engine: kiro, label: 'Kiro' },
   // "Bring your own" — one engine drives any user-onboarded CLI (Pro). Hidden
   // from /health (it's not a single installable agent; the extension manages the
   // list and validates commands via /agent-check).
@@ -117,6 +121,9 @@ async function handleChat(req, res) {
   }
   const target = ENGINES[body.agent];
   if (!target) return json(res, 404, { error: `Unknown agent "${body.agent}"` });
+  if (Array.isArray(body.images) && body.images.length) {
+    log('info', `chat: ${body.agent} received ${body.images.length} image(s)`);
+  }
 
   // Open the SSE stream.
   res.writeHead(200, {
@@ -138,6 +145,7 @@ async function handleChat(req, res) {
         messages: Array.isArray(body.messages) ? body.messages : [],
         system: body.system || '',
         options: body.options || {},
+        images: Array.isArray(body.images) ? body.images : [],
       },
       (obj) => {
         if (!closed) emit(obj);
@@ -249,7 +257,7 @@ const server = createServer(async (req, res) => {
         version: VERSION,
         home: os.homedir(),
         codex: findAgentBin('codex') || null,
-        gemini: findAgentBin('gemini') || null,
+        agy: findAgentBin('agy') || null,
         path: process.env.PATH,
       });
     }
@@ -278,7 +286,7 @@ function startServer() {
       const a = await engine.available().catch(() => ({ ok: false }));
       log('info', `  ${a.ok ? '✓' : '✕'} ${label}${a.ok ? '' : ' — ' + (a.reason || 'unavailable')}`);
     }
-    log('info', 'Open the ChatPanel side panel; installed agents (Claude Code, Codex, Gemini CLI) appear automatically.');
+    log('info', 'Open the ChatPanel side panel; installed agents (Claude Code, Codex, Antigravity) appear automatically.');
   });
 }
 

package/src/engines/gemini.js

@@ -1,122 +0,0 @@
-// Gemini engine — drives the Gemini CLI (`gemini -p`) using your local login.
-//
-// Like the Codex engine, this shells out to the installed `gemini` binary in
-// non-interactive mode: `gemini -p "<prompt>"` runs once, prints the answer to
-// stdout, and exits. We run in an empty scratch dir for general chat so Gemini
-// never crawls the bridge's own files; set a working dir on the agent to point
-// it at a real project.
-//
-// Install: `npm i -g @google/gemini-cli`, then run `gemini` once to sign in.
-
-import { spawn, spawnSync } from 'node:child_process';
-import { mkdirSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { findAgentBin } from '../env.js';
-
-// Idle timeout: re-armed on every stdout/stderr chunk, so a long run that keeps
-// streaming never trips it — only true silence does. Override with
-// CHATPANEL_GEMINI_TIMEOUT_MS (ms).
-const IDLE_MS = Number(process.env.CHATPANEL_GEMINI_TIMEOUT_MS) || 180_000;
-const SCRATCH = path.join(os.tmpdir(), 'chatpanel-gemini-scratch');
-
-// Gemini CLI has no "list models" command (--help only lists extensions/sessions)
-// and stores no model in settings.json, so offer the common current ids. Free
-// text still accepted.
-export async function listModels() {
-  return ['gemini-2.5-pro', 'gemini-2.5-flash', 'gemini-2.5-flash-lite'];
-}
-
-let installed = false;
-let lastProbe = 0;
-export async function available() {
-  // Cache a positive result, but keep re-probing (throttled) while not found, so
-  // it self-heals once gemini appears on PATH — never cache a negative forever.
-  if (!installed && Date.now() - lastProbe > 4000) {
-    lastProbe = Date.now();
-    try {
-      installed = !!findAgentBin('gemini');
-    } catch {
-      installed = false;
-    }
-  }
-  return installed
-    ? { ok: true }
-    : { ok: false, reason: 'gemini not found on PATH. Install @google/gemini-cli, then run `gemini` once to sign in.' };
-}
-
-function buildPrompt(messages, system) {
-  let p = system ? `${system}\n\n` : '';
-  const history = messages.slice(0, -1);
-  const last = messages[messages.length - 1];
-  if (history.length) {
-    p += 'Conversation so far:\n';
-    for (const m of history) p += `${m.role === 'user' ? 'User' : 'Assistant'}: ${m.content}\n\n`;
-    p += '---\n\n';
-  }
-  p += last ? last.content : '';
-  return p;
-}
-
-export async function chat({ messages, system, options }, emit) {
-  try {
-    mkdirSync(SCRATCH, { recursive: true });
-  } catch {
-    /* best effort */
-  }
-  const cwd = options.workingDir ? path.resolve(options.workingDir) : SCRATCH;
-
-  // `-p` is non-interactive (no TTY prompts). `-m` picks the model. `-y` (yolo)
-  // auto-approves tool calls when the user opted into bypassPermissions — without
-  // it Gemini would block on an approval it can't show in a headless run.
-  const args = ['-p', buildPrompt(messages, system)];
-  if (options.model) args.push('-m', options.model);
-  if (options.permissionMode === 'bypassPermissions') args.push('-y');
-
-  await new Promise((resolve, reject) => {
-    let child;
-    try {
-      // stdin ignored: the prompt is passed via -p, and no TTY means no
-      // interactive "trust this folder?" dialog can block us.
-      child = spawn('gemini', args, { cwd, stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env } });
-    } catch (e) {
-      return reject(new Error(`Failed to start gemini: ${e.message}`));
-    }
-
-    let out = '';
-    let err = '';
-    let streamed = false;
-    let idleTimer;
-    const armIdle = () => {
-      clearTimeout(idleTimer);
-      idleTimer = setTimeout(() => {
-        child.kill('SIGKILL');
-        reject(new Error(`Gemini timed out — no output for ${Math.round(IDLE_MS / 1000)}s.`));
-      }, IDLE_MS);
-    };
-    armIdle();
-
-    child.stdout.on('data', (d) => {
-      armIdle();
-      const s = d.toString();
-      out += s;
-      streamed = true;
-      emit({ type: 'delta', text: s });
-    });
-    child.stderr.on('data', (d) => { armIdle(); err += d.toString(); });
-    child.on('error', (e) => {
-      clearTimeout(idleTimer);
-      reject(new Error(`Failed to start gemini: ${e.message}`));
-    });
-    child.on('close', (code) => {
-      clearTimeout(idleTimer);
-      if (code === 0) {
-        if (!streamed) emit({ type: 'delta', text: out.trim() || '(no output)' });
-        emit({ type: 'done', text: '' });
-        resolve();
-      } else {
-        reject(new Error(`Gemini exited ${code}: ${err.trim() || out.trim() || 'failed'}`));
-      }
-    });
-  });
-}