runwork 0.5.1 → 0.6.1

package/dist/agents/__tests__/claude-code-stats.test.d.ts

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

package/dist/agents/__tests__/claude-code-stats.test.js

@@ -0,0 +1,153 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { execFileSync } from 'child_process';
+import path from 'path';
+vi.mock('fs');
+vi.mock('os');
+vi.mock('child_process');
+// Avoid side-effects from other imports in claude-code.ts that use fs/os
+vi.mock('../utils/json-config.js', () => ({
+    mergeJsonMcpServers: vi.fn(),
+    readJsonConfig: vi.fn(() => ({})),
+    writeJsonConfig: vi.fn(),
+}));
+vi.mock('../utils/instruction-hint.js', () => ({
+    writeHintToFile: vi.fn(),
+}));
+import { ClaudeCodeAdapter } from '../claude-code.js';
+const FIXTURE_STATS = path.resolve(__dirname, './fixtures/claude-code/stats-cache.json');
+// Read the real fixture once for use in mocks
+// (We read it at import time before mocks interfere, via a direct require)
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realFs = require('fs');
+const fixtureContent = realFs.readFileSync(FIXTURE_STATS, 'utf-8');
+let adapter;
+beforeEach(() => {
+    vi.restoreAllMocks();
+    vi.mocked(homedir).mockReturnValue('/mock-home');
+    adapter = new ClaudeCodeAdapter();
+});
+// Helper: make existsSync return true only for specified paths
+function mockExistsPaths(paths) {
+    vi.mocked(existsSync).mockImplementation((p) => paths.includes(p));
+}
+describe('ClaudeCodeAdapter.readUsageStats', () => {
+    it('parses stats-cache.json and returns correct totals when lastSyncAt is null', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/stats-cache.json',
+        ]);
+        vi.mocked(readFileSync).mockReturnValue(fixtureContent);
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).not.toBeNull();
+        // All 6 days: 15+22+0+40+10+35 = 122 messages
+        expect(stats.messageCount).toBe(122);
+        // 2+3+0+4+1+5 = 15 sessions
+        expect(stats.sessionCount).toBe(15);
+        // 8+12+0+25+5+18 = 68 tool calls
+        expect(stats.toolCallCount).toBe(68);
+        expect(stats.hasNewActivity).toBe(true);
+    });
+    it('filters days after lastSyncAt date', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/stats-cache.json',
+        ]);
+        vi.mocked(readFileSync).mockReturnValue(fixtureContent);
+        const stats = await adapter.readUsageStats('2026-03-27T00:00:00Z');
+        expect(stats).not.toBeNull();
+        // Days after 2026-03-27: 28, 29, 30 => 40+10+35 = 85
+        expect(stats.messageCount).toBe(85);
+        // 4+1+5 = 10
+        expect(stats.sessionCount).toBe(10);
+        // 25+5+18 = 48
+        expect(stats.toolCallCount).toBe(48);
+    });
+    it('returns null when all data is before lastSyncAt', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/stats-cache.json',
+        ]);
+        vi.mocked(readFileSync).mockReturnValue(fixtureContent);
+        const stats = await adapter.readUsageStats('2099-01-01T00:00:00Z');
+        expect(stats).toBeNull();
+    });
+    it('returns null when ~/.claude does not exist', async () => {
+        mockExistsPaths([]);
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).toBeNull();
+    });
+    it('returns null on corrupted stats-cache.json', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/stats-cache.json',
+        ]);
+        vi.mocked(readFileSync).mockReturnValue('not valid json {{{');
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).toBeNull();
+    });
+    it('returns null on unexpected schema (missing dailyActivity)', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/stats-cache.json',
+        ]);
+        vi.mocked(readFileSync).mockReturnValue(JSON.stringify({ version: 2 }));
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).toBeNull();
+    });
+    it('returns null on empty dailyActivity array', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/stats-cache.json',
+        ]);
+        vi.mocked(readFileSync).mockReturnValue(JSON.stringify({ version: 2, dailyActivity: [] }));
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).toBeNull();
+    });
+    it('falls back to session-env directory counting when stats-cache.json missing', async () => {
+        mockExistsPaths([
+            '/mock-home/.claude',
+            '/mock-home/.claude/session-env',
+        ]);
+        vi.mocked(readdirSync).mockReturnValue(['session-a', 'session-b', 'session-c']);
+        vi.mocked(statSync).mockImplementation((p) => {
+            const name = p.split('/').pop();
+            const mtimes = {
+                'session-a': Date.now() - 1000,
+                'session-b': Date.now() - 2000,
+                'session-c': Date.now() - 3000,
+            };
+            return { mtimeMs: mtimes[name] ?? 0 };
+        });
+        const stats = await adapter.readUsageStats(null);
+        expect(stats).not.toBeNull();
+        expect(stats.sessionCount).toBe(3);
+        expect(stats.messageCount).toBe(0);
+        expect(stats.hasNewActivity).toBe(true);
+    });
+});
+describe('ClaudeCodeAdapter.readVersion', () => {
+    it('returns version string from claude --version', async () => {
+        vi.mocked(execFileSync).mockReturnValue(Buffer.from('claude-code 1.0.23\n'));
+        const version = await adapter.readVersion();
+        expect(version).toBe('claude-code 1.0.23');
+        expect(execFileSync).toHaveBeenCalledWith('claude', ['--version'], {
+            stdio: 'pipe',
+        });
+    });
+    it('returns null when claude is not installed', async () => {
+        vi.mocked(execFileSync).mockImplementation(() => {
+            throw new Error('ENOENT');
+        });
+        const version = await adapter.readVersion();
+        expect(version).toBeNull();
+    });
+});
+describe('ClaudeCodeAdapter.readSkillUsage', () => {
+    it('returns null when no skills directory exists', async () => {
+        vi.mocked(existsSync).mockReturnValue(false);
+        const usage = await adapter.readSkillUsage(null);
+        expect(usage).toBeNull();
+    });
+});

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

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

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

