@meltstudio/meltctl 4.38.0 → 4.39.0

package/dist/commands/init.test.js

@@ -1,478 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('fs-extra', () => ({
-    default: {
-        pathExists: vi.fn(),
-        pathExistsSync: vi.fn(),
-        writeFile: vi.fn(),
-        readFile: vi.fn(),
-        ensureDir: vi.fn(),
-    },
-}));
-vi.mock('../utils/auth.js', () => ({
-    isAuthenticated: vi.fn(),
-}));
-vi.mock('../utils/templates.js', () => ({
-    fetchTemplates: vi.fn(),
-}));
-vi.mock('@inquirer/prompts', () => ({
-    checkbox: vi.fn(),
-    confirm: vi.fn(),
-}));
-import fs from 'fs-extra';
-import { isAuthenticated } from '../utils/auth.js';
-import { fetchTemplates } from '../utils/templates.js';
-import { checkbox, confirm } from '@inquirer/prompts';
-import { initCommand } from './init.js';
-const MOCK_TEMPLATES = {
-    'agents-md.md': '# AGENTS.md\nProject standards go here.',
-    'workflows/setup.md': '# Setup Workflow\nAnalyze project.',
-    'workflows/plan.md': '# Plan Workflow\nDesign approach.',
-    'workflows/validate.md': '# Validate Workflow\nRun validation.',
-    'workflows/review.md': '# Review Workflow\nReview code.',
-    'workflows/pr.md': '# PR Workflow\nCreate PR.',
-    'workflows/debug.md': '# Debug Workflow\nDebug issue.',
-    'workflows/audit.md': '# Audit Workflow\nRun audit.',
-    'workflows/ux-audit.md': '# UX Audit Workflow\nReview UI.',
-    'workflows/security-audit.md': '# Security Audit Workflow\nSecurity check.',
-    'workflows/update.md': '# Update Workflow\nUpdate skills.',
-    'workflows/help.md': '# Help Workflow\nAnswer questions.',
-    'workflows/link.md': '# Link Workflow\nConnect tools.',
-    'claude-settings.json': '{"permissions":{"allow":["Read"],"deny":["Bash"]}}',
-    'mcp-configs/base.json': '{"mcpServers":{"context7":{"command":"npx","args":["context7"]}}}',
-};
-beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    vi.spyOn(console, 'error').mockImplementation(() => { });
-    vi.spyOn(process, 'exit').mockImplementation((code) => {
-        throw new Error(`process.exit(${code})`);
-    });
-    isAuthenticated.mockResolvedValue(true);
-    fs.pathExists.mockImplementation(async (p) => {
-        if (p.endsWith('.git'))
-            return true;
-        return false;
-    });
-    fs.pathExistsSync.mockReturnValue(false);
-    fs.writeFile.mockResolvedValue(undefined);
-    fs.readFile.mockResolvedValue('');
-    fs.ensureDir.mockResolvedValue(undefined);
-    fetchTemplates.mockResolvedValue(MOCK_TEMPLATES);
-});
-describe('initCommand', () => {
-    describe('authentication', () => {
-        it('exits when not authenticated', async () => {
-            ;
-            isAuthenticated.mockResolvedValue(false);
-            await expect(initCommand({})).rejects.toThrow('process.exit(1)');
-            expect(console.error).toHaveBeenCalled();
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Not authenticated'))).toBe(true);
-        });
-    });
-    describe('git repository check', () => {
-        it('prompts to continue when not in a git repo and aborts if declined', async () => {
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return false;
-                return false;
-            });
-            confirm.mockResolvedValue(false);
-            await initCommand({});
-            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({ message: expect.stringContaining('Continue') }));
-            // Should not have fetched templates since we aborted
-            expect(fetchTemplates).not.toHaveBeenCalled();
-        });
-        it('proceeds when not in a git repo but user confirms', async () => {
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return false;
-                return false;
-            });
-            confirm.mockResolvedValue(true);
-            checkbox.mockResolvedValue(['claude']);
-            await initCommand({});
-            expect(fetchTemplates).toHaveBeenCalled();
-        });
-    });
-    describe('fresh init with flags', () => {
-        it('creates AGENTS.md from templates', async () => {
-            await initCommand({ claude: true });
-            expect(fs.writeFile).toHaveBeenCalledWith(expect.stringContaining('AGENTS.md'), '# AGENTS.md\nProject standards go here.', 'utf-8');
-        });
-        it('creates Claude skills with frontmatter', async () => {
-            await initCommand({ claude: true });
-            // Check that skills are created with frontmatter prepended
-            const writeCalls = fs.writeFile.mock.calls;
-            const setupSkill = writeCalls.find(c => c[0].includes('.claude/skills/melt-setup') && c[0].endsWith('SKILL.md'));
-            expect(setupSkill).toBeDefined();
-            expect(setupSkill[1]).toContain('---');
-            expect(setupSkill[1]).toContain('user-invocable: true');
-            expect(setupSkill[1]).toContain('Analyze the project');
-            expect(setupSkill[1]).toContain('# Setup Workflow');
-            // Verify ensureDir was called for skill directories
-            const ensureDirCalls = fs.ensureDir.mock.calls;
-            const skillDirs = ensureDirCalls.filter(c => c[0].includes('.claude/skills/melt-'));
-            expect(skillDirs.length).toBeGreaterThanOrEqual(12);
-        });
-        it('creates all 11 Claude skills', async () => {
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const skillFiles = writeCalls.filter(c => c[0].includes('.claude/skills/melt-') && c[0].endsWith('SKILL.md'));
-            expect(skillFiles.length).toBe(12);
-            const skillNames = skillFiles.map(c => {
-                const match = c[0].match(/\.claude\/skills\/melt-([^/]+)/);
-                return match ? match[1] : '';
-            });
-            expect(skillNames).toContain('setup');
-            expect(skillNames).toContain('plan');
-            expect(skillNames).toContain('validate');
-            expect(skillNames).toContain('review');
-            expect(skillNames).toContain('pr');
-            expect(skillNames).toContain('debug');
-            expect(skillNames).toContain('audit');
-            expect(skillNames).toContain('ux-audit');
-            expect(skillNames).toContain('security-audit');
-            expect(skillNames).toContain('update');
-            expect(skillNames).toContain('help');
-            expect(skillNames).toContain('link');
-        });
-        it('creates Cursor commands without frontmatter', async () => {
-            await initCommand({ cursor: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const cursorFiles = writeCalls.filter(c => c[0].includes('.cursor/commands/melt-'));
-            expect(cursorFiles.length).toBe(12);
-            // Cursor commands should NOT have frontmatter
-            const setupCmd = cursorFiles.find(c => c[0].includes('melt-setup.md'));
-            expect(setupCmd).toBeDefined();
-            expect(setupCmd[1]).toBe('# Setup Workflow\nAnalyze project.');
-            expect(setupCmd[1]).not.toContain('---');
-        });
-        it('creates OpenCode commands with frontmatter', async () => {
-            await initCommand({ opencode: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const opencodeFiles = writeCalls.filter(c => c[0].includes('.opencode/commands/melt-'));
-            expect(opencodeFiles.length).toBe(12);
-            // OpenCode commands should have shorter frontmatter
-            const setupCmd = opencodeFiles.find(c => c[0].includes('melt-setup.md'));
-            expect(setupCmd).toBeDefined();
-            expect(setupCmd[1]).toContain('---');
-            expect(setupCmd[1]).toContain('description: Analyze the project');
-            expect(setupCmd[1]).toContain('# Setup Workflow');
-        });
-        it('only creates files for --claude flag', async () => {
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const cursorFiles = writeCalls.filter(c => c[0].includes('.cursor/'));
-            const opencodeFiles = writeCalls.filter(c => c[0].includes('.opencode/'));
-            expect(cursorFiles.length).toBe(0);
-            expect(opencodeFiles.length).toBe(0);
-        });
-        it('only creates files for --cursor flag', async () => {
-            await initCommand({ cursor: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const claudeFiles = writeCalls.filter(c => c[0].includes('.claude/'));
-            const opencodeFiles = writeCalls.filter(c => c[0].includes('.opencode/'));
-            expect(claudeFiles.length).toBe(0);
-            expect(opencodeFiles.length).toBe(0);
-        });
-        it('only creates files for --opencode flag', async () => {
-            await initCommand({ opencode: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const claudeFiles = writeCalls.filter(c => c[0].includes('.claude/'));
-            const cursorFiles = writeCalls.filter(c => c[0].includes('.cursor/'));
-            expect(claudeFiles.length).toBe(0);
-            expect(cursorFiles.length).toBe(0);
-        });
-        it('creates files for all tools when all flags are set', async () => {
-            await initCommand({ claude: true, cursor: true, opencode: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const claudeFiles = writeCalls.filter(c => c[0].includes('.claude/'));
-            const cursorFiles = writeCalls.filter(c => c[0].includes('.cursor/'));
-            const opencodeFiles = writeCalls.filter(c => c[0].includes('.opencode/'));
-            expect(claudeFiles.length).toBeGreaterThan(0);
-            expect(cursorFiles.length).toBeGreaterThan(0);
-            expect(opencodeFiles.length).toBeGreaterThan(0);
-        });
-    });
-    describe('interactive tool selection', () => {
-        it('prompts with checkbox when no flags provided', async () => {
-            ;
-            checkbox.mockResolvedValue(['claude', 'cursor']);
-            await initCommand({});
-            expect(checkbox).toHaveBeenCalledWith(expect.objectContaining({ message: expect.stringContaining('AI coding tools') }));
-        });
-        it('exits when no tools selected', async () => {
-            ;
-            checkbox.mockResolvedValue([]);
-            await expect(initCommand({})).rejects.toThrow('process.exit(0)');
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('No tools selected'))).toBe(true);
-        });
-    });
-    describe('.mcp.json', () => {
-        it('creates .mcp.json from template when none exists', async () => {
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const mcpWrite = writeCalls.find(c => c[0].endsWith('.mcp.json'));
-            expect(mcpWrite).toBeDefined();
-            expect(mcpWrite[1]).toBe(MOCK_TEMPLATES['mcp-configs/base.json']);
-        });
-        it('merges .mcp.json with existing config', async () => {
-            const existingMcp = JSON.stringify({
-                mcpServers: { existing: { command: 'existing-cmd' } },
-            });
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('.mcp.json'))
-                    return true;
-                return false;
-            });
-            fs.readFile.mockImplementation(async (p) => {
-                if (p.endsWith('.mcp.json'))
-                    return existingMcp;
-                return '';
-            });
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const mcpWrite = writeCalls.find(c => c[0].endsWith('.mcp.json'));
-            expect(mcpWrite).toBeDefined();
-            const written = JSON.parse(mcpWrite[1]);
-            // Should have both existing and template servers
-            expect(written.mcpServers.existing).toEqual({ command: 'existing-cmd' });
-            expect(written.mcpServers.context7).toEqual({ command: 'npx', args: ['context7'] });
-        });
-    });
-    describe('.claude/settings.json', () => {
-        it('creates claude settings from template when none exists', async () => {
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const settingsWrite = writeCalls.find(c => c[0].includes('.claude/settings.json'));
-            expect(settingsWrite).toBeDefined();
-            expect(settingsWrite[1]).toBe(MOCK_TEMPLATES['claude-settings.json']);
-        });
-        it('merges claude settings with existing permissions', async () => {
-            const existingSettings = JSON.stringify({
-                permissions: { allow: ['Bash'], deny: ['Write'] },
-            });
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('.claude/settings.json'))
-                    return true;
-                return false;
-            });
-            fs.readFile.mockImplementation(async (p) => {
-                if (p.endsWith('settings.json'))
-                    return existingSettings;
-                return '';
-            });
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const settingsWrite = writeCalls.find(c => c[0].includes('.claude/settings.json'));
-            expect(settingsWrite).toBeDefined();
-            const written = JSON.parse(settingsWrite[1]);
-            // Should have deduplicated merged arrays
-            expect(written.permissions.allow).toContain('Bash');
-            expect(written.permissions.allow).toContain('Read');
-            expect(written.permissions.deny).toContain('Write');
-            expect(written.permissions.deny).toContain('Bash');
-        });
-    });
-    describe('.gitignore', () => {
-        it('creates .gitignore with melt entries when none exists', async () => {
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const gitignoreWrite = writeCalls.find(c => c[0].endsWith('.gitignore'));
-            expect(gitignoreWrite).toBeDefined();
-            expect(gitignoreWrite[1]).toContain('.env.local');
-            expect(gitignoreWrite[1]).toContain('.claude/settings.local.json');
-            expect(gitignoreWrite[1]).toContain('# Melt - local settings');
-        });
-        it('appends missing entries to existing .gitignore', async () => {
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('.gitignore'))
-                    return true;
-                return false;
-            });
-            fs.readFile.mockImplementation(async (p) => {
-                if (p.endsWith('.gitignore'))
-                    return 'node_modules\n.env.local\n';
-                return '';
-            });
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const gitignoreWrite = writeCalls.find(c => c[0].endsWith('.gitignore'));
-            expect(gitignoreWrite).toBeDefined();
-            // Should keep existing content and add only missing entry
-            expect(gitignoreWrite[1]).toContain('node_modules');
-            expect(gitignoreWrite[1]).toContain('.claude/settings.local.json');
-        });
-        it('does not modify .gitignore when all entries already present', async () => {
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('.gitignore'))
-                    return true;
-                return false;
-            });
-            fs.readFile.mockImplementation(async (p) => {
-                if (p.endsWith('.gitignore'))
-                    return '.env.local\n.claude/settings.local.json\n';
-                return '';
-            });
-            await initCommand({ claude: true });
-            const writeCalls = fs.writeFile.mock.calls;
-            const gitignoreWrite = writeCalls.find(c => c[0].endsWith('.gitignore'));
-            // Should not write .gitignore when all entries exist
-            expect(gitignoreWrite).toBeUndefined();
-        });
-    });
-    describe('re-init flow', () => {
-        beforeEach(() => {
-            // AGENTS.md exists (already initialized)
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('AGENTS.md'))
-                    return true;
-                return false;
-            });
-        });
-        it('detects existing tools and prompts to add more', async () => {
-            ;
-            fs.pathExistsSync.mockImplementation((p) => {
-                if (p.includes('.claude/settings.json'))
-                    return true;
-                return false;
-            });
-            confirm.mockResolvedValue(true);
-            checkbox.mockResolvedValue(['cursor']);
-            await initCommand({});
-            // Should prompt to add more
-            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({ message: expect.stringContaining('Add configuration') }));
-            // Checkbox should NOT include Claude since it already exists
-            const checkboxCall = checkbox.mock.calls[0][0];
-            const values = checkboxCall.choices.map((c) => c.value);
-            expect(values).not.toContain('claude');
-            expect(values).toContain('cursor');
-            expect(values).toContain('opencode');
-        });
-        it('skips AGENTS.md and .mcp.json on re-init', async () => {
-            ;
-            confirm.mockResolvedValue(true);
-            checkbox.mockResolvedValue(['cursor']);
-            await initCommand({});
-            const writeCalls = fs.writeFile.mock.calls;
-            const agentsWrite = writeCalls.find(c => c[0].endsWith('AGENTS.md'));
-            const mcpWrite = writeCalls.find(c => c[0].endsWith('.mcp.json'));
-            expect(agentsWrite).toBeUndefined();
-            expect(mcpWrite).toBeUndefined();
-        });
-        it('exits when user declines to add more tools', async () => {
-            ;
-            confirm.mockResolvedValue(false);
-            await expect(initCommand({})).rejects.toThrow('process.exit(0)');
-        });
-        it('exits when all tools are already initialized', async () => {
-            ;
-            fs.pathExistsSync.mockImplementation((p) => {
-                if (p.includes('.claude/settings.json'))
-                    return true;
-                if (p.includes('.cursor/commands'))
-                    return true;
-                if (p.includes('.opencode/commands'))
-                    return true;
-                return false;
-            });
-            await expect(initCommand({})).rejects.toThrow('process.exit(1)');
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('already initialized with all tools'))).toBe(true);
-        });
-        it('uses flags directly in re-init mode without prompting', async () => {
-            ;
-            fs.pathExistsSync.mockImplementation((p) => {
-                if (p.includes('.claude/settings.json'))
-                    return true;
-                return false;
-            });
-            await initCommand({ cursor: true });
-            // Should NOT have prompted
-            expect(confirm).not.toHaveBeenCalled();
-            expect(checkbox).not.toHaveBeenCalled();
-            // Should have created cursor files
-            const writeCalls = fs.writeFile.mock.calls;
-            const cursorFiles = writeCalls.filter(c => c[0].includes('.cursor/'));
-            expect(cursorFiles.length).toBeGreaterThan(0);
-        });
-    });
-    describe('--force flag', () => {
-        it('overwrites existing files when --force is set', async () => {
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('AGENTS.md'))
-                    return true;
-                return false;
-            });
-            await initCommand({ force: true, claude: true });
-            // Should create AGENTS.md even though it already exists
-            const writeCalls = fs.writeFile.mock.calls;
-            const agentsWrite = writeCalls.find(c => c[0].endsWith('AGENTS.md'));
-            expect(agentsWrite).toBeDefined();
-        });
-        it('does not prompt for re-init when --force is set', async () => {
-            ;
-            fs.pathExists.mockImplementation(async (p) => {
-                if (p.endsWith('.git'))
-                    return true;
-                if (p.endsWith('AGENTS.md'))
-                    return true;
-                return false;
-            });
-            await initCommand({ force: true, claude: true });
-            expect(confirm).not.toHaveBeenCalled();
-        });
-    });
-    describe('template fetch failure', () => {
-        it('handles session expired error', async () => {
-            ;
-            fetchTemplates.mockRejectedValue(new Error('Token expired'));
-            await expect(initCommand({ claude: true })).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('expired'))).toBe(true);
-        });
-        it('handles network error', async () => {
-            ;
-            fetchTemplates.mockRejectedValue(new Error('Failed to fetch'));
-            await expect(initCommand({ claude: true })).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Could not reach'))).toBe(true);
-        });
-        it('handles generic error', async () => {
-            ;
-            fetchTemplates.mockRejectedValue(new Error('Something broke'));
-            await expect(initCommand({ claude: true })).rejects.toThrow('process.exit(1)');
-            const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Something broke'))).toBe(true);
-        });
-    });
-    describe('other tool selection', () => {
-        it('prints Slack message when "other" is selected', async () => {
-            ;
-            checkbox.mockResolvedValue(['other']);
-            await initCommand({});
-            const logCalls = console.log.mock.calls.map((c) => String(c[0]));
-            expect(logCalls.some((msg) => msg.includes('Slack'))).toBe(true);
-        });
-    });
-});

