runwork 0.2.0

package/dist/__tests__/types-manager.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs');
+const mockFs = await import('fs');
+const { populateTypes } = await import('../types-manager.js');
+describe('types-manager', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('populateTypes()', () => {
+        it('creates .runwork/types directory', async () => {
+            // No node_modules, no bundled-types
+            vi.mocked(mockFs.existsSync).mockReturnValue(false);
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            await populateTypes('/project');
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith('/project/.runwork/types', { recursive: true });
+            warnSpy.mockRestore();
+        });
+        it('copies from node_modules when available (Tier 1)', async () => {
+            vi.mocked(mockFs.existsSync).mockImplementation((path) => {
+                if (String(path).includes('node_modules/@runworkai/framework/dist')) {
+                    return true;
+                }
+                return false;
+            });
+            vi.mocked(mockFs.readdirSync).mockReturnValue(['core-utils.d.ts', 'index.d.ts', 'README.md', 'index.js']);
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            await populateTypes('/project');
+            expect(mockFs.readdirSync).toHaveBeenCalledWith('/project/node_modules/@runworkai/framework/dist');
+            expect(logSpy).toHaveBeenCalledWith('Types populated from node_modules/@runworkai/framework');
+            logSpy.mockRestore();
+        });
+        it('copies only .d.ts files, not other files', async () => {
+            vi.mocked(mockFs.existsSync).mockImplementation((path) => {
+                if (String(path).includes('node_modules/@runworkai/framework/dist')) {
+                    return true;
+                }
+                return false;
+            });
+            vi.mocked(mockFs.readdirSync).mockReturnValue(['types.d.ts', 'index.js', 'utils.d.ts', 'readme.md', 'config.json']);
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            await populateTypes('/project');
+            // Only .d.ts files should be copied
+            expect(mockFs.copyFileSync).toHaveBeenCalledTimes(2);
+            expect(mockFs.copyFileSync).toHaveBeenCalledWith('/project/node_modules/@runworkai/framework/dist/types.d.ts', '/project/.runwork/types/types.d.ts');
+            expect(mockFs.copyFileSync).toHaveBeenCalledWith('/project/node_modules/@runworkai/framework/dist/utils.d.ts', '/project/.runwork/types/utils.d.ts');
+            logSpy.mockRestore();
+        });
+        it('falls back to bundled types (Tier 3) when node_modules unavailable', async () => {
+            vi.mocked(mockFs.existsSync).mockImplementation((path) => {
+                if (String(path).includes('bundled-types')) {
+                    return true;
+                }
+                return false;
+            });
+            vi.mocked(mockFs.readdirSync).mockReturnValue(['framework.d.ts']);
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            await populateTypes('/project');
+            // Should have called readdirSync on the bundled-types directory
+            expect(mockFs.readdirSync).toHaveBeenCalled();
+            expect(mockFs.copyFileSync).toHaveBeenCalledTimes(1);
+            expect(logSpy).toHaveBeenCalledWith('Types populated from bundled types');
+            logSpy.mockRestore();
+        });
+        it('warns when no types found at all', async () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(false);
+            const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+            await populateTypes('/project');
+            expect(warnSpy).toHaveBeenCalledWith('No type definitions found. Install @runworkai/framework or reinstall the CLI.');
+            warnSpy.mockRestore();
+        });
+        it('does not copy non-.d.ts files in bundled types fallback', async () => {
+            vi.mocked(mockFs.existsSync).mockImplementation((path) => {
+                if (String(path).includes('bundled-types')) {
+                    return true;
+                }
+                return false;
+            });
+            vi.mocked(mockFs.readdirSync).mockReturnValue(['types.d.ts', 'package.json', 'index.js']);
+            const logSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            await populateTypes('/project');
+            expect(mockFs.copyFileSync).toHaveBeenCalledTimes(1);
+            logSpy.mockRestore();
+        });
+    });
+});

package/dist/api/__tests__/client.test.d.ts

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

package/dist/api/__tests__/client.test.js

