@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/heart/daemon/container-healthcheck.js

@@ -0,0 +1,112 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContainerHealthcheck = runContainerHealthcheck;
+exports.runContainerHealthcheckMain = runContainerHealthcheckMain;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../identity");
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const container_runtime_1 = require("./container-runtime");
+const sanctuary_bundle_migration_1 = require("./sanctuary-bundle-migration");
+const sanctuary_package_management_1 = require("./sanctuary-package-management");
+function fail(reason) {
+    (0, runtime_1.emitNervesEvent)({ level: "error", component: "daemon", event: "daemon.container_healthcheck_error", message: "container healthcheck failed", meta: { reason } });
+    process.exitCode = 1;
+    throw new Error(reason);
+}
+function runContainerHealthcheck(options = {}) {
+    const argv = options.argv ?? process.argv;
+    const now = options.now ?? Date.now;
+    const index = argv.indexOf("--agent");
+    const agent = index >= 0 ? argv[index + 1] : undefined;
+    if (!agent)
+        fail("missing agent");
+    const packageManagement = (0, sanctuary_package_management_1.resolveSanctuaryPackageManagementActivation)({ mode: "production", argv, managedAgents: [agent], repoRoot: (0, identity_1.getRepoRoot)(), bundlesRoot: (0, identity_1.getAgentBundlesRoot)(), runtimePackageVersion: (0, bundle_manifest_1.getPackageVersion)() });
+    if (packageManagement.kind !== "active")
+        fail("invalid package-managed Sanctuary activation");
+    let installState;
+    try {
+        installState = (0, sanctuary_bundle_migration_1.inspectSanctuaryPackageManagedBundle)(packageManagement);
+    }
+    catch {
+        fail("package-managed Sanctuary inspection unavailable");
+    }
+    if (!installState.ok || !installState.data.ready)
+        fail("package-managed Sanctuary bundle is not ready");
+    const healthPath = path.join(os.homedir(), ".ouro-cli", "daemon-health.json");
+    let stat;
+    let health;
+    try {
+        stat = fs.statSync(healthPath);
+        health = JSON.parse(fs.readFileSync(healthPath, "utf8"));
+    }
+    catch {
+        fail("health state unavailable");
+    }
+    const checkedAt = now();
+    if (checkedAt - stat.mtimeMs > 90_000 || stat.mtimeMs > checkedAt + 1_000)
+        fail("health state stale");
+    if (health.pid !== 1 || !fs.existsSync("/proc/1"))
+        fail("daemon is not PID 1");
+    if (health.status !== "healthy" && health.status !== "partial")
+        fail("daemon status is not ready");
+    const agents = health.agents;
+    const managed = agents?.[agent];
+    if (!managed || managed.status !== "running" || typeof managed.pid !== "number" || managed.pid <= 0)
+        fail("managed agent is not running");
+    let processArguments = "";
+    try {
+        processArguments = (0, node_child_process_1.execFileSync)("ps", ["-eo", "args="], { encoding: "utf8", timeout: 2_000 });
+    }
+    catch {
+        fail("managed process inventory is unavailable");
+    }
+    if (!(0, container_runtime_1.hasManagedAgentProcess)(processArguments, agent))
+        fail("managed agent is not running exactly once");
+    if (!(0, container_runtime_1.hasManagedTelegramProcess)(processArguments, agent))
+        fail("managed Telegram sense is not running exactly once");
+    if (!(0, container_runtime_1.hasManagedSupercronicProcess)(processArguments, agent))
+        fail("managed Supercronic scheduler is not running exactly once");
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.container_healthcheck_end", message: "container healthcheck passed", meta: { agent } });
+}
+function runContainerHealthcheckMain(isMain, runner) {
+    if (isMain)
+        runner();
+}
+runContainerHealthcheckMain(require.main === module, runContainerHealthcheck);

package/dist/heart/daemon/container-runtime.js

