claude-threads 0.14.1 → 0.16.2

package/dist/session/reactions.js

@@ -1,151 +0,0 @@
-/**
- * User reaction handling module
- *
- * Handles emoji reactions on posts: plan approval, question answers,
- * message approval, cancel/escape actions.
- */
-import { isApprovalEmoji, isDenialEmoji, isAllowAllEmoji, getNumberEmojiIndex, } from '../utils/emoji.js';
-import { postCurrentQuestion } from './events.js';
-// ---------------------------------------------------------------------------
-// Question reaction handling
-// ---------------------------------------------------------------------------
-/**
- * Handle a reaction on a question post (number emoji to select an option).
- */
-export async function handleQuestionReaction(session, postId, emojiName, username, ctx) {
-    if (!session.pendingQuestionSet)
-        return;
-    const { currentIndex, questions } = session.pendingQuestionSet;
-    const question = questions[currentIndex];
-    if (!question)
-        return;
-    const optionIndex = getNumberEmojiIndex(emojiName);
-    if (optionIndex < 0 || optionIndex >= question.options.length)
-        return;
-    const selectedOption = question.options[optionIndex];
-    question.answer = selectedOption.label;
-    if (ctx.debug)
-        console.log(`  💬 @${username} answered "${question.header}": ${selectedOption.label}`);
-    // Update the post to show answer
-    try {
-        await session.platform.updatePost(postId, `✅ **${question.header}**: ${selectedOption.label}`);
-    }
-    catch (err) {
-        console.error('  ⚠️ Failed to update answered question:', err);
-    }
-    // Move to next question or finish
-    session.pendingQuestionSet.currentIndex++;
-    if (session.pendingQuestionSet.currentIndex < questions.length) {
-        // Post next question
-        await postCurrentQuestion(session, {
-            debug: ctx.debug,
-            registerPost: () => { }, // Will be called by events module
-            flush: async () => { },
-            startTyping: ctx.startTyping,
-            stopTyping: ctx.stopTyping,
-            appendContent: () => { },
-        });
-    }
-    else {
-        // All questions answered - send tool result
-        let answersText = 'Here are my answers:\n';
-        for (const q of questions) {
-            answersText += `- **${q.header}**: ${q.answer}\n`;
-        }
-        if (ctx.debug)
-            console.log('  ✅ All questions answered');
-        // Get the toolUseId before clearing
-        const toolUseId = session.pendingQuestionSet.toolUseId;
-        // Clear pending questions
-        session.pendingQuestionSet = null;
-        // Send tool result to Claude (AskUserQuestion expects a tool_result, not a user message)
-        if (session.claude.isRunning()) {
-            session.claude.sendToolResult(toolUseId, answersText);
-            ctx.startTyping(session);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Plan approval reaction handling
-// ---------------------------------------------------------------------------
-/**
- * Handle a reaction on a plan approval post (thumbs up/down).
- */
-export async function handleApprovalReaction(session, emojiName, username, ctx) {
-    if (!session.pendingApproval)
-        return;
-    const isApprove = isApprovalEmoji(emojiName);
-    const isReject = isDenialEmoji(emojiName);
-    if (!isApprove && !isReject)
-        return;
-    const { postId, toolUseId } = session.pendingApproval;
-    const shortId = session.threadId.substring(0, 8);
-    console.log(`  ${isApprove ? '✅' : '❌'} Plan ${isApprove ? 'approved' : 'rejected'} (${shortId}…) by @${username}`);
-    // Update the post to show the decision
-    try {
-        const statusMessage = isApprove
-            ? `✅ **Plan approved** by @${username} - starting implementation...`
-            : `❌ **Changes requested** by @${username}`;
-        await session.platform.updatePost(postId, statusMessage);
-    }
-    catch (err) {
-        console.error('  ⚠️ Failed to update approval post:', err);
-    }
-    // Clear pending approval and mark as approved
-    session.pendingApproval = null;
-    if (isApprove) {
-        session.planApproved = true;
-    }
-    // Send tool result to Claude (ExitPlanMode expects a tool_result, not a user message)
-    if (session.claude.isRunning()) {
-        const response = isApprove
-            ? 'Approved. Please proceed with the implementation.'
-            : 'Please revise the plan. I would like some changes.';
-        session.claude.sendToolResult(toolUseId, response);
-        ctx.startTyping(session);
-    }
-}
-// ---------------------------------------------------------------------------
-// Message approval reaction handling
-// ---------------------------------------------------------------------------
-/**
- * Handle a reaction on a message approval post (approve/invite/deny).
- */
-export async function handleMessageApprovalReaction(session, emoji, approver, ctx) {
-    const pending = session.pendingMessageApproval;
-    if (!pending)
-        return;
-    // Only session owner or globally allowed users can approve
-    if (session.startedBy !== approver && !session.platform.isUserAllowed(approver)) {
-        return;
-    }
-    const isAllow = isApprovalEmoji(emoji);
-    const isInvite = isAllowAllEmoji(emoji);
-    const isDeny = isDenialEmoji(emoji);
-    if (!isAllow && !isInvite && !isDeny)
-        return;
-    if (isAllow) {
-        // Allow this single message
-        await session.platform.updatePost(pending.postId, `✅ Message from @${pending.fromUser} approved by @${approver}`);
-        session.claude.sendMessage(pending.originalMessage);
-        session.lastActivityAt = new Date();
-        ctx.startTyping(session);
-        console.log(`  ✅ Message from @${pending.fromUser} approved by @${approver}`);
-    }
-    else if (isInvite) {
-        // Invite user to session
-        session.sessionAllowedUsers.add(pending.fromUser);
-        await session.platform.updatePost(pending.postId, `✅ @${pending.fromUser} invited to session by @${approver}`);
-        await ctx.updateSessionHeader(session);
-        session.claude.sendMessage(pending.originalMessage);
-        session.lastActivityAt = new Date();
-        ctx.startTyping(session);
-        console.log(`  👋 @${pending.fromUser} invited to session by @${approver}`);
-    }
-    else if (isDeny) {
-        // Deny
-        await session.platform.updatePost(pending.postId, `❌ Message from @${pending.fromUser} denied by @${approver}`);
-        console.log(`  ❌ Message from @${pending.fromUser} denied by @${approver}`);
-    }
-    session.pendingMessageApproval = null;
-}

package/dist/session/streaming.d.ts

@@ -1,47 +0,0 @@
-/**
- * Message streaming and flushing utilities
- *
- * Handles buffering, formatting, and posting Claude responses to the platform.
- */
-import type { PlatformClient, PlatformFile } from '../platform/index.js';
-import type { Session } from './types.js';
-import type { ContentBlock } from '../claude/cli.js';
-/**
- * Schedule a delayed flush of the session's pending content.
- * If an update is already scheduled, this is a no-op.
- *
- * Used during streaming to batch updates and avoid excessive API calls.
- */
-export declare function scheduleUpdate(session: Session, onFlush: (session: Session) => Promise<void>): void;
-/**
- * Build message content for Claude, including images if present.
- * Returns either a string or an array of content blocks.
- *
- * @param text - The text message
- * @param platform - Platform client for downloading images
- * @param files - Optional files attached to the message
- * @param debug - Whether to log debug info
- * @returns Plain string or content blocks array with images
- */
-export declare function buildMessageContent(text: string, platform: PlatformClient, files?: PlatformFile[], debug?: boolean): Promise<string | ContentBlock[]>;
-/**
- * Start sending typing indicators to the platform.
- * Sends immediately, then every 3 seconds until stopped.
- */
-export declare function startTyping(session: Session): void;
-/**
- * Stop sending typing indicators.
- */
-export declare function stopTyping(session: Session): void;
-/**
- * Flush pending content to the platform.
- *
- * Handles:
- * - Message length limits (splits into multiple posts if needed)
- * - Creating vs updating posts
- * - Post registration for reaction routing
- *
- * @param session - The session to flush
- * @param registerPost - Callback to register post for reaction routing
- */
-export declare function flush(session: Session, registerPost: (postId: string, threadId: string) => void): Promise<void>;

package/dist/session/streaming.js

@@ -1,152 +0,0 @@
-/**
- * Message streaming and flushing utilities
- *
- * Handles buffering, formatting, and posting Claude responses to the platform.
- */
-/**
- * Schedule a delayed flush of the session's pending content.
- * If an update is already scheduled, this is a no-op.
- *
- * Used during streaming to batch updates and avoid excessive API calls.
- */
-export function scheduleUpdate(session, onFlush) {
-    if (session.updateTimer)
-        return;
-    session.updateTimer = setTimeout(() => {
-        session.updateTimer = null;
-        onFlush(session);
-    }, 500);
-}
-/**
- * Build message content for Claude, including images if present.
- * Returns either a string or an array of content blocks.
- *
- * @param text - The text message
- * @param platform - Platform client for downloading images
- * @param files - Optional files attached to the message
- * @param debug - Whether to log debug info
- * @returns Plain string or content blocks array with images
- */
-export async function buildMessageContent(text, platform, files, debug = false) {
-    // Filter to only image files
-    const imageFiles = files?.filter(f => f.mimeType.startsWith('image/') &&
-        ['image/jpeg', 'image/png', 'image/gif', 'image/webp'].includes(f.mimeType)) || [];
-    // If no images, return plain text
-    if (imageFiles.length === 0) {
-        return text;
-    }
-    // Build content blocks with images
-    const blocks = [];
-    // Download and add each image
-    for (const file of imageFiles) {
-        try {
-            if (!platform.downloadFile) {
-                console.warn(`  ⚠️ Platform does not support file downloads, skipping ${file.name}`);
-                continue;
-            }
-            const buffer = await platform.downloadFile(file.id);
-            const base64 = buffer.toString('base64');
-            blocks.push({
-                type: 'image',
-                source: {
-                    type: 'base64',
-                    media_type: file.mimeType,
-                    data: base64,
-                },
-            });
-            if (debug) {
-                console.log(`  📷 Attached image: ${file.name} (${file.mimeType}, ${Math.round(buffer.length / 1024)}KB)`);
-            }
-        }
-        catch (err) {
-            console.error(`  ⚠️ Failed to download image ${file.name}:`, err);
-        }
-    }
-    // Add the text message
-    if (text) {
-        blocks.push({
-            type: 'text',
-            text,
-        });
-    }
-    return blocks;
-}
-/**
- * Start sending typing indicators to the platform.
- * Sends immediately, then every 3 seconds until stopped.
- */
-export function startTyping(session) {
-    if (session.typingTimer)
-        return;
-    // Send typing immediately, then every 3 seconds
-    session.platform.sendTyping(session.threadId);
-    session.typingTimer = setInterval(() => {
-        session.platform.sendTyping(session.threadId);
-    }, 3000);
-}
-/**
- * Stop sending typing indicators.
- */
-export function stopTyping(session) {
-    if (session.typingTimer) {
-        clearInterval(session.typingTimer);
-        session.typingTimer = null;
-    }
-}
-/**
- * Flush pending content to the platform.
- *
- * Handles:
- * - Message length limits (splits into multiple posts if needed)
- * - Creating vs updating posts
- * - Post registration for reaction routing
- *
- * @param session - The session to flush
- * @param registerPost - Callback to register post for reaction routing
- */
-export async function flush(session, registerPost) {
-    if (!session.pendingContent.trim())
-        return;
-    let content = session.pendingContent.replace(/\n{3,}/g, '\n\n').trim();
-    // Most chat platforms have post length limits (~16K for Mattermost/Slack)
-    const MAX_POST_LENGTH = 16000; // Leave some margin
-    const CONTINUATION_THRESHOLD = 14000; // Start new message before we hit the limit
-    // Check if we need to start a new message due to length
-    if (session.currentPostId && content.length > CONTINUATION_THRESHOLD) {
-        // Finalize the current post with what we have up to the threshold
-        // Find a good break point (end of line) near the threshold
-        let breakPoint = content.lastIndexOf('\n', CONTINUATION_THRESHOLD);
-        if (breakPoint < CONTINUATION_THRESHOLD * 0.7) {
-            // If we can't find a good line break, just break at the threshold
-            breakPoint = CONTINUATION_THRESHOLD;
-        }
-        const firstPart = content.substring(0, breakPoint).trim() + '\n\n*... (continued below)*';
-        const remainder = content.substring(breakPoint).trim();
-        // Update the current post with the first part
-        await session.platform.updatePost(session.currentPostId, firstPart);
-        // Start a new post for the continuation
-        session.currentPostId = null;
-        session.pendingContent = remainder;
-        // Create the continuation post if there's content
-        if (remainder) {
-            const post = await session.platform.createPost('*(continued)*\n\n' + remainder, session.threadId);
-            session.currentPostId = post.id;
-            registerPost(post.id, session.threadId);
-        }
-        return;
-    }
-    // Normal case: content fits in current post
-    if (content.length > MAX_POST_LENGTH) {
-        // Safety truncation if we somehow got content that's still too long
-        content = content.substring(0, MAX_POST_LENGTH - 50) + '\n\n*... (truncated)*';
-    }
-    if (session.currentPostId) {
-        await session.platform.updatePost(session.currentPostId, content);
-    }
-    else {
-        const post = await session.platform.createPost(content, session.threadId);
-        session.currentPostId = post.id;
-        // Register post for reaction routing
-        registerPost(post.id, session.threadId);
-    }
-}

package/dist/session/types.d.ts

@@ -1,78 +0,0 @@
-/**
- * Session management types and interfaces
- */
-import type { ClaudeCli } from '../claude/cli.js';
-import type { PlatformClient } from '../platform/index.js';
-import type { WorktreeInfo } from '../persistence/session-store.js';
-export interface QuestionOption {
-    label: string;
-    description: string;
-}
-export interface PendingQuestionSet {
-    toolUseId: string;
-    currentIndex: number;
-    currentPostId: string | null;
-    questions: Array<{
-        header: string;
-        question: string;
-        options: QuestionOption[];
-        answer: string | null;
-    }>;
-}
-export interface PendingApproval {
-    postId: string;
-    type: 'plan' | 'action';
-    toolUseId: string;
-}
-/**
- * Pending message from unauthorized user awaiting approval
- */
-export interface PendingMessageApproval {
-    postId: string;
-    originalMessage: string;
-    fromUser: string;
-}
-/**
- * Represents a single Claude Code session tied to a platform thread.
- * Each session has its own Claude CLI process and state.
- */
-export interface Session {
-    platformId: string;
-    threadId: string;
-    sessionId: string;
-    claudeSessionId: string;
-    startedBy: string;
-    startedAt: Date;
-    lastActivityAt: Date;
-    sessionNumber: number;
-    platform: PlatformClient;
-    workingDir: string;
-    claude: ClaudeCli;
-    currentPostId: string | null;
-    pendingContent: string;
-    pendingApproval: PendingApproval | null;
-    pendingQuestionSet: PendingQuestionSet | null;
-    pendingMessageApproval: PendingMessageApproval | null;
-    planApproved: boolean;
-    sessionAllowedUsers: Set<string>;
-    forceInteractivePermissions: boolean;
-    sessionStartPostId: string | null;
-    tasksPostId: string | null;
-    activeSubagents: Map<string, string>;
-    updateTimer: ReturnType<typeof setTimeout> | null;
-    typingTimer: ReturnType<typeof setInterval> | null;
-    timeoutWarningPosted: boolean;
-    isRestarting: boolean;
-    isResumed: boolean;
-    wasInterrupted: boolean;
-    inProgressTaskStart: number | null;
-    activeToolStarts: Map<string, number>;
-    worktreeInfo?: WorktreeInfo;
-    pendingWorktreePrompt?: boolean;
-    worktreePromptDisabled?: boolean;
-    queuedPrompt?: string;
-    worktreePromptPostId?: string;
-}
-export declare const MAX_SESSIONS: number;
-export declare const SESSION_TIMEOUT_MS: number;
-export declare const SESSION_WARNING_MS: number;

package/dist/session/types.js

@@ -1,9 +0,0 @@
-/**
- * Session management types and interfaces
- */
-// =============================================================================
-// Configuration Constants
-// =============================================================================
-export const MAX_SESSIONS = parseInt(process.env.MAX_SESSIONS || '5', 10);
-export const SESSION_TIMEOUT_MS = parseInt(process.env.SESSION_TIMEOUT_MS || '1800000', 10); // 30 min
-export const SESSION_WARNING_MS = 5 * 60 * 1000; // Warn 5 minutes before timeout

package/dist/session/worktree.d.ts

@@ -1,56 +0,0 @@
-/**
- * Git worktree management utilities
- *
- * Handles worktree prompts, creation, switching, and cleanup.
- */
-import type { Session } from './types.js';
-import type { WorktreeMode } from '../config.js';
-import type { ClaudeEvent } from '../claude/cli.js';
-/**
- * Check if we should prompt the user to create a worktree.
- * Returns the reason for prompting, or null if we shouldn't prompt.
- */
-export declare function shouldPromptForWorktree(session: Session, worktreeMode: WorktreeMode, hasOtherSessionInRepo: (repoRoot: string, excludeThreadId: string) => boolean): Promise<string | null>;
-/**
- * Post the worktree prompt message to the user.
- */
-export declare function postWorktreePrompt(session: Session, reason: string, registerPost: (postId: string, threadId: string) => void): Promise<void>;
-/**
- * Handle user providing a branch name in response to worktree prompt.
- * Returns true if handled (whether successful or not).
- */
-export declare function handleWorktreeBranchResponse(session: Session, branchName: string, username: string, createAndSwitch: (threadId: string, branch: string, username: string) => Promise<void>): Promise<boolean>;
-/**
- * Handle ❌ reaction on worktree prompt - skip worktree and continue in main repo.
- */
-export declare function handleWorktreeSkip(session: Session, username: string, persistSession: (session: Session) => void, startTyping: (session: Session) => void): Promise<void>;
-/**
- * Create a new worktree and switch the session to it.
- */
-export declare function createAndSwitchToWorktree(session: Session, branch: string, username: string, options: {
-    skipPermissions: boolean;
-    chromeEnabled: boolean;
-    handleEvent: (sessionId: string, event: ClaudeEvent) => void;
-    handleExit: (sessionId: string, code: number) => Promise<void>;
-    updateSessionHeader: (session: Session) => Promise<void>;
-    flush: (session: Session) => Promise<void>;
-    persistSession: (session: Session) => void;
-    startTyping: (session: Session) => void;
-    stopTyping: (session: Session) => void;
-}): Promise<void>;
-/**
- * Switch to an existing worktree.
- */
-export declare function switchToWorktree(session: Session, branchOrPath: string, username: string, changeDirectory: (threadId: string, newDir: string, username: string) => Promise<void>): Promise<void>;
-/**
- * List all worktrees for the current repository.
- */
-export declare function listWorktreesCommand(session: Session): Promise<void>;
-/**
- * Remove a worktree.
- */
-export declare function removeWorktreeCommand(session: Session, branchOrPath: string, username: string): Promise<void>;
-/**
- * Disable worktree prompts for a session.
- */
-export declare function disableWorktreePrompt(session: Session, username: string, persistSession: (session: Session) => void): Promise<void>;