@wukongcrm/mcp-server 0.1.3 → 0.2.0

package/dist/oauth.js

@@ -0,0 +1,446 @@
+import { createCipheriv, createDecipheriv, createHash, createHmac, randomBytes, randomUUID } from "node:crypto";
+import { AccessDeniedError, InvalidGrantError, InvalidScopeError, InvalidTargetError, InvalidTokenError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { CrmClient } from "./client.js";
+import { FileOAuthState, RedisOAuthState } from "./oauth-state.js";
+import { CRM_READ_SCOPE, OAUTH_SCOPES, OFFLINE_ACCESS_SCOPE } from "./server.js";
+export class WukongOAuthProvider {
+    clientsStore;
+    resourceUrl;
+    crmBaseUrl;
+    fetchImpl;
+    crmBindingAuthorizeUrl;
+    crmBindingExchangeUrl;
+    crmBindingCallbackUrl;
+    crmBindingClientId;
+    crmBindingClientSecret;
+    encryptionKey;
+    accessTokenTtlSeconds;
+    refreshTokenTtlSeconds;
+    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", { allowHttp: options.crmBindingExchangeAllowHttp });
+        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 = options.stateStore ?? (options.redisUrl
+            ? new RedisOAuthState({ url: options.redisUrl, keyPrefix: options.redisKeyPrefix })
+            : new FileOAuthState(options.dataDirectory));
+    }
+    async initialize() {
+        await this.clientsStore.initialize();
+    }
+    async close() {
+        await this.clientsStore.close();
+    }
+    async authorize(client, params, res) {
+        const resource = normalizeResourceUrl(params.resource ?? this.resourceUrl);
+        this.assertResource(resource);
+        const scopes = normalizeScopes(params.scopes);
+        const requestId = randomUUID();
+        const pending = {
+            client,
+            params,
+            resource,
+            scopes,
+            expiresAt: Date.now() + 5 * 60 * 1000
+        };
+        await this.clientsStore.setPendingAuthorization(requestId, this.encryptTransientState("pending", serializePendingAuthorization(pending)), pending.expiresAt);
+        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) {
+        const pendingValue = await this.clientsStore.getPendingAuthorization(requestId);
+        const pending = pendingValue
+            ? deserializePendingAuthorization(this.decryptTransientState("pending", pendingValue))
+            : undefined;
+        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();
+        const codeData = {
+            ...pending,
+            expiresAt: Date.now() + 5 * 60 * 1000,
+            apiKey: normalizedApiKey
+        };
+        await this.clientsStore.setAuthorizationCode(code, this.encryptTransientState("code", serializeAuthorizationCode(codeData)), codeData.expiresAt);
+        await this.clientsStore.deletePendingAuthorization(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");
+        let response;
+        try {
+            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 })
+            });
+        }
+        catch (error) {
+            throw new Error(`72CRM 绑定交换请求失败（${this.crmBindingExchangeUrl.origin}）：${describeFetchError(error)}`, { cause: error });
+        }
+        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 = await this.getAuthorizationCode(client, authorizationCode);
+        return codeData.params.codeChallenge;
+    }
+    async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, redirectUri, resource) {
+        const codeData = await 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 与授权请求不一致。");
+        }
+        const consumedCodeData = await this.consumeAuthorizationCode(client, authorizationCode);
+        return this.issueTokens(consumedCodeData.apiKey, client.client_id, consumedCodeData.scopes, consumedCodeData.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.
+        }
+    }
+    async getAuthorizationCode(client, authorizationCode) {
+        const value = await this.clientsStore.getAuthorizationCode(authorizationCode);
+        const codeData = value
+            ? deserializeAuthorizationCode(this.decryptTransientState("code", value))
+            : undefined;
+        if (!codeData || codeData.client.client_id !== client.client_id) {
+            throw new InvalidGrantError("授权码无效或已过期。");
+        }
+        return codeData;
+    }
+    async consumeAuthorizationCode(client, authorizationCode) {
+        const value = await this.clientsStore.consumeAuthorizationCode(authorizationCode);
+        const codeData = value
+            ? deserializeAuthorizationCode(this.decryptTransientState("code", value))
+            : undefined;
+        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 payload = this.decryptValue("wkm1", token);
+        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;
+    }
+    encryptTransientState(type, data) {
+        return this.encryptValue("wks1", { version: 1, type, data });
+    }
+    decryptTransientState(type, value) {
+        const decoded = this.decryptValue("wks1", value);
+        if (!decoded || typeof decoded !== "object") {
+            throw new Error("Invalid OAuth transient state payload");
+        }
+        const payload = decoded;
+        if (payload.version !== 1 || payload.type !== type) {
+            throw new Error("Invalid OAuth transient state payload");
+        }
+        return payload.data;
+    }
+    encryptValue(prefix, value) {
+        const iv = randomBytes(12);
+        const cipher = createCipheriv("aes-256-gcm", this.encryptionKey, iv);
+        const encrypted = Buffer.concat([
+            cipher.update(JSON.stringify(value), "utf8"),
+            cipher.final()
+        ]);
+        const tag = cipher.getAuthTag();
+        return [prefix, iv.toString("base64url"), encrypted.toString("base64url"), tag.toString("base64url")].join(".");
+    }
+    decryptValue(prefix, value) {
+        const [actualPrefix, ivText, encryptedText, tagText, extraPart] = value.split(".");
+        if (actualPrefix !== prefix || !ivText || !encryptedText || !tagText || extraPart) {
+            throw new Error("Malformed encrypted value");
+        }
+        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");
+        return JSON.parse(plaintext);
+    }
+    assertResource(resource) {
+        if (normalizeResourceUrl(resource).href !== this.resourceUrl.href) {
+            throw new InvalidTargetError("请求的 resource 不是当前 MCP 服务。");
+        }
+    }
+}
+function serializePendingAuthorization(pending) {
+    return {
+        client: pending.client,
+        params: {
+            state: pending.params.state,
+            scopes: pending.params.scopes,
+            codeChallenge: pending.params.codeChallenge,
+            redirectUri: pending.params.redirectUri,
+            resource: pending.params.resource?.href
+        },
+        resource: pending.resource.href,
+        scopes: pending.scopes,
+        expiresAt: pending.expiresAt
+    };
+}
+function serializeAuthorizationCode(codeData) {
+    return {
+        ...serializePendingAuthorization(codeData),
+        apiKey: codeData.apiKey
+    };
+}
+function deserializePendingAuthorization(value) {
+    if (!isRecord(value) || !isRecord(value.client) || !isRecord(value.params)) {
+        throw new Error("Invalid OAuth pending authorization state");
+    }
+    const client = value.client;
+    const params = value.params;
+    if (typeof client.client_id !== "string" ||
+        !isStringArray(client.redirect_uris) ||
+        typeof params.codeChallenge !== "string" ||
+        typeof params.redirectUri !== "string" ||
+        (params.state !== undefined && typeof params.state !== "string") ||
+        (params.scopes !== undefined && !isStringArray(params.scopes)) ||
+        (params.resource !== undefined && typeof params.resource !== "string") ||
+        typeof value.resource !== "string" ||
+        !isStringArray(value.scopes) ||
+        typeof value.expiresAt !== "number" ||
+        !Number.isFinite(value.expiresAt) ||
+        value.expiresAt <= Date.now()) {
+        throw new Error("Invalid or expired OAuth pending authorization state");
+    }
+    return {
+        client: value.client,
+        params: {
+            state: params.state,
+            scopes: params.scopes,
+            codeChallenge: params.codeChallenge,
+            redirectUri: params.redirectUri,
+            resource: params.resource === undefined ? undefined : new URL(params.resource)
+        },
+        resource: new URL(value.resource),
+        scopes: value.scopes,
+        expiresAt: value.expiresAt
+    };
+}
+function deserializeAuthorizationCode(value) {
+    if (!isRecord(value) || typeof value.apiKey !== "string" || !value.apiKey) {
+        throw new Error("Invalid OAuth authorization code state");
+    }
+    return {
+        ...deserializePendingAuthorization(value),
+        apiKey: value.apiKey
+    };
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function normalizeResourceUrl(url) {
+    const normalized = new URL(url.href);
+    normalized.hash = "";
+    return normalized;
+}
+function normalizeBindingEndpoint(url, name, options = {}) {
+    const normalized = new URL(url.href);
+    const isLocalHttp = normalized.protocol === "http:" &&
+        (normalized.hostname === "localhost" || normalized.hostname === "127.0.0.1");
+    const isExplicitlyAllowedHttp = normalized.protocol === "http:" && options.allowHttp === true;
+    if (normalized.protocol !== "https:" && !isLocalHttp && !isExplicitlyAllowedHttp) {
+        const exchangeHint = name === "CRM_BINDING_EXCHANGE_URL"
+            ? "；可信内网 HTTP 可同时设置 CRM_BINDING_EXCHANGE_ALLOW_HTTP=true"
+            : "";
+        throw new Error(`${name} 必须使用 HTTPS（本机 localhost 调试除外${exchangeHint}）。`);
+    }
+    if (normalized.username || normalized.password || normalized.search || normalized.hash) {
+        throw new Error(`${name} 不能包含用户信息、查询参数或片段。`);
+    }
+    return normalized;
+}
+function describeFetchError(error) {
+    const details = [];
+    let current = error;
+    for (let depth = 0; depth < 3 && current; depth++) {
+        if (current instanceof Error && current.message) {
+            details.push(current.message);
+        }
+        if (typeof current === "object" && "code" in current) {
+            const code = Reflect.get(current, "code");
+            if (typeof code === "string" && code) {
+                details.push(code);
+            }
+        }
+        current = current instanceof Error ? current.cause : undefined;
+    }
+    return [...new Set(details)].join("; ") || "unknown network error";
+}
+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;