@chatpanel/bridge 0.1.1 → 0.2.0

package/README.md

@@ -7,25 +7,45 @@ so this bridges the gap.
 - **Claude Code** — embedded via `@anthropic-ai/claude-agent-sdk`, using your
   existing Claude Code login (or `ANTHROPIC_API_KEY`).
 - **Codex** — driven via the `codex exec` CLI, using your `codex login`.
+- **Gemini CLI** — driven via the `gemini -p` CLI, using your `gemini` login.
+
+Bring whichever agent you already have installed — the extension auto-detects
+the ones the bridge reports as available.
 
 ## Run it
 
-**No clone, no install** — `npx` fetches the package (and its one dependency) and
-starts the server:
+### Option A — download the app (no Node.js needed)
+
+Grab the standalone binary for your OS from the
+[latest release](https://github.com/chatpanel/chatpanel-bridge/releases/latest) —
+it bundles its own runtime, so **nothing to install**. Run it once to set it up to
+start automatically at login and run in the background:
 
 ```bash
-npx @chatpanel/bridge        # → http://127.0.0.1:4319
+# macOS / Linux (make it executable first on macOS)
+chmod +x chatpanel-bridge-macos-arm64
+./chatpanel-bridge-macos-arm64 --install
+
+# Windows (PowerShell)
+.\chatpanel-bridge-windows-x64.exe --install
 ```
 
-…then leave it running and open the ChatPanel side panel. That's the whole setup.
+That's it — open the ChatPanel side panel and your agents appear. Manage it with
+`--status` (is it set up?) and `--uninstall` (remove auto-start). Run with no flags
+to start it once in the foreground instead.
 
-Prefer a persistent command? Install it globally:
+> Until these binaries are code-signed, macOS Gatekeeper / Windows SmartScreen may
+> warn on first run (on macOS, right-click the file → **Open**). Signing is on the way.
+
+### Option B — via npm (needs Node.js 18+)
 
 ```bash
-npm i -g @chatpanel/bridge
-chatpanel-bridge             # → http://127.0.0.1:4319
+npx @chatpanel/bridge        # → http://127.0.0.1:4319
 ```
 
+…then leave it running and open the ChatPanel side panel. Prefer a persistent
+command? `npm i -g @chatpanel/bridge` then `chatpanel-bridge`.
+
 Prerequisites (the agents you want to use must already be set up):
 
 - **Claude Code**: be signed in (`claude`) or set `ANTHROPIC_API_KEY`.

package/package.json

@@ -1,18 +1,40 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "type": "module",
-  "description": "Local bridge that exposes Claude Code (Agent SDK) and Codex (CLI) to the ChatPanel Chrome extension over a localhost SSE endpoint.",
-  "keywords": ["chatpanel", "claude-code", "codex", "chrome-extension", "ai-agents", "bridge"],
+  "description": "Local bridge that exposes the AI coding agents installed on your machine — Claude Code (Agent SDK), Codex (CLI), and Gemini CLI — to the ChatPanel Chrome extension over a localhost SSE endpoint. Bring your own agent.",
+  "keywords": [
+    "chatpanel",
+    "claude-code",
+    "codex",
+    "gemini-cli",
+    "chrome-extension",
+    "ai-agents",
+    "bridge"
+  ],
   "homepage": "https://chatpanel.net",
-  "repository": { "type": "git", "url": "git+https://github.com/chatpanel/chatpanel-bridge.git" },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chatpanel/chatpanel-bridge.git"
+  },
   "license": "MIT",
