@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/test/pack-trust-root.test.js

@@ -1,202 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  The trust root — where the fleet learns which code it is allowed to run.
- *
- *  Every one of these pins a property that was absent: the JWKS URL was built from whatever
- *  AGENTHIPPO_LEASE_URL pointed at, fetched with a bare `fetch()`, with no scheme requirement, no
- *  pinning, and nothing signing the document. Whoever could answer that URL chose the trust root.
- *--------------------------------------------------------------------------------------------*/
-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 warrant_1 = require("../authority/warrant");
-const signature_1 = require("../pack/signature");
-const key = (0, warrant_1.generateWarrantKeypair)('k1');
-const other = (0, warrant_1.generateWarrantKeypair)('k2');
-const okResponse = (body) => ({
-    ok: true,
-    status: 200,
-    json: async () => body,
-});
-const fetchReturning = (body) => (async () => okResponse(body));
-suite('trust root — scheme', () => {
-    test('an http JWKS origin is refused: the keyring that decides what runs must not be rewritable in flight', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'http://plane.example/.well-known/jwks.json' },
-            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
-        });
-        assert.strictEqual(root.status, 'unavailable');
-        assert.match(root.reason ?? '', /must be https/);
-        assert.deepStrictEqual(root.keys, {});
-    });
-    test('https is accepted with no warning', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://plane.example/.well-known/jwks.json' },
-            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
-        });
-        assert.strictEqual(root.status, 'configured');
-        assert.deepStrictEqual(Object.keys(root.keys), ['k1']);
-    });
-    test('the local-dev escape hatch works and is LOUD', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: {
-                [signature_1.PACK_JWKS_URL_ENV]: 'http://localhost:9000/.well-known/jwks.json',
-                [signature_1.ALLOW_INSECURE_TRUST_ROOT_ENV]: '1',
-            },
-            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
-        });
-        assert.strictEqual(root.status, 'configured');
-        assert.ok(root.warnings.some((w) => /INSECURE/.test(w)), 'the opt-out must announce itself');
-    });
-    test('assertSecureTrustUrl rejects a malformed URL rather than assuming a scheme', () => {
-        const r = (0, signature_1.assertSecureTrustUrl)('not a url', 'the trust root', {});
-        assert.strictEqual(r.ok, false);
-    });
-});
-suite('trust root — independence from the lease origin', () => {
-    test('a dedicated JWKS URL takes precedence over anything derived from the lease', async () => {
-        let asked = '';
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://trust.example/jwks.json' },
-            leaseUrl: 'https://attacker.example/lease',
-            fetchImpl: (async (u) => { asked = u; return okResponse({ pemsByKid: { k1: key.publicKeyPem } }); }),
-        });
-        assert.strictEqual(asked, 'https://trust.example/jwks.json');
-        assert.strictEqual(root.status, 'configured');
-    });
-    test('deriving from the lease origin still works but says it is weaker', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: {},
-            leaseUrl: 'https://plane.example/lease',
-            fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem } }),
-        });
-        assert.strictEqual(root.status, 'configured');
-        assert.strictEqual(root.derivedFromLease, true);
-        assert.ok(root.warnings.some((w) => /derived from AGENTHIPPO_LEASE_URL/.test(w)));
-    });
-    test('the derived URL asks for the pack-signing purpose, so a plane that splits keys by purpose still answers it', async () => {
-        let asked = '';
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: {},
-            leaseUrl: 'https://plane.example/lease',
-            fetchImpl: (async (u) => { asked = u; return okResponse({ pemsByKid: { k1: key.publicKeyPem } }); }),
-        });
-        // Without the query string a plane that now serves one purpose per document can hand back
-        // a set with no pack-signing key in it — an empty trust root, which with signing fail-closed
-        // means every instance refuses to boot at once.
-        assert.strictEqual(asked, 'https://plane.example/.well-known/jwks.json?purpose=pack-signing');
-        assert.strictEqual(root.status, 'configured');
-    });
-    test('nothing configured is UNCONFIGURED, not an error — an unmanaged deployment has no plane', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({ env: {} });
-        assert.strictEqual(root.status, 'unconfigured');
-        assert.deepStrictEqual(root.keys, {});
-    });
-});
-suite('trust root — thumbprint pinning', () => {
-    test('a key that matches no pin is REFUSED, by either thumbprint form', async () => {
-        const tp = (0, signature_1.publicKeyThumbprints)(key.publicKeyPem);
-        for (const pin of [tp.jwk, tp.spki, `sha256:${tp.spki.toUpperCase()}`]) {
-            const root = await (0, signature_1.loadPackTrustRoot)({
-                env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j', [signature_1.PACK_JWKS_PINS_ENV]: pin },
-                fetchImpl: fetchReturning({ pemsByKid: { k1: key.publicKeyPem, k2: other.publicKeyPem } }),
-            });
-            assert.strictEqual(root.status, 'configured', `pin form ${pin} should match`);
-            assert.deepStrictEqual(Object.keys(root.keys), ['k1'], 'the unpinned key must be dropped');
-            assert.ok(root.warnings.some((w) => /k2 does not match any pin/.test(w)));
-        }
-    });
-    test('a swapped trust root that matches NO pin is unavailable, not silently empty', async () => {
-        const tp = (0, signature_1.publicKeyThumbprints)(key.publicKeyPem);
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j', [signature_1.PACK_JWKS_PINS_ENV]: tp.spki },
-            fetchImpl: fetchReturning({ pemsByKid: { k2: other.publicKeyPem } }),
-        });
-        assert.strictEqual(root.status, 'unavailable');
-        assert.match(root.reason ?? '', /pin check/);
-    });
-    test('parseJwksPins tolerates whitespace, prefixes and blanks', () => {
-        assert.deepStrictEqual((0, signature_1.parseJwksPins)(' sha256:AB , ,cd '), ['ab', 'cd']);
-        assert.deepStrictEqual((0, signature_1.parseJwksPins)(undefined), []);
-    });
-});
-suite('trust root — A4: unavailable is not the same as unconfigured', () => {
-    test('a non-200 JWKS is an ERROR, not an empty keyring', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
-            fetchImpl: (async () => ({ ok: false, status: 503 })),
-        });
-        assert.strictEqual(root.status, 'unavailable');
-        assert.match(root.reason ?? '', /HTTP 503/);
-    });
-    test('a transport failure is an ERROR', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
-            fetchImpl: (async () => { throw new Error('ECONNREFUSED'); }),
-        });
-        assert.strictEqual(root.status, 'unavailable');
-        assert.match(root.reason ?? '', /ECONNREFUSED/);
-    });
-    test('a garbled inline keyring is an ERROR — a typo must not read as "unmanaged"', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({ env: { AGENTHIPPO_PACK_SIGNING_KEYS: '{not json' } });
-        assert.strictEqual(root.status, 'unavailable');
-        assert.match(root.reason ?? '', /not valid JSON/);
-    });
-    test('a JWKS with no usable ES256 keys is an ERROR', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
-            fetchImpl: fetchReturning({ keys: [{ kty: 'RSA', kid: 'r1', n: 'x', e: 'AQAB' }] }),
-        });
-        assert.strictEqual(root.status, 'unavailable');
-    });
-});
-suite('trust root — document shapes', () => {
-    test('a standard JWKS (what authority/warrant.ts publishes) is accepted', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { [signature_1.PACK_JWKS_URL_ENV]: 'https://t.example/j' },
-            fetchImpl: fetchReturning((0, warrant_1.jwks)([key])),
-        });
-        assert.strictEqual(root.status, 'configured');
-        assert.deepStrictEqual(Object.keys(root.keys), ['k1']);
-    });
-    test('inline keys need no network at all (air-gapped)', async () => {
-        const root = await (0, signature_1.loadPackTrustRoot)({
-            env: { AGENTHIPPO_PACK_SIGNING_KEYS: JSON.stringify({ k1: key.publicKeyPem }) },
-            fetchImpl: (async () => { throw new Error('must not be called'); }),
-        });
-        assert.strictEqual(root.status, 'configured');
-    });
-});

