@cspeach/cli 0.6.4 → 0.6.5

package/dist/tools/__tests__/_web-shared.test.js

@@ -1,143 +0,0 @@
-// cspeach-cli/src/tools/__tests__/_web-shared.test.ts
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { validateUrl, isPrivateIp, BlockedHostError, BlockedProtocolError, MalformedUrlError, } from '../web/_web-shared.js';
-// Test helper: stub the DNS resolver to return a fixed address list.
-function fakeResolver(addresses) {
-    return {
-        resolveAll: async () => addresses,
-    };
-}
-let origAllowPrivate;
-beforeEach(() => {
-    origAllowPrivate = process.env.CSPEACH_WEB_ALLOW_PRIVATE;
-    delete process.env.CSPEACH_WEB_ALLOW_PRIVATE;
-});
-afterEach(() => {
-    if (origAllowPrivate === undefined)
-        delete process.env.CSPEACH_WEB_ALLOW_PRIVATE;
-    else
-        process.env.CSPEACH_WEB_ALLOW_PRIVATE = origAllowPrivate;
-});
-describe('isPrivateIp', () => {
-    it('flags IPv4 RFC1918 + loopback + link-local + multicast + reserved as private', () => {
-        expect(isPrivateIp('0.0.0.0')).toBe(true);
-        expect(isPrivateIp('127.0.0.1')).toBe(true);
-        expect(isPrivateIp('10.0.0.1')).toBe(true);
-        expect(isPrivateIp('172.16.0.1')).toBe(true);
-        expect(isPrivateIp('172.31.255.255')).toBe(true);
-        expect(isPrivateIp('192.168.1.1')).toBe(true);
-        expect(isPrivateIp('169.254.169.254')).toBe(true); // AWS / Azure metadata
-        expect(isPrivateIp('224.0.0.1')).toBe(true); // multicast
-        expect(isPrivateIp('255.255.255.255')).toBe(true); // broadcast
-        // 100.64.0.0/10 — CGNAT / shared address space (RFC 6598). Used by
-        // Fargate / Cloud Run / ACI for task-local networking. CSPeach must
-        // treat as private to avoid task-to-task SSRF inside a container host.
-        expect(isPrivateIp('100.64.0.1')).toBe(true);
-        expect(isPrivateIp('100.127.255.255')).toBe(true);
-    });
-    it('flags IPv6 loopback + ULA + link-local + unspecified as private', () => {
-        expect(isPrivateIp('::1')).toBe(true);
-        expect(isPrivateIp('fc00::1')).toBe(true);
-        expect(isPrivateIp('fe80::1')).toBe(true);
-        expect(isPrivateIp('::')).toBe(true);
-        // Link-local boundary: fe80::/10 spans fe80–febf. fe8: / febf: must
-        // resolve correctly — see the boundary test below for the false-positive
-        // case the regex used to allow.
-        expect(isPrivateIp('febf::1')).toBe(true); // link-local, top of range
-    });
-    it('flags IPv4-mapped IPv6 in hex form (Node URL parser normalization)', () => {
-        // Node's URL parser normalises https://[::ffff:192.168.1.1]/ to
-        // [::ffff:c0a8:101] (hex 16-bit-group form). Without explicit handling,
-        // an attacker bypasses RFC1918 + loopback by URL-encoding the address.
-        expect(isPrivateIp('::ffff:c0a8:101')).toBe(true); // 192.168.1.1 in hex
-        expect(isPrivateIp('::ffff:7f00:1')).toBe(true); // 127.0.0.1 in hex
-        expect(isPrivateIp('::ffff:0a00:1')).toBe(true); // 10.0.0.1 in hex
-        expect(isPrivateIp('::ffff:8080:8080')).toBe(false); // 128.128.128.128 — public, in hex
-    });
-    it('does NOT flag public IPv4 + IPv6 addresses', () => {
-        expect(isPrivateIp('8.8.8.8')).toBe(false);
-        expect(isPrivateIp('1.1.1.1')).toBe(false);
-        expect(isPrivateIp('172.15.0.1')).toBe(false); // just outside 172.16.0.0/12
-        expect(isPrivateIp('172.32.0.1')).toBe(false); // just outside the other end
-        expect(isPrivateIp('100.63.255.255')).toBe(false); // just below CGNAT
-        expect(isPrivateIp('100.128.0.1')).toBe(false); // just above CGNAT
-        expect(isPrivateIp('2001:db8::1')).toBe(false); // documentation prefix — counts as public for our purposes
-        expect(isPrivateIp('2606:4700:4700::1111')).toBe(false); // Cloudflare DNS
-        // Link-local regex must NOT false-positive on three-nibble groups.
-        // 'fe8:' / 'feb:' are global unicast, not fe80::/10 link-local.
-        expect(isPrivateIp('fe8::1')).toBe(false);
-        expect(isPrivateIp('fec0::1')).toBe(false); // site-local (deprecated, not blocked)
-    });
-});
-describe('validateUrl — protocol + scheme', () => {
-    it('accepts a valid HTTPS URL with public-resolving hostname', async () => {
-        const v = await validateUrl('https://example.com/foo?bar=baz', {
-            deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]),
-        });
-        expect(v.url.hostname).toBe('example.com');
-        expect(v.pinnedAddress).toBe('93.184.216.34');
-        expect(typeof v.pinnedLookup).toBe('function');
-    });
-    it('rejects http:// (HTTPS-only)', async () => {
-        await expect(validateUrl('http://example.com/', {
-            deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]),
-        })).rejects.toThrow(BlockedProtocolError);
-    });
-    it('rejects file:// and ftp:// and javascript: schemes', async () => {
-        for (const u of ['file:///etc/passwd', 'ftp://example.com/', 'javascript:alert(1)']) {
-            await expect(validateUrl(u, { deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]) })).rejects.toThrow(BlockedProtocolError);
-        }
-    });
-    it('rejects a malformed URL with MalformedUrlError', async () => {
-        await expect(validateUrl('not a url', { deps: fakeResolver([]) })).rejects.toThrow(MalformedUrlError);
-    });
-    it('pinnedLookup returns ENOTFOUND when called with a hostname other than the pinned one', async () => {
-        // Defends against a misconfigured https.request that re-dispatches the
-        // lookup with a hostname different to the one we validated. We MUST
-        // refuse that call — silently honouring it re-opens DNS rebinding.
-        const v = await validateUrl('https://example.com/', {
-            deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]),
-        });
-        const err = await new Promise((resolve) => {
-            v.pinnedLookup('attacker-controlled.com', {}, (e) => resolve(e));
-        });
-        expect(err).not.toBeNull();
-        expect(err?.code).toBe('ENOTFOUND');
-    });
-});
-describe('validateUrl — hostname + IP blocklists', () => {
-    it('rejects literal localhost hostname (string match BEFORE DNS)', async () => {
-        await expect(validateUrl('https://localhost/', {
-            deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]), // even if DNS lies, blocked on name
-        })).rejects.toThrow(BlockedHostError);
-    });
-    it('rejects .local mDNS suffixes', async () => {
-        await expect(validateUrl('https://mymac.local/', { deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]) })).rejects.toThrow(BlockedHostError);
-    });
-    it('rejects metadata.google.internal by literal name match', async () => {
-        await expect(validateUrl('https://metadata.google.internal/computeMetadata/v1/', {
-            deps: fakeResolver([{ address: '93.184.216.34', family: 4 }]),
-        })).rejects.toThrow(BlockedHostError);
-    });
-    it('rejects a public-looking hostname that resolves to a private IP (DNS-rebinding defense)', async () => {
-        await expect(validateUrl('https://attacker-controlled.example.com/', {
-            deps: fakeResolver([{ address: '127.0.0.1', family: 4 }]),
-        })).rejects.toThrow(BlockedHostError);
-    });
-    it('rejects a hostname where ANY resolved address is private (mixed result)', async () => {
-        // Some resolvers return BOTH a public and a private IP; we must reject if EITHER is private.
-        await expect(validateUrl('https://mixed.example.com/', {
-            deps: fakeResolver([
-                { address: '93.184.216.34', family: 4 },
-                { address: '169.254.169.254', family: 4 },
-            ]),
-        })).rejects.toThrow(BlockedHostError);
-    });
-    it('accepts a private-IP-resolving URL when CSPEACH_WEB_ALLOW_PRIVATE=on is set', async () => {
-        process.env.CSPEACH_WEB_ALLOW_PRIVATE = 'on';
-        const v = await validateUrl('https://dev.localhost.test/', {
-            deps: fakeResolver([{ address: '127.0.0.1', family: 4 }]),
-        });
-        expect(v.pinnedAddress).toBe('127.0.0.1');
-    });
-});

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

