claude-b 0.3.2 → 0.4.0

package/dist/daemon/index.js

@@ -24,11 +24,6 @@ import { nanoid } from "nanoid";
 import { EventEmitter } from "events";
 import { mkdir, writeFile, readFile, appendFile } from "fs/promises";
 import { existsSync } from "fs";
-var pty = null;
-try {
-  pty = await import("node-pty");
-} catch {
-}
 var Session = class _Session extends EventEmitter {
   id;
   name;
@@ -39,7 +34,6 @@ var Session = class _Session extends EventEmitter {
   fireAndForget = false;
   lastActivityAt;
   workingDir;
-  configDir;
   sessionDir;
   process = null;
   outputBuffer = [];
@@ -64,7 +58,6 @@ var Session = class _Session extends EventEmitter {
     this.status = state.status;
     this.createdAt = state.createdAt;
     this.workingDir = state.workingDir;
-    this.configDir = configDir;
     this.sessionDir = `${configDir}/sessions/${this.id}`;
     this.lastPromptId = state.lastPromptId;
     this.promptCount = state.promptCount || 0;
@@ -154,14 +147,6 @@ var Session = class _Session extends EventEmitter {
     const historyPath = `${this.sessionDir}/history.jsonl`;
     await appendFile(historyPath, JSON.stringify(entry) + "\n");
   }
-  waitForReady() {
-    if (this.isReady) {
-      return Promise.resolve();
-    }
-    return new Promise((resolve) => {
-      this.readyResolvers.push(resolve);
-    });
-  }
   markReady() {
     if (this.isReady) return;
     this.isReady = true;
@@ -170,47 +155,6 @@ var Session = class _Session extends EventEmitter {
     }
     this.readyResolvers = [];
   }
-  async startClaudeProcess() {
-    if (this.process) {
-      return;
-    }
-    await this.ensureSessionDir();
-    const claudePath = getClaudePath();
-    if (pty) {
-      this.process = pty.spawn(claudePath, ["--dangerously-skip-permissions"], {
-        name: "xterm-256color",
-        cols: 120,
-        rows: 40,
-        cwd: this.workingDir,
-        env: { ...process.env, TERM: "xterm-256color" }
-      });
-      this.process.onData((data) => {
-        this.handleOutput(data);
-      });
-      this.process.onExit(({ exitCode }) => {
-        this.handleProcessExit(exitCode);
-      });
-    } else {
-      const proc = spawn(claudePath, ["--print"], {
-        cwd: this.workingDir,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: { ...process.env }
-      });
-      this.process = proc;
-      proc.stdout?.on("data", (chunk) => {
-        this.handleOutput(chunk.toString());
-      });
-      proc.stderr?.on("data", (chunk) => {
-        this.handleOutput(chunk.toString());
-      });
-      proc.on("exit", (code) => {
-        this.handleProcessExit(code);
-      });
-      proc.on("error", (error) => {
-        this.handleProcessError(error);
-      });
-    }
-  }
   handleOutput(data) {
     this.outputBuffer.push(data);
     this.currentPromptOutput.push(data);
@@ -969,7 +913,7 @@ async function registerSessionRoutes(app, sessionManager) {
   });
   app.get("/api/sessions/current", {
     preHandler: [app.authenticate]
-  }, async (request, reply) => {
+  }, async (_request, reply) => {
     const session = sessionManager.current();
     if (!session) {
       return reply.status(404).send({
@@ -1131,7 +1075,7 @@ async function registerAuthRoutes(app, authManager) {
   });
   app.get("/api/auth/verify", {
     preHandler: [app.authenticate]
-  }, async (request, reply) => {
+  }, async (request, _reply) => {
     return {
       valid: true,
       user: request.user
@@ -1369,6 +1313,18 @@ async function registerNotificationRoutes(app, inbox) {
     const cleared = await inbox.markAllRead();
     return { success: true, cleared };
   });
+  app.post("/api/notifications/delete-all", {
+    preHandler: [app.authenticate]
+  }, async () => {
+    const deleted = await inbox.deleteAll();
+    return { success: true, deleted };
+  });
+  app.post("/api/notifications/delete-read", {
+    preHandler: [app.authenticate]
+  }, async () => {
+    const deleted = await inbox.deleteAll({ onlyRead: true });
+    return { success: true, deleted };
+  });
 }
 
 // src/rest/routes/telegram.ts
@@ -1847,7 +1803,7 @@ var PipelineExecutor = class extends EventEmitter3 {
       results = await Promise.race([
         Promise.all(promises),
         new Promise((resolve) => {
-          promises.forEach(async (p, i) => {
+          promises.forEach(async (p) => {
             const result = await p;
             if (result.status === "completed") {
               resolve([result]);
@@ -2017,12 +1973,10 @@ var HealthMonitor = class extends EventEmitter4 {
   isHealthy = true;
   consecutiveFailures = 0;
   consecutiveSuccesses = 0;
-  startTime;
   constructor(client, config) {
     super();
     this.client = client;
     this.config = { ...DEFAULT_CONFIG, ...config };
-    this.startTime = Date.now();
   }
   start() {
     if (this.intervalId) return;
@@ -2796,6 +2750,7 @@ var OrchestrationManager = class extends EventEmitter6 {
   }
 };
 function createHost(url, apiKey, options) {
+  const hc = options?.healthCheck;
   return {
     id: nanoid2(8),
     name: options?.name || new URL(url).hostname,
@@ -2804,7 +2759,11 @@ function createHost(url, apiKey, options) {
     apiKey,
     enabled: options?.enabled ?? true,
     priority: options?.priority ?? 1,
-    healthCheck: options?.healthCheck
+    healthCheck: hc ? {
+      interval: hc.interval ?? 3e4,
+      timeout: hc.timeout ?? 5e3,
+      unhealthyThreshold: hc.unhealthyThreshold ?? 3
+    } : void 0
   };
 }
 
@@ -3479,27 +3438,39 @@ var HookEngine = class extends EventEmitter7 {
 };
 
 // src/notifications/inbox.ts
-import { appendFile as appendFile2, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir6, unlink } from "fs/promises";
+import { appendFile as appendFile2, readFile as readFile6, writeFile as writeFile6, mkdir as mkdir6, unlink, rename } from "fs/promises";
 import { existsSync as existsSync6 } from "fs";
 import { nanoid as nanoid4 } from "nanoid";
 var NotificationInbox = class {
   configDir;
   inboxPath;
+  tmpPath;
+  /** Tail of the per-instance write chain. Each mutating op chains onto it. */
+  writeChain = Promise.resolve();
   constructor(configDir) {
     this.configDir = configDir;
     this.inboxPath = `${configDir}/notifications.jsonl`;
+    this.tmpPath = `${configDir}/notifications.jsonl.tmp`;
+  }
+  /** Run an async fn under the write mutex; resolves with its result. */
+  withLock(fn) {
+    const next = this.writeChain.then(fn, fn);
+    this.writeChain = next.catch(() => void 0);
+    return next;
   }
   async addNotification(input) {
-    await mkdir6(this.configDir, { recursive: true });
-    const notification = {
-      ...input,
-      id: nanoid4(8),
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      read: false
-    };
-    await appendFile2(this.inboxPath, JSON.stringify(notification) + "\n");
-    await this.writeMarker(notification);
-    return notification;
+    return this.withLock(async () => {
+      await mkdir6(this.configDir, { recursive: true });
+      const notification = {
+        ...input,
+        id: nanoid4(8),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        read: false
+      };
+      await appendFile2(this.inboxPath, JSON.stringify(notification) + "\n");
+      await this.writeMarker(notification);
+      return notification;
+    });
   }
   async writeMarker(notification) {
     try {
@@ -3521,31 +3492,63 @@ var NotificationInbox = class {
     return limit ? all.slice(-limit) : all;
   }
   async markAllRead() {
-    const all = await this.readAll();
-    const unreadCount = all.filter((n) => !n.read).length;
-    if (unreadCount === 0) return 0;
-    const marked = all.map((n) => ({ ...n, read: true }));
-    await this.writeAll(marked);
-    await this.clearMarker();
-    return unreadCount;
+    return this.withLock(async () => {
+      const all = await this.readAll();
+      const unreadCount = all.filter((n) => !n.read).length;
+      if (unreadCount === 0) return 0;
+      const marked = all.map((n) => ({ ...n, read: true }));
+      await this.writeAll(marked);
+      await this.clearMarker();
+      return unreadCount;
+    });
   }
   async markRead(id) {
-    const all = await this.readAll();
-    const notification = all.find((n) => n.id === id);
-    if (!notification || notification.read) return false;
-    notification.read = true;
-    await this.writeAll(all);
-    if (!all.some((n) => !n.read)) {
-      await this.clearMarker();
-    }
-    return true;
+    return this.withLock(async () => {
+      const all = await this.readAll();
+      const notification = all.find((n) => n.id === id);
+      if (!notification || notification.read) return false;
+      notification.read = true;
+      await this.writeAll(all);
+      if (!all.some((n) => !n.read)) {
+        await this.clearMarker();
+      }
+      return true;
+    });
   }
   async deleteNotification(id) {
-    const all = await this.readAll();
-    const filtered = all.filter((n) => n.id !== id);
-    if (filtered.length === all.length) return false;
-    await this.writeAll(filtered);
-    return true;
+    return this.withLock(async () => {
+      const all = await this.readAll();
+      const filtered = all.filter((n) => n.id !== id);
+      if (filtered.length === all.length) return false;
+      await this.writeAll(filtered);
+      return true;
+    });
+  }
+  /**
+   * Delete every notification (or every read notification when
+   * `onlyRead === true`) in a single atomic rewrite — far safer than
+   * fanning out N independent DELETE calls from a remote client, each of
+   * which would race the others through the read-modify-write cycle.
+   */
+  async deleteAll(opts = {}) {
+    return this.withLock(async () => {
+      const all = await this.readAll();
+      let kept;
+      let removed;
+      if (opts.onlyRead) {
+        kept = all.filter((n) => !n.read);
+        removed = all.length - kept.length;
+      } else {
+        kept = [];
+        removed = all.length;
+      }
+      if (removed === 0) return 0;
+      await this.writeAll(kept);
+      if (kept.every((n) => n.read)) {
+        await this.clearMarker();
+      }
+      return removed;
+    });
   }
   async count() {
     const all = await this.readAll();
@@ -3560,25 +3563,67 @@ var NotificationInbox = class {
     } catch {
     }
   }
+  /**
+   * Robust JSONL reader. Skips unparseable lines instead of blackholing
+   * the entire inbox if any single line has been corrupted (e.g., by a
+   * crashed writer that didn't finish flushing). The skipped lines stay
+   * on disk — a later writeAll() rewrites the file from `kept`, dropping
+   * them naturally.
+   */
   async readAll() {
     if (!existsSync6(this.inboxPath)) return [];
+    let content;
     try {
-      const content = await readFile6(this.inboxPath, "utf-8");
-      return content.trim().split("\n").filter(Boolean).map((line) => JSON.parse(line));
-    } catch {
+      content = await readFile6(this.inboxPath, "utf-8");
+    } catch (err) {
+      console.error("[inbox] failed to read notifications.jsonl:", err.message);
       return [];
     }
+    const lines = content.split("\n").filter(Boolean);
+    const out = [];
+    let badLines = 0;
+    for (const line of lines) {
+      try {
+        out.push(JSON.parse(line));
+      } catch {
+        badLines++;
+      }
+    }
+    if (badLines > 0) {
+      console.error(
+        `[inbox] skipped ${badLines} malformed line(s) in notifications.jsonl (of ${lines.length} total). They will be dropped on next rewrite.`
+      );
+    }
+    return out;
   }
+  /**
+   * Atomic rewrite: stage to `<file>.tmp`, then rename over the
+   * destination. The rename is guaranteed atomic on POSIX, so a reader
+   * sees either the pre-write file or the post-write file — never a
+   * partial / truncated state.
+   */
   async writeAll(notifications) {
     await mkdir6(this.configDir, { recursive: true });
-    const content = notifications.map((n) => JSON.stringify(n)).join("\n") + "\n";
-    await writeFile6(this.inboxPath, content);
+    const content = notifications.length === 0 ? "" : notifications.map((n) => JSON.stringify(n)).join("\n") + "\n";
+    await writeFile6(this.tmpPath, content);
+    await rename(this.tmpPath, this.inboxPath);
   }
 };
 
 // src/telegram/bot.ts
 import TelegramBot from "node-telegram-bot-api";
 import { EventEmitter as EventEmitter8 } from "events";
+
+// src/telegram/allow-list.ts
+function isChatAllowed(chatId, allowedRaw) {
+  const raw = allowedRaw?.trim();
+  if (!raw) return true;
+  const allowed = raw.split(",").map((s) => s.trim()).filter(Boolean);
+  if (allowed.length === 0) return true;
+  return allowed.includes(chatId);
+}
+
+// src/telegram/bot.ts
 function markdownToTelegramHtml(md) {
   const codeBlocks = [];
   let html = md.replace(/```[\w]*\n?([\s\S]*?)```/g, (_m, code) => {
@@ -3785,6 +3830,10 @@ var ClaudeBTelegramBot = class extends EventEmitter8 {
   }
   async handleStart(msg) {
     const chatId = String(msg.chat.id);
+    if (!isChatAllowed(chatId, process.env.TELEGRAM_ALLOWED_CHAT_IDS)) {
+      await this.safeSend(chatId, "\u26D4 This bot is private. Your chat is not authorised.");
+      return;
+    }
     await this.configManager.addChatId(chatId);
     const voiceStatus = this.voicePipeline ? "\u{1F3A4} Voice input: Active" : "\u{1F3A4} Voice input: Not configured";
     const text = [
@@ -4390,7 +4439,7 @@ function createSTTTTSProvider(config, tempDir) {
     case "deepgram":
       return new DeepgramProvider(config.apiKey);
     case "openai":
-      return new OpenAIProvider(config.apiKey, tempDir, config.ttsModel, config.ttsVoice);
+      return new OpenAIProvider(config.apiKey, config.ttsModel, config.ttsVoice);
     default:
       throw new Error(`Unknown STT provider: ${config.provider}`);
   }
@@ -4488,12 +4537,10 @@ var DeepgramProvider = class {
 };
 var OpenAIProvider = class {
   apiKey;
-  tempDir;
   ttsModel;
   ttsVoice;
-  constructor(apiKey, tempDir, ttsModel, ttsVoice) {
+  constructor(apiKey, ttsModel, ttsVoice) {
     this.apiKey = apiKey;
-    this.tempDir = tempDir;
     this.ttsModel = ttsModel || "gpt-4o-mini-tts";
     this.ttsVoice = ttsVoice || "alloy";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-b",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Background-capable Claude Code with async workflows and REST API",
   "type": "module",
   "main": "dist/cli/index.js",
@@ -56,7 +56,7 @@
     "claude-code"
   ],
   "author": "danimoya",
-  "license": "AGPL-3.0",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/danimoya/Claude-B.git"

package/scripts/install.sh

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 # Claude-B installer
 # Usage:
-#   curl -fsSL https://cb.danielmoya.cv | bash
-#   curl -fsSL https://cb.danielmoya.cv | bash -s -- --method npm
+#   curl -fsSL https://cb.danimoya.com | bash
+#   curl -fsSL https://cb.danimoya.com | bash -s -- --method npm
 #
 # Methods (auto-detected, override with --method):
 #   npm     — requires node >= 20

package/website/DOCKERHUB.md

@@ -0,0 +1,138 @@
+# Claude-B
+
+> Background-capable [Claude Code](https://claude.ai/code) — async AI workflows, a Telegram bot,
+> a REST API, and multi-host orchestration in a single container.
+
+## Why
+
+- **Fire-and-forget tasks.** Kick off long Claude Code jobs and keep working. Results wait in an
+  inbox until you're ready.
+- **Telegram remote control.** Get notified when a session finishes. Reply by text or voice note
+  from your phone — Whisper transcribes, Claude optimises, TTS plays the result back.
+- **REST API + WebSocket.** Programmatic access to every session. Build bots, dashboards, CI
+  integrations.
+- **Multi-host orchestration.** Distribute work across machines with health-aware routing and
+  automatic failover.
+- **Tmux bridge.** Live Claude Code panes post completion notifications to Telegram via a `Stop`
+  hook. No code changes to your existing workflow.
+- **Stateless on config, stateful on data.** One `.env` file configures everything. All session
+  state lives in a mounted volume.
+
+## The voice pipeline — the actual differentiator
+
+Other Telegram/WhatsApp AI integrations forward your voice note to one model and play the reply
+back. Claude-B chains **four specialised models** per voice-to-voice round-trip, and the middle
+step — prompt optimisation with fresh session context — turns *"um, can you uh, fix the thing
+we were just working on"* into an actionable prompt Claude Code can execute.
+
+![Voice pipeline](https://raw.githubusercontent.com/danimoya/Claude-B/main/assets/voice-pipeline.png)
+
+Every stage is provider-swappable. Default stack: Whisper → Claude Haiku 4.5 → your session's
+main model (Sonnet / Opus) → OpenAI `gpt-4o-mini-tts`. Confirm-before-execute is baked in, so
+a botched transcription never becomes a rogue `rm -rf`.
+
+## Quick start
+
+Pull the image and run — everything reads from `~/.claude-b/.env`, created by `cb init` on
+first run.
+
+```bash
+# 1. One-time interactive setup
+docker run --rm -it \
+  -v "$HOME/.claude-b:/root/.claude-b" \
+  danimoya/claude-b:latest cb init
+
+# 2. Run the daemon
+docker run -d \
+  --name claude-b \
+  --restart unless-stopped \
+  -v "$HOME/.claude-b:/root/.claude-b" \
+  -p 3847:3847 \
+  danimoya/claude-b:latest
+
+# 3. Use it from the container
+docker exec -it claude-b cb "summarise README.md"
+```
+
+`cb init` walks you through BotFather, auto-captures your Telegram chat id, and writes the `.env`
+file for you. You never copy tokens by hand.
+
+## docker-compose
+
+```yaml
+services:
+  claude-b:
+    image: danimoya/claude-b:latest
+    restart: unless-stopped
+    ports:
+      - "3847:3847"
+    volumes:
+      - claude-b-data:/root/.claude-b
+    environment:
+      ANTHROPIC_API_KEY: ${ANTHROPIC_API_KEY}
+      TELEGRAM_BOT_TOKEN: ${TELEGRAM_BOT_TOKEN}      # optional
+      OPENAI_API_KEY: ${OPENAI_API_KEY}              # optional — enables voice notes
+
+volumes:
+  claude-b-data:
+```
+
+```bash
+docker compose up -d
+docker compose exec claude-b cb init   # if you didn't set env vars above
+```
+
+## Configuration
+
+Precedence: `process env` > `/root/.claude-b/.env` > `./.env`.
+
+| Variable | Required | Purpose |
+|---|---|---|
+| `ANTHROPIC_API_KEY` | yes | Claude Code authentication |
+| `TELEGRAM_BOT_TOKEN` | no | Enable Telegram remote control |
+| `TELEGRAM_ALLOWED_CHAT_IDS` | no | Comma-separated list of allowed chat ids |
+| `OPENAI_API_KEY` | no | Whisper STT + TTS for voice notes |
+| `SPEECHMATICS_API_KEY` / `DEEPGRAM_API_KEY` | no | Alternative STT providers |
+| `CB_DATA_DIR` | no | Override `/root/.claude-b` (rarely needed in containers) |
+| `CB_REST_HOST` / `CB_REST_PORT` | no | REST API bind address (defaults `0.0.0.0:3847`) |
+| `CB_REST_API_KEY` | no | Pre-set REST API key (auto-generated otherwise) |
+
+## Tags
+
+| Tag | Points at | Use for |
+|---|---|---|
+| `latest` | newest release | quick start, demos |
+| `0.3`, `0` | newest 0.3.x / 0.x | pin to a minor/major series |
+| `0.3.2`, `v0.3.2` | exact release | reproducible deploys |
+
+Images are multi-arch: `linux/amd64` and `linux/arm64` (runs on Raspberry Pi, Apple Silicon,
+Graviton).
+
+## Alternatives to Docker
+
+```bash
+# One-line install — auto-detects npm or docker
+curl -fsSL https://cb.danimoya.com | bash
+
+# npm (requires Node.js 20+)
+npm i -g claude-b && cb init
+
+# Build from source
+git clone https://github.com/danimoya/Claude-B.git
+cd Claude-B && pnpm install && pnpm build && pnpm link --global
+```
+
+## Links
+
+- **Source & docs:** https://github.com/danimoya/Claude-B
+- **Issues:** https://github.com/danimoya/Claude-B/issues
+- **GHCR mirror:** `ghcr.io/danimoya/claude-b`
+- **License:** Apache-2.0
+
+## Topics
+
+AI agents · Anthropic Claude · Claude Code · coding assistant · AI automation ·
+background jobs · async workflows · Telegram bot · voice assistant · Whisper STT ·
+OpenAI TTS · REST API · WebSocket · CLI tool · developer tools · DevOps · tmux ·
+multi-host orchestration · self-hosted · Node.js · TypeScript
+

package/website/deploy.sh

@@ -1,5 +1,5 @@
 #!/usr/bin/env bash
-# Deploy the claude-b.danielmoya.cv / cb.danielmoya.cv landing container.
+# Deploy the claude-b.danimoya.com / cb.danimoya.com landing container.
 #
 # Prerequisites:
 #   - Docker daemon reachable
@@ -7,7 +7,7 @@
 #   - NPM credentials exported:
 #       NPM_USER=daniel.moya@...
 #       NPM_PASSWORD=...
-#   - A record for claude-b.danielmoya.cv + cb.danielmoya.cv pointing at the server IP
+#   - A record for claude-b.danimoya.com + cb.danimoya.com pointing at the server IP
 #
 # Usage:
 #   cd website && ./deploy.sh
@@ -21,7 +21,7 @@ cp ../scripts/install.sh install.sh
 IMAGE="claude-b-landing:latest"
 CONTAINER="claude-b-landing"
 NETWORK="management-network"
-DOMAINS='["claude-b.danielmoya.cv","cb.danielmoya.cv"]'
+DOMAINS='["claude-b.danimoya.com","cb.danimoya.com"]'
 
 echo "==> Building $IMAGE"
 docker build -t "$IMAGE" .
@@ -51,7 +51,7 @@ HOST_ID=$(curl -fsS "http://localhost:81/api/nginx/proxy-hosts" \
 import json, sys
 hosts = json.load(sys.stdin)
 for h in hosts:
-    if 'cb.danielmoya.cv' in h['domain_names'] or 'claude-b.danielmoya.cv' in h['domain_names']:
+    if 'cb.danimoya.com' in h['domain_names'] or 'claude-b.danimoya.com' in h['domain_names']:
         print(h['id']); break
 ")
 
@@ -91,7 +91,7 @@ echo "==> Requesting Let's Encrypt cert"
 CERT_ID=$(curl -fsS -X POST "http://localhost:81/api/nginx/certificates" \
   -H "Authorization: Bearer $TOKEN" \
   -H "Content-Type: application/json" \
-  -d "{\"provider\":\"letsencrypt\",\"nice_name\":\"cb.danielmoya.cv\",\"domain_names\":$DOMAINS,\"meta\":{\"dns_challenge\":false}}" \
+  -d "{\"provider\":\"letsencrypt\",\"nice_name\":\"cb.danimoya.com\",\"domain_names\":$DOMAINS,\"meta\":{\"dns_challenge\":false}}" \
   | python3 -c 'import json,sys; print(json.load(sys.stdin)["id"])' 2>/dev/null || echo "")
 
 if [ -n "$CERT_ID" ]; then
@@ -109,4 +109,4 @@ fi
 
 echo
 echo "✓ Deployed. Test with:"
-echo "    curl -fsSL https://cb.danielmoya.cv | head"
+echo "    curl -fsSL https://cb.danimoya.com | head"