runwork 0.6.1 → 0.8.2

package/dist/agents/__tests__/claude-desktop-plugin-tree.test.js

@@ -0,0 +1,161 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { writePluginMcpConfig, writePluginMetadata, writePluginSkills, writePluginTeamInstructions, writePluginTree, } from '../claude-desktop-plugin-tree.js';
+describe('claude-desktop plugin-tree helpers', () => {
+    let workDir;
+    beforeEach(() => {
+        workDir = mkdtempSync(join(tmpdir(), 'runwork-plugin-tree-'));
+    });
+    afterEach(() => {
+        rmSync(workDir, { recursive: true, force: true });
+    });
+    describe('writePluginMetadata', () => {
+        it('writes .claude-plugin/plugin.json with the expected shape', () => {
+            writePluginMetadata(workDir, {
+                pluginName: 'runwork',
+                pluginVersion: '1.0.0',
+                description: 'Skills and tools from your Runwork workspace',
+                authorName: 'Runwork',
+            });
+            const raw = readFileSync(join(workDir, '.claude-plugin', 'plugin.json'), 'utf-8');
+            const parsed = JSON.parse(raw);
+            expect(parsed).toEqual({
+                name: 'runwork',
+                version: '1.0.0',
+                description: 'Skills and tools from your Runwork workspace',
+                author: { name: 'Runwork' },
+            });
+        });
+    });
+    describe('writePluginMcpConfig', () => {
+        it('wraps entries under mcpServers and embeds the bearer token in the URL', () => {
+            const servers = [
+                {
+                    name: 'Runwork',
+                    url: 'https://runwork.ai/api/workspaces/abc/mcp',
+                    transport: 'streamable-http',
+                    headers: { Authorization: 'Bearer rk_test_token' },
+                    description: 'Workspace tools',
+                },
+            ];
+            writePluginMcpConfig(workDir, servers);
+            const raw = readFileSync(join(workDir, '.mcp.json'), 'utf-8');
+            const parsed = JSON.parse(raw);
+            expect(Object.keys(parsed.mcpServers)).toEqual(['Runwork']);
+            const entry = parsed.mcpServers['Runwork'];
+            expect(entry.type).toBe('http');
+            expect(entry.url).toBe('https://runwork.ai/api/workspaces/abc/mcp?token=rk_test_token');
+            expect(entry.description).toBe('Workspace tools');
+        });
+        it('leaves the URL untouched when no Authorization header is present', () => {
+            const servers = [
+                {
+                    name: 'Public Server',
+                    url: 'https://example.com/mcp',
+                    transport: 'streamable-http',
+                },
+            ];
+            writePluginMcpConfig(workDir, servers);
+            const parsed = JSON.parse(readFileSync(join(workDir, '.mcp.json'), 'utf-8'));
+            expect(parsed.mcpServers['Public Server'].url).toBe('https://example.com/mcp');
+            expect(parsed.mcpServers['Public Server']).not.toHaveProperty('description');
+        });
+    });
+    describe('writePluginSkills', () => {
+        it('writes one SKILL.md per skill in kebab-cased directories', () => {
+            const skills = [
+                {
+                    name: 'Write Cold Email',
+                    filename: 'write-cold-email',
+                    content: 'Draft a cold email.',
+                    description: 'Write Cold Email - Runwork workspace skill',
+                },
+                {
+                    name: 'Blog Writing Specialist',
+                    filename: 'blog-writing-specialist',
+                    content: '---\nname: blog-writing-specialist\ndescription: existing\n---\n\nBody',
+                    description: 'Blog skill',
+                },
+            ];
+            writePluginSkills(workDir, skills);
+            expect(existsSync(join(workDir, 'skills', 'write-cold-email', 'SKILL.md'))).toBe(true);
+            expect(existsSync(join(workDir, 'skills', 'blog-writing-specialist', 'SKILL.md'))).toBe(true);
+            const coldEmail = readFileSync(join(workDir, 'skills', 'write-cold-email', 'SKILL.md'), 'utf-8');
+            expect(coldEmail).toContain('name: write-cold-email');
+            expect(coldEmail).toContain('Draft a cold email.');
+        });
+        it('removes legacy directories named with spaces from prior sync runs', () => {
+            const legacyDir = join(workDir, 'skills', 'Write Cold Email');
+            writePluginSkills(workDir, [
+                {
+                    name: 'Write Cold Email',
+                    filename: 'write-cold-email',
+                    content: 'original',
+                    description: 'original',
+                },
+            ]);
+            // First write creates kebab dir only — nothing to clean up yet.
+            expect(existsSync(legacyDir)).toBe(false);
+            // Simulate a legacy dir left behind from an earlier sync then re-run.
+            const { mkdirSync, writeFileSync } = require('fs');
+            mkdirSync(legacyDir, { recursive: true });
+            writeFileSync(join(legacyDir, 'SKILL.md'), 'stale');
+            writePluginSkills(workDir, [
+                {
+                    name: 'Write Cold Email',
+                    filename: 'write-cold-email',
+                    content: 'refreshed',
+                    description: 'refreshed',
+                },
+            ]);
+            expect(existsSync(legacyDir)).toBe(false);
+            expect(existsSync(join(workDir, 'skills', 'write-cold-email', 'SKILL.md'))).toBe(true);
+        });
+    });
+    describe('writePluginTeamInstructions', () => {
+        it('writes a runwork-team-instructions SKILL.md with YAML frontmatter', () => {
+            writePluginTeamInstructions(workDir, 'Always reply in British English.\n- Second rule.');
+            const skillPath = join(workDir, 'skills', 'runwork-team-instructions', 'SKILL.md');
+            expect(existsSync(skillPath)).toBe(true);
+            const content = readFileSync(skillPath, 'utf-8');
+            expect(content.startsWith('---\n')).toBe(true);
+            expect(content).toContain('name: runwork-team-instructions');
+            expect(content).toContain('description: Team instructions');
+            expect(content).toContain('Always reply in British English.');
+            expect(content).toContain('- Second rule.');
+        });
+    });
+    describe('writePluginTree', () => {
+        it('writes metadata, mcp config, and skills in one call', () => {
+            writePluginTree(workDir, {
+                pluginName: 'runwork',
+                pluginVersion: '1.0.0',
+                description: 'Skills and tools from your Runwork workspace',
+                authorName: 'Runwork',
+                skills: [
+                    {
+                        name: 'Runwork',
+                        filename: 'runwork',
+                        content: 'Intro skill',
+                        description: 'Runwork intro',
+                    },
+                ],
+                mcpServers: [
+                    {
+                        name: 'Runwork',
+                        url: 'https://runwork.ai/api/workspaces/abc/mcp',
+                        transport: 'streamable-http',
+                        headers: { Authorization: 'Bearer rk_test' },
+                    },
+                ],
+            });
+            expect(existsSync(join(workDir, '.claude-plugin', 'plugin.json'))).toBe(true);
+            expect(existsSync(join(workDir, '.mcp.json'))).toBe(true);
+            expect(existsSync(join(workDir, 'skills', 'runwork', 'SKILL.md'))).toBe(true);
+            const mcpJson = JSON.parse(readFileSync(join(workDir, '.mcp.json'), 'utf-8'));
+            expect(mcpJson.mcpServers['Runwork'].url).toContain('token=rk_test');
+        });
+    });
+});

