@teamvibe/poller 0.1.29 → 0.1.31

package/dist/claude-spawner.d.ts

@@ -1,12 +1,13 @@
 import type { TeamVibeQueueMessage } from './types.js';
 import { type SessionLogger } from './logger.js';
+import type { TypingIndicator } from './slack-client.js';
 export interface SpawnResult {
     success: boolean;
     output: string;
     exitCode: number | null;
     error?: string;
 }
-export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void): Promise<SpawnResult & {
+export declare function spawnClaudeCode(msg: TeamVibeQueueMessage, sessionLog: SessionLogger, cwd: string, sessionId?: string, isFirstMessage?: boolean, lastMessageTs?: string, onMessageSent?: () => void, typingIndicator?: TypingIndicator): Promise<SpawnResult & {
     newSessionId?: string;
 }>;
 export declare function getActiveProcessCount(): number;

package/dist/claude-spawner.js

@@ -4,6 +4,45 @@ import { WebClient } from '@slack/web-api';
 import { config } from './config.js';
 import { logger } from './logger.js';
 import { getBaseBrainPath } from './brain-manager.js';
+/**
+ * Maps tool names (or prefixes) to human-readable status messages.
+ * More specific patterns are checked first.
+ */
+const TOOL_STATUS_MAP = [
+    // Slack MCP tools
+    { pattern: 'mcp__slack__search_messages', status: 'Searching Slack messages...' },
+    { pattern: 'mcp__slack__read_thread', status: 'Reading thread...' },
+    { pattern: 'mcp__slack__send_message', status: 'Sending message...' },
+    { pattern: 'mcp__slack__set_status', status: '' }, // Don't override Claude's own status
+    { pattern: 'mcp__slack__upload_snippet', status: 'Uploading snippet...' },
+    { pattern: /^mcp__slack__/, status: 'Working with Slack...' },
+    // Web tools
+    { pattern: 'WebSearch', status: 'Searching the web...' },
+    { pattern: 'WebFetch', status: 'Reading a webpage...' },
+    // File/code tools
+    { pattern: 'Read', status: 'Reading files...' },
+    { pattern: 'Grep', status: 'Searching code...' },
+    { pattern: 'Glob', status: 'Finding files...' },
+    { pattern: 'Edit', status: 'Editing code...' },
+    { pattern: 'Write', status: 'Writing code...' },
+    { pattern: 'Bash', status: 'Running a command...' },
+    { pattern: 'Agent', status: 'Delegating to a sub-agent...' },
+    // Generic MCP fallback
+    { pattern: /^mcp__/, status: 'Using an integration...' },
+];
+function getStatusForTool(toolName) {
+    for (const { pattern, status } of TOOL_STATUS_MAP) {
+        if (typeof pattern === 'string') {
+            if (toolName === pattern)
+                return status;
+        }
+        else {
+            if (pattern.test(toolName))
+                return status;
+        }
+    }
+    return null;
+}
 // Per-token Slack client cache for thread context
 const slackClients = new Map();
 function getSlackClient(botToken) {
@@ -126,7 +165,7 @@ function formatStreamEvent(event) {
             return null;
     }
 }
-async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent) {
+async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
     const slackContext = msg.response_context.slack;
     const isCronMessage = msg.source === 'cron';
     if (!slackContext && !isCronMessage) {
@@ -231,6 +270,20 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                         event.name === 'mcp__slack__send_message') {
                         onMessageSent();
                     }
+                    // Auto-update typing indicator status based on tool usage
+                    if (typingIndicator) {
+                        if (event.type === 'tool_use' && event.name) {
+                            const status = getStatusForTool(event.name);
+                            if (status !== null && status !== '') {
+                                typingIndicator.updateStatus(status);
+                            }
+                            // When status is '' (e.g. set_status tool), don't override — Claude is managing it
+                        }
+                        else if (event.type === 'assistant') {
+                            // Reset to "Thinking..." when Claude is reasoning between tool calls
+                            typingIndicator.updateStatus('Thinking...');
+                        }
+                    }
                 }
                 catch {
                     const truncated = line.length > 500 ? line.slice(0, 500) + '...' : line;
@@ -243,8 +296,11 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
             stderr += chunk;
             sessionLog.claude('stderr', chunk.trimEnd());
         });
