@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/cli/pack-loader.js

@@ -1,418 +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.resolvePackPath = resolvePackPath;
-exports.listAvailablePacks = listAvailablePacks;
-exports.loadAgentPack = loadAgentPack;
-exports.getDefaultConfig = getDefaultConfig;
-exports.getEnvDefaultModel = getEnvDefaultModel;
-exports.getApiConfig = getApiConfig;
-exports.hasCredentialForEngine = hasCredentialForEngine;
-exports.getFileAccess = getFileAccess;
-/**
- * Agent Pack Loader
- *
- * Loads and validates agent packs from the filesystem.
- */
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const yaml = __importStar(require("js-yaml"));
-const branding_1 = require("../branding");
-// -----------------------------------------------------------------------------
-// Constants
-// -----------------------------------------------------------------------------
-function getEnvVar(primary, legacy) {
-    return process.env[primary] ?? (legacy ? process.env[legacy] : undefined);
-}
-const AGENTHIPPO_HOME = process.env.AGENTHIPPO_HOME || path.join(os.homedir(), branding_1.AGENTIDE_DIR_NAME);
-const USER_AGENTS_DIR = path.join(AGENTHIPPO_HOME, 'agents');
-const AGENTS_SUBDIR = 'agents';
-// -----------------------------------------------------------------------------
-// Pack Resolution
-// -----------------------------------------------------------------------------
-/**
- * Resolve a pack path with version support.
- *
- * Resolution order:
- * 1. Check for current.txt pointer → use that version
- * 2. Check if basePath itself has agent.yaml → flat structure
- * 3. Auto-detect version directories (semver-like: X.Y.Z) → use latest
- */
-function resolveVersionedPath(basePath) {
-    if (!fs.existsSync(basePath)) {
-        return undefined;
-    }
-    // 1. Check for current.txt version pointer
-    const currentFile = path.join(basePath, 'current.txt');
-    if (fs.existsSync(currentFile)) {
-        const version = fs.readFileSync(currentFile, 'utf-8').trim();
-        const versionPath = path.join(basePath, version);
-        if (fs.existsSync(versionPath)) {
-            return versionPath;
-        }
-    }
-    // 2. Flat structure - agent.yaml directly in basePath
-    const flatManifest = path.join(basePath, 'agent.yaml');
-    if (fs.existsSync(flatManifest)) {
-        return basePath;
-    }
-    // 3. Auto-detect version directories (look for semver-like: X.Y.Z or X.Y.Z-xxx)
-    try {
-        const entries = fs.readdirSync(basePath, { withFileTypes: true });
-        const versionDirs = entries
-            .filter(e => e.isDirectory() && /^\d+\.\d+\.\d+/.test(e.name))
-            .map(e => e.name)
-            .sort((a, b) => {
-            // Sort by semver (descending - latest first)
-            const [aMajor, aMinor, aPatch] = a.split('.').map(n => parseInt(n, 10) || 0);
-            const [bMajor, bMinor, bPatch] = b.split('.').map(n => parseInt(n, 10) || 0);
-            if (bMajor !== aMajor) {
-                return bMajor - aMajor;
-            }
-            if (bMinor !== aMinor) {
-                return bMinor - aMinor;
-            }
-            return bPatch - aPatch;
-        });
-        // Use latest version that has agent.yaml
-        for (const version of versionDirs) {
-            const versionPath = path.join(basePath, version);
-            const manifestPath = path.join(versionPath, 'agent.yaml');
-            if (fs.existsSync(manifestPath)) {
-                return versionPath;
-            }
-        }
-    }
-    catch {
-        // Ignore read errors
-    }
-    return undefined;
-}
-/**
- * Find an agent pack by name or path.
- *
- * Search order:
- * 1. Explicit path (absolute or relative to cwd)
- * 2. Direct folder in cwd: ./<name> (convenience for development)
- * 3. Local agents folder: ./agents/<name> (in cwd, for development)
- * 4. Workspace branding folder: <workspace>/<brand>/agents/<name>
- * 5. User agent library: ~/<brand>/agents/<name>
- *
- * @param nameOrPath - Pack name or path
- * @param workspaceRoot - Workspace root directory (for workspace-local packs)
- */
-function resolvePackPath(nameOrPath, workspaceRoot) {
-    // 1. Explicit path (absolute or relative to cwd)
-    // This handles both absolute paths and relative paths like "./myagent" or "../agents/myagent"
-    if (path.isAbsolute(nameOrPath) || nameOrPath.startsWith('./') || nameOrPath.startsWith('../')) {
-        const resolvedPath = path.isAbsolute(nameOrPath) ? nameOrPath : path.resolve(process.cwd(), nameOrPath);
-        if (fs.existsSync(resolvedPath)) {
-            try {
-                if (fs.statSync(resolvedPath).isDirectory()) {
-                    return resolveVersionedPath(resolvedPath) ?? resolvedPath;
-                }
-            }
-            catch {
-                // Ignore stat errors, fall back to raw path.
-            }
-            return resolvedPath;
-        }
-        // If explicit path doesn't exist, don't fall through to other search locations
-        return undefined;
-    }
-    // From here, nameOrPath is just a name (e.g., "joker1"), not a path
-    // Search in standard locations in priority order
-    // 2. Direct folder in cwd: ./<name> (convenience for development)
-    const cwdDirectPath = path.join(process.cwd(), nameOrPath);
-    const cwdDirectResolved = resolveVersionedPath(cwdDirectPath);
-    if (cwdDirectResolved) {
-        return cwdDirectResolved;
-    }
-    // 3. Local agents folder: ./agents/<name> (in cwd, for development)
-    const localAgentsPath = path.join(process.cwd(), AGENTS_SUBDIR, nameOrPath);
-    const localResolved = resolveVersionedPath(localAgentsPath);
-    if (localResolved) {
-        return localResolved;
-    }
-    // 4. Workspace branding folder: <workspace>/<brand>/agents/<name>
-    if (workspaceRoot) {
-        const workspacePackPath = path.join(workspaceRoot, branding_1.AGENTIDE_DIR_NAME, AGENTS_SUBDIR, nameOrPath);
-        const resolved = resolveVersionedPath(workspacePackPath);
-        if (resolved) {
-            return resolved;
-        }
-    }
-    // 5. User agent library: ~/<brand>/agents/<name>
-    const ualPath = path.join(USER_AGENTS_DIR, nameOrPath);
-    const resolved = resolveVersionedPath(ualPath);
-    if (resolved) {
-        return resolved;
-    }
-    return undefined;
-}
-/**
- * List packs from a directory.
- */
-function listPacksFromDir(agentsDir, source) {
-    const packs = [];
-    if (!fs.existsSync(agentsDir)) {
-        return packs;
-    }
-    const entries = fs.readdirSync(agentsDir, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        if (entry.name.startsWith('.')) {
-            continue;
-        }
-        const packPath = path.join(agentsDir, entry.name);
-        const resolvedPath = resolveVersionedPath(packPath);
-        if (!resolvedPath) {
-            continue;
-        }
-        // Extract version from resolved path
-        let version;
-        if (resolvedPath !== packPath) {
-            version = path.basename(resolvedPath);
-        }
-        packs.push({
-            name: entry.name,
-            path: resolvedPath,
-            version,
-            source,
-        });
-    }
-    return packs;
-}
-/**
- * List all available agent packs.
- *
- * @param workspaceRoot - Workspace root to search for workspace-local packs
- * @returns Array of packs from both workspace and user library
- */
-function listAvailablePacks(workspaceRoot) {
-    const packs = [];
-    const seen = new Set();
-    // 1. Workspace-local packs (higher priority)
-    if (workspaceRoot) {
-        const workspaceAgentsDir = path.join(workspaceRoot, branding_1.AGENTIDE_DIR_NAME, AGENTS_SUBDIR);
-        const workspacePacks = listPacksFromDir(workspaceAgentsDir, 'workspace');
-        for (const pack of workspacePacks) {
-            packs.push(pack);
-            seen.add(pack.name);
-        }
-    }
-    // 2. User library packs (skip if already in workspace)
-    const userPacks = listPacksFromDir(USER_AGENTS_DIR, 'user-library');
-    for (const pack of userPacks) {
-        if (!seen.has(pack.name)) {
-            packs.push(pack);
-        }
-    }
-    return packs;
-}
-// -----------------------------------------------------------------------------
-// Pack Loading
-// -----------------------------------------------------------------------------
-/**
- * Load an agent pack from the filesystem.
- *
- * @param nameOrPath - Pack name or path
- * @param workspaceRoot - Workspace root for finding workspace-local packs
- */
-async function loadAgentPack(nameOrPath, workspaceRoot) {
-    const packPath = resolvePackPath(nameOrPath, workspaceRoot);
-    if (!packPath) {
-        const isExplicitPath = path.isAbsolute(nameOrPath) || nameOrPath.startsWith('./') || nameOrPath.startsWith('../');
-        const searchedLocations = isExplicitPath
-            ? [path.resolve(process.cwd(), nameOrPath)]
-            : [
-                `${process.cwd()}/${nameOrPath}`,
-                `${process.cwd()}/agents/${nameOrPath}`,
-                workspaceRoot ? `${workspaceRoot}/${branding_1.AGENTIDE_DIR_NAME}/agents/${nameOrPath}` : null,
-                `${USER_AGENTS_DIR}/${nameOrPath}`,
-            ].filter(Boolean);
-        throw new Error(`Agent pack not found: ${nameOrPath}\n  Searched: ${searchedLocations.join(', ')}`);
-    }
-    // Load manifest
-    const manifestPath = path.join(packPath, 'agent.yaml');
-    if (!fs.existsSync(manifestPath)) {
-        throw new Error(`Missing agent.yaml in pack: ${packPath}`);
-    }
-    const manifestContent = fs.readFileSync(manifestPath, 'utf-8');
-    const manifest = yaml.load(manifestContent);
-    // Validate manifest
-    validateManifest(manifest, manifestPath);
-    const normalizedManifest = normalizeManifestForRuntime(manifest);
-    // Load system prompt
-    let systemPrompt = '';
-    const systemPromptPath = path.join(packPath, 'AGENTS.md');
-    if (fs.existsSync(systemPromptPath)) {
-        systemPrompt = fs.readFileSync(systemPromptPath, 'utf-8');
-    }
-    // Load rules
-    const rules = [];
-    return {
-        manifest: normalizedManifest,
-        packPath,
-        systemPrompt,
-        rules,
-    };
-}
-function normalizeManifestForRuntime(manifest) {
-    const rawEngine = manifest.spec.engine?.trim() ?? '';
-    const normalizedEngine = rawEngine.toLowerCase();
-    if (rawEngine !== normalizedEngine) {
-        return {
-            ...manifest,
-            spec: {
-                ...manifest.spec,
-                engine: normalizedEngine,
-            },
-        };
-    }
-    return manifest;
-}
-/**
- * Validate a pack manifest.
- */
-function validateManifest(manifest, sourcePath) {
-    const errors = [];
-    if (!manifest.metadata?.name) {
-        errors.push('Missing metadata.name');
-    }
-    if (!manifest.metadata?.version) {
-        errors.push('Missing metadata.version');
-    }
-    if (!manifest.spec?.engine?.trim()) {
-        errors.push('Missing spec.engine');
-    }
-    const normalizedEngine = manifest.spec?.engine?.trim().toLowerCase();
-    if (normalizedEngine === 'custom') {
-        errors.push('Invalid spec.engine: use the concrete custom engine id (for example, openclaw), not "custom"');
-    }
-    if (manifest.spec?.cheapModel !== undefined && typeof manifest.spec.cheapModel !== 'string') {
-        errors.push('Invalid spec.cheapModel: must be a string when provided');
-    }
-    if (manifest.spec?.dataPlane !== undefined) {
-        if (typeof manifest.spec.dataPlane !== 'object' || !manifest.spec.dataPlane.connector?.trim()) {
-            errors.push('Invalid spec.dataPlane: requires a `connector` path (stdio MCP module run broker-side)');
-        }
-        if (manifest.spec.dataPlane?.provider !== undefined && typeof manifest.spec.dataPlane.provider !== 'string') {
-            errors.push('Invalid spec.dataPlane.provider: must be a string when provided');
-        }
-    }
-    if (errors.length > 0) {
-        throw new Error(`Invalid agent manifest at ${sourcePath}:\n  - ${errors.join('\n  - ')}`);
-    }
-}
-/**
- * Get default engine and model when no pack is specified.
- */
-function getDefaultConfig() {
-    const rawEngine = (getEnvVar('AGENTHIPPO_DEFAULT_ENGINE', 'AGENTIDE_DEFAULT_ENGINE') || 'claude').trim().toLowerCase();
-    return {
-        engine: rawEngine,
-        model: getEnvVar('AGENTHIPPO_DEFAULT_MODEL', 'AGENTIDE_DEFAULT_MODEL') || 'claude-sonnet-4-5-20250929',
-    };
-}
-/**
- * Returns the env-configured default model without a hardcoded fallback.
- * Used after custom engine manifest defaults so AGENTHIPPO_DEFAULT_MODEL only
- * wins when no request, pack, or manifest model is available.
- */
-function getEnvDefaultModel() {
-    return getEnvVar('AGENTHIPPO_DEFAULT_MODEL', 'AGENTIDE_DEFAULT_MODEL')?.trim() || undefined;
-}
-/**
- * Get API configuration from environment.
- *
- * Returns the credentials keyed by destination (litellm / openai / anthropic) rather than a
- * single collapsed key. The engine selects the one matching the endpoint it dials — see
- * resolveApiRouting — so a codex deployment can no longer send an Anthropic key to OpenAI.
- */
-function getApiConfig() {
-    const litellmApiKey = getEnvVar('AGENTHIPPO_LITELLM_API_KEY', 'AGENTIDE_LITELLM_API_KEY');
-    const litellmBaseUrl = getEnvVar('AGENTHIPPO_LITELLM_BASE_URL', 'AGENTIDE_LITELLM_BASE_URL');
-    const anthropicApiKey = process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_API_KEY;
-    const openaiApiKey = process.env.OPENAI_API_KEY;
-    // The URL alone defines the trust domain. When a LiteLLM/gateway URL is configured, ALL
-    // engine traffic routes there — so it must authenticate with the LiteLLM key (or
-    // resolveApiRouting's 'sk-dummy' fallback), NEVER a provider secret, and must carry the
-    // analytics metadata headers. Requiring key+URL here once created a silent half-state:
-    // URL-only routed every call to the gateway with the REAL provider key as auth and no
-    // metadata at all (verified live 2026-07-27 with a header-capture stub). A missing key now
-    // yields a clean 401 against a strict gateway instead of a leaked credential.
-    const useLiteLLM = Boolean(litellmBaseUrl);
-    return {
-        // Kept only for the "is any credential present at all?" boot check; routing never uses it.
-        apiKey: litellmApiKey || anthropicApiKey || openaiApiKey,
-        baseUrl: litellmBaseUrl,
-        useLiteLLM,
-        litellmApiKey,
-        openaiApiKey,
-        anthropicApiKey,
-    };
-}
-/**
- * Does the environment carry a usable credential for `engine`? Engine-aware so a codex
- * deployment with only an Anthropic key (or vice-versa) fails loudly at boot instead of
- * 401-ing at the first model call. A configured LiteLLM proxy satisfies every engine.
- */
-function hasCredentialForEngine(engine, cfg = getApiConfig()) {
-    if (cfg.useLiteLLM) {
-        return true;
-    }
-    const e = engine.trim().toLowerCase();
-    if (e === 'claude') {
-        return Boolean(cfg.anthropicApiKey);
-    }
-    if (e === 'codex') {
-        return Boolean(cfg.openaiApiKey);
-    }
-    // Custom engines can authenticate via their own manifest-declared env var — don't gate them here.
-    return true;
-}
-/**
- * Get file access mode from pack manifest.
- */
-function getFileAccess(pack) {
-    return pack?.manifest.spec.permissions?.fileAccess ?? 'workspace-write';
-}

