@danyow/lark-mcp 0.5.1

package/dist/mcp-server/transport/stdio.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initStdioServer = void 0;
+const express_1 = __importDefault(require("express"));
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const auth_1 = require("../../auth");
+const auth_2 = require("../../auth");
+const logger_1 = require("../../utils/logger");
+const initStdioServer = async (getNewServer, options, { needAuthFlow } = { needAuthFlow: false }) => {
+    const { userAccessToken, appId, oauth } = options;
+    let authHandler;
+    if (!userAccessToken && needAuthFlow) {
+        const app = (0, express_1.default)();
+        app.use(express_1.default.json());
+        authHandler = new auth_2.LarkAuthHandlerLocal(app, options);
+        if (oauth) {
+            authHandler.setupRoutes();
+        }
+    }
+    const transport = new stdio_js_1.StdioServerTransport();
+    const userAccessTokenValue = userAccessToken
+        ? userAccessToken
+        : appId
+            ? { getter: async () => await auth_1.authStore.getLocalAccessToken(appId) }
+            : undefined;
+    const mcpServer = getNewServer({ ...options, userAccessToken: userAccessTokenValue }, authHandler);
+    logger_1.logger.info(`[StdioServerTransport] Connecting to MCP Server, userAccessToken: ${Boolean(userAccessToken)}, appId: ${appId}`);
+    mcpServer.connect(transport).catch((error) => {
+        logger_1.logger.error(`[StdioServerTransport] MCP Connect Error: ${error}`);
+        process.exit(1);
+    });
+};
+exports.initStdioServer = initStdioServer;

package/dist/mcp-server/transport/streamable.d.ts

@@ -0,0 +1,2 @@
+import { InitTransportServerFunction } from '../shared';
+export declare const initStreamableServer: InitTransportServerFunction;

