@meltstudio/meltctl 4.34.0 → 4.36.0

package/dist/commands/coins.test.js

@@ -1,9 +1,17 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('../utils/auth.js', () => ({
     isAuthenticated: vi.fn(),
-    authenticatedFetch: vi.fn(),
 }));
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+const mockClient = vi.hoisted(() => ({
+    coins: {
+        getBalance: vi.fn(),
+        getLeaderboard: vi.fn(),
+    },
+}));
+vi.mock('../utils/api.js', () => ({
+    getClient: vi.fn().mockResolvedValue(mockClient),
+}));
+import { isAuthenticated } from '../utils/auth.js';
 import { coinsCommand } from './coins.js';
 beforeEach(() => {
     vi.clearAllMocks();
@@ -24,23 +32,16 @@ describe('coinsCommand', () => {
         it('displays coin balance on success', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            const mockResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue({ coins: 5, period: '28d' }),
-            };
-            authenticatedFetch.mockResolvedValue(mockResponse);
+            mockClient.coins.getBalance.mockResolvedValue({ coins: 5, period: '28d' });
             await coinsCommand({});
-            expect(authenticatedFetch).toHaveBeenCalledWith('/coins');
+            expect(mockClient.coins.getBalance).toHaveBeenCalled();
             const logCalls = console.log.mock.calls.map((c) => String(c[0]));
             expect(logCalls.some((msg) => msg.includes('5'))).toBe(true);
         });
         it('displays singular coin text for 1 coin', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValue({
-                ok: true,
-                json: vi.fn().mockResolvedValue({ coins: 1, period: '28d' }),
-            });
+            mockClient.coins.getBalance.mockResolvedValue({ coins: 1, period: '28d' });
             await coinsCommand({});
             const logCalls = console.log.mock.calls.map((c) => String(c[0]));
             expect(logCalls.some((msg) => msg.includes('coin') && !msg.includes('coins'))).toBe(true);
@@ -48,10 +49,7 @@ describe('coinsCommand', () => {
         it('displays plural coin text for multiple coins', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValue({
-                ok: true,
-                json: vi.fn().mockResolvedValue({ coins: 3, period: '28d' }),
-            });
+            mockClient.coins.getBalance.mockResolvedValue({ coins: 3, period: '28d' });
             await coinsCommand({});
             const logCalls = console.log.mock.calls.map((c) => String(c[0]));
             expect(logCalls.some((msg) => msg.includes('coins'))).toBe(true);
@@ -59,12 +57,7 @@ describe('coinsCommand', () => {
         it('exits with error when API returns failure', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            const mockResponse = {
-                ok: false,
-                statusText: 'Internal Server Error',
-                json: vi.fn().mockResolvedValue({ error: 'Something went wrong' }),
-            };
-            authenticatedFetch.mockResolvedValue(mockResponse);
+            mockClient.coins.getBalance.mockRejectedValue(new Error('Something went wrong'));
             await expect(coinsCommand({})).rejects.toThrow('process.exit(1)');
             const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
             expect(errorCalls.some((msg) => msg.includes('Something went wrong'))).toBe(true);
@@ -84,12 +77,9 @@ describe('coinsCommand', () => {
                 { name: 'Bob', coins: 7 },
                 { name: 'Charlie', coins: 3 },
             ];
-            authenticatedFetch.mockResolvedValue({
-                ok: true,
-                json: vi.fn().mockResolvedValue(entries),
-            });
+            mockClient.coins.getLeaderboard.mockResolvedValue(entries);
             await coinsCommand({ leaderboard: true });
-            expect(authenticatedFetch).toHaveBeenCalledWith('/coins/leaderboard');
+            expect(mockClient.coins.getLeaderboard).toHaveBeenCalled();
             const logCalls = console.log.mock.calls.map((c) => String(c[0]));
             expect(logCalls.some((msg) => msg.includes('Leaderboard'))).toBe(true);
             expect(logCalls.some((msg) => msg.includes('Alice'))).toBe(true);
@@ -98,10 +88,7 @@ describe('coinsCommand', () => {
         it('shows message when no coins have been sent', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValue({
-                ok: true,
-                json: vi.fn().mockResolvedValue([]),
-            });
+            mockClient.coins.getLeaderboard.mockResolvedValue([]);
             await coinsCommand({ leaderboard: true });
             const logCalls = console.log.mock.calls.map((c) => String(c[0]));
             expect(logCalls.some((msg) => msg.includes('No coins'))).toBe(true);
@@ -109,25 +96,18 @@ describe('coinsCommand', () => {
         it('exits with error when leaderboard API fails', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValue({
-                ok: false,
-                statusText: 'Forbidden',
-                json: vi.fn().mockResolvedValue({ error: 'Access denied' }),
-            });
+            mockClient.coins.getLeaderboard.mockRejectedValue(new Error('Access denied'));
             await expect(coinsCommand({ leaderboard: true })).rejects.toThrow('process.exit(1)');
             const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
             expect(errorCalls.some((msg) => msg.includes('Access denied'))).toBe(true);
         });
-        it('calls /coins/leaderboard endpoint not /coins', async () => {
+        it('calls getLeaderboard not getBalance', async () => {
             ;
             isAuthenticated.mockResolvedValue(true);
-            authenticatedFetch.mockResolvedValue({
-                ok: true,
-                json: vi.fn().mockResolvedValue([{ name: 'Test', coins: 1 }]),
-            });
+            mockClient.coins.getLeaderboard.mockResolvedValue([{ name: 'Test', coins: 1 }]);
             await coinsCommand({ leaderboard: true });
-            expect(authenticatedFetch).toHaveBeenCalledWith('/coins/leaderboard');
-            expect(authenticatedFetch).not.toHaveBeenCalledWith('/coins');
+            expect(mockClient.coins.getLeaderboard).toHaveBeenCalled();
+            expect(mockClient.coins.getBalance).not.toHaveBeenCalled();
         });
     });
 });

package/dist/commands/feedback.js

@@ -1,6 +1,7 @@
 import chalk from 'chalk';
 import { input, select, editor } from '@inquirer/prompts';
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { isAuthenticated } from '../utils/auth.js';
+import { getClient } from '../utils/api.js';
 const EDITOR_HINT = chalk.dim('(type \\\\e to open your editor)');
 async function promptDescription() {
     const value = await input({
@@ -35,6 +36,7 @@ export async function feedbackCommand(options) {
         console.error(chalk.red('Not authenticated. Run `npx @meltstudio/meltctl@latest login` first.'));
         process.exit(1);
     }
+    const client = await getClient();
     let toUserId;
     let coins;
     let description;
@@ -49,13 +51,7 @@ export async function feedbackCommand(options) {
         // Fetch recipients
         let recipients;
         try {
-            const res = await authenticatedFetch('/feedback/recipients');
-            if (!res.ok) {
-                const body = (await res.json());
-                console.error(chalk.red(`Failed to load recipients: ${body.error ?? res.statusText}`));
-                process.exit(1);
-            }
-            recipients = (await res.json());
+            recipients = await client.feedback.getRecipients();
         }
         catch {
             console.error(chalk.red('Failed to connect to the server.'));
@@ -83,17 +79,12 @@ export async function feedbackCommand(options) {
         });
         description = await promptDescription();
     }
-    const res = await authenticatedFetch('/feedback', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ toUserId, coins, description }),
-    });
-    if (res.ok) {
+    try {
+        await client.feedback.submit({ toUserId, coins, description });
         console.log(chalk.green(`\n  ✓ Feedback sent! You gave ${coins} coin${coins > 1 ? 's' : ''}.\n`));
     }
-    else {
-        const body = (await res.json());
-        console.error(chalk.red(`\nFailed to send feedback: ${body.error ?? res.statusText}`));
+    catch (error) {
+        console.error(chalk.red(`\nFailed to send feedback: ${error instanceof Error ? error.message : 'Unknown error'}`));
         process.exit(1);
     }
 }

package/dist/commands/feedback.test.js

@@ -1,14 +1,22 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('../utils/auth.js', () => ({
     isAuthenticated: vi.fn(),
-    authenticatedFetch: vi.fn(),
+}));
+const mockClient = vi.hoisted(() => ({
+    feedback: {
+        submit: vi.fn(),
+        getRecipients: vi.fn(),
+    },
+}));
+vi.mock('../utils/api.js', () => ({
+    getClient: vi.fn().mockResolvedValue(mockClient),
 }));
 vi.mock('@inquirer/prompts', () => ({
     input: vi.fn(),
     select: vi.fn(),
     editor: vi.fn(),
 }));
-import { isAuthenticated, authenticatedFetch } from '../utils/auth.js';
+import { isAuthenticated } from '../utils/auth.js';
 import { input, select } from '@inquirer/prompts';
 import { feedbackCommand } from './feedback.js';
 beforeEach(() => {
@@ -29,24 +37,16 @@ describe('feedbackCommand', () => {
     it('submits feedback with correct payload using option flags', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const submitResponse = {
-            ok: true,
-            json: vi.fn().mockResolvedValue({}),
-        };
-        authenticatedFetch.mockResolvedValue(submitResponse);
+        mockClient.feedback.submit.mockResolvedValue({});
         await feedbackCommand({
             to: '42',
             coins: '2',
             description: 'Great job on the feature implementation!',
         });
-        expect(authenticatedFetch).toHaveBeenCalledWith('/feedback', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                toUserId: 42,
-                coins: 2,
-                description: 'Great job on the feature implementation!',
-            }),
+        expect(mockClient.feedback.submit).toHaveBeenCalledWith({
+            toUserId: 42,
+            coins: 2,
+            description: 'Great job on the feature implementation!',
         });
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('Feedback sent'))).toBe(true);
@@ -54,10 +54,7 @@ describe('feedbackCommand', () => {
     it('displays singular coin text when sending 1 coin', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        authenticatedFetch.mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue({}),
-        });
+        mockClient.feedback.submit.mockResolvedValue({});
         await feedbackCommand({ to: '1', coins: '1', description: 'Nice work' });
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('1 coin') && !msg.includes('1 coins'))).toBe(true);
@@ -65,10 +62,7 @@ describe('feedbackCommand', () => {
     it('displays plural coin text when sending multiple coins', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        authenticatedFetch.mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue({}),
-        });
+        mockClient.feedback.submit.mockResolvedValue({});
         await feedbackCommand({ to: '1', coins: '3', description: 'Excellent work' });
         const logCalls = console.log.mock.calls.map((c) => String(c[0]));
         expect(logCalls.some((msg) => msg.includes('3 coins'))).toBe(true);
@@ -76,12 +70,7 @@ describe('feedbackCommand', () => {
     it('exits with error when API returns failure', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const submitResponse = {
-            ok: false,
-            statusText: 'Bad Request',
-            json: vi.fn().mockResolvedValue({ error: 'Insufficient coins' }),
-        };
-        authenticatedFetch.mockResolvedValue(submitResponse);
+        mockClient.feedback.submit.mockRejectedValue(new Error('Insufficient coins'));
         await expect(feedbackCommand({ to: '42', coins: '2', description: 'Good work' })).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Insufficient coins'))).toBe(true);
@@ -89,12 +78,7 @@ describe('feedbackCommand', () => {
     it('exits with error when API returns failure without error body', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        const submitResponse = {
-            ok: false,
-            statusText: 'Internal Server Error',
-            json: vi.fn().mockResolvedValue({}),
-        };
-        authenticatedFetch.mockResolvedValue(submitResponse);
+        mockClient.feedback.submit.mockRejectedValue(new Error('Internal Server Error'));
         await expect(feedbackCommand({ to: '42', coins: '2', description: 'Good work' })).rejects.toThrow('process.exit(1)');
         const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
         expect(errorCalls.some((msg) => msg.includes('Internal Server Error'))).toBe(true);
@@ -102,20 +86,13 @@ describe('feedbackCommand', () => {
     it('sends correct numeric types in payload', async () => {
         ;
         isAuthenticated.mockResolvedValue(true);
-        authenticatedFetch.mockResolvedValue({
-            ok: true,
-            json: vi.fn().mockResolvedValue({}),
-        });
+        mockClient.feedback.submit.mockResolvedValue({});
         await feedbackCommand({ to: '7', coins: '3', description: 'Awesome' });
-        const call = authenticatedFetch.mock.calls[0];
-        const body = JSON.parse(call[1].body);
-        expect(body).toEqual({
+        expect(mockClient.feedback.submit).toHaveBeenCalledWith({
             toUserId: 7,
             coins: 3,
             description: 'Awesome',
         });
-        expect(typeof body.toUserId).toBe('number');
-        expect(typeof body.coins).toBe('number');
     });
     describe('interactive flow', () => {
         const mockRecipients = [
@@ -128,73 +105,45 @@ describe('feedbackCommand', () => {
         }
         it('prompts for recipient, coins, and description in interactive mode', async () => {
             setupInteractiveMocks();
-            const recipientsResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue(mockRecipients),
-            };
-            const submitResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue({}),
-            };
-            authenticatedFetch
-                .mockResolvedValueOnce(recipientsResponse)
-                .mockResolvedValueOnce(submitResponse);
+            mockClient.feedback.getRecipients.mockResolvedValue(mockRecipients);
+            mockClient.feedback.submit.mockResolvedValue({});
             select.mockResolvedValueOnce(1).mockResolvedValueOnce(2);
             input.mockResolvedValueOnce('This is a great piece of feedback that is long enough to pass validation easily.');
             await feedbackCommand({});
-            expect(authenticatedFetch).toHaveBeenCalledWith('/feedback/recipients');
+            expect(mockClient.feedback.getRecipients).toHaveBeenCalled();
             expect(select).toHaveBeenCalledTimes(2);
             expect(input).toHaveBeenCalledTimes(1);
-            expect(authenticatedFetch).toHaveBeenCalledWith('/feedback', expect.objectContaining({
-                method: 'POST',
-                body: expect.stringContaining('"toUserId":1'),
+            expect(mockClient.feedback.submit).toHaveBeenCalledWith(expect.objectContaining({
+                toUserId: 1,
             }));
         });
         it('shows no recipients message when list is empty', async () => {
             setupInteractiveMocks();
-            const recipientsResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue([]),
-            };
-            authenticatedFetch.mockResolvedValueOnce(recipientsResponse);
+            mockClient.feedback.getRecipients.mockResolvedValue([]);
             await feedbackCommand({});
             const logCalls = console.log.mock.calls.map((c) => String(c[0]));
             expect(logCalls.some((msg) => msg.includes('No recipients'))).toBe(true);
-            // Should not call POST /feedback
-            expect(authenticatedFetch).toHaveBeenCalledTimes(1);
+            // Should not call submit
+            expect(mockClient.feedback.submit).not.toHaveBeenCalled();
         });
         it('exits with error when recipients API fails', async () => {
             setupInteractiveMocks();
-            const recipientsResponse = {
-                ok: false,
-                statusText: 'Forbidden',
-                json: vi.fn().mockResolvedValue({ error: 'Not allowed' }),
-            };
-            authenticatedFetch.mockResolvedValueOnce(recipientsResponse);
+            mockClient.feedback.getRecipients.mockRejectedValue(new Error('Not allowed'));
             await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
             const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Not allowed'))).toBe(true);
+            expect(errorCalls.some((msg) => msg.includes('Failed to connect'))).toBe(true);
         });
         it('exits with error when recipients fetch throws network error', async () => {
             setupInteractiveMocks();
-            authenticatedFetch.mockRejectedValueOnce(new Error('Network error'));
+            mockClient.feedback.getRecipients.mockRejectedValue(new Error('Network error'));
             await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
             const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
             expect(errorCalls.some((msg) => msg.includes('Failed to connect'))).toBe(true);
         });
         it('re-prompts when description is too short', async () => {
             setupInteractiveMocks();
-            const recipientsResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue(mockRecipients),
-            };
-            const submitResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue({}),
-            };
-            authenticatedFetch
-                .mockResolvedValueOnce(recipientsResponse)
-                .mockResolvedValueOnce(submitResponse);
+            mockClient.feedback.getRecipients.mockResolvedValue(mockRecipients);
+            mockClient.feedback.submit.mockResolvedValue({});
             select.mockResolvedValueOnce(2).mockResolvedValueOnce(3);
             input
                 .mockResolvedValueOnce('Too short')
@@ -206,17 +155,8 @@ describe('feedbackCommand', () => {
         });
         it('re-prompts when description is too long', async () => {
             setupInteractiveMocks();
-            const recipientsResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue(mockRecipients),
-            };
-            const submitResponse = {
-                ok: true,
-                json: vi.fn().mockResolvedValue({}),
-            };
-            authenticatedFetch
-                .mockResolvedValueOnce(recipientsResponse)
-                .mockResolvedValueOnce(submitResponse);
+            mockClient.feedback.getRecipients.mockResolvedValue(mockRecipients);
+            mockClient.feedback.submit.mockResolvedValue({});
             select.mockResolvedValueOnce(1).mockResolvedValueOnce(1);
             input
                 .mockResolvedValueOnce('x'.repeat(501))
@@ -228,15 +168,10 @@ describe('feedbackCommand', () => {
         });
         it('falls back to recipients error statusText when no error body', async () => {
             setupInteractiveMocks();
-            const recipientsResponse = {
-                ok: false,
-                statusText: 'Service Unavailable',
-                json: vi.fn().mockResolvedValue({}),
-            };
-            authenticatedFetch.mockResolvedValueOnce(recipientsResponse);
+            mockClient.feedback.getRecipients.mockRejectedValue(new Error('Service Unavailable'));
             await expect(feedbackCommand({})).rejects.toThrow('process.exit(1)');
             const errorCalls = console.error.mock.calls.map((c) => String(c[0]));
-            expect(errorCalls.some((msg) => msg.includes('Service Unavailable'))).toBe(true);
+            expect(errorCalls.some((msg) => msg.includes('Failed to connect'))).toBe(true);
         });
     });
 });

package/dist/commands/login.js

@@ -2,6 +2,7 @@ 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;
@@ -70,26 +71,20 @@ export async function loginCommand() {
         });
     });
     console.log(chalk.dim('Exchanging authorization code...'));
-    const response = await fetch(`${API_BASE}/auth/token`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ code: authCode, redirect_uri: redirectUri }),
-    });
-    if (!response.ok) {
-        const error = (await response.json());
-        if (response.status === 403) {
-            console.error(chalk.red('Only @meltstudio.co accounts can use this tool.'));
-            process.exit(1);
-        }
-        console.error(chalk.red(`Authentication failed: ${error.error ?? 'Unknown error'}`));
+    // 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);
     }
-    const data = (await response.json());
-    await storeAuth({
-        token: data.token,
-        email: data.email,
-        expiresAt: data.expiresAt,
-    });
-    console.log();
-    console.log(chalk.green(`Logged in as ${data.email}`));
 }

package/dist/commands/plan.js

@@ -1,7 +1,7 @@
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import path from 'path';
-import { getToken, tokenFetch } from '../utils/api.js';
+import { getClient } from '../utils/api.js';
 import { getGitBranch, getGitCommit, getGitRepository, getProjectName, extractTicketId, findMdFiles, } from '../utils/git.js';
 function extractFrontmatterStatus(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
@@ -29,7 +29,7 @@ async function autoDetectPlanFile() {
     return mdFiles[0] ?? null;
 }
 export async function planSubmitCommand(file) {
-    const token = await getToken();
+    const client = await getClient();
     let filePath;
     if (file) {
         filePath = path.resolve(file);
@@ -55,38 +55,23 @@ export async function planSubmitCommand(file) {
     const repo = getGitRepository();
     const ticket = extractTicketId(branch) ?? extractTicketId(filename);
     const status = extractFrontmatterStatus(content);
-    const payload = {
-        project,
-        repository: repo?.slug ?? null,
-        repositoryUrl: repo?.url ?? null,
-        branch,
-        commit,
-        content,
-        metadata: { filename },
-    };
-    if (ticket)
-        payload.ticket = ticket;
-    if (status)
-        payload.status = status;
     try {
-        const res = await tokenFetch(token, '/plans', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(payload),
+        const result = await client.plans.submit({
+            project,
+            repository: repo?.slug ?? null,
+            repositoryUrl: repo?.url ?? null,
+            branch,
+            commit,
+            content,
+            ticket: ticket ?? null,
+            status: status ?? null,
+            metadata: { filename },
         });
-        if (res.ok) {
-            const body = (await res.json());
-            if (body.created) {
-                console.log(chalk.green(`\n  ✓ Plan submitted! ID: ${body.id}\n`));
-            }
-            else {
-                console.log(chalk.green(`\n  ✓ Plan updated! ID: ${body.id}\n`));
-            }
+        if (result.created) {
+            console.log(chalk.green(`\n  ✓ Plan submitted! ID: ${result.id}\n`));
         }
         else {
-            const body = (await res.json());
-            console.error(chalk.red(`\nFailed to submit plan: ${body.error ?? res.statusText}`));
-            process.exit(1);
+            console.log(chalk.green(`\n  ✓ Plan updated! ID: ${result.id}\n`));
         }
     }
     catch (error) {
@@ -95,28 +80,13 @@ export async function planSubmitCommand(file) {
     }
 }
 export async function planListCommand(options) {
-    const token = await getToken();
-    const params = new URLSearchParams();
-    if (options.repository)
-        params.set('repository', options.repository);
-    if (options.author)
-        params.set('author', options.author);
-    if (options.limit)
-        params.set('limit', options.limit);
-    const query = params.toString();
-    const urlPath = `/plans${query ? `?${query}` : ''}`;
+    const client = await getClient();
     try {
-        const res = await tokenFetch(token, urlPath);
-        if (res.status === 403) {
-            console.error(chalk.red('Access denied. Only Team Managers can list plans.'));
-            process.exit(1);
-        }
-        if (!res.ok) {
-            const body = (await res.json());
-            console.error(chalk.red(`Failed to list plans: ${body.error ?? res.statusText}`));
-            process.exit(1);
-        }
-        const body = (await res.json());
+        const body = await client.plans.list({
+            repository: options.repository,
+            author: options.author,
+            limit: options.limit ? parseInt(options.limit, 10) : undefined,
+        });
         if (body.plans.length === 0) {
             console.log(chalk.dim('\n  No plans found.\n'));
             return;