claude-threads 1.21.0 → 1.21.1

package/CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.21.1] - 2026-08-07
+
+### Fixed
+- **A respawning session can no longer be torn down by its own dying Claude process.** Two stacked races made `!cd` / `!permissions` / worktree respawns flaky (seen as the recurring `!cd should restart Claude CLI` failure on main's Integration Tests): a last event flushed by the dying process ran `resetSessionActivity`, which unconditionally flipped the session's `restarting` state back to `active` — so when the old process's exit landed, `handleExit` mistook it for the current process dying and did a full session teardown mid-restart. `resetSessionActivity` now leaves `restarting`/`cancelling` states alone, `handleExit` ignores exits from a CLI instance that is no longer the session's current one (the exit event can be delivered after the respawn already swapped in the new instance), and a successful respawn transitions to `active` explicitly instead of relying on the old exit's side effect. `ClaudeCli.kill()` gained an integration-test caller trace, mirroring the existing `sendMessage` one — attributing kills is the key question when debugging these races in CI logs.
+- **`checkGitHubCli` unit tests no longer spawn the real `gh` CLI.** The two subprocess probes each carry a 5s timeout, overrunning bun's 5s per-test budget on a slow runner (the flaky `checkGitHubCli` timeout on main's CI). The exec call is now injectable and the tests cover all three outcomes (installed+authenticated, not installed, not authenticated) deterministically.
+- **Integration: the `!cd` confirmation wait no longer matches the user's own message.** The loose `/changed|directory|\/tmp/i` pattern matched the `!cd /tmp` command itself, ending the test while the respawn was still in flight — `afterEach`'s `killAllSessions` then raced the restart and leaked an orphaned mock CLI into the next test.
+
 ## [1.21.0] - 2026-08-07
 
 ### Fixed

package/dist/index.js