package/dist/mcp-server/transport/streamable.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initStreamableServer = void 0;
+const express_1 = __importDefault(require("express"));
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const utils_1 = require("./utils");
+const auth_1 = require("../../auth");
+const logger_1 = require("../../utils/logger");
+const initStreamableServer = (getNewServer, options, { needAuthFlow } = { needAuthFlow: false }) => {
+    const { userAccessToken, oauth, port, host } = options;
+    if (!port || !host) {
+        throw new Error('[Lark MCP] Port and host are required');
+    }
+    const app = (0, express_1.default)();
+    app.use(express_1.default.json());
+    let authHandler;
+    if (!userAccessToken && needAuthFlow) {
+        authHandler = new auth_1.LarkAuthHandler(app, options);
+        if (oauth) {
+            authHandler.setupRoutes();
+        }
+    }
+    const authMiddleware = (req, res, next) => {
+        var _a;
+        if (authHandler && oauth) {
+            authHandler.authenticateRequest(req, res, next);
+        }
+        else {
+            const authToken = (_a = req.headers.authorization) === null || _a === void 0 ? void 0 : _a.split(' ')[1];
+            if (authToken) {
+                req.auth = { token: authToken, clientId: 'client_id_for_local_auth', scopes: [] };
+            }
+            next();
+        }
+    };
+    app.post('/mcp', authMiddleware, async (req, res) => {
+        var _a;
+        const token = (_a = req.auth) === null || _a === void 0 ? void 0 : _a.token;
+        const { data } = (0, utils_1.parseMCPServerOptionsFromRequest)(req);
+        const server = getNewServer({ ...options, ...data, userAccessToken: data.userAccessToken || token }, authHandler);
+        const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        res.on('close', () => {
+            transport.close();
+            server.close();
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    });
+    const handleMethodNotAllowed = async (_req, res) => {
+        res
+            .writeHead(405)
+            .end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Method not allowed.' }, id: null }));
+    };
+    app.get('/mcp', async (req, res) => {
+        try {
+            console.log('Received GET MCP request');
+            logger_1.logger.info(`[StreamableServerTransport] Received GET MCP request`);
+            await handleMethodNotAllowed(req, res);
+        }
+        catch (error) {
+            (0, utils_1.sendJsonRpcError)(res, error);
+        }
+    });
+    app.delete('/mcp', async (req, res) => {
+        try {
+            console.log('Received DELETE MCP request');
+            logger_1.logger.info(`[StreamableServerTransport] Received DELETE MCP request`);
+            await handleMethodNotAllowed(req, res);
+        }
+        catch (error) {
+            (0, utils_1.sendJsonRpcError)(res, error);
+        }
+    });
+    app.listen(port, host, (error) => {
+        if (error) {
+            logger_1.logger.error(`[StreamableServerTransport] Server error: ${error}`);
+            process.exit(1);
+        }
+        console.log(`📡 Streamable endpoint: http://${host}:${port}/mcp`);
+        logger_1.logger.info(`[StreamableServerTransport] Streamable endpoint: http://${host}:${port}/mcp`);
+    });
+};
+exports.initStreamableServer = initStreamableServer;

package/dist/mcp-server/transport/utils.d.ts

@@ -0,0 +1,16 @@
+import { Request, Response } from 'express';
+import { McpServerOptions } from '../shared';
+export declare enum JSONRPCErrorCodes {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603
+}
+export declare function parseMCPServerOptionsFromRequest(req: Request): {
+    data: McpServerOptions;
+    success: boolean;
+    message?: string;
+};
+export declare function sendJsonRpcError(res: Response, error: Error, httpCode?: number, code?: JSONRPCErrorCodes, id?: number | null): void;
+export declare function sendResponseError(res: Response, error: Error, httpCode?: number): void;

package/dist/mcp-server/transport/utils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONRPCErrorCodes = void 0;
+exports.parseMCPServerOptionsFromRequest = parseMCPServerOptionsFromRequest;
+exports.sendJsonRpcError = sendJsonRpcError;
+exports.sendResponseError = sendResponseError;
+const shared_1 = require("../shared");
+var JSONRPCErrorCodes;
+(function (JSONRPCErrorCodes) {
+    JSONRPCErrorCodes[JSONRPCErrorCodes["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    JSONRPCErrorCodes[JSONRPCErrorCodes["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+})(JSONRPCErrorCodes || (exports.JSONRPCErrorCodes = JSONRPCErrorCodes = {}));
+function parseMCPServerOptionsFromRequest(req) {
+    const result = shared_1.mcpServerOptionSchema.safeParse(req.query || {});
+    if (!result.success) {
+        return { data: {}, success: false, message: result.error.message };
+    }
+    return { data: result.data, success: true };
+}
+function sendJsonRpcError(res, error, httpCode = 500, code = JSONRPCErrorCodes.INTERNAL_ERROR, id = null) {
+    console.error(error);
+    if (!res.headersSent) {
+        res.status(httpCode).json({ jsonrpc: '2.0', error: { code, message: error.message }, id });
+    }
+}
+function sendResponseError(res, error, httpCode = 500) {
+    console.error(error);
+    if (!res.headersSent) {
+        res.status(httpCode).send(error.message);
+    }
+}

package/dist/mcp-tool/constants.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Commonly used tools in MCP
+ */
+import { ToolName } from './tools';
+export declare enum PresetName {
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    LIGHT = "preset.light",
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    DEFAULT = "preset.default",
+    /**
+     * IM related tools for chat and message operations
+     */
+    IM_DEFAULT = "preset.im.default",
+    /**
+     * Base preset for base operations
+     */
+    BASE_DEFAULT = "preset.base.default",
+    /**
+     * Base tools with batch operations
+     */
+    BASE_BATCH = "preset.base.batch",
+    /**
+     * Document related tools for content and permission operations
+     */
+    DOC_DEFAULT = "preset.doc.default",
+    /**
+     * Task management related tools
+     */
+    TASK_DEFAULT = "preset.task.default",
+    /**
+     * Calendar event management tools
+     */
+    CALENDAR_DEFAULT = "preset.calendar.default"
+}
+export declare const presetLightToolNames: ToolName[];
+export declare const presetContactToolNames: ToolName[];
+export declare const presetImToolNames: ToolName[];
+export declare const presetBaseCommonToolNames: ToolName[];
+export declare const presetBaseToolNames: ToolName[];
+export declare const presetBaseRecordBatchToolNames: ToolName[];
+export declare const presetDocToolNames: ToolName[];
+export declare const presetTaskToolNames: ToolName[];
+export declare const presetCalendarToolNames: ToolName[];
+export declare const defaultToolNames: ToolName[];
+export declare const presetTools: Record<PresetName, ToolName[]>;

package/dist/mcp-tool/constants.js

@@ -0,0 +1,115 @@
+"use strict";
+/**
+ * Commonly used tools in MCP
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.presetTools = exports.defaultToolNames = exports.presetCalendarToolNames = exports.presetTaskToolNames = exports.presetDocToolNames = exports.presetBaseRecordBatchToolNames = exports.presetBaseToolNames = exports.presetBaseCommonToolNames = exports.presetImToolNames = exports.presetContactToolNames = exports.presetLightToolNames = exports.PresetName = void 0;
+var PresetName;
+(function (PresetName) {
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    PresetName["LIGHT"] = "preset.light";
+    /**
+     * Default preset including IM, Bitable, Doc and Contact tools
+     */
+    PresetName["DEFAULT"] = "preset.default";
+    /**
+     * IM related tools for chat and message operations
+     */
+    PresetName["IM_DEFAULT"] = "preset.im.default";
+    /**
+     * Base preset for base operations
+     */
+    PresetName["BASE_DEFAULT"] = "preset.base.default";
+    /**
+     * Base tools with batch operations
+     */
+    PresetName["BASE_BATCH"] = "preset.base.batch";
+    /**
+     * Document related tools for content and permission operations
+     */
+    PresetName["DOC_DEFAULT"] = "preset.doc.default";
+    /**
+     * Task management related tools
+     */
+    PresetName["TASK_DEFAULT"] = "preset.task.default";
+    /**
+     * Calendar event management tools
+     */
+    PresetName["CALENDAR_DEFAULT"] = "preset.calendar.default";
+})(PresetName || (exports.PresetName = PresetName = {}));
+exports.presetLightToolNames = [
+    'im.v1.message.list',
+    'im.v1.message.create',
+    'im.v1.chat.search',
+    'contact.v3.user.batchGetId',
+    'docx.v1.document.rawContent',
+    'docx.builtin.import',
+    'docx.builtin.search',
+    'wiki.v2.space.getNode',
+    'bitable.v1.appTableRecord.search',
+    'bitable.v1.appTableRecord.batchCreate',
+];
+exports.presetContactToolNames = ['contact.v3.user.batchGetId'];
+exports.presetImToolNames = [
+    'im.v1.chat.create',
+    'im.v1.chat.list',
+    'im.v1.chatMembers.get',
+    'im.v1.message.create',
+    'im.v1.message.list',
+];
+exports.presetBaseCommonToolNames = [
+    'bitable.v1.app.create',
+    'bitable.v1.appTable.create',
+    'bitable.v1.appTable.list',
+    'bitable.v1.appTableField.list',
+    'bitable.v1.appTableRecord.search',
+];
+exports.presetBaseToolNames = [
+    ...exports.presetBaseCommonToolNames,
+    'bitable.v1.appTableRecord.create',
+    'bitable.v1.appTableRecord.update',
+];
+exports.presetBaseRecordBatchToolNames = [
+    ...exports.presetBaseCommonToolNames,
+    'bitable.v1.appTableRecord.batchCreate',
+    'bitable.v1.appTableRecord.batchUpdate',
+];
+exports.presetDocToolNames = [
+    'docx.v1.document.rawContent',
+    'docx.builtin.import',
+    'docx.builtin.search',
+    'drive.v1.permissionMember.create',
+    'wiki.v2.space.getNode',
+    'wiki.v1.node.search',
+];
+exports.presetTaskToolNames = [
+    'task.v2.task.create',
+    'task.v2.task.patch',
+    'task.v2.task.addMembers',
+    'task.v2.task.addReminders',
+];
+exports.presetCalendarToolNames = [
+    'calendar.v4.calendarEvent.create',
+    'calendar.v4.calendarEvent.patch',
+    'calendar.v4.calendarEvent.get',
+    'calendar.v4.freebusy.list',
+    'calendar.v4.calendar.primary',
+];
+exports.defaultToolNames = [
+    ...exports.presetImToolNames,
+    ...exports.presetBaseToolNames,
+    ...exports.presetDocToolNames,
+    ...exports.presetContactToolNames,
+];
+exports.presetTools = {
+    [PresetName.LIGHT]: exports.presetLightToolNames,
+    [PresetName.DEFAULT]: exports.defaultToolNames,
+    [PresetName.IM_DEFAULT]: exports.presetImToolNames,
+    [PresetName.BASE_DEFAULT]: exports.presetBaseToolNames,
+    [PresetName.BASE_BATCH]: exports.presetBaseRecordBatchToolNames,
+    [PresetName.DOC_DEFAULT]: exports.presetDocToolNames,
+    [PresetName.TASK_DEFAULT]: exports.presetTaskToolNames,
+    [PresetName.CALENDAR_DEFAULT]: exports.presetCalendarToolNames,
+};

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

@@ -0,0 +1 @@
+export * from './recall';

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

@@ -0,0 +1,17 @@
+"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("./recall"), exports);

package/dist/mcp-tool/document-tool/recall/index.d.ts

@@ -0,0 +1,2 @@
+import { DocumentRecallTool } from "./type";
+export declare const RecallTool: DocumentRecallTool;

package/dist/mcp-tool/document-tool/recall/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecallTool = void 0;
+const zod_1 = require("zod");
+const request_1 = require("./request");
+const searchParamsSchema = {
+    query: zod_1.z.string().describe("user input"),
+};
+exports.RecallTool = {
+    name: "openplatform_developer_document_recall",
+    description: "Recall for relevant documents in all of the Feishu/Lark Open Platform Developer Documents based on user input.",
+    schema: searchParamsSchema,
+    handler: async (params, options) => {
+        const { query } = params;
+        try {
+            const results = await (0, request_1.recallDeveloperDocument)(query, options);
+            // Return results
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: results.length ? `Find ${results.length} results:\n${results.join("\n\n")}` : "No results found",
+                    }
+                ],
+            };
+        }
+        catch (error) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: `Search failed:${error instanceof Error ? error.message : 'Unknown error'}`,
+                    },
+                ],
+            };
+        }
+    }
+};

