claude-slack-channel-bots 0.1.4 → 0.2.1

package/README.md

@@ -89,6 +89,8 @@ A skeleton file is created by postinstall. Populate it before running `start`.
   "port": 3100,
   "session_restart_delay": 60,
   "health_check_interval": 120,
+  "exit_timeout": 120,
+  "stop_timeout": 30,
   "mcp_config_path": "~/.claude/slack-mcp.json"
 }
 ```
@@ -98,12 +100,14 @@ A skeleton file is created by postinstall. Populate it before running `start`.
 | Field | Type | Default | Description |
 |---|---|---|---|
 | `routes` | object | required | Map of Slack channel ID → route entry. Each entry requires a `cwd` field: the working directory for that session. Used to identify sessions via `roots/list` after MCP handshake. `~` is expanded. Each `cwd` must be unique across all routes. |
-| `default_route` | string | — | CWD path to use when a message arrives on a channel with no explicit entry in `routes`. Must match an existing route `cwd`. |
+| `default_route` | string | — | CWD path to use when a message arrives on a channel with no explicit entry in `routes`. Must match an existing route `cwd`. Channels that are in `routes` but whose session is not yet registered have their messages dropped — they do not fall back to `default_route`. |
 | `default_dm_session` | string | — | CWD path of the session that handles direct messages. Must match an existing route `cwd`. |
 | `bind` | string | `"127.0.0.1"` | Interface the HTTP server binds to. Use `"0.0.0.0"` to expose on all interfaces. |
 | `port` | number | `3100` | Port the HTTP server listens on. |
 | `session_restart_delay` | number | `60` | Seconds to wait before auto-restarting a dead session. Set to `0` to disable auto-restart. Must be non-negative. |
 | `health_check_interval` | number | `120` | Seconds between periodic liveness polls. Set to `0` to disable. Must be non-negative. |
+| `exit_timeout` | number | `120` | Seconds to wait for a managed Claude Code session to exit gracefully during `clean_restart` before force-killing its tmux session. |
+| `stop_timeout` | number | `30` | Seconds to wait for the server process to exit after `SIGTERM` before escalating to `SIGKILL`. |
 | `mcp_config_path` | string | `~/.claude/slack-mcp.json` | Path to the MCP config file passed to Claude Code when launching managed sessions. |
 | `append_system_prompt_file` | string | — | Path to a file appended to every managed session's system prompt via `--append-system-prompt-file`. Missing file silently skipped. See `skills/EXAMPLE_CLAUDE.md` for a template. |
 
@@ -200,7 +204,7 @@ Behavior by case:
 
 - **PID file missing:** prints `server is not running` and exits 0.
 - **Stale PID file** (process no longer running): removes the PID file, prints `server is not running (removed stale PID file)`, exits 0.
-- **Live process:** sends `SIGTERM`, polls for exit every 100ms for up to 5 seconds. Prints `[slack] Server stopped.` on clean exit. Prints a warning if the server does not stop within 5 seconds (does not force-kill).
+- **Live process:** sends `SIGTERM`, polls for exit for up to `stop_timeout` seconds (default 30s). Prints `[slack] Server stopped.` on clean exit. Escalates to `SIGKILL` if the process does not exit within `stop_timeout`.
 
 ### `claude-slack-channel-bots clean_restart`
 
@@ -210,7 +214,7 @@ Gracefully exits all managed Claude Code sessions, then stops and starts the ser
 claude-slack-channel-bots clean_restart
 ```
 
-For each session in `sessions.json`, sends `/exit` to the tmux session and polls until Claude exits. All sessions are processed in parallel. If a session does not exit within 60 seconds, its tmux session is force-killed. Individual session errors are logged and do not abort the restart. After the server restarts, sessions are relaunched with `--resume` using the stored session IDs in `sessions.json`, preserving conversation context.
+For each session in `sessions.json`, sends `/exit` to the tmux session and polls until Claude exits. All sessions are processed in parallel. If a session does not exit within `exit_timeout` seconds (default 120s), its tmux session is force-killed. Individual session errors are logged and do not abort the restart. After the server restarts, sessions are relaunched with `--resume` using the stored session IDs in `sessions.json`, preserving conversation context.
 
 Behavior by case:
 
