@baitong-dev/mcp-helpers 0.0.3 → 0.0.5

package/dist/file/index.d.ts

@@ -4,7 +4,7 @@ export * as Ripgrep from './ripgrep';
  * @param path The path to check
  * @returns Whether the path is a directory
  */
-export declare function isDir(path: string): Promise<boolean>;
+export declare function isDirectory(path: string): boolean;
 /**
  * 检查一个目录是否是另一个目录的子目录
  * @param parent - 父目录路径

package/dist/file/index.js

@@ -37,18 +37,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Ripgrep = void 0;
-exports.isDir = isDir;
+exports.isDirectory = isDirectory;
 exports.isSubdirectory = isSubdirectory;
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 exports.Ripgrep = __importStar(require("./ripgrep"));
 /**
  * Check if a path is a directory.
  * @param path The path to check
  * @returns Whether the path is a directory
  */
-async function isDir(path) {
+function isDirectory(path) {
     try {
-        const stat = await Bun.file(path).stat();
+        const stat = fs_1.default.statSync(path);
         return stat.isDirectory();
     }
     catch {

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from './file';
 export * from './process';
 export * from './util';
 export * from './wasm';
+export * from './tools';

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./file"), exports);
 __exportStar(require("./process"), exports);
 __exportStar(require("./util"), exports);
 __exportStar(require("./wasm"), exports);
+__exportStar(require("./tools"), exports);

package/dist/tools/index.d.ts

@@ -0,0 +1,2 @@
+export * as Tool from './tool';
+export * from './question';

package/dist/tools/index.js

@@ -0,0 +1,41 @@
+"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;
+    };
+})();
+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 });
+exports.Tool = void 0;
+exports.Tool = __importStar(require("./tool"));
+__exportStar(require("./question"), exports);

package/dist/tools/question.d.ts

