runwork 0.15.0 → 0.15.2

package/dist/api/client.js

@@ -1,427 +0,0 @@
-import { httpFetch } from '../utils/http.js';
-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 || {}).filter(([, v]) => v !== undefined)),
-        };
-        if (this.apiKey) {
-            headers['Authorization'] = `Bearer ${this.apiKey}`;
-        }
-        const response = await httpFetch(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 httpFetch(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 }),
-        });
-    }
-    async searchIntegrations(query, limit = 20, workspaceId) {
-        const params = new URLSearchParams({ q: query, limit: String(limit) });
-        if (workspaceId)
-            params.set('workspaceId', workspaceId);
-        const res = await this.request(`/api/integrations/search?${params}`);
-        return res.data;
-    }
-    async listConnectedIntegrations(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/integrations`);
-        return res.data.integrations;
-    }
-    async getTeamIntegrationUsage(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/integrations/team-usage`);
-        return res.data.usage;
-    }
-    /**
-     * 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.
-     */
-    async getWorkspaceAll(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/all`);
-        return res.data;
-    }
-    getGitRemoteUrl(workspaceId, appId) {
-        return `${this.baseUrl}/api/git/${workspaceId}/${appId}`;
-    }
-    // --- Workspace Chat API (skills & MCP) ---
-    async listWorkspaceSkills(workspaceId, includeContent = false) {
-        const query = includeContent ? '?includeContent=true' : '';
-        const res = await this.request(`/api/workspaces/${workspaceId}/skills${query}`);
-        return res.data.skills;
-    }
-    async listExternalSkills(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/external-skills`);
-        return res.data.skills;
-    }
-    async importExternalSkill(workspaceId, skill) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/external-skills`, { method: 'POST', body: JSON.stringify(skill) });
-        return res.data.skill;
-    }
-    async updateExternalSkill(workspaceId, skillId, skill) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/external-skills/${skillId}`, { method: 'PUT', body: JSON.stringify(skill) });
-        return res.data.skill;
-    }
-    async getAppSkillContent(workspaceId, appId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/apps/${appId}/skill`);
-        return res.data.skill;
-    }
-    async listMcpServers(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/mcp-servers`);
-        return res.data.servers;
-    }
-    async addMcpServer(workspaceId, server) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/mcp-servers`, { method: 'POST', body: JSON.stringify(server) });
-        return res.data.server;
-    }
-    async removeMcpServer(workspaceId, serverId) {
-        await this.request(`/api/workspaces/${workspaceId}/mcp-servers/${serverId}`, { method: 'DELETE' });
-    }
-    /**
-     * Resolve decrypted auth headers for header-auth MCP servers, scoped to the
-     * authenticated user (their own + workspace-wide credentials). Keyed by server id.
-     */
-    async resolveMcpCredentials(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/mcp-credentials/resolved`);
-        return res.data.servers;
-    }
-    // --- Community Marketplace ---
-    async searchCommunitySkills(query, limit = 10, includeContent = false) {
-        const res = await this.request(`/api/community/skills/search?q=${encodeURIComponent(query)}&limit=${limit}&include_content=${includeContent}`);
-        return res.data;
-    }
-    async getCommunitySkillContent(source, skillId) {
-        // source is "owner/repo", keep the slash as a path separator (route is /skills/:owner/:repo/:skillId)
-        const encodedSource = source.split('/').map(encodeURIComponent).join('/');
-        const res = await this.request(`/api/community/skills/${encodedSource}/${encodeURIComponent(skillId)}`);
-        return res.data;
-    }
-    async searchCommunityMcpServers(query, limit = 20) {
-        const res = await this.request(`/api/community/mcp-servers/search?q=${encodeURIComponent(query)}&limit=${limit}`);
-        return res.data;
-    }
-    // --- Workspace Registry: Entities ---
-    async listEntities(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/entities`);
-        return res.data.entities;
-    }
-    async listEntityRecords(workspaceId, entityName, opts) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/list`, {
-            method: 'POST',
-            body: JSON.stringify({
-                limit: opts?.limit,
-                cursor: opts?.cursor,
-                deploymentMode: opts?.deploymentMode,
-            }),
-        });
-        return res.data;
-    }
-    async getEntityRecord(workspaceId, entityName, recordId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/${encodeURIComponent(recordId)}`);
-        return res.data;
-    }
-    async createEntityRecord(workspaceId, entityName, data) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}`, { method: 'POST', body: JSON.stringify({ data }) });
-        return res.data;
-    }
-    async updateEntityRecord(workspaceId, entityName, recordId, data) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/${encodeURIComponent(recordId)}`, { method: 'PUT', body: JSON.stringify({ data }) });
-        return res.data;
-    }
-    async deleteEntityRecord(workspaceId, entityName, recordId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/entities/${encodeURIComponent(entityName)}/${encodeURIComponent(recordId)}`, { method: 'DELETE' });
-        return res.data;
-    }
-    // --- Workspace Registry: Workflows ---
-    async listWorkflows(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/workflows?includeStatus=true`);
-        return res.data.workflows;
-    }
-    async triggerWorkflow(workspaceId, opts) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/workflows/trigger`, { method: 'POST', body: JSON.stringify(opts) });
-        return res.data;
-    }
-    async listWorkflowInstances(workspaceId, appId, opts) {
-        const params = new URLSearchParams({ appId });
-        if (opts?.workflowName)
-            params.set('workflowName', opts.workflowName);
-        if (opts?.status)
-            params.set('status', opts.status);
-        if (opts?.limit)
-            params.set('limit', String(opts.limit));
-        const res = await this.request(`/api/workspaces/${workspaceId}/workflows/instances?${params}`);
-        return res.data;
-    }
-    async getWorkflowInstance(workspaceId, instanceId, appId) {
-        const params = appId ? `?appId=${appId}` : '';
-        const res = await this.request(`/api/workspaces/${workspaceId}/workflows/instances/${encodeURIComponent(instanceId)}${params}`);
-        return res.data;
-    }
-    // --- Workspace Registry: Schedules ---
-    async listSchedules(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/schedules?includeStatus=true`);
-        return res.data.schedules;
-    }
-    async triggerSchedule(workspaceId, opts) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/schedules/trigger`, { method: 'POST', body: JSON.stringify(opts) });
-        return res.data;
-    }
-    async getScheduleHistory(workspaceId, appId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/schedules/history?appId=${appId}`);
-        return res.data;
-    }
-    async getScheduleStatus(workspaceId, appId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/schedules/status?appId=${appId}`);
-        return res.data;
-    }
-    async pauseSchedule(workspaceId, scheduleName, appId) {
-        await this.request(`/api/workspaces/${workspaceId}/schedules/${encodeURIComponent(scheduleName)}/pause?appId=${appId}`, { method: 'POST' });
-    }
-    async resumeSchedule(workspaceId, scheduleName, appId) {
-        await this.request(`/api/workspaces/${workspaceId}/schedules/${encodeURIComponent(scheduleName)}/resume?appId=${appId}`, { method: 'POST' });
-    }
-    // --- Workspace Registry: Endpoints ---
-    async listEndpoints(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/endpoints`);
-        return res.data.endpoints;
-    }
-    // --- Workspace Registry: File Storage ---
-    async listFileStorages(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/file-storages`);
-        return res.data.fileStorages;
-    }
-    async listBucketFiles(workspaceId, bucketName, opts) {
-        const params = new URLSearchParams();
-        if (opts?.prefix)
-            params.set('prefix', opts.prefix);
-        if (opts?.delimiter)
-            params.set('delimiter', opts.delimiter);
-        const query = params.toString();
-        const res = await this.request(`/api/workspaces/${workspaceId}/file-storages/${encodeURIComponent(bucketName)}/files${query ? `?${query}` : ''}`);
-        return res.data;
-    }
-    async getPresignedUrl(workspaceId, bucketName, opts) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/file-storages/${encodeURIComponent(bucketName)}/presign`, { method: 'POST', body: JSON.stringify(opts) });
-        return res.data;
-    }
-    async deleteBucketFile(workspaceId, bucketName, key) {
-        await this.request(`/api/workspaces/${workspaceId}/file-storages/${encodeURIComponent(bucketName)}/files?key=${encodeURIComponent(key)}`, { method: 'DELETE' });
-    }
-    // --- Workspace Registry: Components ---
-    async listComponents(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/components`);
-        return res.data.components;
-    }
-    // --- Workspace Registry: API Keys ---
-    async listApiKeys(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/api-keys`);
-        return res.data.apiKeys;
-    }
-    async createApiKey(workspaceId, opts) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/api-keys`, { method: 'POST', body: JSON.stringify(opts) });
-        return res.data;
-    }
-    // --- Workspace Registry: Agents ---
-    async listAgents(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/agents`);
-        return res.data.agents;
-    }
-    async getAgentStatus(workspaceId, agentName, appId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/agents/status`, { method: 'POST', body: JSON.stringify({ agentName, appId }) });
-        return res.data;
-    }
-    async listAgentExecutions(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/agent-executions`);
-        return res.data.executions;
-    }
-    async getAgentExecutionStream(workspaceId, sessionId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/agent-executions/${encodeURIComponent(sessionId)}/stream`);
-        return res.data.stream;
-    }
-    // --- Team Telemetry ---
-    async getOnboardingConfig(workspaceId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/onboarding-config`);
-        return res.data;
-    }
-    async reportTelemetry(workspaceId, events) {
-        await this.request(`/api/workspaces/${workspaceId}/team/telemetry`, { method: 'POST', body: JSON.stringify({ events }) });
-    }
-    // --- Shared Conversations ---
-    async createSharedConversation(workspaceId, body) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/shared-conversations`, {
-            method: 'POST',
-            body: JSON.stringify(body),
-        });
-        return res.data;
-    }
-    async listSharedConversations(workspaceId, opts) {
-        const search = new URLSearchParams();
-        if (opts?.scope)
-            search.set('scope', opts.scope);
-        if (opts?.limit !== undefined)
-            search.set('limit', String(opts.limit));
-        if (opts?.offset !== undefined)
-            search.set('offset', String(opts.offset));
-        const query = search.toString() ? `?${search.toString()}` : '';
-        const res = await this.request(`/api/workspaces/${workspaceId}/shared-conversations${query}`);
-        return res.data;
-    }
-    async getSharedConversation(workspaceId, shareId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/shared-conversations/${shareId}`);
-        return res.data;
-    }
-    async downloadSharedConversationBundle(workspaceId, shareId, format) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/shared-conversations/${shareId}/bundle/${encodeURIComponent(format)}`);
-        return res.data;
-    }
-    async markSharedConversationResumed(workspaceId, shareId) {
-        const res = await this.request(`/api/workspaces/${workspaceId}/shared-conversations/${shareId}/resumed`, { method: 'POST' });
-        return res.data;
-    }
-    // --- Integrations: Proxy Call ---
-    async callIntegrationProxy(integrationDbId, method, path, opts) {
-        const targetPath = opts?.query ? `${path}?${opts.query}` : path;
-        const url = `${this.baseUrl}/api/proxy/integrations${targetPath}`;
-        const headers = {
-            'X-Workspace-Integration-Id': integrationDbId,
-            ...Object.fromEntries(Object.entries(opts?.headers || {})),
-        };
-        if (this.apiKey) {
-            headers['Authorization'] = `Bearer ${this.apiKey}`;
-        }
-        if (opts?.body) {
-            headers['Content-Type'] = 'application/json';
-        }
-        const response = await httpFetch(url, {
-            method,
-            headers,
-            body: opts?.body ? JSON.stringify(opts.body) : undefined,
-        });
-        if (!response.ok) {
-            const body = await response.text();
-            throw new Error(`Integration proxy error ${response.status}: ${body}`);
-        }
-        const contentType = response.headers.get('content-type') || '';
-        if (contentType.includes('application/json')) {
-            return response.json();
-        }
-        return response.text();
-    }
-}

