@cspeach/cli 0.6.4 → 0.6.5

package/dist/tools/__tests__/file-read.test.js

@@ -1,81 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { fileReadHandler } from '../filesystem/file-read.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-file-read-')); });
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true }); });
-describe('file_read handler', () => {
-    it('reads a file from the project and returns content with line numbers', async () => {
-        await fs.writeFile(path.join(root, 'foo.ts'), 'line one\nline two\nline three\n', 'utf-8');
-        const r = await fileReadHandler({ path: 'foo.ts' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('1\tline one');
-        expect(r.content).toContain('2\tline two');
-        expect(r.content).toContain('3\tline three');
-    });
-    it('refuses paths outside the project root', async () => {
-        const r = await fileReadHandler({ path: '../../etc/passwd' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/outside/i);
-    });
-    it('returns an error envelope when the file does not exist', async () => {
-        const r = await fileReadHandler({ path: 'nope.ts' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/not found|ENOENT/i);
-    });
-    it('truncates at 2000 lines and indicates truncation', async () => {
-        const lines = Array.from({ length: 3000 }, (_, i) => `line ${i + 1}`).join('\n');
-        await fs.writeFile(path.join(root, 'big.ts'), lines, 'utf-8');
-        const r = await fileReadHandler({ path: 'big.ts' }, ctx());
-        expect(r.content).toContain('1\tline 1');
-        expect(r.content).toContain('2000\tline 2000');
-        expect(r.content).not.toContain('2001\tline 2001');
-        expect(r.content).toMatch(/truncated.*1000.*more/i);
-    });
-    it('respects optional offset + limit args (read a window)', async () => {
-        const lines = Array.from({ length: 100 }, (_, i) => `L${i + 1}`).join('\n');
-        await fs.writeFile(path.join(root, 'mid.ts'), lines, 'utf-8');
-        const r = await fileReadHandler({ path: 'mid.ts', offset: 50, limit: 5 }, ctx());
-        expect(r.content).toContain('51\tL51');
-        expect(r.content).toContain('55\tL55');
-        expect(r.content).not.toContain('56\tL56');
-    });
-    it('rejects negative offset', async () => {
-        await fs.writeFile(path.join(root, 'foo.ts'), 'line\n', 'utf-8');
-        const r = await fileReadHandler({ path: 'foo.ts', offset: -1 }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/offset.*non-negative/i);
-    });
-    it('rejects negative limit', async () => {
-        await fs.writeFile(path.join(root, 'foo.ts'), 'line\n', 'utf-8');
-        const r = await fileReadHandler({ path: 'foo.ts', limit: -5 }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/limit.*positive/i);
-    });
-    it('refuses to read .cspeach/* (sensitive denylist)', async () => {
-        await fs.mkdir(path.join(root, '.cspeach'), { recursive: true });
-        await fs.writeFile(path.join(root, '.cspeach', 'auth.json'), '{"password":"secret"}', 'utf-8');
-        const r = await fileReadHandler({ path: '.cspeach/auth.json' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/sensitive path/i);
-        expect(r.content).not.toContain('secret'); // must not leak
-    });
-    it('refuses to read .env (denylist)', async () => {
-        await fs.writeFile(path.join(root, '.env'), 'SECRET=value', 'utf-8');
-        const r = await fileReadHandler({ path: '.env' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/sensitive path/i);
-    });
-    it('does NOT mis-number a trailing blank line on files ending in newline', async () => {
-        // "a\nb\n" split naively produces ['a', 'b', ''] — line 3 should NOT appear.
-        await fs.writeFile(path.join(root, 'trailer.ts'), 'a\nb\n', 'utf-8');
-        const r = await fileReadHandler({ path: 'trailer.ts' }, ctx());
-        expect(r.content).toContain('1\ta');
-        expect(r.content).toContain('2\tb');
-        expect(r.content).not.toContain('3\t');
-    });
-});

package/dist/tools/__tests__/file-write.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { fileWriteHandler } from '../filesystem/file-write.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-file-write-')); });
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }); });
-describe('file_write handler', () => {
-    it('creates a new file with the given content', async () => {
-        const r = await fileWriteHandler({ path: 'newfile.ts', content: 'hello world\n' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/wrote.*newfile\.ts/i);
-        const written = await fs.readFile(path.join(root, 'newfile.ts'), 'utf-8');
-        expect(written).toBe('hello world\n');
-    });
-    it('overwrites an existing file', async () => {
-        await fs.writeFile(path.join(root, 'existing.ts'), 'old content\n', 'utf-8');
-        const r = await fileWriteHandler({ path: 'existing.ts', content: 'new content\n' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/wrote.*existing\.ts/i);
-        const written = await fs.readFile(path.join(root, 'existing.ts'), 'utf-8');
-        expect(written).toBe('new content\n');
-    });
-    it('creates parent directories that do not exist yet', async () => {
-        const r = await fileWriteHandler({ path: 'deep/nested/dir/file.ts', content: 'content\n' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/wrote.*deep\/nested\/dir\/file\.ts/i);
-        const written = await fs.readFile(path.join(root, 'deep', 'nested', 'dir', 'file.ts'), 'utf-8');
-        expect(written).toBe('content\n');
-    });
-    it('refuses path traversal (../foo)', async () => {
-        const r = await fileWriteHandler({ path: '../../etc/evil.txt', content: 'bad' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/outside/i);
-    });
-    it('refuses denylisted path (.cspeach/auth.json)', async () => {
-        await fs.mkdir(path.join(root, '.cspeach'), { recursive: true });
-        const r = await fileWriteHandler({ path: '.cspeach/auth.json', content: '{"token":"hacked"}' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/sensitive path/i);
-        // file must not have been created/modified with the new content
-        const exists = await fs.access(path.join(root, '.cspeach', 'auth.json')).then(() => true, () => false);
-        expect(exists).toBe(false);
-    });
-    it('refuses denylisted path (.git/config)', async () => {
-        await fs.mkdir(path.join(root, '.git'), { recursive: true });
-        await fs.writeFile(path.join(root, '.git', 'config'), '[core]\n', 'utf-8');
-        const r = await fileWriteHandler({ path: '.git/config', content: 'tampered\n' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/sensitive path/i);
-        // original file must be unchanged
-        const content = await fs.readFile(path.join(root, '.git', 'config'), 'utf-8');
-        expect(content).toBe('[core]\n');
-    });
-    it('atomic write — no leftover .tmp file on success', async () => {
-        const r = await fileWriteHandler({ path: 'atomic.ts', content: 'data\n' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        // target file exists
-        const written = await fs.readFile(path.join(root, 'atomic.ts'), 'utf-8');
-        expect(written).toBe('data\n');
-        // no leftover .tmp
-        const tmpExists = await fs.access(path.join(root, 'atomic.ts.tmp')).then(() => true, () => false);
-        expect(tmpExists).toBe(false);
-    });
-});

package/dist/tools/__tests__/glob.test.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { globHandler, globToRegex } from '../filesystem/glob.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => {
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-glob-'));
-});
-afterEach(async () => {
-    await fs.rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
-});
-// ─── globToRegex unit tests ────────────────────────────────────────────────
-describe('globToRegex', () => {
-    it('* matches any chars within a single path segment (not /)', () => {
-        const re = globToRegex('*.ts');
-        expect(re.test('foo.ts')).toBe(true);
-        expect(re.test('bar.tsx')).toBe(false);
-        expect(re.test('src/foo.ts')).toBe(false); // * must not cross /
-        expect(re.test('.ts')).toBe(true); // zero chars is fine
-    });
-    it('** matches across path segments including /', () => {
-        const re = globToRegex('src/**/*.ts');
-        expect(re.test('src/foo.ts')).toBe(true);
-        expect(re.test('src/a/b/c/foo.ts')).toBe(true);
-        expect(re.test('lib/foo.ts')).toBe(false);
-    });
-    it('? matches exactly one char within a segment (not /)', () => {
-        const re = globToRegex('?.ts');
-        expect(re.test('a.ts')).toBe(true);
-        expect(re.test('ab.ts')).toBe(false);
-        expect(re.test('/a.ts')).toBe(false); // ? must not cross /
-    });
-    it('literal dots and special regex chars are escaped', () => {
-        const re = globToRegex('package.json');
-        expect(re.test('package.json')).toBe(true);
-        expect(re.test('packageXjson')).toBe(false); // dot must not act as regex .
-    });
-    it('** at root matches files at any depth', () => {
-        const re = globToRegex('**/*.json');
-        expect(re.test('foo.json')).toBe(true);
-        expect(re.test('a/b/c/foo.json')).toBe(true);
-        expect(re.test('a/b/c/foo.ts')).toBe(false);
-    });
-});
-// ─── globHandler integration tests ────────────────────────────────────────
-describe('glob handler', () => {
-    it('returns "no files match" when the project is empty', async () => {
-        const r = await globHandler({ pattern: '*.ts' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/no files match/i);
-    });
-    it('finds .ts files with a simple *.ts pattern', async () => {
-        await fs.writeFile(path.join(root, 'index.ts'), 'export {}', 'utf-8');
-        await fs.writeFile(path.join(root, 'README.md'), '# hi', 'utf-8');
-        const r = await globHandler({ pattern: '*.ts' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('index.ts');
-        expect(r.content).not.toContain('README.md');
-    });
-    it('finds nested .tsx files with **/*.tsx pattern', async () => {
-        await fs.mkdir(path.join(root, 'src', 'components'), { recursive: true });
-        await fs.writeFile(path.join(root, 'src', 'components', 'Button.tsx'), 'export {}', 'utf-8');
-        await fs.writeFile(path.join(root, 'src', 'components', 'Button.test.ts'), 'test', 'utf-8');
-        const r = await globHandler({ pattern: '**/*.tsx' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('src/components/Button.tsx');
-        expect(r.content).not.toContain('Button.test.ts');
-    });
-    it('sorts results by mtime descending (most recent first)', async () => {
-        // Write three files with deliberate delays via manipulated mtime
-        const fileA = path.join(root, 'a.ts');
-        const fileB = path.join(root, 'b.ts');
-        const fileC = path.join(root, 'c.ts');
-        await fs.writeFile(fileA, 'a', 'utf-8');
-        await fs.writeFile(fileB, 'b', 'utf-8');
-        await fs.writeFile(fileC, 'c', 'utf-8');
-        // Manually set mtimes: A=oldest, B=middle, C=newest
-        const now = Date.now();
-        await fs.utimes(fileA, new Date(now - 3000), new Date(now - 3000));
-        await fs.utimes(fileB, new Date(now - 2000), new Date(now - 2000));
-        await fs.utimes(fileC, new Date(now - 1000), new Date(now - 1000));
-        const r = await globHandler({ pattern: '*.ts' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        const lines = r.content.split('\n');
-        const posA = lines.findIndex((l) => l.includes('a.ts'));
-        const posB = lines.findIndex((l) => l.includes('b.ts'));
-        const posC = lines.findIndex((l) => l.includes('c.ts'));
-        // c should appear before b which should appear before a
-        expect(posC).toBeLessThan(posB);
-        expect(posB).toBeLessThan(posA);
-    });
-    it('excludes denylisted paths (.cspeach/auth.json)', async () => {
-        await fs.mkdir(path.join(root, '.cspeach'), { recursive: true });
-        await fs.writeFile(path.join(root, '.cspeach', 'auth.json'), '{"token":"secret"}', 'utf-8');
-        await fs.writeFile(path.join(root, 'ok.json'), '{}', 'utf-8');
-        const r = await globHandler({ pattern: '**/*.json' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).not.toContain('auth.json');
-        expect(r.content).toContain('ok.json');
-    });
-    it('skips node_modules directory', async () => {
-        await fs.mkdir(path.join(root, 'node_modules', 'foo'), { recursive: true });
-        await fs.writeFile(path.join(root, 'node_modules', 'foo', 'index.ts'), 'module', 'utf-8');
-        await fs.writeFile(path.join(root, 'real.ts'), 'real', 'utf-8');
-        const r = await globHandler({ pattern: '**/*.ts' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).not.toContain('node_modules');
-        expect(r.content).toContain('real.ts');
-    });
-    it('refuses cwd that escapes the project root', async () => {
-        const r = await globHandler({ pattern: '*.ts', cwd: '../../etc' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/outside/i);
-    });
-    it('returns an error when search root does not exist', async () => {
-        const r = await globHandler({ pattern: '*.ts', cwd: 'nonexistent-dir' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/does not exist/i);
-    });
-    it('returns an error when pattern is missing or empty', async () => {
-        const r = await globHandler({ pattern: '' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/pattern.*required/i);
-    });
-});

package/dist/tools/__tests__/grep.test.js

@@ -1,71 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { grepHandler } from '../filesystem/grep.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-grep-')); });
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }); });
-describe('grep handler', () => {
-    it('finds a literal string match', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'const x = 1;\nconst y = 2;\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'const x' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/a\.ts:1:const x = 1;/);
-    });
-    it('matches a regex pattern', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'foo123\nbar456\n', 'utf-8');
-        const r = await grepHandler({ pattern: '\\d+' }, ctx());
-        expect(r.content).toContain('a.ts:1:foo123');
-        expect(r.content).toContain('a.ts:2:bar456');
-    });
-    it('is case-insensitive when case_insensitive=true', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'Hello\nHELLO\nhello\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'hello', case_insensitive: true }, ctx());
-        expect(r.content.split('\n')).toHaveLength(3);
-    });
-    it('glob filter scopes which files get scanned', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'match\n', 'utf-8');
-        await fs.writeFile(path.join(root, 'b.md'), 'match\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'match', glob: '**/*.ts' }, ctx());
-        expect(r.content).toContain('a.ts');
-        expect(r.content).not.toContain('b.md');
-    });
-    it('files_with_matches mode returns just filenames', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'foo\nfoo\n', 'utf-8');
-        await fs.writeFile(path.join(root, 'b.ts'), 'foo\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'foo', output_mode: 'files_with_matches' }, ctx());
-        const lines = r.content.split('\n').sort();
-        expect(lines).toEqual(['a.ts', 'b.ts']);
-    });
-    it('count mode returns per-file counts', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'foo\nfoo\nfoo\n', 'utf-8');
-        await fs.writeFile(path.join(root, 'b.ts'), 'foo\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'foo', output_mode: 'count' }, ctx());
-        expect(r.content).toContain('3\ta.ts');
-        expect(r.content).toContain('1\tb.ts');
-    });
-    it('returns error envelope on invalid regex', async () => {
-        const r = await grepHandler({ pattern: '[invalid' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/invalid regex/i);
-    });
-    it('does NOT scan denylisted paths (.cspeach/auth.json)', async () => {
-        await fs.mkdir(path.join(root, '.cspeach'), { recursive: true });
-        await fs.writeFile(path.join(root, '.cspeach', 'auth.json'), '{"password":"SECRET"}', 'utf-8');
-        await fs.writeFile(path.join(root, 'a.ts'), 'no match here\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'SECRET' }, ctx());
-        // The denylist blocks .cspeach/auth.json — nothing matches, so we get the no-matches sentinel.
-        // The no-matches message echoes the pattern name; what must NOT appear is a content line
-        // referencing the denylist file.
-        expect(r.content).toMatch(/no matches/i);
-        expect(r.content).not.toContain('auth.json');
-    });
-    it('returns "no matches" when nothing hits', async () => {
-        await fs.writeFile(path.join(root, 'a.ts'), 'hello world\n', 'utf-8');
-        const r = await grepHandler({ pattern: 'xyz123' }, ctx());
-        expect(r.content).toMatch(/no matches/i);
-    });
-});

package/dist/tools/__tests__/monitor_emit.test.js

@@ -1,96 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { monitorEmitHandler } from '../subagent/monitor_emit.js';
-import { registerBackground, recordEvent, __resetRegistryForTests, MAX_EVENTS_PER_BG, } from '../subagent/_background-shared.js';
-import { makeCtx } from './_helpers.js';
-const ctx = () => makeCtx(process.cwd());
-beforeEach(() => { __resetRegistryForTests(); });
-function fakeRegister(bg_id) {
-    registerBackground({
-        bg_id,
-        command: 'node',
-        argv: ['-e', 'noop'],
-        child: { kill: () => true, pid: 1 },
-    });
-}
-// monitor_emit's BG_ID_PATTERN enforces this exact shape — bg-<v4-uuid>.
-// Tests register IDs that match the pattern so the handler validates them.
-const BG_1 = 'bg-11111111-1111-1111-1111-111111111111';
-const BG_2 = 'bg-22222222-2222-2222-2222-222222222222';
-const BG_3 = 'bg-33333333-3333-3333-3333-333333333333';
-const BG_4 = 'bg-44444444-4444-4444-4444-444444444444';
-const BG_EVICT = 'bg-eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee';
-const BG_CLOSED = 'bg-aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa';
-describe('monitor_emit handler', () => {
-    it('returns recorded stdout events as JSON', async () => {
-        fakeRegister(BG_1);
-        recordEvent(BG_1, { kind: 'stdout', text: 'hello', ts: 1 });
-        recordEvent(BG_1, { kind: 'stdout', text: 'world', ts: 2 });
-        const r = await monitorEmitHandler({ bg_id: BG_1 }, ctx());
-        expect(r.is_error).toBeFalsy();
-        const parsed = JSON.parse(r.content);
-        expect(parsed.events).toHaveLength(2);
-        expect(parsed.events[0].text).toBe('hello');
-        expect(parsed.events[1].text).toBe('world');
-        expect(parsed.closed).toBe(false);
-        expect(parsed.dropped).toBe(0);
-    });
-    it('advances the cursor per call — subsequent calls only see new events', async () => {
-        fakeRegister(BG_2);
-        recordEvent(BG_2, { kind: 'stdout', text: 'first', ts: 1 });
-        const r1 = await monitorEmitHandler({ bg_id: BG_2 }, ctx());
-        expect(JSON.parse(r1.content).events).toHaveLength(1);
-        recordEvent(BG_2, { kind: 'stdout', text: 'second', ts: 2 });
-        const r2 = await monitorEmitHandler({ bg_id: BG_2 }, ctx());
-        const parsed2 = JSON.parse(r2.content);
-        expect(parsed2.events).toHaveLength(1);
-        expect(parsed2.events[0].text).toBe('second');
-    });
-    it('caps max per-call at 1000 even when buffer holds more', async () => {
-        fakeRegister(BG_3);
-        for (let i = 0; i < 1500; i++)
-            recordEvent(BG_3, { kind: 'stdout', text: `n${i}`, ts: i });
-        const r = await monitorEmitHandler({ bg_id: BG_3, max: 999999 }, ctx());
-        const parsed = JSON.parse(r.content);
-        expect(parsed.events.length).toBe(1000);
-    });
-    it('honours max arg (default 100)', async () => {
-        fakeRegister(BG_4);
-        for (let i = 0; i < 200; i++)
-            recordEvent(BG_4, { kind: 'stdout', text: `n${i}`, ts: i });
-        const rDefault = await monitorEmitHandler({ bg_id: BG_4 }, ctx());
-        expect(JSON.parse(rDefault.content).events.length).toBe(100);
-        const rExplicit = await monitorEmitHandler({ bg_id: BG_4, max: 50 }, ctx());
-        expect(JSON.parse(rExplicit.content).events.length).toBe(50);
-    });
-    it('returns structured error for an unknown bg_id (with valid shape)', async () => {
-        // Use a well-formed UUID-shape bg_id that hasn't been registered.
-        const r = await monitorEmitHandler({ bg_id: 'bg-99999999-9999-9999-9999-999999999999' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/not found|unknown/i);
-    });
-    it('surfaces dropped counter after FIFO eviction; counter resets on read', async () => {
-        fakeRegister(BG_EVICT);
-        for (let i = 0; i < MAX_EVENTS_PER_BG + 30; i++) {
-            recordEvent(BG_EVICT, { kind: 'stdout', text: `n${i}`, ts: i });
-        }
-        const r1 = await monitorEmitHandler({ bg_id: BG_EVICT, max: 1000 }, ctx());
-        expect(JSON.parse(r1.content).dropped).toBe(30);
-        const r2 = await monitorEmitHandler({ bg_id: BG_EVICT, max: 1000 }, ctx());
-        expect(JSON.parse(r2.content).dropped).toBe(0);
-    });
-    it('marks closed: true after the child emits an exit event', async () => {
-        fakeRegister(BG_CLOSED);
-        recordEvent(BG_CLOSED, { kind: 'stdout', text: 'final', ts: 1 });
-        recordEvent(BG_CLOSED, { kind: 'exit', text: 'code=0', ts: 2, exitCode: 0, signal: null });
-        const r = await monitorEmitHandler({ bg_id: BG_CLOSED }, ctx());
-        const parsed = JSON.parse(r.content);
-        expect(parsed.closed).toBe(true);
-        expect(parsed.exitCode).toBe(0);
-        expect(parsed.events.some((e) => e.kind === 'exit')).toBe(true);
-    });
-    it('rejects bg_id with invalid shape (defense-in-depth on registry-key injection)', async () => {
-        const r = await monitorEmitHandler({ bg_id: '../../etc/passwd' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/invalid|not found/i);
-    });
-});

package/dist/tools/__tests__/playbook_get.test.js

@@ -1,109 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { playbookGetHandler, __resetPlaybookCacheForTests, __setPlaybookCacheTtlForTests } from '../project/playbook_get.js';
-import { makeCtx } from './_helpers.js';
-const FAKE_KEY = 'sk-ant-test-key-leak-guard-1234567890';
-let origAnthropic;
-let origCspeach;
-let origBrave;
-beforeEach(() => {
-    origAnthropic = process.env.ANTHROPIC_API_KEY;
-    origCspeach = process.env.CSPEACH_API_KEY;
-    origBrave = process.env.CSPEACH_BRAVE_SEARCH_KEY;
-    process.env.ANTHROPIC_API_KEY = FAKE_KEY;
-    process.env.CSPEACH_API_KEY = FAKE_KEY;
-    process.env.CSPEACH_BRAVE_SEARCH_KEY = FAKE_KEY;
-    __resetPlaybookCacheForTests();
-    __setPlaybookCacheTtlForTests(300_000);
-});
-afterEach(() => {
-    if (origAnthropic === undefined)
-        delete process.env.ANTHROPIC_API_KEY;
-    else
-        process.env.ANTHROPIC_API_KEY = origAnthropic;
-    if (origCspeach === undefined)
-        delete process.env.CSPEACH_API_KEY;
-    else
-        process.env.CSPEACH_API_KEY = origCspeach;
-    if (origBrave === undefined)
-        delete process.env.CSPEACH_BRAVE_SEARCH_KEY;
-    else
-        process.env.CSPEACH_BRAVE_SEARCH_KEY = origBrave;
-    __resetPlaybookCacheForTests();
-    __setPlaybookCacheTtlForTests(300_000);
-    vi.restoreAllMocks();
-});
-function makeSource(body, name = 'abap-review') {
-    const calls = [];
-    const src = {
-        async getSkillBody(n) {
-            calls.push(n);
-            return { name: n, body, sha256: 'fake-sha', signature: 'fake-sig', signedAt: '2026-05-12T00:00:00Z' };
-        },
-        async listAvailableSkills() { return [name]; },
-        describe() { return 'fake'; },
-    };
-    src.__calls = calls;
-    return src;
-}
-function makeFailingSource(err) {
-    return {
-        async getSkillBody() { throw err; },
-        async listAvailableSkills() { return []; },
-        describe() { return 'failing-fake'; },
-    };
-}
-describe('playbook_get', () => {
-    it('returns the body when ctx.skillSource resolves', async () => {
-        const src = makeSource('---\nname: abap-review\n---\n\nReview ABAP code.\n');
-        const ctx = makeCtx(process.cwd(), { skillSource: src });
-        const r = await playbookGetHandler({ name: 'abap-review' }, ctx);
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('Review ABAP code.');
-        expect(src.__calls).toEqual(['abap-review']);
-    });
-    it('returns a structured error when ctx.skillSource is undefined', async () => {
-        const ctx = makeCtx(process.cwd());
-        const r = await playbookGetHandler({ name: 'abap-review' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/skillSource|not available|not wired/i);
-    });
-    it('rejects an empty name with a structured error', async () => {
-        const src = makeSource('body', 'abap-review');
-        const ctx = makeCtx(process.cwd(), { skillSource: src });
-        const r = await playbookGetHandler({ name: '' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/name.*required|empty/i);
-    });
-    it('rejects a malformed name with a structured error', async () => {
-        const src = makeSource('body', 'abap-review');
-        const ctx = makeCtx(process.cwd(), { skillSource: src });
-        const r = await playbookGetHandler({ name: '../etc/passwd' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/invalid|malformed|name/i);
-    });
-    it('caches the result — second call within TTL does not refetch', async () => {
-        const src = makeSource('cached body', 'abap-review');
-        const ctx = makeCtx(process.cwd(), { skillSource: src });
-        await playbookGetHandler({ name: 'abap-review' }, ctx);
-        await playbookGetHandler({ name: 'abap-review' }, ctx);
-        expect(src.__calls).toEqual(['abap-review']);
-    });
-    it('refetches when the TTL has expired', async () => {
-        const src = makeSource('body', 'abap-review');
-        const ctx = makeCtx(process.cwd(), { skillSource: src });
-        __setPlaybookCacheTtlForTests(1);
-        await playbookGetHandler({ name: 'abap-review' }, ctx);
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        await playbookGetHandler({ name: 'abap-review' }, ctx);
-        expect(src.__calls).toEqual(['abap-review', 'abap-review']);
-    });
-    it('scrubs API key values from error envelopes', async () => {
-        const err = new Error(`auth failed: bearer=${FAKE_KEY} request denied`);
-        const src = makeFailingSource(err);
-        const ctx = makeCtx(process.cwd(), { skillSource: src });
-        const r = await playbookGetHandler({ name: 'abap-review' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).not.toContain(FAKE_KEY);
-        expect(r.content).toMatch(/\*\*\*/);
-    });
-});

package/dist/tools/__tests__/project_context_get.test.js

@@ -1,71 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { promises as fs } from 'node:fs';
-import { projectContextGetHandler, __resetToolCacheForTests } from '../project/project_context_get.js';
-import { makeCtx } from './_helpers.js';
-import { __resetProjectContextCacheForTests } from '../../agent/maybe-build-project-context.js';
-let tmpRoot;
-beforeEach(async () => {
-    tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-project-context-get-'));
-    __resetProjectContextCacheForTests();
-    __resetToolCacheForTests();
-});
-afterEach(async () => {
-    try {
-        await fs.rm(tmpRoot, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-    __resetProjectContextCacheForTests();
-    __resetToolCacheForTests();
-    vi.restoreAllMocks();
-});
-describe('project_context_get', () => {
-    it('returns a rendered <project_context> block when cwd resolves', async () => {
-        await fs.writeFile(path.join(tmpRoot, 'CLAUDE.md'), '# Test project\n');
-        await fs.writeFile(path.join(tmpRoot, 'package.json'), JSON.stringify({ name: 'x', version: '1.0.0' }));
-        const r = await projectContextGetHandler({}, makeCtx(tmpRoot));
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/<project_context/);
-        expect(r.content).toMatch(/<\/project_context>/);
-    });
-    it('returns a structured error when cwd is empty', async () => {
-        const r = await projectContextGetHandler({}, makeCtx(''));
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/cwd/i);
-    });
-    it('uses the cached render on a default call (force_refresh false)', async () => {
-        await fs.writeFile(path.join(tmpRoot, 'CLAUDE.md'), '# Initial content\n');
-        const r1 = await projectContextGetHandler({}, makeCtx(tmpRoot));
-        expect(r1.is_error).toBeFalsy();
-        expect(r1.content).toMatch(/Initial content/);
-        await fs.writeFile(path.join(tmpRoot, 'CLAUDE.md'), '# Updated content\n');
-        const r2 = await projectContextGetHandler({}, makeCtx(tmpRoot));
-        expect(r2.is_error).toBeFalsy();
-        expect(r2.content).toMatch(/Initial content/);
-        expect(r2.content).not.toMatch(/Updated content/);
-    });
-    it('rebuilds when force_refresh: true is passed', async () => {
-        await fs.writeFile(path.join(tmpRoot, 'CLAUDE.md'), '# First content\n');
-        const r1 = await projectContextGetHandler({}, makeCtx(tmpRoot));
-        expect(r1.content).toMatch(/First content/);
-        await fs.writeFile(path.join(tmpRoot, 'CLAUDE.md'), '# Refreshed content\n');
-        const r2 = await projectContextGetHandler({ force_refresh: true }, makeCtx(tmpRoot));
-        expect(r2.is_error).toBeFalsy();
-        expect(r2.content).toMatch(/Refreshed content/);
-        expect(r2.content).not.toMatch(/First content/);
-    });
-    it('rendered block does not contain bearer or known key prefixes (sanity scrub)', async () => {
-        await fs.writeFile(path.join(tmpRoot, 'CLAUDE.md'), '# Plain project\n');
-        const r = await projectContextGetHandler({}, makeCtx(tmpRoot));
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).not.toMatch(/Bearer\s+ey[A-Za-z0-9._-]+/i);
-        expect(r.content).not.toMatch(/sk-ant-[A-Za-z0-9_-]+/);
-        expect(r.content).not.toMatch(/ANTHROPIC_API_KEY/);
-    });
-    it('rejects force_refresh with a non-boolean value', async () => {
-        const r = await projectContextGetHandler({ force_refresh: 'yes' }, makeCtx(tmpRoot));
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/force_refresh.*boolean/i);
-    });
-});