@showrun/core 0.1.0 → 0.1.1-b

package/dist/__tests__/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/__tests__/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/config.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/config.test.js

@@ -0,0 +1,164 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdirSync, rmSync, existsSync } from 'fs';
+import { join, resolve } from 'path';
+import { tmpdir } from 'os';
+import { randomBytes } from 'crypto';
+import { deepMerge, discoverConfigDirs, loadConfig, applyConfigToEnv, resolveFilePath, } from '../config.js';
+/** Create a unique temporary directory for each test */
+function makeTempDir() {
+    const dir = join(tmpdir(), `showrun-test-${randomBytes(6).toString('hex')}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+describe('deepMerge', () => {
+    it('merges flat objects', () => {
+        const base = { a: 1, b: 2 };
+        const override = { b: 3, c: 4 };
+        expect(deepMerge(base, override)).toEqual({ a: 1, b: 3, c: 4 });
+    });
+    it('recursively merges nested objects', () => {
+        const base = { llm: { provider: 'openai', openai: { apiKey: 'k1' } } };
+        const override = { llm: { provider: 'anthropic', anthropic: { apiKey: 'k2' } } };
+        const result = deepMerge(base, override);
+        expect(result).toEqual({
+            llm: {
+                provider: 'anthropic',
+                openai: { apiKey: 'k1' },
+                anthropic: { apiKey: 'k2' },
+            },
+        });
+    });
+    it('skips null and undefined values in override', () => {
+        const base = { a: 1, b: 2 };
+        const override = { a: null, b: undefined, c: 3 };
+        expect(deepMerge(base, override)).toEqual({ a: 1, b: 2, c: 3 });
+    });
+    it('replaces arrays instead of merging them', () => {
+        const base = { items: [1, 2, 3] };
+        const override = { items: [4, 5] };
+        expect(deepMerge(base, override)).toEqual({ items: [4, 5] });
+    });
+    it('replaces primitives', () => {
+        const base = { x: 'old' };
+        const override = { x: 'new' };
+        expect(deepMerge(base, override)).toEqual({ x: 'new' });
+    });
+});
+describe('discoverConfigDirs', () => {
+    it('returns an array of strings', () => {
+        const dirs = discoverConfigDirs();
+        expect(Array.isArray(dirs)).toBe(true);
+        expect(dirs.length).toBeGreaterThan(0);
+        for (const d of dirs) {
+            expect(typeof d).toBe('string');
+        }
+    });
+    it('includes cwd/.showrun as the last entry', () => {
+        const dirs = discoverConfigDirs();
+        const last = dirs[dirs.length - 1];
+        expect(last).toBe(join(process.cwd(), '.showrun'));
+    });
+    it('respects XDG_CONFIG_HOME when set (non-Windows)', () => {
+        if (process.platform === 'win32')
+            return; // skip on Windows
+        const original = process.env.XDG_CONFIG_HOME;
+        const customXdg = '/tmp/custom-xdg-config';
+        process.env.XDG_CONFIG_HOME = customXdg;
+        try {
+            const dirs = discoverConfigDirs();
+            expect(dirs[0]).toBe(join(customXdg, 'showrun'));
+        }
+        finally {
+            if (original === undefined)
+                delete process.env.XDG_CONFIG_HOME;
+            else
+                process.env.XDG_CONFIG_HOME = original;
+        }
+    });
+});
+describe('applyConfigToEnv', () => {
+    const testEnvVars = [
+        'LLM_PROVIDER',
+        'ANTHROPIC_API_KEY',
+        'OPENAI_API_KEY',
+        'MAX_BROWSER_ROUNDS',
+    ];
+    const saved = {};
+    beforeEach(() => {
+        for (const v of testEnvVars) {
+            saved[v] = process.env[v];
+            delete process.env[v];
+        }
+    });
+    afterEach(() => {
+        for (const v of testEnvVars) {
+            if (saved[v] === undefined)
+                delete process.env[v];
+            else
+                process.env[v] = saved[v];
+        }
+    });
+    it('sets env vars from config when not already present', () => {
+        const config = {
+            llm: { provider: 'anthropic', anthropic: { apiKey: 'sk-test' } },
+        };
+        applyConfigToEnv(config);
+        expect(process.env.LLM_PROVIDER).toBe('anthropic');
+        expect(process.env.ANTHROPIC_API_KEY).toBe('sk-test');
+    });
+    it('does not overwrite existing env vars', () => {
+        process.env.ANTHROPIC_API_KEY = 'existing-key';
+        const config = {
+            llm: { anthropic: { apiKey: 'should-not-replace' } },
+        };
+        applyConfigToEnv(config);
+        expect(process.env.ANTHROPIC_API_KEY).toBe('existing-key');
+    });
+    it('converts numbers to strings', () => {
+        const config = {
+            agent: { maxBrowserRounds: 5 },
+        };
+        applyConfigToEnv(config);
+        expect(process.env.MAX_BROWSER_ROUNDS).toBe('5');
+    });
+});
+describe('loadConfig', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = makeTempDir();
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('returns empty config and loadedFiles when no config files exist', () => {
+        // loadConfig uses discoverConfigDirs which won't include tempDir
+        // but this validates the basic structure
+        const result = loadConfig();
+        expect(result.config).toBeDefined();
+        expect(Array.isArray(result.loadedFiles)).toBe(true);
+        expect(Array.isArray(result.searchedDirs)).toBe(true);
+    });
+});
+describe('resolveFilePath', () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = makeTempDir();
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it('returns null when file is not found', () => {
+        const result = resolveFilePath(`nonexistent-${randomBytes(8).toString('hex')}.txt`);
+        expect(result).toBeNull();
+    });
+    it('finds a file in cwd', () => {
+        // This tests the cwd fallback — the EXPLORATION_AGENT_SYSTEM_PROMPT.md
+        // should be found if it exists in the repo root
+        const promptFile = 'EXPLORATION_AGENT_SYSTEM_PROMPT.md';
+        const cwdPath = resolve(process.cwd(), promptFile);
+        if (existsSync(cwdPath)) {
+            const result = resolveFilePath(promptFile);
+            expect(result).toBeTruthy();
+        }
+    });
+});

package/dist/__tests__/httpReplay.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=httpReplay.test.d.ts.map

package/dist/__tests__/httpReplay.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"httpReplay.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/httpReplay.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/httpReplay.test.js

@@ -0,0 +1,306 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { isFlowHttpCompatible, replayFromSnapshot } from '../httpReplay.js';
+function makeSnapshotFile(stepIds) {
+    const snapshots = {};
+    for (const id of stepIds) {
+        snapshots[id] = {
+            stepId: id,
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'GET',
+                url: 'https://api.example.com/data',
+                headers: { 'content-type': 'application/json' },
+                body: null,
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: 'application/json',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: [],
+        };
+    }
+    return { version: 1, snapshots };
+}
+// ---------------------------------------------------------------------------
+// isFlowHttpCompatible
+// ---------------------------------------------------------------------------
+describe('isFlowHttpCompatible', () => {
+    it('returns true when all network_replay steps have snapshots and no DOM extraction', () => {
+        const steps = [
+            { id: 'nav1', type: 'navigate', params: { url: 'https://example.com' } },
+            { id: 'find1', type: 'network_find', params: { where: { urlIncludes: '/api/' }, saveAs: 'reqId' } },
+            {
+                id: 'replay1', type: 'network_replay',
+                params: { requestId: '{{vars.reqId}}', auth: 'browser_context', out: 'data', response: { as: 'json' } },
+            },
+            { id: 'var1', type: 'set_var', params: { name: 'x', value: 'y' } },
+        ];
+        const snapshots = makeSnapshotFile(['replay1']);
+        expect(isFlowHttpCompatible(steps, snapshots)).toBe(true);
+    });
+    it('returns false when snapshots is null', () => {
+        const steps = [
+            {
+                id: 'replay1', type: 'network_replay',
+                params: { requestId: '{{vars.reqId}}', auth: 'browser_context', out: 'data', response: { as: 'json' } },
+            },
+        ];
+        expect(isFlowHttpCompatible(steps, null)).toBe(false);
+    });
+    it('returns false when a replay step has no snapshot', () => {
+        const steps = [
+            {
+                id: 'replay1', type: 'network_replay',
+                params: { requestId: '{{vars.reqId}}', auth: 'browser_context', out: 'data', response: { as: 'json' } },
+            },
+            {
+                id: 'replay2', type: 'network_replay',
+                params: { requestId: '{{vars.reqId2}}', auth: 'browser_context', out: 'data2', response: { as: 'json' } },
+            },
+        ];
+        const snapshots = makeSnapshotFile(['replay1']); // Missing replay2
+        expect(isFlowHttpCompatible(steps, snapshots)).toBe(false);
+    });
+    it('returns false when flow contains extract_text step', () => {
+        const steps = [
+            {
+                id: 'replay1', type: 'network_replay',
+                params: { requestId: '{{vars.reqId}}', auth: 'browser_context', out: 'data', response: { as: 'json' } },
+            },
+            {
+                id: 'extract1', type: 'extract_text',
+                params: { target: { kind: 'css', selector: '.title' }, out: 'title' },
+            },
+        ];
+        const snapshots = makeSnapshotFile(['replay1']);
+        expect(isFlowHttpCompatible(steps, snapshots)).toBe(false);
+    });
+    it('returns false when flow has no network_replay steps', () => {
+        const steps = [
+            { id: 'nav1', type: 'navigate', params: { url: 'https://example.com' } },
+            { id: 'var1', type: 'set_var', params: { name: 'x', value: 'y' } },
+        ];
+        const snapshots = makeSnapshotFile([]);
+        expect(isFlowHttpCompatible(steps, snapshots)).toBe(false);
+    });
+    it('returns false when a snapshot is stale (TTL expired)', () => {
+        const snapshots = makeSnapshotFile(['replay1']);
+        snapshots.snapshots['replay1'].capturedAt = Date.now() - 120_000;
+        snapshots.snapshots['replay1'].ttl = 60_000;
+        const steps = [
+            {
+                id: 'replay1', type: 'network_replay',
+                params: { requestId: '{{vars.reqId}}', auth: 'browser_context', out: 'data', response: { as: 'json' } },
+            },
+        ];
+        expect(isFlowHttpCompatible(steps, snapshots)).toBe(false);
+    });
+    it('allows sleep, set_var, and network_extract in HTTP mode', () => {
+        const steps = [
+            {
+                id: 'replay1', type: 'network_replay',
+                params: { requestId: '{{vars.reqId}}', auth: 'browser_context', out: 'data', response: { as: 'json' } },
+            },
+            { id: 'sleep1', type: 'sleep', params: { durationMs: 100 } },
+            { id: 'var1', type: 'set_var', params: { name: 'x', value: 'y' } },
+            {
+                id: 'extract1', type: 'network_extract',
+                params: { fromVar: 'data', as: 'json', path: 'results', out: 'items' },
+            },
+        ];
+        const snapshots = makeSnapshotFile(['replay1']);
+        expect(isFlowHttpCompatible(steps, snapshots)).toBe(true);
+    });
+});
+// ---------------------------------------------------------------------------
+// replayFromSnapshot
+// ---------------------------------------------------------------------------
+describe('replayFromSnapshot', () => {
+    const originalFetch = globalThis.fetch;
+    afterEach(() => {
+        globalThis.fetch = originalFetch;
+    });
+    it('makes a GET request from snapshot data', async () => {
+        const mockResponse = {
+            status: 200,
+            text: async () => '{"results":[]}',
+            headers: new Headers({ 'content-type': 'application/json' }),
+        };
+        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+        const snapshot = {
+            stepId: 'test',
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'GET',
+                url: 'https://api.example.com/items',
+                headers: { accept: 'application/json' },
+                body: null,
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: 'application/json',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: [],
+        };
+        const result = await replayFromSnapshot(snapshot, {}, {});
+        expect(globalThis.fetch).toHaveBeenCalledWith('https://api.example.com/items', expect.objectContaining({ method: 'GET' }));
+        expect(result.status).toBe(200);
+        expect(result.body).toBe('{"results":[]}');
+    });
+    it('makes a POST request with body', async () => {
+        const mockResponse = {
+            status: 200,
+            text: async () => '{"ok":true}',
+            headers: new Headers({ 'content-type': 'application/json' }),
+        };
+        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+        const snapshot = {
+            stepId: 'test',
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'POST',
+                url: 'https://api.example.com/search',
+                headers: { 'content-type': 'application/json' },
+                body: '{"query":"test"}',
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: 'application/json',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: [],
+        };
+        await replayFromSnapshot(snapshot, {}, {});
+        expect(globalThis.fetch).toHaveBeenCalledWith('https://api.example.com/search', expect.objectContaining({
+            method: 'POST',
+            body: '{"query":"test"}',
+        }));
+    });
+    it('applies overrides from inputs before request', async () => {
+        const mockResponse = {
+            status: 200,
+            text: async () => '{"data":[]}',
+            headers: new Headers({ 'content-type': 'application/json' }),
+        };
+        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+        const snapshot = {
+            stepId: 'test',
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'POST',
+                url: 'https://api.example.com/search',
+                headers: { 'content-type': 'application/json' },
+                body: '{"batch":"W24"}',
+            },
+            overrides: {
+                bodyReplace: [{ find: 'W24', replace: '{{inputs.batch}}' }],
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: 'application/json',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: [],
+        };
+        await replayFromSnapshot(snapshot, { batch: 'S25' }, {});
+        expect(globalThis.fetch).toHaveBeenCalledWith('https://api.example.com/search', expect.objectContaining({
+            body: '{"batch":"S25"}',
+        }));
+    });
+    it('does not send body for GET requests', async () => {
+        const mockResponse = {
+            status: 200,
+            text: async () => '{}',
+            headers: new Headers({}),
+        };
+        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+        const snapshot = {
+            stepId: 'test',
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'GET',
+                url: 'https://api.example.com/items',
+                headers: {},
+                body: 'should-be-ignored',
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: '',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: [],
+        };
+        await replayFromSnapshot(snapshot, {}, {});
+        const fetchCall = globalThis.fetch.mock.calls[0][1];
+        expect(fetchCall.body).toBeUndefined();
+    });
+    it('preserves sensitive headers in the request (needed for auth)', async () => {
+        const mockResponse = {
+            status: 200,
+            text: async () => '{}',
+            headers: new Headers({}),
+        };
+        globalThis.fetch = vi.fn().mockResolvedValue(mockResponse);
+        const snapshot = {
+            stepId: 'test',
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'GET',
+                url: 'https://api.example.com/items',
+                headers: {
+                    accept: 'application/json',
+                    cookie: 'session=abc123',
+                    Authorization: 'Bearer token',
+                },
+                body: null,
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: '',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: ['cookie', 'Authorization'],
+        };
+        await replayFromSnapshot(snapshot, {}, {});
+        const fetchCall = globalThis.fetch.mock.calls[0][1];
+        expect(fetchCall.headers).toHaveProperty('accept', 'application/json');
+        expect(fetchCall.headers).toHaveProperty('cookie', 'session=abc123');
+        expect(fetchCall.headers).toHaveProperty('Authorization', 'Bearer token');
+    });
+    it('throws timeout error when fetch takes too long', async () => {
+        // Mock a fetch that never resolves
+        globalThis.fetch = vi.fn().mockImplementation((_url, options) => new Promise((_resolve, reject) => {
+            options.signal?.addEventListener('abort', () => {
+                const err = new Error('The operation was aborted');
+                err.name = 'AbortError';
+                reject(err);
+            });
+        }));
+        const snapshot = {
+            stepId: 'test',
+            capturedAt: Date.now(),
+            ttl: null,
+            request: {
+                method: 'GET',
+                url: 'https://api.example.com/items',
+                headers: {},
+                body: null,
+            },
+            responseValidation: {
+                expectedStatus: 200,
+                expectedContentType: '',
+                expectedKeys: [],
+            },
+            sensitiveHeaders: [],
+        };
+        await expect(replayFromSnapshot(snapshot, {}, {}, { timeoutMs: 50 })).rejects.toThrow('HTTP replay timed out');
+    });
+});

package/dist/__tests__/requestSnapshot.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=requestSnapshot.test.d.ts.map

package/dist/__tests__/requestSnapshot.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requestSnapshot.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/requestSnapshot.test.ts"],"names":[],"mappings":""}