@supercollab/cli 0.4.4 → 0.4.5

package/README.md

@@ -133,6 +133,22 @@ Print MCP config:
 supercollab mcp print-config --client codex
 ```
 
+For Claude Desktop on macOS, generate the config from the project directory you
+want the agent to use:
+
+```bash
+cd /path/to/project
+supercollab mcp print-config --client claude
+```
+
+The Claude config uses absolute Node and CLI paths plus an explicit `PATH` so it
+does not depend on Homebrew, nvm, zsh, or GUI app shell startup behavior. Before
+opening Claude, verify the local MCP handshake:
+
+```bash
+supercollab mcp smoke
+```
+
 Default server: `https://hyper.polynode.dev`.
 
 Local config is stored at `~/.supercollab/config.json` with mode `0600`; the

package/bin/supercollab.js

@@ -3,11 +3,13 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import crypto from 'node:crypto';
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
 import * as readlineCore from 'node:readline';
 import { stdin as input, stdout as output } from 'node:process';
 
-const VERSION = '0.4.4';
+const VERSION = '0.4.5';
+const CLI_ENTRY = fileURLToPath(import.meta.url);
 const DEFAULT_SERVER = process.env.SUPERCOLLAB_URL || 'https://hyper.polynode.dev';
 const DEFAULT_CONFIG = process.env.SUPERCOLLAB_CONFIG || path.join(os.homedir(), '.supercollab', 'config.json');
 const SESSION_TTL_SKEW = 60;
@@ -60,6 +62,7 @@ Usage:
   supercollab embeddings warmup
   supercollab mcp stdio
   supercollab mcp print-config --client codex
+  supercollab mcp smoke [--timeout 5000]
   supercollab config path
 
 Options:
@@ -1169,9 +1172,96 @@ async function runMcp(opts) {
   }
 }
 
+function encodeMcpMessage(msg) {
+  const raw = Buffer.from(JSON.stringify(msg));
+  return Buffer.concat([Buffer.from(`Content-Length: ${raw.length}\r\n\r\n`), raw]);
+}
+
+function parseMcpMessages(state) {
+  const messages = [];
+  while (true) {
+    const headerEnd = state.buffer.indexOf('\r\n\r\n');
+    if (headerEnd < 0) break;
+    const header = state.buffer.subarray(0, headerEnd).toString();
+    const match = header.match(/content-length:\s*(\d+)/i);
+    if (!match) {
+      state.parseError = `missing content-length in MCP output: ${header.slice(0, 200)}`;
+      break;
+    }
+    const length = Number(match[1]);
+    const total = headerEnd + 4 + length;
+    if (state.buffer.length < total) break;
+    const body = state.buffer.subarray(headerEnd + 4, total).toString();
+    state.buffer = state.buffer.subarray(total);
+    try {
+      messages.push(JSON.parse(body));
+    } catch (err) {
+      state.parseError = err.message || String(err);
+      break;
+    }
+  }
+  return messages;
+}
+
+async function runMcpSmoke(opts) {
+  const file = configPath(opts);
+  const timeoutMs = Math.max(1000, Math.min(Number(opts.timeout || 5000), 30000));
+  const args = [CLI_ENTRY, 'mcp', 'stdio', '--config', file];
+  return await new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        PATH: defaultPathEnv(),
+        SUPERCOLLAB_CONFIG: file,
+      },
+    });
+    const state = { buffer: Buffer.alloc(0), parseError: null };
+    const responses = [];
+    let stderr = '';
+    let settled = false;
+    const finish = (err, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      try { child.kill('SIGTERM'); } catch {}
+      if (err) reject(err);
+      else resolve(result);
+    };
+    const timer = setTimeout(() => {
+      finish(new Error(`MCP smoke timed out after ${timeoutMs}ms. stderr: ${stderr.slice(0, 1000)}`));
+    }, timeoutMs);
+    child.on('error', (err) => finish(err));
+    child.stderr.on('data', (chunk) => { stderr += chunk.toString(); });
+    child.stdout.on('data', (chunk) => {
+      state.buffer = Buffer.concat([state.buffer, chunk]);
+      for (const msg of parseMcpMessages(state)) responses.push(msg);
+      if (state.parseError) {
+        finish(new Error(state.parseError));
+        return;
+      }
+      if (responses.some((msg) => msg.id === 1) && responses.some((msg) => msg.id === 2)) {
+        const init = responses.find((msg) => msg.id === 1);
+        const tools = responses.find((msg) => msg.id === 2);
+        finish(null, {
+          ok: Boolean(init?.result?.serverInfo && Array.isArray(tools?.result?.tools)),
+          command: process.execPath,
+          args,
+          config: file,
+          server_info: init?.result?.serverInfo || null,
+          tools: (tools?.result?.tools || []).map((tool) => tool.name),
+          stderr: stderr.trim() || null,
+        });
+      }
+    });
+    child.stdin.write(encodeMcpMessage({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} }));
+    child.stdin.write(encodeMcpMessage({ jsonrpc: '2.0', id: 2, method: 'tools/list', params: {} }));
+  });
+}
+
 function printCodexConfig(opts) {
   const file = configPath(opts);
-  console.log(mcpConfigText(String(opts.client || 'codex'), file));
+  console.log(mcpConfigText(String(opts.client || 'codex'), file, opts));
 }
 
 async function embeddingStatus() {
@@ -1670,14 +1760,35 @@ async function runSetupSmoke(config, file, roomId, prompts) {
   };
 }
 
-function mcpConfigText(client, file) {
+function defaultPathEnv() {
+  const parts = [
+    path.dirname(process.execPath),
+    '/opt/homebrew/bin',
+    '/usr/local/bin',
+    '/usr/bin',
+    '/bin',
+    '/usr/sbin',
+    '/sbin',
+    process.env.PATH || '',
+  ].flatMap((part) => String(part || '').split(path.delimiter)).filter(Boolean);
+  return Array.from(new Set(parts)).join(path.delimiter);
+}
+
+function mcpConfigText(client, file, opts = {}) {
+  const absoluteFile = path.resolve(file);
   const escaped = file.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
   if (client === 'claude') {
+    const cwd = path.resolve(String(opts.cwd || process.env.SUPERCOLLAB_WORKDIR || process.cwd()));
     return JSON.stringify({
       mcpServers: {
         supercollab: {
-          command: 'supercollab',
-          args: ['mcp', 'stdio', '--config', file],
+          type: 'stdio',
+          command: process.execPath,
+          args: [CLI_ENTRY, 'mcp', 'stdio', '--config', absoluteFile],
+          env: {
+            PATH: defaultPathEnv(),
+            SUPERCOLLAB_WORKDIR: cwd,
+          },
         },
       },
     }, null, 2);
@@ -2321,6 +2432,7 @@ async function main() {
     if (sub === 'warmup') return console.log(JSON.stringify(await embeddingWarmup(), null, 2));
   }
   if (cmd === 'mcp' && sub === 'stdio') return runMcp(opts);
+  if (cmd === 'mcp' && sub === 'smoke') return console.log(JSON.stringify(await runMcpSmoke(opts), null, 2));
   if (cmd === 'mcp' && sub === 'print-config') return printCodexConfig(opts);
   throw new Error(`unknown command: ${positionals.join(' ')}`);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supercollab/cli",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "description": "SuperCollab CLI and MCP bridge for encrypted local-search agent group chat.",
   "type": "module",
   "bin": {