claude-threads 0.15.0 → 0.16.3

package/dist/mattermost/api.test.js

@@ -1,319 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { mattermostApi, getMe, getUser, createPost, updatePost, addReaction, isUserAllowed, createInteractivePost, } from './api.js';
-const mockConfig = {
-    url: 'https://mattermost.example.com',
-    token: 'test-token',
-};
-describe('mattermostApi', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('adds authorization header', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ id: '123' }),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await mattermostApi(mockConfig, 'GET', '/users/me');
-        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/users/me', expect.objectContaining({
-            headers: expect.objectContaining({
-                Authorization: 'Bearer test-token',
-            }),
-        }));
-    });
-    it('includes Content-Type header', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({}),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await mattermostApi(mockConfig, 'POST', '/posts', { message: 'test' });
-        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            headers: expect.objectContaining({
-                'Content-Type': 'application/json',
-            }),
-        }));
-    });
-    it('stringifies body for POST requests', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({}),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await mattermostApi(mockConfig, 'POST', '/posts', { message: 'hello' });
-        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            body: JSON.stringify({ message: 'hello' }),
-        }));
-    });
-    it('throws on non-ok response', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 401,
-            text: () => Promise.resolve('Unauthorized'),
-        }));
-        await expect(mattermostApi(mockConfig, 'GET', '/users/me')).rejects.toThrow('Mattermost API error 401');
-    });
-    it('includes error details in thrown error', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 403,
-            text: () => Promise.resolve('Access denied'),
-        }));
-        await expect(mattermostApi(mockConfig, 'GET', '/users/me')).rejects.toThrow('Access denied');
-    });
-});
-describe('getMe', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('returns the current user', async () => {
-        const mockUser = { id: 'bot123', username: 'bot' };
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockUser),
-        }));
-        const result = await getMe(mockConfig);
-        expect(result).toEqual(mockUser);
-    });
-});
-describe('getUser', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('returns user when found', async () => {
-        const mockUser = { id: 'user123', username: 'testuser' };
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockUser),
-        }));
-        const result = await getUser(mockConfig, 'user123');
-        expect(result).toEqual(mockUser);
-    });
-    it('returns null when user not found', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
-            ok: false,
-            status: 404,
-            text: () => Promise.resolve('Not found'),
-        }));
-        const result = await getUser(mockConfig, 'nonexistent');
-        expect(result).toBeNull();
-    });
-});
-describe('createPost', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('creates a post with correct parameters', async () => {
-        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockPost),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await createPost(mockConfig, 'channel1', 'Hello');
-        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/posts', expect.objectContaining({
-            method: 'POST',
-            body: JSON.stringify({
-                channel_id: 'channel1',
-                message: 'Hello',
-                root_id: undefined,
-            }),
-        }));
-    });
-    it('includes root_id for thread replies', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({}),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await createPost(mockConfig, 'channel1', 'Reply', 'thread123');
-        expect(mockFetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
-            body: JSON.stringify({
-                channel_id: 'channel1',
-                message: 'Reply',
-                root_id: 'thread123',
-            }),
-        }));
-    });
-});
-describe('updatePost', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('updates a post with correct parameters', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({ id: 'post123', message: 'Updated' }),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await updatePost(mockConfig, 'post123', 'Updated');
-        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/posts/post123', expect.objectContaining({
-            method: 'PUT',
-            body: JSON.stringify({
-                id: 'post123',
-                message: 'Updated',
-            }),
-        }));
-    });
-});
-describe('addReaction', () => {
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-    });
-    it('adds a reaction with correct parameters', async () => {
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve({}),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await addReaction(mockConfig, 'post123', 'bot123', '+1');
-        expect(mockFetch).toHaveBeenCalledWith('https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
-            method: 'POST',
-            body: JSON.stringify({
-                user_id: 'bot123',
-                post_id: 'post123',
-                emoji_name: '+1',
-            }),
-        }));
-    });
-});
-describe('isUserAllowed', () => {
-    it('returns true when allowlist is empty', () => {
-        expect(isUserAllowed('anyone', [])).toBe(true);
-    });
-    it('returns true when user is in allowlist', () => {
-        expect(isUserAllowed('alice', ['alice', 'bob'])).toBe(true);
-    });
-    it('returns false when user is not in allowlist', () => {
-        expect(isUserAllowed('eve', ['alice', 'bob'])).toBe(false);
-    });
-    it('is case-sensitive', () => {
-        expect(isUserAllowed('Alice', ['alice'])).toBe(false);
-    });
-});
-describe('createInteractivePost', () => {
-    let consoleSpy;
-    beforeEach(() => {
-        vi.stubGlobal('fetch', vi.fn());
-        consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(() => {
-        vi.unstubAllGlobals();
-        consoleSpy.mockRestore();
-    });
-    it('creates a post and adds reactions', async () => {
-        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockPost),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        const result = await createInteractivePost(mockConfig, 'channel1', 'Hello', ['+1', '-1'], undefined, 'bot123');
-        expect(result).toEqual(mockPost);
-        // First call: createPost, second+third: addReaction
-        expect(mockFetch).toHaveBeenCalledTimes(3);
-    });
-    it('creates post in a thread when rootId is provided', async () => {
-        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Reply' };
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockPost),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await createInteractivePost(mockConfig, 'channel1', 'Reply', ['+1'], 'thread123', 'bot123');
-        // Check the first call (createPost) includes root_id
-        expect(mockFetch).toHaveBeenNthCalledWith(1, 'https://mattermost.example.com/api/v4/posts', expect.objectContaining({
-            body: JSON.stringify({
-                channel_id: 'channel1',
-                message: 'Reply',
-                root_id: 'thread123',
-            }),
-        }));
-    });
-    it('continues adding reactions even if one fails', async () => {
-        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
-        let callCount = 0;
-        const mockFetch = vi.fn().mockImplementation(() => {
-            callCount++;
-            if (callCount === 1) {
-                // createPost succeeds
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve(mockPost),
-                });
-            }
-            else if (callCount === 2) {
-                // First reaction fails
-                return Promise.resolve({
-                    ok: false,
-                    status: 500,
-                    text: () => Promise.resolve('Server error'),
-                });
-            }
-            else {
-                // Second reaction succeeds
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({}),
-                });
-            }
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        const result = await createInteractivePost(mockConfig, 'channel1', 'Hello', ['+1', '-1'], undefined, 'bot123');
-        // Should still return the post
-        expect(result).toEqual(mockPost);
-        // All three calls should have been made
-        expect(mockFetch).toHaveBeenCalledTimes(3);
-        // Error should have been logged
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining('Failed to add reaction'), expect.any(Error));
-    });
-    it('returns the post even with no reactions', async () => {
-        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockPost),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        const result = await createInteractivePost(mockConfig, 'channel1', 'Hello', [], undefined, 'bot123');
-        expect(result).toEqual(mockPost);
-        // Only createPost call, no reactions
-        expect(mockFetch).toHaveBeenCalledTimes(1);
-    });
-    it('adds reactions in the correct order', async () => {
-        const mockPost = { id: 'post123', channel_id: 'channel1', message: 'Hello' };
-        const mockFetch = vi.fn().mockResolvedValue({
-            ok: true,
-            json: () => Promise.resolve(mockPost),
-        });
-        vi.stubGlobal('fetch', mockFetch);
-        await createInteractivePost(mockConfig, 'channel1', 'Hello', ['+1', 'white_check_mark', '-1'], undefined, 'bot123');
-        // Check reaction calls are in order
-        expect(mockFetch).toHaveBeenNthCalledWith(2, 'https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
-            body: expect.stringContaining('+1'),
-        }));
-        expect(mockFetch).toHaveBeenNthCalledWith(3, 'https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
-            body: expect.stringContaining('white_check_mark'),
-        }));
-        expect(mockFetch).toHaveBeenNthCalledWith(4, 'https://mattermost.example.com/api/v4/reactions', expect.objectContaining({
-            body: expect.stringContaining('-1'),
-        }));
-    });
-});

package/dist/mcp/permission-server.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/onboarding.d.ts

@@ -1 +0,0 @@
-export declare function runOnboarding(reconfigure?: boolean): Promise<void>;

package/dist/onboarding.js

@@ -1,318 +0,0 @@
-import prompts from 'prompts';
-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`;
-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.'));
-        }
-    }
-    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('  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('');
-        // 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: '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',
-            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',
-            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: existingMattermost?.botName || 'claude-code',
-            hint: 'Users will @mention this name',
-        },
-        {
-            type: 'text',
-            name: 'allowedUsers',
-            message: 'Allowed usernames (optional)',
-            initial: existingMattermost?.allowedUsers?.join(',') || '',
-            hint: 'Comma-separated, or empty to allow everyone',
-        },
-        {
-            type: 'confirm',
-            name: 'skipPermissions',
-            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: '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,
-    };
-}