package/dist/commands/login.d.ts

@@ -1 +0,0 @@
-export declare function loginCommand(): Promise<void>;

package/dist/commands/login.js

@@ -1,90 +0,0 @@
-import chalk from 'chalk';
-import http from 'http';
-import { URL } from 'url';
-import { exec } from 'child_process';
-import { createMeltClient } from '@meltstudio/meltctl-sdk';
-import { API_BASE, storeAuth } from '../utils/auth.js';
-import { printBanner } from '../utils/banner.js';
-const LOGIN_TIMEOUT_MS = 60_000;
-function openBrowser(url) {
-    const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
-    exec(`${command} "${url}"`);
-}
-function findFreePort() {
-    return new Promise((resolve, reject) => {
-        const server = http.createServer();
-        server.listen(0, () => {
-            const address = server.address();
-            if (address && typeof address === 'object') {
-                const port = address.port;
-                server.close(() => resolve(port));
-            }
-            else {
-                reject(new Error('Could not find free port'));
-            }
-        });
-    });
-}
-export async function loginCommand() {
-    printBanner();
-    console.log(chalk.bold('  Logging in to Melt...'));
-    const port = await findFreePort();
-    const redirectUri = `http://localhost:${port.toString()}`;
-    const authCode = await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            server.close();
-            reject(new Error('Authentication timed out. Please try again.'));
-        }, LOGIN_TIMEOUT_MS);
-        const server = http.createServer((req, res) => {
-            const url = new URL(req.url ?? '/', `http://localhost:${port.toString()}`);
-            const code = url.searchParams.get('code');
-            const error = url.searchParams.get('error');
-            if (error) {
-                res.writeHead(200, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h2>Authentication failed</h2><p>You can close this tab.</p></body></html>');
-                clearTimeout(timeout);
-                server.close();
-                reject(new Error(`Authentication denied: ${error}`));
-                return;
-            }
-            if (!code) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end('<html><body><h2>Missing authorization code</h2></body></html>');
-                return;
-            }
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end('<html><body><h2>Authentication successful!</h2><p>You can close this tab and return to your terminal.</p></body></html>');
-            clearTimeout(timeout);
-            server.close();
-            resolve(code);
-        });
-        server.listen(port, () => {
-            const authUrl = `${API_BASE}/auth/google?redirect_uri=${encodeURIComponent(redirectUri)}`;
-            console.log();
-            console.log(chalk.bold('  A browser window will open shortly.'));
-            console.log(chalk.dim('  Please log in with your @meltstudio.co Google Workspace account.'));
-            console.log();
-            setTimeout(() => {
-                openBrowser(authUrl);
-                console.log(chalk.dim(`  If the browser didn't open, visit: ${authUrl}`));
-            }, 2000);
-        });
-    });
-    console.log(chalk.dim('Exchanging authorization code...'));
-    // Use SDK with empty token for the unauthenticated token exchange
-    const client = createMeltClient({ baseUrl: API_BASE, token: '' });
-    try {
-        const data = await client.auth.exchangeToken(authCode, redirectUri);
-        await storeAuth({
-            token: data.token,
-            email: data.email,
-            expiresAt: data.expiresAt,
-        });
-        console.log();
-        console.log(chalk.green(`Logged in as ${data.email}`));
-    }
-    catch (error) {
-        console.error(chalk.red(`Authentication failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
-        process.exit(1);
-    }
-}

package/dist/commands/login.test.d.ts

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