@yinuo-ngm/mcp-server 0.1.1 → 0.1.3

package/lib/tools/hub-v2/client.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HubV2Client = void 0;
+exports.compact = compact;
+exports.compactUndefined = compactUndefined;
+const errors_1 = require("./errors");
+class HubV2Client {
+    constructor(context) {
+        this.context = context;
+    }
+    tokenUrl(suffix, query) {
+        return this.queryUrl("api/token", suffix, query);
+    }
+    personalUrl(suffix, query) {
+        return this.queryUrl("api/personal", suffix, query);
+    }
+    async request(method, url, body, options = {}) {
+        const headers = { Authorization: `Bearer ${this.context.token}` };
+        const init = { method, headers };
+        if (body !== undefined) {
+            headers["Content-Type"] = "application/json";
+            init.body = JSON.stringify(options.preserveNull ? compactUndefined(body) : compact(body));
+        }
+        const response = await fetch(url, init);
+        const text = await response.text();
+        const parsed = parseResponseBody(text);
+        if (!response.ok) {
+            throw (0, errors_1.toHubV2HttpError)(response.status, response.statusText, parsed);
+        }
+        return (parsed ?? { code: "OK", data: null });
+    }
+    async multipart(method, url, body) {
+        const response = await fetch(url, {
+            method,
+            headers: { Authorization: `Bearer ${this.context.token}` },
+            body,
+        });
+        const text = await response.text();
+        const parsed = parseResponseBody(text);
+        if (!response.ok) {
+            throw (0, errors_1.toHubV2HttpError)(response.status, response.statusText, parsed);
+        }
+        return (parsed ?? { code: "OK", data: null });
+    }
+    async raw(method, url) {
+        const response = await fetch(url, {
+            method,
+            headers: { Authorization: `Bearer ${this.context.token}` },
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw (0, errors_1.toHubV2HttpError)(response.status, response.statusText, parseResponseBody(text));
+        }
+        return {
+            content: Buffer.from(await response.arrayBuffer()),
+            contentType: response.headers.get("content-type") ?? "application/octet-stream",
+            contentDisposition: response.headers.get("content-disposition"),
+        };
+    }
+    queryUrl(prefix, suffix, query) {
+        let url = `${this.context.baseUrl}/${prefix}/projects/${encodeURIComponent(this.context.projectKey)}${suffix}`;
+        const queryString = toQueryString(query ?? {});
+        if (queryString) {
+            url += `?${queryString}`;
+        }
+        return url;
+    }
+}
+exports.HubV2Client = HubV2Client;
+function compact(values) {
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (value !== undefined && value !== null && !(Array.isArray(value) && value.length === 0)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function compactUndefined(values) {
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+        if (value !== undefined && !(Array.isArray(value) && value.length === 0)) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function toQueryString(values) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(compact(values))) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                params.append(key, String(item));
+            }
+        }
+        else {
+            params.set(key, String(value));
+        }
+    }
+    return params.toString();
+}
+function parseResponseBody(text) {
+    if (!text.trim()) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}

package/lib/tools/hub-v2/config/config-paths.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveAgentConnectionsPath(): string;
+export declare function configSearchPaths(pathValue?: string): string[];

package/lib/tools/hub-v2/config/config-paths.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAgentConnectionsPath = resolveAgentConnectionsPath;
+exports.configSearchPaths = configSearchPaths;
+const os_1 = require("os");
+const path_1 = require("path");
+const env_1 = require("./env");
+function resolveAgentConnectionsPath() {
+    const envConfig = (0, env_1.envValue)("HUB_V2_CONFIG");
+    if (envConfig) {
+        return (0, path_1.resolve)(envConfig);
+    }
+    return (0, path_1.join)((0, os_1.homedir)(), ".ng-manager", "agent-connections.json");
+}
+function configSearchPaths(pathValue) {
+    return pathValue ? [(0, path_1.resolve)(pathValue)] : [resolveAgentConnectionsPath()];
+}

package/lib/tools/hub-v2/config/env.d.ts

@@ -0,0 +1 @@
+export declare function envValue(...names: string[]): string | undefined;

package/lib/tools/hub-v2/config/env.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envValue = envValue;
+function envValue(...names) {
+    for (const name of names) {
+        const value = process.env[name];
+        if (value !== undefined && value !== null && String(value).trim()) {
+            return String(value).trim();
+        }
+    }
+    return undefined;
+}

