@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/headless/index.js

@@ -1,539 +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.resolveModelAlias = exports.getSessionDir = exports.createSessionDir = exports.computeSkillsSignature = exports.syncPackToWorkspace = exports.initSessionStoreWithStore = exports.CLIPermissionHandler = exports.AutoApprovePermissionHandler = exports.DirectorySessionStore = exports.FileSessionStore = exports.MemorySessionStore = exports.StaticConfigProvider = exports.NoOpEditTracker = exports.NoOpLogger = exports.ConsoleLogger = void 0;
-exports.createHeadlessRunner = createHeadlessRunner;
-exports.createEvalRunner = createEvalRunner;
-exports.createCLIRunner = createCLIRunner;
-/**
- * AgentIDE Headless Mode
- *
- * This module provides a production-ready entry point for running AgentIDE
- * engines without VS Code. Suitable for:
- * - Eval mode (fresh state per example, auto-approve all tools)
- * - CLI applications
- * - Production servers (API endpoints, WebSocket handlers)
- * - CI/CD pipelines
- *
- * @example Basic Usage
- * ```typescript
- * import { createHeadlessRunner } from './headless';
- *
- * const runner = createHeadlessRunner({
- *   storagePath: '/tmp/agentide-storage',
- *   apiKey: process.env.ANTHROPIC_API_KEY,
- * });
- *
- * const result = await runner.run({
- *   engineId: 'claude',
- *   modelId: 'claude-sonnet-4-5-20250929',
- *   message: 'Hello, agent!',
- *   workspaceRoot: process.cwd(),
- * });
- *
- * console.log(result.text);
- * runner.dispose();
- * ```
- *
- * @example Custom StreamEmitter for Real-Time Output
- * ```typescript
- * import { createHeadlessRunner, StreamEmitter } from './headless';
- *
- * const runner = createHeadlessRunner({ storagePath: '/tmp/agent' });
- *
- * // Custom emitter for real-time streaming to console
- * const customEmitter: StreamEmitter = {
- *   async thinking(delta) {
- *     process.stdout.write('\x1b[90m' + delta + '\x1b[0m'); // gray
- *   },
- *   async text(delta) {
- *     process.stdout.write(delta);
- *   },
- *   async toolStart(name, input, toolCallId) {
- *     // allow-any-unicode-next-line
- *     console.log(`\n\x1b[34m🔧 ${name}\x1b[0m`); // blue
- *     if (input) console.log(`   ${input}`);
- *   },
- *   async toolEnd(name, toolCallId, result, isError) {
- *     // allow-any-unicode-next-line
- *     console.log(isError ? '\x1b[31m✗\x1b[0m' : '\x1b[32m✓\x1b[0m');
- *   },
- *   async progress(msg) {
- *     // allow-any-unicode-next-line
- *     console.log(`\x1b[33m⏳ ${msg}\x1b[0m`); // yellow
- *   },
- *   async error(msg) {
- *     // allow-any-unicode-next-line
- *     console.error(`\x1b[31m❌ ${msg}\x1b[0m`); // red
- *   },
- *   async done() {
- *     console.log('\n');
- *   },
- * };
- *
- * await runner.run({
- *   engineId: 'claude',
- *   modelId: 'claude-sonnet-4-5-20250929',
- *   message: 'Refactor this file',
- *   workspaceRoot: process.cwd(),
- *   emitter: customEmitter,
- * });
- * ```
- *
- * @example Production Server with Express
- * ```typescript
- * import express from 'express';
- * import { createHeadlessRunner, ConsoleLogger, AutoApprovePermissionHandler } from './headless';
- *
- * const runner = createHeadlessRunner({
- *   storagePath: '/var/lib/agentide',
- *   apiKey: process.env.API_KEY,
- *   baseUrl: process.env.LLM_BASE_URL,
- *   useLiteLLM: true,
- *   logger: new ConsoleLogger('[API]'),
- *   permissionHandler: new AutoApprovePermissionHandler(),
- *   freshState: false, // Persist sessions across requests
- * });
- *
- * const app = express();
- * app.use(express.json());
- *
- * app.post('/api/chat', async (req, res) => {
- *   const { message, sessionId, workspaceRoot } = req.body;
- *
- *   const result = await runner.run({
- *     engineId: 'claude',
- *     modelId: 'claude-sonnet-4-5-20250929',
- *     message,
- *     workspaceRoot,
- *     sessionId,
- *   });
- *
- *   res.json({
- *     success: result.success,
- *     text: result.text,
- *     toolCalls: result.toolCalls,
- *     error: result.error,
- *   });
- * });
- *
- * app.listen(3000);
- * ```
- *
- * @module headless
- */
-const path = __importStar(require("path"));
-const codex_1 = require("../engines/codex");
-const claude_1 = require("../engines/claude");
-const base_1 = require("../engines/base");
-const interfaces_1 = require("../runtime/interfaces");
-Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return interfaces_1.ConsoleLogger; } });
-Object.defineProperty(exports, "NoOpLogger", { enumerable: true, get: function () { return interfaces_1.NoOpLogger; } });
-Object.defineProperty(exports, "NoOpEditTracker", { enumerable: true, get: function () { return interfaces_1.NoOpEditTracker; } });
-Object.defineProperty(exports, "StaticConfigProvider", { enumerable: true, get: function () { return interfaces_1.StaticConfigProvider; } });
-Object.defineProperty(exports, "MemorySessionStore", { enumerable: true, get: function () { return interfaces_1.MemorySessionStore; } });
-Object.defineProperty(exports, "FileSessionStore", { enumerable: true, get: function () { return interfaces_1.FileSessionStore; } });
-Object.defineProperty(exports, "DirectorySessionStore", { enumerable: true, get: function () { return interfaces_1.DirectorySessionStore; } });
-Object.defineProperty(exports, "AutoApprovePermissionHandler", { enumerable: true, get: function () { return interfaces_1.AutoApprovePermissionHandler; } });
-Object.defineProperty(exports, "CLIPermissionHandler", { enumerable: true, get: function () { return interfaces_1.CLIPermissionHandler; } });
-const session_1 = require("../session");
-const sync_1 = require("./sync");
-const sessionEvents_1 = require("../analytics/sessionEvents");
-const runtime_1 = require("../cli/runtime");
-const credential_context_1 = require("../cli/credential-context");
-const paths_1 = require("../utils/paths");
-function resolveHeadlessAnalyticsUserId(runOverride, configOverride) {
-    const fromRun = runOverride?.trim();
-    if (fromRun) {
-        return fromRun;
-    }
-    const fromConfig = configOverride?.trim();
-    if (fromConfig) {
-        return fromConfig;
-    }
-    // Headless/CLI parity with IDE:
-    // - explicit override first
-    // - system username next
-    // In non-VSCode contexts there is no telemetry machineId fallback.
-    const fromEnvOverride = process.env.AGENTHIPPO_ANALYTICS_USER_ID?.trim() ||
-        process.env.AGENTIDE_ANALYTICS_USER_ID?.trim();
-    if (fromEnvOverride) {
-        return fromEnvOverride;
-    }
-    const fromSystemUser = process.env.LOGNAME?.trim() ||
-        process.env.USER?.trim() ||
-        process.env.LNAME?.trim() ||
-        process.env.USERNAME?.trim();
-    if (fromSystemUser) {
-        return fromSystemUser;
-    }
-    return 'anonymous';
-}
-// -----------------------------------------------------------------------------
-// Implementation
-// -----------------------------------------------------------------------------
-/**
- * Create a headless runner for production use.
- *
- * @param config - Headless configuration
- * @returns Headless runner instance
- */
-function createHeadlessRunner(config) {
-    // Initialize session store for the headless runtime.
-    if (config.freshState) {
-        const memoryStore = new interfaces_1.MemorySessionStore();
-        (0, session_1.initSessionStoreWithStore)(memoryStore);
-    }
-    else {
-        // Per-session files (not one shared provider-sessions.json) so object-store
-        // sync across a sticky-routed fleet doesn't clobber a shared map. Migrates
-        // the legacy single file at provider-sessions.json on first load.
-        (0, session_1.initSessionStoreWithStore)(new interfaces_1.DirectorySessionStore(path.join(config.storagePath, 'provider-sessions')));
-    }
-    // Per-destination credentials. When a caller supplies the split keys (serve), use them so
-    // each engine picks the key for the endpoint it dials. Otherwise fall back to the single
-    // `apiKey` as the LiteLLM key (back-compat: eval/CLI runners configured one key).
-    const hasSplitKeys = Boolean(config.litellmApiKey || config.openaiApiKey || config.anthropicApiKey);
-    const engineConfig = {
-        storagePath: config.storagePath,
-        codexHome: undefined,
-        claudeConfigDir: undefined,
-        litellmApiKey: config.litellmApiKey ?? (hasSplitKeys ? undefined : config.apiKey),
-        litellmBaseUrl: config.baseUrl,
-        openaiApiKey: config.openaiApiKey,
-        anthropicApiKey: config.anthropicApiKey,
-        claudeCodeExecutablePath: config.claudeCodeExecutablePath,
-        codexExecutablePath: config.codexExecutablePath,
-    };
-    // Build runtime context
-    const logger = config.logger ?? new interfaces_1.ConsoleLogger('[AgentIDE]');
-    const editTracker = config.editTracker ?? new interfaces_1.NoOpEditTracker();
-    const configProvider = new interfaces_1.StaticConfigProvider({}, config.customProviders ?? {}, config.engineSettings ?? {});
-    const permissionHandler = config.permissionHandler ?? new interfaces_1.AutoApprovePermissionHandler();
-    const runtimeContext = {
-        logger,
-        editTracker,
-        configProvider,
-        permissionHandler,
-        cliEnvPatch: config.cliEnvPatch,
-    };
-    // Pack ID for skills signature (defaults to 'default')
-    const packId = config.packId ?? 'default';
-    // Skills signature getter (matches what SyncService provides)
-    const getSkillsSignature = (workspaceRoot) => {
-        return (0, sync_1.computeSkillsSignature)(workspaceRoot, packId);
-    };
-    // Bundled prompts directory getter
-    const getBundledBasePromptsDir = () => {
-        return config.bundledPromptsDir;
-    };
-    // Create engines lazily
-    let claudeEngine;
-    let codexEngine;
-    let customEngine;
-    const getClaudeEngine = () => {
-        if (!claudeEngine) {
-            claudeEngine = new claude_1.ClaudeEngine(engineConfig, 
-            // Claude uses workspace signature for session management
-            async (workspaceRoot, _dirs) => {
-                const sig = getSkillsSignature(workspaceRoot);
-                return sig ?? `headless-${packId}`;
-            }, getBundledBasePromptsDir);
-        }
-        return claudeEngine;
-    };
-    const getCodexEngine = () => {
-        if (!codexEngine) {
-            codexEngine = new codex_1.CodexEngine(engineConfig, getSkillsSignature, getBundledBasePromptsDir);
-        }
-        return codexEngine;
-    };
-    const getCustomEngine = async () => {
-        if (!customEngine) {
-            const { CustomEngine: CustomEngineCtor } = await import('../engines/custom.js');
-            customEngine = new CustomEngineCtor(engineConfig, getBundledBasePromptsDir);
-        }
-        return customEngine;
-    };
-    // Shared session event writer for Layer 2 analytics. Defaults to getAgentideHome() — the
-    // exact directory sessionJsonlFleet.ts and query-analytics.sh already scan, so tool-call/
-    // warrant events stay discoverable — but honors an explicit override (config.analyticsSessionsDir)
-    // so callers with their own state-dir precedence (serve.ts) don't regress durability when
-    // no AGENTHIPPO_HOME-style env var is set but a durable --state-dir was given explicitly.
-    const sessionEventWriter = new sessionEvents_1.SessionEventWriter(config.analyticsSessionsDir ?? path.join((0, paths_1.getAgentideHome)(), 'analytics', 'sessions'));
-    return {
-        async run(options) {
-            const result = {
-                success: false,
-                text: '',
-                thinking: '',
-                toolCalls: [],
-            };
-            // Create collector emitter if not provided
-            const baseEmitter = options.emitter ?? {
-                async thinking(delta) {
-                    result.thinking += delta;
-                },
-                async text(delta) {
-                    result.text += delta;
-                },
-                async toolStart(toolName, input, _toolCallId) {
-                    result.toolCalls.push({ name: toolName, input });
-                },
-                async toolEnd(toolName, _toolCallId, toolResult, isError) {
-                    const call = result.toolCalls.find(c => c.name === toolName && !c.result);
-                    if (call) {
-                        call.result = toolResult;
-                        call.isError = isError;
-                    }
-                },
-                async progress(_message) {
-                    // Progress messages are logged but not stored
-                    logger.debug(`[Progress] ${_message}`);
-                },
-                async question(payload) {
-                    logger.debug(`[Question] ${payload.prompt}`);
-                    return {
-                        selected: [],
-                        freeText: null,
-                        declined: true,
-                    };
-                },
-                async error(message) {
-                    result.error = message;
-                },
-                async done() {
-                    if (!result.error) {
-                        result.success = true;
-                    }
-                },
-            };
-            // Generate a request ID for this user message → agent response cycle
-            const requestId = (0, base_1.generateRequestId)();
-            // Wrap emitter with observability (Layer 2 session events)
-            // Session events are written to ~/.agent-hippo/analytics/sessions/<session_id>.jsonl
-            // Capture warrant userId here (inside serve's runWithCredential continuation), not
-            // later at tool emit — custom-engine IPC callbacks can lose/stick ambient ALS.
-            const sessionId = options.sessionId ?? `headless-${Date.now()}`;
-            const provenance = config.provenance?.();
-            const observableEmitter = (0, sessionEvents_1.wrapEmitterWithObservability)(baseEmitter, sessionEventWriter, sessionId, requestId, (0, credential_context_1.currentCredential)()?.userId, provenance && {
-                policy_version: provenance.policyVersion,
-                pack_digest: provenance.packDigest,
-                engine_version: provenance.engineVersion,
-                tier: provenance.tier,
-                // Layer 2 must be joinable to an instance ON ITS OWN. Without this the session
-                // lane could only be attributed by going through Layer 1 (the OTEL span), which
-                // defeats the point of self-stamping: with a shared collector spool, the
-                // shipper's INSTANCE_ID cannot know which instance actually ran a turn.
-                instance_id: provenance.instanceId,
-            });
-            const requestOptions = {
-                modelId: options.modelId,
-                engineId: options.engineId,
-                workspaceRoot: options.workspaceRoot,
-                additionalDirectories: options.additionalDirectories,
-                sessionId,
-                analyticsUserId: resolveHeadlessAnalyticsUserId(options.analyticsUserId, config.analyticsUserId),
-                // With split keys (serve), leave options.apiKey UNSET so resolveApiRouting selects
-                // the key for the engine's destination — passing the collapsed key here would let
-                // it win over the correct provider key (the original bug). Back-compat single-key
-                // callers keep options.apiKey.
-                apiKey: hasSplitKeys ? undefined : config.apiKey,
-                baseUrl: config.baseUrl,
-                useLiteLLM: config.useLiteLLM,
-                agentPackId: packId,
-                agentPackVersion: config.packVersion,
-                policyVersion: provenance?.policyVersion,
-                packDigest: provenance?.packDigest,
-                engineVersion: provenance?.engineVersion,
-                tier: provenance?.tier,
-                instanceId: provenance?.instanceId,
-                permissions: options.permissions,
-                requestId, // Same requestId used by ObservableStreamEmitter for Layer 1/2 correlation
-            };
-            // Emit turn_start event
-            await observableEmitter.emitTurnStart();
-            const perRunRuntime = {
-                ...runtimeContext,
-                cliEnvPatch: {
-                    ...(runtimeContext.cliEnvPatch ?? {}),
-                    ...(0, runtime_1.buildSessionEnvPatch)({
-                        workspaceRoot: options.workspaceRoot,
-                        chatSessionId: sessionId,
-                        gatewaySessionKey: options.gatewaySessionKey,
-                    }),
-                    ...(options.turnEnv ?? {}),
-                },
-            };
-            try {
-                const requestedEngine = options.engineId.trim().toLowerCase();
-                if (requestedEngine === 'claude') {
-                    const engine = getClaudeEngine();
-                    await engine.stream(options.message, requestOptions, observableEmitter, perRunRuntime, options.signal);
-                }
-                else if (requestedEngine === 'codex') {
-                    const engine = getCodexEngine();
-                    await engine.stream(options.message, requestOptions, observableEmitter, perRunRuntime, options.signal);
-                }
-                else {
-                    const engine = await getCustomEngine();
-                    await engine.stream(options.message, requestOptions, observableEmitter, perRunRuntime, options.signal);
-                }
-            }
-            catch (e) {
-                result.error = e instanceof Error ? e.message : String(e);
-                result.success = false;
-                // Record error in Layer 2 session events.
-                await observableEmitter.error(result.error);
-            }
-            // Emit turn_end event
-            await observableEmitter.emitTurnEnd(result.success);
-            return result;
-        },
-        dispose() {
-            claudeEngine?.dispose();
-            codexEngine?.dispose();
-            customEngine?.dispose();
-        },
-    };
-}
-// Re-export session initialization for FileSessionStore usage
-var session_2 = require("../session");
-Object.defineProperty(exports, "initSessionStoreWithStore", { enumerable: true, get: function () { return session_2.initSessionStoreWithStore; } });
-// Re-export sync utilities for CLI
-var sync_2 = require("./sync");
-Object.defineProperty(exports, "syncPackToWorkspace", { enumerable: true, get: function () { return sync_2.syncPackToWorkspace; } });
-Object.defineProperty(exports, "computeSkillsSignature", { enumerable: true, get: function () { return sync_2.computeSkillsSignature; } });
-Object.defineProperty(exports, "createSessionDir", { enumerable: true, get: function () { return sync_2.createSessionDir; } });
-Object.defineProperty(exports, "getSessionDir", { enumerable: true, get: function () { return sync_2.getSessionDir; } });
-// Re-export model resolution for CLI
-var models_1 = require("../shared/models");
-Object.defineProperty(exports, "resolveModelAlias", { enumerable: true, get: function () { return models_1.resolveModelAlias; } });
-/**
- * Create a simple eval runner with auto-approve and fresh state.
- * Optimized for running eval examples in isolation.
- *
- * Features:
- * - Fresh session state per instance (no cross-contamination between examples)
- * - Silent logging (NoOpLogger)
- * - Auto-approve all tool executions
- *
- * @param storagePath - Directory for agent state storage
- * @param apiKey - API key for the provider
- * @param baseUrl - Optional custom base URL
- * @returns Headless runner configured for eval mode
- *
- * @example
- * ```typescript
- * import { createEvalRunner } from './headless';
- *
- * const runner = createEvalRunner('/tmp/eval', process.env.ANTHROPIC_API_KEY!);
- *
- * // Run eval examples in isolation
- * for (const example of evalExamples) {
- *   const result = await runner.run({
- *     engineId: 'claude',
- *     modelId: 'claude-sonnet-4-5-20250929',
- *     message: example.prompt,
- *     workspaceRoot: example.workspaceDir,
- *   });
- *
- *   console.log(`Example ${example.id}: ${result.success ? 'PASS' : 'FAIL'}`);
- * }
- *
- * runner.dispose();
- * ```
- */
-function createEvalRunner(storagePath, apiKey, baseUrl) {
-    return createHeadlessRunner({
-        storagePath,
-        apiKey,
-        baseUrl,
-        freshState: true,
-        logger: new interfaces_1.NoOpLogger(), // Silent for eval
-    });
-}
-/**
- * Create a CLI runner with console output.
- *
- * Features:
- * - Console logging with [Agent] prefix
- * - Session persistence (conversations resume across runs)
- * - Auto-approve all tool executions
- *
- * @param storagePath - Directory for agent state storage
- * @param apiKey - API key for the provider
- * @param baseUrl - Optional custom base URL
- * @returns Headless runner configured for CLI use
- *
- * @example
- * ```typescript
- * import * as readline from 'readline/promises';
- * import { createCLIRunner } from './headless';
- *
- * const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
- * const runner = createCLIRunner(`${process.env.HOME}/.agentide`, process.env.ANTHROPIC_API_KEY!);
- *
- * console.log('AgentIDE CLI (type "exit" to quit)\n');
- *
- * while (true) {
- *   const message = await rl.question('> ');
- *   if (message === 'exit') break;
- *
- *   const result = await runner.run({
- *     engineId: 'claude',
- *     modelId: 'claude-sonnet-4-5-20250929',
- *     message,
- *     workspaceRoot: process.cwd(),
- *   });
- *
- *   console.log('\n' + result.text + '\n');
- * }
- *
- * runner.dispose();
- * rl.close();
- * ```
- */
-function createCLIRunner(storagePath, apiKey, baseUrl) {
-    return createHeadlessRunner({
-        storagePath,
-        apiKey,
-        baseUrl,
-        logger: new interfaces_1.ConsoleLogger('[Agent]'),
-    });
-}