@supercollab/cli 0.4.3 → 0.4.5

package/README.md

@@ -15,11 +15,33 @@ npm install -g @supercollab/cli
 supercollab
 ```
 
-Running `supercollab` opens the guided setup flow. It detects your OS/CPU/Node
-runtime, verifies native SQLite and sqlite-vec, downloads and warms the BGE model
-locally, writes the selected local engine into `~/.supercollab/config.json`,
-creates or logs into your account, registers the local agent, creates or joins a
-room, activates a project directory, and prints MCP config.
+Running `supercollab` opens guided setup the first time, then opens the full
+interactive menu after your account and local agent are configured. You can also
+open the menu directly:
+
+```bash
+supercollab menu
+```
+
+The menu is designed so normal use does not require memorizing command-line
+flags. It includes scrollable/selectable flows for:
+
+- creating a room
+- joining with a private invite
+- choosing an existing room
+- typing a room ID manually when needed
+- activating a room for a local project directory
+- creating private invites
+- sending, reading, syncing, and searching room messages
+- running the local system check and BGE model install/warmup
+- viewing MCP config snippets
+- managing sessions and server settings
+
+Guided setup detects your OS/CPU/Node runtime, verifies native SQLite and
+sqlite-vec, downloads and warms the BGE model locally, writes the selected local
+engine into `~/.supercollab/config.json`, creates or logs into your account,
+registers the local agent, creates/joins/selects a room, activates a project
+directory, and prints MCP config.
 
 You can also run the checks directly:
 
@@ -111,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.3';
+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;
@@ -34,6 +36,7 @@ function printHelp() {
   console.log(`SuperCollab CLI ${VERSION}
 
 Usage:
+  supercollab menu
   supercollab setup
   supercollab doctor [--json] [--skip-model]
   supercollab register --username NAME [--password PASS] [--label LABEL]
