@cordfuse/crosstalk 7.0.0-alpha.16 → 7.0.0-alpha.18

package/commands/agent.js

@@ -0,0 +1,69 @@
+// crosstalk agent <list> — installed CLI agents on the host.
+//
+// Mirrors llmux's `agent list`. Talks to /agents/installed on the
+// engine, which is responsible for actually probing PATH; the CLI just
+// presents the result.
+
+import { apiFor } from '../lib/api-client.js';
+import { reportAndExit } from '../lib/errors.js';
+import { has } from '../lib/argv.js';
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk agent list [--installed] [--json]
+  crosstalk agent --help
+
+  --installed  Only show CLIs found on PATH (default: show all known
+               agents, marking which are installed/claimed/yaml-known).
+  --json       Print raw JSON instead of human-readable lines.
+`,
+  );
+  process.exit(exit);
+}
+
+export async function run(argv) {
+  if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const sub = argv[0];
+  if (!sub) usage(1);
+
+  if (sub !== 'list') {
+    process.stderr.write(`crosstalk agent: unknown subcommand '${sub}'.\n`);
+    usage(1);
+  }
+
+  const api = apiFor(argv);
+  let r;
+  try {
+    r = await api.get('/agents/installed');
+  } catch (err) {
+    reportAndExit(err, 'crosstalk agent list');
+  }
+
+  if (has(argv, '--json')) {
+    process.stdout.write(JSON.stringify(r, null, 2) + '\n');
+    return 0;
+  }
+
+  const installed = new Set(r.installed || []);
+  const yamlRef = new Set(r.yaml_referenced || []);
+  const claimed = new Set(r.claimed || []);
+  const onlyInstalled = has(argv, '--installed');
+  const universe = onlyInstalled ? [...installed] : (r.known || []);
+
+  if (universe.length === 0) {
+    process.stdout.write('(no agents)\n');
+    return 0;
+  }
+
+  for (const name of universe) {
+    const flags = [
+      installed.has(name) ? 'installed' : '-',
+      yamlRef.has(name)   ? 'yaml'      : '-',
+      claimed.has(name)   ? 'claimed'   : '-',
+    ].join(' ');
+    process.stdout.write(`  ${name.padEnd(12)}  ${flags}\n`);
+  }
+  return 0;
+}

package/commands/auth.js

@@ -0,0 +1,273 @@
+// crosstalk auth <login|logout|whoami|list|use> — CLI-side authentication.
+//
+// Multi-profile (v8 alpha.18): a single CLI can hold credentials for
+// multiple engines (local loopback, hosted prod, etc.) in
+// ~/.config/crosstalk/credentials.json. The active profile drives
+// outbound calls; `--profile <name>` overrides per-invocation.
+//
+// Verbs:
+//   login   — POST /api/auth/login → bearer token; saves new profile
+//   logout  — POST /api/auth/logout (best-effort) + delete profile locally
+//   whoami  — GET /api/account on the active profile
+//   list    — show all saved profiles + which is active
+//   use     — mark a saved profile as active
+
+import { apiFor, ApiError } from '../lib/api-client.js';
+import {
+  saveProfile,
+  setActiveProfile,
+  deleteActiveProfile,
+  getActiveProfile,
+  listProfiles,
+  credentialsFilePath,
+} from '../lib/credentials.js';
+import { positionals, has, flag } from '../lib/argv.js';
+import { reportAndExit } from '../lib/errors.js';
+
+function usage(exit = 0) {
+  const w = exit === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage:
+  crosstalk auth login [--server <url>] [--username <name>] [--passphrase <pp>] [--profile <name>]
+  crosstalk auth logout [--profile <name>] [--no-revoke]
+  crosstalk auth whoami [--profile <name>]
+  crosstalk auth list
+  crosstalk auth use <profile>
+  crosstalk auth --help
+
+Interactive: --username and --passphrase are prompted when omitted.
+Credentials stored at: ${credentialsFilePath()}
+`,
+  );
+  process.exit(exit);
+}
+
+// Control bytes the raw-mode passphrase reader handles.
+const CTRL_C = String.fromCharCode(3);
+const BS = String.fromCharCode(127);
+const BS_ALT = String.fromCharCode(8);
+
+/** Read a single line from stdin with no echo (for passphrase entry). */
+function promptHidden(label) {
+  return new Promise((resolve, reject) => {
+    if (!process.stdin.isTTY) {
+      let data = '';
+      process.stdin.setEncoding('utf-8');
+      process.stdin.on('data', (chunk) => { data += chunk; });
+      process.stdin.once('end', () => resolve(data.replace(/\r?\n$/, '')));
+      process.stdin.once('error', reject);
+      return;
+    }
+    process.stdout.write(label);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf-8');
+    let buf = '';
+    const onData = (ch) => {
+      if (ch === CTRL_C) {
+        stdin.setRawMode(wasRaw);
+        stdin.pause();
+        stdin.removeListener('data', onData);
+        process.stdout.write('\n');
+        reject(new Error('aborted'));
+        return;
+      }
+      if (ch === '\r' || ch === '\n') {
+        stdin.setRawMode(wasRaw);
+        stdin.pause();
+        stdin.removeListener('data', onData);
+        process.stdout.write('\n');
+        resolve(buf);
+        return;
+      }
+      if (ch === BS || ch === BS_ALT) {
+        if (buf.length > 0) buf = buf.slice(0, -1);
+        return;
+      }
+      buf += ch;
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function promptLine(label) {
+  return new Promise((resolve, reject) => {
+    process.stdout.write(label);
+    const stdin = process.stdin;
+    stdin.setEncoding('utf-8');
+    stdin.resume();
+    let buf = '';
+    const onData = (chunk) => {
+      buf += chunk;
+      const nl = buf.indexOf('\n');
+      if (nl !== -1) {
+        stdin.removeListener('data', onData);
+        stdin.pause();
+        resolve(buf.slice(0, nl).replace(/\r$/, ''));
+      }
+    };
+    stdin.on('data', onData);
+    stdin.once('error', reject);
+  });
+}
+
+export async function run(argv) {
+  if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const pos = positionals(argv, [
+    '--username', '--passphrase', '--server', '--profile',
+  ]);
+  const sub = pos[0];
+  if (!sub) usage(1);
+
+  if (sub === 'login') return await runLogin(argv);
+  if (sub === 'logout') return await runLogout(argv);
+  if (sub === 'whoami') return await runWhoami(argv);
+  if (sub === 'list') return runList();
+  if (sub === 'use') return runUse(pos[1]);
+
+  process.stderr.write(`crosstalk auth: unknown subcommand '${sub}'.\n`);
+  usage(1);
+}
+
+async function runLogin(argv) {
+  const server = flag(argv, '--server') || 'http://127.0.0.1:7000';
+  const profileName = flag(argv, '--profile') || 'default';
+  // serverOverride: the explicit --server (or default) wins over any
+  // existing active profile. Otherwise a re-login that targets a new
+  // engine would silently hit the old profile's URL.
+  const api = apiFor(argv, { serverOverride: server });
+  let username = flag(argv, '--username');
+  let passphrase = flag(argv, '--passphrase');
+  try {
+    if (!username) username = (await promptLine('username: ')).trim();
+    if (!passphrase) passphrase = await promptHidden('passphrase: ');
+  } catch (err) {
+    process.stderr.write(`crosstalk auth login: ${err.message}\n`);
+    return 1;
+  }
+  if (!username || !passphrase) {
+    process.stderr.write('crosstalk auth login: username + passphrase required.\n');
+    return 1;
+  }
+  let r;
+  try {
+    r = await api.postNoAuth('/api/auth/login', { username, passphrase });
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 503) {
+      process.stderr.write(
+        'crosstalk auth login: setup needed.\n' +
+        'The engine has no admin user yet. Visit /setup in a browser using\n' +
+        'the URL printed at engine boot, then run `crosstalk auth login` again.\n',
+      );
+      return 1;
+    }
+    reportAndExit(err, 'crosstalk auth login');
+  }
+  if (!r || typeof r.token !== 'string') {
+    process.stderr.write('crosstalk auth login: malformed response from engine.\n');
+    return 1;
+  }
+  // sas_<tokenId>.<secret> — pull the tokenId out for display + future
+  // revoke. Fallback: store null tokenId if the format ever changes.
+  const tokenId = parseTokenId(r.token);
+  saveProfile(profileName, {
+    server,
+    username,
+    token: r.token,
+    tokenId,
+  });
+  setActiveProfile(profileName);
+  process.stdout.write(
+    `logged in as ${username} (profile '${profileName}' → ${server})\n` +
+    `  credentials stored at ${credentialsFilePath()}\n`,
+  );
+  return 0;
+}
+
+function parseTokenId(token) {
+  // Wire format: sas_<id>.<secret>
+  const m = /^sas_([^.]+)\./.exec(token);
+  return m ? m[1] : null;
+}
+
+async function runLogout(argv) {
+  const profile = getActiveProfile(argv);
+  if (!profile) {
+    process.stdout.write('not logged in.\n');
+    return 0;
+  }
+  if (!has(argv, '--no-revoke')) {
+    const api = apiFor(argv);
+    try {
+      await api.post('/api/auth/logout');
+    } catch (_err) {
+      // Best-effort. Even if the server rejects (token already
+      // revoked elsewhere, network gone), still clean up locally.
+    }
+  }
+  const removed = deleteActiveProfile();
+  if (removed) {
+    process.stdout.write(`logged out (profile '${removed}' removed)\n`);
+  } else {
+    process.stdout.write('logged out\n');
+  }
+  return 0;
+}
+
+async function runWhoami(argv) {
+  if (!getActiveProfile(argv)) {
+    process.stderr.write("not logged in. Run 'crosstalk auth login'.\n");
+    return 1;
+  }
+  const api = apiFor(argv);
+  let r;
+  try {
+    r = await api.get('/api/account');
+  } catch (err) {
+    reportAndExit(err, 'crosstalk auth whoami');
+  }
+  process.stdout.write(
+    `username: ${r.username}\n` +
+    `name:     ${r.name}\n` +
+    `role:     ${r.admin ? 'admin' : 'member'}\n` +
+    `created:  ${r.createdAt}\n`,
+  );
+  return 0;
+}
+
+function runList() {
+  const profiles = listProfiles();
+  if (profiles.length === 0) {
+    process.stdout.write('no profiles. Run `crosstalk auth login` to create one.\n');
+    return 0;
+  }
+  // Compact tabular: active marker, name, username, server.
+  const nameW = Math.max(7, ...profiles.map((p) => p.name.length));
+  const userW = Math.max(8, ...profiles.map((p) => (p.username || '-').length));
+  const header = `  ${'PROFILE'.padEnd(nameW)}  ${'USERNAME'.padEnd(userW)}  SERVER`;
+  process.stdout.write(`${header}\n`);
+  for (const p of profiles) {
+    const marker = p.active ? '*' : ' ';
+    process.stdout.write(
+      `${marker} ${p.name.padEnd(nameW)}  ${(p.username || '-').padEnd(userW)}  ${p.server}\n`,
+    );
+  }
+  return 0;
+}
+
+function runUse(name) {
+  if (!name) {
+    process.stderr.write('crosstalk auth use: profile name required.\n');
+    return 1;
+  }
+  try {
+    setActiveProfile(name);
+  } catch (err) {
+    process.stderr.write(`crosstalk auth use: ${err.message}\n`);
+    return 1;
+  }
+  process.stdout.write(`active profile: ${name}\n`);
+  return 0;
+}

package/commands/channel.js

@@ -1,22 +1,24 @@
-// crosstalk channel <name> — create a channel via POST /channels.
+// crosstalk channel <list|create|rename|delete> — channel management.
 //
-// P4 only ships create. --rename and --delete need PATCH/DELETE
-// endpoints that haven't been added to the engine yet; they land
-// when the engine gains them.
+// alpha.18 noun-verb shape: every operation has an explicit verb.
+// The old flag-form (`channel <handle> --rename <new>`, `--delete`,
+// bare `channel <name>` create) is gone — clean break, no aliases.
 
 import { apiFor } from '../lib/api-client.js';
 import { reportAndExit } from '../lib/errors.js';
-import { positionals, has, flag } from '../lib/argv.js';
+import { positionals, has } from '../lib/argv.js';
 
 function usage(exit = 0) {
   const w = exit === 0 ? process.stdout : process.stderr;
   w.write(
 `Usage:
   crosstalk channel list                              # list channels
-  crosstalk channel <name>                            # create a channel
-  crosstalk channel <name-or-uuid> --rename <new>     # rename
-  crosstalk channel <name-or-uuid> --delete           # delete (with confirmation)
+  crosstalk channel create <name>                     # create a channel
+  crosstalk channel rename <handle> <new-name>        # rename
+  crosstalk channel delete <handle>                   # delete
   crosstalk channel --help
+
+<handle> is either the channel name or its UUID.
 `,
   );
   process.exit(exit);
@@ -24,13 +26,15 @@ function usage(exit = 0) {
 
 export async function run(argv) {
   if (has(argv, '--help') || has(argv, '-h')) usage(0);
+  const pos = positionals(argv, [
+    '--containername', '-c', '--profile', '--server',
+  ]);
+  const sub = pos[0];
+  if (!sub) usage(1);
 
   const api = apiFor(argv);
-  const pos = positionals(argv, ['--rename', '--containername', '-c']);
-  if (pos.length === 0) usage(1);
 
-  // `crosstalk channel list` → list channels
-  if (pos[0] === 'list') {
+  if (sub === 'list') {
     let r;
     try {
       r = await api.get('/channels');
@@ -49,47 +53,61 @@ export async function run(argv) {
     return 0;
   }
 
-  const handle = pos[0];
-  const renameTo = flag(argv, '--rename');
-  const wantDelete = has(argv, '--delete');
-
-  if (renameTo && wantDelete) {
-    process.stderr.write('crosstalk channel: --rename and --delete are mutually exclusive.\n');
-    return 1;
+  if (sub === 'create') {
+    const name = pos[1];
+    if (!name) {
+      process.stderr.write('crosstalk channel create: <name> required.\n');
+      return 1;
+    }
+    let r;
+    try {
+      r = await api.post('/channels', { name });
+    } catch (err) {
+      reportAndExit(err, 'crosstalk channel create');
+    }
+    process.stdout.write(`Created channel: ${r.uuid}\n`);
+    process.stdout.write(`  name: ${r.name}\n`);
+    return 0;
   }
 
-  // Rename: PATCH /channels/<handle> { name: <new> }
-  if (renameTo) {
+  if (sub === 'rename') {
+    const handle = pos[1];
+    const newName = pos[2];
+    if (!handle || !newName) {
+      process.stderr.write('crosstalk channel rename: <handle> <new-name> required.\n');
+      return 1;
+    }
     let r;
     try {
-      r = await api.patch(`/channels/${encodeURIComponent(handle)}`, { name: renameTo });
+      r = await api.patch(`/channels/${encodeURIComponent(handle)}`, { name: newName });
     } catch (err) {
-      reportAndExit(err, 'crosstalk channel');
+      reportAndExit(err, 'crosstalk channel rename');
     }
     if (r.noop) {
-      process.stdout.write(`No-op: ${handle} already named ${renameTo}.\n`);
+      process.stdout.write(`No-op: ${handle} already named ${newName}.\n`);
       return 0;
     }
     process.stdout.write(`Renamed: ${handle} -> ${r.name} (${r.uuid})\n`);
     return 0;
   }
 
-  // Delete: DELETE /channels/<handle>?confirm=<name>
-  // Engine returns 400 if confirm is missing/wrong, with the expected
-  // value in the error message. Client reads the channel's name first
-  // and passes it as confirm — operator's explicit --delete flag IS the
-  // confirmation for now. Interactive prompt deferred (would block on
-  // stdin in scripts).
-  if (wantDelete) {
+  if (sub === 'delete') {
+    const handle = pos[1];
+    if (!handle) {
+      process.stderr.write('crosstalk channel delete: <handle> required.\n');
+      return 1;
+    }
+    // Engine requires ?confirm=<name>. We resolve the channel's current
+    // name first so the verb itself is the operator's explicit consent.
     let target;
     try {
       const all = await api.get('/channels');
       target = all.channels.find((c) => c.uuid === handle || c.name === handle);
     } catch (err) {
-      reportAndExit(err, 'crosstalk channel');
+      reportAndExit(err, 'crosstalk channel delete');
     }
     if (!target) {
-      process.stderr.write(`crosstalk channel: '${handle}' not found.\n`);
+      process.stderr.write(`crosstalk channel delete: '${handle}' not found.\n`);
       return 1;
     }
     const confirm = target.name ?? target.uuid;
@@ -99,20 +117,12 @@ export async function run(argv) {
         `/channels/${encodeURIComponent(handle)}?confirm=${encodeURIComponent(confirm)}`,
       );
     } catch (err) {
-      reportAndExit(err, 'crosstalk channel');
+      reportAndExit(err, 'crosstalk channel delete');
     }
     process.stdout.write(`Deleted channel: ${r.name ?? '(unnamed)'} (${r.uuid})\n`);
     return 0;
   }
 
-  // No flags → create a channel with the given name.
-  let r;
-  try {
-    r = await api.post('/channels', { name: handle });
-  } catch (err) {
-    reportAndExit(err, 'crosstalk channel');
-  }
-  process.stdout.write(`Created channel: ${r.uuid}\n`);
-  process.stdout.write(`  name: ${r.name}\n`);
-  return 0;
+  process.stderr.write(`crosstalk channel: unknown subcommand '${sub}'.\n`);
+  usage(1);
 }