runwork 0.6.1 → 0.8.2

package/dist/__tests__/install-scripts.test.d.ts

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

package/dist/__tests__/install-scripts.test.js

@@ -0,0 +1,247 @@
+/**
+ * Integration tests for the Runwork install scripts.
+ *
+ * install.sh runs end-to-end against a local HTTP server that serves a fake
+ * release manifest and a tar.gz for the current host platform. install.ps1 is
+ * checked statically (grep of invariants) because PowerShell is not available
+ * on the Unix runners that execute this suite.
+ *
+ * Design note: install.sh uses curl to fetch from the in-process Node HTTP
+ * server, so we MUST run the child process asynchronously. Using execFileSync
+ * would block the Node event loop, preventing the HTTP server from responding
+ * to curl and deadlocking the test.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { execFileSync, spawn } from 'node:child_process';
+import { createServer } from 'node:http';
+import { chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+const INSTALL_SH = fileURLToPath(new URL('../../install.sh', import.meta.url));
+const INSTALL_PS1 = fileURLToPath(new URL('../../install.ps1', import.meta.url));
+function detectHostPlatform() {
+    const osMap = { darwin: 'darwin', linux: 'linux' };
+    const archMap = { x64: 'x64', arm64: 'arm64' };
+    const os = osMap[process.platform];
+    const arch = archMap[process.arch];
+    if (!os || !arch) {
+        throw new Error(`install.sh integration test requires darwin/linux and x64/arm64; got ${process.platform}/${process.arch}`);
+    }
+    return { os, arch, platform: `${os}-${arch}` };
+}
+function sha256Hex(data) {
+    return createHash('sha256').update(data).digest('hex');
+}
+function runInstallSh(env) {
+    return new Promise((resolvePromise) => {
+        const child = spawn('sh', [INSTALL_SH], {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (err) => {
+            resolvePromise({ status: -1, stdout, stderr: stderr + `\n[spawn error] ${err.message}` });
+        });
+        child.on('close', (code) => {
+            resolvePromise({ status: code ?? -1, stdout, stderr });
+        });
+    });
+}
+describe('install.sh (end-to-end)', () => {
+    let workDir;
+    let serverDir;
+    let server;
+    let serverUrl;
+    let platformInfo;
+    let archivePath;
+    beforeEach(async () => {
+        platformInfo = detectHostPlatform();
+        workDir = mkdtempSync(join(tmpdir(), 'runwork-install-test-'));
+        serverDir = join(workDir, 'server');
+        mkdirSync(serverDir, { recursive: true });
+        // Fake binary that prints a recognizable version string.
+        const binaryName = `runwork-${platformInfo.platform}`;
+        const binarySource = join(workDir, 'binary-source');
+        mkdirSync(binarySource, { recursive: true });
+        const binaryPath = join(binarySource, binaryName);
+        writeFileSync(binaryPath, '#!/bin/sh\necho "runwork 99.99.99 (test)"\n');
+        chmodSync(binaryPath, 0o755);
+        // Pack the binary into a tar.gz at the manifest path.
+        const archiveName = `${binaryName}.tar.gz`;
+        const releasesDir = join(serverDir, 'cli', 'releases', '99.99.99');
+        mkdirSync(releasesDir, { recursive: true });
+        archivePath = join(releasesDir, archiveName);
+        execFileSync('tar', ['-czf', archivePath, binaryName], { cwd: binarySource });
+        const sha = sha256Hex(readFileSync(archivePath));
+        // Write the manifest consumed by install.sh.
+        const manifest = {
+            name: 'runwork',
+            version: '99.99.99',
+            publishedAt: new Date().toISOString(),
+            artifacts: {
+                [platformInfo.platform]: {
+                    path: `/cli/releases/99.99.99/${archiveName}`,
+                    sha256: sha,
+                },
+            },
+        };
+        writeFileSync(join(serverDir, 'cli', 'latest.json'), JSON.stringify(manifest, null, 2) + '\n');
+        // Minimal static HTTP server rooted at serverDir.
+        server = createServer((req, res) => {
+            const requestPath = decodeURIComponent(req.url ?? '/').replace(/^\/+/, '');
+            const filePath = join(serverDir, requestPath);
+            if (!filePath.startsWith(serverDir) ||
+                !existsSync(filePath) ||
+                statSync(filePath).isDirectory()) {
+                res.writeHead(404, { 'Content-Type': 'text/plain' });
+                res.end('not found');
+                return;
+            }
+            const body = readFileSync(filePath);
+            res.writeHead(200, {
+                'Content-Type': 'application/octet-stream',
+                'Content-Length': body.length,
+            });
+            res.end(body);
+        });
+        await new Promise((resolvePromise) => {
+            server.listen(0, '127.0.0.1', () => {
+                const addr = server.address();
+                if (addr && typeof addr === 'object') {
+                    serverUrl = `http://127.0.0.1:${addr.port}`;
+                }
+                resolvePromise();
+            });
+        });
+    });
+    afterEach(async () => {
+        await new Promise((resolvePromise) => {
+            server.close(() => resolvePromise());
+        });
+        rmSync(workDir, { recursive: true, force: true });
+    });
+    function envFor(overrides) {
+        return {
+            ...process.env,
+            HOME: workDir,
+            RUNWORK_DOWNLOAD_BASE_URL: serverUrl,
+            ...overrides,
+        };
+    }
+    it('installs the binary to the canonical location and symlinks it onto PATH', async () => {
+        const installDir = join(workDir, 'install');
+        const linkDir = join(workDir, 'link');
+        const result = await runInstallSh(envFor({
+            RUNWORK_INSTALL_DIR: installDir,
+            RUNWORK_BIN_LINK_DIR: linkDir,
+        }));
+        expect(result.status, `installer failed:\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`).toBe(0);
+        expect(result.stdout).toContain('99.99.99');
+        expect(result.stdout).toContain(platformInfo.platform);
+        const installedBinary = join(installDir, 'runwork');
+        expect(existsSync(installedBinary)).toBe(true);
+        expect(statSync(installedBinary).mode & 0o111).toBeGreaterThan(0);
+        const linkPath = join(linkDir, 'runwork');
+        expect(existsSync(linkPath)).toBe(true);
+        expect(lstatSync(linkPath).isSymbolicLink()).toBe(true);
+        expect(readlinkSync(linkPath)).toBe(installedBinary);
+        const versionOutput = execFileSync(installedBinary, [], { encoding: 'utf-8' });
+        expect(versionOutput).toContain('99.99.99');
+    });
+    it('defaults install location to $HOME/.runwork/bin when RUNWORK_INSTALL_DIR is unset', async () => {
+        const result = await runInstallSh(envFor({
+            RUNWORK_BIN_LINK_DIR: join(workDir, 'link'),
+        }));
+        expect(result.status, `installer failed:\nstdout:\n${result.stdout}\nstderr:\n${result.stderr}`).toBe(0);
+        const defaultBinary = join(workDir, '.runwork', 'bin', 'runwork');
+        expect(existsSync(defaultBinary)).toBe(true);
+    });
+    it('aborts on sha256 mismatch and leaves the install directory untouched', async () => {
+        // Tamper with the archive the server is about to serve.
+        writeFileSync(archivePath, Buffer.from('tampered payload'));
+        const installDir = join(workDir, 'install');
+        const result = await runInstallSh(envFor({
+            RUNWORK_INSTALL_DIR: installDir,
+            RUNWORK_BIN_LINK_DIR: join(workDir, 'link'),
+        }));
+        expect(result.status).not.toBe(0);
+        expect(result.stderr).toContain('sha256 mismatch');
+        expect(existsSync(join(installDir, 'runwork'))).toBe(false);
+    });
+    it('reports a clear error when the manifest is unreachable', async () => {
+        rmSync(join(serverDir, 'cli', 'latest.json'));
+        const result = await runInstallSh(envFor({
+            RUNWORK_INSTALL_DIR: join(workDir, 'install'),
+            RUNWORK_BIN_LINK_DIR: join(workDir, 'link'),
+        }));
+        expect(result.status).not.toBe(0);
+        expect(result.stderr).toContain('failed to fetch release manifest');
+    });
+    it('reports a clear error when the manifest has no artifact for the host platform', async () => {
+        const fakePlatform = platformInfo.platform === 'linux-x64' ? 'linux-arm64' : 'linux-x64';
+        const manifest = {
+            name: 'runwork',
+            version: '99.99.99',
+            publishedAt: new Date().toISOString(),
+            artifacts: {
+                [fakePlatform]: {
+                    path: `/cli/releases/99.99.99/runwork-${fakePlatform}.tar.gz`,
+                    sha256: 'deadbeef',
+                },
+            },
+        };
+        writeFileSync(join(serverDir, 'cli', 'latest.json'), JSON.stringify(manifest, null, 2));
+        const result = await runInstallSh(envFor({
+            RUNWORK_INSTALL_DIR: join(workDir, 'install'),
+            RUNWORK_BIN_LINK_DIR: join(workDir, 'link'),
+        }));
+        expect(result.status).not.toBe(0);
+        expect(result.stderr).toContain('no artifact entry for platform');
+    });
+});
+describe('install.ps1 (static invariants)', () => {
+    let contents;
+    beforeEach(() => {
+        contents = readFileSync(INSTALL_PS1, 'utf-8');
+    });
+    it('exists alongside install.sh', () => {
+        expect(existsSync(INSTALL_PS1)).toBe(true);
+    });
+    it('resolves the manifest against runwork.ai/cli/latest.json by default', () => {
+        expect(contents).toContain("'https://runwork.ai'");
+        expect(contents).toContain('/cli/latest.json');
+    });
+    it('honors the RUNWORK_* env var overrides documented in the plan', () => {
+        expect(contents).toContain('RUNWORK_VERSION');
+        expect(contents).toContain('RUNWORK_INSTALL_DIR');
+        expect(contents).toContain('RUNWORK_DOWNLOAD_BASE_URL');
+    });
+    it('verifies sha256 with Get-FileHash -Algorithm SHA256', () => {
+        expect(contents).toContain('Get-FileHash');
+        expect(contents).toContain('SHA256');
+        expect(contents).toContain('sha256 mismatch');
+    });
+    it('targets the canonical Windows install location under %USERPROFILE%\\.runwork\\bin', () => {
+        expect(contents).toMatch(/\$env:USERPROFILE/);
+        expect(contents).toMatch(/['"]\.runwork\\bin['"]/);
+    });
+    it('modifies the user PATH scope only (never machine)', () => {
+        expect(contents).toContain("'User'");
+        expect(contents).not.toContain("'Machine'");
+    });
+    it('downloads release artifacts from /cli/releases/<version>/<artifact>', () => {
+        expect(contents).toMatch(/\/cli\/releases\//);
+    });
+    it('does not escalate to admin', () => {
+        expect(contents).not.toMatch(/Start-Process.*-Verb\s+RunAs/i);
+    });
+});

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

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

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

@@ -0,0 +1,47 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, readFileSync, rmSync } 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),
+    };
+});
+import { ClaudeCodeAdapter } from '../claude-code.js';
+describe('ClaudeCodeAdapter MCP plugin files', () => {
+    let tempHomeDir;
+    beforeEach(() => {
+        tempHomeDir = mkdtempSync(join(tmpdir(), 'runwork-cli-claude-code-'));
+        mockHomeDir = tempHomeDir;
+    });
+    afterEach(() => {
+        rmSync(tempHomeDir, { recursive: true, force: true });
+    });
+    it('writes the Runwork MCP config into the marketplace plugin directory', async () => {
+        const adapter = new ClaudeCodeAdapter();
+        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(tempHomeDir, '.claude', 'plugins', 'cache', 'runwork', 'runwork', '1.0.0', '.mcp.json');
+        const marketplaceMcpPath = join(tempHomeDir, '.claude', 'plugins', 'marketplaces', 'runwork', 'plugins', 'runwork', '.mcp.json');
+        const cacheConfig = JSON.parse(readFileSync(cacheMcpPath, 'utf-8'));
+        const marketplaceConfig = JSON.parse(readFileSync(marketplaceMcpPath, 'utf-8'));
+        expect(marketplaceConfig).toEqual(cacheConfig);
+        expect(marketplaceConfig).toMatchObject({
+            'Runwork': {
+                type: 'http',
+                url: 'https://runwork.ai/api/workspaces/test/mcp',
+            },
+        });
+    });
+});

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

@@ -2,7 +2,6 @@ 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');
@@ -16,115 +15,181 @@ 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');
+const HOME = '/mock-home';
+const CLAUDE_DIR = `${HOME}/.claude`;
+const PROJECTS_DIR = `${CLAUDE_DIR}/projects`;
 let adapter;
 beforeEach(() => {
     vi.restoreAllMocks();
-    vi.mocked(homedir).mockReturnValue('/mock-home');
+    vi.mocked(homedir).mockReturnValue(HOME);
     adapter = new ClaudeCodeAdapter();
 });
 // Helper: make existsSync return true only for specified paths
 function mockExistsPaths(paths) {
     vi.mocked(existsSync).mockImplementation((p) => paths.includes(p));
 }
+function jsonl(entries) {
+    return entries.map(e => {
+        const obj = { type: e.type };
+        if (e.ts)
+            obj.timestamp = e.ts;
+        if (e.type === 'user') {
+            obj.message = { role: 'user', content: e.content ?? 'hello' };
+        }
+        else if (e.type === 'assistant') {
+            obj.message = {
+                role: 'assistant',
+                content: e.content ?? [{ type: 'text', text: 'hi' }],
+                ...(e.usage ? { usage: e.usage } : {}),
+            };
+        }
+        return JSON.stringify(obj);
+    }).join('\n');
+}
 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);
+    it('parses an active session JSONL and aggregates messages, tool calls, and tokens', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['-Users-test-project'];
+            if (p === `${PROJECTS_DIR}/-Users-test-project`) {
+                return ['sess-a.jsonl'];
+            }
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue(jsonl([
+            { type: 'user', ts: '2026-04-13T22:00:00.000Z' },
+            { type: 'assistant', ts: '2026-04-13T22:00:05.000Z',
+                content: [{ type: 'text', text: 'response' }],
+                usage: { input_tokens: 100, output_tokens: 50, cache_read_input_tokens: 1000 } },
+            { type: 'assistant', ts: '2026-04-13T22:00:10.000Z',
+                content: [{ type: 'tool_use', name: 'Read' }, { type: 'tool_use', name: 'Edit' }],
+                usage: { input_tokens: 50, output_tokens: 20 } },
+            { type: 'user', ts: '2026-04-13T22:00:15.000Z' },
+            // Lines without timestamps are ignored
+            { type: 'permission-mode' },
+        ]));
         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);
+        expect(stats.sessionCount).toBe(1);
+        expect(stats.messageCount).toBe(4); // 2 user + 2 assistant
+        expect(stats.toolCallCount).toBe(2);
+        expect(stats.tokensUsed).toBe(220); // 150 input + 70 output (cache_read in extra)
+        expect(stats.lastActiveAt).toBe('2026-04-13T22:00:15.000Z');
+        expect(stats.extra).toEqual({ inputTokens: 150, outputTokens: 70, cacheReadTokens: 1000 });
     });
-    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');
+    it('filters out entries with timestamp <= lastSyncAt within the same file', async () => {
+        const sinceIso = '2026-04-13T20:00:00.000Z';
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: Date.parse('2026-04-13T22:00:00Z') });
+        vi.mocked(readFileSync).mockReturnValue(jsonl([
+            { type: 'user', ts: '2026-04-13T19:00:00.000Z' }, // before sync, ignored
+            { type: 'assistant', ts: '2026-04-13T19:30:00.000Z',
+                usage: { input_tokens: 999, output_tokens: 999 } }, // before sync, tokens NOT counted
+            { type: 'user', ts: '2026-04-13T21:00:00.000Z' }, // after sync, counted
+            { type: 'assistant', ts: '2026-04-13T21:00:05.000Z',
+                content: [{ type: 'tool_use', name: 'Read' }],
+                usage: { input_tokens: 10, output_tokens: 5 } },
+        ]));
+        const stats = await adapter.readUsageStats(sinceIso);
         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);
+        expect(stats.messageCount).toBe(2); // only post-sync entries
+        expect(stats.toolCallCount).toBe(1);
+        expect(stats.tokensUsed).toBe(15); // 10 + 5, pre-sync 999+999 ignored
+        expect(stats.sessionCount).toBe(1);
     });
-    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');
+    it('skips JSONL files with mtime <= lastSyncAt without parsing them', async () => {
+        const sinceIso = '2026-04-13T20:00:00.000Z';
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['stale.jsonl'];
+            return [];
+        });
+        // mtime is BEFORE sinceMs - file should be skipped entirely
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: Date.parse('2026-04-13T18:00:00Z') });
+        const readSpy = vi.mocked(readFileSync);
+        const stats = await adapter.readUsageStats(sinceIso);
         expect(stats).toBeNull();
+        expect(readSpy).not.toHaveBeenCalled();
     });
-    it('returns null when ~/.claude does not exist', async () => {
-        mockExistsPaths([]);
+    it('counts multiple sessions across multiple cwd directories', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            const path = p;
+            if (path === PROJECTS_DIR) {
+                return ['-Users-a-proj1', '-Users-a-proj2'];
+            }
+            if (path === `${PROJECTS_DIR}/-Users-a-proj1`) {
+                return ['s1.jsonl'];
+            }
+            if (path === `${PROJECTS_DIR}/-Users-a-proj2`) {
+                return ['s2.jsonl', 's3.jsonl'];
+            }
+            return [];
+        });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue(jsonl([
+            { type: 'user', ts: '2026-04-13T22:00:00.000Z' },
+            { type: 'assistant', ts: '2026-04-13T22:00:05.000Z' },
+        ]));
         const stats = await adapter.readUsageStats(null);
-        expect(stats).toBeNull();
+        expect(stats).not.toBeNull();
+        expect(stats.sessionCount).toBe(3);
+        expect(stats.messageCount).toBe(6); // 2 messages * 3 sessions
     });
-    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 {{{');
+    it('returns null when ~/.claude does not exist', async () => {
+        mockExistsPaths([]);
         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 }));
+    it('returns null when ~/.claude/projects does not exist', async () => {
+        mockExistsPaths([CLAUDE_DIR]);
         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: [] }));
+    it('returns null when projects dir has no active sessions', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return [];
+            return [];
+        });
         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 };
+    it('skips malformed JSONL lines without crashing', async () => {
+        mockExistsPaths([CLAUDE_DIR, PROJECTS_DIR]);
+        vi.mocked(readdirSync).mockImplementation((p) => {
+            if (p === PROJECTS_DIR)
+                return ['cwd'];
+            if (p === `${PROJECTS_DIR}/cwd`)
+                return ['s.jsonl'];
+            return [];
         });
+        vi.mocked(statSync).mockReturnValue({ mtimeMs: 2_000_000_000_000 });
+        vi.mocked(readFileSync).mockReturnValue([
+            'not json at all',
+            '{"type":"user","timestamp":"2026-04-13T22:00:00.000Z","message":{"role":"user","content":"ok"}}',
+            '{{{ broken',
+            '{"type":"assistant","timestamp":"2026-04-13T22:00:05.000Z","message":{"role":"assistant","content":[]}}',
+            '',
+        ].join('\n'));
         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);
+        expect(stats.messageCount).toBe(2);
+        expect(stats.sessionCount).toBe(1);
     });
 });
 describe('ClaudeCodeAdapter.readVersion', () => {

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

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