@agenthippo-ai/agenthippo 0.1.0

package/out/gateway/sessionRouting.js

@@ -0,0 +1,77 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) AgentHippo.ai. All rights reserved.
+ *--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeInboundBindLabel = normalizeInboundBindLabel;
+exports.inboundBindLabelsMatch = inboundBindLabelsMatch;
+exports.extractCliBindLabelFromGatewaySessionKey = extractCliBindLabelFromGatewaySessionKey;
+exports.gatewayBaseRouteKey = gatewayBaseRouteKey;
+exports.looksLikeGatewayChannelRouteKey = looksLikeGatewayChannelRouteKey;
+exports.hasCliRouteLabel = hasCliRouteLabel;
+exports.shouldUsePublishedInboundFallback = shouldUsePublishedInboundFallback;
+const bridge_js_1 = require("./bridge.js");
+/**
+ * Map chat title / CLI `--session-id` to one comparable token: trim, lowercase, whitespace → `-`,
+ * collapse repeated hyphens, strip leading/trailing hyphens.
+ */
+function normalizeInboundBindLabel(raw) {
+    let s = raw.trim().toLowerCase().replace(/\s+/g, "-");
+    s = s.replace(/-+/g, "-");
+    s = s.replace(/^-+|-+$/g, "");
+    return s;
+}
+function inboundBindLabelsMatch(a, b) {
+    return normalizeInboundBindLabel(a) === normalizeInboundBindLabel(b);
+}
+/**
+ * CLI `openclaw agent --session-id <label>` becomes gateway key `agent:<agentId>:<label>`.
+ * The `::sid:` suffix is the Pi transcript id, not the CLI label — match the middle segment.
+ */
+function extractCliBindLabelFromGatewaySessionKey(gatewaySessionKey) {
+    const trimmed = gatewaySessionKey.trim();
+    const prefix = "agent:";
+    if (!trimmed.toLowerCase().startsWith(prefix)) {
+        return undefined;
+    }
+    const without = trimmed.slice(prefix.length);
+    const firstColon = without.indexOf(":");
+    if (firstColon < 0) {
+        return undefined;
+    }
+    const rest = without.slice(firstColon + 1).trim();
+    return rest.length > 0 ? rest : undefined;
+}
+function gatewayBaseRouteKey(routeKey) {
+    if (!routeKey) {
+        return undefined;
+    }
+    return routeKey.includes("::sid:")
+        ? routeKey.slice(0, routeKey.lastIndexOf("::sid:"))
+        : routeKey;
+}
+function looksLikeGatewayChannelRouteKey(routeKey) {
+    const baseKey = gatewayBaseRouteKey(routeKey);
+    const label = baseKey ? (extractCliBindLabelFromGatewaySessionKey(baseKey) ?? baseKey) : undefined;
+    const parts = label?.split(":").filter(Boolean) ?? [];
+    if (parts.length < 1) {
+        return false;
+    }
+    return ["channel", "chat", "dm", "group", "thread", "user"].includes(parts[0].trim().toLowerCase());
+}
+function hasCliRouteLabel(routeKey) {
+    const baseKey = gatewayBaseRouteKey(routeKey);
+    return Boolean(baseKey && extractCliBindLabelFromGatewaySessionKey(baseKey));
+}
+/**
+ * Whether an all-inbound published IDE chat should receive this inbound route key as fallback.
+ */
+function shouldUsePublishedInboundFallback(sessionKey, publishedForPeer) {
+    if (publishedForPeer) {
+        return false;
+    }
+    if ((0, bridge_js_1.isIdeThreadCompositeRouteKey)(sessionKey)) {
+        return false;
+    }
+    return !hasCliRouteLabel(sessionKey) || looksLikeGatewayChannelRouteKey(sessionKey);
+}

package/out/headless/index.js

@@ -0,0 +1,505 @@
+"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");
+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')));
+    }
+    // Build engine config
+    const engineConfig = {
+        storagePath: config.storagePath,
+        codexHome: undefined,
+        claudeConfigDir: undefined,
+        litellmApiKey: config.apiKey,
+        litellmBaseUrl: config.baseUrl,
+        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
+    const sessionEventWriter = new sessionEvents_1.SessionEventWriter();
+    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
+            const sessionId = options.sessionId ?? `headless-${Date.now()}`;
+            const observableEmitter = (0, sessionEvents_1.wrapEmitterWithObservability)(baseEmitter, sessionEventWriter, sessionId, requestId);
+            const requestOptions = {
+                modelId: options.modelId,
+                engineId: options.engineId,
+                workspaceRoot: options.workspaceRoot,
+                additionalDirectories: options.additionalDirectories,
+                sessionId,
+                analyticsUserId: resolveHeadlessAnalyticsUserId(options.analyticsUserId, config.analyticsUserId),
+                apiKey: config.apiKey,
+                baseUrl: config.baseUrl,
+                useLiteLLM: config.useLiteLLM,
+                agentPackId: packId,
+                agentPackVersion: config.packVersion,
+                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,
+                    }),
+                },
+            };
+            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]'),
+    });
+}