claude-threads 0.15.0 → 0.16.2

package/dist/session/manager.js

@@ -1,537 +0,0 @@
-/**
- * SessionManager - Orchestrates Claude Code sessions across chat platforms
- *
- * This is the main coordinator that delegates to specialized modules:
- * - lifecycle.ts: Session start, resume, exit
- * - events.ts: Claude event handling
- * - reactions.ts: User reaction handling
- * - commands.ts: User commands (!cd, !invite, etc.)
- * - worktree.ts: Git worktree management
- * - streaming.ts: Message streaming and flushing
- */
-import { SessionStore } from '../persistence/session-store.js';
-import { isCancelEmoji, isEscapeEmoji, } from '../utils/emoji.js';
-// Import extracted modules
-import * as streaming from './streaming.js';
-import * as events from './events.js';
-import * as reactions from './reactions.js';
-import * as commands from './commands.js';
-import * as lifecycle from './lifecycle.js';
-import * as worktreeModule from './worktree.js';
-// Import constants for internal use
-import { MAX_SESSIONS, SESSION_TIMEOUT_MS, SESSION_WARNING_MS } from './types.js';
-/**
- * SessionManager - Main orchestrator for Claude Code sessions
- */
-export class SessionManager {
-    // Platform management
-    platforms = new Map();
-    workingDir;
-    skipPermissions;
-    chromeEnabled;
-    worktreeMode;
-    debug = process.env.DEBUG === '1' || process.argv.includes('--debug');
-    // Session state
-    sessions = new Map();
-    postIndex = new Map();
-    // Persistence
-    sessionStore = new SessionStore();
-    // Cleanup
-    cleanupTimer = null;
-    // Shutdown flag
-    isShuttingDown = false;
-    constructor(workingDir, skipPermissions = false, chromeEnabled = false, worktreeMode = 'prompt') {
-        this.workingDir = workingDir;
-        this.skipPermissions = skipPermissions;
-        this.chromeEnabled = chromeEnabled;
-        this.worktreeMode = worktreeMode;
-        // Start periodic cleanup
-        this.cleanupTimer = setInterval(() => {
-            lifecycle.cleanupIdleSessions(SESSION_TIMEOUT_MS, SESSION_WARNING_MS, this.getLifecycleContext());
-        }, 60000);
-    }
-    // ---------------------------------------------------------------------------
-    // Platform Management
-    // ---------------------------------------------------------------------------
-    addPlatform(platformId, client) {
-        this.platforms.set(platformId, client);
-        client.on('message', (post, user) => this.handleMessage(platformId, post, user));
-        client.on('reaction', (reaction, user) => {
-            if (user) {
-                this.handleReaction(platformId, reaction.postId, reaction.emojiName, user.username);
-            }
-        });
-        console.log(`  📡 Platform "${platformId}" registered`);
-    }
-    removePlatform(platformId) {
-        this.platforms.delete(platformId);
-    }
-    // ---------------------------------------------------------------------------
-    // Context Builders (for module delegation)
-    // ---------------------------------------------------------------------------
-    getLifecycleContext() {
-        return {
-            workingDir: this.workingDir,
-            skipPermissions: this.skipPermissions,
-            chromeEnabled: this.chromeEnabled,
-            debug: this.debug,
-            maxSessions: MAX_SESSIONS,
-            sessions: this.sessions,
-            postIndex: this.postIndex,
-            platforms: this.platforms,
-            sessionStore: this.sessionStore,
-            isShuttingDown: this.isShuttingDown,
-            getSessionId: (pid, tid) => this.getSessionId(pid, tid),
-            findSessionByThreadId: (tid) => this.findSessionByThreadId(tid),
-            handleEvent: (sid, e) => this.handleEvent(sid, e),
-            handleExit: (sid, code) => this.handleExit(sid, code),
-            registerPost: (pid, tid) => this.registerPost(pid, tid),
-            startTyping: (s) => this.startTyping(s),
-            stopTyping: (s) => this.stopTyping(s),
-            flush: (s) => this.flush(s),
-            persistSession: (s) => this.persistSession(s),
-            unpersistSession: (sid) => this.unpersistSession(sid),
-            updateSessionHeader: (s) => this.updateSessionHeader(s),
-            shouldPromptForWorktree: (s) => this.shouldPromptForWorktree(s),
-            postWorktreePrompt: (s, r) => this.postWorktreePrompt(s, r),
-            buildMessageContent: (t, p, f) => this.buildMessageContent(t, p, f),
-        };
-    }
-    getEventContext() {
-        return {
-            debug: this.debug,
-            registerPost: (pid, tid) => this.registerPost(pid, tid),
-            flush: (s) => this.flush(s),
-            startTyping: (s) => this.startTyping(s),
-            stopTyping: (s) => this.stopTyping(s),
-            appendContent: (s, t) => this.appendContent(s, t),
-        };
-    }
-    getReactionContext() {
-        return {
-            debug: this.debug,
-            startTyping: (s) => this.startTyping(s),
-            stopTyping: (s) => this.stopTyping(s),
-            updateSessionHeader: (s) => this.updateSessionHeader(s),
-        };
-    }
-    getCommandContext() {
-        return {
-            skipPermissions: this.skipPermissions,
-            chromeEnabled: this.chromeEnabled,
-            maxSessions: MAX_SESSIONS,
-            handleEvent: (tid, e) => this.handleEvent(tid, e),
-            handleExit: (tid, code) => this.handleExit(tid, code),
-            flush: (s) => this.flush(s),
-            startTyping: (s) => this.startTyping(s),
-            stopTyping: (s) => this.stopTyping(s),
-            persistSession: (s) => this.persistSession(s),
-            killSession: (tid) => this.killSession(tid),
-            registerPost: (pid, tid) => this.registerPost(pid, tid),
-        };
-    }
-    // ---------------------------------------------------------------------------
-    // Session ID and Post Index
-    // ---------------------------------------------------------------------------
-    getSessionId(platformId, threadId) {
-        return `${platformId}:${threadId}`;
-    }
-    registerPost(postId, threadId) {
-        this.postIndex.set(postId, threadId);
-    }
-    getSessionByPost(postId) {
-        const threadId = this.postIndex.get(postId);
-        if (!threadId)
-            return undefined;
-        return this.findSessionByThreadId(threadId);
-    }
-    // ---------------------------------------------------------------------------
-    // Message Handling
-    // ---------------------------------------------------------------------------
-    async handleMessage(_platformId, _post, _user) {
-        // Message handling is done by the platform client routing to startSession/sendFollowUp
-        // This is just a placeholder for the event subscription
-    }
-    // ---------------------------------------------------------------------------
-    // Reaction Handling
-    // ---------------------------------------------------------------------------
-    async handleReaction(platformId, postId, emojiName, username) {
-        const session = this.getSessionByPost(postId);
-        if (!session)
-            return;
-        // Verify this reaction is from the same platform
-        if (session.platformId !== platformId)
-            return;
-        // Only process reactions from allowed users
-        if (!session.sessionAllowedUsers.has(username) && !session.platform.isUserAllowed(username)) {
-            return;
-        }
-        await this.handleSessionReaction(session, postId, emojiName, username);
-    }
-    async handleSessionReaction(session, postId, emojiName, username) {
-        // Handle ❌ on worktree prompt
-        if (session.worktreePromptPostId === postId && emojiName === 'x') {
-            await worktreeModule.handleWorktreeSkip(session, username, (s) => this.persistSession(s), (s) => this.startTyping(s));
-            return;
-        }
-        // Handle cancel/escape reactions on session start post
-        if (session.sessionStartPostId === postId) {
-            if (isCancelEmoji(emojiName)) {
-                await commands.cancelSession(session, username, this.getCommandContext());
-                return;
-            }
-            if (isEscapeEmoji(emojiName)) {
-                await commands.interruptSession(session, username);
-                return;
-            }
-        }
-        // Handle question reactions
-        if (session.pendingQuestionSet?.currentPostId === postId) {
-            await reactions.handleQuestionReaction(session, postId, emojiName, username, this.getReactionContext());
-            return;
-        }
-        // Handle plan approval reactions
-        if (session.pendingApproval?.postId === postId) {
-            await reactions.handleApprovalReaction(session, emojiName, username, this.getReactionContext());
-            return;
-        }
-        // Handle message approval reactions
-        if (session.pendingMessageApproval?.postId === postId) {
-            await reactions.handleMessageApprovalReaction(session, emojiName, username, this.getReactionContext());
-            return;
-        }
-    }
-    // ---------------------------------------------------------------------------
-    // Event Handling (delegates to events module)
-    // ---------------------------------------------------------------------------
-    handleEvent(sessionId, event) {
-        const session = this.sessions.get(sessionId);
-        if (!session)
-            return;
-        events.handleEvent(session, event, this.getEventContext());
-    }
-    // ---------------------------------------------------------------------------
-    // Exit Handling (delegates to lifecycle module)
-    // ---------------------------------------------------------------------------
-    async handleExit(sessionId, code) {
-        await lifecycle.handleExit(sessionId, code, this.getLifecycleContext());
-    }
-    // ---------------------------------------------------------------------------
-    // Streaming utilities (delegates to streaming module)
-    // ---------------------------------------------------------------------------
-    appendContent(session, text) {
-        if (!text)
-            return;
-        session.pendingContent += text + '\n';
-        streaming.scheduleUpdate(session, (s) => this.flush(s));
-    }
-    async flush(session) {
-        await streaming.flush(session, (pid, tid) => this.registerPost(pid, tid));
-    }
-    startTyping(session) {
-        streaming.startTyping(session);
-    }
-    stopTyping(session) {
-        streaming.stopTyping(session);
-    }
-    async buildMessageContent(text, platform, files) {
-        return streaming.buildMessageContent(text, platform, files, this.debug);
-    }
-    // ---------------------------------------------------------------------------
-    // Worktree utilities
-    // ---------------------------------------------------------------------------
-    async shouldPromptForWorktree(session) {
-        return worktreeModule.shouldPromptForWorktree(session, this.worktreeMode, (repoRoot, excludeId) => this.hasOtherSessionInRepo(repoRoot, excludeId));
-    }
-    hasOtherSessionInRepo(repoRoot, excludeThreadId) {
-        for (const session of this.sessions.values()) {
-            // Skip the session we're checking from (compare raw threadIds)
-            if (session.threadId === excludeThreadId)
-                continue;
-            if (session.workingDir === repoRoot)
-                return true;
-            if (session.worktreeInfo?.repoRoot === repoRoot)
-                return true;
-        }
-        return false;
-    }
-    async postWorktreePrompt(session, reason) {
-        await worktreeModule.postWorktreePrompt(session, reason, (pid, tid) => this.registerPost(pid, tid));
-        this.stopTyping(session);
-    }
-    // ---------------------------------------------------------------------------
-    // Persistence
-    // ---------------------------------------------------------------------------
-    persistSession(session) {
-        const state = {
-            platformId: session.platformId,
-            threadId: session.threadId,
-            claudeSessionId: session.claudeSessionId,
-            startedBy: session.startedBy,
-            startedAt: session.startedAt.toISOString(),
-            lastActivityAt: session.lastActivityAt.toISOString(),
-            sessionNumber: session.sessionNumber,
-            workingDir: session.workingDir,
-            planApproved: session.planApproved,
-            sessionAllowedUsers: [...session.sessionAllowedUsers],
-            forceInteractivePermissions: session.forceInteractivePermissions,
-            sessionStartPostId: session.sessionStartPostId,
-            tasksPostId: session.tasksPostId,
-            worktreeInfo: session.worktreeInfo,
-            pendingWorktreePrompt: session.pendingWorktreePrompt,
-            worktreePromptDisabled: session.worktreePromptDisabled,
-            queuedPrompt: session.queuedPrompt,
-        };
-        this.sessionStore.save(session.sessionId, state);
-    }
-    unpersistSession(sessionId) {
-        this.sessionStore.remove(sessionId);
-    }
-    // ---------------------------------------------------------------------------
-    // Session Header
-    // ---------------------------------------------------------------------------
-    async updateSessionHeader(session) {
-        await commands.updateSessionHeader(session, this.getCommandContext());
-    }
-    // ---------------------------------------------------------------------------
-    // Public API
-    // ---------------------------------------------------------------------------
-    async initialize() {
-        const persisted = this.sessionStore.load();
-        if (persisted.size === 0)
-            return;
-        console.log(`  🔄 Found ${persisted.size} persisted session(s), attempting resume...`);
-        for (const state of persisted.values()) {
-            await lifecycle.resumeSession(state, this.getLifecycleContext());
-        }
-    }
-    async startSession(options, username, replyToPostId, platformId = 'default') {
-        await lifecycle.startSession(options, username, replyToPostId, platformId, this.getLifecycleContext());
-    }
-    // Helper to find session by threadId (sessions are keyed by composite platformId:threadId)
-    findSessionByThreadId(threadId) {
-        for (const session of this.sessions.values()) {
-            if (session.threadId === threadId) {
-                return session;
-            }
-        }
-        return undefined;
-    }
-    // Helper to find persisted session by threadId (persisted sessions are keyed by composite sessionId)
-    findPersistedByThreadId(threadId) {
-        const persisted = this.sessionStore.load();
-        for (const session of persisted.values()) {
-            if (session.threadId === threadId) {
-                return session;
-            }
-        }
-        return undefined;
-    }
-    async sendFollowUp(threadId, message, files) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session || !session.claude.isRunning())
-            return;
-        await lifecycle.sendFollowUp(session, message, files, this.getLifecycleContext());
-    }
-    isSessionActive() {
-        return this.sessions.size > 0;
-    }
-    isInSessionThread(threadRoot) {
-        const session = this.findSessionByThreadId(threadRoot);
-        return session !== undefined && session.claude.isRunning();
-    }
-    hasPausedSession(threadId) {
-        if (this.findSessionByThreadId(threadId))
-            return false;
-        return this.findPersistedByThreadId(threadId) !== undefined;
-    }
-    async resumePausedSession(threadId, message, files) {
-        await lifecycle.resumePausedSession(threadId, message, files, this.getLifecycleContext());
-    }
-    getPersistedSession(threadId) {
-        return this.findPersistedByThreadId(threadId);
-    }
-    killSession(threadId, unpersist = true) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        lifecycle.killSession(session, unpersist, this.getLifecycleContext());
-    }
-    killAllSessions() {
-        lifecycle.killAllSessions(this.getLifecycleContext());
-    }
-    // Commands
-    async cancelSession(threadId, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.cancelSession(session, username, this.getCommandContext());
-    }
-    async interruptSession(threadId, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.interruptSession(session, username);
-    }
-    async changeDirectory(threadId, newDir, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.changeDirectory(session, newDir, username, this.getCommandContext());
-    }
-    async inviteUser(threadId, invitedUser, invitedBy) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.inviteUser(session, invitedUser, invitedBy, this.getCommandContext());
-    }
-    async kickUser(threadId, kickedUser, kickedBy) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.kickUser(session, kickedUser, kickedBy, this.getCommandContext());
-    }
-    async enableInteractivePermissions(threadId, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.enableInteractivePermissions(session, username, this.getCommandContext());
-    }
-    isSessionInteractive(threadId) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return !this.skipPermissions;
-        if (!this.skipPermissions)
-            return true;
-        return session.forceInteractivePermissions;
-    }
-    async requestMessageApproval(threadId, username, message) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await commands.requestMessageApproval(session, username, message, this.getCommandContext());
-    }
-    // Worktree commands
-    async handleWorktreeBranchResponse(threadId, branchName, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return false;
-        return worktreeModule.handleWorktreeBranchResponse(session, branchName, username, (tid, branch, user) => this.createAndSwitchToWorktree(tid, branch, user));
-    }
-    async handleWorktreeSkip(threadId, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await worktreeModule.handleWorktreeSkip(session, username, (s) => this.persistSession(s), (s) => this.startTyping(s));
-    }
-    async createAndSwitchToWorktree(threadId, branch, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await worktreeModule.createAndSwitchToWorktree(session, branch, username, {
-            skipPermissions: this.skipPermissions,
-            chromeEnabled: this.chromeEnabled,
-            handleEvent: (tid, e) => this.handleEvent(tid, e),
-            handleExit: (tid, code) => this.handleExit(tid, code),
-            updateSessionHeader: (s) => this.updateSessionHeader(s),
-            flush: (s) => this.flush(s),
-            persistSession: (s) => this.persistSession(s),
-            startTyping: (s) => this.startTyping(s),
-            stopTyping: (s) => this.stopTyping(s),
-        });
-    }
-    async switchToWorktree(threadId, branchOrPath, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await worktreeModule.switchToWorktree(session, branchOrPath, username, (tid, dir, user) => this.changeDirectory(tid, dir, user));
-    }
-    async listWorktreesCommand(threadId, _username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await worktreeModule.listWorktreesCommand(session);
-    }
-    async removeWorktreeCommand(threadId, branchOrPath, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await worktreeModule.removeWorktreeCommand(session, branchOrPath, username);
-    }
-    async disableWorktreePrompt(threadId, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session)
-            return;
-        await worktreeModule.disableWorktreePrompt(session, username, (s) => this.persistSession(s));
-    }
-    hasPendingWorktreePrompt(threadId) {
-        const session = this.findSessionByThreadId(threadId);
-        return session?.pendingWorktreePrompt === true;
-    }
-    // Missing public methods needed by index.ts
-    getActiveThreadIds() {
-        // Return raw threadIds (not composite sessionIds) for posting to chat
-        return [...this.sessions.values()].map(s => s.threadId);
-    }
-    killAllSessionsAndUnpersist() {
-        for (const session of this.sessions.values()) {
-            this.stopTyping(session);
-            session.claude.kill();
-            this.unpersistSession(session.sessionId);
-        }
-        this.sessions.clear();
-        this.postIndex.clear();
-    }
-    isUserAllowedInSession(threadId, username) {
-        const session = this.findSessionByThreadId(threadId);
-        if (!session) {
-            // Check persisted session
-            const persisted = this.getPersistedSession(threadId);
-            if (persisted) {
-                return persisted.sessionAllowedUsers.includes(username) ||
-                    this.platforms.get(persisted.platformId)?.isUserAllowed(username) || false;
-            }
-            return false;
-        }
-        return session.sessionAllowedUsers.has(username) || session.platform.isUserAllowed(username);
-    }
-    async startSessionWithWorktree(options, branch, username, replyToPostId, platformId = 'default') {
-        // Start normal session first
-        await this.startSession(options, username, replyToPostId, platformId);
-        // Then switch to worktree
-        const threadId = replyToPostId || '';
-        const session = this.sessions.get(this.getSessionId(platformId, threadId));
-        if (session) {
-            await this.createAndSwitchToWorktree(session.threadId, branch, username);
-        }
-    }
-    setShuttingDown() {
-        this.isShuttingDown = true;
-    }
-    // Shutdown
-    async shutdown(message) {
-        this.isShuttingDown = true;
-        if (this.cleanupTimer) {
-            clearInterval(this.cleanupTimer);
-            this.cleanupTimer = null;
-        }
-        // Post shutdown message to all active sessions
-        if (message) {
-            for (const session of this.sessions.values()) {
-                try {
-                    await session.platform.createPost(message, session.threadId);
-                }
-                catch {
-                    // Ignore
-                }
-            }
-        }
-        // Kill all sessions but preserve persistence
-        for (const session of this.sessions.values()) {
-            this.stopTyping(session);
-            session.claude.kill();
-        }
-        this.sessions.clear();
-        this.postIndex.clear();
-    }
-}

package/dist/session/reactions.d.ts

@@ -1,25 +0,0 @@
-/**
- * User reaction handling module
- *
- * Handles emoji reactions on posts: plan approval, question answers,
- * message approval, cancel/escape actions.
- */
-import type { Session } from './types.js';
-export interface ReactionContext {
-    debug: boolean;
-    startTyping: (session: Session) => void;
-    stopTyping: (session: Session) => void;
-    updateSessionHeader: (session: Session) => Promise<void>;
-}
-/**
- * Handle a reaction on a question post (number emoji to select an option).
- */
-export declare function handleQuestionReaction(session: Session, postId: string, emojiName: string, username: string, ctx: ReactionContext): Promise<void>;
-/**
- * Handle a reaction on a plan approval post (thumbs up/down).
- */
-export declare function handleApprovalReaction(session: Session, emojiName: string, username: string, ctx: ReactionContext): Promise<void>;
-/**
- * Handle a reaction on a message approval post (approve/invite/deny).
- */
-export declare function handleMessageApprovalReaction(session: Session, emoji: string, approver: string, ctx: ReactionContext): Promise<void>;