claude-b 0.4.2 → 0.5.0

package/dist/cli/index.js

@@ -157,8 +157,78 @@ var DaemonClient = class extends EventEmitter {
   }
 };
 
+// package.json
+var package_default = {
+  name: "claude-b",
+  version: "0.5.0",
+  description: "Background-capable Claude Code with async workflows and REST API",
+  type: "module",
+  main: "dist/cli/index.js",
+  bin: {
+    cb: "./bin/cb"
+  },
+  scripts: {
+    dev: "tsup src/cli/index.ts src/daemon/index.ts --watch --format esm",
+    build: "tsup src/cli/index.ts src/daemon/index.ts --format esm --dts --clean",
+    test: "vitest",
+    lint: "eslint src/",
+    typecheck: "tsc --noEmit",
+    "start:daemon": "node dist/daemon/index.js"
+  },
+  dependencies: {
+    "@anthropic-ai/sdk": "^0.74.0",
+    "@fastify/cors": "^10.0.0",
+    "@fastify/jwt": "^9.0.0",
+    "@fastify/rate-limit": "^10.0.0",
+    "@fastify/websocket": "^11.0.0",
+    "@speechmatics/batch-client": "^5.1.0",
+    chalk: "^5.3.0",
+    commander: "^12.1.0",
+    fastify: "^5.0.0",
+    nanoid: "^5.0.7",
+    "node-pty": "^1.0.0",
+    "node-telegram-bot-api": "^0.67.0",
+    ora: "^8.1.0",
+    "strip-ansi": "^7.1.0",
+    ws: "^8.18.0"
+  },
+  devDependencies: {
+    "@types/node": "^22.10.0",
+    "@types/node-telegram-bot-api": "^0.64.13",
+    "@types/ws": "^8.18.1",
+    "@typescript-eslint/eslint-plugin": "^8.53.0",
+    "@typescript-eslint/parser": "^8.53.0",
+    eslint: "^9.39.2",
+    tsup: "^8.3.0",
+    typescript: "^5.7.0",
+    vitest: "^2.1.0"
+  },
+  engines: {
+    node: ">=20.0.0"
+  },
+  keywords: [
+    "claude",
+    "ai",
+    "cli",
+    "background",
+    "async",
+    "anthropic",
+    "claude-code"
+  ],
+  author: "danimoya",
+  license: "Apache-2.0",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/danimoya/Claude-B.git"
+  },
+  homepage: "https://github.com/danimoya/Claude-B#readme",
+  bugs: {
+    url: "https://github.com/danimoya/Claude-B/issues"
+  }
+};
+
 // src/utils/version.ts
-var version = "0.1.0";
+var version = package_default.version;
 
 // src/cli/init.ts
 import { createInterface } from "readline";
@@ -397,6 +467,184 @@ async function runInit() {
   }
 }
 
