@meltstudio/meltctl 4.34.0 → 4.36.0

package/dist/commands/standup.test.js

@@ -1,13 +1,21 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('../utils/auth.js', () => ({
     isAuthenticated: vi.fn(),
-    authenticatedFetch: vi.fn(),
+}));
+const mockClient = vi.hoisted(() => ({
+    standups: {
+        getStatus: vi.fn(),
+        submit: vi.fn(),
+    },
+}));
+vi.mock('../utils/api.js', () => ({
+    getClient: vi.fn().mockResolvedValue(mockClient),
 }));
 vi.mock('@inquirer/prompts', () => ({
     input: vi.fn(),
     editor: vi.fn(),
 }));
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { isAuthenticated } from '../utils/auth.js';
 import { input, editor } from '@inquirer/prompts';
 import { standupCommand } from './standup.js';
 beforeEach(() => {
@@ -28,47 +36,33 @@ describe('standupCommand', () => {
     it('returns early when standup already submitted today', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({
-                yesterday: 'Did stuff',
-                today: 'More stuff',
-                blockers: null,
-            }),
-        };
-        authenticatedFetch.mockResolvedValue(statusResponse);
+        mockClient.standups.getStatus.mockResolvedValue({
+            yesterday: 'Did stuff',
+            today: 'More stuff',
+            blockers: null,
+        });
         await standupCommand({});
-        expect(authenticatedFetch).toHaveBeenCalledWith('/standups/status');
-        // Should not call POST /standups
-        expect(authenticatedFetch).toHaveBeenCalledTimes(1);
+        expect(mockClient.standups.getStatus).toHaveBeenCalled();
+        // Should not call submit
+        expect(mockClient.standups.submit).not.toHaveBeenCalled();
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('already submitted'))).toBe(true);
     });
     it('submits standup with correct payload using option flags', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        // Status check returns not found (no existing standup)
-        const statusResponse = { ok: false };
-        const submitResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({}),
-        };
-        authenticatedFetch
-            .mockResolvedValueOnce(statusResponse)
-            .mockResolvedValueOnce(submitResponse);
+        // Status check returns null (no existing standup)
+        mockClient.standups.getStatus.mockResolvedValue(null);
+        mockClient.standups.submit.mockResolvedValue({});
         await standupCommand({
             yesterday: 'Fixed bugs',
             today: 'Write tests',
             blockers: 'None',
         });