@@ -349,4 +353,4 @@ Check that the Slack app has interactivity enabled (Interactivity & Shortcuts
 After 3 consecutive launch failures for a route, auto-restart is suspended until the server is restarted. Restart the server with `claude-slack-channel-bots stop && claude-slack-channel-bots start`. To disable auto-restart entirely, set `session_restart_delay` to `0` in `routing.json`.
 
 **Session stuck during clean_restart**
-If a session does not exit within 60 seconds, `clean_restart` force-kills its tmux session and proceeds. To manually recover, run `tmux kill-session -t <session-name>` for any remaining sessions, then `claude-slack-channel-bots stop && claude-slack-channel-bots start`.
+If a session does not exit within `exit_timeout` seconds (default 120s), `clean_restart` force-kills its tmux session and proceeds. To manually recover, run `tmux kill-session -t <session-name>` for any remaining sessions, then `claude-slack-channel-bots stop && claude-slack-channel-bots start`.

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "description": "Multi-session Slack-to-Claude bridge — run multiple Claude Code bots across Slack channels via Socket Mode",
   "type": "module",
   "bin": {
-    "claude-slack-channel-bots": "./src/cli.ts"
+    "claude-slack-channel-bots": "src/cli.ts"
   },
   "files": [
     "src/*.ts",
@@ -38,6 +38,6 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/gabemahoney/claude-slack-channel-bots.git"
+    "url": "git+https://github.com/gabemahoney/claude-slack-channel-bots.git"
   }
 }

package/src/cli.ts

@@ -11,11 +11,13 @@
 
 import { homedir } from 'os'
 import { join, resolve } from 'path'
-import { existsSync, readFileSync, unlinkSync } from 'fs'
+import { existsSync, openSync, readFileSync, unlinkSync } from 'fs'
 import { spawnSync } from 'child_process'
 import { isProcessRunning } from './pid.ts'
-import { defaultTmuxClient, isClaudeRunning as tmuxIsClaudeRunning } from './tmux.ts'
+import { defaultTmuxClient, isClaudeRunning as tmuxIsClaudeRunning, sessionName as tmuxSessionName } from './tmux.ts'
 import { readSessions, type SessionsMap } from './sessions.ts'
+import { loadConfig as configLoadConfig, type RoutingConfig } from './config.ts'
+import { initLogging } from './logging.ts'
 
 // ---------------------------------------------------------------------------
 // Injectable dependency interface
