@yagni-app/code 1.0.5 → 1.0.6

package/dist/extension/mcp/auth.js

@@ -0,0 +1,560 @@
+/**
+ * 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 { createServer } from "node:http";
+import { randomBytes } from "node:crypto";
+import { auth as sdkAuth, discoverOAuthServerInfo } from "@modelcontextprotocol/sdk/client/auth.js";
+import { expandServerEnv } from "./config.js";
+import { runningUnderTest } from "../crashReport.js";
+import { getStoredOAuthEntry, updateStoredOAuthEntry } from "./authStore.js";
+import { deleteStoredOAuthEntry as clearStoredOAuthEntry } from "./authStore.js";
+import { logMcpEvent, redactSensitiveUrlParams } from "./log.js";
+import { renderAuthErrorPage, renderAuthStateMismatchPage, renderAuthSuccessPage, } from "./callbackPage.js";
+/** Cancellation via an AbortSignal (Ctrl-C / Esc in the /mcp panel). */
+export class AuthenticationCancelledError extends Error {
+    constructor(message = "OAuth cancelled") {
+        super(message);
+        this.name = "AuthenticationCancelledError";
+    }
+}
+/**
+ * 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 function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+/** Five-minute loopback wait, matching Claude Code's `Authentication timeout`. */
+export const OAuthFlowTimeoutMs = 5 * 60 * 1000; // exported so tests can shrink it via opts
+/**
+ * Run one bounded sdkAuth phase (discovery+DCR, or the token exchange).
+ *
+ * The deadline and the caller's abort signal both drive ONE AbortController
+ * that is threaded into the SDK as `fetchFn` — so a hung authorization-server
+ * endpoint doesn't just lose the race, its socket is actually closed (an
+ * unbounded fetch would otherwise outlive the flow and leak the handle). On
+ * settle the controller is aborted regardless, as socket hygiene.
+ *
+ * Classification mirrors Claude Code: caller-abort → AuthenticationCancelledError
+ * (swallowed quietly upstream), deadline → `Authentication timeout (<phase>)`,
+ * anything else rethrown as-is.
+ */
+async function sdkAuthPhase(label, provider, args, opts) {
+    const controller = new AbortController();
+    const forward = () => controller.abort();
+    opts.signal?.addEventListener("abort", forward, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort();
+    }, opts.timeoutMs);
+    timer.unref?.();
+    const fetchFn = (input, init) => {
+        const inner = init?.signal;
+        if (!inner)
+            return fetch(input, { ...init, signal: controller.signal });
+        const combo = new AbortController();
+        inner.addEventListener("abort", () => combo.abort(), { once: true });
+        controller.signal.addEventListener("abort", () => combo.abort(), { once: true });
+        return fetch(input, { ...init, signal: combo.signal });
+    };
+    try {
+        return await sdkAuth(provider, { ...args, fetchFn });
+    }
+    catch (err) {
+        if (opts.signal?.aborted)
+            throw new AuthenticationCancelledError();
+        if (timedOut)
+            throw new Error(`Authentication timeout (${label})`);
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+        controller.abort();
+        opts.signal?.removeEventListener("abort", forward);
+    }
+}
+/**
+ * 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 function instrumentOAuthFetch(serverName, baseFetch = fetch) {
+    return async (input, init) => {
+        const response = await baseFetch(input, init);
+        try {
+            const method = (init?.method ?? "GET").toUpperCase();
+            if (method === "POST" && init?.body != null) {
+                const body = typeof init.body === "string" ? init.body : init.body.toString();
+                if (body.includes("grant_type=refresh_token") && !response.ok) {
+                    let errorCode = "unknown";
+                    try {
+                        const text = await response.clone().text();
+                        const m = text.match(/"error"\s*:\s*"([^"]+)"/);
+                        if (m)
+                            errorCode = m[1];
+                    }
+                    catch {
+                        /* body may be empty/unparseable */
+                    }
+                    logMcpEvent(serverName, "oauth_refresh_failed", { httpStatus: response.status, errorCode });
+                }
+            }
+        }
+        catch {
+            // instrumentation must never break the fetch chain
+        }
+        return response;
+    };
+}
+/** Fallback loopback port for the transport-level (refresh-only) provider. */
+export 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 function authProviderForServer(serverName, config, redirectUrl) {
+    const fixed = config.oauth?.callbackPort;
+    const uri = redirectUrl ?? buildRedirectUri(fixed ?? DEFAULT_REDIRECT_PORT);
+    return new YagniAuthProvider(serverName, config, uri);
+}
+/**
+ * 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 class YagniAuthProvider {
+    serverName;
+    config;
+    redirectUri;
+    _codeVerifier;
+    _state;
+    _authorizationUrl;
+    constructor(serverName, config, redirectUri) {
+        this.serverName = serverName;
+        this.config = config;
+        this.redirectUri = redirectUri;
+    }
+    get redirectUrl() {
+        return this.redirectUri;
+    }
+    /** The authorization URL the SDK last asked us to redirect to. */
+    get authorizationUrl() {
+        return this._authorizationUrl;
+    }
+    get clientMetadata() {
+        return {
+            client_name: `YAGNI Code (${this.serverName})`,
+            redirect_uris: [this.redirectUri],
+            grant_types: ["authorization_code", "refresh_token"],
+            response_types: ["code"],
+            token_endpoint_auth_method: "none",
+        };
+    }
+    async state() {
+        this._state ??= randomBytes(32).toString("base64url");
+        return this._state;
+    }
+    async clientInformation() {
+        const entry = getStoredOAuthEntry(this.serverName, this.config);
+        if (!entry?.clientId)
+            return undefined;
+        return {
+            client_id: entry.clientId,
+            ...(entry.clientSecret ? { client_secret: entry.clientSecret } : {}),
+        };
+    }
+    async saveClientInformation(info) {
+        updateStoredOAuthEntry(this.serverName, this.config, (entry) => {
+            entry.clientId = info.client_id;
+            if (info.client_secret != null)
+                entry.clientSecret = info.client_secret;
+        });
+    }
+    async tokens() {
+        const entry = getStoredOAuthEntry(this.serverName, this.config);
+        if (!entry?.accessToken)
+            return undefined;
+        const expiresIn = entry.expiresAt ? Math.max(1, Math.floor((entry.expiresAt - Date.now()) / 1000)) : undefined;
+        return {
+            access_token: entry.accessToken,
+            token_type: "Bearer",
+            ...(entry.refreshToken ? { refresh_token: entry.refreshToken } : {}),
+            ...(expiresIn != null ? { expires_in: expiresIn } : {}),
+            ...(entry.scopes ? { scope: entry.scopes.join(" ") } : {}),
+        };
+    }
+    async saveTokens(tokens) {
+        const expiresIn = typeof tokens.expires_in === "number" ? tokens.expires_in : 3600;
+        updateStoredOAuthEntry(this.serverName, this.config, (entry) => {
+            entry.accessToken = tokens.access_token;
+            if (tokens.refresh_token)
+                entry.refreshToken = tokens.refresh_token;
+            entry.expiresAt = Date.now() + expiresIn * 1000;
+            if (tokens.scope)
+                entry.scopes = tokens.scope.split(/\s+/).filter(Boolean);
+        });
+    }
+    async saveCodeVerifier(codeVerifier) {
+        this._codeVerifier = codeVerifier;
+    }
+    async codeVerifier() {
+        if (!this._codeVerifier)
+            throw new Error("No PKCE code verifier stored for this session");
+        return this._codeVerifier;
+    }
+    async redirectToAuthorization(authorizationUrl) {
+        this._authorizationUrl = authorizationUrl.toString();
+        logMcpEvent(this.serverName, "oauth_redirect", {
+            authorizationUrl: redactSensitiveUrlParams(this._authorizationUrl),
+            scope: authorizationUrl.searchParams.get("scope") ?? undefined,
+        });
+    }
+    async invalidateCredentials(scope) {
+        updateStoredOAuthEntry(this.serverName, this.config, (entry) => {
+            if (scope === "client" || scope === "all") {
+                delete entry.clientId;
+                delete entry.clientSecret;
+            }
+            if (scope === "tokens" || scope === "all") {
+                delete entry.accessToken;
+                delete entry.refreshToken;
+                delete entry.expiresAt;
+            }
+        });
+        if (scope === "verifier" || scope === "all")
+            this._codeVerifier = undefined;
+    }
+}
+function traceOutcomeFromError(err) {
+    if (err instanceof AuthenticationCancelledError)
+        return "cancelled";
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("Authentication timeout"))
+        return "timeout";
+    if (msg.includes("state mismatch"))
+        return "state_mismatch";
+    if (msg.includes("OAuth error:"))
+        return "provider_denied";
+    if (msg.includes("authorization code") || msg.includes("token") || msg.includes("exchange"))
+        return "token_exchange_failed";
+    return "error";
+}
+export async function authenticate(serverName, config, deps = {}, opts = {}) {
+    const openUrl = deps.openUrl ?? defaultOpenUrl;
+    const timeoutMs = opts.timeoutMs ?? OAuthFlowTimeoutMs;
+    // Discovery and the token exchange go to the ${VAR}-expanded URL when the
+    // caller provides one; the provider below keeps the RAW config so the
+    // auth-store key (sha256 of type+url+headers) is stable across env changes.
+    const serverUrl = opts.serverUrl ?? config.url;
+    // Bind the loopback port FIRST so redirect_uri and the listener agree.
+    const fixedPort = config.oauth?.callbackPort;
+    const port = fixedPort ?? (await findFreePort());
+    const redirectUri = buildRedirectUri(port);
+    const provider = new YagniAuthProvider(serverName, config, redirectUri);
+    // Step 1: discovery + DCR + PKCE challenge; SDK calls redirectToAuthorization
+    // (captured on the provider) and returns REDIRECT. Bounded: a hung discovery
+    // or DCR endpoint must fail the flow AND close its socket, not hold the
+    // command handler hostage.
+    let first;
+    try {
+        first = await sdkAuthPhase("discovery", provider, { serverUrl }, { signal: opts.signal, timeoutMs });
+    }
+    catch (err) {
+        if (err instanceof AuthenticationCancelledError)
+            throw err;
+        logMcpEvent(serverName, "oauth_result", {
+            phase: "discovery",
+            outcome: traceOutcomeFromError(err),
+            errorDescription: err instanceof Error ? err.message.slice(0, 300) : String(err),
+        });
+        throw err;
+    }
+    if (first !== "REDIRECT") {
+        // Cached tokens refreshed cleanly — already authorized.
+        const tokens = await provider.tokens();
+        logMcpEvent(serverName, "oauth_result", { outcome: "refreshed", redirectUri });
+        return { result: "AUTHORIZED", tokens };
+    }
+    const authorizationUrl = provider.authorizationUrl;
+    if (!authorizationUrl) {
+        logMcpEvent(serverName, "oauth_result", { phase: "redirect", outcome: "error", errorDescription: "SDK did not produce an authorization URL", redirectUri });
+        throw new Error("SDK did not produce an authorization URL");
+    }
+    // Bind the loopback listener FIRST, then open the browser (Claude Code
+    // parity: `server.listen` before `openBrowser`), so a fast redirect can never
+    // race the bind. The wait itself is bounded by the timeout below, so a source
+    // that errors before redirecting (Sentry's consent 500) can no longer wedge
+    // the command loop forever.
+    const state = await provider.state();
+    const codePromise = waitForCode(port, state, { signal: opts.signal, timeoutMs, onEvent: (evt, fields) => logMcpEvent(serverName, evt, { ...fields, redirectUri }) });
+    await openUrl(authorizationUrl);
+    let code;
+    try {
+        code = await codePromise;
+    }
+    catch (err) {
+        logMcpEvent(serverName, "oauth_result", { phase: "callback", outcome: traceOutcomeFromError(err), errorDescription: err instanceof Error ? err.message.slice(0, 300) : String(err), redirectUri });
+        throw err;
+    }
+    if (!code) {
+        logMcpEvent(serverName, "oauth_result", { phase: "callback", outcome: "provider_denied", errorDescription: "no authorization code received", redirectUri });
+        throw new Error("OAuth cancelled — no authorization code received");
+    }
+    // Step 3: exchange the code for tokens (SDK persists them via saveTokens).
+    // Bounded like discovery: a hung token endpoint must fail, not wedge.
+    let result;
+    try {
+        result = await sdkAuthPhase("token exchange", provider, { serverUrl, authorizationCode: code }, { signal: opts.signal, timeoutMs });
+    }
+    catch (err) {
+        if (err instanceof AuthenticationCancelledError)
+            throw err;
+        logMcpEvent(serverName, "oauth_result", { phase: "exchange", outcome: traceOutcomeFromError(err), errorDescription: err instanceof Error ? err.message.slice(0, 300) : String(err) });
+        throw err;
+    }
+    if (result !== "AUTHORIZED") {
+        logMcpEvent(serverName, "oauth_result", { phase: "exchange", outcome: "token_exchange_failed", errorDescription: `result: ${result}` });
+        throw new Error(`OAuth flow did not complete (result: ${result})`);
+    }
+    logMcpEvent(serverName, "oauth_result", { outcome: "authorized", redirectUri });
+    return { result, tokens: await provider.tokens() };
+}
+/** Find a free loopback port (OS-assigned). */
+export function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const probe = createServer();
+        probe.once("error", reject);
+        probe.listen(0, "127.0.0.1", () => {
+            const port = probe.address().port;
+            probe.close(() => resolve(port));
+        });
+    });
+}
+export function buildRedirectUri(port) {
+    return `http://127.0.0.1:${port}/callback`;
+}
+/** Listen on 127.0.0.1 for the callback; resolves with the code, rejects with a typed error on timeout/cancel/no-code. */
+function waitForCode(port, expectedState, opts = {}) {
+    return new Promise((resolve, reject) => {
+        let server = null;
+        let timeoutId = null;
+        let settled = false;
+        const { onEvent } = opts;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (server) {
+                try {
+                    server.close();
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            resolve(code);
+        };
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            if (server) {
+                try {
+                    server.close();
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            reject(err);
+        };
+        if (opts.signal) {
+            if (opts.signal.aborted) {
+                onEvent?.("oauth_cancelled", {});
+                fail(new AuthenticationCancelledError());
+                return;
+            }
+            opts.signal.addEventListener("abort", () => {
+                onEvent?.("oauth_cancelled", {});
+                fail(new AuthenticationCancelledError());
+            }, { once: true });
+        }
+        server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404);
+                res.end();
+                return;
+            }
+            const state = url.searchParams.get("state");
+            const error = url.searchParams.get("error");
+            const errorDescription = url.searchParams.get("error_description");
+            const errorUri = url.searchParams.get("error_uri");
+            const code = url.searchParams.get("code") ?? undefined;
+            if (error) {
+                onEvent?.("oauth_callback_error", { errorCode: error, errorDescription, errorUri });
+                res.writeHead(200, { "Content-Type": "text/html" });
+                // The provider-controlled values are HTML-escaped: any local process
+                // can hit the loopback with a crafted ?error=<script> payload, and the
+                // page must never reflect it (same spot Claude Code sanitizes).
+                res.end(renderAuthErrorPage({
+                    error: escapeHtml(error),
+                    errorDescription: errorDescription ? escapeHtml(errorDescription) : undefined,
+                }));
+                finish(undefined);
+                return;
+            }
+            if (state !== expectedState) {
+                onEvent?.("oauth_callback_state_mismatch", {});
+                res.writeHead(400, { "Content-Type": "text/html" });
+                res.end(renderAuthStateMismatchPage());
+                fail(new Error("OAuth state mismatch - possible CSRF attack"));
+                return;
+            }
+            onEvent?.("oauth_callback_code", {});
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end(renderAuthSuccessPage());
+            finish(code);
+        });
+        server.on("error", () => {
+            onEvent?.("oauth_cancelled", {});
+            fail(new Error("OAuth callback server failed"));
+        });
+        server.listen(port, "127.0.0.1");
+        server.unref();
+        const timeoutMs = opts.timeoutMs ?? OAuthFlowTimeoutMs;
+        timeoutId = setTimeout(() => {
+            onEvent?.("oauth_timeout", {});
+            fail(new Error("Authentication timeout"));
+        }, timeoutMs);
+        timeoutId.unref();
+    });
+}
+/**
+ * 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 async function revokeServerTokens(serverName, config, metadata, clientInfo, deps = {}) {
+    const fetchFn = deps.fetch ?? fetch;
+    const rawEndpoint = metadata.revocation_endpoint;
+    if (!rawEndpoint)
+        return;
+    const endpoint = rawEndpoint instanceof URL ? rawEndpoint.toString() : rawEndpoint;
+    const entry = getStoredOAuthEntry(serverName, config);
+    if (!entry)
+        return;
+    const clientId = clientInfo.client_id;
+    const secret = clientInfo.client_secret;
+    const revokeOne = async (token, hint) => {
+        if (!token)
+            return;
+        const body = new URLSearchParams({ token, token_type_hint: hint });
+        if (clientId)
+            body.set("client_id", clientId);
+        const baseHeaders = { "Content-Type": "application/x-www-form-urlencoded" };
+        if (secret)
+            baseHeaders.Authorization = `Basic ${Buffer.from(`${clientId}:${secret}`).toString("base64")}`;
+        try {
+            let res = await fetchFn(endpoint, { method: "POST", headers: baseHeaders, body });
+            if (!secret && res.status === 401) {
+                res = await fetchFn(endpoint, {
+                    method: "POST",
+                    headers: { ...baseHeaders, Authorization: `Bearer ${token}` },
+                    body,
+                });
+            }
+            void res;
+        }
+        catch {
+            // best-effort
+        }
+    };
+    await revokeOne(entry.refreshToken, "refresh_token");
+    await revokeOne(entry.accessToken, "access_token");
+}
+/** Best-effort browser open without a shell (injected in tests).
+ *
+ * A no-op under the test runner (crashReport.ts's runningUnderTest): a test
+ * that forgets to inject `openUrl` must not pop a real browser window on the
+ * developer's machine. Same philosophy as crash-report suppression — make the
+ * whole class of leak impossible rather than fixing one call site at a time.
+ */
+async function defaultOpenUrl(url) {
+    if (runningUnderTest())
+        return;
+    const { spawn } = await import("node:child_process");
+    const platform = process.platform;
+    const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+    const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+    try {
+        spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+    }
+    catch {
+        // best-effort — the URL is surfaced to the user by the panel caller
+    }
+}
+/**
+ * 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 async function revokeTokensOnRemove(serverName, config, deps = {}) {
+    try {
+        // Discovery needs the resolvable (${VAR}-expanded) URL; store operations
+        // below key off the raw config. Best-effort: an unresolvable var leaves
+        // the raw URL, discovery fails, and the local entry is still cleared.
+        const discoveryUrl = expandServerEnv(config).config.url;
+        const info = await discoverOAuthServerInfo(discoveryUrl, { fetchFn: deps.fetch });
+        const metadata = info.authorizationServerMetadata;
+        const entry = getStoredOAuthEntry(serverName, config);
+        if (metadata && entry?.clientId) {
+            const clientInfo = {
+                client_id: entry.clientId,
+                ...(entry.clientSecret ? { client_secret: entry.clientSecret } : {}),
+            };
+            await revokeServerTokens(serverName, config, metadata, clientInfo, deps);
+        }
+    }
+    catch {
+        // discovery or revoke failed — still clear locally below
+    }
+    clearStoredOAuthEntry(serverName, config);
+}
+//# sourceMappingURL=auth.js.map

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

@@ -0,0 +1,61 @@
+/**
+ * OAuth token + client-credential store for MCP servers, pure file I/O (no
+ * network, no pi imports) so it is shared verbatim between the extension
+ * session and the `yagni mcp` CLI (revoke-on-remove reads it too).
+ *
+ *   ~/.yagni-code/mcp-auth.json   (0600 — access/refresh tokens and any
+ *                                 pre-registered client secret are secrets)
+ *
+ * Entries are keyed `serverName|<sha256(type+url+headers)[:16]>` — the same
+ * key Claude Code derives via `getServerKey`, so a server whose URL/headers
+ * change invalidates its stored credentials automatically. Writes are atomic
+ * (temp + rename) and chmod 0600, exactly like the mcp.json config writes.
+ */
+import type { McpHttpServerConfig } from "./config.js";
+export interface StoredOAuthEntry {
+    serverName: string;
+    serverUrl: string;
+    /** Client id from DCR, or a pre-registered `oauth.clientId`. */
+    clientId?: string;
+    /** Pre-registered client secret (`yagni mcp add --client-secret`), NOT a DCR secret. */
+    clientSecret?: string;
+    accessToken?: string;
+    refreshToken?: string;
+    /** Epoch ms when the access token expires (refresh happens before this). */
+    expiresAt?: number;
+    scopes?: string[];
+}
+export interface McpAuthFile {
+    servers?: Record<string, StoredOAuthEntry>;
+}
+export declare function _setMcpAuthHomeForTest(dir: string | null): void;
+export declare function mcpAuthPath(): string;
+/**
+ * The stable key for one server's credentials. Hash covers type + url +
+ * headers (NOT the client id, matching Claude Code) so a URL/header change
+ * orphans old tokens rather than silently reusing them against a different
+ * endpoint.
+ */
+export declare function getServerKey(serverName: string, config: McpHttpServerConfig): string;
+/** Read + parse the auth store; missing/unparseable → empty with error noted. */
+export declare function readMcpAuth(): {
+    file: McpAuthFile;
+    errors: string[];
+};
+/** Atomic write + chmod 0600 (tokens/secrets must never be world-readable). */
+export declare function writeMcpAuth(file: McpAuthFile): void;
+/** Read one entry by server key; undefined when absent. */
+export declare function getStoredOAuthEntry(serverName: string, config: McpHttpServerConfig): StoredOAuthEntry | undefined;
+/**
+ * Read-modify-write one entry. `mutate` receives the current entry (or a fresh
+ * one) and may edit it in place; returning `false` deletes it. Used by both
+ * the provider (save tokens/creds) and revocation (clear on remove).
+ */
+export declare function updateStoredOAuthEntry(serverName: string, config: McpHttpServerConfig, mutate: (entry: StoredOAuthEntry) => void | false): {
+    errors: string[];
+};
+/** Remove every credential entry (used by revoke-on-remove). */
+export declare function deleteStoredOAuthEntry(serverName: string, config: McpHttpServerConfig): {
+    errors: string[];
+};
+//# sourceMappingURL=authStore.d.ts.map