@wukongcrm/mcp-server 0.1.3 → 0.1.4

package/dist/oauth.js

@@ -0,0 +1,400 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { AccessDeniedError, InvalidGrantError, InvalidScopeError, InvalidTargetError, InvalidTokenError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { CrmClient } from "./client.js";
+import { CRM_READ_SCOPE, OAUTH_SCOPES, OFFLINE_ACCESS_SCOPE } from "./server.js";
+export class FileOAuthState {
+    filePath;
+    clients = new Map();
+    revoked = new Map();
+    ready;
+    persistQueue = Promise.resolve();
+    constructor(dataDirectory) {
+        this.filePath = path.join(dataDirectory, "oauth-state.json");
+        this.ready = this.load();
+    }
+    async getClient(clientId) {
+        await this.ready;
+        return this.clients.get(clientId);
+    }
+    async registerClient(client) {
+        await this.ready;
+        const now = Math.floor(Date.now() / 1000);
+        const fullClient = {
+            ...client,
+            client_id: client.client_id ?? randomUUID(),
+            client_id_issued_at: client.client_id_issued_at ?? now
+        };
+        this.clients.set(fullClient.client_id, fullClient);
+        await this.persist();
+        return fullClient;
+    }
+    async revoke(jti, expiresAt) {
+        await this.ready;
+        this.removeExpiredRevocations();
+        this.revoked.set(jti, expiresAt);
+        await this.persist();
+    }
+    async isRevoked(jti) {
+        await this.ready;
+        this.removeExpiredRevocations();
+        return this.revoked.has(jti);
+    }
+    async load() {
+        try {
+            const parsed = JSON.parse(await readFile(this.filePath, "utf8"));
+            for (const [clientId, client] of Object.entries(parsed.clients ?? {})) {
+                if (client && client.client_id === clientId && Array.isArray(client.redirect_uris)) {
+                    this.clients.set(clientId, client);
+                }
+            }
+            for (const [jti, expiresAt] of Object.entries(parsed.revoked ?? {})) {
+                if (Number.isFinite(expiresAt)) {
+                    this.revoked.set(jti, expiresAt);
+                }
+            }
+            this.removeExpiredRevocations();
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    removeExpiredRevocations() {
+        const now = Math.floor(Date.now() / 1000);
+        for (const [jti, expiresAt] of this.revoked) {
+            if (expiresAt <= now) {
+                this.revoked.delete(jti);
+            }
+        }
+    }
+    async persist() {
+        const operation = this.persistQueue.catch(() => undefined).then(async () => {
+            const directory = path.dirname(this.filePath);
+            await mkdir(directory, { recursive: true });
+            const temporaryPath = `${this.filePath}.${process.pid}.tmp`;
+            const state = {
+                clients: Object.fromEntries(this.clients),
+                revoked: Object.fromEntries(this.revoked)
+            };
+            await writeFile(temporaryPath, `${JSON.stringify(state, null, 2)}\n`, {
+                encoding: "utf8",
+                mode: 0o600
+            });
+            await rename(temporaryPath, this.filePath);
+        });
+        this.persistQueue = operation;
+        await operation;
+    }
+}
+export class WukongOAuthProvider {
+    clientsStore;
+    resourceUrl;
+    crmBaseUrl;
+    fetchImpl;
+    crmBindingAuthorizeUrl;
+    crmBindingExchangeUrl;
+    crmBindingCallbackUrl;
+    crmBindingClientId;
+    crmBindingClientSecret;
+    encryptionKey;
+    accessTokenTtlSeconds;
+    refreshTokenTtlSeconds;
+    pendingAuthorizations = new Map();
+    authorizationCodes = new Map();
+    constructor(options) {
+        if (options.secret.length < 32) {
+            throw new Error("MCP_OAUTH_SECRET 至少需要 32 个字符。");
+        }
+        this.resourceUrl = normalizeResourceUrl(options.resourceUrl);
+        this.crmBaseUrl = options.crmBaseUrl;
+        this.fetchImpl = options.fetchImpl;
+        this.crmBindingAuthorizeUrl = normalizeBindingEndpoint(options.crmBindingAuthorizeUrl, "CRM_BINDING_AUTHORIZE_URL");
+        this.crmBindingExchangeUrl = normalizeBindingEndpoint(options.crmBindingExchangeUrl, "CRM_BINDING_EXCHANGE_URL");
+        this.crmBindingCallbackUrl = normalizeBindingEndpoint(options.crmBindingCallbackUrl, "CRM_BINDING_CALLBACK_URL");
+        if (!options.crmBindingClientId.trim()) {
+            throw new Error("CRM_BINDING_CLIENT_ID 不能为空。");
+        }
+        if (options.crmBindingClientSecret.length < 32) {
+            throw new Error("CRM_BINDING_CLIENT_SECRET 至少需要 32 个字符。");
+        }
+        this.crmBindingClientId = options.crmBindingClientId.trim();
+        this.crmBindingClientSecret = options.crmBindingClientSecret;
+        this.encryptionKey = createHash("sha256").update(options.secret, "utf8").digest();
+        this.accessTokenTtlSeconds = options.accessTokenTtlSeconds ?? 60 * 60;
+        this.refreshTokenTtlSeconds = options.refreshTokenTtlSeconds ?? 30 * 24 * 60 * 60;
+        this.clientsStore = new FileOAuthState(options.dataDirectory);
+    }
+    async authorize(client, params, res) {
+        this.cleanupTransientState();
+        const resource = normalizeResourceUrl(params.resource ?? this.resourceUrl);
+        this.assertResource(resource);
+        const scopes = normalizeScopes(params.scopes);
+        const requestId = randomUUID();
+        this.pendingAuthorizations.set(requestId, {
+            client,
+            params,
+            resource,
+            scopes,
+            expiresAt: Date.now() + 5 * 60 * 1000
+        });
+        const authorizationUrl = new URL(this.crmBindingAuthorizeUrl.href);
+        authorizationUrl.searchParams.set("client_id", this.crmBindingClientId);
+        authorizationUrl.searchParams.set("redirect_uri", this.crmBindingCallbackUrl.href);
+        authorizationUrl.searchParams.set("state", requestId);
+        res.setHeader("Cache-Control", "no-store");
+        res.setHeader("Pragma", "no-cache");
+        res.redirect(302, authorizationUrl.href);
+    }
+    async completeBindingAuthorization(requestId, bindingCode) {
+        this.cleanupTransientState();
+        const pending = this.pendingAuthorizations.get(requestId);
+        if (!pending) {
+            throw new AccessDeniedError("授权请求已失效，请返回 ChatGPT 重新授权。");
+        }
+        const normalizedCode = bindingCode.trim();
+        if (!normalizedCode || normalizedCode.length > 256) {
+            throw new AccessDeniedError("72CRM 返回的绑定码无效。");
+        }
+        const normalizedApiKey = await this.exchangeBindingCode(normalizedCode);
+        const crmClient = new CrmClient({
+            baseUrl: this.crmBaseUrl,
+            apiKey: normalizedApiKey,
+            fetchImpl: this.fetchImpl
+        });
+        const status = await crmClient.authStatus();
+        if (!status.ok) {
+            throw new AccessDeniedError("72CRM 静默生成的 API Key 验证失败，请重新授权。");
+        }
+        const code = randomUUID();
+        this.authorizationCodes.set(code, {
+            ...pending,
+            expiresAt: Date.now() + 5 * 60 * 1000,
+            apiKey: normalizedApiKey
+        });
+        this.pendingAuthorizations.delete(requestId);
+        const target = new URL(pending.params.redirectUri);
+        target.searchParams.set("code", code);
+        if (pending.params.state) {
+            target.searchParams.set("state", pending.params.state);
+        }
+        return target.toString();
+    }
+    async exchangeBindingCode(bindingCode) {
+        const timestamp = Math.floor(Date.now() / 1000).toString();
+        const message = `${this.crmBindingClientId}\n${timestamp}\n${bindingCode}`;
+        const signature = createHmac("sha256", this.crmBindingClientSecret)
+            .update(message, "utf8")
+            .digest("base64url");
+        const response = await (this.fetchImpl ?? fetch)(this.crmBindingExchangeUrl, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-MCP-Client-Id": this.crmBindingClientId,
+                "X-MCP-Timestamp": timestamp,
+                "X-MCP-Signature": signature
+            },
+            body: JSON.stringify({ code: bindingCode })
+        });
+        if (!response.ok) {
+            throw new AccessDeniedError("无法从 72CRM 完成静默凭证交换。");
+        }
+        const result = (await response.json());
+        const apiKey = result.code === 0 ? result.data?.apiKey?.trim() : undefined;
+        if (!apiKey || apiKey.length > 4096) {
+            throw new AccessDeniedError("72CRM 返回的静默凭证无效。");
+        }
+        return apiKey;
+    }
+    async challengeForAuthorizationCode(client, authorizationCode) {
+        const codeData = this.getAuthorizationCode(client, authorizationCode);
+        return codeData.params.codeChallenge;
+    }
+    async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, redirectUri, resource) {
+        const codeData = this.getAuthorizationCode(client, authorizationCode);
+        if (redirectUri && redirectUri !== codeData.params.redirectUri) {
+            throw new InvalidGrantError("redirect_uri 与授权请求不一致。");
+        }
+        if (resource && normalizeResourceUrl(resource).href !== codeData.resource.href) {
+            throw new InvalidTargetError("resource 与授权请求不一致。");
+        }
+        this.authorizationCodes.delete(authorizationCode);
+        return this.issueTokens(codeData.apiKey, client.client_id, codeData.scopes, codeData.resource);
+    }
+    async exchangeRefreshToken(client, refreshToken, scopes, resource) {
+        const payload = await this.decodeAndVerifyToken(refreshToken, "refresh");
+        if (payload.clientId !== client.client_id) {
+            throw new InvalidGrantError("刷新令牌不属于当前客户端。");
+        }
+        const requestedResource = normalizeResourceUrl(resource ?? new URL(payload.resource));
+        if (requestedResource.href !== payload.resource) {
+            throw new InvalidTargetError("resource 与刷新令牌不一致。");
+        }
+        const requestedScopes = scopes?.length ? normalizeScopes(scopes) : payload.scopes;
+        if (requestedScopes.some((scope) => !payload.scopes.includes(scope))) {
+            throw new InvalidScopeError("刷新请求不能扩大原授权范围。");
+        }
+        await this.clientsStore.revoke(payload.jti, payload.expiresAt);
+        return this.issueTokens(payload.apiKey, client.client_id, requestedScopes, requestedResource);
+    }
+    async verifyAccessToken(token) {
+        const payload = await this.decodeAndVerifyToken(token, "access");
+        this.assertResource(new URL(payload.resource));
+        return {
+            token,
+            clientId: payload.clientId,
+            scopes: payload.scopes,
+            expiresAt: payload.expiresAt,
+            resource: new URL(payload.resource),
+            extra: {
+                crmApiKey: payload.apiKey
+            }
+        };
+    }
+    async revokeToken(client, request) {
+        try {
+            const payload = this.decryptToken(request.token);
+            if (payload.clientId === client.client_id) {
+                await this.clientsStore.revoke(payload.jti, payload.expiresAt);
+            }
+        }
+        catch {
+            // RFC 7009 requires an invalid token to produce the same successful response.
+        }
+    }
+    getAuthorizationCode(client, authorizationCode) {
+        this.cleanupTransientState();
+        const codeData = this.authorizationCodes.get(authorizationCode);
+        if (!codeData || codeData.client.client_id !== client.client_id) {
+            throw new InvalidGrantError("授权码无效或已过期。");
+        }
+        return codeData;
+    }
+    issueTokens(apiKey, clientId, scopes, resource) {
+        const now = Math.floor(Date.now() / 1000);
+        const accessPayload = {
+            version: 1,
+            type: "access",
+            apiKey,
+            clientId,
+            scopes,
+            resource: resource.href,
+            issuedAt: now,
+            expiresAt: now + this.accessTokenTtlSeconds,
+            jti: randomUUID()
+        };
+        const tokens = {
+            access_token: this.encryptToken(accessPayload),
+            token_type: "Bearer",
+            expires_in: this.accessTokenTtlSeconds,
+            scope: scopes.join(" ")
+        };
+        if (scopes.includes(OFFLINE_ACCESS_SCOPE)) {
+            tokens.refresh_token = this.encryptToken({
+                ...accessPayload,
+                type: "refresh",
+                expiresAt: now + this.refreshTokenTtlSeconds,
+                jti: randomUUID()
+            });
+        }
+        return tokens;
+    }
+    async decodeAndVerifyToken(token, expectedType) {
+        let payload;
+        try {
+            payload = this.decryptToken(token);
+        }
+        catch {
+            throw new InvalidTokenError("Invalid token.");
+        }
+        const now = Math.floor(Date.now() / 1000);
+        if (payload.type !== expectedType || payload.expiresAt <= now) {
+            throw new InvalidTokenError("Invalid or expired token.");
+        }
+        if (await this.clientsStore.isRevoked(payload.jti)) {
+            throw new InvalidTokenError("Token has been revoked.");
+        }
+        return payload;
+    }
+    encryptToken(payload) {
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", this.encryptionKey, iv);
+        const encrypted = Buffer.concat([
+            cipher.update(JSON.stringify(payload), "utf8"),
+            cipher.final()
+        ]);
+        const tag = cipher.getAuthTag();
+        return ["wkm1", iv.toString("base64url"), encrypted.toString("base64url"), tag.toString("base64url")].join(".");
+    }
+    decryptToken(token) {
+        const [prefix, ivText, encryptedText, tagText, extraPart] = token.split(".");
+        if (prefix !== "wkm1" || !ivText || !encryptedText || !tagText || extraPart) {
+            throw new Error("Malformed token");
+        }
+        const decipher = createDecipheriv("aes-256-gcm", this.encryptionKey, Buffer.from(ivText, "base64url"));
+        decipher.setAuthTag(Buffer.from(tagText, "base64url"));
+        const plaintext = Buffer.concat([
+            decipher.update(Buffer.from(encryptedText, "base64url")),
+            decipher.final()
+        ]).toString("utf8");
+        const payload = JSON.parse(plaintext);
+        if (payload.version !== 1 ||
+            (payload.type !== "access" && payload.type !== "refresh") ||
+            typeof payload.apiKey !== "string" ||
+            typeof payload.clientId !== "string" ||
+            !Array.isArray(payload.scopes) ||
+            typeof payload.resource !== "string" ||
+            typeof payload.issuedAt !== "number" ||
+            typeof payload.expiresAt !== "number" ||
+            typeof payload.jti !== "string") {
+            throw new Error("Invalid token payload");
+        }
+        return payload;
+    }
+    assertResource(resource) {
+        if (normalizeResourceUrl(resource).href !== this.resourceUrl.href) {
+            throw new InvalidTargetError("请求的 resource 不是当前 MCP 服务。");
+        }
+    }
+    cleanupTransientState() {
+        const now = Date.now();
+        for (const [requestId, pending] of this.pendingAuthorizations) {
+            if (pending.expiresAt <= now) {
+                this.pendingAuthorizations.delete(requestId);
+            }
+        }
+        for (const [code, codeData] of this.authorizationCodes) {
+            if (codeData.expiresAt <= now) {
+                this.authorizationCodes.delete(code);
+            }
+        }
+    }
+}
+function normalizeResourceUrl(url) {
+    const normalized = new URL(url.href);
+    normalized.hash = "";
+    return normalized;
+}
+function normalizeBindingEndpoint(url, name) {
+    const normalized = new URL(url.href);
+    const isLocalHttp = normalized.protocol === "http:" &&
+        (normalized.hostname === "localhost" || normalized.hostname === "127.0.0.1");
+    if (normalized.protocol !== "https:" && !isLocalHttp) {
+        throw new Error(`${name} 必须使用 HTTPS（本机 localhost 调试除外）。`);
+    }
+    if (normalized.username || normalized.password || normalized.search || normalized.hash) {
+        throw new Error(`${name} 不能包含用户信息、查询参数或片段。`);
+    }
+    return normalized;
+}
+function normalizeScopes(scopes) {
+    const requested = scopes?.length ? [...new Set(scopes)] : [CRM_READ_SCOPE];
+    for (const scope of requested) {
+        if (!OAUTH_SCOPES.includes(scope)) {
+            throw new InvalidScopeError(`不支持的授权范围：${scope}`);
+        }
+    }
+    return requested;
+}

package/dist/server.d.ts

@@ -1,3 +1,14 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { CrmClientConfig } from "./client.js";
-export declare function createWukongMcpServer(config?: CrmClientConfig): McpServer;
+export declare const CRM_READ_SCOPE = "crm.read";
+export declare const CRM_WRITE_SCOPE = "crm.write";
+export declare const OFFLINE_ACCESS_SCOPE = "offline_access";
+export declare const MCP_RESOURCE_SCOPES: readonly ["crm.read", "crm.write"];
+export declare const OAUTH_SCOPES: readonly ["crm.read", "crm.write", "offline_access"];
+export interface WukongMcpServerConfig extends CrmClientConfig {
+    oauth?: {
+        scopes: string[];
+        resourceMetadataUrl: string;
+    };
+}
+export declare function createWukongMcpServer(config?: WukongMcpServerConfig): McpServer;