rovecode 0.3.2 → 0.4.0-beta.2

package/src/mcp/oauth.ts

@@ -1,251 +0,0 @@
-/** MCP server OAuth (port #76): the rovecode `OAuthClientProvider` behind the MCP SDK's `authProvider` seam, the
- *  stored record beside the API keys, the `rovecode mcp login <name>` flow and the runtime provider factory.
- *
- *  Design: the SDK does the protocol — bearer injection (client/streamableHttp.js `_commonHeaders`, sse.js alike),
- *  401 → `auth()` (RFC 9728 protected-resource discovery → RFC 8414 AS metadata → RFC 7591 dynamic registration →
- *  PKCE S256 authorization-code flow, or `grant_type=refresh_token` when a refresh token is stored; one retry after
- *  `invalidateCredentials`) and the 401-after-auth circuit breaker. rovecode supplies ONLY persistence, the loopback
- *  redirect (providers/oauth/loopback.ts, the #66 server) and the CLI (cli/mcp-login.ts). Two provider modes:
- *  - LOGIN (`McpLoginAuthProvider`, `rovecode mcp login`): the callback server is bound FIRST so the ephemeral
- *    redirect_uri is known before dynamic registration — pattern: google-gemini/gemini-cli
- *    packages/core/src/mcp/oauth-provider.ts:399-405 "start callback server first to allocate port" (Apache-2.0,
- *    pattern level, no code copied; snapshot research/source_snapshots/google-gemini-gemini-cli @ 0bd1d43);
- *    registration is fresh per login (`token_endpoint_auth_method: "none"`, never a client_secret) unless
- *    `oauth.clientId` is configured; `state` is the callback path nonce; the authorize URL reaches the terminal as the
- *    #66 `auth_url` notice (nothing opens a browser); the accepted code is exchanged through `auth(…, {authorizationCode})`.
- *  - RUNTIME (`McpRuntimeAuthProvider`, a connect): the stored record is the whole session — `clientInformation()` and
- *    `discoveryState()` come from it (no .well-known, no /register in-session), a 401 refreshes ONCE and persists the
- *    new tokens before the retried request, and everything that would need a browser throws `McpNeedsLoginError`,
- *    whose text is the remedy `needs login — run \`rovecode mcp login <name>\``. The SDK registers BEFORE it calls
- *    `saveClientInformation` (client/auth.js authInternal), so a `clientInformation()` that refuses is the guard that
- *    keeps /register at 0; `saveClientInformation` throws too, as the second fence. Refreshes are capped at one per
- *    provider instance (= per connect) — the legacy SSE transport has no circuit breaker of its own.
- *  Record (providers/auth.ts owns the shape): `credentials.json` id `mcp:<name>`, `type: "mcp-oauth"`, fields `url`
- *  (attached only when it EQUALS the configured url), `access`, `refresh`, `expires` (ms), `clientInformation`,
- *  `discovery`. Never for stdio; never when a static `headers.Authorization` is configured — static auth wins. No
- *  token, verifier or code reaches a message: SDK errors are wrapped as `<what> failed (<ErrorClass>[: <oauth error>])`
- *  because a `ServerError` embeds the response body. opencode packages/opencode/src/mcp/oauth-provider.ts (MIT) was
- *  read for the provider-class shape over the same seam; its fixed callback port is deliberately not followed. Not
- *  live-verified against a remote OAuth MCP server (none on this box) — verified against the in-process fake in
- *  test/helpers/mcp-oauth-fixtures.ts. */
-
-import { auth, extractWWWAuthenticateParams, type OAuthClientProvider, type OAuthDiscoveryState } from "@modelcontextprotocol/sdk/client/auth.js";
-import { OAuthError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
-import type { OAuthClientInformationMixed, OAuthClientMetadata, OAuthTokens } from "@modelcontextprotocol/sdk/shared/auth.js";
-import { LATEST_PROTOCOL_VERSION } from "@modelcontextprotocol/sdk/types.js";
-import { isMcpOAuthRecord, readEntry, writeEntry, type StoredMcpOAuthRecord } from "../providers/auth.ts";
-import { LOGIN_CANCELLED, fetchOrCancel, loginCancelled, type OAuthDeps, type OAuthLoginIO } from "../providers/oauth/common.ts";
-import { startLoopbackCallback } from "../providers/oauth/loopback.ts";
-import { randomState } from "../providers/oauth/pkce.ts";
-import type { McpServerConfig } from "./config.ts";
-import { McpNeedsLoginError, hasStaticAuthorization, needsLoginText } from "./shared.ts";
-import pkg from "../../package.json";
-
-export type McpOAuthRecord = StoredMcpOAuthRecord;
-type ClientInfo = NonNullable<McpOAuthRecord["clientInformation"]>;
-
-/** the credentials.json id of a server's record */
-export function mcpOAuthId(name: string): string {
-  return `mcp:${name}`;
-}
-
-// needsLoginText / McpNeedsLoginError / hasStaticAuthorization live in shared.ts (SDK-free, so transport.ts can
-// name the remedy without loading this module); re-exported here because this is where callers look for them.
-export { McpNeedsLoginError, hasStaticAuthorization, needsLoginText };
-
-/** The stored record for `name`, or undefined when absent, malformed, or bound to a different url. */
-export function loadMcpOAuth(name: string, url: string | undefined): McpOAuthRecord | undefined {
-  const raw = readEntry(mcpOAuthId(name));
-  if (url === undefined || !isMcpOAuthRecord(raw) || raw.url !== url) return undefined;
-  return raw;
-}
-
-export function saveMcpOAuth(name: string, record: McpOAuthRecord): void {
-  writeEntry(mcpOAuthId(name), record);
-}
-
-function expiresAt(tokens: OAuthTokens, now: number): number {
-  return typeof tokens.expires_in === "number" && Number.isFinite(tokens.expires_in) ? now + Math.max(0, tokens.expires_in) * 1000 : Number.MAX_SAFE_INTEGER;
-}
-
-/** a configured `oauth.clientId` beats whatever registration produced */
-function knownClient(config: McpServerConfig, stored: ClientInfo | undefined): ClientInfo | undefined {
-  const id = config.oauth?.clientId;
-  return id ? { client_id: id } : stored;
-}
-
-/** what of a registration answer is kept: the id plus a DCR-issued secret and its dates when the server sent them */
-function pickClientInfo(info: OAuthClientInformationMixed): ClientInfo {
-  const out: ClientInfo = { client_id: info.client_id };
-  if (typeof info.client_secret === "string") out.client_secret = info.client_secret;
-  if (typeof info.client_id_issued_at === "number") out.client_id_issued_at = info.client_id_issued_at;
-  if (typeof info.client_secret_expires_at === "number") out.client_secret_expires_at = info.client_secret_expires_at;
-  return out;
-}
-
-function clientMetadataFor(redirectUri: string, scope: string | undefined): OAuthClientMetadata {
-  return {
-    client_name: "rovecode", redirect_uris: [redirectUri], grant_types: ["authorization_code", "refresh_token"],
-    response_types: ["code"], token_endpoint_auth_method: "none", ...(scope ? { scope } : {}),
-  };
-}
-
-function discoveryOf(record: McpOAuthRecord): OAuthDiscoveryState | undefined {
-  const d = record.discovery;
-  return d !== undefined && typeof d.authorizationServerUrl === "string" ? (d as unknown as OAuthDiscoveryState) : undefined;
-}
-
-/** truthy so the SDK never takes its non-interactive (client_credentials) branch; never sent — the runtime provider
- *  throws before any redirect could carry it */
-const RUNTIME_REDIRECT = "http://127.0.0.1/callback/needs-login";
-
-/** Runtime mode: the stored record, refresh once, everything else is `needs login`. */
-export class McpRuntimeAuthProvider implements OAuthClientProvider {
-  private refreshes = 0;
-  constructor(private readonly config: McpServerConfig, private record: McpOAuthRecord, private readonly now: () => number = Date.now) {}
-  get redirectUrl(): string { return RUNTIME_REDIRECT; }
-  get clientMetadata(): OAuthClientMetadata { return clientMetadataFor(RUNTIME_REDIRECT, this.config.oauth?.scope); }
-  /** the configured or registered client — refusing HERE (before the SDK's registerClient) keeps /register at 0 */
-  clientInformation(): OAuthClientInformationMixed {
-    const info = knownClient(this.config, this.record.clientInformation);
-    if (!info) throw new McpNeedsLoginError(this.config.name);
-    return info;
-  }
-  saveClientInformation(): never { throw new McpNeedsLoginError(this.config.name); }
-  discoveryState(): OAuthDiscoveryState | undefined { return discoveryOf(this.record); }
-  saveDiscoveryState(state: OAuthDiscoveryState): void { this.persist({ ...this.record, discovery: state as unknown as Record<string, unknown> }); }
-  tokens(): OAuthTokens | undefined {
-    const { access, refresh, expires } = this.record;
-    if (access.length === 0) return undefined;
-    const t: OAuthTokens = { access_token: access, token_type: "Bearer" };
-    // ONE refresh per connect: afterwards the SDK sees no refresh token, asks for a browser, and gets the remedy
-    if (refresh.length > 0 && this.refreshes === 0) t.refresh_token = refresh;
-    if (expires < Number.MAX_SAFE_INTEGER) t.expires_in = Math.max(0, Math.floor((expires - this.now()) / 1000));
-    return t;
-  }
-  /** the refreshed tokens — persisted BEFORE the SDK retries the request; the refresh token is kept when none came back */
-  saveTokens(tokens: OAuthTokens): void {
-    this.refreshes += 1;
-    this.persist({ ...this.record, access: tokens.access_token, refresh: tokens.refresh_token ?? this.record.refresh, expires: expiresAt(tokens, this.now()) });
-  }
-  redirectToAuthorization(): never { throw new McpNeedsLoginError(this.config.name); }
-  saveCodeVerifier(): void { /* the SDK calls this right before redirectToAuthorization, which throws */ }
-  codeVerifier(): never { throw new McpNeedsLoginError(this.config.name); }
-  /** field-level: 'tokens' keeps the client and discovery so the SDK's own retry never registers; `url` always stays */
-  invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier" | "discovery"): void {
-    const next: McpOAuthRecord = { ...this.record };
-    if (scope === "all" || scope === "tokens") { next.access = ""; next.refresh = ""; next.expires = 0; }
-    if (scope === "all" || scope === "client") delete next.clientInformation;
-    if (scope === "all" || scope === "discovery") delete next.discovery;
-    this.persist(next);
-  }
-  private persist(next: McpOAuthRecord): void {
-    this.record = next;
-    saveMcpOAuth(this.config.name, next);
-  }
-}
-
-/** Login mode: in-memory registration + verifier, the bound callback as redirect, the notice as the redirect. */
-export class McpLoginAuthProvider implements OAuthClientProvider {
-  private registered: ClientInfo | undefined;
-  private verifier: string | undefined;
-  private discovery: OAuthDiscoveryState | undefined;
-  /** the record saveTokens wrote (the flow returns it) */
-  stored: McpOAuthRecord | undefined;
-  constructor(private readonly config: McpServerConfig, private readonly callbackUrl: string, private readonly nonce: string, private readonly io: OAuthLoginIO, private readonly now: () => number) {}
-  get redirectUrl(): string { return this.callbackUrl; }
-  get clientMetadata(): OAuthClientMetadata { return clientMetadataFor(this.callbackUrl, this.config.oauth?.scope); }
-  state(): string { return this.nonce; }
-  clientInformation(): OAuthClientInformationMixed | undefined { return knownClient(this.config, this.registered); }
-  /** memory only: registration is fresh per login because the ephemeral redirect port changes */
-  saveClientInformation(info: OAuthClientInformationMixed): void { this.registered = pickClientInfo(info); }
-  discoveryState(): OAuthDiscoveryState | undefined { return this.discovery; }
-  saveDiscoveryState(state: OAuthDiscoveryState): void { this.discovery = state; }
-  /** a login always starts the browser flow */
-  tokens(): undefined { return undefined; }
-  saveTokens(tokens: OAuthTokens): void {
-    const info = this.clientInformation();
-    const record: McpOAuthRecord = {
-      type: "mcp-oauth", url: this.config.url ?? "", access: tokens.access_token, refresh: tokens.refresh_token ?? "", expires: expiresAt(tokens, this.now()),
-      ...(info ? { clientInformation: pickClientInfo(info) } : {}),
-      ...(this.discovery ? { discovery: this.discovery as unknown as Record<string, unknown> } : {}),
-    };
-    saveMcpOAuth(this.config.name, record);
-    this.stored = record;
-  }
-  redirectToAuthorization(url: URL): void { this.io.notify({ type: "auth_url", url: url.toString(), callbackUrl: this.callbackUrl }); }
-  saveCodeVerifier(verifier: string): void { this.verifier = verifier; }
-  codeVerifier(): string {
-    if (this.verifier === undefined) throw new Error("no PKCE verifier for this login");
-    return this.verifier;
-  }
-}
-
-/** `<what> failed (<ErrorClass>[: <oauth error code>])` — an OAuthError's message may embed the response body
- *  (ServerError), so only its class and code are surfaced; other errors are SDK-built and token-free, clipped. */
-function wrapSdkError(what: string, err: unknown): Error {
-  if (err instanceof McpNeedsLoginError || (err instanceof Error && err.message === LOGIN_CANCELLED)) return err;
-  if (err instanceof OAuthError) return new Error(`${what} failed (${err.name}: ${err.errorCode})`);
-  const detail = err instanceof Error ? `${err.constructor.name}: ${err.message.slice(0, 200)}` : String(err).slice(0, 200);
-  return new Error(`${what} failed (${detail})`);
-}
-
-const PROBE_BODY = JSON.stringify({ jsonrpc: "2.0", id: 0, method: "initialize", params: { protocolVersion: LATEST_PROTOCOL_VERSION, capabilities: {}, clientInfo: { name: "rovecode", version: pkg.version } } });
-
-export interface McpLoginFlowDeps extends OAuthDeps {
-  /** loopback wait budget (default 5 minutes) */
-  timeoutMs?: number;
-}
-
-/** The whole login: bind the callback → probe once (must be 401) → SDK auth() to the redirect → the browser's code →
- *  SDK auth() exchange → the stored record. Throws token-free Errors; loginCancelled() when `io.signal` fired. */
-export async function runMcpLoginFlow(config: McpServerConfig, io: OAuthLoginIO, deps: McpLoginFlowDeps): Promise<McpOAuthRecord> {
-  const name = config.name;
-  if (config.transport === "stdio" || config.url === undefined) throw new Error(`MCP server "${name}" is a stdio server — OAuth login applies to url servers only`);
-  if (io.signal.aborted) throw loginCancelled();
-  const url = config.url;
-  const what = `MCP server "${name}"`;
-  const nonce = randomState();
-  let provider: McpLoginAuthProvider | undefined;
-  let seed: { resourceMetadataUrl?: URL; scope?: string } = {};
-  // bound FIRST: dynamic registration needs the real redirect_uri (gemini-cli oauth-provider.ts:399-405)
-  const callback = startLoopbackCallback<McpOAuthRecord>({
-    nonce, signal: io.signal, what, retryHint: `Run rovecode mcp login ${name} again.`, exchange: "token exchange", requireStateParam: true,
-    ...(deps.timeoutMs !== undefined ? { timeoutMs: deps.timeoutMs } : {}),
-    onCode: async (code) => {
-      if (!provider) throw new Error(`${what} token exchange failed (callback before the authorization request)`);
-      const result = await auth(provider, { serverUrl: url, authorizationCode: code, resourceMetadataUrl: seed.resourceMetadataUrl, scope: seed.scope, fetchFn: deps.fetch })
-        .catch((e: unknown) => { throw wrapSdkError(`${what} token exchange`, e); });
-      if (result !== "AUTHORIZED" || !provider.stored) throw new Error(`${what} token exchange failed (no tokens were issued)`);
-      return provider.stored;
-    },
-  });
-  try {
-    // ONE probe — an initialize POST: anything but 401 means the server does not gate on OAuth
-    let res: Response;
-    try {
-      res = await fetchOrCancel(deps, url, { method: "POST", headers: { "content-type": "application/json", accept: "application/json, text/event-stream" }, body: PROBE_BODY }, io.signal);
-    } catch (e) {
-      throw e instanceof Error && e.message === LOGIN_CANCELLED ? e : new Error(`${what} probe failed (${e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200)})`);
-    }
-    await res.body?.cancel().catch(() => {});
-    if (res.status !== 401) throw new Error(`server does not require OAuth (HTTP ${res.status})`);
-    seed = extractWWWAuthenticateParams(res);
-    provider = new McpLoginAuthProvider(config, callback.callbackUrl, nonce, io, deps.now);
-    const first = await auth(provider, { serverUrl: url, resourceMetadataUrl: seed.resourceMetadataUrl, scope: seed.scope, fetchFn: deps.fetch })
-      .catch((e: unknown) => { throw wrapSdkError(`${what} authorization`, e); });
-    if (first !== "REDIRECT") throw new Error(`${what} authorization failed (expected a browser redirect, got ${first})`);
-    return await callback.result;
-  } finally {
-    callback.stop();
-  }
-}
-
-/** The provider a connect attaches: stdio → none; a static Authorization header → none (static auth wins); no valid
- *  record for THIS url → none (a 401 then surfaces as the SDK's 401 error, which transport.ts maps to the remedy). */
-export function runtimeAuthProvider(config: McpServerConfig): OAuthClientProvider | undefined {
-  if (config.transport === "stdio" || config.url === undefined) return undefined;
-  if (hasStaticAuthorization(config)) return undefined;
-  const record = loadMcpOAuth(config.name, config.url);
-  return record ? new McpRuntimeAuthProvider(config, record) : undefined;
-}

package/src/mcp/prompts-resources.ts

@@ -1,249 +0,0 @@
-/** MCP prompts + resources (port #57), lazy like tools: nothing is fetched until
- *  mcp_prompts / mcp_prompt / mcp_resources / mcp_read asks; then cached per
- *  server with the manager's TTL and dropped early by the server's
- *  prompts/resources list_changed notifications (client.ts onListChanged). A
- *  server WITHOUT the capability yields an EMPTY list, never an error — "no
- *  prompts here" is a fact for the model, not a failure. One index per manager
- *  (depthFor), so the tools and the /mcp status share the caches.
- *  Pattern source (Apache-2.0, PATTERN ONLY — no code copied): gemini-cli
- *  list-mcp-resources.ts / read-mcp-resource.ts — server-scoped listing, text
- *  content verbatim, binary content summarized instead of fed raw.
- *  Rovecode: SDK-free at load (tools.ts pulls this in at createRuntime — method-not-found is a
- *  duck-typed code check, shared.ts), and every request goes through the per-call signal the
- *  tool paths use (shared.ts perCallSignal: the SDK never removes its abort listener). */
-
-import type { McpManager } from "./client.ts";
-import { isRecord, message } from "./config.ts";
-import { capOutput, isMethodNotFound, walkPages, withCallSignal } from "./shared.ts";
-
-export interface McpPromptArg { name: string; description: string; required: boolean }
-export interface McpPromptInfo { server: string; name: string; description: string; arguments: McpPromptArg[] }
-export interface McpResourceInfo { server: string; uri: string; name: string; description: string; mimeType?: string }
-export interface McpTemplateInfo { server: string; uriTemplate: string; name: string; description: string; mimeType?: string }
-export interface McpResourceIndex { resources: McpResourceInfo[]; templates: McpTemplateInfo[] }
-/** cache-only counts for /mcp: a key is absent until a listing fetched it (lazy) */
-export interface McpDepthCounts { prompts?: number; resources?: number; templates?: number }
-
-const str = (v: unknown): string => (typeof v === "string" ? v : "");
-const mime = (v: unknown): { mimeType?: string } => (typeof v === "string" && v.length > 0 ? { mimeType: v } : {});
-
-export class McpDepth {
-  private readonly prompts = new Map<string, { at: number; items: McpPromptInfo[] }>();
-  private readonly resources = new Map<string, { at: number; index: McpResourceIndex }>();
-  /** per kind:server, bumped on list_changed (and on manager close) — a listing that raced the
-   *  notification never re-caches its stale page for the TTL (mirrors client.ts toolGen) */
-  private readonly gens = new Map<string, number>();
-
-  constructor(private readonly manager: McpManager) {
-    manager.onListChanged((server, kind) => {
-      if (kind === "tools") return;
-      (kind === "prompts" ? this.prompts : this.resources).delete(server);
-      this.gens.set(`${kind}:${server}`, this.gen(kind, server) + 1);
-    });
-  }
-
-  private gen(kind: "prompts" | "resources", server: string): number {
-    return this.gens.get(`${kind}:${server}`) ?? 0;
-  }
-
-  /** request options for one SDK call — `signal` is the per-call one withCallSignal hands out */
-  private opts(signal: AbortSignal): { timeout: number; signal: AbortSignal } {
-    return { timeout: this.manager.requestTimeoutMs, signal };
-  }
-
-  /** One server's prompts (cached; EMPTY when the server lacks the capability). */
-  async promptsOf(server: string, signal?: AbortSignal): Promise<McpPromptInfo[]> {
-    const cached = this.prompts.get(server);
-    const now = Date.now();
-    if (cached && now - cached.at < this.manager.ttlMs) return cached.items;
-    const { client, caps } = this.manager.connection(server);
-    const gen = this.gen("prompts", server);
-    const items = !caps.prompts ? [] : await walkPages<McpPromptInfo>("prompt", server, async (cursor) => {
-      const res = await withCallSignal(signal, (sig) => client.listPrompts(cursor === undefined ? undefined : { cursor }, this.opts(sig)));
-      return {
-        items: res.prompts.map((p) => ({
-          server, name: p.name, description: str(p.description),
-          arguments: (p.arguments ?? []).map((a) => ({ name: a.name, description: str(a.description), required: a.required === true })),
-        })),
-        nextCursor: res.nextCursor,
-      };
-    }, signal);
-    if (this.gen("prompts", server) === gen) this.prompts.set(server, { at: now, items }); // a mid-flight list_changed wins
-    return items;
-  }
-
-  /** One server's resources + URI templates (cached; EMPTY without the capability; a
-   *  resources-capable server that answers templates/list with method-not-found simply
-   *  has no templates). */
-  async resourcesOf(server: string, signal?: AbortSignal): Promise<McpResourceIndex> {
-    const cached = this.resources.get(server);
-    const now = Date.now();
-    if (cached && now - cached.at < this.manager.ttlMs) return cached.index;
-    const { client, caps } = this.manager.connection(server);
-    const gen = this.gen("resources", server);
-    const index: McpResourceIndex = { resources: [], templates: [] };
-    if (caps.resources) {
-      index.resources = await walkPages<McpResourceInfo>("resource", server, async (cursor) => {
-        const res = await withCallSignal(signal, (sig) => client.listResources(cursor === undefined ? undefined : { cursor }, this.opts(sig)));
-        return {
-          items: res.resources.map((r) => ({ server, uri: r.uri, name: str(r.name), description: str(r.description), ...mime(r.mimeType) })),
-          nextCursor: res.nextCursor,
-        };
-      }, signal);
-      try {
-        index.templates = await walkPages<McpTemplateInfo>("resource template", server, async (cursor) => {
-          const res = await withCallSignal(signal, (sig) => client.listResourceTemplates(cursor === undefined ? undefined : { cursor }, this.opts(sig)));
-          return {
-            items: res.resourceTemplates.map((t) => ({ server, uriTemplate: t.uriTemplate, name: str(t.name), description: str(t.description), ...mime(t.mimeType) })),
-            nextCursor: res.nextCursor,
-          };
-        }, signal);
-      } catch (err) {
-        if (!isMethodNotFound(err)) throw err;
-      }
-    }
-    if (this.gen("resources", server) === gen) this.resources.set(server, { at: now, index }); // a mid-flight list_changed wins
-    return index;
-  }
-
-  /** Every connected server's prompts; one failing server is a note, never a poisoned list. */
-  async listPrompts(signal?: AbortSignal): Promise<{ prompts: McpPromptInfo[]; notes: string[] }> {
-    const prompts: McpPromptInfo[] = [];
-    const notes: string[] = [];
-    for (const server of this.manager.connectedNames()) {
-      try {
-        prompts.push(...(await this.promptsOf(server, signal)));
-      } catch (err) {
-        notes.push(`${server}: ${message(err)}`);
-      }
-    }
-    return { prompts, notes };
-  }
-
-  /** Every connected server's resources + templates, same isolation. */
-  async listResources(signal?: AbortSignal): Promise<{ index: McpResourceIndex; notes: string[] }> {
-    const index: McpResourceIndex = { resources: [], templates: [] };
-    const notes: string[] = [];
-    for (const server of this.manager.connectedNames()) {
-      try {
-        const one = await this.resourcesOf(server, signal);
-        index.resources.push(...one.resources);
-        index.templates.push(...one.templates);
-      } catch (err) {
-        notes.push(`${server}: ${message(err)}`);
-      }
-    }
-    return { index, notes };
-  }
-
-  /** Render one prompt (prompts/get) as `[role] text` lines. Never throws; an
-   *  unknown name comes back with the server's prompt names for self-correction. */
-  async getPrompt(server: string, name: string, args: unknown, signal?: AbortSignal): Promise<{ ok: boolean; output: string }> {
-    if (args !== undefined && args !== null && !isRecord(args)) {
-      return { ok: false, output: `args for prompt ${server}/${name} must be a JSON object (got ${Array.isArray(args) ? "array" : typeof args})` };
-    }
-    let conn: ReturnType<McpManager["connection"]>;
-    try {
-      conn = this.manager.connection(server);
-    } catch (err) {
-      return { ok: false, output: message(err) };
-    }
-    if (!conn.caps.prompts) return { ok: false, output: `MCP server "${server}" advertises no prompts` };
-    // prompt arguments are strings on the wire — non-strings travel as JSON
-    const argv: Record<string, string> = {};
-    for (const [k, v] of Object.entries(args ?? {})) argv[k] = typeof v === "string" ? v : JSON.stringify(v);
-    try {
-      const res = await withCallSignal(signal, (sig) => conn.client.getPrompt({ name, ...(Object.keys(argv).length > 0 ? { arguments: argv } : {}) }, this.opts(sig)));
-      const lines: string[] = [];
-      if (str(res.description)) lines.push(`# ${res.description}`);
-      for (const m of res.messages) lines.push(`[${m.role}] ${renderPromptPart(m.content)}`);
-      return { ok: true, output: capOutput(lines.join("\n"), "mcp prompt") };
-    } catch (err) {
-      let hint = "";
-      try {
-        const known = (await this.promptsOf(server, signal)).map((p) => p.name);
-        if (!known.includes(name)) hint = `. Available prompts: ${known.length > 0 ? known.join(", ") : "(none)"}`;
-      } catch {
-        /* keep the raw error */
-      }
-      return { ok: false, output: `mcp prompt ${server}/${name} failed: ${message(err)}${hint}` };
-    }
-  }
-
-  /** Read one resource (resources/read): text as-is, a blob as an annotation line
-   *  (uri, mime, byte size) plus its base64 — the whole thing under the shared 10k
-   *  cap, so a binary resource can never flood the conversation. Never throws. */
-  async readResource(server: string, uri: string, signal?: AbortSignal): Promise<{ ok: boolean; output: string }> {
-    let conn: ReturnType<McpManager["connection"]>;
-    try {
-      conn = this.manager.connection(server);
-    } catch (err) {
-      return { ok: false, output: message(err) };
-    }
-    if (!conn.caps.resources) return { ok: false, output: `MCP server "${server}" advertises no resources` };
-    try {
-      const res = await withCallSignal(signal, (sig) => conn.client.readResource({ uri }, this.opts(sig)));
-      const text = res.contents.map((c) => renderResourceContent(c)).join("\n");
-      return { ok: true, output: capOutput(text, "mcp resource") || `(empty resource ${uri})` };
-    } catch (err) {
-      return { ok: false, output: `mcp read ${server} ${uri} failed: ${message(err)}` };
-    }
-  }
-
-  /** Cache-only counts for /mcp (a key is absent until fetched — lazy). */
-  counts(server: string): McpDepthCounts {
-    const out: McpDepthCounts = {};
-    const p = this.prompts.get(server);
-    if (p) out.prompts = p.items.length;
-    const r = this.resources.get(server);
-    if (r) {
-      out.resources = r.index.resources.length;
-      out.templates = r.index.templates.length;
-    }
-    return out;
-  }
-
-  /** `/mcp connect`: warm every list on the connected servers; per-server failures are notes. */
-  async prefetch(signal?: AbortSignal): Promise<string[]> {
-    await this.manager.listTools(false, signal);
-    return [...(await this.listPrompts(signal)).notes, ...(await this.listResources(signal)).notes];
-  }
-}
-
-/** A resources/read content entry: text verbatim; a blob becomes an annotation
- *  line plus its base64 (the caller caps the total). */
-export function renderResourceContent(c: unknown): string {
-  if (!isRecord(c)) return "";
-  if (typeof c.text === "string") return c.text;
-  if (typeof c.blob === "string") {
-    const b64 = c.blob;
-    const bytes = Math.floor((b64.length * 3) / 4) - (b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0);
-    return `[blob ${str(c.uri)} ${str(c.mimeType) || "application/octet-stream"} ${bytes} bytes, base64 follows]\n${b64}`;
-  }
-  return `[resource ${str(c.uri)}: no text or blob content]`;
-}
-
-/** One prompt message content part: text verbatim, everything else a marker (an
- *  embedded resource keeps its text/blob rendering under the marker). */
-export function renderPromptPart(part: unknown): string {
-  if (!isRecord(part)) return "";
-  switch (part.type) {
-    case "text": return str(part.text);
-    case "resource": return `[embedded resource]\n${renderResourceContent(part.resource)}`;
-    case "resource_link": return `[resource_link ${str(part.uri)}${str(part.name) ? ` ${str(part.name)}` : ""}]`;
-    case "image": case "audio": return `[${part.type} ${str(part.mimeType)}]`;
-    default: return typeof part.type === "string" ? `[${part.type} content]` : "";
-  }
-}
-
-const depths = new WeakMap<McpManager, McpDepth>();
-
-/** The ONE index per manager — tools.ts and the /mcp status share its caches. */
-export function depthFor(manager: McpManager): McpDepth {
-  let d = depths.get(manager);
-  if (!d) {
-    d = new McpDepth(manager);
-    depths.set(manager, d);
-  }
-  return d;
-}

package/src/mcp/shared.ts

@@ -1,149 +0,0 @@
-/** Shared MCP plumbing (port #57, split out of client.ts for the ADR-002 cap):
- *  the ONE render cap every MCP payload fed back to the model shares (tool
- *  results, prompt messages, resource contents — mirroring the bash tool's 10k
- *  output cap in coding/hashline.ts runOnce), the bounded pagination walk, the
- *  timeout race, and the per-call abort signal every SDK request goes through
- *  (client.ts for tools, prompts-resources.ts for the rest — the leak it stops is
- *  documented on perCallSignal). Also the token-free "needs login" remedy, kept
- *  here so transport.ts can name it without loading oauth.ts (which imports the SDK).
- *  SDK-free by design: this module is on the boot path through tools.ts. */
-
-import { isRecord } from "./config.ts";
-
-/** Pagination guard: no sane server needs 50 list pages; beyond this we assume
- *  a misbehaving server and stop instead of looping forever. */
-export const MAX_LIST_PAGES = 50;
-/** Chars of any one MCP result the conversation ever sees. */
-export const OUTPUT_MAX = 10_000;
-
-/** Cap text at OUTPUT_MAX chars; the marker names what was cut. */
-export function capOutput(text: string, what = "mcp output"): string {
-  if (text.length <= OUTPUT_MAX) return text;
-  return `${text.slice(0, OUTPUT_MAX)}\n[${what} truncated: showing ${OUTPUT_MAX} of ${text.length} chars]`;
-}
-
-/** Flatten an MCP content array to text; non-text parts become markers. Falls
- *  back to structuredContent JSON when there is no text at all. Capped. */
-export function renderContent(content: unknown, structured: unknown): string {
-  const parts: string[] = [];
-  if (Array.isArray(content)) {
-    for (const item of content) {
-      if (!isRecord(item)) continue;
-      if (item.type === "text" && typeof item.text === "string") parts.push(item.text);
-      else if (typeof item.type === "string") parts.push(`[${item.type} content]`);
-    }
-  }
-  if (parts.length === 0 && structured !== undefined) {
-    try {
-      parts.push(JSON.stringify(structured));
-    } catch {
-      /* unserializable structured content */
-    }
-  }
-  return capOutput(parts.join("\n"));
-}
-
-/** One call's signal, linked to the caller's and thrown away with the call.
- *
- *  The SDK does `options.signal.addEventListener("abort", …)` per request (shared/protocol.js:709) and
- *  never removes it. Every surface passes the RUN's signal, which lives for the whole run, so the
- *  listeners pile up on one emitter: at eleven, Node fires MaxListenersExceededWarning and prints the
- *  emitter it is complaining about — a whole Writable, pages of it — on stderr, straight over the TUI's
- *  alternate screen. Observed on a Playwright MCP session, twelve calls in.
- *
- *  A per-call controller ends that: the SDK's listener belongs to a signal nobody keeps, and the link
- *  back to the run's signal is removed in the caller's finally. Aborting still works in both directions
- *  — the run aborts the call; the call finishing does not touch the run. Every request the manager or
- *  the depth index makes (tools/list, tools/call, prompts/list, prompts/get, resources/list,
- *  resources/templates/list, resources/read) goes through one of these; mcp-signal-leak.test.ts counts. */
-export function perCallSignal(outer?: AbortSignal): { signal: AbortSignal; dispose: () => void } {
-  const ac = new AbortController();
-  if (outer === undefined) return { signal: ac.signal, dispose: () => {} };
-  if (outer.aborted) { ac.abort(outer.reason); return { signal: ac.signal, dispose: () => {} }; }
-  const forward = () => ac.abort(outer.reason);
-  outer.addEventListener("abort", forward, { once: true });
-  return { signal: ac.signal, dispose: () => outer.removeEventListener("abort", forward) };
-}
-
-/** Run one SDK request under a per-call signal: `fn` gets the throwaway signal, the link is dropped in finally. */
-export async function withCallSignal<T>(outer: AbortSignal | undefined, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
-  const per = perCallSignal(outer);
-  try {
-    return await fn(per.signal);
-  } finally {
-    per.dispose();
-  }
-}
-
-/** JSON-RPC -32601 from the server (the SDK throws McpError with `.code`): a resources-capable server
- *  without a templates/list handler. Duck-typed so this module never imports the SDK's error class. */
-export function isMethodNotFound(err: unknown): boolean {
-  return typeof err === "object" && err !== null && (err as { code?: unknown }).code === -32601;
-}
-
-/** the ONE remedy text — token-free, ≤ 80 chars for names ≤ 20 chars so status.ts's clip keeps it whole */
-export function needsLoginText(name: string): string {
-  return `needs login — run \`rovecode mcp login ${name}\``;
-}
-
-/** Thrown by the runtime OAuth provider (oauth.ts) wherever the SDK would need a browser or a registration;
- *  transport.ts describeError passes the message through as-is. */
-export class McpNeedsLoginError extends Error {
-  constructor(name: string) {
-    super(needsLoginText(name));
-    this.name = "McpNeedsLoginError";
-  }
-}
-
-/** a configured `headers.Authorization` (any case) — static auth, never overridden by a stored token */
-export function hasStaticAuthorization(config: { headers?: Record<string, string> | undefined }): boolean {
-  return config.headers !== undefined && Object.keys(config.headers).some((k) => k.toLowerCase() === "authorization");
-}
-
-export async function withTimeout<T>(p: Promise<T>, ms: number, note: string): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const gate = new Promise<never>((_, reject) => {
-    timer = setTimeout(() => reject(new Error(note)), ms);
-  });
-  try {
-    return await Promise.race([p, gate]);
-  } finally {
-    if (timer !== undefined) clearTimeout(timer);
-  }
-}
-
-/** One page of a paginated MCP list (tools / prompts / resources / templates). */
-export interface ListPage<T> { items: T[]; nextCursor?: string | undefined }
-
-/** Walk a paginated list under the house bounds: a repeated cursor or more than
- *  MAX_LIST_PAGES pages throws (partial count in the message) instead of hanging
- *  the agent; the signal is checked between pages (the page fetcher hands it to
- *  the SDK for in-flight cancellation). `what` is the singular noun for messages. */
-export async function walkPages<T>(
-  what: string,
-  server: string,
-  fetchPage: (cursor: string | undefined) => Promise<ListPage<T>>,
-  signal?: AbortSignal,
-): Promise<T[]> {
-  const items: T[] = [];
-  const seenCursors = new Set<string>();
-  let cursor: string | undefined;
-  let pages = 0;
-  do {
-    if (signal?.aborted) throw new Error(`${what} listing on "${server}" aborted`);
-    const page = await fetchPage(cursor);
-    pages += 1;
-    items.push(...page.items);
-    cursor = typeof page.nextCursor === "string" ? page.nextCursor : undefined;
-    if (cursor !== undefined) {
-      if (seenCursors.has(cursor)) {
-        throw new Error(`${what} listing on "${server}" stopped: server repeated pagination cursor ${JSON.stringify(cursor)} (partial: ${items.length} ${what}s in ${pages} pages)`);
-      }
-      seenCursors.add(cursor);
-      if (pages >= MAX_LIST_PAGES) {
-        throw new Error(`${what} listing on "${server}" stopped after ${MAX_LIST_PAGES} pages without a final page (partial: ${items.length} ${what}s)`);
-      }
-    }
-  } while (cursor !== undefined);
-  return items;
-}