@yinuo-ngm/mcp-server 0.1.1 → 0.1.3

package/lib/register-tools.js

@@ -6,22 +6,83 @@ const tool_policy_1 = require("./policy/tool-policy");
 const tools_1 = require("./tools");
 const errors_1 = require("./utils/errors");
 const result_1 = require("./utils/result");
+const audit_log_service_1 = require("./audit/audit-log.service");
+function resultOperationStatus(result) {
+    if (!result?.ok || typeof result.data !== "object" || result.data === null)
+        return undefined;
+    const operation = result.data.operation;
+    if (!operation || typeof operation !== "object")
+        return undefined;
+    const status = operation.status;
+    return typeof status === "string" ? status : undefined;
+}
+function shouldWriteAudit(tool, confirmed, result) {
+    if (!(0, audit_log_service_1.shouldAuditTool)(tool.name, tool.riskLevel))
+        return false;
+    if (!confirmed)
+        return false;
+    const status = resultOperationStatus(result);
+    return status === "executed" || status === "failed";
+}
+function registerMcpTool(server, tool, handler) {
+    const compatibleServer = server;
+    compatibleServer.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+    }, async (args) => handler(args));
+}
 function registerTools(server, context) {
     const policy = (0, tool_policy_1.createDefaultToolPolicy)();
-    const registerTool = server.registerTool.bind(server);
     for (const tool of (0, tools_1.allTools)()) {
-        registerTool(tool.name, {
-            description: tool.description,
-            inputSchema: tool.inputSchema,
-        }, async (args) => {
+        registerMcpTool(server, tool, async (args) => {
+            const startedAt = Date.now();
+            let parsed;
+            let result;
+            let confirmed = true;
             try {
-                (0, assert_tool_policy_1.assertToolPolicy)(policy, tool.name, tool.riskLevel);
-                const parsed = tool.inputSchema.parse(args);
-                const result = await tool.handler(parsed, context);
+                parsed = tool.inputSchema.parse(args);
+                const parsedArgs = parsed;
+                confirmed = tool.isConfirmed?.(parsedArgs) ?? true;
+                const isAllowedPreview = tool.allowPreviewWhenBlocked === true && (!confirmed || tool.deferPolicyToHandler === true);
+                if (!isAllowedPreview) {
+                    (0, assert_tool_policy_1.assertToolPolicy)(policy, tool.name, tool.riskLevel);
+                }
+                result = await tool.handler(parsedArgs, context);
+                result = { ...result, tool: tool.name };
+                if (shouldWriteAudit(tool, confirmed, result)) {
+                    try {
+                        await (0, audit_log_service_1.writeAuditLog)(context, {
+                            tool: tool.name,
+                            riskLevel: tool.riskLevel,
+                            args: parsed,
+                            result,
+                            durationMs: Date.now() - startedAt,
+                        });
+                    }
+                    catch (auditError) {
+                        result = (0, result_1.withAuditWarning)(result, (0, audit_log_service_1.auditWarning)(auditError));
+                    }
+                }
                 return (0, result_1.toMcpTextResult)(result);
             }
             catch (error) {
-                return (0, result_1.toMcpTextResult)((0, result_1.fail)(tool.name, (0, errors_1.errorMessage)(error)));
+                result = (0, result_1.fail)(tool.name, (0, errors_1.errorMessage)(error), (0, errors_1.errorMetadata)(error));
+                if (shouldWriteAudit(tool, confirmed, result)) {
+                    try {
+                        await (0, audit_log_service_1.writeAuditLog)(context, {
+                            tool: tool.name,
+                            riskLevel: tool.riskLevel,
+                            args: parsed ?? args,
+                            result,
+                            error,
+                            durationMs: Date.now() - startedAt,
+                        });
+                    }
+                    catch (auditError) {
+                        result = (0, result_1.withAuditWarning)(result, (0, audit_log_service_1.auditWarning)(auditError));
+                    }
+                }
+                return (0, result_1.toMcpTextResult)(result);
             }
         });
     }

package/lib/registry/tool-names.d.ts

@@ -0,0 +1,95 @@
+export declare const MCP_TOOL_NAMES: {
+    readonly HUB_V2_DOCS_CREATE: "hub_v2_docs_create";
+    readonly HUB_V2_DOCS_GET: "hub_v2_docs_get";
+    readonly HUB_V2_DOCS_GET_BY_SLUG: "hub_v2_docs_get_by_slug";
+    readonly HUB_V2_DOCS_LIST: "hub_v2_docs_list";
+    readonly HUB_V2_DOCS_UPDATE: "hub_v2_docs_update";
+    readonly HUB_V2_ISSUES_ASSIGN: "hub_v2_issues_assign";
+    readonly HUB_V2_ISSUES_COMMENT: "hub_v2_issues_comment";
+    readonly HUB_V2_ISSUES_CREATE: "hub_v2_issues_create";
+    readonly HUB_V2_ISSUES_GET: "hub_v2_issues_get";
+    readonly HUB_V2_ISSUES_LIST: "hub_v2_issues_list";
+    readonly HUB_V2_ISSUES_UPDATE: "hub_v2_issues_update";
+    readonly HUB_V2_PROJECT_MEMBERS_LIST: "hub_v2_project_members_list";
+    readonly HUB_V2_PROJECTS_GET: "hub_v2_projects_get";
+    readonly HUB_V2_PROJECTS_LIST: "hub_v2_projects_list";
+    readonly HUB_V2_RD_ADVANCE_STAGE: "hub_v2_rd_advance_stage";
+    readonly HUB_V2_RD_CREATE: "hub_v2_rd_create";
+    readonly HUB_V2_RD_GET: "hub_v2_rd_get";
+    readonly HUB_V2_RD_LIST: "hub_v2_rd_list";
+    readonly HUB_V2_RD_STAGE_TASKS_CREATE: "hub_v2_rd_stage_tasks_create";
+    readonly HUB_V2_RD_STAGE_TASKS_LIST: "hub_v2_rd_stage_tasks_list";
+    readonly HUB_V2_RD_UPDATE_PROGRESS: "hub_v2_rd_update_progress";
+    readonly HUB_V2_UPLOAD_MARKDOWN_IMAGE: "hub_v2_upload_markdown_image";
+    readonly NGM_ANGULAR_VALIDATE_COMPONENT_BOUNDARY: "ngm_angular_validate_component_boundary";
+    readonly NGM_ANGULAR_VALIDATE_COMPONENT_NAMING: "ngm_angular_validate_component_naming";
+    readonly NGM_ANGULAR_VALIDATE_STRUCTURE: "ngm_angular_validate_structure";
+    readonly NGM_CAPABILITIES: "ngm_capabilities";
+    readonly NGM_DOCTOR: "ngm_doctor";
+    readonly NGM_FILE_WRITE: "ngm_file_write";
+    readonly NGM_GIT_DIFF: "ngm_git_diff";
+    readonly NGM_GIT_GENERATE_COMMIT_MESSAGE: "ngm_git_generate_commit_message";
+    readonly NGM_GIT_GENERATE_REVIEW_SUMMARY: "ngm_git_generate_review_summary";
+    readonly NGM_GIT_STATUS: "ngm_git_status";
+    readonly NGM_GIT_VALIDATE_BRANCH_NAME: "ngm_git_validate_branch_name";
+    readonly NGM_GIT_VALIDATE_COMMIT_MESSAGE: "ngm_git_validate_commit_message";
+    readonly NGM_LOG_SEARCH: "ngm_log_search";
+    readonly NGM_LOG_TAIL: "ngm_log_tail";
+    readonly NGM_NGINX_CONFIG_GET_MAIN: "ngm_nginx_config_get_main";
+    readonly NGM_NGINX_CONFIG_VALIDATE: "ngm_nginx_config_validate";
+    readonly NGM_NGINX_LOGS_TAIL: "ngm_nginx_logs_tail";
+    readonly NGM_NGINX_PROXY_SAVE: "ngm_nginx_proxy_save";
+    readonly NGM_NGINX_RELOAD: "ngm_nginx_reload";
+    readonly NGM_NGINX_SERVER_GET: "ngm_nginx_server_get";
+    readonly NGM_NGINX_SERVERS_LIST: "ngm_nginx_servers_list";
+    readonly NGM_NGINX_STATUS: "ngm_nginx_status";
+    readonly NGM_NGINX_UPSTREAMS_LIST: "ngm_nginx_upstreams_list";
+    readonly NGM_PROJECT_FIND: "ngm_project_find";
+    readonly NGM_PROJECT_GET: "ngm_project_get";
+    readonly NGM_PROJECT_GET_SCRIPTS: "ngm_project_get_scripts";
+    readonly NGM_PROJECT_HEALTH_CHECK: "ngm_project_health_check";
+    readonly NGM_PROJECT_LIST: "ngm_project_list";
+    readonly NGM_PROJECT_LIST_TASKS: "ngm_project_list_tasks";
+    readonly NGM_PROJECT_MANAGED_LIST: "ngm_project_managed_list";
+    readonly NGM_PROJECT_PORT_CHECK: "ngm_project_port_check";
+    readonly NGM_PROJECT_READ_PACKAGE_JSON: "ngm_project_read_package_json";
+    readonly NGM_PROJECT_RUN_SCRIPT: "ngm_project_run_script";
+    readonly NGM_PROJECT_STOP: "ngm_project_stop";
+    readonly NGM_PROJECT_TASK_LOGS: "ngm_project_task_logs";
+    readonly NGM_PROJECT_TASK_STATUS: "ngm_project_task_status";
+    readonly NGM_PROXY_LIST: "ngm_proxy_list";
+    readonly NGM_PROXY_VALIDATE: "ngm_proxy_validate";
+    readonly NGM_REVIEW_DETECT_RISKS: "ngm_review_detect_risks";
+    readonly NGM_REVIEW_GENERATE_CHECKLIST: "ngm_review_generate_checklist";
+    readonly NGM_REVIEW_GENERATE_REPORT: "ngm_review_generate_report";
+    readonly NGM_REVIEW_SCAN_CHANGED_FILES: "ngm_review_scan_changed_files";
+    readonly NGM_ROUTE_TASK: "ngm_route_task";
+    readonly NGM_RUNTIME_CURRENT: "ngm_runtime_current";
+    readonly NGM_RUNTIME_DETECT_REQUIREMENT: "ngm_runtime_detect_requirement";
+    readonly NGM_RUNTIME_LIST: "ngm_runtime_list";
+    readonly NGM_RUNTIME_RESOLVE_FOR_PROJECT: "ngm_runtime_resolve_for_project";
+    readonly NGM_RUNTIME_SET_FOR_PROJECT: "ngm_runtime_set_for_project";
+    readonly NGM_STANDARD_GET: "ngm_standard_get";
+    readonly NGM_STANDARD_INIT: "ngm_standard_init";
+    readonly NGM_STANDARD_VALIDATE_PROJECT: "ngm_standard_validate_project";
+    readonly NGM_TASK_GET_STATUS: "ngm_task_get_status";
+    readonly NGM_TASK_LIST: "ngm_task_list";
+    readonly NGM_TEST_DETECT_MISSING_SPECS: "ngm_test_detect_missing_specs";
+    readonly NGM_TEST_GENERATE_SPEC_PLAN: "ngm_test_generate_spec_plan";
+    readonly NGM_TEST_VALIDATE_NAMING: "ngm_test_validate_naming";
+    readonly NGM_WORKFLOW_ADVANCE_STATUS: "ngm_workflow_advance_status";
+    readonly NGM_WORKFLOW_CREATE_FRONTEND_TASK: "ngm_workflow_create_frontend_task";
+    readonly NGM_WORKFLOW_GENERATE_DELIVERY_REPORT: "ngm_workflow_generate_delivery_report";
+    readonly NGM_WORKFLOW_GENERATE_DEV_PLAN: "ngm_workflow_generate_dev_plan";
+    readonly NGM_WORKFLOW_VALIDATE_BEFORE_COMMIT: "ngm_workflow_validate_before_commit";
+    readonly NGM_WORKFLOW_VALIDATE_BEFORE_WRITE: "ngm_workflow_validate_before_write";
+    readonly NGM_WORKSPACE_APPLY_PATCH_PREVIEW: "ngm_workspace_apply_patch_preview";
+    readonly NGM_WORKSPACE_CAPABILITY_MAP: "ngm_workspace_capability_map";
+    readonly NGM_WORKSPACE_DIFF: "ngm_workspace_diff";
+    readonly NGM_WORKSPACE_GET_PACKAGE: "ngm_workspace_get_package";
+    readonly NGM_WORKSPACE_LIST_PACKAGES: "ngm_workspace_list_packages";
+    readonly NGM_WORKSPACE_MCP_TOOLS: "ngm_workspace_mcp_tools";
+    readonly NGM_WORKSPACE_SUMMARY: "ngm_workspace_summary";
+};
+export type McpToolName = (typeof MCP_TOOL_NAMES)[keyof typeof MCP_TOOL_NAMES];
+export declare const MCP_TOOL_NAME_SET: Set<string>;

package/lib/registry/tool-names.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCP_TOOL_NAME_SET = exports.MCP_TOOL_NAMES = void 0;
+exports.MCP_TOOL_NAMES = {
+    HUB_V2_DOCS_CREATE: "hub_v2_docs_create",
+    HUB_V2_DOCS_GET: "hub_v2_docs_get",
+    HUB_V2_DOCS_GET_BY_SLUG: "hub_v2_docs_get_by_slug",
+    HUB_V2_DOCS_LIST: "hub_v2_docs_list",
+    HUB_V2_DOCS_UPDATE: "hub_v2_docs_update",
+    HUB_V2_ISSUES_ASSIGN: "hub_v2_issues_assign",
+    HUB_V2_ISSUES_COMMENT: "hub_v2_issues_comment",
+    HUB_V2_ISSUES_CREATE: "hub_v2_issues_create",
+    HUB_V2_ISSUES_GET: "hub_v2_issues_get",
+    HUB_V2_ISSUES_LIST: "hub_v2_issues_list",
+    HUB_V2_ISSUES_UPDATE: "hub_v2_issues_update",
+    HUB_V2_PROJECT_MEMBERS_LIST: "hub_v2_project_members_list",
+    HUB_V2_PROJECTS_GET: "hub_v2_projects_get",
+    HUB_V2_PROJECTS_LIST: "hub_v2_projects_list",
+    HUB_V2_RD_ADVANCE_STAGE: "hub_v2_rd_advance_stage",
+    HUB_V2_RD_CREATE: "hub_v2_rd_create",
+    HUB_V2_RD_GET: "hub_v2_rd_get",
+    HUB_V2_RD_LIST: "hub_v2_rd_list",
+    HUB_V2_RD_STAGE_TASKS_CREATE: "hub_v2_rd_stage_tasks_create",
+    HUB_V2_RD_STAGE_TASKS_LIST: "hub_v2_rd_stage_tasks_list",
+    HUB_V2_RD_UPDATE_PROGRESS: "hub_v2_rd_update_progress",
+    HUB_V2_UPLOAD_MARKDOWN_IMAGE: "hub_v2_upload_markdown_image",
+    NGM_ANGULAR_VALIDATE_COMPONENT_BOUNDARY: "ngm_angular_validate_component_boundary",
+    NGM_ANGULAR_VALIDATE_COMPONENT_NAMING: "ngm_angular_validate_component_naming",
+    NGM_ANGULAR_VALIDATE_STRUCTURE: "ngm_angular_validate_structure",
+    NGM_CAPABILITIES: "ngm_capabilities",
+    NGM_DOCTOR: "ngm_doctor",
+    NGM_FILE_WRITE: "ngm_file_write",
+    NGM_GIT_DIFF: "ngm_git_diff",
+    NGM_GIT_GENERATE_COMMIT_MESSAGE: "ngm_git_generate_commit_message",
+    NGM_GIT_GENERATE_REVIEW_SUMMARY: "ngm_git_generate_review_summary",
+    NGM_GIT_STATUS: "ngm_git_status",
+    NGM_GIT_VALIDATE_BRANCH_NAME: "ngm_git_validate_branch_name",
+    NGM_GIT_VALIDATE_COMMIT_MESSAGE: "ngm_git_validate_commit_message",
+    NGM_LOG_SEARCH: "ngm_log_search",
+    NGM_LOG_TAIL: "ngm_log_tail",
+    NGM_NGINX_CONFIG_GET_MAIN: "ngm_nginx_config_get_main",
+    NGM_NGINX_CONFIG_VALIDATE: "ngm_nginx_config_validate",
+    NGM_NGINX_LOGS_TAIL: "ngm_nginx_logs_tail",
+    NGM_NGINX_PROXY_SAVE: "ngm_nginx_proxy_save",
+    NGM_NGINX_RELOAD: "ngm_nginx_reload",
+    NGM_NGINX_SERVER_GET: "ngm_nginx_server_get",
+    NGM_NGINX_SERVERS_LIST: "ngm_nginx_servers_list",
+    NGM_NGINX_STATUS: "ngm_nginx_status",
+    NGM_NGINX_UPSTREAMS_LIST: "ngm_nginx_upstreams_list",
+    NGM_PROJECT_FIND: "ngm_project_find",
+    NGM_PROJECT_GET: "ngm_project_get",
+    NGM_PROJECT_GET_SCRIPTS: "ngm_project_get_scripts",
+    NGM_PROJECT_HEALTH_CHECK: "ngm_project_health_check",
+    NGM_PROJECT_LIST: "ngm_project_list",
+    NGM_PROJECT_LIST_TASKS: "ngm_project_list_tasks",
+    NGM_PROJECT_MANAGED_LIST: "ngm_project_managed_list",
+    NGM_PROJECT_PORT_CHECK: "ngm_project_port_check",
+    NGM_PROJECT_READ_PACKAGE_JSON: "ngm_project_read_package_json",
+    NGM_PROJECT_RUN_SCRIPT: "ngm_project_run_script",
+    NGM_PROJECT_STOP: "ngm_project_stop",
+    NGM_PROJECT_TASK_LOGS: "ngm_project_task_logs",
+    NGM_PROJECT_TASK_STATUS: "ngm_project_task_status",
+    NGM_PROXY_LIST: "ngm_proxy_list",
+    NGM_PROXY_VALIDATE: "ngm_proxy_validate",
+    NGM_REVIEW_DETECT_RISKS: "ngm_review_detect_risks",
+    NGM_REVIEW_GENERATE_CHECKLIST: "ngm_review_generate_checklist",
+    NGM_REVIEW_GENERATE_REPORT: "ngm_review_generate_report",
+    NGM_REVIEW_SCAN_CHANGED_FILES: "ngm_review_scan_changed_files",
+    NGM_ROUTE_TASK: "ngm_route_task",
+    NGM_RUNTIME_CURRENT: "ngm_runtime_current",
+    NGM_RUNTIME_DETECT_REQUIREMENT: "ngm_runtime_detect_requirement",
+    NGM_RUNTIME_LIST: "ngm_runtime_list",
+    NGM_RUNTIME_RESOLVE_FOR_PROJECT: "ngm_runtime_resolve_for_project",
+    NGM_RUNTIME_SET_FOR_PROJECT: "ngm_runtime_set_for_project",
+    NGM_STANDARD_GET: "ngm_standard_get",
+    NGM_STANDARD_INIT: "ngm_standard_init",
+    NGM_STANDARD_VALIDATE_PROJECT: "ngm_standard_validate_project",
+    NGM_TASK_GET_STATUS: "ngm_task_get_status",
+    NGM_TASK_LIST: "ngm_task_list",
+    NGM_TEST_DETECT_MISSING_SPECS: "ngm_test_detect_missing_specs",
+    NGM_TEST_GENERATE_SPEC_PLAN: "ngm_test_generate_spec_plan",
+    NGM_TEST_VALIDATE_NAMING: "ngm_test_validate_naming",
+    NGM_WORKFLOW_ADVANCE_STATUS: "ngm_workflow_advance_status",
+    NGM_WORKFLOW_CREATE_FRONTEND_TASK: "ngm_workflow_create_frontend_task",
+    NGM_WORKFLOW_GENERATE_DELIVERY_REPORT: "ngm_workflow_generate_delivery_report",
+    NGM_WORKFLOW_GENERATE_DEV_PLAN: "ngm_workflow_generate_dev_plan",
+    NGM_WORKFLOW_VALIDATE_BEFORE_COMMIT: "ngm_workflow_validate_before_commit",
+    NGM_WORKFLOW_VALIDATE_BEFORE_WRITE: "ngm_workflow_validate_before_write",
+    NGM_WORKSPACE_APPLY_PATCH_PREVIEW: "ngm_workspace_apply_patch_preview",
+    NGM_WORKSPACE_CAPABILITY_MAP: "ngm_workspace_capability_map",
+    NGM_WORKSPACE_DIFF: "ngm_workspace_diff",
+    NGM_WORKSPACE_GET_PACKAGE: "ngm_workspace_get_package",
+    NGM_WORKSPACE_LIST_PACKAGES: "ngm_workspace_list_packages",
+    NGM_WORKSPACE_MCP_TOOLS: "ngm_workspace_mcp_tools",
+    NGM_WORKSPACE_SUMMARY: "ngm_workspace_summary",
+};
+exports.MCP_TOOL_NAME_SET = new Set(Object.values(exports.MCP_TOOL_NAMES));

package/lib/services/path-guard.service.d.ts

@@ -0,0 +1,4 @@
+export declare class PathGuardService {
+    assertSafeRelativePath(relativePath: string): void;
+    resolveInsideProject(projectRoot: string, relativePath: string): string;
+}

package/lib/services/path-guard.service.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathGuardService = void 0;
+const path = __importStar(require("path"));
+const error_codes_1 = require("../errors/error-codes");
+const mcp_tool_error_1 = require("../errors/mcp-tool-error");
+function isAbsolutePath(value) {
+    return path.isAbsolute(value) || path.win32.isAbsolute(value) || path.posix.isAbsolute(value);
+}
+function isInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+class PathGuardService {
+    assertSafeRelativePath(relativePath) {
+        const normalized = relativePath.trim().replace(/\\/g, "/");
+        if (!normalized || normalized.includes("\0")) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.TOOL_INPUT_INVALID, "relativePath is required");
+        }
+        if (isAbsolutePath(normalized)) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.ABSOLUTE_PATH_DENIED, "relativePath must not be absolute", { relativePath });
+        }
+        const parts = normalized.split("/").filter(Boolean);
+        if (!parts.length || parts.includes("..")) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.PATH_ESCAPE_DENIED, "relativePath must stay inside the project directory", {
+                relativePath,
+            });
+        }
+    }
+    resolveInsideProject(projectRoot, relativePath) {
+        this.assertSafeRelativePath(relativePath);
+        const target = path.resolve(projectRoot, ...relativePath.replace(/\\/g, "/").split("/").filter(Boolean));
+        if (!isInside(path.resolve(projectRoot), target)) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.PATH_ESCAPE_DENIED, "resolved path escapes project root", {
+                projectRoot,
+                relativePath,
+            });
+        }
+        return target;
+    }
+}
+exports.PathGuardService = PathGuardService;

