runwork 0.4.1 → 0.5.1

package/bundled-types/task-delegation.d.ts

@@ -0,0 +1,2 @@
+export { agentTaskToolSchema, runAgentTask, getAgentTaskStatus } from './task-delegation/index';
+export type { AgentTaskResult, AgentTaskInputFile, AgentTaskOutputFile, AgentTaskUsage, ExecutionLimits, AgentTaskExecution, RunAgentTaskOptions, } from './task-delegation/types';

package/dist/__tests__/curl-parser.test.d.ts

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

package/dist/__tests__/curl-parser.test.js

@@ -0,0 +1,250 @@
+import { describe, it, expect } from 'vitest';
+import { parseCurlToRequest } from '../utils/curl-parser.js';
+describe('parseCurlToRequest', () => {
+    describe('basic requests', () => {
+        it('parses a simple GET request', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users'");
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/users');
+            expect(result.query).toBeUndefined();
+            expect(result.body).toBeUndefined();
+        });
+        it('parses GET with query parameters', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users?limit=10&offset=20'");
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/users');
+            expect(result.query).toBe('limit=10&offset=20');
+        });
+        it('parses explicit GET method', async () => {
+            const result = await parseCurlToRequest("curl -X GET 'https://api.example.com/data'");
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/data');
+        });
+        it('parses URL without quotes', async () => {
+            const result = await parseCurlToRequest('curl https://api.example.com/items');
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/items');
+        });
+    });
+    describe('HTTP methods', () => {
+        it('parses POST with -X', async () => {
+            const result = await parseCurlToRequest("curl -X POST 'https://api.example.com/users'");
+            expect(result.method).toBe('POST');
+        });
+        it('parses PUT with --request', async () => {
+            const result = await parseCurlToRequest("curl --request PUT 'https://api.example.com/users/1'");
+            expect(result.method).toBe('PUT');
+        });
+        it('parses DELETE', async () => {
+            const result = await parseCurlToRequest("curl -X DELETE 'https://api.example.com/users/1'");
+            expect(result.method).toBe('DELETE');
+        });
+        it('parses PATCH', async () => {
+            const result = await parseCurlToRequest("curl -X PATCH 'https://api.example.com/users/1'");
+            expect(result.method).toBe('PATCH');
+        });
+        it('infers POST when --data is present without -X', async () => {
+            const result = await parseCurlToRequest(`curl 'https://api.example.com/users' -d '{"name":"test"}'`);
+            expect(result.method).toBe('POST');
+        });
+    });
+    describe('headers', () => {
+        it('parses single header with -H', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Accept: application/json'");
+            expect(result.headers['Accept']).toBe('application/json');
+        });
+        it('parses multiple headers', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Accept: application/json' -H 'X-Custom: value'");
+            expect(result.headers['Accept']).toBe('application/json');
+            expect(result.headers['X-Custom']).toBe('value');
+        });
+        it('strips Authorization header', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Authorization: Bearer token123' -H 'Accept: application/json'");
+            expect(result.headers['Authorization']).toBeUndefined();
+            expect(result.headers['Accept']).toBe('application/json');
+        });
+        it('strips Cookie header', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Cookie: session=abc' -H 'Accept: application/json'");
+            expect(result.headers['Cookie']).toBeUndefined();
+            expect(result.headers['Accept']).toBe('application/json');
+        });
+        it('strips Host header', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Host: api.example.com'");
+            expect(result.headers['Host']).toBeUndefined();
+        });
+        it('strips User-Agent header', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'User-Agent: Mozilla/5.0' -H 'Accept: text/html'");
+            expect(result.headers['User-Agent']).toBeUndefined();
+            expect(result.headers['Accept']).toBe('text/html');
+        });
+        it('strips Connection header', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Connection: keep-alive'");
+            expect(result.headers['Connection']).toBeUndefined();
+        });
+        it('preserves Content-Type header', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -H 'Content-Type: application/json'");
+            expect(result.headers['Content-Type']).toBe('application/json');
+        });
+    });
+    describe('request body', () => {
+        it('parses JSON body with -d', async () => {
+            const result = await parseCurlToRequest(`curl 'https://api.example.com/users' -X POST -d '{"name":"John","age":30}'`);
+            expect(result.body).toEqual({ name: 'John', age: 30 });
+        });
+        it('parses JSON body with --data', async () => {
+            const result = await parseCurlToRequest(`curl 'https://api.example.com/users' -X POST --data '{"key":"value"}'`);
+            expect(result.body).toEqual({ key: 'value' });
+        });
+        it('parses JSON body with --data-raw', async () => {
+            const result = await parseCurlToRequest(`curl 'https://api.example.com/users' -X POST --data-raw '{"items":[1,2,3]}'`);
+            expect(result.body).toEqual({ items: [1, 2, 3] });
+        });
+        it('handles form-encoded body as parsed object', async () => {
+            const result = await parseCurlToRequest(`curl 'https://api.example.com/submit' -X POST -d 'name=John&age=30'`);
+            // curlconverter parses form data into key-value pairs
+            expect(result.body).toEqual({ name: 'John', age: '30' });
+        });
+        it('parses empty body', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users' -X POST");
+            expect(result.body).toBeUndefined();
+        });
+    });
+    describe('Chrome DevTools "Copy as cURL" format', () => {
+        it('parses typical Chrome GET request', async () => {
+            const curl = `curl 'https://api.hubapi.com/crm/v3/objects/contacts?limit=10&properties=email%2Cfirstname' \\
+  -H 'accept: application/json, text/plain, */*' \\
+  -H 'accept-language: en-US,en;q=0.9' \\
+  -H 'authorization: Bearer REDACTED' \\
+  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)' \\
+  -H 'cookie: session=abc123'`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/crm/v3/objects/contacts');
+            expect(result.query).toContain('limit=10');
+            expect(result.headers['authorization']).toBeUndefined();
+            expect(result.headers['cookie']).toBeUndefined();
+            expect(result.headers['user-agent']).toBeUndefined();
+            expect(result.headers['accept']).toBe('application/json, text/plain, */*');
+        });
+        it('parses Chrome POST with JSON body', async () => {
+            const curl = `curl 'https://api.hubapi.com/crm/v3/objects/contacts' \\
+  -H 'accept: application/json' \\
+  -H 'authorization: Bearer REDACTED' \\
+  -H 'content-type: application/json' \\
+  --data-raw '{"properties":{"email":"test@example.com","firstname":"Test"}}' \\
+  --compressed`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.method).toBe('POST');
+            expect(result.path).toBe('/crm/v3/objects/contacts');
+            expect(result.body).toEqual({
+                properties: { email: 'test@example.com', firstname: 'Test' },
+            });
+        });
+        it('parses Chrome PUT request', async () => {
+            const curl = `curl 'https://api.example.com/crm/v3/objects/contacts/123' \\
+  -X 'PUT' \\
+  -H 'content-type: application/json' \\
+  --data-raw '{"properties":{"firstname":"Updated"}}'`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.method).toBe('PUT');
+            expect(result.path).toBe('/crm/v3/objects/contacts/123');
+            expect(result.body).toEqual({ properties: { firstname: 'Updated' } });
+        });
+        it('parses Chrome DELETE request', async () => {
+            const curl = `curl 'https://api.example.com/crm/v3/objects/contacts/123' \\
+  -X 'DELETE' \\
+  -H 'authorization: Bearer REDACTED'`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.method).toBe('DELETE');
+            expect(result.path).toBe('/crm/v3/objects/contacts/123');
+        });
+    });
+    describe('URL path extraction', () => {
+        it('extracts path from URL with port', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com:8443/v2/users'");
+            expect(result.path).toBe('/v2/users');
+        });
+        it('handles root path', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/'");
+            expect(result.path).toBe('/');
+        });
+        it('handles deeply nested path', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/v3/crm/objects/contacts/search'");
+            expect(result.path).toBe('/v3/crm/objects/contacts/search');
+        });
+        it('preserves URL-encoded characters in path', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/users/john%40example.com'");
+            expect(result.path).toBe('/users/john%40example.com');
+        });
+    });
+    describe('edge cases', () => {
+        it('handles double-quoted strings', async () => {
+            const result = await parseCurlToRequest('curl "https://api.example.com/users" -H "Accept: application/json"');
+            expect(result.path).toBe('/users');
+            expect(result.headers['Accept']).toBe('application/json');
+        });
+        it('handles --compressed flag', async () => {
+            const result = await parseCurlToRequest("curl 'https://api.example.com/data' --compressed -H 'Accept-Encoding: gzip'");
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/data');
+        });
+        it('handles -s (silent) flag', async () => {
+            const result = await parseCurlToRequest("curl -s 'https://api.example.com/health'");
+            expect(result.path).toBe('/health');
+        });
+        it('handles -L (follow redirects) flag', async () => {
+            const result = await parseCurlToRequest("curl -L 'https://api.example.com/redirect'");
+            expect(result.path).toBe('/redirect');
+        });
+        it('throws on empty/invalid input', async () => {
+            await expect(parseCurlToRequest('')).rejects.toThrow();
+        });
+        it('handles multiline curl with backslash continuations', async () => {
+            const curl = `curl \\
+  'https://api.example.com/users' \\
+  -H 'Accept: application/json' \\
+  -H 'X-Request-Id: abc-123'`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.path).toBe('/users');
+            expect(result.headers['Accept']).toBe('application/json');
+            expect(result.headers['X-Request-Id']).toBe('abc-123');
+        });
+        it('handles complex JSON body with nested objects', async () => {
+            const curl = `curl 'https://api.example.com/search' -X POST -H 'Content-Type: application/json' --data-raw '{"filters":{"and":[{"property":"email","operator":"EQ","value":"test@example.com"}]},"limit":10}'`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.body).toEqual({
+                filters: {
+                    and: [{ property: 'email', operator: 'EQ', value: 'test@example.com' }],
+                },
+                limit: 10,
+            });
+        });
+        it('handles request with many headers (real-world Chrome copy)', async () => {
+            const curl = `curl 'https://api.stripe.com/v1/charges?limit=3' \\
+  -H 'accept: application/json' \\
+  -H 'accept-language: en-US,en;q=0.9,tr;q=0.8' \\
+  -H 'authorization: Bearer sk_test_xxx' \\
+  -H 'cache-control: no-cache' \\
+  -H 'connection: keep-alive' \\
+  -H 'cookie: __stripe_mid=abc; __stripe_sid=def' \\
+  -H 'pragma: no-cache' \\
+  -H 'sec-ch-ua: "Chromium";v="128"' \\
+  -H 'sec-fetch-dest: empty' \\
+  -H 'sec-fetch-mode: cors' \\
+  -H 'sec-fetch-site: same-origin' \\
+  -H 'user-agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)'`;
+            const result = await parseCurlToRequest(curl);
+            expect(result.method).toBe('GET');
+            expect(result.path).toBe('/v1/charges');
+            expect(result.query).toBe('limit=3');
+            // Proxy-managed headers stripped
+            expect(result.headers['authorization']).toBeUndefined();
+            expect(result.headers['cookie']).toBeUndefined();
+            expect(result.headers['connection']).toBeUndefined();
+            expect(result.headers['user-agent']).toBeUndefined();
+            // App headers preserved
+            expect(result.headers['accept']).toBe('application/json');
+            expect(result.headers['cache-control']).toBe('no-cache');
+        });
+    });
+});

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