@@ -0,0 +1,97 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasManagedAgentProcess = hasManagedAgentProcess;
+exports.hasManagedTelegramProcess = hasManagedTelegramProcess;
+exports.hasManagedSupercronicProcess = hasManagedSupercronicProcess;
+exports.readContainerRuntimePolicy = readContainerRuntimePolicy;
+const fs = __importStar(require("node:fs"));
+const runtime_1 = require("../../nerves/runtime");
+function hasManagedAgentProcess(processArguments, agent) {
+    const wanted = agent.trim();
+    if (!wanted)
+        return false;
+    const matches = processArguments.split("\n").filter((line) => {
+        const fields = line.trim().split(/\s+/u);
+        const entryIndex = fields.findIndex((field) => field === "/opt/ouro/dist/heart/agent-entry.js");
+        const agentIndex = fields.findIndex((field) => field === "--agent");
+        return entryIndex >= 0 && agentIndex >= 0 && fields[agentIndex + 1] === wanted;
+    });
+    return matches.length === 1;
+}
+function hasManagedTelegramProcess(processArguments, agent) {
+    const wanted = agent.trim();
+    if (!wanted)
+        return false;
+    const matches = processArguments.split("\n").filter((line) => {
+        const fields = line.trim().split(/\s+/u);
+        const entryIndex = fields.findIndex((field) => field === "/opt/ouro/dist/senses/telegram-entry.js");
+        const agentIndex = fields.findIndex((field) => field === "--agent");
+        return entryIndex >= 0 && agentIndex >= 0 && fields[agentIndex + 1] === wanted;
+    });
+    return matches.length === 1;
+}
+function hasManagedSupercronicProcess(processArguments, agent) {
+    const expected = [
+        "/usr/local/bin/supercronic",
+        "-split-logs",
+        "-inotify",
+        `/home/ouro/.ouro-cli/scheduler/${agent}.crontab`,
+    ];
+    const matches = processArguments.split("\n").filter((line) => {
+        const fields = line.trim().split(/\s+/u);
+        return fields.length === expected.length && fields.every((field, index) => field === expected[index]);
+    });
+    return matches.length === 1;
+}
+function readContainerRuntimePolicy(options = {}) {
+    const filePath = options.path ?? "/opt/ouro/container-runtime.json";
+    const readFile = options.readFile ?? ((target) => fs.readFileSync(target, "utf8"));
+    let raw;
+    try {
+        raw = readFile(filePath);
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const value = JSON.parse(raw);
+    if (value.scheduler !== "supercronic" || value.updates !== "disabled" || Object.keys(value).sort().join(",") !== "scheduler,updates") {
+        throw new Error("container runtime policy is invalid");
+    }
+    (0, runtime_1.emitNervesEvent)({ component: "daemon", event: "daemon.container_runtime_policy_loaded", message: "container runtime policy loaded", meta: { scheduler: value.scheduler, updates: value.updates } });
+    return { scheduler: "supercronic", updates: "disabled" };
+}

package/dist/heart/daemon/container-spec-auditor-main.js

@@ -0,0 +1,171 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runContainerSpecAuditorCli = runContainerSpecAuditorCli;
+exports.runContainerSpecAuditorMain = runContainerSpecAuditorMain;
+const fs = __importStar(require("node:fs"));
+const runtime_1 = require("../../nerves/runtime");
+const container_spec_auditor_1 = require("./container-spec-auditor");
+const { decodeUtf8 } = require("../../../deploy/unraid/docker-man-template-xml.cjs");
+function parseModeArguments(args, flags) {
+    if (args.length !== flags.length * 2)
+        return null;
+    const allowed = new Set(flags);
+    const parsed = {};
+    for (let index = 0; index < args.length; index += 2) {
+        const flag = args[index];
+        const value = args[index + 1];
+        if (!allowed.has(flag) || Object.prototype.hasOwnProperty.call(parsed, flag) || !value)
+            return null;
+        parsed[flag] = value;
+    }
+    return parsed;
+}
+function parseSingleInspect(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (!Array.isArray(value) || value.length !== 1)
+            return null;
+        const item = value[0];
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return null;
+        return item;
+    }
+    catch {
+        return null;
+    }
+}
+function runContainerSpecAuditorCli(args, deps = {}) {
+    const readFile = deps.readFile ?? ((filePath) => fs.readFileSync(filePath));
+    const readText = (filePath) => decodeUtf8(readFile(filePath));
+    const write = deps.write ?? ((text) => process.stdout.write(text));
+    const staged = parseModeArguments(args, ["--template", "--runtime-policy", "--expected-image", "--mount-contract"]);
+    const persistent = parseModeArguments(args, ["--persistent-template", "--runtime-policy", "--expected-image-reference", "--mount-contract"]);
+    const effective = parseModeArguments(args, ["--inspect", "--image-inspect", "--expected-image", "--expected-image-reference", "--expected-icon", "--mount-contract"]);
+    const sourceCandidate = parseModeArguments(args, ["--inspect", "--image-inspect", "--expected-image", "--mount-contract"]);
+    const sourceContract = sourceCandidate?.["--mount-contract"];
+    const sourceEffective = sourceContract === "legacy-alpha742" ? sourceCandidate : null;
+    const selectedEffective = effective ?? sourceEffective;
+    if (!staged && !persistent && !selectedEffective) {
+        write(JSON.stringify({ ok: false, error: "usage: all modes require --mount-contract canonical-pre-gateway|canonical-gateway; staged --template <path> --runtime-policy <path> --expected-image <id>; persistent --persistent-template <path> --runtime-policy <path> --expected-image-reference <tag>; effective --inspect <path> --image-inspect <path> --expected-image <id> --expected-image-reference <tag> --expected-icon <url>; source compatibility effective --inspect <path> --image-inspect <path> --expected-image <id> --mount-contract legacy-alpha742" }) + "\n");
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.container_spec_auditor_cli_error",
+            message: "container spec auditor arguments were invalid",
+            meta: { argumentCount: args.length },
+        });
+        return 2;
+    }
+    if (selectedEffective) {
+        let containerText;
+        let imageText;
+        try {
+            containerText = readText(selectedEffective["--inspect"]);
+            imageText = readText(selectedEffective["--image-inspect"]);
+        }
+        catch (error) {
+            write(JSON.stringify({ ok: false, error: "effective audit inputs are unreadable" }) + "\n");
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.container_spec_auditor_cli_error",
+                message: "container spec auditor could not read effective inputs",
+                meta: { reason: error instanceof Error ? error.message : String(error) },
+            });
+            return 2;
+        }
+        const containerInspect = parseSingleInspect(containerText);
+        const imageInspect = parseSingleInspect(imageText);
+        const imageConfig = imageInspect?.Config;
+        const expectedEnvironment = imageConfig && typeof imageConfig === "object" && !Array.isArray(imageConfig)
+            ? imageConfig.Env
+            : null;
+        if (!containerInspect || !imageInspect || !Array.isArray(expectedEnvironment) || !expectedEnvironment.every((entry) => typeof entry === "string")) {
+            write(JSON.stringify({ ok: false, error: "effective audit inputs must each contain exactly one canonical inspect record" }) + "\n");
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "daemon",
+                event: "daemon.container_spec_auditor_cli_error",
+                message: "container spec auditor effective inputs were invalid",
+                meta: { containerValid: !!containerInspect, imageValid: !!imageInspect },
+            });
+            return 2;
+        }
+        const result = (0, container_spec_auditor_1.auditSanctuaryContainerSpec)(containerInspect, {
+            expectedImage: selectedEffective["--expected-image"],
+            expectedEnvironment,
+            expectedImageReference: selectedEffective["--expected-image-reference"],
+            expectedIcon: selectedEffective["--expected-icon"],
+            mountContract: selectedEffective["--mount-contract"],
+        });
+        if (imageInspect.Id !== selectedEffective["--expected-image"]) {
+            result.ok = false;
+            result.violations.unshift("reviewed image inspect identity does not match the expected local image ID");
+        }
+        write(JSON.stringify(result) + "\n");
+        return result.ok ? 0 : 1;
+    }
+    const templateArguments = persistent ?? staged;
+    const mountContract = templateArguments["--mount-contract"];
+    const templatePath = persistent ? templateArguments["--persistent-template"] : templateArguments["--template"];
+    let templateXml;
+    let runtimePolicyText;
+    try {
+        templateXml = readText(templatePath);
+        runtimePolicyText = readText(templateArguments["--runtime-policy"]);
+    }
+    catch (error) {
+        write(JSON.stringify({ ok: false, error: "staged audit inputs are unreadable" }) + "\n");
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.container_spec_auditor_cli_error",
+            message: "container spec auditor could not read staged files",
+            meta: { reason: error instanceof Error ? error.message : String(error) },
+        });
+        return 2;
+    }
+    const result = persistent
+        ? (0, container_spec_auditor_1.auditSanctuaryPersistentTemplate)({ templateXml, runtimePolicyText, expectedImageReference: persistent["--expected-image-reference"], mountContract })
+        : (0, container_spec_auditor_1.auditSanctuaryStagedFiles)({ templateXml, runtimePolicyText, expectedImage: staged["--expected-image"], mountContract });
+    write(JSON.stringify(result) + "\n");
+    return result.ok ? 0 : 1;
+}
+function runContainerSpecAuditorMain(isMain, args, runner) {
+    if (isMain)
+        process.exitCode = runner(args);
+}
+runContainerSpecAuditorMain(require.main === module, process.argv.slice(2), runContainerSpecAuditorCli);

