claude-threads 0.17.0 → 0.18.0

package/CHANGELOG.md

@@ -5,7 +5,35 @@ 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).
 
-## [Unreleased]
+## [0.18.0] - 2026-01-01
+
+### Added
+- **Keep-alive support** - Prevents system sleep while Claude sessions are active
+  - Automatically starts when first session begins, stops when all sessions end
+  - Cross-platform: macOS (`caffeinate`), Linux (`systemd-inhibit`), Windows (`SetThreadExecutionState`)
+  - Enabled by default, disable with `--no-keep-alive` CLI flag or `keepAlive: false` in config
+  - Shows `☕ Keep-alive enabled` in startup output
+- **Resume timed-out sessions via emoji reaction** - React with 🔄 to the timeout message or session header to resume a timed-out session
+  - Timeout message now shows resume hint: "💡 React with 🔄 to resume, or send a new message to continue."
+  - Resume also works by sending a new message in the thread (existing behavior)
+  - Session header now displays truncated session ID for reference
+  - Supports multiple resume emojis: 🔄 (arrows_counterclockwise), ▶️ (arrow_forward), 🔁 (repeat)
+
+### Fixed
+- **Sticky task list**: Task list now correctly stops being sticky when all tasks are completed
+  - Previously, the task list stayed at the bottom even after all tasks had `status: 'completed'`
+  - Now properly detects when all tasks are done using `todos.every(t => t.status === 'completed')`
+
+## [0.17.1] - 2025-12-31
+
+### Fixed
+- **Sticky task list optimization**: Completed task lists no longer move to the bottom
+  - Once all tasks are done, the "~~Tasks~~ *(completed)*" message stays in place
+  - Reduces unnecessary message deletions and recreations
+  - Added `tasksCompleted` flag to session state for explicit tracking
+
+### Changed
+- **Task list visual separator**: Added horizontal rule (`---`) above task list for better visibility
 
 ## [0.17.0] - 2025-12-31
 

package/dist/index.js

@@ -13694,6 +13694,22 @@ class SessionStore {
       console.log("  [persist] Cleared all sessions");
     }
   }
