claude-threads 0.12.0

package/dist/claude/session.d.ts

@@ -0,0 +1,256 @@
+import { ClaudeCli } from './cli.js';
+import { MattermostClient } from '../mattermost/client.js';
+import { MattermostFile } from '../mattermost/types.js';
+import { PersistedSession, WorktreeInfo } from '../persistence/session-store.js';
+import { WorktreeMode } from '../config.js';
+interface QuestionOption {
+    label: string;
+    description: string;
+}
+interface PendingQuestionSet {
+    toolUseId: string;
+    currentIndex: number;
+    currentPostId: string | null;
+    questions: Array<{
+        header: string;
+        question: string;
+        options: QuestionOption[];
+        answer: string | null;
+    }>;
+}
+interface PendingApproval {
+    postId: string;
+    type: 'plan' | 'action';
+    toolUseId: string;
+}
+/**
+ * Pending message from unauthorized user awaiting approval
+ */
+interface PendingMessageApproval {
+    postId: string;
+    originalMessage: string;
+    fromUser: string;
+}
+/**
+ * Represents a single Claude Code session tied to a Mattermost thread.
+ * Each session has its own Claude CLI process and state.
+ */
+interface Session {
+    threadId: string;
+    claudeSessionId: string;
+    startedBy: string;
+    startedAt: Date;
+    lastActivityAt: Date;
+    sessionNumber: number;
+    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 class SessionManager {
+    private mattermost;
+    private workingDir;
+    private skipPermissions;
+    private chromeEnabled;
+    private worktreeMode;
+    private debug;
+    private sessions;
+    private postIndex;
+    private sessionStore;
+    private cleanupTimer;
+    private isShuttingDown;
+    constructor(mattermost: MattermostClient, workingDir: string, skipPermissions?: boolean, chromeEnabled?: boolean, worktreeMode?: WorktreeMode);
+    /**
+     * Initialize session manager by resuming any persisted sessions.
+     * Should be called before starting to listen for new messages.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Resume a single session from persisted state
+     */
+    private resumeSession;
+    /**
+     * Persist a session to disk
+     */
+    private persistSession;
+    /**
+     * Remove a session from persistence
+     */
+    private unpersistSession;
+    /** Get a session by thread ID */
+    getSession(threadId: string): Session | undefined;
+    /** Check if a session exists for this thread */
+    hasSession(threadId: string): boolean;
+    /** Get the number of active sessions */
+    getSessionCount(): number;
+    /** Get all active session thread IDs */
+    getActiveThreadIds(): string[];
+    /** Mark that we're shutting down (prevents cleanup of persisted sessions) */
+    setShuttingDown(): void;
+    /** Register a post for reaction routing */
+    private registerPost;
+    /** Find session by post ID (for reaction routing) */
+    private getSessionByPost;
+    /**
+     * Check if a user is allowed in a specific session.
+     * Checks global allowlist first, then session-specific allowlist.
+     */
+    isUserAllowedInSession(threadId: string, username: string): boolean;
+    startSession(options: {
+        prompt: string;
+        files?: MattermostFile[];
+    }, username: string, replyToPostId?: string): Promise<void>;
+    /**
+     * Start a session with an initial worktree specified.
+     * Used when user specifies "on branch X" or "!worktree X" in their initial message.
+     */
+    startSessionWithWorktree(options: {
+        prompt: string;
+        files?: MattermostFile[];
+    }, branch: string, username: string, replyToPostId?: string): Promise<void>;
+    /**
+     * Check if we should prompt for a worktree before starting work.
+     * Returns the reason string if we should prompt, or null if not.
+     */
+    private shouldPromptForWorktree;
+    /**
+     * Check if another session is using the same repository
+     */
+    private hasOtherSessionInRepo;
+    /**
+     * Post the worktree prompt message
+     */
+    private postWorktreePrompt;
+    private handleEvent;
+    private handleTaskComplete;
+    private handleExitPlanMode;
+    private handleTodoWrite;
+    private handleTaskStart;
+    private handleAskUserQuestion;
+    private postCurrentQuestion;
+    private handleReaction;
+    private handleQuestionReaction;
+    private handleApprovalReaction;
+    private handleMessageApprovalReaction;
+    private formatEvent;
+    private appendContent;
+    private scheduleUpdate;
+    /**
+     * Build message content for Claude, including images if present.
+     * Returns either a string or an array of content blocks.
+     */
+    private buildMessageContent;
+    private startTyping;
+    private stopTyping;
+    private flush;
+    private handleExit;
+    /** Check if any sessions are active */
+    isSessionActive(): boolean;
+    /** Check if a session exists for this thread */
+    isInSessionThread(threadRoot: string): boolean;
+    /** Send a follow-up message to an existing session */
+    sendFollowUp(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
+    /**
+     * Check if there's a paused (persisted but not active) session for this thread.
+     * This is used to detect when we should resume a session instead of ignoring the message.
+     */
+    hasPausedSession(threadId: string): boolean;
+    /**
+     * Resume a paused session and send a message to it.
+     * Called when a user sends a message to a thread with a paused session.
+     */
+    resumePausedSession(threadId: string, message: string, files?: MattermostFile[]): Promise<void>;
+    /**
+     * Get persisted session info for access control checks
+     */
+    getPersistedSession(threadId: string): PersistedSession | undefined;
+    /** Kill a specific session */
+    killSession(threadId: string, unpersist?: boolean): void;
+    /** Cancel a session with user feedback */
+    cancelSession(threadId: string, username: string): Promise<void>;
+    /** Interrupt current processing but keep session alive (like Escape in CLI) */
+    interruptSession(threadId: string, username: string): Promise<void>;
+    /** Change working directory for a session (restarts Claude CLI) */
+    changeDirectory(threadId: string, newDir: string, username: string): Promise<void>;
+    /** Invite a user to participate in a specific session */
+    inviteUser(threadId: string, invitedUser: string, invitedBy: string): Promise<void>;
+    /** Kick a user from a specific session */
+    kickUser(threadId: string, kickedUser: string, kickedBy: string): Promise<void>;
+    /**
+     * Enable interactive permissions for a session.
+     * Can only downgrade (skip → interactive), not upgrade.
+     */
+    enableInteractivePermissions(threadId: string, username: string): Promise<void>;
+    /** Check if a session should use interactive permissions */
+    isSessionInteractive(threadId: string): boolean;
+    /** Update the session header post with current participants */
+    private updateSessionHeader;
+    /** Request approval for a message from an unauthorized user */
+    requestMessageApproval(threadId: string, username: string, message: string): Promise<void>;
+    /**
+     * Handle a worktree branch response from user.
+     * Called when user replies with a branch name to the worktree prompt.
+     */
+    handleWorktreeBranchResponse(threadId: string, branchName: string, username: string): Promise<boolean>;
+    /**
+     * Handle ❌ reaction on worktree prompt - skip worktree and continue in main repo.
+     */
+    handleWorktreeSkip(threadId: string, username: string): Promise<void>;
+    /**
+     * Create a new worktree and switch the session to it.
+     */
+    createAndSwitchToWorktree(threadId: string, branch: string, username: string): Promise<void>;
+    /**
+     * Switch to an existing worktree.
+     */
+    switchToWorktree(threadId: string, branchOrPath: string, username: string): Promise<void>;
+    /**
+     * List all worktrees for the current repository.
+     */
+    listWorktreesCommand(threadId: string, _username: string): Promise<void>;
+    /**
+     * Remove a worktree.
+     */
+    removeWorktreeCommand(threadId: string, branchOrPath: string, username: string): Promise<void>;
+    /**
+     * Disable worktree prompts for a session.
+     */
+    disableWorktreePrompt(threadId: string, username: string): Promise<void>;
+    /**
+     * Check if a session has a pending worktree prompt.
+     */
+    hasPendingWorktreePrompt(threadId: string): boolean;
+    /**
+     * Get the worktree prompt post ID for a session.
+     */
+    getWorktreePromptPostId(threadId: string): string | undefined;
+    /** Kill all active sessions (for graceful shutdown) */
+    killAllSessions(): void;
+    /** Kill all sessions AND unpersist them (for emergency shutdown - no resume) */
+    killAllSessionsAndUnpersist(): void;
+    /** Cleanup idle sessions that have exceeded timeout */
+    private cleanupIdleSessions;
+}
+export {};