@@ -0,0 +1,264 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { ApiClient } from '../client.js';
+const mockFetch = vi.fn();
+globalThis.fetch = mockFetch;
+function createJsonResponse(data, status = 200) {
+    return {
+        ok: status >= 200 && status < 300,
+        status,
+        json: () => Promise.resolve(data),
+        text: () => Promise.resolve(JSON.stringify(data)),
+        arrayBuffer: () => Promise.resolve(new ArrayBuffer(8)),
+    };
+}
+const defaultCreds = {
+    apiKey: 'test-key-abc',
+    email: 'user@test.com',
+    baseUrl: 'https://custom.runwork.dev',
+};
+describe('ApiClient', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('constructor', () => {
+        it('uses default base URL when baseUrl is empty', () => {
+            const client = new ApiClient({
+                apiKey: 'key',
+                email: 'e@e.com',
+                baseUrl: '',
+            });
+            // Verify by calling a method and checking the URL
+            mockFetch.mockResolvedValue(createJsonResponse({ data: [] }));
+            client.listWorkspaces();
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('https://runwork.ai'), expect.anything());
+        });
+        it('uses custom base URL when provided', () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: [] }));
+            client.listWorkspaces();
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('https://custom.runwork.dev'), expect.anything());
+        });
+        it('uses provided API key for authorization', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: [] }));
+            await client.listWorkspaces();
+            const callArgs = mockFetch.mock.calls[0];
+            expect(callArgs[1].headers['Authorization']).toBe('Bearer test-key-abc');
+        });
+    });
+    describe('request() - via methods', () => {
+        it('adds Authorization header when API key is set', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: [] }));
+            await client.listWorkspaces();
+            const headers = mockFetch.mock.calls[0][1].headers;
+            expect(headers['Authorization']).toBe('Bearer test-key-abc');
+        });
+        it('omits Authorization header when API key is empty', async () => {
+            const client = new ApiClient({
+                apiKey: '',
+                email: 'e@e.com',
+                baseUrl: 'https://runwork.ai',
+            });
+            mockFetch.mockResolvedValue(createJsonResponse({ data: [] }));
+            await client.listWorkspaces();
+            const headers = mockFetch.mock.calls[0][1].headers;
+            expect(headers['Authorization']).toBeUndefined();
+        });
+        it('throws on non-ok response with status and body', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ error: 'forbidden' }, 403));
+            await expect(client.listWorkspaces()).rejects.toThrow('API error 403');
+        });
+    });
+    describe('listWorkspaces()', () => {
+        it('calls correct endpoint and unwraps data', async () => {
+            const workspaces = [{ id: 'ws-1', name: 'My Workspace' }];
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: workspaces }));
+            const result = await client.listWorkspaces();
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/workspaces', expect.anything());
+            expect(result).toEqual(workspaces);
+        });
+    });
+    describe('listApps()', () => {
+        it('calls correct endpoint without workspace filter', async () => {
+            const apps = [{ id: 'app-1', name: 'App' }];
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: apps }));
+            const result = await client.listApps();
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/apps', expect.anything());
+            expect(result).toEqual(apps);
+        });
+        it('includes workspaceId query param when provided', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: [] }));
+            await client.listApps('ws-123');
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/apps?workspaceId=ws-123', expect.anything());
+        });
+    });
+    describe('getApp()', () => {
+        it('calls correct endpoint with appId', async () => {
+            const app = { id: 'app-42', name: 'Test App' };
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: app }));
+            const result = await client.getApp('app-42');
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/apps/app-42', expect.anything());
+            expect(result).toEqual(app);
+        });
+    });
+    describe('initApp()', () => {
+        it('sends POST with correct body', async () => {
+            const app = { id: 'new-app', name: 'New App' };
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: app }));
+            const result = await client.initApp('ws-1', 'New App');
+            const callArgs = mockFetch.mock.calls[0];
+            expect(callArgs[1].method).toBe('POST');
+            expect(JSON.parse(callArgs[1].body)).toEqual({
+                workspaceId: 'ws-1',
+                appName: 'New App',
+            });
+            expect(result).toEqual(app);
+        });
+    });
+    describe('startDevSession()', () => {
+        it('sends POST with appId', async () => {
+            const session = {
+                sessionId: 's-1',
+                previewUrl: 'https://preview.test',
+                appId: 'app-1',
+            };
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: session }));
+            const result = await client.startDevSession('app-1');
+            const callArgs = mockFetch.mock.calls[0];
+            expect(callArgs[1].method).toBe('POST');
+            expect(JSON.parse(callArgs[1].body)).toEqual({ appId: 'app-1' });
+            expect(result).toEqual(session);
+        });
+    });
+    describe('getDevStatus()', () => {
+        it('calls correct endpoint', async () => {
+            const status = {
+                sessionId: 's-1',
+                previewUrl: 'https://preview.test',
+                appId: 'app-99',
+            };
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: status }));
+            const result = await client.getDevStatus('app-99');
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/status/app-99', expect.anything());
+            expect(result).toEqual(status);
+        });
+    });
+    describe('triggerDeploy()', () => {
+        it('sends POST and returns deploymentUrl', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({
+                data: { deploymentUrl: 'https://deployed.test' },
+            }));
+            const result = await client.triggerDeploy('app-1');
+            const callArgs = mockFetch.mock.calls[0];
+            expect(callArgs[0]).toBe('https://custom.runwork.dev/api/dev/deploy/app-1');
+            expect(callArgs[1].method).toBe('POST');
+            expect(result).toEqual({ deploymentUrl: 'https://deployed.test' });
+        });
+    });
+    describe('initiateLogin()', () => {
+        it('sends POST to auth/login', async () => {
+            const loginData = {
+                sessionId: 'sess-123',
+                loginUrl: 'https://runwork.ai/cli-auth?session=sess-123',
+            };
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: loginData }));
+            const result = await client.initiateLogin();
+            const callArgs = mockFetch.mock.calls[0];
+            expect(callArgs[0]).toBe('https://custom.runwork.dev/api/dev/auth/login');
+            expect(callArgs[1].method).toBe('POST');
+            expect(result).toEqual(loginData);
+        });
+    });
+    describe('pollLogin()', () => {
+        it('returns credentials when available', async () => {
+            const creds = {
+                apiKey: 'new-key',
+                email: 'new@test.com',
+                baseUrl: 'https://runwork.ai',
+            };
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ data: creds }));
+            const result = await client.pollLogin('sess-123');
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/auth/poll/sess-123', expect.anything());
+            expect(result).toEqual(creds);
+        });
+        it('returns null on error', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue(createJsonResponse({ error: 'pending' }, 404));
+            const result = await client.pollLogin('sess-123');
+            expect(result).toBeNull();
+        });
+        it('returns null when fetch throws', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockRejectedValue(new Error('network error'));
+            const result = await client.pollLogin('sess-123');
+            expect(result).toBeNull();
+        });
+    });
+    describe('downloadSkeleton()', () => {
+        it('makes raw fetch call to skeleton endpoint', async () => {
+            const client = new ApiClient(defaultCreds);
+            const buffer = new ArrayBuffer(16);
+            mockFetch.mockResolvedValue({
+                ok: true,
+                arrayBuffer: () => Promise.resolve(buffer),
+            });
+            const result = await client.downloadSkeleton();
+            expect(mockFetch).toHaveBeenCalledWith('https://custom.runwork.dev/api/dev/skeleton', expect.objectContaining({
+                headers: expect.objectContaining({
+                    Authorization: 'Bearer test-key-abc',
+                }),
+            }));
+            expect(result).toBe(buffer);
+        });
+        it('throws on non-ok response', async () => {
+            const client = new ApiClient(defaultCreds);
+            mockFetch.mockResolvedValue({
+                ok: false,
+                status: 500,
+            });
+            await expect(client.downloadSkeleton()).rejects.toThrow('Failed to download skeleton: 500');
+        });
+        it('omits Authorization when apiKey is empty', async () => {
+            const client = new ApiClient({
+                apiKey: '',
+                email: 'e@e.com',
+                baseUrl: 'https://runwork.ai',
+            });
+            mockFetch.mockResolvedValue({
+                ok: true,
+                arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
+            });
+            await client.downloadSkeleton();
+            const headers = mockFetch.mock.calls[0][1].headers;
+            expect(headers['Authorization']).toBeUndefined();
+        });
+    });
+    describe('getGitRemoteUrl()', () => {
+        it('returns correct URL format', () => {
+            const client = new ApiClient(defaultCreds);
+            const url = client.getGitRemoteUrl('ws-1', 'app-1');
+            expect(url).toBe('https://custom.runwork.dev/api/git/ws-1/app-1');
+        });
+        it('uses default base URL when none provided', () => {
+            const client = new ApiClient({
+                apiKey: 'key',
+                email: 'e@e.com',
+                baseUrl: '',
+            });
+            const url = client.getGitRemoteUrl('ws-2', 'app-2');
+            expect(url).toBe('https://runwork.ai/api/git/ws-2/app-2');
+        });
+    });
+});

