@supercollab/cli 0.1.2 → 0.1.3

package/bin/supercollab.js

@@ -7,7 +7,7 @@ import * as readlineCore from 'node:readline';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
 
-const VERSION = '0.1.2';
+const VERSION = '0.1.3';
 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;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@supercollab/cli",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "SuperCollab CLI and MCP bridge for secure agent collaboration workspaces.",
   "type": "module",
   "bin": {
     "supercollab": "./bin/supercollab.js"
   },
   "files": [
-    "bin",
+    "bin/supercollab.js",
     "README.md"
   ],
   "engines": {

package/bin/supercollab.js.bak-20260624T032438Z

@@ -1,405 +0,0 @@
-#!/usr/bin/env node
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-
-const VERSION = '0.1.1';
-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;
-
-function printHelp() {
-  console.log(`SuperCollab CLI ${VERSION}
-
-Usage:
-  supercollab register --username NAME [--password PASS] [--server URL] [--label LABEL]
-  supercollab login --username NAME [--password PASS] [--server URL]
-  supercollab whoami
-  supercollab agent register [--label LABEL]
-  supercollab workspace list
-  supercollab workspace create --title TITLE --goal GOAL [--slug SLUG]
-  supercollab workspace invite --workspace ID [--role member]
-  supercollab workspace join --invite TOKEN
-  supercollab workspace message --workspace ID --text TEXT
-  supercollab workspace messages --workspace ID [--limit 20]
-  supercollab workspace search --workspace ID --query TEXT
-  supercollab workspace write --workspace ID --path PATH --content TEXT
-  supercollab workspace read --workspace ID --path PATH
-  supercollab workspace git --workspace ID
-  supercollab heartbeat set --workspace ID --prompt TEXT [--interval 900]
-  supercollab heartbeat tick --workspace ID
-  supercollab mcp stdio
-  supercollab mcp print-config --client codex
-  supercollab config path
-
-Options:
-  --config PATH       Config path, default ~/.supercollab/config.json
-  --server URL        SuperCollab API URL, default ${DEFAULT_SERVER}
-
-Environment:
-  SUPERCOLLAB_PASSWORD can provide password non-interactively.
-  SUPERCOLLAB_CONFIG can override config path.
-`);
-}
-
-function parse(argv) {
-  const positionals = [];
-  const opts = {};
-  for (let i = 0; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg.startsWith('--')) {
-      const key = arg.slice(2);
-      const next = argv[i + 1];
-      if (!next || next.startsWith('--')) {
-        opts[key] = true;
-      } else {
-        opts[key] = next;
-        i++;
-      }
-    } else {
-      positionals.push(arg);
-    }
-  }
-  return { positionals, opts };
-}
-
-function configPath(opts = {}) {
-  return opts.config || DEFAULT_CONFIG;
-}
-
-function ensureConfigDir(file) {
-  const dir = path.dirname(file);
-  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
-  try { fs.chmodSync(dir, 0o700); } catch {}
-}
-
-function loadConfig(file = DEFAULT_CONFIG) {
-  if (!fs.existsSync(file)) return { serverUrl: DEFAULT_SERVER };
-  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
-  return { serverUrl: DEFAULT_SERVER, ...data };
-}
-
-function saveConfig(config, file = DEFAULT_CONFIG) {
-  ensureConfigDir(file);
-  const tmp = `${file}.${process.pid}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
-  fs.renameSync(tmp, file);
-  try { fs.chmodSync(file, 0o600); } catch {}
-}
-
-function requireValue(opts, key) {
-  if (!opts[key] || opts[key] === true) throw new Error(`missing --${key}`);
-  return String(opts[key]);
-}
-
-async function readPassword(prompt = 'Password: ') {
-  if (process.env.SUPERCOLLAB_PASSWORD) return process.env.SUPERCOLLAB_PASSWORD;
-  if (!process.stdin.isTTY || typeof process.stdin.setRawMode !== 'function') {
-    throw new Error('password required; pass --password or set SUPERCOLLAB_PASSWORD');
-  }
-  return await new Promise((resolve, reject) => {
-    let password = '';
-    const stdin = process.stdin;
-    const wasRaw = stdin.isRaw;
-    const cleanup = () => {
-      stdin.off('data', onData);
-      try { stdin.setRawMode(Boolean(wasRaw)); } catch {}
-      stdin.pause();
-    };
-    const onData = (chunk) => {
-      for (const char of chunk.toString('utf8')) {
-        if (char === '\u0003') {
-          cleanup();
-          output.write('\n');
-          reject(new Error('cancelled'));
-          return;
-        }
-        if (char === '\r' || char === '\n' || char === '\u0004') {
-          cleanup();
-          output.write('\n');
-          resolve(password);
-          return;
-        }
-        if (char === '\u007f' || char === '\b') {
-          if (password.length > 0) {
-            password = password.slice(0, -1);
-            output.write('\b \b');
-          }
-          continue;
-        }
-        password += char;
-        output.write('*');
-      }
-    };
-    output.write(prompt);
-    stdin.setEncoding('utf8');
-    stdin.setRawMode(true);
-    stdin.resume();
-    stdin.on('data', onData);
-  });
-}
-
-async function api(config, method, endpoint, body, token) {
-  const server = (config.serverUrl || DEFAULT_SERVER).replace(/\/$/, '');
-  const headers = { 'content-type': 'application/json', 'user-agent': `supercollab-cli/${VERSION}` };
-  const auth = token || config.userToken || config.agentSessionToken;
-  if (auth) headers.authorization = `Bearer ${auth}`;
-  const res = await fetch(server + endpoint, {
-    method,
-    headers,
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
-  const text = await res.text();
-  let data = {};
-  if (text) {
-    try { data = JSON.parse(text); } catch { data = { text }; }
-  }
-  if (!res.ok) {
-    const detail = data.detail ? JSON.stringify(data.detail) : text;
-    throw new Error(`HTTP ${res.status} ${endpoint}: ${detail}`);
-  }
-  return data;
-}
-
-function generateAgentKeypair() {
-  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
-  const publicKeyPem = publicKey.export({ type: 'spki', format: 'pem' }).toString();
-  const privateKeyPem = privateKey.export({ type: 'pkcs8', format: 'pem' }).toString();
-  const raw = publicKey.export({ type: 'spki', format: 'der' });
-  const digest = crypto.createHash('sha256').update(raw).digest().subarray(0, 10);
-  const fingerprint = 'ed25519:' + digest.toString('base64url').toLowerCase();
-  return { publicKeyPem, privateKeyPem, fingerprint };
-}
-
-function signRequest(privateKeyPem, method, endpoint, bodyString, timestamp, nonce) {
-  const bodyHash = crypto.createHash('sha256').update(bodyString).digest('hex');
-  const signing = Buffer.from(`${method.toUpperCase()}\n${endpoint}\n${bodyHash}\n${timestamp}\n${nonce}`);
-  const sig = crypto.sign(null, signing, crypto.createPrivateKey(privateKeyPem)).toString('base64url');
-  return sig + '='.repeat((4 - (sig.length % 4)) % 4);
-}
-
-async function ensureAgentSession(config) {
-  const now = Math.floor(Date.now() / 1000);
-  if (config.agentSessionToken && config.agentSessionExpiresAt && config.agentSessionExpiresAt - SESSION_TTL_SKEW > now) {
-    return config.agentSessionToken;
-  }
-  if (!config.agentId || !config.agentPrivateKeyPem) throw new Error('no local agent registered; run supercollab agent register');
-  const endpoint = '/v1/agent-sessions';
-  const bodyString = JSON.stringify({ agent_id: config.agentId });
-  const timestamp = String(now);
-  const nonce = crypto.randomBytes(18).toString('base64url');
-  const signature = signRequest(config.agentPrivateKeyPem, 'POST', endpoint, bodyString, timestamp, nonce);
-  const server = (config.serverUrl || DEFAULT_SERVER).replace(/\/$/, '');
-  const res = await fetch(server + endpoint, {
-    method: 'POST',
-    headers: {
-      'content-type': 'application/json',
-      'user-agent': `supercollab-cli/${VERSION}`,
-      'x-supercollab-timestamp': timestamp,
-      'x-supercollab-nonce': nonce,
-      'x-supercollab-signature': signature,
-    },
-    body: bodyString,
-  });
-  const data = await res.json();
-  if (!res.ok) throw new Error(`agent session failed: ${JSON.stringify(data)}`);
-  config.agentSessionToken = data.token;
-  config.agentSessionExpiresAt = data.expires_at;
-  return data.token;
-}
-
-async function apiAsAgent(config, method, endpoint, body) {
-  const token = await ensureAgentSession(config);
-  return api(config, method, endpoint, body, token);
-}
-
-async function registerAgent(config, label) {
-  if (!config.userToken) throw new Error('login/register first');
-  const keys = generateAgentKeypair();
-  const data = await api(config, 'POST', '/v1/agents/register', { label, public_key_pem: keys.publicKeyPem }, config.userToken);
-  config.agentId = data.agent_id;
-  config.agentLabel = label;
-  config.agentFingerprint = data.fingerprint;
-  config.agentPrivateKeyPem = keys.privateKeyPem;
-  delete config.agentSessionToken;
-  delete config.agentSessionExpiresAt;
-  return data;
-}
-
-async function doRegister(opts) {
-  const file = configPath(opts);
-  const config = loadConfig(file);
-  config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
-  const username = requireValue(opts, 'username');
-  const password = opts.password ? String(opts.password) : await readPassword();
-  const data = await api(config, 'POST', '/v1/auth/register', { username, password }, null);
-  config.userId = data.user_id;
-  config.username = data.username;
-  config.userToken = data.token;
-  const agent = await registerAgent(config, String(opts.label || `${os.hostname()}-agent`));
-  saveConfig(config, file);
-  console.log(JSON.stringify({ ok: true, username: config.username, user_id: config.userId, agent_id: agent.agent_id, fingerprint: agent.fingerprint, config: file }, null, 2));
-}
-
-async function doLogin(opts) {
-  const file = configPath(opts);
-  const config = loadConfig(file);
-  config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
-  const username = requireValue(opts, 'username');
-  const password = opts.password ? String(opts.password) : await readPassword();
-  const data = await api(config, 'POST', '/v1/auth/login', { username, password }, null);
-  config.userId = data.user_id;
-  config.username = data.username;
-  config.userToken = data.token;
-  delete config.agentSessionToken;
-  delete config.agentSessionExpiresAt;
-  saveConfig(config, file);
-  console.log(JSON.stringify({ ok: true, username: config.username, user_id: config.userId, config: file }, null, 2));
-}
-
-function toolSchema(name, description, properties = {}, required = []) {
-  return { name, description, inputSchema: { type: 'object', properties, required } };
-}
-
-function mcpTools() {
-  const s = { type: 'string' };
-  return [
-    toolSchema('supercollab_status', 'Check SuperCollab server and authenticated actor status.'),
-    toolSchema('workspace_list', 'List workspaces visible to this agent.'),
-    toolSchema('workspace_create', 'Create a goal-scoped workspace.', { title: s, goal: s, slug: s }, ['title', 'goal']),
-    toolSchema('workspace_invite', 'Create a short-lived invite token.', { workspace_id: s, role: s, ttl_seconds: { type: 'integer' } }, ['workspace_id']),
-    toolSchema('workspace_join', 'Accept an invite token.', { invite_token: s, fingerprint: s }, ['invite_token']),
-    toolSchema('workspace_message_send', 'Send a workspace message.', { workspace_id: s, text: s }, ['workspace_id', 'text']),
-    toolSchema('workspace_messages_read', 'Read workspace events/messages.', { workspace_id: s, limit: { type: 'integer' } }, ['workspace_id']),
-    toolSchema('workspace_file_list', 'List workspace files.', { workspace_id: s, path: s }, ['workspace_id']),
-    toolSchema('workspace_file_read', 'Read a workspace file.', { workspace_id: s, path: s }, ['workspace_id', 'path']),
-    toolSchema('workspace_file_write', 'Write a workspace file and commit it.', { workspace_id: s, path: s, content: s, commit_message: s }, ['workspace_id', 'path', 'content']),
-    toolSchema('workspace_git_status', 'Show workspace Git status and recent commits.', { workspace_id: s }, ['workspace_id']),
-    toolSchema('workspace_task_create', 'Create a task.', { workspace_id: s, title: s, body: s, owner: s }, ['workspace_id', 'title']),
-    toolSchema('workspace_decision_record', 'Record a decision.', { workspace_id: s, title: s, decision: s, rationale: s }, ['workspace_id', 'title', 'decision']),
-    toolSchema('workspace_memory_reindex', 'Rebuild workspace search index.', { workspace_id: s }, ['workspace_id']),
-    toolSchema('workspace_memory_search', 'Search workspace memory.', { workspace_id: s, query: s, limit: { type: 'integer' } }, ['workspace_id', 'query']),
-    toolSchema('workspace_heartbeat_get', 'Read heartbeat config.', { workspace_id: s }, ['workspace_id']),
-    toolSchema('workspace_heartbeat_set', 'Set heartbeat config.', { workspace_id: s, prompt: s, interval_seconds: { type: 'integer' }, enabled: { type: 'boolean' } }, ['workspace_id', 'prompt']),
-    toolSchema('workspace_heartbeat_tick', 'Emit heartbeat now.', { workspace_id: s }, ['workspace_id']),
-  ];
-}
-
-async function callTool(config, name, args) {
-  if (name === 'supercollab_status') return { health: await api(config, 'GET', '/health'), me: await apiAsAgent(config, 'GET', '/v1/me') };
-  if (name === 'workspace_list') return apiAsAgent(config, 'GET', '/v1/workspaces');
-  if (name === 'workspace_create') return apiAsAgent(config, 'POST', '/v1/workspaces', { title: args.title, goal: args.goal, slug: args.slug });
-  if (name === 'workspace_invite') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/invites`, { role: args.role || 'member', ttl_seconds: args.ttl_seconds || 86400 });
-  if (name === 'workspace_join') return apiAsAgent(config, 'POST', '/v1/invites/accept', { token: args.invite_token, fingerprint: args.fingerprint || config.agentFingerprint });
-  if (name === 'workspace_message_send') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/messages`, { text: args.text });
-  if (name === 'workspace_messages_read') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/messages?limit=${encodeURIComponent(args.limit || 50)}`);
-  if (name === 'workspace_file_list') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/files?path=${encodeURIComponent(args.path || '')}`);
-  if (name === 'workspace_file_read') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/files/read?path=${encodeURIComponent(args.path)}`);
-  if (name === 'workspace_file_write') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/files/write`, { path: args.path, content: args.content, commit_message: args.commit_message });
-  if (name === 'workspace_git_status') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/git/status`);
-  if (name === 'workspace_task_create') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/tasks`, { title: args.title, body: args.body || '', owner: args.owner || 'unassigned' });
-  if (name === 'workspace_decision_record') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/decisions`, { title: args.title, decision: args.decision, rationale: args.rationale || '' });
-  if (name === 'workspace_memory_reindex') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/memory/reindex`, {});
-  if (name === 'workspace_memory_search') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/memory/search?q=${encodeURIComponent(args.query)}&limit=${encodeURIComponent(args.limit || 8)}`);
-  if (name === 'workspace_heartbeat_get') return apiAsAgent(config, 'GET', `/v1/workspaces/${args.workspace_id}/heartbeat`);
-  if (name === 'workspace_heartbeat_set') return apiAsAgent(config, 'PUT', `/v1/workspaces/${args.workspace_id}/heartbeat`, { prompt: args.prompt, interval_seconds: args.interval_seconds || 900, enabled: args.enabled !== false });
-  if (name === 'workspace_heartbeat_tick') return apiAsAgent(config, 'POST', `/v1/workspaces/${args.workspace_id}/heartbeat/tick`, {});
-  throw new Error(`unknown tool: ${name}`);
-}
-
-function writeRpc(payload) {
-  const raw = Buffer.from(JSON.stringify(payload));
-  process.stdout.write(`Content-Length: ${raw.length}\r\n\r\n`);
-  process.stdout.write(raw);
-}
-
-async function runMcp(opts) {
-  const config = loadConfig(configPath(opts));
-  let buffer = Buffer.alloc(0);
-  for await (const chunk of process.stdin) {
-    buffer = Buffer.concat([buffer, chunk]);
-    while (true) {
-      const headerEnd = buffer.indexOf('\r\n\r\n');
-      if (headerEnd < 0) break;
-      const header = buffer.subarray(0, headerEnd).toString();
-      const match = header.match(/content-length:\s*(\d+)/i);
-      if (!match) throw new Error('missing content-length');
-      const length = Number(match[1]);
-      const total = headerEnd + 4 + length;
-      if (buffer.length < total) break;
-      const body = buffer.subarray(headerEnd + 4, total).toString();
-      buffer = buffer.subarray(total);
-      const msg = JSON.parse(body);
-      const id = msg.id;
-      try {
-        let result;
-        if (msg.method === 'initialize') {
-          result = { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'supercollab', version: VERSION } };
-        } else if (msg.method === 'tools/list') {
-          result = { tools: mcpTools() };
-        } else if (msg.method === 'tools/call') {
-          const data = await callTool(config, msg.params.name, msg.params.arguments || {});
-          result = { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
-        } else if (msg.method && msg.method.startsWith('notifications/')) {
-          continue;
-        } else {
-          throw new Error(`unsupported method: ${msg.method}`);
-        }
-        if (id !== undefined) writeRpc({ jsonrpc: '2.0', id, result });
-      } catch (err) {
-        if (id !== undefined) writeRpc({ jsonrpc: '2.0', id, error: { code: -32000, message: err.message } });
-      }
-    }
-  }
-}
-
-function printCodexConfig(opts) {
-  const file = configPath(opts);
-  console.log(`[mcp_servers.supercollab]\ncommand = "supercollab"\nargs = ["mcp", "stdio", "--config", "${file.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"]`);
-}
-
-async function main() {
-  const { positionals, opts } = parse(process.argv.slice(2));
-  if (opts.help || positionals.length === 0) { printHelp(); return; }
-  const [cmd, sub] = positionals;
-  const file = configPath(opts);
-  const config = loadConfig(file);
-  config.serverUrl = opts.server || config.serverUrl || DEFAULT_SERVER;
-
-  if (cmd === 'register') return doRegister(opts);
-  if (cmd === 'login') return doLogin(opts);
-  if (cmd === 'whoami') return console.log(JSON.stringify(await api(config, 'GET', '/v1/me'), null, 2));
-  if (cmd === 'config' && sub === 'path') return console.log(file);
-  if (cmd === 'agent' && sub === 'register') {
-    const data = await registerAgent(config, String(opts.label || `${os.hostname()}-agent`));
-    saveConfig(config, file);
-    return console.log(JSON.stringify({ ok: true, agent_id: data.agent_id, fingerprint: data.fingerprint, config: file }, null, 2));
-  }
-  if (cmd === 'mcp' && sub === 'stdio') return runMcp(opts);
-  if (cmd === 'mcp' && sub === 'print-config') return printCodexConfig(opts);
-  if (cmd === 'workspace') {
-    if (sub === 'list') return console.log(JSON.stringify(await callTool(config, 'workspace_list', {}), null, 2));
-    if (sub === 'create') return console.log(JSON.stringify(await callTool(config, 'workspace_create', { title: requireValue(opts, 'title'), goal: requireValue(opts, 'goal'), slug: opts.slug }), null, 2));
-    if (sub === 'invite') return console.log(JSON.stringify(await callTool(config, 'workspace_invite', { workspace_id: requireValue(opts, 'workspace'), role: opts.role || 'member', ttl_seconds: opts.ttl || 86400 }), null, 2));
-    if (sub === 'join') return console.log(JSON.stringify(await callTool(config, 'workspace_join', { invite_token: requireValue(opts, 'invite') }), null, 2));
-    if (sub === 'message') return console.log(JSON.stringify(await callTool(config, 'workspace_message_send', { workspace_id: requireValue(opts, 'workspace'), text: requireValue(opts, 'text') }), null, 2));
-    if (sub === 'messages') return console.log(JSON.stringify(await callTool(config, 'workspace_messages_read', { workspace_id: requireValue(opts, 'workspace'), limit: opts.limit || 20 }), null, 2));
-    if (sub === 'search') return console.log(JSON.stringify(await callTool(config, 'workspace_memory_search', { workspace_id: requireValue(opts, 'workspace'), query: requireValue(opts, 'query'), limit: opts.limit || 8 }), null, 2));
-    if (sub === 'write') return console.log(JSON.stringify(await callTool(config, 'workspace_file_write', { workspace_id: requireValue(opts, 'workspace'), path: requireValue(opts, 'path'), content: requireValue(opts, 'content'), commit_message: opts.message }), null, 2));
-    if (sub === 'read') return console.log(JSON.stringify(await callTool(config, 'workspace_file_read', { workspace_id: requireValue(opts, 'workspace'), path: requireValue(opts, 'path') }), null, 2));
-    if (sub === 'git') return console.log(JSON.stringify(await callTool(config, 'workspace_git_status', { workspace_id: requireValue(opts, 'workspace') }), null, 2));
-  }
-  if (cmd === 'heartbeat') {
-    if (sub === 'set') return console.log(JSON.stringify(await callTool(config, 'workspace_heartbeat_set', { workspace_id: requireValue(opts, 'workspace'), prompt: requireValue(opts, 'prompt'), interval_seconds: opts.interval || 900, enabled: opts.enabled !== 'false' }), null, 2));
-    if (sub === 'tick') return console.log(JSON.stringify(await callTool(config, 'workspace_heartbeat_tick', { workspace_id: requireValue(opts, 'workspace') }), null, 2));
-  }
-  throw new Error(`unknown command: ${positionals.join(' ')}`);
-}
-
-main().catch((err) => {
-  console.error(`supercollab: ${err.message}`);
-  process.exit(1);
-});