claude-threads 0.12.0

package/dist/persistence/session-store.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Worktree information for a session
+ */
+export interface WorktreeInfo {
+    repoRoot: string;
+    worktreePath: string;
+    branch: string;
+}
+/**
+ * Persisted session state for resuming after bot restart
+ */
+export interface PersistedSession {
+    threadId: string;
+    claudeSessionId: string;
+    startedBy: string;
+    startedAt: string;
+    sessionNumber: number;
+    workingDir: string;
+    sessionAllowedUsers: string[];
+    forceInteractivePermissions: boolean;
+    sessionStartPostId: string | null;
+    tasksPostId: string | null;
+    lastActivityAt: string;
+    planApproved: boolean;
+    worktreeInfo?: WorktreeInfo;
+    pendingWorktreePrompt?: boolean;
+    worktreePromptDisabled?: boolean;
+    queuedPrompt?: string;
+}
+/**
+ * SessionStore - Persistence layer for session state
+ * Stores session data as JSON file for resume after restart
+ */
+export declare class SessionStore {
+    private debug;
+    constructor();
+    /**
+     * Load all persisted sessions
+     */
+    load(): Map<string, PersistedSession>;
+    /**
+     * Save a session (creates or updates)
+     */
+    save(threadId: string, session: PersistedSession): void;
+    /**
+     * Remove a session
+     */
+    remove(threadId: string): void;
+    /**
+     * Remove sessions older than maxAgeMs
+     */
+    cleanStale(maxAgeMs: number): string[];
+    /**
+     * Clear all sessions
+     */
+    clear(): void;
+    /**
+     * Load raw data from file
+     */
+    private loadRaw;
+    /**
+     * Write data atomically (write to temp file, then rename)
+     */
+    private writeAtomic;
+}

package/dist/persistence/session-store.js