package/dist/api/client.d.ts

@@ -0,0 +1,72 @@
+import type { Credentials, AppInfo, WorkspaceInfo, DevSession } from '../types.js';
+export declare class ApiClient {
+    private baseUrl;
+    private apiKey;
+    constructor(credentials: Credentials);
+    private request;
+    listWorkspaces(): Promise<WorkspaceInfo[]>;
+    listApps(workspaceId?: string): Promise<AppInfo[]>;
+    getApp(appId: string): Promise<AppInfo>;
+    initApp(workspaceId: string, appName: string): Promise<AppInfo>;
+    startDevSession(appId: string): Promise<DevSession>;
+    getDevStatus(appId: string): Promise<DevSession>;
+    triggerDeploy(appId: string): Promise<{
+        deploymentUrl: string;
+    }>;
+    initiateLogin(): Promise<{
+        sessionId: string;
+        loginUrl: string;
+    }>;
+    pollLogin(sessionId: string): Promise<Credentials | null>;
+    getAppSkill(appId: string): Promise<{
+        skill: string;
+        appName: string;
+    }>;
+    getPreviewLogs(appId: string): Promise<{
+        stdout: string;
+        stderr: string;
+    }>;
+    getProductionLogs(appId: string, options?: {
+        limit?: number;
+        level?: string;
+        search?: string;
+        startTime?: string;
+        endTime?: string;
+    }): Promise<{
+        logs: Array<Record<string, unknown>>;
+        pagination?: {
+            total?: number;
+            hasMore?: boolean;
+        };
+    }>;
+    getAppEvents(appId: string, options?: {
+        limit?: number;
+        type?: string;
+        source?: string;
+        before?: string;
+    }): Promise<{
+        events: Array<{
+            id: string;
+            source: string;
+            type: string;
+            content: string;
+            summary?: string;
+            metadata?: Record<string, unknown>;
+            appId?: string;
+            timestamp: string;
+        }>;
+        totalCount: number;
+        hasMore: boolean;
+    }>;
+    downloadSkeleton(): Promise<ArrayBuffer>;
+    syncFiles(appId: string, files: Array<{
+        filePath: string;
+        fileContents: string;
+    }>, deletedFiles?: string[]): Promise<void>;
+    /**
+     * Get git remote URL for an app.
+     * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and
+     * subdomain ({slug}.runwork.ai/api/git/{appId}) formats are supported.
+     */
+    getGitRemoteUrl(workspaceId: string, appId: string): string;
+}

