@cspeach/cli 0.6.3 → 0.6.4

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

@@ -0,0 +1,135 @@
+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

@@ -0,0 +1,106 @@
+/**
+ * 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

@@ -0,0 +1,128 @@
+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');
+    });
+});