claude-threads 1.21.1 → 1.22.0

package/dist/mcp/mcp-server.js

@@ -51569,6 +51569,8 @@ class MessageManager {
   emitSessionUpdateCallback;
   toolStartTimes = new Map;
   taskTracker = new TaskTracker;
+  pendingBridgePlan = null;
+  pendingBridgeQuestion = null;
   flushTimer = null;
   static DEFAULT_FLUSH_DELAY_MS = 500;
   flushDelayMs;
@@ -52030,9 +52032,66 @@ class MessageManager {
     logger.debug("Reaction not handled by any executor");
     return false;
   }
+  handleBridgeRequest(request, signal) {
+    if (request.kind === "plan_approval") {
+      this.pendingBridgePlan?.resolve({ behavior: "deny", message: "Superseded by a newer plan" });
+      return new Promise((resolve2) => {
+        const pending = { resolve: resolve2, input: request.input };
+        this.pendingBridgePlan = pending;
+        signal?.addEventListener("abort", () => {
+          if (this.pendingBridgePlan === pending)
+            this.pendingBridgePlan = null;
+        });
+      });
+    }
+    if (request.kind === "question") {
+      this.pendingBridgeQuestion?.resolve({ behavior: "deny", message: "Superseded by newer questions" });
+      return new Promise((resolve2) => {
+        const pending = { resolve: resolve2, input: request.input };
+        this.pendingBridgeQuestion = pending;
+        signal?.addEventListener("abort", () => {
+          if (this.pendingBridgeQuestion === pending)
+            this.pendingBridgeQuestion = null;
+        });
+      });
+    }
+    return Promise.resolve({ behavior: "deny", message: `Unknown bridge request kind` });
+  }
+  resolveBridgePlan(approved) {
+    const pending = this.pendingBridgePlan;
+    if (!pending)
+      return false;
+    this.pendingBridgePlan = null;
+    pending.resolve(approved ? { behavior: "allow", updatedInput: pending.input } : { behavior: "deny", message: "The user rejected the plan." });
+    return true;
+  }
+  resolveBridgeQuestion(answers) {
+    const pending = this.pendingBridgeQuestion;
+    if (!pending)
+      return false;
+    this.pendingBridgeQuestion = null;
+    const questions = Array.isArray(pending.input.questions) ? pending.input.questions : [];
+    const record4 = {};
+    for (const a of answers) {
+      const match = questions.find((q) => q.header === a.header);
+      record4[match?.question ?? a.header] = a.answer;
+    }
+    pending.resolve({
+      behavior: "allow",
+      updatedInput: { ...pending.input, answers: record4 }
+    });
+    return true;
+  }
+  denyPendingBridgeRequests(reason) {
+    this.pendingBridgePlan?.resolve({ behavior: "deny", message: reason });
+    this.pendingBridgePlan = null;
+    this.pendingBridgeQuestion?.resolve({ behavior: "deny", message: reason });
+    this.pendingBridgeQuestion = null;
+  }
   clearClaudeSessionState() {
     this.toolStartTimes.clear();
     this.taskTracker.clear();
+    this.denyPendingBridgeRequests("Claude was restarted before a decision was made");
   }
   reset() {
     this.cancelScheduledFlush();
@@ -52048,6 +52107,7 @@ class MessageManager {
     this.systemExecutor.reset();
   }
   dispose() {
+    this.denyPendingBridgeRequests("Session ended before a decision was made");
     this.cancelScheduledFlush();
     this.postTracker.clearSession(this.sessionId);
     this.events.removeAllListeners();
@@ -55751,6 +55811,148 @@ class UsernameAnonymizer {
     return anonymized;
   }
 }
+// src/mcp/decision-bridge.ts
+import { createServer, createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+
+class BridgeUnavailableError extends Error {
+}
+function bridgeSocketPath() {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\ctb-${randomUUID()}`;
+  }
+  const dir = mkdtempSync(join3(tmpdir(), "ctb-"));
+  return join3(dir, "b.sock");
+}
+
+class DecisionBridgeServer {
+  server;
+  path;
+  liveSockets = new Set;
+  constructor(server, path) {
+    this.server = server;
+    this.path = path;
+  }
+  static async create(handler2) {
+    const path = bridgeSocketPath();
+    const liveSockets = new Set;
+    const server = createServer((socket) => {
+      liveSockets.add(socket);
+      socket.once("close", () => liveSockets.delete(socket));
+      let buffer = "";
+      const aborter = new AbortController;
+      let responded = false;
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        const newline = buffer.indexOf(`
+`);
+        if (newline === -1)
+          return;
+        const line = buffer.slice(0, newline);
+        buffer = "";
+        let request;
+        try {
+          request = JSON.parse(line);
+        } catch {
+          responded = true;
+          socket.end(JSON.stringify({ behavior: "deny", message: "Malformed bridge request" }) + `
+`);
+          return;
+        }
+        handler2(request, aborter.signal).then((response) => {
+          responded = true;
+          socket.end(JSON.stringify(response) + `
+`);
+        }).catch((err) => {
+          responded = true;
+          if (err instanceof BridgeUnavailableError) {
+            socket.destroy();
+            return;
+          }
+          socket.end(JSON.stringify({
+            behavior: "deny",
+            message: `Bridge handler failed: ${err instanceof Error ? err.message : String(err)}`
+          }) + `
+`);
+        });
+      });
+      socket.on("close", () => {
+        if (!responded)
+          aborter.abort();
+      });
+      socket.on("error", () => {});
+    });
+    try {
+      await new Promise((resolve4, reject) => {
+        server.once("error", reject);
+        server.listen(path, () => {
+          server.removeListener("error", reject);
+          resolve4();
+        });
+      });
+    } catch (err) {
+      if (process.platform !== "win32") {
+        await rm(join3(path, ".."), { recursive: true, force: true }).catch(() => {});
+      }
+      throw err;
+    }
+    const bridge = new DecisionBridgeServer(server, path);
+    bridge.liveSockets = liveSockets;
+    return bridge;
+  }
+  async close() {
+    for (const socket of this.liveSockets)
+      socket.destroy();
+    await new Promise((resolve4) => this.server.close(() => resolve4()));
+    if (process.platform !== "win32") {
+      await rm(join3(this.path, ".."), { recursive: true, force: true }).catch(() => {});
+    }
+  }
+}
+function requestBridgeDecision(path, request, timeoutMs) {
+  return new Promise((resolve4, reject) => {
+    const socket = createConnection(path);
+    let buffer = "";
+    let settled = false;
+    const fail = (err) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      reject(err);
+    };
+    const timer = setTimeout(() => fail(new Error(`Bridge decision timed out after ${timeoutMs}ms`)), timeoutMs);
+    socket.on("connect", () => {
+      socket.write(JSON.stringify(request) + `
+`);
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf8");
+      const newline = buffer.indexOf(`
+`);
+      if (newline === -1)
+        return;
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      try {
+        resolve4(JSON.parse(buffer.slice(0, newline)));
+      } catch {
+        reject(new Error("Malformed bridge response"));
+      }
+    });
+    socket.on("error", (err) => fail(err));
+    socket.on("close", () => fail(new Error("Bridge connection closed before a decision arrived")));
+  });
+}
+
 // src/utils/spawn.ts
 import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "child_process";
 var isWindows = process.platform === "win32";
@@ -55769,8 +55971,8 @@ import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve4, dirname as dirname5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { existsSync as existsSync4, readFileSync as readFileSync3, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join as join3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join4 } from "path";
 
 // src/mcp/outbound-env.ts
 var OUTBOUND_ENV = {
@@ -55864,11 +56066,11 @@ function parseRateLimitEvent(event, now = Date.now()) {
 var log8 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
-    const tempDir = tmpdir();
+    const tempDir = tmpdir2();
     const files = readdirSync(tempDir);
     for (const file2 of files) {
       if (file2.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join3(tempDir, file2);
+        const filePath = join4(tempDir, file2);
         try {
           const stats = statSync(filePath);
           if (stats.isSocket()) {
@@ -55882,7 +56084,7 @@ function cleanupBrowserBridgeSockets() {
     log8.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
-function buildClaudeChildEnv(parentEnv, account) {
+function buildClaudeChildEnv(parentEnv, account, opts) {
   const env = { ...parentEnv };
   if (env.MCP_CONNECTION_NONBLOCKING === undefined) {
     env.MCP_CONNECTION_NONBLOCKING = "true";
@@ -55890,6 +56092,9 @@ function buildClaudeChildEnv(parentEnv, account) {
   if (env.ENABLE_PROMPT_CACHING_1H === undefined) {
     env.ENABLE_PROMPT_CACHING_1H = "true";
   }
+  if (opts?.decisionBridge && env.MCP_TOOL_TIMEOUT === undefined) {
+    env.MCP_TOOL_TIMEOUT = "3600000";
+  }
   if (account?.home) {
     env.HOME = account.home;
     env.USERPROFILE = account.home;
@@ -55913,8 +56118,8 @@ function materializeMcpConfig(config3, sessionId, opts = {}) {
   if (opts.inline) {
     return { mode: "inline", value: JSON.stringify(config3) };
   }
-  const dir = opts.tmpDirOverride ?? tmpdir();
-  const path = join3(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  const dir = opts.tmpDirOverride ?? tmpdir2();
+  const path = join4(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
   writeFileSync(path, JSON.stringify(config3), { mode: 384 });
   return { mode: "file", path };
 }
@@ -55938,6 +56143,12 @@ function buildPermissionArgs(opts) {
     PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
     SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
   };
+  if (opts.decisionBridgePath) {
+    mcpEnv.DECISION_BRIDGE_PATH = opts.decisionBridgePath;
+    if (process.env.DECISION_BRIDGE_TIMEOUT_MS) {
+      mcpEnv.DECISION_BRIDGE_TIMEOUT_MS = process.env.DECISION_BRIDGE_TIMEOUT_MS;
+    }
+  }
   if (opts.platformConfig.appToken) {
     mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
   }
@@ -56078,7 +56289,8 @@ class ClaudeCli extends EventEmitter2 {
       workingDir: this.options.workingDir,
       uploadDir: this.options.uploadDir,
       outboundFiles: this.options.outboundFiles,
-      sessionOwnerUsername: this.options.sessionOwnerUsername
+      sessionOwnerUsername: this.options.sessionOwnerUsername,
+      decisionBridgePath: this.options.decisionBridgePath
     });
     args.push(...permResult.args);
     this.mcpConfigTempFile = permResult.tempFile;
@@ -56089,7 +56301,7 @@ class ClaudeCli extends EventEmitter2 {
       args.push("--append-system-prompt", this.options.appendSystemPrompt);
     }
     if (this.options.sessionId) {
-      this.statusFilePath = join3(tmpdir(), `claude-threads-status-${this.options.sessionId}.json`);
+      this.statusFilePath = join4(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const statusLineSettings = {
         statusLine: {
@@ -56312,7 +56524,9 @@ class ClaudeCli extends EventEmitter2 {
     return true;
   }
   buildChildEnv() {
-    return buildClaudeChildEnv(process.env, this.options.account);
+    return buildClaudeChildEnv(process.env, this.options.account, {
+      decisionBridge: this.options.decisionBridgePath !== undefined
+    });
   }
   getMcpServerPath() {
     const __filename2 = fileURLToPath3(import.meta.url);
@@ -57005,10 +57219,10 @@ init_emoji();
 
 // src/persistence/github-emails-store.ts
 import { homedir as homedir4 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var log18 = createLogger("gh-emails");
-var DEFAULT_CONFIG_DIR = join5(homedir4(), ".config", "claude-threads");
-var DEFAULT_FILE = join5(DEFAULT_CONFIG_DIR, "github-emails.yaml");
+var DEFAULT_CONFIG_DIR = join6(homedir4(), ".config", "claude-threads");
+var DEFAULT_FILE = join6(DEFAULT_CONFIG_DIR, "github-emails.yaml");
 
 // src/operations/commands/handler.ts
 var log19 = createLogger("commands");
@@ -58380,6 +58594,8 @@ var PLATFORM_CHANNEL_ID = process.env.PLATFORM_CHANNEL_ID || "";
 var PLATFORM_THREAD_ID = process.env.PLATFORM_THREAD_ID || "";
 var ALLOWED_USERS = (process.env.ALLOWED_USERS || "").split(",").map((u) => u.trim()).filter((u) => u.length > 0);
 var PERMISSION_TIMEOUT_MS = parseInt(process.env.PERMISSION_TIMEOUT_MS || "120000", 10);
+var DECISION_BRIDGE_PATH = process.env.DECISION_BRIDGE_PATH || "";
+var DECISION_BRIDGE_TIMEOUT_MS = parseInt(process.env.DECISION_BRIDGE_TIMEOUT_MS || "3600000", 10);
 var SESSION_OWNER_USERNAME = process.env.SESSION_OWNER_USERNAME || "";
 var SESSION_WORKING_DIR = process.env[OUTBOUND_ENV.SESSION_WORKING_DIR] || "";
 var SESSION_UPLOAD_DIR = process.env[OUTBOUND_ENV.SESSION_UPLOAD_DIR] || "";
@@ -58442,6 +58658,21 @@ async function handlePermissionWith(toolName, toolInput, cfg) {
     mcpLogger.debug(`Skipping standard prompt for ${toolName} (handler enforces its own gate)`);
     return { behavior: "allow", updatedInput: toolInput };
   }
+  const hasMultiSelect = toolName === "AskUserQuestion" && Array.isArray(toolInput.questions) && toolInput.questions.some((q) => q?.multiSelect === true);
+  if ((toolName === "ExitPlanMode" || toolName === "AskUserQuestion") && cfg.decisionBridge && !hasMultiSelect) {
+    const kind = toolName === "ExitPlanMode" ? "plan_approval" : "question";
+    try {
+      const decision = await (cfg.decisionBridge.request ?? requestBridgeDecision)(cfg.decisionBridge.path, { kind, toolName, input: toolInput }, cfg.decisionBridge.timeoutMs);
+      mcpLogger.info(`${toolName} decided via bridge: ${decision.behavior}`);
+      return {
+        behavior: decision.behavior,
+        updatedInput: decision.updatedInput ?? toolInput,
+        message: decision.message
+      };
+    } catch (err) {
+      mcpLogger.warn(`Decision bridge unavailable for ${toolName} (${err}) — legacy fallback`);
+    }
+  }
   if (toolName === "AskUserQuestion") {
     mcpLogger.debug("Auto-allowing AskUserQuestion (question UI is handled by the main bot)");
     return { behavior: "allow", updatedInput: toolInput };
@@ -58528,7 +58759,8 @@ async function handlePermission(toolName, toolInput) {
     getAllowAll: () => allowAllSession,
     setAllowAll: (v) => {
       allowAllSession = v;
-    }
+    },
+    decisionBridge: DECISION_BRIDGE_PATH ? { path: DECISION_BRIDGE_PATH, timeoutMs: DECISION_BRIDGE_TIMEOUT_MS } : undefined
   });
 }
 var permissionInputSchema = {

package/docs/CONFIGURATION.md

@@ -211,6 +211,7 @@ Exactly one of `home` or `apiKey` should be set per account. Persisted sessions
 | `SESSION_TIMEOUT_MS` | Idle timeout in milliseconds. Legacy fallback for `limits.sessionTimeoutMinutes`. | `1800000` (30 min) |
 | `DEBUG` | Enable verbose logging | - |
 | `CLAUDE_PATH` | Path to the `claude` binary. Overrides the PATH lookup and the common install locations. | `claude` (from PATH) |
+| `DECISION_BRIDGE_TIMEOUT_MS` | How long the MCP permission server waits for a plan approval or question answer routed through the decision bridge (the bot's reaction UI) before falling back to the legacy behavior (generic prompt for plans, auto-allow for questions). | `3600000` (1 h) |
 | `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` | Strip `ANTHROPIC_*`, `AWS_*_TOKEN`, `CLAUDE_CODE_OAUTH_TOKEN`, `GOOGLE_APPLICATION_CREDENTIALS`, and similar from Bash, hook, and stdio-MCP subprocesses Claude spawns. Bot-specific vars like `PLATFORM_TOKEN` pass through. **Also forces permission mode to `default`**; `--dangerously-skip-permissions` will be rejected. Requires Claude CLI 2.1.83+. | - |
 | `CLAUDE_THREADS_SESSIONS_PATH` | Override the path to the persisted sessions file (default `~/.config/claude-threads/sessions.json`). | - |
 | `CLAUDE_THREADS_GITHUB_EMAILS_PATH` | Override the path to the GitHub-emails store used for commit attribution. | - |
@@ -218,15 +219,16 @@ Exactly one of `home` or `apiKey` should be set per account. Persisted sessions
 
 ### Forwarded to Claude CLI automatically
 
-The bot sets two tuning flags on the Claude child process when they aren't
+The bot sets these tuning flags on the Claude child process when they aren't
 already present in the bot's environment:
 
 | Variable | Effect | Requires |
 |----------|--------|----------|
 | `MCP_CONNECTION_NONBLOCKING=true` | Caps `--mcp-config` connects at 5s so a slow MCP server never delays startup | Claude CLI 2.1.89+ |
 | `ENABLE_PROMPT_CACHING_1H=true` | Opts into 1-hour prompt cache TTL, cutting re-caching cost on long-lived threads | Claude CLI 2.1.108+ |
+| `MCP_TOOL_TIMEOUT=3600000` | Only set when the session has a decision bridge. Without it the CLI abandons a pending MCP permission call after ~2 minutes — far too short for plan approvals and question answers that wait on a human reaction. One hour matches the bridge's own `DECISION_BRIDGE_TIMEOUT_MS` default. Verified against CLI 2.1.223. | — |
 
-Export either with a different value in the bot's own env to disable.
+Export any of them with a different value in the bot's own env to override.
 
 ## CLI Options
 

package/docs/MCP-TOOLS.md

@@ -15,7 +15,7 @@ The permission handler the Claude CLI calls before running a tool that needs app
 | `tool_name` | string | Name of the tool requesting permission. |
 | `input` | object | The tool's input parameters, shown to the user in the prompt. |
 
-**Guardrail:** Only reactions from users on the session allowlist count. The bot's own reactions (the option emoji it adds) are ignored. If no reaction arrives within `limits.permissionTimeoutSeconds` (default 120), the request is denied.
+**Guardrail:** Only reactions from users on the session allowlist count. The bot's own reactions (the option emoji it adds) are ignored. If no reaction arrives within `limits.permissionTimeoutSeconds` (default 120), the request is denied. Exception: on modern CLIs, `ExitPlanMode` and `AskUserQuestion` don't post a generic prompt at all — they are forwarded over the session's decision bridge to the bot's plan/question reaction UI and wait up to `DECISION_BRIDGE_TIMEOUT_MS` (default 1 hour) for a decision there. To make that hour real, the bot spawns the CLI with `MCP_TOOL_TIMEOUT=3600000` whenever a bridge is configured — without it the CLI abandons a pending permission call after ~2 minutes (verified against CLI 2.1.223). Multi-select questions and any bridge failure fall back to the legacy behavior: generic prompt for plans, auto-allow for questions.
 
 ## send_file
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.21.1",
+  "version": "1.22.0",
   "description": "Run Claude Code from Slack or Mattermost. Sessions stream live into threads where your whole team can watch and steer.",
   "main": "dist/index.js",
   "type": "module",