claude-multi-session 1.0.0

package/bin/cli.js

@@ -0,0 +1,693 @@
+#!/usr/bin/env node
+
+/**
+ * ╔══════════════════════════════════════════════════════════════╗
+ * ║  claude-multi-session (cms) — CLI for multi-session control  ║
+ * ╚══════════════════════════════════════════════════════════════╝
+ *
+ * Usage:  cms <command> [options]
+ *     or: npx claude-multi-session <command> [options]
+ *
+ * Commands:
+ *   spawn    Start a new streaming session
+ *   send     Send a message to an existing session
+ *   resume   Restore and resume a stopped/paused session
+ *   pause    Pause a session (keeps process alive)
+ *   fork     Branch off a session into a new one
+ *   stop     Gracefully stop a session
+ *   kill     Force kill a session
+ *   status   Show detailed session info
+ *   output   Get last response text
+ *   list     List all sessions
+ *   history  Show full interaction history
+ *   delete   Permanently remove a session
+ *   batch    Spawn multiple sessions from JSON file
+ *   cleanup  Remove old sessions
+ *   delegate Smart task delegation with safety + control loop
+ *   continue Send follow-up to a delegated session
+ *   setup    Register MCP server with Claude Code
+ *   help     Show this help
+ */
+
+const { SessionManager, Delegate } = require('../src/index');
+const fs = require('fs');
+const path = require('path');
+
+// ============================================================================
+// Argument Parser
+// ============================================================================
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  if (args.length === 0) return { command: 'help', flags: {} };
+
+  const command = args[0];
+  const flags = {};
+  let i = 1;
+
+  while (i < args.length) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      const key = arg.slice(2);
+      if (key.includes('=')) {
+        const [k, ...v] = key.split('=');
+        flags[k] = v.join('=');
+      } else if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+        flags[key] = args[i + 1];
+        i++;
+      } else {
+        flags[key] = true;
+      }
+    }
+    i++;
+  }
+
+  return { command, flags };
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function truncate(str, maxLen) {
+  if (!str) return '';
+  const single = str.replace(/\n/g, ' ').trim();
+  return single.length <= maxLen ? single : single.slice(0, maxLen - 3) + '...';
+}
+
+function timeAgo(iso) {
+  if (!iso) return 'unknown';
+  const diff = Date.now() - new Date(iso).getTime();
+  if (diff < 60000) return 'just now';
+  if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+  if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+  return `${Math.floor(diff / 86400000)}d ago`;
+}
+
+function statusIcon(status) {
+  return {
+    created: '○', starting: '◐', ready: '●', busy: '⟳',
+    paused: '⏸', stopped: '□', killed: '⊘', failed: '✗', error: '✗',
+    completed: '✓',
+  }[status] || '?';
+}
+
+function printResponse(name, response) {
+  console.log(`\n=== ${name} ===`);
+  if (response.isError) console.log('Status: ERROR');
+  if (response.cost) console.log(`Cost: $${response.cost.toFixed(4)}`);
+  if (response.turns) console.log(`Turns: ${response.turns}`);
+  if (response.duration) console.log(`Duration: ${(response.duration / 1000).toFixed(1)}s`);
+  console.log('---');
+  console.log(response.text || '(no output)');
+  console.log('');
+}
+
+// ============================================================================
+// Command Handlers
+// ============================================================================
+async function cmdSpawn(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.prompt) { console.error('Error: --prompt required'); process.exit(1); }
+
+  console.log(`Spawning "${flags.name}" (model: ${flags.model || 'sonnet'})...`);
+
+  const { session, response } = await mgr.spawn(flags.name, {
+    prompt: flags.prompt,
+    model: flags.model,
+    workDir: flags['work-dir'],
+    permissionMode: flags['permission-mode'],
+    allowedTools: flags['allowed-tools'] ? flags['allowed-tools'].split(',') : undefined,
+    systemPrompt: flags['system-prompt'],
+    maxBudget: flags['max-budget'] ? parseFloat(flags['max-budget']) : undefined,
+    agent: flags.agent,
+  });
+
+  if (response) {
+    printResponse(flags.name, response);
+  }
+
+  console.log(`Session "${flags.name}" is ready (ID: ${session.id})`);
+
+  // If --stop flag, stop session after first response (one-shot mode)
+  if (flags.stop) {
+    mgr.stop(flags.name);
+    console.log(`Session stopped. Resume later: cms resume --name ${flags.name}`);
+  } else {
+    console.log(`Send follow-up: cms send --name ${flags.name} --message "..."`);
+    console.log(`Session is alive and waiting. Stop with: cms stop --name ${flags.name}`);
+  }
+}
+
+async function cmdSend(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.message) { console.error('Error: --message required'); process.exit(1); }
+
+  // Check if session is alive — if not, auto-resume
+  const sessions = mgr.sessions;
+  if (!sessions.has(flags.name)) {
+    console.log(`Session "${flags.name}" not alive. Auto-resuming...`);
+    const response = await mgr.resume(flags.name, flags.message);
+    if (response) {
+      printResponse(flags.name, response);
+    }
+
+    // Stop after if requested
+    if (flags.stop) {
+      mgr.stop(flags.name);
+      console.log(`Session stopped.`);
+    }
+    return;
+  }
+
+  console.log(`Sending to "${flags.name}"...`);
+  const response = await mgr.send(flags.name, flags.message);
+  printResponse(flags.name, response);
+
+  if (flags.stop) {
+    mgr.stop(flags.name);
+    console.log(`Session stopped.`);
+  }
+}
+
+async function cmdResume(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  console.log(`Resuming "${flags.name}"...`);
+  const response = await mgr.resume(flags.name, flags.message);
+
+  if (response) {
+    printResponse(flags.name, response);
+  }
+
+  console.log(`Session "${flags.name}" is alive.`);
+  console.log(`Send: cms send --name ${flags.name} --message "..."`);
+}
+
+function cmdPause(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.pause(flags.name);
+  console.log(`Session "${flags.name}" paused.`);
+}
+
+async function cmdFork(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags['new-name']) { console.error('Error: --new-name required'); process.exit(1); }
+
+  console.log(`Forking "${flags.name}" -> "${flags['new-name']}"...`);
+  const { session, response } = await mgr.fork(flags.name, flags['new-name'], {
+    message: flags.message || 'Continue from the forked conversation.',
+    model: flags.model,
+  });
+
+  if (response) {
+    printResponse(flags['new-name'], response);
+  }
+
+  console.log(`Forked session "${flags['new-name']}" is ready.`);
+}
+
+function cmdStop(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.stop(flags.name);
+  console.log(`Session "${flags.name}" stopped. Resume: cms resume --name ${flags.name}`);
+}
+
+function cmdKill(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.kill(flags.name);
+  console.log(`Session "${flags.name}" killed.`);
+}
+
+function cmdStatus(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const info = mgr.status(flags.name);
+  console.log(`\n=== Session: ${info.name} ===`);
+  console.log(`Status:        ${statusIcon(info.status)} ${info.status}`);
+  console.log(`Model:         ${info.model}`);
+  console.log(`Session ID:    ${info.claudeSessionId || info.id || 'unknown'}`);
+  console.log(`Work Dir:      ${info.workDir}`);
+  console.log(`Cost:          $${(info.totalCostUsd || 0).toFixed(4)}`);
+  console.log(`Turns:         ${info.totalTurns || 0}`);
+  console.log(`Interactions:  ${info.interactionCount || (info.interactions || []).length}`);
+  if (info.pid) console.log(`PID:           ${info.pid}`);
+  console.log('');
+}
+
+function cmdOutput(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const last = mgr.lastOutput(flags.name);
+  if (!last) {
+    console.log(`No output for "${flags.name}" yet.`);
+    return;
+  }
+
+  if (flags.full) {
+    console.log(last.response || '(no output)');
+  } else {
+    console.log(`\n[${flags.name}] (${last.timestamp || 'unknown'})`);
+    console.log(`Prompt: ${truncate(last.prompt, 100)}`);
+    console.log('---');
+    console.log(last.response || '(no output)');
+    console.log('');
+  }
+}
+
+function cmdList(mgr, flags) {
+  const sessions = mgr.list(flags.status);
+
+  if (sessions.length === 0) {
+    console.log(flags.status ? `No sessions with status "${flags.status}".` : 'No sessions.');
+    return;
+  }
+
+  sessions.sort((a, b) => (b.lastSaved || b.created || '') > (a.lastSaved || a.created || '') ? 1 : -1);
+
+  console.log(`\n${'Name'.padEnd(25)} ${'Status'.padEnd(12)} ${'Model'.padEnd(8)} ${'Turns'.padEnd(6)} ${'Cost'.padEnd(10)} ${'Interactions'}`);
+  console.log('-'.repeat(80));
+
+  for (const s of sessions) {
+    const icon = statusIcon(s.status);
+    const interactions = s.interactionCount || (s.interactions || []).length;
+    console.log(
+      `${truncate(s.name, 24).padEnd(25)} ` +
+      `${(icon + ' ' + s.status).padEnd(12)} ` +
+      `${(s.model || '?').padEnd(8)} ` +
+      `${String(s.totalTurns || 0).padEnd(6)} ` +
+      `${'$' + (s.totalCostUsd || 0).toFixed(4).padEnd(9)} ` +
+      `${interactions}`
+    );
+  }
+
+  console.log(`\nTotal: ${sessions.length}`);
+  console.log('');
+}
+
+function cmdHistory(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+
+  const hist = mgr.history(flags.name);
+  if (hist.length === 0) {
+    console.log(`No history for "${flags.name}".`);
+    return;
+  }
+
+  console.log(`\n=== History: ${flags.name} (${hist.length} interactions) ===\n`);
+
+  hist.forEach((h, i) => {
+    console.log(`--- #${i} ${h.type || 'send'} — ${h.timestamp || 'unknown'} ---`);
+    console.log(`PROMPT:   ${flags.full ? h.prompt : truncate(h.prompt, 200)}`);
+    console.log(`RESPONSE: ${flags.full ? h.response : truncate(h.response, 300)}`);
+    if (h.cost) console.log(`COST:     $${h.cost.toFixed(4)}`);
+    if (h.duration) console.log(`DURATION: ${(h.duration / 1000).toFixed(1)}s`);
+    console.log('');
+  });
+}
+
+function cmdDelete(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  mgr.delete(flags.name);
+  console.log(`Session "${flags.name}" deleted permanently.`);
+}
+
+async function cmdBatch(mgr, flags) {
+  if (!flags.file) { console.error('Error: --file required (JSON file path)'); process.exit(1); }
+
+  const filePath = path.resolve(flags.file);
+  if (!fs.existsSync(filePath)) {
+    console.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  let specs;
+  try { specs = JSON.parse(fs.readFileSync(filePath, 'utf-8')); } catch (e) {
+    console.error(`Invalid JSON: ${e.message}`);
+    process.exit(1);
+  }
+
+  if (!Array.isArray(specs)) {
+    console.error('JSON must be an array of session specs.');
+    process.exit(1);
+  }
+
+  console.log(`Spawning ${specs.length} sessions in parallel...`);
+  const results = await mgr.batch(specs);
+
+  for (const r of results) {
+    if (r.error) {
+      console.log(`  ✗ ${r.session?.name || 'unknown'}: ${r.error}`);
+    } else {
+      const resp = r.response;
+      console.log(`  ✓ ${r.session.name}: ${resp ? truncate(resp.text, 80) : 'started (no prompt)'}`);
+    }
+  }
+
+  console.log(`\nDone. List all: cms list`);
+
+  // Stop all after batch unless --keep-alive
+  if (!flags['keep-alive']) {
+    mgr.stopAll();
+    console.log('All sessions stopped. Resume individually: cms resume --name <name>');
+  }
+}
+
+// ============================================================================
+// Delegate Commands (Control Loop + Safety Net)
+// ============================================================================
+
+/**
+ * DELEGATE — Smart task delegation with safety limits and auto-permission handling.
+ *
+ * Required: --name, --task
+ * Optional: --model, --preset, --max-cost, --max-turns, --context, --work-dir, --json
+ */
+async function cmdDelegate(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.task) { console.error('Error: --task required'); process.exit(1); }
+
+  const delegate = new Delegate(mgr);
+
+  const preset = flags.preset || 'edit';
+  const maxCost = flags['max-cost'] ? parseFloat(flags['max-cost']) : 2.00;
+  const maxTurns = flags['max-turns'] ? parseInt(flags['max-turns']) : 50;
+
+  if (!flags.json) {
+    console.log(`Delegating to "${flags.name}" (model: ${flags.model || 'sonnet'}, preset: ${preset}, max: $${maxCost.toFixed(2)})...`);
+  }
+
+  // --no-safety flag disables the safety net entirely
+  const useSafety = !flags['no-safety'];
+
+  const result = await delegate.run(flags.name, {
+    task: flags.task,
+    model: flags.model,
+    preset: preset,
+    workDir: flags['work-dir'],
+    maxCost: maxCost,
+    maxTurns: maxTurns,
+    context: flags.context,
+    systemPrompt: flags['system-prompt'],
+    agent: flags.agent,
+    safety: useSafety,
+  });
+
+  // Stop session after delegation (can be resumed)
+  delegate.finish(flags.name);
+
+  if (flags.json) {
+    // Output as JSON for programmatic consumption by parent Claude
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printDelegateResult(result);
+  }
+}
+
+/**
+ * CONTINUE — Send follow-up to a delegated session with safety limits.
+ *
+ * Required: --name, --message
+ * Optional: --json
+ */
+async function cmdContinue(mgr, flags) {
+  if (!flags.name) { console.error('Error: --name required'); process.exit(1); }
+  if (!flags.message) { console.error('Error: --message required'); process.exit(1); }
+
+  const delegate = new Delegate(mgr);
+
+  if (!flags.json) {
+    console.log(`Continuing "${flags.name}"...`);
+  }
+
+  const result = await delegate.continue(flags.name, flags.message);
+
+  // Stop after
+  delegate.finish(flags.name);
+
+  if (flags.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    printDelegateResult(result);
+  }
+}
+
+/**
+ * Print a DelegateResult in human-readable format.
+ */
+function printDelegateResult(result) {
+  const statusEmoji = {
+    completed: '✓',
+    needs_input: '?',
+    failed: '✗',
+    cost_exceeded: '$',
+    turns_exceeded: '#',
+    protected_path: '!',
+  }[result.status] || '?';
+
+  console.log(`\n${statusEmoji} Status: ${result.status.toUpperCase()}`);
+  if (result.error) console.log(`  Error: ${result.error}`);
+  if (result.cost) console.log(`  Cost: $${result.cost.toFixed(4)}`);
+  if (result.turns) console.log(`  Turns: ${result.turns}`);
+  if (result.duration) console.log(`  Duration: ${(result.duration / 1000).toFixed(1)}s`);
+  if (result.toolsUsed.length > 0) console.log(`  Tools: ${[...new Set(result.toolsUsed)].join(', ')}`);
+  console.log(`  Can continue: ${result.canContinue ? 'yes' : 'no'}`);
+
+  if (result.safety && result.safety.totalViolations > 0) {
+    console.log(`  Safety violations: ${result.safety.totalViolations}`);
+    result.safety.violations.forEach(v => console.log(`    - ${v.message}`));
+  }
+
+  console.log(`\n--- Response ---`);
+  console.log(result.response || '(no output)');
+  console.log('');
+
+  if (result.canContinue) {
+    console.log(`Continue: cms continue --name ${result.name} --message "..."`);
+  }
+}
+
+// ============================================================================
+// Setup Command
+// ============================================================================
+
+/**
+ * SETUP — Register the MCP server with Claude Code settings.
+ * Delegates to bin/setup.js which handles the interactive wizard.
+ */
+async function cmdSetup(flags) {
+  const { run } = require('./setup');
+  await run(flags);
+}
+
+function cmdCleanup(mgr, flags) {
+  const days = flags.days ? parseInt(flags.days) : 7;
+  const removed = mgr.cleanup(days);
+  if (removed.length === 0) {
+    console.log(`No sessions older than ${days} days to clean.`);
+  } else {
+    console.log(`Removed ${removed.length} sessions: ${removed.join(', ')}`);
+  }
+}
+
+function cmdHelp() {
+  console.log(`
+╔══════════════════════════════════════════════════════════════╗
+║  claude-multi-session (cms) — Multi-Session Orchestrator     ║
+║  Streaming-powered session management for Claude Code CLI    ║
+╚══════════════════════════════════════════════════════════════╝
+
+COMMANDS:
+
+  spawn     Start a new streaming session (keeps process alive)
+            --name <name>  --prompt <text>
+            [--model sonnet|opus|haiku]  [--stop]
+            [--work-dir <path>]  [--permission-mode <mode>]
+            [--allowed-tools <t1,t2>]  [--system-prompt <text>]
+            [--max-budget <usd>]  [--agent <name>]
+
+  send      Send a follow-up message (auto-resumes if stopped)
+            --name <name>  --message <text>  [--stop]
+
+  resume    Restore a stopped/paused session
+            --name <name>  [--message <text>]
+
+  pause     Pause session (process stays alive, no messages accepted)
+            --name <name>
+
+  fork      Branch off a session into a new one
+            --name <source>  --new-name <target>
+            [--message <text>]  [--model <model>]
+
+  stop      Gracefully stop (saves state, can resume later)
+            --name <name>
+
+  kill      Force kill a session
+            --name <name>
+
+  status    Show detailed session info
+            --name <name>
+
+  output    Get last response text
+            --name <name>  [--full]
+
+  list      List all sessions
+            [--status ready|paused|stopped|killed]
+
+  history   Show full interaction history
+            --name <name>  [--full]
+
+  delete    Permanently remove a session
+            --name <name>
+
+  batch     Spawn multiple sessions from JSON file
+            --file <path>  [--keep-alive]
+
+  cleanup   Remove old sessions
+            [--days <n>]
+
+  delegate  Smart task delegation with safety limits & auto-permission
+            --name <name>  --task <text>
+            [--model sonnet|opus|haiku]  [--preset read-only|review|edit|full|plan]
+            [--max-cost <usd>]  [--max-turns <n>]  [--no-safety]
+            [--context <text>]  [--work-dir <path>]
+            [--system-prompt <text>]  [--agent <name>]  [--json]
+
+  continue  Send follow-up to a delegated session
+            --name <name>  --message <text>  [--json]
+
+  setup     Register MCP server with Claude Code
+            [--global]  [--local]  [--uninstall]
+            [--guide]  [--no-guide]
+
+HOW IT WORKS:
+
+  Unlike the resume approach (new process per message), this system
+  uses Claude's stream-json protocol to keep ONE process alive per
+  session. Messages are piped in/out via stdin/stdout.
+
+  Benefits:
+    • No process restart overhead (~2-3s saved per message)
+    • No context reload (lower token cost)
+    • Instant follow-up responses
+    • True multi-turn conversations
+
+  Sessions are persisted to ~/.claude-multi-session/ and can be
+  resumed even after the manager process exits (using --resume).
+
+EXAMPLES:
+
+  # Start a session, send prompt, keep alive for follow-ups
+  cms spawn --name fix-auth --prompt "Fix the auth bug in auth.service.ts"
+  cms send --name fix-auth --message "Also add input validation"
+  cms send --name fix-auth --message "Now write tests"
+  cms stop --name fix-auth
+
+  # One-shot: spawn, get result, stop automatically
+  cms spawn --name quick-task --prompt "Count TypeScript files" --stop
+
+  # Resume a stopped session days later
+  cms resume --name fix-auth --message "Actually, also handle edge cases"
+
+  # Fork to try a different approach
+  cms fork --name fix-auth --new-name fix-auth-v2 --message "Try JWT instead"
+
+  # Parallel batch
+  cms batch --file tasks.json
+
+  # Send to stopped session (auto-resumes)
+  cms send --name fix-auth --message "Add error handling"
+
+DELEGATE (Control Loop + Safety Net):
+
+  # Delegate a task with $1 cost limit, auto-permission handling
+  cms delegate --name fix-bug --task "Fix auth bug in auth.service.ts" --max-cost 1.00
+
+  # Delegate with read-only preset (no file edits allowed)
+  cms delegate --name review --task "Review code quality" --preset read-only
+
+  # Get structured JSON output (for programmatic use by parent Claude)
+  cms delegate --name task-1 --task "Count files" --model haiku --json
+
+  # Send follow-up to a delegated session
+  cms continue --name fix-bug --message "Also add input validation"
+
+  # Full control: delegate with context and custom limits
+  cms delegate --name big-task --task "Refactor auth" --model opus \\
+    --preset full --max-cost 5.00 --max-turns 100 \\
+    --context "Use JWT, not sessions"
+
+PRESETS (for delegate):
+
+  read-only   Can search/read files, no edits
+  review      Same as read-only (code review mode)
+  edit        Can read and edit files (default)
+  full        Full access (use with caution)
+  plan        Explore only, no execution
+
+INSTALL:
+
+  npm install -g claude-multi-session
+  cms setup              # Register MCP server with Claude Code
+  # Then use: cms <command>
+  # Or: npx claude-multi-session <command>
+`);
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+async function main() {
+  const { command, flags } = parseArgs(process.argv);
+
+  // Create manager (shared across commands)
+  const mgr = new SessionManager();
+
+  const commands = {
+    spawn: () => cmdSpawn(mgr, flags),
+    send: () => cmdSend(mgr, flags),
+    input: () => cmdSend(mgr, flags), // Alias
+    resume: () => cmdResume(mgr, flags),
+    pause: () => cmdPause(mgr, flags),
+    fork: () => cmdFork(mgr, flags),
+    stop: () => cmdStop(mgr, flags),
+    kill: () => cmdKill(mgr, flags),
+    status: () => cmdStatus(mgr, flags),
+    output: () => cmdOutput(mgr, flags),
+    list: () => cmdList(mgr, flags),
+    history: () => cmdHistory(mgr, flags),
+    delete: () => cmdDelete(mgr, flags),
+    batch: () => cmdBatch(mgr, flags),
+    cleanup: () => cmdCleanup(mgr, flags),
+    delegate: () => cmdDelegate(mgr, flags),
+    continue: () => cmdContinue(mgr, flags),
+    setup: () => cmdSetup(flags),
+    help: () => cmdHelp(),
+  };
+
+  if (!commands[command]) {
+    console.error(`Unknown command: "${command}". Run "cms help" for usage.`);
+    process.exit(1);
+  }
+
+  try {
+    await commands[command]();
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+
+  // If any sessions are still alive, keep the process running
+  // so streaming sessions don't get killed
+  if (mgr.sessions.size > 0 && !['list', 'status', 'output', 'history', 'help', 'cleanup'].includes(command)) {
+    // Keep process alive until stopped
+    if (['spawn', 'send', 'resume', 'fork'].includes(command) && !flags.stop) {
+      // Don't hold the process — sessions survive in background
+      // We stop them gracefully and they can be resumed
+      mgr.stopAll();
+    }
+  }
+}
+
+main().catch(err => {
+  console.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});