@@ -1,166 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { agentRunHandler, MAX_AGENT_DEPTH, DEFAULT_MAX_TOKENS, HARD_MAX_TOKENS } from '../subagent/agent_run.js';
-import { makeCtx } from './_helpers.js';
-// runTurn import is hoisted-mocked below so we can inspect the args
-// agent_run handed it without actually invoking the LLM.
-const { runTurnMock } = vi.hoisted(() => ({ runTurnMock: vi.fn() }));
-vi.mock('../../agent/loop.js', () => ({
-    runTurn: runTurnMock,
-}));
-function makeSkillSource(body = '# fake skill body') {
-    return {
-        async getSkillBody(name) {
-            return { name, body, sha256: 'fake', signature: 'fake', signedAt: '2026-05-14T00:00:00Z' };
-        },
-        async listAvailableSkills() { return ['abap-review']; },
-        describe() { return 'fake-source'; },
-    };
-}
-function makeProvider() {
-    return { kind: 'anthropic', name: 'fake-provider' };
-}
-let savedDepth;
-beforeEach(() => {
-    runTurnMock.mockReset();
-    savedDepth = process.env.CSPEACH_AGENT_DEPTH;
-    delete process.env.CSPEACH_AGENT_DEPTH;
-});
-afterEach(() => {
-    if (savedDepth === undefined)
-        delete process.env.CSPEACH_AGENT_DEPTH;
-    else
-        process.env.CSPEACH_AGENT_DEPTH = savedDepth;
-    vi.restoreAllMocks();
-});
-describe('agent_run handler', () => {
-    it('invokes runTurn with a fresh child session and returns the child assistant text', async () => {
-        runTurnMock.mockImplementation(async (params) => {
-            // Simulate the child loop pushing an assistant text block.
-            params.ctx.session.messages.push({
-                role: 'assistant',
-                content: [{ type: 'text', text: 'child says hi' }],
-            });
-        });
-        const ctx = makeCtx(process.cwd(), {
-            provider: makeProvider(),
-            skillSource: makeSkillSource(),
-        });
-        const r = await agentRunHandler({ skill: 'abap-review', task: 'review ZCL_X' }, ctx);
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toContain('child says hi');
-        expect(runTurnMock).toHaveBeenCalledOnce();
-        const callArgs = runTurnMock.mock.calls[0][0];
-        expect(callArgs.ctx).not.toBe(ctx);
-        expect(callArgs.ctx.session).not.toBe(ctx.session);
-        // I2 fix: chunkEmitter is now a null-sink EventEmitter (not undefined)
-        // so subagent stdout is silently dropped without polluting parent UI.
-        expect(callArgs.chunkEmitter).toBeDefined();
-        expect(callArgs.chunkEmitter.listenerCount?.('chunk') ?? 0).toBe(0);
-        expect(callArgs.ctx.previewHook).toBeUndefined();
-        expect(callArgs.ctx.chunkEmitter).toBeUndefined();
-        expect(callArgs.skill).toBe('abap-review');
-    });
-    it('I1 regression — child session.usage is a clone, not a shared reference', async () => {
-        runTurnMock.mockImplementation(async () => { });
-        const parentSession = {
-            messages: [],
-            usage: { input_tokens: 100, output_tokens: 50, cache_read_input_tokens: 10 },
-        };
-        const ctx = makeCtx(process.cwd(), {
-            provider: makeProvider(),
-            skillSource: makeSkillSource(),
-            session: parentSession,
-        });
-        await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        const callArgs = runTurnMock.mock.calls[0][0];
-        expect(callArgs.ctx.session.usage).not.toBe(parentSession.usage);
-        expect(callArgs.ctx.session.usage).toEqual(parentSession.usage);
-    });
-    it('rejects when ctx.provider is missing (not wired)', async () => {
-        const ctx = makeCtx(process.cwd(), { skillSource: makeSkillSource() });
-        const r = await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/provider/i);
-        expect(runTurnMock).not.toHaveBeenCalled();
-    });
-    it('rejects when ctx.skillSource is missing', async () => {
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider() });
-        const r = await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/skillSource|skill source/i);
-        expect(runTurnMock).not.toHaveBeenCalled();
-    });
-    it('rejects missing skill arg', async () => {
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        const r = await agentRunHandler({ task: 't' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/skill/i);
-        expect(runTurnMock).not.toHaveBeenCalled();
-    });
-    it('rejects missing task arg', async () => {
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        const r = await agentRunHandler({ skill: 'abap-review' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/task/i);
-        expect(runTurnMock).not.toHaveBeenCalled();
-    });
-    it('refuses to dispatch when depth would exceed MAX_AGENT_DEPTH', async () => {
-        process.env.CSPEACH_AGENT_DEPTH = String(MAX_AGENT_DEPTH);
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        const r = await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/depth/i);
-        expect(runTurnMock).not.toHaveBeenCalled();
-    });
-    it('increments CSPEACH_AGENT_DEPTH for the child before invoking runTurn', async () => {
-        let observed;
-        runTurnMock.mockImplementation(async () => {
-            observed = process.env.CSPEACH_AGENT_DEPTH;
-        });
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(observed).toBe('1');
-    });
-    it('restores CSPEACH_AGENT_DEPTH to its prior value after runTurn returns', async () => {
-        process.env.CSPEACH_AGENT_DEPTH = '1';
-        runTurnMock.mockResolvedValueOnce(undefined);
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(process.env.CSPEACH_AGENT_DEPTH).toBe('1');
-    });
-    it('clamps max_tokens to HARD_MAX_TOKENS', async () => {
-        let observedMaxTokens;
-        runTurnMock.mockImplementation(async (params) => {
-            observedMaxTokens = params.maxTokensOverride;
-        });
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        await agentRunHandler({ skill: 'abap-review', task: 't', max_tokens: 999_999_999 }, ctx);
-        expect(observedMaxTokens).toBe(HARD_MAX_TOKENS);
-    });
-    it('uses DEFAULT_MAX_TOKENS when max_tokens omitted', async () => {
-        let observedMaxTokens;
-        runTurnMock.mockImplementation(async (params) => {
-            observedMaxTokens = params.maxTokensOverride;
-        });
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(observedMaxTokens).toBe(DEFAULT_MAX_TOKENS);
-    });
-    it('forwards a runTurn rejection as a structured error envelope', async () => {
-        runTurnMock.mockRejectedValueOnce(new Error('child loop crashed'));
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        const r = await agentRunHandler({ skill: 'abap-review', task: 't' }, ctx);
-        expect(r.is_error).toBe(true);
-        // M5: assert BOTH wrapper AND inner message — guards against the
-        // wrapper swallowing the underlying error text.
-        expect(r.content).toMatch(/subagent failed/i);
-        expect(r.content).toMatch(/child loop crashed/i);
-    });
-    it('validates skill name shape (defense in depth on ctx.skillSource lookup key)', async () => {
-        const ctx = makeCtx(process.cwd(), { provider: makeProvider(), skillSource: makeSkillSource() });
-        const r = await agentRunHandler({ skill: '../etc/passwd', task: 't' }, ctx);
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/invalid skill/i);
-        expect(runTurnMock).not.toHaveBeenCalled();
-    });
-});