package/dist/heart/daemon/container-spec-auditor.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditSanctuaryContainerSpec = auditSanctuaryContainerSpec;
+exports.auditSanctuaryStagedFiles = auditSanctuaryStagedFiles;
+exports.auditSanctuaryPersistentTemplate = auditSanctuaryPersistentTemplate;
+const runtime_1 = require("../../nerves/runtime");
+const { parseDockerManTemplateXml } = require("../../../deploy/unraid/docker-man-template-xml.cjs");
+const EXPECTED_BINDS = [
+    "/mnt/user/appdata/ouro-butler/runtime/.ouro-cli:/home/ouro/.ouro-cli:rw",
+    "/mnt/user/appdata/ouro-butler/agent/sanctuary.ouro:/home/ouro/AgentBundles/sanctuary.ouro:rw",
+    "/boot/config/custom/ouro-events/spool:/run/ouro-events:ro",
+    "/run/ouro-authority:/run/ouro-authority:ro",
+];
+const EXPECTED_MOUNTS = [
+    ["/mnt/user/appdata/ouro-butler/runtime/.ouro-cli", "/home/ouro/.ouro-cli", true, "rprivate"],
+    ["/mnt/user/appdata/ouro-butler/agent/sanctuary.ouro", "/home/ouro/AgentBundles/sanctuary.ouro", true, "rprivate"],
+    ["/boot/config/custom/ouro-events/spool", "/run/ouro-events", false, "rprivate"],
+    ["/run/ouro-authority", "/run/ouro-authority", false, "rprivate"],
+];
+const PRE_GATEWAY_BINDS = EXPECTED_BINDS.slice(0, 3);
+const PRE_GATEWAY_MOUNTS = EXPECTED_MOUNTS.slice(0, 3);
+const LEGACY_ALPHA742_IMAGE = "sha256:681449ad47a2621705cd339b481e6339236b31dc65e195b1cf5025d0f2191d7d";
+const LEGACY_ALPHA742_MOUNTS = EXPECTED_MOUNTS.slice(0, 2);
+const EXPECTED_EXTRA_PARAMS = "--restart=unless-stopped --user=10001:10001";
+const EXPECTED_NAME = "ouro-butler";
+const EXPECTED_TEMPLATE_URL = "https://raw.githubusercontent.com/ourostack/ouroboros/main/deploy/unraid/sanctuary.xml";
+const EXPECTED_ICON = "https://raw.githubusercontent.com/ourostack/ouroboros/main/assets/ouroboros.png";
+const EXACT_IMAGE = /^sha256:[a-f0-9]{64}$/u;
+const VERSION_REFERENCE = /^ghcr\.io\/ourostack\/ouroboros-butler:[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?$/u;
+const PACKAGE_DAEMON_ARGS = ["/opt/ouro/dist/heart/daemon/daemon-entry.js", "--package-managed-agent", "sanctuary"];
+const PACKAGE_ENTRYPOINT = ["node", ...PACKAGE_DAEMON_ARGS];
+const LEGACY_DAEMON_ARGS = ["/opt/ouro/dist/heart/daemon/daemon-entry.js"];
+const LEGACY_ENTRYPOINT = ["node", ...LEGACY_DAEMON_ARGS];
+function record(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : null;
+}
+function isEmptyRecord(value) {
+    const candidate = record(value);
+    return candidate !== null && Object.keys(candidate).length === 0;
+}
+function auditSanctuaryContainerSpec(value, options) {
+    const violations = [];
+    const root = record(value);
+    const config = record(root?.Config);
+    const host = record(root?.HostConfig);
+    const network = record(root?.NetworkSettings);
+    if (!root || !config || !host) {
+        violations.push("inspect payload must contain object Config and HostConfig records");
+    }
+    else {
+        if (!EXACT_IMAGE.test(options.expectedImage))
+            violations.push("expected image must be an exact local Docker image ID");
+        const mountContract = options.mountContract;
+        if (mountContract !== "canonical-pre-gateway" && mountContract !== "canonical-gateway" && mountContract !== "legacy-alpha742")
+            violations.push("unsupported mount contract");
+        if (mountContract === "legacy-alpha742" && options.expectedImage !== LEGACY_ALPHA742_IMAGE)
+            violations.push("legacy mount exception requires the pinned alpha.742 image ID");
+        const expectedMounts = mountContract === "legacy-alpha742" ? LEGACY_ALPHA742_MOUNTS : mountContract === "canonical-pre-gateway" ? PRE_GATEWAY_MOUNTS : EXPECTED_MOUNTS;
+        const expectedArgs = mountContract !== "legacy-alpha742" ? PACKAGE_DAEMON_ARGS : LEGACY_DAEMON_ARGS;
+        const expectedEntrypoint = mountContract !== "legacy-alpha742" ? PACKAGE_ENTRYPOINT : LEGACY_ENTRYPOINT;
+        if (root.Image !== options.expectedImage)
+            violations.push("image does not match the reviewed exact local Docker image ID");
+        if (root.Path !== "node")
+            violations.push("effective container path must be node");
+        if (JSON.stringify(root.Args) !== JSON.stringify(expectedArgs))
+            violations.push("effective container arguments must be the reviewed direct daemon entry");
+        if (config.User !== "10001:10001")
+            violations.push("container user must be 10001:10001");
+        if (JSON.stringify(config.Entrypoint) !== JSON.stringify(expectedEntrypoint))
+            violations.push("entrypoint must be the reviewed direct daemon entry");
+        if (!(config.Cmd === null || (Array.isArray(config.Cmd) && config.Cmd.length === 0)))
+            violations.push("container command must be empty");
+        const environment = stringArray(config.Env);
+        if (!environment || JSON.stringify(environment) !== JSON.stringify(options.expectedEnvironment))
+            violations.push("container environment must exactly match the reviewed image environment");
+        if (!(config.ExposedPorts === null || config.ExposedPorts === undefined || isEmptyRecord(config.ExposedPorts)))
+            violations.push("container must expose no ports");
+        if (host.NetworkMode !== "host")
+            violations.push("network mode must be host");
+        if (host.PidMode !== "")
+            violations.push("PID namespace must be private");
+        if (host.IpcMode !== "private")
+            violations.push("IPC namespace must be private");
+        if (host.Privileged !== false)
+            violations.push("container must not be privileged");
+        if (host.ReadonlyRootfs !== false)
+            violations.push("root filesystem mode must match the reviewed runtime");
+        if (!(host.SecurityOpt === null || (Array.isArray(host.SecurityOpt) && host.SecurityOpt.length === 0)))
+            violations.push("container must set no security options");
+        const restart = record(host.RestartPolicy);
+        if (restart?.Name !== "unless-stopped" || restart.MaximumRetryCount !== 0)
+            violations.push("restart policy must be unless-stopped");
+        if (!isEmptyRecord(host.PortBindings))
+            violations.push("container must publish no ports");
+        if (!Array.isArray(host.Devices) || host.Devices.length !== 0)
+            violations.push("container must have no devices");
+        if (!(host.CapAdd === null || (Array.isArray(host.CapAdd) && host.CapAdd.length === 0)))
+            violations.push("container must add no capabilities");
+        if (!(host.CapDrop === null || (Array.isArray(host.CapDrop) && host.CapDrop.length === 0)))
+            violations.push("container must drop no capabilities");
+        if (host.PublishAllPorts !== false)
+            violations.push("container must not publish all exposed ports");
+        if (!isEmptyRecord(network?.Ports))
+            violations.push("effective network ports must be empty");
+        if (mountContract !== "legacy-alpha742" && root.Name !== `/${EXPECTED_NAME}`)
+            violations.push("container name must be /ouro-butler");
+        if (mountContract !== "legacy-alpha742") {
+            if (!options.expectedImageReference || !VERSION_REFERENCE.test(options.expectedImageReference))
+                violations.push("expected image reference must be the canonical package-version tag");
+            if (config.Image !== options.expectedImageReference)
+                violations.push("configured image must equal the canonical package-version tag");
+            if (options.expectedIcon !== EXPECTED_ICON)
+                violations.push("expected icon must equal the canonical template icon");
+            const labels = record(config.Labels);
+            if (labels?.["net.unraid.docker.managed"] !== "dockerman")
+                violations.push("container must carry the DockerMan managed label");
+            if (labels?.["net.unraid.docker.icon"] !== options.expectedIcon)
+                violations.push("container icon label must equal the canonical template icon");
+            if (labels && Object.prototype.hasOwnProperty.call(labels, "net.unraid.docker.webui"))
+                violations.push("container must not carry a DockerMan WebUI label");
+        }
+        const mounts = Array.isArray(root.Mounts) ? root.Mounts : [];
+        const normalizedMounts = mounts.map((mount) => {
+            const item = record(mount);
+            return item && item.Type === "bind" && typeof item.RW === "boolean" && typeof item.Source === "string" && typeof item.Destination === "string" && item.Propagation === "rprivate"
+                ? [item.Source, item.Destination, item.RW, item.Propagation]
+                : null;
+        });
+        if (normalizedMounts.some((mount) => mount === null)
+            || JSON.stringify(normalizedMounts.sort()) !== JSON.stringify(expectedMounts.map((mount) => [...mount]).sort())) {
+            violations.push("effective mounts do not match the selected Sanctuary mount contract");
+        }
+    }
+    const result = { ok: violations.length === 0, violations };
+    if (result.ok) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.container_spec_audit_end",
+            message: "Sanctuary container spec audit passed",
+            meta: { violationCount: 0 },
+        });
+    }
+    else {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.container_spec_audit_error",
+            message: "Sanctuary container spec audit failed",
+            meta: { violationCount: violations.length },
+        });
+    }
+    return result;
+}
+function directChildren(document, name) {
+    return document?.children.filter((child) => child.name === name) ?? [];
+}
+function singleTextChild(document, name) {
+    const children = directChildren(document, name);
+    const child = children.length === 1 ? children[0] : undefined;
+    return child?.form === "text" && Object.keys(child.attributes).length === 0 ? child.text : undefined;
+}
+function auditTemplate(input, expectedRepository, repositoryIsValid, repositoryViolation) {
+    const violations = [];
+    if (input.mountContract !== "canonical-pre-gateway" && input.mountContract !== "canonical-gateway")
+        violations.push("unsupported template mount contract");
+    const expectedBinds = input.mountContract === "canonical-pre-gateway" ? PRE_GATEWAY_BINDS : EXPECTED_BINDS;
+    const template = parseDockerManTemplateXml(input.templateXml);
+    if (!template)
+        violations.push("canonical DockerMan XML structure is invalid");
+    let runtimePolicy;
+    try {
+        runtimePolicy = JSON.parse(input.runtimePolicyText);
+    }
+    catch {
+        runtimePolicy = null;
+    }
+    const policy = record(runtimePolicy);
+    if (policy?.scheduler !== "supercronic" || policy.updates !== "disabled" || Object.keys(policy).sort().join(",") !== "scheduler,updates") {
+        violations.push("container runtime policy must be exactly scheduler=supercronic and updates=disabled");
+    }
+    const configEntries = directChildren(template, "Config");
+    const pathConfigs = configEntries.map((entry) => {
+        const { Type: type, Target: target, Mode: mode } = entry.attributes;
+        return entry.form === "text" && type === "Path" && target && mode ? `${entry.text}:${target}:${mode}` : "invalid";
+    });
+    if (configEntries.length !== expectedBinds.length
+        || JSON.stringify([...pathConfigs].sort()) !== JSON.stringify([...expectedBinds].sort())) {
+        violations.push("template Config entries must equal the canonical path binds");
+    }
+    const postArgs = directChildren(template, "PostArgs");
+    if (postArgs.length !== 1 || postArgs[0].text !== "" || Object.keys(postArgs[0].attributes).length !== 0) {
+        violations.push("template PostArgs must be present exactly once and empty");
+    }
+    const extraParams = singleTextChild(template, "ExtraParams");
+    if (extraParams !== EXPECTED_EXTRA_PARAMS)
+        violations.push("template ExtraParams must equal the canonical user and restart flags");
+    const repository = singleTextChild(template, "Repository");
+    if (!repositoryIsValid)
+        violations.push(repositoryViolation);
+    if (repository !== expectedRepository)
+        violations.push("template repository does not match the reviewed image identity");
+    if (singleTextChild(template, "Name") !== EXPECTED_NAME)
+        violations.push("template technical name must be exactly ouro-butler");
+    if (singleTextChild(template, "TemplateURL") !== EXPECTED_TEMPLATE_URL)
+        violations.push("template URL must equal the canonical release template");
+    if (singleTextChild(template, "Icon") !== EXPECTED_ICON)
+        violations.push("template icon must equal the canonical release icon");
+    const webUi = directChildren(template, "WebUI");
+    if (webUi.length !== 1 || webUi[0].form !== "empty" || Object.keys(webUi[0].attributes).length !== 0)
+        violations.push("template WebUI must be present exactly once and empty");
+    if (singleTextChild(template, "Network") !== "host")
+        violations.push("network mode must be host");
+    if (singleTextChild(template, "Privileged") !== "false")
+        violations.push("container must not be privileged");
+    return violations;
+}
+function auditSanctuaryStagedFiles(input) {
+    const violations = auditTemplate(input, input.expectedImage, EXACT_IMAGE.test(input.expectedImage), "expected image must be an exact local Docker image ID");
+    return { ok: violations.length === 0, violations };
+}
+function auditSanctuaryPersistentTemplate(input) {
+    const violations = auditTemplate(input, input.expectedImageReference, VERSION_REFERENCE.test(input.expectedImageReference), "expected image reference must be the canonical package-version tag");
+    return { ok: violations.length === 0, violations };
+}