+        let timedOut = false;
+        const timeoutMinutes = Math.round(config.CLAUDE_TIMEOUT_MS / 60000);
         const timeout = setTimeout(() => {
-            logger.error(`Claude Code process timed out after ${config.CLAUDE_TIMEOUT_MS}ms`);
+            timedOut = true;
+            logger.error(`Claude Code process timed out after ${timeoutMinutes} minutes`);
             proc.kill('SIGTERM');
             setTimeout(() => proc.kill('SIGKILL'), 5000);
         }, config.CLAUDE_TIMEOUT_MS);
@@ -256,7 +312,10 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
                 output: stdout,
                 exitCode: code,
             };
-            if (code !== 0) {
+            if (timedOut) {
+                result.error = `Session timed out after ${timeoutMinutes} minutes. The task was still running when the time limit was reached. Consider breaking complex tasks into smaller steps.`;
+            }
+            else if (code !== 0) {
                 result.error = stderr || `Process exited with code ${code}`;
             }
             resolve(result);
@@ -273,20 +332,20 @@ async function runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = t
         });
     });
 }
-export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent) {
-    const result = await runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage, lastMessageTs, onMessageSent);
+export async function spawnClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage = true, lastMessageTs, onMessageSent, typingIndicator) {
+    const result = await runClaudeCode(msg, sessionLog, cwd, sessionId, isFirstMessage, lastMessageTs, onMessageSent, typingIndicator);
     // If --resume failed, retry as a fresh session (session files may have been lost on container restart)
     let retryResult = result;
     if (!result.success && sessionId && !isFirstMessage) {
         sessionLog.info('Resume failed, retrying as fresh session (session files may have been lost)');
-        retryResult = await runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent);
+        retryResult = await runClaudeCode(msg, sessionLog, cwd, sessionId, true, lastMessageTs, onMessageSent, typingIndicator);
     }
     // If session ID is "already in use" (stale lock file), retry with a fresh session ID
     if (!retryResult.success && sessionId && retryResult.error?.includes('already in use')) {
         sessionLog.info('Session ID already in use (stale lock), retrying with fresh session ID');
         const { randomUUID } = await import('crypto');
         const freshId = randomUUID();
-        const freshResult = await runClaudeCode(msg, sessionLog, cwd, freshId, true, lastMessageTs, onMessageSent);
+        const freshResult = await runClaudeCode(msg, sessionLog, cwd, freshId, true, lastMessageTs, onMessageSent, typingIndicator);
         return { ...freshResult, newSessionId: freshId };
     }
     return retryResult;

package/dist/config.js

