runwork 0.4.1 → 0.5.0

package/dist/agents/copilot-cli.js

@@ -0,0 +1,46 @@
+import { execFileSync } from 'child_process';
+import { join } from 'path';
+import { homedir } from 'os';
+import { mergeJsonMcpServers } from './utils/json-config.js';
+export class CopilotCliAdapter {
+    name = 'GitHub Copilot CLI';
+    slug = 'copilot-cli';
+    async detect() {
+        try {
+            execFileSync('which', ['copilot'], { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            try {
+                execFileSync('gh', ['copilot', '--version'], { stdio: 'pipe' });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    supportsMcpScope(_scope) {
+        return true;
+    }
+    supportsSkills() {
+        return false;
+    }
+    async writeMcpServers(servers, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.copilot', 'mcp-config.json')
+            : join(homedir(), '.copilot', 'mcp-config.json');
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                type: 'http',
+                url: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(filePath, entries, 'mcpServers');
+    }
+    async writeSkills(_skills, _scope) {
+        // Not supported
+    }
+}

package/dist/agents/copilot-vscode.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class CopilotVscodeAdapter implements AgentAdapter {
+    name: string;
+    slug: string;
+    detect(): Promise<boolean>;
+    supportsMcpScope(scope: 'project' | 'user'): boolean;
+    supportsSkills(): boolean;
+    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
+    writeSkills(_skills: SkillFile[], _scope: 'project' | 'user'): Promise<void>;
+}

package/dist/agents/copilot-vscode.js

@@ -0,0 +1,37 @@
+import { execFileSync } from 'child_process';
+import { join } from 'path';
+import { mergeJsonMcpServers } from './utils/json-config.js';
+export class CopilotVscodeAdapter {
+    name = 'GitHub Copilot (VS Code)';
+    slug = 'copilot-vscode';
+    async detect() {
+        try {
+            const output = execFileSync('code', ['--list-extensions'], { stdio: 'pipe', encoding: 'utf-8' });
+            return output.includes('GitHub.copilot');
+        }
+        catch {
+            return false;
+        }
+    }
+    supportsMcpScope(scope) {
+        return scope === 'project';
+    }
+    supportsSkills() {
+        return false;
+    }
+    async writeMcpServers(servers, _scope) {
+        const filePath = join(process.cwd(), '.vscode', 'mcp.json');
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                type: 'http',
+                url: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(filePath, entries, 'servers');
+    }
+    async writeSkills(_skills, _scope) {
+        // Not supported
+    }
+}

package/dist/agents/cursor.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class CursorAdapter implements AgentAdapter {
+    name: string;
+    slug: string;
+    detect(): Promise<boolean>;
+    supportsMcpScope(_scope: 'project' | 'user'): boolean;
+    supportsSkills(): boolean;
+    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
+    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+}

package/dist/agents/cursor.js

@@ -0,0 +1,55 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { execFileSync } from 'child_process';
+import { mergeJsonMcpServers } from './utils/json-config.js';
+export class CursorAdapter {
+    name = 'Cursor';
+    slug = 'cursor';
+    async detect() {
+        const os = platform();
+        if (os === 'darwin' && existsSync('/Applications/Cursor.app'))
+            return true;
+        try {
+            execFileSync('which', ['cursor'], { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    supportsMcpScope(_scope) {
+        return true;
+    }
+    supportsSkills() {
+        return true;
+    }
+    async writeMcpServers(servers, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.cursor', 'mcp.json')
+            : join(homedir(), '.cursor', 'mcp.json');
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                url: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(filePath, entries, 'mcpServers');
+    }
+    async writeSkills(skills, scope) {
+        if (scope === 'user')
+            return;
+        const rulesDir = join(process.cwd(), '.cursor', 'rules');
+        mkdirSync(rulesDir, { recursive: true });
+        for (const skill of skills) {
+            const mdcContent = `---
+description: "${skill.description}"
+alwaysApply: false
+---
+
+${skill.content}`;
+            writeFileSync(join(rulesDir, `${skill.filename}.mdc`), mdcContent);
+        }
+    }
+}

package/dist/agents/detect.d.ts

@@ -0,0 +1,4 @@
+import type { AgentAdapter } from './types.js';
+export declare function detectAgents(): Promise<AgentAdapter[]>;
+export declare function getAdapterBySlug(slug: string): AgentAdapter | undefined;
+export declare function printNoAgentsMessage(): void;

package/dist/agents/detect.js

@@ -0,0 +1,43 @@
+import { ClaudeCodeAdapter } from './claude-code.js';
+import { ClaudeDesktopAdapter } from './claude-desktop.js';
+import { CursorAdapter } from './cursor.js';
+import { CodexAdapter } from './codex.js';
+import { WindsurfAdapter } from './windsurf.js';
+import { CopilotVscodeAdapter } from './copilot-vscode.js';
+import { CopilotCliAdapter } from './copilot-cli.js';
+import { GeminiAdapter } from './gemini.js';
+const ALL_ADAPTERS = [
+    new ClaudeCodeAdapter(),
+    new ClaudeDesktopAdapter(),
+    new CursorAdapter(),
+    new CodexAdapter(),
+    new WindsurfAdapter(),
+    new CopilotVscodeAdapter(),
+    new CopilotCliAdapter(),
+    new GeminiAdapter(),
+];
+export async function detectAgents() {
+    const results = await Promise.all(ALL_ADAPTERS.map(async (adapter) => {
+        try {
+            const detected = await adapter.detect();
+            return detected ? adapter : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return results.filter((a) => a !== null);
+}
+export function getAdapterBySlug(slug) {
+    return ALL_ADAPTERS.find(a => a.slug === slug);
+}
+export function printNoAgentsMessage() {
+    console.log('No supported AI coding agents detected.\n');
+    console.log('Install one to get started:\n');
+    console.log('  Claude Code:  npm i -g @anthropic-ai/claude-code');
+    console.log('  Cursor:       https://cursor.com');
+    console.log('  Codex CLI:    npm i -g @openai/codex');
+    console.log('  Gemini CLI:   https://github.com/google-gemini/gemini-cli');
+    console.log('  Windsurf:     https://windsurf.com');
+    console.log('');
+}

package/dist/agents/gemini.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class GeminiAdapter implements AgentAdapter {
+    name: string;
+    slug: string;
+    detect(): Promise<boolean>;
+    supportsMcpScope(_scope: 'project' | 'user'): boolean;
+    supportsSkills(): boolean;
+    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
+    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+}

package/dist/agents/gemini.js

@@ -0,0 +1,47 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execFileSync } from 'child_process';
+import { buildSkillMd } from './types.js';
+import { mergeJsonMcpServers } from './utils/json-config.js';
+export class GeminiAdapter {
+    name = 'Gemini CLI';
+    slug = 'gemini';
+    async detect() {
+        try {
+            execFileSync('which', ['gemini'], { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    supportsMcpScope(_scope) {
+        return true;
+    }
+    supportsSkills() {
+        return true;
+    }
+    async writeMcpServers(servers, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.gemini', 'settings.json')
+            : join(homedir(), '.gemini', 'settings.json');
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                url: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(filePath, entries, 'mcpServers');
+    }
+    async writeSkills(skills, scope) {
+        const baseDir = scope === 'project'
+            ? join(process.cwd(), '.gemini', 'commands')
+            : join(homedir(), '.gemini', 'commands');
+        mkdirSync(baseDir, { recursive: true });
+        for (const skill of skills) {
+            writeFileSync(join(baseDir, `${skill.filename}.md`), buildSkillMd(skill));
+        }
+    }
+}

package/dist/agents/types.d.ts

@@ -0,0 +1,35 @@
+export interface McpServerEntry {
+    name: string;
+    url: string;
+    transport: 'sse' | 'streamable-http';
+    headers?: Record<string, string>;
+}
+export interface SkillFile {
+    name: string;
+    filename: string;
+    content: string;
+    description: string;
+}
+export interface AgentAdapter {
+    /** Display name, e.g. "Claude Code" */
+    name: string;
+    /** CLI identifier, e.g. "claude-code" */
+    slug: string;
+    /** Check if this agent is installed */
+    detect(): Promise<boolean>;
+    /** Write MCP server configs (merge with existing, only touch runwork-* entries) */
+    writeMcpServers(servers: McpServerEntry[], scope: 'project' | 'user'): Promise<void>;
+    /** Write skill files to agent's skills directory */
+    writeSkills(skills: SkillFile[], 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;
+}
+/** Prefix for MCP server entries managed by runwork */
+export declare const RUNWORK_MCP_PREFIX = "runwork-";
+/**
+ * Build a SKILL.md file with YAML frontmatter.
+ * Ensures the content always has proper frontmatter for agent discovery.
+ */
+export declare function buildSkillMd(skill: SkillFile): string;

package/dist/agents/types.js

@@ -0,0 +1,13 @@
+/** Prefix for MCP server entries managed by runwork */
+export const RUNWORK_MCP_PREFIX = '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
+    if (skill.content.trimStart().startsWith('---\n')) {
+        return skill.content;
+    }
+    return `---\nname: ${skill.name}\ndescription: ${skill.description}\n---\n\n${skill.content}`;
+}

package/dist/agents/utils/json-config.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Read a JSON config file. Returns empty object if file doesn't exist.
+ */
+export declare function readJsonConfig(filePath: string): Record<string, unknown>;
+/**
+ * Write a JSON config file, creating parent directories as needed.
+ */
+export declare function writeJsonConfig(filePath: string, config: Record<string, unknown>): void;
+/**
+ * Merge MCP server entries into a JSON config file.
+ * Removes all existing runwork-* entries, adds new ones.
+ * Preserves user's non-runwork entries.
+ */
+export declare function mergeJsonMcpServers(filePath: string, servers: Record<string, Record<string, unknown>>, topKey: string): void;

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

@@ -0,0 +1,42 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+import { RUNWORK_MCP_PREFIX } from '../types.js';
+/**
+ * Read a JSON config file. Returns empty object if file doesn't exist.
+ */
+export function readJsonConfig(filePath) {
+    if (!existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Write a JSON config file, creating parent directories as needed.
+ */
+export function writeJsonConfig(filePath, config) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n');
+}
+/**
+ * Merge MCP server entries into a JSON config file.
+ * Removes all existing runwork-* entries, adds new ones.
+ * Preserves user's non-runwork entries.
+ */
+export function mergeJsonMcpServers(filePath, servers, topKey) {
+    const config = readJsonConfig(filePath);
+    const existing = (config[topKey] || {});
+    // Remove all runwork-* entries
+    for (const key of Object.keys(existing)) {
+        if (key.startsWith(RUNWORK_MCP_PREFIX)) {
+            delete existing[key];
+        }
+    }
+    // Add new runwork entries
+    Object.assign(existing, servers);
+    config[topKey] = existing;
+    writeJsonConfig(filePath, config);
+}

package/dist/agents/utils/toml-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Merge MCP servers into a Codex config.toml file.
+ * Removes existing [mcp_servers.runwork-*] sections, adds new ones.
+ */
+export declare function mergeTomlMcpServers(filePath: string, servers: Record<string, {
+    url: string;
+    bearerTokenEnvVar?: string;
+}>): void;

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

@@ -0,0 +1,27 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { dirname } from 'path';
+/**
+ * Merge MCP servers into a Codex config.toml file.
+ * Removes existing [mcp_servers.runwork-*] sections, adds new ones.
+ */
+export function mergeTomlMcpServers(filePath, servers) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    let content = existsSync(filePath) ? readFileSync(filePath, 'utf-8') : '';
+    // Remove existing runwork-* mcp_servers sections
+    content = content.replace(/\[mcp_servers\.runwork-[^\]]*\]\n(?:[^\[]*\n?)*/g, '');
+    // Remove trailing blank lines
+    content = content.trimEnd();
+    // Append new sections
+    const sections = [];
+    for (const [name, config] of Object.entries(servers)) {
+        const lines = [`[mcp_servers.${name}]`, `url = "${config.url}"`];
+        if (config.bearerTokenEnvVar) {
+            lines.push(`bearer_token_env_var = "${config.bearerTokenEnvVar}"`);
+        }
+        sections.push(lines.join('\n'));
+    }
+    if (sections.length > 0) {
+        content += '\n\n' + sections.join('\n\n') + '\n';
+    }
+    writeFileSync(filePath, content);
+}

package/dist/agents/windsurf.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class WindsurfAdapter implements AgentAdapter {
+    name: string;
+    slug: string;
+    detect(): Promise<boolean>;
+    supportsMcpScope(scope: 'project' | 'user'): boolean;
+    supportsSkills(): boolean;
+    writeMcpServers(servers: McpServerEntry[], _scope: 'project' | 'user'): Promise<void>;
+    writeSkills(skills: SkillFile[], scope: 'project' | 'user'): Promise<void>;
+}

package/dist/agents/windsurf.js

@@ -0,0 +1,50 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { execFileSync } from 'child_process';
+import { mergeJsonMcpServers } from './utils/json-config.js';
+function getConfigPath() {
+    return join(homedir(), '.codeium', 'windsurf', 'mcp_config.json');
+}
+export class WindsurfAdapter {
+    name = 'Windsurf';
+    slug = 'windsurf';
+    async detect() {
+        const os = platform();
+        if (os === 'darwin' && existsSync('/Applications/Windsurf.app'))
+            return true;
+        try {
+            execFileSync('which', ['windsurf'], { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    supportsMcpScope(scope) {
+        return scope === 'user';
+    }
+    supportsSkills() {
+        return true;
+    }
+    async writeMcpServers(servers, _scope) {
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = {
+                serverUrl: s.url,
+                ...(s.headers ? { headers: s.headers } : {}),
+            };
+        }
+        mergeJsonMcpServers(getConfigPath(), entries, 'mcpServers');
+    }
+    async writeSkills(skills, scope) {
+        if (scope === 'user')
+            return;
+        const rulesDir = join(process.cwd(), '.windsurf', 'rules');
+        mkdirSync(rulesDir, { recursive: true });
+        for (const skill of skills) {
+            const content = `---\ntrigger: manual\n---\n\n${skill.content}`;
+            writeFileSync(join(rulesDir, `${skill.filename}.md`), content);
+        }
+    }
+}

package/dist/api/client.d.ts

@@ -1,4 +1,4 @@
-import type { Credentials, AppInfo, WorkspaceInfo, DevSession, WorkspaceAllData } from '../types.js';
+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 declare class ApiClient {
     private baseUrl;
     private apiKey;
@@ -92,4 +92,100 @@ export declare class ApiClient {
      */
     getWorkspaceAll(workspaceId: string): Promise<WorkspaceAllData>;
     getGitRemoteUrl(workspaceId: string, appId: string): string;
+    listWorkspaceSkills(workspaceId: string): Promise<WorkspaceSkill[]>;
+    listExternalSkills(workspaceId: string): Promise<ExternalSkillRegistration[]>;
+    importExternalSkill(workspaceId: string, skill: {
+        name: string;
+        description: string;
+        content: string;
+        importedFrom: string;
+    }): Promise<ExternalSkillRegistration>;
+    updateExternalSkill(workspaceId: string, skillId: string, skill: {
+        name: string;
+        description: string;
+        content: string;
+    }): Promise<ExternalSkillRegistration>;
+    getAppSkillContent(workspaceId: string, appId: string): Promise<string>;
+    listMcpServers(workspaceId: string): Promise<McpServerConfig[]>;
+    addMcpServer(workspaceId: string, server: {
+        name: string;
+        url: string;
+        transport: 'sse' | 'streamable-http';
+    }): Promise<McpServerConfig>;
+    removeMcpServer(workspaceId: string, serverId: string): Promise<void>;
+    listEntities(workspaceId: string): Promise<RegistryEntity[]>;
+    listEntityRecords(workspaceId: string, entityName: string, opts?: {
+        limit?: number;
+        cursor?: string;
+        deploymentMode?: string;
+    }): Promise<{
+        items: unknown[];
+        next: string | null;
+    }>;
+    getEntityRecord(workspaceId: string, entityName: string, recordId: string): Promise<{
+        item: unknown;
+    }>;
+    createEntityRecord(workspaceId: string, entityName: string, data: Record<string, unknown>): Promise<{
+        item: unknown;
+    }>;
+    updateEntityRecord(workspaceId: string, entityName: string, recordId: string, data: Record<string, unknown>): Promise<{
+        item: unknown;
+    }>;
+    deleteEntityRecord(workspaceId: string, entityName: string, recordId: string): Promise<{
+        success: boolean;
+    }>;
+    listWorkflows(workspaceId: string): Promise<WorkflowInfo[]>;
+    triggerWorkflow(workspaceId: string, opts: {
+        workflowName: string;
+        appId: string;
+        params?: Record<string, unknown>;
+        instanceId?: string;
+    }): Promise<TriggerWorkflowResponse>;
+    listWorkflowInstances(workspaceId: string, appId: string, opts?: {
+        workflowName?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<WorkflowInstancesData>;
+    getWorkflowInstance(workspaceId: string, instanceId: string, appId?: string): Promise<WorkflowInstanceDetailData>;
+    listSchedules(workspaceId: string): Promise<ScheduleInfo[]>;
+    triggerSchedule(workspaceId: string, opts: {
+        scheduleName: string;
+        appId: string;
+        deploymentMode?: string;
+    }): Promise<TriggerScheduleResponse>;
+    getScheduleHistory(workspaceId: string, appId: string): Promise<ScheduleHistoryData>;
+    getScheduleStatus(workspaceId: string, appId: string): Promise<Record<string, unknown>>;
+    pauseSchedule(workspaceId: string, scheduleName: string, appId: string): Promise<void>;
+    resumeSchedule(workspaceId: string, scheduleName: string, appId: string): Promise<void>;
+    listEndpoints(workspaceId: string): Promise<WorkspaceEndpoint[]>;
+    listFileStorages(workspaceId: string): Promise<FileStorageInfo[]>;
+    listBucketFiles(workspaceId: string, bucketName: string, opts?: {
+        prefix?: string;
+        delimiter?: string;
+    }): Promise<ListBucketFilesData>;
+    getPresignedUrl(workspaceId: string, bucketName: string, opts: {
+        action: 'read' | 'write';
+        key: string;
+        expiresIn?: number;
+    }): Promise<{
+        url: string;
+    }>;
+    deleteBucketFile(workspaceId: string, bucketName: string, key: string): Promise<void>;
+    listComponents(workspaceId: string): Promise<ComponentInfo[]>;
+    listApiKeys(workspaceId: string): Promise<ApiKeyInfo[]>;
+    createApiKey(workspaceId: string, opts: {
+        name: string;
+        appId?: string;
+        allowedEndpoints?: string[];
+        scopes?: string[];
+    }): Promise<ApiKeyCreateResponse>;
+    listAgents(workspaceId: string): Promise<AgentInfo[]>;
+    getAgentStatus(workspaceId: string, agentName: string, appId: string): Promise<AgentStatusResponse>;
+    listAgentExecutions(workspaceId: string): Promise<AgentExecutionRecord[]>;
+    getAgentExecutionStream(workspaceId: string, sessionId: string): Promise<string>;
+    callIntegrationProxy(integrationDbId: string, method: string, path: string, opts?: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        query?: string;
+    }): Promise<unknown>;
 }