claude-threads 0.13.0 → 0.14.1

package/dist/onboarding.js

@@ -1,85 +1,187 @@
 import prompts from 'prompts';
-import { writeFileSync, mkdirSync, readFileSync, existsSync } from 'fs';
-import { homedir } from 'os';
-import { resolve, dirname } from 'path';
-import { parse } from 'dotenv';
+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`;
-// Paths to search for .env files (in order of priority)
-const ENV_PATHS = [
-    resolve(process.cwd(), '.env'),
-    resolve(homedir(), '.config', 'claude-threads', '.env'),
-    resolve(homedir(), '.claude-threads.env'),
-];
-function loadExistingConfig() {
-    for (const envPath of ENV_PATHS) {
-        if (existsSync(envPath)) {
-            try {
-                const content = readFileSync(envPath, 'utf-8');
-                return { path: envPath, values: parse(content) };
-            }
-            catch {
-                return { path: null, values: {} };
-            }
+const onCancel = () => {
+    console.log('');
+    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('');
+    // 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.'));
         }
     }
-    return { path: null, values: {} };
-}
-export async function runOnboarding(reconfigure = false) {
-    const { path: existingPath, values: existing } = reconfigure ? loadExistingConfig() : { path: null, values: {} };
-    const hasExisting = Object.keys(existing).length > 0;
+    else {
+        console.log('  Welcome! Let\'s configure claude-threads.');
+    }
     console.log('');
-    if (reconfigure && hasExisting) {
-        console.log(bold('  Reconfiguring claude-threads'));
-        console.log(dim('  ─────────────────────────────────'));
+    // 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('  Now let\'s add your platform connections.'));
+    console.log('');
+    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('  Press Enter to keep existing values.'));
+        // 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++;
     }
-    else {
-        console.log(bold('  Welcome to claude-threads!'));
-        console.log(dim('  ─────────────────────────────────'));
+    // Validate at least one platform
+    if (config.platforms.length === 0) {
         console.log('');
-        console.log('  No configuration found. Let\'s set things up.');
+        console.log(dim('  ⚠️  No platforms configured. Setup cancelled.'));
+        process.exit(1);
     }
+    // Save config
+    saveConfig(config);
     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(green('  ✓ Configuration saved!'));
+    console.log(dim(`    ${CONFIG_PATH}`));
     console.log('');
-    // Handle Ctrl+C gracefully
-    prompts.override({});
-    const onCancel = () => {
-        console.log('');
-        console.log(dim('  Setup cancelled.'));
-        process.exit(0);
-    };
-    // Helper to get worktree mode index
-    const worktreeModeIndex = (mode) => {
-        if (mode === 'off')
-            return 1;
-        if (mode === 'require')
-            return 2;
-        return 0; // default to 'prompt'
-    };
+    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: existing.MATTERMOST_URL || '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: existing.MATTERMOST_TOKEN
-                ? 'Enter to keep existing, or type new token'
-                : 'Create at: Integrations > Bot Accounts > Add Bot Account',
+            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 an existing token (user wants to keep it)
-                if (!v && existing.MATTERMOST_TOKEN)
+                // Allow empty if we have existing token
+                if (!v && existingMattermost?.token)
                     return true;
                 return v.length > 0 ? true : 'Token is required';
             },
@@ -88,106 +190,129 @@ export async function runOnboarding(reconfigure = false) {
             type: 'text',
             name: 'channelId',
             message: 'Channel ID',
-            initial: existing.MATTERMOST_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: existing.MATTERMOST_BOT_NAME || 'claude-code',
+            initial: existingMattermost?.botName || 'claude-code',
             hint: 'Users will @mention this name',
         },
         {
             type: 'text',
             name: 'allowedUsers',
-            message: 'Allowed usernames',
-            initial: existing.ALLOWED_USERS || '',
-            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: existing.SKIP_PERMISSIONS !== undefined
-                ? existing.SKIP_PERMISSIONS === 'true'
-                : 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 });
+    // Use existing token if user left it empty
+    const finalToken = response.token || existingMattermost?.token;
+    if (!finalToken) {
+        console.log('');
+        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(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: 'confirm',
-            name: 'chrome',
-            message: 'Enable Chrome integration?',
-            initial: existing.CLAUDE_CHROME === 'true',
-            hint: 'Requires Claude in Chrome extension',
+            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: 'select',
-            name: 'worktreeMode',
-            message: 'Git worktree mode',
-            hint: 'Isolate changes in separate worktrees',
-            choices: [
-                { title: 'Prompt', value: 'prompt', description: 'Ask when starting new sessions' },
-                { title: 'Off', value: 'off', description: 'Never use worktrees' },
-                { title: 'Require', value: 'require', description: 'Always require a branch name' },
-            ],
-            initial: worktreeModeIndex(existing.WORKTREE_MODE),
+            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 });
-    // Check if user cancelled - token can be empty if keeping existing
-    const finalToken = response.token || existing.MATTERMOST_TOKEN;
-    if (!response.url || !finalToken || !response.channelId) {
+    // 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('  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=${finalToken}
-
-# 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'}
-
-# Chrome integration (requires Claude in Chrome extension)
-CLAUDE_CHROME=${response.chrome ? 'true' : 'false'}
-
-# Git worktree mode (off, prompt, require)
-WORKTREE_MODE=${response.worktreeMode || 'prompt'}
-`;
-    // Save to same location if reconfiguring, otherwise default location
-    const defaultConfigDir = resolve(homedir(), '.config', 'claude-threads');
-    const defaultEnvPath = resolve(defaultConfigDir, '.env');
-    const envPath = existingPath || defaultEnvPath;
-    const configDir = dirname(envPath);
-    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('  ⚠️  Both tokens are required. Setup cancelled.'));
         process.exit(1);
     }
-    console.log('');
-    console.log(green('  ✓ Configuration saved!'));
-    console.log(dim(`    ${envPath}`));
-    console.log('');
-    console.log(dim('  Starting claude-threads...'));
-    console.log('');
+    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) {