Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
45.7 KB
Raw Blame
import { afterEach, describe, expect, test } from "bun:test";
import { spawn, type ChildProcess } from "node:child_process";
import { createCipheriv, randomBytes } from "node:crypto";
import { existsSync } from "node:fs";
import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join, resolve } from "node:path";
import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
import { EnterpriseMcpClientError } from "@omnirush/enterprise-mcp-client";

import { ApiError } from "./errors.js";
import {
  createLocalManagedMcpConnection,
  deleteLocalManagedMcp,
  listLocalManagedMcpConnectionsSafe,
  setLocalManagedMcpEnabled,
} from "./local-managed-mcp.js";
import { runtimeStorageDir } from "./runtime-db.js";
import { readRuntimeMcpConfig, runtimeMcpMap, writeRuntimeOpencodeConfig } from "./runtime-opencode-config-store.js";
import { startServer } from "./server.js";
import type { ServerConfig } from "./types.js";

type Served = { port: number; stop: () => void | Promise<void> };
type EngineRequest = { method: string; pathname: string; body: unknown };

const repoRoot = resolve(import.meta.dir, "../../..");
const stops: Array<() => void | Promise<void>> = [];
const roots: string[] = [];
const children: ChildProcess[] = [];

afterEach(async () => {
  while (stops.length) await stops.pop()?.();
  while (children.length) children.pop()?.kill();
  while (roots.length) await rm(roots.pop()!, { recursive: true, force: true });
});

async function freePort(): Promise<number> {
  const server = Bun.serve({ hostname: "127.0.0.1", port: 0, fetch: () => new Response("") });
  const port = server.port;
  server.stop(true);
  if (port === undefined) throw new Error("failed to allocate a free port");
  return port;
}

async function waitFor<T>(read: () => Promise<T | null>, label: string, timeoutMs = 10_000): Promise<T> {
  const deadline = Date.now() + timeoutMs;
  let lastError: unknown = null;
  while (Date.now() < deadline) {
    try {
      const value = await read();
      if (value !== null) return value;
    } catch (error) {
      lastError = error;
    }
    await Bun.sleep(50);
  }
  throw new Error(`timed out waiting for ${label}${lastError ? `: ${String(lastError)}` : ""}`);
}

function startMockOpencode() {
  const requests: EngineRequest[] = [];
  const server = Bun.serve({
    hostname: "127.0.0.1",
    port: 0,
    async fetch(request) {
      const url = new URL(request.url);
      const body = request.method === "POST" ? await request.json().catch(() => null) : null;
      requests.push({ method: request.method, pathname: url.pathname, body });
      if (url.pathname === "/mcp" && request.method === "POST") {
        const name = typeof body === "object" && body !== null && "name" in body ? String(body.name) : "managed";
        return Response.json({ [name]: { status: "connected" } });
      }
      if (url.pathname === "/mcp" && request.method === "GET") return Response.json({});
      if (url.pathname === "/instance/dispose") return Response.json({ disposed: true });
      if (/^\/mcp\/[^/]+\/disconnect$/.test(url.pathname)) return Response.json({});
      return Response.json({ code: "not_found", message: "Not found" }, { status: 404 });
    },
  }) as Served;
  stops.push(() => server.stop());
  return { server, requests };
}

async function startOAuthProvider(port: number): Promise<string> {
  const child = spawn("node", [join(repoRoot, "scripts/mock-oauth-mcp-server.mjs")], {
    env: {
      ...process.env,
      PORT: String(port),
      AUTO_APPROVE: "1",
      STRICT_REFRESH_TOKENS: "1",
      MOCK_ERROR_TOOL_NAME: "mock_provider_error",
    },
    stdio: "ignore",
  });
  children.push(child);
  const baseUrl = `http://127.0.0.1:${port}`;
  await waitFor(async () => (await fetch(`${baseUrl}/health`)).ok ? baseUrl : null, "OAuth MCP mock");
  return baseUrl;
}

type HandshakeFailure = "oauth-client-registration" | "mcp-discovery" | "mcp-initialize" | "unexpected-sdk-failure";

