claude-threads 0.15.0 → 0.16.2

package/dist/session/events.js

@@ -1,368 +0,0 @@
-/**
- * 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

@@ -1,7 +0,0 @@
-/**
- * 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

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

package/dist/session/lifecycle.d.ts

@@ -1,70 +0,0 @@
-/**
- * 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;