@yinuo-ngm/mcp-server 0.1.2 → 0.1.3

package/lib/context/tool-context.d.ts

@@ -1,4 +1,7 @@
 import type { CoreApp } from "@yinuo-ngm/core";
+import type { PathGuardService } from "../services/path-guard.service";
+import type { PermissionService } from "../services/permission.service";
+import type { ProjectResolverService } from "../services/project-resolver.service";
 export type GitReadService = {
     status(input: {
         projectId?: string;
@@ -9,10 +12,43 @@ export type GitReadService = {
         projectPath?: string;
         maxBytes?: number;
     }): Promise<unknown>;
+    changedFiles?(input: {
+        projectId?: string;
+        projectPath?: string;
+    }): Promise<string[]>;
+    currentBranch?(input: {
+        projectId?: string;
+        projectPath?: string;
+    }): Promise<string>;
+    latestLog?(input: {
+        projectId?: string;
+        projectPath?: string;
+    }): Promise<string>;
+};
+export type LocalServerAvailability = {
+    available: boolean;
+    url?: string;
+    reason?: string;
+};
+export type LocalServerClient = {
+    availability(): Promise<LocalServerAvailability>;
+    refreshTaskProject(projectId: string): Promise<any[]>;
+    refreshProjectScripts(projectId: string): Promise<any>;
+    updateProjectRuntime(projectId: string, runtime: unknown): Promise<any>;
+    listTaskViews(projectId: string): Promise<any[]>;
+    listActiveTasks(): Promise<any[]>;
+    startTask(taskId: string): Promise<any>;
+    stopTask(taskId: string): Promise<any>;
+    getTaskStatus(taskId: string): Promise<any>;
+    getTaskLogTail(runId: string, tail: number): Promise<any[]>;
 };
 export type ToolServices = {
     core: CoreApp;
     git: GitReadService;
+    pathGuard: PathGuardService;
+    permission: PermissionService;
+    projectResolver: ProjectResolverService;
+    localServer?: LocalServerClient;
 };
 export type ToolContext = {
     workspaceRoot: string;

package/lib/doctor.d.ts

@@ -0,0 +1,8 @@
+type DoctorStatus = "OK" | "WARN" | "ERROR";
+type DoctorReport = {
+    status: DoctorStatus;
+    text: string;
+};
+export declare function createDoctorReport(): DoctorReport;
+export declare function doctor(write?: (text: string) => void): Promise<void>;
+export {};

package/lib/doctor.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDoctorReport = createDoctorReport;
+exports.doctor = doctor;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const tool_policy_1 = require("./policy/tool-policy");
+const tools_1 = require("./tools");
+const index_1 = require("./tools/hub-v2/config/index");
+function envValue(name) {
+    const value = process.env[name];
+    return value !== undefined && value !== null && String(value).trim()
+        ? String(value).trim()
+        : undefined;
+}
+function statusRank(status) {
+    return status === "ERROR" ? 2 : status === "WARN" ? 1 : 0;
+}
+function maxStatus(...statuses) {
+    return statuses.reduce((current, next) => (statusRank(next) > statusRank(current) ? next : current), "OK");
+}
+function defaultDataDir() {
+    return envValue("NGM_DATA_DIR") ?? (0, path_1.join)((0, os_1.homedir)(), ".ng-manager");
+}
+function readPackageInfo() {
+    try {
+        const packagePath = (0, path_1.join)(__dirname, "..", "package.json");
+        const parsed = JSON.parse((0, fs_1.readFileSync)(packagePath, "utf8"));
+        const name = parsed.name ?? "@yinuo-ngm/mcp-server";
+        const version = parsed.version ?? "unknown";
+        return { text: `${name} ${version}`, status: version === "unknown" ? "WARN" : "OK" };
+    }
+    catch {
+        return { text: "@yinuo-ngm/mcp-server unknown", status: "WARN" };
+    }
+}
+function configured(value) {
+    return value ? "configured" : "missing";
+}
+function displayValue(value) {
+    return value || "missing";
+}
+function selectedProject(config) {
+    const projects = config.projects ?? {};
+    const entries = Object.entries(projects);
+    const selected = envValue("HUB_V2_PROJECT") ?? config.default_project;
+    if (selected) {
+        return {
+            name: selected,
+            project: projects[selected] ?? {},
+            status: projects[selected] || !entries.length ? "OK" : "WARN",
+        };
+    }
+    if (entries.length === 1) {
+        return { name: entries[0][0], project: entries[0][1], status: "OK" };
+    }
+    if (entries.length > 1) {
+        return { name: undefined, project: {}, status: "WARN" };
+    }
+    return { name: undefined, project: {}, status: "WARN" };
+}
+function configValue(config, project, key) {
+    return project[key] ?? config[key];
+}
+function hubV2Section() {
+    const path = (0, index_1.resolveAgentConnectionsPath)();
+    if (!(0, fs_1.existsSync)(path)) {
+        return {
+            status: "WARN",
+            lines: [
+                "Hub V2:",
+                "  config: missing",
+                `  path: ${path}`,
+            ],
+        };
+    }
+    let config;
+    try {
+        config = (0, index_1.loadConfig)(path);
+    }
+    catch (error) {
+        return {
+            status: "ERROR",
+            lines: [
+                "Hub V2:",
+                "  config: invalid",
+                `  path: ${path}`,
+                `  error: ${error instanceof Error ? error.message : String(error)}`,
+            ],
+        };
+    }
+    const selected = selectedProject(config);
+    const project = selected.project;
+    const baseUrl = envValue("HUB_V2_BASE_URL") ?? configValue(config, project, "base_url");
+    const projectKey = envValue("HUB_V2_PROJECT_KEY") ?? configValue(config, project, "project_key");
+    const projectToken = envValue("HUB_V2_PROJECT_TOKEN") ?? configValue(config, project, "project_token");
+    const personalToken = envValue("HUB_V2_PERSONAL_TOKEN") ?? configValue(config, project, "personal_token");
+    const fieldStatus = baseUrl && projectKey && projectToken && personalToken ? "OK" : "WARN";
+    return {
+        status: maxStatus(selected.status, fieldStatus),
+        lines: [
+            "Hub V2:",
+            "  config: found",
+            `  defaultProject: ${displayValue(config.default_project)}`,
+            `  project: ${displayValue(selected.name)}`,
+            `  baseUrl: ${displayValue(baseUrl)}`,
+            `  projectKey: ${displayValue(projectKey)}`,
+            `  projectToken: ${configured(projectToken)}`,
+            `  personalToken: ${configured(personalToken)}`,
+        ],
+    };
+}
+function policySection() {
+    const policy = (0, tool_policy_1.createDefaultToolPolicy)();
+    return [
+        "Policy:",
+        "  read: enabled",
+        `  write: ${policy.write ? "enabled" : "disabled"}`,
+        `  execute: ${policy.execute ? "enabled" : "disabled"}`,
+        `  dangerous: ${policy.dangerous ? "enabled" : "disabled"}`,
+    ];
+}
+function toolsSection() {
+    try {
+        const counts = {
+            read: 0,
+            write: 0,
+            execute: 0,
+            dangerous: 0,
+        };
+        const tools = (0, tools_1.allTools)();
+        for (const tool of tools) {
+            counts[tool.riskLevel] += 1;
+        }
+        return {
+            status: "OK",
+            lines: [
+                "Tools:",
+                `  total: ${tools.length}`,
+                `  read: ${counts.read}`,
+                `  write: ${counts.write}`,
+                `  execute: ${counts.execute}`,
+                `  dangerous: ${counts.dangerous}`,
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            status: "ERROR",
+            lines: [
+                "Tools:",
+                "  status: failed",
+                `  error: ${error instanceof Error ? error.message : String(error)}`,
+            ],
+        };
+    }
+}
+function enterpriseMvpSection() {
+    const names = new Set((0, tools_1.allTools)().map((tool) => tool.name));
+    const required = {
+        frontendStandard: ["ngm_standard_get", "ngm_standard_init", "ngm_standard_validate_project"],
+        workflow: ["ngm_workflow_create_frontend_task", "ngm_workflow_generate_dev_plan", "ngm_workflow_advance_status", "ngm_workflow_validate_before_commit", "ngm_workflow_generate_delivery_report"],
+        audit: ["ngm_standard_init", "ngm_workflow_create_frontend_task", "ngm_review_generate_report"],
+        patchPreview: ["ngm_workspace_diff", "ngm_workspace_apply_patch_preview"],
+        dottedAliases: ["ngm_project_run_script", "ngm_project_stop", "ngm_runtime_set_for_project", "ngm_nginx_reload", "ngm_nginx_proxy_save"],
+    };
+    const missing = Object.entries(required)
+        .flatMap(([group, tools]) => tools.filter((tool) => !names.has(tool)).map((tool) => `${group}:${tool}`));
+    return {
+        status: missing.length ? "WARN" : "OK",
+        lines: [
+            "Enterprise MVP:",
+            `  frontendStandard: ${required.frontendStandard.every((tool) => names.has(tool)) ? "available" : "missing"}`,
+            `  workflow: ${required.workflow.every((tool) => names.has(tool)) ? "available" : "missing"}`,
+            "  audit: project-local .ng-manager/audit/mcp-YYYY-MM-DD.jsonl",
+            `  patchPreview: ${required.patchPreview.every((tool) => names.has(tool)) ? "available" : "missing"}`,
+            `  dottedAliases: ${required.dottedAliases.every((tool) => names.has(tool)) ? "available" : "missing"}`,
+            ...(missing.length ? [`  missing: ${missing.join(", ")}`] : []),
+        ],
+    };
+}
+function createDoctorReport() {
+    const packageInfo = readPackageInfo();
+    const hubV2 = hubV2Section();
+    const tools = toolsSection();
+    const enterprise = enterpriseMvpSection();
+    const status = maxStatus(packageInfo.status, hubV2.status, tools.status, enterprise.status);
+    const lines = [
+        "ng-manager MCP Doctor",
+        "",
+        "Runtime:",
+        `  Node.js: ${process.version}`,
+        `  Platform: ${process.platform} ${process.arch}`,
+        `  CWD: ${process.cwd()}`,
+        `  MCP Server: ${packageInfo.text}`,
+        "",
+        "Paths:",
+        `  dataDir: ${defaultDataDir()}`,
+        `  agentConnections: ${(0, index_1.resolveAgentConnectionsPath)()}`,
+        "",
+        ...hubV2.lines,
+        "",
+        ...policySection(),
+        "",
+        ...tools.lines,
+        "",
+        ...enterprise.lines,
+        "",
+        "Status:",
+        `  ${status}`,
+    ];
+    return {
+        status,
+        text: lines.join("\n"),
+    };
+}
+async function doctor(write = (text) => process.stdout.write(text)) {
+    const report = createDoctorReport();
+    write(`${report.text}\n`);
+}

package/lib/errors/error-codes.d.ts

@@ -0,0 +1,12 @@
+export declare const McpErrorCodes: {
+    readonly PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND";
+    readonly PROJECT_ROOT_NOT_FOUND: "PROJECT_ROOT_NOT_FOUND";
+    readonly PATH_ESCAPE_DENIED: "PATH_ESCAPE_DENIED";
+    readonly ABSOLUTE_PATH_DENIED: "ABSOLUTE_PATH_DENIED";
+    readonly CONFIRM_REQUIRED: "CONFIRM_REQUIRED";
+    readonly WRITE_NOT_ALLOWED: "WRITE_NOT_ALLOWED";
+    readonly EXECUTE_NOT_ALLOWED: "EXECUTE_NOT_ALLOWED";
+    readonly LOCAL_SERVER_UNAVAILABLE: "LOCAL_SERVER_UNAVAILABLE";
+    readonly TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID";
+};
+export type McpErrorCode = (typeof McpErrorCodes)[keyof typeof McpErrorCodes];

package/lib/errors/error-codes.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpErrorCodes = void 0;
+exports.McpErrorCodes = {
+    PROJECT_NOT_FOUND: "PROJECT_NOT_FOUND",
+    PROJECT_ROOT_NOT_FOUND: "PROJECT_ROOT_NOT_FOUND",
+    PATH_ESCAPE_DENIED: "PATH_ESCAPE_DENIED",
+    ABSOLUTE_PATH_DENIED: "ABSOLUTE_PATH_DENIED",
+    CONFIRM_REQUIRED: "CONFIRM_REQUIRED",
+    WRITE_NOT_ALLOWED: "WRITE_NOT_ALLOWED",
+    EXECUTE_NOT_ALLOWED: "EXECUTE_NOT_ALLOWED",
+    LOCAL_SERVER_UNAVAILABLE: "LOCAL_SERVER_UNAVAILABLE",
+    TOOL_INPUT_INVALID: "TOOL_INPUT_INVALID",
+};

package/lib/errors/mcp-tool-error.d.ts

@@ -0,0 +1,8 @@
+import type { McpErrorCode } from "./error-codes";
+export declare class McpToolError extends Error {
+    readonly errorCode: McpErrorCode;
+    readonly code: McpErrorCode;
+    readonly status?: number;
+    readonly detail?: unknown;
+    constructor(errorCode: McpErrorCode, message: string, detail?: unknown, status?: number);
+}

package/lib/errors/mcp-tool-error.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.McpToolError = void 0;
+class McpToolError extends Error {
+    constructor(errorCode, message, detail, status) {
+        super(message);
+        this.name = "McpToolError";
+        this.errorCode = errorCode;
+        this.code = errorCode;
+        this.detail = detail;
+        this.status = status;
+    }
+}
+exports.McpToolError = McpToolError;

package/lib/filesystem/project-files.d.ts

@@ -0,0 +1,18 @@
+import type { ToolContext } from "../context/tool-context";
+export type ProjectLocator = {
+    projectId?: string;
+    projectPath?: string;
+};
+export type ResolvedProjectRoot = {
+    projectId?: string;
+    projectName?: string;
+    projectRoot: string;
+};
+export declare function resolveProjectRoot(context: ToolContext, locator?: ProjectLocator): Promise<ResolvedProjectRoot>;
+export declare function projectRelativePath(projectRoot: string, filePath: string): string;
+export declare function assertPathInsideProject(projectRoot: string, targetPath: string): void;
+export declare function resolveNgManagerPath(projectRoot: string, ...segments: string[]): string;
+export declare function pathExists(filePath: string): Promise<boolean>;
+export declare function writeJsonFile(filePath: string, value: unknown): Promise<void>;
+export declare function writeTextFile(filePath: string, value: string): Promise<void>;
+export declare function validateSafeId(kind: string, value: string): void;

package/lib/filesystem/project-files.js

@@ -0,0 +1,112 @@
+"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.resolveProjectRoot = resolveProjectRoot;
+exports.projectRelativePath = projectRelativePath;
+exports.assertPathInsideProject = assertPathInsideProject;
+exports.resolveNgManagerPath = resolveNgManagerPath;
+exports.pathExists = pathExists;
+exports.writeJsonFile = writeJsonFile;
+exports.writeTextFile = writeTextFile;
+exports.validateSafeId = validateSafeId;
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+function normalizePath(value) {
+    const resolved = path.resolve(value);
+    return process.platform === "win32" ? resolved.replace(/\\/g, "/").toLowerCase() : resolved;
+}
+function isInside(parent, child) {
+    const relative = path.relative(parent, child);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function resolveProjectRoot(context, locator = {}) {
+    if (locator.projectId) {
+        const project = await context.services.core.project.get(locator.projectId);
+        return {
+            projectId: project.id,
+            projectName: project.name,
+            projectRoot: path.resolve(project.root),
+        };
+    }
+    if (locator.projectPath) {
+        return {
+            projectRoot: path.resolve(locator.projectPath),
+        };
+    }
+    return {
+        projectRoot: path.resolve(context.workspaceRoot),
+    };
+}
+function projectRelativePath(projectRoot, filePath) {
+    return path.relative(projectRoot, filePath).replace(/\\/g, "/") || ".";
+}
+function assertPathInsideProject(projectRoot, targetPath) {
+    const root = normalizePath(projectRoot);
+    const target = normalizePath(targetPath);
+    if (!isInside(root, target)) {
+        throw new Error(`Path escapes project root: ${targetPath}`);
+    }
+}
+function resolveNgManagerPath(projectRoot, ...segments) {
+    const base = path.resolve(projectRoot, ".ng-manager");
+    const target = path.resolve(base, ...segments);
+    assertPathInsideProject(projectRoot, target);
+    if (!isInside(normalizePath(base), normalizePath(target))) {
+        throw new Error(`Path escapes .ng-manager directory: ${target}`);
+    }
+    return target;
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeJsonFile(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+}
+async function writeTextFile(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, value.endsWith("\n") ? value : `${value}\n`, "utf-8");
+}
+function validateSafeId(kind, value) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(value)) {
+        throw new Error(`${kind} must be 1-80 chars and contain only letters, numbers, dot, underscore, or dash`);
+    }
+}

package/lib/git/local-git-read-service.d.ts

@@ -0,0 +1,2 @@
+import type { GitReadService } from "../context/tool-context";
+export declare function createLocalGitReadService(workspaceRoot: string): GitReadService;

package/lib/git/local-git-read-service.js

@@ -0,0 +1,96 @@
+"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.createLocalGitReadService = createLocalGitReadService;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const util_1 = require("util");
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+function resolveCwd(workspaceRoot, projectPath) {
+    return path.resolve(projectPath || workspaceRoot);
+}
+async function git(cwd, args, maxBuffer = 200000) {
+    const { stdout } = await execFileAsync("git", args, {
+        cwd,
+        windowsHide: true,
+        timeout: 10000,
+        maxBuffer,
+    });
+    return String(stdout);
+}
+function parseChangedFiles(statusText) {
+    return statusText
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => line.replace(/^(.{2})\s+/, "").replace(/^"|"$/g, ""))
+        .map((line) => line.includes(" -> ") ? line.split(" -> ").pop() : line)
+        .filter(Boolean);
+}
+function createLocalGitReadService(workspaceRoot) {
+    return {
+        async status(input) {
+            const cwd = resolveCwd(workspaceRoot, input.projectPath);
+            const short = await git(cwd, ["status", "--short", "--untracked-files=all"]);
+            return {
+                cwd,
+                branch: (await git(cwd, ["branch", "--show-current"])).trim() || undefined,
+                changedFiles: parseChangedFiles(short),
+                short,
+            };
+        },
+        async diff(input) {
+            const cwd = resolveCwd(workspaceRoot, input.projectPath);
+            const text = await git(cwd, ["diff", "--no-ext-diff"], input.maxBytes ?? 200000);
+            const maxBytes = input.maxBytes ?? 200000;
+            return {
+                cwd,
+                diff: text.length > maxBytes ? text.slice(0, maxBytes) : text,
+                truncated: text.length > maxBytes || undefined,
+            };
+        },
+        async changedFiles(input) {
+            const cwd = resolveCwd(workspaceRoot, input.projectPath);
+            const short = await git(cwd, ["status", "--short", "--untracked-files=all"]);
+            return parseChangedFiles(short);
+        },
+        async currentBranch(input) {
+            return (await git(resolveCwd(workspaceRoot, input.projectPath), ["branch", "--show-current"])).trim();
+        },
+        async latestLog(input) {
+            return (await git(resolveCwd(workspaceRoot, input.projectPath), ["log", "-1", "--pretty=format:%h %s"])).trim();
+        },
+    };
+}

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 #!/usr/bin/env node
+export { createDoctorReport, doctor } from "./doctor";
 export declare function main(): Promise<void>;

package/lib/index.js

@@ -1,11 +1,15 @@
 #!/usr/bin/env node
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = exports.createDoctorReport = void 0;
 exports.main = main;
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const create_tool_context_1 = require("./context/create-tool-context");
 const create_mcp_server_1 = require("./create-mcp-server");
 const errors_1 = require("./utils/errors");
+var doctor_1 = require("./doctor");
+Object.defineProperty(exports, "createDoctorReport", { enumerable: true, get: function () { return doctor_1.createDoctorReport; } });
+Object.defineProperty(exports, "doctor", { enumerable: true, get: function () { return doctor_1.doctor; } });
 async function main() {
     const context = await (0, create_tool_context_1.createToolContext)();
     const server = (0, create_mcp_server_1.createMcpServer)(context);

package/lib/policy/assert-tool-policy.js

@@ -1,8 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertToolPolicy = assertToolPolicy;
+const error_codes_1 = require("../errors/error-codes");
+const mcp_tool_error_1 = require("../errors/mcp-tool-error");
 function assertToolPolicy(policy, toolName, riskLevel) {
     if (!policy[riskLevel]) {
-        throw new Error(`Tool ${toolName} is blocked by policy: ${riskLevel} tools are disabled`);
+        const errorCode = riskLevel === "write"
+            ? error_codes_1.McpErrorCodes.WRITE_NOT_ALLOWED
+            : riskLevel === "execute"
+                ? error_codes_1.McpErrorCodes.EXECUTE_NOT_ALLOWED
+                : error_codes_1.McpErrorCodes.TOOL_INPUT_INVALID;
+        throw new mcp_tool_error_1.McpToolError(errorCode, `Tool ${toolName} is blocked by policy: ${riskLevel} tools are disabled`, {
+            riskLevel,
+        });
     }
 }