claude-slack-channel-bots 0.0.4 → 0.1.0

package/README.md

@@ -185,7 +185,7 @@ Checks prerequisites, then daemonizes the server.
 3. `SLACK_APP_TOKEN` is set — fails with `missing prerequisite: SLACK_APP_TOKEN environment variable` if absent.
 4. `routing.json` exists at `STATE_DIR/routing.json` — fails with the full path if not found.
 
-If all checks pass, the parent process spawns a detached child process and exits immediately, printing the child PID. The child starts the server and writes its PID to `STATE_DIR/server.pid`.
+If all checks pass, the parent process spawns a detached child process and exits immediately, printing the child PID. The child starts the server and writes its PID to `STATE_DIR/server.pid`. Conversation context is preserved across server restarts when possible.
 
 ```
 [slack] Server starting in background (PID 12345)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-slack-channel-bots",
-  "version": "0.0.4",
+  "version": "0.1.0",
   "description": "Multi-session Slack-to-Claude bridge — run multiple Claude Code bots across Slack channels via Socket Mode",
   "type": "module",
   "bin": {

package/src/config.ts

@@ -12,6 +12,12 @@ import { readFileSync } from 'fs'
 import { homedir } from 'os'
 import { resolve } from 'path'
 
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+export const MCP_SERVER_NAME = 'slack-channel-router'
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------

package/src/postinstall.ts

@@ -13,6 +13,7 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
 import { dirname, join } from 'path'
 import { defaultAccess } from './lib.ts'
+import { MCP_SERVER_NAME } from './config.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -70,7 +71,7 @@ export function runPostinstall(options: PostinstallOptions = {}): void {
   } else {
     const skeleton = {
       mcpServers: {
-        'slack-channel-router': {
+        [MCP_SERVER_NAME]: {
           type: 'http',
           url: 'http://127.0.0.1:3100/mcp',
         },

package/src/registry.ts

@@ -14,7 +14,7 @@ import {
   CallToolRequestSchema,
   ListToolsRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js'
-import type { RoutingConfig } from './config.ts'
+import { MCP_SERVER_NAME, type RoutingConfig } from './config.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -335,7 +335,7 @@ export function createSessionServer(
   const { web, assertOutboundAllowed, assertSendable, getAccess, resolveUserName, inboxDir, consumeAck } = deps
 
   const server = new Server(
-    { name: 'slack-channel-router', version: '0.1.0' },
+    { name: MCP_SERVER_NAME, version: '0.1.0' },
     {
       capabilities: {
         experimental: { 'claude/channel': {} },

package/src/restart.ts

@@ -14,7 +14,7 @@
 export interface RestartDeps {
   isSessionAlive(channelId: string): Promise<boolean>
   killSession(channelId: string): Promise<void>
-  launchSession(channelId: string, cwd: string): Promise<boolean>
+  launchSession(channelId: string, cwd: string, sessionId?: string): Promise<boolean>
   getRestartDelay(): number
   isShuttingDown(): boolean
 }
@@ -46,7 +46,7 @@ export function initRestart(d: RestartDeps): void {
 // scheduleRestart
 // ---------------------------------------------------------------------------
 
-export function scheduleRestart(channelId: string, cwd: string): void {
+export function scheduleRestart(channelId: string, cwd: string, sessionId?: string): void {
   if (!deps) {
     console.error('[slack] scheduleRestart: deps not initialized — skipping')
     return
@@ -109,7 +109,7 @@ export function scheduleRestart(channelId: string, cwd: string): void {
 
       let ok: boolean
       try {
-        ok = await deps.launchSession(channelId, cwd)
+        ok = await deps.launchSession(channelId, cwd, sessionId)
       } catch (err) {
         console.error(`[slack] restart: launchSession threw for channel=${channelId}:`, err)
         ok = false

package/src/server.ts

@@ -37,7 +37,7 @@ import {
   type Access,
   type GateResult,
 } from './lib.ts'
-import { loadConfig, expandTilde, type RoutingConfig } from './config.ts'
+import { loadConfig, expandTilde, type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
 import { readSessions, writeSessions } from './sessions.ts'
 import { defaultTmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
 import { startupSessionManager, launchSession } from './session-manager.ts'
@@ -296,7 +296,7 @@ function initPendingSession(): { pendingId: string; transport: WebStandardStream
           : undefined
         if (channelId) {
           console.error(`[slack] Session disconnected: channel=${channelId} cwd="${cwd}"`)
-          scheduleRestart(channelId, cwd)
+          scheduleRestart(channelId, cwd, readSessions()[channelId]?.sessionId)
         } else {
           console.error(`[slack] Session disconnected: cwd="${cwd}"`)
         }
@@ -1266,7 +1266,7 @@ export async function main(): Promise<void> {
               : undefined
             if (channelId) {
               console.error(`[slack] Session disconnected (SSE abort): channel=${channelId} cwd="${cwd}"`)
-              scheduleRestart(channelId, cwd)
+              scheduleRestart(channelId, cwd, readSessions()[channelId]?.sessionId)
             } else {
               console.error(`[slack] Session disconnected (SSE abort): cwd="${cwd}"`)
             }
@@ -1288,10 +1288,10 @@ export async function main(): Promise<void> {
   console.error(`[slack] MCP server listening on http://${mcpHost}:${mcpPort}/mcp`)
   console.error('')
   console.error('Save this to ~/.claude/slack-mcp.json:')
