claude-threads 0.12.1 → 0.14.0

package/dist/utils/tool-formatter.test.js

@@ -1,5 +1,20 @@
 import { describe, it, expect, beforeEach, afterEach } from 'vitest';
 import { shortenPath, parseMcpToolName, formatToolUse, formatToolForPermission, } from './tool-formatter.js';
+// Mock formatter for tests - uses standard markdown syntax
+const formatter = {
+    formatBold: (text) => `**${text}**`,
+    formatItalic: (text) => `_${text}_`,
+    formatCode: (text) => `\`${text}\``,
+    formatCodeBlock: (code, language) => language ? `\`\`\`${language}\n${code}\n\`\`\`` : `\`\`\`\n${code}\n\`\`\``,
+    formatUserMention: (username) => `@${username}`,
+    formatLink: (text, url) => `[${text}](${url})`,
+    formatListItem: (text) => `- ${text}`,
+    formatNumberedListItem: (num, text) => `${num}. ${text}`,
+    formatBlockquote: (text) => `> ${text}`,
+    formatHorizontalRule: () => '---',
+    formatHeading: (text, level) => `${'#'.repeat(level)} ${text}`,
+    escapeText: (text) => text,
+};
 describe('shortenPath', () => {
     const originalHome = process.env.HOME;
     beforeEach(() => {
@@ -65,11 +80,11 @@ describe('formatToolUse', () => {
         it('formats Read with file path', () => {
             const result = formatToolUse('Read', {
                 file_path: '/Users/testuser/file.ts',
-            });
+            }, formatter);
             expect(result).toBe('📄 **Read** `~/file.ts`');
         });
         it('shows full path when not under home', () => {
-            const result = formatToolUse('Read', { file_path: '/var/log/app.log' });
+            const result = formatToolUse('Read', { file_path: '/var/log/app.log' }, formatter);
             expect(result).toBe('📄 **Read** `/var/log/app.log`');
         });
     });
@@ -79,7 +94,7 @@ describe('formatToolUse', () => {
                 file_path: '/Users/testuser/file.ts',
                 old_string: 'old',
                 new_string: 'new',
-            });
+            }, formatter);
             expect(result).toBe('✏️ **Edit** `~/file.ts`');
         });
         it('formats Edit with diff in detailed mode', () => {
@@ -87,7 +102,7 @@ describe('formatToolUse', () => {
                 file_path: '/Users/testuser/file.ts',
                 old_string: 'old line',
                 new_string: 'new line',
-            }, { detailed: true });
+            }, formatter, { detailed: true });
             expect(result).toContain('✏️ **Edit** `~/file.ts`');
             expect(result).toContain('```diff');
             expect(result).toContain('- old line');
@@ -100,7 +115,7 @@ describe('formatToolUse', () => {
                 file_path: '/Users/testuser/file.ts',
                 old_string: oldLines,
                 new_string: newLines,
-            }, { detailed: true, maxPreviewLines: 10 });
+            }, formatter, { detailed: true, maxPreviewLines: 10 });
             expect(result).toContain('more lines');
         });
     });
@@ -109,16 +124,16 @@ describe('formatToolUse', () => {
             const result = formatToolUse('Write', {
                 file_path: '/Users/testuser/file.ts',
                 content: 'hello world',
-            });
+            }, formatter);
             expect(result).toBe('📝 **Write** `~/file.ts`');
         });
         it('formats Write with preview in detailed mode', () => {
             const result = formatToolUse('Write', {
                 file_path: '/Users/testuser/file.ts',
                 content: 'line 1\nline 2\nline 3',
-            }, { detailed: true });
+            }, formatter, { detailed: true });
             expect(result).toContain('📝 **Write** `~/file.ts`');
-            expect(result).toContain('*(3 lines)*');
+            expect(result).toContain('_(3 lines)_');
             expect(result).toContain('line 1');
         });
         it('truncates long content previews', () => {
@@ -126,189 +141,189 @@ describe('formatToolUse', () => {
             const result = formatToolUse('Write', {
                 file_path: '/Users/testuser/file.ts',
                 content,
-            }, { detailed: true });
+            }, formatter, { detailed: true });
             expect(result).toContain('more lines');
         });
     });
     describe('Bash tool', () => {
         it('formats short commands', () => {
-            const result = formatToolUse('Bash', { command: 'ls -la' });
+            const result = formatToolUse('Bash', { command: 'ls -la' }, formatter);
             expect(result).toBe('💻 **Bash** `ls -la`');
         });
         it('truncates long commands', () => {
             const longCmd = 'x'.repeat(100);
-            const result = formatToolUse('Bash', { command: longCmd });
+            const result = formatToolUse('Bash', { command: longCmd }, formatter);
             expect(result).not.toBeNull();
             expect(result).toContain('...');
             expect(result.length).toBeLessThan(120);
         });
         it('respects custom maxCommandLength', () => {
-            const result = formatToolUse('Bash', { command: '1234567890' }, { maxCommandLength: 5 });
+            const result = formatToolUse('Bash', { command: '1234567890' }, formatter, { maxCommandLength: 5 });
             expect(result).toBe('💻 **Bash** `12345...`');
         });
     });
     describe('Other tools', () => {
         it('formats Glob', () => {
-            const result = formatToolUse('Glob', { pattern: '**/*.ts' });
+            const result = formatToolUse('Glob', { pattern: '**/*.ts' }, formatter);
             expect(result).toBe('🔍 **Glob** `**/*.ts`');
         });
         it('formats Grep', () => {
-            const result = formatToolUse('Grep', { pattern: 'TODO' });
+            const result = formatToolUse('Grep', { pattern: 'TODO' }, formatter);
             expect(result).toBe('🔎 **Grep** `TODO`');
         });
         it('formats EnterPlanMode', () => {
-            const result = formatToolUse('EnterPlanMode', {});
+            const result = formatToolUse('EnterPlanMode', {}, formatter);
             expect(result).toBe('📋 **Planning...**');
         });
         it('formats WebFetch', () => {
             const result = formatToolUse('WebFetch', {
                 url: 'https://example.com/page',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Fetching** `https://example.com/page`');
         });
         it('formats WebSearch', () => {
-            const result = formatToolUse('WebSearch', { query: 'typescript guide' });
+            const result = formatToolUse('WebSearch', { query: 'typescript guide' }, formatter);
             expect(result).toBe('🔍 **Searching** `typescript guide`');
         });
     });
     describe('Tools that return null', () => {
         it('returns null for Task', () => {
-            expect(formatToolUse('Task', {})).toBeNull();
+            expect(formatToolUse('Task', {}, formatter)).toBeNull();
         });
         it('returns null for ExitPlanMode', () => {
-            expect(formatToolUse('ExitPlanMode', {})).toBeNull();
+            expect(formatToolUse('ExitPlanMode', {}, formatter)).toBeNull();
         });
         it('returns null for AskUserQuestion', () => {
-            expect(formatToolUse('AskUserQuestion', {})).toBeNull();
+            expect(formatToolUse('AskUserQuestion', {}, formatter)).toBeNull();
         });
         it('returns null for TodoWrite', () => {
-            expect(formatToolUse('TodoWrite', {})).toBeNull();
+            expect(formatToolUse('TodoWrite', {}, formatter)).toBeNull();
         });
     });
     describe('MCP tools', () => {
         it('formats MCP tools', () => {
-            const result = formatToolUse('mcp__myserver__mytool', { arg: 'value' });
-            expect(result).toBe('🔌 **mytool** *(myserver)*');
+            const result = formatToolUse('mcp__myserver__mytool', { arg: 'value' }, formatter);
+            expect(result).toBe('🔌 **mytool** _(myserver)_');
         });
         it('formats MCP tools with underscores in name', () => {
-            const result = formatToolUse('mcp__my_server__my_tool', { arg: 'value' });
-            expect(result).toBe('🔌 **my_tool** *(my_server)*');
+            const result = formatToolUse('mcp__my_server__my_tool', { arg: 'value' }, formatter);
+            expect(result).toBe('🔌 **my_tool** _(my_server)_');
         });
     });
     describe('Claude in Chrome tools', () => {
         it('formats computer screenshot action', () => {
-            const result = formatToolUse('mcp__claude-in-chrome__computer', { action: 'screenshot' });
+            const result = formatToolUse('mcp__claude-in-chrome__computer', { action: 'screenshot' }, formatter);
             expect(result).toBe('🌐 **Chrome**[computer] `screenshot`');
         });
         it('formats computer click actions with coordinates', () => {
             const result = formatToolUse('mcp__claude-in-chrome__computer', {
                 action: 'left_click',
                 coordinate: [100, 200],
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[computer] `left_click at (100, 200)`');
         });
         it('formats computer type action', () => {
             const result = formatToolUse('mcp__claude-in-chrome__computer', {
                 action: 'type',
                 text: 'hello world',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[computer] `type "hello world"`');
         });
         it('truncates long type text', () => {
             const result = formatToolUse('mcp__claude-in-chrome__computer', {
                 action: 'type',
                 text: 'this is a very long text that should be truncated',
-            });
+            }, formatter);
             expect(result).toContain('...');
         });
         it('formats computer key action', () => {
             const result = formatToolUse('mcp__claude-in-chrome__computer', {
                 action: 'key',
                 text: 'Enter',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[computer] `key Enter`');
         });
         it('formats computer scroll action', () => {
             const result = formatToolUse('mcp__claude-in-chrome__computer', {
                 action: 'scroll',
                 scroll_direction: 'up',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[computer] `scroll up`');
         });
         it('formats computer wait action', () => {
             const result = formatToolUse('mcp__claude-in-chrome__computer', {
                 action: 'wait',
                 duration: 2,
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[computer] `wait 2s`');
         });
         it('formats navigate tool', () => {
             const result = formatToolUse('mcp__claude-in-chrome__navigate', {
                 url: 'https://example.com/page',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[navigate] `https://example.com/page`');
         });
         it('truncates long URLs in navigate', () => {
             const result = formatToolUse('mcp__claude-in-chrome__navigate', {
                 url: 'https://example.com/' + 'x'.repeat(100),
-            });
+            }, formatter);
             expect(result).toContain('...');
         });
         it('formats tabs_context_mcp tool', () => {
-            const result = formatToolUse('mcp__claude-in-chrome__tabs_context_mcp', {});
+            const result = formatToolUse('mcp__claude-in-chrome__tabs_context_mcp', {}, formatter);
             expect(result).toBe('🌐 **Chrome**[tabs] reading context');
         });
         it('formats tabs_create_mcp tool', () => {
-            const result = formatToolUse('mcp__claude-in-chrome__tabs_create_mcp', {});
+            const result = formatToolUse('mcp__claude-in-chrome__tabs_create_mcp', {}, formatter);
             expect(result).toBe('🌐 **Chrome**[tabs] creating new tab');
         });
         it('formats read_page tool', () => {
-            const result = formatToolUse('mcp__claude-in-chrome__read_page', {});
+            const result = formatToolUse('mcp__claude-in-chrome__read_page', {}, formatter);
             expect(result).toBe('🌐 **Chrome**[read_page] accessibility tree');
         });
         it('formats read_page tool with interactive filter', () => {
             const result = formatToolUse('mcp__claude-in-chrome__read_page', {
                 filter: 'interactive',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[read_page] interactive elements');
         });
         it('formats find tool', () => {
             const result = formatToolUse('mcp__claude-in-chrome__find', {
                 query: 'login button',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[find] `login button`');
         });
         it('formats form_input tool', () => {
             const result = formatToolUse('mcp__claude-in-chrome__form_input', {
                 ref: 'ref_1',
                 value: 'test',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[form_input] setting value');
         });
         it('formats get_page_text tool', () => {
-            const result = formatToolUse('mcp__claude-in-chrome__get_page_text', {});
+            const result = formatToolUse('mcp__claude-in-chrome__get_page_text', {}, formatter);
             expect(result).toBe('🌐 **Chrome**[get_page_text] extracting content');
         });
         it('formats javascript_tool', () => {
             const result = formatToolUse('mcp__claude-in-chrome__javascript_tool', {
                 text: 'document.title',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[javascript] executing script');
         });
         it('formats gif_creator tool', () => {
             const result = formatToolUse('mcp__claude-in-chrome__gif_creator', {
                 action: 'start_recording',
-            });
+            }, formatter);
             expect(result).toBe('🌐 **Chrome**[gif] start_recording');
         });
         it('formats unknown Chrome tools', () => {
-            const result = formatToolUse('mcp__claude-in-chrome__new_tool', {});
+            const result = formatToolUse('mcp__claude-in-chrome__new_tool', {}, formatter);
             expect(result).toBe('🌐 **Chrome**[new_tool]');
         });
     });
     describe('Unknown tools', () => {
         it('formats unknown tools with bullet', () => {
-            const result = formatToolUse('CustomTool', {});
+            const result = formatToolUse('CustomTool', {}, formatter);
             expect(result).toBe('● **CustomTool**');
         });
     });
@@ -324,34 +339,34 @@ describe('formatToolForPermission', () => {
     it('formats Read tool', () => {
         const result = formatToolForPermission('Read', {
             file_path: '/Users/testuser/file.ts',
-        });
+        }, formatter);
         expect(result).toBe('📄 **Read** `~/file.ts`');
     });
     it('formats Write tool', () => {
         const result = formatToolForPermission('Write', {
             file_path: '/Users/testuser/file.ts',
-        });
+        }, formatter);
         expect(result).toBe('📝 **Write** `~/file.ts`');
     });
     it('formats Edit tool', () => {
         const result = formatToolForPermission('Edit', {
             file_path: '/Users/testuser/file.ts',
-        });
+        }, formatter);
         expect(result).toBe('✏️ **Edit** `~/file.ts`');
     });
     it('formats Bash with longer truncation limit (100 chars)', () => {
         const cmd = 'x'.repeat(100);
-        const result = formatToolForPermission('Bash', { command: cmd });
+        const result = formatToolForPermission('Bash', { command: cmd }, formatter);
         // Should truncate at 100
         expect(result).toContain('...');
         expect(result.length).toBeLessThan(150);
     });
     it('formats MCP tools', () => {
-        const result = formatToolForPermission('mcp__server__tool', {});
-        expect(result).toBe('🔌 **tool** *(server)*');
+        const result = formatToolForPermission('mcp__server__tool', {}, formatter);
+        expect(result).toBe('🔌 **tool** _(server)_');
     });
     it('formats unknown tools', () => {
-        const result = formatToolForPermission('CustomTool', {});
+        const result = formatToolForPermission('CustomTool', {}, formatter);
         expect(result).toBe('● **CustomTool**');
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Share Claude Code sessions live in a Mattermost channel with interactive features",
   "main": "dist/index.js",
   "type": "module",
@@ -51,15 +51,14 @@
     "@modelcontextprotocol/sdk": "^1.25.1",
     "commander": "^14.0.2",
     "diff": "^8.0.2",
-    "dotenv": "^16.4.7",
     "prompts": "^2.4.2",
     "update-notifier": "^7.3.1",
     "ws": "^8.18.0",
+    "yaml": "^2.8.2",
     "zod": "^4.2.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
-    "@types/diff": "^7.0.2",
     "@types/node": "^22.19.3",
     "@types/prompts": "^2.4.9",
     "@types/update-notifier": "^6.0.8",

package/dist/claude/session.d.ts

@@ -1,256 +0,0 @@
-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 {};