385 lines
38 KiB
TypeScript
385 lines
38 KiB
TypeScript
import { MCP_REQUEST_MONITOR_PROJECTION } from "../modules/mcp/request-monitor-projection.js"
|
|
import { humanIpsecUserBundleMetadata, readHumanIpsecUserBundleArtifact } from "../modules/mcp/ipsec-user-create-artifact.js"
|
|
import { humanIpsecExistingCertificateExportMetadata, readHumanIpsecExistingCertificateExportArtifact } from "../services/ipsec-existing-certificate-export-artifact.js"
|
|
import type { createIpsecExistingCertificateExportArtifactStore } from "../services/ipsec-existing-certificate-export-artifact.js"
|
|
import type { FastifyPluginAsync } from "fastify"
|
|
import { z } from "zod"
|
|
import { randomUUID, createHash } from "node:crypto"
|
|
import { mcpCatalogResponseSchema, mcpConnectionCreateSchema, mcpPageQuerySchema, mcpPolicyPreviewRequestSchema, mcpPolicyPreviewResponseSchema, mcpSettingsPatchSchema, mcpTemporaryGrantSchema } from "@mmapp/contracts/mcp"
|
|
import { mcpProtectionCreateRequestSchema } from "../modules/mcp/protection-requests.js"
|
|
import { env } from "../config.js"
|
|
import { requireAuth } from "../plugins/auth.js"
|
|
import { listMcpOperations, findMcpOperation } from "../modules/mcp/registry.js"
|
|
import { evaluateMcpPolicy } from "../modules/mcp/policy.js"
|
|
import { listActions } from "../modules/mcp/actions.js"
|
|
import { pool } from "../db/index.js"
|
|
import { hasPermission, type AuthUser } from "../lib/permissions.js"
|
|
import { accessGeneration, decryptSecret, encryptSecret, McpError, randomToken, redact, tokenDigest } from "../modules/mcp/security.js"
|
|
import { createMcpConnection, listMcpConnections, getMcpSettings, updateMcpSettings, getConnection, assertConnectionVisible, rotateConnectionToken, setConnectionStatus, updateMcpConnection, transaction, audit } from "../modules/mcp/store.js"
|
|
import { approvePlan, loadPlan, publicPlan } from "../modules/mcp/runtime.js"
|
|
import { applyPlan, invokeMcpTool } from "../modules/mcp/runtime.js"
|
|
import { routeAiProfileSchema } from "@mmapp/contracts/mcp-routing"
|
|
import { revalidateMcpOwner } from "../modules/mcp/store.js"
|
|
import { resourceById } from "../modules/mcp/resources.js"
|
|
import { registerManagementChannel } from "../modules/mcp/management.js"
|
|
import { MAX_RESTORE_ARCHIVE_BYTES, uploadRestoreArchive, readRestoreReceipt, readRestoreReceiptAuditStatus } from "../modules/mcp/database-restore.js"
|
|
import { assertPortalClaimsCurrent } from "../modules/mcp/portal-revocation.js"
|
|
import { readFile } from "node:fs/promises"
|
|
import { checkMcpProtocol, type ProtocolProbe } from "../modules/mcp/readiness.js"
|
|
import { humanBackupDownloadMetadata, readHumanBackupDownloadArtifact } from "../modules/mcp/backup-download-artifact.js"
|
|
import { humanDatabaseBackupMetadata, readHumanDatabaseBackupArtifact } from "../modules/mcp/database-backup-artifact.js"
|
|
import { humanWireguardExportMetadata, readHumanWireguardExportArtifact } from "../modules/mcp/wireguard-export-artifact.js"
|
|
import { humanArtifactReceipts } from "../modules/mcp/human-artifact-receipts.js"
|
|
import { readHumanHostFilesArtifact } from "../modules/mcp/host-files-artifact.js"
|
|
import { loadLogExportArtifactMetadata } from "../modules/mcp/log-artifacts.js"
|
|
import { readServerPollCapacity } from "../services/server-poll-capacity.js"
|
|
import { connectProbeStorage } from "../services/server-probe-storage-connection.js"
|
|
|
|
const uuid = z.string().uuid()
|
|
const deviceResource = z.enum(["ethernet", "bridge", "bridge_port", "bridge_vlan", "vlan", "ipv4_address", "ipv6_address", "vrf"])
|
|
const devicePlanCommon = { connectionId: uuid, fields: z.record(z.string(), z.unknown()).default({}) }
|
|
export const mcpDevicePlanBodySchema = z.discriminatedUnion("action", [
|
|
z.object({ ...devicePlanCommon, action: z.literal("create") }).strict(),
|
|
z.object({ ...devicePlanCommon, action: z.literal("update"), id: z.string().min(1).max(200).optional() }).strict(),
|
|
z.object({ ...devicePlanCommon, action: z.literal("delete"), id: z.string().min(1).max(200).optional() }).strict(),
|
|
])
|
|
export function mcpDevicePlanArguments(serverId: number, input: z.infer<typeof mcpDevicePlanBodySchema>) {
|
|
return { serverId, ...(input.action === "create" ? {} : { id: input.id }), fields: input.fields }
|
|
}
|
|
const idOf = (params: unknown) => z.object({ id: uuid }).parse(params).id
|
|
const actorOf = (actor?: AuthUser) => { if (!actor) throw new McpError("UNAUTHORIZED", "Требуется вход", 401); return actor }
|
|
async function pollCapacityForPortal(ownerId:string,admin:boolean){
|
|
const options={deadlineAt:Date.now()+3000}
|
|
let connection:Awaited<ReturnType<typeof connectProbeStorage>>|undefined
|
|
try{
|
|
connection=await connectProbeStorage(options)
|
|
return await readServerPollCapacity({query:(text,values)=>connection!.query(text,values,{timeoutMs:Math.max(1,options.deadlineAt-Date.now())})},ownerId,admin)
|
|
}catch{return {status:"unavailable" as const}}
|
|
finally{connection?.release()}
|
|
}
|
|
/** Only the delegated MCP identity failed; the human JWT/claims hooks ran outside.
|
|
* Never translate OWNER_CLAIMS_REVOKED or another authentication failure. */
|
|
async function ownerDelegate<T>(work: () => Promise<T>): Promise<T> {
|
|
try { return await work() }
|
|
catch (error) {
|
|
if (error instanceof McpError && error.code === "UNAUTHORIZED" && error.statusCode === 401)
|
|
throw new McpError("PERMISSION_DENIED", "Допуск MCP подключения недоступен", 403)
|
|
throw error
|
|
}
|
|
}
|
|
async function ownerPrincipal(connectionId: string, actor: AuthUser, operationId: string) {
|
|
const connection = await getConnection(connectionId)
|
|
if (connection.owner_id !== actor.id) throw new McpError("PERMISSION_DENIED", "Выполнение из web UI доступно владельцу подключения")
|
|
const action = listActions().find(action => action.operation.id === operationId)
|
|
if (!action || action.operation.requiredPermissions.some(permission => !hasPermission(actor.permissions, permission))) throw new McpError("PERMISSION_DENIED", "Текущий пользователь не имеет права выполнить операцию")
|
|
// Fixed UI actions use the connection's existing access without exposing credentials.
|
|
const { rows: [credential] } = await pool.query(`SELECT c.id,c.expires_at FROM mcp_credentials c WHERE c.connection_id=$1 AND c.kind='bearer'
|
|
AND c.revoked_at IS NULL AND c.expires_at>now() AND NOT EXISTS(SELECT 1 FROM mcp_grants g WHERE g.payload->>'credentialId'=c.id::text)
|
|
ORDER BY c.created_at DESC LIMIT 1`, [connectionId])
|
|
if (!credential) throw new McpError("PERMISSION_DENIED", "У подключения нет действующего основного допуска", 403)
|
|
return { connectionId, credentialId: credential.id, credentialExpiresAt: credential.expires_at.toISOString() }
|
|
}
|
|
|
|
/** Human administration and fixed owner UI actions; never a generic RouterOS proxy. */
|
|
export function createMcpRoutes(checkClaims = assertPortalClaimsCurrent, options: { existingCertificateArtifact?: Pick<ReturnType<typeof createIpsecExistingCertificateExportArtifactStore>, "metadata" | "read"> } = {}): FastifyPluginAsync {
|
|
const existingCertificateArtifact = options.existingCertificateArtifact ?? { metadata: humanIpsecExistingCertificateExportMetadata, read: readHumanIpsecExistingCertificateExportArtifact }
|
|
return async app => {
|
|
app.addContentTypeParser("application/octet-stream", { parseAs: "buffer", bodyLimit: MAX_RESTORE_ARCHIVE_BYTES }, (_request, body, done) => done(null, body))
|
|
app.setErrorHandler((error, request, reply) => {
|
|
if (error instanceof z.ZodError) return reply.code(400).send({ error: "Некорректные параметры MCP", code: "INVALID_INPUT", details: error.flatten() })
|
|
if (error instanceof McpError) return reply.code(error.statusCode).send({ error: error.message, code: error.code })
|
|
request.log.error({ error: redact(error instanceof Error ? error.message : error) }, "MCP administration failed")
|
|
return reply.code(503).send({ error: "Хранилище MCP или аудит недоступны", code: "AUDIT_UNAVAILABLE" })
|
|
})
|
|
app.addHook("onRequest", async (request, reply) => {
|
|
if (!env.authRequired) return reply.code(503).send({ error: "Для управления MCP включите проверку входа через портал" })
|
|
// Explicit guard: these routes must stay protected if the global API hook changes.
|
|
await requireAuth(request, reply)
|
|
if (reply.sent) return
|
|
await checkClaims(actorOf(request.authUser))
|
|
if (request.headers.origin && request.headers.origin !== env.CORS_ORIGIN) return reply.code(403).send({ error: "Недопустимый Origin" })
|
|
})
|
|
|
|
app.post("/mcp/database/archives", { bodyLimit: MAX_RESTORE_ARCHIVE_BYTES }, async request => uploadRestoreArchive(request.body as Buffer, actorOf(request.authUser)))
|
|
app.get("/mcp/database/receipts/:id", async request => readRestoreReceipt(idOf(request.params), actorOf(request.authUser)))
|
|
app.get("/mcp/database/receipts/:id/audit-status", async request => readRestoreReceiptAuditStatus(idOf(request.params), actorOf(request.authUser)))
|
|
app.post("/mcp/database/plan", async request => {
|
|
const { connectionId, archiveRef, expectedSha256 } = z.object({ connectionId: uuid, archiveRef: uuid, expectedSha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict().parse(request.body)
|
|
const actor = actorOf(request.authUser)
|
|
return ownerDelegate(async () => invokeMcpTool(await ownerPrincipal(connectionId, actor, "database.restore"), "mm_database_restore_plan", { archiveRef, expectedSha256 }))
|
|
})
|
|
app.get("/mcp/catalog", async () => mcpCatalogResponseSchema.parse({
|
|
stage: "runtime", executionAvailable: true, operations: listMcpOperations(),
|
|
}))
|
|
app.get("/mcp/coverage", async () => JSON.parse(await readFile(new URL("../../mcp-coverage.json", import.meta.url), "utf8")))
|
|
app.get("/mcp/management-channels", async () => ({ channels: (await pool.query("SELECT id,server_id,created_by,attestation,expires_at,verified_at,revoked_at FROM mcp_management_channels ORDER BY server_id")).rows }))
|
|
app.post("/mcp/management-channels", async request => registerManagementChannel(request.body, actorOf(request.authUser)))
|
|
app.delete("/mcp/management-channels/:id", async request => {
|
|
const actor = actorOf(request.authUser), id = idOf(request.params)
|
|
await transaction(async db => {
|
|
await db.query("UPDATE mcp_management_channels SET revoked_at=now() WHERE id=$1", [id])
|
|
await audit(db, actor.id, "management.revoke", null, { channelId: id })
|
|
}); return { ok: true }
|
|
})
|
|
|
|
app.post("/mcp/policy/preview", async (request, reply) => {
|
|
const parsed = mcpPolicyPreviewRequestSchema.safeParse(request.body)
|
|
if (!parsed.success) return reply.code(400).send({ error: "Некорректные параметры симуляции политики MCP", details: parsed.error.flatten() })
|
|
const now = new Date()
|
|
return mcpPolicyPreviewResponseSchema.parse({
|
|
simulation: true,
|
|
executionAvailable: false,
|
|
evaluatedAt: now.toISOString(),
|
|
policyVersion: parsed.data.policy.version,
|
|
result: evaluateMcpPolicy(parsed.data, now),
|
|
})
|
|
})
|
|
|
|
app.get("/mcp/connections", async request => ({ connections: await listMcpConnections(actorOf(request.authUser)) }))
|
|
app.post("/mcp/connections", async request => {
|
|
const input = mcpConnectionCreateSchema.parse(request.body)
|
|
const available = new Set(listActions().map(action => action.operation.id))
|
|
if (input.scope.operationIds.some(id => !available.has(id))) throw new McpError("UNKNOWN_OPERATION", "Можно выдать только реализованные операции", 400)
|
|
return createMcpConnection(input, actorOf(request.authUser))
|
|
})
|
|
app.put("/mcp/connections/:id", async request => {
|
|
const input = mcpConnectionCreateSchema.parse(request.body), available = new Set(listActions().map(action => action.operation.id))
|
|
if (input.scope.operationIds.some(id => !available.has(id))) throw new McpError("UNKNOWN_OPERATION", "Можно выдать только реализованные операции", 400)
|
|
return updateMcpConnection(idOf(request.params), input, actorOf(request.authUser))
|
|
})
|
|
app.post("/mcp/connections/:id/status", async request => {
|
|
await setConnectionStatus(idOf(request.params), z.object({ status: z.enum(["active", "paused", "revoked"]) }).strict().parse(request.body).status, actorOf(request.authUser)); return { ok: true }
|
|
})
|
|
app.post("/mcp/connections/:id/rotate", async request => rotateConnectionToken(idOf(request.params), actorOf(request.authUser)))
|
|
app.post("/mcp/connections/:id/revalidate", async request => revalidateMcpOwner(idOf(request.params), actorOf(request.authUser)))
|
|
app.get("/mcp/devices/catalog", async request => {
|
|
const { connectionId } = z.object({ connectionId: uuid }).strict().parse(request.query), actor = actorOf(request.authUser), connection = await getConnection(connectionId)
|
|
if (connection.owner_id !== actor.id) throw new McpError("PERMISSION_DENIED", "Выберите своё подключение")
|
|
const servers = (await pool.query("SELECT id,name,host,enabled FROM servers WHERE id=ANY($1::bigint[]) ORDER BY name LIMIT 1000", [connection.policy.scope.serverIds])).rows
|
|
const resources = deviceResource.options.map(id => {
|
|
const resource = resourceById(id), json = z.toJSONSchema(resource.fields, { io: "input" })
|
|
const allowed = (action: string) => connection.policy.scope.operationIds.includes(`ros.${id}.${action}`) && hasPermission(actor.permissions, resource.permission + (action === "list" ? ":read" : ":write")) && (action === "list" || connection.policy.mode !== "observer")
|
|
const fields = Object.entries(json.properties ?? {}).map(([key, property]) => {
|
|
const schema = property as { type?: string; enum?: string[]; minimum?: number; maximum?: number; minLength?: number; maxLength?: number }
|
|
return { key, type: schema.type === "boolean" ? "boolean" : ["number", "integer"].includes(schema.type ?? "") ? "number" : "string", ...(schema.enum ? { options: schema.enum } : {}), min: schema.minimum, max: schema.maximum, maxLength: schema.maxLength, requiredOnCreate: resource.requiredOnCreate?.includes(key) ?? false }
|
|
})
|
|
return { id, title: resource.title, fields, read: allowed("list"), create: resource.create && allowed("create"), update: allowed("update"), delete: resource.remove && allowed("delete") }
|
|
}).filter(resource => resource.read || resource.create || resource.update || resource.delete)
|
|
return { servers, resources }
|
|
})
|
|
app.get("/mcp/devices/:serverId/:resource", async request => {
|
|
const params = z.object({ serverId: z.coerce.number().int().positive(), resource: deviceResource }).parse(request.params)
|
|
const query = z.object({ connectionId: uuid, offset: z.coerce.number().int().min(0).max(1000000).default(0) }).strict().parse(request.query)
|
|
const principal = await ownerPrincipal(query.connectionId, actorOf(request.authUser), `ros.${params.resource}.list`)
|
|
return ownerDelegate(async () => invokeMcpTool(principal, `mm_${params.resource}_list`, { serverId: params.serverId, limit: 100, offset: query.offset }))
|
|
})
|
|
app.post("/mcp/devices/:serverId/:resource/plan", async request => {
|
|
const params = z.object({ serverId: z.coerce.number().int().positive(), resource: deviceResource }).parse(request.params)
|
|
const input = mcpDevicePlanBodySchema.parse(request.body)
|
|
const actor = actorOf(request.authUser), principal = await ownerPrincipal(input.connectionId, actor, `ros.${params.resource}.${input.action}`)
|
|
await audit(pool, actor.id, "device.web.plan", input.connectionId, { serverId: params.serverId, resource: params.resource, action: input.action, objectId: input.action === "create" ? null : input.id ?? null })
|
|
return ownerDelegate(async () => invokeMcpTool(principal, `mm_${params.resource}_${input.action}_plan`, mcpDevicePlanArguments(params.serverId, input)))
|
|
})
|
|
app.get("/mcp/settings", async () => getMcpSettings())
|
|
app.put("/mcp/settings", async request => updateMcpSettings(mcpSettingsPatchSchema.parse(request.body), actorOf(request.authUser)))
|
|
app.post("/mcp/pause", async request => { await updateMcpSettings({ enabled: false }, actorOf(request.authUser)); return { ok: true } })
|
|
app.post("/mcp/stop-automation", async request => {
|
|
const actor = actorOf(request.authUser)
|
|
await transaction(async client => {
|
|
await client.query("UPDATE mcp_settings SET enabled=false,updated_at=now() WHERE id=1")
|
|
await client.query("UPDATE mcp_routing_profiles SET enabled=false,state=state || '{\"pausedReason\":\"Аварийная остановка автоматических изменений\"}'::jsonb,updated_at=now() WHERE enabled")
|
|
await audit(client, actor.id, "automation.emergency-stop", null, {})
|
|
}); return { ok: true }
|
|
})
|
|
app.get("/mcp/overview", async request => {
|
|
const actor = actorOf(request.authUser), admin = hasPermission(actor.permissions, "mm:mcp:admin")
|
|
const { rows: [summary] } = await pool.query(`SELECT
|
|
(SELECT count(*)::int FROM mcp_connections WHERE ($1::boolean OR owner_id=$2) AND policy->>'status'='active') AS connections,
|
|
(SELECT count(*)::int FROM mcp_requests r JOIN mcp_connections c ON c.id=r.connection_id WHERE ($1::boolean OR c.owner_id=$2) AND r.created_at>now()-interval '24 hours') AS calls,
|
|
(SELECT count(*)::int FROM mcp_requests r JOIN mcp_connections c ON c.id=r.connection_id WHERE ($1::boolean OR c.owner_id=$2) AND r.created_at>now()-interval '24 hours' AND r.status IN ('error','denied')) AS errors,
|
|
(SELECT count(*)::int FROM mcp_plans p JOIN mcp_connections c ON c.id=p.connection_id WHERE ($1::boolean OR c.owner_id=$2) AND p.state='awaiting-approval' AND p.expires_at>now()) AS approvals,
|
|
(SELECT count(*)::int FROM mcp_operations o JOIN mcp_connections c ON c.id=o.connection_id WHERE ($1::boolean OR c.owner_id=$2) AND o.state IN ('running','pending')) AS running`, [admin, actor.id])
|
|
return { ...summary, pollStorageCapacity:await pollCapacityForPortal(actor.id,admin), enabled: (await getMcpSettings()).enabled, observedAt: new Date().toISOString() }
|
|
})
|
|
for (const table of ["requests", "plans", "operations", "audit", "drift"] as const) {
|
|
app.get(`/mcp/${table}`, async request => {
|
|
const actor = actorOf(request.authUser), query = mcpPageQuerySchema.parse(request.query), admin = hasPermission(actor.permissions, "mm:mcp:admin")
|
|
const relation = "mcp_" + table, values: unknown[] = [admin, actor.id]
|
|
const owner = table === "drift" ? "EXISTS(SELECT 1 FROM mcp_operations o JOIN mcp_connections c ON c.id=o.connection_id WHERE o.id=r.operation_id AND c.owner_id=$2)" : "EXISTS(SELECT 1 FROM mcp_connections c WHERE c.id=r.connection_id AND c.owner_id=$2)"
|
|
const clauses = [`($1::boolean OR ${owner})`]
|
|
const bind = (value: unknown) => { values.push(value); return "$" + values.length }
|
|
if (query.connectionId && table !== "drift") clauses.push(`r.connection_id=${bind(query.connectionId)}::uuid`)
|
|
if (query.status && ["requests", "plans", "operations"].includes(table)) clauses.push(`r.${table === "requests" ? "status" : "state"}=${bind(query.status)}`)
|
|
if (query.tool && table === "requests") clauses.push(`r.tool=${bind(query.tool)}`)
|
|
if (query.userId && ["requests", "audit"].includes(table)) clauses.push(`r.actor_id=${bind(query.userId)}`)
|
|
if (query.serverId && table === "requests") clauses.push(`${bind(query.serverId)}::bigint=ANY(r.server_ids)`)
|
|
const dateField = table === "drift" ? "detected_at" : "created_at"
|
|
if (query.from) clauses.push(`r.${dateField}>=${bind(query.from)}::timestamptz`)
|
|
if (query.to) clauses.push(`r.${dateField}<=${bind(query.to)}::timestamptz`)
|
|
if (query.cursor) {
|
|
const valid = table === "audit" ? /^[1-9]\d{0,18}$/.test(query.cursor) : z.string().uuid().safeParse(query.cursor).success
|
|
if (!valid) throw new McpError("INVALID_CURSOR", "Некорректный курсор страницы", 400)
|
|
clauses.push(`(r.${dateField},r.id)<(SELECT ${dateField},id FROM ${relation} WHERE id=${bind(query.cursor)}::${table === "audit" ? "bigint" : "uuid"})`)
|
|
}
|
|
const count = await pool.query<{ total: number }>(`SELECT count(*)::int AS total FROM ${relation} r WHERE ${clauses.join(" AND ")}`, values)
|
|
const { rows } = await pool.query(`SELECT ${table === "requests" ? MCP_REQUEST_MONITOR_PROJECTION : "r.*"} FROM ${relation} r WHERE ${clauses.join(" AND ")} ORDER BY r.${dateField} DESC,r.id DESC LIMIT ${bind(query.limit + 1)}`, values)
|
|
const entries = rows.slice(0, query.limit)
|
|
const receipts = table === "operations" ? await humanArtifactReceipts(entries, actor, { query: (sql, values) => pool.query(sql, values), authorize: (id, actor, kind) => kind === "ipsec-existing-certificate-bundle" ? existingCertificateArtifact.metadata(id, actor, checkClaims) : kind === "ipsec-user-bundle" ? humanIpsecUserBundleMetadata(id, actor, checkClaims) : kind === "wireguard-export" ? humanWireguardExportMetadata(id, actor, checkClaims) : kind === "database-backup" ? humanDatabaseBackupMetadata(id, actor, checkClaims) : humanBackupDownloadMetadata(id, actor, checkClaims), checkClaims }) : new Map()
|
|
return { items: table === "plans" ? await Promise.all(entries.map(row => publicPlan(row as Awaited<ReturnType<typeof loadPlan>>))) : entries.map(row => table === "operations" ? { ...redact(row) as Record<string, unknown>, artifactReceipts: (receipts.get(row.id) ?? []).map((receipt: { artifactId: string }) => ({ ...receipt, downloadPath: `/api/mcp/artifacts/${receipt.artifactId}` })) } : redact(row)), total: count.rows[0].total, nextCursor: rows.length > query.limit ? String(entries.at(-1)?.id) : null }
|
|
})
|
|
}
|
|
app.get("/mcp/plans/:id", async request => {
|
|
const plan = await loadPlan(idOf(request.params)); assertConnectionVisible(await getConnection(plan.connection_id), actorOf(request.authUser)); return publicPlan(plan)
|
|
})
|
|
app.post("/mcp/plans/:id/decision", async request => { await approvePlan(idOf(request.params), actorOf(request.authUser), z.object({ approve: z.boolean() }).strict().parse(request.body).approve); return { ok: true } })
|
|
for (const action of ["recover", "reconcile"] as const) app.post(`/mcp/operations/:id/${action}`, async request => {
|
|
const id = idOf(request.params), actor = actorOf(request.authUser)
|
|
const { rows: [operation] } = await pool.query("SELECT o.connection_id,p.operation_id FROM mcp_operations o JOIN mcp_plans p ON p.id=o.plan_id WHERE o.id=$1", [id])
|
|
if (!operation) throw new McpError("NOT_FOUND", "Операция не найдена", 404)
|
|
const globalReconcile = action === "reconcile" && findMcpOperation(operation.operation_id)?.scope === "global"
|
|
const principal = await ownerPrincipal(operation.connection_id, actor, action === "recover" ? "operations.recover" : globalReconcile ? "operations.global.reconcile" : "operations.reconcile")
|
|
return ownerDelegate(async () => invokeMcpTool(principal, action === "recover" ? "mm_operation_recovery_plan" : globalReconcile ? "mm_global_operation_reconcile" : "mm_operation_reconcile", { operationId: id }))
|
|
})
|
|
app.post("/mcp/plans/:id/apply", async request => {
|
|
const plan = await loadPlan(idOf(request.params)), actor = actorOf(request.authUser)
|
|
const principal = await ownerPrincipal(plan.connection_id, actor, plan.operation_id)
|
|
await audit(pool, actor.id, "plan.web.apply", plan.connection_id, { planId: plan.id })
|
|
return ownerDelegate(async () => applyPlan(principal, plan.id, `web:${plan.id}`))
|
|
})
|
|
app.get("/mcp/protections", async request => {
|
|
const actor = actorOf(request.authUser)
|
|
return { protections: (await pool.query(`SELECT p.* FROM mcp_protections p WHERE $1::boolean OR p.created_by=$2 OR EXISTS(
|
|
SELECT 1 FROM mcp_connections c WHERE c.owner_id=$2 AND c.policy->'scope'->'serverIds' @> jsonb_build_array((p.object_ref->>'serverId')::bigint)) ORDER BY p.created_at DESC LIMIT 1000`, [hasPermission(actor.permissions, "mm:mcp:admin"), actor.id])).rows }
|
|
})
|
|
app.post("/mcp/protections", async request => {
|
|
const input = mcpProtectionCreateRequestSchema.parse(request.body), actor = actorOf(request.authUser), id = randomUUID()
|
|
await transaction(async client => { await client.query("INSERT INTO mcp_protections(id,object_ref,reason,created_by) VALUES($1,$2::jsonb,$3,$4)", [id, JSON.stringify(input.object), input.reason, actor.id]); await audit(client, actor.id, "protection.create", null, input) })
|
|
return { id }
|
|
})
|
|
app.delete("/mcp/protections/:id", async request => { const id = idOf(request.params); await transaction(async client => { await client.query("DELETE FROM mcp_protections WHERE id=$1", [id]); await audit(client, actorOf(request.authUser).id, "protection.delete", null, { id }) }); return { ok: true } })
|
|
app.post("/mcp/connections/:id/grants", async request => {
|
|
const connectionId = idOf(request.params)
|
|
const input = mcpTemporaryGrantSchema.parse(request.body), connection = await getConnection(connectionId), actor = actorOf(request.authUser)
|
|
assertConnectionVisible(connection, actor)
|
|
if (Date.parse(input.expiresAt) <= Date.now() || connection.policy.status !== "active" || connection.generation !== await accessGeneration()) throw new McpError("GRANT_INACTIVE", "Подключение или временный доступ недействительны", 400)
|
|
if (input.scope.operationIds.some(id => !connection.policy.scope.operationIds.includes(id)) || input.scope.serverIds.some(id => !connection.policy.scope.serverIds.includes(id)) || input.scope.allowGlobal && !connection.policy.scope.allowGlobal || Date.parse(input.expiresAt) > Math.min(Date.parse(connection.policy.expiresAt), connection.owner_valid_until.getTime())) throw new McpError("PERMISSION_DENIED", "Временный доступ не может расширять основной доступ и срок подтверждённых прав владельца")
|
|
const credentialId = randomUUID(), token = randomToken("bearer")
|
|
await transaction(async client => {
|
|
await client.query("INSERT INTO mcp_credentials(id,connection_id,digest,kind,expires_at) VALUES($1,$2,$3,'bearer',$4)", [credentialId, connectionId, tokenDigest(token), input.expiresAt])
|
|
await client.query("INSERT INTO mcp_grants(id,connection_id,payload) VALUES($1,$2,$3::jsonb)", [randomUUID(), connectionId, JSON.stringify({ ...input, credentialId })])
|
|
await audit(client, actor.id, "grant.create", connectionId, input)
|
|
})
|
|
return { token, expiresAt: input.expiresAt }
|
|
})
|
|
app.get("/mcp/connections/:id/grants", async request => {
|
|
const connection = await getConnection(idOf(request.params)); assertConnectionVisible(connection, actorOf(request.authUser))
|
|
return { grants: (await pool.query("SELECT id,payload-'credentialId' AS grant,revoked_at FROM mcp_grants WHERE connection_id=$1 ORDER BY payload->>'expiresAt' DESC LIMIT 200", [connection.id])).rows }
|
|
})
|
|
app.delete("/mcp/grants/:id", async request => {
|
|
const id = idOf(request.params), actor = actorOf(request.authUser)
|
|
await transaction(async client => {
|
|
const grant = (await client.query("SELECT * FROM mcp_grants WHERE id=$1 FOR UPDATE", [id])).rows[0]
|
|
if (!grant) throw new McpError("NOT_FOUND", "Допуск не найден", 404)
|
|
assertConnectionVisible(await getConnection(grant.connection_id, client), actor)
|
|
await client.query("UPDATE mcp_grants SET revoked_at=now() WHERE id=$1", [id])
|
|
await client.query("UPDATE mcp_credentials SET revoked_at=now() WHERE id=$1", [grant.payload.credentialId])
|
|
await audit(client, actor.id, "grant.revoke", grant.connection_id, { grantId: id })
|
|
})
|
|
return { ok: true }
|
|
})
|
|
app.post("/mcp/connections/:id/check", async request => {
|
|
const connection = await getConnection(idOf(request.params)); assertConnectionVisible(connection, actorOf(request.authUser))
|
|
const actions = listActions(), checks = {
|
|
enabled: (await getMcpSettings()).enabled,
|
|
generation: connection.generation === await accessGeneration(), active: connection.policy.status === "active",
|
|
expires: Date.parse(connection.policy.expiresAt) > Date.now(),
|
|
ownerPermissionsFresh: connection.owner_valid_until.getTime() > Date.now(),
|
|
operations: connection.policy.scope.operationIds.every(id => actions.some(action => action.operation.id === id)),
|
|
permissions: actions.filter(action => connection.policy.scope.operationIds.includes(action.operation.id)).every(action => action.operation.requiredPermissions.every(permission => hasPermission(connection.owner_permissions, permission) && hasPermission(connection.policy.permissions, permission))),
|
|
credentials: (await pool.query("SELECT 1 FROM mcp_credentials WHERE connection_id=$1 AND revoked_at IS NULL AND expires_at>now() AND kind IN ('bearer','access') LIMIT 1", [connection.id])).rows.length > 0,
|
|
}
|
|
const protocolProbe: ProtocolProbe = Object.values(checks).every(Boolean) ? await checkMcpProtocol(connection.id, actorOf(request.authUser)) : { status: "skipped", reason: "PRECHECK_FAILED", elapsedMs: 0, credentialType: "temporary-no-operations", clientCredentialsVerified: false }
|
|
const result = { ...checks, protocolHandshake: protocolProbe.status === "passed" }
|
|
await audit(pool, actorOf(request.authUser).id, "connection.check", connection.id, { checks: result, protocolProbe })
|
|
return { ok: Object.values(result).every(Boolean), checks: result, protocolProbe, checkedAt: new Date().toISOString(), transport: "streamable-http", endpointPath: "/mcp" }
|
|
})
|
|
app.get("/mcp/routing-profiles", async request => {
|
|
const actor = actorOf(request.authUser)
|
|
return { profiles: (await pool.query("SELECT p.id,p.connection_id,p.version,p.config,p.state,p.enabled,p.grant_expires_at,p.updated_at FROM mcp_routing_profiles p JOIN mcp_connections c ON c.id=p.connection_id WHERE ($1::boolean OR c.owner_id=$2) ORDER BY p.updated_at DESC LIMIT 200", [hasPermission(actor.permissions, "mm:mcp:admin"), actor.id])).rows }
|
|
})
|
|
app.post("/mcp/routing-profiles/:id/pause", async request => {
|
|
const id = idOf(request.params), actor = actorOf(request.authUser)
|
|
await transaction(async client => {
|
|
const profile = (await client.query("SELECT connection_id FROM mcp_routing_profiles WHERE id=$1 FOR UPDATE", [id])).rows[0]
|
|
if (!profile) throw new McpError("NOT_FOUND", "Профиль не найден", 404)
|
|
assertConnectionVisible(await getConnection(profile.connection_id, client), actor)
|
|
await client.query("UPDATE mcp_routing_profiles SET enabled=false,state=state || '{\"pausedReason\":\"Остановлен администратором\"}'::jsonb WHERE id=$1", [id])
|
|
await audit(client, actor.id, "controller.pause", profile.connection_id, { profileId: id })
|
|
})
|
|
return { ok: true }
|
|
})
|
|
app.post("/mcp/routing-profiles/:id/check", async request => {
|
|
const id = idOf(request.params), actor = actorOf(request.authUser)
|
|
const { candidateId, proofPurpose } = z.object({ candidateId: z.string().min(1).max(100), proofPurpose: z.enum(["community", "control-path"]).default("community") }).strict().parse(request.body)
|
|
const { rows: [row] } = await pool.query("SELECT connection_id,config FROM mcp_routing_profiles WHERE id=$1", [id])
|
|
if (!row) throw new McpError("NOT_FOUND", "Профиль не найден", 404)
|
|
const principal = await ownerPrincipal(row.connection_id, actor, "routing.path.verify")
|
|
return ownerDelegate(async () => invokeMcpTool(principal, "mm_route_path_verify", { profile: routeAiProfileSchema.parse(row.config), candidateId, proofPurpose }))
|
|
})
|
|
app.post("/mcp/routing-profiles/plan", async request => {
|
|
const input = z.object({ connectionId: uuid, profileId: uuid.optional(), profile: routeAiProfileSchema, enabled: z.boolean(), expiresAt: z.string().datetime({ offset: true }) }).strict().parse(request.body)
|
|
const actor = actorOf(request.authUser), principal = await ownerPrincipal(input.connectionId, actor, "routing.profiles.save")
|
|
if (input.enabled && !hasPermission(actor.permissions, "mm:filters:write")) throw new McpError("PERMISSION_DENIED", "Контроллер Community требует право изменения фильтров")
|
|
const { connectionId: _connection, ...payload } = input
|
|
await audit(pool, actor.id, "controller.web.plan", input.connectionId, { profileId: input.profileId ?? null })
|
|
return ownerDelegate(async () => invokeMcpTool(principal, "mm_route_profile_save_plan", payload))
|
|
})
|
|
app.post("/mcp/secrets", async request => {
|
|
const input = z.object({ purpose: z.string().min(1).max(512), serverId: z.number().int().positive().optional(), value: z.string().min(1).max(1000000) }).strict().parse(request.body), id = randomUUID(), actor = actorOf(request.authUser)
|
|
await transaction(async client => { await client.query("INSERT INTO mcp_secrets(id,purpose,server_id,ciphertext,created_by) VALUES($1,$2,$3,$4,$5)", [id, input.purpose, input.serverId ?? null, await encryptSecret(input.value), actor.id]); await audit(client, actor.id, "secret.create", null, { secretRef: id, purpose: input.purpose, serverId: input.serverId }) })
|
|
return { secretRef: id }
|
|
})
|
|
app.get("/mcp/artifacts/:id", async (request, reply) => {
|
|
// The portal owner is authenticated by onRequest. A sealed artifact's
|
|
// delegated credential can expire or be revoked without ending that login.
|
|
const readForOwner = async <T>(read: () => Promise<T>): Promise<T> => {
|
|
try { return await read() }
|
|
catch (error) {
|
|
if (error instanceof McpError && error.code === "UNAUTHORIZED" && error.statusCode === 401) throw new McpError("PERMISSION_DENIED", "Доступ к файлу отозван", 403)
|
|
throw error
|
|
}
|
|
}
|
|
const { rows: [artifact] } = await pool.query("SELECT id,connection_id,filename,media_type,CASE WHEN octet_length(access_scope::text)<=32768 THEN access_scope ELSE NULL END AS access_scope FROM mcp_artifacts WHERE id=$1 AND expires_at>now() AND octet_length(filename)<=1024 AND octet_length(media_type)<=200", [idOf(request.params)])
|
|
if (!artifact) throw new McpError("NOT_FOUND", "Файл отсутствует или срок истёк", 404)
|
|
if(artifact.access_scope?.kind==="backup-download" || artifact.access_scope?.kind==="database-backup" || artifact.access_scope?.kind==="wireguard-export" || artifact.access_scope?.kind==="ipsec-user-bundle" || artifact.access_scope?.kind==="ipsec-existing-certificate-bundle"){
|
|
const cancellation=new AbortController(),abort=()=>{if(!reply.raw.writableFinished)cancellation.abort()}
|
|
request.raw.once("aborted",abort);reply.raw.once("close",abort)
|
|
try {
|
|
const read = artifact.access_scope.kind === "ipsec-existing-certificate-bundle" ? existingCertificateArtifact.read : artifact.access_scope.kind === "ipsec-user-bundle" ? readHumanIpsecUserBundleArtifact : artifact.access_scope.kind === "wireguard-export" ? readHumanWireguardExportArtifact : artifact.access_scope.kind === "database-backup" ? readHumanDatabaseBackupArtifact : readHumanBackupDownloadArtifact
|
|
const file=await readForOwner(() => read(artifact.id,actorOf(request.authUser),checkClaims,cancellation.signal))
|
|
return reply.type(file.mediaType).header("Cache-Control","private, no-store").header("Content-Disposition",`attachment; filename="${file.filename}"`).send(file.content)
|
|
} finally {request.raw.off("aborted",abort);reply.raw.off("close",abort)}
|
|
}
|
|
if(artifact.access_scope?.kind==="netflow-host-files"){
|
|
const file=await readForOwner(() => readHumanHostFilesArtifact(artifact.id,actorOf(request.authUser)))
|
|
return reply.type(file.mediaType).header("Content-Disposition",`attachment; filename="${file.filename.replace(/[^a-zA-Z0-9._-]/g,"_")}"`).send(file.content)
|
|
}
|
|
const connection = await getConnection(artifact.connection_id); assertConnectionVisible(connection, actorOf(request.authUser))
|
|
if (connection.generation !== await accessGeneration() || connection.policy.status !== "active") throw new McpError("PERMISSION_DENIED", "Доступ к файлу отозван")
|
|
const metadata=await loadLogExportArtifactMetadata(artifact.id,connection.id)
|
|
if(!hasPermission(actorOf(request.authUser).permissions,"mm:servers:read") || !hasPermission(connection.policy.permissions,"mm:servers:read") || metadata.access_scope.policyVersion!==connection.policy.version || metadata.access_scope.generation!==await accessGeneration() || metadata.access_scope.serverIds.some(id=>!connection.policy.scope.serverIds.includes(id))) throw new McpError("PERMISSION_DENIED","Доступ к области выгрузки отозван")
|
|
const payload=(await pool.query("SELECT ciphertext FROM mcp_artifacts WHERE id=$1 AND connection_id=$2 AND access_scope->>'proof'=$3 AND expires_at>now() AND octet_length(ciphertext)<=12582912",[artifact.id,artifact.connection_id,metadata.access_scope.proof])).rows[0]
|
|
if(!payload)throw new McpError("NOT_FOUND","Файл отсутствует или срок истёк",404)
|
|
if(createHash("sha256").update(payload.ciphertext).digest("hex")!==metadata.access_scope.encryptedSha256)throw new McpError("ARTIFACT_INVALID","Зашифрованная выгрузка изменилась",409)
|
|
const content=await decryptSecret(payload.ciphertext)
|
|
if(Buffer.byteLength(content)!==metadata.access_scope.bytes || createHash("sha256").update(content).digest("hex")!==metadata.access_scope.sha256)throw new McpError("ARTIFACT_INVALID","Размер или SHA-256 выгрузки не совпал",409)
|
|
await checkClaims(actorOf(request.authUser))
|
|
const fresh=await getConnection(connection.id)
|
|
if(fresh.generation!==await accessGeneration() || fresh.policy.status!=="active" || fresh.policy.version!==metadata.access_scope.policyVersion || !hasPermission(fresh.policy.permissions,"mm:servers:read") || metadata.access_scope.serverIds.some(id=>!fresh.policy.scope.serverIds.includes(id)))throw new McpError("PERMISSION_DENIED","Доступ к файлу отозван")
|
|
return reply.type(artifact.media_type).header("Content-Disposition", `attachment; filename="${artifact.filename.replace(/[^a-zA-Z0-9._-]/g, "_")}"`).send(content)
|
|
})
|
|
}
|
|
|
|
}
|
|
export default createMcpRoutes()
|