-        expect(authenticatedFetch).toHaveBeenCalledWith('/standups', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                yesterday: 'Fixed bugs',
-                today: 'Write tests',
-                blockers: 'None',
-            }),
+        expect(mockClient.standups.submit).toHaveBeenCalledWith({
+            yesterday: 'Fixed bugs',
+            today: 'Write tests',
+            blockers: 'None',
         });
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('Standup submitted'))).toBe(true);
@@ -76,58 +70,45 @@ describe('standupCommand', () => {
     it('submits standup without blockers when empty string', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = { ok: false };
-        const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-        authenticatedFetch
-            .mockResolvedValueOnce(statusResponse)
-            .mockResolvedValueOnce(submitResponse);
+        mockClient.standups.getStatus.mockResolvedValue(null);
+        mockClient.standups.submit.mockResolvedValue({});
         await standupCommand({
             yesterday: 'Did things',
             today: 'More things',
         });
-        const call = authenticatedFetch.mock.calls[1];
-        const body = JSON.parse(call[1].body);
-        expect(body.blockers).toBeUndefined();
+        expect(mockClient.standups.submit).toHaveBeenCalledWith({
+            yesterday: 'Did things',
+            today: 'More things',
+            blockers: undefined,
+        });
     });
     it('exits with error when API returns failure', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = { ok: false };
-        const submitResponse = {
-            ok: false,
-            statusText: 'Bad Request',
-            json: vi.fn().mockResolvedValue({ error: 'Invalid standup' }),
-        };
-        authenticatedFetch
-            .mockResolvedValueOnce(statusResponse)
-            .mockResolvedValueOnce(submitResponse);
+        mockClient.standups.getStatus.mockResolvedValue(null);
+        mockClient.standups.submit.mockRejectedValue(new Error('Invalid standup'));
         await expect(standupCommand({ yesterday: 'x', today: 'y' })).rejects.toThrow('process.exit(1)');
         expect(console.error).toHaveBeenCalled();
     });
     it('continues to submission when status check throws', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        authenticatedFetch
-            .mockRejectedValueOnce(new Error('Network error'))
-            .mockResolvedValueOnce({ ok: true, json: vi.fn().mockResolvedValue({}) });
+        mockClient.standups.getStatus.mockRejectedValue(new Error('Network error'));
+        mockClient.standups.submit.mockResolvedValue({});
         await standupCommand({ yesterday: 'a', today: 'b' });
-        expect(authenticatedFetch).toHaveBeenCalledTimes(2);
-        expect(authenticatedFetch).toHaveBeenCalledWith('/standups', expect.objectContaining({
-            method: 'POST',
+        expect(mockClient.standups.submit).toHaveBeenCalledWith(expect.objectContaining({
+            yesterday: 'a',
+            today: 'b',
         }));
     });
     it('displays existing standup with blockers', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const statusResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({
-                yesterday: 'Bug fixes',
-                today: 'Feature work',
-                blockers: 'Waiting on review',
-            }),
-        };
-        authenticatedFetch.mockResolvedValue(statusResponse);
+        mockClient.standups.getStatus.mockResolvedValue({
+            yesterday: 'Bug fixes',
+            today: 'Feature work',
+            blockers: 'Waiting on review',
+        });
         await standupCommand({});
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('already submitted'))).toBe(true);
@@ -136,44 +117,41 @@ describe('standupCommand', () => {
         function setupInteractiveAuth() {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValueOnce({ ok: false });
+            // Status check returns null (no existing standup)
+            mockClient.standups.getStatus.mockResolvedValue(null);
         }
         it('prompts for yesterday, today, and blockers in interactive mode', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('Worked on feature X')
                 .mockResolvedValueOnce('Working on feature Y')
                 .mockResolvedValueOnce('No blockers');
             await standupCommand({});
             expect(input).toHaveBeenCalledTimes(3);
-            expect(authenticatedFetch).toHaveBeenCalledWith('/standups', expect.objectContaining({
-                method: 'POST',
-                body: JSON.stringify({
-                    yesterday: 'Worked on feature X',
-                    today: 'Working on feature Y',
-                    blockers: 'No blockers',
-                }),
-            }));
+            expect(mockClient.standups.submit).toHaveBeenCalledWith({
+                yesterday: 'Worked on feature X',
+                today: 'Working on feature Y',
+                blockers: 'No blockers',
+            });
         });
         it('submits without blockers when left empty in interactive mode', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('Did code review')
                 .mockResolvedValueOnce('Deploy to staging')
                 .mockResolvedValueOnce('');
             await standupCommand({});
-            const call = authenticatedFetch.mock.calls[1];
-            const body = JSON.parse(call[1].body);
-            expect(body.blockers).toBeUndefined();
+            expect(mockClient.standups.submit).toHaveBeenCalledWith({
+                yesterday: 'Did code review',
+                today: 'Deploy to staging',
+                blockers: undefined,
+            });
         });
         it('re-prompts when required field is empty', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('  ') // empty yesterday -> re-prompt
                 .mockResolvedValueOnce('Fixed a bug') // valid yesterday
@@ -186,8 +164,7 @@ describe('standupCommand', () => {
         });
         it('opens editor when user types \\e', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('\\e') // trigger editor for yesterday
                 .mockResolvedValueOnce('Writing docs') // today
@@ -196,14 +173,13 @@ describe('standupCommand', () => {
             editor.mockResolvedValueOnce('Detailed yesterday notes from editor');
             await standupCommand({});
             expect(editor).toHaveBeenCalledTimes(1);
-            const call = authenticatedFetch.mock.calls[1];
-            const body = JSON.parse(call[1].body);
-            expect(body.yesterday).toBe('Detailed yesterday notes from editor');
+            expect(mockClient.standups.submit).toHaveBeenCalledWith(expect.objectContaining({
+                yesterday: 'Detailed yesterday notes from editor',
+            }));
         });
         it('falls back to inline input when editor fails', async () => {
             setupInteractiveAuth();
-            const submitResponse = { ok: true, json: vi.fn().mockResolvedValue({}) };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockResolvedValue({});
             input
                 .mockResolvedValueOnce('\\e') // trigger editor for yesterday
                 .mockResolvedValueOnce('Fallback input') // fallback after editor fails
@@ -218,12 +194,7 @@ describe('standupCommand', () => {
         });
         it('exits with error when API fails in interactive mode', async () => {
             setupInteractiveAuth();
-            const submitResponse = {
-                ok: false,
-                statusText: 'Unprocessable Entity',
-                json: vi.fn().mockResolvedValue({ error: 'Missing fields' }),
-            };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockRejectedValue(new Error('Missing fields'));
             input
                 .mockResolvedValueOnce('Yesterday work')
                 .mockResolvedValueOnce('Today work')
@@ -234,12 +205,7 @@ describe('standupCommand', () => {
         });
         it('falls back to statusText when API error has no error body', async () => {
             setupInteractiveAuth();
-            const submitResponse = {
-                ok: false,
-                statusText: 'Bad Gateway',
-                json: vi.fn().mockResolvedValue({}),
-            };
-            authenticatedFetch.mockResolvedValueOnce(submitResponse);
+            mockClient.standups.submit.mockRejectedValue(new Error('Bad Gateway'));
             input
                 .mockResolvedValueOnce('Yesterday')
                 .mockResolvedValueOnce('Today')

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+export declare function detectPackageManager(): 'npm' | 'yarn' | 'unknown';
+export declare function updateCommand(): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,74 @@
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getCurrentCliVersion, getLatestCliVersion, getUpdateSeverity, } from '../utils/version-check.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+export function detectPackageManager() {
+    const installPath = path.resolve(__dirname, '../..');
+    try {
+        const npmGlobalPrefix = execSync('npm prefix -g', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (installPath.startsWith(npmGlobalPrefix)) {
+            return 'npm';
+        }
+    }
+    catch {
+        // npm not available
+    }
+    try {
+        const yarnGlobalDir = execSync('yarn global dir', { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (installPath.startsWith(yarnGlobalDir)) {
+            return 'yarn';
+        }
+    }
+    catch {
+        // yarn not available
+    }
+    // Check path heuristics as fallback
+    if (installPath.includes('yarn'))
+        return 'yarn';
+    if (installPath.includes('npm'))
+        return 'npm';
+    return 'unknown';
+}
+export async function updateCommand() {
+    const currentVersion = await getCurrentCliVersion();
+    const latestVersion = await getLatestCliVersion();
+    if (!latestVersion) {
+        console.error(chalk.red('Could not check for updates. Check your network connection.'));
+        process.exit(1);
+    }
+    const severity = getUpdateSeverity(currentVersion, latestVersion);
+    if (severity === 'none') {
+        console.log(chalk.green(`  ✓ Already on the latest version (${currentVersion})`));
+        return;
+    }
+    console.log(chalk.dim(`  ${currentVersion} → ${latestVersion}`));
+    console.log();
+    const pm = detectPackageManager();
+    let cmd;
+    if (pm === 'yarn') {
+        cmd = 'yarn global add @meltstudio/meltctl@latest';
+    }
+    else if (pm === 'npm') {
+        cmd = 'npm install -g @meltstudio/meltctl@latest';
+    }
+    else {
+        // Unknown install method — try npm as default
+        console.log(chalk.dim('  Could not detect package manager, trying npm...'));
+        cmd = 'npm install -g @meltstudio/meltctl@latest';
+    }
+    console.log(chalk.dim(`  Running: ${cmd}`));
+    console.log();
+    try {
+        execSync(cmd, { stdio: 'inherit' });
+        console.log();
+        console.log(chalk.green(`  ✓ Updated to ${latestVersion}`));
+    }
+    catch {
+        console.error();
+        console.error(chalk.red('  Update failed. Try running manually:'));
+        console.error(chalk.cyan(`    ${cmd}`));
+        process.exit(1);
+    }
+}

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

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

package/dist/commands/update.test.js

@@ -0,0 +1,93 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('child_process', () => ({
+    execSync: vi.fn(),
+}));
+vi.mock('fs-extra', () => ({
+    default: {
+        readJson: vi.fn(),
+    },
+}));
+vi.mock('../utils/version-check.js', () => ({
+    getCurrentCliVersion: vi.fn(),
+    getLatestCliVersion: vi.fn(),
+    getUpdateSeverity: vi.fn(),
+}));
+import { execSync } from 'child_process';
+import { getCurrentCliVersion, getLatestCliVersion, getUpdateSeverity, } from '../utils/version-check.js';
+import { updateCommand, detectPackageManager } from './update.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    vi.spyOn(process, 'exit').mockImplementation(() => undefined);
+});
+describe('detectPackageManager', () => {
+    it('returns npm when install path matches npm prefix', () => {
+        ;
+        execSync.mockImplementation((cmd) => {
+            if (cmd === 'npm prefix -g')
+                return '/usr/local/lib\n';
+            throw new Error('not found');
+        });
+        // This test depends on the actual install path, so just verify it returns a valid value
+        const result = detectPackageManager();
+        expect(['npm', 'yarn', 'unknown']).toContain(result);
+    });
+    it('returns unknown when neither npm nor yarn detected', () => {
+        ;
+        execSync.mockImplementation(() => {
+            throw new Error('not found');
+        });
+        const result = detectPackageManager();
+        expect(['npm', 'yarn', 'unknown']).toContain(result);
+    });
+});
+describe('updateCommand', () => {
+    it('prints already up to date when on latest', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getUpdateSeverity).mockReturnValue('none');
+        await updateCommand();
+        const logCalls = console.log.mock.calls.map((c) => String(c[0]));
+        expect(logCalls.some((msg) => msg.includes('Already on the latest'))).toBe(true);
+        expect(process.exit).not.toHaveBeenCalled();
+    });
+    it('exits when latest version cannot be fetched', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue(null);
+        await updateCommand();
+        expect(process.exit).toHaveBeenCalledWith(1);
+    });
+    it('runs npm install when update available and npm detected', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.33.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getUpdateSeverity).mockReturnValue('minor');
+        execSync.mockImplementation((cmd) => {
+            if (cmd === 'npm prefix -g')
+                return '/usr/local/lib\n';
+            if (cmd.startsWith('npm install -g'))
+                return '';
+            throw new Error('not found');
+        });
+        await updateCommand();
+        expect(execSync).toHaveBeenCalledWith('npm install -g @meltstudio/meltctl@latest', {
+            stdio: 'inherit',
+        });
+    });
+    it('exits with error when install command fails', async () => {
+        vi.mocked(getCurrentCliVersion).mockResolvedValue('4.33.0');
+        vi.mocked(getLatestCliVersion).mockResolvedValue('4.34.0');
+        vi.mocked(getUpdateSeverity).mockReturnValue('minor');
+        execSync.mockImplementation((cmd) => {
+            if (cmd === 'npm prefix -g')
+                return '/usr/local/lib\n';
+            if (cmd.startsWith('npm install -g'))
+                throw new Error('permission denied');
+            throw new Error('not found');
+        });
+        await updateCommand();
+        expect(process.exit).toHaveBeenCalledWith(1);
+        const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
+        expect(errorCalls.some((msg) => msg.includes('Update failed'))).toBe(true);
+    });
+});

package/dist/index.js

@@ -16,6 +16,7 @@ import { feedbackCommand } from './commands/feedback.js';
 import { coinsCommand } from './commands/coins.js';
 import { auditSubmitCommand, auditListCommand, auditViewCommand } from './commands/audit.js';
 import { planSubmitCommand, planListCommand } from './commands/plan.js';
+import { updateCommand } from './commands/update.js';
 import { trackCommand } from './utils/analytics.js';
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
@@ -186,6 +187,12 @@ plan
     .action(async (options) => {
     await planListCommand(options);
 });
+program
+    .command('update')
+    .description('update meltctl to the latest version')
+    .action(async () => {
+    await updateCommand();
+});
 program
     .command('version')
     .description('show current version')

package/dist/utils/analytics.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { createMeltClient } from '@meltstudio/meltctl-sdk';
 import { getStoredAuth, API_BASE } from './auth.js';
 import { getGitRepository, getGitBranch, getProjectName } from './git.js';
 import { debugLog } from './debug.js';
@@ -27,15 +28,11 @@ export async function trackCommand(command, success, errorMessage) {
             return;
         }
         const repo = getGitRepository();
+        const client = createMeltClient({ baseUrl: API_BASE, token: auth.token });
         const controller = new AbortController();
         const timeout = setTimeout(() => controller.abort(), 3000);
-        const res = await fetch(`${API_BASE}/events`, {
-            method: 'POST',
-            headers: {
-                Authorization: `Bearer ${auth.token}`,
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
+        try {
+            await client.events.submit({
                 command,
                 project: getProjectName(),
                 repository: repo?.slug ?? null,
@@ -43,20 +40,13 @@ export async function trackCommand(command, success, errorMessage) {
                 version: getVersion(),
                 success,
                 errorMessage: errorMessage?.slice(0, 500) ?? null,
-            }),
-            signal: controller.signal,
-        }).catch(e => {
-            debugLog(`Analytics fetch failed: ${e instanceof Error ? e.message : e}`);
-            return null;
-        });
-        clearTimeout(timeout);
-        if (res && !res.ok) {
-            const body = await res.text().catch(() => '');
-            debugLog(`Analytics API error ${res.status}: ${body}`);
-        }
-        else if (res) {
+            });
             debugLog(`Analytics event sent for "${command}"`);
         }
+        catch (e) {
+            debugLog(`Analytics error: ${e instanceof Error ? e.message : e}`);
+        }
+        clearTimeout(timeout);
     }
     catch (e) {
         debugLog(`Analytics error: ${e instanceof Error ? e.message : e}`);

package/dist/utils/api.d.ts

@@ -1,2 +1,3 @@
+import { type MeltClient } from '@meltstudio/meltctl-sdk';
 export declare function getToken(): Promise<string>;
-export declare function tokenFetch(token: string, urlPath: string, options?: RequestInit): Promise<Response>;
+export declare function getClient(): Promise<MeltClient>;

package/dist/utils/api.js

@@ -1,4 +1,5 @@
 import chalk from 'chalk';
+import { createMeltClient } from '@meltstudio/meltctl-sdk';
 import { getStoredAuth, API_BASE } from './auth.js';
 export async function getToken() {
     const envToken = process.env['MELTCTL_TOKEN'];
@@ -16,16 +17,7 @@ export async function getToken() {
     }
     return auth.token;
 }
-export async function tokenFetch(token, urlPath, options = {}) {
-    const response = await fetch(`${API_BASE}${urlPath}`, {
-        ...options,
-        headers: {
-            Authorization: `Bearer ${token}`,
-            ...options.headers,
-        },
-    });
-    if (response.status === 401) {
-        throw new Error('Authentication failed. Run `npx @meltstudio/meltctl@latest login` or check your MELTCTL_TOKEN.');
-    }
-    return response;
+export async function getClient() {
+    const token = await getToken();
+    return createMeltClient({ baseUrl: API_BASE, token });
 }

package/dist/utils/api.test.js

@@ -3,8 +3,12 @@ vi.mock('./auth.js', () => ({
     getStoredAuth: vi.fn(),
     API_BASE: 'https://test-api.example.com',
 }));
-import { getStoredAuth, API_BASE } from './auth.js';
-import { getToken, tokenFetch } from './api.js';
+vi.mock('@meltstudio/meltctl-sdk', () => ({
+    createMeltClient: vi.fn().mockReturnValue({ mock: true }),
+}));
+import { getStoredAuth } from './auth.js';
+import { createMeltClient } from '@meltstudio/meltctl-sdk';
+import { getToken, getClient } from './api.js';
 beforeEach(() => {
     vi.clearAllMocks();
     vi.spyOn(console, 'error').mockImplementation(() => { });
@@ -47,50 +51,26 @@ describe('getToken', () => {
         expect(console.error).toHaveBeenCalled();
     });
 });
-describe('tokenFetch', () => {
-    it('makes request with bearer token', async () => {
-        const mockResponse = { status: 200, ok: true };
-        const fetchMock = vi.fn().mockResolvedValue(mockResponse);
-        vi.stubGlobal('fetch', fetchMock);
-        const result = await tokenFetch('my-token', '/audits');
-        expect(result).toBe(mockResponse);
-        expect(fetchMock).toHaveBeenCalledWith(`${API_BASE}/audits`, expect.objectContaining({
-            headers: expect.objectContaining({
-                Authorization: 'Bearer my-token',
-            }),
-        }));
-        vi.unstubAllGlobals();
-    });
-    it('merges custom options and headers', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({ status: 200, ok: true });
-        vi.stubGlobal('fetch', fetchMock);
-        await tokenFetch('tok', '/test', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: '{}',
+describe('getClient', () => {
+    it('creates SDK client with token and base URL', async () => {
+        ;
+        getStoredAuth.mockResolvedValue({
+            token: 'my-token',
+            email: 'dev@meltstudio.co',
+            expiresAt: '2099-12-31T00:00:00Z',
+        });
+        await getClient();
+        expect(createMeltClient).toHaveBeenCalledWith({
+            baseUrl: 'https://test-api.example.com',
+            token: 'my-token',
         });
-        expect(fetchMock).toHaveBeenCalledWith(`${API_BASE}/test`, expect.objectContaining({
-            method: 'POST',
-            body: '{}',
-            headers: expect.objectContaining({
-                Authorization: 'Bearer tok',
-                'Content-Type': 'application/json',
-            }),
-        }));
-        vi.unstubAllGlobals();
-    });
-    it('throws when API returns 401', async () => {
-        const fetchMock = vi.fn().mockResolvedValue({ status: 401, ok: false });
-        vi.stubGlobal('fetch', fetchMock);
-        await expect(tokenFetch('bad-token', '/test')).rejects.toThrow('Authentication failed');
-        vi.unstubAllGlobals();
     });
-    it('returns response for non-401 errors without throwing', async () => {
-        const mockResponse = { status: 500, ok: false, statusText: 'Internal Server Error' };
-        const fetchMock = vi.fn().mockResolvedValue(mockResponse);
-        vi.stubGlobal('fetch', fetchMock);
-        const result = await tokenFetch('tok', '/test');
-        expect(result.status).toBe(500);
-        vi.unstubAllGlobals();
+    it('uses env token when MELTCTL_TOKEN is set', async () => {
+        process.env['MELTCTL_TOKEN'] = 'env-token';
+        await getClient();
+        expect(createMeltClient).toHaveBeenCalledWith({
+            baseUrl: 'https://test-api.example.com',
+            token: 'env-token',
+        });
     });
 });

package/dist/utils/templates.d.ts

@@ -1,4 +1,2 @@
-export interface TemplateFiles {
-    [key: string]: string;
-}
-export declare function fetchTemplates(): Promise<TemplateFiles>;
+export type { TemplateFiles } from '@meltstudio/meltctl-sdk';
+export declare function fetchTemplates(): Promise<Record<string, string>>;