@agenthippo-ai/agenthippo 0.1.0

package/out/test/permissions.test.js

@@ -0,0 +1,175 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+require("mocha");
+const assert = __importStar(require("assert"));
+const permissions_1 = require("../permissions");
+function createManifest(spec = {}) {
+    return {
+        apiVersion: 'agenthippo.ai/v1',
+        kind: 'Agent',
+        metadata: {
+            name: 'test-agent',
+            version: '1.0.0',
+        },
+        spec: {
+            engine: 'claude',
+            ...spec,
+        },
+    };
+}
+suite('Default Permissions', () => {
+    test('DEFAULT_PERMISSIONS stays full by default', () => {
+        assert.strictEqual(permissions_1.DEFAULT_PERMISSIONS.fileAccess, 'full');
+    });
+    test('getDefaultPermissions returns mapping-config default', () => {
+        const defaults = (0, permissions_1.getDefaultPermissions)();
+        assert.strictEqual(defaults.fileAccess, 'full');
+    });
+    test('getDefaultPermissions returns a new object each time', () => {
+        const a = (0, permissions_1.getDefaultPermissions)();
+        const b = (0, permissions_1.getDefaultPermissions)();
+        assert.notStrictEqual(a, b);
+        assert.deepStrictEqual(a, b);
+    });
+});
+suite('Parse Permissions from Manifest', () => {
+    test('parsePermissions returns defaults for undefined manifest', () => {
+        const perms = (0, permissions_1.parsePermissions)(undefined);
+        assert.strictEqual(perms.fileAccess, 'full');
+    });
+    test('parsePermissions returns defaults for manifest without permissions', () => {
+        const manifest = createManifest({});
+        const perms = (0, permissions_1.parsePermissions)(manifest);
+        assert.strictEqual(perms.fileAccess, 'full');
+    });
+    test('parsePermissions reads fileAccess: read-only', () => {
+        const manifest = createManifest({
+            permissions: { fileAccess: 'read-only' },
+        });
+        const perms = (0, permissions_1.parsePermissions)(manifest);
+        assert.strictEqual(perms.fileAccess, 'read-only');
+    });
+    test('parsePermissions reads fileAccess: workspace-write', () => {
+        const manifest = createManifest({
+            permissions: { fileAccess: 'workspace-write' },
+        });
+        const perms = (0, permissions_1.parsePermissions)(manifest);
+        assert.strictEqual(perms.fileAccess, 'workspace-write');
+    });
+    test('parsePermissions reads fileAccess: full', () => {
+        const manifest = createManifest({
+            permissions: { fileAccess: 'full' },
+        });
+        const perms = (0, permissions_1.parsePermissions)(manifest);
+        assert.strictEqual(perms.fileAccess, 'full');
+    });
+});
+suite('Parse Manifest Permissions', () => {
+    test('parseManifestPermissions reads spec.permissions.fileAccess', () => {
+        const manifest = createManifest({
+            permissions: { fileAccess: 'read-only' },
+        });
+        const perms = (0, permissions_1.parseManifestPermissions)(manifest);
+        assert.strictEqual(perms.fileAccess, 'read-only');
+    });
+    test('parseManifestPermissions returns defaults for empty manifest', () => {
+        const manifest = createManifest({});
+        const perms = (0, permissions_1.parseManifestPermissions)(manifest);
+        assert.strictEqual(perms.fileAccess, 'full');
+    });
+});
+suite('Permission Enforcement', () => {
+    test('user fileAccess takes precedence over manifest fileAccess', () => {
+        assert.strictEqual((0, permissions_1.enforcePermissions)({ fileAccess: 'read-only' }, { fileAccess: 'full' }).fileAccess, 'full');
+        assert.strictEqual((0, permissions_1.enforcePermissions)({ fileAccess: 'full' }, { fileAccess: 'read-only' }).fileAccess, 'read-only');
+        assert.strictEqual((0, permissions_1.enforcePermissions)({ fileAccess: 'workspace-write' }, { fileAccess: 'workspace-write' }).fileAccess, 'workspace-write');
+    });
+});
+suite('Claude Permission Mapping', () => {
+    const workspaceFolders = ['/workspace/root', '/workspace/other'];
+    test('fileAccess: read-only maps to plan mode with workspace dirs', () => {
+        const opts = (0, permissions_1.toClaudeOptions)({ fileAccess: 'read-only' }, workspaceFolders);
+        assert.strictEqual(opts.permissionMode, 'plan');
+        assert.strictEqual(opts.allowDangerouslySkipPermissions, false);
+        assert.deepStrictEqual(opts.additionalDirectories, workspaceFolders);
+    });
+    test('fileAccess: workspace-write maps to acceptEdits with workspace dirs', () => {
+        const opts = (0, permissions_1.toClaudeOptions)({ fileAccess: 'workspace-write' }, workspaceFolders);
+        assert.strictEqual(opts.permissionMode, 'acceptEdits');
+        assert.strictEqual(opts.allowDangerouslySkipPermissions, false);
+        assert.deepStrictEqual(opts.additionalDirectories, workspaceFolders);
+    });
+    test('fileAccess: full maps to bypassPermissions with unrestricted dirs', () => {
+        const opts = (0, permissions_1.toClaudeOptions)({ fileAccess: 'full' }, workspaceFolders);
+        assert.strictEqual(opts.permissionMode, 'bypassPermissions');
+        assert.strictEqual(opts.allowDangerouslySkipPermissions, true);
+        assert.strictEqual(opts.additionalDirectories, undefined);
+    });
+});
+suite('Codex Permission Mapping', () => {
+    const workspaceFolders = ['/workspace/root', '/workspace/other'];
+    test('approvalPolicy is always never for non-interactive V1', () => {
+        const opts = (0, permissions_1.toCodexOptions)({ fileAccess: 'workspace-write' }, workspaceFolders);
+        assert.strictEqual(opts.approvalPolicy, 'never');
+    });
+    test('fileAccess: read-only maps to sandboxMode: read-only', () => {
+        const opts = (0, permissions_1.toCodexOptions)({ fileAccess: 'read-only' }, workspaceFolders);
+        assert.strictEqual(opts.sandboxMode, 'read-only');
+    });
+    test('fileAccess: workspace-write maps to sandboxMode: workspace-write', () => {
+        const opts = (0, permissions_1.toCodexOptions)({ fileAccess: 'workspace-write' }, workspaceFolders);
+        assert.strictEqual(opts.sandboxMode, 'workspace-write');
+    });
+    test('fileAccess: full maps to sandboxMode: danger-full-access', () => {
+        const opts = (0, permissions_1.toCodexOptions)({ fileAccess: 'full' }, workspaceFolders);
+        assert.strictEqual(opts.sandboxMode, 'danger-full-access');
+    });
+    test('additionalDirectories always includes workspace folders', () => {
+        const opts = (0, permissions_1.toCodexOptions)({ fileAccess: 'full' }, workspaceFolders);
+        assert.deepStrictEqual(opts.additionalDirectories, workspaceFolders);
+    });
+});
+suite('Permissions Config Loader', () => {
+    test('config cache can be reset', () => {
+        // Sanity check: function exists and doesn't throw
+        (0, permissions_1._resetMappingConfigCache)();
+        const defaults = (0, permissions_1.getDefaultPermissions)();
+        assert.ok(defaults.fileAccess);
+    });
+});

