claude-b 0.4.3 → 0.5.1

package/dist/cli/index.js

@@ -160,7 +160,7 @@ var DaemonClient = class extends EventEmitter {
 // package.json
 var package_default = {
   name: "claude-b",
-  version: "0.4.3",
+  version: "0.5.1",
   description: "Background-capable Claude Code with async workflows and REST API",
   type: "module",
   main: "dist/cli/index.js",
@@ -467,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();
@@ -480,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;
@@ -676,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"));
@@ -909,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);
@@ -964,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,
@@ -1330,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/dist/daemon/index.js

@@ -3765,39 +3765,96 @@ var ClaudeBTelegramBot = class extends EventEmitter8 {
     const duration = notification.durationMs ? `${(notification.durationMs / 1e3).toFixed(1)}s` : "";
     const cost = notification.costUsd ? ` \xB7 $${notification.costUsd.toFixed(4)}` : "";
     const escHtml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    const lines = [];
-    lines.push(`${icon} <b>${escHtml(name)}</b> ${status}${duration ? ` (${duration}${cost})` : ""}`);
-    if (notification.goal) {
-      lines.push(`PWD: ${escHtml(notification.goal)}`);
-    }
-    if (notification.resultPreview) {
-      lines.push("");
-      lines.push(markdownToTelegramHtml(notification.resultPreview.slice(0, 3e3)));
+    const header = `${icon} <b>${escHtml(name)}</b> ${status}${duration ? ` (${duration}${cost})` : ""}`;
+    const pwdLine = notification.goal ? `PWD: ${escHtml(notification.goal)}` : "";
+    const footer = `Reply to follow up, or /select ${notification.sessionId.slice(0, 8)}`;
+    const RAW_CHUNK_BUDGET = 2800;
+    const HARD_LIMIT = 4096;
+    const rawBody = notification.resultPreview || "";
+    const rawChunks = [];
+    if (rawBody) {
+      const inLines = rawBody.split("\n");
+      let cur = "";
+      const flush = () => {
+        if (cur) {
+          rawChunks.push(cur);
+          cur = "";
+        }
+      };
+      for (const ln of inLines) {
+        let remaining = ln;
+        while (remaining.length > RAW_CHUNK_BUDGET) {
+          flush();
+          rawChunks.push(remaining.slice(0, RAW_CHUNK_BUDGET));
+          remaining = remaining.slice(RAW_CHUNK_BUDGET);
+        }
+        if (cur.length + remaining.length + 1 > RAW_CHUNK_BUDGET) flush();
+        cur += (cur ? "\n" : "") + remaining;
+      }
+      flush();
     }
-    lines.push("");
-    lines.push(`Reply to follow up, or /select ${notification.sessionId.slice(0, 8)}`);
-    const text = lines.join("\n");
-    try {
+    const total = Math.max(1, rawChunks.length);
+    const buildMessage = (idx) => {
+      const parts = [];
+      const tag = total > 1 ? ` (${idx + 1}/${total})` : "";
+      if (idx === 0) {
+        parts.push(`${header}${tag}`);
+        if (pwdLine) parts.push(pwdLine);
+        if (rawChunks[0]) {
+          parts.push("");
+          parts.push(markdownToTelegramHtml(rawChunks[0]));
+        }
+      } else {
+        parts.push(`\u{1F4C4} <b>${escHtml(name)}</b> continued${tag}`);
+        parts.push("");
+        parts.push(markdownToTelegramHtml(rawChunks[idx]));
+      }
+      if (idx === total - 1) {
+        parts.push("");
+        parts.push(footer);
+      }
+      let text = parts.join("\n");
+      if (text.length > HARD_LIMIT) {
+        text = text.slice(0, HARD_LIMIT - 24) + "\n\u2026 [truncated]";
+      }
+      return text;
+    };
+    const sendOne = async (text) => {
       const opts = { parse_mode: "HTML" };
-      let sent;
       try {
-        sent = await this.bot.sendMessage(chatId, text, opts);
+        return await this.bot.sendMessage(chatId, text, opts);
       } catch {
-        sent = await this.bot.sendMessage(chatId, lines.join("\n").replace(/<[^>]+>/g, ""));
+        let plain = text.replace(/<[^>]+>/g, "");
+        if (plain.length > HARD_LIMIT) plain = plain.slice(0, HARD_LIMIT - 24) + "\n\u2026 [truncated]";
+        try {
+          return await this.bot.sendMessage(chatId, plain);
+        } catch {
+          return void 0;
+        }
       }
-      await this.configManager.mapMessage(String(sent.message_id), notification.sessionId);
+    };
+    try {
+      const firstSent = await sendOne(buildMessage(0));
+      if (!firstSent) return void 0;
+      await this.configManager.mapMessage(String(firstSent.message_id), notification.sessionId);
       if (this.voicePipeline && notification.resultPreview) {
-        this.configManager.storeResult(String(sent.message_id), notification.resultPreview);
+        this.configManager.storeResult(String(firstSent.message_id), notification.resultPreview);
         try {
           await this.bot.editMessageReplyMarkup({
             inline_keyboard: [[
-              { text: "\u{1F50A} Listen", callback_data: `listen:${sent.message_id}` }
+              { text: "\u{1F50A} Listen", callback_data: `listen:${firstSent.message_id}` }
             ]]
-          }, { chat_id: chatId, message_id: sent.message_id });
+          }, { chat_id: chatId, message_id: firstSent.message_id });
         } catch {
         }
       }
-      return sent.message_id;
+      for (let i = 1; i < total; i++) {
+        const cont = await sendOne(buildMessage(i));
+        if (cont) {
+          await this.configManager.mapMessage(String(cont.message_id), notification.sessionId);
+        }
+      }
+      return firstSent.message_id;
     } catch (err) {
       this.emit("error", err);
       return void 0;

package/package.json

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