@crush-protocol/mcp-client 0.1.14 → 0.3.0

package/dist/mcp/oauthRemoteClient.d.ts

@@ -0,0 +1,171 @@
+import { type AuthResult } from "@modelcontextprotocol/sdk/client/auth.js";
+import { type InteractiveOAuthProviderOptions } from "./oauthProvider.js";
+import type { McpClientLike } from "./types.js";
+export type OAuthRemoteMcpClientOptions = {
+    serverUrl: string;
+    clientName?: string;
+    clientVersion?: string;
+    scope?: string;
+    token?: string;
+    fetch?: typeof fetch;
+    oauth?: Omit<InteractiveOAuthProviderOptions, "serverUrl" | "clientName" | "clientVersion" | "scope">;
+};
+export declare class OAuthRemoteMcpClient implements McpClientLike {
+    private readonly options;
+    private readonly client;
+    private readonly transport;
+    private readonly authProvider;
+    constructor(options: OAuthRemoteMcpClientOptions);
+    connect(): Promise<void>;
+    ensureAuthorized(): Promise<void>;
+    runAuthFlow(): Promise<AuthResult>;
+    completeAuthorization(): Promise<void>;
+    close(): Promise<void>;
+    terminateSession(): Promise<void>;
+    ping(): Promise<{
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+    listTools(): Promise<{
+        [x: string]: unknown;
+        tools: {
+            inputSchema: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
+            };
+            name: string;
+            description?: string | undefined;
+            outputSchema?: {
+                [x: string]: unknown;
+                type: "object";
+                properties?: Record<string, object> | undefined;
+                required?: string[] | undefined;
+            } | undefined;
+            annotations?: {
+                title?: string | undefined;
+                readOnlyHint?: boolean | undefined;
+                destructiveHint?: boolean | undefined;
+                idempotentHint?: boolean | undefined;
+                openWorldHint?: boolean | undefined;
+            } | undefined;
+            execution?: {
+                taskSupport?: "optional" | "required" | "forbidden" | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        }[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        nextCursor?: string | undefined;
+    }>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<{
+        [x: string]: unknown;
+        content: ({
+            type: "text";
+            text: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "image";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "audio";
+            data: string;
+            mimeType: string;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            type: "resource";
+            resource: {
+                uri: string;
+                text: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            } | {
+                uri: string;
+                blob: string;
+                mimeType?: string | undefined;
+                _meta?: Record<string, unknown> | undefined;
+            };
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: Record<string, unknown> | undefined;
+        } | {
+            uri: string;
+            name: string;
+            type: "resource_link";
+            description?: string | undefined;
+            mimeType?: string | undefined;
+            annotations?: {
+                audience?: ("user" | "assistant")[] | undefined;
+                priority?: number | undefined;
+                lastModified?: string | undefined;
+            } | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+            icons?: {
+                src: string;
+                mimeType?: string | undefined;
+                sizes?: string[] | undefined;
+                theme?: "light" | "dark" | undefined;
+            }[] | undefined;
+            title?: string | undefined;
+        })[];
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+        structuredContent?: Record<string, unknown> | undefined;
+        isError?: boolean | undefined;
+    } | {
+        [x: string]: unknown;
+        toolResult: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    }>;
+}

package/dist/mcp/oauthRemoteClient.js

@@ -0,0 +1,95 @@
+import { auth, UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InteractiveOAuthProvider } from "./oauthProvider.js";
+export class OAuthRemoteMcpClient {
+    options;
+    client;
+    transport;
+    authProvider;
+    constructor(options) {
+        this.options = options;
+        this.client = new Client({
+            name: options.clientName ?? "crush-mcp-client",
+            version: options.clientVersion ?? "0.2.0",
+        }, {
+            capabilities: {},
+        });
+        this.authProvider = new InteractiveOAuthProvider({
+            serverUrl: options.serverUrl,
+            clientName: options.clientName,
+            clientVersion: options.clientVersion,
+            scope: options.scope,
+            ...options.oauth,
+        });
+        this.transport = new StreamableHTTPClientTransport(new URL(options.serverUrl), {
+            authProvider: this.authProvider,
+            requestInit: options.token
+                ? {
+                    headers: {
+                        Authorization: `Bearer ${options.token}`,
+                    },
+                }
+                : undefined,
+            fetch: options.fetch,
+        });
+    }
+    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.client.connect(this.transport);
+        }
+    }
+    async ensureAuthorized() {
+        const authResult = await this.runAuthFlow();
+        if (authResult === "REDIRECT") {
+            await this.completeAuthorization();
+        }
+    }
+    async runAuthFlow() {
+        return auth(this.authProvider, {
+            serverUrl: this.options.serverUrl,
+            scope: this.options.scope,
+            fetchFn: this.options.fetch,
+        });
+    }
+    async completeAuthorization() {
+        const authorizationCode = await this.authProvider.waitForAuthorizationCode();
+        await this.transport.finishAuth(authorizationCode);
+    }
+    async close() {
+        await this.authProvider.close();
+        await this.transport.close();
+    }
+    async terminateSession() {
+        await this.transport.terminateSession();
+    }
+    async ping() {
+        return this.client.ping();
+    }
+    async listTools() {
+        return this.client.listTools();
+    }
+    async callTool(name, args = {}) {
+        return this.client.callTool({
+            name,
+            arguments: args,
+        });
+    }
+}