@@ -44,8 +46,12 @@ export interface CliDeps {
   exit: (code: number) => never
   /** Returns true if a tmux session with the given name exists. */
   hasSession: (name: string) => Promise<boolean>
+  /** Load the routing configuration. */
+  loadConfig: () => RoutingConfig
+  /** Returns the canonical tmux session name for a given working directory path. */
+  sessionName: (cwd: string) => string
   /** Sends keystrokes to the given tmux session. */
-  sendKeys: (session: string, keys: string) => Promise<void>
+  sendKeys: (session: string, ...keys: string[]) => Promise<void>
   /** Returns true if a 'claude' process is running in the given tmux session. */
   isClaudeRunning: (session: string) => Promise<boolean>
   /** Kills the named tmux session. */
@@ -109,9 +115,11 @@ export function createCli(deps: CliDeps): CliHandlers {
     if (!process.env['_CLI_DAEMON_CHILD']) {
       // Parent: spawn a detached background child and exit
       const { spawn } = await import('child_process')
+      const logPath = join(stateDir, 'server.log')
+      const logFd = openSync(logPath, 'a')
       const child = spawn(process.execPath, [import.meta.filename, 'start'], {
         detached: true,
-        stdio: 'ignore',
+        stdio: ['ignore', logFd, logFd],
         env: { ...process.env, _CLI_DAEMON_CHILD: '1' },
       })
       child.unref()
@@ -119,6 +127,9 @@ export function createCli(deps: CliDeps): CliHandlers {
       deps.exit(0)
     }
 
+    // Child (daemon): redirect stderr/stdout to server.log
+    try { initLogging(join(stateDir, 'server.log')) } catch { /* best-effort: log redirect failure is non-fatal */ }
+
     // Child (daemon): start the server
     await deps.startServer()
   }
@@ -151,90 +162,121 @@ export function createCli(deps: CliDeps): CliHandlers {
       deps.exit(0)
     }
 
-    // Live process — send SIGTERM and poll until exit or 5s timeout
+    // Load stop_timeout from config (fall back to 30s if unavailable)
+    let stopTimeoutMs = 30_000
+    try {
+      const config = deps.loadConfig()
+      if (typeof config.stop_timeout === 'number') {
+        stopTimeoutMs = config.stop_timeout * 1000
+      }
+    } catch { /* use default */ }
+
+    // Live process — send SIGTERM and poll until exit or stop_timeout
     deps.kill(pid!, 'SIGTERM')
 
-    const deadline = Date.now() + 5000
+    const deadline = Date.now() + stopTimeoutMs
     while (Date.now() < deadline) {
       await new Promise<void>((r) => setTimeout(r, 100))
       if (!deps.isProcessRunning(pid!)) {
+        try { deps.unlinkSync(pidFile) } catch { /* ignore */ }
         console.error('[slack] Server stopped.')
         deps.exit(0)
       }
     }
 
-    console.error('[slack] Warning: server did not stop within 5s after SIGTERM.')
-    deps.exit(0)
+    // SIGTERM timed out — escalate to SIGKILL
+    console.error(`[slack] Warning: server did not stop within ${stopTimeoutMs / 1000}s after SIGTERM — sending SIGKILL.`)
+    deps.kill(pid!, 'SIGKILL')
+
+    // Poll briefly (~2s) to confirm death after SIGKILL
+    const killDeadline = Date.now() + 2000
+    while (Date.now() < killDeadline) {
+      await new Promise<void>((r) => setTimeout(r, 100))
+      if (!deps.isProcessRunning(pid!)) {
+        try { deps.unlinkSync(pidFile) } catch { /* ignore */ }
+        console.error('[slack] Server killed.')
+        deps.exit(0)
+      }
+    }
+
+    console.error('[slack] Warning: server did not die after SIGKILL.')
+    deps.exit(1)
   }
 
   async function clean_restart(): Promise<void> {
-    const sessions = deps.readSessions()
-    const entries = Object.entries(sessions)
-
-    if (entries.length > 0) {
-      console.error(`[slack] clean_restart: sending /exit to ${entries.length} session(s)`)
-
-      // Fan out: send /exit + Enter to all sessions in parallel (best-effort)
-      await Promise.all(entries.map(async ([channelId, record]) => {
-        try {
-          const exists = await deps.hasSession(record.tmuxSession)
-          if (!exists) {
-            console.error(`[slack] clean_restart: session not found for channel=${channelId}, skipping`)
-            return
-          }
-          await deps.sendKeys(record.tmuxSession, '/exit')
-          await deps.sendKeys(record.tmuxSession, 'Enter')
-          console.error(`[slack] clean_restart: sent /exit to channel=${channelId} session=${record.tmuxSession}`)
-        } catch (err) {
-          console.error(`[slack] clean_restart: error sending /exit to channel=${channelId}:`, err)
+    try { initLogging(join(deps.resolveStateDir(), 'clean_restart.log')) } catch { /* best-effort */ }
+
+    // Phase 1: Load config
+    let config: RoutingConfig
+    try {
+      config = deps.loadConfig()
+    } catch (err) {
+      console.error('[slack] clean_restart: failed to load config:', err)
+      deps.exit(1)
+    }
+    const { routes, exit_timeout } = config!
+
+    // Phase 2: Stop the server daemon
+    console.error('[slack] clean_restart: stopping server')
+    const stopResult = deps.spawnSync(process.execPath, [process.argv[1], 'stop'])
+    if (stopResult.status !== 0) {
+      console.error(`[slack] clean_restart: stop returned non-zero exit code: ${stopResult.status}`)
+    }
+
+    // Phases 3-4: Exit Claude sessions concurrently
+    await Promise.allSettled(Object.entries(routes).map(async ([channelId, route]) => {
+      const name = deps.sessionName(route.cwd)
+      try {
+        // Phase 3: Check session exists
+        const exists = await deps.hasSession(name)
+        if (!exists) {
+          console.error(`[slack] clean_restart: session not found for channel=${channelId} session=${name}`)
+          return
+        }
+
+        const claudeRunning = await deps.isClaudeRunning(name)
+        if (!claudeRunning) {
+          console.error(`[slack] clean_restart: Claude not running for channel=${channelId} session=${name}`)
+          return
         }
-      }))
-
-      // Poll each session until Claude exits or 60s timeout (best-effort)
-      await Promise.all(entries.map(async ([channelId, record]) => {
-        try {
-          const exists = await deps.hasSession(record.tmuxSession)
-          if (!exists) return
-
-          const timeout = 60_000
-          const start = Date.now()
-          let delay = 500
-          const maxDelay = 5_000
-
-          while (Date.now() - start < timeout) {
-            const running = await deps.isClaudeRunning(record.tmuxSession)
-            if (!running) {
-              console.error(`[slack] clean_restart: channel=${channelId} exited cleanly`)
-              return
-            }
-            await new Promise<void>((r) => setTimeout(r, delay))
-            delay = Math.min(delay * 2, maxDelay)
-          }
 
-          // Timed out — force kill
-          console.error(`[slack] clean_restart: timeout waiting for channel=${channelId}, force-killing`)
-          try {
-            await deps.killSession(record.tmuxSession)
-          } catch (err) {
-            console.error(`[slack] clean_restart: killSession failed for channel=${channelId}:`, err)
+        // Phase 4: Send /exit atomically
+        await deps.sendKeys(name, '/exit', 'Enter')
+
+        // Poll with exponential backoff until exit or timeout
+        const timeoutMs = exit_timeout * 1000
+        const start = Date.now()
+        let delay = 500
+        const maxDelay = 5_000
+
+        while (Date.now() - start < timeoutMs) {
+          await new Promise<void>((r) => setTimeout(r, delay))
+          delay = Math.min(delay * 2, maxDelay)
+          const running = await deps.isClaudeRunning(name)
+          if (!running) {
+            const elapsed = Date.now() - start
+            console.error(`[slack] clean_restart: channel=${channelId} session=${name} exited cleanly in ${elapsed}ms`)
+            return
           }
-        } catch (err) {
-          console.error(`[slack] clean_restart: error polling channel=${channelId}:`, err)
         }
-      }))
-    }
 
-    // Stop the server
-    console.error('[slack] clean_restart: stopping server')
-    deps.spawnSync(process.execPath, [process.argv[1], 'stop'])
+        // Timeout — force kill
+        const elapsed = Date.now() - start
+        await deps.killSession(name)
+        console.error(`[slack] clean_restart: channel=${channelId} session=${name} force-killed after ${elapsed}ms`)
+      } catch (err) {
+        console.error(`[slack] clean_restart: error processing channel=${channelId} session=${name}:`, err)
+      }
+    }))
 
-    // Start the server
+    // Phases 5-6: Start new server and exit
     console.error('[slack] clean_restart: starting server')
     const startResult = deps.spawnSync(process.execPath, [process.argv[1], 'start'])
     if (startResult.status !== 0) {
       console.error(`[slack] clean_restart: start failed with exit code ${startResult.status}`)
       deps.exit(startResult.status ?? 1)
     }
+    console.error('[slack] clean_restart: done')
   }
 
   return { start, stop, clean_restart }
@@ -267,8 +309,10 @@ if (import.meta.main) {
     resolveStateDir: defaultStateDir,
     startServer: async () => { const { main } = await import('./server.ts'); return main() },
     exit: (code) => process.exit(code),
+    loadConfig: () => configLoadConfig(),
+    sessionName: (cwd) => tmuxSessionName(cwd),
     hasSession: (name) => defaultTmuxClient.hasSession(name),
-    sendKeys: (session, keys) => defaultTmuxClient.sendKeys(session, keys),
+    sendKeys: (session, ...keys) => defaultTmuxClient.sendKeys(session, ...keys),
     isClaudeRunning: (session) => tmuxIsClaudeRunning(session, defaultTmuxClient),
     killSession: (session) => defaultTmuxClient.killSession(session),
     readSessions: () => readSessions(),

package/src/config.ts

@@ -37,6 +37,8 @@ export interface RoutingConfigInput {
   port?: number
   session_restart_delay?: number
   health_check_interval?: number
+  exit_timeout?: number
+  stop_timeout?: number
   mcp_config_path?: string
   append_system_prompt_file?: string
 }
@@ -50,6 +52,8 @@ export interface RoutingConfig {
   port: number
   session_restart_delay: number
   health_check_interval: number
+  exit_timeout: number
+  stop_timeout: number
   mcp_config_path: string
   append_system_prompt_file?: string
 }
@@ -71,6 +75,8 @@ export function applyDefaults(input: RoutingConfigInput): RoutingConfig {
     port: input.port ?? 3100,
     session_restart_delay: input.session_restart_delay ?? 60,
     health_check_interval: input.health_check_interval ?? 120,
+    exit_timeout: input.exit_timeout ?? 120,
+    stop_timeout: input.stop_timeout ?? 30,
     mcp_config_path: input.mcp_config_path ?? '~/.claude/slack-mcp.json',
     append_system_prompt_file: input.append_system_prompt_file,
   }
@@ -132,6 +138,20 @@ export function validateConfig(config: RoutingConfig): void {
     )
   }
 
+  // exit_timeout must not be negative
+  if (config.exit_timeout < 0) {
+    throw new Error(
+      'Routing config validation error: exit_timeout must be a non-negative number.',
+    )
+  }
+
+  // stop_timeout must not be negative
+  if (config.stop_timeout < 0) {
+    throw new Error(
+      'Routing config validation error: stop_timeout must be a non-negative number.',
+    )
+  }
+
   // default_dm_session must reference an existing route CWD
   if (config.default_dm_session !== undefined) {
     if (!seen.has(config.default_dm_session)) {

package/src/lib.ts

@@ -254,8 +254,10 @@ export async function gate(event: unknown, opts: GateOptions): Promise<GateResul
 
   if (!policy && !isRouted) return { action: 'drop' }
 
-  // Use the explicit policy if present, otherwise fall back to permissive defaults
-  const effectivePolicy = policy ?? { requireMention: false, allowFrom: [] }
+  // Use the explicit policy if present, otherwise fall back to permissive defaults.
+  // Merge with defaults so partial entries (e.g. missing allowFrom) don't crash.
+  const defaults = { requireMention: false, allowFrom: [] as string[] }
+  const effectivePolicy = policy ? { ...defaults, ...policy } : defaults
 
   if (effectivePolicy.allowFrom.length > 0 && !effectivePolicy.allowFrom.includes(ev['user'] as string)) {
     return { action: 'drop' }

package/src/logging.ts

@@ -0,0 +1,44 @@
+import { closeSync, openSync, writeSync } from 'node:fs'
+
+// --- Logging ---
+
+let fd: number | null = null
+const originalConsoleError = console.error
+const originalConsoleLog = console.log
+
+function formatArgs(args: unknown[]): string {
+  return args
+    .map(arg => {
+      if (typeof arg === 'string') return arg
+      if (arg instanceof Error) return `${arg.name}: ${arg.message}\n${arg.stack ?? ''}`
+      if (arg !== null && typeof arg === 'object') return JSON.stringify(arg)
+      return String(arg)
+    })
+    .join(' ')
+}
+
+function makeLogFn(original: (...args: unknown[]) => void): (...args: unknown[]) => void {
+  return (...args: unknown[]): void => {
+    const timestamp = new Date().toISOString()
+    const message = formatArgs(args)
+    const line = `[${timestamp}] ${message}`
+    if (fd !== null) {
+      try {
+        writeSync(fd, line + '\n')
+        return
+      } catch {
+        // fall through to original
+      }
+    }
+    original(...args)
+  }
+}
+
+export function initLogging(logFilePath: string): void {
+  if (fd !== null) {
+    try { closeSync(fd) } catch { /* ignore */ }
+  }
+  fd = openSync(logFilePath, 'a')
+  console.error = makeLogFn(originalConsoleError) as typeof console.error
+  console.log = makeLogFn(originalConsoleLog) as typeof console.log
+}

package/src/registry.ts

@@ -182,12 +182,30 @@ export function getAllPendingSessions(): PendingSessionEntry[] {
  * Remove a session from the registry by its MCP session ID.
  * Marks the entry as disconnected before removal.
  * Returns the CWD if found, undefined otherwise.
+ *
+ * Guards against a race condition where a reconnect registers a new session
+ * for the same CWD before the old SSE abort fires. If the current registry
+ * entry's transport belongs to a different MCP session, the old mapping is
+ * cleaned up but the new session is left intact.
  */
 export function unregisterByMcpSessionId(mcpSessionId: string): string | undefined {
   const cwd = mcpSessionIdToCwd.get(mcpSessionId)
   if (!cwd) return undefined
+
+  // Always clean up the stale MCP ID → CWD mapping
+  mcpSessionIdToCwd.delete(mcpSessionId)
+
   const entry = registry.get(cwd)
-  if (entry) entry.connected = false
+  if (!entry) return cwd
+
+  // If a newer session has already replaced this one in the registry,
+  // don't destroy it — just clean up the old mapping and return.
+  if (entry.transport.sessionId !== mcpSessionId) {
+    console.error(`[registry] Skipping unregister for stale MCP session "${mcpSessionId}" — CWD "${cwd}" already has a newer session`)
+    return undefined
+  }
+
+  entry.connected = false
   unregisterSession(cwd)
   return cwd
 }

package/src/restart.ts

@@ -13,6 +13,9 @@
 
 export interface RestartDeps {
   isSessionAlive(channelId: string): Promise<boolean>
+  /** Check if the session already has a live MCP connection in the registry. */
+  isSessionConnected(channelId: string): boolean
+  reconnectSession(channelId: string): Promise<void>
   killSession(channelId: string): Promise<void>
   launchSession(channelId: string, cwd: string, sessionId?: string): Promise<boolean>
   getRestartDelay(): number
@@ -96,7 +99,18 @@ export function scheduleRestart(channelId: string, cwd: string, sessionId?: stri
       }
 
       if (alive) {
-        console.error(`[slack] Session already live — skipping restart for channel=${channelId}`)
+        // If the session already re-established its MCP connection (e.g. Claude
+        // Code refreshed the SSE stream on its own), skip the reconnect.
+        if (deps.isSessionConnected(channelId)) {
+          console.error(`[slack] Session already reconnected — skipping restart for channel=${channelId}`)
+          return
+        }
+        console.error(`[slack] Session alive but disconnected — reconnecting MCP for channel=${channelId}`)
+        try {
+          await deps.reconnectSession(channelId)
+        } catch (err) {
+          console.error(`[slack] restart: reconnectSession failed for channel=${channelId}:`, err)
+        }
         return
       }