@agenthippo-ai/agenthippo 0.1.0

package/out/cli/runtime.js

@@ -0,0 +1,409 @@
+"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.OPENCLAW_GATEWAY_TOKEN_ENV = exports.AGENTHIPPO_CHAT_SESSION_ID_ENV = exports.AGENTIDE_CHAT_SESSION_ID_ENV = void 0;
+exports.readOpenClawGatewayToken = readOpenClawGatewayToken;
+exports.getBundledToolsHealth = getBundledToolsHealth;
+exports.getCliHealth = getCliHealth;
+exports.buildSessionEnvPatch = buildSessionEnvPatch;
+exports.buildCliEnvPatch = buildCliEnvPatch;
+exports.runCli = runCli;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const branding_1 = require("../branding");
+const outboundPaths_js_1 = require("../gateway/outboundPaths.js");
+const index_1 = require("../utils/index");
+/** VS Code / CLI chat session id exposed to agent shell tools and skills. */
+exports.AGENTIDE_CHAT_SESSION_ID_ENV = 'AGENTIDE_CHAT_SESSION_ID';
+/** Legacy alias used by custom engine subprocesses; kept in sync with {@link AGENTIDE_CHAT_SESSION_ID_ENV}. */
+exports.AGENTHIPPO_CHAT_SESSION_ID_ENV = 'AGENTHIPPO_CHAT_SESSION_ID';
+exports.OPENCLAW_GATEWAY_TOKEN_ENV = 'OPENCLAW_GATEWAY_TOKEN';
+/** Gateway auth token from env or ~/.openclaw/openclaw.json (used by serve and gateway send). */
+function readOpenClawGatewayToken(baseEnv) {
+    const fromEnv = baseEnv?.OPENCLAW_GATEWAY_TOKEN?.trim() || process.env.OPENCLAW_GATEWAY_TOKEN?.trim();
+    if (fromEnv) {
+        return fromEnv;
+    }
+    try {
+        const configPath = path.join(os.homedir(), '.openclaw', 'openclaw.json');
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const token = parsed.gateway?.auth?.token;
+        return typeof token === 'string' ? token.trim() : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const BUNDLED_TOOL_NAMES = ['rg', 'sg', 'tree-sitter'];
+function getPlatformKey(platform = process.platform, arch = process.arch) {
+    if (platform === 'darwin' && arch === 'arm64') {
+        return 'darwin-arm64';
+    }
+    if (platform === 'darwin' && arch === 'x64') {
+        return 'darwin-x64';
+    }
+    if (platform === 'linux' && arch === 'x64') {
+        return 'linux-x64';
+    }
+    if (platform === 'linux' && arch === 'arm64') {
+        return 'linux-arm64';
+    }
+    if (platform === 'win32' && arch === 'x64') {
+        return 'win32-x64';
+    }
+    if (platform === 'win32' && arch === 'arm64') {
+        return 'win32-arm64';
+    }
+    return undefined;
+}
+function getToolExecutableName(tool) {
+    if (process.platform !== 'win32') {
+        return tool;
+    }
+    return `${tool}.exe`;
+}
+function hasBundledToolset(toolsDir) {
+    for (const tool of BUNDLED_TOOL_NAMES) {
+        const toolPath = path.join(toolsDir, getToolExecutableName(tool));
+        try {
+            const mode = process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK;
+            fs.accessSync(toolPath, mode);
+            return true;
+        }
+        catch {
+            // Continue scanning for other known tools.
+        }
+    }
+    return false;
+}
+function getBundledToolsCandidates(extensionPath, binaryDirHint) {
+    const platformKey = getPlatformKey();
+    if (!platformKey) {
+        return [];
+    }
+    const candidates = [];
+    const envPath = process.env.AGENTHIPPO_TOOLS_DIR || process.env.AGENTIDE_TOOLS_DIR;
+    if (envPath?.trim()) {
+        candidates.push(normalizePath(envPath));
+    }
+    if (extensionPath?.trim()) {
+        candidates.push(path.join(extensionPath, 'tools', platformKey));
+    }
+    if (binaryDirHint?.trim()) {
+        candidates.push(path.join(binaryDirHint, 'tools', platformKey));
+    }
+    return candidates;
+}
+function resolveBundledToolsPath(extensionPath, binaryDirHint) {
+    const candidates = getBundledToolsCandidates(extensionPath, binaryDirHint);
+    for (const candidate of candidates) {
+        if (hasBundledToolset(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function getBundledToolsHealth(args = {}) {
+    const platformKey = getPlatformKey();
+    const candidates = getBundledToolsCandidates(args.extensionPath, args.binaryDirHint);
+    const toolsDir = candidates.find(candidate => hasBundledToolset(candidate));
+    const baseDir = toolsDir ?? candidates[0];
+    const tools = BUNDLED_TOOL_NAMES.map(name => {
+        const fallbackDir = baseDir ?? '';
+        const toolPath = path.join(fallbackDir, getToolExecutableName(name));
+        let available = false;
+        if (baseDir) {
+            try {
+                const mode = process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK;
+                fs.accessSync(toolPath, mode);
+                available = true;
+            }
+            catch {
+                available = false;
+            }
+        }
+        return { name, path: toolPath, available };
+    });
+    return {
+        platformKey,
+        toolsDir,
+        tools,
+    };
+}
+function prependPathEntries(existingPath, entries) {
+    const filteredEntries = entries
+        .map(entry => entry.trim())
+        .filter(Boolean);
+    const existingParts = existingPath
+        .split(path.delimiter)
+        .map(part => part.trim())
+        .filter(Boolean);
+    const seen = new Set();
+    const merged = [];
+    for (const value of [...filteredEntries, ...existingParts]) {
+        const key = process.platform === 'win32' ? value.toLowerCase() : value;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        merged.push(value);
+    }
+    return merged.join(path.delimiter);
+}
+function getPathKey(baseEnv) {
+    if (process.platform !== 'win32') {
+        return 'PATH';
+    }
+    if (baseEnv && Object.prototype.hasOwnProperty.call(baseEnv, 'Path')) {
+        return 'Path';
+    }
+    return 'PATH';
+}
+const HEALTH_CACHE_TTL_MS = 30_000;
+let cachedHealth;
+async function isRunnableFile(filePath) {
+    try {
+        const mode = process.platform === 'win32' ? fs.constants.F_OK : fs.constants.X_OK;
+        await fs.promises.access(filePath, mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizePath(candidate) {
+    return candidate.trim().replace(/^"|"$/g, '');
+}
+async function resolveCliPath(opts) {
+    const configured = opts.configuredPath?.trim();
+    if (configured) {
+        const normalized = normalizePath(configured);
+        if (await isRunnableFile(normalized)) {
+            return { path: normalized, source: 'setting' };
+        }
+    }
+    if (opts.extensionPath) {
+        const cliBaseNames = [branding_1.AGENTIDE_CLI_NAME, 'agentide'];
+        const suffixes = process.platform === 'win32'
+            ? ['.cmd', '.exe', '.bat', '']
+            : [''];
+        const candidates = [];
+        for (const baseName of cliBaseNames) {
+            for (const suffix of suffixes) {
+                candidates.push(path.join(opts.extensionPath, 'dist', `${baseName}${suffix}`));
+            }
+        }
+        for (const candidate of candidates) {
+            if (await isRunnableFile(candidate)) {
+                return { path: candidate, source: 'bundled' };
+            }
+        }
+    }
+    if (opts.forceRefresh) {
+        (0, index_1.clearBinaryCache)(branding_1.AGENTIDE_CLI_NAME);
+    }
+    const onPath = await (0, index_1.findBinaryCached)(branding_1.AGENTIDE_CLI_NAME, (0, index_1.getCommonBinaryPaths)(branding_1.AGENTIDE_CLI_NAME));
+    if (onPath) {
+        return { path: onPath, source: 'path' };
+    }
+    return { source: 'not_found' };
+}
+async function readVersion(binaryPath) {
+    try {
+        const result = await runCli(binaryPath, ['--version'], { timeoutMs: 5_000 });
+        if (result.code !== 0) {
+            return undefined;
+        }
+        const firstLine = result.stdout.trim().split(/\r?\n/)[0];
+        return firstLine || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function getCliHealth(options = {}) {
+    const now = Date.now();
+    if (!options.forceRefresh && cachedHealth && now - cachedHealth.lastCheckedAt < HEALTH_CACHE_TTL_MS) {
+        return cachedHealth;
+    }
+    const resolved = await resolveCliPath(options);
+    if (!resolved.path) {
+        cachedHealth = {
+            installed: false,
+            source: 'not_found',
+            lastCheckedAt: now,
+            error: options.configuredPath ? `Configured path not found: ${options.configuredPath}` : undefined,
+        };
+        return cachedHealth;
+    }
+    const version = await readVersion(resolved.path);
+    cachedHealth = {
+        installed: true,
+        path: resolved.path,
+        version,
+        source: resolved.source,
+        lastCheckedAt: now,
+    };
+    return cachedHealth;
+}
+/** Session-scoped env vars for agent subprocesses (chat id, gateway outbound file). */
+function buildSessionEnvPatch(args) {
+    const chatSessionId = args.chatSessionId?.trim();
+    const gatewaySessionKey = args.gatewaySessionKey?.trim();
+    if (!chatSessionId && !gatewaySessionKey) {
+        return {};
+    }
+    const env = {};
+    if (chatSessionId) {
+        env[exports.AGENTIDE_CHAT_SESSION_ID_ENV] = chatSessionId;
+        env[exports.AGENTHIPPO_CHAT_SESSION_ID_ENV] = chatSessionId;
+    }
+    const outboundFile = (0, outboundPaths_js_1.resolveGatewayOutboundFilePath)({
+        workspaceRoot: args.workspaceRoot,
+        gatewaySessionKey,
+        chatSessionId: gatewaySessionKey ? undefined : chatSessionId,
+    });
+    if (outboundFile) {
+        env[outboundPaths_js_1.AGENTHIPPO_GATEWAY_OUTBOUND_FILE_ENV] = outboundFile;
+    }
+    return env;
+}
+function buildCliEnvPatch(args) {
+    const env = {
+        AGENTHIPPO_WORKSPACE_ROOT: args.workspaceRoot,
+        AGENTHIPPO_ACTIVE_AGENT: args.agentId,
+        ...buildSessionEnvPatch({
+            workspaceRoot: args.workspaceRoot,
+            chatSessionId: args.chatSessionId,
+        }),
+    };
+    const gatewayToken = readOpenClawGatewayToken(args.baseEnv);
+    if (gatewayToken) {
+        env[exports.OPENCLAW_GATEWAY_TOKEN_ENV] = gatewayToken;
+    }
+    // Claude SDK refuses nested sessions when CLAUDECODE is present.
+    // Force-unset in child runtime for CLI ask/chat/serve subprocesses.
+    env.CLAUDECODE = '';
+    const pathEntries = [];
+    // User-installed tools (from Command Palette "Install Bundled Tools") take precedence.
+    if (args.userInstalledToolsDir?.trim()) {
+        pathEntries.push(args.userInstalledToolsDir.trim());
+        env.AGENTHIPPO_TOOLS_DIR = args.userInstalledToolsDir.trim();
+        env.AGENTIDE_TOOLS_DIR = args.userInstalledToolsDir.trim();
+    }
+    // Prefer VS Code's bundled ripgrep when running inside the IDE (no need to vendor rg).
+    try {
+        const rg = require('@vscode/ripgrep');
+        if (rg?.rgPath && typeof rg.rgPath === 'string') {
+            pathEntries.push(path.dirname(rg.rgPath));
+        }
+    }
+    catch {
+        // @vscode/ripgrep not available (e.g. standalone CLI); rely on vendored tools or PATH.
+    }
+    if (args.cliPath?.trim()) {
+        const cliPath = args.cliPath.trim();
+        env.AGENTHIPPO_CLI_PATH = cliPath;
+        pathEntries.push(path.dirname(cliPath));
+    }
+    const binaryDirHint = args.cliPath?.trim() ? path.dirname(args.cliPath.trim()) : undefined;
+    const bundledToolsPath = resolveBundledToolsPath(args.extensionPath, binaryDirHint);
+    if (bundledToolsPath && !args.userInstalledToolsDir?.trim()) {
+        env.AGENTHIPPO_TOOLS_DIR = bundledToolsPath;
+        env.AGENTIDE_TOOLS_DIR = bundledToolsPath;
+        pathEntries.push(bundledToolsPath);
+    }
+    else if (bundledToolsPath) {
+        pathEntries.push(bundledToolsPath);
+    }
+    if (pathEntries.length > 0) {
+        const pathKey = getPathKey(args.baseEnv);
+        const currentPath = args.baseEnv?.[pathKey] ?? args.baseEnv?.PATH ?? args.baseEnv?.Path ?? '';
+        env[pathKey] = prependPathEntries(currentPath, pathEntries);
+    }
+    return env;
+}
+async function runCli(binaryPath, args, opts) {
+    return await new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(binaryPath, args, {
+            cwd: opts?.cwd,
+            env: {
+                ...process.env,
+                ...(opts?.env ?? {}),
+            },
+            shell: false,
+        });
+        let stdout = '';
+        let stderr = '';
+        let finished = false;
+        const timeoutMs = opts?.timeoutMs ?? 60_000;
+        const timer = setTimeout(() => {
+            if (!finished) {
+                child.kill();
+                reject(new Error(`CLI command timed out after ${timeoutMs}ms`));
+            }
+        }, timeoutMs);
+        child.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        child.on('error', (error) => {
+            if (!finished) {
+                finished = true;
+                clearTimeout(timer);
+                reject(error);
+            }
+        });
+        child.on('close', (code) => {
+            if (!finished) {
+                finished = true;
+                clearTimeout(timer);
+                resolve({
+                    code: code ?? 1,
+                    stdout,
+                    stderr,
+                });
+            }
+        });
+    });
+}