package/dist/mcp/remoteClient.d.ts

@@ -1,10 +1,11 @@
+import type { McpClientLike } from "./types.js";
 export type RemoteMcpClientOptions = {
     serverUrl: string;
     token: string;
     clientName?: string;
     clientVersion?: string;
 };
-export declare class RemoteMcpClient {
+export declare class RemoteMcpClient implements McpClientLike {
     private readonly client;
     private readonly transport;
     constructor(options: RemoteMcpClientOptions);

package/dist/mcp/remoteClient.js

@@ -4,8 +4,8 @@ export class RemoteMcpClient {
     client;
     transport;
     constructor(options) {
-        if (!options.token.startsWith("mcp_")) {
-            throw new Error("Invalid token format. Expected mcp_xxx");
+        if (typeof options.token !== "string" || options.token.trim().length === 0) {
+            throw new Error("Invalid token. Expected a non-empty OAuth access token");
         }
         this.client = new Client({
             name: options.clientName || "crush-mcp-client",

package/dist/mcp/types.d.ts

@@ -0,0 +1,8 @@
+export interface McpClientLike {
+    connect(): Promise<void>;
+    close(): Promise<void>;
+    terminateSession(): Promise<void>;
+    ping(): Promise<unknown>;
+    listTools(): Promise<unknown>;
+    callTool(name: string, args?: Record<string, unknown>): Promise<unknown>;
+}

package/dist/mcp/types.js

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

package/dist/setup/setupClients.d.ts

@@ -0,0 +1,3 @@
+export type SetupTarget = "cursor" | "claude" | "codex" | "gemini" | "opencode";
+export type SetupScope = "user" | "project";
+export declare const installClientConfig: (target: SetupTarget, serverUrl: string, scope: SetupScope) => string;

package/dist/setup/setupClients.js

@@ -0,0 +1,119 @@
+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 ensureDir = (filePath) => {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+};
+const readJson = (filePath) => {
+    if (!fs.existsSync(filePath))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Failed to parse JSON config at ${filePath}: ${error.message}`);
+    }
+};
+const writeJson = (filePath, value) => {
+    ensureDir(filePath);
+    fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+};
+const createNpxConfig = (serverUrl) => ({
+    command: "npx",
+    args: ["-y", PACKAGE_NAME, "--url", serverUrl],
+});
+const getCursorConfigPath = (scope) => scope === "project"
+    ? path.join(process.cwd(), ".cursor", "mcp.json")
+    : path.join(os.homedir(), ".cursor", "mcp.json");
+const getGeminiConfigPath = () => path.join(os.homedir(), ".gemini", "settings.json");
+const getOpenCodeConfigPath = (scope) => scope === "project"
+    ? path.join(process.cwd(), "opencode.json")
+    : path.join(os.homedir(), ".config", "opencode", "opencode.json");
+const getCodexConfigPath = () => path.join(os.homedir(), ".codex", "config.toml");
+const installCursor = (serverUrl, scope) => {
+    const filePath = getCursorConfigPath(scope);
+    const config = readJson(filePath);
+    const mcpServers = (config.mcpServers ?? {});
+    mcpServers[SERVER_NAME] = createNpxConfig(serverUrl);
+    config.mcpServers = mcpServers;
+    writeJson(filePath, config);
+    return filePath;
+};
+const installGemini = (serverUrl) => {
+    const filePath = getGeminiConfigPath();
+    const config = readJson(filePath);
+    const mcpServers = (config.mcpServers ?? {});
+    mcpServers[SERVER_NAME] = createNpxConfig(serverUrl);
+    config.mcpServers = mcpServers;
+    writeJson(filePath, config);
+    return filePath;
+};
+const installOpenCode = (serverUrl, scope) => {
+    const filePath = getOpenCodeConfigPath(scope);
+    const config = readJson(filePath);
+    const mcp = (config.mcp ?? {});
+    if (typeof config.$schema !== "string") {
+        config.$schema = "https://opencode.ai/config.json";
+    }
+    mcp[SERVER_NAME] = {
+        type: "local",
+        command: ["npx", "-y", PACKAGE_NAME, "--url", serverUrl],
+        enabled: true,
+    };
+    config.mcp = mcp;
+    writeJson(filePath, config);
+    return filePath;
+};
+const installCodex = (serverUrl) => {
+    const filePath = getCodexConfigPath();
+    const section = `[mcp_servers.${SERVER_NAME}]
+command = "npx"
+args = ["-y", "${PACKAGE_NAME}", "--url", "${serverUrl}"]
+startup_timeout_ms = 20000
+`;
+    ensureDir(filePath);
+    const existing = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+    if (!existing.includes(`[mcp_servers.${SERVER_NAME}]`)) {
+        const next = existing.trim().length > 0 ? `${existing.trimEnd()}\n\n${section}` : section;
+        fs.writeFileSync(filePath, next, "utf8");
+    }
+    return filePath;
+};
+const installClaude = (serverUrl, scope) => {
+    const configJson = JSON.stringify({
+        type: "stdio",
+        command: "npx",
+        args: ["-y", PACKAGE_NAME, "--url", serverUrl],
+    });
+    const result = spawnSync("claude", ["mcp", "add-json", "--scope", scope, SERVER_NAME, configJson], {
+        stdio: "pipe",
+        encoding: "utf8",
+    });
+    if (result.error) {
+        throw new Error(`Failed to run Claude CLI: ${result.error.message}`);
+    }
+    if (result.status !== 0) {
+        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";
+};
+export const installClientConfig = (target, serverUrl, scope) => {
+    switch (target) {
+        case "cursor":
+            return installCursor(serverUrl, scope);
+        case "claude":
+            return installClaude(serverUrl, scope);
+        case "codex":
+            return installCodex(serverUrl);
+        case "gemini":
+            return installGemini(serverUrl);
+        case "opencode":
+            return installOpenCode(serverUrl, scope);
+        default:
+            throw new Error(`Unsupported setup target: ${target}`);
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crush-protocol/mcp-client",
-  "version": "0.1.14",
+  "version": "0.3.0",
   "description": "Crush MCP npm client package (remote Streamable HTTP + optional ClickHouse direct)",
   "type": "module",
   "license": "MIT",
@@ -13,6 +13,9 @@
     "dist",
     "INSTRUCTIONS.md"
   ],
+  "publishConfig": {
+    "access": "public"
+  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -23,7 +26,7 @@
     "@modelcontextprotocol/sdk": "^1.26.0",
     "dotenv": "^17.2.1",
     "zod": "^3.25.76",
-    "@crush-protocol/mcp-contracts": "0.1.0"
+    "@crush-protocol/mcp-contracts": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",
@@ -38,6 +41,7 @@
   "scripts": {
     "build": "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"
   }
 }