package/dist/tools/__tests__/approval-advisory.test.js

@@ -1,66 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock loadConfig while preserving the rest of the module's exports so that
-// approval.ts's other imports (WriteMode, isValidWriteMode, etc., if any) stay
-// intact at import time.
-const mockLoadConfig = vi.fn();
-vi.mock('../../config/loader.js', async () => {
-    const actual = await vi.importActual('../../config/loader.js');
-    return { ...actual, loadConfig: mockLoadConfig };
-});
-// Mock the prompt (don't mock the renderer — it's pure).
-const mockPromptAdvisory = vi.fn();
-vi.mock('../../approvals/advisory-prompt.js', () => ({
-    promptAdvisory: mockPromptAdvisory,
-}));
-describe('handleAdvisoryApproval', () => {
-    const baseRequest = {
-        summary: 'Create ZCL_FOO',
-        risk: 'low',
-        transport: 'DEVK900123',
-        changes: [
-            { op: 'create', object: 'ZCL_FOO', type: 'CLAS', diff: 'CLASS...' },
-        ],
-    };
-    beforeEach(() => {
-        mockLoadConfig.mockReset();
-        mockPromptAdvisory.mockReset();
-    });
-    it('does not mint approval_ids when write_mode=advisory-only (outcome=applied)', async () => {
-        mockLoadConfig.mockResolvedValue({
-            write_mode: 'advisory-only',
-            sap: { DEV: { auto_approve: 'never' } },
-        });
-        mockPromptAdvisory.mockResolvedValue('applied');
-        const { handleAdvisoryApproval } = await import('../approval.js');
-        const result = await handleAdvisoryApproval(baseRequest, { sapAlias: 'DEV' });
-        const payload = JSON.parse(result.content);
-        expect(payload.approval_ids).toBeUndefined();
-        expect(payload.advisory_outcome).toBe('applied');
-        expect(String(payload.ai_directive).toLowerCase()).toContain('propos');
-        expect(String(payload.ai_directive).toLowerCase()).toContain('do not attempt');
-    });
-    it('returns outcome=skipped when developer chooses skip', async () => {
-        mockLoadConfig.mockResolvedValue({
-            write_mode: 'advisory-only',
-            sap: { DEV: { auto_approve: 'never' } },
-        });
-        mockPromptAdvisory.mockResolvedValue('skipped');
-        const { handleAdvisoryApproval } = await import('../approval.js');
-        const result = await handleAdvisoryApproval(baseRequest, { sapAlias: 'DEV' });
-        const payload = JSON.parse(result.content);
-        expect(payload.advisory_outcome).toBe('skipped');
-        expect(String(payload.ai_directive).toLowerCase()).toContain('skipped');
-    });
-    it('returns outcome=aborted when developer chooses abort', async () => {
-        mockLoadConfig.mockResolvedValue({
-            write_mode: 'advisory-only',
-            sap: { DEV: { auto_approve: 'never' } },
-        });
-        mockPromptAdvisory.mockResolvedValue('aborted');
-        const { handleAdvisoryApproval } = await import('../approval.js');
-        const result = await handleAdvisoryApproval(baseRequest, { sapAlias: 'DEV' });
-        const payload = JSON.parse(result.content);
-        expect(payload.advisory_outcome).toBe('aborted');
-        expect(String(payload.ai_directive).toLowerCase()).toContain('abort');
-    });
-});

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