@@ -0,0 +1,91 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import z from 'zod';
+import { Info as ToolInfo } from './tool';
+import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import { ServerRequest } from '@modelcontextprotocol/sdk/types.js';
+import { ServerNotification } from '@modelcontextprotocol/sdk/types.js';
+declare const Questions: z.ZodArray<z.ZodObject<{
+    header: z.ZodString;
+    multiple: z.ZodOptional<z.ZodBoolean>;
+    options: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>;
+    question: z.ZodString;
+}, z.core.$strip>>;
+type Questions = z.infer<typeof Questions>;
+export declare class Question {
+    static Option: z.ZodObject<{
+        label: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>;
+    static Info: z.ZodObject<{
+        question: z.ZodString;
+        header: z.ZodString;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        custom: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+    static Questions: z.ZodArray<z.ZodObject<{
+        header: z.ZodString;
+        multiple: z.ZodOptional<z.ZodBoolean>;
+        options: z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            description: z.ZodString;
+        }, z.core.$strip>>;
+        question: z.ZodString;
+    }, z.core.$strip>>;
+    static Answer: z.ZodArray<z.ZodString>;
+    static Answers: z.ZodArray<z.ZodArray<z.ZodString>>;
+    static InfoSchema: z.ZodObject<{
+        method: z.ZodLiteral<"question:ask">;
+        params: z.ZodObject<{
+            requestId: z.ZodString;
+            toolInfo: z.ZodObject<{
+                sessionId: z.ZodString;
+                messageId: z.ZodString;
+                callId: z.ZodString;
+            }, z.core.$strip>;
+            questions: z.ZodArray<z.ZodObject<{
+                header: z.ZodString;
+                multiple: z.ZodOptional<z.ZodBoolean>;
+                options: z.ZodArray<z.ZodObject<{
+                    label: z.ZodString;
+                    description: z.ZodString;
+                }, z.core.$strip>>;
+                question: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    static AnswerSchema: z.ZodObject<{
+        method: z.ZodLiteral<"question:answer">;
+        params: z.ZodObject<{
+            requestId: z.ZodString;
+            toolInfo: z.ZodObject<{
+                sessionId: z.ZodString;
+                messageId: z.ZodString;
+                callId: z.ZodString;
+            }, z.core.$strip>;
+            answers: z.ZodArray<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    private _server;
+    constructor(server: McpServer);
+    /**
+     * Ask questions to the user and wait for the answers.
+     * @param questions Questions to ask
+     * @param toolInfo ToolInfo
+     * @returns Answers
+     */
+    ask(questions: Questions, toolInfo: ToolInfo, extra: RequestHandlerExtra<ServerRequest, ServerNotification>): Promise<{
+        title: string;
+        output: string;
+        metadata: {
+            answers: string[][];
+        };
+    }>;
+}
+export {};

package/dist/tools/question.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Question = void 0;
+const zod_1 = __importDefault(require("zod"));
+const tool_1 = require("./tool");
+const Option = zod_1.default
+    .object({
+    label: zod_1.default.string().describe('Display text (1-5 words, concise)'),
+    description: zod_1.default.string().describe('Explanation of choice')
+})
+    .meta({
+    ref: 'QuestionOption'
+});
+const Info = zod_1.default
+    .object({
+    question: zod_1.default.string().describe('Complete question'),
+    header: zod_1.default.string().describe('Very short label (max 30 chars)'),
+    options: zod_1.default.array(Option).describe('Available choices'),
+    multiple: zod_1.default.boolean().optional().describe('Allow selecting multiple choices'),
+    custom: zod_1.default.boolean().optional().describe('Allow typing a custom answer (default: true)')
+})
+    .meta({
+    ref: 'QuestionInfo'
+});
+const Questions = zod_1.default.array(Info.omit({ custom: true })).describe('Questions to ask');
+const Answer = zod_1.default.array(zod_1.default.string()).meta({
+    ref: 'QuestionAnswer'
+});
+const Answers = zod_1.default
+    .array(Answer)
+    .describe('User answers in order of questions (each answer is an array of selected labels)');
+const InfoSchema = zod_1.default.object({
+    method: zod_1.default.literal('question:ask'),
+    params: zod_1.default.object({
+        requestId: zod_1.default.string().describe('Request ID'),
+        toolInfo: tool_1.Info,
+        questions: Questions
+    })
+});
+const AnswerSchema = zod_1.default.object({
+    method: zod_1.default.literal('question:answer'),
+    params: zod_1.default.object({
+        requestId: zod_1.default.string().describe('Request ID'),
+        toolInfo: tool_1.Info,
+        answers: Answers
+    })
+});
+class Question {
+    constructor(server) {
+        this._server = server;
+    }
+    /**
+     * Ask questions to the user and wait for the answers.
+     * @param questions Questions to ask
+     * @param toolInfo ToolInfo
+     * @returns Answers
+     */
+    async ask(questions, toolInfo, extra) {
+        if (questions.length === 0) {
+            throw new Error('At least one question is required');
+        }
+        for (const question of questions) {
+            if (question.options.length === 0) {
+                throw new Error('At least one option is required for each question');
+            }
+        }
+        const requestId = (0, tool_1.createRequestId)(extra.requestId);
+        // 开始询问问题
+        let progressTimer;
+        try {
+            const startTime = Date.now();
+            const maxWaitTime = 10 * 60 * 1000;
+            const progressToken = extra._meta?.progressToken;
+            // 不断重置超时时间，防止用户长时间不回答
+            const heartbeat = () => {
+                if (!progressToken)
+                    return;
+                progressTimer = setTimeout(() => {
+                    const waitTime = Date.now() - startTime;
+                    this._server.server.notification({
+                        method: 'notifications/progress',
+                        params: {
+                            total: maxWaitTime,
+                            progress: waitTime,
+                            progressToken
+                        }
+                    }, { relatedRequestId: extra.requestId });
+                    if (waitTime <= maxWaitTime) {
+                        heartbeat();
+                    }
+                }, 10 * 1000);
+            };
+            heartbeat();
+            // 发送问题请求并等待回答
+            const response = await this._server.server.request({
+                method: 'question:ask',
+                params: {
+                    questions,
+                    requestId,
+                    toolInfo
+                }
+            }, AnswerSchema, {
+                timeout: maxWaitTime, // 10分钟超时
+                maxTotalTimeout: maxWaitTime,
+                relatedRequestId: extra.requestId
+            });
+            const answers = response.params.answers;
+            function format(answer) {
+                if (!answer?.length)
+                    return 'Unanswered';
+                return answer.join(', ');
+            }
+            const formatted = questions
+                .map((q, i) => `"${q.question}"="${format(answers[i])}"`)
+                .join(', ');
+            const output = `User has answered your questions: ${formatted}. You can now continue with the user's answers in mind.`;
+            return {
+                title: `Asked ${questions.length} question${questions.length > 1 ? 's' : ''}`,
+                output,
+                metadata: {
+                    answers
+                }
+            };
+        }
+        finally {
+            clearTimeout(progressTimer);
+        }
+    }
+}
+exports.Question = Question;
+Question.Option = Option;
+Question.Info = Info;
+Question.Questions = Questions;
+Question.Answer = Answer;
+Question.Answers = Answers;
+Question.InfoSchema = InfoSchema;
+Question.AnswerSchema = AnswerSchema;

package/dist/tools/tool.d.ts

@@ -0,0 +1,9 @@
+import z from 'zod';
+import { RequestId } from '@modelcontextprotocol/sdk/types.js';
+export declare const Info: z.ZodObject<{
+    sessionId: z.ZodString;
+    messageId: z.ZodString;
+    callId: z.ZodString;
+}, z.core.$strip>;
+export type Info = z.infer<typeof Info>;
+export declare function createRequestId(requestId: RequestId): string;

package/dist/tools/tool.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Info = void 0;
+exports.createRequestId = createRequestId;
+const zod_1 = __importDefault(require("zod"));
+const uuid_1 = require("uuid");
+exports.Info = zod_1.default
+    .object({
+    sessionId: zod_1.default.string().describe('Session ID'),
+    messageId: zod_1.default.string().describe('Message ID'),
+    callId: zod_1.default.string().describe('Tool Call ID')
+})
+    .meta({ ref: 'ToolInfo' });
+function createRequestId(requestId) {
+    return (0, uuid_1.v5)(`${requestId}-${Date.now()}`, uuid_1.v5.DNS);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baitong-dev/mcp-helpers",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "main": "./dist/index.js",
   "files": [
     "dist",
@@ -12,7 +12,8 @@
   ],
   "description": "mcp-helpers",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1"
+    "@modelcontextprotocol/sdk": "^1.25.1",
+    "uuid": "^11.0.5"
   },
   "devDependencies": {
     "typescript": "^5.9.2"