package/lib/services/permission.service.d.ts

@@ -0,0 +1,5 @@
+export type McpActionType = "read" | "write" | "execute" | "external";
+export declare class PermissionService {
+    assertAllowed(actionType: McpActionType): void;
+    getRequiredEnv(actionType: McpActionType): string[];
+}

package/lib/services/permission.service.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionService = void 0;
+const error_codes_1 = require("../errors/error-codes");
+const mcp_tool_error_1 = require("../errors/mcp-tool-error");
+const requiredEnvByAction = {
+    read: [],
+    write: ["NGM_MCP_ALLOW_WRITE"],
+    execute: ["NGM_MCP_ALLOW_EXECUTE"],
+    external: ["NGM_MCP_ALLOW_HUB"],
+};
+function isEnabled(name) {
+    return String(process.env[name] ?? "").trim().toLowerCase() === "true";
+}
+class PermissionService {
+    assertAllowed(actionType) {
+        const missing = this.getRequiredEnv(actionType).filter((name) => !isEnabled(name));
+        if (missing.length === 0)
+            return;
+        const errorCode = actionType === "write"
+            ? error_codes_1.McpErrorCodes.WRITE_NOT_ALLOWED
+            : actionType === "execute"
+                ? error_codes_1.McpErrorCodes.EXECUTE_NOT_ALLOWED
+                : error_codes_1.McpErrorCodes.TOOL_INPUT_INVALID;
+        throw new mcp_tool_error_1.McpToolError(errorCode, `${missing.join(", ")}=true is required before confirmed ${actionType} operations can run`, {
+            requires: missing,
+            policy: missing.map((name) => ({
+                env: name,
+                requiredValue: "true",
+                currentValue: process.env[name] ? "[set-but-not-enabled]" : "[unset]",
+            })),
+        });
+    }
+    getRequiredEnv(actionType) {
+        return requiredEnvByAction[actionType];
+    }
+}
+exports.PermissionService = PermissionService;