@@ -1,113 +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 { backgroundRunHandler } from '../subagent/background_run.js';
-import { getBackground, consumeEvents, __resetRegistryForTests, } from '../subagent/_background-shared.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => {
-    __resetRegistryForTests();
-    root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-bg-'));
-});
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }); });
-/** Wait for the entry to be marked closed. Polls; ceiling so the test fails clearly. */
-// If you see flakes on slow CI, bump timeoutMs ceiling — don't tighten the poll interval.
-async function waitForExit(bg_id, timeoutMs = 5000) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const e = getBackground(bg_id);
-        if (e?.closed)
-            return;
-        await new Promise((r) => setTimeout(r, 25));
-    }
-    throw new Error(`background ${bg_id} did not close within ${timeoutMs}ms`);
-}
-describe('background_run handler', () => {
-    it('spawns a safelisted command and returns a bg_id immediately', async () => {
-        const r = await backgroundRunHandler({ command: 'node', args: ['-e', 'process.stdout.write("hello"); process.exit(0)'] }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/bg_id:\s*bg-[a-f0-9-]+/);
-        const m = r.content.match(/bg_id:\s*(bg-[a-f0-9-]+)/);
-        expect(m).not.toBeNull();
-        expect(getBackground(m[1])).toBeDefined();
-    });
-    it('records stdout events captured from the child', async () => {
-        const r = await backgroundRunHandler({ command: 'node', args: ['-e', 'process.stdout.write("line1\\nline2\\n"); process.exit(0)'] }, ctx());
-        const bg_id = r.content.match(/bg_id:\s*(bg-[a-f0-9-]+)/)[1];
-        await waitForExit(bg_id);
-        const consumed = consumeEvents(bg_id, 100);
-        expect(consumed).not.toBeNull();
-        const stdoutTexts = consumed.events.filter((e) => e.kind === 'stdout').map((e) => e.text);
-        expect(stdoutTexts.join('')).toMatch(/line1[\s\S]*line2/);
-        expect(consumed.closed).toBe(true);
-        expect(consumed.exitCode).toBe(0);
-    });
-    it('records stderr events separately from stdout', async () => {
-        const r = await backgroundRunHandler({ command: 'node', args: ['-e', 'process.stderr.write("oops\\n"); process.exit(1)'] }, ctx());
-        const bg_id = r.content.match(/bg_id:\s*(bg-[a-f0-9-]+)/)[1];
-        await waitForExit(bg_id);
-        const consumed = consumeEvents(bg_id, 100);
-        const stderrTexts = consumed.events.filter((e) => e.kind === 'stderr').map((e) => e.text);
-        expect(stderrTexts.join('')).toMatch(/oops/);
-        expect(consumed.exitCode).toBe(1);
-    });
-    it('refuses a non-safelisted command', async () => {
-        const r = await backgroundRunHandler({ command: 'curl', args: ['https://example.com'] }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/safelist/i);
-    });
-    it('refuses an absolute path even if basename is safelisted', async () => {
-        const abs = process.platform === 'win32' ? 'C:\\Windows\\System32\\cmd.exe' : '/bin/sh';
-        const r = await backgroundRunHandler({ command: abs, args: [] }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/separators|absolute/i);
-    });
-    it('rejects argv > MAX_ARGS', async () => {
-        const tooMany = Array.from({ length: 1001 }, () => 'x');
-        const r = await backgroundRunHandler({ command: 'node', args: tooMany }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/too many args/i);
-    });
-    it('refuses cwd outside the project root', async () => {
-        const outside = process.platform === 'win32' ? 'C:\\' : '/';
-        const r = await backgroundRunHandler({ command: 'node', args: ['-e', 'process.exit(0)'], cwd: outside }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/outside|cwd/i);
-    });
-    it('does NOT leak CSPEACH_*/ANTHROPIC_*/SAP_* env vars to the child', async () => {
-        process.env.CSPEACH_BG_TEST_LEAK = 'must-not-leak';
-        process.env.ANTHROPIC_BG_TEST_LEAK = 'must-not-leak';
-        process.env.FOO_BG_TEST_LEAK_CANARY = 'must-not-leak';
-        try {
-            const r = await backgroundRunHandler({
-                command: 'node',
-                args: [
-                    '-e',
-                    'const k = ["CSPEACH_BG_TEST_LEAK","ANTHROPIC_BG_TEST_LEAK","FOO_BG_TEST_LEAK_CANARY"].filter(x=>process.env[x]); process.stdout.write(k.join(","))',
-                ],
-            }, ctx());
-            const bg_id = r.content.match(/bg_id:\s*(bg-[a-f0-9-]+)/)[1];
-            await waitForExit(bg_id);
-            const consumed = consumeEvents(bg_id, 100);
-            const text = consumed.events.map((e) => e.text).join('');
-            expect(text).not.toContain('must-not-leak');
-        }
-        finally {
-            delete process.env.CSPEACH_BG_TEST_LEAK;
-            delete process.env.ANTHROPIC_BG_TEST_LEAK;
-            delete process.env.FOO_BG_TEST_LEAK_CANARY;
-        }
-    });
-    it('records exit event with exitCode + signal', async () => {
-        const r = await backgroundRunHandler({ command: 'node', args: ['-e', 'process.exit(7)'] }, ctx());
-        const bg_id = r.content.match(/bg_id:\s*(bg-[a-f0-9-]+)/)[1];
-        await waitForExit(bg_id);
-        const consumed = consumeEvents(bg_id, 100);
-        const exitEv = consumed.events.find((e) => e.kind === 'exit');
-        expect(exitEv).toBeDefined();
-        expect(exitEv.exitCode).toBe(7);
-        expect(consumed.exitCode).toBe(7);
-    });
-});

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