package/dist/agents/__tests__/claude-desktop-plugin.test.d.ts

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

package/dist/agents/__tests__/claude-desktop-plugin.test.js

@@ -0,0 +1,117 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+let mockHomeDir = '/tmp/runwork-cli-tests';
+vi.mock('os', async () => {
+    const actual = await vi.importActual('os');
+    return {
+        ...actual,
+        homedir: vi.fn(() => mockHomeDir),
+        platform: vi.fn(() => 'darwin'),
+    };
+});
+import { ClaudeDesktopAdapter } from '../claude-desktop.js';
+const ACCOUNT_ID = 'account-id';
+const ORG_ID = 'org-id';
+function getClaudeRoot(homeDir) {
+    return join(homeDir, 'Library', 'Application Support', 'Claude');
+}
+function getCoworkOrgDir(homeDir) {
+    return join(getClaudeRoot(homeDir), 'local-agent-mode-sessions', ACCOUNT_ID, ORG_ID);
+}
+function getCoworkPluginsDir(homeDir) {
+    return join(getCoworkOrgDir(homeDir), 'cowork_plugins');
+}
+describe('ClaudeDesktopAdapter plugin registration', () => {
+    let tempHomeDir;
+    beforeEach(() => {
+        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-cli-claude-desktop-'));
+        mockHomeDir = tempHomeDir;
+        const pluginsDir = getCoworkPluginsDir(tempHomeDir);
+        mkdirSync(pluginsDir, { recursive: true });
+        writeFileSync(join(pluginsDir, 'installed_plugins.json'), JSON.stringify({
+            version: 2,
+            plugins: {},
+        }));
+        writeFileSync(join(pluginsDir, 'known_marketplaces.json'), JSON.stringify({}));
+    });
+    afterEach(() => {
+        rmSync(tempHomeDir, { recursive: true, force: true });
+    });
+    it('re-enables the Runwork cowork plugin during sync', async () => {
+        const adapter = new ClaudeDesktopAdapter();
+        const coworkSettingsPath = join(getCoworkOrgDir(tempHomeDir), 'cowork_settings.json');
+        writeFileSync(coworkSettingsPath, JSON.stringify({
+            enabledPlugins: {
+                'cowork-plugin-management@knowledge-work-plugins': true,
+                'runwork@runwork': false,
+            },
+        }));
+        await adapter.writeSkills([{
+                name: 'Runwork',
+                filename: 'runwork',
+                content: '# Runwork',
+                description: 'Runwork intro skill',
+            }], 'user');
+        const settings = JSON.parse(readFileSync(coworkSettingsPath, 'utf-8'));
+        expect(settings.enabledPlugins?.['cowork-plugin-management@knowledge-work-plugins']).toBe(true);
+        expect(settings.enabledPlugins?.['runwork@runwork']).toBe(true);
+    });
+    it('writes cowork plugin mcp config using the mcpServers wrapper', async () => {
+        const adapter = new ClaudeDesktopAdapter();
+        const server = {
+            name: 'Runwork',
+            url: 'https://runwork.ai/api/workspaces/test/mcp',
+            transport: 'streamable-http',
+            headers: {
+                Authorization: 'Bearer test-token',
+            },
+            description: 'Runwork workspace tools',
+        };
+        await adapter.writeMcpServers([server], 'user');
+        const cacheMcpPath = join(getCoworkPluginsDir(tempHomeDir), 'cache', 'runwork', 'runwork', '1.0.0', '.mcp.json');
+        const marketplaceMcpPath = join(getCoworkPluginsDir(tempHomeDir), 'marketplaces', 'runwork', 'plugins', 'runwork', '.mcp.json');
+        const cacheConfig = JSON.parse(readFileSync(cacheMcpPath, 'utf-8'));
+        const marketplaceConfig = JSON.parse(readFileSync(marketplaceMcpPath, 'utf-8'));
+        expect(cacheConfig.mcpServers?.['Runwork']?.url).toBe('https://runwork.ai/api/workspaces/test/mcp?token=test-token');
+        expect(marketplaceConfig).toEqual(cacheConfig);
+    });
+    it('removes the cowork enable flag during cleanup', async () => {
+        const adapter = new ClaudeDesktopAdapter();
+        const pluginsDir = getCoworkPluginsDir(tempHomeDir);
+        const coworkSettingsPath = join(getCoworkOrgDir(tempHomeDir), 'cowork_settings.json');
+        const cacheDir = join(pluginsDir, 'cache', 'runwork', 'runwork', '1.0.0');
+        const marketplaceDir = join(pluginsDir, 'marketplaces', 'runwork');
+        mkdirSync(cacheDir, { recursive: true });
+        mkdirSync(marketplaceDir, { recursive: true });
+        writeFileSync(join(pluginsDir, 'installed_plugins.json'), JSON.stringify({
+            version: 2,
+            plugins: {
+                'runwork@runwork': [{
+                        scope: 'user',
+                        installPath: cacheDir,
+                        version: '1.0.0',
+                    }],
+            },
+        }));
+        writeFileSync(join(pluginsDir, 'known_marketplaces.json'), JSON.stringify({
+            runwork: {
+                source: { source: 'directory', path: marketplaceDir },
+                installLocation: marketplaceDir,
+            },
+        }));
+        writeFileSync(coworkSettingsPath, JSON.stringify({
+            enabledPlugins: {
+                'runwork@runwork': true,
+                'cowork-plugin-management@knowledge-work-plugins': true,
+            },
+        }));
+        await adapter.cleanup('user');
+        const settings = JSON.parse(readFileSync(coworkSettingsPath, 'utf-8'));
+        expect(settings.enabledPlugins?.['runwork@runwork']).toBeUndefined();
+        expect(settings.enabledPlugins?.['cowork-plugin-management@knowledge-work-plugins']).toBe(true);
+        expect(existsSync(cacheDir)).toBe(false);
+        expect(existsSync(marketplaceDir)).toBe(false);
+    });
+});

