runwork 0.15.0 → 0.15.2

package/dist/commands/__tests__/sync-redetect.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-vi.mock('../../agents/detect.js', () => ({
-    detectAgents: vi.fn(),
-    // getAdapterBySlug is imported by sync.ts at module load; stub it so the
-    // import graph resolves without dragging in real adapter side-effects.
-    getAdapterBySlug: vi.fn(() => undefined),
-}));
-import { detectAgents } from '../../agents/detect.js';
-import { shouldRedetect, refreshConfiguredAgents, REDETECT_TTL_MS, } from '../sync.js';
-const baseOpts = {
-    dryRun: false,
-    pullOnly: false,
-    yes: true,
-};
-function makeState(overrides = {}) {
-    return {
-        workspaceId: 'ws-1',
-        workspaceName: 'Test',
-        configuredAgents: ['claude-code'],
-        scope: 'user',
-        lastSyncAt: '',
-        mcpServers: [],
-        skills: [],
-        skillHashes: {},
-        lastDetectedAt: new Date().toISOString(),
-        ...overrides,
-    };
-}
-function fakeAdapter(slug) {
-    return {
-        name: slug,
-        slug,
-        detect: async () => true,
-        writeMcpServers: async () => { },
-        writeSkills: async () => { },
-        writeInstructionHint: async () => { },
-        supportsSkills: () => false,
-        supportsMcpScope: () => false,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-});
-describe('shouldRedetect', () => {
-    it('returns true when --redetect is passed even on fresh state', () => {
-        expect(shouldRedetect(makeState(), { ...baseOpts, redetect: true })).toBe(true);
-    });
-    it('returns true when configuredAgents is empty (recovery)', () => {
-        expect(shouldRedetect(makeState({ configuredAgents: [] }), baseOpts)).toBe(true);
-    });
-    it('returns true when lastDetectedAt is missing (first sync)', () => {
-        expect(shouldRedetect(makeState({ lastDetectedAt: undefined }), baseOpts)).toBe(true);
-    });
-    it('returns true when lastDetectedAt is unparseable (corrupt state)', () => {
-        expect(shouldRedetect(makeState({ lastDetectedAt: 'not-a-date' }), baseOpts)).toBe(true);
-    });
-    it('returns true when lastDetectedAt is older than the TTL', () => {
-        const stale = new Date(Date.now() - REDETECT_TTL_MS - 1000).toISOString();
-        expect(shouldRedetect(makeState({ lastDetectedAt: stale }), baseOpts)).toBe(true);
-    });
-    it('returns false when lastDetectedAt is fresh (within TTL)', () => {
-        const fresh = new Date(Date.now() - 60_000).toISOString();
-        expect(shouldRedetect(makeState({ lastDetectedAt: fresh }), baseOpts)).toBe(false);
-    });
-});
-describe('refreshConfiguredAgents', () => {
-    it('appends newly-detected agents and returns the diff', async () => {
-        vi.mocked(detectAgents).mockResolvedValue([
-            fakeAdapter('claude-code'),
-            fakeAdapter('codex'),
-            fakeAdapter('cursor'),
-        ]);
-        const state = makeState({ configuredAgents: ['claude-code'], lastDetectedAt: undefined });
-        const added = await refreshConfiguredAgents(state);
-        expect(added.sort()).toEqual(['codex', 'cursor']);
-        expect(state.configuredAgents.sort()).toEqual(['claude-code', 'codex', 'cursor']);
-        expect(state.lastDetectedAt).toBeTruthy();
-    });
-    it('returns empty diff and stamps lastDetectedAt when nothing new is found', async () => {
-        vi.mocked(detectAgents).mockResolvedValue([fakeAdapter('claude-code')]);
-        const state = makeState({ configuredAgents: ['claude-code'], lastDetectedAt: undefined });
-        const added = await refreshConfiguredAgents(state);
-        expect(added).toEqual([]);
-        expect(state.configuredAgents).toEqual(['claude-code']);
-        expect(state.lastDetectedAt).toBeTruthy();
-    });
-    it('never removes agents that are no longer detected', async () => {
-        // A transient PATH glitch or temporarily-unmounted disk shouldn't wipe
-        // an agent the user explicitly configured. Removal is opt-in via setup.
-        vi.mocked(detectAgents).mockResolvedValue([fakeAdapter('claude-code')]);
-        const state = makeState({ configuredAgents: ['claude-code', 'codex', 'cursor'] });
-        const added = await refreshConfiguredAgents(state);
-        expect(added).toEqual([]);
-        expect(state.configuredAgents.sort()).toEqual(['claude-code', 'codex', 'cursor']);
-    });
-});