package/lib/services/project-resolver.service.d.ts

@@ -0,0 +1,32 @@
+export interface ResolvedProject {
+    id: string;
+    name: string;
+    root: string;
+    type?: string;
+    createdAt?: number;
+    updatedAt?: number;
+    framework?: string;
+    scripts?: Record<string, string>;
+    packageManager?: string;
+    runtime?: any;
+    nodeVersion?: string;
+    isFavorite?: boolean;
+    repoUrl?: string;
+    repoPageUrl?: string;
+    env?: unknown;
+    assets?: unknown;
+    lastOpened?: unknown;
+}
+type ProjectRegistry = {
+    list?: () => Promise<any[]>;
+    get?: (projectId: string) => Promise<any>;
+};
+export declare class ProjectResolverService {
+    private readonly projectRegistry;
+    constructor(projectRegistry: ProjectRegistry);
+    listProjects(): Promise<ResolvedProject[]>;
+    resolveProject(projectId: string): Promise<ResolvedProject>;
+    private getProject;
+    private normalizeProject;
+}
+export {};

package/lib/services/project-resolver.service.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectResolverService = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const error_codes_1 = require("../errors/error-codes");
+const mcp_tool_error_1 = require("../errors/mcp-tool-error");
+class ProjectResolverService {
+    constructor(projectRegistry) {
+        this.projectRegistry = projectRegistry;
+    }
+    async listProjects() {
+        if (typeof this.projectRegistry.list !== "function") {
+            return [];
+        }
+        const projects = await this.projectRegistry.list();
+        return projects.map((project) => this.normalizeProject(project));
+    }
+    async resolveProject(projectId) {
+        const id = projectId.trim();
+        if (!id) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.TOOL_INPUT_INVALID, "projectId is required");
+        }
+        const listed = await this.listProjects();
+        const fromList = listed.find((project) => project.id === id);
+        const project = fromList ?? await this.getProject(id);
+        if (!project) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${id}`, { projectId: id });
+        }
+        const normalized = this.normalizeProject(project);
+        if (!(0, fs_1.existsSync)(normalized.root)) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.PROJECT_ROOT_NOT_FOUND, "registered project root does not exist", {
+                project: { id: normalized.id, name: normalized.name, root: normalized.root },
+            });
+        }
+        return normalized;
+    }
+    async getProject(projectId) {
+        if (typeof this.projectRegistry.get !== "function") {
+            return null;
+        }
+        try {
+            return await this.projectRegistry.get(projectId);
+        }
+        catch (error) {
+            throw new mcp_tool_error_1.McpToolError(error_codes_1.McpErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, {
+                projectId,
+                reason: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    normalizeProject(project) {
+        return {
+            ...project,
+            id: String(project.id),
+            name: String(project.name),
+            root: path.resolve(String(project.root)),
+            type: project.type ?? (typeof project.framework === "string" ? project.framework : undefined),
+        };
+    }
+}
+exports.ProjectResolverService = ProjectResolverService;

package/lib/standard/frontend-standard.default.d.ts

@@ -0,0 +1,2 @@
+import type { FrontendStandard } from "./frontend-standard.schema";
+export declare const defaultFrontendStandard: FrontendStandard;

package/lib/standard/frontend-standard.default.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultFrontendStandard = void 0;
+exports.defaultFrontendStandard = {
+    framework: {
+        name: "Angular",
+    },
+    uiLibrary: {
+        name: "NG-ZORRO",
+        componentPrefix: "nz",
+    },
+    style: {
+        language: "Less",
+        fileExtension: ".less",
+    },
+    naming: {
+        branchPatterns: [
+            "feature/{issueId}-{short-name}",
+            "fix/{issueId}-{short-name}",
+            "refactor/{module}-{short-name}",
+            "hotfix/{date}-{short-name}",
+        ],
+        commitTypes: ["feat", "fix", "refactor", "docs", "test", "chore"],
+        componentSuffixes: ["page", "component", "dialog", "drawer", "table", "form"],
+    },
+    structure: {
+        pagesDir: "src/app/pages",
+        componentsDir: "src/app/components",
+        servicesDir: "src/app/services",
+        modelsDir: "src/app/models",
+        maxComponentFileLines: 400,
+    },
+    git: {
+        branchPatterns: [
+            "^feature/[A-Za-z0-9]+-[a-z0-9][a-z0-9-]*$",
+            "^fix/[A-Za-z0-9]+-[a-z0-9][a-z0-9-]*$",
+            "^refactor/[a-z0-9][a-z0-9-]*-[a-z0-9][a-z0-9-]*$",
+            "^hotfix/\\d{8}-[a-z0-9][a-z0-9-]*$",
+        ],
+        commitPattern: "^(feat|fix|refactor|docs|test|chore)\\([a-z0-9-]+\\): .+",
+    },
+    testing: {
+        requireServiceSpec: true,
+        requireUtilSpec: true,
+        suggestComponentSpec: true,
+    },
+    review: {
+        requireChecklist: true,
+        riskKeywords: ["auth", "permission", "token", "password", "delete", "migration", "runtime", "process"],
+    },
+};