package/out/cli/pack-runtime.js

@@ -1,61 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) AgentHippo.ai. All rights reserved.
- *--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPackRunner = createPackRunner;
-/**
- * One way to stand up a `HeadlessRunner` for an agent pack.
- *
- * `serve` and `sandbox` run the SAME engines against the SAME pack; the only difference is where
- * the process sits. Every time the sandbox re-derived a piece of that setup itself it drifted from
- * serve and broke live (the hand-rolled agent.yaml parser, the engine executable paths, the
- * skipped `ensureDeps`). So the wiring lives here once and both call it: engine discovery,
- * bundled prompts, the child env patch, and the credential shape.
- *
- * What is NOT here is deliberately not shared: credentials are the caller's business. serve
- * holds provider keys; a sandbox only ever gets a per-sandbox, budget-capped model token that arrives
- * on the run frame. Both express that through `credentials`, and nothing in this module can
- * widen it.
- */
-const headless_1 = require("../headless");
-const runtime_1 = require("./runtime");
-const utils_1 = require("./utils");
-/**
- * Build the runner. Engine executables are resolved here rather than by the SDKs themselves:
- * the engines ship WITH agenthippo, and a runtime image does not carry the SDK's own bundled
- * cli.js — without these paths every turn inside a sandbox fails with "executable not found".
- */
-function createPackRunner(options) {
-    return (0, headless_1.createHeadlessRunner)({
-        storagePath: options.storagePath,
-        analyticsSessionsDir: options.analyticsSessionsDir,
-        packId: options.packId,
-        packVersion: options.packVersion,
-        provenance: options.provenance,
-        bundledPromptsDir: (0, utils_1.findBundledBasePromptsDir)(),
-        apiKey: options.credentials.apiKey,
-        baseUrl: options.credentials.baseUrl,
-        useLiteLLM: options.credentials.useLiteLLM,
-        litellmApiKey: options.credentials.litellmApiKey,
-        openaiApiKey: options.credentials.openaiApiKey,
-        anthropicApiKey: options.credentials.anthropicApiKey,
-        logger: options.logger,
-        freshState: options.freshState ?? false,
-        claudeCodeExecutablePath: (0, utils_1.findClaudeCodePath)(),
-        codexExecutablePath: (0, utils_1.findCodexPath)(),
-        permissionHandler: options.permissionHandler,
-        // Gives engine children AGENTHIPPO_WORKSPACE_ROOT / AGENTHIPPO_ACTIVE_AGENT and puts the
-        // agenthippo binary on their PATH — without it a pack skill that shells out to the CLI
-        // cannot find it, which is exactly the kind of silent difference a sandbox must not have.
-        cliEnvPatch: (0, runtime_1.buildCliEnvPatch)({
-            cliPath: process.execPath,
-            workspaceRoot: options.workspaceRoot,
-            agentId: options.packId,
-            chatSessionId: options.chatSessionId,
-            baseEnv: process.env,
-            omitGatewayToken: options.omitGatewayToken,
-        }),
-        ...(options.claudeCheapModel ? { engineSettings: { claudeCheapModel: options.claudeCheapModel } } : {}),
-    });
-}