claude-threads 0.12.1 → 0.14.0

package/dist/session/events.js

@@ -0,0 +1,368 @@
+/**
+ * Claude event handling module
+ *
+ * Handles events from Claude CLI: assistant messages, tool use,
+ * tool results, tasks, questions, and plan approvals.
+ */
+import { formatToolUse as sharedFormatToolUse } from '../utils/tool-formatter.js';
+import { NUMBER_EMOJIS, APPROVAL_EMOJIS, DENIAL_EMOJIS, } from '../utils/emoji.js';
+// ---------------------------------------------------------------------------
+// Main event handler
+// ---------------------------------------------------------------------------
+/**
+ * Handle a Claude event from the CLI stream.
+ * Routes to appropriate handler based on event type.
+ */
+export function handleEvent(session, event, ctx) {
+    // Update last activity and reset timeout warning
+    session.lastActivityAt = new Date();
+    session.timeoutWarningPosted = false;
+    // Check for special tool uses that need custom handling
+    if (event.type === 'assistant') {
+        const msg = event.message;
+        let hasSpecialTool = false;
+        for (const block of msg?.content || []) {
+            if (block.type === 'tool_use') {
+                if (block.name === 'ExitPlanMode') {
+                    handleExitPlanMode(session, block.id, ctx);
+                    hasSpecialTool = true;
+                }
+                else if (block.name === 'TodoWrite') {
+                    handleTodoWrite(session, block.input);
+                }
+                else if (block.name === 'Task') {
+                    handleTaskStart(session, block.id, block.input);
+                }
+                else if (block.name === 'AskUserQuestion') {
+                    handleAskUserQuestion(session, block.id, block.input, ctx);
+                    hasSpecialTool = true;
+                }
+            }
+        }
+        if (hasSpecialTool)
+            return;
+    }
+    // Check for tool_result to update subagent status
+    if (event.type === 'user') {
+        const msg = event.message;
+        for (const block of msg?.content || []) {
+            if (block.type === 'tool_result' && block.tool_use_id) {
+                const postId = session.activeSubagents.get(block.tool_use_id);
+                if (postId) {
+                    handleTaskComplete(session, block.tool_use_id, postId);
+                }
+            }
+        }
+    }
+    const formatted = formatEvent(session, event, ctx);
+    if (ctx.debug) {
+        console.log(`[DEBUG] handleEvent(${session.threadId}): ${event.type} -> ${formatted ? formatted.substring(0, 100) : '(null)'}`);
+    }
+    if (formatted)
+        ctx.appendContent(session, formatted);
+}
+// ---------------------------------------------------------------------------
+// Event formatters
+// ---------------------------------------------------------------------------
+/**
+ * Format a Claude event for display in chat platforms.
+ */
+function formatEvent(session, e, ctx) {
+    switch (e.type) {
+        case 'assistant': {
+            const msg = e.message;
+            const parts = [];
+            for (const block of msg?.content || []) {
+                if (block.type === 'text' && block.text) {
+                    // Filter out <thinking> tags that may appear in text content
+                    const text = block.text.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
+                    if (text)
+                        parts.push(text);
+                }
+                else if (block.type === 'tool_use' && block.name) {
+                    const formatted = sharedFormatToolUse(block.name, block.input || {}, session.platform.getFormatter(), { detailed: true });
+                    if (formatted)
+                        parts.push(formatted);
+                }
+                else if (block.type === 'thinking' && block.thinking) {
+                    // Extended thinking - show abbreviated version
+                    const thinking = block.thinking;
+                    const preview = thinking.length > 100 ? thinking.substring(0, 100) + '...' : thinking;
+                    parts.push(`💭 *Thinking: ${preview}*`);
+                }
+                else if (block.type === 'server_tool_use' && block.name) {
+                    // Server-managed tools like web search
+                    parts.push(`🌐 **${block.name}** ${block.input ? JSON.stringify(block.input).substring(0, 50) : ''}`);
+                }
+            }
+            return parts.length > 0 ? parts.join('\n') : null;
+        }
+        case 'tool_use': {
+            const tool = e.tool_use;
+            // Track tool start time for elapsed display
+            if (tool.id) {
+                session.activeToolStarts.set(tool.id, Date.now());
+            }
+            return sharedFormatToolUse(tool.name, tool.input || {}, session.platform.getFormatter(), { detailed: true }) || null;
+        }
+        case 'tool_result': {
+            const result = e.tool_result;
+            // Calculate elapsed time
+            let elapsed = '';
+            if (result.tool_use_id) {
+                const startTime = session.activeToolStarts.get(result.tool_use_id);
+                if (startTime) {
+                    const secs = Math.round((Date.now() - startTime) / 1000);
+                    if (secs >= 3) {
+                        // Only show if >= 3 seconds
+                        elapsed = ` (${secs}s)`;
+                    }
+                    session.activeToolStarts.delete(result.tool_use_id);
+                }
+            }
+            if (result.is_error)
+                return `  ↳ ❌ Error${elapsed}`;
+            if (elapsed)
+                return `  ↳ ✓${elapsed}`;
+            return null;
+        }
+        case 'result': {
+            // Response complete - stop typing and start new post for next message
+            ctx.stopTyping(session);
+            ctx.flush(session);
+            session.currentPostId = null;
+            session.pendingContent = '';
+            return null;
+        }
+        case 'system':
+            if (e.subtype === 'error')
+                return `❌ ${e.error}`;
+            return null;
+        case 'user': {
+            // Handle local command output (e.g., /context, /cost responses)
+            const msg = e.message;
+            if (typeof msg?.content === 'string') {
+                // Extract content from <local-command-stdout> tags
+                const match = msg.content.match(/<local-command-stdout>([\s\S]*?)<\/local-command-stdout>/);
+                if (match) {
+                    return match[1].trim();
+                }
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Plan mode handling
+// ---------------------------------------------------------------------------
+/**
+ * Handle ExitPlanMode tool use - post approval prompt.
+ */
+async function handleExitPlanMode(session, toolUseId, ctx) {
+    // If already approved in this session, send empty tool result to acknowledge
+    if (session.planApproved) {
+        if (ctx.debug)
+            console.log('  ↪ Plan already approved, sending acknowledgment');
+        if (session.claude.isRunning()) {
+            session.claude.sendToolResult(toolUseId, 'Plan already approved. Proceeding.');
+        }
+        return;
+    }
+    // If we already have a pending approval, don't post another one
+    if (session.pendingApproval && session.pendingApproval.type === 'plan') {
+        if (ctx.debug)
+            console.log('  ↪ Plan approval already pending, waiting');
+        return;
+    }
+    // Flush any pending content first
+    await ctx.flush(session);
+    session.currentPostId = null;
+    session.pendingContent = '';
+    // Post approval message with reactions
+    const message = `✅ **Plan ready for approval**\n\n` +
+        `👍 Approve and start building\n` +
+        `👎 Request changes\n\n` +
+        `*React to respond*`;
+    const post = await session.platform.createInteractivePost(message, [APPROVAL_EMOJIS[0], DENIAL_EMOJIS[0]], session.threadId);
+    // Register post for reaction routing
+    ctx.registerPost(post.id, session.threadId);
+    // Track this for reaction handling - include toolUseId for proper response
+    session.pendingApproval = { postId: post.id, type: 'plan', toolUseId };
+    // Stop typing while waiting
+    ctx.stopTyping(session);
+}
+// ---------------------------------------------------------------------------
+// Task/Todo handling
+// ---------------------------------------------------------------------------
+/**
+ * Handle TodoWrite tool use - update task list display.
+ */
+async function handleTodoWrite(session, input) {
+    const todos = input.todos;
+    if (!todos || todos.length === 0) {
+        // Clear tasks display if empty
+        if (session.tasksPostId) {
+            try {
+                await session.platform.updatePost(session.tasksPostId, '📋 ~~Tasks~~ *(completed)*');
+            }
+            catch (err) {
+                console.error('  ⚠️ Failed to update tasks:', err);
+            }
+        }
+        return;
+    }
+    // Count progress
+    const completed = todos.filter((t) => t.status === 'completed').length;
+    const total = todos.length;
+    const pct = Math.round((completed / total) * 100);
+    // Check if there's an in_progress task and track timing
+    const hasInProgress = todos.some((t) => t.status === 'in_progress');
+    if (hasInProgress && !session.inProgressTaskStart) {
+        session.inProgressTaskStart = Date.now();
+    }
+    else if (!hasInProgress) {
+        session.inProgressTaskStart = null;
+    }
+    // Format tasks nicely with progress header
+    let message = `📋 **Tasks** (${completed}/${total} · ${pct}%)\n\n`;
+    for (const todo of todos) {
+        let icon;
+        let text;
+        switch (todo.status) {
+            case 'completed':
+                icon = '✅';
+                text = `~~${todo.content}~~`;
+                break;
+            case 'in_progress': {
+                icon = '🔄';
+                // Add elapsed time if we have a start time
+                let elapsed = '';
+                if (session.inProgressTaskStart) {
+                    const secs = Math.round((Date.now() - session.inProgressTaskStart) / 1000);
+                    if (secs >= 5) {
+                        // Only show if >= 5 seconds
+                        elapsed = ` (${secs}s)`;
+                    }
+                }
+                text = `**${todo.activeForm}**${elapsed}`;
+                break;
+            }
+            default:
+                // pending
+                icon = '○';
+                text = todo.content;
+        }
+        message += `${icon} ${text}\n`;
+    }
+    // Update or create tasks post
+    try {
+        if (session.tasksPostId) {
+            await session.platform.updatePost(session.tasksPostId, message);
+        }
+        else {
+            const post = await session.platform.createPost(message, session.threadId);
+            session.tasksPostId = post.id;
+        }
+    }
+    catch (err) {
+        console.error('  ⚠️ Failed to update tasks:', err);
+    }
+}
+/**
+ * Handle Task (subagent) start - post status message.
+ */
+async function handleTaskStart(session, toolUseId, input) {
+    const description = input.description || 'Working...';
+    const subagentType = input.subagent_type || 'general';
+    // Post subagent status
+    const message = `🤖 **Subagent** *(${subagentType})*\n` + `> ${description}\n` + `⏳ Running...`;
+    try {
+        const post = await session.platform.createPost(message, session.threadId);
+        session.activeSubagents.set(toolUseId, post.id);
+    }
+    catch (err) {
+        console.error('  ⚠️ Failed to post subagent status:', err);
+    }
+}
+/**
+ * Handle Task (subagent) completion - update status message.
+ */
+async function handleTaskComplete(session, toolUseId, postId) {
+    try {
+        await session.platform.updatePost(postId, session.activeSubagents.has(toolUseId)
+            ? `🤖 **Subagent** ✅ *completed*`
+            : `🤖 **Subagent** ✅`);
+        session.activeSubagents.delete(toolUseId);
+    }
+    catch (err) {
+        console.error('  ⚠️ Failed to update subagent completion:', err);
+    }
+}
+// ---------------------------------------------------------------------------
+// Question handling
+// ---------------------------------------------------------------------------
+/**
+ * Handle AskUserQuestion tool use - start interactive question flow.
+ */
+async function handleAskUserQuestion(session, toolUseId, input, ctx) {
+    // If we already have pending questions, don't start another set
+    if (session.pendingQuestionSet) {
+        if (ctx.debug)
+            console.log('  ↪ Questions already pending, waiting');
+        return;
+    }
+    // Flush any pending content first
+    await ctx.flush(session);
+    session.currentPostId = null;
+    session.pendingContent = '';
+    const questions = input.questions;
+    if (!questions || questions.length === 0)
+        return;
+    // Create a new question set - we'll ask one at a time
+    session.pendingQuestionSet = {
+        toolUseId,
+        currentIndex: 0,
+        currentPostId: null,
+        questions: questions.map((q) => ({
+            header: q.header,
+            question: q.question,
+            options: q.options,
+            answer: null,
+        })),
+    };
+    // Post the first question
+    await postCurrentQuestion(session, ctx);
+    // Stop typing while waiting for answer
+    ctx.stopTyping(session);
+}
+/**
+ * Post the current question in the question set.
+ */
+export async function postCurrentQuestion(session, ctx) {
+    if (!session.pendingQuestionSet)
+        return;
+    const { currentIndex, questions } = session.pendingQuestionSet;
+    if (currentIndex >= questions.length)
+        return;
+    const q = questions[currentIndex];
+    const total = questions.length;
+    // Format the question message
+    let message = `❓ **Question** *(${currentIndex + 1}/${total})*\n`;
+    message += `**${q.header}:** ${q.question}\n\n`;
+    for (let i = 0; i < q.options.length && i < 4; i++) {
+        const emoji = ['1️⃣', '2️⃣', '3️⃣', '4️⃣'][i];
+        message += `${emoji} **${q.options[i].label}**`;
+        if (q.options[i].description) {
+            message += ` - ${q.options[i].description}`;
+        }
+        message += '\n';
+    }
+    // Post the question with reaction options
+    const reactionOptions = NUMBER_EMOJIS.slice(0, q.options.length);
+    const post = await session.platform.createInteractivePost(message, reactionOptions, session.threadId);
+    session.pendingQuestionSet.currentPostId = post.id;
+    // Register post for reaction routing
+    ctx.registerPost(post.id, session.threadId);
+}

package/dist/session/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Session module public exports
+ *
+ * Provides SessionManager for managing multiple concurrent Claude Code sessions.
+ */
+export { SessionManager } from './manager.js';
+export type { Session, PendingApproval, PendingQuestionSet, PendingMessageApproval, } from './types.js';

package/dist/session/index.js

@@ -0,0 +1,6 @@
+/**
+ * Session module public exports
+ *
+ * Provides SessionManager for managing multiple concurrent Claude Code sessions.
+ */
+export { SessionManager } from './manager.js';

package/dist/session/lifecycle.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Session lifecycle management module
+ *
+ * Handles session start, resume, exit, cleanup, and shutdown.
+ */
+import type { Session } from './types.js';
+import type { PlatformClient, PlatformFile } from '../platform/index.js';
+import type { ClaudeEvent, ContentBlock } from '../claude/cli.js';
+import type { PersistedSession, SessionStore } from '../persistence/session-store.js';
+export interface LifecycleContext {
+    workingDir: string;
+    skipPermissions: boolean;
+    chromeEnabled: boolean;
+    debug: boolean;
+    maxSessions: number;
+    sessions: Map<string, Session>;
+    postIndex: Map<string, string>;
+    platforms: Map<string, PlatformClient>;
+    sessionStore: SessionStore;
+    isShuttingDown: boolean;
+    getSessionId: (platformId: string, threadId: string) => string;
+    findSessionByThreadId: (threadId: string) => Session | undefined;
+    handleEvent: (sessionId: string, event: ClaudeEvent) => void;
+    handleExit: (sessionId: string, code: number) => Promise<void>;
+    registerPost: (postId: string, threadId: string) => void;
+    startTyping: (session: Session) => void;
+    stopTyping: (session: Session) => void;
+    flush: (session: Session) => Promise<void>;
+    persistSession: (session: Session) => void;
+    unpersistSession: (sessionId: string) => void;
+    updateSessionHeader: (session: Session) => Promise<void>;
+    shouldPromptForWorktree: (session: Session) => Promise<string | null>;
+    postWorktreePrompt: (session: Session, reason: string) => Promise<void>;
+    buildMessageContent: (text: string, platform: PlatformClient, files?: PlatformFile[]) => Promise<string | ContentBlock[]>;
+}
+/**
+ * Create a new session for a thread.
+ */
+export declare function startSession(options: {
+    prompt: string;
+    files?: PlatformFile[];
+}, username: string, replyToPostId: string | undefined, platformId: string, ctx: LifecycleContext): Promise<void>;
+/**
+ * Resume a session from persisted state.
+ */
+export declare function resumeSession(state: PersistedSession, ctx: LifecycleContext): Promise<void>;
+/**
+ * Send a follow-up message to an existing session.
+ */
+export declare function sendFollowUp(session: Session, message: string, files: PlatformFile[] | undefined, ctx: LifecycleContext): Promise<void>;
+/**
+ * Resume a paused session and send a message to it.
+ */
+export declare function resumePausedSession(threadId: string, message: string, files: PlatformFile[] | undefined, ctx: LifecycleContext): Promise<void>;
+/**
+ * Handle Claude CLI exit event.
+ */
+export declare function handleExit(sessionId: string, code: number, ctx: LifecycleContext): Promise<void>;
+/**
+ * Kill a specific session.
+ */
+export declare function killSession(session: Session, unpersist: boolean, ctx: LifecycleContext): void;
+/**
+ * Kill all active sessions.
+ */
+export declare function killAllSessions(ctx: LifecycleContext): void;
+/**
+ * Clean up idle sessions that have timed out.
+ */
+export declare function cleanupIdleSessions(timeoutMs: number, warningMs: number, ctx: LifecycleContext): void;