package/out/test/persistent-engine-worker.test.js

@@ -0,0 +1,220 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const persistentEngineWorker_js_1 = require("../engines/persistentEngineWorker.js");
+/**
+ * A fake runner that speaks the worker NDJSON protocol, driven by FAKE_MODE on the spawn env:
+ *  - normal       : ready; per run → text(message) then result(nativeSessionId="sess-<id>")
+ *  - fail         : ready; per run → error event + failed control message
+ *  - ignore-abort : ready; per run → one text event, then never settles (ignores abort)
+ *  - hang-start   : never emits ready (simulates a wedged engine import)
+ * On startup it appends its pid to SPAWN_COUNT_FILE when set, so tests can count (re)spawns.
+ */
+const FAKE_RUNNER = `
+const { createInterface } = require('node:readline');
+const fs = require('node:fs');
+const mode = process.env.FAKE_MODE || 'normal';
+const spawnFile = process.env.SPAWN_COUNT_FILE;
+if (spawnFile) { try { fs.appendFileSync(spawnFile, process.pid + '\\n'); } catch {} }
+function emit(o) { process.stdout.write(JSON.stringify(o) + '\\n'); }
+if (mode !== 'hang-start') { emit({ type: 'ready' }); }
+const rl = createInterface({ input: process.stdin });
+rl.on('line', (line) => {
+	let req; try { req = JSON.parse(line); } catch { return; }
+	if (req.type === 'run') {
+		const id = req.id;
+		if (mode === 'fail') {
+			emit({ id, event: { type: 'error', message: 'boom' } });
+			emit({ type: 'failed', id, message: 'boom' });
+		} else if (mode === 'ignore-abort') {
+			emit({ id, event: { type: 'text', delta: 'partial' } });
+		} else {
+			emit({ id, event: { type: 'text', delta: (req.env && req.env.AGENTHIPPO_MESSAGE) || 'hi' } });
+			emit({ type: 'result', id, nativeSessionId: 'sess-' + id });
+		}
+	} else if (req.type === 'shutdown') {
+		rl.close();
+	}
+});
+rl.on('close', () => process.exit(0));
+if (mode === 'hang-start') { setInterval(() => {}, 1000); }
+`;
+function deferred() {
+    let resolve;
+    const promise = new Promise((r) => { resolve = r; });
+    return { promise, resolve };
+}
+function makeEmitter() {
+    const texts = [];
+    const errors = [];
+    let textGate;
+    const emitter = {
+        async thinking() { },
+        async text(delta) { texts.push(delta); if (textGate) {
+            await textGate.promise;
+        } },
+        async toolStart() { },
+        async toolEnd() { },
+        async progress() { },
+        async question() { return { selected: [], freeText: null, declined: true }; },
+        async error(message) { errors.push(message); },
+        async done() { },
+    };
+    return { emitter, texts, errors, setTextGate: (g) => { textGate = g; } };
+}
+const noopLogger = { debug: () => { }, info: () => { }, warn: () => { }, error: () => { } };
+async function waitFor(cond, timeoutMs = 4000) {
+    const start = Date.now();
+    while (!cond()) {
+        if (Date.now() - start > timeoutMs) {
+            throw new Error('waitFor timed out');
+        }
+        await new Promise((r) => setTimeout(r, 10));
+    }
+}
+suite('Persistent engine worker pool', () => {
+    let tmpDir;
+    let runnerPath;
+    let pool;
+    let keySeq = 0;
+    setup(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'persistent-worker-'));
+        runnerPath = path.join(tmpDir, 'fake-runner.cjs');
+        fs.writeFileSync(runnerPath, FAKE_RUNNER, 'utf8');
+        pool = new persistentEngineWorker_js_1.PersistentEngineWorkerPool();
+    });
+    teardown(() => {
+        pool.disposeAll();
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function opts(mode, extra = {}) {
+        return {
+            cacheKey: `key-${++keySeq}`,
+            runnerPath,
+            nodeBin: process.execPath,
+            cwd: tmpDir,
+            spawnEnv: { PATH: process.env.PATH ?? '', FAKE_MODE: mode },
+            logger: noopLogger,
+            label: `test.${mode}`,
+            ...extra,
+        };
+    }
+    test('runs a turn on a warm worker and streams text + result', async () => {
+        const o = opts('normal');
+        const { emitter, texts } = makeEmitter();
+        const result = await pool.run(o, { AGENTHIPPO_MESSAGE: 'hello' }, emitter);
+        assert.deepStrictEqual(texts, ['hello']);
+        assert.strictEqual(result.nativeSessionId, 'sess-1');
+        assert.strictEqual(pool._workerCountForTest(), 1);
+    });
+    test('reuses the same worker across turns (single spawn)', async () => {
+        const spawnFile = path.join(tmpDir, 'spawns.txt');
+        const o = opts('normal', { spawnEnv: { PATH: process.env.PATH ?? '', FAKE_MODE: 'normal', SPAWN_COUNT_FILE: spawnFile } });
+        await pool.run(o, {}, makeEmitter().emitter);
+        await pool.run(o, {}, makeEmitter().emitter);
+        await pool.run(o, {}, makeEmitter().emitter);
+        const spawns = fs.readFileSync(spawnFile, 'utf8').trim().split('\n').filter(Boolean);
+        assert.strictEqual(spawns.length, 1, 'engine should spawn exactly once for repeated turns');
+    });
+    test('a failed turn rejects, retires the worker, and the next turn spawns fresh', async () => {
+        const spawnFile = path.join(tmpDir, 'spawns.txt');
+        const o = opts('fail', { spawnEnv: { PATH: process.env.PATH ?? '', FAKE_MODE: 'fail', SPAWN_COUNT_FILE: spawnFile } });
+        const first = makeEmitter();
+        await assert.rejects(pool.run(o, {}, first.emitter), /boom/);
+        assert.deepStrictEqual(first.errors, ['boom'], 'error event should reach the emitter before reject');
+        // Retired worker must not be reused — the next turn gets a brand new child.
+        await assert.rejects(pool.run(o, {}, makeEmitter().emitter), /boom/);
+        await waitFor(() => fs.existsSync(spawnFile) && fs.readFileSync(spawnFile, 'utf8').trim().split('\n').filter(Boolean).length >= 2);
+        const spawns = fs.readFileSync(spawnFile, 'utf8').trim().split('\n').filter(Boolean);
+        assert.strictEqual(spawns.length, 2, 'failed worker should be replaced by a fresh spawn');
+    });
+    test('startup watchdog rejects when the engine never signals ready', async () => {
+        const o = opts('hang-start', { startupTimeoutMs: 250 });
+        const start = Date.now();
+        await assert.rejects(pool.run(o, {}, makeEmitter().emitter), /did not become ready/);
+        assert.ok(Date.now() - start < 3000, 'should reject promptly via the watchdog, not hang');
+        assert.strictEqual(pool._workerCountForTest(), 0, 'dead worker should be dropped from the pool');
+    });
+    test('abort settles the turn even when the engine ignores its AbortSignal', async () => {
+        const o = opts('ignore-abort', { abortSettleTimeoutMs: 250 });
+        const { emitter } = makeEmitter();
+        const controller = new AbortController();
+        const runPromise = pool.run(o, {}, emitter, controller.signal);
+        // Let the run get going (the worker emits one text event), then abort.
+        await new Promise((r) => setTimeout(r, 200));
+        controller.abort();
+        await assert.rejects(runPromise, /aborted/);
+    });
+    test('per-run line chains: a stalled emitter on one turn does not block another', async () => {
+        const o = opts('normal');
+        const a = makeEmitter();
+        const b = makeEmitter();
+        const gate = deferred();
+        a.setTextGate(gate); // turn A's emitter.text will block until we release the gate
+        const runA = pool.run(o, { AGENTHIPPO_MESSAGE: 'A' }, a.emitter);
+        // Wait until A's text is being delivered (emitter.text entered and now blocked on the gate).
+        await waitFor(() => a.texts.length === 1);
+        const runB = pool.run(o, { AGENTHIPPO_MESSAGE: 'B' }, b.emitter);
+        // B must stream through while A is still blocked — proving chains are per-run, not global.
+        await waitFor(() => b.texts.length === 1);
+        assert.deepStrictEqual(b.texts, ['B']);
+        gate.resolve();
+        const [resA, resB] = await Promise.all([runA, runB]);
+        assert.deepStrictEqual(a.texts, ['A']);
+        assert.ok(resA.nativeSessionId && resB.nativeSessionId);
+    });
+    test('onMaintenance reaps idle workers', async () => {
+        const o = opts('normal', { idleTtlMs: 0 });
+        await pool.run(o, {}, makeEmitter().emitter);
+        assert.strictEqual(pool._workerCountForTest(), 1);
+        await new Promise((r) => setTimeout(r, 5)); // let lastUsedAt fall past the (0ms) TTL
+        pool.onMaintenance();
+        assert.strictEqual(pool._workerCountForTest(), 0);
+    });
+    test('disposeAll tears down all workers', async () => {
+        await pool.run(opts('normal'), {}, makeEmitter().emitter);
+        await pool.run(opts('normal'), {}, makeEmitter().emitter);
+        assert.strictEqual(pool._workerCountForTest(), 2);
+        pool.disposeAll();
+        assert.strictEqual(pool._workerCountForTest(), 0);
+    });
+});

package/out/test/refreshPolicy.test.js

@@ -0,0 +1,60 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = __importStar(require("assert"));
+const viewsConfigMerge_1 = require("../analytics/dashboard/viewsConfigMerge");
+suite('shouldRunScriptsOnNavigation', () => {
+    test('fleet widget script infers always refresh', () => {
+        const fleetView = { scripts: [viewsConfigMerge_1.FLEET_WIDGET_SCRIPT] };
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)(fleetView, []), true);
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)(fleetView, ['chart']), true);
+    });
+    test('refreshOnNavigate always runs scripts even without fleet widget', () => {
+        const liveView = { scripts: [], refreshOnNavigate: 'always' };
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)(liveView, []), true);
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)(liveView, ['chart']), true);
+    });
+    test('when-empty with chart artifacts skips scripts', () => {
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)({ scripts: [] }, ['chart']), false);
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)({ scripts: [], refreshOnNavigate: 'when-empty' }, ['report', 'chart']), false);
+    });
+    test('when-empty without charts runs scripts', () => {
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)({ scripts: [] }, []), true);
+        assert.strictEqual((0, viewsConfigMerge_1.shouldRunScriptsOnNavigation)({ scripts: [] }, ['report', 'export']), true);
+    });
+});