claude-threads 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -7,6 +7,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.43.0] - 2026-01-07
+
+### Added
+- **Auto-restart on updates** - Bot automatically restarts after installing updates when running with daemon wrapper
+- **`!update` command family** - Check update status, force immediate update (`!update now`), or defer (`!update defer`)
+- **`--auto-restart` / `--no-auto-restart` CLI flags** - Control auto-restart behavior (enabled by default when `autoUpdate.enabled`)
+
+### Changed
+- **Platform-specific formatting for update messages** - Update notifications now use proper bold/italic formatting per platform (Mattermost vs Slack)
+- **Improved daemon wrapper** - Now correctly uses local binary instead of global installation
+
 ## [0.42.0] - 2026-01-07
 
 ### Fixed

package/bin/claude-threads-daemon

@@ -0,0 +1,151 @@
+#!/usr/bin/env bash
+#
+# claude-threads-daemon - Auto-restart wrapper for claude-threads
+#
+# This script runs claude-threads and automatically restarts it when
+# it exits with code 42 (the special "update restart" signal).
+#
+# For other exit codes:
+# - 0: Clean exit, don't restart
+# - 1+: Error, optional restart based on flags
+#
+# Usage:
+#   claude-threads-daemon [options]
+#   claude-threads-daemon --restart-on-error  # Also restart on errors
+#   claude-threads-daemon --max-restarts 10   # Limit restart count
+#
+# Environment variables:
+#   CLAUDE_THREADS_MAX_RESTARTS - Maximum restart attempts (default: unlimited)
+#   CLAUDE_THREADS_RESTART_DELAY - Delay between restarts in seconds (default: 2)
+#
+
+set -e
+
+# Exit code that signals "restart for update"
+RESTART_EXIT_CODE=42
+
+# Configuration
+MAX_RESTARTS=${CLAUDE_THREADS_MAX_RESTARTS:-0}  # 0 = unlimited
+RESTART_DELAY=${CLAUDE_THREADS_RESTART_DELAY:-2}
+RESTART_ON_ERROR=false
+VERBOSE=false
+
+# Path to claude-threads binary (set by index.ts when spawning daemon)
+# Falls back to global 'claude-threads' command if not set
+# If CLAUDE_THREADS_BIN is a .js file, run it with bun
+if [ -n "$CLAUDE_THREADS_BIN" ]; then
+    if [[ "$CLAUDE_THREADS_BIN" == *.js ]]; then
+        CLAUDE_THREADS_CMD="bun $CLAUDE_THREADS_BIN"
+    else
+        CLAUDE_THREADS_CMD="$CLAUDE_THREADS_BIN"
+    fi
+else
+    CLAUDE_THREADS_CMD="claude-threads"
+fi
+
+# Track restart count
+restart_count=0
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        --restart-on-error)
+            RESTART_ON_ERROR=true
+            shift
+            ;;
+        --max-restarts)
+            MAX_RESTARTS="$2"
+            shift 2
+            ;;
+        --restart-delay)
+            RESTART_DELAY="$2"
+            shift 2
+            ;;
+        --verbose|-v)
+            VERBOSE=true
+            shift
+            ;;
+        --help|-h)
+            echo "claude-threads-daemon - Auto-restart wrapper for claude-threads"
+            echo ""
+            echo "Usage: claude-threads-daemon [options]"
+            echo ""
+            echo "Options:"
+            echo "  --restart-on-error    Also restart on non-zero exit codes"
+            echo "  --max-restarts N      Maximum number of restarts (default: unlimited)"
+            echo "  --restart-delay N     Seconds to wait between restarts (default: 2)"
+            echo "  --verbose, -v         Print debug information"
+            echo "  --help, -h            Show this help message"
+            echo ""
+            echo "Exit codes:"
+            echo "  0     Clean exit, no restart"
+            echo "  42    Update restart signal (always restarts)"
+            echo "  other Error (restarts only with --restart-on-error)"
+            exit 0
+            ;;
+        *)
+            # Pass through to claude-threads
+            break
+            ;;
+    esac
+done
+
+log() {
+    if [ "$VERBOSE" = true ]; then
+        echo "[daemon] $*" >&2
+    fi
+}
+
+log "Starting claude-threads daemon"
+log "Binary: $CLAUDE_THREADS_CMD"
+log "Max restarts: ${MAX_RESTARTS:-unlimited}"
+log "Restart delay: ${RESTART_DELAY}s"
+log "Restart on error: $RESTART_ON_ERROR"
+
+while true; do
+    log "Starting claude-threads (restart #$restart_count)..."
+
+    # Run claude-threads with any remaining arguments
+    # Note: CLAUDE_THREADS_CMD may be "bun /path/to/file.js" so we use eval
+    set +e
+    eval $CLAUDE_THREADS_CMD '"$@"'
+    exit_code=$?
+    set -e
+
+    log "claude-threads exited with code $exit_code"
+
+    # Check if we should restart
+    should_restart=false
+
+    if [ $exit_code -eq $RESTART_EXIT_CODE ]; then
+        # Exit code 42 = restart for update
+        log "Received update restart signal"
+        should_restart=true
+    elif [ $exit_code -eq 0 ]; then
+        # Clean exit
+        log "Clean exit, not restarting"
+        should_restart=false
+    elif [ "$RESTART_ON_ERROR" = true ]; then
+        # Error exit with restart-on-error enabled
+        log "Error exit, restarting due to --restart-on-error"
+        should_restart=true
+    fi
+
+    if [ "$should_restart" = false ]; then
+        log "Exiting daemon with code $exit_code"
+        exit $exit_code
+    fi
+
+    # Check max restarts
+    if [ $MAX_RESTARTS -gt 0 ]; then
+        restart_count=$((restart_count + 1))
+        if [ $restart_count -ge $MAX_RESTARTS ]; then
+            echo "[daemon] Maximum restart count ($MAX_RESTARTS) reached, exiting" >&2
+            exit 1
+        fi
+    fi
+
+    # Wait before restart
+    log "Waiting ${RESTART_DELAY}s before restart..."
+    sleep "$RESTART_DELAY"
+done