package/dist/mcp-tool/document-tool/recall/request.d.ts

@@ -0,0 +1,2 @@
+import { DocumentRecallToolOptions } from './type';
+export declare const recallDeveloperDocument: (query: string, options: DocumentRecallToolOptions) => Promise<any>;

package/dist/mcp-tool/document-tool/recall/request.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recallDeveloperDocument = void 0;
+const http_instance_1 = require("../../../utils/http-instance");
+const recallDeveloperDocument = async (query, options) => {
+    try {
+        const { domain, count = 3 } = options;
+        // Get Feishu search API endpoint
+        const searchEndpoint = `${domain}/document_portal/v1/recall`;
+        const payload = {
+            question: query,
+        };
+        // Send network request to Feishu search API
+        const response = await http_instance_1.commonHttpInstance.post(searchEndpoint, payload, {
+            timeout: 10000,
+        });
+        // Process search results
+        let results = response.data.chunks || [];
+        return results.slice(0, count);
+    }
+    catch (error) {
+        throw error;
+    }
+};
+exports.recallDeveloperDocument = recallDeveloperDocument;

package/dist/mcp-tool/document-tool/recall/type.d.ts

@@ -0,0 +1,19 @@
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types";
+import type { z } from "zod";
+export interface DocumentRecallToolOptions {
+    domain?: string;
+    smallToBig?: boolean;
+    count?: number;
+    multiQuery?: boolean;
+    timeout?: number;
+}
+export interface DocumentRecallTool {
+    name: string;
+    description: string;
+    schema: {
+        query: z.ZodType<string>;
+    };
+    handler: (params: {
+        query: string;
+    }, options: DocumentRecallToolOptions) => Promise<CallToolResult>;
+}

