@catchmexz/fedin-vibe-mcp-server 0.1.1 → 0.1.3

package/dist/common/miniprogram-utils.js

@@ -0,0 +1,57 @@
+/**
+ * 小程序相关的请求工具函数
+ */
+const MINIPROGRAM_API_BASE_URL = "https://backend.api.fedin.cn/api";
+// API端点配置
+export const MINIPROGRAM_ENDPOINTS = {
+    getPreAuthKey: '/wechatcomponent/get_pre_auth_key',
+    queryAuthStatus: '/wechatcomponent/auth/status',
+    queryAuthInfo: '/wechatcomponent/auth/info',
+    submitCode: '/wechatcomponent/submit/code',
+    auditStatus: '/wechatcomponent/audit/status'
+};
+/**
+ * 小程序API请求函数
+ * @param endpoint API端点
+ * @param options 请求选项
+ * @returns 响应数据
+ */
+export async function miniprogramRequest(endpoint, options = {}) {
+    const url = `${MINIPROGRAM_API_BASE_URL}${endpoint}`;
+    const requestHeaders = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        ...options.headers,
+    };
+    // console.info(`[MINIPROGRAM] Request: ${options.method || 'GET'} ${url}`);
+    const response = await fetch(url, {
+        method: options.method || "GET",
+        headers: requestHeaders,
+        body: options.body ? JSON.stringify(options.body) : undefined,
+    });
+    const responseBody = await response.json();
+    // console.info(`[MINIPROGRAM] Response status: ${response.status}, code: ${responseBody.code}`);
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${responseBody.message || 'Request failed'}`);
+    }
+    // 检查业务状态码
+    if (responseBody.code !== 200) {
+        throw new Error(`API Error ${responseBody.code}: ${responseBody.message || 'Unknown error'}`);
+    }
+    return responseBody.data;
+}
+/**
+ * 构建带查询参数的端点路径
+ * @param endpoint 端点
+ * @param params 查询参数
+ * @returns 带查询参数的端点路径
+ */
+export function buildMiniprogramUrl(endpoint, params) {
+    const url = new URL(`http://dummy.com${endpoint}`); // 使用dummy域名只是为了构建查询参数
+    Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, value.toString());
+        }
+    });
+    return url.pathname + url.search; // 只返回路径和查询参数，不包含域名
+}

package/dist/common/supabase-utils.js

