claude-b 0.3.2

package/bin/cb

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import('../dist/cli/index.js');

package/bin/cb-notify.sh

@@ -0,0 +1,156 @@
+#!/usr/bin/env bash
+# Claude Code Stop hook → Claude-B /api/notify → Telegram
+#
+# Fires every time a top-level Claude Code response finishes in any tmux pane.
+# Extracts the last assistant text from the session transcript, tags it with
+# the tmux target (session:window.pane) + pane title (Claude's slug), and
+# POSTs the payload to Claude-B's REST API. Claude-B forwards it to Telegram
+# via the existing bot.broadcastNotification path.
+#
+# Design rules:
+#  - NEVER fail the host Claude session. Always exit 0 on any error.
+#  - Skip silently if not running inside tmux.
+#  - Skip silently if Claude-B daemon / REST / API key is unavailable.
+#
+# Installed as: ~/.claude/settings.json hooks.Stop → this script
+#   "hooks": { "Stop": [{ "hooks": [{ "type": "command",
+#     "command": "$HOME/Claude-B/bin/cb-notify.sh" }] }] }
+
+set +e  # tolerate errors — we never want to break the host session
+
+CB_URL="${CB_NOTIFY_URL:-http://127.0.0.1:3847/api/notify}"
+CB_KEY_FILE="${CB_API_KEY_FILE:-$HOME/.claude-b/api.key}"
+MAX_RESULT_CHARS=3000
+LOG_FILE="${CB_NOTIFY_LOG:-$HOME/.claude-b/cb-notify.log}"
+
+# ─── Read Claude Code hook payload from stdin ───────────────────────────────
+payload=$(cat)
+[[ -z "$payload" ]] && exit 0
+
+transcript_path=$(jq -r '.transcript_path // empty' <<<"$payload" 2>/dev/null)
+claude_session_id=$(jq -r '.session_id // empty' <<<"$payload" 2>/dev/null)
+hook_cwd=$(jq -r '.cwd // empty' <<<"$payload" 2>/dev/null)
+
+# ─── We only notify for tmux-hosted sessions ────────────────────────────────
+# $TMUX is set by tmux itself for any process running inside a pane.
+if [[ -z "${TMUX:-}" ]]; then
+  exit 0
+fi
+
+# ─── Derive the tmux target + human label ───────────────────────────────────
+# Prefer $TMUX_PANE (the unique pane id like %42) for lookup, then ask tmux
+# for the stable session:window.pane target and the pane title.
+pane_ref="${TMUX_PANE:-}"
+if [[ -n "$pane_ref" ]]; then
+  tmux_target=$(tmux display-message -p -t "$pane_ref" '#S:#I.#P' 2>/dev/null)
+  pane_title=$(tmux display-message -p -t "$pane_ref" '#T' 2>/dev/null)
+else
+  tmux_target=$(tmux display-message -p '#S:#I.#P' 2>/dev/null)
+  pane_title=$(tmux display-message -p '#T' 2>/dev/null)
+fi
+
+if [[ -z "$tmux_target" ]]; then
+  exit 0
+fi
+
+session_label="$tmux_target"
+if [[ -n "$pane_title" ]]; then
+  session_label="${tmux_target} ${pane_title}"
+fi
+
+# ─── Extract last assistant text from the transcript ────────────────────────
+# Transcript is JSONL where each line is a typed record. We want the most
+# recent assistant message that has at least one text content block. Some
+# assistant turns end with tool_use blocks only (e.g. a final Edit/Bash
+# without commentary); those are skipped backwards until a text-bearing
+# message is found.
+#
+# Small delay: the Stop hook fires right after the response completes but
+# the transcript file may still have unflushed data in kernel/process
+# buffers. Without this, grep can miss the final lines and return an
+# intermediate assistant message instead of the actual summary.
+sleep 0.5
+
+last_assistant=""
+if [[ -n "$transcript_path" && -f "$transcript_path" ]]; then
+  last_assistant=$(
+    grep '"type":"assistant"' "$transcript_path" 2>/dev/null \
+      | tac \
+      | while IFS= read -r line; do
+          text=$(jq -r '
+            .message.content // []
+            | map(select(.type=="text"))
+            | map(.text)
+            | join("\n")
+          ' <<<"$line" 2>/dev/null)
+          if [[ -n "$text" ]]; then
+            echo "$text"
+            break
+          fi
+        done
+  )
+fi
+
+# Grab the most recent turn_duration record if present (Claude writes one
+# system:turn_duration line after each completed assistant turn).
+duration_ms=""
+if [[ -n "$transcript_path" && -f "$transcript_path" ]]; then
+  duration_ms=$(
+    grep '"subtype":"turn_duration"' "$transcript_path" 2>/dev/null \
+      | tail -1 \
+      | jq -r '.durationMs // empty' 2>/dev/null
+  )
+fi
+
+# Fallback body if no assistant message had text at all
+if [[ -z "$last_assistant" ]]; then
+  last_assistant="(session completed — no assistant text in transcript)"
+fi
+
+# Truncate for the mobile display
+if [[ ${#last_assistant} -gt $MAX_RESULT_CHARS ]]; then
+  last_assistant="${last_assistant:0:$MAX_RESULT_CHARS}…"
+fi
+
+# ─── Look up API key and POST to /api/notify ────────────────────────────────
+if [[ ! -r "$CB_KEY_FILE" ]]; then
+  exit 0
+fi
+api_key=$(<"$CB_KEY_FILE")
+[[ -z "$api_key" ]] && exit 0
+
+# Build JSON body safely via jq (handles quoting + newlines).
+# transcriptPath is cached by the daemon so the Telegram voice pipeline can
+# later ground optimizePrompt in real session history.
+body=$(jq -n \
+  --arg sessionId "tmux:${tmux_target}" \
+  --arg sessionName "$session_label" \
+  --arg goal "$hook_cwd" \
+  --arg result "$last_assistant" \
+  --arg duration "$duration_ms" \
+  --arg transcriptPath "$transcript_path" \
+  '{
+    sessionId: $sessionId,
+    sessionName: $sessionName,
+    type: "prompt.completed",
+    goal: $goal,
+    exitCode: 0,
+    resultPreview: $result
+  }
+  + (if $duration != "" then { durationMs: ($duration | tonumber) } else {} end)
+  + (if $transcriptPath != "" then { transcriptPath: $transcriptPath } else {} end)')
+
+# Fire and forget — short timeout, discard output. Log to a rolling file so
+# the user can debug without cluttering their terminal.
+{
+  echo "[$(date -Iseconds)] → $tmux_target (${#last_assistant} chars)"
+  curl -sS -m 5 -X POST "$CB_URL" \
+    -H 'Content-Type: application/json' \
+    -H "X-Claude-B-Key: ${api_key}" \
+    --data-binary "$body" 2>&1
+  echo
+} >>"$LOG_FILE" 2>&1 &
+
+# Detach background curl so we exit immediately — never block host session.
+disown 2>/dev/null || true
+exit 0

package/dist/chunk-6D3ICY25.js

@@ -0,0 +1,303 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/config/env.ts
+import { homedir } from "os";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function parseEnvFile(path) {
+  const out = {};
+  const raw = readFileSync(path, "utf-8");
+  for (const rawLine of raw.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq === -1) continue;
+    const key = line.slice(0, eq).trim();
+    if (!/^[A-Z_][A-Z0-9_]*$/i.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    out[key] = value;
+  }
+  return out;
+}
+function loadEnv() {
+  const dataDir = process.env.CB_DATA_DIR || join(homedir(), ".claude-b");
+  const sources = [
+    join(dataDir, ".env"),
+    join(process.cwd(), ".env")
+  ];
+  for (const path of sources) {
+    if (!existsSync(path)) continue;
+    try {
+      const parsed = parseEnvFile(path);
+      for (const [key, value] of Object.entries(parsed)) {
+        if (process.env[key] === void 0) {
+          process.env[key] = value;
+        }
+      }
+    } catch {
+    }
+  }
+  if (process.env.CB_REST_HOST === void 0 && process.env.REST_HOST) {
+    process.env.CB_REST_HOST = process.env.REST_HOST;
+  }
+  if (process.env.CB_REST_PORT === void 0 && process.env.REST_PORT) {
+    process.env.CB_REST_PORT = process.env.REST_PORT;
+  }
+}
+function getDataDir() {
+  return process.env.CB_DATA_DIR || join(homedir(), ".claude-b");
+}
+function envTemplate() {
+  return `# Claude-B configuration
+# Precedence: process env > ~/.claude-b/.env > ./.env
+# Uncomment and fill the vars you need.
+
+# --- Required for Claude Code ---
+# ANTHROPIC_API_KEY=sk-ant-...
+
+# --- Optional: voice pipeline (Telegram voice notes) ---
+# OPENAI_API_KEY=sk-...
+# SPEECHMATICS_API_KEY=
+# DEEPGRAM_API_KEY=
+
+# --- Optional: Telegram integration ---
+# TELEGRAM_BOT_TOKEN=123456:ABC...
+# TELEGRAM_ALLOWED_CHAT_IDS=123456789,987654321
+
+# --- Optional: Claude-B infrastructure ---
+# CB_DATA_DIR=~/.claude-b
+# CB_REST_HOST=127.0.0.1
+# CB_REST_PORT=3847
+# CB_REST_API_KEY=
+`;
+}
+
+// src/utils/claude-detector.ts
+import { existsSync as existsSync2 } from "fs";
+import { execSync } from "child_process";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var cachedInstallation = null;
+var CLAUDE_LOCATIONS = [
+  // Native installer (new)
+  { path: join2(homedir2(), ".claude", "bin", "claude"), type: "native" },
+  // npm global (common)
+  { path: join2(homedir2(), ".npm-global", "bin", "claude"), type: "npm-global" },
+  // Local bin
+  { path: join2(homedir2(), ".local", "bin", "claude"), type: "local" },
+  // Homebrew (macOS)
+  { path: "/opt/homebrew/bin/claude", type: "homebrew" },
+  { path: "/usr/local/bin/claude", type: "homebrew" },
+  // Linux system
+  { path: "/usr/bin/claude", type: "path" }
+];
+function detectClaude() {
+  if (cachedInstallation) {
+    return cachedInstallation;
+  }
+  const envPath = process.env.CLAUDE_PATH;
+  if (envPath && existsSync2(envPath)) {
+    cachedInstallation = { path: envPath, type: "env" };
+    cachedInstallation.version = getClaudeVersion(envPath);
+    return cachedInstallation;
+  }
+  try {
+    const whichResult = execSync("which claude 2>/dev/null", { encoding: "utf-8" }).trim();
+    if (whichResult && existsSync2(whichResult)) {
+      cachedInstallation = { path: whichResult, type: "path" };
+      cachedInstallation.version = getClaudeVersion(whichResult);
+      return cachedInstallation;
+    }
+  } catch {
+  }
+  for (const location of CLAUDE_LOCATIONS) {
+    if (existsSync2(location.path)) {
+      cachedInstallation = { path: location.path, type: location.type };
+      cachedInstallation.version = getClaudeVersion(location.path);
+      return cachedInstallation;
+    }
+  }
+  return null;
+}
+function getClaudeVersion(claudePath) {
+  try {
+    const result = execSync(`"${claudePath}" --version 2>/dev/null`, { encoding: "utf-8" });
+    const match = result.match(/(\d+\.\d+\.\d+)/);
+    return match ? match[1] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getClaudePath() {
+  const installation = detectClaude();
+  if (!installation) {
+    throw new Error(
+      "Claude Code not found. Please install it:\n  npm install -g @anthropic-ai/claude-code\nOr set CLAUDE_PATH environment variable to the claude executable path."
+    );
+  }
+  return installation.path;
+}
+
+// src/telegram/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+var DEFAULT_CONFIG = {
+  token: "",
+  enabled: false,
+  chatIds: [],
+  sessionMap: {},
+  pendingPrompts: {},
+  resultMap: {}
+};
+var TelegramConfigManager = class {
+  configPath;
+  configDir;
+  config = { ...DEFAULT_CONFIG };
+  constructor(configDir) {
+    this.configDir = configDir;
+    this.configPath = `${configDir}/telegram.json`;
+  }
+  async load() {
+    if (!existsSync3(this.configPath)) {
+      this.config = { ...DEFAULT_CONFIG };
+      return this.config;
+    }
+    try {
+      const content = await readFile(this.configPath, "utf-8");
+      this.config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+      if (this.config.speechmaticsApiKey && !this.config.sttProvider) {
+        this.config.sttProvider = { provider: "speechmatics", apiKey: this.config.speechmaticsApiKey };
+        await this.save();
+      }
+    } catch {
+      this.config = { ...DEFAULT_CONFIG };
+    }
+    return this.config;
+  }
+  async save() {
+    await mkdir(this.configDir, { recursive: true });
+    await writeFile(this.configPath, JSON.stringify(this.config, null, 2) + "\n");
+  }
+  get() {
+    return this.config;
+  }
+  shouldForwardSession() {
+    return this.config.forwardAllSessions ?? true;
+  }
+  async setForwardAllSessions(enabled) {
+    this.config.forwardAllSessions = enabled;
+    await this.save();
+  }
+  async setToken(token) {
+    this.config.token = token;
+    this.config.enabled = true;
+    await this.save();
+  }
+  async disable() {
+    this.config.enabled = false;
+    this.config.token = "";
+    this.config.chatIds = [];
+    this.config.sessionMap = {};
+    await this.save();
+  }
+  async addChatId(chatId) {
+    if (!this.config.chatIds.includes(chatId)) {
+      this.config.chatIds.push(chatId);
+      await this.save();
+    }
+  }
+  async mapMessage(telegramMessageId, claudeSessionId) {
+    this.config.sessionMap[telegramMessageId] = claudeSessionId;
+    const keys = Object.keys(this.config.sessionMap);
+    if (keys.length > 500) {
+      for (const key of keys.slice(0, keys.length - 500)) {
+        delete this.config.sessionMap[key];
+      }
+    }
+    await this.save();
+  }
+  getSessionForMessage(telegramMessageId) {
+    return this.config.sessionMap[telegramMessageId];
+  }
+  // Voice config
+  async setSTTProvider(config) {
+    this.config.sttProvider = config;
+    if (config.provider === "speechmatics") {
+      this.config.speechmaticsApiKey = config.apiKey;
+    }
+    await this.save();
+  }
+  /** @deprecated Use setSTTProvider instead */
+  async setSpeechmaticsKey(key) {
+    await this.setSTTProvider({ provider: "speechmatics", apiKey: key });
+  }
+  async setAIProvider(config) {
+    this.config.aiProvider = config;
+    await this.save();
+  }
+  // Pending prompts (awaiting user confirmation)
+  addPendingPrompt(messageId, pending) {
+    this.config.pendingPrompts[messageId] = pending;
+    const now = Date.now();
+    const entries = Object.entries(this.config.pendingPrompts);
+    for (const [key, val] of entries) {
+      if (now - val.timestamp > 10 * 60 * 1e3) {
+        delete this.config.pendingPrompts[key];
+      }
+    }
+    const keys = Object.keys(this.config.pendingPrompts);
+    if (keys.length > 50) {
+      for (const key of keys.slice(0, keys.length - 50)) {
+        delete this.config.pendingPrompts[key];
+      }
+    }
+  }
+  getPendingPrompt(messageId) {
+    const pending = this.config.pendingPrompts[messageId];
+    if (pending && Date.now() - pending.timestamp > 10 * 60 * 1e3) {
+      delete this.config.pendingPrompts[messageId];
+      return void 0;
+    }
+    return pending;
+  }
+  removePendingPrompt(messageId) {
+    delete this.config.pendingPrompts[messageId];
+  }
+  updatePendingPrompt(messageId, optimizedPrompt) {
+    const pending = this.config.pendingPrompts[messageId];
+    if (pending) {
+      pending.optimizedPrompt = optimizedPrompt;
+    }
+  }
+  // Result map (for TTS playback of notification results)
+  storeResult(messageId, resultText) {
+    this.config.resultMap[messageId] = resultText.slice(0, 5e3);
+    const keys = Object.keys(this.config.resultMap);
+    if (keys.length > 200) {
+      for (const key of keys.slice(0, keys.length - 200)) {
+        delete this.config.resultMap[key];
+      }
+    }
+  }
+  getResult(messageId) {
+    return this.config.resultMap[messageId];
+  }
+};
+
+export {
+  __require,
+  loadEnv,
+  getDataDir,
+  envTemplate,
+  detectClaude,
+  getClaudePath,
+  TelegramConfigManager
+};

package/dist/cli/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node