@@ -1,14 +1,22 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 vi.mock('fs');
+vi.mock('../generated/bundled-types.js', () => ({
+    BUNDLED_TYPES: {},
+}));
 const mockFs = await import('fs');
+const bundledTypesModule = await import('../generated/bundled-types.js');
 const { populateTypes } = await import('../types-manager.js');
+function setBundledTypes(types) {
+    Object.keys(bundledTypesModule.BUNDLED_TYPES).forEach(k => delete bundledTypesModule.BUNDLED_TYPES[k]);
+    Object.assign(bundledTypesModule.BUNDLED_TYPES, types);
+}
 describe('types-manager', () => {
     beforeEach(() => {
         vi.clearAllMocks();
+        setBundledTypes({});
     });
     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');
@@ -46,39 +54,35 @@ describe('types-manager', () => {
             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.existsSync).mockReturnValue(false);
+            setBundledTypes({
+                'framework.d.ts': 'export type Framework = {};',
             });
-            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(mockFs.writeFileSync).toHaveBeenCalledWith('/project/.runwork/types/framework.d.ts', 'export type Framework = {};');
             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);
+            setBundledTypes({});
             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;
+        it('writes all bundled type entries in Tier 3 fallback', async () => {
+            vi.mocked(mockFs.existsSync).mockReturnValue(false);
+            setBundledTypes({
+                'types.d.ts': 'export type A = {};',
+                'utils.d.ts': 'export type B = {};',
             });
-            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);
+            expect(mockFs.writeFileSync).toHaveBeenCalledTimes(2);
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/project/.runwork/types/types.d.ts', 'export type A = {};');
+            expect(mockFs.writeFileSync).toHaveBeenCalledWith('/project/.runwork/types/utils.d.ts', 'export type B = {};');
             logSpy.mockRestore();
         });
     });

