wicked-bus 1.1.0 → 2.0.0

package/commands/cli.js

@@ -33,7 +33,7 @@ function printUsage() {
     commands: [
       'init', 'emit', 'subscribe', 'status', 'replay',
       'cleanup', 'register', 'deregister', 'list', 'ack',
-      'dlq',
+      'dlq', 'daemon', 'ui',
     ],
     global_flags: ['--db-path <path>', '--json', '--log-level <level>'],
   };
@@ -128,6 +128,16 @@ async function main() {
         await cmdDlq(args, globals, args._positional || []);
         break;
       }
+      case 'daemon': {
+        const { cmdDaemon } = await import('./cmd-daemon.js');
+        await cmdDaemon(args, globals, args._positional || []);
+        break;
+      }
+      case 'ui': {
+        const { cmdUi } = await import('./cmd-ui.js');
+        await cmdUi(args, globals);
+        break;
+      }
       default:
         printUsage();
         process.exit(command ? 1 : 0);

package/commands/cmd-daemon.js

@@ -0,0 +1,238 @@
+/**
+ * `wicked-bus daemon <subcommand>` — start, stop, status.
+ *
+ * - `start [--detached]`   spawn the daemon in this process or detach a child
+ * - `stop`                 send SIGTERM to the running daemon (clean shutdown)
+ * - `status`               JSON snapshot: socket path, pid, subscribers
+ *
+ * Lifecycle uses lib/daemon-singleton.js for the PID lock and
+ * lib/daemon.js for the socket server. Subscribers connect via the
+ * library / wrapper APIs; this CLI is operator-facing only.
+ *
+ * @module commands/cmd-daemon
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { resolveDataDir, ensureDataDir } from '../lib/paths.js';
+import {
+  startDaemon,
+  socketPath,
+} from '../lib/daemon.js';
+import {
+  acquireDaemonLock,
+} from '../lib/daemon-singleton.js';
+import { probeDaemon } from '../lib/daemon-client.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = path.dirname(__filename);
+
+export async function cmdDaemon(args, globals, positional) {
+  const sub = (positional && positional[0]) || null;
+  if (!sub) {
+    return emitJson({
+      error: 'usage',
+      message: 'daemon requires a subcommand: start | stop | status',
+    });
+  }
+
+  switch (sub) {
+    case 'start':  return cmdDaemonStart(args, globals);
+    case 'stop':   return cmdDaemonStop(args, globals);
+    case 'status': return cmdDaemonStatus(args, globals);
+    default:
+      return emitJson({
+        error: 'usage',
+        message: `unknown daemon subcommand: ${sub}`,
+      });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// start
+// ---------------------------------------------------------------------------
+
+async function cmdDaemonStart(args /*, globals */) {
+  const dataDir = resolveDataDir();
+  ensureDataDir();
+
+  // Detached: fork ourselves with `--no-detach` so the child runs the
+  // foreground branch. Parent waits for the socket to come up, prints
+  // status, exits 0. Stderr is captured to a log file in dataDir so the
+  // child's startup errors are diagnosable even when stdio is detached.
+  if (args.detached !== false && (args.detached === true || args['detach'] === true)) {
+    const logPath = path.join(dataDir, 'daemon.log');
+    const logFd = fs.openSync(logPath, 'a');
+    const child = spawn(
+      process.execPath,
+      [path.resolve(__dirname, 'cli.js'), 'daemon', 'start', '--no-detach'],
+      {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: process.env,
+        cwd: dataDir,
+      },
+    );
+    fs.closeSync(logFd);
+    child.unref();
+
+    const ok = await waitForSocket(dataDir, 5000);
+    if (!ok) {
+      let logTail = '';
+      try { logTail = fs.readFileSync(logPath, 'utf8').slice(-2000); }
+      catch (_e) { /* ignore */ }
+      return emitJsonExit({
+        error: 'daemon-start-timeout',
+        message: 'spawned daemon did not start listening within 5s',
+        socket: socketPath(dataDir),
+        log_tail: logTail,
+      }, 1);
+    }
+    return emitJson({
+      ok: true,
+      mode: 'detached',
+      pid: child.pid,
+      socket: socketPath(dataDir),
+    });
+  }
+
+  // Foreground: hold the lock, run the daemon, hand off to a SIGTERM/SIGINT
+  // handler for clean shutdown. This branch is what `--detached` re-enters.
+  let lock;
+  try {
+    lock = acquireDaemonLock(dataDir);
+  } catch (e) {
+    if (e.code === 'EALREADY_RUNNING') {
+      return emitJsonExit({
+        error: 'EALREADY_RUNNING',
+        message: e.message,
+        prior_pid: e.priorPid,
+        socket: socketPath(dataDir),
+      }, 1);
+    }
+    throw e;
+  }
+
+  const daemon = await startDaemon({
+    dataDir,
+    inline_payload_max_bytes: numFlag(args, 'inline-payload-max-bytes'),
+    subscriber_queue_max:     numFlag(args, 'subscriber-queue-max'),
+  });
+
+  const shutdown = async () => {
+    try { await daemon.stop(); } catch (_e) { /* ignore */ }
+    try { lock.release(); } catch (_e) { /* ignore */ }
+    process.exit(0);
+  };
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT',  shutdown);
+
+  emitJson({
+    ok: true,
+    mode: 'foreground',
+    pid: process.pid,
+    socket: daemon.socketPath,
+  });
+
+  // Stay alive until a signal fires shutdown(). The Node event loop keeps
+  // the process running because the server holds an active handle.
+}
+
+// ---------------------------------------------------------------------------
+// stop
+// ---------------------------------------------------------------------------
+
+async function cmdDaemonStop(/* args, globals */) {
+  const dataDir = resolveDataDir();
+  const lockPath = path.join(dataDir, 'daemon.lock');
+
+  let pid;
+  try {
+    pid = parseInt(fs.readFileSync(lockPath, 'utf8'), 10) || null;
+  } catch (_e) {
+    pid = null;
+  }
+
+  if (!pid) {
+    return emitJson({ ok: false, reason: 'no-lock-file', socket: socketPath(dataDir) });
+  }
+
+  try {
+    process.kill(pid, 'SIGTERM');
+  } catch (e) {
+    return emitJsonExit({
+      error: 'kill-failed',
+      pid,
+      message: e.message,
+    }, 1);
+  }
+
+  // Best-effort wait for the daemon to release the lock.
+  const released = await waitForLockRelease(lockPath, 5000);
+  return emitJson({
+    ok: true,
+    pid,
+    released,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// status
+// ---------------------------------------------------------------------------
+
+async function cmdDaemonStatus(/* args, globals */) {
+  const dataDir = resolveDataDir();
+  const lockPath = path.join(dataDir, 'daemon.lock');
+  const sockPath = socketPath(dataDir);
+
+  let pid = null;
+  try { pid = parseInt(fs.readFileSync(lockPath, 'utf8'), 10) || null; }
+  catch (_e) { /* no lock */ }
+
+  const reachable = await probeDaemon(dataDir, 200);
+
+  return emitJson({
+    socket: sockPath,
+    lock_path: lockPath,
+    pid,
+    reachable,
+  });
+}
+
+// ---------------------------------------------------------------------------
+
+function emitJson(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+function emitJsonExit(obj, code) {
+  process.stderr.write(JSON.stringify(obj) + '\n');
+  process.exit(code);
+}
+
+function numFlag(args, name) {
+  const v = args[name];
+  if (v == null || v === true) return undefined;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+async function waitForSocket(dataDir, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await probeDaemon(dataDir, 100)) return true;
+    await new Promise(r => setTimeout(r, 50));
+  }
+  return false;
+}
+
+async function waitForLockRelease(lockPath, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!fs.existsSync(lockPath)) return true;
+    await new Promise(r => setTimeout(r, 50));
+  }
+  return false;
+}

package/commands/cmd-ui.js

@@ -0,0 +1,156 @@
+/**
+ * `wicked-bus ui` — operator-facing CLI for the read-only UI server.
+ *
+ *   wicked-bus ui                 start in foreground, JSON to stdout
+ *   wicked-bus ui --detached      fork a child, print connection info, exit 0
+ *   wicked-bus ui --rotate-token  regenerate the bearer token
+ *   wicked-bus ui --host 0.0.0.0  bind non-loopback (warning printed)
+ *   wicked-bus ui --port 7842     bind a specific port (default 0 = ephemeral
+ *                                 in foreground; default 7842 in detached
+ *                                 mode so a known port is reachable)
+ *
+ * Foreground sets up SIGTERM/SIGINT handlers for clean shutdown. Detached
+ * redirects child stdio to `<dataDir>/ui.log` so startup failures are
+ * diagnosable (same lesson as the daemon CLI: stdio:'ignore' on a long-
+ * running spawn hides everything).
+ *
+ * @module commands/cmd-ui
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { resolveDataDir, ensureDataDir } from '../lib/paths.js';
+import { openDb } from '../lib/db.js';
+import { startUiServer, DEFAULT_HOST, DEFAULT_PORT } from '../lib/ui-server.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname  = path.dirname(__filename);
+
+export async function cmdUi(args /*, globals */) {
+  const dataDir = resolveDataDir();
+  ensureDataDir();
+
+  // --no-detach is the inner branch; --detached is the outer fork.
+  if (args.detached === true || args['detach'] === true) {
+    return startDetached(args, dataDir);
+  }
+
+  return startForeground(args, dataDir);
+}
+
+// ---------------------------------------------------------------------------
+
+async function startDetached(args, dataDir) {
+  const logPath = path.join(dataDir, 'ui.log');
+  const logFd = fs.openSync(logPath, 'a');
+
+  // Re-invoke ourselves with --no-detach + a known port so the child can
+  // start cleanly and the parent can probe.
+  const port = args.port ? String(args.port) : String(DEFAULT_PORT);
+  const host = args.host ? String(args.host) : DEFAULT_HOST;
+
+  const childArgs = [
+    path.resolve(__dirname, 'cli.js'),
+    'ui', '--no-detach',
+    '--port', port,
+    '--host', host,
+  ];
+  if (args['rotate-token'] === true || args.rotate_token === true) {
+    childArgs.push('--rotate-token');
+  }
+
+  const child = spawn(process.execPath, childArgs, {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
+    env: process.env,
+    cwd: dataDir,
+  });
+  fs.closeSync(logFd);
+  child.unref();
+
+  const reachable = await waitForUi(host, port, 5000);
+  if (!reachable) {
+    let logTail = '';
+    try { logTail = fs.readFileSync(logPath, 'utf8').slice(-2000); }
+    catch (_e) { /* ignore */ }
+    return emitJsonExit({
+      error: 'ui-start-timeout',
+      message: 'spawned UI did not start listening within 5s',
+      log_tail: logTail,
+    }, 1);
+  }
+
+  return emitJson({
+    ok: true,
+    mode: 'detached',
+    pid: child.pid,
+    host,
+    port: Number(port),
+  });
+}
+
+// ---------------------------------------------------------------------------
+
+async function startForeground(args, dataDir) {
+  const liveDb = openDb();
+  const ui = await startUiServer({
+    dataDir,
+    liveDb,
+    host: args.host ?? DEFAULT_HOST,
+    port: args.port != null ? Number(args.port) : DEFAULT_PORT,
+    rotate_token: args['rotate-token'] === true || args.rotate_token === true,
+  });
+
+  const shutdown = async () => {
+    try { await ui.stop(); } catch (_e) { /* ignore */ }
+    try { liveDb.close(); } catch (_e) { /* ignore */ }
+    process.exit(0);
+  };
+  process.on('SIGTERM', shutdown);
+  process.on('SIGINT',  shutdown);
+
+  emitJson({
+    ok: true,
+    mode: 'foreground',
+    pid: process.pid,
+    host: ui.host,
+    port: ui.port,
+    token_path: ui.token_path,
+  });
+}
+
+// ---------------------------------------------------------------------------
+
+async function waitForUi(host, port, timeoutMs) {
+  const http = await import('node:http');
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (await ping(http.default, host, port)) return true;
+    await new Promise(r => setTimeout(r, 50));
+  }
+  return false;
+}
+
+function ping(http, host, port) {
+  return new Promise((resolve) => {
+    const req = http.request({ host, port, path: '/healthz', method: 'GET', timeout: 200 }, (res) => {
+      // Drain so the connection releases.
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => { req.destroy(); resolve(false); });
+    req.end();
+  });
+}
+
+function emitJson(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+function emitJsonExit(obj, code) {
+  process.stderr.write(JSON.stringify(obj) + '\n');
+  process.exit(code);
+}

package/install.mjs

@@ -11,8 +11,46 @@ const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const skillsSource = join(__dirname, "skills");
 const home = homedir();
 
+// Claude-root candidate builder. Mirrors the 1.1.1 wicked-testing /
+// wicked-brain fix: $CLAUDE_CONFIG_DIR is authoritative when set;
+// otherwise probe common alt-config layouts. Claude Code's config root
+// is redirectable, and hardcoded ~/.claude silently misses users on
+// shared-home / multi-tenant setups.
+function buildClaudeTarget(rootDir, source, { trusted = false } = {}) {
+  return {
+    name: "claude",
+    rootDir,
+    dir: join(rootDir, "skills"),
+    platform: "claude",
+    identityMarkers: ["settings.json", "plugins", "projects"],
+    source,
+    trusted,
+  };
+}
+
+function resolveClaudeCandidates() {
+  const envDir = process.env.CLAUDE_CONFIG_DIR;
+  if (envDir && typeof envDir === "string" && envDir.trim()) {
+    // Function replacement avoids `$&` etc. being interpreted as regex
+    // back-references if $HOME contains those literals.
+    const root = resolve(envDir.trim().replace(/^~/, () => home));
+    return [buildClaudeTarget(root, "env:CLAUDE_CONFIG_DIR", { trusted: true })];
+  }
+  return [
+    buildClaudeTarget(join(home, ".claude"),                "default"),
+    buildClaudeTarget(join(home, "alt-configs", ".claude"), "alt-configs"),
+    buildClaudeTarget(join(home, ".config", "claude"),      "xdg"),
+  ];
+}
+
+function claudeHasIdentityMarker(target) {
+  if (target.trusted) return true;
+  if (!existsSync(target.rootDir)) return false;
+  return (target.identityMarkers || []).some(m => existsSync(join(target.rootDir, m)));
+}
+
+// Non-claude canonical targets. Claude is expanded dynamically above.
 const CLI_TARGETS = [
-  { name: "claude",      dir: join(home, ".claude", "skills"),      platform: "claude" },
   { name: "gemini",      dir: join(home, ".gemini", "skills"),      platform: "gemini" },
   { name: "copilot",     dir: join(home, ".github", "skills"),      platform: "copilot" },
   { name: "codex",       dir: join(home, ".codex", "skills"),       platform: "codex" },
@@ -24,19 +62,43 @@ const CLI_TARGETS = [
 console.log("wicked-bus installer\n");
 
 const args = argv.slice(2);
-const argValue = (a) => a.split("=")[1];
-const cliArg = args.find((a) => a.startsWith("--cli="));
-const pathArg = args.find((a) => a.startsWith("--path="));
+
+// Flag parser supporting both --flag=value and --flag value forms, plus
+// narrow string-boolean coercion ("true" / "false" → booleans). Previously
+// the ad-hoc parser silently dropped space-separated values — same bug
+// that hit wicked-testing 0.3.2 / wicked-brain 0.3.7.
+const flagValue = (name) => {
+  const f = args.find(a => a === `--${name}` || a.startsWith(`--${name}=`));
+  if (!f) return null;
+  let val;
+  if (f.includes("=")) {
+    // slice from the first '=' forward — split("=")[1] would truncate at
+    // the second '=' (e.g. --path=/volumes/build=artifacts).
+    val = f.slice(f.indexOf("=") + 1);
+  } else {
+    const idx = args.indexOf(f);
+    const next = args[idx + 1];
+    val = (next && !next.startsWith("-")) ? next : true;
+  }
+  if (val === "false") return false;
+  if (val === "true")  return true;
+  return val;
+};
+
+const cliArg  = flagValue("cli");
+const pathArg = flagValue("path");
+
+// Validate --cli upfront so a mistyped --cli / --cli= fails fast
+// instead of silently falling through to "all detected".
+if (cliArg === true || cliArg === "") {
+  console.error("Error: --cli requires a value (e.g. --cli=claude or --cli claude)");
+  process.exit(1);
+}
 
 let targets;
 
-if (pathArg) {
-  const rawPath = argValue(pathArg);
-  if (!rawPath) {
-    console.error("Error: --path requires a value (e.g. --path=~/.claude)");
-    process.exit(1);
-  }
-  const customPath = resolve(rawPath.replace(/^~/, home));
+if (pathArg && typeof pathArg === "string" && pathArg !== "") {
+  const customPath = resolve(pathArg.replace(/^~/, () => home));
   const dirName = basename(customPath).replace(/^\./, "");
   targets = [{
     name: dirName,
@@ -44,18 +106,29 @@ if (pathArg) {
     platform: dirName,
   }];
   console.log(`Custom path: ${customPath}\n`);
+} else if (pathArg === true || pathArg === "") {
+  console.error("Error: --path requires a value (e.g. --path=~/.claude or --path ~/.claude)");
+  process.exit(1);
 } else {
-  const detected = CLI_TARGETS.filter((t) => existsSync(resolve(t.dir, "..")));
+  // Expanded detection: claude candidates (env var OR alt-config probes,
+  // identity-marker gated) + non-claude parent-dir-exists heuristic.
+  const claudeDetected = resolveClaudeCandidates().filter(claudeHasIdentityMarker);
+  const otherDetected  = CLI_TARGETS.filter((t) => existsSync(resolve(t.dir, "..")));
+  const detected = [...claudeDetected, ...otherDetected];
 
   if (detected.length === 0) {
     console.log("No supported AI CLIs detected. Supported: claude, gemini, copilot, codex, cursor, kiro, antigravity");
-    console.log("Install skills manually by copying the skills/ directory.");
+    console.log("Install skills manually by copying the skills/ directory, or set CLAUDE_CONFIG_DIR.");
     process.exit(1);
   }
 
-  console.log(`Detected CLIs: ${detected.map((d) => d.name).join(", ")}\n`);
+  const claudeCount = claudeDetected.length;
+  const label = (d) => d.name === "claude" && claudeCount > 1 && d.source
+    ? `${d.name}[${d.source}]`
+    : d.name;
+  console.log(`Detected CLIs: ${detected.map(label).join(", ")}\n`);
 
-  const cliFilter = cliArg ? argValue(cliArg).split(",") : null;
+  const cliFilter = (typeof cliArg === "string" && cliArg !== "") ? cliArg.split(",") : null;
   targets = cliFilter ? detected.filter((d) => cliFilter.includes(d.name)) : detected;
 }