@agenthippo-ai/agenthippo 0.1.0

package/out/utils/pid.js

@@ -0,0 +1,180 @@
+"use strict";
+/*---------------------------------------------------------------------------------------------
+ *  PID File Utilities
+ *
+ *  Shared utilities for fast process status checks using PID files.
+ *  Cost: ~1-2ms (file read + signal check, no process spawn)
+ *
+ *  Used by:
+ *  - Gateway lifecycle manager (Agent Anywhere)
+ *  - Analytics service (Spotlight)
+ *--------------------------------------------------------------------------------------------*/
+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.isProcessRunning = isProcessRunning;
+exports.isProcessRunningAsync = isProcessRunningAsync;
+exports.isPidFileProcessRunning = isPidFileProcessRunning;
+exports.readPidFile = readPidFile;
+exports.writePidFile = writePidFile;
+exports.removePidFile = removePidFile;
+exports.checkPidFileWithCleanup = checkPidFileWithCleanup;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+/**
+ * Check if a process with the given PID is running.
+ * Uses process.kill(pid, 0) which is synchronous and sub-millisecond.
+ *
+ * Cross-platform behavior:
+ * - Unix: Signal 0 checks if process exists without killing it
+ * - Windows: Returns true if process exists, throws EPERM if exists but no permission,
+ *            throws ESRCH if process doesn't exist
+ */
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        // EPERM = process exists but we don't have permission (Windows)
+        // ESRCH = process doesn't exist
+        const errObj = err;
+        if (errObj?.code === 'EPERM') {
+            return true;
+        }
+        return false;
+    }
+}
+/**
+ * Check if a process with the given PID is running (async wrapper for consistency).
+ */
+async function isProcessRunningAsync(pid) {
+    return isProcessRunning(pid);
+}
+/**
+ * Read a PID file and check if the process is running.
+ * Cost: ~1-2ms (file read + signal check, no process spawn)
+ *
+ * @param pidFile - Path to the PID file
+ * @returns true if the process is running, false otherwise
+ */
+async function isPidFileProcessRunning(pidFile) {
+    try {
+        const pidContent = await fs_1.promises.readFile(pidFile, 'utf8').catch(() => null);
+        if (!pidContent) {
+            return false;
+        }
+        const pid = parseInt(pidContent.trim().split('\n')[0], 10);
+        if (isNaN(pid)) {
+            return false;
+        }
+        return isProcessRunning(pid);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Read and parse a PID file.
+ * Returns null if file doesn't exist or is invalid.
+ *
+ * @param pidFile - Path to the PID file
+ * @returns Parsed PID data or null
+ */
+async function readPidFile(pidFile) {
+    try {
+        const content = await fs_1.promises.readFile(pidFile, 'utf8');
+        const lines = content.trim().split('\n');
+        const pid = parseInt(lines[0], 10);
+        if (isNaN(pid)) {
+            return null;
+        }
+        return {
+            pid,
+            metadata: lines.slice(1),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write a PID file with optional metadata lines.
+ *
+ * @param pidFile - Path to the PID file
+ * @param pid - Process ID to write
+ * @param metadata - Optional additional lines to write (e.g., port, binary path)
+ */
+async function writePidFile(pidFile, pid, ...metadata) {
+    try {
+        const dir = path.dirname(pidFile);
+        await fs_1.promises.mkdir(dir, { recursive: true });
+        const content = [pid, ...metadata].join('\n') + '\n';
+        await fs_1.promises.writeFile(pidFile, content, 'utf8');
+    }
+    catch {
+        // Non-fatal: fast detection just won't work
+    }
+}
+/**
+ * Remove a PID file.
+ *
+ * @param pidFile - Path to the PID file
+ */
+async function removePidFile(pidFile) {
+    try {
+        await fs_1.promises.unlink(pidFile);
+    }
+    catch {
+        // File may not exist
+    }
+}
+/**
+ * Check if PID file exists and process is running; clean up if stale.
+ *
+ * @param pidFile - Path to the PID file
+ * @returns The PID data if process is running, null otherwise
+ */
+async function checkPidFileWithCleanup(pidFile) {
+    const data = await readPidFile(pidFile);
+    if (!data) {
+        return null;
+    }
+    if (!isProcessRunning(data.pid)) {
+        // Stale PID file, clean it up
+        await removePidFile(pidFile);
+        return null;
+    }
+    return data;
+}

package/out/utils/pythonRunner.js

@@ -0,0 +1,258 @@
+"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.runPythonWithDeps = runPythonWithDeps;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+const DEFAULT_MAX_BUFFER = 10 * 1024 * 1024;
+function getDefaultInterpreterCandidates() {
+    return process.platform === 'win32' ? ['python', 'python3'] : ['python3', 'python'];
+}
+function getVenvPythonCandidates(venvDir) {
+    if (process.platform === 'win32') {
+        return [
+            path.join(venvDir, 'Scripts', 'python.exe'),
+            path.join(venvDir, 'Scripts', 'python'),
+        ];
+    }
+    return [
+        path.join(venvDir, 'bin', 'python3'),
+        path.join(venvDir, 'bin', 'python'),
+    ];
+}
+function isMissingExecutable(error) {
+    return Boolean(error?.code === 'ENOENT');
+}
+function hasExitCode(error) {
+    return typeof error?.code === 'number';
+}
+function looksLikeMissingInterpreterText(text, interpreter) {
+    const haystack = text.toLowerCase();
+    const needle = interpreter.toLowerCase();
+    return (haystack.includes('not found') || haystack.includes('no such file'))
+        && haystack.includes(needle);
+}
+function looksLikeMissingInterpreter(error, interpreter) {
+    const failure = error;
+    const stderr = typeof failure?.stderr === 'string' ? failure.stderr.toLowerCase() : '';
+    const message = typeof failure?.message === 'string' ? failure.message.toLowerCase() : '';
+    return looksLikeMissingInterpreterText(`${stderr}\n${message}`, interpreter);
+}
+function looksLikeMissingInterpreterResult(result, interpreter) {
+    return looksLikeMissingInterpreterText(result.stderr, interpreter);
+}
+/**
+ * Detect failures that originate from `uv` itself (interpreter discovery, environment
+ * setup, package resolution) rather than from the script it was asked to run. uv prints
+ * such errors as a line beginning with `error:` and never executes the target script, so
+ * its exit code is meaningless to callers expecting the script's own contract. When this
+ * happens we must fall back to the local venv instead of passing uv's exit code through.
+ *
+ * Example seen on Windows where uv scans an inaccessible system Python install:
+ *   error: failed to open file `C:\ProgramData\miniconda3\Scripts\archspec.exe`: Access is denied. (os error 5)
+ */
+function looksLikeUvOwnFailure(text) {
+    if (!text) {
+        return false;
+    }
+    // uv may colorize its output; strip ANSI escapes before matching.
+    // eslint-disable-next-line no-control-regex
+    const plain = text.replace(/\x1b\[[0-9;]*m/g, '');
+    return /^error:/m.test(plain);
+}
+function extractCommandFailure(error) {
+    return error;
+}
+async function executeCommand(command, args, execOptions, preserveNonZeroExit) {
+    try {
+        const result = await execFileAsync(command, args, {
+            timeout: execOptions.timeout,
+            maxBuffer: execOptions.maxBuffer ?? DEFAULT_MAX_BUFFER,
+            env: execOptions.env,
+            cwd: execOptions.cwd,
+            signal: execOptions.signal,
+        });
+        return {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            code: 0,
+        };
+    }
+    catch (error) {
+        const failure = extractCommandFailure(error);
+        if (preserveNonZeroExit && typeof failure.code === 'number') {
+            return {
+                stdout: typeof failure.stdout === 'string' ? failure.stdout : '',
+                stderr: typeof failure.stderr === 'string' ? failure.stderr : '',
+                code: failure.code,
+            };
+        }
+        throw error;
+    }
+}
+async function tryUvRun(request, interpreters) {
+    const depArgs = request.deps.flatMap(dep => ['--with', dep]);
+    const preserveNonZeroExit = request.preserveNonZeroExit ?? false;
+    let sawUvBinary = false;
+    for (const interpreter of interpreters) {
+        try {
+            sawUvBinary = true;
+            const result = await executeCommand('uv', ['run', ...depArgs, interpreter, request.scriptPath, ...request.args], request.execOptions, preserveNonZeroExit);
+            if (result.code !== 0 && preserveNonZeroExit && looksLikeMissingInterpreterResult(result, interpreter)) {
+                request.log?.(`[Dashboard] uv could not find ${interpreter}; trying next interpreter`);
+                continue;
+            }
+            if (result.code !== 0 && looksLikeUvOwnFailure(result.stderr)) {
+                request.log?.('[Dashboard] uv failed before running the script; falling back to local venv');
+                return undefined;
+            }
+            return result;
+        }
+        catch (error) {
+            if (isMissingExecutable(error)) {
+                request.log?.('[Dashboard] uv not found; falling back to local venv');
+                return undefined;
+            }
+            if (hasExitCode(error) && looksLikeMissingInterpreter(error, interpreter)) {
+                request.log?.(`[Dashboard] uv could not find ${interpreter}; trying next interpreter`);
+                continue;
+            }
+            if (hasExitCode(error) && looksLikeUvOwnFailure(extractCommandFailure(error).stderr)) {
+                request.log?.('[Dashboard] uv failed before running the script; falling back to local venv');
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    if (sawUvBinary) {
+        request.log?.('[Dashboard] uv run failed for available interpreter candidates; falling back to local venv');
+    }
+    return undefined;
+}
+function findExistingVenvPython(venvDir) {
+    const candidates = getVenvPythonCandidates(venvDir);
+    for (const candidate of candidates) {
+        if ((0, fs_1.existsSync)(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+async function ensureVenv(request, venvDir, interpreters) {
+    let venvPython = findExistingVenvPython(venvDir);
+    if (venvPython) {
+        return venvPython;
+    }
+    request.log?.(`[Dashboard] Creating Python venv at ${venvDir}`);
+    let lastError;
+    for (const interpreter of interpreters) {
+        try {
+            await executeCommand(interpreter, ['-m', 'venv', venvDir], {
+                timeout: request.execOptions.timeout,
+                env: request.execOptions.env,
+                cwd: request.execOptions.cwd,
+                signal: request.execOptions.signal,
+            }, false);
+            venvPython = findExistingVenvPython(venvDir);
+            if (venvPython) {
+                return venvPython;
+            }
+        }
+        catch (error) {
+            lastError = error;
+            if (isMissingExecutable(error)) {
+                continue;
+            }
+            throw error;
+        }
+    }
+    if (lastError) {
+        throw lastError;
+    }
+    throw new Error('Unable to create Python virtual environment: no usable interpreter found');
+}
+function toMissingDepsMessage(deps, interpreters) {
+    const missing = deps.length > 0 ? deps.join(', ') : 'required packages';
+    const preferred = interpreters[0] ?? 'python';
+    const installCommand = deps.length > 0
+        ? `${preferred} -m pip install ${deps.join(' ')}`
+        : `${preferred} -m pip install <packages>`;
+    return `Missing Python dependency (${missing}). Install uv (recommended: https://docs.astral.sh/uv/) or run: ${installCommand}`;
+}
+async function runPythonWithDeps(request) {
+    const interpreters = request.interpreterCandidates && request.interpreterCandidates.length > 0
+        ? request.interpreterCandidates
+        : getDefaultInterpreterCandidates();
+    const preserveNonZeroExit = request.preserveNonZeroExit ?? false;
+    const uvResult = await tryUvRun(request, interpreters);
+    if (uvResult) {
+        return uvResult;
+    }
+    const venvDir = path.join(request.analyticsRoot, '.venv');
+    const venvPython = await ensureVenv(request, venvDir, interpreters);
+    try {
+        if (request.deps.length > 0) {
+            const pipArgs = request.requirementsPath && (0, fs_1.existsSync)(request.requirementsPath)
+                ? ['-m', 'pip', 'install', '--quiet', '-r', request.requirementsPath]
+                : ['-m', 'pip', 'install', '--quiet', ...request.deps];
+            await executeCommand(venvPython, pipArgs, {
+                timeout: Math.max(request.execOptions.timeout, 120_000),
+                env: request.execOptions.env,
+                cwd: request.execOptions.cwd,
+                signal: request.execOptions.signal,
+                maxBuffer: request.execOptions.maxBuffer,
+            }, false);
+            request.log?.(`[Dashboard] Python venv deps ready: ${request.deps.join(', ')}`);
+        }
+        return await executeCommand(venvPython, [request.scriptPath, ...request.args], request.execOptions, preserveNonZeroExit);
+    }
+    catch (error) {
+        const failure = extractCommandFailure(error);
+        const errMsg = [
+            typeof failure.message === 'string' ? failure.message : '',
+            typeof failure.stderr === 'string' ? failure.stderr : '',
+        ].join('\n');
+        if (errMsg.includes('ModuleNotFoundError') || errMsg.includes('No module named')) {
+            throw new Error(toMissingDepsMessage(request.deps, interpreters));
+        }
+        throw error;
+    }
+}

package/out/utils/resolveNodeBinary.js

@@ -0,0 +1,168 @@
+"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.getNodeBinaryCandidates = getNodeBinaryCandidates;
+exports.resolveNodeBinary = resolveNodeBinary;
+exports.prependPathDir = prependPathDir;
+/**
+ * Resolve a Node.js binary for custom-engine subprocesses.
+ * Mirrors Agent Anywhere / gateway setup precedence:
+ *   NODE_BIN → gateway install.json nodePath → ~/.agenthippo/tools/node → PATH/common paths → npm_node_execpath (last resort).
+ *
+ * Rationale:
+ * - In IDE hosts (VS Code/Cursor) on Windows, `npm_node_execpath` can point at a bundled helper
+ *   `node.exe` path that is missing or unstable across updates. Treat it as a last resort.
+ * - Prefer a real Node binary (or managed gateway bootstrap node) that is known to spawn reliably.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const binary_1 = require("./binary");
+const IS_WINDOWS = process.platform === 'win32';
+const NODE_FILE = IS_WINDOWS ? 'node.exe' : 'node';
+const GATEWAY_INSTALL_MANIFEST = path.join(os.homedir(), '.agenthippo', 'gateway', 'install.json');
+const BOOTSTRAP_NODE_ROOT = path.join(os.homedir(), '.agenthippo', 'tools', 'node');
+function isExecutable(filePath) {
+    try {
+        const mode = IS_WINDOWS ? fs.constants.F_OK : fs.constants.X_OK;
+        fs.accessSync(filePath, mode);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readGatewayInstallNodePath() {
+    try {
+        if (!fs.existsSync(GATEWAY_INSTALL_MANIFEST)) {
+            return undefined;
+        }
+        const raw = fs.readFileSync(GATEWAY_INSTALL_MANIFEST, 'utf8').replace(/^\uFEFF/, '');
+        const parsed = JSON.parse(raw);
+        const candidate = parsed.nodePath?.trim();
+        return candidate && isExecutable(candidate) ? candidate : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Same scan as setup-gateway.sh: find bootstrap node under .agenthippo/tools/node (newest first). */
+function listBootstrapNodePaths() {
+    if (!fs.existsSync(BOOTSTRAP_NODE_ROOT)) {
+        return [];
+    }
+    const found = [];
+    const scan = (dir, depth) => {
+        if (depth > 4) {
+            return;
+        }
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                scan(full, depth + 1);
+            }
+            else if (entry.isFile() && entry.name === NODE_FILE && dir.endsWith(`${path.sep}bin`)) {
+                found.push(full);
+            }
+        }
+    };
+    scan(BOOTSTRAP_NODE_ROOT, 0);
+    return found.sort().reverse();
+}
+function uniqueExisting(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const candidate of paths) {
+        const normalized = path.resolve(candidate);
+        if (seen.has(normalized) || !isExecutable(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        out.push(normalized);
+    }
+    return out;
+}
+/**
+ * Ordered Node binary candidates (first match wins when passed to pickNodeBinary).
+ */
+function getNodeBinaryCandidates() {
+    const candidates = [];
+    if (process.env.NODE_BIN?.trim()) {
+        candidates.push(process.env.NODE_BIN.trim());
+    }
+    const gatewayNode = readGatewayInstallNodePath();
+    if (gatewayNode) {
+        candidates.push(gatewayNode);
+    }
+    candidates.push(...listBootstrapNodePaths());
+    // npm_node_execpath is frequently set inside Electron-based IDE hosts; treat as a last resort.
+    if (process.env.npm_node_execpath?.trim()) {
+        candidates.push(process.env.npm_node_execpath.trim());
+    }
+    return uniqueExisting(candidates);
+}
+/**
+ * Resolve Node for spawning custom-engine runner. Falls back to PATH via findBinaryCached.
+ */
+async function resolveNodeBinary() {
+    const explicit = getNodeBinaryCandidates();
+    if (explicit.length > 0) {
+        return explicit[0];
+    }
+    const fromPath = await (0, binary_1.findBinaryCached)('node', (0, binary_1.getCommonBinaryPaths)('node'));
+    if (fromPath) {
+        return fromPath;
+    }
+    return 'node';
+}
+/** Prepend the Node binary's bin directory to PATH (for child ripgrep/npm tooling). */
+function prependPathDir(env, dir) {
+    if (!dir?.trim()) {
+        return;
+    }
+    const entry = dir.trim();
+    const current = env.PATH?.trim();
+    env.PATH = current ? `${entry}${path.delimiter}${current}` : entry;
+}

package/out/utils/toolPath.js

@@ -0,0 +1,83 @@
+"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.augmentPathForTools = augmentPathForTools;
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Prepend common tool binary locations to PATH.
+ * When VS Code is launched from the Dock/Finder/Start menu (not a terminal),
+ * it inherits a minimal PATH that often excludes ~/.local/bin, Homebrew, etc.
+ * This ensures uv, python3, pip, and other tools are discoverable.
+ */
+function augmentPathForTools(currentPath) {
+    const home = os.homedir();
+    if (!home) {
+        return currentPath;
+    }
+    const sep = path.delimiter;
+    const extraDirs = getCandidateDirs(home);
+    const existing = new Set(currentPath.split(sep).filter(Boolean));
+    const toAdd = extraDirs.filter(d => d && !existing.has(d));
+    if (toAdd.length === 0) {
+        return currentPath;
+    }
+    return currentPath ? [...toAdd, currentPath].join(sep) : toAdd.join(sep);
+}
+function getCandidateDirs(home) {
+    if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local');
+        const programFiles = process.env.ProgramFiles ?? 'C:\\Program Files';
+        return [
+            path.join(home, '.local', 'bin'), // uv official installer
+            path.join(home, '.cargo', 'bin'), // cargo install
+            path.join(localAppData, 'Microsoft', 'WinGet', 'Links'), // winget shims
+            path.join(localAppData, 'Programs', 'uv'), // uv via some installers
+            path.join(home, 'scoop', 'shims'), // scoop
+            path.join(programFiles, 'uv'),
+        ];
+    }
+    return [
+        path.join(home, '.local', 'bin'), // pip install --user, uv official installer
+        path.join(home, '.cargo', 'bin'), // cargo install
+        path.join(home, '.uv', 'bin'), // uv self-install
+        '/opt/homebrew/bin', // Homebrew (Apple Silicon)
+        '/usr/local/bin', // Homebrew (Intel Mac), system tools
+        '/home/linuxbrew/.linuxbrew/bin', // Linuxbrew
+    ];
+}