package/dist/api/client.js

@@ -0,0 +1,144 @@
+const DEFAULT_BASE_URL = 'https://runwork.ai';
+export class ApiClient {
+    baseUrl;
+    apiKey;
+    constructor(credentials) {
+        this.baseUrl = credentials.baseUrl || DEFAULT_BASE_URL;
+        this.apiKey = credentials.apiKey;
+    }
+    async request(path, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+            ...Object.fromEntries(Object.entries(options.headers || {})),
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(url, { ...options, headers });
+        if (!response.ok) {
+            const body = await response.text();
+            throw new Error(`API error ${response.status}: ${body}`);
+        }
+        return response.json();
+    }
+    async listWorkspaces() {
+        const res = await this.request('/api/dev/workspaces');
+        return res.data;
+    }
+    async listApps(workspaceId) {
+        const query = workspaceId ? `?workspaceId=${workspaceId}` : '';
+        const res = await this.request(`/api/dev/apps${query}`);
+        return res.data;
+    }
+    async getApp(appId) {
+        const res = await this.request(`/api/dev/apps/${appId}`);
+        return res.data;
+    }
+    async initApp(workspaceId, appName) {
+        const res = await this.request('/api/dev/init', {
+            method: 'POST',
+            body: JSON.stringify({ workspaceId, appName }),
+        });
+        const app = res.data;
+        // Server returns `appName` for init, normalize to `name`
+        if (!app.name && app.appName) {
+            app.name = app.appName;
+        }
+        return app;
+    }
+    async startDevSession(appId) {
+        const res = await this.request('/api/dev/sessions', {
+            method: 'POST',
+            body: JSON.stringify({ appId }),
+        });
+        return res.data;
+    }
+    async getDevStatus(appId) {
+        const res = await this.request(`/api/dev/status/${appId}`);
+        return res.data;
+    }
+    async triggerDeploy(appId) {
+        const res = await this.request(`/api/dev/deploy/${appId}`, {
+            method: 'POST',
+        });
+        return res.data;
+    }
+    async initiateLogin() {
+        const res = await this.request('/api/dev/auth/login', { method: 'POST' });
+        return res.data;
+    }
+    async pollLogin(sessionId) {
+        try {
+            const res = await this.request(`/api/dev/auth/poll/${sessionId}`);
+            return res.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    async getAppSkill(appId) {
+        const res = await this.request(`/api/dev/skill/${appId}`);
+        return res.data;
+    }
+    async getPreviewLogs(appId) {
+        const res = await this.request(`/api/dev/logs/${appId}/preview`);
+        return res.data.logs;
+    }
+    async getProductionLogs(appId, options) {
+        const params = new URLSearchParams();
+        if (options?.limit !== undefined)
+            params.set('limit', String(options.limit));
+        if (options?.level)
+            params.set('level', options.level);
+        if (options?.search)
+            params.set('search', options.search);
+        if (options?.startTime)
+            params.set('startTime', options.startTime);
+        if (options?.endTime)
+            params.set('endTime', options.endTime);
+        const query = params.toString();
+        const res = await this.request(`/api/dev/logs/${appId}/production${query ? `?${query}` : ''}`);
+        return res.data;
+    }
+    async getAppEvents(appId, options) {
+        const params = new URLSearchParams();
+        if (options?.limit !== undefined)
+            params.set('limit', String(options.limit));
+        if (options?.type)
+            params.set('type', options.type);
+        if (options?.source)
+            params.set('source', options.source);
+        if (options?.before)
+            params.set('before', options.before);
+        const query = params.toString();
+        const res = await this.request(`/api/dev/events/${appId}${query ? `?${query}` : ''}`);
+        return res.data;
+    }
+    async downloadSkeleton() {
+        const url = `${this.baseUrl}/api/dev/skeleton`;
+        const headers = {};
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            throw new Error(`Failed to download skeleton: ${response.status}`);
+        }
+        return response.arrayBuffer();
+    }
+    async syncFiles(appId, files, deletedFiles) {
+        await this.request(`/api/dev/sync/${appId}`, {
+            method: 'POST',
+            body: JSON.stringify({ files, deletedFiles }),
+        });
+    }
+    /**
+     * Get git remote URL for an app.
+     * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and
+     * subdomain ({slug}.runwork.ai/api/git/{appId}) formats are supported.
+     */
+    getGitRemoteUrl(workspaceId, appId) {
+        return `${this.baseUrl}/api/git/${workspaceId}/${appId}`;
+    }
+}

package/dist/auth/__tests__/store.test.d.ts

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

package/dist/auth/__tests__/store.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+vi.mock('fs');
+vi.mock('os', () => ({
+    homedir: () => '/tmp/test-runwork-home',
+}));
+const mockFs = await import('fs');
+const { getCredentials, saveCredentials, clearCredentials, requireAuth, } = await import('../store.js');
+const EXPECTED_DIR = '/tmp/test-runwork-home/.runwork';
+const EXPECTED_FILE = '/tmp/test-runwork-home/.runwork/.credentials';
+const validCredentials = {
+    apiKey: 'test-api-key-123',
+    email: 'test@example.com',
+    baseUrl: 'https://runwork.ai',
+};
+describe('auth/store', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('getCredentials()', () => {
+        it('returns null when credentials file does not exist', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(false);
+            const result = getCredentials();
+            expect(result).toBeNull();
+            expect(mockFs.existsSync).toHaveBeenCalledWith(EXPECTED_FILE);
+        });
+        it('returns parsed credentials when file exists with valid JSON', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(true);
+            vi.mocked(mockFs.readFileSync).mockReturnValue(JSON.stringify(validCredentials));
+            const result = getCredentials();
+            expect(result).toEqual(validCredentials);
+            expect(mockFs.readFileSync).toHaveBeenCalledWith(EXPECTED_FILE, 'utf-8');
+        });
+        it('returns null on malformed JSON', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(true);
+            vi.mocked(mockFs.readFileSync).mockReturnValue('not valid json {{{');
+            const result = getCredentials();
+            expect(result).toBeNull();
+        });
+        it('returns null when readFileSync throws', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(true);
+            vi.mocked(mockFs.readFileSync).mockImplementation(() => {
+                throw new Error('EACCES: permission denied');
+            });
+            const result = getCredentials();
+            expect(result).toBeNull();
+        });
+    });
+    describe('saveCredentials()', () => {
+        it('creates the .runwork directory recursively', () => {
+            saveCredentials(validCredentials);
+            expect(mockFs.mkdirSync).toHaveBeenCalledWith(EXPECTED_DIR, {
+                recursive: true,
+            });
+        });
+        it('writes JSON with 0o600 permissions', () => {
+            saveCredentials(validCredentials);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith(EXPECTED_FILE, JSON.stringify(validCredentials, null, 2), { mode: 0o600 });
+        });
+        it('stores the correct credential data', () => {
+            const customCreds = {
+                apiKey: 'custom-key',
+                email: 'custom@test.com',
+                baseUrl: 'https://custom.runwork.dev',
+            };
+            saveCredentials(customCreds);
+            const writtenData = vi.mocked(mockFs.writeFileSync).mock.calls[0][1];
+            const parsed = JSON.parse(writtenData);
+            expect(parsed).toEqual(customCreds);
+        });
+    });
+    describe('clearCredentials()', () => {
+        it('deletes the credentials file when it exists', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(true);
+            clearCredentials();
+            expect(mockFs.unlinkSync).toHaveBeenCalledWith(EXPECTED_FILE);
+        });
+        it('does nothing when credentials file does not exist', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(false);
+            clearCredentials();
+            expect(mockFs.unlinkSync).not.toHaveBeenCalled();
+        });
+    });
+    describe('requireAuth()', () => {
+        it('returns credentials when logged in', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(true);
+            vi.mocked(mockFs.readFileSync).mockReturnValue(JSON.stringify(validCredentials));
+            const result = requireAuth();
+            expect(result).toEqual(validCredentials);
+        });
+        it('exits process with code 1 when not logged in', () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(false);
+            const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
+                throw new Error('process.exit called');
+            }));
+            const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            expect(() => requireAuth()).toThrow('process.exit called');
+            expect(exitSpy).toHaveBeenCalledWith(1);
+            expect(errorSpy).toHaveBeenCalledWith('Not logged in. Run `runwork login` first.');
+            exitSpy.mockRestore();
+            errorSpy.mockRestore();
+        });
+    });
+});

package/dist/auth/browser.d.ts

@@ -0,0 +1,2 @@
+export declare function openBrowserForAuth(_authUrl: string): Promise<void>;
+export declare function startAuthCallbackServer(_port: number): Promise<string>;