@wukongcrm/mcp-server 0.1.4 → 0.2.0

package/dist/oauth.js

@@ -1,94 +1,8 @@
 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 { FileOAuthState, RedisOAuthState } from "./oauth-state.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;
@@ -102,8 +16,6 @@ export class WukongOAuthProvider {
     encryptionKey;
     accessTokenTtlSeconds;
     refreshTokenTtlSeconds;
-    pendingAuthorizations = new Map();
-    authorizationCodes = new Map();
     constructor(options) {
         if (options.secret.length < 32) {
             throw new Error("MCP_OAUTH_SECRET 至少需要 32 个字符。");
@@ -112,7 +24,7 @@ export class WukongOAuthProvider {
         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.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 不能为空。");
@@ -125,21 +37,29 @@ export class WukongOAuthProvider {
         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);
+        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) {
-        this.cleanupTransientState();
         const resource = normalizeResourceUrl(params.resource ?? this.resourceUrl);
         this.assertResource(resource);
         const scopes = normalizeScopes(params.scopes);
         const requestId = randomUUID();
-        this.pendingAuthorizations.set(requestId, {
+        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);
@@ -149,8 +69,10 @@ export class WukongOAuthProvider {
         res.redirect(302, authorizationUrl.href);
     }
     async completeBindingAuthorization(requestId, bindingCode) {
-        this.cleanupTransientState();
-        const pending = this.pendingAuthorizations.get(requestId);
+        const pendingValue = await this.clientsStore.getPendingAuthorization(requestId);
+        const pending = pendingValue
+            ? deserializePendingAuthorization(this.decryptTransientState("pending", pendingValue))
+            : undefined;
         if (!pending) {
             throw new AccessDeniedError("授权请求已失效，请返回 ChatGPT 重新授权。");
         }
@@ -169,12 +91,13 @@ export class WukongOAuthProvider {
             throw new AccessDeniedError("72CRM 静默生成的 API Key 验证失败，请重新授权。");
         }
         const code = randomUUID();
-        this.authorizationCodes.set(code, {
+        const codeData = {
             ...pending,
             expiresAt: Date.now() + 5 * 60 * 1000,
             apiKey: normalizedApiKey
-        });
-        this.pendingAuthorizations.delete(requestId);
+        };
+        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) {
@@ -188,16 +111,22 @@ export class WukongOAuthProvider {
         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 })
-        });
+        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 完成静默凭证交换。");
         }
@@ -209,19 +138,19 @@ export class WukongOAuthProvider {
         return apiKey;
     }
     async challengeForAuthorizationCode(client, authorizationCode) {
-        const codeData = this.getAuthorizationCode(client, authorizationCode);
+        const codeData = await this.getAuthorizationCode(client, authorizationCode);
         return codeData.params.codeChallenge;
     }
     async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, redirectUri, resource) {
-        const codeData = this.getAuthorizationCode(client, authorizationCode);
+        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 与授权请求不一致。");
         }
-        this.authorizationCodes.delete(authorizationCode);
-        return this.issueTokens(codeData.apiKey, client.client_id, codeData.scopes, codeData.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");
@@ -264,14 +193,26 @@ export class WukongOAuthProvider {
             // RFC 7009 requires an invalid token to produce the same successful response.
         }
     }
-    getAuthorizationCode(client, authorizationCode) {
-        this.cleanupTransientState();
-        const codeData = this.authorizationCodes.get(authorizationCode);
+    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 = {
@@ -329,17 +270,7 @@ export class WukongOAuthProvider {
         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);
+        const payload = this.decryptValue("wkm1", token);
         if (payload.version !== 1 ||
             (payload.type !== "access" && payload.type !== "refresh") ||
             typeof payload.apiKey !== "string" ||
@@ -353,42 +284,157 @@ export class WukongOAuthProvider {
         }
         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 服务。");
         }
     }
-    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 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) {
+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");
-    if (normalized.protocol !== "https:" && !isLocalHttp) {
-        throw new Error(`${name} 必须使用 HTTPS（本机 localhost 调试除外）。`);
+    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) {

package/dist/server.js

@@ -1,5 +1,6 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
+import { createNocodeToolHandlers, nocodeToolDefinitions } from "./nocode.js";
 import { createToolHandlers } from "./tools.js";
 export const CRM_READ_SCOPE = "crm.read";
 export const CRM_WRITE_SCOPE = "crm.write";
@@ -180,13 +181,28 @@ export function createWukongMcpServer(config = {}) {
     const { oauth, ...crmConfig } = config;
     const server = new McpServer({
         name: "wukong-mcp",
-        version: "0.1.4"
+        version: "0.2.0"
     }, {
         instructions: "先使用只读工具确认模块、记录和字段，再执行写入。所有写入必须显式传 confirm=true；不要尝试任意 URL 请求。"
     });
-    const handlers = createToolHandlers(crmConfig);
-    for (const [name, description, schema] of toolDefinitions) {
-        const access = toolAccess(name, description);
+    const handlers = {
+        ...createToolHandlers(crmConfig),
+        ...createNocodeToolHandlers(crmConfig)
+    };
+    const registeredTools = [
+        ...toolDefinitions.map(([name, description, schema]) => ({
+            name,
+            description,
+            schema,
+            access: toolAccess(name, description),
+            destructive: isDestructiveTool(name)
+        })),
+        ...nocodeToolDefinitions.map((definition) => ({
+            ...definition,
+            destructive: definition.destructive ?? false
+        }))
+    ];
+    for (const { name, description, schema, access, destructive } of registeredTools) {
         const requiredScopes = access === "write"
             ? [CRM_READ_SCOPE, CRM_WRITE_SCOPE]
             : [CRM_READ_SCOPE];
@@ -199,7 +215,7 @@ export function createWukongMcpServer(config = {}) {
             annotations: {
                 readOnlyHint: access === "read",
                 openWorldHint: false,
-                destructiveHint: isDestructiveTool(name),
+                destructiveHint: destructive,
                 ...(access === "read" ? { idempotentHint: true } : {})
             },
             _meta: {
@@ -214,7 +230,11 @@ export function createWukongMcpServer(config = {}) {
                 return insufficientScopeResult(requiredScopes, missingScopes, oauth.resourceMetadataUrl);
             }
             try {
-                const result = await handlers[name](args ?? {});
+                const handler = handlers[name];
+                if (!handler) {
+                    throw new Error(`未找到工具实现：${name}`);
+                }
+                const result = await handler(args ?? {});
                 return toToolResult(result);
             }
             catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wukongcrm/mcp-server",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Local and remote MCP server for fixed 72CRM API access.",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,9 +21,10 @@
     "build": "tsc -p tsconfig.json",
     "prepack": "npm run build",
     "pack:local": "npm pack",
-    "test": "tsx --test test/client.test.ts test/server.test.ts test/oauth.test.ts test/http.test.ts test/tools.test.ts",
+    "test": "tsx --test test/client.test.ts test/server.test.ts test/oauth-state.test.ts test/oauth.test.ts test/http.test.ts test/tools.test.ts test/nocode.test.ts",
     "start": "node dist/index.js",
-    "start:http": "node dist/http-entry.js"
+    "start:http": "node dist/http-entry.js",
+    "start:fc": "node dist/fc-entry.js"
   },
   "engines": {
     "node": ">=18"
@@ -31,6 +32,7 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
     "express": "^5.2.1",
+    "redis": "5.10.0",
     "zod": "^3.25.76"
   },
   "devDependencies": {