bitfire-lark-mcp 1.0.0

package/dist/mcp-tool/utils/filter-tools.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterTools = filterTools;
+const types_1 = require("../types");
+function filterTools(tools, options) {
+    let filteredTools = tools.filter((tool) => {
+        var _a, _b;
+        return ((_a = options.allowTools) === null || _a === void 0 ? void 0 : _a.includes(tool.name)) ||
+            ((_b = options.allowProjects) === null || _b === void 0 ? void 0 : _b.includes(tool.project));
+    });
+    // Filter by token mode
+    if (options.tokenMode && options.tokenMode !== types_1.TokenMode.AUTO) {
+        filteredTools = filteredTools.filter((tool) => {
+            if (!tool.accessTokens) {
+                return false;
+            }
+            if (options.tokenMode === types_1.TokenMode.USER_ACCESS_TOKEN) {
+                return tool.accessTokens.includes('user');
+            }
+            if (options.tokenMode === types_1.TokenMode.TENANT_ACCESS_TOKEN) {
+                return tool.accessTokens.includes('tenant');
+            }
+            return true;
+        });
+    }
+    return filteredTools;
+}

package/dist/mcp-tool/utils/get-should-use-uat.d.ts

@@ -0,0 +1,2 @@
+import { TokenMode } from '../types';
+export declare function getShouldUseUAT(tokenMode?: TokenMode, useUAT?: boolean): boolean | undefined;

package/dist/mcp-tool/utils/get-should-use-uat.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShouldUseUAT = getShouldUseUAT;
+const types_1 = require("../types");
+function getShouldUseUAT(tokenMode = types_1.TokenMode.AUTO, useUAT) {
+    switch (tokenMode) {
+        case types_1.TokenMode.USER_ACCESS_TOKEN: {
+            return true;
+        }
+        case types_1.TokenMode.TENANT_ACCESS_TOKEN: {
+            return false;
+        }
+        case types_1.TokenMode.AUTO:
+        default: {
+            return useUAT;
+        }
+    }
+}

package/dist/mcp-tool/utils/handler.d.ts

@@ -0,0 +1,2 @@
+import { McpHandler } from '../types';
+export declare const larkOapiHandler: McpHandler;

package/dist/mcp-tool/utils/handler.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.larkOapiHandler = void 0;
+const lark = __importStar(require("@larksuiteoapi/node-sdk"));
+const logger_1 = require("../../utils/logger");
+const sdkFuncCall = async (client, params, options) => {
+    const { tool, userAccessToken } = options || {};
+    const { sdkName, path, httpMethod } = tool || {};
+    if (!sdkName) {
+        logger_1.logger.error(`[larkOapiHandler] Invalid sdkName`);
+        throw new Error('Invalid sdkName');
+    }
+    const chain = sdkName.split('.');
+    let func = client;
+    for (const element of chain) {
+        func = func[element];
+        if (!func) {
+            func = async (params, ...args) => await client.request({ method: httpMethod, url: path, ...params }, ...args);
+            break;
+        }
+    }
+    if (!(func instanceof Function)) {
+        func = async (params, ...args) => await client.request({ method: httpMethod, url: path, ...params }, ...args);
+    }
+    if (params === null || params === void 0 ? void 0 : params.useUAT) {
+        if (!userAccessToken) {
+            logger_1.logger.error(`[larkOapiHandler] UserAccessToken is invalid or expired`);
+            throw new Error('UserAccessToken is invalid or expired');
+        }
+        return await func(params, lark.withUserAccessToken(userAccessToken));
+    }
+    return await func(params);
+};
+const larkOapiHandler = async (client, params, options) => {
+    var _a, _b;
+    try {
+        const response = await sdkFuncCall(client, params, options);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify((_a = response === null || response === void 0 ? void 0 : response.data) !== null && _a !== void 0 ? _a : response),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.data) || (error === null || error === void 0 ? void 0 : error.message) || error),
+                },
+            ],
+        };
+    }
+};
+exports.larkOapiHandler = larkOapiHandler;

package/dist/mcp-tool/utils/index.d.ts

@@ -0,0 +1,4 @@
+export * from './filter-tools';
+export * from './handler';
+export * from './case-transf';
+export * from './get-should-use-uat';

package/dist/mcp-tool/utils/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./filter-tools"), exports);
+__exportStar(require("./handler"), exports);
+__exportStar(require("./case-transf"), exports);
+__exportStar(require("./get-should-use-uat"), exports);

package/dist/utils/clean-env-args.d.ts

@@ -0,0 +1 @@
+export declare function cleanEnvArgs(args: Record<string, string | undefined>): Record<string, string>;