package/lib/tools/hub-v2/config/index.d.ts

@@ -0,0 +1,8 @@
+export { resolveAgentConnectionsPath } from "./config-paths";
+export { envValue } from "./env";
+export { loadConfig, normalizeConfig } from "./load-config";
+export type { HubV2Config, HubV2ProjectConfig } from "./load-config";
+export { loadJsonFile, parseJsonObject } from "./jsonc";
+export { getConfiguredProject, listConfiguredProjects } from "./project-selector";
+export { resolveHubV2Context } from "./resolve-context";
+export type { HubV2ResolvedContext, HubV2ResolveOptions } from "./resolve-context";

package/lib/tools/hub-v2/config/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHubV2Context = exports.listConfiguredProjects = exports.getConfiguredProject = exports.parseJsonObject = exports.loadJsonFile = exports.normalizeConfig = exports.loadConfig = exports.envValue = exports.resolveAgentConnectionsPath = void 0;
+var config_paths_1 = require("./config-paths");
+Object.defineProperty(exports, "resolveAgentConnectionsPath", { enumerable: true, get: function () { return config_paths_1.resolveAgentConnectionsPath; } });
+var env_1 = require("./env");
+Object.defineProperty(exports, "envValue", { enumerable: true, get: function () { return env_1.envValue; } });
+var load_config_1 = require("./load-config");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return load_config_1.loadConfig; } });
+Object.defineProperty(exports, "normalizeConfig", { enumerable: true, get: function () { return load_config_1.normalizeConfig; } });
+var jsonc_1 = require("./jsonc");
+Object.defineProperty(exports, "loadJsonFile", { enumerable: true, get: function () { return jsonc_1.loadJsonFile; } });
+Object.defineProperty(exports, "parseJsonObject", { enumerable: true, get: function () { return jsonc_1.parseJsonObject; } });
+var project_selector_1 = require("./project-selector");
+Object.defineProperty(exports, "getConfiguredProject", { enumerable: true, get: function () { return project_selector_1.getConfiguredProject; } });
+Object.defineProperty(exports, "listConfiguredProjects", { enumerable: true, get: function () { return project_selector_1.listConfiguredProjects; } });
+var resolve_context_1 = require("./resolve-context");
+Object.defineProperty(exports, "resolveHubV2Context", { enumerable: true, get: function () { return resolve_context_1.resolveHubV2Context; } });

package/lib/tools/hub-v2/config/jsonc.d.ts

@@ -0,0 +1,5 @@
+export declare function asRecord(value: unknown): Record<string, unknown>;
+export declare function getString(record: Record<string, unknown>, ...keys: string[]): string | undefined;
+export declare function putIfValue(target: Record<string, unknown>, key: string, value: unknown): void;
+export declare function parseJsonObject(content: string): Record<string, unknown>;
+export declare function loadJsonFile(path: string): Record<string, unknown>;

package/lib/tools/hub-v2/config/jsonc.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asRecord = asRecord;
+exports.getString = getString;
+exports.putIfValue = putIfValue;
+exports.parseJsonObject = parseJsonObject;
+exports.loadJsonFile = loadJsonFile;
+const fs_1 = require("fs");
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function getString(record, ...keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value !== undefined && value !== null && String(value).trim()) {
+            return String(value).trim();
+        }
+    }
+    return undefined;
+}
+function putIfValue(target, key, value) {
+    if (value !== undefined && value !== null && String(value).trim()) {
+        target[key] = String(value).trim();
+    }
+}
+function stripJsonComments(input) {
+    let output = "";
+    let inString = false;
+    let stringQuote = "";
+    let escaped = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        const next = input[index + 1];
+        if (inString) {
+            output += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === stringQuote) {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringQuote = char;
+            output += char;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            while (index < input.length && input[index] !== "\n") {
+                index += 1;
+            }
+            output += "\n";
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            index += 2;
+            while (index < input.length && !(input[index] === "*" && input[index + 1] === "/")) {
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        output += char;
+    }
+    return output;
+}
+function parseJsonObject(content) {
+    if (!content.trim()) {
+        return {};
+    }
+    const parsed = JSON.parse(stripJsonComments(content));
+    return asRecord(parsed);
+}
+function loadJsonFile(path) {
+    if (!(0, fs_1.existsSync)(path)) {
+        return {};
+    }
+    return parseJsonObject((0, fs_1.readFileSync)(path, "utf8"));
+}

package/lib/tools/hub-v2/config/load-config.d.ts

@@ -0,0 +1,18 @@
+export type HubV2ProjectConfig = {
+    name?: string;
+    alias?: string;
+    id?: string;
+    base_url?: string;
+    project_key?: string;
+    project_name?: string;
+    project_token?: string;
+    personal_token?: string;
+    source?: string;
+};
+export type HubV2Config = HubV2ProjectConfig & {
+    default_project?: string;
+    projects?: Record<string, HubV2ProjectConfig>;
+};
+export declare function normalizeConfig(rawValue: unknown): HubV2Config;
+export declare function loadConfig(pathValue?: string): HubV2Config;
+export declare function configEnvValue(name: string): string | undefined;

package/lib/tools/hub-v2/config/load-config.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeConfig = normalizeConfig;
+exports.loadConfig = loadConfig;
+exports.configEnvValue = configEnvValue;
+const config_paths_1 = require("./config-paths");
+const env_1 = require("./env");
+const jsonc_1 = require("./jsonc");
+function mergeHubObject(target, value) {
+    const source = (0, jsonc_1.asRecord)(value);
+    (0, jsonc_1.putIfValue)(target, "base_url", (0, jsonc_1.getString)(source, "base_url", "baseUrl"));
+    (0, jsonc_1.putIfValue)(target, "project_key", (0, jsonc_1.getString)(source, "project_key", "projectKey"));
+    (0, jsonc_1.putIfValue)(target, "project_name", (0, jsonc_1.getString)(source, "project_name", "projectName"));
+    (0, jsonc_1.putIfValue)(target, "project_token", (0, jsonc_1.getString)(source, "project_token", "projectToken", "token"));
+    (0, jsonc_1.putIfValue)(target, "personal_token", (0, jsonc_1.getString)(source, "personal_token", "personalToken"));
+    (0, jsonc_1.putIfValue)(target, "source", (0, jsonc_1.getString)(source, "source"));
+    (0, jsonc_1.putIfValue)(target, "default_project", (0, jsonc_1.getString)(source, "default_project", "defaultProject", "project"));
+}
+function mergeEnvObject(target, value) {
+    const env = (0, jsonc_1.asRecord)(value);
+    (0, jsonc_1.putIfValue)(target, "base_url", (0, jsonc_1.getString)(env, "HUB_V2_BASE_URL"));
+    (0, jsonc_1.putIfValue)(target, "project_key", (0, jsonc_1.getString)(env, "HUB_V2_PROJECT_KEY"));
+    (0, jsonc_1.putIfValue)(target, "project_token", (0, jsonc_1.getString)(env, "HUB_V2_PROJECT_TOKEN"));
+    (0, jsonc_1.putIfValue)(target, "personal_token", (0, jsonc_1.getString)(env, "HUB_V2_PERSONAL_TOKEN"));
+    (0, jsonc_1.putIfValue)(target, "source", (0, jsonc_1.getString)(env, "HUB_V2_SOURCE"));
+    (0, jsonc_1.putIfValue)(target, "default_project", (0, jsonc_1.getString)(env, "HUB_V2_PROJECT"));
+}
+function normalizeProject(raw) {
+    const config = normalizeConfig(raw);
+    const record = (0, jsonc_1.asRecord)(raw);
+    (0, jsonc_1.putIfValue)(config, "name", record.name);
+    (0, jsonc_1.putIfValue)(config, "alias", record.alias);
+    (0, jsonc_1.putIfValue)(config, "id", record.id);
+    delete config.projects;
+    delete config.default_project;
+    return config;
+}
+function normalizeProjects(raw) {
+    const value = raw.projects;
+    const projects = {};
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        for (const [name, projectValue] of Object.entries(value)) {
+            const project = normalizeProject(projectValue);
+            const projectName = project.name ?? project.alias ?? name.trim();
+            if (projectName) {
+                projects[projectName] = project;
+            }
+        }
+    }
+    if (Array.isArray(value)) {
+        for (const projectValue of value) {
+            const project = normalizeProject(projectValue);
+            const projectName = project.name ?? project.alias ?? project.id;
+            if (projectName) {
+                projects[projectName] = project;
+            }
+        }
+    }
+    return projects;
+}
+function mergeProjects(...maps) {
+    const merged = {};
+    for (const map of maps) {
+        for (const [name, project] of Object.entries(map)) {
+            merged[name] = { ...(merged[name] ?? {}), ...project };
+        }
+    }
+    return merged;
+}
+function normalizeConfig(rawValue) {
+    const raw = (0, jsonc_1.asRecord)(rawValue);
+    const normalized = {};
+    mergeHubObject(normalized, raw);
+    mergeHubObject(normalized, raw.hubV2);
+    mergeEnvObject(normalized, raw.env);
+    const projects = mergeProjects(normalizeProjects(raw), normalizeProjects((0, jsonc_1.asRecord)(raw.hubV2)));
+    if (Object.keys(projects).length) {
+        normalized.projects = projects;
+    }
+    return normalized;
+}
+function loadConfig(pathValue) {
+    for (const path of (0, config_paths_1.configSearchPaths)(pathValue)) {
+        const config = normalizeConfig((0, jsonc_1.loadJsonFile)(path));
+        if (Object.keys(config).length) {
+            return config;
+        }
+    }
+    return {};
+}
+function configEnvValue(name) {
+    return (0, env_1.envValue)(name);
+}

package/lib/tools/hub-v2/config/project-selector.d.ts

@@ -0,0 +1,5 @@
+import type { HubV2Config, HubV2ProjectConfig, HubV2ResolveOptions } from "./resolve-context";
+export declare function selectedProjectConfig(config: HubV2Config, options: HubV2ResolveOptions): HubV2ProjectConfig;
+export declare function configValue(config: HubV2Config, projectConfig: HubV2ProjectConfig, key: keyof HubV2ProjectConfig): string | undefined;
+export declare function listConfiguredProjects(project?: string, pathValue?: string): Record<string, unknown>;
+export declare function getConfiguredProject(options: HubV2ResolveOptions, pathValue?: string): Record<string, unknown>;

package/lib/tools/hub-v2/config/project-selector.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectedProjectConfig = selectedProjectConfig;
+exports.configValue = configValue;
+exports.listConfiguredProjects = listConfiguredProjects;
+exports.getConfiguredProject = getConfiguredProject;
+const env_1 = require("./env");
+const load_config_1 = require("./load-config");
+function selectedProjectConfig(config, options) {
+    const projects = config.projects ?? {};
+    const entries = Object.entries(projects);
+    if (!entries.length) {
+        return {};
+    }
+    const selected = options.project ?? (0, env_1.envValue)("HUB_V2_PROJECT") ?? config.default_project;
+    if (selected) {
+        const project = projects[selected];
+        if (!project) {
+            throw new Error(`project config not found: ${selected}. Available projects: ${entries.map(([name]) => name).sort().join(", ")}`);
+        }
+        return project;
+    }
+    if (entries.length === 1) {
+        return entries[0][1];
+    }
+    throw new Error(`multiple projects configured; pass project. Available projects: ${entries.map(([name]) => name).sort().join(", ")}`);
+}
+function configValue(config, projectConfig, key) {
+    return projectConfig[key] ?? config[key];
+}
+function projectSummary(name, config, project) {
+    return {
+        name,
+        projectName: project.project_name,
+        projectKey: project.project_key,
+        baseUrl: project.base_url ?? config.base_url,
+        hasProjectToken: Boolean(project.project_token ?? config.project_token),
+        hasPersonalToken: Boolean(project.personal_token ?? config.personal_token),
+        isDefault: name === config.default_project,
+    };
+}
+function listConfiguredProjects(project, pathValue) {
+    const config = (0, load_config_1.loadConfig)(pathValue);
+    const envProjectKey = (0, env_1.envValue)("HUB_V2_PROJECT_KEY") ?? config.project_key;
+    let items;
+    if (envProjectKey) {
+        items = [
+            {
+                name: (0, env_1.envValue)("HUB_V2_PROJECT") ?? config.default_project ?? "default",
+                projectName: config.project_name,
+                projectKey: envProjectKey,
+                baseUrl: (0, env_1.envValue)("HUB_V2_BASE_URL") ?? config.base_url,
+                hasProjectToken: Boolean((0, env_1.envValue)("HUB_V2_PROJECT_TOKEN") ?? config.project_token),
+                hasPersonalToken: Boolean((0, env_1.envValue)("HUB_V2_PERSONAL_TOKEN") ?? config.personal_token),
+                isDefault: true,
+            },
+        ];
+    }
+    else {
+        const projects = config.projects ?? {};
+        items = Object.entries(projects).map(([name, item]) => projectSummary(name, config, item));
+    }
+    const filtered = project
+        ? items.filter((item) => item.name === project || item.projectName === project || item.projectKey === project)
+        : items;
+    return {
+        items: filtered,
+        total: filtered.length,
+    };
+}
+function getConfiguredProject(options, pathValue) {
+    const config = (0, load_config_1.loadConfig)(pathValue);
+    const selected = options.project ?? options.projectKey ?? (0, env_1.envValue)("HUB_V2_PROJECT") ?? config.default_project;
+    if (selected) {
+        const projects = listConfiguredProjects(selected, pathValue).items;
+        if (projects.length === 1) {
+            return projects[0];
+        }
+        if (!projects.length) {
+            throw new Error("Hub V2 project config not found");
+        }
+        throw new Error("multiple Hub V2 project configs matched");
+    }
+    const projects = listConfiguredProjects(options.project ?? options.projectKey, pathValue).items;
+    if (projects.length === 1) {
+        return projects[0];
+    }
+    if (!projects.length) {
+        throw new Error("Hub V2 project config not found");
+    }
+    throw new Error("multiple Hub V2 project configs matched");
+}

package/lib/tools/hub-v2/config/resolve-context.d.ts

@@ -0,0 +1,13 @@
+export type { HubV2Config, HubV2ProjectConfig } from "./load-config";
+export type HubV2ResolveOptions = {
+    project?: string;
+    projectKey?: string;
+};
+export type HubV2ResolvedContext = {
+    baseUrl: string;
+    projectKey: string;
+    token: string;
+    source: string;
+};
+type TokenKind = "project" | "personal";
+export declare function resolveHubV2Context(options: HubV2ResolveOptions, tokenKind: TokenKind, pathValue?: string): HubV2ResolvedContext;

package/lib/tools/hub-v2/config/resolve-context.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHubV2Context = resolveHubV2Context;
+const env_1 = require("./env");
+const load_config_1 = require("./load-config");
+const project_selector_1 = require("./project-selector");
+function resolveHubV2Context(options, tokenKind, pathValue) {
+    const config = (0, load_config_1.loadConfig)(pathValue);
+    const projectConfig = (0, project_selector_1.selectedProjectConfig)(config, options);
+    const baseUrl = ((0, env_1.envValue)("HUB_V2_BASE_URL") ??
+        (0, project_selector_1.configValue)(config, projectConfig, "base_url"))?.replace(/\/+$/, "");
+    const projectKey = options.projectKey ??
+        (0, env_1.envValue)("HUB_V2_PROJECT_KEY") ??
+        (0, project_selector_1.configValue)(config, projectConfig, "project_key");
+    const projectToken = (0, env_1.envValue)("HUB_V2_PROJECT_TOKEN") ??
+        (0, project_selector_1.configValue)(config, projectConfig, "project_token");
+    const personalToken = (0, env_1.envValue)("HUB_V2_PERSONAL_TOKEN") ??
+        (0, project_selector_1.configValue)(config, projectConfig, "personal_token");
+    const source = (0, env_1.envValue)("HUB_V2_SOURCE") ??
+        (0, project_selector_1.configValue)(config, projectConfig, "source") ??
+        "ngm-mcp";
+    if (!baseUrl) {
+        throw new Error("HUB_V2_BASE_URL is required");
+    }
+    if (!projectKey) {
+        throw new Error("HUB_V2_PROJECT_KEY is required");
+    }
+    const token = tokenKind === "project" ? projectToken : personalToken;
+    if (!token) {
+        throw new Error(tokenKind === "project" ? "HUB_V2_PROJECT_TOKEN is required" : "HUB_V2_PERSONAL_TOKEN is required");
+    }
+    return { baseUrl, projectKey, token, source };
+}

package/lib/tools/hub-v2/docs.tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpToolDefinition } from "../index";
+export declare function hubV2DocsTools(): McpToolDefinition[];