@@ -56341,6 +56341,12 @@ class ClaudeCli extends EventEmitter2 {
     const pid = proc.pid;
     this.process = null;
     this.log.debug(`Killing Claude process (pid=${pid})`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+    }
     return new Promise((resolve4) => {
       this.log.debug("Sending first SIGINT");
       proc.kill("SIGINT");
@@ -58526,7 +58532,10 @@ function resetSessionActivity(session) {
   session.lastActivityAt = new Date;
   session.timeoutWarningPosted = false;
   session.lifecyclePostId = undefined;
-  transitionTo(session, "active");
+  const state = session.lifecycle.state;
+  if (state !== "restarting" && state !== "cancelling") {
+    transitionTo(session, "active");
+  }
   if (session.worktreeInfo?.worktreePath) {
     updateWorktreeActivity(session.worktreeInfo.worktreePath, session.sessionId);
   }
@@ -62641,9 +62650,9 @@ _Reported via claude-threads bug report feature_`);
 function escapeShell(str2) {
   return str2.replace(/"/g, "\\\"");
 }
-function checkGitHubCli() {
+function checkGitHubCli(exec2 = execSync2) {
   try {
-    execSync2("gh --version", {
+    exec2("gh --version", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -62656,7 +62665,7 @@ function checkGitHubCli() {
     };
   }
   try {
-    execSync2("gh auth status", {
+    exec2("gh auth status", {
       encoding: "utf-8",
       timeout: 5000,
       stdio: ["pipe", "pipe", "pipe"]
@@ -68233,10 +68242,14 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
           appendSystemPrompt: await buildAppendSystemPrompt(session.platform, session.platformId, existing.path, session.threadId, session.startedBy, session.sessionAllowedUsers, options.appendSystemPrompt ?? "", options.githubEmailsStore, { omitSessionContext: !needsTitlePrompt, userAttribution: session.userAttribution })
         };
         session.messageManager?.clearClaudeSessionState();
-        session.claude = new ClaudeCli(cliOptions);
-        session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
-        session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
-        session.claude.start();
+        const newClaude = new ClaudeCli(cliOptions);
+        session.claude = newClaude;
+        newClaude.on("event", (e) => options.handleEvent(session.sessionId, e));
+        newClaude.on("exit", (code) => options.handleExit(session.sessionId, code, newClaude));
+        newClaude.start();
+        if (isSessionRestarting(session)) {
+          transitionTo(session, "active");
+        }
       }
       await options.updateSessionHeader(session);
       await post(session, "success", `${fmt.formatBold("Joined existing worktree")} for branch ${fmt.formatCode(branch)}
@@ -68326,10 +68339,14 @@ ${fmt.formatItalic("Claude Code restarted in the worktree")}`);
         appendSystemPrompt: await buildAppendSystemPrompt(session.platform, session.platformId, worktreePath, session.threadId, session.startedBy, session.sessionAllowedUsers, options.appendSystemPrompt ?? "", options.githubEmailsStore, { omitSessionContext: !needsTitlePrompt, userAttribution: session.userAttribution })
       };
       session.messageManager?.clearClaudeSessionState();
-      session.claude = new ClaudeCli(cliOptions);
-      session.claude.on("event", (e) => options.handleEvent(session.sessionId, e));
-      session.claude.on("exit", (code) => options.handleExit(session.sessionId, code));
-      session.claude.start();
+      const newClaude = new ClaudeCli(cliOptions);
+      session.claude = newClaude;
+      newClaude.on("event", (e) => options.handleEvent(session.sessionId, e));
+      newClaude.on("exit", (code) => options.handleExit(session.sessionId, code, newClaude));
+      newClaude.start();
+      if (isSessionRestarting(session)) {
+        transitionTo(session, "active");
+      }
     }
     await options.updateSessionHeader(session);
     const shortWorktreePath = shortenPath(worktreePath, undefined, { path: worktreePath, branch });
@@ -69230,15 +69247,21 @@ async function restartClaudeSession(session, cliOptions, ctx, actionName) {
   if (!cliOptions.resume) {
     session.messageManager?.clearClaudeSessionState();
   }
-  session.claude = new ClaudeCli(cliOptions);
-  session.claude.on("event", (e) => ctx.ops.handleEvent(session.sessionId, e));
-  session.claude.on("exit", (code) => ctx.ops.handleExit(session.sessionId, code));
-  session.claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
+  const newClaude = new ClaudeCli(cliOptions);
+  session.claude = newClaude;
+  newClaude.on("event", (e) => ctx.ops.handleEvent(session.sessionId, e));
+  newClaude.on("exit", (code) => ctx.ops.handleExit(session.sessionId, code, newClaude));
+  newClaude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
-    session.claude.start();
+    newClaude.start();
+    if (isSessionRestarting(session)) {
+      transitionTo(session, "active");
+    }
     return true;
   } catch (err) {
-    transitionTo(session, "active");
+    if (isSessionRestarting(session)) {
+      transitionTo(session, "active");
+    }
     await logAndNotify(err, { action: actionName, session });
     return false;
   }
@@ -70351,7 +70374,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
   await ctx.ops.updateStickyMessage();
   ctx.ops.startTyping(session);
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
-  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code));
+  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code, claude));
   claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
     claude.start();
@@ -70546,7 +70569,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   ctx.ops.emitSessionAdd(session);
   keepAlive.sessionStarted();
   claude.on("event", (e) => ctx.ops.handleEvent(sessionId, e));
-  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code));
+  claude.on("exit", (code) => ctx.ops.handleExit(sessionId, code, claude));
   claude.on("rate-limit", (hit) => handleRateLimit(session, hit, ctx));
   try {
     claude.start();
@@ -70634,7 +70657,7 @@ async function resumePausedSession(threadId, message, files, ctx, username) {
     log31.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
-async function handleExit(sessionId, code, ctx) {
+async function handleExit(sessionId, code, ctx, source) {
   const session = mutableSessions(ctx).get(sessionId);
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
@@ -70642,6 +70665,10 @@ async function handleExit(sessionId, code, ctx) {
     log31.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
+  if (source && session.claude !== source) {
+    sessionLog6(session).debug(`Ignoring exit from replaced Claude process`);
+    return;
+  }
   if (isSessionRestarting(session)) {
     sessionLog6(session).debug(`Restarting, skipping cleanup`);
     transitionTo(session, "active");
@@ -71365,7 +71392,7 @@ class SessionManager extends EventEmitter4 {
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       updateStickyMessage: () => this.updateStickyMessage(),
       handleEvent: (sid, e) => this.handleEvent(sid, e),
-      handleExit: (sid, code) => this.handleExit(sid, code),
+      handleExit: (sid, code, source) => this.handleExit(sid, code, source),
       killSession: (tid) => this.killSession(tid),
       shouldPromptForWorktree: (s) => this.shouldPromptForWorktree(s),
       postWorktreePrompt: (s, r) => this.postWorktreePrompt(s, r),
@@ -71469,8 +71496,8 @@ class SessionManager extends EventEmitter4 {
     session.messageManager.handleEvent(event);
     handleEventPostProcessing(session, event, this.getContext());
   }
-  async handleExit(sessionId, code) {
-    await handleExit(sessionId, code, this.getContext());
+  async handleExit(sessionId, code, source) {
+    await handleExit(sessionId, code, this.getContext(), source);
   }
   startTyping(session) {
     const wasTyping = session.timers.typingTimer !== null;
@@ -71985,7 +72012,7 @@ class SessionManager extends EventEmitter4 {
       worktreeMode: this.worktreeMode,
       permissionTimeoutMs: this.limits.permissionTimeoutSeconds * 1000,
       handleEvent: (tid, e) => this.handleEvent(tid, e),
-      handleExit: (tid, code) => this.handleExit(tid, code),
+      handleExit: (tid, code, source) => this.handleExit(tid, code, source),
       updateSessionHeader: (s) => this.updateSessionHeader(s),
       flush: async (s) => {
         if (s.messageManager) {

package/dist/mcp/mcp-server.js

@@ -56263,6 +56263,12 @@ class ClaudeCli extends EventEmitter2 {
     const pid = proc.pid;
     this.process = null;
     this.log.debug(`Killing Claude process (pid=${pid})`);
+    if (process.env.INTEGRATION_TEST === "1") {
+      const stack = new Error().stack?.split(`
+`).slice(2, 7).join(" > ").replace(/\s+at\s+/g, " < ") ?? "?";
+      process.stderr.write(`[claude-cli kill pid=${pid}] | ${stack}
+`);
+    }
     return new Promise((resolve5) => {
       this.log.debug("Sending first SIGINT");
       proc.kill("SIGINT");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.21.0",
+  "version": "1.21.1",
   "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",