@teamvibe/poller 0.1.30 → 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;
@@ -279,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/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);
@@ -164,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

@@ -103,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 {
@@ -119,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.30",
+  "version": "0.1.31",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {