@yinuo-ngm/mcp-server 0.1.2 → 0.1.4

package/lib/catalog/tools/nginx.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nginxTools = void 0;
+exports.nginxTools = [
+    {
+        name: "ngm_nginx_status",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Read local Nginx binding and process status.",
+    },
+    {
+        name: "ngm_nginx_servers_list",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "List local Nginx server blocks.",
+    },
+    {
+        name: "ngm_nginx_server_get",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Get one local Nginx server block.",
+    },
+    {
+        name: "ngm_nginx_upstreams_list",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "List local Nginx upstream definitions.",
+    },
+    {
+        name: "ngm_nginx_config_validate",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Validate current or supplied local Nginx config without reload.",
+    },
+    {
+        name: "ngm_nginx_config_get_main",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Read local Nginx main config metadata and content.",
+    },
+    {
+        name: "ngm_nginx_logs_tail",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Read recent local Nginx access or error log lines.",
+    },
+    {
+        name: "ngm_nginx_reload",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "execute",
+        description: "Validate and preview or reload the ng-manager managed local Nginx instance; preferred over direct nginx commands and audit logged when confirmed.",
+    },
+    {
+        name: "ngm_nginx_proxy_save",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "write",
+        description: "Preview or save a ng-manager managed Nginx proxy server block; validates inputs, avoids arbitrary file writes, and audit logs confirmed saves.",
+    },
+    {
+        name: "ngm_proxy_list",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Compatibility tool for current ng-manager Nginx/proxy bindings.",
+    },
+    {
+        name: "ngm_proxy_validate",
+        skill: "ngm-nginx",
+        capability: "nginx",
+        riskLevel: "read",
+        description: "Compatibility tool for validating Nginx/proxy config.",
+    },
+];

package/lib/catalog/tools/project.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCatalogEntry } from "../types";
+export declare const projectTools: ToolCatalogEntry[];

package/lib/catalog/tools/project.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectTools = void 0;
+exports.projectTools = [
+    {
+        name: "ngm_project_list",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "List registered ng-manager projects by projectId; prefer before shell discovery because it uses the project registry and does not scan arbitrary roots.",
+    },
+    {
+        name: "ngm_project_managed_list",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "List projects managed by ng-manager.",
+    },
+    {
+        name: "ngm_project_find",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Find ng-manager local projects by name, path, framework, or package manager.",
+    },
+    {
+        name: "ngm_project_get",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Get one ng-manager project by projectId or projectPath.",
+    },
+    {
+        name: "ngm_project_get_scripts",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Get package scripts and runtime hints for one ng-manager project.",
+    },
+    {
+        name: "ngm_project_read_package_json",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Read package.json metadata for one registered ng-manager local project.",
+    },
+    {
+        name: "ngm_project_run_script",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "execute",
+        description: "Preview or run an existing package.json script for a registered projectId through the local ng-manager server runtime; preferred over direct shell so task state, logs, and audit stay unified.",
+    },
+    {
+        name: "ngm_project_stop",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "execute",
+        description: "Preview or stop a ng-manager managed task by taskId or projectId through the local server runtime; preferred over killing PIDs and audit logged when confirmed.",
+    },
+    {
+        name: "ngm_file_write",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "write",
+        description: "Preview or write a text file inside a registered project using projectId and safe relativePath only; rejects absolute paths/traversal and audit logs confirmed writes.",
+    },
+    {
+        name: "ngm_project_list_tasks",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "List ng-manager managed project tasks from the shared local server runtime state.",
+    },
+    {
+        name: "ngm_project_task_status",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Read structured runtime status for one ng-manager managed task.",
+    },
+    {
+        name: "ngm_project_task_logs",
+        skill: "ngm-project",
+        capability: "logs",
+        riskLevel: "read",
+        description: "Read a limited, redacted log tail for one ng-manager managed task or run.",
+    },
+    {
+        name: "ngm_project_port_check",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Check whether one local host/port is listening without shell execution or range scanning.",
+    },
+    {
+        name: "ngm_project_health_check",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Perform a short local HTTP health check by URL or managed task/project runtime URL.",
+    },
+    {
+        name: "ngm_task_list",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "List registered task views for a project, or active tasks when projectId is omitted.",
+    },
+    {
+        name: "ngm_task_get_status",
+        skill: "ngm-project",
+        capability: "project",
+        riskLevel: "read",
+        description: "Get the runtime status for a registered task.",
+    },
+    {
+        name: "ngm_log_tail",
+        skill: "ngm-project",
+        capability: "logs",
+        riskLevel: "read",
+        description: "Read recent task logs by runId or taskId.",
+    },
+];

package/lib/catalog/tools/router.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCatalogEntry } from "../types";
+export declare const routerTools: ToolCatalogEntry[];

package/lib/catalog/tools/router.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routerTools = void 0;
+exports.routerTools = [
+    {
+        name: "ngm_capabilities",
+        skill: "ngm-router",
+        capability: "discovery",
+        riskLevel: "read",
+        description: "List ng-manager MCP capability groups, skills, and tool coverage.",
+    },
+    {
+        name: "ngm_route_task",
+        skill: "ngm-router",
+        capability: "routing",
+        riskLevel: "read",
+        description: "Route a user request to Hub V2 or NGM local skills and read-only MCP tools.",
+    },
+    {
+        name: "ngm_doctor",
+        skill: "ngm-router",
+        capability: "discovery",
+        riskLevel: "read",
+        description: "Inspect MCP readiness, policy flags, Hub V2 config, and tool coverage through the controlled ng-manager MCP view.",
+    },
+];

package/lib/catalog/tools/runtime.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCatalogEntry } from "../types";
+export declare const runtimeTools: ToolCatalogEntry[];

package/lib/catalog/tools/runtime.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeTools = void 0;
+exports.runtimeTools = [
+    {
+        name: "ngm_runtime_current",
+        skill: "ngm-runtime",
+        capability: "runtime",
+        riskLevel: "read",
+        description: "Read current Node version manager information.",
+    },
+    {
+        name: "ngm_runtime_list",
+        skill: "ngm-runtime",
+        capability: "runtime",
+        riskLevel: "read",
+        description: "List Node runtimes known to ng-manager.",
+    },
+    {
+        name: "ngm_runtime_resolve_for_project",
+        skill: "ngm-runtime",
+        capability: "runtime",
+        riskLevel: "read",
+        description: "Resolve the Node runtime ng-manager would use for a project.",
+    },
+    {
+        name: "ngm_runtime_detect_requirement",
+        skill: "ngm-runtime",
+        capability: "runtime",
+        riskLevel: "read",
+        description: "Detect project Node version requirements from package metadata.",
+    },
+    {
+        name: "ngm_runtime_set_for_project",
+        skill: "ngm-runtime",
+        capability: "runtime",
+        riskLevel: "write",
+        description: "Preview or set a registered projectId's Node runtime binding through the local server; preferred over config/shell edits and audit logged when confirmed.",
+    },
+];

package/lib/catalog/tools/workspace.d.ts

@@ -0,0 +1,2 @@
+import type { ToolCatalogEntry } from "../types";
+export declare const workspaceTools: ToolCatalogEntry[];

package/lib/catalog/tools/workspace.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceTools = void 0;
+exports.workspaceTools = [
+    {
+        name: "ngm_workspace_summary",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Summarize the local ng-manager workspace and major app/package areas.",
+    },
+    {
+        name: "ngm_workspace_list_packages",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "List local workspace package metadata from known ng-manager package roots.",
+    },
+    {
+        name: "ngm_workspace_get_package",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Get package.json metadata for one local workspace package or app.",
+    },
+    {
+        name: "ngm_workspace_mcp_tools",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "List ng-manager MCP tools with capability and skill mapping.",
+    },
+    {
+        name: "ngm_workspace_capability_map",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Map ng-manager workspace areas to local capability domains.",
+    },
+    {
+        name: "ngm_log_search",
+        skill: "ngm-workspace",
+        capability: "logs",
+        riskLevel: "read",
+        description: "Search recent ng-manager system logs by keyword.",
+    },
+    {
+        name: "ngm_git_status",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Read Git working tree status for a project when the core Git service is available.",
+    },
+    {
+        name: "ngm_git_diff",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Read Git diff for a project when the core Git service is available.",
+    },
+    {
+        name: "ngm_workspace_diff",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Read a safe project diff summary without exposing forbidden workspace paths.",
+    },
+    {
+        name: "ngm_workspace_apply_patch_preview",
+        skill: "ngm-workspace",
+        capability: "workspace",
+        riskLevel: "read",
+        description: "Preview a unified patch without writing files.",
+    },
+];