package/dist/mcp-tool/document-tool/recall/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,5 @@
+export * from './mcp-tool';
+export * from './tools';
+export * from './types';
+export * from './constants';
+export * from './document-tool';

package/dist/mcp-tool/index.js

@@ -0,0 +1,21 @@
+"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("./mcp-tool"), exports);
+__exportStar(require("./tools"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./document-tool"), exports);

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

@@ -0,0 +1,52 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { LarkMcpToolOptions, McpTool, SettableValue, ToolNameCase } from './types';
+import { LarkAuthHandler } from '../auth';
+/**
+ * Feishu/Lark MCP
+ */
+export declare class LarkMcpTool {
+    private client;
+    private userAccessToken;
+    private auth;
+    private options;
+    private allTools;
+    /**
+     * Feishu/Lark MCP
+     * @param options Feishu/Lark Client Options
+     */
+    constructor(options: LarkMcpToolOptions, auth?: LarkAuthHandler);
+    /**
+     * Get MCP Tools
+     * @returns MCP Tool Definition Array
+     */
+    getTools(): McpTool[];
+    /**
+     * Update User Access Token
+     * @param userAccessToken User Access Token
+     */
+    updateUserAccessToken(userAccessToken: string | SettableValue): void;
+    private getUserAccessToken;
+    private setUserAccessToken;
+    reAuthorize(): Promise<{
+        userAccessToken?: string;
+        authorizeUrl?: string;
+    }>;
+    ensureGetUserAccessToken(): Promise<{
+        userAccessToken?: string;
+        authorizeUrl?: string;
+    }>;
+    getReAuthorizeMessage(authorizeUrl?: string, errorCode?: number, errorText?: string): {
+        isError: boolean;
+        content: {
+            type: "text";
+            text: string;
+        }[];
+    };
+    /**
+     * Register Tools to MCP Server
+     * @param server MCP Server Instance
+     */
+    registerMcpServer(server: McpServer, options?: {
+        toolNameCase?: ToolNameCase;
+    }): void;
+}