@cordfuse/crosstalk 7.0.0-alpha.9 → 8.0.0-alpha.1

package/bin/crosstalk.js

@@ -1,84 +1,118 @@
 #!/usr/bin/env node
-// crosstalk — host-side client for the crosstalkd daemon.
+// crosstalk — single-binary CLI for the Crosstalk protocol.
 //
-// Thin subcommand dispatcher. Routes operator commands to either:
-//   - the engine's HTTP API on 127.0.0.1:<port> (protocol commands)
-//   - the local docker daemon (lifecycle: up, down, restart, pull, logs)
-//   - `docker exec -it <container>` via a PTY wrapper (chat, shell)
+// v8-monorepo: the daemon is an internal subcommand of this CLI.
+// `crosstalk daemon dispatch ...` is what `crosstalk server start`
+// spawns under the hood.
 //
-// Subcommands and their groups:
-//
-//   Protocol (HTTP API):  run, replies, status, channel, init
-//   Lifecycle (docker):   up, down, restart, pull, logs
-//   Interactive (pty):    chat, shell
-//   Observability:        version
-//
-// P3 only ships `version` as a proof-of-life. Other subcommands land
-// in P4 (protocol), P5 (lifecycle), P6 (interactive).
+// Strict noun-verb shape, mirroring @cordfuse/llmux where the concepts
+// overlap. See V8-CLI-ALIGN.md for the full surface + design rationale.
 
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 
-const SUBCOMMANDS = {
-  // each entry is the file in commands/ to load
+// Each entry is a file in commands/ that exports an async `run(argv)`.
+// The noun handler receives the full argv MINUS the noun itself; it's
+// responsible for dispatching its own verbs.
+const NOUNS = {
+  // Meta — no verb required
   version: 'version.js',
-  run:     'run.js',
-  replies: 'replies.js',
-  status:  'status.js',
-  channel: 'channel.js',
-  init:    'init.js',
-  up:      'up.js',
-  down:    'down.js',
-  rm:      'rm.js',
-  restart: 'restart.js',
-  pull:    'pull.js',
-  logs:    'logs.js',
-  chat:    'chat.js',
+
+  // Auth
+  auth:     'auth.js',     // login | logout | whoami | list | use
+  token:    'token.js',    // create | list | revoke | rename
+
+  // Lifecycle + transport
+  server:   'server.js',   // start | stop | restart | status | logs
+  transport:'transport.js',// init | rm
+  daemon:   'daemon.js',   // dispatch | init | stop  (internal — spawned by server start + systemd)
+
+  // Protocol surface
+  channel:  'channel.js',  // list | create | rename | delete
+  message:  'message.js',  // send | replies
+  workflow: 'workflow.js', // compose | run | status
+
+  // Observability
+  agent:    'agent.js',    // list
+  logs:     'logs.js',     // list | tail
+  settings: 'settings.js', // show
+  status:   'status.js',   // (no verb — transport-level snapshot)
+
+  // Interactive PTY
+  chat:     'chat.js',     // <agent> positional | --shell
 };
 
 const argv = process.argv.slice(2);
 const thisDir = dirname(fileURLToPath(import.meta.url));
 
 function printUsage(exitCode = 0) {
-  process.stdout.write(
-`Usage: crosstalk <subcommand> [args...]
+  const w = exitCode === 0 ? process.stdout : process.stderr;
+  w.write(
+`Usage: crosstalk <noun> <verb> [args...]
 
-The host-side client for crosstalkd. Most commands talk to the engine's
-HTTP API on 127.0.0.1; lifecycle commands talk to the local docker daemon.
+Nouns:
+  version                                meta
+  auth      login|logout|whoami|list|use credentials
+  token     create|list|revoke|rename    bearer tokens
+  server    start|stop|restart|status|logs   daemon lifecycle
+  transport init|rm                       transport scaffold + teardown
+  daemon    dispatch|init                 internal — spawned by 'server start'
+  channel   list|create|rename|delete     bus channels
+  message   send|replies                  send a primitive or check replies
+  workflow  compose|run|status            workflow runtime
+  agent     list                          installed agent CLI catalog
+  logs      list|tail                     engine event log
+  settings  show                          engine config snapshot
+  status                                  transport-level snapshot
+  chat      <agent>|--shell               interactive PTY
 
-Subcommands:
-${Object.keys(SUBCOMMANDS).map((s) => `  ${s}`).join('\n')}
+Global flags:
+  --containername <name> | -c <name>     target a named transport (default: 'crosstalk')
+  --help | -h                            print this help
 
-If your engine listens on a non-default port, set CROSSTALK_API_PORT.
-
-v7.0.0-dev — many subcommands are not implemented yet (see bin/crosstalk.js).
+Env:
+  CROSSTALK_USER_MODE=1                  run engine + state under $HOME (user mode)
+  CROSSTALK_API_PORT=<port>              override the engine HTTP port
 `,
   );
   process.exit(exitCode);
 }
 
-if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') printUsage(0);
-
-if (argv[0] === '--version') {
-  // delegate to the version command so the engine-side number can also
-  // be queried in a uniform place
-  argv[0] = 'version';
+if (argv.length === 0) printUsage(1);
+if (argv[0] === '--help' || argv[0] === '-h') printUsage(0);
+if (argv[0] === '--version' || argv[0] === '-v') {
+  // Short-circuit version to avoid loading the noun module for this hot path.
+  // (commands/version.js still handles `crosstalk version` for the engine comparison.)
+  const pkg = JSON.parse(readFileSync(join(thisDir, '..', 'package.json'), 'utf-8'));
+  process.stdout.write(`crosstalk ${pkg.version}\n`);
+  process.exit(0);
 }
 
-const cmd = argv[0];
-const file = SUBCOMMANDS[cmd];
-if (!file) {
-  process.stderr.write(`crosstalk: unknown subcommand '${cmd}'\n\n`);
+const noun = argv[0];
+const nounFile = NOUNS[noun];
+if (!nounFile) {
+  process.stderr.write(`crosstalk: unknown noun '${noun}'\n\n`);
   printUsage(1);
 }
 
-const modulePath = join(thisDir, '..', 'commands', file);
-if (!existsSync(modulePath)) {
-  process.stderr.write(`crosstalk: command file missing for '${cmd}' (expected ${modulePath})\n`);
+const handlerPath = join(thisDir, '..', 'commands', nounFile);
+if (!existsSync(handlerPath)) {
+  process.stderr.write(`crosstalk: handler missing — ${handlerPath}\n`);
+  process.exit(2);
+}
+
+const mod = await import(handlerPath);
+if (typeof mod.run !== 'function') {
+  process.stderr.write(`crosstalk: ${nounFile} does not export run()\n`);
   process.exit(2);
 }
 
-const mod = await import(modulePath);
-const exit = await mod.run(argv.slice(1));
-process.exit(typeof exit === 'number' ? exit : 0);
+// Hand the noun-stripped argv to the handler. It dispatches its own verbs.
+try {
+  const code = await mod.run(argv.slice(1));
+  process.exit(typeof code === 'number' ? code : 0);
+} catch (err) {
+  process.stderr.write(`crosstalk ${noun}: ${err?.message || err}\n`);
+  process.exit(1);
+}

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);
 }