-  console.error(JSON.stringify({ mcpServers: { 'slack-channel-router': { type: 'http', url: `http://${mcpHost}:${mcpPort}/mcp` } } }, null, 2))
+  console.error(JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: { type: 'http', url: `http://${mcpHost}:${mcpPort}/mcp` } } }, null, 2))
   console.error('')
   console.error('Then launch Claude from a project directory with:')
-  console.error('  claude --mcp-config ~/.claude/slack-mcp.json --dangerously-load-development-channels server:slack-channel-router')
+  console.error(`  claude --mcp-config ~/.claude/slack-mcp.json --dangerously-load-development-channels server:${MCP_SERVER_NAME}`)
   console.error('')
 
   // Initialize restart module with adapters bridging tmux + session-manager
@@ -1311,9 +1311,13 @@ export async function main(): Promise<void> {
       const exists = await defaultTmuxClient.hasSession(name)
       if (exists) await defaultTmuxClient.killSession(name)
     },
-    launchSession: (channelId, cwd) => {
+    launchSession: (channelId, cwd, sessionId) => {
       if (!routingConfig) return Promise.resolve(false)
-      return launchSession(channelId, cwd, routingConfig, defaultTmuxClient, readSessions, writeSessions)
+      const resolvedSessionId = sessionId ?? readSessions()[channelId]?.sessionId
+      return launchSession(
+        channelId, cwd, routingConfig, defaultTmuxClient, readSessions, writeSessions,
+        resolvedSessionId !== undefined ? { sessionId: resolvedSessionId } : undefined,
+      )
     },
     getRestartDelay: () => routingConfig?.session_restart_delay ?? 60,
     isShuttingDown: () => shuttingDown,

package/src/session-manager.ts

@@ -1,16 +1,20 @@
 /**
  * session-manager.ts — Startup orchestration for tmux-managed Claude Code sessions.
  *
- * Handles two cases per route at server startup:
- *   exists  — tmux session found → kill and relaunch
- *   missing — no tmux session → launch fresh
+ * Handles three cases per route at server startup:
+ *   reconnect — tmux session exists AND Claude is running → send /mcp reconnect, do not relaunch
+ *   resume    — dead or missing process with stored session ID → kill stale session, relaunch with --resume
+ *   fresh     — dead or missing process without stored session ID → kill stale session, launch fresh
  *
  * SPDX-License-Identifier: MIT
  */
 
+import { readdirSync, readFileSync } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
 import { type TmuxClient, sessionName, isClaudeRunning } from './tmux.ts'
 import { type SessionsMap } from './sessions.ts'
-import { type RoutingConfig } from './config.ts'
+import { type RoutingConfig, MCP_SERVER_NAME } from './config.ts'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -19,14 +23,63 @@ import { type RoutingConfig } from './config.ts'
 export interface LaunchOptions {
   /** Maximum time in ms to poll for the safety prompt. Default: 60000. */
   pollTimeout?: number
+  /** Claude session UUID to resume. When provided, --resume <id> is appended to the CLI command. */
+  sessionId?: string
 }
 
 export interface SessionStateResult {
   channelId: string
-  action: 'relaunched' | 'launched' | 'failed'
+  action: 'reconnected' | 'launched' | 'resumed' | 'failed'
   sessionName: string
 }
 
+// ---------------------------------------------------------------------------
+// Session ID capture helper
+// ---------------------------------------------------------------------------
+
+/**
+ * Polls ~/.claude/sessions/ for a new session file matching the given CWD
+ * with a startedAt timestamp after `launchTimestamp`. Returns the sessionId
+ * string if found, or undefined if capture fails or times out.
+ *
+ * Polls up to ~2 seconds (4 × 500ms intervals).
+ */
+async function captureSessionId(cwd: string, launchTimestamp: number): Promise<string | undefined> {
+  const sessionsDir = join(homedir(), '.claude', 'sessions')
+  const POLL_INTERVAL_MS = 500
+  const POLL_ATTEMPTS = 4
+
+  for (let i = 0; i < POLL_ATTEMPTS; i++) {
+    await new Promise<void>((resolve) => setTimeout(resolve, POLL_INTERVAL_MS))
+    try {
+      const files = readdirSync(sessionsDir)
+      for (const file of files) {
+        if (!file.endsWith('.json')) continue
+        try {
+          const raw = readFileSync(join(sessionsDir, file), 'utf-8')
+          const entry = JSON.parse(raw)
+          if (
+            typeof entry === 'object' &&
+            entry !== null &&
+            entry.cwd === cwd &&
+            typeof entry.startedAt === 'number' &&
+            entry.startedAt > launchTimestamp &&
+            typeof entry.sessionId === 'string' &&
+            entry.sessionId.length > 0
+          ) {
+            return entry.sessionId as string
+          }
+        } catch {
+          // skip unreadable or malformed files
+        }
+      }
+    } catch {
+      // sessionsDir may not exist yet; keep polling
+    }
+  }
+  return undefined
+}
+
 // ---------------------------------------------------------------------------
 // launchSession
 // ---------------------------------------------------------------------------
@@ -36,6 +89,10 @@ export interface SessionStateResult {
  * correct MCP config, polls for the safety prompt, and records the session
  * in sessions.json on success.
  *
+ * When options.sessionId is provided, appends --resume <id> to the CLI
+ * command. If the resume attempt fails, kills the tmux session and retries
+ * once with a fresh launch (no --resume).
+ *
  * Returns true on success, false on failure.
  */
 export async function launchSession(
@@ -49,64 +106,114 @@ export async function launchSession(
 ): Promise<boolean> {
   const name = sessionName(cwd)
   const pollTimeout = options?.pollTimeout ?? 60_000
+  const resumeSessionId = options?.sessionId
 
-  // Create detached tmux session with the channel's CWD
-  await tmuxClient.newSession(name, cwd)
-  console.error(`[slack] Session created: ${name} (cwd="${cwd}")`)
-
-  // Send the claude launch command, then Enter to execute it
   const escapedConfigPath = routingConfig.mcp_config_path.replace(/'/g, "'\\''")
-  const launchCmd = `claude --mcp-config '${escapedConfigPath}' --dangerously-load-development-channels server:slack-channel-router`
-  await tmuxClient.sendKeys(name, launchCmd)
-  await tmuxClient.sendKeys(name, 'Enter')
-  console.error(`[slack] Claude launch command sent to session: ${name}`)
+  const baseCmd = `claude --mcp-config '${escapedConfigPath}' --dangerously-load-development-channels server:${MCP_SERVER_NAME}`
 
-  // Poll capturePane for the safety prompt with exponential backoff.
-  // Start at 500ms, double each iteration, cap at 5s, total limit 60s.
   const POLL_START_MS = 500
   const POLL_CAP_MS = 5_000
   const PROMPT_TEXT = 'I am using this for local development'
 
-  let delay = POLL_START_MS
-  const deadline = Date.now() + pollTimeout
+  // Inner helper: sends the launch command and polls for the safety prompt.
+  // Returns { ok: true, capturedId } on success (capturedId may be undefined if capture failed),
+  // or { ok: false } when Claude is not running after the poll timeout.
+  async function attemptLaunch(
+    withResumeId: string | undefined,
+  ): Promise<{ ok: true; capturedId: string | undefined } | { ok: false }> {
+    const safeResumeId = withResumeId && /^[a-zA-Z0-9_-]+$/.test(withResumeId) ? withResumeId : undefined
+    if (withResumeId && !safeResumeId) {
+      console.error(`[slack] Invalid session ID format — ignoring resume for channel=${channelId}`)
+    }
+    const launchTimestamp = Date.now()
+    const launchCmd = safeResumeId ? `${baseCmd} --resume ${safeResumeId}` : baseCmd
+    if (safeResumeId) {
+      console.error(`[slack] Attempting resume launch for channel=${channelId} sessionId=${safeResumeId}`)
+    } else {
+      console.error(`[slack] Attempting fresh launch for channel=${channelId}`)
+    }
+    await tmuxClient.sendKeys(name, launchCmd)
+    await tmuxClient.sendKeys(name, 'Enter')
+    console.error(`[slack] Claude launch command sent to session: ${name}`)
 
-  while (Date.now() < deadline) {
-    await new Promise<void>((resolve) => setTimeout(resolve, delay))
-    delay = Math.min(delay * 2, POLL_CAP_MS)
+    let delay = POLL_START_MS
+    const deadline = launchTimestamp + pollTimeout
 
-    let pane: string
-    try {
-      pane = await tmuxClient.capturePane(name)
-    } catch {
-      // capturePane failure is terminal — session may have died
-      break
+    while (Date.now() < deadline) {
+      await new Promise<void>((resolve) => setTimeout(resolve, delay))
+      delay = Math.min(delay * 2, POLL_CAP_MS)
+
+      let pane: string
+      try {
+        pane = await tmuxClient.capturePane(name)
+      } catch {
+        // capturePane failure is terminal — session may have died
+        break
+      }
+
+      if (pane.includes(PROMPT_TEXT)) {
+        await tmuxClient.sendKeys(name, 'Enter')
+        console.error(`[slack] Safety prompt acknowledged in session: ${name}`)
+        const capturedId = await captureSessionId(cwd, launchTimestamp)
+        if (capturedId) {
+          console.error(`[slack] Session ID captured for channel=${channelId}: ${capturedId}`)
+        } else {
+          console.error(`[slack] Session ID capture failed for channel=${channelId} — continuing without it`)
+        }
+        return { ok: true, capturedId }
+      }
     }
 
-    if (pane.includes(PROMPT_TEXT)) {
-      // Safety prompt found — acknowledge it and record success
-      await tmuxClient.sendKeys(name, 'Enter')
-      console.error(`[slack] Safety prompt acknowledged in session: ${name}`)
-      const sessions = readSessionsFn()
-      sessions[channelId] = { tmuxSession: name, lastLaunch: new Date().toISOString() }
-      writeSessionsFn(sessions)
-      console.error(`[slack] Session recorded in sessions.json: channel=${channelId}`)
-      return true
+    // Prompt not found — check if Claude is running anyway (forward-compatible)
+    const running = await isClaudeRunning(name, tmuxClient)
+    if (running) {
+      console.error(`[slack] Safety prompt not found but Claude is running — accepting session: ${name}`)
+      const capturedId = await captureSessionId(cwd, launchTimestamp)
+      if (capturedId) {
+        console.error(`[slack] Session ID captured for channel=${channelId}: ${capturedId}`)
+      } else {
+        console.error(`[slack] Session ID capture failed for channel=${channelId} — continuing without it`)
+      }
+      return { ok: true, capturedId }
     }
+
+    return { ok: false }
   }
 
-  // Prompt not found — check if Claude is running anyway (forward-compatible)
-  const running = await isClaudeRunning(name, tmuxClient)
-  if (running) {
-    console.error(`[slack] Safety prompt not found but Claude is running — accepting session: ${name}`)
-    const sessions = readSessionsFn()
-    sessions[channelId] = { tmuxSession: name, lastLaunch: new Date().toISOString() }
-    writeSessionsFn(sessions)
-    console.error(`[slack] Session recorded in sessions.json: channel=${channelId}`)
-    return true
+  // Create detached tmux session with the channel's CWD
+  await tmuxClient.newSession(name, cwd)
+  console.error(`[slack] Session created: ${name} (cwd="${cwd}")`)
+
+  // Attempt launch (with --resume if sessionId provided)
+  let result = await attemptLaunch(resumeSessionId)
+
+  // resumeSessionId was provided but launch failed — fall back to a fresh launch
+  if (!result.ok && resumeSessionId !== undefined) {
+    console.error(`[slack] Resume failed for channel=${channelId} — killing session and retrying with fresh launch`)
+    try {
+      await tmuxClient.killSession(name)
+    } catch {
+      // ignore kill errors; proceed with fresh session creation
+    }
+    await tmuxClient.newSession(name, cwd)
+    console.error(`[slack] Session recreated for fresh fallback: ${name} (cwd="${cwd}")`)
+    result = await attemptLaunch(undefined)
   }
 
-  console.error(`[slack] Session launch failed — Claude not running in session: ${name}`)
-  return false
+  if (!result.ok) {
+    console.error(`[slack] Session launch failed — Claude not running in session: ${name}`)
+    return false
+  }
+
+  const sessions = readSessionsFn()
+  sessions[channelId] = {
+    tmuxSession: name,
+    lastLaunch: new Date().toISOString(),
+    ...(result.capturedId !== undefined ? { sessionId: result.capturedId } : {}),
+  }
+  writeSessionsFn(sessions)
+  console.error(`[slack] Session recorded in sessions.json: channel=${channelId}`)
+  return true
 }
 
 // ---------------------------------------------------------------------------
@@ -114,9 +221,11 @@ export async function launchSession(
 // ---------------------------------------------------------------------------
 
 /**
- * On server startup, inspects all configured routes and takes action:
- *   - Exists (session found): kills session and relaunches
- *   - Missing: launches fresh
+ * On server startup, inspects all configured routes and takes action using a
+ * three-branch decision tree per route:
+ *   - Reconnect: tmux session exists AND Claude is running → send /mcp reconnect, do not relaunch
+ *   - Resume: dead or missing process with stored session ID → kill stale session, relaunch with --resume
+ *   - Fresh: dead or missing process without stored session ID → kill stale session, launch fresh
  *
  * Returns early with a warning if tmux is unavailable.
  */
@@ -138,6 +247,9 @@ export async function startupSessionManager(
 
   const results: SessionStateResult[] = []
 
+  // Load stored session IDs for all channels once before the route iteration loop
+  const storedSessions = readSessionsFn()
+
   for (const [channelId, route] of Object.entries(routingConfig.routes)) {
     const name = sessionName(route.cwd)
 
@@ -145,17 +257,38 @@ export async function startupSessionManager(
       const exists = await tmuxClient.hasSession(name)
 
       if (exists) {
-        // Session exists — kill and relaunch regardless of whether Claude is running
-        console.error(`[slack] Session exists — killing and relaunching: channel=${channelId} session=${name}`)
+        const running = await isClaudeRunning(name, tmuxClient)
+
+        if (running) {
+          // Branch 1: Reconnect — session live, send /mcp reconnect <server-name>
+          console.error(`[slack] Session live — reconnecting MCP server "${MCP_SERVER_NAME}": channel=${channelId} session=${name}`)
+          await tmuxClient.sendKeys(name, `/mcp reconnect ${MCP_SERVER_NAME}`)
+          await tmuxClient.sendKeys(name, 'Enter')
+          results.push({ channelId, action: 'reconnected', sessionName: name })
+          continue
+        }
+      }
+
+      // Branch 2 or 3: Dead or missing process — check for stored session ID
+      const storedSessionId = storedSessions[channelId]?.sessionId
+
+      if (exists) {
+        // Kill stale tmux session before relaunching
+        console.error(`[slack] Stale session found — killing before relaunch: channel=${channelId} session=${name}`)
         await tmuxClient.killSession(name)
+      }
+
+      if (storedSessionId) {
+        // Branch 2: Resume — launch with stored session ID
+        console.error(`[slack] Dead/missing process with stored session ID — resuming: channel=${channelId} session=${name} sessionId=${storedSessionId}`)
         const ok = await launchSession(
           channelId, route.cwd, routingConfig, tmuxClient,
-          readSessionsFn, writeSessionsFn, options,
+          readSessionsFn, writeSessionsFn, { ...options, sessionId: storedSessionId },
         )
-        results.push({ channelId, action: ok ? 'relaunched' : 'failed', sessionName: name })
+        results.push({ channelId, action: ok ? 'resumed' : 'failed', sessionName: name })
       } else {
-        // No session — launch fresh
-        console.error(`[slack] No session found — launching: channel=${channelId} session=${name}`)
+        // Branch 3: Fresh — launch without session ID
+        console.error(`[slack] No stored session ID — launching fresh: channel=${channelId} session=${name}`)
         const ok = await launchSession(
           channelId, route.cwd, routingConfig, tmuxClient,
           readSessionsFn, writeSessionsFn, options,

package/src/sessions.ts

@@ -23,6 +23,7 @@ import { expandTilde } from './config.ts'
 export interface SessionRecord {
   tmuxSession: string
   lastLaunch: string // ISO-8601, e.g. new Date().toISOString()
+  sessionId?: string // Claude session UUID, captured after launch
 }
 
 export type SessionsMap = Record<string, SessionRecord>