package/dist/index.js

@@ -51460,6 +51460,74 @@ async function updateSessionHeader(session, ctx) {
   const postId = session.sessionStartPostId;
   await withErrorHandling(() => session.platform.updatePost(postId, msg), { action: "Update session header", session });
 }
+async function showUpdateStatus(session, updateManager) {
+  const formatter = session.platform.getFormatter();
+  if (!updateManager) {
+    await postInfo(session, `Auto-update is not available`);
+    return;
+  }
+  if (!updateManager.isEnabled()) {
+    await postInfo(session, `Auto-update is disabled in configuration`);
+    return;
+  }
+  const updateInfo = await updateManager.checkNow();
+  if (!updateInfo || !updateInfo.available) {
+    await postSuccess(session, `${formatter.formatBold("Up to date")} - no updates available`);
+    return;
+  }
+  const scheduledAt = updateManager.getScheduledRestartAt();
+  const config = updateManager.getConfig();
+  let statusLine;
+  if (scheduledAt) {
+    const secondsRemaining = Math.max(0, Math.round((scheduledAt.getTime() - Date.now()) / 1000));
+    statusLine = `Restarting in ${secondsRemaining} seconds`;
+  } else {
+    statusLine = `Mode: ${config.autoRestartMode}`;
+  }
+  await postInfo(session, `\uD83D\uDD04 ${formatter.formatBold("Update available")}
+
+` + `Current: v${updateInfo.currentVersion}
+` + `Latest: v${updateInfo.latestVersion}
+` + `${statusLine}
+
+` + `Commands:
+` + `\u2022 ${formatter.formatCode("!update now")} - Update immediately
+` + `\u2022 ${formatter.formatCode("!update defer")} - Defer for 1 hour`);
+}
+async function forceUpdateNow(session, username, updateManager) {
+  if (!await requireSessionOwner(session, username, "force updates")) {
+    return;
+  }
+  const formatter = session.platform.getFormatter();
+  if (!updateManager) {
+    await postWarning(session, `Auto-update is not available`);
+    return;
+  }
+  if (!updateManager.hasUpdate()) {
+    await postInfo(session, `No update available to install`);
+    return;
+  }
+  await postInfo(session, `\uD83D\uDD04 ${formatter.formatBold("Forcing update")} - restarting shortly...
+` + formatter.formatItalic("Sessions will resume automatically"));
+  await updateManager.forceUpdate();
+}
+async function deferUpdate(session, username, updateManager) {
+  if (!await requireSessionOwner(session, username, "defer updates")) {
+    return;
+  }
+  const formatter = session.platform.getFormatter();
+  if (!updateManager) {
+    await postWarning(session, `Auto-update is not available`);
+    return;
+  }
+  if (!updateManager.hasUpdate()) {
+    await postInfo(session, `No pending update to defer`);
+    return;
+  }
+  updateManager.deferUpdate(60);
+  await postSuccess(session, `\u23F8\uFE0F ${formatter.formatBold("Update deferred")} for 1 hour
+` + formatter.formatItalic("Use !update now to apply earlier"));
+}
 
 // src/session/lifecycle.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -51529,6 +51597,9 @@ Users can control sessions with these commands:
 - \`!kick @user\`: Remove a user from the session
 - \`!cd /path\`: Change working directory (restarts the session)
 - \`!permissions interactive|skip\`: Toggle permission prompts
+- \`!update\`: Show auto-update status
+- \`!update now\`: Apply pending update immediately
+- \`!update defer\`: Defer pending update for 1 hour
 
 SESSION METADATA: At the START of your first response, include metadata about this session:
 
@@ -52848,6 +52919,18 @@ async function buildStatusBar(sessionCount, config, formatter, platformId) {
   if (pausedPlatforms.get(platformId)) {
     items.push(formatter.formatCode("\u23F8\uFE0F Platform paused"));
   }
+  if (config.updateStatus?.available) {
+    const status = config.updateStatus;
+    if (status.countdownSeconds !== undefined && status.countdownSeconds > 0) {
+      items.push(formatter.formatCode(`\uD83D\uDD04 Restarting in ${status.countdownSeconds}s`));
+    } else if (status.status === "installing") {
+      items.push(formatter.formatCode(`\uD83D\uDCE6 Installing v${status.latestVersion}...`));
+    } else if (status.status === "available") {
+      items.push(formatter.formatCode(`\uD83C\uDD95 Update: v${status.latestVersion}`));
+    } else if (status.status === "deferred") {
+      items.push(formatter.formatCode(`\u23F8\uFE0F Update deferred`));
+    }
+  }
   const claudeVersion = getClaudeCliVersion();
   const versionStr = claudeVersion ? `v${VERSION} \xB7 CLI ${claudeVersion}` : `v${VERSION}`;
   items.push(formatter.formatCode(versionStr));
@@ -53143,6 +53226,7 @@ class SessionManager extends EventEmitter4 {
   sessionStore;
   cleanupTimer = null;
   isShuttingDown = false;
+  autoUpdateManager = null;
   constructor(workingDir, skipPermissions = false, chromeEnabled = false, worktreeMode = "prompt", sessionsPath) {
     super();
     this.workingDir = workingDir;
@@ -53179,6 +53263,9 @@ class SessionManager extends EventEmitter4 {
   removePlatform(platformId) {
     this.platforms.delete(platformId);
   }
+  setAutoUpdateManager(manager) {
+    this.autoUpdateManager = manager;
+  }
   registerWorktreeUser(worktreePath, sessionId) {
     if (!this.worktreeUsers.has(worktreePath)) {
       this.worktreeUsers.set(worktreePath, new Set);
@@ -53789,6 +53876,24 @@ class SessionManager extends EventEmitter4 {
       return;
     await enableInteractivePermissions(session, username, this.getContext());
   }
+  async showUpdateStatus(threadId, _username) {
+    const session = this.findSessionByThreadId(threadId);
+    if (!session)
+      return;
+    await showUpdateStatus(session, this.autoUpdateManager);
+  }
+  async forceUpdateNow(threadId, username) {
+    const session = this.findSessionByThreadId(threadId);
+    if (!session)
+      return;
+    await forceUpdateNow(session, username, this.autoUpdateManager);
+  }
+  async deferUpdate(threadId, username) {
+    const session = this.findSessionByThreadId(threadId);
+    if (!session)
+      return;
+    await deferUpdate(session, username, this.autoUpdateManager);
+  }
   isSessionInteractive(threadId) {
     const session = this.findSessionByThreadId(threadId);
     if (!session)
@@ -53928,6 +54033,60 @@ class SessionManager extends EventEmitter4 {
     this.isShuttingDown = true;
     setShuttingDown(true);
   }
+  getActivityInfo() {
+    const sessions = [...this.sessions.values()];
+    if (sessions.length === 0) {
+      return {
+        activeSessionCount: 0,
+        lastActivityAt: null,
+        anySessionBusy: false
+      };
+    }
+    let lastActivity = null;
+    let anyBusy = false;
+    for (const session of sessions) {
+      if (!lastActivity || session.lastActivityAt > lastActivity) {
+        lastActivity = session.lastActivityAt;
+      }
+      if (session.typingTimer !== null) {
+        anyBusy = true;
+      }
+    }
+    return {
+      activeSessionCount: sessions.length,
+      lastActivityAt: lastActivity,
+      anySessionBusy: anyBusy
+    };
+  }
+  async broadcastToAll(messageBuilder) {
+    for (const session of this.sessions.values()) {
+      try {
+        const formatter = session.platform.getFormatter();
+        const message = messageBuilder(formatter);
+        await postInfo(session, message);
+      } catch (err) {
+        log18.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
+      }
+    }
+  }
+  async postUpdateAskMessage(threadIds, version) {
+    for (const threadId of threadIds) {
+      const session = this.findSessionByThreadId(threadId);
+      if (!session)
+        continue;
+      try {
+        const fmt = session.platform.getFormatter();
+        const message = `\uD83D\uDD04 ${fmt.formatBold("Update available:")} v${version}
+
+` + `React: \uD83D\uDC4D to update now | \uD83D\uDC4E to defer for 1 hour
+` + fmt.formatItalic("Update will proceed automatically after timeout if no response");
+        const post = await session.platform.createInteractivePost(message, ["\uD83D\uDC4D", "\uD83D\uDC4E"], session.threadId);
+        this.registerPost(post.id, session.threadId);
+      } catch (err) {
+        log18.warn(`Failed to post ask message to ${threadId}: ${err}`);
+      }
+    }
+  }
   async shutdown(message) {
     this.isShuttingDown = true;
     if (this.cleanupTimer) {
@@ -63380,6 +63539,9 @@ async function handleMessage(client, session, post, user, options) {
           [code("!kick @user"), "Remove an invited user"],
           [code("!permissions interactive"), "Enable interactive permissions"],
           [code("!approve"), "Approve pending plan (alternative to \uD83D\uDC4D reaction)"],
+          [code("!update"), "Show auto-update status"],
+          [code("!update now"), "Apply pending update immediately"],
+          [code("!update defer"), "Defer pending update for 1 hour"],
           [code("!escape"), "Interrupt current task (session stays active)"],
           [code("!stop"), "Stop this session"],
           [code("!kill"), "Emergency shutdown (kills ALL sessions, exits bot)"]
@@ -63430,6 +63592,18 @@ Release notes not available. See ${formatter.formatLink("GitHub releases", "http
         await session.changeDirectory(threadRoot, cdMatch[1].trim(), username);
         return;
       }
+      const updateMatch = content.trim().match(/^!update(?:\s+(now|defer))?$/i);
+      if (updateMatch) {
+        const subcommand = updateMatch[1]?.toLowerCase();
+        if (subcommand === "now") {
+          await session.forceUpdateNow(threadRoot, username);
+        } else if (subcommand === "defer") {
+          await session.deferUpdate(threadRoot, username);
+        } else {
+          await session.showUpdateStatus(threadRoot, username);
+        }
+        return;
+      }
       const worktreeMatch = content.match(/^!worktree\s+(\S+)(?:\s+(.*))?$/i);
       if (worktreeMatch) {
         const subcommand = worktreeMatch[1].toLowerCase();
@@ -63535,6 +63709,681 @@ Release notes not available. See ${formatter.formatLink("GitHub releases", "http
   }
 }
 
+// src/auto-update/manager.ts
+import { EventEmitter as EventEmitter9 } from "events";
+
+// src/auto-update/checker.ts
+import { EventEmitter as EventEmitter7 } from "events";
+var log19 = createLogger("checker");
+var PACKAGE_NAME2 = "claude-threads";
+function compareVersions(a, b) {
+  const partsA = a.replace(/^v/, "").split(".").map(Number);
+  const partsB = b.replace(/^v/, "").split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA > numB)
+      return 1;
+    if (numA < numB)
+      return -1;
+  }
+  return 0;
+}
+async function fetchLatestVersion() {
+  try {
+    const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME2}/latest`, {
+      headers: {
+        Accept: "application/json"
+      }
+    });
+    if (!response.ok) {
+      log19.warn(`Failed to fetch latest version: HTTP ${response.status}`);
+      return null;
+    }
+    const data = await response.json();
+    return data.version ?? null;
+  } catch (err) {
+    log19.warn(`Failed to fetch latest version: ${err}`);
+    return null;
+  }
+}
+
+class UpdateChecker extends EventEmitter7 {
+  config;
+  checkInterval = null;
+  lastCheck = null;
+  lastUpdateInfo = null;
+  isChecking = false;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  start() {
+    if (!this.config.enabled) {
+      log19.debug("Auto-update disabled, not starting checker");
+      return;
+    }
+    setTimeout(() => {
+      this.check().catch((err) => {
+        log19.warn(`Initial update check failed: ${err}`);
+      });
+    }, 5000);
+    const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
+    this.checkInterval = setInterval(() => {
+      this.check().catch((err) => {
+        log19.warn(`Periodic update check failed: ${err}`);
+      });
+    }, intervalMs);
+    log19.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
+  }
+  stop() {
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+    log19.debug("Update checker stopped");
+  }
+  async check() {
+    if (this.isChecking) {
+      log19.debug("Check already in progress, skipping");
+      return this.lastUpdateInfo;
+    }
+    this.isChecking = true;
+    this.emit("check:start");
+    try {
+      log19.debug("Checking for updates...");
+      const latestVersion2 = await fetchLatestVersion();
+      if (!latestVersion2) {
+        this.emit("check:complete", false);
+        return null;
+      }
+      this.lastCheck = new Date;
+      const currentVersion = VERSION;
+      const hasUpdate = compareVersions(latestVersion2, currentVersion) > 0;
+      if (hasUpdate) {
+        const updateInfo = {
+          available: true,
+          currentVersion,
+          latestVersion: latestVersion2,
+          detectedAt: new Date
+        };
+        if (!this.lastUpdateInfo || this.lastUpdateInfo.latestVersion !== latestVersion2) {
+          log19.info(`\uD83C\uDD95 Update available: v${currentVersion} \u2192 v${latestVersion2}`);
+          this.lastUpdateInfo = updateInfo;
+          this.emit("update", updateInfo);
+        }
+        this.emit("check:complete", true);
+        return updateInfo;
+      }
+      log19.debug(`Up to date (v${currentVersion})`);
+      this.emit("check:complete", false);
+      return null;
+    } catch (err) {
+      log19.warn(`Update check failed: ${err}`);
+      this.emit("check:error", err);
+      return null;
+    } finally {
+      this.isChecking = false;
+    }
+  }
+  getLastUpdateInfo() {
+    return this.lastUpdateInfo;
+  }
+  getLastCheckTime() {
+    return this.lastCheck;
+  }
+  updateConfig(config) {
+    const oldInterval = this.config.checkIntervalMinutes;
+    this.config = config;
+    if (config.checkIntervalMinutes !== oldInterval && this.checkInterval) {
+      this.stop();
+      this.start();
+    }
+  }
+}
+
+// src/auto-update/scheduler.ts
+import { EventEmitter as EventEmitter8 } from "events";
+
+// src/auto-update/types.ts
+var RESTART_EXIT_CODE = 42;
+var DEFAULT_CHECK_INTERVAL_MINUTES = 60;
+var DEFAULT_IDLE_TIMEOUT_MINUTES = 5;
+var DEFAULT_QUIET_TIMEOUT_MINUTES = 10;
+var DEFAULT_ASK_TIMEOUT_MINUTES = 30;
+var MIN_CHECK_INTERVAL_MINUTES = 5;
+var UPDATE_STATE_FILENAME = "update-state.json";
+var DEFAULT_AUTO_UPDATE_CONFIG = {
+  enabled: true,
+  checkIntervalMinutes: DEFAULT_CHECK_INTERVAL_MINUTES,
+  autoRestartMode: "idle",
+  idleTimeoutMinutes: DEFAULT_IDLE_TIMEOUT_MINUTES,
+  quietTimeoutMinutes: DEFAULT_QUIET_TIMEOUT_MINUTES,
+  scheduledWindow: {
+    startHour: 2,
+    endHour: 5
+  },
+  askTimeoutMinutes: DEFAULT_ASK_TIMEOUT_MINUTES
+};
+function mergeAutoUpdateConfig(userConfig) {
+  if (!userConfig) {
+    return { ...DEFAULT_AUTO_UPDATE_CONFIG };
+  }
+  return {
+    enabled: userConfig.enabled ?? DEFAULT_AUTO_UPDATE_CONFIG.enabled,
+    checkIntervalMinutes: Math.max(MIN_CHECK_INTERVAL_MINUTES, userConfig.checkIntervalMinutes ?? DEFAULT_AUTO_UPDATE_CONFIG.checkIntervalMinutes),
+    autoRestartMode: userConfig.autoRestartMode ?? DEFAULT_AUTO_UPDATE_CONFIG.autoRestartMode,
+    idleTimeoutMinutes: userConfig.idleTimeoutMinutes ?? DEFAULT_AUTO_UPDATE_CONFIG.idleTimeoutMinutes,
+    quietTimeoutMinutes: userConfig.quietTimeoutMinutes ?? DEFAULT_AUTO_UPDATE_CONFIG.quietTimeoutMinutes,
+    scheduledWindow: userConfig.scheduledWindow ?? DEFAULT_AUTO_UPDATE_CONFIG.scheduledWindow,
+    askTimeoutMinutes: userConfig.askTimeoutMinutes ?? DEFAULT_AUTO_UPDATE_CONFIG.askTimeoutMinutes
+  };
+}
+function isInScheduledWindow(window2) {
+  const now = new Date;
+  const hour = now.getHours();
+  if (window2.startHour > window2.endHour) {
+    return hour >= window2.startHour || hour < window2.endHour;
+  }
+  return hour >= window2.startHour && hour < window2.endHour;
+}
+
+// src/auto-update/scheduler.ts
+var log20 = createLogger("scheduler");
+
+class UpdateScheduler extends EventEmitter8 {
+  config;
+  getSessionActivity;
+  getActiveThreadIds;
+  postAskMessage;
+  pendingUpdate = null;
+  checkTimer = null;
+  countdownTimer = null;
+  idleStartTime = null;
+  scheduledRestartAt = null;
+  askApprovals = new Map;
+  askStartTime = null;
+  constructor(config, getSessionActivity, getActiveThreadIds, postAskMessage) {
+    super();
+    this.config = config;
+    this.getSessionActivity = getSessionActivity;
+    this.getActiveThreadIds = getActiveThreadIds;
+    this.postAskMessage = postAskMessage;
+  }
+  scheduleUpdate(updateInfo) {
+    this.pendingUpdate = updateInfo;
+    if (this.config.autoRestartMode === "immediate") {
+      log20.info("Immediate mode: triggering update now");
+      this.emit("ready", updateInfo);
+      return;
+    }
+    this.startChecking();
+  }
+  cancelSchedule() {
+    this.stopChecking();
+    this.pendingUpdate = null;
+    this.idleStartTime = null;
+    this.scheduledRestartAt = null;
+    this.askApprovals.clear();
+    this.askStartTime = null;
+    log20.debug("Update schedule cancelled");
+  }
+  deferUpdate(minutes) {
+    const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
+    this.scheduledRestartAt = null;
+    this.idleStartTime = null;
+    this.emit("deferred", deferUntil);
+    log20.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
+    return deferUntil;
+  }
+  recordAskResponse(threadId, approved) {
+    this.askApprovals.set(threadId, approved);
+    log20.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
+    this.checkAskCondition();
+  }
+  getScheduledRestartAt() {
+    return this.scheduledRestartAt;
+  }
+  getPendingUpdate() {
+    return this.pendingUpdate;
+  }
+  updateConfig(config) {
+    this.config = config;
+  }
+  stop() {
+    this.stopChecking();
+    this.stopCountdown();
+  }
+  startChecking() {
+    if (this.checkTimer)
+      return;
+    this.checkCondition();
+    this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
+    log20.debug(`Started checking for ${this.config.autoRestartMode} condition`);
+  }
+  stopChecking() {
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = null;
+    }
+  }
+  checkCondition() {
+    if (!this.pendingUpdate)
+      return;
+    switch (this.config.autoRestartMode) {
+      case "idle":
+        this.checkIdleCondition();
+        break;
+      case "quiet":
+        this.checkQuietCondition();
+        break;
+      case "scheduled":
+        this.checkScheduledCondition();
+        break;
+      case "ask":
+        this.checkAskCondition();
+        break;
+    }
+  }
+  checkIdleCondition() {
+    const activity = this.getSessionActivity();
+    if (activity.activeSessionCount === 0) {
+      if (!this.idleStartTime) {
+        this.idleStartTime = new Date;
+        log20.debug("No active sessions, starting idle timer");
+      }
+      const idleMs = Date.now() - this.idleStartTime.getTime();
+      const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
+      if (idleMs >= requiredMs) {
+        log20.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
+        this.triggerCountdown();
+      }
+    } else {
+      if (this.idleStartTime) {
+        log20.debug("Sessions became active, resetting idle timer");
+        this.idleStartTime = null;
+      }
+    }
+  }
+  checkQuietCondition() {
+    const activity = this.getSessionActivity();
+    if (activity.lastActivityAt) {
+      const quietMs = Date.now() - activity.lastActivityAt.getTime();
+      const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
+      if (quietMs >= requiredMs && !activity.anySessionBusy) {
+        log20.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
+        this.triggerCountdown();
+      }
+    } else if (activity.activeSessionCount === 0) {
+      if (!this.idleStartTime) {
+        this.idleStartTime = new Date;
+      }
+      const idleMs = Date.now() - this.idleStartTime.getTime();
+      const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
+      if (idleMs >= requiredMs) {
+        log20.info("No sessions and quiet timeout reached, triggering update");
+        this.triggerCountdown();
+      }
+    }
+  }
+  checkScheduledCondition() {
+    if (!isInScheduledWindow(this.config.scheduledWindow)) {
+      return;
+    }
+    const activity = this.getSessionActivity();
+    if (activity.activeSessionCount === 0) {
+      log20.info("Within scheduled window and no active sessions, triggering update");
+      this.triggerCountdown();
+    } else if (activity.lastActivityAt) {
+      const quietMs = Date.now() - activity.lastActivityAt.getTime();
+      const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
+      if (quietMs >= requiredMs && !activity.anySessionBusy) {
+        log20.info("Within scheduled window and sessions quiet, triggering update");
+        this.triggerCountdown();
+      }
+    }
+  }
+  checkAskCondition() {
+    const threadIds = this.getActiveThreadIds();
+    if (threadIds.length === 0) {
+      log20.info("No active threads, proceeding with update");
+      this.triggerCountdown();
+      return;
+    }
+    if (!this.askStartTime && this.pendingUpdate) {
+      this.askStartTime = new Date;
+      this.postAskMessage(threadIds, this.pendingUpdate.latestVersion).catch((err) => {
+        log20.warn(`Failed to post ask message: ${err}`);
+      });
+      return;
+    }
+    let approvals = 0;
+    let denials = 0;
+    for (const approved of this.askApprovals.values()) {
+      if (approved)
+        approvals++;
+      else
+        denials++;
+    }
+    if (approvals > threadIds.length / 2) {
+      log20.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
+      this.triggerCountdown();
+      return;
+    }
+    if (denials > threadIds.length / 2) {
+      log20.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
+      this.deferUpdate(60);
+      return;
+    }
+    if (this.askStartTime) {
+      const elapsedMs = Date.now() - this.askStartTime.getTime();
+      const timeoutMs = this.config.askTimeoutMinutes * 60 * 1000;
+      if (elapsedMs >= timeoutMs) {
+        log20.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
+        this.triggerCountdown();
+      }
+    }
+  }
+  triggerCountdown() {
+    if (!this.pendingUpdate)
+      return;
+    this.stopChecking();
+    this.scheduledRestartAt = new Date(Date.now() + 60000);
+    let secondsRemaining = 60;
+    this.emit("countdown", secondsRemaining);
+    this.countdownTimer = setInterval(() => {
+      secondsRemaining--;
+      this.emit("countdown", secondsRemaining);
+      if (secondsRemaining <= 0) {
+        this.stopCountdown();
+        this.emit("ready", this.pendingUpdate);
+      }
+    }, 1000);
+    log20.info("Update countdown started (60 seconds)");
+  }
+  stopCountdown() {
+    if (this.countdownTimer) {
+      clearInterval(this.countdownTimer);
+      this.countdownTimer = null;
+    }
+  }
+}
+
+// src/auto-update/installer.ts
+import { spawn as spawn5 } from "child_process";
+import { existsSync as existsSync11, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { dirname as dirname6, resolve as resolve6 } from "path";
+import { homedir as homedir4 } from "os";
+var log21 = createLogger("installer");
+var STATE_PATH = resolve6(homedir4(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
+var PACKAGE_NAME3 = "claude-threads";
+function loadUpdateState() {
+  try {
+    if (existsSync11(STATE_PATH)) {
+      const content = readFileSync8(STATE_PATH, "utf-8");
+      return JSON.parse(content);
+    }
+  } catch (err) {
+    log21.warn(`Failed to load update state: ${err}`);
+  }
+  return {};
+}
+function saveUpdateState(state) {
+  try {
+    const dir = dirname6(STATE_PATH);
+    if (!existsSync11(dir)) {
+      mkdirSync3(dir, { recursive: true });
+    }
+    writeFileSync4(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
+    log21.debug("Update state saved");
+  } catch (err) {
+    log21.warn(`Failed to save update state: ${err}`);
+  }
+}
+function clearUpdateState() {
+  try {
+    if (existsSync11(STATE_PATH)) {
+      writeFileSync4(STATE_PATH, "{}", "utf-8");
+    }
+  } catch (err) {
+    log21.warn(`Failed to clear update state: ${err}`);
+  }
+}
+function checkJustUpdated() {
+  const state = loadUpdateState();
+  if (state.justUpdated && state.previousVersion) {
+    saveUpdateState({
+      ...state,
+      justUpdated: false
+    });
+    return {
+      previousVersion: state.previousVersion,
+      currentVersion: VERSION
+    };
+  }
+  return null;
+}
+async function installVersion(version) {
+  log21.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME3}@${version}...`);
+  saveUpdateState({
+    previousVersion: VERSION,
+    targetVersion: version,
+    startedAt: new Date().toISOString(),
+    justUpdated: false
+  });
+  return new Promise((resolve7) => {
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    const child = spawn5(npmCmd, ["install", "-g", `${PACKAGE_NAME3}@${version}`], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        npm_config_progress: "false"
+      }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        log21.info(`\u2705 Successfully installed ${PACKAGE_NAME3}@${version}`);
+        saveUpdateState({
+          previousVersion: VERSION,
+          targetVersion: version,
+          startedAt: new Date().toISOString(),
+          justUpdated: true
+        });
+        resolve7({ success: true });
+      } else {
+        const errorMsg = stderr || stdout || `Exit code: ${code}`;
+        log21.error(`\u274C Installation failed: ${errorMsg}`);
+        clearUpdateState();
+        resolve7({ success: false, error: errorMsg });
+      }
+    });
+    child.on("error", (err) => {
+      log21.error(`\u274C Failed to spawn npm: ${err}`);
+      clearUpdateState();
+      resolve7({ success: false, error: err.message });
+    });
+    setTimeout(() => {
+      if (child.exitCode === null) {
+        child.kill();
+        log21.error("\u274C Installation timed out");
+        clearUpdateState();
+        resolve7({ success: false, error: "Installation timed out" });
+      }
+    }, 5 * 60 * 1000);
+  });
+}
+function getRollbackInstructions(previousVersion) {
+  return `To rollback to the previous version, run:
+  npm install -g ${PACKAGE_NAME3}@${previousVersion}`;
+}
+
+class UpdateInstaller {
+  isInstalling = false;
+  async install(updateInfo) {
+    if (this.isInstalling) {
+      return { success: false, error: "Installation already in progress" };
+    }
+    this.isInstalling = true;
+    try {
+      return await installVersion(updateInfo.latestVersion);
+    } finally {
+      this.isInstalling = false;
+    }
+  }
+  isInProgress() {
+    return this.isInstalling;
+  }
+  checkJustUpdated() {
+    return checkJustUpdated();
+  }
+  getState() {
+    return loadUpdateState();
+  }
+  clearState() {
+    clearUpdateState();
+  }
+}
+
+// src/auto-update/manager.ts
+var log22 = createLogger("auto-update");
+
+class AutoUpdateManager extends EventEmitter9 {
+  config;
+  callbacks;
+  checker;
+  scheduler;
+  installer;
+  state = {
+    status: "idle"
+  };
+  deferredUntil = null;
+  constructor(configOverride, callbacks) {
+    super();
+    this.config = mergeAutoUpdateConfig(configOverride);
+    this.callbacks = callbacks;
+    this.checker = new UpdateChecker(this.config);
+    this.scheduler = new UpdateScheduler(this.config, callbacks.getSessionActivity, callbacks.getActiveThreadIds, callbacks.postAskMessage);
+    this.installer = new UpdateInstaller;
+    this.setupEventHandlers();
+  }
+  start() {
+    if (!this.config.enabled) {
+      log22.info("Auto-update is disabled");
+      return;
+    }
+    const updateResult = this.installer.checkJustUpdated();
+    if (updateResult) {
+      log22.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) => {
+        log22.warn(`Failed to broadcast update notification: ${err}`);
+      });
+    }
+    this.checker.start();
+    log22.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+  }
+  stop() {
+    this.checker.stop();
+    this.scheduler.stop();
+    log22.debug("Auto-update manager stopped");
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  async checkNow() {
+    return this.checker.check();
+  }
+  async forceUpdate() {
+    const updateInfo = this.state.updateInfo || await this.checker.check();
+    if (!updateInfo) {
+      log22.info("No update available");
+      return;
+    }
+    log22.info("Forcing immediate update");
+    await this.performUpdate(updateInfo);
+  }
+  deferUpdate(minutes = 60) {
+    this.deferredUntil = this.scheduler.deferUpdate(minutes);
+    this.updateStatus("deferred", `Deferred until ${this.deferredUntil.toLocaleTimeString()}`);
+  }
+  recordAskResponse(threadId, approved) {
+    this.scheduler.recordAskResponse(threadId, approved);
+  }
+  isEnabled() {
+    return this.config.enabled;
+  }
+  hasUpdate() {
+    return this.state.updateInfo?.available ?? false;
+  }
+  getUpdateInfo() {
+    return this.state.updateInfo;
+  }
+  getScheduledRestartAt() {
+    return this.scheduler.getScheduledRestartAt();
+  }
+  setupEventHandlers() {
+    this.checker.on("update", (info) => {
+      this.state.updateInfo = info;
+      this.updateStatus("available");
+      this.emit("update:available", info);
+      this.callbacks.refreshUI().catch(() => {});
+      this.scheduler.scheduleUpdate(info);
+    });
+    this.scheduler.on("countdown", (seconds) => {
+      this.emit("update:countdown", seconds);
+      if (seconds === 60 || seconds === 30 || seconds === 10) {
+        const latestVersion2 = this.state.updateInfo?.latestVersion;
+        this.callbacks.broadcastUpdate((fmt) => `\u23F3 ${fmt.formatBold(`Restarting in ${seconds} seconds`)} for update to v${latestVersion2}`).catch(() => {});
+      }
+    });
+    this.scheduler.on("ready", async (info) => {
+      await this.performUpdate(info);
+    });
+    this.scheduler.on("deferred", (until) => {
+      this.deferredUntil = until;
+      this.updateStatus("deferred");
+    });
+  }
+  async performUpdate(updateInfo) {
+    this.updateStatus("installing");
+    await this.callbacks.broadcastUpdate((fmt) => `\uD83D\uDCE6 ${fmt.formatBold("Installing update")} v${updateInfo.latestVersion}...`).catch(() => {});
+    const result = await this.installer.install(updateInfo);
+    if (result.success) {
+      this.updateStatus("pending_restart");
+      this.emit("update:restart", updateInfo.latestVersion);
+      await this.callbacks.broadcastUpdate((fmt) => `\u2705 ${fmt.formatBold("Update installed")} - restarting now. ${fmt.formatItalic("Sessions will resume automatically.")}`).catch(() => {});
+      await new Promise((resolve7) => setTimeout(resolve7, 1000));
+      log22.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      process.exit(RESTART_EXIT_CODE);
+    } else {
+      const errorMsg = result.error ?? "Unknown error";
+      this.state.errorMessage = errorMsg;
+      this.updateStatus("failed", errorMsg);
+      this.emit("update:failed", errorMsg);
+      const errorText = result.error;
+      await this.callbacks.broadcastUpdate((fmt) => `\u274C ${fmt.formatBold("Update failed")}: ${errorText}
+${getRollbackInstructions(VERSION)}`).catch(() => {});
+    }
+  }
+  updateStatus(status, message) {
+    this.state.status = status;
+    if (message) {
+      this.state.errorMessage = status === "failed" ? message : undefined;
+    }
+    this.emit("update:status", status, message);
+    this.callbacks.refreshUI().catch(() => {});
+  }
+}
 // src/index.ts
 function createPlatformClient(config) {
   switch (config.type) {
@@ -63572,12 +64421,56 @@ function wirePlatformEvents(platformId, client, session, ui) {
     ui.addLog({ level: "error", component: platformId, message: String(e) });
   });
 }
-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").option("--skip-version-check", "Skip Claude CLI version compatibility check").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").option("--skip-version-check", "Skip Claude CLI version compatibility check").option("--auto-restart", "Enable auto-restart on updates (default when autoUpdate enabled)").option("--no-auto-restart", "Disable auto-restart on updates").parse();
 var opts = program.opts();
 function hasRequiredCliArgs(args) {
   return !!(args.url && args.token && args.channel);
 }
 async function main() {
+  const shouldUseAutoRestart = async () => {
+    if (opts.autoRestart === false)
+      return false;
+    if (opts.autoRestart === true)
+      return true;
+    if (await configExists()) {
+      try {
+        const config2 = loadConfigWithMigration();
+        if (!config2)
+          return false;
+        return config2.autoUpdate?.enabled !== false;
+      } catch {
+        return false;
+      }
+    }
+    return false;
+  };
+  if (await shouldUseAutoRestart()) {
+    const { spawn: spawn6 } = await import("child_process");
+    const { dirname: dirname7, resolve: resolve7 } = await import("path");
+    const { fileURLToPath: fileURLToPath6 } = await import("url");
+    const __filename2 = fileURLToPath6(import.meta.url);
+    const __dirname6 = dirname7(__filename2);
+    const daemonPath = resolve7(__dirname6, "..", "bin", "claude-threads-daemon");
+    const args = process.argv.slice(2).filter((arg) => arg !== "--auto-restart" && arg !== "--no-auto-restart").concat("--no-auto-restart");
+    console.log("\uD83D\uDD04 Starting with auto-restart enabled...");
+    console.log("");
+    const binPath = __filename2;
+    const child = spawn6(daemonPath, ["--restart-on-error", ...args], {
+      stdio: "inherit",
+      env: {
+        ...process.env,
+        CLAUDE_THREADS_BIN: binPath
+      }
+    });
+    child.on("error", (err) => {
+      console.error(`Failed to start daemon: ${err.message}`);
+      process.exit(1);
+    });
+    child.on("exit", (code) => {
+      process.exit(code ?? 0);
+    });
+    return;
+  }
   checkForUpdates();
   if (opts.debug) {
     process.env.DEBUG = "1";
@@ -63634,6 +64527,7 @@ async function main() {
     keepAliveEnabled
   };
   let sessionManager = null;
+  let autoUpdateManager = null;
   const ui = await startUI({
     config: {
       version: VERSION,
@@ -63748,6 +64642,31 @@ async function main() {
     }
   }));
   await session.initialize();
+  autoUpdateManager = new AutoUpdateManager(config.autoUpdate, {
+    getSessionActivity: () => session.getActivityInfo(),
+    getActiveThreadIds: () => session.getActiveThreadIds(),
+    broadcastUpdate: (msg) => session.broadcastToAll(msg),
+    postAskMessage: (ids, ver) => session.postUpdateAskMessage(ids, ver),
+    refreshUI: () => session.updateAllStickyMessages()
+  });
+  session.setAutoUpdateManager(autoUpdateManager);
+  autoUpdateManager.on("update:available", (info) => {
+    ui.addLog({ level: "info", component: "update", message: `\uD83C\uDD95 Update available: v${info.currentVersion} \u2192 v${info.latestVersion}` });
+  });
+  autoUpdateManager.on("update:countdown", (seconds) => {
+    if (seconds === 60 || seconds === 30 || seconds === 10 || seconds <= 5) {
+      ui.addLog({ level: "info", component: "update", message: `\uD83D\uDD04 Restarting in ${seconds} seconds...` });
+    }
+  });
+  autoUpdateManager.on("update:status", (status, message) => {
+    if (message) {
+      ui.addLog({ level: "info", component: "update", message: `\uD83D\uDD04 ${status}: ${message}` });
+    }
+  });
+  autoUpdateManager.on("update:failed", (error) => {
+    ui.addLog({ level: "error", component: "update", message: `\u274C Update failed: ${error}` });
+  });
+  autoUpdateManager.start();
   ui.setReady();
   let isShuttingDown2 = false;
   const shutdown = async (_signal) => {
@@ -63755,7 +64674,7 @@ async function main() {
       return;
     isShuttingDown2 = true;
     ui.setShuttingDown();
-    await new Promise((resolve6) => setTimeout(resolve6, 50));
+    await new Promise((resolve7) => setTimeout(resolve7, 50));
     session.setShuttingDown();
     await session.updateAllStickyMessages();
     const activeCount = session.getActiveThreadIds().length;
@@ -63764,6 +64683,7 @@ async function main() {
       await session.postShutdownMessages();
     }
     await session.killAllSessions();
+    autoUpdateManager?.stop();
     for (const client of platforms.values()) {
       client.disconnect();
     }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "claude-threads",
-  "version": "0.42.0",
+  "version": "0.43.0",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
     "claude-threads": "./dist/index.js",
-    "claude-threads-mcp": "./dist/mcp/permission-server.js"
+    "claude-threads-mcp": "./dist/mcp/permission-server.js",
+    "claude-threads-daemon": "./bin/claude-threads-daemon"
   },
   "scripts": {
     "dev": "bun --watch src/index.ts",
@@ -53,6 +54,7 @@
   "homepage": "https://github.com/anneschuth/claude-threads#readme",
   "files": [
     "dist",
+    "bin",
     "README.md",
     "CHANGELOG.md",
     "LICENSE",