function startHandshakeFailureProvider(failure: HandshakeFailure): string {
  const nestedSecret = `${failure}-nested-secret`;
  const server = Bun.serve({
    hostname: "127.0.0.1",
    port: 0,
    async fetch(request) {
      const url = new URL(request.url);
      const origin = url.origin;
      if (url.pathname === "/.well-known/oauth-protected-resource"
        || url.pathname === "/.well-known/oauth-protected-resource/mcp"
        || url.pathname === "/mcp/.well-known/oauth-protected-resource") {
        return Response.json({
          resource: `${origin}/mcp`,
          authorization_servers: [origin],
          scopes_supported: ["mcp:read"],
        });
      }
      if (url.pathname === "/.well-known/oauth-authorization-server"
        || url.pathname === "/.well-known/oauth-authorization-server/mcp") {
        return Response.json({
          issuer: origin,
          authorization_endpoint: `${origin}/authorize`,
          token_endpoint: `${origin}/token`,
          registration_endpoint: `${origin}/register`,
          response_types_supported: ["code"],
          grant_types_supported: ["authorization_code", "refresh_token"],
          token_endpoint_auth_methods_supported: ["none"],
          code_challenge_methods_supported: ["S256"],
          scopes_supported: ["mcp:read"],
        });
      }
      if (url.pathname === "/register" && request.method === "POST") {
        if (failure === "oauth-client-registration") {
          return Response.json({
            error: "invalid_client_metadata",
            error_description: nestedSecret,
            client_secret: nestedSecret,
          }, { status: 400 });
        }
        if (failure === "unexpected-sdk-failure") {
          return Response.json({ client_id: 42 }, { status: 201 });
        }
        const body: unknown = await request.json();
        const redirectUris = typeof body === "object" && body !== null && "redirect_uris" in body
          && Array.isArray(body.redirect_uris)
          ? body.redirect_uris.filter((value): value is string => typeof value === "string")
          : [];
        return Response.json({
          client_id: "handshake-witness-client",
          client_id_issued_at: Math.floor(Date.now() / 1_000),
          token_endpoint_auth_method: "none",
          redirect_uris: redirectUris,
          grant_types: ["authorization_code", "refresh_token"],
          response_types: ["code"],
          scope: "mcp:read",
        }, { status: 201 });
      }
      if (url.pathname === "/authorize" && request.method === "GET") {
        const callback = new URL(url.searchParams.get("redirect_uri") ?? "");
        callback.searchParams.set("code", "handshake-witness-code");
        callback.searchParams.set("state", url.searchParams.get("state") ?? "");
        return new Response(null, { status: 302, headers: { location: callback.toString() } });
      }
      if (url.pathname === "/token" && request.method === "POST") {
        return Response.json({
          access_token: "handshake-witness-access-token",
          refresh_token: "handshake-witness-refresh-token",
          token_type: "Bearer",
          expires_in: 3600,
          scope: "mcp:read",
        });
      }
      if (url.pathname === "/mcp") {
        if (request.headers.get("authorization") !== "Bearer handshake-witness-access-token") {
          return Response.json({ error: "missing_token" }, {
            status: 401,
            headers: { "www-authenticate": `Bearer resource_metadata="${origin}/.well-known/oauth-protected-resource"` },
          });
        }
        const body: unknown = await request.json().catch(() => null);
        const method = typeof body === "object" && body !== null && "method" in body ? body.method : null;
        const id = typeof body === "object" && body !== null && "id" in body ? body.id : null;
        if (method === "server/discover" && failure === "mcp-discovery") {
          return Response.json({
            error: "provider_discovery_failed",
            cause: { client_secret: nestedSecret },
          }, { status: 503 });
        }
        if (method === "initialize") {
          if (failure === "mcp-initialize") {
            return Response.json({
              error: "provider_initialize_failed",
              cause: { client_secret: nestedSecret },
            }, { status: 503 });
          }
          return Response.json({
            jsonrpc: "2.0",
            id,
            result: {
              protocolVersion: "2025-06-18",
              capabilities: { tools: {} },
              serverInfo: { name: "handshake-witness", version: "1.0.0" },
            },
          });
        }
        if (method === "notifications/initialized") return new Response(null, { status: 202 });
        if (method === "tools/list") {
          return Response.json({ jsonrpc: "2.0", id, result: { tools: [] } });
        }
      }
      return Response.json({ error: "not_found" }, { status: 404 });
    },
  });
  stops.push(() => server.stop());
  return `http://127.0.0.1:${server.port}`;
}

function createConfig(input: {
  port: number;
  workspaceRoot: string;
  engineBaseUrl: string;
  vaultKey: Uint8Array;
}): ServerConfig {
  return {
    host: "127.0.0.1",
    port: input.port,
    token: "owt_local_managed_test",
    hostToken: "owh_local_managed_test",
    approval: { mode: "auto", timeoutMs: 1_000 },
    corsOrigins: ["*"],
    workspaces: [{
      id: "ws_managed",
      name: "Managed OAuth Workspace",
      path: input.workspaceRoot,
      preset: "starter",
      workspaceType: "local",
      baseUrl: input.engineBaseUrl,
    }],
    authorizedRoots: [input.workspaceRoot],
    readOnly: false,
    startedAt: Date.now(),
    tokenSource: "cli",
    hostTokenSource: "cli",
    logFormat: "pretty",
    logRequests: false,
    localManagedMcpVaultKey: async () => input.vaultKey,
  };
}

function clientHeaders(token: string): HeadersInit {
  return { authorization: `Bearer ${token}`, "content-type": "application/json" };
}

async function connectGateway(runtimeConfig: Record<string, unknown>): Promise<Client> {
  const url = new URL(String(runtimeConfig.url));
  const headers = runtimeConfig.headers as Record<string, string>;
  const client = new Client({ name: "omnirush-managed-mcp-test", version: "1.0.0" }, { capabilities: {} });
  await client.connect(new StreamableHTTPClientTransport(url, { requestInit: { headers } }));
  return client;
}

