@crush-protocol/mcp-client 0.4.3 → 0.4.4

package/dist/cli.js

@@ -3,6 +3,7 @@ import "dotenv/config";
 import { BacktestClient } from "./backtest/backtestClient.js";
 import { ClickHouseDirectClient } from "./clickhouse/directClient.js";
 import { DEFAULT_MCP_SERVER_URL } from "./config.js";
+import { assertManualLoginNotRequired } from "./mcp/authPreflight.js";
 import { OAuthRemoteMcpClient } from "./mcp/oauthRemoteClient.js";
 import { getCachedAuthStatus, loadStoredTokens } from "./mcp/oauthStorage.js";
 import { runProxy } from "./mcp/proxy.js";
@@ -73,6 +74,11 @@ const createSmartClient = (flags) => {
     };
 };
 const connectClient = async (flags) => {
+    const explicitToken = getExplicitToken(flags);
+    if (!explicitToken) {
+        const serverUrl = getServerUrl(typeof flags.server === "string" ? flags.server : undefined);
+        await assertManualLoginNotRequired(serverUrl);
+    }
     const { client, needsOAuthConnect } = createSmartClient(flags);
     if (needsOAuthConnect) {
         await client.connect();

package/dist/mcp/authPreflight.d.ts

@@ -0,0 +1,9 @@
+import { type CachedAuthStatus } from "./oauthStorage.js";
+export type AuthPreflightResult = {
+    authStatus: CachedAuthStatus;
+    requiresManualLogin: boolean;
+    canAutoRefreshLogin: boolean;
+};
+export declare const getAuthPreflight: (serverUrl: string) => Promise<AuthPreflightResult>;
+export declare const assertManualLoginNotRequired: (serverUrl: string) => Promise<AuthPreflightResult>;
+export declare const getPreflightStatusMessage: (preflight: AuthPreflightResult) => string | null;

package/dist/mcp/authPreflight.js

@@ -0,0 +1,26 @@
+import { formatAutomaticRefreshMessage, formatLoginRequiredMessage } from "../onboarding/cliOutput.js";
+import { getCachedAuthStatus } from "./oauthStorage.js";
+export const getAuthPreflight = async (serverUrl) => {
+    const authStatus = await getCachedAuthStatus(serverUrl);
+    return {
+        authStatus,
+        requiresManualLogin: authStatus.status === "not_authenticated",
+        canAutoRefreshLogin: authStatus.status !== "not_authenticated",
+    };
+};
+export const assertManualLoginNotRequired = async (serverUrl) => {
+    const preflight = await getAuthPreflight(serverUrl);
+    if (preflight.requiresManualLogin) {
+        throw new Error(formatLoginRequiredMessage(serverUrl));
+    }
+    return preflight;
+};
+export const getPreflightStatusMessage = (preflight) => {
+    if (preflight.requiresManualLogin) {
+        return formatLoginRequiredMessage(preflight.authStatus.serverUrl);
+    }
+    if (preflight.authStatus.status === "registered") {
+        return formatAutomaticRefreshMessage(preflight.authStatus.serverUrl);
+    }
+    return null;
+};

package/dist/mcp/oauthProvider.d.ts

@@ -9,6 +9,7 @@ export type InteractiveOAuthProviderOptions = {
     redirectPath?: string;
     storageDir?: string;
     openBrowser?: boolean;
+    authorizationOutput?: "stdout" | "stderr" | "silent";
     onAuthorizationUrl?: (authorizationUrl: URL) => void | Promise<void>;
 };
 export declare class InteractiveOAuthProvider implements OAuthClientProvider {
@@ -17,6 +18,7 @@ export declare class InteractiveOAuthProvider implements OAuthClientProvider {
     private readonly storageFile;
     private readonly scope;
     private readonly openBrowserByDefault;
+    private readonly authorizationOutput;
     private readonly onAuthorizationUrl?;
     private callbackServer?;
     private pendingAuthorization?;

package/dist/mcp/oauthProvider.js

@@ -72,6 +72,7 @@ export class InteractiveOAuthProvider {
     storageFile;
     scope;
     openBrowserByDefault;
+    authorizationOutput;
     onAuthorizationUrl;
     callbackServer;
     pendingAuthorization;
@@ -82,6 +83,7 @@ export class InteractiveOAuthProvider {
         this.redirectUrl = new URL(`http://127.0.0.1:${redirectPort}${redirectPath}`);
         this.scope = options.scope ?? DEFAULT_OAUTH_SCOPE;
         this.openBrowserByDefault = options.openBrowser ?? true;
+        this.authorizationOutput = options.authorizationOutput ?? "stdout";
         const storageDir = options.storageDir ?? defaultStorageDir();
         this.storageFile = getStorageFileForServer(options.serverUrl, storageDir);
         this.onAuthorizationUrl = options.onAuthorizationUrl;
@@ -132,7 +134,12 @@ export class InteractiveOAuthProvider {
                 // Fall back to printing the URL when no browser launcher is available.
             }
         }
-        process.stdout.write(`\nOpen this URL to authorize Crush MCP:\n${authorizationUrl.toString()}\n\n`);
+        if (this.authorizationOutput === "stdout") {
+            process.stdout.write(`\nOpen this URL to authorize Crush MCP:\n${authorizationUrl.toString()}\n\n`);
+        }
+        else if (this.authorizationOutput === "stderr") {
+            process.stderr.write(`\nOpen this URL to authorize Crush MCP:\n${authorizationUrl.toString()}\n\n`);
+        }
     }
     async saveCodeVerifier(codeVerifier) {
         const data = await this.loadState();

package/dist/mcp/oauthRemoteClient.d.ts

@@ -16,6 +16,9 @@ export declare class OAuthRemoteMcpClient implements McpClientLike {
     private readonly transport;
     private readonly authProvider;
     constructor(options: OAuthRemoteMcpClientOptions);
+    private isAuthError;
+    private recoverAuthorization;
+    private withReauthorization;
     connect(): Promise<void>;
     ensureAuthorized(): Promise<void>;
     runAuthFlow(): Promise<AuthResult>;

package/dist/mcp/oauthRemoteClient.js

@@ -35,25 +35,38 @@ export class OAuthRemoteMcpClient {
             fetch: options.fetch,
         });
     }
+    isAuthError(error) {
+        return (error instanceof UnauthorizedError || String(error).includes("Unauthorized") || String(error).includes("401"));
+    }
+    async recoverAuthorization(error) {
+        if (!this.isAuthError(error)) {
+            throw error;
+        }
+        const authResult = await auth(this.authProvider, {
+            serverUrl: this.options.serverUrl,
+            scope: this.options.scope,
+            fetchFn: this.options.fetch,
+        });
+        if (authResult === "REDIRECT") {
+            const authorizationCode = await this.authProvider.waitForAuthorizationCode();
+            await this.transport.finishAuth(authorizationCode);
+        }
+    }
+    async withReauthorization(operation) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            await this.recoverAuthorization(error);
+            return operation();
+        }
+    }
     async connect() {
         try {
             await this.client.connect(this.transport);
         }
         catch (error) {
-            if (!(error instanceof UnauthorizedError)) {
-                throw error;
-            }
-            const authResult = await auth(this.authProvider, {
-                serverUrl: this.options.serverUrl,
-                scope: this.options.scope,
-                fetchFn: this.options.fetch,
-            });
-            if (authResult !== "REDIRECT") {
-                await this.client.connect(this.transport);
-                return;
-            }
-            const authorizationCode = await this.authProvider.waitForAuthorizationCode();
-            await this.transport.finishAuth(authorizationCode);
+            await this.recoverAuthorization(error);
             await this.client.connect(this.transport);
         }
     }
@@ -82,15 +95,15 @@ export class OAuthRemoteMcpClient {
         await this.transport.terminateSession();
     }
     async ping() {
-        return this.client.ping();
+        return this.withReauthorization(() => this.client.ping());
     }
     async listTools() {
-        return this.client.listTools();
+        return this.withReauthorization(() => this.client.listTools());
     }
     async callTool(name, args = {}) {
-        return this.client.callTool({
+        return this.withReauthorization(() => this.client.callTool({
             name,
             arguments: args,
-        });
+        }));
     }
 }

package/dist/mcp/proxy.js

@@ -3,159 +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 { mkdir, readFile, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, PingRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-import { getLoginCommand } from "../onboarding/cliOutput.js";
-import { defaultStorageDir, getStorageFileForServer, loadStoredTokens, } from "./oauthStorage.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 saveTokens = async (serverUrl, tokens) => {
-    const storageFile = getStorageFileForServer(serverUrl, defaultStorageDir());
-    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 = getStorageFileForServer(serverUrl, defaultStorageDir());
-        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 loadStoredTokens(serverUrl);
-    if (!tokens?.access_token) {
-        process.stderr.write("Crush is connected but not authenticated.\n\n" +
-            "Run this once in your terminal:\n" +
-            `${getLoginCommand(serverUrl)}\n\n` +
-            "After login, retry the same request.\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 authentication expired. Attempting refresh...\n");
-            const refreshed = await refreshAccessToken(serverUrl, tokens);
-            if (!refreshed) {
-                process.stderr.write("Crush authentication needs to be renewed.\n\n" +
-                    "Run:\n" +
-                    `${getLoginCommand(serverUrl)}\n\n` +
-                    "Then retry the same request.\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

@@ -7,6 +7,8 @@ export type DoctorCheck = {
 };
 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

@@ -14,6 +14,21 @@ 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 = [

package/package.json

@@ -1,9 +1,30 @@
 {
   "name": "@crush-protocol/mcp-client",
-  "version": "0.4.3",
-  "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__/cliOutput.test.d.ts

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

package/dist/__tests__/cliOutput.test.js

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { formatAuthStatus, formatSetupSummary, getLoginCommand } from "../onboarding/cliOutput.js";
-describe("cliOutput", () => {
-    it("renders setup summary with next steps", () => {
-        const results = [
-            {
-                target: "cursor",
-                scope: "user",
-                status: "created",
-                location: "/tmp/.cursor/mcp.json",
-            },
-        ];
-        const output = formatSetupSummary(results, "user");
-        expect(output).toContain("Crush MCP configured for Cursor.");
-        expect(output).toContain("Restart Cursor");
-        expect(output).toContain("npx -y @crush-protocol/mcp-client login");
-    });
-    it("renders auth status with login guidance when missing", () => {
-        const output = formatAuthStatus({
-            serverUrl: "https://crush-mcp-ats.dev.xexlab.com/mcp",
-            status: "not_authenticated",
-            hasClientInformation: false,
-            hasAccessToken: false,
-            hasRefreshToken: false,
-            hasCodeVerifier: false,
-        });
-        expect(output).toContain("Status: Not authenticated");
-        expect(output).toContain("Run:");
-        expect(output).toContain("npx -y @crush-protocol/mcp-client login");
-    });
-    it("renders custom login command for non-default server URLs", () => {
-        expect(getLoginCommand("https://example.com/mcp")).toBe('CRUSH_MCP_SERVER_URL="https://example.com/mcp" npx -y @crush-protocol/mcp-client login');
-    });
-});

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();
-    });
-});

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

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

package/dist/__tests__/oauthStorage.test.js

@@ -1,52 +0,0 @@
-import { mkdtemp, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { defaultStorageDir, getCachedAuthStatus, getStorageFileForServer, loadStoredTokens, } from "../mcp/oauthStorage.js";
-const tempDirs = [];
-describe("oauthStorage", () => {
-    afterEach(async () => {
-        await Promise.all(tempDirs
-            .splice(0)
-            .map((dir) => import("node:fs/promises").then((fs) => fs.rm(dir, { recursive: true, force: true }))));
-    });
-    it("reports authenticated state when tokens are present", async () => {
-        const storageDir = await mkdtemp(path.join(os.tmpdir(), "crush-mcp-storage-"));
-        tempDirs.push(storageDir);
-        const storageFile = getStorageFileForServer("https://example.com/mcp", storageDir);
-        await writeFile(storageFile, JSON.stringify({
-            clientInformation: { client_id: "client_123" },
-            tokens: { access_token: "atk_123", refresh_token: "rt_123", token_type: "Bearer", scope: "mcp:tools" },
-        }), "utf8");
-        const status = await getCachedAuthStatus("https://example.com/mcp", storageDir);
-        expect(status.status).toBe("authenticated");
-        expect(status.hasRefreshToken).toBe(true);
-        expect(status.storageFile).toBe(storageFile);
-    });
-    it("falls back between /mcp and base URL variants", async () => {
-        const storageDir = await mkdtemp(path.join(os.tmpdir(), "crush-mcp-storage-"));
-        tempDirs.push(storageDir);
-        const storageFile = getStorageFileForServer("https://example.com", storageDir);
-        await writeFile(storageFile, JSON.stringify({
-            clientInformation: { client_id: "client_123" },
-            tokens: { access_token: "atk_123", token_type: "Bearer" },
-        }), "utf8");
-        const tokens = await loadStoredTokens("https://example.com/mcp", storageDir);
-        expect(tokens?.access_token).toBe("atk_123");
-    });
-    it("reports registered state when only client metadata exists", async () => {
-        const storageDir = await mkdtemp(path.join(os.tmpdir(), "crush-mcp-storage-"));
-        tempDirs.push(storageDir);
-        const storageFile = getStorageFileForServer("https://example.com/mcp", storageDir);
-        await writeFile(storageFile, JSON.stringify({
-            clientInformation: { client_id: "client_123" },
-            codeVerifier: "verifier_123",
-        }), "utf8");
-        const status = await getCachedAuthStatus("https://example.com/mcp", storageDir);
-        expect(status.status).toBe("registered");
-        expect(status.hasCodeVerifier).toBe(true);
-    });
-    it("uses the default storage directory helper", () => {
-        expect(defaultStorageDir()).toContain(".crush-mcp");
-    });
-});