package/lib/catalog/types.d.ts

@@ -0,0 +1,15 @@
+import type { ToolRiskLevel } from "../policy/tool-policy";
+export type ToolCatalogEntry = {
+    name: string;
+    skill: string;
+    capability: string;
+    riskLevel: ToolRiskLevel;
+    description: string;
+};
+export type CapabilityCatalogEntry = {
+    id: string;
+    label: string;
+    skills: string[];
+    tools: string[];
+    notes?: string[];
+};

package/lib/catalog/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/context/create-tool-context.js

@@ -37,17 +37,14 @@ exports.createToolContext = createToolContext;
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const core_1 = require("@yinuo-ngm/core");
-const gitStub = {
-    async status() {
-        throw new Error("Git service is not implemented in core yet");
-    },
-    async diff() {
-        throw new Error("Git service is not implemented in core yet");
-    },
-};
+const local_server_client_1 = require("./local-server-client");
+const local_git_read_service_1 = require("../git/local-git-read-service");
+const path_guard_service_1 = require("../services/path-guard.service");
+const permission_service_1 = require("../services/permission.service");
+const project_resolver_service_1 = require("../services/project-resolver.service");
 async function createToolContext() {
     const dataDir = process.env.NGM_DATA_DIR || path.join(os.homedir(), ".ng-manager");
-    const workspaceRoot = process.env.NGM_WORKSPACE_ROOT || process.cwd();
+    const workspaceRoot = process.cwd();
     const core = await (0, core_1.createCoreApp)({
         dataDir,
         sysLogCapacity: 3000,
@@ -57,7 +54,11 @@ async function createToolContext() {
         dataDir,
         services: {
             core,
-            git: gitStub,
+            git: (0, local_git_read_service_1.createLocalGitReadService)(workspaceRoot),
+            pathGuard: new path_guard_service_1.PathGuardService(),
+            permission: new permission_service_1.PermissionService(),
+            projectResolver: new project_resolver_service_1.ProjectResolverService(core.project),
+            localServer: (0, local_server_client_1.createLocalServerClient)(),
         },
         async dispose() {
             await core.dispose();

package/lib/context/local-server-client.d.ts

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

package/lib/context/local-server-client.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalServerClient = createLocalServerClient;
+const runtime_1 = require("@yinuo-ngm/runtime");
+const error_codes_1 = require("../errors/error-codes");
+function normalizeHostForValidation(host) {
+    return host.trim().toLowerCase().replace(/^\[|\]$/g, "");
+}
+function isAllowedLocalHost(host) {
+    const normalized = normalizeHostForValidation(host);
+    return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1";
+}
+function validatePort(port) {
+    const value = Number(port);
+    return Number.isInteger(value) && value >= 1 && value <= 65535 ? value : null;
+}
+function validateServerUrl(value, source) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new Error(`invalid ${source} local server URL`);
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error(`${source} local server URL must use http or https`);
+    }
+    if (!isAllowedLocalHost(url.hostname)) {
+        throw new Error(`${source} local server host must be localhost, 127.0.0.1, or ::1`);
+    }
+    const port = validatePort(url.port || (url.protocol === "https:" ? 443 : 80));
+    if (!port) {
+        throw new Error(`${source} local server port must be 1-65535`);
+    }
+    return url.origin;
+}
+function envServerUrl() {
+    const value = process.env.NGM_MCP_SERVER_URL || process.env.NGM_SERVER_URL;
+    const trimmed = value?.trim();
+    return trimmed ? validateServerUrl(trimmed, "env") : undefined;
+}
+function lockServerUrl() {
+    const lock = (0, runtime_1.readLocalServerLock)();
+    if (!lock?.port)
+        return undefined;
+    const host = lock.host || "127.0.0.1";
+    if (!isAllowedLocalHost(host)) {
+        throw new Error("lock local server host must be localhost, 127.0.0.1, or ::1");
+    }
+    const port = validatePort(lock.port);
+    if (!port) {
+        throw new Error("lock local server port must be 1-65535");
+    }
+    const normalizedHost = normalizeHostForValidation(host);
+    const urlHost = normalizedHost === "::1" ? "[::1]" : normalizedHost;
+    return validateServerUrl(`http://${urlHost}:${port}`, "lock");
+}
+async function fetchWithTimeout(url, init = {}, timeoutMs = 1500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, {
+            ...init,
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function unwrap(value) {
+    const envelope = value;
+    if (envelope && typeof envelope === "object" && "ok" in envelope) {
+        if (envelope.ok === false) {
+            throw new Error(envelope.error || "ng-manager server request failed");
+        }
+        if ("data" in envelope) {
+            return envelope.data;
+        }
+        return value;
+    }
+    return value;
+}
+function unavailableError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const normalized = error instanceof Error && error.name === "AbortError"
+        ? "request timed out"
+        : message;
+    const out = new Error(`ng-manager local server is unavailable: ${normalized}`);
+    out.code = error_codes_1.McpErrorCodes.LOCAL_SERVER_UNAVAILABLE;
+    out.errorCode = error_codes_1.McpErrorCodes.LOCAL_SERVER_UNAVAILABLE;
+    return out;
+}
+function clampTail(tail) {
+    return Math.min(Math.max(Number.isInteger(tail) ? tail : 100, 1), 500);
+}
+function createLocalServerClient() {
+    async function baseUrl() {
+        const url = envServerUrl() || lockServerUrl();
+        if (!url) {
+            throw new Error(`ng-manager local server is not discoverable from ${(0, runtime_1.getLocalServerDataDir)()}; start ng-manager UI/server first`);
+        }
+        return url.replace(/\/+$/, "");
+    }
+    async function request(method, route, body) {
+        const url = `${await baseUrl()}${route}`;
+        let response;
+        try {
+            response = await fetchWithTimeout(url, {
+                method,
+                headers: body === undefined ? undefined : { "content-type": "application/json" },
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (error) {
+            throw unavailableError(error);
+        }
+        const contentType = response.headers.get("content-type") || "";
+        const payload = contentType.includes("application/json") ? await response.json() : await response.text();
+        if (!response.ok) {
+            const envelope = payload;
+            throw new Error(envelope?.error || `ng-manager server request failed: ${response.status}`);
+        }
+        return unwrap(payload);
+    }
+    return {
+        async availability() {
+            let url;
+            try {
+                url = await baseUrl();
+            }
+            catch (error) {
+                return { available: false, reason: error instanceof Error ? error.message : String(error) };
+            }
+            try {
+                const health = await request("GET", "/health");
+                if (health?.name === "ngm-server" && typeof health.pid === "number") {
+                    return { available: true, url };
+                }
+                return { available: false, url, reason: "health check did not identify ngm-server" };
+            }
+            catch (error) {
+                return { available: false, url, reason: error instanceof Error ? error.message : String(error) };
+            }
+        },
+        refreshTaskProject(projectId) {
+            return request("POST", `/api/tasks/refresh/${encodeURIComponent(projectId)}`);
+        },
+        refreshProjectScripts(projectId) {
+            return request("POST", `/api/projects/refreshScripts/${encodeURIComponent(projectId)}`);
+        },
+        updateProjectRuntime(projectId, runtime) {
+            return request("POST", `/api/projects/${encodeURIComponent(projectId)}/runtime`, { runtime });
+        },
+        listTaskViews(projectId) {
+            return request("GET", `/api/tasks/list/${encodeURIComponent(projectId)}`);
+        },
+        listActiveTasks() {
+            return request("GET", "/api/tasks/active");
+        },
+        startTask(taskId) {
+            return request("POST", "/api/tasks/start", { taskId });
+        },
+        stopTask(taskId) {
+            return request("POST", "/api/tasks/stop", { taskId });
+        },
+        getTaskStatus(taskId) {
+            return request("GET", `/api/tasks/status/${encodeURIComponent(taskId)}`);
+        },
+        getTaskLogTail(runId, tail) {
+            return request("GET", `/api/tasks/log/run/${encodeURIComponent(runId)}?tail=${encodeURIComponent(String(clampTail(tail)))}`);
+        },
+    };
+}

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 {};