@@ -0,0 +1,280 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+vi.mock('fs', () => ({
+    existsSync: vi.fn(),
+    readdirSync: vi.fn(),
+    readFileSync: vi.fn(),
+    statSync: vi.fn(),
+    writeFileSync: vi.fn(),
+    mkdirSync: vi.fn(),
+}));
+vi.mock('os', () => ({
+    homedir: vi.fn(() => '/mock/home'),
+    platform: vi.fn(() => 'darwin'),
+}));
+// Mock the utility imports so the module loads cleanly
+vi.mock('../utils/json-config.js', () => ({
+    mergeJsonMcpServers: vi.fn(),
+    readJsonConfig: vi.fn(() => ({})),
+    writeJsonConfig: vi.fn(),
+}));
+import { existsSync, readdirSync, readFileSync, statSync } from 'fs';
+import { ClaudeDesktopAdapter } from '../claude-desktop.js';
+import * as path from 'path';
+const CLAUDE_APP_DIR = '/mock/home/Library/Application Support/Claude';
+const AGENT_SESSIONS_DIR = `${CLAUDE_APP_DIR}/local-agent-mode-sessions`;
+const CODE_SESSIONS_DIR = `${CLAUDE_APP_DIR}/claude-code-sessions`;
+const SCHEDULED_TASKS_PATH = `${CLAUDE_APP_DIR}/scheduled-tasks.json`;
+const SDK_VERSION_PATH = `${CLAUDE_APP_DIR}/claude-code/sdk-version`;
+// Fixture data
+const SESSION_1 = JSON.stringify({
+    sessionId: 'test-session-1',
+    title: 'Test coding session',
+    model: 'claude-opus-4-6',
+    createdAt: 1711929600000,
+    lastActivityAt: 1711933200000,
+    isArchived: false,
+    cwd: '/test/project',
+    memoryEnabled: true,
+    enabledMcpTools: { 'tool-a': {}, 'tool-b': {}, 'tool-c': {} },
+});
+const SESSION_2 = JSON.stringify({
+    sessionId: 'test-session-2',
+    title: 'Research session',
+    model: 'claude-sonnet-4-6',
+    createdAt: 1712000000000,
+    lastActivityAt: 1712003600000,
+    isArchived: false,
+    cwd: '/test/other',
+    memoryEnabled: true,
+});
+const SCHEDULED_TASKS = JSON.stringify([
+    {
+        name: 'daily-research',
+        createdAt: '2026-03-01T00:00:00Z',
+        lastRunAt: '2026-03-30T06:00:00Z',
+        lastScheduledFor: '2026-03-30T06:00:00Z',
+    },
+]);
+// Helper to set up the typical org/user directory structure
+function setupSessionDirs(baseDir, sessions) {
+    const orgIds = [...new Set(sessions.map(s => s.orgId))];
+    const userIds = [...new Set(sessions.map(s => `${s.orgId}/${s.userId}`))];
+    readdirSync.mockImplementation((dir) => {
+        if (dir === baseDir)
+            return orgIds;
+        for (const org of orgIds) {
+            if (dir === path.join(baseDir, org)) {
+                // Deduplicate userIds within this org
+                return [...new Set(sessions.filter(s => s.orgId === org).map(s => s.userId))];
+            }
+        }
+        for (const uid of userIds) {
+            if (dir === path.join(baseDir, uid)) {
+                return sessions.filter(s => `${s.orgId}/${s.userId}` === uid).map(s => s.fileName);
+            }
+        }
+        return [];
+    });
+    statSync.mockImplementation(() => ({
+        isDirectory: () => true,
+    }));
+    readFileSync.mockImplementation((filePath) => {
+        for (const s of sessions) {
+            if (filePath === path.join(baseDir, s.orgId, s.userId, s.fileName)) {
+                return s.content;
+            }
+        }
+        if (filePath === SCHEDULED_TASKS_PATH)
+            return SCHEDULED_TASKS;
+        if (filePath === SDK_VERSION_PATH)
+            return '1.2.3\n';
+        return '';
+    });
+}
+describe('ClaudeDesktopAdapter.readUsageStats', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = new ClaudeDesktopAdapter();
+        // Default: Claude app dir exists
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            return false;
+        });
+    });
+    it('reads and counts sessions across org/user directories', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        setupSessionDirs(AGENT_SESSIONS_DIR, [
+            { orgId: 'org1', userId: 'user1', fileName: 'session1.json', content: SESSION_1 },
+            { orgId: 'org1', userId: 'user2', fileName: 'session2.json', content: SESSION_2 },
+        ]);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.sessionCount).toBe(2);
+        expect(result.hasNewActivity).toBe(true);
+    });
+    it('filters sessions by lastSyncAt', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        setupSessionDirs(AGENT_SESSIONS_DIR, [
+            { orgId: 'org1', userId: 'user1', fileName: 'session1.json', content: SESSION_1 },
+            { orgId: 'org1', userId: 'user1', fileName: 'session2.json', content: SESSION_2 },
+        ]);
+        // lastSyncAt between session1 and session2
+        const syncAt = new Date(1711940000000).toISOString();
+        const result = await adapter.readUsageStats(syncAt);
+        expect(result).not.toBeNull();
+        // Only session2 (lastActivityAt 1712003600000) is after syncAt
+        expect(result.sessionCount).toBe(1);
+    });
+    it('collects unique models used', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        setupSessionDirs(AGENT_SESSIONS_DIR, [
+            { orgId: 'org1', userId: 'user1', fileName: 's1.json', content: SESSION_1 },
+            { orgId: 'org1', userId: 'user1', fileName: 's2.json', content: SESSION_2 },
+        ]);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.modelsUsed).toContain('claude-opus-4-6');
+        expect(result.modelsUsed).toContain('claude-sonnet-4-6');
+        expect(result.modelsUsed.length).toBe(2);
+    });
+    it('counts max MCP tools from enabledMcpTools', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        setupSessionDirs(AGENT_SESSIONS_DIR, [
+            { orgId: 'org1', userId: 'user1', fileName: 's1.json', content: SESSION_1 },
+            { orgId: 'org1', userId: 'user1', fileName: 's2.json', content: SESSION_2 },
+        ]);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        // session1 has 3 MCP tools, session2 has none
+        expect(result.mcpToolCount).toBe(3);
+    });
+    it('counts scheduled task runs since lastSyncAt', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === SCHEDULED_TASKS_PATH)
+                return true;
+            return false;
+        });
+        readFileSync.mockImplementation((filePath) => {
+            if (filePath === SCHEDULED_TASKS_PATH)
+                return SCHEDULED_TASKS;
+            return '';
+        });
+        // Sync before the task run
+        const syncAt = new Date('2026-03-29T00:00:00Z').toISOString();
+        const result = await adapter.readUsageStats(syncAt);
+        expect(result).not.toBeNull();
+        expect(result.extra).toBeDefined();
+        expect(result.extra.scheduledTaskRuns).toBe(1);
+    });
+    it('returns null when Claude Desktop not installed', async () => {
+        existsSync.mockReturnValue(false);
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('returns null when local-agent-mode-sessions directory is empty', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        readdirSync.mockReturnValue([]);
+        const result = await adapter.readUsageStats(null);
+        expect(result).toBeNull();
+    });
+    it('handles corrupted session JSON gracefully', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        setupSessionDirs(AGENT_SESSIONS_DIR, [
+            { orgId: 'org1', userId: 'user1', fileName: 'bad.json', content: '{{{invalid json' },
+            { orgId: 'org1', userId: 'user1', fileName: 'good.json', content: SESSION_1 },
+        ]);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        // Only the valid session is counted
+        expect(result.sessionCount).toBe(1);
+    });
+    it('handles session with missing fields', async () => {
+        const minimalSession = JSON.stringify({
+            sessionId: 'minimal',
+            createdAt: 1712000000000,
+            lastActivityAt: 1712003600000,
+        });
+        existsSync.mockImplementation((p) => {
+            if (p === CLAUDE_APP_DIR)
+                return true;
+            if (p === AGENT_SESSIONS_DIR)
+                return true;
+            return false;
+        });
+        setupSessionDirs(AGENT_SESSIONS_DIR, [
+            { orgId: 'org1', userId: 'user1', fileName: 's.json', content: minimalSession },
+        ]);
+        const result = await adapter.readUsageStats(null);
+        expect(result).not.toBeNull();
+        expect(result.sessionCount).toBe(1);
+        // No model, no enabledMcpTools
+        expect(result.modelsUsed).toEqual([]);
+        expect(result.mcpToolCount).toBeUndefined();
+    });
+});
+describe('ClaudeDesktopAdapter.readVersion', () => {
+    let adapter;
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        adapter = new ClaudeDesktopAdapter();
+    });
+    it('returns version from sdk-version file', async () => {
+        existsSync.mockImplementation((p) => {
+            if (p === SDK_VERSION_PATH)
+                return true;
+            return false;
+        });
+        readFileSync.mockImplementation((filePath) => {
+            if (filePath === SDK_VERSION_PATH)
+                return '1.2.3\n';
+            return '';
+        });
+        const version = await adapter.readVersion();
+        expect(version).toBe('1.2.3');
+    });
+    it('returns null when file does not exist', async () => {
+        existsSync.mockReturnValue(false);
+        const version = await adapter.readVersion();
+        expect(version).toBeNull();
+    });
+});

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

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