package/dist/auth/__tests__/login-flow.test.d.ts

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

package/dist/auth/__tests__/login-flow.test.js

@@ -1,101 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock only the side-effect dependencies, not ApiClient
-vi.mock('../store.js', () => ({
-    saveCredentials: vi.fn(),
-}));
-vi.mock('../../git/credentials.js', () => ({
-    configureGitCredentials: vi.fn().mockResolvedValue(undefined),
-}));
-// HTTP goes through our `httpFetch` wrapper (single seam for diagnostics
-// and the optional `curl` transport). Tests mock that wrapper directly so
-// they exercise the same code path the production CLI uses.
-const mockFetch = vi.fn();
-vi.mock('../../utils/http.js', () => ({
-    httpFetch: (...args) => mockFetch(...args),
-}));
-import { saveCredentials } from '../store.js';
-function jsonResponse(data, status = 200) {
-    return {
-        ok: status >= 200 && status < 300,
-        status,
-        statusText: '',
-        url: '',
-        headers: new Headers(),
-        json: () => Promise.resolve(data),
-        text: () => Promise.resolve(JSON.stringify(data)),
-        arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    vi.spyOn(console, 'error').mockImplementation(() => { });
-});
-describe('performLoginNoOpen', () => {
-    it('with printOnly prints URL and returns null without polling', async () => {
-        mockFetch.mockResolvedValue(jsonResponse({
-            data: { sessionId: 'sess-123', loginUrl: 'https://runwork.ai/cli-auth?session=sess-123' },
-        }));
-        const { performLoginNoOpen } = await import('../login-flow.js');
-        const result = await performLoginNoOpen('https://runwork.ai', true);
-        expect(console.log).toHaveBeenCalledWith('https://runwork.ai/cli-auth?session=sess-123');
-        expect(result).toBeNull();
-        expect(saveCredentials).not.toHaveBeenCalled();
-    });
-});
-describe('performLoginWithApiKey', () => {
-    it('validates key by listing workspaces and saves credentials', async () => {
-        mockFetch.mockResolvedValue(jsonResponse({
-            data: [{ id: 'ws-1', name: 'My Workspace' }],
-        }));
-        const { performLoginWithApiKey } = await import('../login-flow.js');
-        const result = await performLoginWithApiKey('rw_test123');
-        expect(saveCredentials).toHaveBeenCalledWith(expect.objectContaining({
-            apiKey: 'rw_test123',
-            defaultWorkspaceId: 'ws-1',
-            defaultWorkspaceName: 'My Workspace',
-        }));
-        expect(result.apiKey).toBe('rw_test123');
-    });
-    it('saves credentials with custom base URL', async () => {
-        mockFetch.mockResolvedValue(jsonResponse({ data: [{ id: 'ws-1', name: 'WS' }] }));
-        const { performLoginWithApiKey } = await import('../login-flow.js');
-        const result = await performLoginWithApiKey('rw_key', 'https://custom.runwork.dev');
-        expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('https://custom.runwork.dev'), expect.anything());
-        expect(result.baseUrl).toBe('https://custom.runwork.dev');
-    });
-    it('handles no workspaces (sets no default)', async () => {
-        mockFetch.mockResolvedValue(jsonResponse({ data: [] }));
-        const { performLoginWithApiKey } = await import('../login-flow.js');
-        const result = await performLoginWithApiKey('rw_key');
-        expect(saveCredentials).toHaveBeenCalledWith(expect.objectContaining({
-            apiKey: 'rw_key',
-            defaultWorkspaceId: undefined,
-            defaultWorkspaceName: undefined,
-        }));
-        expect(result.apiKey).toBe('rw_key');
-    });
-    it('exits on invalid API key', async () => {
-        mockFetch.mockResolvedValue({
-            ok: false,
-            status: 401,
-            statusText: 'Unauthorized',
-            url: '',
-            headers: new Headers(),
-            json: () => Promise.resolve({ error: 'Unauthorized' }),
-            text: () => Promise.resolve('Unauthorized'),
-            arrayBuffer: () => Promise.resolve(new ArrayBuffer(0)),
-        });
-        const mockExit = vi.spyOn(process, 'exit').mockImplementation(((code) => {
-            throw new Error(`process.exit(${code})`);
-        }));
-        try {
-            const { performLoginWithApiKey } = await import('../login-flow.js');
-            await expect(performLoginWithApiKey('bad-key')).rejects.toThrow('process.exit(1)');
-            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('Invalid API key'));
-        }
-        finally {
-            mockExit.mockRestore();
-        }
-    });
-});

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

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

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