describe("OmniRush.ai-managed local MCP OAuth gateway", () => {
  test("leaves ordinary MCP fallbacks usable when no managed vault exists", async () => {
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-fallback-"));
    roots.push(workspaceRoot);
    const config = createConfig({
      port: await freePort(),
      workspaceRoot,
      engineBaseUrl: "http://127.0.0.1:1",
      vaultKey: randomBytes(32),
    });
    config.configPath = join(workspaceRoot, "server.json");
    config.localManagedMcpVaultKey = async () => {
      throw new Error("vault key should not be requested");
    };

    expect(await setLocalManagedMcpEnabled(config, "ws_managed", "ordinary", false)).toBe(false);
    expect(await deleteLocalManagedMcp(config, "ws_managed", "ordinary")).toBe(false);
    expect(existsSync(join(runtimeStorageDir(config), "local-managed-mcp-vault.json"))).toBe(false);
  });

  test("rolls back a new managed connection when the initial OAuth handshake fails", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-rollback-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    process.env.OMNIRUSH_DEV_MODE = "1";

    try {
      const engine = startMockOpencode();
      const unavailableProviderPort = await freePort();
      const config = createConfig({
        port: await freePort(),
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey: randomBytes(32),
      });
      const server = await startServer(config);
      stops.push(() => server.stop());
      const omnirushBaseUrl = `http://127.0.0.1:${server.port}`;

      const created = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/managed`, {
        method: "POST",
        headers: clientHeaders(config.token),
        body: JSON.stringify({
          name: "unreachable-oauth",
          url: `http://127.0.0.1:${unavailableProviderPort}/mcp`,
          oauth: { applicationType: "native", requestedScopes: ["mcp:read"] },
        }),
      });
      expect(created.status).toBe(502);
      expect(await created.json()).toMatchObject({
        code: "managed_mcp_connection_failed",
        message: "OmniRush.ai could not connect to this MCP server. Check its OAuth settings and availability, then try again.",
      });

      const status = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/unreachable-oauth/managed`,
        { headers: clientHeaders(config.token) },
      );
      expect(status.status).toBe(404);
      expect(await readRuntimeMcpConfig(config, "ws_managed", "unreachable-oauth")).toBeNull();
    } finally {
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
    }
  });

  test("returns safe connection errors for DCR and protocol negotiation failures", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const previousTelemetry = globalThis.__omnirushDesktopTelemetry;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-handshake-errors-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    process.env.OMNIRUSH_DEV_MODE = "1";
    const captured: unknown[] = [];
    globalThis.__omnirushDesktopTelemetry = {
      captureException: (error) => {
        captured.push(error);
        return true;
      },
    };

    try {
      const engine = startMockOpencode();
      const config = createConfig({
        port: await freePort(),
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey: randomBytes(32),
      });
      const server = await startServer(config);
      stops.push(() => server.stop());
      const omnirushBaseUrl = `http://127.0.0.1:${server.port}`;
      const expectedMessage = "OmniRush.ai could not connect to this MCP server. Check its OAuth settings and availability, then try again.";

      const registrationProvider = startHandshakeFailureProvider("oauth-client-registration");
      await createLocalManagedMcpConnection(config, {
        workspaceId: "ws_managed",
        name: "registration-failure",
        serverUrl: `${registrationProvider}/mcp`,
        oauth: { applicationType: "native", requestedScopes: ["mcp:read"] },
      });
      const reconnect = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/registration-failure/managed/connect`,
        { method: "POST", headers: clientHeaders(config.token) },
      );
      expect(reconnect.status).toBe(502);
      const reconnectBody = await reconnect.json();
      expect(reconnectBody).toEqual({
        code: "managed_mcp_connection_failed",
        message: expectedMessage,
      });
      expect(JSON.stringify(reconnectBody)).not.toContain("oauth-client-registration-nested-secret");
      const reconnectStatus = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/registration-failure/managed`,
        { headers: clientHeaders(config.token) },
      );
      expect(await reconnectStatus.json()).toMatchObject({
        status: "reconnect_required",
        lastError: expectedMessage,
        hasCredential: false,
      });

      const initializeProvider = startHandshakeFailureProvider("mcp-initialize");
      await createLocalManagedMcpConnection(config, {
        workspaceId: "ws_managed",
        name: "initialize-failure",
        serverUrl: `${initializeProvider}/mcp`,
        oauth: { applicationType: "native", requestedScopes: ["mcp:read"] },
      });
      const started = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/initialize-failure/managed/connect`,
        { method: "POST", headers: clientHeaders(config.token) },
      );
      expect(started.status).toBe(200);
      const startedBody: unknown = await started.json();
      if (typeof startedBody !== "object" || startedBody === null
        || !("authorizeUrl" in startedBody) || typeof startedBody.authorizeUrl !== "string") {
        throw new Error("Expected an OAuth authorization URL.");
      }
      expect(startedBody).toMatchObject({ status: "needs_auth" });
      const authorization = await fetch(startedBody.authorizeUrl, { redirect: "manual" });
      expect(authorization.status).toBe(302);
      const callback = await fetch(authorization.headers.get("location")!);
      expect(callback.status).toBe(502);
      const callbackBody = await callback.json();
      expect(callbackBody).toEqual({
        code: "managed_mcp_connection_failed",
        message: expectedMessage,
      });
      expect(JSON.stringify(callbackBody)).not.toContain("mcp-initialize-nested-secret");
      const callbackStatus = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/initialize-failure/managed`,
        { headers: clientHeaders(config.token) },
      );
      expect(await callbackStatus.json()).toMatchObject({
        status: "reconnect_required",
        lastError: expectedMessage,
        hasCredential: false,
      });

      const discoveryProvider = startHandshakeFailureProvider("mcp-discovery");
      await createLocalManagedMcpConnection(config, {
        workspaceId: "ws_managed",
        name: "discovery-failure",
        serverUrl: `${discoveryProvider}/mcp`,
        oauth: { applicationType: "native", requestedScopes: ["mcp:read"] },
      });
      const discoveryStarted = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/discovery-failure/managed/connect`,
        { method: "POST", headers: clientHeaders(config.token) },
      );
      expect(discoveryStarted.status).toBe(200);
      const discoveryStartedBody: unknown = await discoveryStarted.json();
      if (typeof discoveryStartedBody !== "object" || discoveryStartedBody === null
        || !("authorizeUrl" in discoveryStartedBody) || typeof discoveryStartedBody.authorizeUrl !== "string") {
        throw new Error("Expected an OAuth authorization URL.");
      }
      const discoveryAuthorization = await fetch(discoveryStartedBody.authorizeUrl, { redirect: "manual" });
      expect(discoveryAuthorization.status).toBe(302);
      const discoveryCallback = await fetch(discoveryAuthorization.headers.get("location")!);
      expect(discoveryCallback.status).toBe(502);
      const discoveryCallbackBody = await discoveryCallback.json();
      expect(discoveryCallbackBody).toEqual({
        code: "managed_mcp_connection_failed",
        message: expectedMessage,
      });
      expect(JSON.stringify(discoveryCallbackBody)).not.toContain("mcp-discovery-nested-secret");
      const discoveryStatus = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/discovery-failure/managed`,
        { headers: clientHeaders(config.token) },
      );
      expect(await discoveryStatus.json()).toMatchObject({
        status: "reconnect_required",
        lastError: expectedMessage,
        hasCredential: false,
      });
      expect(captured).toEqual([]);

      const internalProvider = startHandshakeFailureProvider("unexpected-sdk-failure");
      await createLocalManagedMcpConnection(config, {
        workspaceId: "ws_managed",
        name: "unexpected-sdk-failure",
        serverUrl: `${internalProvider}/mcp`,
        oauth: { applicationType: "native", requestedScopes: ["mcp:read"] },
      });
      const internalFailure = await fetch(
        `${omnirushBaseUrl}/workspace/ws_managed/mcp/unexpected-sdk-failure/managed/connect`,
        { method: "POST", headers: clientHeaders(config.token) },
      );
      expect(internalFailure.status).toBe(500);
      expect(await internalFailure.json()).toEqual({
        code: "internal_error",
        message: "Unexpected server error",
      });
      expect(captured).toHaveLength(1);
      expect(captured[0]).toBeInstanceOf(EnterpriseMcpClientError);
      expect(captured[0]).not.toBeInstanceOf(ApiError);
      expect(captured[0]).toMatchObject({
        code: "MCP_CONNECTION_HANDSHAKE_FAILED",
        requestPhase: "mcp-discovery",
      });
    } finally {
      globalThis.__omnirushDesktopTelemetry = previousTelemetry;
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
    }
  }, 30_000);

  test("returns actionable input errors without persisting managed connections", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const previousAllowPrivateUrls = process.env.OMNIRUSH_ALLOW_PRIVATE_MCP_URLS;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-input-errors-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    delete process.env.OMNIRUSH_DEV_MODE;
    delete process.env.OMNIRUSH_ALLOW_PRIVATE_MCP_URLS;

    try {
      const engine = startMockOpencode();
      const config = createConfig({
        port: await freePort(),
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey: randomBytes(32),
      });
      const server = await startServer(config);
      stops.push(() => server.stop());
      const omnirushBaseUrl = `http://127.0.0.1:${server.port}`;
      const cases = [
        { name: "malformed-url", url: "not-a-url", code: "managed_mcp_url_invalid", message: "not-a-url" },
        { name: "http-url", url: "http://example.com/mcp", code: "managed_mcp_url_not_allowed", message: "HTTPS" },
        {
          name: "unresolved-url",
          url: "https://managed-mcp-does-not-resolve.invalid/mcp",
          code: "managed_mcp_url_not_allowed",
          message: "resolve",
        },
      ];

      for (const input of cases) {
        const created = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/managed`, {
          method: "POST",
          headers: clientHeaders(config.token),
          body: JSON.stringify({ name: input.name, url: input.url, oauth: { applicationType: "native" } }),
        });
        expect(created.status).toBe(400);
        expect(await created.json()).toMatchObject({
          code: input.code,
          message: expect.stringContaining(input.message),
        });

        const list = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp`, {
          headers: clientHeaders(config.token),
        });
        expect(list.status).toBe(200);
        expect(JSON.stringify(await list.json())).not.toContain(`"name":"${input.name}"`);
        const status = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/${input.name}/managed`, {
          headers: clientHeaders(config.token),
        });
        expect(status.status).toBe(404);
      }
    } finally {
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
      if (previousAllowPrivateUrls === undefined) delete process.env.OMNIRUSH_ALLOW_PRIVATE_MCP_URLS;
      else process.env.OMNIRUSH_ALLOW_PRIVATE_MCP_URLS = previousAllowPrivateUrls;
    }
  });

  test("owns OAuth, exposes provider tools to OpenCode, refreshes, survives restart, and disconnects", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    process.env.OMNIRUSH_DEV_MODE = "1";

    try {
      const engine = startMockOpencode();
      const providerPort = await freePort();
      const providerBaseUrl = await startOAuthProvider(providerPort);
      const omnirushPort = await freePort();
      const vaultKey = randomBytes(32);
      const config = createConfig({
        port: omnirushPort,
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey,
      });
      const server = await startServer(config);
      stops.push(() => server.stop());
      const omnirushBaseUrl = `http://127.0.0.1:${server.port}`;

      const created = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/managed`, {
        method: "POST",
        headers: clientHeaders(config.token),
        body: JSON.stringify({
          name: "mock-oauth",
          url: `${providerBaseUrl}/mcp`,
          oauth: { applicationType: "native", requestedScopes: ["mcp:read", "mcp:write"] },
        }),
      });
      expect(created.status).toBe(201);
      const started = await created.json() as { status: string; authorizeUrl?: string };
      expect(started.status).toBe("needs_auth");
      expect(started.authorizeUrl).toBeTruthy();

      const authorization = await fetch(started.authorizeUrl!, { redirect: "manual" });
      expect(authorization.status).toBe(302);
      const callbackUrl = authorization.headers.get("location");
      expect(callbackUrl).toStartWith(`${omnirushBaseUrl}/mcp/oauth/callback`);
      const callback = await fetch(callbackUrl!);
      expect(callback.status).toBe(200);

      const status = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed`, {
        headers: clientHeaders(config.token),
      });
      expect(status.status).toBe(200);
      expect(await status.json()).toMatchObject({ status: "connected", hasCredential: true, enabled: true });

      const firstRuntimeConfig = await readRuntimeMcpConfig(config, "ws_managed", "mock-oauth");
      expect(firstRuntimeConfig).toMatchObject({ type: "remote", enabled: true, oauth: false });
      expect(String(firstRuntimeConfig?.url)).toStartWith(`${omnirushBaseUrl}/mcp/managed/ws_managed/mock-oauth`);
      expect(JSON.stringify(firstRuntimeConfig)).not.toContain(providerBaseUrl);
      expect(JSON.stringify(firstRuntimeConfig)).not.toContain("mock-access-");
      const unauthorizedGateway = await fetch(String(firstRuntimeConfig?.url), {
        method: "POST",
        headers: { "content-type": "application/json", accept: "application/json, text/event-stream" },
        body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} }),
      });
      expect(unauthorizedGateway.status).toBe(401);
      const engineRegistration = engine.requests.find((request) => request.pathname === "/mcp" && request.method === "POST");
      expect(engineRegistration?.body).toMatchObject({ name: "mock-oauth", config: firstRuntimeConfig });

      const firstClient = await connectGateway(firstRuntimeConfig!);
      expect((await firstClient.listTools()).tools.map((tool) => tool.name)).toContain("mock_echo");
      expect(await firstClient.callTool({ name: "mock_echo", arguments: { text: "through OmniRush.ai" } }))
        .toMatchObject({ content: [{ type: "text", text: "through OmniRush.ai" }] });
      await expect(firstClient.callTool({ name: "mock_provider_error", arguments: {} })).rejects.toThrow();
      const providerErrorStatus = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed`, {
        headers: clientHeaders(config.token),
      });
      expect(await providerErrorStatus.json()).toMatchObject({ status: "connected", hasCredential: true });
      await firstClient.close();

      const expired = await fetch(`${providerBaseUrl}/admin/expire-access-tokens`, { method: "POST" });
      expect(expired.ok).toBe(true);
      const refreshClient = await connectGateway(firstRuntimeConfig!);
      expect((await refreshClient.listTools()).tools.map((tool) => tool.name)).toContain("mock_echo");
      await refreshClient.close();
      const providerRequests = await (await fetch(`${providerBaseUrl}/requests`)).json() as {
        requests: Array<{ path: string; grantType?: string }>;
      };
      expect(providerRequests.requests.some((request) => request.path === "/token" && request.grantType === "refresh_token")).toBe(true);

      await server.stop();
      stops.pop();
      const restartedConfig = createConfig({
        port: omnirushPort,
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey,
      });
      const restartedServer = await startServer(restartedConfig);
      stops.push(() => restartedServer.stop());
      const restartedRuntimeConfig = await readRuntimeMcpConfig(restartedConfig, "ws_managed", "mock-oauth");
      expect(restartedRuntimeConfig).toMatchObject({ type: "remote", enabled: true, oauth: false });
      expect((restartedRuntimeConfig?.headers as Record<string, string>).Authorization)
        .not.toBe((firstRuntimeConfig?.headers as Record<string, string>).Authorization);
      const restartedClient = await connectGateway(restartedRuntimeConfig!);
      expect((await restartedClient.listTools()).tools.map((tool) => tool.name)).toContain("mock_echo");
      await restartedClient.close();

      const vaultText = await readFile(join(runtimeStorageDir(restartedConfig), "local-managed-mcp-vault.json"), "utf8");
      expect(vaultText).toContain('"algorithm":"aes-256-gcm"');
      expect(vaultText).not.toContain("mock-access-");
      expect(vaultText).not.toContain("refresh_token");
      expect(existsSync(join(runtimeStorageDir(restartedConfig), "local-managed-mcp-vault.key"))).toBe(false);

      const revoked = await fetch(`${providerBaseUrl}/admin/expire-oauth-tokens`, { method: "POST" });
      expect(revoked.ok).toBe(true);
      const revokedClient = await connectGateway(restartedRuntimeConfig!);
      await expect(revokedClient.listTools()).rejects.toThrow();
      await revokedClient.close();
      const revokedStatus = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed`, {
        headers: clientHeaders(restartedConfig.token),
      });
      expect(await revokedStatus.json()).toMatchObject({ status: "reconnect_required", hasCredential: false });

      const disconnected = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/auth`, {
        method: "DELETE",
        headers: clientHeaders(restartedConfig.token),
      });
      expect(disconnected.status).toBe(200);
      expect(await readRuntimeMcpConfig(restartedConfig, "ws_managed", "mock-oauth"))
        .toMatchObject({ enabled: false, oauth: false });

      const reconnect = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed/connect`, {
        method: "POST",
        headers: clientHeaders(restartedConfig.token),
      });
      expect(reconnect.status).toBe(200);
      expect(await reconnect.json()).toMatchObject({ status: "needs_auth" });
      const reconnectStatus = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed`, {
        headers: clientHeaders(restartedConfig.token),
      });
      expect(await reconnectStatus.json()).toMatchObject({ status: "needs_auth", enabled: true, hasCredential: false });
      expect(await readRuntimeMcpConfig(restartedConfig, "ws_managed", "mock-oauth"))
        .toMatchObject({ enabled: true, oauth: false });
      expect((await readdir(runtimeStorageDir(restartedConfig)))
        .some((entry) => entry.includes(".omnirush-backup-"))).toBe(false);
    } finally {
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
    }
  }, 60_000);

  test("quarantines and rebuilds the vault after a secure-storage key change, then reconnects", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-rotation-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    process.env.OMNIRUSH_DEV_MODE = "1";

    try {
      const engine = startMockOpencode();
      const providerBaseUrl = await startOAuthProvider(await freePort());
      const omnirushPort = await freePort();
      const config = createConfig({
        port: omnirushPort,
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey: randomBytes(32),
      });
      const server = await startServer(config);
      stops.push(() => server.stop());
      const omnirushBaseUrl = `http://127.0.0.1:${server.port}`;

      for (const name of ["mock-oauth", "mock-oauth-b"]) {
        const created = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/managed`, {
          method: "POST",
          headers: clientHeaders(config.token),
          body: JSON.stringify({
            name,
            url: `${providerBaseUrl}/mcp`,
            oauth: { applicationType: "native", requestedScopes: ["mcp:read"] },
          }),
        });
        expect(created.status).toBe(201);
        const started = await created.json() as { status: string; authorizeUrl?: string };
        expect(started.status).toBe("needs_auth");
        const authorization = await fetch(started.authorizeUrl!, { redirect: "manual" });
        expect(authorization.status).toBe(302);
        expect((await fetch(authorization.headers.get("location")!)).status).toBe(200);
      }

      await server.stop();
      stops.pop();

      const rotatedConfig = createConfig({
        port: omnirushPort,
        workspaceRoot,
        engineBaseUrl: `http://127.0.0.1:${engine.server.port}`,
        vaultKey: randomBytes(32),
      });
      const storageDir = runtimeStorageDir(rotatedConfig);
      const reconnectCopy = "Secure storage on this device changed, so saved sign-ins were cleared. Reconnect to restore this connection.";
      const scanVaultForSecrets = async () => {
        const text = await readFile(join(storageDir, "local-managed-mcp-vault.json"), "utf8");
        expect(text).toContain('"schemaVersion":2');
        expect(text).not.toContain("mock-access-");
        expect(text).not.toContain("refresh_token");
        expect(text).not.toContain("client_secret");
        expect(text).not.toContain("clientSecret");
        expect(text).not.toContain("codeVerifier");
      };

      const safeList = await listLocalManagedMcpConnectionsSafe(rotatedConfig, "ws_managed");
      expect(safeList.available).toBe(true);
      expect(safeList.connections.map((connection) => connection.name)).toEqual(["mock-oauth", "mock-oauth-b"]);
      for (const connection of safeList.connections) {
        expect(connection).toMatchObject({
          status: "reconnect_required",
          hasCredential: false,
          lastError: reconnectCopy,
        });
      }
      expect(safeList.recovery).toMatchObject({ reason: "secure_storage_changed" });

      const backups = (await readdir(storageDir))
        .filter((entry) => entry.startsWith("local-managed-mcp-vault.json.omnirush-backup-"));
      expect(backups).toHaveLength(1);
      expect(safeList.recovery?.quarantinedTo).toBe(backups[0]!);
      const backupValue = JSON.parse(await readFile(join(storageDir, backups[0]!), "utf8")) as {
        schemaVersion?: number;
        vault?: { algorithm?: string };
      };
      expect(backupValue.schemaVersion).toBe(2);
      expect(backupValue.vault?.algorithm).toBe("aes-256-gcm");
      await scanVaultForSecrets();

      const rotatedServer = await startServer(rotatedConfig);
      stops.push(() => rotatedServer.stop());

      // Engine boot-time tool discovery must not overwrite the recovery copy:
      // the gateway rejects, and the stored reconnect reason stays intact.
      const preReconnectRuntimeConfig = await readRuntimeMcpConfig(rotatedConfig, "ws_managed", "mock-oauth");
      const recoveredGatewayClient = await connectGateway(preReconnectRuntimeConfig!);
      await expect(recoveredGatewayClient.listTools()).rejects.toThrow();
      await recoveredGatewayClient.close();
      const afterDiscoveryFailure = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed`, {
        headers: clientHeaders(rotatedConfig.token),
      });
      expect(await afterDiscoveryFailure.json()).toMatchObject({
        status: "reconnect_required",
        hasCredential: false,
        lastError: reconnectCopy,
      });
      const safeListAfterDiscoveryFailure = await listLocalManagedMcpConnectionsSafe(rotatedConfig, "ws_managed");
      expect(safeListAfterDiscoveryFailure.connections
        .find((connection) => connection.name === "mock-oauth")?.lastError).toBe(reconnectCopy);

      const reconnect = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed/connect`, {
        method: "POST",
        headers: clientHeaders(rotatedConfig.token),
      });
      expect(reconnect.status).toBe(200);
      const restarted = await reconnect.json() as { status: string; authorizeUrl?: string };
      expect(restarted.status).toBe("needs_auth");
      expect(restarted.authorizeUrl).toBeTruthy();
      const reauthorization = await fetch(restarted.authorizeUrl!, { redirect: "manual" });
      expect(reauthorization.status).toBe(302);
      const callbackUrl = reauthorization.headers.get("location");
      expect(callbackUrl).toStartWith(`${omnirushBaseUrl}/mcp/oauth/callback`);
      expect((await fetch(callbackUrl!)).status).toBe(200);

      const reconnected = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth/managed`, {
        headers: clientHeaders(rotatedConfig.token),
      });
      expect(await reconnected.json()).toMatchObject({ status: "connected", hasCredential: true, enabled: true });
      const second = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp/mock-oauth-b/managed`, {
        headers: clientHeaders(rotatedConfig.token),
      });
      expect(await second.json()).toMatchObject({
        status: "reconnect_required",
        hasCredential: false,
        lastError: reconnectCopy,
      });

      const runtimeConfig = await readRuntimeMcpConfig(rotatedConfig, "ws_managed", "mock-oauth");
      const gatewayClient = await connectGateway(runtimeConfig!);
      expect((await gatewayClient.listTools()).tools.map((tool) => tool.name)).toContain("mock_echo");
      await gatewayClient.close();

      const workspaceMcp = await fetch(`${omnirushBaseUrl}/workspace/ws_managed/mcp`, {
        headers: clientHeaders(rotatedConfig.token),
      });
      expect(workspaceMcp.status).toBe(200);
      expect(await workspaceMcp.json()).toMatchObject({
        managedOAuthState: {
          available: true,
          recovery: { reason: "secure_storage_changed", quarantinedTo: backups[0]! },
        },
      });

      await scanVaultForSecrets();
      expect((await readdir(storageDir))
        .filter((entry) => entry.startsWith("local-managed-mcp-vault.json.omnirush-backup-"))).toHaveLength(1);
    } finally {
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
    }
  }, 60_000);

  test("serves the plaintext index read-only while secure storage is unavailable", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-unavailable-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    process.env.OMNIRUSH_DEV_MODE = "1";

    try {
      const config = createConfig({
        port: await freePort(),
        workspaceRoot,
        engineBaseUrl: "http://127.0.0.1:1",
        vaultKey: randomBytes(32),
      });
      const created = await createLocalManagedMcpConnection(config, {
        workspaceId: "ws_managed",
        name: "offline-vault",
        serverUrl: `http://127.0.0.1:${await freePort()}/mcp`,
        oauth: {},
      });
      expect(created.status).toBe("needs_auth");

      const unavailableConfig = createConfig({
        port: config.port,
        workspaceRoot,
        engineBaseUrl: "http://127.0.0.1:1",
        vaultKey: randomBytes(32),
      });
      unavailableConfig.localManagedMcpVaultKey = async () => {
        throw new Error("secure storage locked");
      };

      const safeList = await listLocalManagedMcpConnectionsSafe(unavailableConfig, "ws_managed");
      expect(safeList.available).toBe(false);
      expect(safeList.recovery).toBeNull();
      expect(safeList.connections).toHaveLength(1);
      expect(safeList.connections[0]).toMatchObject({
        name: "offline-vault",
        status: "needs_auth",
        hasCredential: false,
        enabled: true,
      });

      expect((await readdir(runtimeStorageDir(unavailableConfig)))
        .some((entry) => entry.includes(".omnirush-backup-"))).toBe(false);

      const failure = await setLocalManagedMcpEnabled(unavailableConfig, "ws_managed", "offline-vault", false)
        .then(() => null, (error: unknown) => error);
      expect(failure).toBeInstanceOf(ApiError);
      expect(failure).toMatchObject({ status: 503, code: "managed_mcp_secure_storage_unavailable" });
    } finally {
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
    }
  });

  test("quarantines a legacy v1 vault it cannot decrypt and prunes orphaned gateway runtime entries", async () => {
    const previousRuntimeDb = process.env.OMNIRUSH_RUNTIME_DB;
    const previousDevMode = process.env.OMNIRUSH_DEV_MODE;
    const workspaceRoot = await mkdtemp(join(tmpdir(), "omnirush-local-managed-mcp-v1-"));
    roots.push(workspaceRoot);
    process.env.OMNIRUSH_RUNTIME_DB = join(workspaceRoot, "runtime.sqlite");
    process.env.OMNIRUSH_DEV_MODE = "1";

    try {
      const config = createConfig({
        port: await freePort(),
        workspaceRoot,
        engineBaseUrl: "http://127.0.0.1:1",
        vaultKey: randomBytes(32),
      });
      const storageDir = runtimeStorageDir(config);
      await mkdir(storageDir, { recursive: true });

      const oldKey = randomBytes(32);
      const iv = randomBytes(12);
      const cipher = createCipheriv("aes-256-gcm", oldKey, iv);
      cipher.setAAD(Buffer.from("omnirush-local-managed-mcp-v1", "utf8"));
      const payload = JSON.stringify({
        schemaVersion: 1,
        connections: {
          [`${"ws_managed".length}:ws_managedlegacy-managed`]: { name: "legacy-managed" },
        },
      });
      const data = Buffer.concat([cipher.update(payload, "utf8"), cipher.final()]);
      await writeFile(join(storageDir, "local-managed-mcp-vault.json"), `${JSON.stringify({
        schemaVersion: 1,
        algorithm: "aes-256-gcm",
        iv: iv.toString("base64"),
        tag: cipher.getAuthTag().toString("base64"),
        data: data.toString("base64"),
      })}\n`, "utf8");

      await writeRuntimeOpencodeConfig(config, "ws_managed", (current) => ({
        ...current,
        mcp: {
          ...runtimeMcpMap(current),
          "legacy-managed": {
            type: "remote",
            url: `http://127.0.0.1:${config.port}/mcp/managed/ws_managed/legacy-managed`,
            enabled: true,
            headers: { Authorization: "Bearer stale-gateway-token" },
            oauth: false,
          },
          "keep-remote": { type: "remote", url: "https://example.com/mcp", enabled: true },
        },
      }));

      const safeList = await listLocalManagedMcpConnectionsSafe(config, "ws_managed");
      expect(safeList.available).toBe(true);
      expect(safeList.connections).toEqual([]);
      expect(safeList.recovery).toMatchObject({ reason: "secure_storage_changed" });

      const backups = (await readdir(storageDir))
        .filter((entry) => entry.startsWith("local-managed-mcp-vault.json.omnirush-backup-"));
      expect(backups).toHaveLength(1);
      expect(safeList.recovery?.quarantinedTo).toBe(backups[0]!);
      expect(JSON.parse(await readFile(join(storageDir, backups[0]!), "utf8"))).toMatchObject({
        schemaVersion: 1,
        algorithm: "aes-256-gcm",
      });

      const rebuilt = JSON.parse(await readFile(join(storageDir, "local-managed-mcp-vault.json"), "utf8")) as {
        schemaVersion?: number;
        index?: Record<string, unknown>;
        lastRecovery?: { quarantinedTo?: string };
      };
      expect(rebuilt.schemaVersion).toBe(2);
      expect(rebuilt.index).toEqual({});
      expect(rebuilt.lastRecovery?.quarantinedTo).toBe(backups[0]!);

      expect(await readRuntimeMcpConfig(config, "ws_managed", "legacy-managed")).toBeNull();
      expect(await readRuntimeMcpConfig(config, "ws_managed", "keep-remote")).toMatchObject({ type: "remote" });
    } finally {
      if (previousRuntimeDb === undefined) delete process.env.OMNIRUSH_RUNTIME_DB;
      else process.env.OMNIRUSH_RUNTIME_DB = previousRuntimeDb;
      if (previousDevMode === undefined) delete process.env.OMNIRUSH_DEV_MODE;
      else process.env.OMNIRUSH_DEV_MODE = previousDevMode;
    }
  });
});