runwork 0.15.0 → 0.15.2

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

@@ -1,154 +0,0 @@
-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-cowork-memory-tests';
-vi.mock('os', async () => {
-    const actual = await vi.importActual('os');
-    return {
-        ...actual,
-        homedir: vi.fn(() => mockHomeDir),
-        platform: vi.fn(() => 'darwin'),
-    };
-});
-import { ClaudeDesktopAdapter, getCoworkMemoryClaudeMdPaths } from '../claude-desktop.js';
-const SESSION_A = 'session-a';
-const SESSION_B = 'session-b';
-const ORG_1 = 'org-1';
-const ORG_2 = 'org-2';
-function coworkBase(homeDir) {
-    return join(homeDir, 'Library', 'Application Support', 'Claude', 'local-agent-mode-sessions');
-}
-function makeOrg(homeDir, sessionId, orgId) {
-    const orgDir = join(coworkBase(homeDir), sessionId, orgId);
-    mkdirSync(orgDir, { recursive: true });
-    return orgDir;
-}
-describe('ClaudeDesktopAdapter Cowork memory/CLAUDE.md', () => {
-    let tempHomeDir;
-    beforeEach(() => {
-        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-cowork-memory-'));
-        mockHomeDir = tempHomeDir;
-    });
-    afterEach(() => {
-        rmSync(tempHomeDir, { recursive: true, force: true });
-    });
-    describe('getCoworkMemoryClaudeMdPaths', () => {
-        it('returns no paths when the cowork base dir does not exist', () => {
-            expect(getCoworkMemoryClaudeMdPaths()).toEqual([]);
-        });
-        it('collects one path per session/org', () => {
-            makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            makeOrg(tempHomeDir, SESSION_A, ORG_2);
-            makeOrg(tempHomeDir, SESSION_B, ORG_1);
-            const paths = getCoworkMemoryClaudeMdPaths();
-            expect(paths).toHaveLength(3);
-            expect(paths).toContain(join(coworkBase(tempHomeDir), SESSION_A, ORG_1, 'memory', 'CLAUDE.md'));
-            expect(paths).toContain(join(coworkBase(tempHomeDir), SESSION_A, ORG_2, 'memory', 'CLAUDE.md'));
-            expect(paths).toContain(join(coworkBase(tempHomeDir), SESSION_B, ORG_1, 'memory', 'CLAUDE.md'));
-        });
-        it('ignores hidden entries and the skills-plugin sibling directory', () => {
-            const base = coworkBase(tempHomeDir);
-            mkdirSync(join(base, '.DS_Store'), { recursive: true });
-            mkdirSync(join(base, 'skills-plugin'), { recursive: true });
-            makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            expect(getCoworkMemoryClaudeMdPaths()).toEqual([
-                join(base, SESSION_A, ORG_1, 'memory', 'CLAUDE.md'),
-            ]);
-        });
-    });
-    describe('writeInstructionHint', () => {
-        it('writes a marker-delimited hint to each org memory/CLAUDE.md', async () => {
-            makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            makeOrg(tempHomeDir, SESSION_A, ORG_2);
-            const adapter = new ClaudeDesktopAdapter();
-            await adapter.writeInstructionHint('<!-- runwork:start -->\nhello from runwork\n<!-- runwork:end -->', 'user');
-            for (const orgId of [ORG_1, ORG_2]) {
-                const filePath = join(coworkBase(tempHomeDir), SESSION_A, orgId, 'memory', 'CLAUDE.md');
-                expect(existsSync(filePath)).toBe(true);
-                const content = readFileSync(filePath, 'utf-8');
-                expect(content).toContain('<!-- runwork:start -->');
-                expect(content).toContain('hello from runwork');
-                expect(content).toContain('<!-- runwork:end -->');
-            }
-        });
-        it('preserves user-authored content above and below the marker block', async () => {
-            const orgDir = makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            const memoryDir = join(orgDir, 'memory');
-            mkdirSync(memoryDir, { recursive: true });
-            const filePath = join(memoryDir, 'CLAUDE.md');
-            writeFileSync(filePath, 'user-authored line 1\nuser-authored line 2\n');
-            const adapter = new ClaudeDesktopAdapter();
-            await adapter.writeInstructionHint('<!-- runwork:start -->\nhint\n<!-- runwork:end -->', 'user');
-            const content = readFileSync(filePath, 'utf-8');
-            expect(content).toContain('user-authored line 1');
-            expect(content).toContain('user-authored line 2');
-            expect(content).toContain('hint');
-        });
-        it('replaces an existing Runwork hint block in place', async () => {
-            const orgDir = makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            const memoryDir = join(orgDir, 'memory');
-            mkdirSync(memoryDir, { recursive: true });
-            const filePath = join(memoryDir, 'CLAUDE.md');
-            writeFileSync(filePath, 'before\n<!-- runwork:start -->\nOLD HINT\n<!-- runwork:end -->\nafter\n');
-            const adapter = new ClaudeDesktopAdapter();
-            await adapter.writeInstructionHint('<!-- runwork:start -->\nNEW HINT\n<!-- runwork:end -->', 'user');
-            const content = readFileSync(filePath, 'utf-8');
-            expect(content).toContain('before');
-            expect(content).toContain('after');
-            expect(content).toContain('NEW HINT');
-            expect(content).not.toContain('OLD HINT');
-        });
-    });
-    describe('writeTeamInstructions', () => {
-        it('writes team instructions to each org memory/CLAUDE.md', async () => {
-            makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            const adapter = new ClaudeDesktopAdapter();
-            await adapter.writeTeamInstructions('Always reply in British English.', 'user');
-            const filePath = join(coworkBase(tempHomeDir), SESSION_A, ORG_1, 'memory', 'CLAUDE.md');
-            const content = readFileSync(filePath, 'utf-8');
-            expect(content).toContain('<!-- runwork-team:start -->');
-            expect(content).toContain('Always reply in British English.');
-            expect(content).toContain('<!-- runwork-team:end -->');
-        });
-        it('coexists with a hint block in the same file', async () => {
-            makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            const adapter = new ClaudeDesktopAdapter();
-            await adapter.writeInstructionHint('<!-- runwork:start -->\nhint body\n<!-- runwork:end -->', 'user');
-            await adapter.writeTeamInstructions('team body', 'user');
-            const filePath = join(coworkBase(tempHomeDir), SESSION_A, ORG_1, 'memory', 'CLAUDE.md');
-            const content = readFileSync(filePath, 'utf-8');
-            expect(content).toContain('hint body');
-            expect(content).toContain('<!-- runwork-team:start -->');
-            expect(content).toContain('team body');
-            expect(content).toContain('<!-- runwork-team:end -->');
-        });
-    });
-    describe('cleanup', () => {
-        it('strips both marker blocks from each org memory/CLAUDE.md, preserving user content', async () => {
-            const orgDir = makeOrg(tempHomeDir, SESSION_A, ORG_1);
-            const memoryDir = join(orgDir, 'memory');
-            mkdirSync(memoryDir, { recursive: true });
-            const filePath = join(memoryDir, 'CLAUDE.md');
-            writeFileSync(filePath, [
-                'user content top',
-                '<!-- runwork:start -->',
-                'hint body',
-                '<!-- runwork:end -->',
-                '<!-- runwork-team:start -->',
-                'team body',
-                '<!-- runwork-team:end -->',
-                'user content bottom',
-            ].join('\n'));
-            const adapter = new ClaudeDesktopAdapter();
-            await adapter.cleanup('user');
-            const content = readFileSync(filePath, 'utf-8');
-            expect(content).toContain('user content top');
-            expect(content).toContain('user content bottom');
-            expect(content).not.toContain('runwork:start');
-            expect(content).not.toContain('runwork-team:start');
-            expect(content).not.toContain('hint body');
-            expect(content).not.toContain('team body');
-        });
-    });
-});

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

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

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

@@ -1,161 +0,0 @@
-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

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

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

@@ -1,117 +0,0 @@
-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

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

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

@@ -1,126 +0,0 @@
-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__/claude-desktop-stats.test.d.ts

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