Files
MikrotikManager/backend/src/modules/mcp/lifecycle-actions.ts
T

135 lines
11 KiB
TypeScript

import { randomUUID } from "node:crypto"
import { setTimeout as delay } from "node:timers/promises"
import { z } from "zod"
import { certificateIssueRequestSchema } from "@mmapp/contracts/certificates"
import { containerRuntimeStatus } from "../../services/container-runtime-status.js"
import { startContainer, stopContainer, removeContainer } from "../../services/containers-live.js"
import { acceptCertificateIssueRequest } from "../../services/certificate-issue-request.js"
import { createIssueJobRecordIfAbsent, getIssueJobRecord, getServerRowByIdString, toIssueJobDto } from "../../services/certificates-service.js"
import { runCertificateIssueJob } from "../../services/certificate-issue-runner.js"
import { readRosSnapshot, routerClient } from "./resources.js"
import { registerMcpService } from "./service-registry.js"
import { fingerprint, McpError } from "./security.js"
import type { add } from "./actions.js"
import type { ChangeEvidence } from "./action-types.js"
const serverId = z.number().int().positive(), id = z.string().min(1).max(100)
async function containerCurrent(input: Record<string, unknown>) {
const { client } = await routerClient(Number(input.serverId))
const rows = z.array(z.object({ ".id": z.string() }).passthrough()).parse(await client.get("/container"))
const matches = rows.filter(row => row[".id"] === input.id)
if (matches.length !== 1) throw new McpError("STATE_CONFLICT", "Контейнер отсутствует или его ID неоднозначен", 409)
const row = matches[0]
const configuration = Object.fromEntries([".id", "name", "root-dir", "remote-image", "interface", "envlist", "envlists", "mounts", "mountlists", "cmd", "hostname", "comment", "start-on-boot"].map(key => [key, row[key]]))
// Runtime counters/status are excluded; free-form cmd and mount/env config
// are sealed by their hash instead of being returned to the AI or audit.
return { id: input.id, status: containerRuntimeStatus(row), configurationFingerprint: fingerprint(configuration), interfaceName: typeof row.interface === "string" && row.interface.trim() ? row.interface.trim() : null }
}
async function removalCurrent(input: Record<string, unknown>) {
const current = await containerCurrent(input)
if (!current.interfaceName) throw new McpError("STATE_CONFLICT", "Не подтверждён интерфейс контейнера", 409)
const { client } = await routerClient(Number(input.serverId))
const inventory = z.array(z.object({ ".id": z.string().min(1), name: z.string().min(1), type: z.string().min(1), disabled: z.union([z.string(), z.boolean()]).optional() }).passthrough()).parse(await client.get("/interface"))
if (new Set(inventory.map(row => row[".id"])).size !== inventory.length) throw new McpError("STATE_CONFLICT", "Неоднозначные ID интерфейсов", 409)
const parents = inventory.filter(row => row.name === current.interfaceName)
if (parents.length !== 1) throw new McpError("STATE_CONFLICT", "Интерфейс контейнера отсутствует или неоднозначен", 409)
const parent = parents[0]
return { ...current, parent: { id: parent[".id"], name: parent.name, type: parent.type, disabled: parent.disabled ?? null } }
}
function containerObjects(sid: number, id: string, parent: Awaited<ReturnType<typeof removalCurrent>>["parent"]): ChangeEvidence["objects"] {
const nativeKind = parent.type === "ether" ? "ethernet" : parent.type
return [{ kind: "container", id, serverId: sid }, { kind: "interface", id: parent.id, serverId: sid }, { kind: nativeKind, id: parent.id, serverId: sid }]
}
export function registerLifecycleActions(register: typeof add) {
for (const action of ["start", "stop"] as const) {
registerMcpService(`containers.${action}`, {
current: removalCurrent,
execute: async input => {
const current = await removalCurrent(input)
if (current.configurationFingerprint !== input.configurationFingerprint || fingerprint(current.parent) !== input.parentFingerprint || !["running", "stopped"].includes(current.status)) throw new McpError("STATE_CONFLICT", "Конфигурация, интерфейс или состояние контейнера изменились", 409)
const { server } = await routerClient(Number(input.serverId)); await (action === "start" ? startContainer : stopContainer)(server, String(input.id)); return { acknowledged: true }
},
verify: async input => {
for (let attempt = 0; attempt < 10; attempt++) {
const current = await removalCurrent(input)
if (current.configurationFingerprint !== input.configurationFingerprint || fingerprint(current.parent) !== input.parentFingerprint) return false
if (current.status === (action === "start" ? "running" : "stopped")) return true
await delay(500)
}
return false
},
})
}
for (const action of ["start", "stop", "restart"] as const) {
register(`containers.${action}`, `mm_container_${action}_plan`, `Контейнер: ${action}`, "network", "mm:network:write", "write", "servers", z.object({ serverId, id }).strict(), {
prepare: async input => {
const before = await removalCurrent(input), sid = Number(input.serverId)
if (!["running", "stopped"].includes(before.status)) throw new McpError("STATE_CONFLICT", "Состояние контейнера неизвестно или переходное", 409)
const actions = action === "restart" ? before.status === "running" ? ["stop", "start"] : ["start"] : [action]
const steps: ChangeEvidence["steps"] = actions.map(action => ({ kind: "service", service: `containers.${action}`, input: { ...input, configurationFingerprint: before.configurationFingerprint, parentFingerprint: fingerprint(before.parent) } }))
return { target: { scope: "servers", serverIds: [sid] }, objects: containerObjects(sid, String(input.id), before.parent), snapshots: [await readRosSnapshot(sid, "container")], before, steps, requiresHuman: true, warnings: ["Состояние проверяется после каждой команды; повторное выполнение при потере подтверждения запрещено."] }
},
})
}
registerMcpService("containers.remove", {
current: removalCurrent,
execute: async input => {
const current = await removalCurrent(input)
if (current.status !== "stopped" || fingerprint(current) !== fingerprint(input.expected)) throw new McpError("STATE_CONFLICT", "Удаление требует исходный остановленный контейнер и неизменный интерфейс", 409)
const { server } = await routerClient(Number(input.serverId))
await removeContainer(server, String(input.id))
return { acknowledged: true, removedId: input.id }
},
verify: async input => {
const { client } = await routerClient(Number(input.serverId))
const rows = z.array(z.object({ ".id": z.string().min(1) }).passthrough()).parse(await client.get("/container"))
return !rows.some(row => row[".id"] === input.id)
},
})
register("containers.remove", "mm_container_remove_plan", "Удаление подтверждённо остановленного контейнера", "network", "mm:network:write", "write", "servers", z.object({ serverId, id }).strict(), {
prepare: async input => {
const before = await removalCurrent(input), sid = Number(input.serverId)
if (before.status !== "stopped") throw new McpError("STATE_CONFLICT", "Сначала остановите контейнер отдельным планом и обновите каталог", 409)
return { target: { scope: "servers", serverIds: [sid] }, objects: containerObjects(sid, String(input.id), before.parent),
snapshots: [await readRosSnapshot(sid, "container")], before, steps: [{ kind: "service", service: "containers.remove", input: { ...input, expected: before } }], requiresHuman: true,
warnings: ["Удаляется только остановленный контейнер. Не выполняются скрытая остановка, удаление mounts/env/interface или файлов root-dir.", "Универсального обратного плана для удаления нет. При потере подтверждения требуется сверка; команда не повторяется."] }
},
})
registerMcpService("certificates.issue", {
current: async input => {
const snapshot = await readRosSnapshot(Number(input.serverId), "certificate")
return snapshot.rows
},
execute: async input => {
let queuedId: string | undefined
const accepted = await acceptCertificateIssueRequest(certificateIssueRequestSchema.parse(input), {
getServer: getServerRowByIdString, getJob: getIssueJobRecord, createJob: createIssueJobRecordIfAbsent,
queue: jobId => { queuedId = jobId },
})
// Await the existing runner inside the operation lease. A queued receipt alone
// must never be presented as an installed certificate.
if (queuedId) await runCertificateIssueJob(queuedId)
const job = await getIssueJobRecord(accepted.jobId)
if (!job || job.status !== "done") throw new McpError("VERIFICATION_FAILED", "Выпуск сертификата не подтверждён; проверьте существующую задачу", 409)
return { jobId: accepted.jobId, status: job.status }
},
verify: async input => (await getIssueJobRecord(String(input.requestId)))?.status === "done",
})
register("certificates.issue", "mm_certificate_issue_plan", "Выпуск и установка сертификата через настроенный ACME", "certificates", "mm:certificates:write", "write", "servers", certificateIssueRequestSchema.extend({ serverId }).strict(), {
prepare: async input => {
const sid = Number(input.serverId), snapshot = await readRosSnapshot(sid, "certificate")
const requestId = input.requestId ?? randomUUID()
if (await getIssueJobRecord(String(requestId))) throw new McpError("STATE_CONFLICT", "Для существующей задачи используйте инструмент просмотра; повторный выпуск запрещён", 409)
return { target: { scope: "servers", serverIds: [sid] }, objects: [{ kind: "server", id: String(sid), serverId: sid }], snapshots: [snapshot], before: snapshot.rows,
steps: [{ kind: "service", service: "certificates.issue", input: { ...input, requestId } }], requiresHuman: true, warnings: ["Используются сохранённые сервером настройки ACME. Секрет Cloudflare не передаётся нейросети.", "Операция завершается только после подтверждённого результата существующего процесса выпуска."] }
},
})
register("certificates.jobs.read", "mm_certificate_job_get", "Состояние задачи выпуска сертификата", "certificates", "mm:certificates:read", "read", "servers", z.object({ serverId, jobId: z.string().uuid() }).strict(), {
read: async input => {
const job = await getIssueJobRecord(String(input.jobId))
if (!job || Number(job.serverId) !== input.serverId) throw new McpError("NOT_FOUND", "Задача не найдена", 404)
return toIssueJobDto(job)
},
})
}