package/dist/utils/clean-env-args.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanEnvArgs = cleanEnvArgs;
+function cleanEnvArgs(args) {
+    const result = {};
+    for (const [key, value] of Object.entries(args)) {
+        if (value) {
+            result[key] = value;
+        }
+    }
+    return result;
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,18 @@
+import envPaths from 'env-paths';
+export declare const ENV_PATHS: envPaths.Paths;
+export declare const USER_AGENT: string;
+export declare const NODE_VERSION_MAJOR: number;
+export declare const OAPI_MCP_DEFAULT_ARGS: {
+    domain: string;
+    toolNameCase: string;
+    language: string;
+    tokenMode: string;
+    mode: string;
+    host: string;
+    port: string;
+};
+export declare const OAPI_MCP_ENV_ARGS: Record<string, string>;
+export declare enum OAPI_MCP_ERROR_CODE {
+    USER_ACCESS_TOKEN_INVALID = 99991668,
+    USER_ACCESS_TOKEN_UNAUTHORIZED = 99991679
+}

package/dist/utils/constants.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAPI_MCP_ERROR_CODE = exports.OAPI_MCP_ENV_ARGS = exports.OAPI_MCP_DEFAULT_ARGS = exports.NODE_VERSION_MAJOR = exports.USER_AGENT = exports.ENV_PATHS = void 0;
+const clean_env_args_1 = require("./clean-env-args");
+const version_1 = require("./version");
+const env_paths_1 = __importDefault(require("env-paths"));
+exports.ENV_PATHS = (0, env_paths_1.default)('lark-mcp');
+const [major] = process.versions.node.split('.').map(Number);
+exports.USER_AGENT = `oapi-sdk-mcp/${version_1.currentVersion}`;
+exports.NODE_VERSION_MAJOR = major;
+exports.OAPI_MCP_DEFAULT_ARGS = {
+    domain: 'https://open.feishu.cn',
+    toolNameCase: 'snake',
+    language: 'en',
+    tokenMode: 'auto',
+    mode: 'stdio',
+    host: 'localhost',
+    port: '3000',
+};
+exports.OAPI_MCP_ENV_ARGS = (0, clean_env_args_1.cleanEnvArgs)({
+    appId: process.env.APP_ID,
+    appSecret: process.env.APP_SECRET,
+    userAccessToken: process.env.USER_ACCESS_TOKEN,
+    tokenMode: process.env.LARK_TOKEN_MODE,
+    tools: process.env.LARK_TOOLS,
+    domain: process.env.LARK_DOMAIN,
+});
+var OAPI_MCP_ERROR_CODE;
+(function (OAPI_MCP_ERROR_CODE) {
+    OAPI_MCP_ERROR_CODE[OAPI_MCP_ERROR_CODE["USER_ACCESS_TOKEN_INVALID"] = 99991668] = "USER_ACCESS_TOKEN_INVALID";
+    OAPI_MCP_ERROR_CODE[OAPI_MCP_ERROR_CODE["USER_ACCESS_TOKEN_UNAUTHORIZED"] = 99991679] = "USER_ACCESS_TOKEN_UNAUTHORIZED";
+})(OAPI_MCP_ERROR_CODE || (exports.OAPI_MCP_ERROR_CODE = OAPI_MCP_ERROR_CODE = {}));

package/dist/utils/http-instance.d.ts

@@ -0,0 +1,2 @@
+export declare const commonHttpInstance: import("axios").AxiosInstance;
+export declare const oapiHttpInstance: import("axios").AxiosInstance;

package/dist/utils/http-instance.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oapiHttpInstance = exports.commonHttpInstance = void 0;
+const axios_1 = __importDefault(require("axios"));
+const proxy_agent_1 = require("proxy-agent");
+const constants_1 = require("./constants");
+const proxyAgent = new proxy_agent_1.ProxyAgent();
+const traceMiddleware = (request) => {
+    if (request.headers) {
+        request.headers['User-Agent'] = constants_1.USER_AGENT;
+    }
+    return request;
+};
+exports.commonHttpInstance = axios_1.default.create({ proxy: false, httpAgent: proxyAgent, httpsAgent: proxyAgent });
+exports.commonHttpInstance.interceptors.request.use(traceMiddleware, undefined, { synchronous: true });
+exports.oapiHttpInstance = axios_1.default.create({ proxy: false, httpAgent: proxyAgent, httpsAgent: proxyAgent });
+exports.oapiHttpInstance.interceptors.request.use(traceMiddleware, undefined, { synchronous: true });
+exports.oapiHttpInstance.interceptors.response.use((response) => response.data);

package/dist/utils/logger.d.ts

@@ -0,0 +1,22 @@
+export declare enum LogLevel {
+    ERROR = 1,
+    WARN = 2,
+    INFO = 3,
+    DEBUG = 4
+}
+export declare class Logger {
+    private level;
+    static logFilesToKeep: number;
+    static logFilePrefix: string;
+    constructor();
+    get logFileName(): string;
+    initLogFile: () => void;
+    cleanHistoryLogFile: () => void;
+    setLevel: (level: LogLevel) => void;
+    log: (message: string) => void;
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+}
+export declare const logger: Logger;

package/dist/utils/logger.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./constants");
+const version_1 = require("./version");
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 1] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 2] = "WARN";
+    LogLevel[LogLevel["INFO"] = 3] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 4] = "DEBUG";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    constructor() {
+        this.level = LogLevel.WARN;
+        this.initLogFile = () => {
+            if (!fs_1.default.existsSync(constants_1.ENV_PATHS.log)) {
+                fs_1.default.mkdirSync(constants_1.ENV_PATHS.log, { recursive: true });
+            }
+        };
+        this.cleanHistoryLogFile = () => {
+            try {
+                // clean old log files, 7 days ago
+                const logFiles = fs_1.default
+                    .readdirSync(constants_1.ENV_PATHS.log)
+                    .filter((file) => file.startsWith(Logger.logFilePrefix) && file.endsWith('.log'));
+                const logFilesToDelete = logFiles.filter((file) => {
+                    const fileDate = file.split('-')[1].split('.')[0];
+                    const fileDateObj = new Date(fileDate);
+                    return fileDateObj < new Date(Date.now() - Logger.logFilesToKeep * 24 * 60 * 60 * 1000);
+                });
+                for (const file of logFilesToDelete) {
+                    try {
+                        fs_1.default.unlinkSync(path_1.default.join(constants_1.ENV_PATHS.log, file));
+                    }
+                    catch (error) {
+                        console.error(`Failed to delete log file: ${error}`);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Failed to clean history log file: ${error}`);
+            }
+        };
+        this.setLevel = (level) => {
+            this.level = level;
+        };
+        this.log = (message) => {
+            try {
+                fs_1.default.appendFileSync(path_1.default.join(constants_1.ENV_PATHS.log, this.logFileName), `[${new Date().toISOString()}] [${version_1.currentVersion}] [${process.pid}] ${message}\n`);
+            }
+            catch (error) {
+                console.error(`Failed to write log: ${error} ${message}`);
+            }
+        };
+        this.debug = (message) => {
+            if (this.level < LogLevel.DEBUG) {
+                return;
+            }
+            this.log(`[DEBUG] ${message}`);
+        };
+        this.info = (message) => {
+            if (this.level < LogLevel.INFO) {
+                return;
+            }
+            this.log(`[INFO] ${message}`);
+        };
+        this.warn = (message) => {
+            if (this.level < LogLevel.WARN) {
+                return;
+            }
+            console.error(`[WARN] ${message}`);
+            this.log(`[WARN] ${message}`);
+        };
+        this.error = (message) => {
+            if (this.level < LogLevel.ERROR) {
+                return;
+            }
+            console.error(`[ERROR] ${message}`);
+            this.log(`[ERROR]  ${message}`);
+        };
+        this.initLogFile();
+        this.cleanHistoryLogFile();
+    }
+    get logFileName() {
+        return `${Logger.logFilePrefix}${new Date().toISOString().split('T')[0]}.log`;
+    }
+}
+exports.Logger = Logger;
+Logger.logFilesToKeep = 7;
+Logger.logFilePrefix = 'lark-mcp-';
+exports.logger = new Logger();

package/dist/utils/noop.d.ts

@@ -0,0 +1 @@
+export declare const noop: () => void;

package/dist/utils/noop.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = void 0;
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+const noop = () => { };
+exports.noop = noop;

package/dist/utils/parser-string-array.d.ts

@@ -0,0 +1 @@
+export declare function parseStringArray(str?: string | string[]): string[];

package/dist/utils/parser-string-array.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStringArray = parseStringArray;
+function parseStringArray(str) {
+    if (!str) {
+        return [];
+    }
+    if (typeof str === 'string') {
+        // split by comma or space and trim space
+        return str.split(/[,\s]+/).map((item) => item.trim());
+    }
+    return str.map((item) => item.trim());
+}

package/dist/utils/safe-json-parse.d.ts

@@ -0,0 +1 @@
+export declare function safeJsonParse<T>(str: string | undefined | null, fallback: T): T;

package/dist/utils/safe-json-parse.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeJsonParse = safeJsonParse;
+function safeJsonParse(str, fallback) {
+    if (!str) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(str);
+    }
+    catch (e) {
+        return fallback;
+    }
+}

package/dist/utils/version.d.ts

@@ -0,0 +1 @@
+export declare const currentVersion: string;

package/dist/utils/version.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentVersion = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const safe_json_parse_1 = require("./safe-json-parse");
+function getPackageJsonVersion() {
+    const filePath = path.join(__dirname, '../../package.json');
+    try {
+        const packageJson = (0, safe_json_parse_1.safeJsonParse)(fs.readFileSync(filePath, 'utf8'), {
+            version: '0.0.0',
+        });
+        return packageJson.version || '0.0.0';
+    }
+    catch (error) {
+        return '0.0.0';
+    }
+}
+exports.currentVersion = getPackageJsonVersion();