@chatpanel/bridge 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "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": [

package/src/engines/claude.js

@@ -122,6 +122,38 @@ export async function chat({ messages, system, options }, emit) {
   emit({ type: 'done', text: streamedAny ? '' : resultText });
 }
 
+// A fast, tool-free single-shot completion — used for prompt autocomplete. No
+// claude_code preset, no tools, no local config: just a quick text continuation
+// from a fast model (Haiku by default). Returns the completion string.
+export async function complete({ prompt, system, model }) {
+  const sdk = await loadSdk();
+  if (!sdk) throw new Error('Claude Agent SDK not installed.');
+  const { query } = sdk;
+  let text = '';
+  const iterator = query({
+    prompt,
+    options: {
+      cwd: os.homedir(),
+      permissionMode: 'default',
+      allowedTools: [], // no tools — pure text completion
+      maxTurns: 1,
+      settingSources: [], // skip CLAUDE.md / MCP for a tiny completion
+      systemPrompt: system || "Continue the user's text briefly. Reply with only the continuation.",
+      model: model || 'haiku',
+    },
+  });
+  for await (const message of iterator) {
+    if (message.type === 'assistant') {
+      for (const block of message.message.content) {
+        if (block.type === 'text') text += block.text;
+      }
+    } else if (message.type === 'result' && message.subtype === 'success' && !text) {
+      text = message.result || '';
+    }
+  }
+  return text.trim();
+}
+
 function toolSummary(block) {
   const i = block.input || {};
   if (i.command) return String(i.command).slice(0, 60);

package/src/env.js

@@ -0,0 +1,59 @@
+// Resolve a usable PATH for spawning the agent CLIs (codex, gemini).
+//
+// 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.
+// So CLIs installed via Homebrew, npm-global, nvm, etc. aren't found. We fix that
+// by (1) asking your login shell for its PATH and (2) adding common bin dirs.
+
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+let enriched = false;
+
+export function enrichPath() {
+  if (enriched || process.platform === 'win32') {
+    enriched = true;
+    return; // Windows scheduled tasks run as the user and inherit a fuller PATH.
+  }
+  enriched = true;
+
+  const home = os.homedir();
+  const common = [
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+    '/usr/sbin',
+    '/sbin',
+    path.join(home, '.local', 'bin'),
+    path.join(home, 'bin'),
+    path.join(home, '.npm-global', 'bin'),
+    path.join(home, '.cargo', 'bin'),
+    path.join(home, '.deno', 'bin'),
+    path.join(home, '.bun', 'bin'),
+  ];
+
+  // Ask the user's login shell for its PATH — captures nvm / Homebrew / asdf, etc.
+  let shellPath = '';
+  try {
+    const shell = process.env.SHELL || '/bin/zsh';
+    const r = spawnSync(shell, ['-ilc', 'command -p echo "$PATH"'], {
+      encoding: 'utf8',
+      timeout: 4000,
+    });
+    if (r.status === 0) shellPath = (r.stdout || '').trim();
+  } catch {
+    /* fall back to common dirs below */
+  }
+
+  const seen = new Set();
+  const merged = [
+    ...(shellPath ? shellPath.split(':') : []),
+    ...(process.env.PATH ? process.env.PATH.split(path.delimiter) : []),
+    ...common,
+  ].filter((p) => p && !seen.has(p) && (seen.add(p), true));
+
+  process.env.PATH = merged.join(path.delimiter);
+}

package/src/server.js

@@ -19,8 +19,9 @@ 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';
+import { enrichPath } from './env.js';
 
-const VERSION = '0.2.0';
+const VERSION = '0.2.2';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
@@ -125,6 +126,46 @@ async function handleChat(req, res) {
   }
 }
 
+// POST /complete → { agent, prompt, model? } → { text } — a fast, single-shot
+// completion for prompt autocomplete. Uses the engine's complete() if it has one
+// (Claude: Haiku, no tools), else a one-shot chat collected into text.
+async function handleComplete(req, res) {
+  let body;
+  try {
+    body = await readBody(req);
+  } catch (e) {
+    return json(res, 400, { error: 'Bad JSON: ' + e.message });
+  }
+  const target = ENGINES[body.agent];
+  if (!target) return json(res, 404, { error: `Unknown agent "${body.agent}"` });
+  const prompt = String(body.prompt || '').slice(0, 6000);
+  if (!prompt) return json(res, 400, { error: 'Empty prompt' });
+  const model = body.model || '';
+  // The extension sends a strict "continue, don't answer" system prompt (with any
+  // page context already in `prompt`); fall back to a sensible default.
+  const system =
+    String(body.system || '').slice(0, 2000) ||
+    'You autocomplete an unfinished message the user is typing. Output ONLY the ' +
+      'few words that come next. Do not answer it. No quotes, no repetition.';
+  try {
+    let text = '';
+    if (typeof target.engine.complete === 'function') {
+      text = await target.engine.complete({ prompt, system, model });
+    } else {
+      await target.engine.chat(
+        { messages: [{ role: 'user', content: prompt }], system, options: { model } },
+        (obj) => {
+          if (obj.type === 'delta') text += obj.text || '';
+          else if (obj.type === 'done' && obj.text) text += obj.text;
+        },
+      );
+    }
+    return json(res, 200, { text: (text || '').trim() });
+  } catch (e) {
+    return json(res, 502, { error: e?.message || String(e) });
+  }
+}
+
 const server = createServer(async (req, res) => {
   cors(req, res);
   if (req.method === 'OPTIONS') {
@@ -135,6 +176,7 @@ const server = createServer(async (req, res) => {
   try {
     if (req.method === 'GET' && url.pathname === '/health') return handleHealth(res);
     if (req.method === 'POST' && url.pathname === '/chat') return handleChat(req, res);
+    if (req.method === 'POST' && url.pathname === '/complete') return handleComplete(req, res);
     json(res, 404, { error: 'Not found' });
   } catch (e) {
     json(res, 500, { error: e?.message || String(e) });
@@ -147,6 +189,7 @@ function log(level, msg) {
 }
 
 function startServer() {
+  enrichPath(); // so codex/gemini are found even under a minimal service PATH
   server.listen(PORT, HOST, async () => {
     log('info', `listening on http://${HOST}:${PORT}`);
     for (const [, { engine, label }] of Object.entries(ENGINES)) {