-  "bin": { "chatpanel-bridge": "src/server.js" },
-  "files": ["src", "README.md", "LICENSE", ".env.example"],
-  "engines": { "node": ">=18" },
+  "bin": {
+    "chatpanel-bridge": "src/server.js"
+  },
+  "files": [
+    "src",
+    "scripts",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
     "start": "node src/server.js",
-    "dev": "node --watch src/server.js"
+    "dev": "node --watch src/server.js",
+    "build:bin": "bash scripts/build-binaries.sh"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.1.0"

package/scripts/build-binaries.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Compile the bridge into standalone, single-file binaries (no Node required to
+# run them). Needs Bun: https://bun.sh
+set -euo pipefail
+cd "$(dirname "$0")/.."
+mkdir -p dist
+rm -f dist/chatpanel-bridge-*
+
+targets=(
+  "bun-darwin-arm64:chatpanel-bridge-macos-arm64"
+  "bun-darwin-x64:chatpanel-bridge-macos-x64"
+  "bun-linux-x64:chatpanel-bridge-linux-x64"
+  "bun-windows-x64:chatpanel-bridge-windows-x64.exe"
+)
+for t in "${targets[@]}"; do
+  target="${t%%:*}"; out="${t##*:}"
+  echo "→ building dist/$out ($target)"
+  bun build src/server.js --compile --target="$target" --outfile "dist/$out"
+done
+echo "✓ binaries in dist/"
+ls -la dist

package/src/engines/claude.js

@@ -10,14 +10,6 @@
 import path from 'node:path';
 import os from 'node:os';
 
-// Always-on guidance so the coding agent behaves like a browser assistant by
-// default: prefer the page context the extension attaches over scanning files.
-const BASE_GUIDANCE =
-  'You are ChatPanel, an AI assistant living in a browser side panel. When the ' +
-  "user's message includes <context> blocks (extracted web pages or selections), " +
-  'answer primarily from those. Only read or modify local files when the user ' +
-  'explicitly asks about code or a project.';
-
 let sdkPromise = null;
 function loadSdk() {
   if (!sdkPromise) sdkPromise = import('@anthropic-ai/claude-agent-sdk').catch(() => null);
@@ -86,11 +78,12 @@ export async function chat({ messages, system, options }, emit) {
       // servers and CLAUDE.md apply. Turn the agent's "Use my local skills &
       // config" off to run clean.
       settingSources: options.useLocalConfig === false ? [] : ['user', 'project'],
-      systemPrompt: {
-        type: 'preset',
-        preset: 'claude_code',
-        append: [BASE_GUIDANCE, system].filter(Boolean).join('\n\n'),
-      },
+      // Native Claude Code system prompt. Only append the user's OWN system
+      // prompt if they set one — no ChatPanel persona is injected, so the agent
+      // is exactly as capable as it is in the terminal.
+      systemPrompt: system
+        ? { type: 'preset', preset: 'claude_code', append: system }
+        : { type: 'preset', preset: 'claude_code' },
       ...(options.model ? { model: options.model } : {}),
       ...(process.env.CHATPANEL_MAX_TURNS ? { maxTurns: Number(process.env.CHATPANEL_MAX_TURNS) } : {}),
     },
@@ -99,9 +92,14 @@ export async function chat({ messages, system, options }, emit) {
   for await (const message of iterator) {
     if (message.type === 'stream_event') {
       const ev = message.event;
-      if (ev?.type === 'content_block_delta' && ev.delta?.type === 'text_delta') {
-        streamedAny = true;
-        emit({ type: 'delta', text: ev.delta.text });
+      if (ev?.type === 'content_block_delta') {
+        if (ev.delta?.type === 'text_delta') {
+          streamedAny = true;
+          emit({ type: 'delta', text: ev.delta.text });
+        } else if (ev.delta?.type === 'thinking_delta') {
+          // Extended thinking — stream the reasoning text to the panel.
+          emit({ type: 'reasoning', text: ev.delta.thinking || '' });
+        }
       }
     } else if (message.type === 'assistant') {
       for (const block of message.message.content) {

package/src/engines/codex.js

@@ -58,14 +58,6 @@ function ensureIsolatedHome() {
   return ISO_HOME;
 }
 
-const BASE_GUIDANCE =
-  'You are ChatPanel, an AI assistant in a browser side panel. Answer the ' +
-  "user's question using the <context> blocks provided (web pages or selections). " +
-  'Do NOT search the filesystem or read local files for general questions — ' +
-  'everything you need is in the prompt. Only inspect files if the user explicitly ' +
-  'asks about local code or a project. When asked for a table, return GitHub-' +
-  'flavored Markdown.';
-
 let installed = null;
 export async function available() {
   if (installed === null) {
@@ -82,7 +74,7 @@ export async function available() {
 }
 
 function buildPrompt(messages, system) {
-  let p = `${[BASE_GUIDANCE, system].filter(Boolean).join('\n\n')}\n\n`;
+  let p = system ? `${system}\n\n` : '';
   const history = messages.slice(0, -1);
   const last = messages[messages.length - 1];
   if (history.length) {

package/src/engines/gemini.js

@@ -0,0 +1,102 @@
+// 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';
+
+const TIMEOUT_MS = Number(process.env.CHATPANEL_GEMINI_TIMEOUT_MS) || 180_000;
+const SCRATCH = path.join(os.tmpdir(), 'chatpanel-gemini-scratch');
+
+let installed = null;
+export async function available() {
+  if (installed === null) {
+    try {
+      const r = spawnSync('gemini', ['--version'], { stdio: 'ignore', timeout: 5000 });
+      installed = r.status === 0 || (r.status === null && r.error === undefined);
+    } 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;
+    const timer = setTimeout(() => {
+      child.kill('SIGKILL');
+      reject(new Error(`Gemini timed out after ${Math.round(TIMEOUT_MS / 1000)}s.`));
+    }, TIMEOUT_MS);
+
+    child.stdout.on('data', (d) => {
+      const s = d.toString();
+      out += s;
+      streamed = true;
+      emit({ type: 'delta', text: s });
+    });
+    child.stderr.on('data', (d) => (err += d.toString()));
+    child.on('error', (e) => {
+      clearTimeout(timer);
+      reject(new Error(`Failed to start gemini: ${e.message}`));
+    });
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      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'}`));
+      }
+    });
+  });
+}

package/src/server.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 // ChatPanel Bridge — a tiny localhost server that exposes the coding agents
-// running on this machine (Claude Code via the Agent SDK, Codex via its CLI) to
-// the ChatPanel Chrome extension. Zero runtime dependencies beyond the optional
-// Claude Agent SDK.
+// running on this machine (Claude Code via the Agent SDK, Codex and Gemini via
+// their CLIs) to the ChatPanel Chrome extension. Zero runtime dependencies
+// beyond the optional Claude Agent SDK.
 //
 //   GET  /health  → { ok, version, agents: [{id,label,available,reason}] }
 //   POST /chat    → Server-Sent Events stream of { type, ... }:
@@ -17,14 +17,17 @@
 import { createServer } from 'node:http';
 import * as claude from './engines/claude.js';
 import * as codex from './engines/codex.js';
+import * as gemini from './engines/gemini.js';
+import { installService, uninstallService, serviceStatus } from './service.js';
 
-const VERSION = '0.1.0';
+const VERSION = '0.2.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' },
 };
 
 // --------------------------------------------------------------------------
@@ -143,11 +146,74 @@ function log(level, msg) {
   fn(`[chatpanel-bridge] ${msg}`);
 }
 
-server.listen(PORT, HOST, async () => {
-  log('info', `listening on http://${HOST}:${PORT}`);
-  for (const [id, { engine, label }] of Object.entries(ENGINES)) {
-    const a = await engine.available().catch(() => ({ ok: false }));
-    log('info', `  ${a.ok ? '✓' : '✕'} ${label}${a.ok ? '' : ' — ' + (a.reason || 'unavailable')}`);
+function startServer() {
+  server.listen(PORT, HOST, async () => {
+    log('info', `listening on http://${HOST}:${PORT}`);
+    for (const [, { engine, label }] of Object.entries(ENGINES)) {
+      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.');
+  });
+}
+
+function printHelp() {
+  console.log(`ChatPanel Bridge v${VERSION}
+
+Usage:
+  chatpanel-bridge              start the bridge (foreground) on ${HOST}:${PORT}
+  chatpanel-bridge --install    run automatically at login, in the background
+  chatpanel-bridge --uninstall  remove the login auto-start
+  chatpanel-bridge --status     show whether auto-start is set up
+  chatpanel-bridge --version    print the version
+
+Env: CHATPANEL_BRIDGE_HOST, CHATPANEL_BRIDGE_PORT`);
+}
+
+// Handle CLI commands before starting the server. Returns true if a command ran.
+function runCli() {
+  const argv = process.argv;
+  const has = (...flags) => flags.some((f) => argv.includes(f));
+
+  if (has('--help', '-h')) {
+    printHelp();
+    return true;
   }
-  log('info', 'Open the ChatPanel side panel; Claude Code & Codex will appear as agents.');
-});
+  if (has('--version', '-v')) {
+    console.log(VERSION);
+    return true;
+  }
+  if (has('--install')) {
+    try {
+      installService();
+      log('info', 'Installed. The bridge now starts automatically at login and is running in the background.');
+    } catch (e) {
+      log('error', 'Install failed: ' + (e?.message || e));
+      process.exitCode = 1;
+    }
+    return true;
+  }
+  if (has('--uninstall')) {
+    try {
+      uninstallService();
+      log('info', 'Removed the login auto-start.');
+    } catch (e) {
+      log('error', 'Uninstall failed: ' + (e?.message || e));
+      process.exitCode = 1;
+    }
+    return true;
+  }
+  if (has('--status')) {
+    let on = false;
+    try {
+      on = serviceStatus();
+    } catch (e) {
+      log('error', String(e?.message || e));
+    }
+    log('info', `auto-start: ${on ? 'installed' : 'not installed'}`);
+    return true;
+  }
+  return false;
+}
+
+if (!runCli()) startServer();

package/src/service.js

@@ -0,0 +1,147 @@
+// Background auto-start for the ChatPanel Bridge.
+//
+// So non-technical users never touch a terminal: download the app, run it once
+// with --install, and it launches at login and stays running.
+//
+//   chatpanel-bridge --install     register login auto-start + start now
+//   chatpanel-bridge --uninstall   remove it
+//   chatpanel-bridge --status      is it registered?
+//
+// macOS → LaunchAgent · Windows → Scheduled Task (ONLOGON) · Linux → systemd user.
+
+import os from 'node:os';
+import path from 'node:path';
+import { mkdirSync, writeFileSync, rmSync, existsSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+
+const LABEL = 'net.chatpanel.bridge';
+const DISPLAY = 'ChatPanel Bridge';
+
+// The command that launches THIS bridge. A compiled single-file binary launches
+// itself (no args); running under node/bun launches the interpreter + this script.
+export function resolveLaunch() {
+  const exe = process.execPath;
+  const base = path.basename(exe).toLowerCase();
+  const underInterpreter = base.startsWith('node') || base.startsWith('bun');
+  if (underInterpreter && process.argv[1]) {
+    return { program: exe, args: [path.resolve(process.argv[1])] };
+  }
+  return { program: exe, args: [] };
+}
+
+function logPaths() {
+  const dir = path.join(os.homedir(), '.chatpanel');
+  mkdirSync(dir, { recursive: true });
+  return { out: path.join(dir, 'bridge.log'), err: path.join(dir, 'bridge.err.log') };
+}
+
+function run(cmd, args, opts = {}) {
+  return spawnSync(cmd, args, { encoding: 'utf8', ...opts });
+}
+
+// ---------------------------------------------------------------- macOS
+const macPlist = () => path.join(os.homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+
+function macInstall() {
+  const { program, args } = resolveLaunch();
+  const { out, err } = logPaths();
+  const progArgs = [program, ...args].map((a) => `      <string>${a}</string>`).join('\n');
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>Label</key><string>${LABEL}</string>
+    <key>ProgramArguments</key>
+    <array>
+${progArgs}
+    </array>
+    <key>RunAtLoad</key><true/>
+    <key>KeepAlive</key><true/>
+    <key>StandardOutPath</key><string>${out}</string>
+    <key>StandardErrorPath</key><string>${err}</string>
+  </dict>
+</plist>
+`;
+  const p = macPlist();
+  mkdirSync(path.dirname(p), { recursive: true });
+  writeFileSync(p, plist);
+  run('launchctl', ['unload', p]); // ignore if not loaded
+  const r = run('launchctl', ['load', '-w', p]);
+  if (r.status !== 0) throw new Error((r.stderr || '').trim() || 'launchctl load failed');
+}
+function macUninstall() {
+  const p = macPlist();
+  run('launchctl', ['unload', '-w', p]);
+  if (existsSync(p)) rmSync(p);
+}
+function macStatus() {
+  return (run('launchctl', ['list']).stdout || '').includes(LABEL);
+}
+
+// ---------------------------------------------------------------- Windows
+const WIN_TASK = 'ChatPanelBridge';
+
+function winInstall() {
+  const { program, args } = resolveLaunch();
+  const tr = [`"${program}"`, ...args.map((a) => `"${a}"`)].join(' ');
+  const r = run('schtasks', ['/Create', '/TN', WIN_TASK, '/TR', tr, '/SC', 'ONLOGON', '/RL', 'LIMITED', '/F']);
+  if (r.status !== 0) throw new Error((r.stderr || '').trim() || 'schtasks create failed');
+  run('schtasks', ['/Run', '/TN', WIN_TASK]); // start now
+}
+function winUninstall() {
+  run('schtasks', ['/Delete', '/TN', WIN_TASK, '/F']);
+}
+function winStatus() {
+  return run('schtasks', ['/Query', '/TN', WIN_TASK]).status === 0;
+}
+
+// ---------------------------------------------------------------- Linux (systemd user)
+const linUnit = () => path.join(os.homedir(), '.config', 'systemd', 'user', 'chatpanel-bridge.service');
+
+function linInstall() {
+  const { program, args } = resolveLaunch();
+  const exec = [program, ...args].map((a) => (/\s/.test(a) ? `"${a}"` : a)).join(' ');
+  const unit = `[Unit]
+Description=${DISPLAY}
+After=network.target
+
+[Service]
+ExecStart=${exec}
+Restart=on-failure
+
+[Install]
+WantedBy=default.target
+`;
+  const p = linUnit();
+  mkdirSync(path.dirname(p), { recursive: true });
+  writeFileSync(p, unit);
+  run('systemctl', ['--user', 'daemon-reload']);
+  const r = run('systemctl', ['--user', 'enable', '--now', 'chatpanel-bridge']);
+  if (r.status !== 0) throw new Error((r.stderr || '').trim() || 'systemctl enable failed');
+}
+function linUninstall() {
+  run('systemctl', ['--user', 'disable', '--now', 'chatpanel-bridge']);
+  const p = linUnit();
+  if (existsSync(p)) rmSync(p);
+}
+function linStatus() {
+  return (run('systemctl', ['--user', 'is-enabled', 'chatpanel-bridge']).stdout || '').trim() === 'enabled';
+}
+
+// ---------------------------------------------------------------- dispatch
+function byPlatform(mac, win, lin) {
+  if (process.platform === 'darwin') return mac();
+  if (process.platform === 'win32') return win();
+  if (process.platform === 'linux') return lin();
+  throw new Error(`Auto-start isn't supported on ${process.platform} yet — run the bridge directly.`);
+}
+
+export function installService() {
+  return byPlatform(macInstall, winInstall, linInstall);
+}
+export function uninstallService() {
+  return byPlatform(macUninstall, winUninstall, linUninstall);
+}
+export function serviceStatus() {
+  return byPlatform(macStatus, winStatus, linStatus);
+}