package/dist/commands/__tests__/sync-telemetry.test.d.ts

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

package/dist/commands/__tests__/sync-telemetry.test.js

@@ -1,281 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { collectTelemetryEvents, summarizeTelemetryForDryRun } from '../sync-telemetry.js';
-function mockAdapter(slug, opts = {}) {
-    return {
-        slug,
-        name: slug,
-        detect: async () => true,
-        supportsSkills: () => false,
-        supportsMcpScope: () => false,
-        writeSkills: async () => { },
-        writeMcpServers: async () => { },
-        writeInstructionHint: async () => { },
-        ...opts,
-    };
-}
-function baseState(overrides = {}) {
-    return {
-        workspaceId: 'ws-1',
-        workspaceName: 'Test',
-        configuredAgents: [],
-        scope: 'user',
-        lastSyncAt: '2026-04-13T00:00:00.000Z',
-        mcpServers: [],
-        skills: [],
-        ...overrides,
-    };
-}
-const NOW = '2026-04-14T00:00:00.000Z';
-describe('collectTelemetryEvents', () => {
-    it('always emits a sync_completed event with aggregate counts', async () => {
-        const result = await collectTelemetryEvents({
-            adapters: [],
-            state: baseState(),
-            syncedSkillsCount: 5,
-            syncedMcpServersCount: 2,
-            teamInstructionsApplied: true,
-            agentConfigsApplied: 1,
-            now: NOW,
-        });
-        const syncCompleted = result.events.find(e => e.eventType === 'local_agent.sync_completed');
-        expect(syncCompleted).toBeDefined();
-        expect(syncCompleted?.metadata).toMatchObject({
-            syncedSkills: 5,
-            syncedMcpServers: 2,
-            teamInstructionsApplied: true,
-            agentConfigsApplied: 1,
-        });
-    });
-    it('emits local_agent.detected only for newly seen agents', async () => {
-        const result = await collectTelemetryEvents({
-            adapters: [],
-            state: baseState({
-                configuredAgents: ['claude-code', 'cursor', 'codex'],
-                reportedAgentSlugs: ['claude-code'],
-            }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        const detectedSlugs = result.events
-            .filter(e => e.eventType === 'local_agent.detected')
-            .map(e => e.agentSlug);
-        expect(detectedSlugs).toEqual(['cursor', 'codex']);
-        expect(result.newlyReportedAgents).toEqual(['cursor', 'codex']);
-    });
-    it('emits local_agent.usage when adapter reports hasNewActivity', async () => {
-        const stats = {
-            hasNewActivity: true,
-            sessionCount: 3,
-            messageCount: 42,
-            toolCallCount: 10,
-            tokensUsed: 1000,
-            aiLinesAdded: 50,
-            aiLinesRemoved: 10,
-            lastActiveAt: '2026-04-13T23:00:00.000Z',
-            modelsUsed: ['sonnet'],
-            mcpToolCount: 5,
-            extra: { customField: 'value' },
-        };
-        const adapter = mockAdapter('claude-code', {
-            readUsageStats: async () => stats,
-        });
-        const result = await collectTelemetryEvents({
-            adapters: [adapter],
-            state: baseState({ configuredAgents: ['claude-code'], reportedAgentSlugs: ['claude-code'] }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        const usage = result.events.find(e => e.eventType === 'local_agent.usage');
-        expect(usage).toBeDefined();
-        expect(usage?.agentSlug).toBe('claude-code');
-        expect(usage?.metadata).toMatchObject({
-            sessionCount: 3,
-            messageCount: 42,
-            tokensUsed: 1000,
-            mcpToolCount: 5,
-            customField: 'value',
-        });
-        expect(result.adapterResults[0].stats).toEqual(stats);
-    });
-    it('does not emit usage event when hasNewActivity is false', async () => {
-        const adapter = mockAdapter('cursor', {
-            readUsageStats: async () => ({
-                hasNewActivity: false,
-                sessionCount: 0,
-                messageCount: 0,
-                toolCallCount: 0,
-                tokensUsed: 0,
-                aiLinesAdded: 0,
-                aiLinesRemoved: 0,
-                lastActiveAt: null,
-            }),
-        });
-        const result = await collectTelemetryEvents({
-            adapters: [adapter],
-            state: baseState({ configuredAgents: ['cursor'], reportedAgentSlugs: ['cursor'] }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        expect(result.events.find(e => e.eventType === 'local_agent.usage')).toBeUndefined();
-        expect(result.adapterResults[0].stats).toBeTruthy();
-    });
-    it('marks stats and skills as unsupported when adapter lacks readers', async () => {
-        const adapter = mockAdapter('cline');
-        const result = await collectTelemetryEvents({
-            adapters: [adapter],
-            state: baseState({ configuredAgents: ['cline'], reportedAgentSlugs: ['cline'] }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        expect(result.adapterResults[0].stats).toBe('unsupported');
-        expect(result.adapterResults[0].skills).toBe('unsupported');
-    });
-    it('captures errors thrown by readUsageStats without failing overall collection', async () => {
-        const good = mockAdapter('codex', {
-            readUsageStats: async () => ({
-                hasNewActivity: true,
-                sessionCount: 1,
-                messageCount: 0,
-                toolCallCount: 0,
-                tokensUsed: 100,
-                aiLinesAdded: 0,
-                aiLinesRemoved: 0,
-                lastActiveAt: NOW,
-            }),
-        });
-        const broken = mockAdapter('cursor', {
-            readUsageStats: async () => {
-                throw new Error('db locked');
-            },
-        });
-        const result = await collectTelemetryEvents({
-            adapters: [broken, good],
-            state: baseState({
-                configuredAgents: ['cursor', 'codex'],
-                reportedAgentSlugs: ['cursor', 'codex'],
-            }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        const brokenResult = result.adapterResults.find(r => r.slug === 'cursor');
-        expect(brokenResult?.error).toContain('db locked');
-        expect(brokenResult?.stats).toBeNull();
-        const goodResult = result.adapterResults.find(r => r.slug === 'codex');
-        expect(goodResult?.error).toBeUndefined();
-        expect(result.events
-            .filter(e => e.eventType === 'local_agent.usage')
-            .map(e => e.agentSlug)).toEqual(['codex']);
-    });
-    it('emits one skill_used event per skill entry', async () => {
-        const entries = [
-            { skillName: 'runwork', count: 1, lastUsedAt: '2026-04-13T12:00:00.000Z' },
-            { skillName: 'seo-content-strategist', count: 2, lastUsedAt: '2026-04-13T13:00:00.000Z' },
-        ];
-        const adapter = mockAdapter('claude-code', {
-            readSkillUsage: async () => entries,
-        });
-        const result = await collectTelemetryEvents({
-            adapters: [adapter],
-            state: baseState({ configuredAgents: ['claude-code'], reportedAgentSlugs: ['claude-code'] }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        const skillEvents = result.events.filter(e => e.eventType === 'local_agent.skill_used');
-        expect(skillEvents).toHaveLength(2);
-        expect(skillEvents[0].metadata?.skillName).toBe('runwork');
-        expect(skillEvents[1].metadata?.skillName).toBe('seo-content-strategist');
-    });
-    it('reports health when lastHealthReportAt is missing', async () => {
-        const adapter = mockAdapter('codex', {
-            readVersion: async () => '0.5.0',
-        });
-        const result = await collectTelemetryEvents({
-            adapters: [adapter],
-            state: baseState({ configuredAgents: ['codex'], reportedAgentSlugs: ['codex'] }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        expect(result.healthReported).toBe(true);
-        const health = result.events.find(e => e.eventType === 'local_agent.health');
-        expect(health?.metadata?.version).toBe('0.5.0');
-        expect(health?.metadata?.installed).toBe(true);
-    });
-    it('skips health when last reported less than 24h ago', async () => {
-        const recent = new Date(Date.now() - 60 * 60 * 1000).toISOString();
-        const adapter = mockAdapter('codex', {
-            readVersion: async () => '0.5.0',
-        });
-        const result = await collectTelemetryEvents({
-            adapters: [adapter],
-            state: baseState({
-                configuredAgents: ['codex'],
-                reportedAgentSlugs: ['codex'],
-                lastHealthReportAt: recent,
-            }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        expect(result.healthReported).toBe(false);
-        expect(result.events.find(e => e.eventType === 'local_agent.health')).toBeUndefined();
-    });
-});
-describe('summarizeTelemetryForDryRun', () => {
-    it('counts adapters with active stats', async () => {
-        const result = await collectTelemetryEvents({
-            adapters: [
-                mockAdapter('codex', {
-                    readUsageStats: async () => ({
-                        hasNewActivity: true,
-                        sessionCount: 1,
-                        messageCount: 0,
-                        toolCallCount: 0,
-                        tokensUsed: 0,
-                        aiLinesAdded: 0,
-                        aiLinesRemoved: 0,
-                        lastActiveAt: NOW,
-                    }),
-                }),
-                mockAdapter('cursor', {
-                    readUsageStats: async () => null,
-                }),
-                mockAdapter('cline'),
-            ],
-            state: baseState({
-                configuredAgents: ['codex', 'cursor', 'cline'],
-                reportedAgentSlugs: ['codex', 'cursor', 'cline'],
-            }),
-            syncedSkillsCount: 0,
-            syncedMcpServersCount: 0,
-            teamInstructionsApplied: false,
-            agentConfigsApplied: 0,
-            now: NOW,
-        });
-        const summary = summarizeTelemetryForDryRun(result);
-        expect(summary).toContain('1 adapter with activity');
-        expect(summary).toContain('events would be sent');
-    });
-});

package/dist/commands/__tests__/upgrade.test.d.ts

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

package/dist/commands/__tests__/upgrade.test.js

@@ -1,157 +0,0 @@
-/**
- * Tests for `runwork upgrade`.
- *
- * The module under test has top-level side effects (it builds a Commander
- * command and captures `httpFetch` references), so we exercise the exported
- * __internal helpers against a local HTTP server that serves a fake
- * /cli/latest.json. We intercept `httpFetch` and rewrite the LATEST_JSON_URL
- * to point at the test server so the actual node:https-backed wrapper is
- * exercised end to end.
- */
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { createServer } from 'node:http';
-let currentServerUrl = null;
-vi.mock('../../utils/http.js', async () => {
-    const actual = await vi.importActual('../../utils/http.js');
-    return {
-        ...actual,
-        httpFetch: (url, init) => {
-            if (currentServerUrl && url.endsWith('/cli/latest.json')) {
-                return actual.httpFetch(`${currentServerUrl}/cli/latest.json`, init);
-            }
-            return actual.httpFetch(url, init);
-        },
-    };
-});
-import { __internal } from '../upgrade.js';
-function startJsonServer(body, status = 200) {
-    return new Promise((resolvePromise) => {
-        const server = createServer((req, res) => {
-            if (req.url === '/cli/latest.json') {
-                if (body === null) {
-                    res.writeHead(status, { 'Content-Type': 'application/json' });
-                    res.end('{"error": "not found"}');
-                    return;
-                }
-                res.writeHead(status, {
-                    'Content-Type': 'application/json; charset=utf-8',
-                });
-                res.end(JSON.stringify(body));
-                return;
-            }
-            res.writeHead(404);
-            res.end('not found');
-        });
-        server.listen(0, '127.0.0.1', () => {
-            const addr = server.address();
-            if (addr && typeof addr === 'object') {
-                const url = `http://127.0.0.1:${addr.port}`;
-                const stop = () => new Promise((resolveStop) => {
-                    server.close(() => resolveStop());
-                });
-                resolvePromise({ url, stop });
-            }
-        });
-    });
-}
-describe('__internal.fetchLatestVersion', () => {
-    let originalBase;
-    let serverStop = null;
-    beforeEach(() => {
-        originalBase = process.env.RUNWORK_DOWNLOAD_BASE_URL;
-    });
-    afterEach(async () => {
-        if (serverStop)
-            await serverStop();
-        serverStop = null;
-        currentServerUrl = null;
-        if (originalBase === undefined)
-            delete process.env.RUNWORK_DOWNLOAD_BASE_URL;
-        else
-            process.env.RUNWORK_DOWNLOAD_BASE_URL = originalBase;
-    });
-    it('parses the version field from a valid manifest', async () => {
-        const server = await startJsonServer({
-            name: 'runwork',
-            version: '1.2.3',
-            publishedAt: '2026-04-14T00:00:00Z',
-            artifacts: {},
-        });
-        serverStop = server.stop;
-        currentServerUrl = server.url;
-        const version = await __internal.fetchLatestVersion();
-        expect(version).toBe('1.2.3');
-    });
-    it('strips a leading v from the version', async () => {
-        const server = await startJsonServer({ version: 'v9.9.9' });
-        serverStop = server.stop;
-        currentServerUrl = server.url;
-        const version = await __internal.fetchLatestVersion();
-        expect(version).toBe('9.9.9');
-    });
-    it('returns null on HTTP error', async () => {
-        const server = await startJsonServer(null, 500);
-        serverStop = server.stop;
-        currentServerUrl = server.url;
-        const version = await __internal.fetchLatestVersion();
-        expect(version).toBeNull();
-    });
-    it('returns null when fetch throws', async () => {
-        // Point at a port that is virtually guaranteed to refuse connections.
-        currentServerUrl = 'http://127.0.0.1:1';
-        const version = await __internal.fetchLatestVersion();
-        expect(version).toBeNull();
-    });
-    it('returns null when the manifest has no version field', async () => {
-        const server = await startJsonServer({ name: 'runwork' });
-        serverStop = server.stop;
-        currentServerUrl = server.url;
-        const version = await __internal.fetchLatestVersion();
-        expect(version).toBeNull();
-    });
-});
-describe('__internal endpoint constants', () => {
-    it('all endpoints live on runwork.ai', () => {
-        expect(__internal.BASE_URL).toBe('https://runwork.ai');
-        expect(__internal.LATEST_JSON_URL).toBe('https://runwork.ai/cli/latest.json');
-        expect(__internal.INSTALL_SH_URL).toBe('https://runwork.ai/install.sh');
-        expect(__internal.INSTALL_PS1_URL).toBe('https://runwork.ai/install.ps1');
-    });
-    it('does not reference api.github.com or github.com/.../releases', () => {
-        const values = Object.values(__internal).filter((v) => typeof v === 'string');
-        for (const v of values) {
-            expect(v).not.toContain('api.github.com');
-            expect(v).not.toContain('/releases');
-        }
-    });
-});
-describe('__internal.detectInstallMethod', () => {
-    const originalArgv1 = process.argv[1];
-    afterEach(() => {
-        process.argv[1] = originalArgv1;
-    });
-    it('detects homebrew installs', () => {
-        process.argv[1] = '/opt/homebrew/Cellar/runwork/0.6.2/bin/runwork';
-        expect(__internal.detectInstallMethod()).toBe('brew');
-    });
-    it('detects bun global installs', () => {
-        process.argv[1] = '/Users/user/.bun/install/global/node_modules/runwork/bin/runwork.js';
-        expect(__internal.detectInstallMethod()).toBe('bun');
-    });
-    it('detects pnpm global installs', () => {
-        process.argv[1] = '/Users/user/.local/share/pnpm/global/5/node_modules/runwork/bin/runwork.js';
-        expect(__internal.detectInstallMethod()).toBe('pnpm');
-    });
-    it('detects yarn global installs', () => {
-        process.argv[1] = '/Users/user/.yarn/bin/runwork';
-        expect(__internal.detectInstallMethod()).toBe('yarn');
-    });
-    it('detects volta installs', () => {
-        process.argv[1] = '/Users/user/.volta/tools/image/packages/runwork/bin/runwork';
-        expect(__internal.detectInstallMethod()).toBe('volta');
-    });
-    it('falls back to binary for standalone paths', () => {
-        process.argv[1] = '/Users/user/.runwork/bin/runwork';
-        expect(__internal.detectInstallMethod()).toBe('binary');
-    });
-});

package/dist/commands/agents.d.ts

@@ -1,2 +0,0 @@
-import { Command } from 'commander';
-export declare const agentsCommand: Command;