runwork 0.5.0 → 0.6.0

package/dist/agents/types.d.ts

@@ -3,12 +3,14 @@ export interface McpServerEntry {
     url: string;
     transport: 'sse' | 'streamable-http';
     headers?: Record<string, string>;
+    description?: string;
 }
 export interface SkillFile {
     name: string;
     filename: string;
     content: string;
     description: string;
+    appId?: string;
 }
 export interface AgentAdapter {
     /** Display name, e.g. "Claude Code" */
@@ -21,13 +23,54 @@ export interface AgentAdapter {
     writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
     /** Write skill files to agent's skills directory */
     writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+    /** Write a minimal Runwork hint to the agent's instruction file (CLAUDE.md, AGENTS.md, etc.) */
+    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
     /** Whether this agent supports skills/commands */
     supportsSkills(): boolean;
     /** Whether this agent supports MCP config at the given scope */
     supportsMcpScope(scope: 'project' | 'user'): boolean;
+    /** Write team-managed instructions (separate marker block from auto-generated hint) */
+    writeTeamInstructions?(instructions: string, scope: 'project' | 'user'): Promise<void>;
+    /** Write agent-specific config overrides from workspace admin (model, permissions) */
+    writeAgentConfig?(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
+    /** Read passive usage stats from local agent files (best-effort, no hooks) */
+    readUsageStats?(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
+    /** Read which skills were used locally since last sync (best-effort) */
+    readSkillUsage?(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
+    /** Get the agent's version string (best-effort) */
+    readVersion?(): Promise<string | null>;
+}
+export interface AgentConfigOverride {
+    extraInstructions?: string;
+    modelPreference?: string;
+    permissionRules?: {
+        allow?: string[];
+        deny?: string[];
+        defaultMode?: string;
+    };
+}
+export interface AgentUsageStats {
+    hasNewActivity: boolean;
+    sessionCount: number;
+    messageCount: number;
+    toolCallCount: number;
+    tokensUsed: number;
+    aiLinesAdded: number;
+    aiLinesRemoved: number;
+    lastActiveAt: string | null;
+    modelsUsed?: string[];
+    mcpToolCount?: number;
+    extra?: Record<string, unknown>;
+}
+export interface SkillUsageEntry {
+    skillName: string;
+    count: number;
+    lastUsedAt: string;
 }
 /** Prefix for MCP server entries managed by runwork */
-export declare const RUNWORK_MCP_PREFIX = "runwork-";
+export declare const RUNWORK_MCP_PREFIX = "Runwork: ";
+/** Legacy prefix used before human-readable names were introduced */
+export declare const RUNWORK_MCP_PREFIX_LEGACY = "runwork-";
 /**
  * Build a SKILL.md file with YAML frontmatter.
  * Ensures the content always has proper frontmatter for agent discovery.

package/dist/agents/types.js

@@ -1,13 +1,20 @@
 /** Prefix for MCP server entries managed by runwork */
-export const RUNWORK_MCP_PREFIX = 'runwork-';
+export const RUNWORK_MCP_PREFIX = 'Runwork: ';
+/** Legacy prefix used before human-readable names were introduced */
+export const RUNWORK_MCP_PREFIX_LEGACY = 'runwork-';
 /**
  * Build a SKILL.md file with YAML frontmatter.
  * Ensures the content always has proper frontmatter for agent discovery.
  */
 export function buildSkillMd(skill) {
-    // If content already has frontmatter, return as-is
+    const description = skill.description || `${skill.name} skill`;
+    // If content already has frontmatter, ensure description is present
     if (skill.content.trimStart().startsWith('---\n')) {
-        return skill.content;
+        const hasDescription = /^description:\s*.+$/m.test(skill.content);
+        if (hasDescription)
+            return skill.content;
+        // Inject description into existing frontmatter
+        return skill.content.replace(/^---\n/, `---\nname: ${skill.name}\ndescription: ${description}\n`);
     }
-    return `---\nname: ${skill.name}\ndescription: ${skill.description}\n---\n\n${skill.content}`;
+    return `---\nname: ${skill.name}\ndescription: ${description}\n---\n\n${skill.content}`;
 }

package/dist/agents/utils/instruction-hint.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Append or replace a Runwork instruction hint in an agent's instruction file.
+ * If the file contains existing Runwork markers, replaces that section.
+ * Otherwise appends the hint at the end.
+ */
+export declare function writeHintToFile(filePath: string, hint: string): void;
+/**
+ * Append or replace team instructions in an agent's instruction file.
+ * Uses separate markers from the auto-generated hint so both coexist.
+ */
+export declare function writeTeamInstructionsToFile(filePath: string, instructions: string): void;

package/dist/agents/utils/instruction-hint.js

@@ -0,0 +1,62 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+const START_MARKER = '<!-- runwork:start -->';
+const END_MARKER = '<!-- runwork:end -->';
+const TEAM_START_MARKER = '<!-- runwork-team:start -->';
+const TEAM_END_MARKER = '<!-- runwork-team:end -->';
+/**
+ * Append or replace a Runwork instruction hint in an agent's instruction file.
+ * If the file contains existing Runwork markers, replaces that section.
+ * Otherwise appends the hint at the end.
+ */
+export function writeHintToFile(filePath, hint) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    let content = '';
+    if (existsSync(filePath)) {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    const startIdx = content.indexOf(START_MARKER);
+    const endIdx = content.indexOf(END_MARKER);
+    if (startIdx >= 0 && endIdx >= 0) {
+        // Replace existing section
+        content = content.substring(0, startIdx) + hint + content.substring(endIdx + END_MARKER.length);
+    }
+    else {
+        // Append with spacing
+        if (content.length > 0 && !content.endsWith('\n')) {
+            content += '\n';
+        }
+        if (content.length > 0) {
+            content += '\n';
+        }
+        content += hint + '\n';
+    }
+    writeFileSync(filePath, content);
+}
+/**
+ * Append or replace team instructions in an agent's instruction file.
+ * Uses separate markers from the auto-generated hint so both coexist.
+ */
+export function writeTeamInstructionsToFile(filePath, instructions) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    let content = '';
+    if (existsSync(filePath)) {
+        content = readFileSync(filePath, 'utf-8');
+    }
+    const block = `${TEAM_START_MARKER}\n${instructions}\n${TEAM_END_MARKER}`;
+    const startIdx = content.indexOf(TEAM_START_MARKER);
+    const endIdx = content.indexOf(TEAM_END_MARKER);
+    if (startIdx >= 0 && endIdx >= 0) {
+        content = content.substring(0, startIdx) + block + content.substring(endIdx + TEAM_END_MARKER.length);
+    }
+    else {
+        if (content.length > 0 && !content.endsWith('\n')) {
+            content += '\n';
+        }
+        if (content.length > 0) {
+            content += '\n';
+        }
+        content += block + '\n';
+    }
+    writeFileSync(filePath, content);
+}

package/dist/agents/utils/json-config.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
 import { dirname } from 'path';
-import { RUNWORK_MCP_PREFIX } from '../types.js';
+import { RUNWORK_MCP_PREFIX, RUNWORK_MCP_PREFIX_LEGACY } from '../types.js';
 /**
  * Read a JSON config file. Returns empty object if file doesn't exist.
  */
@@ -29,9 +29,9 @@ export function writeJsonConfig(filePath, config) {
 export function mergeJsonMcpServers(filePath, servers, topKey) {
     const config = readJsonConfig(filePath);
     const existing = (config[topKey] || {});
-    // Remove all runwork-* entries
+    // Remove all Runwork-managed entries (current and legacy prefixes)
     for (const key of Object.keys(existing)) {
-        if (key.startsWith(RUNWORK_MCP_PREFIX)) {
+        if (key.startsWith(RUNWORK_MCP_PREFIX) || key.startsWith(RUNWORK_MCP_PREFIX_LEGACY)) {
             delete existing[key];
         }
     }

package/dist/agents/windsurf.d.ts

@@ -7,4 +7,6 @@ export declare class WindsurfAdapter implements AgentAdapter {
     supportsSkills(): boolean;
     writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
     writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+    writeTeamInstructions(instructions: string, scope: 'project' | 'user'): Promise<void>;
+    writeInstructionHint(hint: string, scope: 'project' | 'user'): Promise<void>;
 }

package/dist/agents/windsurf.js

@@ -1,10 +1,16 @@
 import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { homedir, platform } from 'os';
-import { execFileSync } from 'child_process';
+import { whichBinary } from '../utils/which.js';
 import { mergeJsonMcpServers } from './utils/json-config.js';
+function getWindsurfDataDir() {
+    if (platform() === 'win32') {
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Codeium', 'windsurf');
+    }
+    return join(homedir(), '.codeium', 'windsurf');
+}
 function getConfigPath() {
-    return join(homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+    return join(getWindsurfDataDir(), 'mcp_config.json');
 }
 export class WindsurfAdapter {
     name = 'Windsurf';
@@ -13,13 +19,7 @@ export class WindsurfAdapter {
         const os = platform();
         if (os === 'darwin' && existsSync('/Applications/Windsurf.app'))
             return true;
-        try {
-            execFileSync('which', ['windsurf'], { stdio: 'pipe' });
-            return true;
-        }
-        catch {
-            return false;
-        }
+        return !!whichBinary('windsurf');
     }
     supportsMcpScope(scope) {
         return scope === 'user';
@@ -47,4 +47,21 @@ export class WindsurfAdapter {
             writeFileSync(join(rulesDir, `${skill.filename}.md`), content);
         }
     }
+    async writeTeamInstructions(instructions, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.windsurf', 'rules', 'runwork-team.md')
+            : join(getWindsurfDataDir(), 'rules', 'runwork-team.md');
+        const content = `---\ntrigger: always_on\ndescription: "Team instructions from Runwork workspace"\n---\n\n${instructions}`;
+        mkdirSync(join(filePath, '..'), { recursive: true });
+        writeFileSync(filePath, content);
+    }
+    async writeInstructionHint(hint, scope) {
+        // Windsurf uses rules files
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.windsurf', 'rules', 'runwork.md')
+            : join(getWindsurfDataDir(), 'rules', 'runwork.md');
+        const content = `---\ntrigger: always\n---\n\n${hint}`;
+        mkdirSync(join(filePath, '..'), { recursive: true });
+        writeFileSync(filePath, content);
+    }
 }

package/dist/api/client.d.ts

@@ -1,4 +1,19 @@
 import type { Credentials, AppInfo, WorkspaceInfo, DevSession, WorkspaceAllData, WorkspaceSkill, ExternalSkillRegistration, McpServerConfig, RegistryEntity, WorkflowInfo, TriggerWorkflowResponse, WorkflowInstancesData, WorkflowInstanceDetailData, ScheduleInfo, TriggerScheduleResponse, ScheduleHistoryData, WorkspaceEndpoint, FileStorageInfo, ListBucketFilesData, ComponentInfo, ApiKeyInfo, ApiKeyCreateResponse, AgentInfo, AgentStatusResponse, AgentExecutionRecord } from '../types.js';
+export interface AgentConfigOverride {
+    extraInstructions?: string;
+    modelPreference?: string;
+    permissionRules?: {
+        allow?: string[];
+        deny?: string[];
+        defaultMode?: string;
+    };
+}
+export interface OnboardingConfigResponse {
+    config: {
+        teamInstructions: string | null;
+        agentConfigs: Record<string, AgentConfigOverride> | null;
+    } | null;
+}
 export declare class ApiClient {
     private baseUrl;
     private apiKey;
@@ -63,11 +78,13 @@ export declare class ApiClient {
         filePath: string;
         fileContents: string;
     }>, deletedFiles?: string[]): Promise<void>;
-    searchIntegrations(query: string, limit?: number): Promise<{
+    searchIntegrations(query: string, limit?: number, workspaceId?: string): Promise<{
         results: Array<{
             id: string;
             name: string;
             provider: string;
+            connectedByUser?: boolean;
+            usedByTeammates?: boolean;
             docs?: {
                 name: string;
                 baseUrl: string;
@@ -85,6 +102,17 @@ export declare class ApiClient {
         status?: string;
         createdAt?: string;
     }>>;
+    getTeamIntegrationUsage(workspaceId: string): Promise<Array<{
+        canonicalId: string;
+        integrationId: string;
+        userCount: number;
+        users: Array<{
+            id: string;
+            name: string;
+            avatarUrl?: string | null;
+        }>;
+        connectedByMe: boolean;
+    }>>;
     /**
      * Get git remote URL for an app.
      * Both canonical ({baseUrl}/api/git/{workspaceId}/{appId}) and
@@ -92,7 +120,7 @@ export declare class ApiClient {
      */
     getWorkspaceAll(workspaceId: string): Promise<WorkspaceAllData>;
     getGitRemoteUrl(workspaceId: string, appId: string): string;
-    listWorkspaceSkills(workspaceId: string): Promise<WorkspaceSkill[]>;
+    listWorkspaceSkills(workspaceId: string, includeContent?: boolean): Promise<WorkspaceSkill[]>;
     listExternalSkills(workspaceId: string): Promise<ExternalSkillRegistration[]>;
     importExternalSkill(workspaceId: string, skill: {
         name: string;
@@ -113,6 +141,54 @@ export declare class ApiClient {
         transport: 'sse' | 'streamable-http';
     }): Promise<McpServerConfig>;
     removeMcpServer(workspaceId: string, serverId: string): Promise<void>;
+    searchCommunitySkills(query: string, limit?: number, includeContent?: boolean): Promise<{
+        query: string;
+        count: number;
+        skills: Array<{
+            id: string;
+            title: string;
+            description: string | null;
+            source: string;
+            refs: {
+                skills_sh: string;
+                github: string;
+                raw: string | null;
+            };
+            install_count: number;
+            relevance_score: number;
+            content: string | null;
+        }>;
+    }>;
+    getCommunitySkillContent(source: string, skillId: string): Promise<{
+        id: string;
+        title: string;
+        description: string | null;
+        source: string;
+        content: string | null;
+        refs: {
+            skills_sh: string;
+            github: string;
+            raw: string | null;
+        };
+        install_count: number;
+    }>;
+    searchCommunityMcpServers(query: string, limit?: number): Promise<{
+        servers: Array<{
+            name: string;
+            description: string;
+            title: string | null;
+            version: string;
+            websiteUrl: string | null;
+            remotes: Array<{
+                type: 'sse' | 'streamable-http';
+                url: string;
+            }>;
+            keywords: string[];
+            publisher: string | null;
+        }>;
+        nextCursor: string | null;
+        count: number;
+    }>;
     listEntities(workspaceId: string): Promise<RegistryEntity[]>;
     listEntityRecords(workspaceId: string, entityName: string, opts?: {
         limit?: number;
@@ -183,6 +259,13 @@ export declare class ApiClient {
     getAgentStatus(workspaceId: string, agentName: string, appId: string): Promise<AgentStatusResponse>;
     listAgentExecutions(workspaceId: string): Promise<AgentExecutionRecord[]>;
     getAgentExecutionStream(workspaceId: string, sessionId: string): Promise<string>;
+    getOnboardingConfig(workspaceId: string): Promise<OnboardingConfigResponse>;
+    reportTelemetry(workspaceId: string, events: Array<{
+        eventType: string;
+        agentSlug?: string;
+        metadata?: Record<string, unknown>;
+        timestamp: string;
+    }>): Promise<void>;
     callIntegrationProxy(integrationDbId: string, method: string, path: string, opts?: {
         body?: unknown;
         headers?: Record<string, string>;

package/dist/api/client.js

@@ -133,8 +133,10 @@ export class ApiClient {
             body: JSON.stringify({ files, deletedFiles }),
         });
     }
-    async searchIntegrations(query, limit = 20) {
+    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;
     }
@@ -142,6 +144,10 @@ export class ApiClient {
         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
@@ -155,36 +161,52 @@ export class ApiClient {
         return `${this.baseUrl}/api/git/${workspaceId}/${appId}`;
     }
     // --- Workspace Chat API (skills & MCP) ---
-    async listWorkspaceSkills(workspaceId) {
-        const res = await this.request(`/api/workspace-chat/${workspaceId}/skills`);
+    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/workspace-chat/${workspaceId}/external-skills`);
+        const res = await this.request(`/api/workspaces/${workspaceId}/external-skills`);
         return res.data.skills;
     }
     async importExternalSkill(workspaceId, skill) {
-        const res = await this.request(`/api/workspace-chat/${workspaceId}/external-skills`, { method: 'POST', body: JSON.stringify(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/workspace-chat/${workspaceId}/external-skills/${skillId}`, { method: 'PUT', body: JSON.stringify(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/workspace-chat/${workspaceId}/apps/${appId}/skill`);
+        const res = await this.request(`/api/workspaces/${workspaceId}/apps/${appId}/skill`);
         return res.data.skill;
     }
     async listMcpServers(workspaceId) {
-        const res = await this.request(`/api/workspace-chat/${workspaceId}/mcp-servers`);
+        const res = await this.request(`/api/workspaces/${workspaceId}/mcp-servers`);
         return res.data.servers;
     }
     async addMcpServer(workspaceId, server) {
-        const res = await this.request(`/api/workspace-chat/${workspaceId}/mcp-servers`, { method: 'POST', body: JSON.stringify(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/workspace-chat/${workspaceId}/mcp-servers/${serverId}`, { method: 'DELETE' });
+        await this.request(`/api/workspaces/${workspaceId}/mcp-servers/${serverId}`, { method: 'DELETE' });
+    }
+    // --- 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) {
@@ -324,6 +346,14 @@ export class ApiClient {
         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 }) });
+    }
     // --- Integrations: Proxy Call ---
     async callIntegrationProxy(integrationDbId, method, path, opts) {
         const targetPath = opts?.query ? `${path}?${opts.query}` : path;

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

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

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

@@ -0,0 +1,125 @@
+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),
+}));
+import { saveCredentials } from '../store.js';
+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 () => {
+        // Mock ApiClient at the instance level via fetch
+        const originalFetch = globalThis.fetch;
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({
+                data: { sessionId: 'sess-123', loginUrl: 'https://runwork.ai/cli-auth?session=sess-123' },
+            }),
+        });
+        globalThis.fetch = mockFetch;
+        try {
+            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();
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+        }
+    });
+});
+describe('performLoginWithApiKey', () => {
+    it('validates key by listing workspaces and saves credentials', async () => {
+        const originalFetch = globalThis.fetch;
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({
+                data: [{ id: 'ws-1', name: 'My Workspace' }],
+            }),
+        });
+        globalThis.fetch = mockFetch;
+        try {
+            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');
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+        }
+    });
+    it('saves credentials with custom base URL', async () => {
+        const originalFetch = globalThis.fetch;
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ data: [{ id: 'ws-1', name: 'WS' }] }),
+        });
+        globalThis.fetch = mockFetch;
+        try {
+            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');
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+        }
+    });
+    it('handles no workspaces (sets no default)', async () => {
+        const originalFetch = globalThis.fetch;
+        const mockFetch = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ data: [] }),
+        });
+        globalThis.fetch = mockFetch;
+        try {
+            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');
+        }
+        finally {
+            globalThis.fetch = originalFetch;
+        }
+    });
+    it('exits on invalid API key', async () => {
+        const originalFetch = globalThis.fetch;
+        globalThis.fetch = vi.fn().mockResolvedValue({
+            ok: false,
+            status: 401,
+            json: () => Promise.resolve({ error: 'Unauthorized' }),
+            text: () => Promise.resolve('Unauthorized'),
+        });
+        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 {
+            globalThis.fetch = originalFetch;
+            mockExit.mockRestore();
+        }
+    });
+});

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

@@ -8,3 +8,19 @@ import type { Credentials } from '../types.js';
  * Returns the credentials on success, exits process on timeout.
  */
 export declare function performLogin(baseUrl?: string): Promise<Credentials>;
+/**
+ * Initiate a login session without opening the browser.
+ * Prints the login URL to stdout and polls for completion.
+ * If printOnly is true, prints the URL and returns null (exits without polling).
+ */
+export declare function performLoginNoOpen(baseUrl?: string, printOnly?: boolean): Promise<Credentials | null>;
+/**
+ * Resume a previously initiated login session by providing the login URL.
+ * Extracts the session ID from the URL and polls until authenticated.
+ */
+export declare function performLoginFromUrl(loginUrl: string): Promise<Credentials>;
+/**
+ * Authenticate directly with an API key (no browser flow).
+ * Validates the key by calling the API, then saves credentials.
+ */
+export declare function performLoginWithApiKey(apiKey: string, baseUrl?: string): Promise<Credentials>;