@@ -0,0 +1,127 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+const STORE_VERSION = 1;
+const CONFIG_DIR = join(homedir(), '.config', 'claude-threads');
+const SESSIONS_FILE = join(CONFIG_DIR, 'sessions.json');
+/**
+ * SessionStore - Persistence layer for session state
+ * Stores session data as JSON file for resume after restart
+ */
+export class SessionStore {
+    debug = process.env.DEBUG === '1' || process.argv.includes('--debug');
+    constructor() {
+        // Ensure config directory exists
+        if (!existsSync(CONFIG_DIR)) {
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+    }
+    /**
+     * Load all persisted sessions
+     */
+    load() {
+        const sessions = new Map();
+        if (!existsSync(SESSIONS_FILE)) {
+            if (this.debug)
+                console.log('  [persist] No sessions file found');
+            return sessions;
+        }
+        try {
+            const data = JSON.parse(readFileSync(SESSIONS_FILE, 'utf-8'));
+            // Version check for future migrations
+            if (data.version !== STORE_VERSION) {
+                console.warn(`  [persist] Sessions file version mismatch (${data.version} vs ${STORE_VERSION}), starting fresh`);
+                return sessions;
+            }
+            for (const [threadId, session] of Object.entries(data.sessions)) {
+                sessions.set(threadId, session);
+            }
+            if (this.debug) {
+                console.log(`  [persist] Loaded ${sessions.size} session(s)`);
+            }
+        }
+        catch (err) {
+            console.error('  [persist] Failed to load sessions:', err);
+        }
+        return sessions;
+    }
+    /**
+     * Save a session (creates or updates)
+     */
+    save(threadId, session) {
+        const data = this.loadRaw();
+        data.sessions[threadId] = session;
+        this.writeAtomic(data);
+        if (this.debug) {
+            const shortId = threadId.substring(0, 8);
+            console.log(`  [persist] Saved session ${shortId}...`);
+        }
+    }
+    /**
+     * Remove a session
+     */
+    remove(threadId) {
+        const data = this.loadRaw();
+        if (data.sessions[threadId]) {
+            delete data.sessions[threadId];
+            this.writeAtomic(data);
+            if (this.debug) {
+                const shortId = threadId.substring(0, 8);
+                console.log(`  [persist] Removed session ${shortId}...`);
+            }
+        }
+    }
+    /**
+     * Remove sessions older than maxAgeMs
+     */
+    cleanStale(maxAgeMs) {
+        const data = this.loadRaw();
+        const now = Date.now();
+        const staleIds = [];
+        for (const [threadId, session] of Object.entries(data.sessions)) {
+            const lastActivity = new Date(session.lastActivityAt).getTime();
+            if (now - lastActivity > maxAgeMs) {
+                staleIds.push(threadId);
+                delete data.sessions[threadId];
+            }
+        }
+        if (staleIds.length > 0) {
+            this.writeAtomic(data);
+            if (this.debug) {
+                console.log(`  [persist] Cleaned ${staleIds.length} stale session(s)`);
+            }
+        }
+        return staleIds;
+    }
+    /**
+     * Clear all sessions
+     */
+    clear() {
+        this.writeAtomic({ version: STORE_VERSION, sessions: {} });
+        if (this.debug) {
+            console.log('  [persist] Cleared all sessions');
+        }
+    }
+    /**
+     * Load raw data from file
+     */
+    loadRaw() {
+        if (!existsSync(SESSIONS_FILE)) {
+            return { version: STORE_VERSION, sessions: {} };
+        }
+        try {
+            return JSON.parse(readFileSync(SESSIONS_FILE, 'utf-8'));
+        }
+        catch {
+            return { version: STORE_VERSION, sessions: {} };
+        }
+    }
+    /**
+     * Write data atomically (write to temp file, then rename)
+     */
+    writeAtomic(data) {
+        const tempFile = `${SESSIONS_FILE}.tmp`;
+        writeFileSync(tempFile, JSON.stringify(data, null, 2), 'utf-8');
+        renameSync(tempFile, SESSIONS_FILE);
+    }
+}

package/dist/update-notifier.d.ts

@@ -0,0 +1,3 @@
+import { type UpdateInfo } from 'update-notifier';
+export declare function checkForUpdates(): void;
+export declare function getUpdateInfo(): UpdateInfo | undefined;

package/dist/update-notifier.js

@@ -0,0 +1,31 @@
+import updateNotifier from 'update-notifier';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = fileURLToPath(new URL('.', import.meta.url));
+let cachedUpdateInfo;
+export function checkForUpdates() {
+    if (process.env.NO_UPDATE_NOTIFIER)
+        return;
+    try {
+        const pkg = JSON.parse(readFileSync(resolve(__dirname, '..', 'package.json'), 'utf-8'));
+        const notifier = updateNotifier({
+            pkg,
+            updateCheckInterval: 1000 * 60 * 30, // Check every 30 minutes
+        });
+        // Cache for Mattermost notifications
+        cachedUpdateInfo = notifier.update;
+        // Show CLI notification
+        notifier.notify({
+            message: `Update available: {currentVersion} → {latestVersion}
+Run: npm install -g claude-threads`,
+        });
+    }
+    catch {
+        // Silently fail - update checking is not critical
+    }
+}
+// Returns update info if available, for posting to Mattermost
+export function getUpdateInfo() {
+    return cachedUpdateInfo;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Simple debug logging utility
+ *
+ * Provides consistent logging across the codebase with:
+ * - Configurable prefix for different components
+ * - DEBUG environment variable check
+ * - stdout vs stderr routing option
+ */
+export interface Logger {
+    /** Log a debug message (only when DEBUG=1) */
+    debug: (msg: string) => void;
+    /** Log an info message (always shown) */
+    info: (msg: string) => void;
+    /** Log an error message (always shown, to stderr) */
+    error: (msg: string) => void;
+}
+/**
+ * Create a logger with a specific prefix
+ *
+ * @param prefix - Prefix to add to all messages (e.g., '[MCP]', '[ws]')
+ * @param useStderr - If true, use stderr for all output (default: false)
+ * @returns Logger object with debug, info, and error methods
+ */
+export declare function createLogger(prefix: string, useStderr?: boolean): Logger;
+/**
+ * Pre-configured logger for MCP permission server
+ * Uses stderr (required for MCP stdio communication)
+ */
+export declare const mcpLogger: Logger;
+/**
+ * Pre-configured logger for WebSocket client
+ * Uses stdout with indentation for visual hierarchy
+ */
+export declare const wsLogger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,42 @@
+/**
+ * Simple debug logging utility
+ *
+ * Provides consistent logging across the codebase with:
+ * - Configurable prefix for different components
+ * - DEBUG environment variable check
+ * - stdout vs stderr routing option
+ */
+/**
+ * Create a logger with a specific prefix
+ *
+ * @param prefix - Prefix to add to all messages (e.g., '[MCP]', '[ws]')
+ * @param useStderr - If true, use stderr for all output (default: false)
+ * @returns Logger object with debug, info, and error methods
+ */
+export function createLogger(prefix, useStderr = false) {
+    const isDebug = () => process.env.DEBUG === '1';
+    const log = useStderr ? console.error : console.log;
+    return {
+        debug: (msg) => {
+            if (isDebug()) {
+                log(`${prefix} ${msg}`);
+            }
+        },
+        info: (msg) => {
+            log(`${prefix} ${msg}`);
+        },
+        error: (msg) => {
+            console.error(`${prefix} ${msg}`);
+        },
+    };
+}
+/**
+ * Pre-configured logger for MCP permission server
+ * Uses stderr (required for MCP stdio communication)
+ */
+export const mcpLogger = createLogger('[MCP]', true);
+/**
+ * Pre-configured logger for WebSocket client
+ * Uses stdout with indentation for visual hierarchy
+ */
+export const wsLogger = createLogger('  [ws]', false);

package/dist/utils/logger.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/logger.test.js

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createLogger, mcpLogger, wsLogger } from './logger.js';
+describe('createLogger', () => {
+    let consoleLogSpy;
+    let consoleErrorSpy;
+    const originalEnv = process.env.DEBUG;
+    beforeEach(() => {
+        consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+        delete process.env.DEBUG;
+    });
+    afterEach(() => {
+        consoleLogSpy.mockRestore();
+        consoleErrorSpy.mockRestore();
+        if (originalEnv !== undefined) {
+            process.env.DEBUG = originalEnv;
+        }
+        else {
+            delete process.env.DEBUG;
+        }
+    });
+    describe('debug', () => {
+        it('does not log when DEBUG is not set', () => {
+            const logger = createLogger('[test]');
+            logger.debug('test message');
+            expect(consoleLogSpy).not.toHaveBeenCalled();
+            expect(consoleErrorSpy).not.toHaveBeenCalled();
+        });
+        it('logs to stdout when DEBUG=1 and useStderr=false', () => {
+            process.env.DEBUG = '1';
+            const logger = createLogger('[test]');
+            logger.debug('test message');
+            expect(consoleLogSpy).toHaveBeenCalledWith('[test] test message');
+            expect(consoleErrorSpy).not.toHaveBeenCalled();
+        });
+        it('logs to stderr when DEBUG=1 and useStderr=true', () => {
+            process.env.DEBUG = '1';
+            const logger = createLogger('[test]', true);
+            logger.debug('test message');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[test] test message');
+            expect(consoleLogSpy).not.toHaveBeenCalled();
+        });
+        it('does not log when DEBUG is set to something other than 1', () => {
+            process.env.DEBUG = 'true';
+            const logger = createLogger('[test]');
+            logger.debug('test message');
+            expect(consoleLogSpy).not.toHaveBeenCalled();
+        });
+    });
+    describe('info', () => {
+        it('always logs to stdout when useStderr=false', () => {
+            const logger = createLogger('[test]');
+            logger.info('info message');
+            expect(consoleLogSpy).toHaveBeenCalledWith('[test] info message');
+        });
+        it('logs to stderr when useStderr=true', () => {
+            const logger = createLogger('[test]', true);
+            logger.info('info message');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[test] info message');
+        });
+        it('logs even when DEBUG is not set', () => {
+            const logger = createLogger('[test]');
+            logger.info('info message');
+            expect(consoleLogSpy).toHaveBeenCalled();
+        });
+    });
+    describe('error', () => {
+        it('always logs to stderr', () => {
+            const logger = createLogger('[test]');
+            logger.error('error message');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[test] error message');
+        });
+        it('logs to stderr even when useStderr=false', () => {
+            const logger = createLogger('[test]', false);
+            logger.error('error message');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[test] error message');
+        });
+        it('logs even when DEBUG is not set', () => {
+            const logger = createLogger('[test]');
+            logger.error('error message');
+            expect(consoleErrorSpy).toHaveBeenCalled();
+        });
+    });
+    describe('prefix formatting', () => {
+        it('includes prefix in debug messages', () => {
+            process.env.DEBUG = '1';
+            const logger = createLogger('[MyPrefix]');
+            logger.debug('my message');
+            expect(consoleLogSpy).toHaveBeenCalledWith('[MyPrefix] my message');
+        });
+        it('includes prefix in info messages', () => {
+            const logger = createLogger('[MyPrefix]');
+            logger.info('my message');
+            expect(consoleLogSpy).toHaveBeenCalledWith('[MyPrefix] my message');
+        });
+        it('includes prefix in error messages', () => {
+            const logger = createLogger('[MyPrefix]');
+            logger.error('my message');
+            expect(consoleErrorSpy).toHaveBeenCalledWith('[MyPrefix] my message');
+        });
+    });
+});
+describe('pre-configured loggers', () => {
+    // Note: mcpLogger and wsLogger are module-level singletons created at import time.
+    // Since they capture console.log/error at creation, we test their behavior by
+    // verifying they have the expected interface and configuration.
+    describe('mcpLogger', () => {
+        it('has debug, info, and error methods', () => {
+            expect(typeof mcpLogger.debug).toBe('function');
+            expect(typeof mcpLogger.info).toBe('function');
+            expect(typeof mcpLogger.error).toBe('function');
+        });
+    });
+    describe('wsLogger', () => {
+        it('has debug, info, and error methods', () => {
+            expect(typeof wsLogger.debug).toBe('function');
+            expect(typeof wsLogger.info).toBe('function');
+            expect(typeof wsLogger.error).toBe('function');
+        });
+    });
+});

package/dist/utils/tool-formatter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Tool formatting utilities for displaying Claude tool calls in Mattermost
+ *
+ * This module provides shared formatting logic used by both:
+ * - src/claude/session.ts (main bot)
+ * - src/mcp/permission-server.ts (MCP permission handler)
+ */
+export interface ToolInput {
+    [key: string]: unknown;
+}
+export interface FormatOptions {
+    /** Include detailed previews (diffs, file content). Default: false */
+    detailed?: boolean;
+    /** Max command length for Bash. Default: 50 */
+    maxCommandLength?: number;
+    /** Max path display length. Default: 60 */
+    maxPathLength?: number;
+    /** Max lines to show in previews. Default: 20 for diff, 6 for content */
+    maxPreviewLines?: number;
+}
+/**
+ * Shorten a file path for display by replacing home directory with ~
+ */
+export declare function shortenPath(path: string, homeDir?: string): string;
+/**
+ * Check if a tool name is an MCP tool and extract server/tool parts
+ */
+export declare function parseMcpToolName(toolName: string): {
+    server: string;
+    tool: string;
+} | null;
+/**
+ * Format a tool use for display in Mattermost
+ *
+ * @param toolName - The name of the tool being called
+ * @param input - The tool input parameters
+ * @param options - Formatting options
+ * @returns Formatted string or null if the tool should not be displayed
+ */
+export declare function formatToolUse(toolName: string, input: ToolInput, options?: FormatOptions): string | null;
+/**
+ * Format tool info for permission prompts (simpler format)
+ *
+ * @param toolName - The name of the tool
+ * @param input - The tool input parameters
+ * @returns Formatted string for permission prompts
+ */
+export declare function formatToolForPermission(toolName: string, input: ToolInput): string;
+/**
+ * Format Claude in Chrome tool calls
+ *
+ * @param tool - The Chrome tool name (after mcp__claude-in-chrome__)
+ * @param input - The tool input parameters
+ * @returns Formatted string for display
+ */
+export declare function formatChromeToolUse(tool: string, input: ToolInput): string;