@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/engines/install.js

@@ -1,372 +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 });
-exports.getDefaultCustomEnginesInstallRoot = getDefaultCustomEnginesInstallRoot;
-exports.installCustomEngineFromFiles = installCustomEngineFromFiles;
-exports.listInstalledCustomEngines = listInstalledCustomEngines;
-exports.uninstallCustomEngine = uninstallCustomEngine;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const util_1 = require("util");
-const branding_1 = require("../branding");
-const utils_1 = require("../utils");
-const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
-const ENGINE_MANIFEST_NAME = 'engine.manifest.json';
-function getDefaultCustomEnginesInstallRoot() {
-    return path.join(process.env.AGENT_HOME_DIR || process.env.AGENTHIPPO_HOME || path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME), 'engines');
-}
-function normalizeArchivePath(rawPath) {
-    const normalized = rawPath.replace(/\\/g, '/').trim().replace(/^\.\//, '');
-    if (!normalized || normalized.includes('\0')) {
-        throw new Error(`Invalid engine package path: ${rawPath}`);
-    }
-    if (normalized.startsWith('/') || /^[A-Za-z]:/.test(normalized)) {
-        throw new Error(`Engine package path must be relative: ${rawPath}`);
-    }
-    const parts = normalized.split('/').filter(Boolean);
-    if (parts.length === 0 || parts.some(part => part === '.' || part === '..')) {
-        throw new Error(`Engine package path must not contain "." or "..": ${rawPath}`);
-    }
-    return parts.join('/');
-}
-function normalizeSafeRelativePath(rawPath, label) {
-    try {
-        return normalizeArchivePath(rawPath).replace(/\//g, path.sep);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`${label}: ${message}`);
-    }
-}
-function assertPathInside(parentDir, candidatePath, label) {
-    const parent = path.resolve(parentDir);
-    const candidate = path.resolve(candidatePath);
-    const rel = path.relative(parent, candidate);
-    if (rel && (rel.startsWith('..') || path.isAbsolute(rel))) {
-        throw new Error(`${label} must stay inside ${parentDir}: ${candidatePath}`);
-    }
-}
-async function pathExists(targetPath) {
-    try {
-        await fs_1.promises.access(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function readJsonObject(content, label) {
-    const parsed = JSON.parse(content);
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        throw new Error(`${label} must be a JSON object`);
-    }
-    return parsed;
-}
-function getStringField(obj, key, label) {
-    const value = obj[key];
-    if (typeof value !== 'string' || value.trim().length === 0) {
-        throw new Error(`${label} missing required string field "${key}"`);
-    }
-    return value.trim();
-}
-function normalizeEngineId(rawId) {
-    const id = rawId.trim().toLowerCase();
-    if (!/^[a-z0-9][a-z0-9._-]*$/.test(id)) {
-        throw new Error(`Custom engine id must contain only lowercase letters, numbers, ".", "_", or "-": ${rawId}`);
-    }
-    return id;
-}
-function validateWorkspaceSyncConfig(raw, label) {
-    if (!raw) {
-        return;
-    }
-    if (typeof raw !== 'object' || Array.isArray(raw)) {
-        throw new Error(`${label} workspaceSync must be an object`);
-    }
-    const config = raw;
-    if (config.enabled !== true) {
-        return;
-    }
-    const dir = getStringField(config, 'dir', `${label} workspaceSync`);
-    const rulesFile = getStringField(config, 'rulesFile', `${label} workspaceSync`);
-    normalizeSafeRelativePath(dir, 'workspaceSync.dir');
-    normalizeSafeRelativePath(rulesFile, 'workspaceSync.rulesFile');
-}
-async function readAndValidateManifest(stageDir) {
-    const manifestPath = path.join(stageDir, ENGINE_MANIFEST_NAME);
-    let raw;
-    try {
-        raw = await fs_1.promises.readFile(manifestPath, 'utf8');
-    }
-    catch {
-        throw new Error(`Custom engine package is missing ${ENGINE_MANIFEST_NAME}`);
-    }
-    const parsed = readJsonObject(raw, ENGINE_MANIFEST_NAME);
-    const id = getStringField(parsed, 'id', ENGINE_MANIFEST_NAME);
-    const manifest = {
-        version: parsed.version,
-        id,
-        displayName: typeof parsed.displayName === 'string' && parsed.displayName.trim()
-            ? parsed.displayName.trim()
-            : undefined,
-        description: typeof parsed.description === 'string' && parsed.description.trim()
-            ? parsed.description.trim()
-            : undefined,
-        entry: getStringField(parsed, 'entry', ENGINE_MANIFEST_NAME),
-        workspaceSync: parsed.workspaceSync,
-    };
-    if (manifest.version !== 2) {
-        throw new Error(`${ENGINE_MANIFEST_NAME} must declare version 2`);
-    }
-    if (manifest.id !== manifest.id.toLowerCase() || !/^[a-z0-9][a-z0-9._-]*$/.test(manifest.id)) {
-        throw new Error(`${ENGINE_MANIFEST_NAME} id must contain only lowercase letters, numbers, ".", "_", or "-"`);
-    }
-    validateWorkspaceSyncConfig(manifest.workspaceSync, ENGINE_MANIFEST_NAME);
-    const entryRel = normalizeSafeRelativePath(manifest.entry, 'entry');
-    const entryPath = path.join(stageDir, entryRel);
-    assertPathInside(stageDir, entryPath, 'Engine entry');
-    if (!await pathExists(entryPath)) {
-        throw new Error(`${ENGINE_MANIFEST_NAME} entry not found: ${manifest.entry}`);
-    }
-    return manifest;
-}
-async function writePackageFiles(stageDir, files) {
-    const seen = new Set();
-    for (const file of files) {
-        const rel = normalizeArchivePath(file.path);
-        if (seen.has(rel)) {
-            throw new Error(`Duplicate engine package path: ${file.path}`);
-        }
-        seen.add(rel);
-        const filePath = path.join(stageDir, ...rel.split('/'));
-        assertPathInside(stageDir, filePath, 'Engine package file');
-        await fs_1.promises.mkdir(path.dirname(filePath), { recursive: true });
-        await fs_1.promises.writeFile(filePath, file.content);
-    }
-}
-async function runCommand(command, args, cwd) {
-    try {
-        await execFileAsync(command, args, {
-            cwd,
-            maxBuffer: 10 * 1024 * 1024,
-            windowsHide: true,
-            shell: process.platform === 'win32' && /\.(?:cmd|bat)$/i.test(command),
-        });
-    }
-    catch (error) {
-        const stderr = typeof error.stderr === 'string'
-            ? error.stderr.trim()
-            : '';
-        const stdout = typeof error.stdout === 'string'
-            ? error.stdout.trim()
-            : '';
-        const detail = stderr || stdout || (error instanceof Error ? error.message : String(error));
-        throw new Error(`${command} ${args.join(' ')} failed: ${detail}`);
-    }
-}
-async function maybeInstallDependencies(stageDir, runNpmCi, logger) {
-    const packageJsonPath = path.join(stageDir, 'package.json');
-    if (!await pathExists(packageJsonPath)) {
-        return false;
-    }
-    const lockfilePath = path.join(stageDir, 'package-lock.json');
-    if (!await pathExists(lockfilePath)) {
-        throw new Error('Custom engine packages with package.json must include package-lock.json');
-    }
-    if (!runNpmCi) {
-        return false;
-    }
-    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
-    if (logger) {
-        (0, utils_1.logInfo)(logger, `[Store] Running npm ci --omit=dev for custom engine`);
-    }
-    await runCommand(npmCommand, ['ci', '--omit=dev'], stageDir);
-    return true;
-}
-async function validateEntrySyntax(stageDir, manifest, logger) {
-    const entryRel = normalizeSafeRelativePath(manifest.entry, 'entry');
-    const entryPath = path.join(stageDir, entryRel);
-    if (logger) {
-        (0, utils_1.logInfo)(logger, `[Store] Validating custom engine entry: ${manifest.entry}`);
-    }
-    await runCommand('node', ['--check', entryPath], stageDir);
-    return entryPath;
-}
-async function replaceInstalledEngine(stageDir, installRoot, engineId, overwrite) {
-    await fs_1.promises.mkdir(installRoot, { recursive: true });
-    const targetDir = path.join(installRoot, engineId);
-    assertPathInside(installRoot, targetDir, 'Custom engine install target');
-    const targetExists = await pathExists(targetDir);
-    if (targetExists && !overwrite) {
-        throw new Error(`Custom engine "${engineId}" already exists at ${targetDir}`);
-    }
-    if (!targetExists) {
-        await fs_1.promises.rename(stageDir, targetDir);
-        return targetDir;
-    }
-    const backupRoot = path.join(installRoot, '.tmp');
-    await fs_1.promises.mkdir(backupRoot, { recursive: true });
-    const backupDir = path.join(backupRoot, `${engineId}.previous-${Date.now()}`);
-    assertPathInside(installRoot, backupDir, 'Custom engine backup target');
-    await fs_1.promises.rm(backupDir, { recursive: true, force: true });
-    await fs_1.promises.rename(targetDir, backupDir);
-    try {
-        await fs_1.promises.rename(stageDir, targetDir);
-        await fs_1.promises.rm(backupDir, { recursive: true, force: true });
-        return targetDir;
-    }
-    catch (error) {
-        await fs_1.promises.rm(targetDir, { recursive: true, force: true }).catch(() => undefined);
-        await fs_1.promises.rename(backupDir, targetDir).catch(() => undefined);
-        throw error;
-    }
-}
-async function installCustomEngineFromFiles(files, options = {}) {
-    if (files.length === 0) {
-        throw new Error('Custom engine package is empty');
-    }
-    const installRoot = path.resolve(options.installRoot ?? getDefaultCustomEnginesInstallRoot());
-    const runNpmCi = options.runNpmCi !== false;
-    const overwrite = options.overwrite !== false;
-    const tempRoot = path.join(installRoot, '.tmp');
-    await fs_1.promises.mkdir(tempRoot, { recursive: true });
-    const stageDir = await fs_1.promises.mkdtemp(path.join(tempRoot, `${options.slug || 'engine'}-`));
-    assertPathInside(tempRoot, stageDir, 'Custom engine staging directory');
-    let stageOwned = true;
-    try {
-        await writePackageFiles(stageDir, files);
-        const manifest = await readAndValidateManifest(stageDir);
-        const npmInstalled = await maybeInstallDependencies(stageDir, runNpmCi, options.logger);
-        const stagedEntryPath = await validateEntrySyntax(stageDir, manifest, options.logger);
-        const installDir = await replaceInstalledEngine(stageDir, installRoot, manifest.id, overwrite);
-        stageOwned = false;
-        const entryPath = path.join(installDir, path.relative(stageDir, stagedEntryPath));
-        const result = {
-            id: manifest.id,
-            displayName: manifest.displayName || manifest.id,
-            version: manifest.version,
-            manifestPath: path.join(installDir, ENGINE_MANIFEST_NAME),
-            installDir,
-            entryPath,
-            npmInstalled,
-        };
-        if (options.logger) {
-            const source = options.sourceUrl ? ` from ${options.sourceUrl}` : '';
-            (0, utils_1.logInfo)(options.logger, `[Store] Installed custom engine ${result.id}${source} to ${installDir}`);
-        }
-        return result;
-    }
-    finally {
-        if (stageOwned) {
-            await fs_1.promises.rm(stageDir, { recursive: true, force: true }).catch(() => undefined);
-        }
-    }
-}
-async function listInstalledCustomEngines(options = {}) {
-    const installRoot = path.resolve(options.installRoot ?? getDefaultCustomEnginesInstallRoot());
-    let entries;
-    try {
-        entries = await fs_1.promises.readdir(installRoot, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const engines = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith('.')) {
-            continue;
-        }
-        const installDir = path.join(installRoot, entry.name);
-        assertPathInside(installRoot, installDir, 'Custom engine install target');
-        const manifestPath = path.join(installDir, ENGINE_MANIFEST_NAME);
-        let id = entry.name;
-        let displayName = entry.name;
-        try {
-            const manifest = readJsonObject(await fs_1.promises.readFile(manifestPath, 'utf8'), manifestPath);
-            if (typeof manifest.id === 'string' && manifest.id.trim()) {
-                id = normalizeEngineId(manifest.id);
-            }
-            if (typeof manifest.displayName === 'string' && manifest.displayName.trim()) {
-                displayName = manifest.displayName.trim();
-            }
-            else {
-                displayName = id;
-            }
-        }
-        catch {
-            // Keep broken/manual installs visible by directory name so they can be removed.
-        }
-        engines.push({ id, displayName, manifestPath, installDir });
-    }
-    return engines.sort((a, b) => a.id.localeCompare(b.id));
-}
-async function uninstallCustomEngine(id, options = {}) {
-    const engineId = normalizeEngineId(id);
-    const installRoot = path.resolve(options.installRoot ?? getDefaultCustomEnginesInstallRoot());
-    const installDir = path.join(installRoot, engineId);
-    assertPathInside(installRoot, installDir, 'Custom engine uninstall target');
-    let displayName;
-    try {
-        const stat = await fs_1.promises.lstat(installDir);
-        if (!stat.isDirectory() || stat.isSymbolicLink()) {
-            throw new Error(`Custom engine install target is not a normal directory: ${installDir}`);
-        }
-        try {
-            const manifest = readJsonObject(await fs_1.promises.readFile(path.join(installDir, ENGINE_MANIFEST_NAME), 'utf8'), ENGINE_MANIFEST_NAME);
-            displayName = typeof manifest.displayName === 'string' && manifest.displayName.trim()
-                ? manifest.displayName.trim()
-                : undefined;
-        }
-        catch {
-            // Missing or invalid manifests should not block removing the install directory.
-        }
-    }
-    catch (error) {
-        if (error?.code === 'ENOENT') {
-            return { id: engineId, installDir, removed: false };
-        }
-        throw error;
-    }
-    await fs_1.promises.rm(installDir, { recursive: true, force: true });
-    if (options.logger) {
-        (0, utils_1.logInfo)(options.logger, `[Store] Uninstalled custom engine ${engineId} from ${installDir}`);
-    }
-    return { id: engineId, displayName, installDir, removed: true };
-}

package/out/engines/persistentEngineWorker.js

@@ -1,320 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistentEngineWorkerPool = void 0;
-const node_child_process_1 = require("node:child_process");
-const node_readline_1 = require("node:readline");
-const customEngineIpc_1 = require("./customEngineIpc");
-/** Idle worker is shut down after this long with no turns (matches custom session TTL). */
-const WORKER_IDLE_TTL_MS = 1000 * 60 * 30;
-/** Safety cap: force-kill a retired worker that never drains its in-flight turns. */
-const RETIRE_DRAIN_TIMEOUT_MS = 1000 * 60;
-/**
- * A worker must emit `ready` (engine module imported) within this long after spawn. A hung import
- * (network I/O at module load, an unresolved top-level await, a wedged native dep) would otherwise
- * leave every turn for that engine awaiting `ensureStarted()` forever, so we time it out, kill the
- * child, and let the next turn spawn fresh.
- */
-const WORKER_STARTUP_TIMEOUT_MS = 1000 * 30;
-/**
- * After a turn is aborted we ask the child to stop and wait for it to settle, but an engine that
- * ignores its AbortSignal would never send `result`/`failed`, leaking the pending run forever. Give
- * the child this long to acknowledge, then settle the host-side promise ourselves.
- */
-const ABORT_SETTLE_TIMEOUT_MS = 1000 * 10;
-/**
- * One long-lived runner child per engine. The SDK stays warm across turns, so there is no
- * per-turn process spawn or session-resume cost. On a turn failure the worker is "retired":
- * no new turns are routed to it and it is killed once its in-flight turns drain, so the next
- * turn gets a fresh child (the targeted equivalent of an extension-host reload).
- */
-class EngineWorker {
-    opts;
-    child;
-    readyPromise;
-    readyResolve;
-    readyReject;
-    pending = new Map();
-    /**
-     * Per-run line chains. Each turn's stdout messages are serialized (so streamed events stay in
-     * order and the terminal result/failed lands after them), but turns are independent — a slow or
-     * stalled emitter on one chat session no longer blocks streaming for every other session sharing
-     * this worker.
-     */
-    lineChains = new Map();
-    seq = 0;
-    stderr = '';
-    retired = false;
-    retireTimer;
-    readyTimer;
-    lastUsedAt = Date.now();
-    constructor(opts) {
-        this.opts = opts;
-    }
-    /** A worker is reusable only while it has a live child and has not been retired. */
-    isUsable() {
-        return !this.retired && this.child !== undefined && this.child.exitCode === null && !this.child.killed;
-    }
-    ensureStarted() {
-        if (this.readyPromise) {
-            return this.readyPromise;
-        }
-        this.readyPromise = new Promise((resolve, reject) => {
-            this.readyResolve = resolve;
-            this.readyReject = reject;
-        });
-        const child = (0, node_child_process_1.spawn)(this.opts.nodeBin, [this.opts.runnerPath], {
-            cwd: this.opts.cwd,
-            env: this.opts.spawnEnv,
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        this.child = child;
-        this.opts.logger.info(`[AgentIDE] Persistent engine worker started (${this.opts.label}, pid=${child.pid})`);
-        const startupTimeoutMs = this.opts.startupTimeoutMs ?? WORKER_STARTUP_TIMEOUT_MS;
-        this.readyTimer = setTimeout(() => {
-            this.opts.logger.warn(`[AgentIDE] Persistent engine worker (${this.opts.label}) did not signal ready within ${startupTimeoutMs}ms; terminating`);
-            this.handleExit(`worker did not become ready within ${startupTimeoutMs}ms`);
-        }, startupTimeoutMs);
-        this.readyTimer.unref?.();
-        const stdoutRl = (0, node_readline_1.createInterface)({ input: child.stdout });
-        stdoutRl.on('line', line => this.routeLine(line));
-        child.stderr?.on('data', chunk => {
-            this.stderr += String(chunk);
-            if (this.stderr.length > 16_384) {
-                this.stderr = this.stderr.slice(-16_384);
-            }
-        });
-        child.on('error', err => this.handleExit(err.message));
-        child.on('close', code => {
-            stdoutRl.close();
-            this.handleExit(this.stderr.trim() || `worker exited with code ${code}`);
-        });
-        return this.readyPromise;
-    }
-    /** Parse a stdout line and dispatch it: `ready` is handled inline; everything else is a
-     * per-run message routed onto that run's own ordering chain. */
-    routeLine(line) {
-        const msg = (0, customEngineIpc_1.parseWorkerOutbound)(line);
-        if (!msg) {
-            return;
-        }
-        if ('type' in msg && msg.type === 'ready') {
-            // Startup signal — the engine module loaded successfully.
-            this.markReady();
-            return;
-        }
-        // Every non-ready message carries an id (control result/failed, or a streamed event).
-        const id = 'id' in msg ? msg.id : undefined;
-        if (id === undefined) {
-            return;
-        }
-        const prev = this.lineChains.get(id) ?? Promise.resolve();
-        const next = prev.then(() => this.handleMessage(msg)).catch(() => undefined);
-        this.lineChains.set(id, next);
-        void next.then(() => {
-            if (this.lineChains.get(id) === next) {
-                this.lineChains.delete(id);
-            }
-        });
-    }
-    async handleMessage(msg) {
-        if ('type' in msg) {
-            if (msg.type === 'ready') {
-                return;
-            }
-            const run = this.pending.get(msg.id);
-            if (!run) {
-                return;
-            }
-            if (msg.type === 'result') {
-                this.finishRun(msg.id, run);
-                run.resolve({ nativeSessionId: msg.nativeSessionId });
-            }
-            else {
-                this.finishRun(msg.id, run);
-                run.reject(new Error(msg.message));
-                // A thrown turn means the warm SDK may be poisoned — retire unless the user aborted.
-                if (!run.aborted) {
-                    this.retire('turn error');
-                }
-            }
-            return;
-        }
-        // Streamed RunnerEvent for an in-flight turn.
-        const run = this.pending.get(msg.id);
-        if (run) {
-            await (0, customEngineIpc_1.applyParsedRunnerEvent)(run.emitter, msg.event);
-        }
-    }
-    markReady() {
-        if (this.readyTimer) {
-            clearTimeout(this.readyTimer);
-            this.readyTimer = undefined;
-        }
-        this.readyResolve?.();
-    }
-    /** Clear a run's abort timer and signal listener (called when the run settles or the worker dies). */
-    cleanupRun(run) {
-        if (run.abortTimer) {
-            clearTimeout(run.abortTimer);
-            run.abortTimer = undefined;
-        }
-        if (run.signal && run.onAbort) {
-            run.signal.removeEventListener('abort', run.onAbort);
-            run.onAbort = undefined;
-        }
-    }
-    finishRun(id, run) {
-        this.cleanupRun(run);
-        this.pending.delete(id);
-        if (this.retired && this.pending.size === 0) {
-            this.kill();
-        }
-    }
-    handleExit(reason) {
-        if (this.retireTimer) {
-            clearTimeout(this.retireTimer);
-            this.retireTimer = undefined;
-        }
-        if (this.readyTimer) {
-            clearTimeout(this.readyTimer);
-            this.readyTimer = undefined;
-        }
-        const child = this.child;
-        this.child = undefined;
-        this.retired = true;
-        // If the child is still alive (e.g. startup timeout fired on a hung import), terminate it.
-        if (child && child.exitCode === null && !child.killed) {
-            try {
-                child.kill('SIGKILL');
-            }
-            catch { /* already gone */ }
-        }
-        this.readyReject?.(new Error(`Persistent engine worker failed to start (${this.opts.label}): ${reason}`));
-        const pendingRuns = [...this.pending.entries()];
-        this.pending.clear();
-        for (const [, run] of pendingRuns) {
-            this.cleanupRun(run);
-            run.reject(new Error(`Custom engine worker exited (${this.opts.label}): ${reason}`));
-        }
-    }
-    /** Stop reusing this worker; kill once in-flight turns drain (or after a safety timeout). */
-    retire(reason) {
-        if (this.retired) {
-            return;
-        }
-        this.retired = true;
-        this.opts.logger.info(`[AgentIDE] Retiring persistent engine worker (${this.opts.label}): ${reason}`);
-        if (this.pending.size === 0) {
-            this.kill();
-        }
-        else {
-            this.retireTimer = setTimeout(() => this.kill(), RETIRE_DRAIN_TIMEOUT_MS);
-            this.retireTimer.unref?.();
-        }
-    }
-    kill() {
-        if (this.retireTimer) {
-            clearTimeout(this.retireTimer);
-            this.retireTimer = undefined;
-        }
-        if (this.readyTimer) {
-            clearTimeout(this.readyTimer);
-            this.readyTimer = undefined;
-        }
-        const child = this.child;
-        this.child = undefined;
-        this.retired = true;
-        if (!child || child.exitCode !== null || child.killed) {
-            return;
-        }
-        // SIGTERM closes the child's stdin readline, whose `close` handler aborts in-flight turns and
-        // exits(0). The child installs no SIGTERM handler, so signalling directly is enough — no
-        // separate `shutdown` line is needed (it would race the signal and never be read).
-        child.kill('SIGTERM');
-    }
-    send(req) {
-        this.child?.stdin?.write((0, customEngineIpc_1.encodeWorkerRequest)(req));
-    }
-    async run(runEnv, emitter, signal) {
-        await this.ensureStarted();
-        this.lastUsedAt = Date.now();
-        const id = String(++this.seq);
-        return new Promise((resolve, reject) => {
-            const run = { emitter, resolve, reject, aborted: false, signal };
-            const onAbort = () => {
-                run.aborted = true;
-                this.send({ type: 'abort', id });
-                // Don't wait on the child indefinitely: if the engine ignores its AbortSignal and never
-                // sends result/failed, settle the host promise ourselves so the turn doesn't leak.
-                run.abortTimer = setTimeout(() => {
-                    const pendingRun = this.pending.get(id);
-                    if (!pendingRun) {
-                        return;
-                    }
-                    this.finishRun(id, pendingRun);
-                    pendingRun.reject(new Error('Custom engine turn aborted'));
-                }, this.opts.abortSettleTimeoutMs ?? ABORT_SETTLE_TIMEOUT_MS);
-                run.abortTimer.unref?.();
-            };
-            if (signal) {
-                run.onAbort = onAbort;
-                if (signal.aborted) {
-                    onAbort();
-                }
-                else {
-                    signal.addEventListener('abort', onAbort, { once: true });
-                }
-            }
-            this.pending.set(id, run);
-            this.send({ type: 'run', id, env: runEnv });
-        });
-    }
-    isIdle(now) {
-        return this.pending.size === 0 && now - this.lastUsedAt > (this.opts.idleTtlMs ?? WORKER_IDLE_TTL_MS);
-    }
-}
-/** Pool of persistent engine workers, keyed by engine cacheKey (id + entry mtimes). */
-class PersistentEngineWorkerPool {
-    workers = new Map();
-    async run(opts, runEnv, emitter, signal) {
-        let worker = this.workers.get(opts.cacheKey);
-        if (!worker || !worker.isUsable()) {
-            worker?.retire('stale or dead');
-            worker = new EngineWorker(opts);
-            this.workers.set(opts.cacheKey, worker);
-        }
-        try {
-            return await worker.run(runEnv, emitter, signal);
-        }
-        catch (err) {
-            // A failed/exited worker must not be reused for the next turn.
-            if (this.workers.get(opts.cacheKey) === worker && !worker.isUsable()) {
-                this.workers.delete(opts.cacheKey);
-            }
-            throw err;
-        }
-    }
-    onMaintenance() {
-        const now = Date.now();
-        for (const [key, worker] of this.workers.entries()) {
-            if (worker.isIdle(now)) {
-                worker.kill();
-                this.workers.delete(key);
-            }
-        }
-    }
-    disposeAll() {
-        for (const worker of this.workers.values()) {
-            worker.kill();
-        }
-        this.workers.clear();
-    }
-    /** Test-only: number of live workers currently tracked by the pool. */
-    _workerCountForTest() {
-        return this.workers.size;
-    }
-}
-exports.PersistentEngineWorkerPool = PersistentEngineWorkerPool;