package/out/test/pathSafety.test.js

@@ -1,63 +0,0 @@
-"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 path = __importStar(require("path"));
-const pathSafety_1 = require("../utils/pathSafety");
-suite('pathSafety', () => {
-    const root = path.resolve('/tmp/agentide-analytics');
-    test('isPathUnderRoot allows paths under root', () => {
-        assert.strictEqual((0, pathSafety_1.isPathUnderRoot)(root, path.join(root, 'views', 'cost-ops', 'view.yaml')), true);
-        assert.strictEqual((0, pathSafety_1.isPathUnderRoot)(root, root), true);
-    });
-    test('isPathUnderRoot rejects parent escape via ..', () => {
-        assert.strictEqual((0, pathSafety_1.isPathUnderRoot)(root, path.join(root, '..', 'secret.txt')), false);
-        assert.strictEqual((0, pathSafety_1.isPathUnderRoot)(root, '/tmp/secret.txt'), false);
-    });
-    test('isPathUnderRoot rejects prefix-only matches', () => {
-        const sibling = `${root}-other`;
-        assert.strictEqual((0, pathSafety_1.isPathUnderRoot)(root, path.join(sibling, 'views', 'x.yaml')), false);
-    });
-    test('isPathUnderAnyRoot checks multiple roots', () => {
-        const other = path.resolve('/tmp/other-analytics');
-        const candidate = path.join(other, 'panel', 'views.yaml');
-        assert.strictEqual((0, pathSafety_1.isPathUnderAnyRoot)([root, other], candidate), true);
-        assert.strictEqual((0, pathSafety_1.isPathUnderAnyRoot)([root], candidate), false);
-    });
-});

package/out/test/permissions.test.js

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

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