@@ -19,8 +19,8 @@ const configSchema = z.object({
     POLL_WAIT_TIME_SECONDS: z.coerce.number().default(20),
     VISIBILITY_TIMEOUT_SECONDS: z.coerce.number().default(60),
     HEARTBEAT_INTERVAL_MS: z.coerce.number().default(40000), // 40 seconds
-    CLAUDE_TIMEOUT_MS: z.coerce.number().default(1800000), // 30 minutes
-    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(2100000), // 35 minutes
+    CLAUDE_TIMEOUT_MS: z.coerce.number().default(3600000), // 60 minutes
+    STALE_LOCK_TIMEOUT_MS: z.coerce.number().default(3900000), // 65 minutes
     // Paths
     TEAMVIBE_DATA_DIR: z.string().default(DEFAULT_DATA_DIR),
     BRAINS_PATH: z.string().default(''),

package/dist/poller.js

@@ -125,14 +125,14 @@ async function processMessage(received) {
     processingMessages.add(messageId);
     const heartbeat = startHeartbeat(receiptHandle, sessionLog);
     // Start typing indicator
-    const stopTyping = hasSlackContext
+    const typing = hasSlackContext
         ? startTypingIndicator(queueMessage)
         : undefined;
     try {
         // Refresh base brain if cooldown has elapsed (5 min default)
         await ensureBaseBrain();
-        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => stopTyping?.());
-        stopTyping?.();
+        const result = await spawnClaudeCode(queueMessage, sessionLog, kbPath, session.session_id || undefined, isFirstMessage, session.last_message_ts, () => typing?.stop(), typing);
+        typing?.stop();
         // If Claude generated a new session ID (stale lock recovery), persist it
         if (result.newSessionId && lockToken) {
             await updateSessionId(threadId, lockToken, result.newSessionId);
@@ -151,8 +151,10 @@ async function processMessage(received) {
         else {
             sessionLog.error(`Claude Code failed: ${result.error}`);
             if (hasSlackContext) {
-                await sendSlackError(queueMessage, result.error || `Process exited with code ${result.exitCode}`);
-                await addReaction(queueMessage, 'x');
+                const errorMessage = result.error || `Process exited with code ${result.exitCode}`;
+                const isTimeout = errorMessage.includes('timed out');
+                await sendSlackError(queueMessage, errorMessage);
+                await addReaction(queueMessage, isTimeout ? 'hourglass' : 'x');
             }
             if (lockToken) {
                 await releaseSessionLock(threadId, lockToken, 'idle');
@@ -162,7 +164,7 @@ async function processMessage(received) {
         sessionLog.info('Message processed and deleted');
     }
     catch (error) {
-        stopTyping?.();
+        typing?.stop();
         sessionLog.error(`Error processing message: ${error instanceof Error ? error.message : error}`);
         if (lockToken) {
             try {

package/dist/slack-client.d.ts

@@ -7,5 +7,11 @@ export declare function sendSlackMessage(msg: TeamVibeQueueMessage, text: string
 export declare function sendSlackError(msg: TeamVibeQueueMessage, error: string): Promise<void>;
 export declare function addReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;
 export declare function setThreadStatus(msg: TeamVibeQueueMessage, status: string): Promise<void>;
-export declare function startTypingIndicator(msg: TeamVibeQueueMessage, statusText?: string): () => void;
+export interface TypingIndicator {
+    /** Update the displayed status text */
+    updateStatus: (newStatus: string) => void;
+    /** Stop the typing indicator and clear the status */
+    stop: () => void;
+}
+export declare function startTypingIndicator(msg: TeamVibeQueueMessage, statusText?: string): TypingIndicator;
 export declare function removeReaction(msg: TeamVibeQueueMessage, emoji: string): Promise<void>;

package/dist/slack-client.js

@@ -60,10 +60,14 @@ export async function sendSlackError(msg, error) {
         return;
     const { channel, thread_ts } = msg.response_context.slack;
     const slack = getSlackClient(msg.teamvibe.botToken);
+    const isTimeout = error.includes('timed out');
+    const text = isTimeout
+        ? `:warning: ${error}`
+        : `Error processing your request:\n\`\`\`\n${error}\n\`\`\``;
     await slack.chat.postMessage({
         channel,
         thread_ts,
-        text: `Error processing your request:\n\`\`\`\n${error}\n\`\`\``,
+        text,
     });
 }
 export async function addReaction(msg, emoji) {
@@ -99,13 +103,14 @@ export async function setThreadStatus(msg, status) {
     }
 }
 export function startTypingIndicator(msg, statusText = 'is thinking...') {
+    let currentStatus = statusText;
     // Set initial status
-    setThreadStatus(msg, statusText);
+    setThreadStatus(msg, currentStatus);
     // Keepalive every 3 seconds (Slack clears after ~2 min timeout)
     let failures = 0;
     const interval = setInterval(async () => {
         try {
-            await setThreadStatus(msg, statusText);
+            await setThreadStatus(msg, currentStatus);
             failures = 0;
         }
         catch {
@@ -115,10 +120,17 @@ export function startTypingIndicator(msg, statusText = 'is thinking...') {
             }
         }
     }, 3000);
-    // Return cleanup function
-    return () => {
-        clearInterval(interval);
-        setThreadStatus(msg, '');
+    return {
+        updateStatus: (newStatus) => {
+            if (newStatus !== currentStatus) {
+                currentStatus = newStatus;
+                setThreadStatus(msg, currentStatus);
+            }
+        },
+        stop: () => {
+            clearInterval(interval);
+            setThreadStatus(msg, '');
+        },
     };
 }
 export async function removeReaction(msg, emoji) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamvibe/poller",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {