rovecode 0.3.3 → 0.4.0-beta.3

package/src/mcp/status.ts

@@ -1,67 +0,0 @@
-/** MCP status text (port #57). Cache-only by default — SHOWING status never connects
- *  anything, so an idle session stays idle; `connectAndPrefetch` forces the connect plus
- *  one listing per kind so the counts are real. Pattern (Apache-2.0, pattern only):
- *  gemini-cli's /mcp per-server status rows.
- *  Rovecode: a pure module with no TUI adapter — rovecode's `/mcp` is the MCP market
- *  (tui/mcp-cmd.ts), so the verb a row points the reader at (`connectVerb`) and the
- *  empty-state hint are the CALLER's words, passed in; the defaults are what a
- *  `/mcp connect` verb would read once a surface adds one. Nothing here is wired yet. */
-
-import type { McpManager } from "./client.ts";
-import { depthFor } from "./prompts-resources.ts";
-
-const ERROR_CLIP = 80;
-
-/** One line, whitespace folded, hard-capped (error text from a server is unbounded). */
-export function clip(text: string, max = ERROR_CLIP): string {
-  const one = text.replace(/\s+/g, " ").trim();
-  return one.length <= max ? one : `${one.slice(0, max - 1)}…`;
-}
-
-/** The connect verb: connect every enabled server, then warm tools/prompts/resources.
- *  Returns human notes (connect failures, per-server listing errors). */
-export async function connectAndPrefetch(manager: McpManager, signal?: AbortSignal): Promise<string[]> {
-  const res = await manager.connect();
-  const notes = res.failed.map((f) => `${f.name}: ${clip(f.error)}`);
-  notes.push(...(await depthFor(manager).prefetch(signal)));
-  return notes;
-}
-
-/** The surface's own words: the verb that connects + prefetches, and how a server gets configured. */
-export interface StatusHints {
-  /** what a not-yet-connected / not-yet-fetched row tells the reader to run (default `/mcp connect`) */
-  connectVerb: string;
-  /** how to add a server (default: the market's shell commands) */
-  addHint: string;
-}
-export const DEFAULT_STATUS_HINTS: StatusHints = { connectVerb: "/mcp connect", addHint: "rovecode mcp search <query> · rovecode mcp add <name>" };
-
-/** One row per configured server. `configPath` (mcpConfigPath(cwd)) feeds the empty-state hint. */
-export function formatMcpStatus(manager: McpManager | null, configPath: string, hints: StatusHints = DEFAULT_STATUS_HINTS): string {
-  if (!manager || manager.serverNames().length === 0) {
-    return `no MCP servers configured — ${hints.addHint} (project config: ${configPath}; a harvested .mcp.json is read too)`;
-  }
-  const depth = depthFor(manager);
-  const rows = manager.status();
-  const lines = rows.map((s) => {
-    const wire = s.wire === undefined || s.wire === "custom" ? s.transport : s.fellBack ? `${s.transport} → ${s.wire} fallback` : s.wire;
-    switch (s.state) {
-      case "disabled": return `${s.name}  disabled (${s.transport})`;
-      case "pending": return `${s.name}  not connected yet (${s.transport}) — ${hints.connectVerb}`;
-      case "failed": return `${s.name}  failed (${s.transport}): ${clip(s.error ?? "unknown error")}`;
-      default: {
-        const c = depth.counts(s.name);
-        const counts = s.tools === undefined && c.prompts === undefined && c.resources === undefined
-          ? `tools/prompts/resources not fetched yet — ${hints.connectVerb}`
-          : [
-              `tools ${s.tools ?? "not fetched"}`,
-              `prompts ${c.prompts ?? "not fetched"}`,
-              `resources ${c.resources ?? "not fetched"}${c.templates ? ` (+${c.templates} template${c.templates === 1 ? "" : "s"})` : ""}`,
-            ].join(" · ");
-        return `${s.name}  connected (${wire}) · ${counts}`;
-      }
-    }
-  });
-  const connected = rows.filter((s) => s.state === "connected").length;
-  return [`MCP servers: ${rows.length} configured, ${connected} connected`, ...lines].join("\n");
-}

package/src/mcp/tools.ts

