426 lines
17 KiB
JavaScript
426 lines
17 KiB
JavaScript
import { createHmac, timingSafeEqual } from "node:crypto";
|
|
|
|
const MCP_PROTOCOL_VERSION = "2025-06-18";
|
|
const MAX_BODY_BYTES = 1024 * 1024;
|
|
|
|
function sendJson(response, statusCode, payload) {
|
|
response.writeHead(statusCode, {
|
|
"cache-control": "no-store",
|
|
"content-type": "application/json; charset=utf-8",
|
|
});
|
|
response.end(JSON.stringify(payload));
|
|
}
|
|
|
|
async function readJsonBody(request, maxBytes = MAX_BODY_BYTES) {
|
|
const chunks = [];
|
|
let size = 0;
|
|
for await (const chunk of request) {
|
|
size += chunk.length;
|
|
if (size > maxBytes) throw new Error("payload_too_large");
|
|
chunks.push(chunk);
|
|
}
|
|
return JSON.parse(Buffer.concat(chunks).toString("utf8"));
|
|
}
|
|
|
|
function timingSafeTokenEqual(left, right) {
|
|
const leftBuffer = Buffer.from(String(left || ""));
|
|
const rightBuffer = Buffer.from(String(right || ""));
|
|
return leftBuffer.length === rightBuffer.length && timingSafeEqual(leftBuffer, rightBuffer);
|
|
}
|
|
|
|
function bearerToken(request) {
|
|
const value = String(request.headers.authorization || "");
|
|
return value.startsWith("Bearer ") ? value.slice("Bearer ".length).trim() : "";
|
|
}
|
|
|
|
function originAllowed(request, allowedOrigins) {
|
|
const origin = String(request.headers.origin || "").trim();
|
|
if (!origin) return true;
|
|
return allowedOrigins.has(origin);
|
|
}
|
|
|
|
function base64UrlJson(value) {
|
|
return Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
|
|
}
|
|
|
|
function parseBase64UrlJson(value) {
|
|
try {
|
|
return JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
function signCapability(encodedPayload, secret) {
|
|
return createHmac("sha256", secret)
|
|
.update(`nodedc.module-foundry.mcp-capability.v1.${encodedPayload}`)
|
|
.digest("base64url");
|
|
}
|
|
|
|
function mintMcpCapability(identity, config) {
|
|
const now = Date.now();
|
|
const payload = {
|
|
schemaVersion: "nodedc.module-foundry.mcp-capability.v1",
|
|
service: "module-foundry",
|
|
actorId: identity.actorId,
|
|
ownerKey: identity.ownerKey,
|
|
issuedAt: now,
|
|
expiresAt: now + config.mcpCapabilityTtlMs,
|
|
};
|
|
const encodedPayload = base64UrlJson(payload);
|
|
return `fnd1.${encodedPayload}.${signCapability(encodedPayload, config.capabilitySecret)}`;
|
|
}
|
|
|
|
function actorFromMcpCapability(token, config) {
|
|
const [prefix, encodedPayload, signature, ...rest] = String(token || "").split(".");
|
|
if (prefix !== "fnd1" || !encodedPayload || !signature || rest.length || !config.capabilitySecret) return null;
|
|
const expectedSignature = signCapability(encodedPayload, config.capabilitySecret);
|
|
if (!timingSafeTokenEqual(signature, expectedSignature)) return null;
|
|
const payload = parseBase64UrlJson(encodedPayload);
|
|
if (!payload || payload.schemaVersion !== "nodedc.module-foundry.mcp-capability.v1" || payload.service !== "module-foundry") return null;
|
|
const actorId = String(payload.actorId || "").trim();
|
|
const ownerKey = String(payload.ownerKey || "").trim();
|
|
const expiresAt = Number(payload.expiresAt);
|
|
const issuedAt = Number(payload.issuedAt);
|
|
if (!actorId || !ownerKey || !Number.isFinite(expiresAt) || !Number.isFinite(issuedAt)) return null;
|
|
if (issuedAt > Date.now() + 60_000 || expiresAt <= Date.now() || expiresAt - issuedAt > config.mcpCapabilityTtlMs + 60_000) return null;
|
|
return { actorId, ownerKey };
|
|
}
|
|
|
|
function mcpError(id, code, message, data) {
|
|
return {
|
|
jsonrpc: "2.0",
|
|
id: id ?? null,
|
|
error: {
|
|
code,
|
|
message,
|
|
...(data === undefined ? {} : { data }),
|
|
},
|
|
};
|
|
}
|
|
|
|
function mcpResult(id, result) {
|
|
return { jsonrpc: "2.0", id: id ?? null, result };
|
|
}
|
|
|
|
function toolText(payload, isError = false) {
|
|
return {
|
|
content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
|
|
structuredContent: payload,
|
|
...(isError ? { isError: true } : {}),
|
|
};
|
|
}
|
|
|
|
function normalizeMcpError(error) {
|
|
const code = String(error?.message || "foundry_operation_failed");
|
|
if (code === "application_not_found") return { code, status: 404 };
|
|
if (code.startsWith("invalid_") || code.startsWith("unknown_") || code.startsWith("map_") || code.endsWith("_required")) return { code, status: 400 };
|
|
if (code.startsWith("duplicate_") || code.includes("conflict") || code.includes("mismatch")) return { code, status: 409 };
|
|
return { code: "foundry_operation_failed", status: 500 };
|
|
}
|
|
|
|
const tools = [
|
|
{
|
|
name: "foundry_status",
|
|
title: "NDC Module Foundry status",
|
|
description: "Read the availability and baseline scope of NDC Module Foundry. Canonical Page Library templates are read-only.",
|
|
inputSchema: { type: "object", additionalProperties: false, properties: {} },
|
|
},
|
|
{
|
|
name: "foundry_list_applications",
|
|
title: "List application instances",
|
|
description: "List editable application instances in NDC Module Foundry. This does not mutate Page Library.",
|
|
inputSchema: { type: "object", additionalProperties: false, properties: {} },
|
|
},
|
|
{
|
|
name: "foundry_get_application",
|
|
title: "Get application instance",
|
|
description: "Read one editable application instance, its page instances, features and map pin bindings.",
|
|
inputSchema: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["applicationId"],
|
|
properties: { applicationId: { type: "string", description: "UUID of an application instance." } },
|
|
},
|
|
},
|
|
{
|
|
name: "foundry_create_application",
|
|
title: "Create application instance",
|
|
description: "Create a draft application instance from a registered page template. The canonical template itself remains unchanged. Application deletion is deliberately unavailable.",
|
|
inputSchema: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["name", "idempotencyKey"],
|
|
properties: {
|
|
name: { type: "string", description: "Human-readable application name." },
|
|
idempotencyKey: { type: "string", description: "Stable key for replay-safe writes." },
|
|
slug: { type: "string" },
|
|
description: { type: "string" },
|
|
templateId: { type: "string", description: "Registered Page Library template id. Defaults to map." },
|
|
templateVersion: { type: "string" },
|
|
theme: { type: "string", enum: ["dark", "light"] },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "foundry_update_application_metadata",
|
|
title: "Update application metadata",
|
|
description: "Rename or describe an application instance. It cannot change canonical templates or delete an application.",
|
|
inputSchema: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["applicationId", "idempotencyKey"],
|
|
properties: {
|
|
applicationId: { type: "string" },
|
|
idempotencyKey: { type: "string" },
|
|
name: { type: "string" },
|
|
slug: { type: "string" },
|
|
description: { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "foundry_add_page_instance",
|
|
title: "Add page instance to application",
|
|
description: "Create one more instance of a registered Page Library template inside an application. A template may be used repeatedly; Page Library remains read-only.",
|
|
inputSchema: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["applicationId", "templateId", "idempotencyKey"],
|
|
properties: {
|
|
applicationId: { type: "string" },
|
|
templateId: { type: "string", description: "Registered Page Library template id." },
|
|
templateVersion: { type: "string" },
|
|
idempotencyKey: { type: "string" },
|
|
title: { type: "string" },
|
|
navigationLabel: { type: "string" },
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "foundry_upsert_map_pin_binding",
|
|
title: "Upsert map pin binding",
|
|
description: "Create or update a visual map-pin binding on a Map Page instance. This stores a stable visual binding; it does not call a provider, Engine or an external data source.",
|
|
inputSchema: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["applicationId", "pageId", "idempotencyKey", "binding"],
|
|
properties: {
|
|
applicationId: { type: "string" },
|
|
pageId: { type: "string", description: "Map Page instance id inside the application." },
|
|
idempotencyKey: { type: "string" },
|
|
binding: {
|
|
type: "object",
|
|
description: "Provider-neutral map-pin binding. Coordinates and source entity are mandatory.",
|
|
required: ["id", "subjectId", "coordinates", "source"],
|
|
properties: {
|
|
id: { type: "string" },
|
|
subjectId: { type: "string" },
|
|
label: { type: "string" },
|
|
status: { type: "string" },
|
|
coordinates: {
|
|
type: "object",
|
|
required: ["longitude", "latitude"],
|
|
properties: {
|
|
longitude: { type: "number" },
|
|
latitude: { type: "number" },
|
|
heightMeters: { type: "number" },
|
|
},
|
|
},
|
|
source: {
|
|
type: "object",
|
|
required: ["entityId"],
|
|
properties: {
|
|
entityId: { type: "string" },
|
|
streamId: { type: "string" },
|
|
displayFields: { type: "array", items: { type: "string" } },
|
|
},
|
|
},
|
|
attributes: { type: "object" },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
{
|
|
name: "foundry_upsert_map_data_product_binding",
|
|
title: "Upsert Map data product binding",
|
|
description: "Bind one approved provider-neutral data product to an entity-stream slot of a Map Page instance. The binding stores no provider transport, endpoint, tenant, connection or credential.",
|
|
inputSchema: {
|
|
type: "object",
|
|
additionalProperties: false,
|
|
required: ["applicationId", "pageId", "idempotencyKey", "binding"],
|
|
properties: {
|
|
applicationId: { type: "string" },
|
|
pageId: { type: "string", description: "Map Page instance id inside the application." },
|
|
idempotencyKey: { type: "string" },
|
|
binding: {
|
|
type: "object",
|
|
required: ["id", "dataProductId", "slotId", "semanticTypes"],
|
|
properties: {
|
|
id: { type: "string" },
|
|
dataProductId: { type: "string", description: "Versioned provider-neutral product, for example fleet.positions.current.v1." },
|
|
slotId: { type: "string", description: "Approved Map Page entity-stream slot." },
|
|
semanticTypes: { type: "array", items: { type: "string" } },
|
|
fieldProjection: { type: "array", items: { type: "string" } },
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
];
|
|
|
|
function toolMap(operations) {
|
|
return {
|
|
foundry_status: () => operations.status(),
|
|
foundry_list_applications: () => operations.listApplications(),
|
|
foundry_get_application: (input) => operations.getApplication(input.applicationId),
|
|
foundry_create_application: (input, actor) => operations.createApplication(input, actor),
|
|
foundry_update_application_metadata: (input, actor) => operations.updateApplicationMetadata(input, actor),
|
|
foundry_add_page_instance: (input, actor) => operations.addPageInstance(input, actor),
|
|
foundry_upsert_map_pin_binding: (input, actor) => operations.upsertMapPinBinding(input, actor),
|
|
foundry_upsert_map_data_product_binding: (input, actor) => operations.upsertMapDataProductBinding(input, actor),
|
|
};
|
|
}
|
|
|
|
export async function handleFoundryMcpRequest(request, response, options) {
|
|
const config = options.getConfig();
|
|
const allowedOrigins = new Set(config.mcpAllowedOrigins || []);
|
|
if (request.method !== "POST") {
|
|
response.writeHead(405, { Allow: "POST" });
|
|
response.end();
|
|
return;
|
|
}
|
|
if (!originAllowed(request, allowedOrigins)) return sendJson(response, 403, { error: "mcp_origin_not_allowed" });
|
|
if (!config.capabilitySecret) return sendJson(response, 503, { error: "foundry_mcp_not_configured" });
|
|
const actor = actorFromMcpCapability(bearerToken(request), config);
|
|
if (!actor) return sendJson(response, 401, { error: "mcp_unauthorized" });
|
|
|
|
let message;
|
|
try {
|
|
message = await readJsonBody(request);
|
|
} catch (error) {
|
|
return sendJson(response, error?.message === "payload_too_large" ? 413 : 400, { error: error?.message === "payload_too_large" ? "payload_too_large" : "invalid_json" });
|
|
}
|
|
if (!message || message.jsonrpc !== "2.0" || typeof message.method !== "string") {
|
|
return sendJson(response, 400, mcpError(message?.id, -32600, "Invalid Request"));
|
|
}
|
|
const id = message.id;
|
|
if (message.method === "initialize") {
|
|
return sendJson(response, 200, mcpResult(id, {
|
|
protocolVersion: MCP_PROTOCOL_VERSION,
|
|
capabilities: { tools: { listChanged: false } },
|
|
serverInfo: { name: "nodedc_module_foundry", version: "0.1.0" },
|
|
instructions: "NDC Module Foundry edits application instances only. Page Library is read-only. Application deletion is unavailable.",
|
|
}));
|
|
}
|
|
if (message.method === "notifications/initialized") return sendJson(response, 202, {});
|
|
if (message.method === "ping") return sendJson(response, 200, mcpResult(id, {}));
|
|
if (message.method === "tools/list") return sendJson(response, 200, mcpResult(id, { tools }));
|
|
if (message.method !== "tools/call") return sendJson(response, 200, mcpError(id, -32601, "Method not found"));
|
|
|
|
const params = message.params && typeof message.params === "object" ? message.params : {};
|
|
const name = String(params.name || "");
|
|
const handler = toolMap(options.operations)[name];
|
|
if (!handler) return sendJson(response, 200, mcpError(id, -32602, "Unknown tool"));
|
|
try {
|
|
const result = await handler(params.arguments && typeof params.arguments === "object" ? params.arguments : {}, actor);
|
|
return sendJson(response, 200, mcpResult(id, toolText(result)));
|
|
} catch (error) {
|
|
const normalized = normalizeMcpError(error);
|
|
return sendJson(response, 200, mcpResult(id, toolText({ error: normalized.code }, true)));
|
|
}
|
|
}
|
|
|
|
function ownerIdentity(owner) {
|
|
const source = owner && typeof owner === "object" ? owner : {};
|
|
const actorId = String(source.userId || source.user_id || source.id || "").trim();
|
|
const ownerKey = String(source.key || source.ownerKey || source.owner_key || actorId).trim();
|
|
const groups = [source.groups, source.roles, source.roleKeys]
|
|
.flatMap((value) => Array.isArray(value) ? value : [])
|
|
.map((value) => String(value || "").trim().toLowerCase())
|
|
.filter(Boolean);
|
|
return { actorId, ownerKey, groups };
|
|
}
|
|
|
|
function hasFoundryAccess(identity, config) {
|
|
if (!identity.actorId || !identity.ownerKey) return false;
|
|
// A Launcher/Authentik block revokes every Foundry surface, including a
|
|
// previously discoverable AI Workspace entitlement.
|
|
if (identity.groups.includes("nodedc:module-foundry:blocked")) return false;
|
|
if (config.allowAllAuthenticated) return true;
|
|
if (config.allowedOwnerIds.includes(identity.actorId) || config.allowedOwnerIds.includes(identity.ownerKey)) return true;
|
|
return identity.groups.some((group) => config.allowedOwnerGroups.includes(group));
|
|
}
|
|
|
|
export async function handleFoundryEntitlementRequest(request, response, options) {
|
|
const config = options.getConfig();
|
|
if (request.method !== "POST") {
|
|
response.writeHead(405, { Allow: "POST" });
|
|
response.end();
|
|
return;
|
|
}
|
|
if (!config.internalAccessToken || !config.capabilitySecret) return sendJson(response, 503, { ok: false, error: "foundry_entitlement_not_configured" });
|
|
if (!timingSafeTokenEqual(bearerToken(request), config.internalAccessToken)) return sendJson(response, 401, { ok: false, error: "entitlement_unauthorized" });
|
|
let body;
|
|
try {
|
|
body = await readJsonBody(request);
|
|
} catch (error) {
|
|
return sendJson(response, error?.message === "payload_too_large" ? 413 : 400, { ok: false, error: "invalid_json" });
|
|
}
|
|
if (body?.schemaVersion !== "ai-workspace.entitlement-request.v1") return sendJson(response, 400, { ok: false, error: "unsupported_entitlement_schema" });
|
|
if (body?.appId !== "module-foundry") return sendJson(response, 400, { ok: false, error: "unsupported_entitlement_app" });
|
|
const identity = ownerIdentity(body.owner);
|
|
const accessAllowed = hasFoundryAccess(identity, config);
|
|
const grantBase = {
|
|
appId: "module-foundry",
|
|
appTitle: "NDC Module Foundry",
|
|
surface: "module-foundry",
|
|
scopes: [
|
|
"foundry.application.read",
|
|
"foundry.application.create",
|
|
"foundry.application.update",
|
|
"foundry.page-instance.create",
|
|
"foundry.map-pin.upsert",
|
|
"foundry.map-data-product.upsert",
|
|
],
|
|
};
|
|
if (!accessAllowed) {
|
|
return sendJson(response, 200, {
|
|
appGrants: {
|
|
"module-foundry": {
|
|
...grantBase,
|
|
enabled: false,
|
|
denied: true,
|
|
reason: "foundry_access_not_granted",
|
|
deniedText: "NDC Module Foundry недоступен в текущем контексте.",
|
|
mcpServers: [],
|
|
},
|
|
},
|
|
});
|
|
}
|
|
if (!config.mcpUrl) return sendJson(response, 503, { ok: false, error: "foundry_mcp_not_configured" });
|
|
const capability = mintMcpCapability(identity, config);
|
|
return sendJson(response, 200, {
|
|
appGrants: {
|
|
"module-foundry": {
|
|
...grantBase,
|
|
enabled: true,
|
|
context: { actorId: identity.actorId },
|
|
mcpServers: [{
|
|
serverName: "nodedc_module_foundry",
|
|
url: config.mcpUrl,
|
|
enabled: true,
|
|
required: false,
|
|
startupTimeoutSec: 20,
|
|
toolTimeoutSec: 60,
|
|
httpHeaders: {
|
|
Authorization: `Bearer ${capability}`,
|
|
"MCP-Protocol-Version": MCP_PROTOCOL_VERSION,
|
|
},
|
|
}],
|
|
},
|
|
},
|
|
});
|
|
}
|