claude-threads 1.14.0 → 1.15.0

package/dist/index.js

@@ -51799,6 +51799,26 @@ async function getThreadRaw(config, threadRootId) {
     return null;
   }
 }
+async function getChannelPostsRaw(config, channelId, perPage) {
+  try {
+    return await mattermostApi(config, "GET", `/channels/${channelId}/posts?per_page=${perPage}`);
+  } catch (err) {
+    apiLog.debug(`Failed to get channel posts ${channelId}: ${err}`);
+    return null;
+  }
+}
+async function searchPostsForTeam(config, teamId, terms, perPage) {
+  try {
+    return await mattermostApi(config, "POST", `/teams/${teamId}/posts/search`, {
+      terms,
+      is_or_search: false,
+      per_page: perPage
+    });
+  } catch (err) {
+    apiLog.debug(`Search failed on team ${teamId}: ${err}`);
+    return null;
+  }
+}
 async function addReaction(config, postId, userId, emojiName) {
   await mattermostApi(config, "POST", "/reactions", {
     user_id: userId,
@@ -51806,6 +51826,22 @@ async function addReaction(config, postId, userId, emojiName) {
     emoji_name: emojiName
   });
 }
+async function getUserByUsernameRaw(config, username) {
+  try {
+    return await mattermostApi(config, "GET", `/users/username/${encodeURIComponent(username)}`);
+  } catch (err) {
+    apiLog.debug(`Failed to lookup user @${username}: ${err}`);
+    return null;
+  }
+}
+async function createDirectChannelRaw(config, userIdA, userIdB) {
+  try {
+    return await mattermostApi(config, "POST", "/channels/direct", [userIdA, userIdB]);
+  } catch (err) {
+    apiLog.debug(`Failed to open direct channel ${userIdA}↔${userIdB}: ${err}`);
+    return null;
+  }
+}
 function isUserInAllowList(username, allowList) {
   if (allowList.length === 0)
     return true;
@@ -51983,6 +52019,11 @@ class MattermostMcpPlatformApi {
     this.channelTypeCache.set(channelId, visibility);
     return visibility;
   }
+  async addReaction(postId, emojiName) {
+    mcpLogger.debug(`addReaction: :${emojiName}: on post ${formatShortId(postId)}`);
+    const botUserId = await this.getBotUserId();
+    await addReaction(this.apiConfig, postId, botUserId, emojiName);
+  }
   async readThread(threadRootId, options) {
     mcpLogger.debug(`readThread: ${formatShortId(threadRootId)}`);
     const thread = await getThreadRaw(this.apiConfig, threadRootId);
@@ -51990,14 +52031,93 @@ class MattermostMcpPlatformApi {
       return [];
     const ordered = thread.order.map((id) => thread.posts[id]).filter((p) => Boolean(p)).sort((a, b) => (a.create_at ?? 0) - (b.create_at ?? 0));
     const limited = options?.limit !== undefined ? ordered.slice(-options.limit) : ordered;
+    return this.hydratePosts(limited);
+  }
+  async readChannelHistory(channelId, options) {
+    const limit = options?.limit ?? 20;
+    mcpLogger.debug(`readChannelHistory: ${formatShortId(channelId)} (limit=${limit})`);
+    const response = await getChannelPostsRaw(this.apiConfig, channelId, limit);
+    if (!response)
+      return null;
+    const ordered = response.order.map((id) => response.posts[id]).filter((p) => Boolean(p)).sort((a, b) => (a.create_at ?? 0) - (b.create_at ?? 0));
+    return this.hydratePosts(ordered);
+  }
+  async getChannelInfo(channelId) {
+    mcpLogger.debug(`getChannelInfo: ${formatShortId(channelId)}`);
+    const channel = await getChannelRaw(this.apiConfig, channelId);
+    if (!channel)
+      return null;
+    const channelType = channel.type === "O" ? "public" : "private";
+    this.channelTypeCache.set(channelId, channelType);
+    const name = channel.display_name || channel.name;
+    return { id: channel.id, channelType, name };
+  }
+  async getChannelMembers(channelId) {
+    try {
+      const members = await mattermostApi(this.apiConfig, "GET", `/channels/${channelId}/members?per_page=200`);
+      return members.map((m) => m.user_id);
+    } catch (err) {
+      mcpLogger.debug(`getChannelMembers ${channelId} failed: ${err}`);
+      return null;
+    }
+  }
+  async resolveRecipient(recipient) {
+    const normalized = recipient.replace(/^@/, "");
+    const user = await getUserByUsernameRaw(this.apiConfig, normalized);
+    if (!user)
+      return null;
+    return { id: user.id, username: user.username };
+  }
+  async sendDirectMessage(recipientUserId, message) {
+    const botUserId = await this.getBotUserId();
+    const dmChannel = await createDirectChannelRaw(this.apiConfig, botUserId, recipientUserId);
+    if (!dmChannel) {
+      throw new Error("failed to open direct channel with recipient");
+    }
+    const post = await createPost(this.apiConfig, dmChannel.id, message);
+    return { postId: post.id };
+  }
+  async searchMessages(query, options) {
+    const limit = options?.limit ?? 10;
+    mcpLogger.debug(`searchMessages: '${query}' (limit=${limit})`);
+    const teamId = await this.resolveTeamIdForBotChannel();
+    if (!teamId) {
+      mcpLogger.warn("searchMessages: could not resolve a team for the bot channel");
+      return null;
+    }
+    const response = await searchPostsForTeam(this.apiConfig, teamId, query, limit);
+    if (!response)
+      return null;
+    const ordered = response.order.map((id) => response.posts[id]).filter((p) => Boolean(p));
+    return this.hydratePosts(ordered);
+  }
+  teamIdForBotChannelCache;
+  async resolveTeamIdForBotChannel() {
+    if (this.teamIdForBotChannelCache !== undefined) {
+      return this.teamIdForBotChannelCache;
+    }
+    const channel = await getChannelRaw(this.apiConfig, this.config.channelId);
+    const teamId = channel?.team_id || null;
+    this.teamIdForBotChannelCache = teamId;
+    if (teamId) {
+      mcpLogger.debug(`Resolved team id ${formatShortId(teamId)} for bot channel`);
+    }
+    return teamId;
+  }
+  async hydratePosts(posts) {
     const usernameByUserId = new Map;
-    for (const p of limited) {
+    for (const p of posts) {
       if (p.user_id && !usernameByUserId.has(p.user_id)) {
         usernameByUserId.set(p.user_id, await this.getUsername(p.user_id));
       }
     }
-    const channelType = limited[0] ? await this.getChannelType(limited[0].channel_id) : undefined;
-    return limited.map((p) => toMcpPost(p, p.user_id ? usernameByUserId.get(p.user_id) ?? null : null, channelType));
+    const channelTypeByChannelId = new Map;
+    for (const p of posts) {
+      if (!channelTypeByChannelId.has(p.channel_id)) {
+        channelTypeByChannelId.set(p.channel_id, await this.getChannelType(p.channel_id));
+      }
+    }
+    return posts.map((p) => toMcpPost(p, p.user_id ? usernameByUserId.get(p.user_id) ?? null : null, channelTypeByChannelId.get(p.channel_id)));
   }
 }
 function toMcpPost(post, username, channelType) {
@@ -52255,6 +52375,15 @@ class SlackMcpPlatformApi {
       return null;
     }
   }
+  async addReaction(postId, emojiName) {
+    const name = emojiName.replace(/:/g, "");
+    mcpLogger.debug(`addReaction: :${name}: on ts ${postId}`);
+    await slackApi("reactions.add", this.config.botToken, {
+      channel: this.config.channelId,
+      timestamp: postId,
+      name
+    });
+  }
   async readThread(threadRootId, options) {
     mcpLogger.debug(`readThread: ts ${threadRootId}`);
     try {
@@ -52277,6 +52406,91 @@ class SlackMcpPlatformApi {
       return [];
     }
   }
+  async readChannelHistory(channelId, options) {
+    const limit = options?.limit ?? 20;
+    mcpLogger.debug(`readChannelHistory: ${channelId} (limit=${limit})`);
+    try {
+      const response = await slackApi("conversations.history", this.config.botToken, {
+        channel: channelId,
+        limit
+      });
+      const messages = [...response.messages ?? []].sort((a, b) => parseFloat(a.ts) - parseFloat(b.ts));
+      const usernameByUserId = new Map;
+      for (const m of messages) {
+        if (m.user && !usernameByUserId.has(m.user)) {
+          usernameByUserId.set(m.user, await this.getUsername(m.user));
+        }
+      }
+      return messages.map((m) => slackMessageToMcpPost(m, channelId, m.user ? usernameByUserId.get(m.user) ?? null : null));
+    } catch (err) {
+      mcpLogger.debug(`readChannelHistory ${channelId} failed: ${err}`);
+      return null;
+    }
+  }
+  async getChannelInfo(channelId) {
+    mcpLogger.debug(`getChannelInfo: ${channelId}`);
+    try {
+      const response = await slackApi("conversations.info", this.config.botToken, { channel: channelId });
+      const ch = response.channel;
+      const isPrivate = ch.is_private || ch.is_im || ch.is_mpim || false;
+      return {
+        id: ch.id,
+        channelType: isPrivate ? "private" : "public",
+        name: ch.name
+      };
+    } catch (err) {
+      mcpLogger.debug(`getChannelInfo ${channelId} failed: ${err}`);
+      return null;
+    }
+  }
+  async getChannelMembers(channelId) {
+    const maxPages = 20;
+    const all = [];
+    let cursor = undefined;
+    try {
+      for (let i2 = 0;i2 < maxPages; i2++) {
+        const params = {
+          channel: channelId,
+          limit: 1000
+        };
+        if (cursor)
+          params.cursor = cursor;
+        const response = await slackApi("conversations.members", this.config.botToken, params);
+        all.push(...response.members ?? []);
+        cursor = response.response_metadata?.next_cursor;
+        if (!cursor)
+          return all;
+      }
+      mcpLogger.warn(`getChannelMembers ${channelId} hit page cap of ${maxPages}`);
+      return all;
+    } catch (err) {
+      mcpLogger.debug(`getChannelMembers ${channelId} failed: ${err}`);
+      return null;
+    }
+  }
+  async resolveRecipient(recipient) {
+    const id = recipient.replace(/^<@/, "").replace(/>$/, "");
+    if (!/^[UW][A-Z0-9]{8,}$/.test(id)) {
+      return null;
+    }
+    try {
+      const response = await slackApi("users.info", this.config.botToken, { user: id });
+      return { id: response.user.id, username: response.user.name ?? null };
+    } catch (err) {
+      mcpLogger.debug(`resolveRecipient ${id} failed: ${err}`);
+      return null;
+    }
+  }
+  async sendDirectMessage(recipientUserId, message) {
+    const opened = await slackApi("conversations.open", this.config.botToken, { users: recipientUserId });
+    const dmChannelId = opened.channel.id;
+    const post = await slackApi("chat.postMessage", this.config.botToken, {
+      channel: dmChannelId,
+      text: message,
+      mrkdwn: true
+    });
+    return { postId: post.ts };
+  }
 }
 function slackMessageToMcpPost(message, channelId, username) {
   const createAt = Math.floor(parseFloat(message.ts) * 1000);
@@ -53453,7 +53667,8 @@ function buildPermissionArgs(opts) {
     PLATFORM_THREAD_ID: opts.threadId || "",
     ALLOWED_USERS: opts.platformConfig.allowedUsers.join(","),
     DEBUG: opts.debug ? "1" : "",
-    PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs)
+    PERMISSION_TIMEOUT_MS: String(opts.permissionTimeoutMs),
+    SESSION_OWNER_USERNAME: opts.sessionOwnerUsername || ""
   };
   if (opts.platformConfig.appToken) {
     mcpEnv.PLATFORM_APP_TOKEN = opts.platformConfig.appToken;
@@ -53592,7 +53807,8 @@ class ClaudeCli extends EventEmitter2 {
       debug: this.debug,
       workingDir: this.options.workingDir,
       uploadDir: this.options.uploadDir,
-      outboundFiles: this.options.outboundFiles
+      outboundFiles: this.options.outboundFiles,
+      sessionOwnerUsername: this.options.sessionOwnerUsername
     });
     args.push(...permResult.args);
     this.mcpConfigTempFile = permResult.tempFile;
@@ -55233,7 +55449,8 @@ function buildRestartCliOptions(session, ctx) {
     permissionTimeoutMs: ctx.permissionTimeoutMs,
     account: ctx.account,
     uploadDir: getSessionUploadDir(session.platformId, session.threadId),
-    outboundFiles: platformMcpConfig.outboundFiles
+    outboundFiles: platformMcpConfig.outboundFiles,
+    sessionOwnerUsername: session.startedBy
   };
 }
 
@@ -66456,7 +66673,8 @@ async function startSession(options, username, displayName, replyToPostId, platf
     permissionTimeoutMs: ctx.config.permissionTimeoutMs,
     account: claudeAccount ? { id: claudeAccount.id, home: claudeAccount.home, apiKey: claudeAccount.apiKey } : undefined,
     uploadDir: getSessionUploadDir(platformId, actualThreadId),
-    outboundFiles: platformMcpConfig.outboundFiles
+    outboundFiles: platformMcpConfig.outboundFiles,
+    sessionOwnerUsername: username
   };
   const claude = new ClaudeCli(cliOptions);
   const session = {
@@ -66607,7 +66825,8 @@ Please start a new session.`), { action: "Post resume failure notification" });
     permissionTimeoutMs: ctx.config.permissionTimeoutMs,
     account: claudeAccount ? { id: claudeAccount.id, home: claudeAccount.home, apiKey: claudeAccount.apiKey } : undefined,
     uploadDir: getSessionUploadDir(platformId, state.threadId),
-    outboundFiles: platformMcpConfig.outboundFiles
+    outboundFiles: platformMcpConfig.outboundFiles,
+    sessionOwnerUsername: state.startedBy
   };
   const claude = new ClaudeCli(cliOptions);
   const session = {
@@ -78631,8 +78850,105 @@ class UpdateInstaller {
   }
 }
 
+// src/auto-update/respawn.ts
+init_logger();
+import { spawn as spawn5 } from "child_process";
+import { existsSync as existsSync15, statSync as statSync4 } from "fs";
+import { delimiter, join as join11 } from "path";
+var log38 = createLogger("respawn");
+function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
+  if (env5.CLAUDE_THREADS_BIN) {
+    return { kind: "exit-for-supervisor", supervisor: "claude-threads-daemon" };
+  }
+  if (env5.pm_id !== undefined && env5.PM2_HOME) {
+    return { kind: "exit-for-supervisor", supervisor: "pm2" };
+  }
+  if (env5.INVOCATION_ID) {
+    return { kind: "exit-for-supervisor", supervisor: "systemd" };
+  }
+  if (env5.CLAUDE_THREADS_INTERACTIVE) {
+    return { kind: "exit-for-supervisor", supervisor: "wrapped-tty" };
+  }
+  if (!isTTY) {
+    return { kind: "exit-for-supervisor", supervisor: "none-headless" };
+  }
+  return { kind: "self-respawn" };
+}
+function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync15, _isFileExecutable = isFileExecutable) {
+  const isWin2 = process.platform === "win32";
+  const names = isWin2 ? ["claude-threads.cmd", "claude-threads.exe", "claude-threads.bat"] : ["claude-threads"];
+  const path10 = _env.PATH || _env.Path || "";
+  const dirs = path10.split(delimiter).filter(Boolean);
+  const home = _env.HOME || _env.USERPROFILE;
+  const bunRoot = _env.BUN_INSTALL || (home ? join11(home, ".bun") : null);
+  if (bunRoot) {
+    const bunBin = join11(bunRoot, "bin");
+    if (!dirs.includes(bunBin)) {
+      dirs.push(bunBin);
+    }
+  }
+  for (const dir of dirs) {
+    for (const name of names) {
+      const candidate = join11(dir, name);
+      if (_existsSync(candidate) && _isFileExecutable(candidate)) {
+        return candidate;
+      }
+    }
+  }
+  return null;
+}
+function isFileExecutable(path10) {
+  try {
+    const stat = statSync4(path10);
+    if (!stat.isFile())
+      return false;
+    if (process.platform === "win32")
+      return true;
+    return (stat.mode & 73) !== 0;
+  } catch {
+    return false;
+  }
+}
+function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeThreadsBin()) {
+  if (!binPath) {
+    log38.error("Could not resolve claude-threads on PATH; self-respawn aborted");
+    return false;
+  }
+  if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
+    try {
+      process.stdin.setRawMode(false);
+    } catch {}
+  }
+  const childEnv = { ...process.env };
+  delete childEnv.CLAUDE_THREADS_BIN;
+  delete childEnv.CLAUDE_THREADS_INTERACTIVE;
+  const useShell = process.platform === "win32";
+  let child;
+  try {
+    child = spawn5(binPath, argv, {
+      detached: true,
+      stdio: "inherit",
+      env: childEnv,
+      shell: useShell
+    });
+  } catch (err) {
+    log38.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
+  }
+  child.once("error", (err) => {
+    log38.error(`Replacement process error: ${err.message}`);
+  });
+  if (child.pid === undefined) {
+    log38.error("Spawn returned no pid (binary likely not executable)");
+    return false;
+  }
+  child.unref();
+  log38.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
+  return true;
+}
+
 // src/auto-update/manager.ts
-var log38 = createLogger("updater");
+var log39 = createLogger("updater");
 
 class AutoUpdateManager extends EventEmitter9 {
   config;
@@ -78655,23 +78971,23 @@ class AutoUpdateManager extends EventEmitter9 {
   }
   start() {
     if (!this.config.enabled) {
-      log38.info("Auto-update is disabled");
+      log39.info("Auto-update is disabled");
       return;
     }
     const updateResult = this.installer.checkJustUpdated();
     if (updateResult) {
-      log38.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
+      log39.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
       this.callbacks.broadcastUpdate((fmt) => `\uD83C\uDF89 ${fmt.formatBold("Bot updated")} from v${updateResult.previousVersion} to v${updateResult.currentVersion}`).catch((err) => {
-        log38.warn(`Failed to broadcast update notification: ${err}`);
+        log39.warn(`Failed to broadcast update notification: ${err}`);
       });
     }
     this.checker.start();
-    log38.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+    log39.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
   }
   stop() {
     this.checker.stop();
     this.scheduler.stop();
-    log38.debug("Auto-update manager stopped");
+    log39.debug("Auto-update manager stopped");
   }
   getState() {
     return { ...this.state };
@@ -78685,10 +79001,10 @@ class AutoUpdateManager extends EventEmitter9 {
   async forceUpdate() {
     const updateInfo = this.state.updateInfo || await this.checker.check();
     if (!updateInfo) {
-      log38.info("No update available");
+      log39.info("No update available");
       return;
     }
-    log38.info("Forcing immediate update");
+    log39.info("Forcing immediate update");
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -78740,12 +79056,41 @@ class AutoUpdateManager extends EventEmitter9 {
     if (result.success) {
       this.updateStatus("pending_restart");
       this.emit("update:restart", updateInfo.latestVersion);
-      await this.callbacks.broadcastUpdate((fmt) => `✅ ${fmt.formatBold("Update installed")} - restarting now. ${fmt.formatItalic("Sessions will resume automatically.")}`).catch(() => {});
+      const decision = decideRespawn();
+      const binPath = decision.kind === "self-respawn" ? resolveClaudeThreadsBin() : null;
+      const canSelfRespawn = decision.kind === "self-respawn" && binPath !== null;
+      const willAutoRestart = decision.kind === "exit-for-supervisor" ? decision.supervisor !== "none-headless" : canSelfRespawn;
+      if (willAutoRestart) {
+        await this.callbacks.broadcastUpdate((fmt) => `✅ ${fmt.formatBold("Update installed")} to v${updateInfo.latestVersion}. Restarting now, sessions will resume automatically.`).catch(() => {});
+      } else {
+        await this.callbacks.broadcastUpdate((fmt) => `✅ ${fmt.formatBold("Update installed")} to v${updateInfo.latestVersion}. Could not auto-restart (no supervisor and no claude-threads on PATH); please run ${fmt.formatCode("claude-threads")} to bring the bot back. Sessions are persisted and will resume.`).catch(() => {});
+      }
       await new Promise((resolve7) => setTimeout(resolve7, 1000));
-      await this.callbacks.prepareForRestart();
-      log38.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      try {
+        await this.callbacks.prepareForRestart();
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        log39.error(`prepareForRestart failed: ${reason}`);
+        await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Restart aborted")}: shutdown sequence failed (${reason}). Sessions may be in an inconsistent state; please run ${fmt.formatCode("claude-threads")} manually.`).catch(() => {});
+        process.exit(1);
+      }
+      log39.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
       process.stdout.write("\x1B[2J\x1B[H");
       process.stdout.write("\x1B[?25h");
+      if (decision.kind === "self-respawn") {
+        if (canSelfRespawn) {
+          const ok = spawnReplacement(undefined, binPath);
+          if (ok) {
+            process.exit(0);
+          }
+          log39.error("Self-respawn launch failed after binary resolution succeeded");
+          await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Auto-restart failed")} after install: please run ${fmt.formatCode("claude-threads")} to bring the bot back. Sessions are persisted and will resume.`).catch(() => {});
+        } else {
+          log39.error("claude-threads not found on PATH; manual restart required");
+        }
+        process.exit(0);
+      }
+      log39.debug(`Restart handled by supervisor: ${decision.supervisor}`);
       process.exit(RESTART_EXIT_CODE);
     } else {
       const errorMsg = result.error ?? "Unknown error";
@@ -78835,7 +79180,7 @@ async function main() {
     return false;
   };
   if (await shouldUseAutoRestart()) {
-    const { spawn: spawn5 } = await import("child_process");
+    const { spawn: spawn6 } = await import("child_process");
     const { dirname: dirname9, resolve: resolve7 } = await import("path");
     const { fileURLToPath: fileURLToPath7 } = await import("url");
     const __filename2 = fileURLToPath7(import.meta.url);
@@ -78847,7 +79192,7 @@ async function main() {
     const binPath = __filename2;
     let child;
     if (process.platform === "win32") {
-      child = spawn5("bash", [daemonPath, "--restart-on-error", ...args], {
+      child = spawn6("bash", [daemonPath, "--restart-on-error", ...args], {
         stdio: "inherit",
         env: {
           ...process.env,
@@ -78856,7 +79201,7 @@ async function main() {
         }
       });
     } else {
-      child = spawn5(daemonPath, ["--restart-on-error", ...args], {
+      child = spawn6(daemonPath, ["--restart-on-error", ...args], {
         stdio: "inherit",
         env: {
           ...process.env,
@@ -79135,9 +79480,9 @@ async function startWithoutDaemon() {
       await session.updateAllStickyMessages();
       await session.killAllSessions();
       autoUpdateManager?.stop();
-      for (const client of platforms.values()) {
-        client.disconnect();
-      }
+      await Promise.all(Array.from(platforms.values()).map((client) => client.disconnect().catch((err) => {
+        ui.addLog({ level: "warn", component: "shutdown", message: `disconnect failed: ${err}` });
+      })));
       if (!isHeadless) {
         process.stdout.write("\x1B[2J\x1B[H");
         process.stdout.write("\x1B[?25h");