@@ -1,275 +0,0 @@
-/** The lazy-disclosure seam (port #3 + #57): a handful of TINY house tools are
- *  advertised to the model, regardless of how many MCP servers/tools exist.
- *  mcp_list returns a compact one-line-per-tool index (schemas on demand via a
- *  {schema:true} flag); mcp_call executes. Port #57 adds the same shape for
- *  prompts (mcp_prompts / mcp_prompt) and resources (mcp_resources / mcp_read).
- *  Full server schemas never enter the system prompt — that is the ~0
- *  idle-token invariant (mcp.test.ts pins the COMBINED schema size). SDK-free at
- *  load: the runtime requires this file at createRuntime. */
-
-import type { Tool, ToolContext, ToolOutput } from "../core/types.ts";
-import type { McpManager } from "./client.ts";
-import { message } from "./config.ts";
-import { depthFor, type McpPromptInfo, type McpResourceIndex } from "./prompts-resources.ts";
-
-const DESC_MAX = 60;
-const SCHEMA_MAX = 1_500;
-
-/** First line of a description, hard-capped for the index. */
-function compact(desc: string): string {
-  const line = (desc.split("\n", 1)[0] ?? "").trim();
-  return line.length <= DESC_MAX ? line : `${line.slice(0, DESC_MAX - 1)}…`;
-}
-
-function renderSchema(schema: object): string {
-  const rendered = JSON.stringify(schema);
-  return rendered.length > SCHEMA_MAX ? `${rendered.slice(0, SCHEMA_MAX)}…` : rendered;
-}
-
-/** A non-empty string argument, or undefined (tolerates non-object rawArgs). */
-function strArg(raw: unknown, key: string): string | undefined {
-  const v = (raw as Record<string, unknown> | null | undefined)?.[key];
-  return typeof v === "string" && v.length > 0 ? v : undefined;
-}
-
-function notConnected(manager: McpManager, server: string): ToolOutput {
-  const connected = manager.connectedNames();
-  return { ok: false, output: `MCP server "${server}" is not connected. Connected: ${connected.length > 0 ? connected.join(", ") : "(none)"}` };
-}
-
-interface McpListArgs {
-  server?: string;
-  tool?: string;
-  schema?: boolean;
-}
-
-interface McpCallArgs {
-  server?: string;
-  tool?: string;
-  args?: unknown;
-}
-
-/** Build the house tools bound to a manager: [mcp_list, mcp_call, mcp_prompts, mcp_prompt, mcp_resources, mcp_read]. */
-export function createMcpTools(manager: McpManager): Tool[] {
-  const list: Tool = {
-    schema: {
-      name: "mcp_list",
-      description:
-        "List tools on connected MCP servers as 'server/tool — description'. " +
-        "With {server, tool, schema:true} returns that one tool's full JSON input schema.",
-      args: {
-        type: "object",
-        properties: {
-          server: { type: "string", description: "only list this server" },
-          tool: { type: "string", description: "tool name (for schema lookup)" },
-          schema: { type: "boolean", description: "return the full input schema for server+tool" },
-        },
-        additionalProperties: false,
-      },
-    },
-    kind: "read",
-    sequential: false,
-    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
-      const a = (rawArgs ?? {}) as McpListArgs;
-      const server = typeof a.server === "string" && a.server.length > 0 ? a.server : undefined;
-      const tool = typeof a.tool === "string" && a.tool.length > 0 ? a.tool : undefined;
-
-      // schema mode: full JSON schema for exactly one tool, on demand
-      if (a.schema === true || tool !== undefined) {
-        if (server === undefined || tool === undefined) {
-          return { ok: false, output: "schema lookup needs both server and tool, e.g. {server:\"x\", tool:\"y\", schema:true}" };
-        }
-        const schema = await manager.toolSchema(server, tool, ctx.signal);
-        if (schema === undefined) {
-          return { ok: false, output: `no schema for "${tool}" on "${server}" (unknown tool or server not connected); run mcp_list first` };
-        }
-        return { ok: true, output: `input schema for ${server}/${tool}: ${renderSchema(schema)}`, data: schema };
-      }
-
-      // index mode: compact one-liners only
-      const tools = await manager.listTools(false, ctx.signal);
-      const filtered = server === undefined ? tools : tools.filter((t) => t.server === server);
-      if (filtered.length === 0) {
-        const connected = manager.connectedNames();
-        if (server !== undefined && !connected.includes(server)) {
-          return { ok: false, output: `MCP server "${server}" is not connected. Connected: ${connected.length > 0 ? connected.join(", ") : "(none)"}` };
-        }
-        return { ok: true, output: connected.length === 0 ? "no MCP servers connected" : "no tools advertised by connected MCP servers" };
-      }
-      const lines = filtered.map((t) => `${t.server}/${t.name} — ${compact(t.description)}`);
-      lines.push("", "call with mcp_call {server, tool, args}; arg schema via mcp_list {server, tool, schema:true}");
-      return { ok: true, output: lines.join("\n"), data: filtered };
-    },
-  };
-
-  const call: Tool = {
-    schema: {
-      name: "mcp_call",
-      description:
-        "Call a tool on a connected MCP server. Discover names with mcp_list; " +
-        "on argument errors the tool's input schema is included so you can retry.",
-      args: {
-        type: "object",
-        properties: {
-          server: { type: "string", description: "MCP server name" },
-          tool: { type: "string", description: "tool name on that server" },
-          args: { type: "object", description: "arguments matching the tool's input schema" },
-        },
-        required: ["server", "tool"],
-        additionalProperties: false,
-      },
-    },
-    kind: "custom", // policy maps this to action "tool.mcp_call" (prompt-gated by default)
-    interruptible: true,
-    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
-      const a = (rawArgs ?? {}) as McpCallArgs;
-      const server = typeof a.server === "string" && a.server.length > 0 ? a.server : undefined;
-      const tool = typeof a.tool === "string" && a.tool.length > 0 ? a.tool : undefined;
-      if (server === undefined || tool === undefined) {
-        return { ok: false, output: 'mcp_call requires string "server" and "tool" (discover them with mcp_list)' };
-      }
-
-      const res = await manager.callTool(server, tool, a.args, ctx.signal, ctx.onUpdate);
-      if (res.ok) return { ok: true, output: res.output };
-
-      // validation-error path: attach the input schema (cache-hot after the call
-      // above) so the model can self-correct without a discovery round-trip.
-      let output = res.output;
-      if (!ctx.signal.aborted) {
-        const schema = await manager.toolSchema(server, tool, ctx.signal);
-        if (schema !== undefined) output += `\n\ninput schema for ${server}/${tool}: ${renderSchema(schema)}`;
-      }
-      return { ok: false, output };
-    },
-  };
-
-  const depth = depthFor(manager);
-  const serverOpt = { server: { type: "string", description: "only list this server" } };
-
-  const prompts: Tool = {
-    schema: {
-      name: "mcp_prompts",
-      description: "List prompts on connected MCP servers as 'server/name — description (args: a, b*)', * = required. Render one with mcp_prompt.",
-      args: { type: "object", properties: serverOpt, additionalProperties: false },
-    },
-    kind: "read",
-    sequential: false,
-    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
-      const server = strArg(rawArgs, "server");
-      let rows: McpPromptInfo[];
-      const notes: string[] = [];
-      if (server !== undefined) {
-        if (!manager.connectedNames().includes(server)) return notConnected(manager, server);
-        try {
-          rows = await depth.promptsOf(server, ctx.signal);
-        } catch (err) {
-          return { ok: false, output: `failed to list prompts on "${server}": ${message(err)}` };
-        }
-      } else {
-        const r = await depth.listPrompts(ctx.signal);
-        rows = r.prompts;
-        notes.push(...r.notes);
-      }
-      const lines = rows.map((p) => {
-        const args = p.arguments.map((a) => (a.required ? `${a.name}*` : a.name)).join(", ");
-        return `${p.server}/${p.name} — ${compact(p.description)}${args ? ` (args: ${args})` : ""}`;
-      });
-      if (lines.length === 0) {
-        lines.push(manager.connectedNames().length === 0 ? "no MCP servers connected" : `no prompts advertised by ${server === undefined ? "connected MCP servers" : `"${server}"`}`);
-      } else lines.push("", "render with mcp_prompt {server, name, args}");
-      return { ok: true, output: [...lines, ...notes.map((n) => `note: ${n}`)].join("\n"), data: rows };
-    },
-  };
-
-  const prompt: Tool = {
-    schema: {
-      name: "mcp_prompt",
-      description: "Render a prompt from an MCP server (prompts/get) as '[role] text' lines. Names and args via mcp_prompts.",
-      args: {
-        type: "object",
-        properties: {
-          server: { type: "string", description: "MCP server name" },
-          name: { type: "string", description: "prompt name on that server" },
-          args: { type: "object", description: "prompt arguments (string values)" },
-        },
-        required: ["server", "name"],
-        additionalProperties: false,
-      },
-    },
-    kind: "read",
-    interruptible: true,
-    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
-      const server = strArg(rawArgs, "server");
-      const name = strArg(rawArgs, "name");
-      if (server === undefined || name === undefined) {
-        return { ok: false, output: 'mcp_prompt requires string "server" and "name" (discover them with mcp_prompts)' };
-      }
-      return depth.getPrompt(server, name, (rawArgs as { args?: unknown } | null | undefined)?.args, ctx.signal);
-    },
-  };
-
-  const resources: Tool = {
-    schema: {
-      name: "mcp_resources",
-      description: "List resources (and URI templates) on connected MCP servers as 'server uri — name: description [mime]'. Read one with mcp_read.",
-      args: { type: "object", properties: serverOpt, additionalProperties: false },
-    },
-    kind: "read",
-    sequential: false,
-    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
-      const server = strArg(rawArgs, "server");
-      let index: McpResourceIndex;
-      const notes: string[] = [];
-      if (server !== undefined) {
-        if (!manager.connectedNames().includes(server)) return notConnected(manager, server);
-        try {
-          index = await depth.resourcesOf(server, ctx.signal);
-        } catch (err) {
-          return { ok: false, output: `failed to list resources on "${server}": ${message(err)}` };
-        }
-      } else {
-        const r = await depth.listResources(ctx.signal);
-        index = r.index;
-        notes.push(...r.notes);
-      }
-      const tail = (name: string, desc: string, mime: string | undefined): string =>
-        `${name || "(unnamed)"}${desc ? `: ${compact(desc)}` : ""}${mime ? ` [${mime}]` : ""}`;
-      const lines = [
-        ...index.resources.map((r) => `${r.server} ${r.uri} — ${tail(r.name, r.description, r.mimeType)}`),
-        ...index.templates.map((t) => `${t.server} template ${t.uriTemplate} — ${tail(t.name, t.description, t.mimeType)}`),
-      ];
-      if (lines.length === 0) {
-        lines.push(manager.connectedNames().length === 0 ? "no MCP servers connected" : `no resources advertised by ${server === undefined ? "connected MCP servers" : `"${server}"`}`);
-      } else lines.push("", "read with mcp_read {server, uri} (fill a template's {variables} first)");
-      return { ok: true, output: [...lines, ...notes.map((n) => `note: ${n}`)].join("\n"), data: index };
-    },
-  };
-
-  const read: Tool = {
-    schema: {
-      name: "mcp_read",
-      description: "Read one MCP resource by uri (resources/read): text as-is, binary as an annotated base64 blob; output capped at 10k chars.",
-      args: {
-        type: "object",
-        properties: {
-          server: { type: "string", description: "MCP server name" },
-          uri: { type: "string", description: "resource uri (from mcp_resources)" },
-        },
-        required: ["server", "uri"],
-        additionalProperties: false,
-      },
-    },
-    kind: "read",
-    interruptible: true,
-    async execute(rawArgs: unknown, ctx: ToolContext): Promise<ToolOutput> {
-      const server = strArg(rawArgs, "server");
-      const uri = strArg(rawArgs, "uri");
-      if (server === undefined || uri === undefined) {
-        return { ok: false, output: 'mcp_read requires string "server" and "uri" (discover them with mcp_resources)' };
-      }
-      return depth.readResource(server, uri, ctx.signal);
-    },
-  };
-
-  return [list, call, prompts, prompt, resources, read];
-}

package/src/mcp/transport.ts

@@ -1,122 +0,0 @@
-/** MCP transport construction + connect-error text (ported 2026-09-07 from the upstream harness's port #57/#76
- *  split of client.ts; the move changes no behaviour). `buildTransport` maps a config + wire to the SDK transport:
- *  the stdio child, streamable HTTP, or the legacy HTTP+SSE wire, with the static `headers` on every request and
- *  the rovecode `OAuthClientProvider` when one applies (mcp/oauth.ts runtimeAuthProvider): the SDK injects
- *  `Authorization: Bearer <access>` from it on every GET/POST of both url wires and runs its 401 → auth() pass;
- *  `requestInit.headers` is spread LAST inside the SDK (client/streamableHttp.js _commonHeaders, sse.js alike), and the
- *  factory hands out no provider when an Authorization header is configured, so static auth always wins.
- *  `describeError` turns a connect failure into the failed[] / status-row / mcp_call text: the SDK's StreamableHTTPError
- *  keeps the HTTP status only in `.code`, so a bare "Error POSTing to endpoint: nope" gets "(HTTP 500)" back; a 401 on a
- *  url server (either wire), the SDK's UnauthorizedError and McpNeedsLoginError all become the short remedy
- *  `needs login — run \`rovecode mcp login <name>\`` (≤ 80 chars for a 20-char name, so status.ts's clip keeps it whole) —
- *  a 401 against a configured static Authorization header names that header instead. Never a token.
- *
- *  Lazy SDK (rovecode): this module, like client.ts, imports only TYPES at load. The MCP SDK is ~200 ms of module
- *  evaluation (zod schemas for every protocol message) and used to be paid inside createRuntime, before the terminal
- *  had painted anything; mcp.test.ts pins that importing client.ts pulls in no @modelcontextprotocol module. So the
- *  SDK is loaded here once, on the first connect (`loadSdk`), and the error classes and the list_changed notification
- *  schemas come out of that same load. `describeError` / `isSseOnlySignature` are synchronous: before the SDK has
- *  loaded no SDK error can exist, so `sdkIfLoaded()` being null simply means the plain-message path. */
-
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { message, type McpServerConfig } from "./config.ts";
-import { McpNeedsLoginError, hasStaticAuthorization, needsLoginText } from "./shared.ts";
-
-/** Everything the manager needs from the SDK, loaded together on the connect path. */
-export interface Sdk {
-  Client: typeof import("@modelcontextprotocol/sdk/client/index.js").Client;
-  StdioClientTransport: typeof import("@modelcontextprotocol/sdk/client/stdio.js").StdioClientTransport;
-  getDefaultEnvironment: typeof import("@modelcontextprotocol/sdk/client/stdio.js").getDefaultEnvironment;
-  StreamableHTTPClientTransport: typeof import("@modelcontextprotocol/sdk/client/streamableHttp.js").StreamableHTTPClientTransport;
-  StreamableHTTPError: typeof import("@modelcontextprotocol/sdk/client/streamableHttp.js").StreamableHTTPError;
-  SSEClientTransport: typeof import("@modelcontextprotocol/sdk/client/sse.js").SSEClientTransport;
-  SseError: typeof import("@modelcontextprotocol/sdk/client/sse.js").SseError;
-  UnauthorizedError: typeof import("@modelcontextprotocol/sdk/client/auth.js").UnauthorizedError;
-  ToolListChangedNotificationSchema: typeof import("@modelcontextprotocol/sdk/types.js").ToolListChangedNotificationSchema;
-  PromptListChangedNotificationSchema: typeof import("@modelcontextprotocol/sdk/types.js").PromptListChangedNotificationSchema;
-  ResourceListChangedNotificationSchema: typeof import("@modelcontextprotocol/sdk/types.js").ResourceListChangedNotificationSchema;
-}
-
-let sdkPromise: Promise<Sdk> | null = null;
-let loaded: Sdk | null = null;
-
-/** The SDK, loaded once (all six modules together) — the first connect pays it, nothing at boot does. */
-export function loadSdk(): Promise<Sdk> {
-  sdkPromise ??= Promise.all([
-    import("@modelcontextprotocol/sdk/client/index.js"),
-    import("@modelcontextprotocol/sdk/client/stdio.js"),
-    import("@modelcontextprotocol/sdk/client/streamableHttp.js"),
-    import("@modelcontextprotocol/sdk/client/sse.js"),
-    import("@modelcontextprotocol/sdk/client/auth.js"),
-    import("@modelcontextprotocol/sdk/types.js"),
-  ]).then(([index, stdio, http, sse, auth, types]) => {
-    loaded = {
-      Client: index.Client,
-      StdioClientTransport: stdio.StdioClientTransport,
-      getDefaultEnvironment: stdio.getDefaultEnvironment,
-      StreamableHTTPClientTransport: http.StreamableHTTPClientTransport,
-      StreamableHTTPError: http.StreamableHTTPError,
-      SSEClientTransport: sse.SSEClientTransport,
-      SseError: sse.SseError,
-      UnauthorizedError: auth.UnauthorizedError,
-      ToolListChangedNotificationSchema: types.ToolListChangedNotificationSchema,
-      PromptListChangedNotificationSchema: types.PromptListChangedNotificationSchema,
-      ResourceListChangedNotificationSchema: types.ResourceListChangedNotificationSchema,
-    };
-    return loaded;
-  });
-  return sdkPromise;
-}
-
-/** The SDK once loadSdk() has resolved; null before (and then no SDK-built error can exist yet). */
-export function sdkIfLoaded(): Sdk | null {
-  return loaded;
-}
-
-/** The initialize POST hitting an SSE-only server: 404 (no such route) or 405 (GET-only route). */
-export function isSseOnlySignature(err: unknown): boolean {
-  const sdk = loaded;
-  return sdk !== null && err instanceof sdk.StreamableHTTPError && (err.code === 404 || err.code === 405);
-}
-
-/** a 401 from either url wire: StreamableHTTPError / SseError carry it in `.code`; the SSE POST path only in its text */
-function isUnauthorized(err: unknown): boolean {
-  const sdk = loaded;
-  if (sdk !== null && (err instanceof sdk.StreamableHTTPError || err instanceof sdk.SseError)) return err.code === 401;
-  return err instanceof Error && /\(HTTP 401\)/.test(err.message);
-}
-
-/** Error text for failed[] / status rows / mcp_call (see the header). */
-export function describeError(err: unknown, config: Pick<McpServerConfig, "name" | "headers">): string {
-  if (err instanceof McpNeedsLoginError) return err.message;
-  const sdk = loaded;
-  if ((sdk !== null && err instanceof sdk.UnauthorizedError) || isUnauthorized(err)) {
-    return hasStaticAuthorization(config) ? "HTTP 401 — the configured Authorization header was rejected" : needsLoginText(config.name);
-  }
-  const text = message(err);
-  return sdk !== null && err instanceof sdk.StreamableHTTPError && typeof err.code === "number" && err.code > 0 && !text.includes(String(err.code)) ? `${text} (HTTP ${err.code})` : text;
-}
-
-/** The SDK transport for one config on one wire (the http → sse fallback calls this twice). */
-export async function buildTransport(config: McpServerConfig, wire: McpServerConfig["transport"], authProvider?: OAuthClientProvider): Promise<Transport> {
-  const sdk = await loadSdk();
-  if (wire === "http" || wire === "sse") {
-    if (config.url === undefined) throw new Error(`${wire} server "${config.name}" has no url`);
-    // headers (auth tokens etc.) ride on every request via fetch's RequestInit — the SSE transport applies them to
-    // the GET stream and to each POST alike; the provider (port #76) is the SDK's own bearer + 401-refresh seam
-    const opts = {
-      ...(config.headers ? { requestInit: { headers: config.headers } } : {}),
-      ...(authProvider ? { authProvider } : {}),
-    };
-    const url = new URL(config.url);
-    return wire === "http" ? new sdk.StreamableHTTPClientTransport(url, opts) : new sdk.SSEClientTransport(url, opts);
-  }
-  if (config.command === undefined) throw new Error(`stdio server "${config.name}" has no command`);
-  return new sdk.StdioClientTransport({
-    command: config.command,
-    args: config.args ?? [],
-    env: { ...sdk.getDefaultEnvironment(), ...(config.env ?? {}) },
-    stderr: "ignore",
-  });
-}

