@fitchmultz/pi-subagents 0.0.0-stage → 0.44.4

package/dist/runs/shared/dynamic-fanout.js

@@ -0,0 +1,274 @@
+import { getSingleResultOutput } from "../../shared/utils.js";
+import { validateStructuredOutputValue } from "./structured-output.js";
+export class DynamicFanoutError extends Error {
+}
+const SAFE_OUTPUT_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ITEM_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const ITEM_REF_PATTERN = /\{([A-Za-z_][A-Za-z0-9_]*)(?:\.([^{}]+))?\}/g;
+const RESERVED_TEMPLATE_NAMES = new Set(["task", "previous", "chain_dir", "outputs"]);
+const DYNAMIC_STEP_KEYS = new Set(["expand", "parallel", "collect", "concurrency", "failFast", "phase", "label", "acceptance"]);
+const RUNNER_DYNAMIC_STEP_KEYS = new Set([...DYNAMIC_STEP_KEYS, "effectiveAcceptance", "sessionFiles"]);
+const DYNAMIC_EXPAND_KEYS = new Set(["from", "item", "key", "maxItems", "onEmpty"]);
+const DYNAMIC_EXPAND_FROM_KEYS = new Set(["output", "path"]);
+const DYNAMIC_PARALLEL_KEYS = new Set(["agent", "task", "phase", "label", "outputSchema", "cwd", "output", "outputMode", "reads", "progress", "skill", "model", "acceptance"]);
+const RUNNER_DYNAMIC_PARALLEL_KEYS = new Set([
+    ...DYNAMIC_PARALLEL_KEYS,
+    "outputName", "structured", "inheritProjectContext", "inheritSkills", "skills", "outputPath", "outputPathFromAgentDefault", "allowSubagents", "maxSubagentDepth",
+    "structuredOutput", "structuredOutputSchema", "tools", "extensions", "mcpDirectTools", "completionGuard", "systemPrompt",
+    "systemPromptMode", "thinking", "modelCandidates", "sessionFile", "effectiveAcceptance", "maxExecutionTimeMs", "maxTokens", "launch",
+]);
+const DYNAMIC_COLLECT_KEYS = new Set(["as", "outputSchema"]);
+export function isSafeOutputName(name) {
+    return SAFE_OUTPUT_NAME_PATTERN.test(name);
+}
+export function assertJsonPointer(pointer, label) {
+    if (pointer === "")
+        return;
+    if (!pointer.startsWith("/")) {
+        throw new DynamicFanoutError(`${label} must be a JSON Pointer starting with '/'.`);
+    }
+    for (const segment of pointer.slice(1).split("/")) {
+        if (/~(?![01])/.test(segment)) {
+            throw new DynamicFanoutError(`${label} contains invalid JSON Pointer escape.`);
+        }
+    }
+}
+function decodePointerSegment(segment) {
+    return segment.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+export function resolveJsonPointer(value, pointer, label) {
+    assertJsonPointer(pointer, label);
+    if (pointer === "")
+        return value;
+    let current = value;
+    for (const rawSegment of pointer.slice(1).split("/")) {
+        const segment = decodePointerSegment(rawSegment);
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9][0-9]*)$/.test(segment)) {
+                throw new DynamicFanoutError(`${label} segment '${segment}' does not address an array index.`);
+            }
+            const index = Number(segment);
+            if (index >= current.length)
+                throw new DynamicFanoutError(`${label} does not exist.`);
+            current = current[index];
+            continue;
+        }
+        if (!current || typeof current !== "object") {
+            throw new DynamicFanoutError(`${label} does not exist.`);
+        }
+        const record = current;
+        if (!Object.prototype.hasOwnProperty.call(record, segment)) {
+            throw new DynamicFanoutError(`${label} does not exist.`);
+        }
+        current = record[segment];
+    }
+    return current;
+}
+function scalarToKey(value, label) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        const key = String(value);
+        if (!key.trim())
+            throw new DynamicFanoutError(`${label} resolved to an empty key.`);
+        if (/[\u0000-\u001F\u007F]/.test(key))
+            throw new DynamicFanoutError(`${label} resolved to an unsafe key.`);
+        if (key.length > 200)
+            throw new DynamicFanoutError(`${label} resolved to a key longer than 200 characters.`);
+        return key;
+    }
+    throw new DynamicFanoutError(`${label} must resolve to a string, number, or boolean.`);
+}
+export function normalizeItemKeyForId(key) {
+    const normalized = key
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 80);
+    return normalized || "item";
+}
+function valueToTemplateText(value, reference) {
+    if (value === undefined)
+        throw new DynamicFanoutError(`Unresolved item reference '${reference}'.`);
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean" || value === null)
+        return String(value);
+    return JSON.stringify(value);
+}
+function resolveItemPath(item, pathText, reference) {
+    if (!pathText)
+        return item;
+    const pointer = `/${pathText.split(".").map((segment) => segment.replace(/~/g, "~0").replace(/\//g, "~1")).join("/")}`;
+    return resolveJsonPointer(item, pointer, reference);
+}
+export function resolveItemTemplate(template, itemName, item) {
+    return template.replace(ITEM_REF_PATTERN, (raw, name, pathText) => {
+        if (name !== itemName)
+            return raw;
+        if (pathText !== undefined && (!pathText.trim() || pathText.includes(".."))) {
+            throw new DynamicFanoutError(`Invalid item reference '${raw}'.`);
+        }
+        return valueToTemplateText(resolveItemPath(item, pathText, raw), raw);
+    });
+}
+function assertOnlyKeys(value, allowed, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new DynamicFanoutError(`${label} must be an object.`);
+    for (const key of Object.keys(value)) {
+        if (!allowed.has(key))
+            throw new DynamicFanoutError(`${label} does not support field '${key}'.`);
+    }
+}
+export function assertNoUnresolvedItemReferences(template, itemName, label) {
+    for (const match of template.matchAll(/\{([^{}]*)\}/g)) {
+        const raw = match[0];
+        const reference = match[1];
+        if (reference === itemName || reference.startsWith(`${itemName}.`)) {
+            if (!ITEM_REF_PATTERN.test(raw) || reference === `${itemName}.` || reference.includes("..")) {
+                throw new DynamicFanoutError(`Invalid item reference '${raw}' in ${label}.`);
+            }
+            ITEM_REF_PATTERN.lastIndex = 0;
+            continue;
+        }
+        ITEM_REF_PATTERN.lastIndex = 0;
+        const name = reference.match(/^[A-Za-z_][A-Za-z0-9_]*/)?.[0];
+        if (name === itemName)
+            throw new DynamicFanoutError(`Invalid item reference '${raw}' in ${label}.`);
+        if (name && RESERVED_TEMPLATE_NAMES.has(name))
+            continue;
+        if (name)
+            throw new DynamicFanoutError(`Unsupported template reference '${raw}' in ${label}.`);
+    }
+    ITEM_REF_PATTERN.lastIndex = 0;
+    if (template.includes(`{${itemName}.}`) || new RegExp(`\\{${itemName}(?:\\.|$)[^}]*$`).test(template)) {
+        throw new DynamicFanoutError(`Invalid item reference in ${label}.`);
+    }
+}
+export function hasDynamicFanoutFields(step) {
+    return !!step && typeof step === "object" && !Array.isArray(step)
+        && (Object.prototype.hasOwnProperty.call(step, "expand") || Object.prototype.hasOwnProperty.call(step, "collect"));
+}
+export function validateDynamicStepShape(step, stepIndex, config = {}) {
+    const prefix = `Dynamic chain step ${stepIndex + 1}`;
+    if (Object.hasOwn(step, "acceptance") || Object.hasOwn(step, "effectiveAcceptance")) {
+        throw new DynamicFanoutError(`Dynamic fanout step ${stepIndex + 1} does not support group-level acceptance; set acceptance on the child template instead.`);
+    }
+    assertOnlyKeys(step, config.allowRunnerFields ? RUNNER_DYNAMIC_STEP_KEYS : DYNAMIC_STEP_KEYS, prefix);
+    if (!step.expand || !step.expand.from)
+        throw new DynamicFanoutError(`${prefix} requires expand.from.`);
+    assertOnlyKeys(step.expand, DYNAMIC_EXPAND_KEYS, `${prefix} expand`);
+    assertOnlyKeys(step.expand.from, DYNAMIC_EXPAND_FROM_KEYS, `${prefix} expand.from`);
+    if (!isSafeOutputName(step.expand.from.output))
+        throw new DynamicFanoutError(`${prefix} has invalid expand.from.output '${step.expand.from.output}'.`);
+    assertJsonPointer(step.expand.from.path, `${prefix} expand.from.path`);
+    if (step.expand.key !== undefined)
+        assertJsonPointer(step.expand.key, `${prefix} expand.key`);
+    const itemName = step.expand.item ?? "item";
+    if (!ITEM_NAME_PATTERN.test(itemName))
+        throw new DynamicFanoutError(`${prefix} has invalid expand.item '${itemName}'.`);
+    if (step.expand.maxItems === undefined && config.maxItems === undefined) {
+        throw new DynamicFanoutError(`${prefix} requires expand.maxItems or config.chain.dynamicFanout.maxItems.`);
+    }
+    if (step.expand.maxItems !== undefined && (!Number.isInteger(step.expand.maxItems) || step.expand.maxItems < 0)) {
+        throw new DynamicFanoutError(`${prefix} expand.maxItems must be an integer >= 0.`);
+    }
+    if (config.maxItems !== undefined && (!Number.isInteger(config.maxItems) || config.maxItems < 0)) {
+        throw new DynamicFanoutError("config.chain.dynamicFanout.maxItems must be an integer >= 0.");
+    }
+    if (!step.parallel || Array.isArray(step.parallel))
+        throw new DynamicFanoutError(`${prefix} requires a single parallel template object and cannot mix dynamic expand/collect with static parallel arrays.`);
+    assertOnlyKeys(step.parallel, config.allowRunnerFields ? RUNNER_DYNAMIC_PARALLEL_KEYS : DYNAMIC_PARALLEL_KEYS, `${prefix} parallel`);
+    if ("expand" in step.parallel)
+        throw new DynamicFanoutError(`${prefix} does not support nested dynamic fanout.`);
+    if (!step.parallel.agent)
+        throw new DynamicFanoutError(`${prefix} parallel.agent is required.`);
+    if (!step.collect?.as || !isSafeOutputName(step.collect.as))
+        throw new DynamicFanoutError(`${prefix} requires collect.as with a safe output name.`);
+    assertOnlyKeys(step.collect, DYNAMIC_COLLECT_KEYS, `${prefix} collect`);
+    for (const [label, template] of [
+        ["parallel.task", step.parallel.task],
+        ["parallel.label", step.parallel.label],
+    ]) {
+        if (template)
+            assertNoUnresolvedItemReferences(template, itemName, `${prefix} ${label}`);
+    }
+}
+export function resolveDynamicFanoutItems(step, outputs, stepIndex, config = {}) {
+    validateDynamicStepShape(step, stepIndex, config);
+    const sourceName = step.expand.from.output;
+    const source = outputs[sourceName];
+    if (!source)
+        throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} references unknown output '${sourceName}'.`);
+    if (source.structured === undefined)
+        throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} requires structured output '${sourceName}'.`);
+    const value = resolveJsonPointer(source.structured, step.expand.from.path, `Dynamic chain step ${stepIndex + 1} expand.from.path`);
+    if (!Array.isArray(value))
+        throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} expand.from.path must resolve to an array.`);
+    const maxItems = step.expand.maxItems ?? config.maxItems;
+    if (maxItems === undefined)
+        throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} requires an effective maxItems.`);
+    if (value.length > maxItems)
+        throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} resolved ${value.length} items, exceeding maxItems ${maxItems}.`);
+    const seen = new Set();
+    const seenIds = new Set();
+    return value.map((item, index) => {
+        const key = step.expand.key === undefined
+            ? String(index)
+            : scalarToKey(resolveJsonPointer(item, step.expand.key, `Dynamic chain step ${stepIndex + 1} expand.key`), `Dynamic chain step ${stepIndex + 1} expand.key`);
+        if (seen.has(key))
+            throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} produced duplicate item key '${key}'.`);
+        seen.add(key);
+        const idKey = normalizeItemKeyForId(key);
+        if (seenIds.has(idKey))
+            throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} produced colliding item id '${idKey}'.`);
+        seenIds.add(idKey);
+        return { index, key, idKey, item };
+    });
+}
+export function materializeDynamicParallelStep(step, outputs, stepIndex, config = {}) {
+    const items = resolveDynamicFanoutItems(step, outputs, stepIndex, config);
+    if (items.length === 0) {
+        if ((step.expand.onEmpty ?? "skip") === "fail") {
+            throw new DynamicFanoutError(`Dynamic chain step ${stepIndex + 1} source array is empty.`);
+        }
+        return { items, parallel: [] };
+    }
+    const itemName = step.expand.item ?? "item";
+    const parallel = items.map((entry) => {
+        const task = resolveItemTemplate(step.parallel.task ?? "{previous}", itemName, entry.item);
+        const label = step.parallel.label ? resolveItemTemplate(step.parallel.label, itemName, entry.item) : undefined;
+        return {
+            ...step.parallel,
+            task,
+            ...(label !== undefined ? { label } : {}),
+        };
+    });
+    return { items, parallel };
+}
+export function collectDynamicResults(step, items, results) {
+    return items.map((entry, index) => {
+        const result = results[index];
+        const text = result
+            ? ("output" in result && typeof result.output === "string" ? result.output : getSingleResultOutput(result))
+            : "";
+        return {
+            key: entry.key,
+            index: entry.index,
+            item: entry.item,
+            agent: result?.agent ?? step.parallel.agent,
+            exitCode: result?.exitCode ?? null,
+            text,
+            ...(result?.structuredOutput !== undefined ? { structured: result.structuredOutput } : {}),
+            ...(result?.error ? { error: result.error } : {}),
+            ...(result?.savedOutputPath ? { outputPath: result.savedOutputPath } : {}),
+            ...(result?.artifactPaths ? { artifactPaths: result.artifactPaths } : {}),
+        };
+    });
+}
+export function validateDynamicCollection(schema, value) {
+    if (!schema)
+        return;
+    const validation = validateStructuredOutputValue(schema, value);
+    if (validation.status === "invalid") {
+        throw new DynamicFanoutError(`Collected output validation failed: ${validation.message}`);
+    }
+}

package/dist/runs/shared/history-index.js

@@ -0,0 +1,72 @@
+import { SubagentHistoryIndex } from "../../history/index.js";
+import { getAgentDir } from "../../shared/utils.js";
+export function closeRunHistory(state) {
+    const index = state.historyIndex;
+    state.historyIndex = undefined;
+    state.historyReady = undefined;
+    state.historyClosing = Promise.all([state.historyClosing, index?.close()]).then(() => { });
+    return state.historyClosing;
+}
+function admitOwner(state, ownerSessionId, ownerSessionFile) {
+    const index = state.historyIndex = new SubagentHistoryIndex(getAgentDir());
+    const snapshot = { ownerSessionId, ownerSessionFile,
+        runs: [...(state.ownedRuns?.values() ?? [])], foregroundRuns: [...(state.foregroundRuns?.values() ?? [])] };
+    state.historyReady = (state.historyClosing ?? Promise.resolve()).then(() => index.setOwner(snapshot));
+    index.onChanged(() => { if (state.historyIndex === index)
+        state.onRunsChanged?.(); });
+    // Retain failed readiness until an explicit retry; background updates must not start a crash loop.
+    void state.historyReady.catch(() => {
+        if (state.historyIndex === index)
+            void index.close();
+    });
+    return index;
+}
+export function startRunHistory(state, ctx) {
+    void closeRunHistory(state).catch((error) => console.error("Could not close subagent history:", error));
+    // Fresh sessions pay no process/database startup cost until they actually browse or own work.
+    if (state.ownedRuns?.size)
+        admitOwner(state, ctx.sessionManager.getSessionId(), ctx.sessionManager.getSessionFile());
+}
+export function updateRunHistory(state, run) {
+    const index = state.historyIndex;
+    if (!index)
+        return;
+    state.historyReady = (state.historyReady ?? Promise.resolve()).then(() => index.updateRun(run, state.foregroundRuns?.get(run.runId)));
+    void state.historyReady.catch(() => {
+        if (state.historyIndex === index)
+            void index.close();
+    });
+}
+function historyOwner(state) {
+    const current = state.lastUiContext?.sessionManager.getSessionId();
+    if (current)
+        return current;
+    // Non-UI callers can hold restored owner handles without an ExtensionContext.
+    // Never infer ownership from a directory or adopt records found by the index.
+    const owners = new Set([...(state.ownedRuns?.values() ?? [])].map((run) => run.ownerSessionId));
+    if (owners.size > 1)
+        throw new Error("History requires one verified owning session.");
+    const owner = owners.values().next().value ?? state.currentSessionId;
+    if (!owner)
+        throw new Error("History requires an active owning session.");
+    return owner;
+}
+export async function runHistoryIndex(state, retry = false) {
+    const ownerSessionId = historyOwner(state);
+    if (retry && state.historyIndex?.failure) {
+        const closing = closeRunHistory(state);
+        await closing;
+        if (state.historyClosing !== closing || historyOwner(state) !== ownerSessionId)
+            throw new Error("Owning session changed while history was loading.");
+    }
+    if (!state.historyIndex) {
+        admitOwner(state, ownerSessionId, state.lastUiContext?.sessionManager.getSessionFile());
+    }
+    const index = state.historyIndex;
+    await state.historyReady;
+    if (state.historyIndex !== index || historyOwner(state) !== ownerSessionId)
+        throw new Error("Owning session changed while history was loading.");
+    if (index.failure)
+        throw index.failure;
+    return index;
+}

package/dist/runs/shared/mcp-direct-tool-allowlist.js

@@ -0,0 +1,334 @@
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentDir } from "../../shared/utils.js";
+const CACHE_VERSION = 1;
+const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
+const GENERIC_GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".config", "mcp", "mcp.json");
+const IMPORT_PATHS = {
+    cursor: [path.join(os.homedir(), ".cursor", "mcp.json")],
+    "claude-code": [
+        path.join(os.homedir(), ".claude", "mcp.json"),
+        path.join(os.homedir(), ".claude.json"),
+        path.join(os.homedir(), ".claude", "claude_desktop_config.json"),
+    ],
+    "claude-desktop": [path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
+    codex: [path.join(os.homedir(), ".codex", "config.json")],
+    windsurf: [path.join(os.homedir(), ".windsurf", "mcp.json")],
+    vscode: [".vscode/mcp.json"],
+};
+export function resolveMcpDirectToolNames(mcpDirectTools, cwd = process.cwd()) {
+    if (!mcpDirectTools?.length)
+        return [];
+    const names = new Set();
+    // Keep pre-v5 and independent Fitch configs paired with their own caches.
+    for (const directory of ["", "fitch-mcp-adapter"]) {
+        try {
+            const config = loadMcpConfig(cwd, directory);
+            const cache = loadMetadataCache(directory);
+            if (!cache)
+                continue;
+            for (const name of resolveDirectToolNames(config, cache, getToolPrefix(config.settings?.toolPrefix), mcpDirectTools)) {
+                names.add(name);
+            }
+        }
+        catch { /* An unavailable adapter does not hide the other adapter's tools. */ }
+    }
+    return [...names];
+}
+function loadMetadataCache(directory) {
+    const cachePath = path.join(getAgentDir(), directory, "mcp-cache.json");
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object")
+        return null;
+    const raw = parsed;
+    if (raw.version !== CACHE_VERSION || !raw.servers || typeof raw.servers !== "object" || Array.isArray(raw.servers)) {
+        return null;
+    }
+    return raw;
+}
+function loadMcpConfig(cwd, directory) {
+    let config = { mcpServers: {} };
+    for (const sourcePath of getConfigPaths(cwd, directory)) {
+        const loaded = readConfig(sourcePath);
+        if (!loaded)
+            continue;
+        config = mergeConfigs(config, expandImports(loaded, cwd));
+    }
+    return config;
+}
+function getConfigPaths(cwd, directory) {
+    const piGlobalPath = path.join(getAgentDir(), directory, "mcp.json");
+    const projectPath = path.resolve(cwd, ".mcp.json");
+    const projectPiPath = path.resolve(cwd, ".pi", directory, "mcp.json");
+    const sources = [];
+    if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath)
+        sources.push(GENERIC_GLOBAL_CONFIG_PATH);
+    sources.push(piGlobalPath);
+    if (projectPath !== piGlobalPath)
+        sources.push(projectPath);
+    if (projectPiPath !== piGlobalPath && projectPiPath !== projectPath)
+        sources.push(projectPiPath);
+    return sources;
+}
+function readConfig(configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+    return validateConfig(parsed);
+}
+function validateConfig(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return { mcpServers: {} };
+    const obj = raw;
+    const servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
+    return {
+        mcpServers: servers && typeof servers === "object" && !Array.isArray(servers) ? servers : {},
+        imports: Array.isArray(obj.imports) ? obj.imports.filter((value) => isImportKind(value)) : undefined,
+        settings: obj.settings && typeof obj.settings === "object" && !Array.isArray(obj.settings)
+            ? obj.settings
+            : undefined,
+    };
+}
+function mergeConfigs(base, next) {
+    const imports = [...(base.imports ?? []), ...(next.imports ?? [])];
+    return {
+        mcpServers: { ...base.mcpServers, ...next.mcpServers },
+        imports: imports.length ? [...new Set(imports)] : undefined,
+        settings: next.settings ? { ...base.settings, ...next.settings } : base.settings,
+    };
+}
+function expandImports(config, cwd) {
+    if (!config.imports?.length)
+        return config;
+    const importedServers = {};
+    for (const importKind of config.imports) {
+        const importPath = resolveImportPath(importKind, cwd);
+        if (!importPath)
+            continue;
+        let imported;
+        try {
+            imported = JSON.parse(fs.readFileSync(importPath, "utf-8"));
+        }
+        catch {
+            continue;
+        }
+        for (const [name, definition] of Object.entries(extractServers(imported, importKind))) {
+            if (!importedServers[name])
+                importedServers[name] = definition;
+        }
+    }
+    return {
+        imports: config.imports,
+        settings: config.settings,
+        mcpServers: { ...importedServers, ...config.mcpServers },
+    };
+}
+function resolveImportPath(importKind, cwd) {
+    for (const candidate of IMPORT_PATHS[importKind]) {
+        const fullPath = candidate.startsWith(".") ? path.resolve(cwd, candidate) : candidate;
+        if (fs.existsSync(fullPath))
+            return fullPath;
+    }
+    return null;
+}
+function extractServers(config, kind) {
+    if (!config || typeof config !== "object" || Array.isArray(config))
+        return {};
+    const obj = config;
+    const servers = kind === "cursor" || kind === "windsurf" || kind === "vscode"
+        ? obj.mcpServers ?? obj["mcp-servers"]
+        : obj.mcpServers;
+    return servers && typeof servers === "object" && !Array.isArray(servers) ? servers : {};
+}
+function resolveDirectToolNames(config, cache, defaultPrefix, envOverride) {
+    const names = [];
+    const seenNames = new Set();
+    const { servers: selectedServers, tools: selectedTools } = parseSelections(envOverride);
+    for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+        if (definition.disabled)
+            continue;
+        const serverCache = cache.servers[serverName];
+        if (!isServerCacheValid(serverCache, definition))
+            continue;
+        const prefix = definition.toolPrefix ?? defaultPrefix;
+        const toolFilter = selectedServers.has(serverName)
+            ? true
+            : selectedTools.get(serverName);
+        if (!toolFilter)
+            continue;
+        for (const tool of Array.isArray(serverCache.tools) ? serverCache.tools : []) {
+            if (typeof tool?.name !== "string" || !tool.name)
+                continue;
+            if (toolFilter !== true && !toolFilter.has(tool.name))
+                continue;
+            if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools))
+                continue;
+            const prefixedName = formatToolName(tool.name, serverName, prefix);
+            if (BUILTIN_TOOL_NAMES.has(prefixedName) || seenNames.has(prefixedName))
+                continue;
+            seenNames.add(prefixedName);
+            names.push(prefixedName);
+        }
+        if (definition.exposeResources === false)
+            continue;
+        for (const resource of Array.isArray(serverCache.resources) ? serverCache.resources : []) {
+            if (typeof resource?.name !== "string" || !resource.name || typeof resource.uri !== "string" || !resource.uri)
+                continue;
+            const baseName = `read_${resourceNameToToolName(resource.name)}`;
+            if (toolFilter !== true && !toolFilter.has(baseName))
+                continue;
+            if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools))
+                continue;
+            const prefixedName = formatToolName(baseName, serverName, prefix);
+            if (BUILTIN_TOOL_NAMES.has(prefixedName) || seenNames.has(prefixedName))
+                continue;
+            seenNames.add(prefixedName);
+            names.push(prefixedName);
+        }
+    }
+    return names;
+}
+function parseSelections(selections) {
+    const servers = new Set();
+    const tools = new Map();
+    for (let item of selections) {
+        item = item.replace(/\/+$/, "");
+        if (item.includes("/")) {
+            const [server, tool] = item.split("/", 2);
+            if (server && tool) {
+                if (!tools.has(server))
+                    tools.set(server, new Set());
+                tools.get(server).add(tool);
+            }
+            else if (server) {
+                servers.add(server);
+            }
+        }
+        else if (item) {
+            servers.add(item);
+        }
+    }
+    return { servers, tools };
+}
+function isServerCacheValid(entry, definition) {
+    if (!entry || entry.configHash !== computeMcpServerHash(definition))
+        return false;
+    if (!entry.cachedAt || typeof entry.cachedAt !== "number")
+        return false;
+    return Date.now() - entry.cachedAt <= CACHE_MAX_AGE_MS;
+}
+function computeMcpServerHash(definition) {
+    const identity = {
+        command: definition.command,
+        args: definition.args,
+        socket: resolveConfigPath(definition.socket),
+        env: interpolateEnvRecord(definition.env),
+        cwd: resolveConfigPath(definition.cwd),
+        url: definition.url ? interpolateEnvVars(definition.url) : definition.url,
+        headers: interpolateEnvRecord(definition.headers),
+        auth: definition.auth,
+        bearerToken: resolveBearerToken(definition),
+        bearerTokenEnv: definition.bearerTokenEnv,
+        exposeResources: definition.exposeResources,
+        includeTools: definition.includeTools,
+        excludeTools: definition.excludeTools,
+    };
+    return createHash("sha256").update(stableStringify(identity)).digest("hex");
+}
+function getToolPrefix(value) {
+    return value === "none" || value === "short" || value === "server" ? value : "server";
+}
+function isImportKind(value) {
+    return typeof value === "string" && Object.hasOwn(IMPORT_PATHS, value);
+}
+function getServerPrefix(serverName, mode) {
+    if (mode === "none")
+        return "";
+    if (mode === "short") {
+        const short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
+        return short || "mcp";
+    }
+    return serverName.replace(/-/g, "_");
+}
+function formatToolName(toolName, serverName, prefix) {
+    const serverPrefix = getServerPrefix(serverName, prefix);
+    return serverPrefix ? `${serverPrefix}_${toolName}` : toolName;
+}
+function isToolExcluded(toolName, serverName, prefix, excludeTools) {
+    if (!Array.isArray(excludeTools) || excludeTools.length === 0)
+        return false;
+    const candidates = new Set([
+        normalizeToolName(toolName),
+        normalizeToolName(formatToolName(toolName, serverName, prefix)),
+        normalizeToolName(formatToolName(toolName, serverName, "server")),
+        normalizeToolName(formatToolName(toolName, serverName, "short")),
+    ]);
+    return excludeTools.some((excluded) => typeof excluded === "string" && candidates.has(normalizeToolName(excluded)));
+}
+function normalizeToolName(value) {
+    return value.replace(/-/g, "_");
+}
+function resourceNameToToolName(name) {
+    let result = name
+        .replace(/[^a-zA-Z0-9]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+/, "")
+        .replace(/_+$/, "")
+        .toLowerCase();
+    if (!result || /^\d/.test(result))
+        result = `resource${result ? `_${result}` : ""}`;
+    return result;
+}
+function interpolateEnvRecord(values) {
+    if (!values || typeof values !== "object" || Array.isArray(values))
+        return undefined;
+    const resolved = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (typeof value === "string")
+            resolved[key] = interpolateEnvVars(value);
+    }
+    return resolved;
+}
+function interpolateEnvVars(value) {
+    return value
+        .replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] ?? "")
+        .replace(/\$env:(\w+)/g, (_, name) => process.env[name] ?? "");
+}
+function resolveConfigPath(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const resolved = interpolateEnvVars(value);
+    if (resolved === "~")
+        return os.homedir();
+    if (resolved.startsWith("~/") || resolved.startsWith("~\\"))
+        return path.join(os.homedir(), resolved.slice(2));
+    return resolved;
+}
+function resolveBearerToken(definition) {
+    if (typeof definition.bearerToken === "string")
+        return interpolateEnvVars(definition.bearerToken);
+    return typeof definition.bearerTokenEnv === "string" ? process.env[definition.bearerTokenEnv] : undefined;
+}
+function stableStringify(value) {
+    if (value === null || value === undefined || typeof value !== "object") {
+        const serialized = JSON.stringify(value);
+        return serialized === undefined ? "undefined" : serialized;
+    }
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    const obj = value;
+    return `{${Object.keys(obj).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`).join(",")}}`;
+}