package/dist/agents/__tests__/claude-desktop-rpm.test.d.ts

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

package/dist/agents/__tests__/claude-desktop-rpm.test.js

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+let mockHomeDir = '/tmp/runwork-cli-rpm-tests';
+vi.mock('os', async () => {
+    const actual = await vi.importActual('os');
+    return {
+        ...actual,
+        homedir: vi.fn(() => mockHomeDir),
+        platform: vi.fn(() => 'darwin'),
+    };
+});
+import { ClaudeDesktopAdapter, findRpmPluginByName } from '../claude-desktop.js';
+const SESSION_ID = 'test-session';
+const ORG_ID = 'test-org';
+function getOrgDir(homeDir) {
+    return join(homeDir, 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions', SESSION_ID, ORG_ID);
+}
+describe('findRpmPluginByName', () => {
+    let tempHomeDir;
+    beforeEach(() => {
+        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-rpm-'));
+        mockHomeDir = tempHomeDir;
+        mkdirSync(getOrgDir(tempHomeDir), { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tempHomeDir, { recursive: true, force: true });
+    });
+    it('returns null when there is no rpm/ directory', () => {
+        expect(findRpmPluginByName('runwork')).toBeNull();
+    });
+    it('returns null when rpm/manifest.json is missing', () => {
+        mkdirSync(join(getOrgDir(tempHomeDir), 'rpm'), { recursive: true });
+        expect(findRpmPluginByName('runwork')).toBeNull();
+    });
+    it('returns null when the manifest does not list the plugin', () => {
+        const rpmDir = join(getOrgDir(tempHomeDir), 'rpm');
+        mkdirSync(rpmDir, { recursive: true });
+        writeFileSync(join(rpmDir, 'manifest.json'), JSON.stringify({
+            lastUpdated: Date.now(),
+            plugins: [
+                { id: 'plugin_other', name: 'other-plugin', marketplaceName: 'My Uploads' },
+            ],
+        }));
+        expect(findRpmPluginByName('runwork')).toBeNull();
+    });
+    it('returns the plugin path and org dir when the plugin is listed', () => {
+        const rpmDir = join(getOrgDir(tempHomeDir), 'rpm');
+        mkdirSync(rpmDir, { recursive: true });
+        writeFileSync(join(rpmDir, 'manifest.json'), JSON.stringify({
+            lastUpdated: Date.now(),
+            plugins: [
+                { id: 'plugin_other', name: 'other-plugin' },
+                { id: 'plugin_01ABC', name: 'runwork', marketplaceName: 'My Uploads' },
+            ],
+        }));
+        // The plugin directory itself doesn't need to exist for the lookup —
+        // we just read the manifest to learn where it lives.
+        const location = findRpmPluginByName('runwork');
+        expect(location).not.toBeNull();
+        expect(location?.pluginPath).toBe(join(rpmDir, 'plugin_01ABC'));
+        expect(location?.orgDir).toBe(getOrgDir(tempHomeDir));
+    });
+    it('handles malformed manifest.json gracefully', () => {
+        const rpmDir = join(getOrgDir(tempHomeDir), 'rpm');
+        mkdirSync(rpmDir, { recursive: true });
+        writeFileSync(join(rpmDir, 'manifest.json'), 'not-json');
+        expect(findRpmPluginByName('runwork')).toBeNull();
+    });
+    it('skips entries that are missing an id field', () => {
+        const rpmDir = join(getOrgDir(tempHomeDir), 'rpm');
+        mkdirSync(rpmDir, { recursive: true });
+        writeFileSync(join(rpmDir, 'manifest.json'), JSON.stringify({ plugins: [{ name: 'runwork' }] }));
+        expect(findRpmPluginByName('runwork')).toBeNull();
+    });
+});
+describe('ClaudeDesktopAdapter.cleanup with rpm plugin', () => {
+    let tempHomeDir;
+    beforeEach(() => {
+        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-rpm-cleanup-'));
+        mockHomeDir = tempHomeDir;
+        mkdirSync(getOrgDir(tempHomeDir), { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tempHomeDir, { recursive: true, force: true });
+    });
+    it('removes rpm plugin directory and manifest entry, leaving other plugins intact', async () => {
+        const rpmDir = join(getOrgDir(tempHomeDir), 'rpm');
+        const runworkPluginDir = join(rpmDir, 'plugin_runwork_id');
+        const otherPluginDir = join(rpmDir, 'plugin_other_id');
+        mkdirSync(join(runworkPluginDir, 'skills', 'intro'), { recursive: true });
+        writeFileSync(join(runworkPluginDir, 'skills', 'intro', 'SKILL.md'), 'stale');
+        mkdirSync(otherPluginDir, { recursive: true });
+        writeFileSync(join(rpmDir, 'manifest.json'), JSON.stringify({
+            lastUpdated: 1,
+            plugins: [
+                { id: 'plugin_runwork_id', name: 'runwork', marketplaceName: 'My Uploads' },
+                { id: 'plugin_other_id', name: 'other-plugin', marketplaceName: 'knowledge-work-plugins' },
+            ],
+        }));
+        const adapter = new ClaudeDesktopAdapter();
+        await adapter.cleanup('user');
+        expect(existsSync(runworkPluginDir)).toBe(false);
+        expect(existsSync(otherPluginDir)).toBe(true);
+        const manifest = JSON.parse(readFileSync(join(rpmDir, 'manifest.json'), 'utf-8'));
+        expect(manifest.plugins).toEqual([
+            { id: 'plugin_other_id', name: 'other-plugin', marketplaceName: 'knowledge-work-plugins' },
+        ]);
+        expect(typeof manifest.lastUpdated).toBe('number');
+        expect(manifest.lastUpdated).toBeGreaterThan(1);
+    });
+    it('is a no-op when no rpm plugin is registered', async () => {
+        const rpmDir = join(getOrgDir(tempHomeDir), 'rpm');
+        mkdirSync(rpmDir, { recursive: true });
+        writeFileSync(join(rpmDir, 'manifest.json'), JSON.stringify({
+            lastUpdated: 1,
+            plugins: [{ id: 'plugin_other_id', name: 'other-plugin' }],
+        }));
+        const adapter = new ClaudeDesktopAdapter();
+        await adapter.cleanup('user');
+        const manifest = JSON.parse(readFileSync(join(rpmDir, 'manifest.json'), 'utf-8'));
+        expect(manifest.plugins).toHaveLength(1);
+        expect(manifest.plugins[0].name).toBe('other-plugin');
+    });
+});

package/dist/agents/__tests__/codex-instructions.test.d.ts

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

package/dist/agents/__tests__/codex-instructions.test.js

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { existsSync, mkdtempSync, readFileSync, rmSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+let mockHomeDir = '/tmp/runwork-cli-codex-instructions-tests';
+vi.mock('os', async () => {
+    const actual = await vi.importActual('os');
+    return {
+        ...actual,
+        homedir: vi.fn(() => mockHomeDir),
+        platform: vi.fn(() => 'darwin'),
+    };
+});
+import { CodexAdapter } from '../codex.js';
+describe('CodexAdapter user-scope instruction file', () => {
+    let tempHomeDir;
+    beforeEach(() => {
+        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-codex-instr-'));
+        mockHomeDir = tempHomeDir;
+    });
+    afterEach(() => {
+        rmSync(tempHomeDir, { recursive: true, force: true });
+    });
+    it('writeInstructionHint writes to ~/.codex/AGENTS.md', async () => {
+        const adapter = new CodexAdapter();
+        await adapter.writeInstructionHint('<!-- runwork:start -->\nhello\n<!-- runwork:end -->', 'user');
+        const agentsPath = join(tempHomeDir, '.codex', 'AGENTS.md');
+        expect(existsSync(agentsPath)).toBe(true);
+        expect(readFileSync(agentsPath, 'utf-8')).toContain('hello');
+        // Legacy location must not be touched.
+        expect(existsSync(join(tempHomeDir, '.codex', 'instructions.md'))).toBe(false);
+    });
+    it('writeTeamInstructions writes to ~/.codex/AGENTS.md', async () => {
+        const adapter = new CodexAdapter();
+        await adapter.writeTeamInstructions('team rule', 'user');
+        const agentsPath = join(tempHomeDir, '.codex', 'AGENTS.md');
+        expect(existsSync(agentsPath)).toBe(true);
+        const contents = readFileSync(agentsPath, 'utf-8');
+        expect(contents).toContain('<!-- runwork-team:start -->');
+        expect(contents).toContain('team rule');
+        expect(contents).toContain('<!-- runwork-team:end -->');
+        expect(existsSync(join(tempHomeDir, '.codex', 'instructions.md'))).toBe(false);
+    });
+    it('cleanup removes both hint and team markers from ~/.codex/AGENTS.md', async () => {
+        const adapter = new CodexAdapter();
+        await adapter.writeInstructionHint('<!-- runwork:start -->\nhint body\n<!-- runwork:end -->', 'user');
+        await adapter.writeTeamInstructions('team body', 'user');
+        const agentsPath = join(tempHomeDir, '.codex', 'AGENTS.md');
+        expect(readFileSync(agentsPath, 'utf-8')).toContain('hint body');
+        await adapter.cleanup('user');
+        const after = readFileSync(agentsPath, 'utf-8');
+        expect(after).not.toContain('runwork:start');
+        expect(after).not.toContain('runwork-team:start');
+        expect(after).not.toContain('hint body');
+        expect(after).not.toContain('team body');
+    });
+});

package/dist/agents/__tests__/codex-stats.test.js

@@ -72,6 +72,15 @@ describe('CodexAdapter (codex).readUsageStats', () => {
         expect(result).not.toBeNull();
         expect(result.sessionCount).toBe(3);
         expect(result.hasNewActivity).toBe(true);
+        // Filtering must use updated_at (not created_at): long-lived threads can
+        // accumulate post-sync activity without ever being newly created.
+        const calls = querySqlite.mock.calls;
+        const countSql = calls.find(c => c[1].includes('count(*)'))?.[1];
+        expect(countSql).toContain('WHERE updated_at >');
+        expect(countSql).not.toContain('created_at >');
+        const tokensSql = calls.find(c => c[1].includes('sum(tokens_used)'))?.[1];
+        expect(tokensSql).toContain('WHERE updated_at >');
+        expect(tokensSql).not.toContain('created_at >');
         // Verify querySqlite was called with the DB path
         expect(querySqlite).toHaveBeenCalledWith(DB_PATH, expect.stringContaining('count(*)'));
     });

package/dist/agents/__tests__/graceful-degradation.test.js

@@ -16,14 +16,14 @@ vi.mock('child_process', () => ({
 }));
 vi.mock('../../utils/sqlite.js', () => ({
     querySqlite: vi.fn(() => ''),
+    openWritableSqlite: vi.fn(() => null),
+    sqliteAvailable: vi.fn(() => false),
+    sqliteFlavor: vi.fn(() => null),
 }));
 vi.mock('smol-toml', () => ({
     parse: vi.fn(() => ({})),
     stringify: vi.fn(() => ''),
 }));
-vi.mock('better-sqlite3', () => ({
-    default: vi.fn(() => { throw new Error('not available'); }),
-}));
 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { homedir } from 'os';
 import { execFileSync } from 'child_process';

package/dist/agents/__tests__/intro-skill.test.js

@@ -70,11 +70,11 @@ describe('generateIntroSkill', () => {
         const skill = generateIntroSkill(makeContext({
             mcpServerCount: 2,
             skillCount: 2,
-            mcpServerNames: ['Workspace Tools', 'aTars MCP'],
+            mcpServerNames: ['Runwork', 'aTars MCP'],
             skillNames: ['Developer Tools', 'Writing Plans'],
         }));
         expect(skill.content).toContain('MCP Servers (2)');
-        expect(skill.content).toContain('Workspace Tools');
+        expect(skill.content).toContain('Runwork');
         expect(skill.content).toContain('Skills (2)');
         expect(skill.content).toContain('Developer Tools');
     });
@@ -84,6 +84,15 @@ describe('generateIntroSkill', () => {
         expect(skill.content).toContain('runwork dev');
         expect(skill.content).toContain('runwork doctor');
     });
+    it('uses canonical install commands and does not reference the old @runworkai/cli package', () => {
+        const skill = generateIntroSkill(makeContext());
+        expect(skill.content).toContain('curl -fsSL https://runwork.ai/install.sh | sh');
+        expect(skill.content).toContain('brew install runwork-ai/tap/runwork');
+        expect(skill.content).toContain('npx runwork@latest');
+        expect(skill.content).toContain('bunx runwork@latest');
+        expect(skill.content).not.toContain('@runworkai/cli');
+        expect(skill.content).not.toContain('npm install -g runwork');
+    });
     it('includes references section', () => {
         const skill = generateIntroSkill(makeContext());
         expect(skill.content).toContain('https://www.runwork.ai');

package/dist/agents/__tests__/skill-slug.test.d.ts

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

package/dist/agents/__tests__/skill-slug.test.js

@@ -0,0 +1,77 @@
+import { describe, it, expect } from 'vitest';
+import { toSlug, buildSkillMd } from '../types.js';
+describe('toSlug', () => {
+    it('converts spaces to hyphens', () => {
+        expect(toSlug('Write Cold Email')).toBe('write-cold-email');
+    });
+    it('lowercases', () => {
+        expect(toSlug('Developer Tools')).toBe('developer-tools');
+    });
+    it('collapses multiple non-alphanumeric chars', () => {
+        expect(toSlug('Link generate - quote payment')).toBe('link-generate-quote-payment');
+    });
+    it('strips leading and trailing hyphens', () => {
+        expect(toSlug('--test--')).toBe('test');
+        expect(toSlug('  hello  ')).toBe('hello');
+    });
+    it('preserves already-slugified names', () => {
+        expect(toSlug('my-skill')).toBe('my-skill');
+        expect(toSlug('runwork')).toBe('runwork');
+    });
+    it('handles special characters', () => {
+        expect(toSlug('Y Combinator slide maker')).toBe('y-combinator-slide-maker');
+        expect(toSlug("my test skill 1")).toBe('my-test-skill-1');
+    });
+});
+describe('buildSkillMd', () => {
+    function makeSkill(overrides = {}) {
+        return {
+            name: 'Write Cold Email',
+            filename: 'write-cold-email',
+            content: 'Some skill content',
+            description: 'A skill for writing emails',
+            ...overrides,
+        };
+    }
+    it('generates frontmatter with slugified name when no frontmatter exists', () => {
+        const result = buildSkillMd(makeSkill());
+        expect(result).toContain('name: write-cold-email');
+        expect(result).not.toContain('name: Write Cold Email');
+        expect(result).toContain('description: A skill for writing emails');
+        expect(result).toContain('Some skill content');
+    });
+    it('normalizes name in existing frontmatter', () => {
+        const result = buildSkillMd(makeSkill({
+            content: '---\nname: Write Cold Email\ndescription: existing desc\n---\n\nBody',
+        }));
+        expect(result).toContain('name: write-cold-email');
+        expect(result).not.toContain('name: Write Cold Email');
+        expect(result).toContain('description: existing desc');
+    });
+    it('normalizes quoted name in existing frontmatter', () => {
+        const result = buildSkillMd(makeSkill({
+            content: '---\nname: "Developer Tools"\ndescription: dev tools\n---\n\nBody',
+            name: 'Developer Tools',
+            filename: 'developer-tools',
+        }));
+        expect(result).toContain('name: developer-tools');
+        expect(result).not.toContain('Developer Tools');
+    });
+    it('preserves already-slugified name in existing frontmatter', () => {
+        const result = buildSkillMd(makeSkill({
+            content: '---\nname: write-cold-email\ndescription: desc\n---\n\nBody',
+        }));
+        expect(result).toContain('name: write-cold-email');
+    });
+    it('injects description when frontmatter exists without one', () => {
+        const result = buildSkillMd(makeSkill({
+            content: '---\nsome-key: value\n---\n\nBody',
+        }));
+        expect(result).toContain('name: write-cold-email');
+        expect(result).toContain('description: A skill for writing emails');
+    });
+    it('uses default description when none provided', () => {
+        const result = buildSkillMd(makeSkill({ description: '' }));
+        expect(result).toContain('description: Write Cold Email skill');
+    });
+});

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

@@ -1,7 +1,8 @@
-import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
+import type { AgentAdapter, AgentConfigOverride, AgentUsageStats, CleanupManifest, McpServerEntry, SkillFile, SkillUsageEntry } from './types.js';
 export declare class ClaudeCodeAdapter implements AgentAdapter {
     name: string;
     slug: string;
+    mcpProvidesSkills: boolean;
     detect(): Promise<boolean>;
     supportsMcpScope(_scope: 'project' | 'user'): boolean;
     supportsSkills(): boolean;
@@ -12,6 +13,7 @@ export declare class ClaudeCodeAdapter implements AgentAdapter {
     writeAgentConfig(config: AgentConfigOverride, scope: 'project' | 'user'): Promise<void>;
     /** Remove the managed marker and all entries after it from a permissions array */
     private removeAfterMarker;
+    cleanup(scope: 'project' | 'user', manifest?: CleanupManifest): Promise<void>;
     readUsageStats(lastSyncAt: string | null): Promise<AgentUsageStats | null>;
     readSkillUsage(lastSyncAt: string | null): Promise<SkillUsageEntry[] | null>;
     readVersion(): Promise<string | null>;