+// src/tunnel/manager.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { writeFile as writeFile2, mkdir as mkdir2, unlink, readdir } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { createServer } from "net";
+var exec = promisify(execFile);
+var UNIT_PREFIX = "cb-tunnel-";
+var NAME_RE = /^[a-zA-Z][a-zA-Z0-9._-]{0,31}$/;
+function renderUnit(spec) {
+  return `[Unit]
+Description=Persistent SSH tunnel for Claude-B (local:${spec.localPort} -> ${spec.sshHost}:${spec.remotePort})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+Environment=AUTOSSH_GATETIME=0
+ExecStart=/usr/bin/autossh -M 0 -N -T \\
+  -o ServerAliveInterval=30 \\
+  -o ServerAliveCountMax=3 \\
+  -o ExitOnForwardFailure=yes \\
+  -o StrictHostKeyChecking=accept-new \\
+  -L ${spec.localPort}:127.0.0.1:${spec.remotePort} \\
+  ${spec.sshHost}
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=${spec.system ? "multi-user.target" : "default.target"}
+`;
+}
+function unitName(name) {
+  return `${UNIT_PREFIX}${name}.service`;
+}
+function unitPath(name, system) {
+  if (system) return `/etc/systemd/system/${unitName(name)}`;
+  return join2(homedir2(), ".config", "systemd", "user", unitName(name));
+}
+async function pickLocalPort() {
+  for (let p = 13847; p < 13947; p++) {
+    const free = await new Promise((resolve) => {
+      const srv = createServer();
+      srv.once("error", () => resolve(false));
+      srv.once("listening", () => srv.close(() => resolve(true)));
+      srv.listen(p, "127.0.0.1");
+    });
+    if (free) return p;
+  }
+  throw new Error("no free port in 13847-13946 \u2014 pass --tunnel-local-port");
+}
+async function which(bin) {
+  try {
+    const { stdout } = await exec("which", [bin]);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function sshReachable(host) {
+  try {
+    await exec("ssh", [
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "ConnectTimeout=5",
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+      host,
+      "true"
+    ]);
+    return { ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: msg.split("\n")[0] };
+  }
+}
+async function systemctl(args, system) {
+  const cmd = system ? ["sudo", "systemctl", ...args] : ["systemctl", "--user", ...args];
+  const { stdout } = await exec(cmd[0], cmd.slice(1));
+  return stdout.trim();
+}
+async function resolveSpec(spec) {
+  if (!NAME_RE.test(spec.name)) {
+    throw new Error(
+      `invalid tunnel name "${spec.name}" \u2014 must match ${NAME_RE} (letters/digits/._- ; starts with letter; max 32 chars)`
+    );
+  }
+  if (!spec.sshHost) throw new Error("--tunnel-ssh-host is required with --install-tunnel");
+  const remotePort = spec.remotePort ?? 3847;
+  const localPort = spec.localPort ?? await pickLocalPort();
+  return {
+    name: spec.name,
+    sshHost: spec.sshHost,
+    localPort,
+    remotePort,
+    system: spec.system ?? false
+  };
+}
+async function install(spec) {
+  const resolved = await resolveSpec(spec);
+  const autossh = await which("autossh");
+  if (!autossh) {
+    throw new Error("autossh is not installed \u2014 install with `dnf install autossh` (RHEL) or `apt install autossh` (Debian)");
+  }
+  const reach = await sshReachable(resolved.sshHost);
+  if (!reach.ok) {
+    throw new Error(
+      `ssh to "${resolved.sshHost}" failed in batch mode (${reach.reason}). autossh needs unattended key auth \u2014 check your ssh config / agent before installing.`
+    );
+  }
+  const path = unitPath(resolved.name, resolved.system);
+  if (existsSync2(path)) {
+    throw new Error(`unit already exists at ${path} \u2014 run \`cb --remove-tunnel ${resolved.name}\` first`);
+  }
+  await mkdir2(join2(path, ".."), { recursive: true });
+  await writeFile2(path, renderUnit(resolved), { mode: 420 });
+  await systemctl(["daemon-reload"], resolved.system);
+  await systemctl(["enable", "--now", unitName(resolved.name)], resolved.system);
+  await new Promise((r) => setTimeout(r, 3e3));
+  let active = false;
+  try {
+    const state = await systemctl(["is-active", unitName(resolved.name)], resolved.system);
+    active = state === "active";
+  } catch {
+    active = false;
+  }
+  return { unitPath: path, spec: resolved, active };
+}
+async function remove(name, system) {
+  if (!NAME_RE.test(name)) throw new Error(`invalid tunnel name "${name}"`);
+  const path = unitPath(name, system);
+  if (!existsSync2(path)) {
+    const otherPath = unitPath(name, !system);
+    if (existsSync2(otherPath)) {
+      throw new Error(`tunnel "${name}" is installed in the ${system ? "user" : "system"} scope, not ${system ? "system" : "user"}. Re-run with${system ? "out" : ""} --tunnel-system.`);
+    }
+    return { removed: false, unitPath: path };
+  }
+  try {
+    await systemctl(["disable", "--now", unitName(name)], system);
+  } catch {
+  }
+  await unlink(path);
+  await systemctl(["daemon-reload"], system).catch(() => void 0);
+  return { removed: true, unitPath: path };
+}
+async function list() {
+  const out = [];
+  const dirs = [
+    { dir: join2(homedir2(), ".config", "systemd", "user"), scope: "user" },
+    { dir: "/etc/systemd/system", scope: "system" }
+  ];
+  for (const { dir, scope } of dirs) {
+    let names = [];
+    try {
+      names = await readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const file of names) {
+      if (!file.startsWith(UNIT_PREFIX) || !file.endsWith(".service")) continue;
+      const name = file.slice(UNIT_PREFIX.length, -".service".length);
+      let active = false;
+      try {
+        const state = await systemctl(["is-active", file], scope === "system");
+        active = state === "active";
+      } catch {
+        active = false;
+      }
+      out.push({ name, unitPath: join2(dir, file), scope, active });
+    }
+  }
+  return out;
+}
+
 // src/cli/index.ts
 loadEnv();
 var program = new Command();
@@ -410,7 +658,48 @@ program.command("init").description("Interactive setup: writes ~/.claude-b/.env,
     process.exit(1);
   }
 });