package/dist/agents/claude-code.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class ClaudeCodeAdapter 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/claude-code.js

@@ -0,0 +1,50 @@
+import { existsSync, 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 ClaudeCodeAdapter {
+    name = 'Claude Code';
+    slug = 'claude-code';
+    async detect() {
+        try {
+            execFileSync('which', ['claude'], { stdio: 'pipe' });
+            return true;
+        }
+        catch {
+            return existsSync('/Applications/Claude.app');
+        }
+    }
+    supportsMcpScope(_scope) {
+        return true;
+    }
+    supportsSkills() {
+        return true;
+    }
+    async writeMcpServers(servers, scope) {
+        const filePath = scope === 'project'
+            ? join(process.cwd(), '.mcp.json')
+            : join(homedir(), '.claude', 'settings.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) {
+        const baseDir = scope === 'project'
+            ? join(process.cwd(), '.claude', 'skills')
+            : join(homedir(), '.claude', 'skills');
+        for (const skill of skills) {
+            const skillDir = join(baseDir, skill.name);
+            mkdirSync(skillDir, { recursive: true });
+            const content = buildSkillMd(skill);
+            writeFileSync(join(skillDir, 'SKILL.md'), content);
+        }
+    }
+}

package/dist/agents/claude-desktop.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class ClaudeDesktopAdapter 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/claude-desktop.js

@@ -0,0 +1,141 @@
+import { existsSync, readdirSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { buildSkillMd } from './types.js';
+import { mergeJsonMcpServers, readJsonConfig, writeJsonConfig } from './utils/json-config.js';
+const PLUGIN_NAME = 'runwork';
+const PLUGIN_VERSION = '1.0.0';
+function getMcpConfigPath() {
+    const os = platform();
+    if (os === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+    }
+    if (os === 'win32') {
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+    }
+    return join(homedir(), '.config', 'Claude', 'claude_desktop_config.json');
+}
+function getCoworkBaseDir() {
+    const os = platform();
+    if (os === 'darwin') {
+        return join(homedir(), 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
+    }
+    if (os === 'win32') {
+        return join(process.env.APPDATA || join(homedir(), 'AppData', 'Roaming'), 'Claude', 'local-agent-mode-sessions');
+    }
+    return join(homedir(), '.config', 'Claude', 'local-agent-mode-sessions');
+}
+/**
+ * Find the cowork_plugins directory by discovering the session/org ID structure.
+ * Path: local-agent-mode-sessions/<session-id>/<org-id>/cowork_plugins/
+ */
+function findCoworkPluginsDir() {
+    const baseDir = getCoworkBaseDir();
+    if (!existsSync(baseDir))
+        return null;
+    try {
+        const entries = readdirSync(baseDir).filter(d => !d.startsWith('.') && d !== 'skills-plugin');
+        for (const sessionId of entries) {
+            const sessionPath = join(baseDir, sessionId);
+            const orgDirs = readdirSync(sessionPath).filter(d => !d.startsWith('.'));
+            for (const orgId of orgDirs) {
+                const pluginsDir = join(sessionPath, orgId, 'cowork_plugins');
+                if (existsSync(join(pluginsDir, 'installed_plugins.json'))) {
+                    return pluginsDir;
+                }
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return null;
+}
+function getPluginJson() {
+    return {
+        name: PLUGIN_NAME,
+        version: PLUGIN_VERSION,
+        description: 'Skills and tools from your Runwork workspace',
+        author: { name: 'Runwork' },
+    };
+}
+export class ClaudeDesktopAdapter {
+    name = 'Claude Desktop (Cowork)';
+    slug = 'claude-desktop';
+    async detect() {
+        const os = platform();
+        if (os === 'darwin')
+            return existsSync('/Applications/Claude.app');
+        return existsSync(getMcpConfigPath());
+    }
+    supportsMcpScope(scope) {
+        return scope === 'user';
+    }
+    supportsSkills() {
+        return true;
+    }
+    async writeMcpServers(servers, _scope) {
+        // Claude Desktop Cowork mode only supports stdio transport.
+        // Use mcp-remote as a bridge for HTTP/SSE servers.
+        const entries = {};
+        for (const s of servers) {
+            const args = ['mcp-remote', s.url];
+            if (s.headers?.Authorization) {
+                args.push('--header', `Authorization:${s.headers.Authorization}`);
+            }
+            entries[s.name] = {
+                command: 'npx',
+                args: ['-y', ...args],
+            };
+        }
+        mergeJsonMcpServers(getMcpConfigPath(), entries, 'mcpServers');
+    }
+    async writeSkills(skills, _scope) {
+        const pluginsDir = findCoworkPluginsDir();
+        if (!pluginsDir) {
+            console.warn('  [Claude Desktop] Cowork plugins directory not found. Open Claude Desktop at least once first.');
+            return;
+        }
+        // Write to both cache (installed copy) and marketplaces (source)
+        const cacheDir = join(pluginsDir, 'cache', 'runwork', PLUGIN_NAME, PLUGIN_VERSION);
+        const marketDir = join(pluginsDir, 'marketplaces', 'runwork', PLUGIN_NAME);
+        // Create plugin.json in both locations
+        for (const dir of [cacheDir, marketDir]) {
+            const pluginJsonDir = join(dir, '.claude-plugin');
+            mkdirSync(pluginJsonDir, { recursive: true });
+            writeFileSync(join(pluginJsonDir, 'plugin.json'), JSON.stringify(getPluginJson(), null, 2));
+        }
+        // Write skill files to both locations
+        for (const skill of skills) {
+            for (const dir of [cacheDir, marketDir]) {
+                const skillDir = join(dir, 'skills', skill.name);
+                mkdirSync(skillDir, { recursive: true });
+                writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+            }
+        }
+        // Register in installed_plugins.json
+        const installedPath = join(pluginsDir, 'installed_plugins.json');
+        const installed = readJsonConfig(installedPath);
+        if (!installed.version)
+            installed.version = 2;
+        if (!installed.plugins)
+            installed.plugins = {};
+        installed.plugins[`${PLUGIN_NAME}@runwork`] = [{
+                scope: 'user',
+                installPath: cacheDir,
+                version: PLUGIN_VERSION,
+                installedAt: new Date().toISOString(),
+                lastUpdated: new Date().toISOString(),
+            }];
+        writeJsonConfig(installedPath, installed);
+        // Register in known_marketplaces.json
+        const marketplacesPath = join(pluginsDir, 'known_marketplaces.json');
+        const marketplaces = readJsonConfig(marketplacesPath);
+        if (!marketplaces['runwork']) {
+            marketplaces['runwork'] = {
+                source: { source: 'local', path: join(pluginsDir, 'marketplaces', 'runwork') },
+                installLocation: join(pluginsDir, 'marketplaces', 'runwork'),
+                lastUpdated: new Date().toISOString(),
+            };
+            writeJsonConfig(marketplacesPath, marketplaces);
+        }
+    }
+}

package/dist/agents/codex.d.ts

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class CodexAdapter 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/codex.js

@@ -0,0 +1,45 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { execFileSync } from 'child_process';
+import { buildSkillMd } from './types.js';
+import { mergeTomlMcpServers } from './utils/toml-config.js';
+export class CodexAdapter {
+    name = 'Codex CLI';
+    slug = 'codex';
+    async detect() {
+        try {
+            execFileSync('which', ['codex'], { 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(), '.codex', 'config.toml')
+            : join(homedir(), '.codex', 'config.toml');
+        const entries = {};
+        for (const s of servers) {
+            entries[s.name] = { url: s.url, bearerTokenEnvVar: 'RUNWORK_API_KEY' };
+        }
+        mergeTomlMcpServers(filePath, entries);
+    }
+    async writeSkills(skills, scope) {
+        const baseDir = scope === 'project'
+            ? join(process.cwd(), '.codex', 'skills')
+            : join(homedir(), '.codex', 'skills');
+        for (const skill of skills) {
+            const skillDir = join(baseDir, skill.name);
+            mkdirSync(skillDir, { recursive: true });
+            writeFileSync(join(skillDir, 'SKILL.md'), buildSkillMd(skill));
+        }
+    }
+}

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

@@ -0,0 +1,10 @@
+import type { AgentAdapter, McpServerEntry, SkillFile } from './types.js';
+export declare class CopilotCliAdapter 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>;
+}