@@ -1,53 +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 { conventionGetHandler } from '../project/convention_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-convention-get-'));
-    __resetProjectContextCacheForTests();
-});
-afterEach(async () => {
-    try {
-        await fs.rm(tmpRoot, { recursive: true, force: true });
-    }
-    catch { /* ignore */ }
-    __resetProjectContextCacheForTests();
-    vi.restoreAllMocks();
-});
-describe('convention_get', () => {
-    it("returns the full conventions object as JSON when field='all'", async () => {
-        const r = await conventionGetHandler({ field: 'all' }, makeCtx(tmpRoot));
-        expect(r.is_error).toBeFalsy();
-        const parsed = JSON.parse(r.content);
-        expect(parsed.style).toBeDefined();
-        expect(parsed.namingPatterns).toBeDefined();
-        expect(typeof parsed.style.indentSize).toBe('number');
-    });
-    it("returns the indent size as a number when field='indentSize'", async () => {
-        const r = await conventionGetHandler({ field: 'indentSize' }, makeCtx(tmpRoot));
-        expect(r.is_error).toBeFalsy();
-        expect(r.content.trim()).toMatch(/^\d+$/);
-    });
-    it("returns the EOL style when field='eol'", async () => {
-        const r = await conventionGetHandler({ field: 'eol' }, makeCtx(tmpRoot));
-        expect(r.is_error).toBeFalsy();
-        expect(['lf', 'crlf']).toContain(r.content.trim());
-    });
-    it("returns the namingPatterns object as JSON when field='namingPatterns'", async () => {
-        const r = await conventionGetHandler({ field: 'namingPatterns' }, makeCtx(tmpRoot));
-        expect(r.is_error).toBeFalsy();
-        const parsed = JSON.parse(r.content);
-        expect(parsed).toHaveProperty('classes');
-        expect(parsed).toHaveProperty('interfaces');
-        expect(parsed).toHaveProperty('cdsViews');
-    });
-    it('rejects an unknown field with a structured error', async () => {
-        const r = await conventionGetHandler({ field: 'flavor' }, makeCtx(tmpRoot));
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/unknown field|invalid field/i);
-    });
-});

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