-program.argument("[prompt...]", "Prompt to send to Claude").option("-l, --last", "Show status and output of last prompt").option("-s, --sess", "List all sessions").option("-a, --attach <id>", "Attach to session (foreground mode)").option("-d, --detach", "Detach from current session").option("-n, --new [name]", "Create new session").option("-m, --model <model>", "Claude model to use").option("-k, --kill <id>", "Kill/terminate session").option("-w, --watch", "Watch live output (tail -f style)").option("-x, --select <id>", "Select session for subsequent commands").option("-c, --current", "Show current selected session").option("-r, --rest [port]", "Start REST API server").option("--rest-stop", "Stop REST API server").option("--status", "Daemon status and health").option("--logs", "View daemon logs").option("--hook <event> <cmd>", "Register shell hook for event").option("--hook-session <id>", "Only trigger hook for this session (use with --hook)").option("--unhook <id>", "Remove a shell hook").option("--hooks", "List all shell hooks").option("--webhook <url>", "Register webhook for notifications").option("--webhook-event <event>", "Event type for webhook (default: *)").option("--webhook-session <id>", "Only trigger webhook for this session (use with --webhook)").option("--unwebhook <id>", "Remove a webhook").option("--webhooks", "List all webhooks").option("--hook-stats", "Show hook statistics").option("--api-key", "Generate/show API key for REST access").option("--config", "Edit configuration").option("--export <id>", "Export session transcript").option("--import <file>", "Import session from file").option("--remote-add <url>", "Add a remote Claude-B host").option("--remote-key <apiKey>", "API key for remote host (use with --remote-add)").option("--remote-name <name>", "Name for remote host (use with --remote-add)").option("--remote-priority <n>", "Priority for remote host (use with --remote-add)").option("--remote-remove <id>", "Remove a remote host").option("--remote-toggle <id>", "Toggle remote host enabled/disabled").option("--remote-hosts", "List all remote hosts").option("--remote-health", "Show health status of remote hosts").option("--remote-stats", "Show orchestration statistics").option("--remote <hostId>", "Send prompt to specific remote host").option("-f, --fire", "Fire and forget (launch task in background, no watching)").option("-g, --goal <description>", "Goal/objective for fire-and-forget task (use with -f)").option("-i, --inbox", "Show notification inbox (completed tasks)").option("--inbox-clear", "Mark all notifications as read").option("--inbox-count", "Show unread notification count").option("--remote-fire <hostId>", "Fire and forget to remote host").option("--telegram <token>", "Set up Telegram bot with token").option("--telegram-stop", "Disable Telegram notifications").option("--telegram-status", "Show Telegram bot status").option("--telegram-forward <on|off>", "Toggle forwarding all session completions to Telegram").option("--voice-setup <provider>", "Configure STT provider: speechmatics, deepgram, or openai").option("--ai-provider <config>", 'Set AI provider: "anthropic <key>" or "openrouter <key>"').option("--voice-status", "Show voice pipeline status").option("--shell-init", "Output shell hook for inbox notifications (add to .bashrc/.zshrc)").action(async (promptParts, options) => {
+program.argument("[prompt...]", "Prompt to send to Claude").option("-l, --last", "Show status and output of last prompt").option("-s, --sess", "List all sessions").option("-a, --attach <id>", "Attach to session (foreground mode)").option("-d, --detach", "Detach from current session").option("-n, --new [name]", "Create new session").option("-m, --model <model>", "Claude model to use").option("-k, --kill <id>", "Kill/terminate session").option("-w, --watch", "Watch live output (tail -f style)").option("-x, --select <id>", "Select session for subsequent commands").option("-c, --current", "Show current selected session").option("-r, --rest [port]", "Start REST API server").option("--rest-stop", "Stop REST API server").option("--status", "Daemon status and health").option("--logs", "View daemon logs").option("--hook <event> <cmd>", "Register shell hook for event").option("--hook-session <id>", "Only trigger hook for this session (use with --hook)").option("--unhook <id>", "Remove a shell hook").option("--hooks", "List all shell hooks").option("--webhook <url>", "Register webhook for notifications").option("--webhook-event <event>", "Event type for webhook (default: *)").option("--webhook-session <id>", "Only trigger webhook for this session (use with --webhook)").option("--unwebhook <id>", "Remove a webhook").option("--webhooks", "List all webhooks").option("--hook-stats", "Show hook statistics").option("--api-key", "Generate/show API key for REST access").option("--config", "Edit configuration").option("--export <id>", "Export session transcript").option("--import <file>", "Import session from file").option("--remote-add <url>", "Add a remote Claude-B host").option("--remote-key <apiKey>", "API key for remote host (use with --remote-add)").option("--remote-name <name>", "Name for remote host (use with --remote-add)").option("--remote-priority <n>", "Priority for remote host (use with --remote-add)").option("--remote-remove <id>", "Remove a remote host").option("--remote-toggle <id>", "Toggle remote host enabled/disabled").option("--remote-hosts", "List all remote hosts").option("--remote-health", "Show health status of remote hosts").option("--remote-stats", "Show orchestration statistics").option("--remote <hostId>", "Send prompt to specific remote host").option("-f, --fire", "Fire and forget (launch task in background, no watching)").option("-g, --goal <description>", "Goal/objective for fire-and-forget task (use with -f)").option("-i, --inbox", "Show notification inbox (completed tasks)").option("--inbox-clear", "Mark all notifications as read").option("--inbox-count", "Show unread notification count").option("--remote-fire <hostId>", "Fire and forget to remote host").option("--install-tunnel <name>", "Install a persistent SSH tunnel (autossh + systemd) so --remote-fire can reach a remote daemon").option("--tunnel-ssh-host <host>", "SSH host alias to tunnel to (required with --install-tunnel)").option("--tunnel-local-port <port>", "Local TCP port to bind (default: auto-pick 13847+)").option("--tunnel-remote-port <port>", "Remote port on the target host (default: 3847)").option("--tunnel-system", "Install at /etc/systemd/system instead of user scope (requires sudo)").option("--remove-tunnel <name>", "Remove an installed tunnel and its systemd unit").option("--list-tunnels", "List installed tunnels (user and system scope)").option("--telegram <token>", "Set up Telegram bot with token").option("--telegram-stop", "Disable Telegram notifications").option("--telegram-status", "Show Telegram bot status").option("--telegram-forward <on|off>", "Toggle forwarding all session completions to Telegram").option("--voice-setup <provider>", "Configure STT provider: speechmatics, deepgram, or openai").option("--ai-provider <config>", 'Set AI provider: "anthropic <key>" or "openrouter <key>"').option("--voice-status", "Show voice pipeline status").option("--shell-init", "Output shell hook for inbox notifications (add to .bashrc/.zshrc)").addHelpText("after", `
+USE CASES \u2014 when to reach for which group of commands:
+
+  Local sessions (default)
+    cb "prompt"                       send a prompt; auto-creates a session
+    cb -s / -l / -w / -a <id>         list / last output / live tail / attach
+    cb -f -g "<goal>" "<prompt>"      fire-and-forget on this host
+
+  Cross-host orchestration  (talk to a Claude-B daemon on another machine)
+    cb --remote-add <url> --remote-key <k> --remote-name <name>
+                                      register a remote daemon
+    cb --remote-fire <name> "..."     fire-and-forget on the named host
+    cb --remote      <name> "..."     synchronous send to that host
+    cb --remote-hosts / --remote-health / --remote-stats
+                                      inspect orchestration state
+    cb -i                             read replies (notification inbox)
+
+  Cross-host plumbing  (only needed if --remote-fire can't reach the target)
+    cb --install-tunnel <name> --tunnel-ssh-host <ssh-alias>
+                                      installs an autossh systemd unit so
+                                      a local port forwards to the remote
+                                      daemon's 127.0.0.1:3847. Survives
+                                      reboots and network blips.
+    cb --remove-tunnel <name>         undoes it
+    cb --list-tunnels                 shows installed tunnels
+
+  The daemon binds 127.0.0.1:3847 only, so cross-host orchestration always
+  needs a TCP path. If both hosts share a private network and you can
+  reconfigure the daemon, bind it to that interface directly. If not (the
+  usual case), install a tunnel and point --remote-add at localhost:<port>.
+
+  Typical first-time setup, host A \u2192 host B:
+    1. cb --install-tunnel b --tunnel-ssh-host hostB
+    2. cb --remote-add http://localhost:13847 \\
+                       --remote-key "$(ssh hostB cat ~/.claude-b/api.key)" \\
+                       --remote-name b
+    3. cb --remote-fire b "hello from A"
+
+  Read in --help-as-documentation order: local \u2192 remote \u2192 tunnels.
+  --remote-fire is the verb you'll type day to day; --install-tunnel is a
+  one-time install on each pair of hosts.
+`).action(async (promptParts, options) => {
   if (options.shellInit) {
     printShellInit();
     return;
@@ -606,6 +895,27 @@ program.argument("[prompt...]", "Prompt to send to Claude").option("-l, --last",
       await showVoiceStatus(client);
       return;
     }
+    if (options.installTunnel) {
+      client.close();
+      await installTunnelCmd({
+        name: options.installTunnel,
+        sshHost: options.tunnelSshHost,
+        localPort: options.tunnelLocalPort ? Number(options.tunnelLocalPort) : void 0,
+        remotePort: options.tunnelRemotePort ? Number(options.tunnelRemotePort) : void 0,
+        system: Boolean(options.tunnelSystem)
+      });
+      return;
+    }
+    if (options.removeTunnel) {
+      client.close();
+      await removeTunnelCmd(options.removeTunnel, Boolean(options.tunnelSystem));
+      return;
+    }
+    if (options.listTunnels) {
+      client.close();
+      await listTunnelsCmd();
+      return;
+    }
     if (options.remoteFire) {
       if (promptParts.length === 0) {
         console.error(chalk2.red("Prompt required for remote fire-and-forget"));
@@ -839,8 +1149,8 @@ async function showStatus(client) {
   process.exit(0);
 }
 async function showLogs() {
-  const { homedir: homedir2 } = await import("os");
-  const logFile = `${homedir2()}/.claude-b/daemon.log`;
+  const { homedir: homedir3 } = await import("os");
+  const logFile = `${homedir3()}/.claude-b/daemon.log`;
   console.log(chalk2.gray(`Log file: ${logFile}`));
   console.log(chalk2.gray("(Log viewing implementation pending)"));
   process.exit(0);
@@ -894,10 +1204,10 @@ async function sendPrompt(client, prompt, model) {
 }
 async function startDaemon() {
   const { spawn } = await import("child_process");
-  const { homedir: homedir2 } = await import("os");
-  const { mkdir: mkdir2 } = await import("fs/promises");
-  const configDir = `${homedir2()}/.claude-b`;
-  await mkdir2(configDir, { recursive: true });
+  const { homedir: homedir3 } = await import("os");
+  const { mkdir: mkdir3 } = await import("fs/promises");
+  const configDir = `${homedir3()}/.claude-b`;
+  await mkdir3(configDir, { recursive: true });
   const daemon = spawn("node", ["dist/daemon/index.js"], {
     cwd: process.cwd(),
     detached: true,
@@ -1260,6 +1570,61 @@ async function fireRemotePrompt(client, hostId, prompt, goal) {
   console.log(`  ${chalk2.yellow("cb -i")}  ${chalk2.gray("# check when done")}`);
   process.exit(0);
 }
+async function installTunnelCmd(spec) {
+  try {
+    const result = await install(spec);
+    console.log(chalk2.green("Tunnel installed"));
+    console.log(`  Name:        ${chalk2.cyan(result.spec.name)}`);
+    console.log(`  Unit:        ${chalk2.gray(result.unitPath)}`);
+    console.log(`  Forward:     ${chalk2.cyan(`127.0.0.1:${result.spec.localPort}`)} \u2192 ${chalk2.cyan(`${result.spec.sshHost}:${result.spec.remotePort}`)}`);
+    console.log(`  Scope:       ${result.spec.system ? "system (sudo systemctl)" : "user (systemctl --user)"}`);
+    console.log(`  Active:      ${result.active ? chalk2.green("yes") : chalk2.yellow("not yet \u2014 check `systemctl status`")}`);
+    console.log("");
+    console.log(chalk2.gray("Next:"));
+    console.log(`  cb --remote-add http://localhost:${result.spec.localPort} \\`);
+    console.log(`     --remote-key "$(ssh ${result.spec.sshHost} cat ~/.claude-b/api.key)" \\`);
+    console.log(`     --remote-name ${result.spec.name}`);
+    console.log(`  cb --remote-fire ${result.spec.name} "your prompt"`);
+    process.exit(0);
+  } catch (err) {
+    console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function removeTunnelCmd(name, system) {
+  try {
+    const result = await remove(name, system);
+    if (result.removed) {
+      console.log(chalk2.green(`Tunnel removed: ${name}`));
+      console.log(chalk2.gray(`  ${result.unitPath}`));
+    } else {
+      console.log(chalk2.yellow(`No tunnel named "${name}" in ${system ? "system" : "user"} scope`));
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
+async function listTunnelsCmd() {
+  try {
+    const tunnels = await list();
+    if (tunnels.length === 0) {
+      console.log(chalk2.gray("No tunnels installed."));
+      console.log(chalk2.gray("Install one with: cb --install-tunnel <name> --tunnel-ssh-host <host>"));
+      process.exit(0);
+    }
+    console.log(chalk2.bold("Installed tunnels:"));
+    for (const t of tunnels) {
+      const status = t.active ? chalk2.green("active") : chalk2.red("inactive");
+      console.log(`  ${chalk2.cyan(t.name.padEnd(20))} ${status.padEnd(20)} ${chalk2.gray(`${t.scope}:`)} ${chalk2.gray(t.unitPath)}`);
+    }
+    process.exit(0);
+  } catch (err) {
+    console.error(chalk2.red(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
 function renderMarkdown(text) {
   const lines = text.split("\n");
   const result = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-b",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Background-capable Claude Code with async workflows and REST API",
   "type": "module",
   "main": "dist/cli/index.js",