@agenthippo-ai/agenthippo 1.110.9 → 1.110.19

package/out/utils.js

@@ -1,968 +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.getAnalyticsScriptsDir = void 0;
-exports.logInfo = logInfo;
-exports.getErrorCode = getErrorCode;
-exports.pathExists = pathExists;
-exports.isDirOrSymlink = isDirOrSymlink;
-exports.ensureRealDirectory = ensureRealDirectory;
-exports.writeFileIfChanged = writeFileIfChanged;
-exports.copyDirRecursive = copyDirRecursive;
-exports.copyDirRecursiveWithTransform = copyDirRecursiveWithTransform;
-exports.symlinkOrCopyFile = symlinkOrCopyFile;
-exports.syncDirByFileLinks = syncDirByFileLinks;
-exports.ensureWorkspaceGitAndGitignore = ensureWorkspaceGitAndGitignore;
-exports.readFileSha256 = readFileSha256;
-exports.getFileStats = getFileStats;
-exports.isCachedHashValid = isCachedHashValid;
-exports.shortSig = shortSig;
-exports.isLocalHttps = isLocalHttps;
-exports.applyLocalTlsBypass = applyLocalTlsBypass;
-exports.getOverrideOpenAIBaseUrl = getOverrideOpenAIBaseUrl;
-exports.inferModelProvider = inferModelProvider;
-exports.resolveApiRouting = resolveApiRouting;
-exports.getExplicitConfigValue = getExplicitConfigValue;
-exports.getAgentideEngineSettings = getAgentideEngineSettings;
-exports.emitStreamEvent = emitStreamEvent;
-exports.createIPCStreamEmitter = createIPCStreamEmitter;
-exports.computeTextDelta = computeTextDelta;
-exports.createDeferred = createDeferred;
-exports.stableAdditionalDirs = stableAdditionalDirs;
-exports.extractFilePaths = extractFilePaths;
-exports.isCreateCommand = isCreateCommand;
-exports.normalizeFileChangeKind = normalizeFileChangeKind;
-exports.isBinaryFile = isBinaryFile;
-const fs_1 = require("fs");
-const child_process_1 = require("child_process");
-const promises_1 = require("stream/promises");
-const util_1 = require("util");
-const path = __importStar(require("path"));
-const crypto = __importStar(require("crypto"));
-const shared_1 = require("./shared");
-const branding_1 = require("./branding");
-const customRegistry_1 = require("./engines/customRegistry");
-const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
-// Lazy-load vscode to allow bundling for CLI/headless mode
-// Use eval to prevent Bun from statically analyzing the require
-let _vscode;
-function getVscode() {
-    if (!_vscode) {
-        try {
-            // eslint-disable-next-line no-eval
-            _vscode = eval('require')('vscode');
-        }
-        catch {
-            throw new Error('vscode module not available. Use ConfigProvider instead of vscode.workspace.getConfiguration');
-        }
-    }
-    return _vscode;
-}
-/** Helper to log a message using whichever method is available */
-function logInfo(logger, msg) {
-    if (logger.appendLine) {
-        logger.appendLine(msg);
-    }
-    else if (logger.info) {
-        logger.info(msg);
-    }
-}
-// -----------------------------------------------------------------------------
-// Error Handling
-// -----------------------------------------------------------------------------
-/**
- * Extract error code from an unknown error object (e.g., Node.js fs errors).
- */
-function getErrorCode(e) {
-    return e && typeof e === 'object' ? e.code : undefined;
-}
-// -----------------------------------------------------------------------------
-// File System Utilities
-// -----------------------------------------------------------------------------
-async function pathExists(targetPath) {
-    try {
-        await fs_1.promises.lstat(targetPath);
-        return true;
-    }
-    catch (e) {
-        if (getErrorCode(e) === 'ENOENT') {
-            return false;
-        }
-        throw e;
-    }
-}
-async function isDirOrSymlink(targetPath) {
-    try {
-        const stat = await fs_1.promises.lstat(targetPath);
-        return stat.isDirectory() || stat.isSymbolicLink();
-    }
-    catch (e) {
-        if (getErrorCode(e) === 'ENOENT') {
-            return false;
-        }
-        throw e;
-    }
-}
-async function ensureRealDirectory(dirPath) {
-    try {
-        const st = await fs_1.promises.lstat(dirPath);
-        if (st.isSymbolicLink() || !st.isDirectory()) {
-            await fs_1.promises.rm(dirPath, { recursive: true, force: true });
-            await fs_1.promises.mkdir(dirPath, { recursive: true });
-        }
-    }
-    catch (e) {
-        if (getErrorCode(e) === 'ENOENT') {
-            await fs_1.promises.mkdir(dirPath, { recursive: true });
-            return;
-        }
-        throw e;
-    }
-}
-async function writeFileIfChanged(targetFile, contents) {
-    try {
-        const existing = await fs_1.promises.readFile(targetFile, 'utf8');
-        if (existing === contents) {
-            return false;
-        }
-    }
-    catch (e) {
-        if (getErrorCode(e) !== 'ENOENT') {
-            throw e;
-        }
-    }
-    await fs_1.promises.mkdir(path.dirname(targetFile), { recursive: true });
-    await fs_1.promises.writeFile(targetFile, contents, 'utf8');
-    return true;
-}
-async function copyDirRecursive(sourceDir, targetDir) {
-    await fs_1.promises.mkdir(targetDir, { recursive: true });
-    const entries = await fs_1.promises.readdir(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const src = path.join(sourceDir, entry.name);
-        const dst = path.join(targetDir, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirRecursive(src, dst);
-        }
-        else if (entry.isFile()) {
-            await fs_1.promises.copyFile(src, dst);
-        }
-        else if (entry.isSymbolicLink()) {
-            // Best-effort: resolve and copy the link target as a file or directory.
-            const resolved = await fs_1.promises.readlink(src);
-            const resolvedAbs = path.isAbsolute(resolved)
-                ? resolved
-                : path.resolve(path.dirname(src), resolved);
-            const stat = await fs_1.promises.stat(resolvedAbs);
-            if (stat.isDirectory()) {
-                await copyDirRecursive(resolvedAbs, dst);
-            }
-            else {
-                await fs_1.promises.copyFile(resolvedAbs, dst);
-            }
-        }
-    }
-}
-/**
- * Copy a directory recursively, applying a text transform to markdown files.
- * Used for bundled skills that may contain branding tokens.
- */
-async function copyDirRecursiveWithTransform(sourceDir, targetDir, transformMd) {
-    await fs_1.promises.mkdir(targetDir, { recursive: true });
-    const entries = await fs_1.promises.readdir(sourceDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const src = path.join(sourceDir, entry.name);
-        const dst = path.join(targetDir, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirRecursiveWithTransform(src, dst, transformMd);
-        }
-        else if (entry.isFile()) {
-            const lowerName = entry.name.toLowerCase();
-            if (lowerName.endsWith('.md')) {
-                // Apply transform to markdown files
-                const content = await fs_1.promises.readFile(src, 'utf8');
-                await fs_1.promises.writeFile(dst, transformMd(content), 'utf8');
-            }
-            else {
-                await fs_1.promises.copyFile(src, dst);
-            }
-        }
-        else if (entry.isSymbolicLink()) {
-            // Best-effort: resolve and copy the link target as a file or directory.
-            const resolved = await fs_1.promises.readlink(src);
-            const resolvedAbs = path.isAbsolute(resolved)
-                ? resolved
-                : path.resolve(path.dirname(src), resolved);
-            const stat = await fs_1.promises.stat(resolvedAbs);
-            if (stat.isDirectory()) {
-                await copyDirRecursiveWithTransform(resolvedAbs, dst, transformMd);
-            }
-            else {
-                const lowerName = entry.name.toLowerCase();
-                if (lowerName.endsWith('.md')) {
-                    const content = await fs_1.promises.readFile(resolvedAbs, 'utf8');
-                    await fs_1.promises.writeFile(dst, transformMd(content), 'utf8');
-                }
-                else {
-                    await fs_1.promises.copyFile(resolvedAbs, dst);
-                }
-            }
-        }
-    }
-}
-/**
- * Create a symlink (or copy as fallback) to a file.
- *
- * @param force - If true, replace any existing file (for derived/managed files).
- *                If false, only replace symlinks pointing elsewhere, never clobber non-symlinks (for user files).
- */
-async function symlinkOrCopyFile(sourceFile, targetFile, logger, label, options) {
-    const force = options?.force ?? false;
-    // Check existing target
-    try {
-        const existing = await fs_1.promises.lstat(targetFile);
-        if (existing.isSymbolicLink()) {
-            // Check if already pointing to correct target
-            try {
-                const current = await fs_1.promises.readlink(targetFile);
-                const currentAbs = path.isAbsolute(current)
-                    ? current
-                    : path.resolve(path.dirname(targetFile), current);
-                if (path.resolve(currentAbs) === path.resolve(sourceFile)) {
-                    return; // Already correct, nothing to do
-                }
-            }
-            catch {
-                // Can't read link, fall through and replace it
-            }
-            await fs_1.promises.unlink(targetFile);
-        }
-        else if (force) {
-            // Force mode: replace any file type
-            await fs_1.promises.rm(targetFile, { recursive: true, force: true });
-        }
-        else {
-            // Preserve mode: don't clobber user-managed non-symlink files
-            return;
-        }
-    }
-    catch (e) {
-        if (getErrorCode(e) !== 'ENOENT') {
-            throw e;
-        }
-        // File doesn't exist, proceed to create
-    }
-    await fs_1.promises.mkdir(path.dirname(targetFile), { recursive: true });
-    if (path.resolve(sourceFile) === path.resolve(targetFile)) {
-        return;
-    }
-    try {
-        await fs_1.promises.symlink(sourceFile, targetFile, 'file');
-        logInfo(logger, `[AgentIDE] Linked ${label} (symlink): ${targetFile} -> ${sourceFile}`);
-    }
-    catch {
-        await fs_1.promises.copyFile(sourceFile, targetFile);
-        logInfo(logger, `[AgentIDE] Linked ${label} (copy fallback): ${targetFile}`);
-    }
-}
-/**
- * Mirror a directory by creating **file symlinks** (with copy fallback) rather than directory symlinks.
- * This avoids Git's "pathspec is beyond a symbolic link" failure mode (which triggers on directory symlinks).
- *
- * Notes:
- * - Hidden entries (starting with ".") are ignored.
- * - Non-symlink files in target that don't exist in source are copied back to source (preserves agent-created content).
- * - Only stale symlinks are removed (symlinks pointing to files no longer in source).
- */
-async function syncDirByFileLinks(sourceDir, targetDir, logger, label) {
-    await ensureRealDirectory(targetDir);
-    const expectedDirs = new Set();
-    const expectedFiles = new Map(); // relPath -> sourceAbs
-    const walk = async (absSrc, rel) => {
-        let entries;
-        try {
-            entries = await fs_1.promises.readdir(absSrc, { withFileTypes: true });
-        }
-        catch (e) {
-            if (getErrorCode(e) === 'ENOENT') {
-                return;
-            }
-            throw e;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith('.')) {
-                continue;
-            }
-            const src = path.join(absSrc, entry.name);
-            const relPath = rel ? path.join(rel, entry.name) : entry.name;
-            if (entry.isDirectory()) {
-                expectedDirs.add(relPath);
-                await walk(src, relPath);
-            }
-            else if (entry.isFile()) {
-                expectedFiles.set(relPath, src);
-            }
-            else if (entry.isSymbolicLink()) {
-                // Best-effort: resolve and mirror the link target.
-                try {
-                    const resolved = await fs_1.promises.readlink(src);
-                    const resolvedAbs = path.isAbsolute(resolved)
-                        ? resolved
-                        : path.resolve(path.dirname(src), resolved);
-                    const stat = await fs_1.promises.stat(resolvedAbs);
-                    if (stat.isDirectory()) {
-                        expectedDirs.add(relPath);
-                        await walk(resolvedAbs, relPath);
-                    }
-                    else {
-                        expectedFiles.set(relPath, resolvedAbs);
-                    }
-                }
-                catch (e) {
-                    const code = getErrorCode(e);
-                    if (code === 'ENOENT' || code === 'ELOOP') {
-                        continue;
-                    }
-                    throw e;
-                }
-            }
-        }
-    };
-    await walk(sourceDir, '');
-    // Ensure all directories exist (parents first).
-    const dirsByDepth = Array.from(expectedDirs).sort((a, b) => a.split(path.sep).length - b.split(path.sep).length);
-    for (const relDir of dirsByDepth) {
-        await ensureRealDirectory(path.join(targetDir, relDir));
-    }
-    // Link files (force overwrite; derived dirs are AgentIDE-managed)
-    for (const [relFile, srcAbs] of expectedFiles.entries()) {
-        await symlinkOrCopyFile(srcAbs, path.join(targetDir, relFile), logger, `${label}/${relFile}`.replace(/\\/g, '/'), { force: true });
-    }
-    // Copy-back: copy non-symlink files from target to source if they don't exist in source.
-    // This preserves agent-created content (scripts, templates, etc.) in the source of truth.
-    const expectedFileSet = new Set(expectedFiles.keys());
-    const copyBack = async (absDst, relDst) => {
-        let entries;
-        try {
-            entries = await fs_1.promises.readdir(absDst, { withFileTypes: true });
-        }
-        catch (e) {
-            if (getErrorCode(e) === 'ENOENT') {
-                return;
-            }
-            throw e;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith('.')) {
-                continue;
-            }
-            const absDstFile = path.join(absDst, entry.name);
-            const relPath = relDst ? path.join(relDst, entry.name) : entry.name;
-            const absSrcFile = path.join(sourceDir, relPath);
-            if (entry.isDirectory()) {
-                await copyBack(absDstFile, relPath);
-            }
-            else if (entry.isFile() && !entry.isSymbolicLink()) {
-                // Real file in target - check if it exists in source
-                if (!expectedFileSet.has(relPath)) {
-                    // File doesn't exist in source - copy it back
-                    try {
-                        await fs_1.promises.mkdir(path.dirname(absSrcFile), { recursive: true });
-                        await fs_1.promises.copyFile(absDstFile, absSrcFile);
-                        logInfo(logger, `[AgentIDE] Copied new file to source: ${label}/${relPath}`.replace(/\\/g, '/'));
-                        // Add to expected files so it becomes a symlink on next sync
-                        expectedFiles.set(relPath, absSrcFile);
-                    }
-                    catch (e) {
-                        logInfo(logger, `[AgentIDE] Warning: failed to copy back ${relPath}: ${e instanceof Error ? e.message : String(e)}`);
-                    }
-                }
-            }
-        }
-    };
-    await copyBack(targetDir, '');
-    // Re-link any files we just copied back (convert them to symlinks)
-    for (const [relFile, srcAbs] of expectedFiles.entries()) {
-        const targetFile = path.join(targetDir, relFile);
-        try {
-            const stat = await fs_1.promises.lstat(targetFile);
-            // If it's a regular file (not symlink), replace with symlink
-            if (stat.isFile() && !stat.isSymbolicLink()) {
-                await fs_1.promises.rm(targetFile, { force: true });
-                await symlinkOrCopyFile(srcAbs, targetFile, logger, `${label}/${relFile}`.replace(/\\/g, '/'), { force: true });
-            }
-        }
-        catch {
-            // File doesn't exist, will be created by the link phase
-        }
-    }
-    // Cleanup: remove unexpected SYMLINK entries in target dir.
-    const cleanup = async (absDst, relDst) => {
-        let entries;
-        try {
-            entries = await fs_1.promises.readdir(absDst, { withFileTypes: true });
-        }
-        catch (e) {
-            if (getErrorCode(e) === 'ENOENT') {
-                return;
-            }
-            throw e;
-        }
-        for (const entry of entries) {
-            if (entry.name.startsWith('.')) {
-                continue;
-            }
-            const abs = path.join(absDst, entry.name);
-            const relPath = relDst ? path.join(relDst, entry.name) : entry.name;
-            if (entry.isDirectory()) {
-                // Recurse into directories to clean up symlinks inside
-                await cleanup(abs, relPath);
-                // Don't remove directories - they may contain user-added files
-            }
-            else if (entry.isSymbolicLink()) {
-                // Only remove symlinks that are no longer expected
-                if (!expectedFileSet.has(relPath)) {
-                    await fs_1.promises.rm(abs, { force: true });
-                }
-            }
-        }
-    };
-    await cleanup(targetDir, '');
-}
-function getManagedWorkspaceDirs(workspaceRoot, extraSearchPath) {
-    const builtins = Object.values(shared_1.AGENT_ENGINES).map(engine => engine.workspaceDir);
-    const custom = (0, customRegistry_1.discoverCustomEngineManifests)(workspaceRoot, extraSearchPath)
-        .filter(manifest => manifest.workspaceSync?.enabled)
-        .map(manifest => manifest.workspaceSync.dir);
-    return [...new Set([...builtins, ...custom])];
-}
-/**
- * Ensure workspace root has git initialized and .gitignore entries for agent directories.
- * If the folder is not a git repository, runs `git init`.
- * Adds managed engine workspace dirs (builtins + custom engines with workspaceSync) to root .gitignore.
- */
-async function ensureWorkspaceGitAndGitignore(workspaceRoot, logger, options) {
-    const gitDir = path.join(workspaceRoot, '.git');
-    // Check if .git exists
-    const gitExists = await pathExists(gitDir);
-    if (!gitExists) {
-        // Initialize git repository
-        try {
-            await execFileAsync('git', ['init'], { cwd: workspaceRoot });
-            logInfo(logger, `[AgentIDE] Initialized git repository in ${workspaceRoot}`);
-        }
-        catch (e) {
-            logInfo(logger, `[AgentIDE] Note: Could not initialize git in ${workspaceRoot}: ${e instanceof Error ? e.message : String(e)}`);
-            // Continue anyway - we still want to create/update .gitignore
-        }
-    }
-    // Ensure root .gitignore has entries for agent directories
-    const rootGitignorePath = path.join(workspaceRoot, '.gitignore');
-    const agentideDirs = getManagedWorkspaceDirs(workspaceRoot, options?.extraSearchPath);
-    const managedBlockLines = [
-        `# ${branding_1.AGENTIDE_BRAND_NAME} (managed)`,
-        `# These directories are managed by ${branding_1.AGENTIDE_BRAND_NAME} and should not be committed.`,
-        ...agentideDirs,
-    ];
-    let existing = '';
-    try {
-        existing = await fs_1.promises.readFile(rootGitignorePath, 'utf8');
-    }
-    catch (e) {
-        if (getErrorCode(e) !== 'ENOENT') {
-            logInfo(logger, `[AgentIDE] Warning: failed to read root .gitignore: ${e instanceof Error ? e.message : String(e)}`);
-            return;
-        }
-    }
-    // Check if all required entries are already present (as standalone lines)
-    const existingLines = existing.split('\n').map(l => l.trim());
-    const missingDirs = agentideDirs.filter(dir => !existingLines.includes(dir));
-    if (missingDirs.length === 0) {
-        return;
-    }
-    // If we have the managed block header but missing some entries, rebuild the block
-    // Otherwise, append the full managed block
-    const managedHeader = `# ${branding_1.AGENTIDE_BRAND_NAME} (managed)`;
-    const legacyHeader = '# AgentIDE (managed)';
-    const hasHeader = existing.includes(managedHeader) || existing.includes(legacyHeader);
-    let next;
-    if (hasHeader) {
-        // Replace the managed block with updated entries
-        // Find the block and replace it
-        const lines = existing.split('\n');
-        const newLines = [];
-        let inManagedBlock = false;
-        for (const line of lines) {
-            if (line.trim() === managedHeader || line.trim() === legacyHeader) {
-                inManagedBlock = true;
-                // Add the new managed block
-                newLines.push(...managedBlockLines);
-                continue;
-            }
-            if (inManagedBlock) {
-                // Skip lines that are part of the managed block (comments or the dirs)
-                if (line.trim().startsWith('#') || agentideDirs.includes(line.trim()) || line.trim() === '') {
-                    continue;
-                }
-                // End of managed block
-                inManagedBlock = false;
-            }
-            newLines.push(line);
-        }
-        next = newLines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
-    }
-    else {
-        // Append the managed block
-        next = [
-            existing.trimEnd(),
-            '',
-            managedBlockLines.join('\n'),
-            '',
-        ].join('\n').replace(/^\n+/, '');
-    }
-    try {
-        const changed = await writeFileIfChanged(rootGitignorePath, next);
-        if (changed) {
-            logInfo(logger, `[AgentIDE] Updated ${rootGitignorePath} to ignore ${branding_1.AGENTIDE_BRAND_NAME} directories`);
-        }
-    }
-    catch (e) {
-        logInfo(logger, `[AgentIDE] Warning: failed to write root .gitignore: ${e instanceof Error ? e.message : String(e)}`);
-    }
-}
-/**
- * Compute SHA256 hash of a file using streaming to avoid loading large files into memory.
- * Returns the hash along with file stats for caching purposes.
- */
-async function readFileSha256(filePath) {
-    const stat = await fs_1.promises.stat(filePath);
-    const hash = crypto.createHash('sha256');
-    await (0, promises_1.pipeline)((0, fs_1.createReadStream)(filePath), hash);
-    return {
-        sha256: hash.digest('hex'),
-        size: stat.size,
-        mtimeMs: stat.mtimeMs,
-    };
-}
-/**
- * Get file stats for mtime caching (fast path check before hashing).
- */
-async function getFileStats(filePath) {
-    try {
-        const stat = await fs_1.promises.stat(filePath);
-        return { size: stat.size, mtimeMs: stat.mtimeMs };
-    }
-    catch (e) {
-        if (getErrorCode(e) === 'ENOENT') {
-            return undefined;
-        }
-        throw e;
-    }
-}
-/**
- * Check if cached file hash is still valid based on mtime and size.
- * If valid, returns the cached entry; otherwise returns undefined to trigger re-hash.
- */
-function isCachedHashValid(cached, currentStats) {
-    if (!cached || !currentStats) {
-        return undefined;
-    }
-    if (cached.mtimeMs === currentStats.mtimeMs && cached.size === currentStats.size) {
-        return cached;
-    }
-    return undefined;
-}
-function shortSig(input) {
-    return crypto.createHash('sha256').update(input).digest('hex').slice(0, 16);
-}
-// -----------------------------------------------------------------------------
-// Environment Utilities
-// -----------------------------------------------------------------------------
-/**
- * Hostnames that are unambiguously this machine. Compared against the PARSED hostname, never a
- * substring of the URL.
- */
-const LOCAL_TLS_HOSTNAMES = new Set(['localhost', '127.0.0.1', '0.0.0.0', '::1', '[::1]']);
-/**
- * Is this URL an HTTPS endpoint on the local machine (a dev LiteLLM/proxy with a self-signed cert)?
- *
- * This used to be `url.includes('localhost')`, which is a substring test on the WHOLE URL — so
- * `https://localhost.attacker.tld/v1` matched, and the caller then disabled TLS verification for
- * the engine child process talking to it. The hostname is parsed and compared exactly now: a
- * registrable domain that merely *contains* "localhost" is a remote host like any other.
- *
- * Note the IPv6 form: `new URL('https://[::1]/').hostname` is `[::1]` (brackets included), so both
- * spellings are in the set.
- */
-function isLocalHttps(url) {
-    if (!url) {
-        return false;
-    }
-    try {
-        const parsed = new URL(url);
-        return parsed.protocol === 'https:' && LOCAL_TLS_HOSTNAMES.has(parsed.hostname.toLowerCase());
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Apply TLS verification bypass for local HTTPS in an environment object.
- * Returns whether TLS verification was disabled.
- *
- * **Residual risk, stated plainly.** `NODE_TLS_REJECT_UNAUTHORIZED=0` is PROCESS-WIDE inside the
- * engine child: it disables certificate verification for every TLS connection that child makes,
- * not just the one to the local proxy. Scoping it per-request is not available to us here — the
- * engines are vendor SDKs (Claude Agent SDK, Codex SDK, arbitrary custom-engine binaries) spawned
- * as separate processes, and the only channel we have into their HTTP stack is the environment.
- * Passing a CA bundle instead (`NODE_EXTRA_CA_CERTS`) would be the real fix and requires the local
- * proxy to publish its cert, which it does not today.
- *
- * What bounds the risk is therefore entirely the check above: the bypass is only ever enabled when
- * the routing endpoint is literally this machine, which is also the only place a self-signed cert
- * is expected. That is why the substring match mattered — it turned an opt-in for `127.0.0.1` into
- * an opt-in for any hostname an attacker could register.
- */
-function applyLocalTlsBypass(env, baseUrl) {
-    if (isLocalHttps(baseUrl)) {
-        env['NODE_TLS_REJECT_UNAUTHORIZED'] = '0';
-        return true;
-    }
-    return false;
-}
-// -----------------------------------------------------------------------------
-// API Routing
-// -----------------------------------------------------------------------------
-/**
- * Get overrideOpenAIBaseUrl for a baseUrl by looking up custom provider config.
- * Uses the provided ConfigProvider or returns undefined (for headless/CLI).
- */
-function getOverrideOpenAIBaseUrl(baseUrl, configProvider) {
-    // If no ConfigProvider, return undefined (no override in headless/CLI mode)
-    if (!configProvider) {
-        return undefined;
-    }
-    const customProviders = configProvider.getCustomProviders();
-    const normalizedInput = baseUrl.replace(/\/$/, '');
-    for (const providerConfig of Object.values(customProviders)) {
-        if (providerConfig.baseUrl) {
-            const normalizedProviderUrl = providerConfig.baseUrl.replace(/\/$/, '');
-            if (normalizedInput === normalizedProviderUrl && providerConfig.overrideOpenAIBaseUrl) {
-                return providerConfig.overrideOpenAIBaseUrl.trim();
-            }
-        }
-    }
-    return undefined;
-}
-/** Infer the direct provider from a model id — used by engines (e.g. custom) that aren't pinned to one vendor. */
-function inferModelProvider(modelId) {
-    return modelId && /claude|anthropic/i.test(modelId) ? 'anthropic' : 'openai';
-}
-/**
- * Resolve the API key + base URL for a turn by the DESTINATION it dials, not a global
- * precedence over provider keys.
- *
- *   - LiteLLM proxy selected (`useLiteLLM`)  → the LiteLLM key.
- *   - direct                                 → the key for THIS engine's provider
- *                                              (codex→openai, claude→anthropic; custom infers
- *                                              from its model). Never the "other" provider's key.
- *
- * An explicit per-request `options.apiKey` (the IDE's single configured key) still wins — the
- * per-provider `creds` are the headless/serve fallback that replaces the old
- * `anthropic || openai` collapse (which sent, e.g., a codex turn to OpenAI with an Anthropic key).
- *
- * @param options - Agent request options (carries an optional explicit apiKey / baseUrl / useLiteLLM)
- * @param creds - Per-destination credentials (EngineConfig satisfies this)
- * @param provider - The engine's direct provider, used only when NOT routing through LiteLLM
- * @param configProvider - Optional config provider for resolving overrideOpenAIBaseUrl
- */
-function resolveApiRouting(options, creds, provider, configProvider) {
-    const useLiteLLM = options.useLiteLLM === true;
-    const baseUrl = options.baseUrl || (useLiteLLM ? creds.litellmBaseUrl : undefined);
-    const directKey = provider === 'anthropic' ? creds.anthropicApiKey : creds.openaiApiKey;
-    const resolvedApiKey = useLiteLLM
-        ? (options.apiKey || creds.litellmApiKey || 'sk-dummy')
-        : (options.apiKey || directKey || '');
-    // For OpenAI-compatible endpoints, check for per-provider overrideOpenAIBaseUrl
-    let openaiBaseUrl = baseUrl;
-    if (baseUrl) {
-        const overrideUrl = getOverrideOpenAIBaseUrl(baseUrl, configProvider);
-        if (overrideUrl) {
-            openaiBaseUrl = overrideUrl;
-        }
-    }
-    return {
-        apiKey: resolvedApiKey,
-        baseUrl,
-        openaiBaseUrl,
-        useLiteLLM,
-    };
-}
-// -----------------------------------------------------------------------------
-// VS Code Configuration
-// -----------------------------------------------------------------------------
-/**
- * Get explicit config value from VS Code configuration.
- * Note: This function requires VS Code runtime.
- */
-function getExplicitConfigValue(config, key) {
-    const inspect = config.inspect(key);
-    if (!inspect) {
-        return undefined;
-    }
-    return (inspect.workspaceFolderValue ?? inspect.workspaceValue ?? inspect.globalValue);
-}
-/**
- * Get engine settings from configuration.
- * Uses the provided ConfigProvider or returns defaults (for headless/CLI).
- */
-function getAgentideEngineSettings(configProvider) {
-    if (configProvider) {
-        return configProvider.getEngineSettings();
-    }
-    // Return defaults when no ConfigProvider (headless/CLI mode)
-    return {
-        claudeMaxThinkingTokens: 0,
-    };
-}
-// -----------------------------------------------------------------------------
-// Stream Emitter Factory
-// -----------------------------------------------------------------------------
-/**
- * Send a stream event to the Workbench via command.
- * The Workbench registers 'agentide.streamCallback' to receive these events.
- */
-async function emitStreamEvent(event) {
-    try {
-        await getVscode().commands.executeCommand('agentide.streamCallback', event);
-    }
-    catch (e) {
-        console.error('[AgentIDE Extension] Failed to emit stream event:', e);
-    }
-}
-/**
- * Create a StreamEmitter for IPC streaming via stream events.
- */
-const STREAM_COALESCE_WINDOW_MS = 40;
-const STREAM_COALESCE_MIN_CHARS = 120;
-function flushCoalescedBuffers(streamId, state) {
-    const emits = [];
-    if (state.markdownBuffer) {
-        emits.push(emitStreamEvent({ streamId, type: 'markdown', data: state.markdownBuffer }));
-        state.markdownBuffer = '';
-    }
-    if (state.thinkingBuffer) {
-        emits.push(emitStreamEvent({ streamId, type: 'thinking', data: state.thinkingBuffer }));
-        state.thinkingBuffer = '';
-    }
-    if (state.flushTimer) {
-        clearTimeout(state.flushTimer);
-        state.flushTimer = undefined;
-    }
-    return Promise.all(emits).then(() => undefined);
-}
-function ensureFlushTimer(streamId, state) {
-    if (state.flushTimer) {
-        return;
-    }
-    state.flushTimer = setTimeout(() => {
-        void flushCoalescedBuffers(streamId, state);
-    }, STREAM_COALESCE_WINDOW_MS);
-}
-function createIPCStreamEmitter(streamId) {
-    const state = {
-        markdownBuffer: '',
-        thinkingBuffer: '',
-        flushTimer: undefined,
-    };
-    return {
-        async thinking(delta) {
-            if (!delta) {
-                return;
-            }
-            state.thinkingBuffer += delta;
-            if (state.thinkingBuffer.length >= STREAM_COALESCE_MIN_CHARS) {
-                await flushCoalescedBuffers(streamId, state);
-                return;
-            }
-            ensureFlushTimer(streamId, state);
-        },
-        async text(delta) {
-            if (!delta) {
-                return;
-            }
-            state.markdownBuffer += delta;
-            if (state.markdownBuffer.length >= STREAM_COALESCE_MIN_CHARS) {
-                await flushCoalescedBuffers(streamId, state);
-                return;
-            }
-            ensureFlushTimer(streamId, state);
-        },
-        async toolStart(toolName, input, toolCallId, metadata) {
-            await flushCoalescedBuffers(streamId, state);
-            await emitStreamEvent({ streamId, type: 'tool_use', toolName, toolCallId, data: input || '', metadata });
-        },
-        async toolEnd(toolName, toolCallId, result, isError, metadata) {
-            await flushCoalescedBuffers(streamId, state);
-            const base = (metadata && typeof metadata === 'object') ? metadata : {};
-            await emitStreamEvent({
-                streamId,
-                type: 'tool_end',
-                toolName,
-                toolCallId,
-                data: result || '',
-                metadata: { ...base, isError }
-            });
-        },
-        async progress(message) {
-            await flushCoalescedBuffers(streamId, state);
-            await emitStreamEvent({ streamId, type: 'progress', data: message });
-        },
-        async question(payload) {
-            await flushCoalescedBuffers(streamId, state);
-            await emitStreamEvent({ streamId, type: 'question', metadata: payload });
-            return {
-                selected: [],
-                freeText: null,
-                declined: true,
-            };
-        },
-        async error(message) {
-            await flushCoalescedBuffers(streamId, state);
-            await emitStreamEvent({ streamId, type: 'error', data: message });
-        },
-        async done() {
-            await flushCoalescedBuffers(streamId, state);
-            await emitStreamEvent({ streamId, type: 'done' });
-        },
-    };
-}
-// -----------------------------------------------------------------------------
-// Text Delta Tracking
-// -----------------------------------------------------------------------------
-/**
- * Helper to compute delta for streaming text (avoids duplicate content).
- * Uses a Map to track last seen text per item ID.
- */
-function computeTextDelta(itemId, newText, tracker) {
-    const prev = tracker.get(itemId) ?? '';
-    const delta = newText.startsWith(prev) ? newText.slice(prev.length) : newText;
-    tracker.set(itemId, newText);
-    return delta;
-}
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-    });
-    return { promise, resolve, reject };
-}
-// -----------------------------------------------------------------------------
-// Stable Helpers
-// -----------------------------------------------------------------------------
-function stableAdditionalDirs(additionalDirectories) {
-    return (additionalDirectories ?? []).slice().filter(Boolean).sort();
-}
-// Re-export from utils/paths for extension convenience
-var paths_1 = require("./utils/paths");
-Object.defineProperty(exports, "getAnalyticsScriptsDir", { enumerable: true, get: function () { return paths_1.getAnalyticsScriptsDir; } });
-// -----------------------------------------------------------------------------
-// Shell Command File Path Extraction (for edit tracking)
-// -----------------------------------------------------------------------------
-const CREATE_CMD_PATTERN = /(?:cat\s*>[^>]|echo\s*>[^>]|touch\s+|>\s*[^>]|<<\s*['"]?EOF)/;
-const EXCLUDED_PREFIXES = ['/tmp/', '/var/', '/dev/'];
-const EXCLUDED_SUFFIXES = ['.tmp', '.bak'];
-/** Extract file paths from shell command. Inclusive approach - better to over-track than miss. */
-function extractFilePaths(command, workspaceRoot) {
-    // Use matchAll with inline regex to avoid shared state issues
-    // Character class includes: whitespace, quotes, backticks, semicolon, pipe, ampersand, parens, equals, and redirects (><)
-    const matches = command.matchAll(/(?:^|[\s'"`;|&()=><])([./]*(?:[\w.\-]+\/)*[\w.\-]+\.[\w]+)(?=[\s'"`;|&()=><]|$)/g);
-    const paths = new Set();
-    for (const m of matches) {
-        const p = m[1].replace(/['"]/g, '').trim();
-        if (!p || p.startsWith('-') || p.includes('..')) {
-            continue;
-        }
-        if (EXCLUDED_PREFIXES.some(x => p.startsWith(x)) || EXCLUDED_SUFFIXES.some(x => p.endsWith(x))) {
-            continue;
-        }
-        paths.add(p.startsWith('/') ? p : `${workspaceRoot}/${p.replace(/^\.\//, '')}`);
-    }
-    return [...paths];
-}
-/** Check if command creates new files (vs modifying existing) */
-function isCreateCommand(cmd) {
-    return CREATE_CMD_PATTERN.test(cmd);
-}
-/**
- * Normalize provider-specific file change kinds to AgentIDE's canonical kinds.
- */
-function normalizeFileChangeKind(kind) {
-    switch (kind) {
-        case 'add':
-        case 'create':
-            return 'create';
-        case 'update':
-        case 'modify':
-            return 'modify';
-        case 'delete':
-            return 'delete';
-        default:
-            return undefined;
-    }
-}
-/** Binary file extensions that should not be tracked for edit diffs (lowercase) */
-const BINARY_EXTENSIONS = new Set([
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-    '.zip', '.tar', '.gz', '.rar', '.7z',
-    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.svg',
-    '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv',
-    '.exe', '.dll', '.so', '.dylib', '.bin',
-    '.woff', '.woff2', '.ttf', '.otf', '.eot',
-    '.pyc', '.class', '.o', '.a',
-]);
-/** Check if file is a binary file (based on extension). Assumes lowercase extensions. */
-function isBinaryFile(filePath) {
-    const dotIdx = filePath.lastIndexOf('.');
-    if (dotIdx === -1) {
-        return false;
-    }
-    return BINARY_EXTENSIONS.has(filePath.slice(dotIdx));
-}