package/src/mcp/trust.ts

@@ -1,25 +0,0 @@
-/** Trust for PROJECT MCP files (.rovecode/mcp.json, .mcp.json) — since 2026-09-07 one name for the general project
- *  trust store in core/trust.ts (the same store and the same bar as project plugins: ~/.rovecode/plugins.json `trusted`,
- *  keyed by the file's absolute path, value = sha256 of its bytes). The store lives in the USER home, so a repo cannot
- *  trust itself; any edit to the file changes the digest and the gate asks again. An untrusted file contributes NOTHING
- *  (config.ts loadMcpConfig skips it with one warning) — absence, not "loaded but marked". Berkay's choice on top of the
- *  gate: files he writes himself through `mcp add --project` / `mcp remove --project` are trusted the moment he approves
- *  them (market-install.ts records the digest right after the write); hand-edited and cloned files ask.
- *  `rovecode mcp trust` acts on the MCP files only; `rovecode trust` (cli/trust-cmd.ts) on every gated project file. */
-
-import { existsSync } from "node:fs";
-import { fileDigest, fileTrustStatus, trustFile, trustedPredicate, untrustFile, type TrustStatus } from "../core/trust.ts";
-import { mcpConfigFiles } from "./config.ts";
-
-export { fileDigest, trustedPredicate };
-export type { TrustStatus };
-
-export const mcpTrustStatus = fileTrustStatus;
-export const trustMcpFile = trustFile;
-export const untrustMcpFile = untrustFile;
-
-/** the project files that exist in this checkout — what `mcp trust` / `mcp show` act on */
-export function projectMcpFiles(cwd: string): string[] {
-  const f = mcpConfigFiles(cwd);
-  return [f.harvest, f.project].filter((p) => existsSync(p));
-}