@cspeach/cli 0.6.4 → 0.6.5

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

@@ -1,135 +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 { shellExecHandler } from '../shell/shell_exec.js';
-import { makeCtx } from './_helpers.js';
-let root;
-const ctx = () => makeCtx(root);
-beforeEach(async () => { root = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-shell-')); });
-afterEach(async () => { await fs.rm(root, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 }); });
-describe('shell_exec handler', () => {
-    it('runs a safelisted command and surfaces stdout + exit code', async () => {
-        const r = await shellExecHandler({ command: 'node', args: ['-e', 'process.stdout.write("hello")'] }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/stdout:\s*hello/);
-        expect(r.content).toMatch(/exit code:\s*0/);
-    });
-    it('surfaces stderr separately from stdout', async () => {
-        const r = await shellExecHandler({ command: 'node', args: ['-e', 'process.stderr.write("err"); process.stdout.write("out")'] }, ctx());
-        expect(r.content).toMatch(/stdout:\s*out/);
-        expect(r.content).toMatch(/stderr:\s*err/);
-    });
-    it('reports non-zero exit code without marking is_error', async () => {
-        const r = await shellExecHandler({ command: 'node', args: ['-e', 'process.exit(42)'] }, ctx());
-        // Non-zero exit is a normal program outcome — the agent should see it
-        // and decide. is_error is reserved for "we refused / spawn failed".
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/exit code:\s*42/);
-    });
-    it('shell metacharacters in args are passed literally — no shell parser', async () => {
-        // The string `; rm -rf /` becomes literal argv[1] to node, which echoes it.
-        // If a shell were interpreting, the `;` would split commands and the test
-        // output would be different (or the rm command would attempt to run).
-        const r = await shellExecHandler({ command: 'node', args: ['-e', 'process.stdout.write(process.argv[1])', '; rm -rf /'] }, ctx());
-        expect(r.content).toMatch(/stdout:\s*; rm -rf \//);
-        expect(r.content).toMatch(/exit code:\s*0/);
-    });
-    it('refuses an absolute-path command even if its basename is safelisted', async () => {
-        const fakeAbsolute = process.platform === 'win32' ? 'C:\\Windows\\System32\\cmd.exe' : '/bin/sh';
-        const r = await shellExecHandler({ command: fakeAbsolute, args: [] }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/safelist|absolute path/i);
-    });
-    it('refuses a non-safelisted command', async () => {
-        const r = await shellExecHandler({ command: 'curl', args: ['https://example.com'] }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/safelist/i);
-        expect(r.content).toMatch(/curl/);
-    });
-    it('refuses a cwd outside the project root', async () => {
-        const outsideAbsolute = process.platform === 'win32' ? 'C:\\' : '/';
-        const r = await shellExecHandler({ command: 'node', args: ['-e', 'process.stdout.write(process.cwd())'], cwd: outsideAbsolute }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/outside|cwd/i);
-    });
-    it('does NOT pass auth-secret env vars (CSPEACH_*, ANTHROPIC_*, SAP_*) to the child', async () => {
-        process.env.CSPEACH_TOKEN_TEST = 'must-not-leak';
-        process.env.ANTHROPIC_API_KEY_TEST = 'must-not-leak';
-        try {
-            const r = await shellExecHandler({
-                command: 'node',
-                args: [
-                    '-e',
-                    'const k = ["CSPEACH_TOKEN_TEST","ANTHROPIC_API_KEY_TEST"].filter(x=>process.env[x]); process.stdout.write(k.join(","))',
-                ],
-            }, ctx());
-            expect(r.content).toMatch(/stdout:\s*\n/); // empty stdout — neither var visible to child
-            expect(r.content).not.toContain('must-not-leak');
-        }
-        finally {
-            delete process.env.CSPEACH_TOKEN_TEST;
-            delete process.env.ANTHROPIC_API_KEY_TEST;
-        }
-    });
-    it('kills a runaway child after the wall-clock timeout', async () => {
-        const start = Date.now();
-        const r = await shellExecHandler({ command: 'node', args: ['-e', 'setInterval(()=>{},1000)'], timeout_ms: 300 }, ctx());
-        const elapsed = Date.now() - start;
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/timeout|timed out/i);
-        expect(elapsed).toBeLessThan(3_000); // generous — must be well under the 30s default
-    });
-    it('truncates stdout when it exceeds the per-stream cap', async () => {
-        // 2 MB of A's — should be truncated at 1 MB with a marker.
-        const r = await shellExecHandler({
-            command: 'node',
-            args: ['-e', 'process.stdout.write("A".repeat(2_000_000))'],
-            timeout_ms: 10_000,
-        }, ctx());
-        expect(r.is_error).toBeFalsy();
-        expect(r.content).toMatch(/\[truncated/i);
-        // Content should not contain the full 2 MB — be conservative, check length cap.
-        expect(r.content.length).toBeLessThan(1_200_000);
-    });
-    it('reports a structured error when the safelisted binary is not on PATH', async () => {
-        const origPath = process.env.PATH;
-        process.env.PATH = root; // PATH points only at empty tempdir — nothing installed.
-        try {
-            const r = await shellExecHandler({ command: 'abaplint', args: ['--version'] }, ctx());
-            expect(r.is_error).toBe(true);
-            expect(r.content).toMatch(/not installed|not found/i);
-            expect(r.content).toMatch(/abaplint/);
-        }
-        finally {
-            if (origPath === undefined)
-                delete process.env.PATH;
-            else
-                process.env.PATH = origPath;
-        }
-    });
-    it('rejects a non-string cwd with a clean error message (not a leaked TypeError)', async () => {
-        const r = await shellExecHandler({ command: 'node', args: [], cwd: 42 }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/cwd must be a string/i);
-        expect(r.content).not.toMatch(/typeerror|includes is not a function/i);
-    });
-    it('rejects a non-number timeout_ms with a clean error message', async () => {
-        const r = await shellExecHandler({ command: 'node', args: [], timeout_ms: 'fast' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/timeout_ms must be a number/i);
-    });
-    it('rejects an argv array longer than the cap (defense-in-depth against memory exhaustion)', async () => {
-        const huge = Array.from({ length: 1_001 }, () => 'x');
-        const r = await shellExecHandler({ command: 'node', args: huge }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/too many args/i);
-    });
-    it('rejects an individual arg larger than the per-arg cap', async () => {
-        const tooBig = 'x'.repeat(100_001);
-        const r = await shellExecHandler({ command: 'node', args: [tooBig] }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/exceeds max length/i);
-        expect(r.content).toMatch(/index 0/);
-    });
-});

package/dist/tools/__tests__/transport-safety.test.js

@@ -1,106 +0,0 @@
-/**
- * B.2 tests: sap_transport_release safety confirmation gate (Rule 9).
- *
- * Verifies that:
- *  - When safety mode is ON and user confirms, presentSafetyConfirmation is called
- *    with the correct SafetyAction shape (rule=RULE_9_TRANSPORT_RELEASE) and
- *    transportRelease proceeds.
- *  - When safety mode is ON and user declines, cancelled_by_user is returned and
- *    transportRelease is NOT called.
- */
-import '../transport.js'; // triggers registration side-effect
-import { getTool } from '../index.js';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// ---------------------------------------------------------------------------
-// Mock @cspeach/sap-client (auditLog used by transport.ts)
-// ---------------------------------------------------------------------------
-vi.mock('@cspeach/sap-client', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        auditLog: vi.fn().mockResolvedValue(undefined),
-    };
-});
-// ---------------------------------------------------------------------------
-// Mock verifyAndSpendApprovalId to bypass JWT check
-// ---------------------------------------------------------------------------
-const mockVerifyAndSpend = vi.hoisted(() => vi.fn());
-vi.mock('../../approvals/jwt.js', () => ({
-    verifyAndSpendApprovalId: mockVerifyAndSpend,
-    mintApprovalId: vi.fn(),
-}));
-// ---------------------------------------------------------------------------
-// Mock safety-mode-state and safety-confirm
-// ---------------------------------------------------------------------------
-const mockIsSafetyConfirmEnabled = vi.hoisted(() => vi.fn());
-vi.mock('../../repl/safety-mode-state.js', () => ({
-    isSafetyConfirmEnabled: mockIsSafetyConfirmEnabled,
-}));
-const mockPresentSafetyConfirmation = vi.hoisted(() => vi.fn());
-vi.mock('../../repl/safety-confirm.js', () => ({
-    presentSafetyConfirmation: mockPresentSafetyConfirmation,
-}));
-// ---------------------------------------------------------------------------
-// Helper: build a minimal ToolContext stub
-// ---------------------------------------------------------------------------
-function makeCtx(adt) {
-    return {
-        adt: adt,
-        sapAlias: 'dev',
-        session: { toolCalls: [] },
-        cwd: '.',
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    // Default: approval always succeeds
-    mockVerifyAndSpend.mockResolvedValue({ ok: true, payload: {} });
-    // Default: safety mode OFF
-    mockIsSafetyConfirmEnabled.mockReturnValue(false);
-});
-// ---------------------------------------------------------------------------
-// B.2 sap_transport_release — safety confirmation gate (Rule 9)
-// ---------------------------------------------------------------------------
-describe('sap_transport_release safety confirmation', () => {
-    it('calls presentSafetyConfirmation with correct SafetyAction and proceeds when confirmed', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(true);
-        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: true });
-        const mockTransportRelease = vi.fn().mockResolvedValue({
-            operation: 'release',
-            transportNumber: 'DEVK900123',
-            status: 'released',
-        });
-        const adt = { transportRelease: mockTransportRelease };
-        const tool = getTool('sap_transport_release');
-        const result = await tool.handler({ transport: 'DEVK900123', approval_id: 'dummy-jwt' }, makeCtx(adt));
-        // Safety confirmation must have been called with correct shape
-        expect(mockPresentSafetyConfirmation).toHaveBeenCalledOnce();
-        const action = mockPresentSafetyConfirmation.mock.calls[0][0];
-        expect(action.rule).toBe('RULE_9_TRANSPORT_RELEASE');
-        expect(action.op).toBe('transport_release');
-        expect(action.object).toEqual({ type: 'TRANSPORT', name: 'DEVK900123' });
-        expect(action.what_will_happen).toBeTruthy();
-        expect(action.rollback_available).toBe(false);
-        expect(action.transport).toBe('DEVK900123');
-        // transportRelease must have been called (confirmed)
-        expect(mockTransportRelease).toHaveBeenCalledOnce();
-        expect(mockTransportRelease).toHaveBeenCalledWith('DEVK900123');
-        const parsed = JSON.parse(result.content);
-        expect(parsed.released).toBe(true);
-        expect(result.is_error).toBeFalsy();
-    });
-    it('returns cancelled_by_user and does NOT call transportRelease when user declines', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(true);
-        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: false, reason: 'not ready' });
-        const mockTransportRelease = vi.fn();
-        const adt = { transportRelease: mockTransportRelease };
-        const tool = getTool('sap_transport_release');
-        const result = await tool.handler({ transport: 'DEVK900123', approval_id: 'dummy-jwt' }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('cancelled_by_user');
-        expect(parsed.reason).toBe('not ready');
-        // Critical: transportRelease must NOT be called
-        expect(mockTransportRelease).not.toHaveBeenCalled();
-    });
-});

