@agenthippo-ai/agenthippo 0.1.0

package/out/engines/persistentEngineWorker.js

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

package/out/engines/publish.js

@@ -0,0 +1,341 @@
+"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.discoverPublishableEngines = discoverPublishableEngines;
+exports.resolveEngineSourceDir = resolveEngineSourceDir;
+exports.validateEngineForPublish = validateEngineForPublish;
+exports.collectEngineFiles = collectEngineFiles;
+exports.isValidPublishVersion = isValidPublishVersion;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const branding_1 = require("../branding");
+const utils_1 = require("../utils");
+const install_1 = require("./install");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const ENGINE_MANIFEST_NAME = 'engine.manifest.json';
+const EXCLUDED_NAMES = new Set([
+    '.git',
+    '.hg',
+    '.svn',
+    '.DS_Store',
+    'node_modules',
+    'dist',
+    'coverage',
+    '.turbo',
+    '.cache',
+    '.pnpm-store',
+    'Thumbs.db',
+]);
+const SECRET_PATTERNS = [
+    ['private key', /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/],
+    ['OpenAI-style key', /\bsk-(?!dummy\b|ant-)[A-Za-z0-9_-]{20,}\b/],
+    ['Anthropic key', /\bsk-ant-[A-Za-z0-9_-]{20,}\b/],
+    ['Google API key', /\bAIza[0-9A-Za-z_-]{30,}\b/],
+    ['GitHub token', /\bgh[pousr]_[A-Za-z0-9_]{20,}\b/],
+    ['Atlassian API token', /\bATATT[A-Za-z0-9_=+/\-]{20,}\b/],
+    ['AWS access key', /\bAKIA[0-9A-Z]{16}\b/],
+    ['JWT', /\beyJ[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{10,}\b/],
+];
+function shouldExclude(name) {
+    if (EXCLUDED_NAMES.has(name)) {
+        return true;
+    }
+    if (/^\.env(?:\.|$)/.test(name)) {
+        return true;
+    }
+    if (/\.log$/i.test(name)) {
+        return true;
+    }
+    return false;
+}
+function normalizeArchivePath(rawPath) {
+    const normalized = rawPath.replace(/\\/g, '/').trim().replace(/^\.\//, '');
+    if (!normalized || normalized === '.' || normalized === '..') {
+        throw new Error('must be a non-empty relative path');
+    }
+    if (normalized.includes('\0') || path.posix.isAbsolute(normalized) || /^[A-Za-z]:[\\/]/.test(normalized)) {
+        throw new Error(`must be a safe relative path: ${rawPath}`);
+    }
+    for (const segment of normalized.split('/')) {
+        if (!segment || segment === '.' || segment === '..') {
+            throw new Error(`must not contain empty, "." or ".." segments: ${rawPath}`);
+        }
+    }
+    return normalized;
+}
+async function readEngineManifest(engineDir) {
+    const manifestPath = path.join(engineDir, ENGINE_MANIFEST_NAME);
+    const raw = await fs_1.promises.readFile(manifestPath, 'utf-8');
+    const manifest = JSON.parse(raw);
+    if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+        throw new Error(`${manifestPath} must contain a JSON object`);
+    }
+    if (manifest.version !== 2) {
+        throw new Error(`${manifestPath} must use custom engine manifest version 2`);
+    }
+    if (typeof manifest.id !== 'string' || !/^[a-z0-9][a-z0-9._-]*$/.test(manifest.id)) {
+        throw new Error(`${manifestPath} has invalid id: ${String(manifest.id)}`);
+    }
+    if (typeof manifest.entry !== 'string') {
+        throw new Error(`${manifestPath} must define string entry`);
+    }
+    const entryRel = normalizeArchivePath(manifest.entry);
+    const entryPath = path.join(engineDir, entryRel);
+    if (!(await (0, utils_1.pathExists)(entryPath))) {
+        throw new Error(`${manifestPath} entry does not exist: ${entryRel}`);
+    }
+    if (manifest.workspaceSync && typeof manifest.workspaceSync === 'object') {
+        const ws = manifest.workspaceSync;
+        if (ws.enabled) {
+            if (typeof ws.dir === 'string') {
+                normalizeArchivePath(ws.dir);
+            }
+            if (typeof ws.rulesFile === 'string') {
+                normalizeArchivePath(ws.rulesFile);
+            }
+        }
+    }
+    return { manifest, manifestPath, entryPath };
+}
+async function collectRawFiles(root, dir = '') {
+    const absDir = path.join(root, dir);
+    const entries = await fs_1.promises.readdir(absDir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        if (shouldExclude(entry.name)) {
+            continue;
+        }
+        const rel = dir ? path.join(dir, entry.name) : entry.name;
+        const abs = path.join(root, rel);
+        if (entry.isDirectory()) {
+            files.push(...await collectRawFiles(root, rel));
+        }
+        else if (entry.isFile()) {
+            files.push({ rel: rel.replace(/\\/g, '/'), abs });
+        }
+    }
+    return files;
+}
+async function scanForSecrets(files) {
+    const findings = [];
+    for (const file of files) {
+        const stats = await fs_1.promises.stat(file.abs);
+        if (stats.size > 5 * 1024 * 1024) {
+            continue;
+        }
+        const buffer = await fs_1.promises.readFile(file.abs);
+        if (buffer.includes(0)) {
+            continue;
+        }
+        const text = buffer.toString('utf8');
+        for (const [label, pattern] of SECRET_PATTERNS) {
+            if (pattern.test(text)) {
+                findings.push(`${file.rel}: ${label}`);
+            }
+        }
+    }
+    return findings;
+}
+async function readSuggestedVersion(engineDir) {
+    const packageJsonPath = path.join(engineDir, 'package.json');
+    if (!(await (0, utils_1.pathExists)(packageJsonPath))) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(await fs_1.promises.readFile(packageJsonPath, 'utf-8'));
+        if (parsed.version && /^\d+\.\d+\.\d+/.test(parsed.version)) {
+            return parsed.version;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/**
+ * Discover custom engines available to publish from workspace and home install roots.
+ */
+async function discoverPublishableEngines(workspaceRoot) {
+    const candidates = [];
+    if (workspaceRoot?.trim()) {
+        candidates.push({
+            root: path.join(path.resolve(workspaceRoot), branding_1.AGENTIDE_DIR_NAME, 'engines'),
+            label: 'workspace',
+        });
+    }
+    candidates.push({
+        root: (0, install_1.getDefaultCustomEnginesInstallRoot)(),
+        label: 'home',
+    });
+    const byId = new Map();
+    for (const { root, label } of candidates) {
+        if (!(await (0, utils_1.pathExists)(root))) {
+            continue;
+        }
+        const entries = await fs_1.promises.readdir(root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory() || shouldExclude(entry.name)) {
+                continue;
+            }
+            const sourceDir = path.join(root, entry.name);
+            const manifestPath = path.join(sourceDir, ENGINE_MANIFEST_NAME);
+            if (!(await (0, utils_1.pathExists)(manifestPath))) {
+                continue;
+            }
+            try {
+                const { manifest } = await readEngineManifest(sourceDir);
+                const id = manifest.id;
+                if (byId.has(id)) {
+                    continue;
+                }
+                byId.set(id, {
+                    id,
+                    displayName: typeof manifest.displayName === 'string'
+                        ? manifest.displayName
+                        : id,
+                    sourceDir,
+                    sourceLabel: label,
+                });
+            }
+            catch {
+                // Skip malformed engine folders.
+            }
+        }
+    }
+    return [...byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+/**
+ * Resolve an engine source directory by id from workspace or home roots.
+ */
+async function resolveEngineSourceDir(engineId, workspaceRoot) {
+    const discovered = await discoverPublishableEngines(workspaceRoot);
+    return discovered.find(engine => engine.id === engineId)?.sourceDir;
+}
+/**
+ * Validate a custom engine before publishing to the store.
+ */
+async function validateEngineForPublish(engineDir, expectedId) {
+    const errors = [];
+    const warnings = [];
+    if (!(await (0, utils_1.pathExists)(engineDir))) {
+        return {
+            valid: false,
+            errors: [`Engine directory not found: ${engineDir}`],
+            warnings,
+        };
+    }
+    let manifest;
+    let entryPath;
+    try {
+        ({ manifest, entryPath } = await readEngineManifest(engineDir));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { valid: false, errors: [message], warnings };
+    }
+    const id = manifest.id;
+    if (expectedId && expectedId !== id) {
+        errors.push(`Engine folder id "${expectedId}" does not match manifest id "${id}"`);
+    }
+    const packageJsonPath = path.join(engineDir, 'package.json');
+    if (await (0, utils_1.pathExists)(packageJsonPath) && !(await (0, utils_1.pathExists)(path.join(engineDir, 'package-lock.json')))) {
+        errors.push('package.json present but package-lock.json is missing');
+    }
+    const rawFiles = await collectRawFiles(engineDir);
+    if (!rawFiles.some(file => file.rel === ENGINE_MANIFEST_NAME)) {
+        errors.push(`Missing ${ENGINE_MANIFEST_NAME} in publishable files`);
+    }
+    const secretFindings = await scanForSecrets(rawFiles);
+    if (secretFindings.length > 0) {
+        errors.push(`Possible secrets found:\n${secretFindings.map(f => `  - ${f}`).join('\n')}`);
+    }
+    try {
+        await execFileAsync(process.execPath, ['--check', entryPath], { windowsHide: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        errors.push(`engine entry failed node --check: ${message}`);
+    }
+    if (!manifest.description) {
+        warnings.push('Consider adding description to engine.manifest.json');
+    }
+    const suggestedVersion = await readSuggestedVersion(engineDir);
+    if (!suggestedVersion) {
+        warnings.push('No package.json version found; you will be prompted for a publish version');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+        metadata: errors.length === 0
+            ? {
+                id,
+                displayName: typeof manifest.displayName === 'string' ? manifest.displayName : id,
+                description: typeof manifest.description === 'string' ? manifest.description : undefined,
+                suggestedVersion,
+            }
+            : undefined,
+    };
+}
+/**
+ * Collect publishable engine files (text) for fork + PR upload.
+ */
+async function collectEngineFiles(engineDir) {
+    const rawFiles = await collectRawFiles(engineDir);
+    const files = [];
+    for (const file of rawFiles) {
+        const stats = await fs_1.promises.stat(file.abs);
+        if (stats.size > 5 * 1024 * 1024) {
+            throw new Error(`File too large to publish (>5MB): ${file.rel}`);
+        }
+        const buffer = await fs_1.promises.readFile(file.abs);
+        if (buffer.includes(0)) {
+            throw new Error(`Binary file cannot be published as text: ${file.rel}`);
+        }
+        files.push({
+            path: file.rel,
+            content: buffer.toString('utf8'),
+        });
+    }
+    return files;
+}
+function isValidPublishVersion(version) {
+    return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(version.trim());
+}

package/out/engines/types.js

@@ -0,0 +1,17 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEngineForModel = exports.getProviderForModel = exports.getEnginesCompatibleWithProvider = exports.getAgentEngine = exports.getModel = exports.getProvider = exports.AGENT_ENGINES = exports.BUILTIN_MODELS = exports.PROVIDERS = void 0;
+// Re-export shared types
+var shared_1 = require("../shared");
+Object.defineProperty(exports, "PROVIDERS", { enumerable: true, get: function () { return shared_1.PROVIDERS; } });
+Object.defineProperty(exports, "BUILTIN_MODELS", { enumerable: true, get: function () { return shared_1.BUILTIN_MODELS; } });
+Object.defineProperty(exports, "AGENT_ENGINES", { enumerable: true, get: function () { return shared_1.AGENT_ENGINES; } });
+Object.defineProperty(exports, "getProvider", { enumerable: true, get: function () { return shared_1.getProvider; } });
+Object.defineProperty(exports, "getModel", { enumerable: true, get: function () { return shared_1.getModel; } });
+Object.defineProperty(exports, "getAgentEngine", { enumerable: true, get: function () { return shared_1.getAgentEngine; } });
+Object.defineProperty(exports, "getEnginesCompatibleWithProvider", { enumerable: true, get: function () { return shared_1.getEnginesCompatibleWithProvider; } });
+Object.defineProperty(exports, "getProviderForModel", { enumerable: true, get: function () { return shared_1.getProviderForModel; } });
+Object.defineProperty(exports, "getEngineForModel", { enumerable: true, get: function () { return shared_1.getEngineForModel; } });