@@ -0,0 +1,59 @@
+/**
+ * Supabase 相关的工具函数
+ */
+/**
+ * 根据 PAT 从 Supabase 获取项目信息
+ * @param pat Personal Access Token
+ * @returns 项目信息
+ */
+export async function getProjectInfoWithPat(pat) {
+    const query = `
+    SELECT
+        ch.id as project_id,
+        ch.mini_app_id
+    FROM
+        schema_dev.chat_history AS ch
+    WHERE
+        ch.pat = '${pat}'
+  `;
+    try {
+        const response = await fetch('https://dev.fedin.cn/api/supabase/query', {
+            method: "post",
+            body: JSON.stringify({
+                query
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        const data = await response.json();
+        if (data.length > 0) {
+            return {
+                projectId: data[0].project_id,
+                miniappId: data[0].mini_app_id
+            };
+        }
+        else {
+            throw new Error("PAT密钥无效：未找到对应的项目信息");
+        }
+    }
+    catch (error) {
+        throw new Error("获取项目信息失败：" + (error instanceof Error ? error.message : String(error)));
+    }
+}
+/**
+ * 从命令行参数中获取 PAT
+ * @returns PAT 字符串
+ */
+export function getPATFromArgs() {
+    let pat = "";
+    process.argv.forEach(arg => {
+        if (arg.includes("--project-pat")) {
+            pat = arg.split("=")?.[1];
+        }
+    });
+    if (!pat) {
+        throw new Error("缺少项目访问令牌 project-pat");
+    }
+    return pat;
+}

package/dist/common/types.js

@@ -14,29 +14,5 @@ GetCompareSchema,
 GetChangeRequestSchema, ListChangeRequestsSchema, CreateChangeRequestSchema, ListChangeRequestPatchSetsSchema, 
 // Change request comment schemas
 CreateChangeRequestCommentSchema, ListChangeRequestCommentsSchema } from "../operations/codeup/types.js";
-// Projex types
-export { 
-// Project schemas
-GetProjectSchema, SearchProjectsSchema, 
-// Sprint schemas
-GetSprintSchema, ListSprintsSchema, CreateSprintSchema, UpdateSprintSchema, 
-// Work item schemas
-GetWorkItemSchema, CreateWorkItemSchema, SearchWorkitemsSchema, UpdateWorkItemSchema, 
-// Work item type schemas
-ListAllWorkItemTypesSchema, ListWorkItemTypesSchema, GetWorkItemTypeSchema, ListWorkItemRelationWorkItemTypesSchema, GetWorkItemTypeFieldConfigSchema, GetWorkItemWorkflowSchema, 
-// Work item comment schemas
-ListWorkItemCommentsSchema, CreateWorkItemCommentSchema } from "../operations/projex/types.js";
-// Flow types
-export { 
-// Pipeline schemas
-GetPipelineSchema, ListPipelinesSchema, CreatePipelineFromDescriptionSchema, CreatePipelineRunSchema, GetLatestPipelineRunSchema, GetPipelineRunSchema, ListPipelineRunsSchema, UpdatePipelineSchema, 
-// Pipeline job schemas
-ListPipelineJobsByCategorySchema, ListPipelineJobHistorysSchema, ExecutePipelineJobRunSchema, GetPipelineJobRunLogSchema, 
-// Service connection schemas
-ListServiceConnectionsSchema } from "../operations/flow/types.js";
-// Packages types
-export { 
-// Package repository schemas
-ListPackageRepositoriesSchema, 
-// Artifact schemas
-ListArtifactsSchema, GetArtifactSchema } from "../operations/packages/types.js";
+// Miniprogram types
+export { GetMiniprogramBindingInfoSchema, GetMiniprogramAuthUrlSchema, SubmitMiniprogramDeploymentSchema, GetMiniprogramAuditStatusSchema, MiniprogramBindingInfoSchema, MiniprogramAuthUrlSchema, MiniprogramDeploymentResponseSchema, MiniprogramAuditStatusSchema } from "../operations/miniprogram/types.js";

package/dist/index.js

@@ -68,7 +68,9 @@ async function getRepositoryIdWithPat(pat) {
     const query = `
     SELECT
         c.*,
-        ch.pat
+        ch.pat,
+        ch.id as project_id,
+        ch.mini_app_id
     FROM
         schema_dev.codeup AS c
     INNER JOIN
@@ -90,7 +92,11 @@ async function getRepositoryIdWithPat(pat) {
         });
         const data = await response.json();
         if (data.length > 0) {
-            return data[0].repositoryId;
+            return {
+                repositoryId: data[0].repositoryId,
+                projectId: data[0].project_id,
+                miniappId: data[0].mini_app_id
+            };
         }
         else {
             throw new Error("pat密钥无效:未找到对应的repositoryId");
@@ -119,11 +125,16 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         if (!pat) {
             throw new Error("缺少项目访问令牌project-pat");
         }
-        const repositoryId = await getRepositoryIdWithPat(pat);
+        const { repositoryId, projectId, miniappId } = await getRepositoryIdWithPat(pat);
         if (!repositoryId) {
             throw new Error("获取repositoryId失败");
         }
         request.params.arguments.repositoryId = repositoryId;
+        request.params.arguments.projectId = projectId;
+        // 只有当 miniappId 不为 null 时才注入，避免 Zod 验证错误
+        if (miniappId) {
+            request.params.arguments.miniappId = miniappId;
+        }
         // Delegate to our modular tool handler
         return await handleToolRequest(request);
     }

package/dist/operations/codeup/files.js

@@ -248,7 +248,7 @@ export async function createFileFunc(organizationId, repositoryId, filePath, con
     });
     return CreateFileResponseSchema.parse(response);
 }
-export async function pushFilesFunc(organizationId, repositoryId, commitMessage, projectPath) {
+export async function pushFilesFunc(organizationId, repositoryId, commitMessage, projectPath, projectId) {
     // 读取 .gitignore 模式
     // const ignorePatterns = readGitignore(projectPath);
     const ignorePatterns = [
@@ -267,6 +267,21 @@ export async function pushFilesFunc(organizationId, repositoryId, commitMessage,
     ];
     // 获取所有文件
     const files = getAllFiles(projectPath, ignorePatterns);
+    // 检测项目类型
+    let projectType = "default"; // 默认值
+    // 检查是否存在 Next.js 配置文件
+    const hasNextConfig = files.some(file => file.path === 'next.config.js' ||
+        file.path === 'next.config.ts');
+    // 检查是否存在 Vite 配置文件
+    const hasViteConfig = files.some(file => file.path === 'vite.config.js' ||
+        file.path === 'vite.config.ts');
+    // 根据配置文件设置项目类型
+    if (hasNextConfig) {
+        projectType = "fc";
+    }
+    else if (hasViteConfig) {
+        projectType = "oss";
+    }
     const remoteFileList = await listFilesFunc(organizationId, repositoryId, undefined, "master", "RECURSIVE");
     const remoteFilePathArr = remoteFileList.map((i) => i.path);
     const shouldCreateFiles = files.filter((file) => !remoteFilePathArr.includes(file.path));
@@ -308,13 +323,36 @@ export async function pushFilesFunc(organizationId, repositoryId, commitMessage,
             deleteFileErrors.push(error.message);
         }
     }
+    const pipelineResponse = await fetch('https://ai.fedin.cn/api/alicloud/create-pipeline-run', {
+        method: "POST",
+        body: JSON.stringify({
+            name: projectId,
+            projectId: projectId,
+            repoUrl: `https://codeup.aliyun.com/ctrod/fedin-ai-project/${projectId}.git`,
+            projectType,
+            organizationId: organizationId,
+            token: process.env.YUNXIAO_ACCESS_TOKEN
+        }),
+        headers: {
+            "Content-Type": "application/json",
+            token: "fedin_ac_9x7k2m8p4w6q1z5n3v7b9c2e8r4t6"
+        }
+    });
+    const pipelineResult = await pipelineResponse.json();
+    let onlineUrl;
+    if (pipelineResult.success && pipelineResult.data?.onlineUrl) {
+        onlineUrl = pipelineResult.data.onlineUrl;
+    }
     return {
-        createFilesSuccess,
-        createFileErrors,
-        updateFilesSuccess,
-        updateFileErrors,
-        deleteFilesSuccess,
-        deleteFileErrors
+        pushResult: {
+            createFilesSuccess,
+            createFileErrors,
+            updateFilesSuccess,
+            updateFileErrors,
+            deleteFilesSuccess,
+            deleteFileErrors,
+        },
+        onlineUrl: onlineUrl || ''
     };
 }
 /**

package/dist/operations/codeup/repositories.js

@@ -1,12 +1,3 @@
-/**
- * 代码库（Repository）相关操作
- *
- * 概念说明：
- * - 代码库（Repository）是云效平台中的代码管理单元，属于CodeUp产品
- * - 代码库与项目（Project）是不同的概念，项目属于项目管理领域
- * - 代码库用于存储和管理源代码，而项目用于管理工作项、迭代等
- * - 请勿混淆这两个概念，它们是不同的资源类型
- */
 import { yunxiaoRequest, buildUrl, handleRepositoryIdEncoding } from "../../common/utils.js";
 import { RepositorySchema } from "./types.js";
 /**

package/dist/operations/miniprogram/miniprogram.js

@@ -0,0 +1,156 @@
+import { miniprogramRequest, buildMiniprogramUrl, MINIPROGRAM_ENDPOINTS } from "../../common/miniprogram-utils.js";
+import { MiniprogramBindingInfoSchema, MiniprogramAuthUrlSchema, MiniprogramDeploymentResponseSchema, MiniprogramAuditStatusSchema } from "./types.js";
+/**
+ * 查询小程序绑定信息（简化版：直接使用注入的项目信息）
+ * @param projectId 项目ID（由系统自动注入）
+ * @param miniappId 小程序ID（由系统自动注入，可选）
+ */
+export async function getMiniprogramBindingInfoFunc(projectId, miniappId) {
+    try {
+        console.error(`[MINIPROGRAM] 查询项目 ${projectId} 的小程序绑定信息`);
+        // 直接尝试查询授权信息
+        try {
+            const url = buildMiniprogramUrl(MINIPROGRAM_ENDPOINTS.queryAuthInfo, { projectId });
+            const authInfo = await miniprogramRequest(url, {
+                method: "GET"
+            });
+            // 如果有返回数据，说明授权成功
+            console.error(`[MINIPROGRAM] 授权信息查询成功，小程序已绑定`);
+            // 解析授权方信息
+            let authorizerInfo = null;
+            try {
+                if (authInfo.authorizerInfo) {
+                    authorizerInfo = JSON.parse(authInfo.authorizerInfo);
+                }
+            }
+            catch (error) {
+                console.error('解析授权方信息失败');
+            }
+            const bindingInfo = {
+                projectId: projectId,
+                appId: authInfo.authorizerAppid,
+                bindingStatus: "bound",
+                bindingTime: authInfo.authFinishTime || undefined,
+                lastUpdateTime: authInfo.dateCreated,
+                principalName: authInfo.principalName, // 添加主体名称
+                authorizerInfo: authorizerInfo ? {
+                    nickName: authorizerInfo.nickName,
+                    headImg: authorizerInfo.headImg,
+                    verifyStatus: authorizerInfo.verifyTypeInfo === 0 ? '已认证' : '未认证！', // 添加认证状态
+                    serviceTypeInfo: authorizerInfo.serviceTypeInfo ? {
+                        id: authorizerInfo.serviceTypeInfo.id
+                    } : undefined,
+                    verifyTypeInfo: authorizerInfo.verifyTypeInfo !== undefined ? {
+                        id: authorizerInfo.verifyTypeInfo
+                    } : undefined
+                } : undefined
+            };
+            return MiniprogramBindingInfoSchema.parse(bindingInfo);
+        }
+        catch (error) {
+            // 如果查询授权信息失败，说明需要授权，生成授权链接
+            console.error(`[MINIPROGRAM] 授权信息查询失败，需要获取授权链接`);
+            try {
+                const authUrl = await miniprogramRequest(MINIPROGRAM_ENDPOINTS.getPreAuthKey, {
+                    method: "POST",
+                    body: {
+                        projectId: projectId
+                    }
+                });
+                const unboundInfo = {
+                    projectId: projectId,
+                    bindingStatus: "unbound",
+                    authUrl: authUrl
+                };
+                return MiniprogramBindingInfoSchema.parse(unboundInfo);
+            }
+            catch (authError) {
+                console.error(`[MINIPROGRAM] 生成授权链接失败`);
+                const unboundInfo = {
+                    projectId: projectId,
+                    bindingStatus: "unbound"
+                };
+                return MiniprogramBindingInfoSchema.parse(unboundInfo);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`[MINIPROGRAM] 查询绑定信息失败`);
+        throw new Error(`查询小程序绑定信息失败: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * 获取小程序授权地址
+ * @param projectId 项目ID
+ */
+export async function getMiniprogramAuthUrlFunc(projectId) {
+    const authUrl = await miniprogramRequest(MINIPROGRAM_ENDPOINTS.getPreAuthKey, {
+        method: "POST",
+        body: {
+            projectId: projectId
+        }
+    });
+    // 构造返回数据（基于前端逻辑推断）
+    const result = {
+        authUrl: authUrl,
+        preAuthCode: "generated_pre_auth_code", // 实际应该从响应中获取
+        expiresIn: 600, // 10分钟过期
+    };
+    return MiniprogramAuthUrlSchema.parse(result);
+}
+/**
+ * 提交小程序代码部署
+ * @param projectId 项目ID
+ * @param appId 小程序AppID（由系统注入）
+ * @param version 版本号
+ * @param description 版本描述
+ * @param templateId 模板ID
+ * @param extJson 第三方平台自定义数据
+ * @param userVersion 代码版本号
+ * @param userDesc 代码描述
+ * @param autoSubmitAudit 是否自动提交审核
+ */
+export async function submitMiniprogramDeploymentFunc(appId, version) {
+    if (!appId) {
+        throw new Error("小程序AppID不存在，无法部署");
+    }
+    const deployResult = await miniprogramRequest(MINIPROGRAM_ENDPOINTS.submitCode, {
+        method: "POST",
+        body: {
+            appId: appId,
+            version: version
+        }
+    });
+    const result = {
+        success: true,
+        message: `部署提交成功，状态：${deployResult.status}`,
+        version: version
+    };
+    return MiniprogramDeploymentResponseSchema.parse(result);
+}
+/**
+ * 获取小程序代码审核状态
+ * @param projectId 项目ID
+ * @param appId 小程序AppID（由系统注入）
+ * @param auditId 审核ID（可选）
+ */
+export async function getMiniprogramAuditStatusFunc(appId) {
+    if (!appId) {
+        throw new Error("小程序AppID不存在，无法查询审核状态");
+    }
+    const auditResult = await miniprogramRequest(MINIPROGRAM_ENDPOINTS.auditStatus, {
+        method: "POST",
+        body: {
+            appId: appId
+        }
+    });
+    // 直接使用API返回的状态值，不进行映射
+    const validStatuses = ["RELEASED", "CHECK_FAILED", "CHECKING", "CANCEL"];
+    const status = validStatuses.includes(auditResult.status) ? auditResult.status : "CHECKING";
+    const result = {
+        status: status,
+        reason: auditResult.reason || undefined,
+        testQrCode: auditResult.testQrCode || undefined
+    };
+    return MiniprogramAuditStatusSchema.parse(result);
+}

package/dist/operations/miniprogram/types.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+// 小程序绑定信息相关Schema
+export const MiniprogramBindingInfoSchema = z.object({
+    projectId: z.string().describe("项目ID"),
+    appId: z.string().optional().describe("小程序AppID"),
+    appSecret: z.string().optional().describe("小程序AppSecret"),
+    bindingStatus: z.enum(["unbound", "bound"]).describe("绑定状态：unbound-未绑定，bound-已绑定"),
+    bindingTime: z.string().optional().describe("绑定时间"),
+    lastUpdateTime: z.string().optional().describe("最后更新时间"),
+    principalName: z.string().optional().describe("主体名称"),
+    authUrl: z.string().optional().describe("授权链接（当状态为unbound时提供）"),
+    authorizerInfo: z.object({
+        nickName: z.string().optional().describe("小程序昵称"),
+        headImg: z.string().optional().describe("小程序头像"),
+        verifyStatus: z.string().optional().describe("微信认证状态：已认证/未认证！"),
+        serviceTypeInfo: z.object({
+            id: z.number().optional().describe("服务类型ID")
+        }).optional().describe("服务类型信息"),
+        verifyTypeInfo: z.object({
+            id: z.number().optional().describe("认证类型ID")
+        }).optional().describe("认证类型信息")
+    }).optional().describe("授权方信息")
+});
+// 小程序授权地址相关Schema
+export const MiniprogramAuthUrlSchema = z.object({
+    authUrl: z.string().url().describe("授权地址"),
+    preAuthCode: z.string().describe("预授权码"),
+    expiresIn: z.number().describe("过期时间（秒）"),
+});
+export const MiniprogramDeploymentResponseSchema = z.object({
+    success: z.boolean().describe("提交是否成功"),
+    message: z.string().describe("返回消息"),
+    taskId: z.string().optional().describe("任务ID"),
+    version: z.string().optional().describe("版本号")
+});
+// 小程序审核状态相关Schema
+export const MiniprogramAuditStatusSchema = z.object({
+    status: z.enum(["RELEASED", "CHECK_FAILED", "CHECKING", "CANCEL"]).describe("审核状态：RELEASED-已发布，CHECK_FAILED-审核失败，CHECKING-审核中，CANCEL-已取消"),
+    reason: z.string().nullable().optional().describe("审核结果说明"),
+    testQrCode: z.string().nullable().optional().describe("体验版二维码URL链接，可复制到浏览器查看或在微信中扫描")
+});
+// 请求参数Schema定义
+export const GetMiniprogramBindingInfoSchema = z.object({
+// 无需任何参数，直接从PAT获取项目信息
+});
+export const GetMiniprogramAuthUrlSchema = z.object({
+// 无需任何参数，直接从PAT获取项目信息
+});
+// 小程序部署提交相关Schema
+export const SubmitMiniprogramDeploymentSchema = z.object({
+    version: z.string().describe("版本号，格式如：1.0.0（必填，用户必须指定）"),
+});
+export const GetMiniprogramAuditStatusSchema = z.object({
+    auditId: z.string().optional().describe("审核ID，如不提供则查询最新的审核状态")
+});

package/dist/tool-handlers/code-management.js

@@ -53,9 +53,11 @@ export const handleCodeManagementTools = async (request) => {
         }
         case "push_files": {
             const args = request.params.arguments;
-            const result = await files.pushFilesFunc(args.organizationId, args.repositoryId, args.commitMessage, args.projectPath);
+            const result = await files.pushFilesFunc(args.organizationId, args.repositoryId, args.commitMessage, args.projectPath, args.projectId);
+            const returnText = `项目部署地址:${result.onlineUrl}\n文件推送结果:${JSON.stringify(result.pushResult)}
+      `;
             return {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+                content: [{ type: "text", text: returnText }]
             };
         }
         case "pull_files": {

package/dist/tool-handlers/index.js

@@ -1,36 +1,12 @@
 import { handleCodeManagementTools } from './code-management.js';
 import { handleOrganizationTools } from './organization.js';
-import { handleProjectManagementTools } from './project-management.js';
-import { handlePipelineTools } from './pipeline.js';
-import { handlePackageManagementTools } from './packages.js';
-import { handleServiceConnectionTools } from './service-connections.js';
-import { handleAppStackTools } from './appstack.js';
-import { handleAppStackTagTools } from './appstack-tags.js';
-import { handleAppStackTemplateTools } from './appstack-templates.js';
-import { handleAppStackGlobalVarTools } from './appstack-global-vars.js';
-import { handleAppStackVariableGroupTools } from './appstack-variable-groups.js';
-import { handleAppStackOrchestrationTools } from './appstack-orchestrations.js';
-import { handleAppStackChangeRequestTools } from './appstack-change-requests.js';
-import { handleAppStackDeploymentResourceTools } from './appstack-deployment-resources.js';
-import { handleAppStackChangeOrderTools } from './appstack-change-orders.js';
+import { handleMiniprogramTools } from './miniprogram.js';
 export const handleToolRequest = async (request) => {
     // Try each handler in sequence until one returns a result
     const handlers = [
         handleCodeManagementTools,
         handleOrganizationTools,
-        handleProjectManagementTools,
-        handlePipelineTools,
-        handlePackageManagementTools,
-        handleServiceConnectionTools,
-        handleAppStackTools,
-        handleAppStackTagTools,
-        handleAppStackTemplateTools,
-        handleAppStackGlobalVarTools,
-        handleAppStackVariableGroupTools,
-        handleAppStackOrchestrationTools,
-        handleAppStackChangeRequestTools,
-        handleAppStackDeploymentResourceTools,
-        handleAppStackChangeOrderTools
+        handleMiniprogramTools
     ];
     for (const handler of handlers) {
         const result = await handler(request);

package/dist/tool-handlers/miniprogram.js

@@ -0,0 +1,109 @@
+import * as miniprogram from '../operations/miniprogram/miniprogram.js';
+import * as types from '../common/types.js';
+import { getProjectInfoWithPat, getPATFromArgs } from '../common/supabase-utils.js';
+export const handleMiniprogramTools = async (request) => {
+    // 从命令行参数获取PAT，然后查询项目信息
+    const pat = getPATFromArgs();
+    const { projectId, miniappId } = await getProjectInfoWithPat(pat);
+    if (!projectId) {
+        throw new Error("MCP异常，无法获取到当前的项目ID。");
+    }
+    switch (request.params.name) {
+        case "get_miniprogram_binding_info": {
+            // 如果没有 miniappId，说明还未绑定，自动获取授权URL
+            if (!miniappId) {
+                const authUrl = await miniprogram.getMiniprogramAuthUrlFunc(projectId);
+                const resultText = `小程序未绑定，请使用以下授权链接完成绑定：
+
+🔗 授权链接: ${authUrl.authUrl}
+⏰ 有效期: ${authUrl.expiresIn} 秒
+
+请复制链接到浏览器中打开，完成小程序授权绑定。`;
+                return {
+                    content: [{ type: "text", text: resultText }]
+                };
+            }
+            // 有 miniappId 时查询绑定信息
+            const bindingInfo = await miniprogram.getMiniprogramBindingInfoFunc(projectId, miniappId);
+            // 根据绑定状态提供不同的提示信息
+            let resultText = `小程序绑定信息:
+${JSON.stringify(bindingInfo, null, 2)}`;
+            if (bindingInfo.bindingStatus === "unbound") {
+                if (bindingInfo.authUrl) {
+                    resultText += `
+
+🔗 小程序未绑定，请复制以下授权链接到浏览器中打开完成授权：
+${bindingInfo.authUrl}`;
+                }
+                else {
+                    resultText += `
+
+❌ 小程序未绑定，且无法生成授权链接，请检查网络连接或稍后重试。`;
+                }
+            }
+            else if (bindingInfo.bindingStatus === "bound") {
+                resultText += `
+
+✅ 小程序已成功绑定，可以进行部署操作。`;
+            }
+            return {
+                content: [{ type: "text", text: resultText }]
+            };
+        }
+        case "get_miniprogram_auth_url": {
+            const authUrl = await miniprogram.getMiniprogramAuthUrlFunc(projectId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(authUrl, null, 2) }]
+            };
+        }
+        case "submit_miniprogram_deployment": {
+            const args = types.SubmitMiniprogramDeploymentSchema.parse(request.params.arguments);
+            // 确保有AppID才能部署
+            if (!miniappId) {
+                throw new Error("小程序未绑定，无法部署。请先使用 get_miniprogram_binding_info 工具完成绑定。");
+            }
+            // 先返回开始提示
+            console.log(`🚀 开始提交小程序代码部署...
+版本号: ${args.version}
+预计耗时: 约40秒
+请稍候，正在处理中...`);
+            const deploymentResult = await miniprogram.submitMiniprogramDeploymentFunc(miniappId, args.version);
+            let resultText = `小程序部署提交结果:\n${JSON.stringify(deploymentResult, null, 2)}`;
+            if (deploymentResult.success) {
+                resultText += `\n\n已自动提交审核，请使用 get_miniprogram_audit_status 工具查看审核状态。`;
+            }
+            return {
+                content: [{ type: "text", text: resultText }]
+            };
+        }
+        case "get_miniprogram_audit_status": {
+            const args = types.GetMiniprogramAuditStatusSchema.parse(request.params.arguments);
+            // 确保有AppID才能查询审核状态
+            if (!miniappId) {
+                throw new Error("小程序未绑定，无法查询审核状态。请先使用 get_miniprogram_binding_info 工具完成绑定。");
+            }
+            const auditStatus = await miniprogram.getMiniprogramAuditStatusFunc(miniappId);
+            // 格式化审核状态显示
+            let resultText = `📊 小程序审核状态查询结果:
+
+🔍 审核状态: ${auditStatus.status}`;
+            if (auditStatus.reason) {
+                resultText += `
+💬 审核说明: ${auditStatus.reason}`;
+            }
+            if (auditStatus.testQrCode) {
+                resultText += `
+
+📱 体验版二维码:
+${auditStatus.testQrCode}
+
+请复制上述链接到浏览器中查看体验版二维码，或直接在微信中扫描使用。`;
+            }
+            return {
+                content: [{ type: "text", text: resultText }]
+            };
+        }
+        default:
+            return null;
+    }
+};