zero-workspace 0.0.2

package/dist/index.js

@@ -0,0 +1,1073 @@
+#!/usr/bin/env node
+// src/index.ts
+// 统一入口：MCP Server + HTTP Server
+// 注意：生产环境应通过 check-node-version.js 启动，以确保版本检查在模块加载前执行
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { createServices } from "./http/services.js";
+import { createServer } from "./http/server.js";
+import { isPortInUse } from "./utils/port.js";
+import { handleOldProcess, writePidInfo, removePidFile, readPidInfo, isProcessRunning } from "./utils/processManager.js";
+import { eventService } from "./services/EventService.js";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+import { workspaceTools } from "./tools/workspace.js";
+import { nodeTools } from "./tools/node.js";
+import { stateTools } from "./tools/state.js";
+import { contextTools } from "./tools/context.js";
+import { logTools } from "./tools/log.js";
+import { sessionTools } from "./tools/session.js";
+import { helpTools } from "./tools/help.js";
+import { importTools } from "./tools/import.js";
+import { dispatchTools } from "./tools/dispatch.js";
+import { configTools } from "./tools/config.js";
+import { memoTools } from "./tools/memo.js";
+import { capabilityTools } from "./tools/capability.js";
+import { searchTools } from "./tools/search.js";
+import { generateImportGuide, listChanges } from "./services/OpenSpecParser.js";
+import { getFullInstructions } from "./prompts/instructions.js";
+import { ZeroError } from "./types/errors.js";
+import { validateAndCorrectParams } from "./utils/paramValidator.js";
+import { logMcpStart, logMcpEnd, logMcpError } from "./utils/sessionLogger.js";
+import { formatManualChangeReminder } from "./utils/manualChangeFormatter.js";
+import { devLog } from "./utils/devLog.js";
+import { INTERNAL_RULES_HASH } from "./services/NodeService.js";
+import { aiAdapter } from "./adapters/OutputAdapter.js";
+// ============================================================================
+// 配置
+// ============================================================================
+const IS_DEV = process.env.NODE_ENV === "development" || process.env.ZERO_DEV === "true";
+// 开发模式默认端口 19541，正式模式默认端口 19540
+const DEFAULT_PORT = IS_DEV ? "19541" : "19540";
+const HTTP_PORT = parseInt(process.env.HTTP_PORT ?? process.env.PORT ?? DEFAULT_PORT, 10);
+const DISABLE_HTTP = process.env.DISABLE_HTTP === "true";
+// ============================================================================
+// 日志工具
+// ============================================================================
+const MODE_LABEL = IS_DEV ? "[DEV]" : "[PROD]";
+function logMcp(message) {
+    console.error(`[mcp]${MODE_LABEL} ${message}`);
+}
+function logHttp(message) {
+    console.error(`[http]${MODE_LABEL} ${message}`);
+}
+// ============================================================================
+// 获取当前版本
+// ============================================================================
+function getCurrentVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        const require = createRequire(import.meta.url);
+        const pkg = require(join(__dirname, "..", "package.json"));
+        return pkg.version;
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+const CURRENT_VERSION = getCurrentVersion();
+// ============================================================================
+// HTTP Server 后台启动
+// ============================================================================
+async function startHttpServerInBackground(port) {
+    // 检查是否禁用 HTTP
+    if (DISABLE_HTTP) {
+        logHttp("HTTP server 已禁用 (DISABLE_HTTP=true)");
+        return null;
+    }
+    // 使用与 server.ts 一致的 host 设置（默认 127.0.0.1，可通过环境变量覆盖）
+    const host = process.env.ZERO_HOST || "127.0.0.1";
+    // 处理旧版本进程
+    const canStart = handleOldProcess(port, CURRENT_VERSION, logHttp);
+    if (!canStart) {
+        // 检查是否是因为相同版本已在运行（不是真正的错误）
+        if (await isPortInUse(port, host)) {
+            logHttp(`相同版本已在运行，复用现有服务`);
+        }
+        return null;
+    }
+    // 再次检测端口占用（处理非 zero-workspace 进程占用的情况）
+    if (await isPortInUse(port, host)) {
+        logHttp(`端口 ${host}:${port} 被其他服务占用，跳过 HTTP 启动`);
+        return null;
+    }
+    try {
+        const server = await createServer();
+        await server.listen({ port, host });
+        logHttp(`Listening on http://${host}:${port} (v${CURRENT_VERSION})`);
+        // 写入 PID 信息
+        writePidInfo({
+            pid: process.pid,
+            port,
+            version: CURRENT_VERSION,
+            startedAt: new Date().toISOString(),
+        });
+        // 进程退出时清理
+        const cleanup = () => {
+            removePidFile();
+        };
+        process.on("exit", cleanup);
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        return server;
+    }
+    catch (err) {
+        logHttp(`启动失败: ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}
+// ============================================================================
+// MCP Server 创建
+// ============================================================================
+function createMcpServer(services) {
+    const server = new Server({
+        name: "zero-workspace",
+        version: "1.0.0",
+    }, {
+        capabilities: {
+            tools: {},
+            prompts: {},
+        },
+    });
+    // 所有工具列表
+    const allTools = [
+        ...workspaceTools,
+        ...nodeTools,
+        ...stateTools,
+        ...contextTools,
+        ...logTools,
+        ...sessionTools,
+        ...helpTools,
+        ...importTools,
+        ...dispatchTools,
+        ...configTools,
+    ];
+    // 汇总所有工具（用于列表和参数验证）
+    const allToolsWithExtras = [...allTools, ...memoTools, ...capabilityTools, ...searchTools];
+    // 创建工具名到 Tool 定义的映射（用于参数验证）
+    const toolMap = new Map(allToolsWithExtras.map(tool => [tool.name, tool]));
+    // 注册工具列表处理器
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: allToolsWithExtras,
+    }));
+    // 注册工具调用处理器
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: rawArgs } = request.params;
+        const startTime = Date.now();
+        // 记录 MCP 调用开始
+        logMcpStart(name, rawArgs || {});
+        try {
+            // 确保基础目录存在
+            await services.fs.ensureIndex();
+            // 参数验证与自动纠错
+            let args = rawArgs;
+            let paramWarnings = [];
+            const tool = toolMap.get(name);
+            if (tool) {
+                const validation = validateAndCorrectParams(name, rawArgs, tool);
+                // 如果有错误，抛出异常
+                if (validation.errors.length > 0) {
+                    throw new ZeroError("UNKNOWN_PARAMS", validation.errors.join("\n"));
+                }
+                // 使用纠正后的参数
+                args = validation.correctedArgs;
+                paramWarnings = validation.warnings;
+            }
+            let result;
+            switch (name) {
+                // Workspace 工具
+                case "workspace_init": {
+                    // 参数验证：检测常见的错误参数名
+                    const wrongParamMapping = {
+                        description: "goal",
+                        desc: "goal",
+                        objective: "goal",
+                        target: "goal",
+                        purpose: "goal",
+                    };
+                    const wrongParams = Object.keys(wrongParamMapping).filter(wrong => args?.[wrong] !== undefined);
+                    if (wrongParams.length > 0) {
+                        const corrections = wrongParams.map(wrong => `"${wrong}" → "${wrongParamMapping[wrong]}"`).join(", ");
+                        throw new ZeroError("INVALID_PARAMS", `参数名错误: ${corrections}。请使用正确的参数名重新调用。`);
+                    }
+                    // 验证必填参数
+                    if (!args?.name) {
+                        throw new ZeroError("INVALID_PARAMS", "缺少必填参数 'name'（工作区名称）");
+                    }
+                    if (!args?.goal) {
+                        throw new ZeroError("INVALID_PARAMS", "缺少必填参数 'goal'（工作区目标描述）");
+                    }
+                    // 验证 scenario 参数（必填）
+                    const validScenarios = ['feature', 'summary', 'optimize', 'debug', 'misc'];
+                    if (!args?.scenario) {
+                        throw new ZeroError("INVALID_PARAMS", `缺少必填参数 'scenario'（任务场景类型）。有效值为: ${validScenarios.join(', ')}`);
+                    }
+                    if (!validScenarios.includes(args.scenario)) {
+                        throw new ZeroError("INVALID_PARAMS", `无效的 scenario 参数: "${args.scenario}"。有效值为: ${validScenarios.join(', ')}`);
+                    }
+                    result = await services.workspace.init({
+                        name: args.name,
+                        goal: args.goal,
+                        rules: args?.rules,
+                        docs: args?.docs,
+                        scenario: args?.scenario,
+                    });
+                    break;
+                }
+                case "workspace_list": {
+                    const statusFilter = args?.status;
+                    const fullResult = await services.workspace.list({ status: statusFilter });
+                    // AI 适配器：简化输出
+                    // - active/archived: 顶层 filter 字段，各项不含 status
+                    // - all: 各项保留 status
+                    result = aiAdapter.transformWorkspaceList(fullResult, statusFilter);
+                    break;
+                }
+                case "workspace_get": {
+                    const fullResult = await services.workspace.get({
+                        workspaceId: args?.workspaceId,
+                    });
+                    // AI 适配器：压缩 logMd
+                    result = {
+                        ...fullResult,
+                        logMd: aiAdapter.transformWorkspaceGetLog(fullResult.logMd),
+                    };
+                    break;
+                }
+                case "workspace_delete":
+                    result = await services.workspace.delete({
+                        workspaceId: args?.workspaceId,
+                        force: args?.force,
+                    });
+                    break;
+                case "workspace_update_rules":
+                    result = await services.workspace.updateRules({
+                        workspaceId: args?.workspaceId,
+                        action: args?.action,
+                        rule: args?.rule,
+                        rules: args?.rules,
+                    });
+                    break;
+                case "workspace_archive":
+                    result = await services.workspace.archive({
+                        workspaceId: args?.workspaceId,
+                    });
+                    break;
+                case "workspace_restore":
+                    result = await services.workspace.restore({
+                        workspaceId: args?.workspaceId,
+                    });
+                    break;
+                case "workspace_health": {
+                    const diagnosticToken = args?.diagnosticToken;
+                    // 令牌校验
+                    if (!diagnosticToken || !services.health.validateToken(diagnosticToken)) {
+                        result = {
+                            actionRequired: {
+                                type: "read_diagnostic_guide",
+                                message: "健康检测需要先阅读诊断指南获取令牌。请阅读指南文件，从 frontmatter 中获取 diagnosticToken，然后携带 token 再次调用。",
+                                guidePath: services.health.getGuidePath(),
+                                hint: "诊断指南包含常见问题解决方案和修复建议",
+                            },
+                        };
+                    }
+                    else {
+                        result = await services.health.checkHealth(args?.workspaceId);
+                    }
+                    break;
+                }
+                // Node 工具
+                case "node_create": {
+                    const nodeRole = args?.role;
+                    const rulesHash = args?.rulesHash;
+                    // 检测 info 类节点：引导使用 starting-info-flow Skill
+                    // 仅对外部调用生效（rulesHash !== INTERNAL_RULES_HASH）
+                    if ((nodeRole === "info_collection" || nodeRole === "info_summary") && rulesHash !== INTERNAL_RULES_HASH) {
+                        const infoTypeName = nodeRole === "info_collection" ? "信息收集" : "信息总结";
+                        result = {
+                            actionRequired: {
+                                type: "invoke_skill",
+                                message: `⚠️ 创建${infoTypeName}节点需要通过能力包流程。
+
+**MUST 调用 Skill(starting-info-flow)** 完成信息流程启动。
+
+Skill 会引导你：
+1. capability_list() → 获取可用能力包
+2. 展示给用户并确认选择
+3. capability_select() → 创建节点并返回对应 Skill 引导
+
+**如果 Skill 不可用**，使用 plugin_path 获取路径后 Read：
+\`\`\`
+plugin_path() → 获取 skillsPath
+Read(file_path: <skillsPath>/starting-info-flow/SKILL.md)
+\`\`\``,
+                                data: {
+                                    skill: "starting-info-flow",
+                                    requestedRole: nodeRole,
+                                },
+                            },
+                        };
+                        break;
+                    }
+                    result = await services.node.create({
+                        workspaceId: args?.workspaceId,
+                        parentId: args?.parentId,
+                        type: args?.type,
+                        title: args?.title,
+                        requirement: args?.requirement,
+                        docs: args?.docs,
+                        rulesHash,
+                        role: nodeRole,
+                        acceptanceCriteria: args?.acceptanceCriteria,
+                        isNeedTest: args?.isNeedTest,
+                        testRequirement: args?.testRequirement,
+                    });
+                    break;
+                }
+                case "node_get":
+                    result = await services.node.get({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                    });
+                    break;
+                case "node_list": {
+                    const fullResult = await services.node.list({
+                        workspaceId: args?.workspaceId,
+                        rootId: args?.rootId,
+                        depth: args?.depth,
+                    });
+                    // AI 适配器：简化输出，只保留 id 和 title
+                    result = aiAdapter.transformNodeList(fullResult);
+                    break;
+                }
+                case "node_delete":
+                    result = await services.node.delete({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                    });
+                    break;
+                // Phase 3: 节点更新
+                case "node_update": {
+                    // MCP 调用必须提供 nodeHash
+                    const nodeHashParam = args?.nodeHash;
+                    if (!nodeHashParam) {
+                        throw new ZeroError("INVALID_PARAMS", "请先 node_get 获取 nodeHash");
+                    }
+                    result = await services.node.update({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        nodeHash: nodeHashParam,
+                        title: args?.title,
+                        requirement: args?.requirement,
+                        note: args?.note,
+                        conclusion: args?.conclusion,
+                        field: args?.field,
+                        old_str: args?.old_str,
+                        new_str: args?.new_str,
+                    });
+                    break;
+                }
+                case "node_move":
+                    result = await services.node.move({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        newParentId: args?.newParentId,
+                    });
+                    break;
+                case "node_reorder":
+                    await services.node.reorderChildren({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        orderedChildIds: args?.orderedChildIds,
+                    });
+                    result = { success: true };
+                    break;
+                // Phase 2: 状态转换工具
+                case "node_transition":
+                    result = await services.state.transition({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        action: args?.action,
+                        reason: args?.reason,
+                        conclusion: args?.conclusion,
+                        conclusionsHash: args?.conclusionsHash,
+                        confirmation: args?.confirmation,
+                    });
+                    break;
+                // Phase 2: 上下文工具
+                case "context_get":
+                    result = await services.context.get({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        includeLog: args?.includeLog,
+                        maxLogEntries: args?.maxLogEntries,
+                        reverseLog: args?.reverseLog,
+                        includeProblem: args?.includeProblem,
+                    });
+                    break;
+                case "context_focus":
+                    result = await services.context.focus({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                    });
+                    break;
+                case "node_isolate":
+                    result = await services.reference.isolate({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        isolate: args?.isolate,
+                    });
+                    break;
+                case "node_reference":
+                    result = await services.reference.reference({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        targetIdOrPath: args?.targetIdOrPath,
+                        action: args?.action,
+                        description: args?.description,
+                    });
+                    break;
+                // Phase 2: 日志工具
+                case "log_append":
+                    result = await services.log.append({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        operator: args?.operator,
+                        event: args?.event,
+                    });
+                    break;
+                case "problem_update":
+                    result = await services.log.updateProblem({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                        problem: args?.problem,
+                        nextStep: args?.nextStep,
+                    });
+                    break;
+                case "problem_clear":
+                    result = await services.log.clearProblem({
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                    });
+                    break;
+                // Session 工具
+                case "session_bind":
+                    result = await services.session.bind({
+                        sessionId: args?.sessionId,
+                        workspaceId: args?.workspaceId,
+                        nodeId: args?.nodeId,
+                    });
+                    break;
+                case "session_unbind":
+                    result = await services.session.unbind({
+                        sessionId: args?.sessionId,
+                    });
+                    break;
+                case "session_status":
+                    result = await services.session.status({
+                        sessionId: args?.sessionId,
+                    });
+                    break;
+                case "get_pending_changes":
+                    result = await services.session.getPendingChanges({
+                        sessionId: args?.sessionId,
+                        workspaceId: args?.workspaceId,
+                    });
+                    break;
+                // Help 工具
+                case "zero_help":
+                    result = await services.help.getHelp(args?.topic);
+                    break;
+                case "zero_prompt":
+                    result = services.help.getPrompt(args?.template, args?.params);
+                    break;
+                // Import 工具
+                case "workspace_import_guide": {
+                    const path = args?.path;
+                    const type = args?.type;
+                    const changeId = args?.changeId;
+                    const projectRoot = args?.projectRoot;
+                    if (type !== 'openspec') {
+                        throw new Error(`不支持的规范类型: ${type}`);
+                    }
+                    result = generateImportGuide(path, changeId, projectRoot);
+                    break;
+                }
+                case "workspace_import_list": {
+                    const path = args?.path;
+                    const type = args?.type;
+                    if (type !== 'openspec') {
+                        throw new Error(`不支持的规范类型: ${type}`);
+                    }
+                    const changes = listChanges(path);
+                    result = { type, changes };
+                    break;
+                }
+                // Dispatch 工具
+                case "dispatch_enable": {
+                    const workspaceId = args?.workspaceId;
+                    const useGit = args?.useGit;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.enableDispatch(workspaceId, projectRoot, { useGit });
+                    break;
+                }
+                case "dispatch_disable": {
+                    const workspaceId = args?.workspaceId;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.queryDisableDispatch(workspaceId, projectRoot);
+                    break;
+                }
+                case "dispatch_disable_execute": {
+                    const workspaceId = args?.workspaceId;
+                    const mergeStrategy = args?.mergeStrategy;
+                    const keepBackupBranch = args?.keepBackupBranch;
+                    const keepProcessBranch = args?.keepProcessBranch;
+                    const commitMessage = args?.commitMessage;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.executeDisableChoice(projectRoot, {
+                        workspaceId,
+                        mergeStrategy,
+                        keepBackupBranch: keepBackupBranch ?? false,
+                        keepProcessBranch: keepProcessBranch ?? false,
+                        commitMessage,
+                    });
+                    break;
+                }
+                case "dispatch_node": {
+                    const workspaceId = args?.workspaceId;
+                    const nodeId = args?.nodeId;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.upgradeToDispatchParent(workspaceId, projectRoot, nodeId);
+                    break;
+                }
+                case "dispatch_complete": {
+                    const workspaceId = args?.workspaceId;
+                    const nodeId = args?.nodeId;
+                    const success = args?.success;
+                    const conclusion = args?.conclusion;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.completeDispatch(workspaceId, projectRoot, nodeId, success, conclusion);
+                    break;
+                }
+                case "dispatch_cleanup": {
+                    const workspaceId = args?.workspaceId;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.cleanupBranches(workspaceId, projectRoot);
+                    break;
+                }
+                case "dispatch_create": {
+                    const workspaceId = args?.workspaceId;
+                    const parentId = args?.parentId;
+                    const exec = args?.exec;
+                    const includeQuality = args?.includeQuality;
+                    const projectRoot = await services.workspace.resolveProjectRoot(workspaceId);
+                    result = await services.dispatch.createDispatchChildren(workspaceId, projectRoot, parentId, exec, includeQuality ?? true);
+                    break;
+                }
+                // Config 工具
+                case "config_get": {
+                    result = await services.config.get();
+                    break;
+                }
+                case "config_set": {
+                    const defaultDispatchMode = args?.defaultDispatchMode;
+                    result = await services.config.set({ defaultDispatchMode });
+                    break;
+                }
+                // Memo 工具
+                case "memo_create": {
+                    result = await services.memo.create({
+                        workspaceId: args?.workspaceId,
+                        title: args?.title,
+                        summary: args?.summary,
+                        content: args?.content,
+                        tags: args?.tags,
+                    });
+                    break;
+                }
+                case "memo_list": {
+                    result = await services.memo.list({
+                        workspaceId: args?.workspaceId,
+                        tags: args?.tags,
+                    });
+                    break;
+                }
+                case "memo_get": {
+                    result = await services.memo.get({
+                        workspaceId: args?.workspaceId,
+                        memoId: args?.memoId,
+                        lineOffset: args?.lineOffset,
+                        lineLimit: args?.lineLimit,
+                    });
+                    break;
+                }
+                case "memo_update": {
+                    result = await services.memo.update({
+                        workspaceId: args?.workspaceId,
+                        memoId: args?.memoId,
+                        contentHash: args?.contentHash,
+                        title: args?.title,
+                        summary: args?.summary,
+                        content: args?.content,
+                        field: args?.field,
+                        old_str: args?.old_str,
+                        new_str: args?.new_str,
+                        tags: args?.tags,
+                    });
+                    break;
+                }
+                case "memo_delete": {
+                    result = await services.memo.delete({
+                        workspaceId: args?.workspaceId,
+                        memoId: args?.memoId,
+                    });
+                    break;
+                }
+                // Capability 工具
+                case "capability_list": {
+                    let scenario = args?.scenario;
+                    // 如果未传入 scenario，尝试从会话绑定的工作区获取
+                    if (!scenario) {
+                        const sessionId = args?.sessionId;
+                        if (sessionId) {
+                            const binding = await services.sessionStorage.getBinding(sessionId);
+                            if (binding) {
+                                const location = await services.json.getWorkspaceLocation(binding.workspaceId);
+                                if (location) {
+                                    const config = await services.json.readWorkspaceConfig(location.projectRoot, location.dirName);
+                                    scenario = config.scenario;
+                                }
+                            }
+                        }
+                    }
+                    if (!scenario) {
+                        throw new Error("scenario 参数必填。请传入 scenario 参数，或确保当前会话已绑定到包含 scenario 配置的工作区。");
+                    }
+                    const { capabilityService } = await import("./services/CapabilityService.js");
+                    const capabilities = capabilityService.getCapabilitiesForScenario(scenario);
+                    result = {
+                        scenario,
+                        basePack: capabilities.basePack,
+                        optionalPack: capabilities.optionalPack,
+                        hint: "使用 capability_select 确认选择的能力包",
+                    };
+                    break;
+                }
+                case "capability_select": {
+                    const workspaceId = args?.workspaceId;
+                    const infoType = args?.infoType;
+                    const nodeId = args?.nodeId;
+                    const selected = args?.selected;
+                    const { capabilityService } = await import("./services/CapabilityService.js");
+                    // 验证 selected 是否为有效的 CapabilityId
+                    const validCapabilities = selected.filter((id) => {
+                        try {
+                            capabilityService.getCapabilityInfo(id);
+                            return true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    });
+                    if (validCapabilities.length === 0) {
+                        throw new Error("未选择有效的能力包");
+                    }
+                    let infoNodeId;
+                    const createdNodes = [];
+                    // 首次调用：创建 info 节点
+                    if (!nodeId) {
+                        if (!infoType) {
+                            throw new Error("首次调用必须提供 infoType 参数");
+                        }
+                        // 创建 info 节点（使用 planning 类型，因为需要有能力子节点）
+                        const infoNodeTitle = infoType === "info_collection" ? "信息收集" : "信息总结";
+                        const infoNodeResult = await services.node.create({
+                            workspaceId,
+                            parentId: "root",
+                            type: "planning",
+                            title: infoNodeTitle,
+                            requirement: `${infoNodeTitle}节点，包含以下能力：${validCapabilities.map((id) => capabilityService.getCapabilityInfo(id).name).join("、")}`,
+                            role: infoType,
+                            rulesHash: INTERNAL_RULES_HASH,
+                        });
+                        infoNodeId = infoNodeResult.nodeId;
+                    }
+                    else {
+                        // 追加调用：使用现有 info 节点
+                        infoNodeId = nodeId;
+                    }
+                    // 为每个能力创建子节点
+                    for (const capabilityId of validCapabilities) {
+                        const capInfo = capabilityService.getCapabilityInfo(capabilityId);
+                        const acceptanceCriteria = capabilityService.getAcceptanceCriteria(capabilityId);
+                        const childNodeResult = await services.node.create({
+                            workspaceId,
+                            parentId: infoNodeId,
+                            type: "execution",
+                            title: capInfo.name,
+                            requirement: capInfo.description,
+                            acceptanceCriteria,
+                            rulesHash: INTERNAL_RULES_HASH,
+                        });
+                        createdNodes.push({
+                            nodeId: childNodeResult.nodeId,
+                            capabilityId,
+                            title: capInfo.name,
+                        });
+                    }
+                    // 构建 Skill 列表（返回 skill 目录名 + 节点映射）
+                    const skillsWithNodes = createdNodes.map((node) => ({
+                        skill: capabilityService.getSkillDirName(node.capabilityId),
+                        nodeId: node.nodeId,
+                        title: node.title,
+                    }));
+                    const skills = skillsWithNodes.map(s => s.skill);
+                    // 构建 Skill 调用引导
+                    const skillList = skillsWithNodes
+                        .map(s => `- Skill(${s.skill}) → 节点「${s.title}」(${s.nodeId})`)
+                        .join("\n");
+                    result = {
+                        infoNodeId,
+                        createdNodes,
+                        skills,
+                        actionRequired: {
+                            type: "invoke_skill",
+                            message: `⚠️ 已创建能力节点，MUST 按顺序调用对应 Skill 执行任务：
+
+${skillList}
+
+**执行流程**：
+1. 调用 Skill(${skills[0]}) 获取第一个任务的执行指导
+2. 按 Skill SOP 完成任务，记录结论到对应节点
+3. 依次执行后续 Skill
+
+**如果 Skill 不可用**，使用 plugin_path 获取路径后 Read：
+\`\`\`
+plugin_path() → 获取 skillsPath
+Read(file_path: <skillsPath>/<skill-name>/SKILL.md)
+\`\`\``,
+                            data: {
+                                skills: skillsWithNodes,
+                            },
+                        },
+                    };
+                    break;
+                }
+                case "plugin_path": {
+                    // 使用 import.meta.url 获取当前模块路径，推导出 plugin 目录
+                    const currentFileUrl = import.meta.url;
+                    const currentFilePath = new URL(currentFileUrl).pathname;
+                    // 从 dist/index.js 往上两级到包根目录，再进入 plugin
+                    const pluginPath = join(dirname(currentFilePath), "..", "plugin");
+                    result = {
+                        path: pluginPath,
+                        skillsPath: join(pluginPath, "skills"),
+                    };
+                    break;
+                }
+                // Search 工具
+                case "workspace_search": {
+                    result = await services.search.workspaceSearch({
+                        query: args?.query,
+                        limit: args?.limit,
+                    });
+                    break;
+                }
+                case "content_search": {
+                    result = await services.search.contentSearch({
+                        workspaceId: args?.workspaceId,
+                        query: args?.query,
+                        id: args?.id,
+                        target: args?.target,
+                        limit: args?.limit,
+                        context: args?.context,
+                    });
+                    break;
+                }
+                default:
+                    throw new Error(`未知工具: ${name}`);
+            }
+            // 记录 MCP 调用成功
+            const duration = Date.now() - startTime;
+            logMcpEnd(name, true, result, duration);
+            // 检查并附加手动变更提醒（针对工作区相关工具）
+            let responseText = JSON.stringify(result, null, 2);
+            // 附加参数纠正警告
+            if (paramWarnings.length > 0) {
+                responseText = responseText + "\n\n⚠️ " + paramWarnings.join("\n⚠️ ");
+            }
+            const workspaceId = args?.workspaceId;
+            // 排除 context_get 和 workspace_get（它们会清除变更，所以不需要提醒）
+            const shouldCheckManualChanges = workspaceId &&
+                name !== "context_get" &&
+                name !== "workspace_get";
+            if (shouldCheckManualChanges) {
+                try {
+                    const manualChanges = await services.workspace.getManualChanges(workspaceId);
+                    if (manualChanges.length > 0) {
+                        const reminder = formatManualChangeReminder(manualChanges);
+                        responseText = responseText + "\n\n" + reminder;
+                    }
+                }
+                catch (error) {
+                    // 静默失败：如果获取变更失败，不影响主响应
+                    devLog.warn("获取手动变更失败", { error });
+                }
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: responseText,
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // 记录 MCP 调用错误
+            const duration = Date.now() - startTime;
+            logMcpError(name, error instanceof Error ? error : String(error));
+            logMcpEnd(name, false, error instanceof Error ? error.message : String(error), duration);
+            if (error instanceof ZeroError) {
+                // 对于 WORKSPACE_NOT_FOUND 错误，附加活跃工作区列表以帮助恢复
+                let errorResponse = {
+                    error: {
+                        code: error.code,
+                        message: error.message,
+                    },
+                };
+                if (error.code === "WORKSPACE_NOT_FOUND") {
+                    try {
+                        const listResult = await services.workspace.list({ status: "active" });
+                        errorResponse.error.availableWorkspaces = listResult.workspaces;
+                    }
+                    catch {
+                        // 获取列表失败时忽略，不影响错误响应
+                    }
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(errorResponse, null, 2),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: {
+                                code: "INTERNAL_ERROR",
+                                message,
+                            },
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    // 注册 Prompts 列表处理器
+    server.setRequestHandler(ListPromptsRequestSchema, async () => ({
+        prompts: [
+            {
+                name: "zero-instructions",
+                description: "ZeroWorkspace 完整使用指南 - AI 首次使用时应获取此指南",
+            },
+            {
+                name: "zero-quick-start",
+                description: "快速开始指南 - 简要的工作流程说明",
+            },
+        ],
+    }));
+    // 注册 Prompt 获取处理器
+    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+        const { name } = request.params;
+        switch (name) {
+            case "zero-instructions":
+                return {
+                    description: "ZeroWorkspace 完整使用指南",
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: getFullInstructions(),
+                            },
+                        },
+                    ],
+                };
+            case "zero-quick-start":
+                return {
+                    description: "ZeroWorkspace 快速开始",
+                    messages: [
+                        {
+                            role: "user",
+                            content: {
+                                type: "text",
+                                text: `# ZeroWorkspace 快速开始
+
+## 基本流程
+1. workspace_init - 创建工作区
+2. node_create - 创建子任务
+3. node_transition(action="start") - 开始执行
+4. log_append - 记录过程
+5. node_transition(action="complete") - 完成任务
+
+## 常用工具
+- zero_help(topic="overview") - 获取系统概述
+- workspace_get - 获取工作区详情
+- context_get - 获取聚焦上下文
+
+详细信息请调用 zero_help(topic="all")`,
+                            },
+                        },
+                    ],
+                };
+            default:
+                throw new Error(`未知 Prompt: ${name}`);
+        }
+    });
+    return server;
+}
+// ============================================================================
+// 启动检测
+// ============================================================================
+async function runStartupDetection(services) {
+    try {
+        // 运行检测
+        const detectionResults = await services.detection.detectAll();
+        // 读取当前 meta
+        const meta = await services.installation.read();
+        const currentVersion = services.installation.getPackageVersion();
+        // 检查是否需要更新 meta（检测到的组件与 meta 记录不一致）
+        let needsUpdate = false;
+        for (const platform of ["claudeCode", "cursor", "codex"]) {
+            const detected = detectionResults[platform];
+            const recorded = meta.global.platforms[platform];
+            if (detected?.detected) {
+                // 构建组件状态（使用新的 ComponentInfo 结构）
+                const components = {
+                    hooks: {
+                        installed: detected.components.hooks.installed,
+                        // 如果检测到已安装但 meta 没有记录版本，说明是新检测到的，使用当前版本
+                        version: detected.components.hooks.installed
+                            ? (recorded?.components?.hooks?.version || currentVersion)
+                            : undefined,
+                    },
+                    mcp: {
+                        installed: detected.components.mcp.installed,
+                        version: detected.components.mcp.installed
+                            ? (recorded?.components?.mcp?.version || currentVersion)
+                            : undefined,
+                    },
+                };
+                // Claude Code 平台特有的 agents 和 skills 组件
+                if (platform === "claudeCode") {
+                    if (detected.components.agents) {
+                        components.agents = {
+                            installed: detected.components.agents.installed,
+                            version: detected.components.agents.installed
+                                ? (recorded?.components?.agents?.version || currentVersion)
+                                : undefined,
+                        };
+                    }
+                    if (detected.components.skills) {
+                        components.skills = {
+                            installed: detected.components.skills.installed,
+                            version: detected.components.skills.installed
+                                ? (recorded?.components?.skills?.version || currentVersion)
+                                : undefined,
+                        };
+                    }
+                }
+                // 检查是否有变更需要同步（比较 installed 状态）
+                const hooksChanged = components.hooks.installed !== recorded?.components?.hooks?.installed;
+                const mcpChanged = components.mcp.installed !== recorded?.components?.mcp?.installed;
+                const agentsChanged = platform === "claudeCode" &&
+                    components.agents?.installed !== recorded?.components?.agents?.installed;
+                const skillsChanged = platform === "claudeCode" &&
+                    components.skills?.installed !== recorded?.components?.skills?.installed;
+                if (!recorded?.enabled || hooksChanged || mcpChanged || agentsChanged || skillsChanged) {
+                    // 检测到组件状态变更，更新 meta
+                    await services.installation.updatePlatform(platform, {
+                        enabled: true,
+                        components,
+                    });
+                    needsUpdate = true;
+                    logMcp(`检测到 ${platform} 组件状态变更，已更新 meta`);
+                }
+            }
+        }
+        if (!needsUpdate) {
+            logMcp("启动检测完成，无需更新");
+        }
+    }
+    catch (err) {
+        // 检测失败不影响启动，只记录警告
+        logMcp(`启动检测失败: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+// ============================================================================
+// 主函数
+// ============================================================================
+async function main() {
+    // 1. 创建共享服务实例
+    const services = createServices();
+    // 1.1 后台运行启动检测（不阻塞启动）
+    runStartupDetection(services);
+    // 2. 尝试启动 HTTP server（后台）
+    const httpServer = await startHttpServerInBackground(HTTP_PORT);
+    // 2.1 如果没有启动本地 HTTP，检测并连接远程 HTTP（用于事件转发）
+    if (!httpServer) {
+        const pidInfo = readPidInfo();
+        if (pidInfo && isProcessRunning(pidInfo.pid) && pidInfo.pid !== process.pid) {
+            // 存在远程 HTTP 服务，配置事件转发
+            eventService.setRemoteHttp(pidInfo.port);
+            logMcp(`已配置事件转发到远程 HTTP (port: ${pidInfo.port})`);
+        }
+    }
+    // 3. 创建并启动 MCP server
+    const mcpServer = createMcpServer(services);
+    const transport = new StdioServerTransport();
+    await mcpServer.connect(transport);
+    logMcp("Server started");
+    // 4. 优雅退出处理
+    const shutdown = async (signal) => {
+        logMcp(`收到 ${signal}，正在关闭...`);
+        // 关闭 HTTP server
+        if (httpServer) {
+            try {
+                await httpServer.close();
+                logHttp("Server closed");
+            }
+            catch (err) {
+                logHttp(`关闭失败: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // 关闭 MCP server
+        try {
+            await mcpServer.close();
+            logMcp("Server closed");
+        }
+        catch (err) {
+            logMcp(`关闭失败: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", () => shutdown("SIGINT"));
+    process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+main().catch((err) => {
+    console.error("[main] 启动失败:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map