@chatpanel/bridge 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chatpanel/bridge",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "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/claude.js

@@ -55,6 +55,13 @@ export async function available() {
   return cachedOk ? { ok: true } : { ok: false, reason: lastReason };
 }
 
+// Claude Code has no "list models" command — it takes stable aliases (or full
+// ids). Return the common aliases so the picker has sensible options; the user
+// can still type any model string (e.g. claude-opus-4-8).
+export async function listModels() {
+  return ['opus', 'sonnet', 'haiku'];
+}
+
 // The bridge is stateless, so we replay the conversation as a single prompt.
 function buildPrompt(messages) {
   const history = messages.slice(0, -1);

package/src/engines/custom.js

@@ -32,6 +32,52 @@ export async function available() {
   return { ok: true };
 }
 
+// Parse a CLI's "list models" stdout into model ids. Tools format this very
+// differently (one-per-line, a table, "provider/model", …), so this is
+// best-effort: take the first token of each line that looks like an id and skip
+// obvious headers/prose. The picker always allows a custom value as a fallback.
+function parseModelList(stdout) {
+  const out = [];
+  const seen = new Set();
+  for (const raw of String(stdout || '').split('\n')) {
+    const tok = raw.trim().split(/\s+/)[0] || '';
+    if (!/^[A-Za-z0-9][\w./:-]{1,79}$/.test(tok)) continue;
+    if (/^(name|model|models|id|provider|available|usage|options|commands)$/i.test(tok)) continue;
+    if (seen.has(tok)) continue;
+    seen.add(tok);
+    out.push(tok);
+    if (out.length >= 200) break;
+  }
+  return out;
+}
+
+// Unified model listing: run the agent's CONFIGURED list-models invocation
+// (e.g. pi `--list-models`, opencode `models`) and parse the output. Returns []
+// when not configured. Pro-gated like chat (it runs the user's CLI).
+export async function listModels(options = {}) {
+  if (!(await isProEntitled(options.entitlement))) {
+    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;
+  const [bin, argv, opts] = buildSpawnSpec(resolved, listArgs.split(/\s+/).filter(Boolean), cwd);
+  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}`)); }
+    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('close', () => { clearTimeout(timer); resolve(out); });
+    try { child.stdin.end(); } catch { /* some CLIs don't read stdin */ }
+  });
+  return parseModelList(stdout);
+}
+
 // The bridge is stateless, so replay the conversation as a single prompt.
 function buildPrompt(messages, system) {
   let p = system ? `${system}\n\n` : '';
@@ -74,6 +120,17 @@ export async function chat({ messages, system, options }, emit) {
     : spec.args
       ? String(spec.args).split(/\s+/).filter(Boolean)
       : [];
+  // Inject the selected model via the agent's CONFIGURED model-arg template
+  // (e.g. "--model {model}" or, for opencode, "-m {model}" with provider/model).
+  // Without a template we can't know how this CLI takes a model, so options.model
+  // is ignored — preserving back-compat with agents that bake the model into args.
+  if (options.model && spec.modelArg) {
+    const tmpl = String(spec.modelArg);
+    const injected = tmpl.includes('{model}')
+      ? tmpl.replaceAll('{model}', options.model).split(/\s+/).filter(Boolean)
+      : [...tmpl.split(/\s+/).filter(Boolean), options.model];
+    args = [...injected, ...args];
+  }
   if (promptVia === 'arg') {
     let placed = false;
     args = args.map((a) => {

package/src/server.js

@@ -27,7 +27,7 @@ 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.1';
+const VERSION = '0.3.2';
 const HOST = process.env.CHATPANEL_BRIDGE_HOST || '127.0.0.1';
 const PORT = Number(process.env.CHATPANEL_BRIDGE_PORT) || 4319;
 
@@ -191,6 +191,28 @@ async function handleComplete(req, res) {
   }
 }
 
+// POST /list-models → { agent, options } → { models } — the unified model-list
+// interface. Each engine decides HOW to enumerate (claude → known aliases; custom
+// → runs the agent's configured `listModelsArgs`, e.g. pi `--list-models` /
+// opencode `models`, and parses stdout). Engines without a lister return [].
+async function handleListModels(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}"` });
+  if (typeof target.engine.listModels !== 'function') return json(res, 200, { models: [] });
+  try {
+    const models = await target.engine.listModels(body.options || {});
+    return json(res, 200, { models: Array.isArray(models) ? models : [] });
+  } catch (e) {
+    return json(res, 502, { error: e?.message || String(e) });
+  }
+}
+
 // POST /agent-check → { command } → { ok, via } — does this command resolve on
 // this machine? Powers the "✓ found" indicator when onboarding a custom agent.
 // `via` tells the user HOW it resolved (native / script / cmd / wsl) so a Windows
@@ -233,6 +255,7 @@ const server = createServer(async (req, res) => {
     }
     if (req.method === 'POST' && url.pathname === '/chat') return handleChat(req, res);
     if (req.method === 'POST' && url.pathname === '/complete') return handleComplete(req, res);
+    if (req.method === 'POST' && url.pathname === '/list-models') return handleListModels(req, res);
     if (req.method === 'POST' && url.pathname === '/agent-check') return handleAgentCheck(req, res);
     if (req.method === 'POST' && url.pathname === '/update') return handleUpdate(res);
     json(res, 404, { error: 'Not found' });