@@ -1,132 +0,0 @@
-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 with TTY guidance when invoked from a terminal', () => {
-            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(() => { });
-            const previousTTY = process.stdin.isTTY;
-            Object.defineProperty(process.stdin, 'isTTY', { value: true, configurable: true });
-            try {
-                expect(() => requireAuth()).toThrow('process.exit called');
-                expect(exitSpy).toHaveBeenCalledWith(1);
-                expect(errorSpy).toHaveBeenCalledWith('Not logged in. Run `runwork login` first.');
-            }
-            finally {
-                Object.defineProperty(process.stdin, 'isTTY', { value: previousTTY, configurable: true });
-                exitSpy.mockRestore();
-                errorSpy.mockRestore();
-            }
-        });
-        it('exits process with code 1 with headless guidance when invoked without a TTY', () => {
-            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(() => { });
-            const previousTTY = process.stdin.isTTY;
-            Object.defineProperty(process.stdin, 'isTTY', { value: false, configurable: true });
-            try {
-                expect(() => requireAuth()).toThrow('process.exit called');
-                expect(exitSpy).toHaveBeenCalledWith(1);
-                const message = errorSpy.mock.calls[0]?.[0];
-                expect(message).toContain('Not logged in.');
-                expect(message).toContain('RUNWORK_API_KEY');
-                expect(message).toContain('runwork login --api-key');
-            }
-            finally {
-                Object.defineProperty(process.stdin, 'isTTY', { value: previousTTY, configurable: true });
-                exitSpy.mockRestore();
-                errorSpy.mockRestore();
-            }
-        });
-    });
-});