@@ -1,72 +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 { fileEditHandler } from '../filesystem/file-edit.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-file-edit-')); });
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true }); });
-describe('file_edit handler', () => {
-    it('happy path — replaces a unique string and returns count', async () => {
-        await fs.writeFile(path.join(root, 'hello.ts'), 'hello world\nsecond line\n', 'utf-8');
-        const r = await fileEditHandler({ path: 'hello.ts', old_string: 'hello world', new_string: 'goodbye world' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/edited.*hello\.ts.*1 replacement/i);
-        const updated = await fs.readFile(path.join(root, 'hello.ts'), 'utf-8');
-        expect(updated).toContain('goodbye world');
-        expect(updated).not.toContain('hello world');
-        expect(updated).toContain('second line');
-    });
-    it('errors when old_string is not found in the file', async () => {
-        await fs.writeFile(path.join(root, 'foo.ts'), 'line one\nline two\n', 'utf-8');
-        const r = await fileEditHandler({ path: 'foo.ts', old_string: 'does not exist', new_string: 'replacement' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/not found/i);
-    });
-    it('errors when old_string matches multiple times without replace_all', async () => {
-        await fs.writeFile(path.join(root, 'dup.ts'), 'foo bar\nfoo baz\n', 'utf-8');
-        const r = await fileEditHandler({ path: 'dup.ts', old_string: 'foo', new_string: 'qux' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/matches 2 times/i);
-        expect(r.content).toMatch(/replace_all/i);
-        // file must be unchanged
-        const unchanged = await fs.readFile(path.join(root, 'dup.ts'), 'utf-8');
-        expect(unchanged).toContain('foo bar');
-    });
-    it('replace_all=true replaces all occurrences', async () => {
-        await fs.writeFile(path.join(root, 'multi.ts'), 'foo bar\nfoo baz\nfoo qux\n', 'utf-8');
-        const r = await fileEditHandler({ path: 'multi.ts', old_string: 'foo', new_string: 'boo', replace_all: true }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/3 replacements/i);
-        const updated = await fs.readFile(path.join(root, 'multi.ts'), 'utf-8');
-        expect(updated).toBe('boo bar\nboo baz\nboo qux\n');
-    });
-    it('refuses path traversal (../foo)', async () => {
-        const r = await fileEditHandler({ path: '../../etc/passwd', old_string: 'root', new_string: 'nobody' }, 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 });
-        await fs.writeFile(path.join(root, '.cspeach', 'auth.json'), '{"token":"secret"}', 'utf-8');
-        const r = await fileEditHandler({ path: '.cspeach/auth.json', old_string: 'secret', new_string: 'redacted' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/sensitive path/i);
-        // file must be unchanged
-        const unchanged = await fs.readFile(path.join(root, '.cspeach', 'auth.json'), 'utf-8');
-        expect(unchanged).toContain('secret');
-    });
-    it('errors when old_string === new_string (no-op edit refused)', async () => {
-        await fs.writeFile(path.join(root, 'noop.ts'), 'some content\n', 'utf-8');
-        const r = await fileEditHandler({ path: 'noop.ts', old_string: 'some content', new_string: 'some content' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/no-op|old_string.*new_string.*identical|same/i);
-    });
-    it('errors when the file does not exist', async () => {
-        const r = await fileEditHandler({ path: 'nonexistent.ts', old_string: 'foo', new_string: 'bar' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/not found|ENOENT/i);
-    });
-});