@crush-protocol/mcp-client 0.4.2 → 0.4.4

package/dist/mcp/proxy.js

@@ -3,181 +3,74 @@
  *
  * 原理：
  *   AI 工具（Cursor/Claude/Antigravity）通过 stdio 连接本 proxy，
- *   proxy 读取 ~/.crush-mcp/ 中缓存的 OAuth token，
- *   将请求转发到远程 MCP Server（Streamable HTTP）。
+ *   proxy 将请求转发到远程 MCP Server（Streamable HTTP）。
  *
  * 使用：
  *   npx @crush-protocol/mcp-client proxy [SERVER_URL]
  *
  * 用户只需执行一次 `login` 获取 token，所有 AI 工具共享同一份凭证。
  */
-import { createHash } from "node:crypto";
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import { ListToolsRequestSchema, CallToolRequestSchema, PingRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, PingRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { getPreflightStatusMessage } from "./authPreflight.js";
+import { OAuthRemoteMcpClient } from "./oauthRemoteClient.js";
+import { getCachedAuthStatus } from "./oauthStorage.js";
 import { CLIENT_NAME, CLIENT_VERSION } from "./version.js";
-const STORAGE_DIR = path.join(os.homedir(), ".crush-mcp");
-const hashServerUrl = (serverUrl) => createHash("sha256").update(serverUrl).digest("hex").slice(0, 16);
-const loadTokens = async (serverUrl) => {
-    // 尝试多个可能的 URL 变体（login 用 base URL，proxy 用 /mcp URL）
-    const candidates = [serverUrl];
-    if (serverUrl.endsWith("/mcp")) {
-        candidates.push(serverUrl.replace(/\/mcp$/, ""));
-    }
-    else {
-        candidates.push(`${serverUrl}/mcp`);
-    }
-    for (const url of candidates) {
-        const storageFile = path.join(STORAGE_DIR, `oauth-${hashServerUrl(url)}.json`);
-        try {
-            const raw = await readFile(storageFile, "utf8");
-            const state = JSON.parse(raw);
-            if (state.tokens?.access_token) {
-                return state.tokens;
-            }
-        }
-        catch {
-            // 继续尝试下一个
-        }
-    }
-    return undefined;
-};
-const saveTokens = async (serverUrl, tokens) => {
-    const storageFile = path.join(STORAGE_DIR, `oauth-${hashServerUrl(serverUrl)}.json`);
-    let state = {};
-    try {
-        const raw = await readFile(storageFile, "utf8");
-        state = JSON.parse(raw);
-    }
-    catch {
-        // ignore
-    }
-    state.tokens = tokens;
-    await mkdir(path.dirname(storageFile), { recursive: true });
-    await writeFile(storageFile, JSON.stringify(state, null, 2), { encoding: "utf8", mode: 0o600 });
-};
-/**
- * 尝试用 refresh_token 刷新 access_token
- */
-const refreshAccessToken = async (serverUrl, tokens) => {
-    if (!tokens.refresh_token)
-        return null;
-    try {
-        // 先获取 token_endpoint
-        const metadataUrl = new URL("/.well-known/oauth-authorization-server", serverUrl);
-        const metaRes = await fetch(metadataUrl.toString());
-        if (!metaRes.ok)
-            return null;
-        const meta = (await metaRes.json());
-        // 获取 client_id
-        const storageFile = path.join(STORAGE_DIR, `oauth-${hashServerUrl(serverUrl)}.json`);
-        const raw = await readFile(storageFile, "utf8");
-        const state = JSON.parse(raw);
-        const clientInfo = state.clientInformation;
-        if (!clientInfo?.client_id)
-            return null;
-        const body = new URLSearchParams({
-            grant_type: "refresh_token",
-            refresh_token: tokens.refresh_token,
-            client_id: clientInfo.client_id,
-        });
-        const res = await fetch(meta.token_endpoint, {
-            method: "POST",
-            headers: { "Content-Type": "application/x-www-form-urlencoded" },
-            body: body.toString(),
-        });
-        if (!res.ok)
-            return null;
-        const newTokens = (await res.json());
-        await saveTokens(serverUrl, newTokens);
-        return newTokens;
-    }
-    catch {
-        return null;
-    }
-};
 export async function runProxy(serverUrl) {
-    // 1. 加载缓存的 token
-    let tokens = await loadTokens(serverUrl);
-    if (!tokens?.access_token) {
-        process.stderr.write(`[crush-mcp-proxy] No cached token found for ${serverUrl}\n` +
-            `  Run: npx @crush-protocol/mcp-client login ${serverUrl}\n`);
+    const authStatus = await getCachedAuthStatus(serverUrl);
+    if (authStatus.status === "not_authenticated") {
+        const message = getPreflightStatusMessage({
+            authStatus,
+            requiresManualLogin: true,
+            canAutoRefreshLogin: false,
+        });
+        process.stderr.write(`${message ?? "Crush needs sign-in on this machine."}\n`);
         process.exit(1);
     }
-    // 2. 创建到远程 MCP Server 的 HTTP 客户端
-    const createTransport = (token) => new StreamableHTTPClientTransport(new URL(serverUrl), {
-        requestInit: {
-            headers: {
-                Authorization: `Bearer ${token}`,
-            },
-        },
+    const preflightMessage = getPreflightStatusMessage({
+        authStatus,
+        requiresManualLogin: false,
+        canAutoRefreshLogin: true,
     });
-    const remoteClient = new Client({ name: `${CLIENT_NAME}-proxy`, version: CLIENT_VERSION }, { capabilities: {} });
-    // 尝试连接，如果 401 则刷新 token
-    let transport = createTransport(tokens.access_token);
-    try {
-        await remoteClient.connect(transport);
+    if (preflightMessage) {
+        process.stderr.write(`${preflightMessage}\n\n`);
     }
-    catch (error) {
-        const msg = String(error);
-        if (msg.includes("401") || msg.includes("Unauthorized")) {
-            process.stderr.write("[crush-mcp-proxy] Token expired, refreshing...\n");
-            const refreshed = await refreshAccessToken(serverUrl, tokens);
-            if (!refreshed) {
-                process.stderr.write("[crush-mcp-proxy] Token refresh failed. Please re-login:\n" +
-                    `  npx @crush-protocol/mcp-client login ${serverUrl}\n`);
-                process.exit(1);
-            }
-            tokens = refreshed;
-            transport = createTransport(tokens.access_token);
-            await remoteClient.connect(transport);
-        }
-        else {
-            throw error;
-        }
-    }
-    // 3. 获取远程 server 的能力
-    const serverInfo = remoteClient.getServerVersion();
+    const remoteClient = new OAuthRemoteMcpClient({
+        serverUrl,
+        oauth: {
+            authorizationOutput: "stderr",
+        },
+    });
+    await remoteClient.connect();
     const remoteTools = await remoteClient.listTools();
-    // 4. 创建本地 stdio server，代理所有请求
     const localServer = new Server({
-        name: serverInfo?.name ?? "crush-mcp-proxy",
-        version: serverInfo?.version ?? "1.0.0",
+        name: `${CLIENT_NAME}-proxy`,
+        version: CLIENT_VERSION,
     }, {
         capabilities: {
             tools: { listChanged: false },
         },
     });
-    // 代理 tools/list
     localServer.setRequestHandler(ListToolsRequestSchema, async () => {
         try {
-            const result = await remoteClient.listTools();
-            return result;
+            return await remoteClient.listTools();
         }
         catch {
             return { tools: remoteTools.tools };
         }
     });
-    // 代理 tools/call
     localServer.setRequestHandler(CallToolRequestSchema, async (request) => {
         const { name, arguments: args } = request.params;
-        return remoteClient.callTool({ name, arguments: args ?? {} });
+        return remoteClient.callTool(name, (args ?? {}));
     });
-    // 代理 ping
     localServer.setRequestHandler(PingRequestSchema, async () => {
         await remoteClient.ping();
         return {};
     });
-    // 5. 启动 stdio transport
     const stdioTransport = new StdioServerTransport();
     await localServer.connect(stdioTransport);
     process.stderr.write(`[crush-mcp-proxy] Connected to ${serverUrl} | stdio proxy ready\n`);
-    // 优雅关闭
     const cleanup = async () => {
         await localServer.close();
         await remoteClient.close();

package/dist/onboarding/cliOutput.d.ts

@@ -0,0 +1,14 @@
+import type { CachedAuthStatus } from "../mcp/oauthStorage.js";
+import type { SetupInstallResult, SetupScope, SetupTarget } from "../setup/setupClients.js";
+export type DoctorCheck = {
+    status: "ok" | "warn" | "error";
+    label: string;
+    detail: string;
+};
+export declare const getTargetLabel: (target: SetupTarget) => string;
+export declare const getLoginCommand: (serverUrl: string) => string;
+export declare const formatLoginRequiredMessage: (serverUrl: string) => string;
+export declare const formatAutomaticRefreshMessage: (serverUrl: string) => string;
+export declare const formatSetupSummary: (results: SetupInstallResult[], scope: SetupScope) => string;
+export declare const formatAuthStatus: (status: CachedAuthStatus) => string;
+export declare const formatDoctorReport: (serverUrl: string, checks: DoctorCheck[]) => string;

package/dist/onboarding/cliOutput.js

@@ -0,0 +1,80 @@
+import { DEFAULT_MCP_SERVER_URL, PACKAGE_NAME } from "../config.js";
+const TARGET_LABELS = {
+    cursor: "Cursor",
+    claude: "Claude Code",
+    codex: "Codex",
+    gemini: "Gemini CLI",
+    opencode: "OpenCode",
+    vscode: "VS Code",
+    windsurf: "Windsurf",
+    "claude-desktop": "Claude Desktop",
+    warp: "Warp",
+};
+export const getTargetLabel = (target) => TARGET_LABELS[target];
+export const getLoginCommand = (serverUrl) => serverUrl === DEFAULT_MCP_SERVER_URL
+    ? `npx -y ${PACKAGE_NAME} login`
+    : `CRUSH_MCP_SERVER_URL=\"${serverUrl}\" npx -y ${PACKAGE_NAME} login`;
+export const formatLoginRequiredMessage = (serverUrl) => [
+    "Crush needs sign-in on this machine.",
+    "",
+    "Run this once in your terminal:",
+    getLoginCommand(serverUrl),
+    "",
+    "Then retry the same request.",
+].join("\n");
+export const formatAutomaticRefreshMessage = (serverUrl) => [
+    "Crush found previous local authorization data.",
+    "Refreshing the sign-in flow automatically...",
+    "",
+    "If the browser does not open, run:",
+    getLoginCommand(serverUrl),
+].join("\n");
+export const formatSetupSummary = (results, scope) => {
+    const targets = results.map((result) => getTargetLabel(result.target)).join(", ");
+    const lines = [
+        `Crush MCP configured for ${targets}.`,
+        "",
+        "Configuration:",
+        ...results.map((result) => `- ${getTargetLabel(result.target)}: ${result.status} (${result.location})`),
+        "",
+        "Next steps:",
+        `1. Restart ${results.length === 1 ? getTargetLabel(results[0].target) : "your AI host"} to load the new MCP server.`,
+        `2. Authenticate once: ${getLoginCommand(DEFAULT_MCP_SERVER_URL)}`,
+        "3. Return to your AI host and ask it to use Crush tools.",
+        "",
+        "Tip:",
+        `This ${scope}-scope setup uses the official hosted Crush MCP for market data, indicators, backtests, and live strategies.`,
+    ];
+    return lines.join("\n");
+};
+export const formatAuthStatus = (status) => {
+    const lines = [
+        "Crush authentication status",
+        "",
+        `Server: ${status.serverUrl}`,
+        `Status: ${status.status === "authenticated" ? "Authenticated" : status.status === "registered" ? "Registered but not authorized" : "Not authenticated"}`,
+        `Client registration: ${status.hasClientInformation ? "present" : "missing"}`,
+        `Access token: ${status.hasAccessToken ? "present" : "missing"}`,
+        `Refresh token: ${status.hasRefreshToken ? "present" : "missing"}`,
+    ];
+    if (status.scope) {
+        lines.push(`Scope: ${status.scope}`);
+    }
+    if (status.storageFile) {
+        lines.push(`Cache file: ${status.storageFile}`);
+    }
+    if (status.matchedServerUrl && status.matchedServerUrl !== status.serverUrl) {
+        lines.push(`Matched cache URL: ${status.matchedServerUrl}`);
+    }
+    if (status.status !== "authenticated") {
+        lines.push("", "Run:", getLoginCommand(status.serverUrl));
+    }
+    return lines.join("\n");
+};
+export const formatDoctorReport = (serverUrl, checks) => {
+    const lines = ["Crush MCP doctor", "", `Server: ${serverUrl}`, ""];
+    for (const check of checks) {
+        lines.push(`[${check.status}] ${check.label} - ${check.detail}`);
+    }
+    return lines.join("\n");
+};

package/dist/setup/setupClients.d.ts

@@ -1,4 +1,11 @@
 export type SetupTarget = "cursor" | "claude" | "codex" | "gemini" | "opencode" | "vscode" | "windsurf" | "claude-desktop" | "warp";
 export type SetupScope = "user" | "project";
+export type SetupInstallStatus = "created" | "updated" | "unchanged" | "configured";
+export type SetupInstallResult = {
+    target: SetupTarget;
+    scope: SetupScope;
+    status: SetupInstallStatus;
+    location: string;
+};
 export declare const ALL_TARGETS: readonly SetupTarget[];
-export declare const installClientConfig: (target: SetupTarget, scope: SetupScope) => string;
+export declare const installClientConfig: (target: SetupTarget, scope: SetupScope) => SetupInstallResult;

package/dist/setup/setupClients.js

@@ -2,9 +2,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-const SERVER_NAME = "crush-protocol";
-const PACKAGE_NAME = "@crush-protocol/mcp-client";
-const REMOTE_URL = "https://crush-mcp-ats.dev.xexlab.com/mcp";
+import { PACKAGE_NAME, SERVER_NAME } from "../config.js";
 export const ALL_TARGETS = [
     "cursor",
     "claude",
@@ -30,8 +28,17 @@ const readJson = (filePath) => {
     }
 };
 const writeJson = (filePath, value) => {
+    const existed = fs.existsSync(filePath);
+    const next = `${JSON.stringify(value, null, 2)}\n`;
+    if (existed) {
+        const previous = fs.readFileSync(filePath, "utf8");
+        if (previous === next) {
+            return "unchanged";
+        }
+    }
     ensureDir(filePath);
-    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    fs.writeFileSync(filePath, next, "utf8");
+    return existed ? "updated" : "created";
 };
 const createNpxConfig = () => ({
     command: "npx",
@@ -47,8 +54,7 @@ const installCursor = (scope) => {
     const mcpServers = (config.mcpServers ?? {});
     mcpServers[SERVER_NAME] = createNpxConfig();
     config.mcpServers = mcpServers;
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "cursor", scope, status: writeJson(filePath, config), location: filePath };
 };
 // ─── Gemini CLI ─────────────────────────────────────────
 const getGeminiConfigPath = () => path.join(os.homedir(), ".gemini", "settings.json");
@@ -58,8 +64,7 @@ const installGemini = () => {
     const mcpServers = (config.mcpServers ?? {});
     mcpServers[SERVER_NAME] = createNpxConfig();
     config.mcpServers = mcpServers;
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "gemini", scope: "user", status: writeJson(filePath, config), location: filePath };
 };
 // ─── OpenCode ───────────────────────────────────────────
 const getOpenCodeConfigPath = (scope) => scope === "project"
@@ -78,8 +83,7 @@ const installOpenCode = (scope) => {
         enabled: true,
     };
     config.mcp = mcp;
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "opencode", scope, status: writeJson(filePath, config), location: filePath };
 };
 // ─── OpenAI Codex ───────────────────────────────────────
 const getCodexConfigPath = () => path.join(os.homedir(), ".codex", "config.toml");
@@ -91,12 +95,15 @@ args = ["-y", "${PACKAGE_NAME}"]
 startup_timeout_ms = 20000
 `;
     ensureDir(filePath);
+    const existed = fs.existsSync(filePath);
     const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+    let status = "unchanged";
     if (!existing.includes(`[mcp_servers.${SERVER_NAME}]`)) {
         const next = existing.trim().length > 0 ? `${existing.trimEnd()}\n\n${section}` : section;
         fs.writeFileSync(filePath, next, "utf8");
+        status = existed ? "updated" : "created";
     }
-    return filePath;
+    return { target: "codex", scope: "user", status, location: filePath };
 };
 // ─── Claude Code CLI ────────────────────────────────────
 const installClaude = (scope) => {
@@ -116,7 +123,7 @@ const installClaude = (scope) => {
         const output = [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
         throw new Error(output || "Claude CLI returned a non-zero exit code.");
     }
-    return "claude-managed-config";
+    return { target: "claude", scope, status: "configured", location: "claude-managed-config" };
 };
 // ─── VS Code ────────────────────────────────────────────
 const getVSCodeConfigPath = (scope) => scope === "project"
@@ -132,8 +139,7 @@ const installVSCode = (scope) => {
         args: ["-y", PACKAGE_NAME],
     };
     config.servers = servers;
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "vscode", scope, status: writeJson(filePath, config), location: filePath };
 };
 // ─── Windsurf ───────────────────────────────────────────
 const getWindsurfConfigPath = () => path.join(os.homedir(), ".codeium", "windsurf", "mcp_config.json");
@@ -143,8 +149,7 @@ const installWindsurf = () => {
     const mcpServers = (config.mcpServers ?? {});
     mcpServers[SERVER_NAME] = createNpxConfig();
     config.mcpServers = mcpServers;
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "windsurf", scope: "user", status: writeJson(filePath, config), location: filePath };
 };
 // ─── Claude Desktop ─────────────────────────────────────
 const getClaudeDesktopConfigPath = () => {
@@ -164,8 +169,7 @@ const installClaudeDesktop = () => {
     const mcpServers = (config.mcpServers ?? {});
     mcpServers[SERVER_NAME] = createNpxConfig();
     config.mcpServers = mcpServers;
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "claude-desktop", scope: "user", status: writeJson(filePath, config), location: filePath };
 };
 // ─── Warp ───────────────────────────────────────────────
 const getWarpConfigPath = () => path.join(os.homedir(), ".warp", "mcp_config.json");
@@ -179,8 +183,7 @@ const installWarp = () => {
         working_directory: null,
         start_on_launch: true,
     };
-    writeJson(filePath, config);
-    return filePath;
+    return { target: "warp", scope: "user", status: writeJson(filePath, config), location: filePath };
 };
 // ─── Router ─────────────────────────────────────────────
 export const installClientConfig = (target, scope) => {

package/package.json

@@ -1,9 +1,30 @@
 {
   "name": "@crush-protocol/mcp-client",
-  "version": "0.4.2",
-  "description": "Crush MCP npm client package (remote Streamable HTTP + optional ClickHouse direct)",
+  "version": "0.4.4",
+  "description": "Official Crush MCP client for hosted market data, backtests, and trading workflows",
   "type": "module",
   "license": "MIT",
+  "homepage": "https://github.com/crush-protocol/crush-mcp-server/tree/main/packages/crush-mcp-client#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/crush-protocol/crush-mcp-server.git",
+    "directory": "packages/crush-mcp-client"
+  },
+  "bugs": {
+    "url": "https://github.com/crush-protocol/crush-mcp-server/issues"
+  },
+  "keywords": [
+    "crush",
+    "crush-protocol",
+    "mcp",
+    "model-context-protocol",
+    "trading",
+    "backtest",
+    "quant",
+    "cursor",
+    "claude-code",
+    "codex"
+  ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -39,7 +60,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "rm -rf dist && tsc -p tsconfig.json",
     "dev": "tsx src/cli.ts",
     "test": "vitest run",
     "test:e2e": "dotenv -e .env.e2e vitest run src/__tests__/e2e.test.ts"

package/dist/__tests__/e2e.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/e2e.test.js

@@ -1,50 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import { BacktestClient } from "../backtest/backtestClient.js";
-import { OAuthRemoteMcpClient } from "../mcp/oauthRemoteClient.js";
-/**
- * E2E 测试：验证 MCP client 能成功连接服务端并调用工具。
- *
- * 前置条件（通过环境变量或 .env.e2e 配置）：
- *   CRUSH_MCP_SERVER_URL — 指向运行中的 MCP server（默认 https://crush-mcp-ats.dev.xexlab.com/mcp）
- *   CRUSH_OAUTH_ACCESS_TOKEN — 有效的 OAuth access token
- */
-const serverUrl = process.env.CRUSH_MCP_SERVER_URL ?? "https://crush-mcp-ats.dev.xexlab.com/mcp";
-const token = process.env.CRUSH_OAUTH_ACCESS_TOKEN ?? "";
-// 没有 token 时跳过所有 e2e 测试
-const describeE2E = token ? describe : describe.skip;
-describeE2E("MCP Client E2E", () => {
-    let mcp;
-    let backtest;
-    beforeAll(async () => {
-        mcp = new OAuthRemoteMcpClient({ serverUrl, token, oauth: { openBrowser: false } });
-        await mcp.connect();
-        backtest = new BacktestClient(mcp);
-    });
-    afterAll(async () => {
-        await mcp.close();
-    });
-    it("ping — 服务端可达", async () => {
-        const result = await mcp.ping();
-        expect(result).toBeDefined();
-    });
-    it("listTools — 返回至少一个工具", async () => {
-        const { tools } = await mcp.listTools();
-        expect(tools.length).toBeGreaterThan(0);
-    });
-    it("backtest:schema — 返回支持的配置 schema", async () => {
-        const schema = await backtest.getConfigSchema();
-        expect(schema).toHaveProperty("platforms");
-        expect(schema).toHaveProperty("timeframes");
-        expect(Array.isArray(schema.platforms)).toBe(true);
-    });
-    it("backtest:tokens — 返回可用交易对列表", async () => {
-        const result = await backtest.getAvailableTokens();
-        expect(result).toHaveProperty("tokens");
-        expect(Array.isArray(result.tokens)).toBe(true);
-    });
-    it("backtest:list — 返回当前用户的回测列表", async () => {
-        const result = await backtest.list({ limit: 5 });
-        expect(result).toHaveProperty("backtests");
-        expect(typeof result.total).toBe("number");
-    });
-});

package/dist/__tests__/oauthProvider.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/oauthProvider.test.js

@@ -1,45 +0,0 @@
-import { mkdtemp, readFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { InteractiveOAuthProvider } from "../mcp/oauthProvider.js";
-const tempDirs = [];
-const createProvider = async () => {
-    const storageDir = await mkdtemp(path.join(os.tmpdir(), "crush-mcp-oauth-"));
-    tempDirs.push(storageDir);
-    const provider = new InteractiveOAuthProvider({
-        serverUrl: "https://example.com/mcp",
-        storageDir,
-        openBrowser: false,
-    });
-    return { provider, storageDir };
-};
-describe("InteractiveOAuthProvider", () => {
-    afterEach(async () => {
-        await Promise.all(tempDirs
-            .splice(0)
-            .map((dir) => import("node:fs/promises").then((fs) => fs.rm(dir, { recursive: true, force: true }))));
-    });
-    it("persists client info, tokens, and code verifier", async () => {
-        const { provider, storageDir } = await createProvider();
-        await provider.saveClientInformation({ client_id: "client_123" });
-        await provider.saveTokens({ access_token: "atk_123", token_type: "Bearer", refresh_token: "rt_123" });
-        await provider.saveCodeVerifier("verifier-123");
-        expect(await provider.clientInformation()).toEqual({ client_id: "client_123" });
-        expect(await provider.tokens()).toEqual({ access_token: "atk_123", token_type: "Bearer", refresh_token: "rt_123" });
-        expect(await provider.codeVerifier()).toBe("verifier-123");
-        const files = await import("node:fs/promises").then((fs) => fs.readdir(storageDir));
-        expect(files.length).toBe(1);
-        const raw = await readFile(path.join(storageDir, files[0]), "utf8");
-        expect(raw).toContain("client_123");
-        expect(raw).toContain("atk_123");
-    });
-    it("invalidates token state without removing client registration", async () => {
-        const { provider } = await createProvider();
-        await provider.saveClientInformation({ client_id: "client_123" });
-        await provider.saveTokens({ access_token: "atk_123", token_type: "Bearer", refresh_token: "rt_123" });
-        await provider.invalidateCredentials?.("tokens");
-        expect(await provider.clientInformation()).toEqual({ client_id: "client_123" });
-        expect(await provider.tokens()).toBeUndefined();
-    });
-});