@yagni-app/code 1.0.5 → 1.0.7

package/dist/extension/mcp/approval.js

@@ -0,0 +1,164 @@
+/**
+ * Approval gate for project-scope `.mcp.json` servers, mirroring Claude Code's
+ * decision shape: a `.mcp.json` in the repo (shared, VCS-controlled) cannot
+ * spawn processes until the user has approved it. Choices live in the
+ * per-project entry of `~/.yagni-code/mcp.json` under Claude Code's exact key
+ * names (`enabledMcpjsonServers` / `disabledMcpjsonServers` /
+ * `enableAllProjectMcpServers`), so a decision made in one tool is respected
+ * by the other.
+ */
+import { mcpConfigPath, readProjectMcpConfig, readUserMcpConfig, writeUserMcpConfig, } from "./config.js";
+/** Read the approval state for one project (abs path). Missing file/entry → fresh state. */
+export function readProjectApproval(repoRoot) {
+    const { file, errors } = readUserMcpConfig();
+    const entry = (file.projects ?? {})[repoRoot] ?? {};
+    return {
+        state: {
+            enabledMcpjsonServers: entry.enabledMcpjsonServers ?? [],
+            disabledMcpjsonServers: entry.disabledMcpjsonServers ?? [],
+            enableAllProjectMcpServers: entry.enableAllProjectMcpServers ?? false,
+        },
+        errors,
+    };
+}
+/** Effective decision for one project-scope server. Undecided by default. */
+export function decisionFor(state, serverName) {
+    if (state.enableAllProjectMcpServers)
+        return "enabled";
+    if (state.enabledMcpjsonServers.includes(serverName))
+        return "enabled";
+    if (state.disabledMcpjsonServers.includes(serverName))
+        return "disabled";
+    return "undecided";
+}
+/** Which configured project servers await a decision (drives the session-start prompt). */
+export function undecidedProjectServers(state, projectServerNames) {
+    return projectServerNames.filter((name) => decisionFor(state, name) === "undecided");
+}
+/**
+ * Record a decision. `enableAll: true` mirrors Claude Code's "Yes, approve all
+ * project servers in this repo" (sets the blanket flag); a single enable/disable
+ * appends to the corresponding list. Idempotent.
+ */
+export function recordProjectDecision(repoRoot, serverName, decision) {
+    const { file, errors } = readUserMcpConfig();
+    if (errors.length > 0)
+        return { errors };
+    const projects = file.projects ?? {};
+    const entry = projects[repoRoot] ?? {};
+    if (serverName === "all") {
+        if (decision === "enabled") {
+            projects[repoRoot] = { ...entry, enableAllProjectMcpServers: true };
+        }
+        else {
+            // "Disable all" clears the blanket flag and marks every current server
+            // disabled by name (a new server added to .mcp.json later re-prompts).
+            const projectServerNames = currentProjectServerNames(repoRoot);
+            projects[repoRoot] = {
+                ...entry,
+                enableAllProjectMcpServers: false,
+                enabledMcpjsonServers: [],
+                disabledMcpjsonServers: projectServerNames,
+            };
+        }
+    }
+    else {
+        const enabled = new Set(entry.enabledMcpjsonServers ?? []);
+        const disabled = new Set(entry.disabledMcpjsonServers ?? []);
+        if (decision === "enabled") {
+            enabled.add(serverName);
+            disabled.delete(serverName);
+        }
+        else {
+            disabled.add(serverName);
+            enabled.delete(serverName);
+        }
+        projects[repoRoot] = {
+            ...entry,
+            enabledMcpjsonServers: [...enabled],
+            disabledMcpjsonServers: [...disabled],
+        };
+    }
+    file.projects = projects;
+    try {
+        writeUserMcpConfig(file);
+        return { errors: [] };
+    }
+    catch (err) {
+        return {
+            errors: [
+                {
+                    sourcePath: mcpConfigPath(),
+                    message: `could not persist approval decision (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+function currentProjectServerNames(repoRoot) {
+    // Read fresh so a just-edited .mcp.json is reflected in a "disable all" write.
+    return Object.keys(readProjectMcpConfig(repoRoot).servers);
+}
+/** Clear this project's `.mcp.json` decisions (`yagni mcp reset-project-choices`). */
+export function resetProjectChoices(repoRoot) {
+    const { file, errors } = readUserMcpConfig();
+    if (errors.length > 0)
+        return { errors };
+    const projects = file.projects ?? {};
+    const entry = projects[repoRoot] ?? {};
+    delete entry.enabledMcpjsonServers;
+    delete entry.disabledMcpjsonServers;
+    delete entry.enableAllProjectMcpServers;
+    // Keep the entry only if it still carries local servers; otherwise drop it.
+    if (Object.keys(entry).length > 0)
+        projects[repoRoot] = entry;
+    else
+        delete projects[repoRoot];
+    file.projects = projects;
+    try {
+        writeUserMcpConfig(file);
+        return { errors: [] };
+    }
+    catch (err) {
+        return {
+            errors: [
+                {
+                    sourcePath: mcpConfigPath(),
+                    message: `could not reset project choices (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+/**
+ * Mutate `~/.yagni-code/mcp.json`'s per-project entry under a read-modify-write
+ * helper shared with CLI commands (add/remove at local scope).
+ */
+export function updateProjectEntry(repoRoot, mutate) {
+    const { file, errors } = readUserMcpConfig();
+    if (errors.length > 0)
+        return { errors };
+    const projects = file.projects ?? {};
+    const entry = projects[repoRoot] ?? {};
+    mutate(entry);
+    if (Object.keys(entry).length > 0)
+        projects[repoRoot] = entry;
+    else
+        delete projects[repoRoot];
+    file.projects = projects;
+    try {
+        writeUserMcpConfig(file);
+        return { errors: [] };
+    }
+    catch (err) {
+        return {
+            errors: [
+                {
+                    sourcePath: mcpConfigPath(),
+                    message: `could not persist project entry (${err instanceof Error ? err.message : String(err)})`,
+                },
+            ],
+        };
+    }
+}
+//# sourceMappingURL=approval.js.map

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

@@ -0,0 +1,124 @@
+/**
+ * OAuth 2.1 for MCP servers over HTTP/SSE transports, mirroring Claude Code's
+ * flow but keeping it to the application layer: the MCP SDK
+ * (`@modelcontextprotocol/sdk/client/auth.js`) already implements discovery,
+ * DCR, PKCE, token refresh, and the authorization-code exchange. This module
+ * is the glue the SDK needs from us:
+ *
+ *   - `YagniAuthProvider` implements `OAuthClientProvider`: reflects our
+ *     client metadata, persists DCR client info + tokens in the auth store,
+ *     and captures the authorization URL when the SDK redirects.
+ *   - `authenticate()` drives the interactive flow: SDK `auth()` (no code) →
+ *     REDIRECT + authorization URL → open browser → loopback listener on
+ *     127.0.0.1 → validate `state` → SDK `auth()` with the code → AUTHORIZED.
+ *   - `revokeServerTokens()` revokes access + refresh tokens (RFC 7009) when a
+ *     server is removed — refresh first, access second, both best-effort.
+ *
+ * Loopback + redirect semantics follow RFC 8252: bind 127.0.0.1 on a random
+ * high port (or a fixed `oauth.callbackPort`), redirect_uri path `/callback`,
+ * and validate the returned `state` to prevent CSRF.
+ */
+import { type OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
+import type { AuthorizationServerMetadata, OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
+import type { McpHttpServerConfig } from "./config.js";
+export interface AuthDeps {
+    /** Open a URL in the browser; injected for tests, default is a best-effort opener. */
+    openUrl?: (url: string) => Promise<void>;
+    /** Traditional fetch for revocation (SDK auth uses its own fetch). */
+    fetch?: typeof fetch;
+}
+export type OAuthResult = {
+    result: "AUTHORIZED";
+    tokens?: OAuthTokens;
+};
+/** Cancellation via an AbortSignal (Ctrl-C / Esc in the /mcp panel). */
+export declare class AuthenticationCancelledError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Escape a provider-controlled string for interpolation into the loopback
+ * callback page's HTML. Dependency-free equivalent of the `xss` filter Claude
+ * Code applies at this exact spot: `&`, `<`, `>`, quotes → entities.
+ */
+export declare function escapeHtml(value: string): string;
+/** Five-minute loopback wait, matching Claude Code's `Authentication timeout`. */
+export declare const OAuthFlowTimeoutMs: number;
+/**
+ * Wrap the fetch used by an OAuth transport so a failed silent token-refresh
+ * POST is recorded with its HTTP status + OAuth error code — the exact thing
+ * that is otherwise invisible when a cached token's refresh fails at connect
+ * time and the SDK falls through to `REDIRECT`. The response is cloned before
+ * inspection so the SDK's own `parseErrorResponse` still reads the original
+ * body untouched.
+ */
+export declare function instrumentOAuthFetch(serverName: string, baseFetch?: typeof fetch): typeof fetch;
+/** Fallback loopback port for the transport-level (refresh-only) provider. */
+export declare const DEFAULT_REDIRECT_PORT = 42000;
+/**
+ * Build a provider for a server at connect time. The redirect URL is only used
+ * when the SDK needs to (re)authorize; refresh- and access-token paths ignore
+ * it, so a stable default port is fine here. `authenticate()` binds its own
+ * fresh port and builds a dedicated provider for the interactive flow.
+ */
+export declare function authProviderForServer(serverName: string, config: McpHttpServerConfig, redirectUrl?: string): YagniAuthProvider;
+/**
+ * The OAuthClientProvider the SDK drives. One instance per connection; the DCR
+ * client info and tokens persist in the auth store (not in memory) so a
+ * reconnect reads what the previous connection stored.
+ */
+export declare class YagniAuthProvider implements OAuthClientProvider {
+    readonly serverName: string;
+    private config;
+    private redirectUri;
+    private _codeVerifier;
+    private _state;
+    private _authorizationUrl;
+    constructor(serverName: string, config: McpHttpServerConfig, redirectUri: string);
+    get redirectUrl(): string;
+    /** The authorization URL the SDK last asked us to redirect to. */
+    get authorizationUrl(): string | undefined;
+    get clientMetadata(): OAuthClientMetadata;
+    state(): Promise<string>;
+    clientInformation(): Promise<OAuthClientInformationMixed | undefined>;
+    saveClientInformation(info: OAuthClientInformationMixed): Promise<void>;
+    tokens(): Promise<OAuthTokens | undefined>;
+    saveTokens(tokens: OAuthTokens): Promise<void>;
+    saveCodeVerifier(codeVerifier: string): Promise<void>;
+    codeVerifier(): Promise<string>;
+    redirectToAuthorization(authorizationUrl: URL): Promise<void>;
+    invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): Promise<void>;
+}
+export declare function authenticate(serverName: string, config: McpHttpServerConfig, deps?: AuthDeps, opts?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    serverUrl?: string;
+}): Promise<OAuthResult>;
+/** Find a free loopback port (OS-assigned). */
+export declare function findFreePort(): Promise<number>;
+export declare function buildRedirectUri(port: number): string;
+type CodeOutcomeEvent = "oauth_callback_code" | "oauth_callback_error" | "oauth_callback_state_mismatch" | "oauth_timeout" | "oauth_cancelled";
+export interface WaitForCodeOpts {
+    /** Cancel the wait (Ctrl-C / Esc). Resolves with undefined via AuthenticationCancelledError → mapped by caller. */
+    signal?: AbortSignal;
+    /** Loopback wait duration before giving up (Claude Code parity: 5 minutes). */
+    timeoutMs?: number;
+    /** Structured log sink (injected so the helper stays free of the logger). */
+    onEvent?: (event: CodeOutcomeEvent, fields: Record<string, unknown>) => void;
+}
+/**
+ * Revoke access + refresh tokens on the server (RFC 7009) — refresh first,
+ * access second, both best-effort. Public clients put client_id in the body
+ * (no Authorization header); a 401 falls back to Bearer auth for
+ * non-compliant servers (CC parity). Never throws.
+ */
+export declare function revokeServerTokens(serverName: string, config: McpHttpServerConfig, metadata: AuthorizationServerMetadata, clientInfo: OAuthClientInformationMixed, deps?: AuthDeps): Promise<void>;
+/**
+ * Revoke tokens + clear stored credentials for a server being removed. Runs
+ * RFC 9728/8414 discovery to find the revocation endpoint, revokes (refresh →
+ * access, best-effort), then deletes the local auth store entry. Callers use
+ * this so `yagni mcp remove` also logs the server out rather than orphaning
+ * live tokens on disk. Never throws — a failed revoke must not block removal.
+ */
+export declare function revokeTokensOnRemove(serverName: string, config: McpHttpServerConfig, deps?: AuthDeps): Promise<void>;
+export {};
+//# sourceMappingURL=auth.d.ts.map