@agenthippo-ai/agenthippo 0.1.0

package/out/engines/factory.js

@@ -0,0 +1,45 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEngines = createEngines;
+const types_1 = require("./types");
+const codex_1 = require("./codex");
+const claude_1 = require("./claude");
+const custom_1 = require("./custom");
+/**
+ * Create all registered engines.
+ * Uses AGENT_ENGINES as the source of truth for which engines to create.
+ */
+function createEngines(deps) {
+    const engines = {};
+    for (const engineDef of Object.values(types_1.AGENT_ENGINES)) {
+        const engine = createEngine(engineDef.id, deps);
+        if (engine) {
+            engines[engineDef.id] = engine;
+        }
+    }
+    // Add-on path: keep built-in engines unchanged, add a dynamic custom engine loader.
+    const customEngine = createEngine('custom', deps);
+    if (customEngine) {
+        engines.custom = customEngine;
+    }
+    return engines;
+}
+/**
+ * Create a single engine by ID.
+ */
+function createEngine(id, deps) {
+    switch (id) {
+        case 'codex':
+            return new codex_1.CodexEngine(deps.config, (root) => deps.syncService.getSkillsSignature(root), deps.getBundledBasePromptsDir);
+        case 'claude':
+            return new claude_1.ClaudeEngine(deps.config, (root, dirs) => deps.syncService.computeWorkspaceAgentideSignature(root, dirs), deps.getBundledBasePromptsDir);
+        case 'custom':
+            return new custom_1.CustomEngine(deps.config, deps.getBundledBasePromptsDir);
+        default:
+            // Unknown engine - could be a future engine not yet implemented
+            return undefined;
+    }
+}

package/out/engines/install.js

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