@yagni-app/code 1.0.4 → 1.0.6

package/dist/extension/mcp/config.js

@@ -0,0 +1,309 @@
+/**
+ * MCP server configuration for YAGNI Code: three scopes, Claude Code-compatible.
+ *
+ *  - project: `.mcp.json` at the repo root — the exact Claude Code schema
+ *    (`{"mcpServers": {...}}`), VCS-shared, approval-gated (see approval.ts).
+ *    A repo configured for Claude Code works here with zero changes.
+ *  - user: top-level `mcpServers` in `~/.yagni-code/mcp.json`.
+ *  - local: `projects[<absPath>].mcpServers` in the same file, keyed by cwd.
+ *
+ * Merge precedence (Claude Code parity): user < project < local — later wins.
+ * Writes are atomic (temp file + rename) so two concurrent sessions can never
+ * interleave into a corrupt config. Validation errors are collected and
+ * surfaced, never fatal: one malformed server entry must not hide the rest.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { codeStateHome } from "../stateHome.js";
+export const PROJECT_CONFIG_FILENAME = ".mcp.json";
+/**
+ * Expand `${VAR}` / `${VAR:-default}` in a config string (Claude Code parity —
+ * .mcp.json files are VCS-shared, so secrets come from the environment).
+ * Missing vars with no default are reported, left in place, and skipped at
+ * connect time so a half-expanded command never spawns.
+ */
+export function expandEnvVarsInString(value, env = process.env) {
+    const missingVars = [];
+    const expanded = value.replace(/\$\{([^}]+)\}/g, (match, varContent) => {
+        const separator = varContent.indexOf(":-");
+        const varName = separator === -1 ? varContent : varContent.slice(0, separator);
+        const defaultValue = separator === -1 ? undefined : varContent.slice(separator + 2);
+        const envValue = env[varName];
+        if (envValue !== undefined)
+            return envValue;
+        if (defaultValue !== undefined)
+            return defaultValue;
+        missingVars.push(varName);
+        return match;
+    });
+    return { expanded, missingVars };
+}
+/** Where env expansion applies within one server config (stdio: command,
+ * args, env values; http/sse: url and header values). */
+export function expandServerEnv(config, env = process.env) {
+    const missingVars = [];
+    if (config.type === "stdio" || config.type === undefined) {
+        const command = expandEnvVarsInString(config.command, env);
+        missingVars.push(...command.missingVars);
+        const args = (config.args ?? []).map((a) => {
+            const r = expandEnvVarsInString(a, env);
+            missingVars.push(...r.missingVars);
+            return r.expanded;
+        });
+        const envValues = {};
+        for (const [k, v] of Object.entries(config.env ?? {})) {
+            const r = expandEnvVarsInString(v, env);
+            missingVars.push(...r.missingVars);
+            envValues[k] = r.expanded;
+        }
+        return {
+            config: { ...config, command: command.expanded, args, env: Object.keys(envValues).length > 0 ? envValues : undefined },
+            missingVars: [...new Set(missingVars)],
+        };
+    }
+    // http/sse: url + header values. Used as a load-time gate (missing vars
+    // → server skipped with a clear error) and at connect time to build the
+    // actual transport. The stored config keeps the raw ${VAR} references —
+    // display and the OAuth auth-store key (sha256 of type+url+headers) must
+    // see the raw form, so env changes never orphan stored tokens.
+    if (config.type === "http" || config.type === "sse") {
+        const url = expandEnvVarsInString(config.url, env);
+        missingVars.push(...url.missingVars);
+        const headerEntries = Object.entries(config.headers ?? {}).map(([k, v]) => {
+            const r = expandEnvVarsInString(v, env);
+            missingVars.push(...r.missingVars);
+            return [k, r.expanded];
+        });
+        return {
+            config: {
+                ...config,
+                url: url.expanded,
+                headers: headerEntries.length > 0 ? Object.fromEntries(headerEntries) : config.headers,
+            },
+            missingVars: [...new Set(missingVars)],
+        };
+    }
+    return { config, missingVars };
+}
+/** Test seam: point the state home at a tmpdir, mirroring errorSink's pattern. */
+let homeOverride = null;
+export function _setMcpHomeForTest(dir) {
+    homeOverride = dir;
+}
+export function mcpConfigPath() {
+    return join(codeStateHome(homeOverride), "mcp.json");
+}
+function projectEntry(file, projectPath) {
+    return (file.projects ?? {})[projectPath] ?? {};
+}
+/** Read + parse `~/.yagni-code/mcp.json`; unreadable/missing → empty with error collected. */
+export function readUserMcpConfig() {
+    const path = mcpConfigPath();
+    if (!existsSync(path))
+        return { file: {}, errors: [] };
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+            return { file: {}, errors: [{ sourcePath: path, message: "not a JSON object at the top level" }] };
+        }
+        return { file: parsed, errors: [] };
+    }
+    catch (err) {
+        return {
+            file: {},
+            errors: [
+                {
+                    sourcePath: path,
+                    message: `could not parse (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+/** Atomic write: temp file in the same directory, then rename over the target. */
+export function writeUserMcpConfig(file) {
+    const path = mcpConfigPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = join(dirname(path), `.${basename(path)}.tmp-${process.pid}`);
+    writeFileSync(tmp, JSON.stringify(file, null, 2) + "\n", "utf-8");
+    renameSync(tmp, path);
+}
+function basename(p) {
+    return p.split(/[\\/]/).filter(Boolean).pop() ?? p;
+}
+/** Read + parse a project `.mcp.json`; missing → empty (not an error). */
+export function readProjectMcpConfig(repoRoot, read = defaultReadFile) {
+    const path = join(repoRoot, PROJECT_CONFIG_FILENAME);
+    let raw;
+    try {
+        raw = read(path);
+    }
+    catch (err) {
+        return {
+            servers: {},
+            errors: [{ sourcePath: path, message: `could not read (${err instanceof Error ? err.message : String(err)})` }],
+        };
+    }
+    if (raw === undefined)
+        return { servers: {}, errors: [] };
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return {
+            servers: {},
+            errors: [{ sourcePath: path, message: `could not parse (${err instanceof Error ? err.message : String(err)})` }],
+        };
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        return { servers: {}, errors: [{ sourcePath: path, message: "not a JSON object at the top level" }] };
+    }
+    const mcpServers = parsed.mcpServers;
+    if (mcpServers !== undefined && (typeof mcpServers !== "object" || mcpServers === null)) {
+        return { servers: {}, errors: [{ sourcePath: path, message: `"mcpServers" must be an object` }] };
+    }
+    const servers = {};
+    const errors = [];
+    for (const [name, value] of Object.entries(mcpServers ?? {})) {
+        const validation = validateServerConfig(value);
+        if (validation.ok)
+            servers[name] = value;
+        else
+            errors.push({ sourcePath: path, serverName: name, message: validation.message });
+    }
+    return { servers, errors };
+}
+function defaultReadFile(path) {
+    return existsSync(path) ? readFileSync(path, "utf-8") : undefined;
+}
+/**
+ * Structural validation of one server entry. Claude Code uses zod; we don't
+ * depend on zod, so this hand-checks the same union: stdio (no type / "stdio",
+ * non-empty command) vs http/sse (type + url).
+ */
+export function validateServerConfig(value) {
+    if (typeof value !== "object" || value === null) {
+        return { ok: false, message: "server entry must be an object" };
+    }
+    const v = value;
+    const type = v["type"];
+    if (type === undefined || type === "stdio") {
+        if (typeof v["command"] !== "string" || v["command"].length === 0) {
+            return { ok: false, message: 'stdio server requires a non-empty "command"' };
+        }
+        if (v["args"] !== undefined && !Array.isArray(v["args"])) {
+            return { ok: false, message: '"args" must be an array of strings' };
+        }
+        return { ok: true };
+    }
+    if (type === "http" || type === "sse") {
+        if (typeof v["url"] !== "string" || v["url"].length === 0) {
+            return { ok: false, message: `${type} server requires a non-empty "url"` };
+        }
+        return { ok: true };
+    }
+    return {
+        ok: false,
+        message: 'unknown "type" — expected "stdio", "http", or "sse" (Claude Code also accepts ws/sdk; YAGNI Code v1 does not)',
+    };
+}
+/**
+ * The repo root for project-scope lookup: the nearest ancestor of `cwd` that
+ * looks like a repo (has `.git`, `.mcp.json`, or is a known project root).
+ * Falls back to cwd itself. CC walks ALL ancestors and merges nearest-wins;
+ * we take the nearest repo boundary — same result for the normal case of one
+ * repo, and it keeps the approval prompt anchored to one file.
+ */
+export function resolveProjectRoot(cwd, exists = defaultExists) {
+    let current = cwd;
+    for (;;) {
+        if (exists(join(current, ".git")) || exists(join(current, PROJECT_CONFIG_FILENAME)))
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return cwd;
+        current = parent;
+    }
+}
+function defaultExists(p) {
+    return existsSync(p);
+}
+/**
+ * Load all three scopes and merge with precedence user < project < local.
+ * Invalid entries are dropped (with errors) rather than failing the load; a
+ * same-name entry in a higher-precedence scope replaces the lower one.
+ * Project servers are returned regardless of approval state — the caller
+ * (session startup, panel, CLI) applies the approval gate via approval.ts.
+ */
+export function loadMcpServers(cwd, env = process.env) {
+    const repoRoot = resolveProjectRoot(cwd);
+    const errors = [];
+    const byScope = { user: [], project: [], local: [] };
+    const { file: userFile, errors: userErrors } = readUserMcpConfig();
+    errors.push(...userErrors);
+    const userServers = userFile.mcpServers ?? {};
+    for (const [name, value] of Object.entries(userServers)) {
+        const validation = validateServerConfig(value);
+        if (validation.ok) {
+            // Gate: a ${VAR} reference with no matching env var (and no default)
+            // skips the server with a clear error, rather than sending a literal
+            // "${VAR}" header on the wire. The pushed config stays raw.
+            const expanded = expandServerEnv(value, env);
+            if (expanded.missingVars.length > 0) {
+                errors.push({
+                    sourcePath: mcpConfigPath(),
+                    serverName: name,
+                    message: `missing environment variable(s): ${expanded.missingVars.join(", ")} — server skipped`,
+                });
+                continue;
+            }
+            byScope.user.push({ name, config: value, scope: "user", sourcePath: mcpConfigPath() });
+        }
+        else {
+            errors.push({ sourcePath: mcpConfigPath(), serverName: name, message: validation.message });
+        }
+    }
+    const projectPath = join(repoRoot, PROJECT_CONFIG_FILENAME);
+    const { servers: projectServers, errors: projectErrors } = readProjectMcpConfig(repoRoot);
+    errors.push(...projectErrors);
+    for (const [name, raw] of Object.entries(projectServers)) {
+        const expanded = expandServerEnv(raw, env);
+        if (expanded.missingVars.length > 0) {
+            errors.push({
+                sourcePath: projectPath,
+                serverName: name,
+                message: `missing environment variable(s): ${expanded.missingVars.join(", ")} — server skipped`,
+            });
+            continue;
+        }
+        byScope.project.push({ name, config: raw, scope: "project", sourcePath: projectPath });
+    }
+    const localEntry = projectEntry(userFile, repoRoot);
+    const localServers = localEntry.mcpServers ?? {};
+    for (const [name, value] of Object.entries(localServers)) {
+        const validation = validateServerConfig(value);
+        if (validation.ok) {
+            const expanded = expandServerEnv(value, env);
+            if (expanded.missingVars.length > 0) {
+                errors.push({
+                    sourcePath: mcpConfigPath(),
+                    serverName: name,
+                    message: `missing environment variable(s): ${expanded.missingVars.join(", ")} — server skipped`,
+                });
+                continue;
+            }
+            byScope.local.push({ name, config: value, scope: "local", sourcePath: mcpConfigPath() });
+        }
+        else {
+            errors.push({ sourcePath: mcpConfigPath(), serverName: name, message: validation.message });
+        }
+    }
+    const merged = new Map();
+    for (const scope of ["user", "project", "local"]) {
+        for (const server of byScope[scope])
+            merged.set(server.name, server);
+    }
+    return { servers: [...merged.values()], errors };
+}
+//# sourceMappingURL=config.js.map

package/dist/extension/mcp/log.d.ts

@@ -0,0 +1,28 @@
+/**
+ * MCP logging primitives shared by session wiring (startup.ts) and the OAuth
+ * flow (auth.ts). Kept as a standalone module so neither import site drags in
+ * the other (startup → manager → auth is already a chain; an auth → startup
+ * edge for the log helper would make it cyclic).
+ *
+ * `appendMcpLogLine` writes the capped/rotated `~/.yagni-code/logs/mcp.log`
+ * (fail-soft — logging never blocks the session or the CLI). The OAuth helpers
+ * here are redaction-first: authorization URLs drop `state` / `nonce` /
+ * `code_challenge` / `code_verifier` / `code`, and error text scrubs any
+ * credential-looking token, so nothing secret reaches the on-disk log.
+ */
+export declare function _setMcpLogHomeForTest(dir: string | null): void;
+/** Fail-soft append with size cap + rotation, mirroring errorSink's pattern. */
+export declare function appendMcpLogLine(line: string): void;
+/**
+ * Redact sensitive OAuth query params from a URL for safe logging (Claude Code
+ * parity — see its `redactSensitiveUrlParams`). Returns the URL unchanged when
+ * it does not parse.
+ */
+export declare function redactSensitiveUrlParams(url: string): string;
+/**
+ * Append one structured MCP event to the log. `fields` are caller-controlled
+ * and expected to already be redacted; only the `server` / `event` / timestamp
+ * are synthesized here.
+ */
+export declare function logMcpEvent(serverName: string, event: string, fields?: Record<string, unknown>): void;
+//# sourceMappingURL=log.d.ts.map

package/dist/extension/mcp/log.js

@@ -0,0 +1,82 @@
+/**
+ * MCP logging primitives shared by session wiring (startup.ts) and the OAuth
+ * flow (auth.ts). Kept as a standalone module so neither import site drags in
+ * the other (startup → manager → auth is already a chain; an auth → startup
+ * edge for the log helper would make it cyclic).
+ *
+ * `appendMcpLogLine` writes the capped/rotated `~/.yagni-code/logs/mcp.log`
+ * (fail-soft — logging never blocks the session or the CLI). The OAuth helpers
+ * here are redaction-first: authorization URLs drop `state` / `nonce` /
+ * `code_challenge` / `code_verifier` / `code`, and error text scrubs any
+ * credential-looking token, so nothing secret reaches the on-disk log.
+ */
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { codeStateHome } from "../stateHome.js";
+const MCP_LOG_MAX_BYTES = 256 * 1024;
+const MCP_LOG_ROTATIONS = 2;
+let mcpLogHomeOverride = null;
+export function _setMcpLogHomeForTest(dir) {
+    mcpLogHomeOverride = dir;
+}
+function mcpLogDir() {
+    return join(codeStateHome(mcpLogHomeOverride), "logs");
+}
+/** Fail-soft append with size cap + rotation, mirroring errorSink's pattern. */
+export function appendMcpLogLine(line) {
+    try {
+        const dir = mcpLogDir();
+        const path = join(dir, "mcp.log");
+        mkdirSync(dir, { recursive: true });
+        try {
+            if (statSync(path).isFile() && statSync(path).size >= MCP_LOG_MAX_BYTES) {
+                for (let i = MCP_LOG_ROTATIONS; i >= 1; i--) {
+                    const from = i === 1 ? path : `${path}.${i - 1}`;
+                    try {
+                        renameSync(from, `${path}.${i}`);
+                    }
+                    catch {
+                        /* absent source — fine */
+                    }
+                }
+            }
+        }
+        catch {
+            /* stat on missing file — fine */
+        }
+        appendFileSync(path, line.endsWith("\n") ? line : line + "\n", "utf8");
+    }
+    catch {
+        // logging must never take the session down
+    }
+}
+/** OAuth query params that must never reach a log line (Claude Code parity). */
+const SENSITIVE_OAUTH_PARAMS = ["state", "nonce", "code_challenge", "code_verifier", "code"];
+/**
+ * Redact sensitive OAuth query params from a URL for safe logging (Claude Code
+ * parity — see its `redactSensitiveUrlParams`). Returns the URL unchanged when
+ * it does not parse.
+ */
+export function redactSensitiveUrlParams(url) {
+    try {
+        const parsed = new URL(url);
+        for (const param of SENSITIVE_OAUTH_PARAMS) {
+            if (parsed.searchParams.has(param)) {
+                parsed.searchParams.set(param, "[REDACTED]");
+            }
+        }
+        return parsed.toString();
+    }
+    catch {
+        return url;
+    }
+}
+/**
+ * Append one structured MCP event to the log. `fields` are caller-controlled
+ * and expected to already be redacted; only the `server` / `event` / timestamp
+ * are synthesized here.
+ */
+export function logMcpEvent(serverName, event, fields = {}) {
+    appendMcpLogLine(JSON.stringify({ ts: new Date().toISOString(), server: serverName, event, ...fields }));
+}
+//# sourceMappingURL=log.js.map

package/dist/extension/mcp/manager.d.ts

@@ -0,0 +1,98 @@
+/**
+ * The MCP manager: owns one live client per configured server, tracks
+ * connection state, and exposes connect/reconnect/disconnect operations used
+ * by both the /mcp panel and session startup. Connection state is what the
+ * panel renders; tool/prompt registration is layered on top by tools.ts /
+ * prompts.ts once a server connects.
+ *
+ * Everything here is fail-soft: a server that fails to connect lands in
+ * `failed` with its error message, never blocking the session or the other
+ * servers. `MCP_TIMEOUT` (connect, ms) and `MCP_TOOL_TIMEOUT` (call, ms) are
+ * honored per Claude Code's env parity.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { McpStdioServerConfig, McpHttpServerConfig, McpScope } from "./config.js";
+import { type AuthDeps } from "./auth.js";
+export type McpServerStatus = "connecting" | "connected" | "failed" | "needs_auth" | "disabled" | "reconnecting";
+export interface ManagedServer {
+    name: string;
+    scope: McpScope;
+    config: McpStdioServerConfig | McpHttpServerConfig;
+    status: McpServerStatus;
+    /** Failure detail for the failed/needs_auth states (panel + logs). */
+    error?: string;
+    client?: Client;
+    transport?: Transport;
+    /** Reconnect attempt count while in `reconnecting`. */
+    reconnectAttempt?: number;
+    connectedAt?: number;
+}
+export interface ManagerEvents {
+    onStateChange?: (server: ManagedServer) => void;
+    /** Structured line for ~/.yagni-code/logs/mcp.log (already sanitized). */
+    onLog?: (line: string) => void;
+}
+export interface ManagerOpts {
+    connectTimeoutMs?: number;
+    events?: ManagerEvents;
+    /** Environment for ${VAR} expansion at connect time (default: process.env). */
+    env?: NodeJS.ProcessEnv;
+}
+export declare function connectTimeoutFromEnv(env: NodeJS.ProcessEnv, fallback?: number): number;
+export declare function toolTimeoutFromEnv(env: NodeJS.ProcessEnv): number | undefined;
+export declare class McpManager {
+    private servers;
+    private events;
+    private connectTimeoutMs;
+    private env;
+    private closed;
+    constructor(opts?: ManagerOpts);
+    list(): ManagedServer[];
+    get(name: string): ManagedServer | undefined;
+    /** Registers a server without connecting (panel listing, kill-switch states). */
+    register(name: string, scope: McpScope, config: McpStdioServerConfig | McpHttpServerConfig, status?: McpServerStatus): ManagedServer;
+    connect(name: string): Promise<ManagedServer | undefined>;
+    disconnect(name: string): Promise<void>;
+    /** Reconnect with bounded attempts, panel-visible progress. */
+    reconnect(name: string, maxAttempts?: number): Promise<ManagedServer | undefined>;
+    /**
+     * Drive the interactive OAuth flow for a `needs_auth` server, then reconnect.
+     * The flow opens a browser and returns once tokens are persisted; a cancelled
+     * or failed flow leaves the server in `needs_auth` and returns its error.
+     * `signal` cancels the loopback wait (Esc / session abort) instead of holding
+     * the command handler for the full 5-minute timeout. `authDeps` is the same
+     * seam `authenticate` takes (openUrl/fetch) so tests drive the real path
+     * without a browser or network.
+     */
+    authenticateServer(name: string, signal?: AbortSignal, authDeps?: AuthDeps): Promise<ManagedServer | undefined>;
+    /** Closes every connected client. Called on session_shutdown (any reason). */
+    closeAll(): Promise<void>;
+    private setStatus;
+}
+export type McpHealthStatus = "connected" | "needs_auth" | "failed";
+export interface McpHealthResult {
+    status: McpHealthStatus;
+    /** Sanitized failure detail for needs_auth/failed. */
+    error?: string;
+}
+/**
+ * One-off health check for a configured server, used by `yagni mcp list` /
+ * `get` and `yagni doctor`. Does NOT mutate manager state: it builds a fresh
+ * transport + client, connect()s against it, classifies the result, and closes
+ * the client. OAuth-capable (http/sse) servers get an auth provider so a fresh
+ * token (or the redirect-required `needs_auth`) is reported faithfully.
+ *
+ * Callers apply the approval gate themselves: a project-scope server that is
+ * undecided/disabled must be reported as such WITHOUT connecting (fail-closed,
+ * never spawn a process the user has not approved), so `probeServer` never
+ * asks about approval — it only ever connects what it is given.
+ */
+export declare function probeServer(name: string, config: McpStdioServerConfig | McpHttpServerConfig, opts?: {
+    connectTimeoutMs?: number;
+    env?: NodeJS.ProcessEnv;
+}): Promise<McpHealthResult>;
+/** 401/403 → needs_auth; everything else → failed. */
+export declare function classifyFailure(message: string): "needs_auth" | "failed";
+export declare function sanitizeError(message: string): string;
+//# sourceMappingURL=manager.d.ts.map