claude-threads 0.12.1 → 0.14.0

package/dist/onboarding.js

@@ -1,116 +1,318 @@
 import prompts from 'prompts';
-import { writeFileSync, mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { resolve } from 'path';
+import { existsSync } from 'fs';
+import { CONFIG_PATH, saveConfig, } from './config/migration.js';
+import YAML from 'yaml';
+import { readFileSync } from 'fs';
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const green = (s) => `\x1b[32m${s}\x1b[0m`;
-export async function runOnboarding() {
+const onCancel = () => {
     console.log('');
-    console.log(bold('  Welcome to claude-threads!'));
+    console.log(dim('  Setup cancelled.'));
+    process.exit(0);
+};
+export async function runOnboarding(reconfigure = false) {
+    console.log('');
+    console.log(bold('  claude-threads setup'));
     console.log(dim('  ─────────────────────────────────'));
     console.log('');
-    console.log('  No configuration found. Let\'s set things up.');
+    // Load existing config if reconfiguring
+    let existingConfig = null;
+    if (reconfigure && existsSync(CONFIG_PATH)) {
+        try {
+            const content = readFileSync(CONFIG_PATH, 'utf-8');
+            existingConfig = YAML.parse(content);
+            console.log(dim('  Reconfiguring existing setup.'));
+        }
+        catch {
+            console.log(dim('  Could not load existing config, starting fresh.'));
+        }
+    }
+    else {
+        console.log('  Welcome! Let\'s configure claude-threads.');
+    }
+    console.log('');
+    // Step 1: Global settings
+    const globalSettings = await prompts([
+        {
+            type: 'text',
+            name: 'workingDir',
+            message: 'Default working directory',
+            initial: existingConfig?.workingDir || process.cwd(),
+            hint: 'Where Claude Code runs by default',
+        },
+        {
+            type: 'confirm',
+            name: 'chrome',
+            message: 'Enable Chrome integration?',
+            initial: existingConfig?.chrome || false,
+            hint: 'Requires Claude in Chrome extension',
+        },
+        {
+            type: 'select',
+            name: 'worktreeMode',
+            message: 'Git worktree mode',
+            choices: [
+                { title: 'Prompt', value: 'prompt', description: 'Ask when starting sessions' },
+                { title: 'Off', value: 'off', description: 'Never use worktrees' },
+                { title: 'Require', value: 'require', description: 'Always require branch name' },
+            ],
+            initial: existingConfig?.worktreeMode === 'off' ? 1 :
+                existingConfig?.worktreeMode === 'require' ? 2 : 0,
+        },
+    ], { onCancel });
+    const config = {
+        version: 2,
+        ...globalSettings,
+        platforms: [],
+    };
+    // Step 2: Add platforms (loop)
     console.log('');
-    console.log(dim('  You\'ll need:'));
-    console.log(dim('  • A Mattermost bot account with a token'));
-    console.log(dim('  • A channel ID where the bot will listen'));
+    console.log(dim('  Now let\'s add your platform connections.'));
     console.log('');
-    // Handle Ctrl+C gracefully
-    prompts.override({});
-    const onCancel = () => {
+    let platformNumber = 1;
+    let addMore = true;
+    while (addMore) {
+        const isFirst = platformNumber === 1;
+        const existingPlatform = existingConfig?.platforms[platformNumber - 1];
+        // Ask what platform type
+        const { platformType } = await prompts({
+            type: 'select',
+            name: 'platformType',
+            message: isFirst ? 'First platform' : `Platform #${platformNumber}`,
+            choices: [
+                { title: 'Mattermost', value: 'mattermost' },
+                { title: 'Slack', value: 'slack' },
+                ...(isFirst ? [] : [{ title: '(Done - finish setup)', value: 'done' }]),
+            ],
+            initial: existingPlatform?.type === 'slack' ? 1 : 0,
+        }, { onCancel });
+        if (platformType === 'done') {
+            addMore = false;
+            break;
+        }
+        // Get platform ID and name
+        const { platformId, displayName } = await prompts([
+            {
+                type: 'text',
+                name: 'platformId',
+                message: 'Platform ID',
+                initial: existingPlatform?.id ||
+                    (config.platforms.length === 0 ? 'default' : `${platformType}-${platformNumber}`),
+                hint: 'Unique identifier (e.g., mattermost-main, slack-eng)',
+                validate: (v) => {
+                    if (!v.match(/^[a-z0-9-]+$/))
+                        return 'Use lowercase letters, numbers, hyphens only';
+                    if (config.platforms.some(p => p.id === v))
+                        return 'ID already in use';
+                    return true;
+                },
+            },
+            {
+                type: 'text',
+                name: 'displayName',
+                message: 'Display name',
+                initial: existingPlatform?.displayName ||
+                    (platformType === 'mattermost' ? 'Mattermost' : 'Slack'),
+                hint: 'Human-readable name (e.g., "Internal Team", "Engineering")',
+            },
+        ], { onCancel });
+        // Configure the platform
+        if (platformType === 'mattermost') {
+            const platform = await setupMattermostPlatform(platformId, displayName, existingPlatform);
+            config.platforms.push(platform);
+        }
+        else {
+            const platform = await setupSlackPlatform(platformId, displayName, existingPlatform);
+            config.platforms.push(platform);
+        }
+        console.log(green(`  ✓ Added ${displayName}`));
         console.log('');
-        console.log(dim('  Setup cancelled.'));
-        process.exit(0);
-    };
+        // Ask to add more (after first one)
+        if (platformNumber === 1) {
+            const { addAnother } = await prompts({
+                type: 'confirm',
+                name: 'addAnother',
+                message: 'Add another platform?',
+                initial: (existingConfig?.platforms.length || 0) > 1,
+            }, { onCancel });
+            addMore = addAnother;
+        }
+        platformNumber++;
+    }
+    // Validate at least one platform
+    if (config.platforms.length === 0) {
+        console.log('');
+        console.log(dim('  ⚠️  No platforms configured. Setup cancelled.'));
+        process.exit(1);
+    }
+    // Save config
+    saveConfig(config);
+    console.log('');
+    console.log(green('  ✓ Configuration saved!'));
+    console.log(dim(`    ${CONFIG_PATH}`));
+    console.log('');
+    console.log(dim(`  Configured ${config.platforms.length} platform(s):`));
+    for (const platform of config.platforms) {
+        console.log(dim(`    • ${platform.displayName} (${platform.type})`));
+    }
+    console.log('');
+    console.log(dim('  Starting claude-threads...'));
+    console.log('');
+}
+async function setupMattermostPlatform(id, displayName, existing) {
+    console.log('');
+    console.log(dim('  Mattermost setup:'));
+    console.log('');
+    const existingMattermost = existing?.type === 'mattermost' ? existing : undefined;
     const response = await prompts([
         {
             type: 'text',
             name: 'url',
-            message: 'Mattermost URL',
-            initial: 'https://your-mattermost-server.com',
-            validate: (v) => v.startsWith('http') ? true : 'URL must start with http:// or https://',
+            message: 'Server URL',
+            initial: existingMattermost?.url || 'https://chat.example.com',
+            validate: (v) => v.startsWith('http') ? true : 'Must start with http(s)://',
         },
         {
             type: 'password',
             name: 'token',
             message: 'Bot token',
-            hint: 'Create at: Integrations > Bot Accounts > Add Bot Account',
-            validate: (v) => v.length > 0 ? true : 'Token is required',
+            initial: existingMattermost?.token,
+            hint: existingMattermost?.token ? 'Enter to keep existing, or type new token' : 'Create at: Integrations > Bot Accounts',
+            validate: (v) => {
+                // Allow empty if we have existing token
+                if (!v && existingMattermost?.token)
+                    return true;
+                return v.length > 0 ? true : 'Token is required';
+            },
         },
         {
             type: 'text',
             name: 'channelId',
             message: 'Channel ID',
-            hint: 'Click channel name > View Info > copy ID from URL',
+            initial: existingMattermost?.channelId || '',
+            hint: 'Click channel > View Info > copy ID from URL',
             validate: (v) => v.length > 0 ? true : 'Channel ID is required',
         },
         {
             type: 'text',
             name: 'botName',
             message: 'Bot mention name',
-            initial: 'claude-code',
+            initial: existingMattermost?.botName || 'claude-code',
             hint: 'Users will @mention this name',
         },
         {
             type: 'text',
             name: 'allowedUsers',
-            message: 'Allowed usernames',
-            initial: '',
-            hint: 'Comma-separated, or empty for all users',
+            message: 'Allowed usernames (optional)',
+            initial: existingMattermost?.allowedUsers?.join(',') || '',
+            hint: 'Comma-separated, or empty to allow everyone',
         },
         {
             type: 'confirm',
             name: 'skipPermissions',
-            message: 'Skip permission prompts?',
-            initial: true,
-            hint: 'If no, you\'ll approve each action via emoji reactions',
+            message: 'Auto-approve all actions?',
+            initial: existingMattermost?.skipPermissions || false,
+            hint: 'If no, you\'ll approve via emoji reactions',
         },
     ], { onCancel });
-    // Check if user cancelled
-    if (!response.url || !response.token || !response.channelId) {
+    // Use existing token if user left it empty
+    const finalToken = response.token || existingMattermost?.token;
+    if (!finalToken) {
         console.log('');
-        console.log(dim('  Setup incomplete. Run claude-threads again to retry.'));
-        process.exit(1);
-    }
-    // Build .env content
-    const envContent = `# claude-threads configuration
-# Generated by claude-threads onboarding
-
-# Mattermost server URL
-MATTERMOST_URL=${response.url}
-
-# Bot token (from Integrations > Bot Accounts)
-MATTERMOST_TOKEN=${response.token}
-
-# Channel ID where the bot listens
-MATTERMOST_CHANNEL_ID=${response.channelId}
-
-# Bot mention name (users @mention this)
-MATTERMOST_BOT_NAME=${response.botName || 'claude-code'}
-
-# Allowed usernames (comma-separated, empty = all users)
-ALLOWED_USERS=${response.allowedUsers || ''}
-
-# Skip permission prompts (true = auto-approve, false = require emoji approval)
-SKIP_PERMISSIONS=${response.skipPermissions ? 'true' : 'false'}
-`;
-    // Save to ~/.config/claude-threads/.env
-    const configDir = resolve(homedir(), '.config', 'claude-threads');
-    const envPath = resolve(configDir, '.env');
-    try {
-        mkdirSync(configDir, { recursive: true });
-        writeFileSync(envPath, envContent, { mode: 0o600 }); // Secure permissions
-    }
-    catch (err) {
-        console.error('');
-        console.error(`  Failed to save config: ${err}`);
+        console.log(dim('  ⚠️  Token is required. Setup cancelled.'));
         process.exit(1);
     }
+    return {
+        id,
+        type: 'mattermost',
+        displayName,
+        url: response.url,
+        token: finalToken,
+        channelId: response.channelId,
+        botName: response.botName,
+        allowedUsers: response.allowedUsers?.split(',').map((u) => u.trim()).filter((u) => u) || [],
+        skipPermissions: response.skipPermissions,
+    };
+}
+async function setupSlackPlatform(id, displayName, existing) {
     console.log('');
-    console.log(green('  ✓ Configuration saved!'));
-    console.log(dim(`    ${envPath}`));
-    console.log('');
-    console.log(dim('  Starting claude-threads...'));
+    console.log(dim('  Slack setup (requires Socket Mode):'));
+    console.log(dim('  Create app at: api.slack.com/apps'));
     console.log('');
+    const existingSlack = existing?.type === 'slack' ? existing : undefined;
+    const response = await prompts([
+        {
+            type: 'password',
+            name: 'botToken',
+            message: 'Bot User OAuth Token',
+            initial: existingSlack?.botToken,
+            hint: existingSlack?.botToken ? 'Enter to keep existing' : 'Starts with xoxb-',
+            validate: (v) => {
+                if (!v && existingSlack?.botToken)
+                    return true;
+                return v.startsWith('xoxb-') ? true : 'Must start with xoxb-';
+            },
+        },
+        {
+            type: 'password',
+            name: 'appToken',
+            message: 'App-Level Token',
+            initial: existingSlack?.appToken,
+            hint: existingSlack?.appToken ? 'Enter to keep existing' : 'Starts with xapp- (enable Socket Mode first)',
+            validate: (v) => {
+                if (!v && existingSlack?.appToken)
+                    return true;
+                return v.startsWith('xapp-') ? true : 'Must start with xapp-';
+            },
+        },
+        {
+            type: 'text',
+            name: 'channelId',
+            message: 'Channel ID',
+            initial: existingSlack?.channelId || '',
+            hint: 'Right-click channel > View details > copy ID',
+            validate: (v) => v.length > 0 ? true : 'Channel ID is required',
+        },
+        {
+            type: 'text',
+            name: 'botName',
+            message: 'Bot mention name',
+            initial: existingSlack?.botName || 'claude',
+            hint: 'Users will @mention this name',
+        },
+        {
+            type: 'text',
+            name: 'allowedUsers',
+            message: 'Allowed usernames (optional)',
+            initial: existingSlack?.allowedUsers?.join(',') || '',
+            hint: 'Comma-separated, or empty for everyone',
+        },
+        {
+            type: 'confirm',
+            name: 'skipPermissions',
+            message: 'Auto-approve all actions?',
+            initial: existingSlack?.skipPermissions || false,
+            hint: 'If no, you\'ll approve via emoji reactions',
+        },
+    ], { onCancel });
+    // Use existing tokens if user left them empty
+    const finalBotToken = response.botToken || existingSlack?.botToken;
+    const finalAppToken = response.appToken || existingSlack?.appToken;
+    if (!finalBotToken || !finalAppToken) {
+        console.log('');
+        console.log(dim('  ⚠️  Both tokens are required. Setup cancelled.'));
+        process.exit(1);
+    }
+    return {
+        id,
+        type: 'slack',
+        displayName,
+        botToken: finalBotToken,
+        appToken: finalAppToken,
+        channelId: response.channelId,
+        botName: response.botName,
+        allowedUsers: response.allowedUsers?.split(',').map((u) => u.trim()).filter((u) => u) || [],
+        skipPermissions: response.skipPermissions,
+    };
 }

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

@@ -10,6 +10,7 @@ export interface WorktreeInfo {
  * Persisted session state for resuming after bot restart
  */
 export interface PersistedSession {
+    platformId: string;
     threadId: string;
     claudeSessionId: string;
     startedBy: string;
@@ -36,18 +37,23 @@ export declare class SessionStore {
     constructor();
     /**
      * Load all persisted sessions
+     * Returns Map with composite sessionId ("platformId:threadId") as key
      */
     load(): Map<string, PersistedSession>;
     /**
      * Save a session (creates or updates)
+     * @param sessionId - Composite key "platformId:threadId"
+     * @param session - Session data to persist
      */
-    save(threadId: string, session: PersistedSession): void;
+    save(sessionId: string, session: PersistedSession): void;
     /**
      * Remove a session
+     * @param sessionId - Composite key "platformId:threadId"
      */
-    remove(threadId: string): void;
+    remove(sessionId: string): void;
     /**
      * Remove sessions older than maxAgeMs
+     * @returns Array of sessionIds that were removed
      */
     cleanStale(maxAgeMs: number): string[];
     /**

package/dist/persistence/session-store.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
-const STORE_VERSION = 1;
+const STORE_VERSION = 2; // v2: Added platformId for multi-platform support
 const CONFIG_DIR = join(homedir(), '.config', 'claude-threads');
 const SESSIONS_FILE = join(CONFIG_DIR, 'sessions.json');
 /**
@@ -18,6 +18,7 @@ export class SessionStore {
     }
     /**
      * Load all persisted sessions
+     * Returns Map with composite sessionId ("platformId:threadId") as key
      */
     load() {
         const sessions = new Map();
@@ -28,13 +29,32 @@ export class SessionStore {
         }
         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`);
+            // Migration: v1 → v2 (add platformId and convert keys to composite format)
+            if (data.version === 1) {
+                console.log('  [persist] Migrating sessions from v1 to v2 (adding platformId)');
+                const newSessions = {};
+                for (const [_oldKey, session] of Object.entries(data.sessions)) {
+                    const v1Session = session;
+                    if (!v1Session.platformId) {
+                        v1Session.platformId = 'default';
+                    }
+                    // Convert key from threadId to platformId:threadId
+                    const newKey = `${v1Session.platformId}:${v1Session.threadId}`;
+                    newSessions[newKey] = v1Session;
+                }
+                data.sessions = newSessions;
+                data.version = 2;
+                // Save migrated data
+                this.writeAtomic(data);
+            }
+            else if (data.version !== STORE_VERSION) {
+                console.warn(`  [persist] Sessions file version ${data.version} not supported, starting fresh`);
                 return sessions;
             }
-            for (const [threadId, session] of Object.entries(data.sessions)) {
-                sessions.set(threadId, session);
+            // Load sessions with composite sessionId as key
+            for (const session of Object.values(data.sessions)) {
+                const sessionId = `${session.platformId}:${session.threadId}`;
+                sessions.set(sessionId, session);
             }
             if (this.debug) {
                 console.log(`  [persist] Loaded ${sessions.size} session(s)`);
@@ -47,42 +67,47 @@ export class SessionStore {
     }
     /**
      * Save a session (creates or updates)
+     * @param sessionId - Composite key "platformId:threadId"
+     * @param session - Session data to persist
      */
-    save(threadId, session) {
+    save(sessionId, session) {
         const data = this.loadRaw();
-        data.sessions[threadId] = session;
+        // Use sessionId as key (already composite)
+        data.sessions[sessionId] = session;
         this.writeAtomic(data);
         if (this.debug) {
-            const shortId = threadId.substring(0, 8);
+            const shortId = sessionId.substring(0, 20);
             console.log(`  [persist] Saved session ${shortId}...`);
         }
     }
     /**
      * Remove a session
+     * @param sessionId - Composite key "platformId:threadId"
      */
-    remove(threadId) {
+    remove(sessionId) {
         const data = this.loadRaw();
-        if (data.sessions[threadId]) {
-            delete data.sessions[threadId];
+        if (data.sessions[sessionId]) {
+            delete data.sessions[sessionId];
             this.writeAtomic(data);
             if (this.debug) {
-                const shortId = threadId.substring(0, 8);
+                const shortId = sessionId.substring(0, 20);
                 console.log(`  [persist] Removed session ${shortId}...`);
             }
         }
     }
     /**
      * Remove sessions older than maxAgeMs
+     * @returns Array of sessionIds that were removed
      */
     cleanStale(maxAgeMs) {
         const data = this.loadRaw();
         const now = Date.now();
         const staleIds = [];
-        for (const [threadId, session] of Object.entries(data.sessions)) {
+        for (const [sessionId, session] of Object.entries(data.sessions)) {
             const lastActivity = new Date(session.lastActivityAt).getTime();
             if (now - lastActivity > maxAgeMs) {
-                staleIds.push(threadId);
-                delete data.sessions[threadId];
+                staleIds.push(sessionId);
+                delete data.sessions[sessionId];
             }
         }
         if (staleIds.length > 0) {

package/dist/platform/client.d.ts

@@ -0,0 +1,140 @@
+import { EventEmitter } from 'events';
+import type { PlatformUser, PlatformPost, PlatformReaction, PlatformFile } from './types.js';
+import type { PlatformFormatter } from './formatter.js';
+/**
+ * Events emitted by PlatformClient
+ */
+export interface PlatformClientEvents {
+    connected: () => void;
+    disconnected: () => void;
+    error: (error: Error) => void;
+    message: (post: PlatformPost, user: PlatformUser | null) => void;
+    reaction: (reaction: PlatformReaction, user: PlatformUser | null) => void;
+}
+/**
+ * Platform-agnostic client interface
+ *
+ * All platform implementations (Mattermost, Slack) must implement this interface.
+ * This allows SessionManager and other code to work with any platform without
+ * knowing the specific implementation details.
+ */
+export interface PlatformClient extends EventEmitter {
+    /**
+     * Unique identifier for this platform instance
+     * e.g., 'mattermost-internal', 'slack-eng'
+     */
+    readonly platformId: string;
+    /**
+     * Platform type
+     * e.g., 'mattermost', 'slack'
+     */
+    readonly platformType: string;
+    /**
+     * Human-readable display name
+     * e.g., 'Internal Team', 'Engineering Slack'
+     */
+    readonly displayName: string;
+    /**
+     * Connect to the platform (WebSocket, Socket Mode, etc.)
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the platform
+     */
+    disconnect(): void;
+    /**
+     * Get the bot's own user info
+     */
+    getBotUser(): Promise<PlatformUser>;
+    /**
+     * Get a user by their ID
+     */
+    getUser(userId: string): Promise<PlatformUser | null>;
+    /**
+     * Check if a username is in the allowed users list
+     */
+    isUserAllowed(username: string): boolean;
+    /**
+     * Get the bot's mention name (e.g., 'claude-code')
+     */
+    getBotName(): string;
+    /**
+     * Get platform config for MCP permission server
+     */
+    getMcpConfig(): {
+        type: string;
+        url: string;
+        token: string;
+        channelId: string;
+        allowedUsers: string[];
+    };
+    /**
+     * Get the platform-specific markdown formatter
+     * Use this to format bold, code, etc. in a platform-appropriate way.
+     */
+    getFormatter(): PlatformFormatter;
+    /**
+     * Create a new post/message
+     * @param message - Message text
+     * @param threadId - Optional thread parent ID
+     * @returns The created post
+     */
+    createPost(message: string, threadId?: string): Promise<PlatformPost>;
+    /**
+     * Update an existing post/message
+     * @param postId - Post ID to update
+     * @param message - New message text
+     * @returns The updated post
+     */
+    updatePost(postId: string, message: string): Promise<PlatformPost>;
+    /**
+     * Create a post with reaction options (for interactive prompts)
+     * @param message - Message text
+     * @param reactions - Array of emoji names to add as options
+     * @param threadId - Optional thread parent ID
+     * @returns The created post
+     */
+    createInteractivePost(message: string, reactions: string[], threadId?: string): Promise<PlatformPost>;
+    /**
+     * Get a post by ID
+     * @param postId - Post ID
+     * @returns The post, or null if not found/deleted
+     */
+    getPost(postId: string): Promise<PlatformPost | null>;
+    /**
+     * Add a reaction to a post
+     * @param postId - Post ID
+     * @param emojiName - Emoji name (e.g., '+1', 'white_check_mark')
+     */
+    addReaction(postId: string, emojiName: string): Promise<void>;
+    /**
+     * Check if a message mentions the bot
+     * @param message - Message text
+     */
+    isBotMentioned(message: string): boolean;
+    /**
+     * Extract the prompt from a message (remove bot mention)
+     * @param message - Message text
+     * @returns The message with bot mention removed
+     */
+    extractPrompt(message: string): string;
+    /**
+     * Send typing indicator to show bot is "thinking"
+     * @param threadId - Optional thread ID
+     */
+    sendTyping(threadId?: string): void;
+    /**
+     * Download a file attachment
+     * @param fileId - File ID
+     * @returns File contents as Buffer
+     */
+    downloadFile?(fileId: string): Promise<Buffer>;
+    /**
+     * Get file metadata
+     * @param fileId - File ID
+     * @returns File metadata
+     */
+    getFileInfo?(fileId: string): Promise<PlatformFile>;
+    on<K extends keyof PlatformClientEvents>(event: K, listener: PlatformClientEvents[K]): this;
+    emit<K extends keyof PlatformClientEvents>(event: K, ...args: Parameters<PlatformClientEvents[K]>): boolean;
+}