@@ -59,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:
@@ -1168,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() {
@@ -1302,6 +1393,234 @@ function promptRequired(value) {
   return String(value || '').trim() ? undefined : 'Required';
 }
 
+function trimmed(value) {
+  return String(value || '').trim();
+}
+
+function shorten(value, max = 80) {
+  const text = String(value || '').replace(/\s+/g, ' ').trim();
+  if (text.length <= max) return text;
+  return `${text.slice(0, Math.max(0, max - 3))}...`;
+}
+
+function roomIdFrom(room) {
+  return trimmed(room?.room_id || room?.id || room?.workspace_id);
+}
+
+function roomTitleFrom(room) {
+  return trimmed(room?.title || room?.name || room?.slug || room?.goal || roomIdFrom(room));
+}
+
+function roomsFromResponse(data) {
+  if (Array.isArray(data)) return data;
+  if (Array.isArray(data?.rooms)) return data.rooms;
+  if (Array.isArray(data?.workspaces)) return data.workspaces;
+  if (Array.isArray(data?.items)) return data.items;
+  return [];
+}
+
+function hasLocalRoomKey(config, roomId) {
+  return Boolean(config.roomKeys?.[roomId]);
+}
+
+function roomLabel(room, config) {
+  const roomId = roomIdFrom(room);
+  const title = roomTitleFrom(room);
+  const prefix = title && title !== roomId ? `${shorten(title, 42)} ` : '';
+  const key = hasLocalRoomKey(config, roomId) ? 'key saved' : 'key missing';
+  return `${prefix}(${roomId})`;
+}
+
+function roomHint(room, config) {
+  const roomId = roomIdFrom(room);
+  const pieces = [];
+  const goal = trimmed(room?.goal || room?.description);
+  if (goal) pieces.push(shorten(goal, 48));
+  pieces.push(hasLocalRoomKey(config, roomId) ? 'encrypted local search ready' : 'join/import key to decrypt');
+  return pieces.join(' - ');
+}
+
+async function listRoomsForMenu(config) {
+  const data = await apiAsAgent(config, 'GET', '/v1/rooms');
+  return roomsFromResponse(data).filter((room) => roomIdFrom(room));
+}
+
+async function promptManualRoomId(prompts, message = 'Room ID') {
+  const roomId = await prompts.text({
+    message,
+    placeholder: 'room_...',
+    validate: promptRequired,
+  });
+  if (prompts.isCancel(roomId)) throw new Error('cancelled');
+  return trimmed(roomId);
+}
+
+async function ensureRoomKeyFromMenu(config, file, prompts, roomId) {
+  try {
+    ensureRoomKey(config, roomId);
+    return true;
+  } catch {
+    const choice = await prompts.select({
+      message: `No local room key for ${roomId}`,
+      options: [
+        { value: 'invite', label: 'Join with private invite', hint: 'recommended if another member invited you' },
+        { value: 'key', label: 'Paste room key', hint: 'sck_... from a trusted device' },
+        { value: 'choose', label: 'Choose another room' },
+        { value: 'cancel', label: 'Cancel' },
+      ],
+    });
+    if (prompts.isCancel(choice) || choice === 'cancel') throw new Error('cancelled');
+    if (choice === 'choose') return false;
+    if (choice === 'invite') {
+      const joined = await promptJoinRoom(config, file, prompts, { quiet: true });
+      return Boolean(joined?.room_id === roomId || joined?.workspace_id === roomId || hasLocalRoomKey(config, roomId));
+    }
+    const key = await prompts.text({
+      message: 'Paste room key',
+      placeholder: 'sck_...',
+      validate: (value) => {
+        try {
+          roomKeyBytes(trimmed(value));
+          return undefined;
+        } catch {
+          return 'Invalid room key';
+        }
+      },
+    });
+    if (prompts.isCancel(key)) throw new Error('cancelled');
+    storeRoomKey(config, roomId, trimmed(key));
+    saveConfig(config, file);
+    return true;
+  }
+}
+
+async function selectRoom(config, file, prompts, options = {}) {
+  const {
+    message = 'Choose room',
+    requireKey = true,
+    includeCreate = false,
+    includeJoin = false,
+    includeManual = true,
+  } = options;
+
+  while (true) {
+    let rooms = [];
+    try {
+      rooms = await listRoomsForMenu(config);
+    } catch (err) {
+      prompts.note(err.message || String(err), 'Could not load rooms');
+    }
+
+    const choices = rooms.map((room) => ({
+      value: roomIdFrom(room),
+      label: roomLabel(room, config),
+      hint: roomHint(room, config),
+    }));
+    if (includeCreate) choices.push({ value: '__create', label: 'Create new room', hint: 'set title and goal now' });
+    if (includeJoin) choices.push({ value: '__join', label: 'Join with private invite', hint: 'paste sci_...sck_...' });
+    if (includeManual) choices.push({ value: '__manual', label: 'Type room ID manually', hint: 'room_...' });
+    choices.push({ value: '__back', label: 'Back' });
+
+    const selected = await prompts.select({ message, options: choices });
+    if (prompts.isCancel(selected) || selected === '__back') throw new Error('cancelled');
+
+    if (selected === '__create') {
+      const created = await promptCreateRoom(config, file, prompts, { quiet: true });
+      if (created?.room_id) return created.room_id;
+      continue;
+    }
+    if (selected === '__join') {
+      const joined = await promptJoinRoom(config, file, prompts, { quiet: true });
+      const joinedRoomId = joined?.room_id || joined?.workspace_id;
+      if (joinedRoomId) return joinedRoomId;
+      continue;
+    }
+
+    const roomId = selected === '__manual'
+      ? await promptManualRoomId(prompts)
+      : String(selected);
+
+    if (!requireKey) return roomId;
+    const ok = await ensureRoomKeyFromMenu(config, file, prompts, roomId);
+    if (ok) return roomId;
+  }
+}
+
+function formatMessagesForNote(messages, maxRows = 12) {
+  const rows = (messages || []).slice(-maxRows);
+  if (!rows.length) return 'No messages yet.';
+  return rows.map((row) => {
+    const when = trimmed(row.created_at).replace('T', ' ').replace('Z', '');
+    return `[${when}] ${row.sender_label || row.actor_id || 'agent'}\n${shorten(row.body, 260)}`;
+  }).join('\n\n');
+}
+
+function formatSearchForNote(results, maxRows = 8) {
+  const rows = (results || []).slice(0, maxRows);
+  if (!rows.length) return 'No matching messages.';
+  return rows.map((row, idx) => {
+    const sources = Array.isArray(row.search_sources) ? row.search_sources.join('+') : 'match';
+    return `${idx + 1}. ${row.sender_label || row.actor_id || 'agent'} - ${sources}\n${shorten(row.body, 260)}`;
+  }).join('\n\n');
+}
+
+async function promptCreateRoom(config, file, prompts, options = {}) {
+  const title = await prompts.text({
+    message: 'Room title',
+    placeholder: 'Launch Room',
+    validate: promptRequired,
+  });
+  if (prompts.isCancel(title)) throw new Error('cancelled');
+  const goal = await prompts.text({
+    message: 'Room goal',
+    placeholder: 'Coordinate agents on this project',
+    validate: promptRequired,
+  });
+  if (prompts.isCancel(goal)) throw new Error('cancelled');
+  const slug = await prompts.text({
+    message: 'Optional short slug',
+    placeholder: 'press Enter to skip',
+  });
+  if (prompts.isCancel(slug)) throw new Error('cancelled');
+  const spin = prompts.spinner();
+  spin.start('Creating encrypted room');
+  try {
+    const created = await doRoomCreate(config, file, {
+      title: trimmed(title),
+      goal: trimmed(goal),
+      slug: trimmed(slug) || undefined,
+    });
+    const roomId = created.room_id || created.id;
+    spin.stop(`Room created: ${roomId}`);
+    if (!options.quiet) prompts.note(`Room ID: ${roomId}\nLocal room key: saved on this machine`, 'Room created');
+    return { ...created, room_id: roomId };
+  } catch (err) {
+    spin.stop('Room creation failed');
+    throw err;
+  }
+}
+
+async function promptJoinRoom(config, file, prompts, options = {}) {
+  const invite = await prompts.text({
+    message: 'Paste private invite',
+    placeholder: 'sci_....sck_...',
+    validate: promptRequired,
+  });
+  if (prompts.isCancel(invite)) throw new Error('cancelled');
+  const spin = prompts.spinner();
+  spin.start('Joining room and saving local room key');
+  try {
+    const joined = await doRoomJoin(config, file, { invite: trimmed(invite) });
+    const roomId = joined.room_id || joined.workspace_id;
+    spin.stop(`Joined room: ${roomId}`);
+    if (!options.quiet) prompts.note(`Room ID: ${roomId}\nLocal room key saved: ${joined.room_key_saved ? 'yes' : 'no'}`, 'Joined');
+    return { ...joined, room_id: roomId };
+  } catch (err) {
+    spin.stop('Join failed');
+    throw err;
+  }
+}
+
 async function ensureAgentForSetup(config, file, prompts) {
   if (config.agentId && config.agentPrivateKeyPem) return null;
   const label = await prompts.text({
@@ -1360,6 +1679,7 @@ async function runRoomSetup(config, file, prompts) {
   const choice = await prompts.select({
     message: 'Room setup',
     options: [
+      { value: 'existing', label: 'Use an existing room', hint: 'pick from your rooms or type a room ID' },
       { value: 'create', label: 'Create a new room', hint: 'start solo or invite agents later' },
       { value: 'join', label: 'Join with private invite', hint: 'paste sci_...sck_...' },
       { value: 'skip', label: 'Skip for now', hint: 'set up auth and local engine only' },
@@ -1368,35 +1688,40 @@ async function runRoomSetup(config, file, prompts) {
   if (prompts.isCancel(choice)) throw new Error('cancelled');
   if (choice === 'skip') return null;
 
-  if (choice === 'join') {
-    const invite = await prompts.text({
-      message: 'Paste private invite',
-      placeholder: 'sci_....sck_...',
-      validate: promptRequired,
+  if (choice === 'existing') {
+    const roomId = await selectRoom(config, file, prompts, {
+      message: 'Choose room to use',
+      requireKey: true,
+      includeCreate: true,
+      includeJoin: true,
     });
-    if (prompts.isCancel(invite)) throw new Error('cancelled');
-    const joined = await doRoomJoin(config, file, { invite: String(invite).trim() });
+    return { room_id: roomId, existing: true };
+  }
+
+  if (choice === 'join') {
+    const joined = await promptJoinRoom(config, file, prompts, { quiet: true });
     return { room_id: joined.room_id || joined.workspace_id, joined };
   }
 
-  const title = await prompts.text({
-    message: 'Room title',
-    placeholder: 'Launch Room',
-    validate: promptRequired,
-  });
-  if (prompts.isCancel(title)) throw new Error('cancelled');
-  const goal = await prompts.text({
-    message: 'Room goal',
-    placeholder: 'Coordinate agents on this project',
-    validate: promptRequired,
-  });
-  if (prompts.isCancel(goal)) throw new Error('cancelled');
-  const created = await doRoomCreate(config, file, { title: String(title), goal: String(goal) });
+  const created = await promptCreateRoom(config, file, prompts, { quiet: true });
   return { room_id: created.room_id || created.id, created };
 }
 
 async function runActivationSetup(config, file, roomId, prompts) {
-  if (!roomId) return null;
+  if (!roomId) {
+    const pick = await prompts.confirm({
+      message: 'Activate an existing room for this project directory?',
+      initialValue: false,
+    });
+    if (prompts.isCancel(pick)) throw new Error('cancelled');
+    if (!pick) return null;
+    roomId = await selectRoom(config, file, prompts, {
+      message: 'Choose room to activate',
+      requireKey: true,
+      includeCreate: true,
+      includeJoin: true,
+    });
+  }
   const shouldActivate = await prompts.confirm({
     message: 'Activate SuperCollab for a local project directory now?',
     initialValue: true,
@@ -1435,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);
@@ -1453,6 +1799,523 @@ function mcpConfigText(client, file) {
   return `supercollab mcp stdio --config "${escaped}"`;
 }
 
+async function promptSystemCheck(config, file, prompts) {
+  const spin = prompts.spinner();
+  spin.start('Checking this machine and warming the local BGE model');
+  const doctor = await runDoctor(config, file, {});
+  spin.stop(doctor.ok ? 'Local engine ready' : 'Local engine needs attention');
+  const checks = [
+    `Node: ${doctor.checks.node_supported.ok ? 'ok' : 'needs Node >=20'} (${doctor.system.node})`,
+    `SQLite vector engine: ${doctor.checks.native_sqlite_vec.ok ? 'ok' : 'failed'}${doctor.checks.native_sqlite_vec.sqlite_vec_version ? ` (${doctor.checks.native_sqlite_vec.sqlite_vec_version})` : ''}`,
+    `BGE model: ${doctor.checks.bge_model.ok ? 'ok' : doctor.checks.bge_model.skipped ? 'skipped' : 'failed'}`,
+    `Embedding profile: ${doctor.local_engine.embedding_profile_id}`,
+  ];
+  if (doctor.advice?.length) checks.push('', ...doctor.advice);
+  prompts.note(checks.join('\n'), doctor.ok ? 'Doctor passed' : 'Doctor');
+  return doctor;
+}
+
+async function promptActivateRoom(config, file, prompts, options = {}) {
+  const roomId = options.roomId || await selectRoom(config, file, prompts, {
+    message: 'Choose room to activate',
+    requireKey: true,
+    includeCreate: true,
+    includeJoin: true,
+  });
+  const cwd = await prompts.text({
+    message: 'Project directory',
+    defaultValue: options.cwd || process.cwd(),
+    placeholder: options.cwd || process.cwd(),
+    validate: (value) => {
+      const resolved = path.resolve(String(value || ''));
+      return fs.existsSync(resolved) ? undefined : 'Directory does not exist';
+    },
+  });
+  if (prompts.isCancel(cwd)) throw new Error('cancelled');
+  const activation = activate(config, file, { room: roomId, cwd: String(cwd) });
+  prompts.note(`${activation.instructions}\n\nActivation root: ${activation.cwd}`, 'Workspace active');
+  return activation;
+}
+
+async function promptDeactivateRoom(config, file, prompts, options = {}) {
+  const cwd = await prompts.text({
+    message: 'Directory to deactivate',
+    defaultValue: options.cwd || process.cwd(),
+    placeholder: options.cwd || process.cwd(),
+    validate: (value) => fs.existsSync(path.resolve(String(value || ''))) ? undefined : 'Directory does not exist',
+  });
+  if (prompts.isCancel(cwd)) throw new Error('cancelled');
+  const result = deactivate(config, file, { cwd: String(cwd) });
+  prompts.note(`SuperCollab is off for ${result.cwd}`, 'Workspace deactivated');
+  return result;
+}
+
+async function promptCreateInvite(config, file, prompts, options = {}) {
+  const roomId = options.roomId || await selectRoom(config, file, prompts, {
+    message: 'Choose room to invite into',
+    requireKey: true,
+    includeCreate: true,
+    includeJoin: false,
+  });
+  const role = await prompts.select({
+    message: 'Invite role',
+    options: [
+      { value: 'member', label: 'Member', hint: 'normal agent/user access' },
+    ],
+  });
+  if (prompts.isCancel(role)) throw new Error('cancelled');
+  const ttl = await prompts.select({
+    message: 'Invite expiry',
+    options: [
+      { value: 86400, label: '24 hours' },
+      { value: 3600, label: '1 hour' },
+      { value: 604800, label: '7 days' },
+    ],
+  });
+  if (prompts.isCancel(ttl)) throw new Error('cancelled');
+  const spin = prompts.spinner();
+  spin.start('Creating private invite');
+  try {
+    const data = await doRoomInvite(config, { room: roomId, role, ttl_seconds: ttl });
+    spin.stop('Private invite created');
+    prompts.note(data.private_invite, 'Share this private invite');
+    return data;
+  } catch (err) {
+    spin.stop('Invite failed');
+    throw err;
+  }
+}
+
+async function promptSendMessage(config, file, prompts, options = {}) {
+  const roomId = options.roomId || await selectRoom(config, file, prompts, {
+    message: 'Choose room to message',
+    requireKey: true,
+    includeCreate: true,
+    includeJoin: true,
+  });
+  let channel = await prompts.select({
+    message: 'Channel',
+    options: [
+      { value: 'agents', label: 'Agents', hint: 'default coordination chat' },
+      { value: 'progress', label: 'Progress', hint: 'status notes' },
+      { value: 'decisions', label: 'Decisions', hint: 'architecture/product decisions' },
+      { value: 'blockers', label: 'Blockers', hint: 'things that need attention' },
+      { value: '__custom', label: 'Type custom channel' },
+    ],
+  });
+  if (prompts.isCancel(channel)) throw new Error('cancelled');
+  if (channel === '__custom') {
+    channel = await prompts.text({ message: 'Channel name', validate: promptRequired });
+    if (prompts.isCancel(channel)) throw new Error('cancelled');
+  }
+  const kind = await prompts.select({
+    message: 'Message type',
+    options: [
+      { value: 'chat.message', label: 'Chat message' },
+      { value: 'progress.note', label: 'Progress note' },
+      { value: 'decision.note', label: 'Decision note' },
+      { value: 'blocker.note', label: 'Blocker note' },
+    ],
+  });
+  if (prompts.isCancel(kind)) throw new Error('cancelled');
+  const text = await prompts.text({
+    message: 'Message',
+    placeholder: 'Concise agent-to-agent note',
+    validate: promptRequired,
+  });
+  if (prompts.isCancel(text)) throw new Error('cancelled');
+  const spin = prompts.spinner();
+  spin.start('Encrypting, uploading, and indexing locally');
+  try {
+    const data = await doChatSend(config, file, {
+      room: roomId,
+      text: String(text),
+      channel: trimmed(channel) || 'agents',
+      kind,
+    });
+    spin.stop('Message sent');
+    prompts.note(`Room: ${roomId}\nMessage ID: ${data.message?.message_id || data.message?.id || 'saved'}`, 'Sent');
+    return data;
+  } catch (err) {
+    spin.stop('Send failed');
+    throw err;
+  }
+}
+
+async function promptReadMessages(config, file, prompts, options = {}) {
+  const roomId = options.roomId || await selectRoom(config, file, prompts, {
+    message: 'Choose room to read',
+    requireKey: true,
+    includeCreate: false,
+    includeJoin: true,
+  });
+  const limit = await prompts.select({
+    message: 'How many recent messages?',
+    options: [
+      { value: 20, label: '20 messages' },
+      { value: 50, label: '50 messages' },
+      { value: 100, label: '100 messages' },
+      { value: 200, label: '200 messages' },
+    ],
+  });
+  if (prompts.isCancel(limit)) throw new Error('cancelled');
+  const spin = prompts.spinner();
+  spin.start('Syncing and decrypting transcript locally');
+  try {
+    const data = await doChatRead(config, file, { room: roomId, limit });
+    spin.stop(`Read ${data.messages.length} local messages`);
+    prompts.note(formatMessagesForNote(data.messages), `Recent messages (${roomId})`);
+    return data;
+  } catch (err) {
+    spin.stop('Read failed');
+    throw err;
+  }
+}
+
+async function promptSearchMessages(config, file, prompts, options = {}) {
+  const roomId = options.roomId || await selectRoom(config, file, prompts, {
+    message: 'Choose room to search',
+    requireKey: true,
+    includeCreate: false,
+    includeJoin: true,
+  });
+  const query = await prompts.text({
+    message: 'Search query',
+    placeholder: 'auth decisions, current blocker, setup note...',
+    validate: promptRequired,
+  });
+  if (prompts.isCancel(query)) throw new Error('cancelled');
+  const mode = await prompts.select({
+    message: 'Search mode',
+    options: [
+      { value: 'hybrid', label: 'Hybrid', hint: 'keyword + BGE vector' },
+      { value: 'keyword', label: 'Keyword', hint: 'SQLite FTS/BM25' },
+      { value: 'vector', label: 'Vector', hint: 'local BGE cosine search' },
+    ],
+  });
+  if (prompts.isCancel(mode)) throw new Error('cancelled');
+  const limit = await prompts.select({
+    message: 'Result limit',
+    options: [
+      { value: 10, label: '10 results' },
+      { value: 20, label: '20 results' },
+      { value: 50, label: '50 results' },
+    ],
+  });
+  if (prompts.isCancel(limit)) throw new Error('cancelled');
+  const spin = prompts.spinner();
+  spin.start('Syncing, embedding locally, and searching');
+  try {
+    const data = await doChatSearch(config, file, { room: roomId, query: String(query), mode, limit });
+    spin.stop(`Found ${data.results.length} result(s)`);
+    prompts.note(formatSearchForNote(data.results), `Search results (${mode})`);
+    return data;
+  } catch (err) {
+    spin.stop('Search failed');
+    throw err;
+  }
+}
+
+async function promptSyncRoom(config, file, prompts, options = {}) {
+  const roomId = options.roomId || await selectRoom(config, file, prompts, {
+    message: 'Choose room to sync',
+    requireKey: true,
+    includeCreate: false,
+    includeJoin: true,
+  });
+  const spin = prompts.spinner();
+  spin.start('Syncing encrypted room transcript into local SQLite');
+  try {
+    const data = await syncRoom(config, file, roomId);
+    spin.stop(`Pulled ${data.pulled} message(s)`);
+    prompts.note(`Local DB: ${data.db}\nLast message ID: ${data.last_message_id}\nChunks embedded: ${data.embedding?.chunks_embedded || 0}`, 'Sync complete');
+    return data;
+  } catch (err) {
+    spin.stop('Sync failed');
+    throw err;
+  }
+}
+
+async function promptRoomActions(config, file, prompts, roomId) {
+  while (true) {
+    const action = await prompts.select({
+      message: `Room ${roomId}`,
+      options: [
+        { value: 'activate', label: 'Activate for a project directory' },
+        { value: 'invite', label: 'Create private invite' },
+        { value: 'send', label: 'Send message' },
+        { value: 'read', label: 'Read recent messages' },
+        { value: 'search', label: 'Search transcript' },
+        { value: 'sync', label: 'Sync locally' },
+        { value: 'back', label: 'Back' },
+      ],
+    });
+    if (prompts.isCancel(action) || action === 'back') return;
+    try {
+      if (action === 'activate') await promptActivateRoom(config, file, prompts, { roomId });
+      if (action === 'invite') await promptCreateInvite(config, file, prompts, { roomId });
+      if (action === 'send') await promptSendMessage(config, file, prompts, { roomId });
+      if (action === 'read') await promptReadMessages(config, file, prompts, { roomId });
+      if (action === 'search') await promptSearchMessages(config, file, prompts, { roomId });
+      if (action === 'sync') await promptSyncRoom(config, file, prompts, { roomId });
+    } catch (err) {
+      if (err.message !== 'cancelled') prompts.note(err.message || String(err), 'Action failed');
+    }
+  }
+}
+
+async function promptBrowseRooms(config, file, prompts) {
+  const roomId = await selectRoom(config, file, prompts, {
+    message: 'Choose room',
+    requireKey: false,
+    includeCreate: true,
+    includeJoin: true,
+    includeManual: true,
+  });
+  const ok = await ensureRoomKeyFromMenu(config, file, prompts, roomId);
+  if (!ok) return promptBrowseRooms(config, file, prompts);
+  return promptRoomActions(config, file, prompts, roomId);
+}
+
+async function promptAccountStatus(config, file, prompts) {
+  let me = null;
+  try {
+    me = config.userToken ? await api(config, 'GET', '/v1/me', undefined, config.userToken) : null;
+  } catch {}
+  const active = await activeStatus(config, file, {});
+  const rooms = await listRoomsForMenu(config).catch(() => []);
+  const lines = [
+    `Server: ${config.serverUrl || DEFAULT_SERVER}`,
+    `User: ${config.username || me?.username || 'not logged in'}`,
+    `Agent: ${config.agentLabel || config.agentId || 'not registered'}`,
+    `Fingerprint: ${config.agentFingerprint || 'none'}`,
+    `Rooms visible: ${rooms.length}`,
+    `Current directory: ${active.active ? `active in ${active.room_id}` : 'SuperCollab off'}`,
+    `Config: ${file}`,
+  ];
+  prompts.note(lines.join('\n'), 'Account and config');
+}
+
+async function promptMcpConfig(config, file, prompts) {
+  const client = await prompts.select({
+    message: 'MCP client config',
+    options: [
+      { value: 'codex', label: 'Codex', hint: 'TOML config snippet' },
+      { value: 'claude', label: 'Claude', hint: 'JSON config snippet' },
+      { value: 'manual', label: 'Manual', hint: 'stdio command' },
+      { value: 'back', label: 'Back' },
+    ],
+  });
+  if (prompts.isCancel(client) || client === 'back') return;
+  prompts.note(mcpConfigText(client, file), `${client} MCP config`);
+}
+
+function sessionsFromResponse(data) {
+  if (Array.isArray(data)) return data;
+  if (Array.isArray(data?.sessions)) return data.sessions;
+  if (Array.isArray(data?.items)) return data.items;
+  return [];
+}
+
+function sessionIdFrom(session) {
+  return trimmed(session?.session_id || session?.id || session?.token_id);
+}
+
+async function promptManageSessions(config, prompts) {
+  const data = await api(config, 'GET', '/v1/agent-sessions', undefined, config.userToken);
+  const sessions = sessionsFromResponse(data).filter((session) => sessionIdFrom(session));
+  if (!sessions.length) {
+    prompts.note('No active sessions returned by the server.', 'Sessions');
+    return;
+  }
+  const selected = await prompts.select({
+    message: 'Choose session to revoke',
+    options: [
+      ...sessions.map((session) => {
+        const id = sessionIdFrom(session);
+        const label = `${shorten(session.agent_label || session.label || id, 36)} (${id})`;
+        const hint = [session.created_at, session.expires_at ? `expires ${session.expires_at}` : null].filter(Boolean).join(' - ');
+        return { value: id, label, hint };
+      }),
+      { value: '__manual', label: 'Type session ID manually' },
+      { value: '__back', label: 'Back' },
+    ],
+  });
+  if (prompts.isCancel(selected) || selected === '__back') return;
+  const sessionId = selected === '__manual'
+    ? await prompts.text({ message: 'Session ID', validate: promptRequired })
+    : selected;
+  if (prompts.isCancel(sessionId)) throw new Error('cancelled');
+  const confirm = await prompts.confirm({ message: `Revoke session ${sessionId}?`, initialValue: false });
+  if (prompts.isCancel(confirm) || !confirm) return;
+  await api(config, 'DELETE', `/v1/agent-sessions/${encodeURIComponent(String(sessionId))}`, undefined, config.userToken);
+  prompts.note(`Revoked ${sessionId}`, 'Session revoked');
+}
+
+async function promptSetServerUrl(config, file, prompts) {
+  const server = await prompts.text({
+    message: 'SuperCollab server URL',
+    defaultValue: config.serverUrl || DEFAULT_SERVER,
+    placeholder: DEFAULT_SERVER,
+    validate: (value) => {
+      try {
+        const parsed = new URL(String(value || ''));
+        return parsed.protocol === 'https:' || parsed.hostname === 'localhost' ? undefined : 'Use https:// for remote servers';
+      } catch {
+        return 'Enter a valid URL';
+      }
+    },
+  });
+  if (prompts.isCancel(server)) throw new Error('cancelled');
+  config.serverUrl = trimmed(server).replace(/\/$/, '');
+  saveConfig(config, file);
+  prompts.note(config.serverUrl, 'Server URL saved');
+}
+
+async function runRoomsMenu(config, file, prompts) {
+  while (true) {
+    const action = await prompts.select({
+      message: 'Rooms',
+      options: [
+        { value: 'browse', label: 'Browse/select room', hint: 'scroll rooms or type room ID' },
+        { value: 'create', label: 'Create room', hint: 'sets up backend room and local key' },
+        { value: 'join', label: 'Join with private invite', hint: 'saves room key locally' },
+        { value: 'invite', label: 'Create private invite' },
+        { value: 'back', label: 'Back' },
+      ],
+    });
+    if (prompts.isCancel(action) || action === 'back') return;
+    try {
+      if (action === 'browse') await promptBrowseRooms(config, file, prompts);
+      if (action === 'create') {
+        const created = await promptCreateRoom(config, file, prompts);
+        if (created?.room_id) await promptRoomActions(config, file, prompts, created.room_id);
+      }
+      if (action === 'join') {
+        const joined = await promptJoinRoom(config, file, prompts);
+        if (joined?.room_id) await promptRoomActions(config, file, prompts, joined.room_id);
+      }
+      if (action === 'invite') await promptCreateInvite(config, file, prompts);
+    } catch (err) {
+      if (err.message !== 'cancelled') prompts.note(err.message || String(err), 'Room action failed');
+    }
+  }
+}
+
+async function runChatMenu(config, file, prompts) {
+  while (true) {
+    const action = await prompts.select({
+      message: 'Chat',
+      options: [
+        { value: 'send', label: 'Send message/note' },
+        { value: 'read', label: 'Read recent messages' },
+        { value: 'search', label: 'Search transcript' },
+        { value: 'sync', label: 'Sync room locally' },
+        { value: 'back', label: 'Back' },
+      ],
+    });
+    if (prompts.isCancel(action) || action === 'back') return;
+    try {
+      if (action === 'send') await promptSendMessage(config, file, prompts);
+      if (action === 'read') await promptReadMessages(config, file, prompts);
+      if (action === 'search') await promptSearchMessages(config, file, prompts);
+      if (action === 'sync') await promptSyncRoom(config, file, prompts);
+    } catch (err) {
+      if (err.message !== 'cancelled') prompts.note(err.message || String(err), 'Chat action failed');
+    }
+  }
+}
+
+async function runWorkspaceMenu(config, file, prompts) {
+  while (true) {
+    const active = await activeStatus(config, file, {});
+    const action = await prompts.select({
+      message: `Workspace activation (${active.active ? `active: ${active.room_id}` : 'off'})`,
+      options: [
+        { value: 'status', label: 'Show current status' },
+        { value: 'activate', label: 'Activate this directory' },
+        { value: 'activate_other', label: 'Activate another directory' },
+        { value: 'deactivate', label: 'Deactivate directory' },
+        { value: 'back', label: 'Back' },
+      ],
+    });
+    if (prompts.isCancel(action) || action === 'back') return;
+    try {
+      if (action === 'status') prompts.note(active.instructions, 'Current workspace');
+      if (action === 'activate') await promptActivateRoom(config, file, prompts, { cwd: process.cwd() });
+      if (action === 'activate_other') await promptActivateRoom(config, file, prompts);
+      if (action === 'deactivate') await promptDeactivateRoom(config, file, prompts, { cwd: process.cwd() });
+    } catch (err) {
+      if (err.message !== 'cancelled') prompts.note(err.message || String(err), 'Workspace action failed');
+    }
+  }
+}
+
+async function runSettingsMenu(config, file, prompts) {
+  while (true) {
+    const action = await prompts.select({
+      message: 'Settings',
+      options: [
+        { value: 'doctor', label: 'System check / install BGE model' },
+        { value: 'account', label: 'Account and config status' },
+        { value: 'mcp', label: 'Show MCP config' },
+        { value: 'sessions', label: 'Manage sessions' },
+        { value: 'server', label: 'Set server URL' },
+        { value: 'back', label: 'Back' },
+      ],
+    });
+    if (prompts.isCancel(action) || action === 'back') return;
+    try {
+      if (action === 'doctor') await promptSystemCheck(config, file, prompts);
+      if (action === 'account') await promptAccountStatus(config, file, prompts);
+      if (action === 'mcp') await promptMcpConfig(config, file, prompts);
+      if (action === 'sessions') await promptManageSessions(config, prompts);
+      if (action === 'server') await promptSetServerUrl(config, file, prompts);
+    } catch (err) {
+      if (err.message !== 'cancelled') prompts.note(err.message || String(err), 'Settings action failed');
+    }
+  }
+}
+
+async function runMainMenu(config, file, opts = {}) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error('interactive menu requires a TTY');
+  }
+  if (!isConfigured(config)) {
+    return runSetupWizard(config, file, opts);
+  }
+  const prompts = await loadPrompts();
+  prompts.intro(`SuperCollab ${VERSION}`);
+  try {
+    while (true) {
+      const active = await activeStatus(config, file, {});
+      const action = await prompts.select({
+        message: `Main menu (${config.username || 'user'} - ${active.active ? `active ${active.room_id}` : 'workspace off'})`,
+        options: [
+          { value: 'rooms', label: 'Rooms', hint: 'create, join, browse, invite' },
+          { value: 'chat', label: 'Chat', hint: 'send, read, search, sync' },
+          { value: 'workspace', label: 'Workspace activation', hint: 'turn SuperCollab on/off for directories' },
+          { value: 'settings', label: 'Settings', hint: 'doctor, MCP config, sessions, server URL' },
+          { value: 'setup', label: 'Run onboarding again' },
+          { value: 'exit', label: 'Exit' },
+        ],
+      });
+      if (prompts.isCancel(action) || action === 'exit') {
+        prompts.outro('Done.');
+        return { ok: true };
+      }
+      if (action === 'rooms') await runRoomsMenu(config, file, prompts);
+      if (action === 'chat') await runChatMenu(config, file, prompts);
+      if (action === 'workspace') await runWorkspaceMenu(config, file, prompts);
+      if (action === 'settings') await runSettingsMenu(config, file, prompts);
+      if (action === 'setup') return runSetupWizard(config, file, opts);
+    }
+  } catch (err) {
+    prompts.cancel(err.message === 'cancelled' ? 'Menu closed.' : `Menu stopped: ${err.message}`);
+    throw err;
+  }
+}
+
 async function runSetupWizard(config, file, opts = {}) {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
     throw new Error('interactive setup requires a TTY; run `supercollab doctor --json` for non-interactive diagnostics');
@@ -1518,10 +2381,15 @@ async function main() {
   config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
 
   if (positionals.length === 0) {
-    if (process.stdin.isTTY && process.stdout.isTTY) return runSetupWizard(config, file, opts);
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+      return isConfigured(config)
+        ? runMainMenu(config, file, opts)
+        : runSetupWizard(config, file, opts);
+    }
     printHelp();
     return;
   }
+  if (cmd === 'menu') return runMainMenu(config, file, opts);
   if (cmd === 'setup') return runSetupWizard(config, file, opts);
   if (cmd === 'doctor') {
     const data = await runDoctor(config, file, opts);
@@ -1564,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.3",
+  "version": "0.4.5",
   "description": "SuperCollab CLI and MCP bridge for encrypted local-search agent group chat.",
   "type": "module",
   "bin": {