package/dist/tools/__tests__/update-method-intercept.test.js

@@ -1,128 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { interceptUpdateMethod, extractMethodBody, CancelledByUserError, } from '../update-method-intercept.js';
-const SAMPLE_CLASS = `CLASS zcl_demo DEFINITION PUBLIC FINAL CREATE PUBLIC.
-  PUBLIC SECTION.
-    METHODS dispatch.
-    METHODS run_diff.
-ENDCLASS.
-
-CLASS zcl_demo IMPLEMENTATION.
-
-  METHOD dispatch.
-    DATA(lv_x) = 1.
-    lv_x = lv_x + 2.
-    " inline comment with " a quote
-    WRITE: lv_x.
-  ENDMETHOD.
-
-  METHOD run_diff.
-    RETURN.
-  ENDMETHOD.
-
-ENDCLASS.`;
-describe('extractMethodBody', () => {
-    it('returns the named method block including METHOD and ENDMETHOD', () => {
-        const body = extractMethodBody(SAMPLE_CLASS, 'dispatch');
-        expect(body).toMatch(/^\s*METHOD dispatch\.$/m);
-        expect(body).toMatch(/^\s*ENDMETHOD\.$/m);
-        expect(body).toContain('DATA(lv_x) = 1.');
-        // Should not bleed into run_diff's body.
-        expect(body).not.toContain('METHOD run_diff');
-    });
-    it('is case-insensitive for the method name', () => {
-        expect(extractMethodBody(SAMPLE_CLASS, 'DISPATCH')).toContain('DATA(lv_x)');
-        expect(extractMethodBody(SAMPLE_CLASS, 'Dispatch')).toContain('DATA(lv_x)');
-    });
-    it('returns empty string when method is not found', () => {
-        expect(extractMethodBody(SAMPLE_CLASS, 'nonexistent')).toBe('');
-    });
-    it('handles a method whose body contains an inline " comment', () => {
-        // The sample dispatch body has `" inline comment with " a quote` — the
-        // parser should NOT treat the `"` inside the comment as ending the body.
-        const body = extractMethodBody(SAMPLE_CLASS, 'dispatch');
-        expect(body).toContain('inline comment');
-    });
-    it('handles a method whose body contains string literals with keywords', () => {
-        const src = `CLASS x IMPLEMENTATION.
-  METHOD foo.
-    DATA(lv) = 'METHOD bar. ENDMETHOD.'.
-    DATA(lw) = \`ENDMETHOD pretend\`.
-    RETURN.
-  ENDMETHOD.
-
-  METHOD other.
-    WRITE 'hi'.
-  ENDMETHOD.
-ENDCLASS.`;
-        const body = extractMethodBody(src, 'foo');
-        expect(body).toMatch(/RETURN\./);
-        // The parser must stop at the REAL ENDMETHOD (not the ones inside the
-        // string literals on lines 3 and 4), so the body should NOT bleed into
-        // METHOD other.
-        expect(body).not.toContain('METHOD other');
-        expect(body).not.toContain("WRITE 'hi'");
-    });
-});
-describe('interceptUpdateMethod', () => {
-    function makeClient(source) {
-        return {
-            getSource: vi.fn(async () => source),
-        };
-    }
-    it('returns the call when the hook confirms', async () => {
-        const client = makeClient(SAMPLE_CLASS);
-        const hook = vi.fn(async () => ({ confirmed: true }));
-        const call = {
-            className: 'ZCL_DEMO',
-            methodName: 'dispatch',
-            methodSource: 'METHOD dispatch.\n  RETURN.\nENDMETHOD.',
-            transport: 'SXXK999999',
-        };
-        const result = await interceptUpdateMethod(client, call, hook);
-        expect(result).toBe(call);
-        expect(hook).toHaveBeenCalledOnce();
-        const passed = hook.mock.calls[0][0];
-        expect(passed.currentBody).toContain('DATA(lv_x) = 1.');
-        expect(passed.proposedBody).toBe(call.methodSource);
-    });
-    it('throws CancelledByUserError when the hook rejects', async () => {
-        const client = makeClient(SAMPLE_CLASS);
-        const hook = async () => ({ confirmed: false });
-        const call = {
-            className: 'ZCL_DEMO',
-            methodName: 'dispatch',
-            methodSource: 'METHOD dispatch.\nENDMETHOD.',
-            transport: 'SXXK999999',
-        };
-        await expect(interceptUpdateMethod(client, call, hook)).rejects.toThrow(CancelledByUserError);
-    });
-    it('passes empty currentBody when method does not exist on current class', async () => {
-        const client = makeClient(SAMPLE_CLASS);
-        const hook = vi.fn(async () => ({ confirmed: true }));
-        const call = {
-            className: 'ZCL_DEMO',
-            methodName: 'brand_new_method',
-            methodSource: 'METHOD brand_new_method.\n  RETURN.\nENDMETHOD.',
-            transport: 'SXXK999999',
-        };
-        await interceptUpdateMethod(client, call, hook);
-        const passed = hook.mock.calls[0][0];
-        expect(passed.currentBody).toBe('');
-        expect(passed.proposedBody).toBe(call.methodSource);
-    });
-    it('propagates a getSource failure unchanged', async () => {
-        const client = {
-            getSource: async () => {
-                throw new Error('ADT 401');
-            },
-        };
-        const hook = async () => ({ confirmed: true });
-        const call = {
-            className: 'ZCL_DEMO',
-            methodName: 'dispatch',
-            methodSource: 'METHOD dispatch.\nENDMETHOD.',
-            transport: 'SXXK999999',
-        };
-        await expect(interceptUpdateMethod(client, call, hook)).rejects.toThrow('ADT 401');
-    });
-});