+  findByThread(platformId, threadId) {
+    const sessionId = `${platformId}:${threadId}`;
+    const data = this.loadRaw();
+    return data.sessions[sessionId];
+  }
+  findByPostId(platformId, postId) {
+    const data = this.loadRaw();
+    for (const session of Object.values(data.sessions)) {
+      if (session.platformId !== platformId)
+        continue;
+      if (session.timeoutPostId === postId || session.sessionStartPostId === postId) {
+        return session;
+      }
+    }
+    return;
+  }
   loadRaw() {
     if (!existsSync3(SESSIONS_FILE)) {
       return { version: STORE_VERSION, sessions: {} };
@@ -13718,6 +13734,7 @@ var ALLOW_ALL_EMOJIS = ["white_check_mark", "heavy_check_mark"];
 var NUMBER_EMOJIS = ["one", "two", "three", "four"];
 var CANCEL_EMOJIS = ["x", "octagonal_sign", "stop_sign"];
 var ESCAPE_EMOJIS = ["double_vertical_bar", "pause_button"];
+var RESUME_EMOJIS = ["arrows_counterclockwise", "arrow_forward", "repeat"];
 function isApprovalEmoji(emoji) {
   return APPROVAL_EMOJIS.includes(emoji);
 }
@@ -13733,6 +13750,9 @@ function isCancelEmoji(emoji) {
 function isEscapeEmoji(emoji) {
   return ESCAPE_EMOJIS.includes(emoji);
 }
+function isResumeEmoji(emoji) {
+  return RESUME_EMOJIS.includes(emoji);
+}
 var UNICODE_NUMBER_EMOJIS = {
   "1\uFE0F\u20E3": 0,
   "2\uFE0F\u20E3": 1,
@@ -13823,6 +13843,9 @@ async function bumpTasksToBottom(session) {
   if (!session.tasksPostId || !session.lastTasksContent) {
     return;
   }
+  if (session.tasksCompleted) {
+    return;
+  }
   try {
     await session.platform.deletePost(session.tasksPostId);
     const newPost = await session.platform.createPost(session.lastTasksContent, session.threadId);
@@ -13853,7 +13876,8 @@ async function flush(session, registerPost) {
     session.currentPostId = null;
     session.pendingContent = remainder;
     if (remainder) {
-      if (session.tasksPostId && session.lastTasksContent) {
+      const hasActiveTasks = session.tasksPostId && session.lastTasksContent && !session.tasksCompleted;
+      if (hasActiveTasks) {
         const postId = await bumpTasksToBottomWithContent(session, `*(continued)*
 
 ` + remainder, registerPost);
@@ -13876,7 +13900,8 @@ async function flush(session, registerPost) {
   if (session.currentPostId) {
     await session.platform.updatePost(session.currentPostId, content);
   } else {
-    if (session.tasksPostId && session.lastTasksContent) {
+    const hasActiveTasks = session.tasksPostId && session.lastTasksContent && !session.tasksCompleted;
+    if (hasActiveTasks) {
       const postId = await bumpTasksToBottomWithContent(session, content, registerPost);
       session.currentPostId = postId;
     } else {
@@ -14843,9 +14868,11 @@ async function handleExitPlanMode(session, toolUseId, ctx) {
 async function handleTodoWrite(session, input) {
   const todos = input.todos;
   if (!todos || todos.length === 0) {
+    session.tasksCompleted = true;
     if (session.tasksPostId) {
       try {
-        const completedMsg = "\uD83D\uDCCB ~~Tasks~~ *(completed)*";
+        const completedMsg = `---
+\uD83D\uDCCB ~~Tasks~~ *(completed)*`;
         await session.platform.updatePost(session.tasksPostId, completedMsg);
         session.lastTasksContent = completedMsg;
       } catch (err) {
@@ -14854,6 +14881,8 @@ async function handleTodoWrite(session, input) {
     }
     return;
   }
+  const allCompleted = todos.every((t) => t.status === "completed");
+  session.tasksCompleted = allCompleted;
   const completed = todos.filter((t) => t.status === "completed").length;
   const total = todos.length;
   const pct = Math.round(completed / total * 100);
@@ -14863,7 +14892,8 @@ async function handleTodoWrite(session, input) {
   } else if (!hasInProgress) {
     session.inProgressTaskStart = null;
   }
-  let message = `\uD83D\uDCCB **Tasks** (${completed}/${total} \xB7 ${pct}%)
+  let message = `---
+\uD83D\uDCCB **Tasks** (${completed}/${total} \xB7 ${pct}%)
 
 `;
   for (const todo of todos) {
@@ -18939,6 +18969,7 @@ async function updateSessionHeader(session, ctx) {
     rows.push(`| \uD83D\uDC65 **Participants** | ${otherParticipants} |`);
   }
   rows.push(`| \uD83D\uDD22 **Session** | #${session.sessionNumber} of ${ctx.maxSessions} max |`);
+  rows.push(`| \uD83C\uDD94 **Session ID** | \`${session.claudeSessionId.substring(0, 8)}\` |`);
   rows.push(`| ${permMode.split(" ")[0]} **Permissions** | ${permMode.split(" ")[1]} |`);
   if (ctx.chromeEnabled) {
     rows.push(`| \uD83C\uDF10 **Chrome** | Enabled |`);
@@ -18971,6 +19002,196 @@ async function updateSessionHeader(session, ctx) {
 // src/session/lifecycle.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { existsSync as existsSync7 } from "fs";
+
+// src/utils/keep-alive.ts
+import { spawn as spawn3 } from "child_process";
+var logger = createLogger("[keep-alive]");
+
+class KeepAliveManager {
+  activeSessionCount = 0;
+  keepAliveProcess = null;
+  enabled = true;
+  platform;
+  constructor() {
+    this.platform = process.platform;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    if (!enabled && this.keepAliveProcess) {
+      this.stopKeepAlive();
+    }
+    logger.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  isActive() {
+    return this.keepAliveProcess !== null;
+  }
+  sessionStarted() {
+    this.activeSessionCount++;
+    logger.debug(`Session started (${this.activeSessionCount} active)`);
+    if (this.activeSessionCount === 1) {
+      this.startKeepAlive();
+    }
+  }
+  sessionEnded() {
+    if (this.activeSessionCount > 0) {
+      this.activeSessionCount--;
+    }
+    logger.debug(`Session ended (${this.activeSessionCount} active)`);
+    if (this.activeSessionCount === 0) {
+      this.stopKeepAlive();
+    }
+  }
+  forceStop() {
+    this.stopKeepAlive();
+    this.activeSessionCount = 0;
+  }
+  getSessionCount() {
+    return this.activeSessionCount;
+  }
+  startKeepAlive() {
+    if (!this.enabled) {
+      logger.debug("Keep-alive disabled, skipping");
+      return;
+    }
+    if (this.keepAliveProcess) {
+      logger.debug("Keep-alive already running");
+      return;
+    }
+    switch (this.platform) {
+      case "darwin":
+        this.startMacOSKeepAlive();
+        break;
+      case "linux":
+        this.startLinuxKeepAlive();
+        break;
+      case "win32":
+        this.startWindowsKeepAlive();
+        break;
+      default:
+        logger.info(`Keep-alive not supported on ${this.platform}`);
+    }
+  }
+  stopKeepAlive() {
+    if (this.keepAliveProcess) {
+      logger.debug("Stopping keep-alive");
+      this.keepAliveProcess.kill();
+      this.keepAliveProcess = null;
+    }
+  }
+  startMacOSKeepAlive() {
+    try {
+      this.keepAliveProcess = spawn3("caffeinate", ["-s", "-i"], {
+        stdio: "ignore",
+        detached: false
+      });
+      this.keepAliveProcess.on("error", (err) => {
+        logger.error(`Failed to start caffeinate: ${err.message}`);
+        this.keepAliveProcess = null;
+      });
+      this.keepAliveProcess.on("exit", (code) => {
+        if (code !== null && code !== 0 && this.activeSessionCount > 0) {
+          logger.debug(`caffeinate exited with code ${code}`);
+        }
+        this.keepAliveProcess = null;
+      });
+      logger.info("System sleep prevention started (caffeinate)");
+    } catch (err) {
+      logger.error(`Failed to start caffeinate: ${err}`);
+    }
+  }
+  startLinuxKeepAlive() {
+    try {
+      this.keepAliveProcess = spawn3("systemd-inhibit", [
+        "--what=sleep:idle:handle-lid-switch",
+        "--why=Claude Code session active",
+        "--mode=block",
+        "sleep",
+        "infinity"
+      ], {
+        stdio: "ignore",
+        detached: false
+      });
+      this.keepAliveProcess.on("error", (err) => {
+        logger.debug(`systemd-inhibit not available: ${err.message}`);
+        this.keepAliveProcess = null;
+        this.startLinuxKeepAliveFallback();
+      });
+      this.keepAliveProcess.on("exit", (code) => {
+        if (code !== null && code !== 0 && this.activeSessionCount > 0) {
+          logger.debug(`systemd-inhibit exited with code ${code}`);
+        }
+        this.keepAliveProcess = null;
+      });
+      logger.info("System sleep prevention started (systemd-inhibit)");
+    } catch (err) {
+      logger.debug(`Failed to start systemd-inhibit: ${err}`);
+      this.startLinuxKeepAliveFallback();
+    }
+  }
+  startLinuxKeepAliveFallback() {
+    try {
+      this.keepAliveProcess = spawn3("bash", [
+        "-c",
+        `while true; do xdg-screensaver reset 2>/dev/null || true; sleep 60; done`
+      ], {
+        stdio: "ignore",
+        detached: false
+      });
+      this.keepAliveProcess.on("error", (err) => {
+        logger.info(`Linux keep-alive fallback not available: ${err.message}`);
+        this.keepAliveProcess = null;
+      });
+      this.keepAliveProcess.on("exit", () => {
+        this.keepAliveProcess = null;
+      });
+      logger.info("System sleep prevention started (xdg-screensaver reset loop)");
+    } catch (err) {
+      logger.info(`Linux keep-alive not available: ${err}`);
+    }
+  }
+  startWindowsKeepAlive() {
+    try {
+      const script = `
+        Add-Type -TypeDefinition @"
+          using System;
+          using System.Runtime.InteropServices;
+          public class PowerState {
+            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+            public static extern uint SetThreadExecutionState(uint esFlags);
+          }
+"@
+        # ES_CONTINUOUS | ES_SYSTEM_REQUIRED
+        [PowerState]::SetThreadExecutionState(0x80000001) | Out-Null
+        # Keep running until killed
+        while ($true) { Start-Sleep -Seconds 60 }
+      `;
+      this.keepAliveProcess = spawn3("powershell", ["-NoProfile", "-Command", script], {
+        stdio: "ignore",
+        detached: false,
+        windowsHide: true
+      });
+      this.keepAliveProcess.on("error", (err) => {
+        logger.info(`Windows keep-alive not available: ${err.message}`);
+        this.keepAliveProcess = null;
+      });
+      this.keepAliveProcess.on("exit", (code) => {
+        if (code !== null && code !== 0 && this.activeSessionCount > 0) {
+          logger.debug(`PowerShell keep-alive exited with code ${code}`);
+        }
+        this.keepAliveProcess = null;
+      });
+      logger.info("System sleep prevention started (SetThreadExecutionState)");
+    } catch (err) {
+      logger.info(`Windows keep-alive not available: ${err}`);
+    }
+  }
+}
+var keepAlive = new KeepAliveManager;
+
+// src/session/lifecycle.ts
 function findPersistedByThreadId(persisted, threadId) {
   for (const session of persisted.values()) {
     if (session.threadId === threadId) {
@@ -19041,6 +19262,7 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
     sessionStartPostId: post.id,
     tasksPostId: null,
     lastTasksContent: null,
+    tasksCompleted: false,
     activeSubagents: new Map,
     updateTimer: null,
     typingTimer: null,
@@ -19055,6 +19277,7 @@ async function startSession(options, username, replyToPostId, platformId, ctx) {
   ctx.registerPost(post.id, actualThreadId);
   const shortId = actualThreadId.substring(0, 8);
   console.log(`  \u25B6 Session #${ctx.sessions.size} started (${shortId}\u2026) by @${username}`);
+  keepAlive.sessionStarted();
   await ctx.updateSessionHeader(session);
   ctx.startTyping(session);
   claude.on("event", (e) => ctx.handleEvent(sessionId, e));
@@ -19153,6 +19376,7 @@ Please start a new session.`, state.threadId);
     sessionStartPostId: state.sessionStartPostId,
     tasksPostId: state.tasksPostId,
     lastTasksContent: state.lastTasksContent ?? null,
+    tasksCompleted: state.tasksCompleted ?? false,
     activeSubagents: new Map,
     updateTimer: null,
     typingTimer: null,
@@ -19173,6 +19397,7 @@ Please start a new session.`, state.threadId);
   if (state.sessionStartPostId) {
     ctx.registerPost(state.sessionStartPostId, state.threadId);
   }
+  keepAlive.sessionStarted();
   claude.on("event", (e) => ctx.handleEvent(sessionId, e));
   claude.on("exit", (code) => ctx.handleExit(sessionId, code));
   try {
@@ -19251,6 +19476,7 @@ async function handleExit(sessionId, code, ctx) {
       session.updateTimer = null;
     }
     ctx.sessions.delete(session.sessionId);
+    keepAlive.sessionEnded();
     return;
   }
   if (session.wasInterrupted) {
@@ -19267,6 +19493,7 @@ async function handleExit(sessionId, code, ctx) {
         ctx.postIndex.delete(postId);
       }
     }
+    keepAlive.sessionEnded();
     try {
       await session.platform.createPost(`\u2139\uFE0F Session paused. Send a new message to continue.`, session.threadId);
     } catch {}
@@ -19281,6 +19508,7 @@ async function handleExit(sessionId, code, ctx) {
       session.updateTimer = null;
     }
     ctx.sessions.delete(session.sessionId);
+    keepAlive.sessionEnded();
     try {
       await session.platform.createPost(`\u26A0\uFE0F **Session resume failed** (exit code ${code}). The session data is preserved - try restarting the bot.`, session.threadId);
     } catch {}
@@ -19302,6 +19530,7 @@ async function handleExit(sessionId, code, ctx) {
       ctx.postIndex.delete(postId);
     }
   }
+  keepAlive.sessionEnded();
   if (code === 0 || code === null) {
     ctx.unpersistSession(session.sessionId);
   } else {
@@ -19322,6 +19551,7 @@ function killSession(session, unpersist, ctx) {
       ctx.postIndex.delete(postId);
     }
   }
+  keepAlive.sessionEnded();
   if (unpersist) {
     ctx.unpersistSession(session.threadId);
   }
@@ -19334,15 +19564,23 @@ function killAllSessions(ctx) {
   }
   ctx.sessions.clear();
   ctx.postIndex.clear();
+  keepAlive.forceStop();
 }
-function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
+async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
   const now = Date.now();
   for (const [_sessionId, session] of ctx.sessions) {
     const idleMs = now - session.lastActivityAt.getTime();
     const shortId = session.threadId.substring(0, 8);
     if (idleMs > timeoutMs) {
       console.log(`  \u23F0 Session (${shortId}\u2026) timed out after ${Math.round(idleMs / 60000)}min idle`);
-      session.platform.createPost(`\u23F0 **Session timed out** after ${Math.round(idleMs / 60000)} minutes of inactivity`, session.threadId).catch(() => {});
+      try {
+        const timeoutPost = await session.platform.createPost(`\u23F0 **Session timed out** after ${Math.round(idleMs / 60000)} minutes of inactivity
+
+` + `\uD83D\uDCA1 React with \uD83D\uDD04 to resume, or send a new message to continue.`, session.threadId);
+        session.timeoutPostId = timeoutPost.id;
+        ctx.persistSession(session);
+        ctx.registerPost(timeoutPost.id, session.threadId);
+      } catch {}
       killSession(session, false, ctx);
       continue;
     }
@@ -19357,13 +19595,13 @@ function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
 }
 
 // src/git/worktree.ts
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { randomUUID as randomUUID3 } from "crypto";
 import * as path9 from "path";
 import * as fs5 from "fs/promises";
 async function execGit(args, cwd) {
   return new Promise((resolve6, reject) => {
-    const proc = spawn3("git", args, { cwd });
+    const proc = spawn4("git", args, { cwd });
     let stdout = "";
     let stderr = "";
     proc.stdout.on("data", (data) => {
@@ -19898,7 +20136,7 @@ class SessionManager {
     this.chromeEnabled = chromeEnabled;
     this.worktreeMode = worktreeMode;
     this.cleanupTimer = setInterval(() => {
-      cleanupIdleSessions(SESSION_TIMEOUT_MS, SESSION_WARNING_MS, this.getLifecycleContext());
+      cleanupIdleSessions(SESSION_TIMEOUT_MS, SESSION_WARNING_MS, this.getLifecycleContext()).catch((err) => console.error("  [cleanup] Error during idle session cleanup:", err));
     }, 60000);
   }
   addPlatform(platformId, client) {
@@ -19993,6 +20231,11 @@ class SessionManager {
   }
   async handleMessage(_platformId, _post, _user) {}
   async handleReaction(platformId, postId, emojiName, username) {
+    if (isResumeEmoji(emojiName)) {
+      const resumed = await this.tryResumeFromReaction(platformId, postId, username);
+      if (resumed)
+        return;
+    }
     const session = this.getSessionByPost(postId);
     if (!session)
       return;
@@ -20003,6 +20246,36 @@ class SessionManager {
     }
     await this.handleSessionReaction(session, postId, emojiName, username);
   }
+  async tryResumeFromReaction(platformId, postId, username) {
+    const persistedSession = this.sessionStore.findByPostId(platformId, postId);
+    if (!persistedSession)
+      return false;
+    const sessionId = `${platformId}:${persistedSession.threadId}`;
+    if (this.sessions.has(sessionId)) {
+      if (this.debug) {
+        console.log(`  [resume] Session already active for ${persistedSession.threadId.substring(0, 8)}...`);
+      }
+      return false;
+    }
+    const allowedUsers = new Set(persistedSession.sessionAllowedUsers);
+    const platform = this.platforms.get(platformId);
+    if (!allowedUsers.has(username) && !platform?.isUserAllowed(username)) {
+      if (platform) {
+        await platform.createPost(`\u26A0\uFE0F @${username} is not authorized to resume this session`, persistedSession.threadId);
+      }
+      return false;
+    }
+    if (this.sessions.size >= MAX_SESSIONS) {
+      if (platform) {
+        await platform.createPost(`\u26A0\uFE0F **Too busy** - ${this.sessions.size} sessions active. Please try again later.`, persistedSession.threadId);
+      }
+      return false;
+    }
+    const shortId = persistedSession.threadId.substring(0, 8);
+    console.log(`  \uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
+    await resumeSession(persistedSession, this.getLifecycleContext());
+    return true;
+  }
   async handleSessionReaction(session, postId, emojiName, username) {
     if (session.worktreePromptPostId === postId && emojiName === "x") {
       await handleWorktreeSkip(session, username, (s) => this.persistSession(s), (s, q) => this.offerContextPrompt(s, q));
@@ -20178,13 +20451,15 @@ class SessionManager {
       sessionStartPostId: session.sessionStartPostId,
       tasksPostId: session.tasksPostId,
       lastTasksContent: session.lastTasksContent,
+      tasksCompleted: session.tasksCompleted,
       worktreeInfo: session.worktreeInfo,
       pendingWorktreePrompt: session.pendingWorktreePrompt,
       worktreePromptDisabled: session.worktreePromptDisabled,
       queuedPrompt: session.queuedPrompt,
       firstPrompt: session.firstPrompt,
       pendingContextPrompt: persistedContextPrompt,
-      needsContextPromptOnNextMessage: session.needsContextPromptOnNextMessage
+      needsContextPromptOnNextMessage: session.needsContextPromptOnNextMessage,
+      timeoutPostId: session.timeoutPostId
     };
     this.sessionStore.save(session.sessionId, state);
   }
@@ -20426,7 +20701,7 @@ class SessionManager {
 var dim2 = (s) => `\x1B[2m${s}\x1B[0m`;
 var bold2 = (s) => `\x1B[1m${s}\x1B[0m`;
 var cyan = (s) => `\x1B[36m${s}\x1B[0m`;
-program.name("claude-threads").version(VERSION).description("Share Claude Code sessions in Mattermost").option("--url <url>", "Mattermost server URL").option("--token <token>", "Mattermost bot token").option("--channel <id>", "Mattermost channel ID").option("--bot-name <name>", "Bot mention name (default: claude-code)").option("--allowed-users <users>", "Comma-separated allowed usernames").option("--skip-permissions", "Skip interactive permission prompts").option("--no-skip-permissions", "Enable interactive permission prompts (override env)").option("--chrome", "Enable Claude in Chrome integration").option("--no-chrome", "Disable Claude in Chrome integration").option("--worktree-mode <mode>", "Git worktree mode: off, prompt, require (default: prompt)").option("--setup", "Run interactive setup wizard (reconfigure existing settings)").option("--debug", "Enable debug logging").parse();
+program.name("claude-threads").version(VERSION).description("Share Claude Code sessions in Mattermost").option("--url <url>", "Mattermost server URL").option("--token <token>", "Mattermost bot token").option("--channel <id>", "Mattermost channel ID").option("--bot-name <name>", "Bot mention name (default: claude-code)").option("--allowed-users <users>", "Comma-separated allowed usernames").option("--skip-permissions", "Skip interactive permission prompts").option("--no-skip-permissions", "Enable interactive permission prompts (override env)").option("--chrome", "Enable Claude in Chrome integration").option("--no-chrome", "Disable Claude in Chrome integration").option("--worktree-mode <mode>", "Git worktree mode: off, prompt, require (default: prompt)").option("--keep-alive", "Enable system sleep prevention (default: enabled)").option("--no-keep-alive", "Disable system sleep prevention").option("--setup", "Run interactive setup wizard (reconfigure existing settings)").option("--debug", "Enable debug logging").parse();
 var opts = program.opts();
 function hasRequiredCliArgs(args) {
   return !!(args.url && args.token && args.channel);
@@ -20444,7 +20719,8 @@ async function main() {
     allowedUsers: opts.allowedUsers,
     skipPermissions: opts.skipPermissions,
     chrome: opts.chrome,
-    worktreeMode: opts.worktreeMode
+    worktreeMode: opts.worktreeMode,
+    keepAlive: opts.keepAlive
   };
   if (opts.setup) {
     await runOnboarding(true);
@@ -20462,6 +20738,11 @@ async function main() {
   if (cliArgs.worktreeMode !== undefined) {
     newConfig.worktreeMode = cliArgs.worktreeMode;
   }
+  if (cliArgs.keepAlive !== undefined) {
+    newConfig.keepAlive = cliArgs.keepAlive;
+  }
+  const keepAliveEnabled = newConfig.keepAlive !== false;
+  keepAlive.setEnabled(keepAliveEnabled);
   const platformConfig = newConfig.platforms.find((p) => p.type === "mattermost");
   if (!platformConfig) {
     throw new Error("No Mattermost platform configured.");
@@ -20481,6 +20762,9 @@ async function main() {
   if (config.chrome) {
     console.log(`  \uD83C\uDF10 ${dim2("Chrome integration enabled")}`);
   }
+  if (keepAliveEnabled) {
+    console.log(`  \u2615 ${dim2("Keep-alive enabled")}`);
+  }
   console.log("");
   const mattermost = new MattermostClient(platformConfig);
   const session = new SessionManager(workingDir, platformConfig.skipPermissions, config.chrome, config.worktreeMode);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",