@ouro.bot/cli 0.1.0-alpha.79 → 0.1.0-alpha.791

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

@@ -0,0 +1,96 @@
+"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 container_runtime_1 = require("./container-runtime");
+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 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,160 @@
+"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");
+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, "utf8"));
+    const write = deps.write ?? ((text) => process.stdout.write(text));
+    const staged = parseModeArguments(args, ["--template", "--runtime-policy", "--expected-image"]);
+    const effective = parseModeArguments(args, ["--inspect", "--image-inspect", "--expected-image"]);
+    const legacyCandidate = parseModeArguments(args, ["--inspect", "--image-inspect", "--expected-image", "--mount-contract"]);
+    const legacyEffective = legacyCandidate?.["--mount-contract"] === "legacy-alpha742" ? legacyCandidate : null;
+    const selectedEffective = effective ?? legacyEffective;
+    if (!staged && !selectedEffective) {
+        write(JSON.stringify({ ok: false, error: "usage: staged --template <path> --runtime-policy <path> --expected-image <id>; 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 = readFile(selectedEffective["--inspect"]);
+            imageText = readFile(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,
+            mountContract: legacyEffective ? "legacy-alpha742" : "canonical",
+        });
+        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;
+    }
+    let templateXml;
+    let runtimePolicyText;
+    try {
+        templateXml = readFile(staged["--template"]);
+        runtimePolicyText = readFile(staged["--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 = (0, container_spec_auditor_1.auditSanctuaryStagedFiles)({ templateXml, runtimePolicyText, expectedImage: staged["--expected-image"] });
+    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,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.auditSanctuaryContainerSpec = auditSanctuaryContainerSpec;
+exports.auditSanctuaryStagedFiles = auditSanctuaryStagedFiles;
+const runtime_1 = require("../../nerves/runtime");
+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",
+];
+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"],
+];
+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";
+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 (!/^sha256:[a-f0-9]{64}$/u.test(options.expectedImage))
+            violations.push("expected image must be an exact local Docker image ID");
+        const mountContract = options.mountContract ?? "canonical";
+        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 : EXPECTED_MOUNTS;
+        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(["/opt/ouro/dist/heart/daemon/daemon-entry.js"]))
+            violations.push("effective container arguments must be the direct daemon entry");
+        if (config.User !== "10001:10001")
+            violations.push("container user must be 10001:10001");
+        if (JSON.stringify(config.Entrypoint) !== JSON.stringify(["node", "/opt/ouro/dist/heart/daemon/daemon-entry.js"]))
+            violations.push("entrypoint must be the 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");
+        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 tagValues(xml, name) {
+    return [...xml.matchAll(new RegExp(`<${name}>([^<]*)</${name}>`, "gu"))]
+        .map((match) => match[1]);
+}
+function singleTag(xml, name) {
+    const values = tagValues(xml, name);
+    return values.length === 1 ? values[0] : undefined;
+}
+function auditSanctuaryStagedFiles(input) {
+    const violations = [];
+    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 configOpenCount = [...input.templateXml.matchAll(/<Config\b/gu)].length;
+    const configEntries = [...input.templateXml.matchAll(/<Config\b([^>]*)>([^<]*)<\/Config>/gu)];
+    const pathConfigs = configEntries
+        .map((match) => {
+        const type = match[1].match(/\bType="([^"]+)"/u)?.[1];
+        const target = match[1].match(/\bTarget="([^"]+)"/u)?.[1];
+        const mode = match[1].match(/\bMode="([^"]+)"/u)?.[1];
+        return type === "Path" && target && mode ? `${match[2]}:${target}:${mode}` : "invalid";
+    });
+    if (configOpenCount !== EXPECTED_BINDS.length
+        || configEntries.length !== EXPECTED_BINDS.length
+        || JSON.stringify([...pathConfigs].sort()) !== JSON.stringify([...EXPECTED_BINDS].sort())) {
+        violations.push("template Config entries must equal the canonical path binds");
+    }
+    const postArgsOpenCount = [...input.templateXml.matchAll(/<PostArgs\b/gu)].length;
+    const postArgs = [...input.templateXml.matchAll(/<PostArgs(?:(?:\s*\/>)|>([^<]*)<\/PostArgs>)/gu)];
+    if (postArgsOpenCount !== 1 || postArgs.length !== 1 || (postArgs[0]?.[1] ?? "") !== "") {
+        violations.push("template PostArgs must be present exactly once and empty");
+    }
+    const extraParams = singleTag(input.templateXml, "ExtraParams");
+    if (extraParams !== EXPECTED_EXTRA_PARAMS)
+        violations.push("template ExtraParams must equal the canonical user and restart flags");
+    const repository = singleTag(input.templateXml, "Repository");
+    if (!/^sha256:[a-f0-9]{64}$/u.test(input.expectedImage))
+        violations.push("expected image must be an exact local Docker image ID");
+    if (repository !== input.expectedImage)
+        violations.push("image does not match the reviewed exact local Docker image ID");
+    if (singleTag(input.templateXml, "Network") !== "host")
+        violations.push("network mode must be host");
+    if (singleTag(input.templateXml, "Privileged") !== "false")
+        violations.push("container must not be privileged");
+    return { ok: violations.length === 0, violations };
+}

package/dist/heart/daemon/daemon-bootstrap-startup.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBLIC_DAEMON_STARTUP_FAILURE_REASON = void 0;
+exports.createProviderReadinessPreparationFailure = createProviderReadinessPreparationFailure;
+exports.failFastContainerCredentialBootstrapStartup = failFastContainerCredentialBootstrapStartup;
+exports.startDaemonAfterContainerCredentialBootstrap = startDaemonAfterContainerCredentialBootstrap;
+const runtime_1 = require("../../nerves/runtime");
+const daemon_tombstone_1 = require("./daemon-tombstone");
+const REDACTED_BOOTSTRAP_STARTUP_ERROR = "container credential bootstrap rejected; recoverable claim retained for reconciliation";
+const REDACTED_DAEMON_PREPARATION_ERROR = "provider runtime preparation failed before startup; run `ouro doctor` for diagnosis";
+exports.PUBLIC_DAEMON_STARTUP_FAILURE_REASON = "startupFailurePublic";
+class DaemonPreparationFailure extends Error {
+    name = "DaemonPreparationFailure";
+}
+function createProviderReadinessPreparationFailure(issues) {
+    const lines = ["Provider checks need attention"];
+    for (const issue of issues) {
+        lines.push(issue.summary);
+        lines.push(...issue.actions.map((action) => `  ${action.actor}: ${action.command}`));
+    }
+    return new DaemonPreparationFailure(lines.join("\n"));
+}
+function failFastContainerCredentialBootstrapStartup(input) {
+    failFastDaemonStartup({
+        exit: input.exit,
+        errorMessage: REDACTED_BOOTSTRAP_STARTUP_ERROR,
+        eventMessage: "daemon entrypoint failed before server startup",
+    });
+}
+function failFastDaemonStartup(input) {
+    const errorMessage = input.errorMessage;
+    const error = new Error(errorMessage);
+    try {
+        (0, daemon_tombstone_1.writeDaemonTombstone)(exports.PUBLIC_DAEMON_STARTUP_FAILURE_REASON, error);
+    }
+    catch {
+        // Exit remains mandatory even if best-effort tombstone reporting fails.
+    }
+    try {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "daemon",
+            event: "daemon.entry_error",
+            message: input.eventMessage,
+            meta: { error: errorMessage },
+        });
+    }
+    catch {
+        // Exit remains mandatory even if best-effort event reporting fails.
+    }
+    input.exit(1);
+}
+async function startDaemonAfterContainerCredentialBootstrap(input) {
+    try {
+        await input.loadBootstrap();
+    }
+    catch {
+        input.markStartupFailure();
+        failFastContainerCredentialBootstrapStartup({ exit: input.exit });
+        return false;
+    }
+    try {
+        await input.prepareDaemon?.();
+    }
+    catch (error) {
+        input.markStartupFailure();
+        const controlledMessage = error instanceof DaemonPreparationFailure ? error.message : null;
+        failFastDaemonStartup({
+            exit: input.exit,
+            errorMessage: controlledMessage ?? REDACTED_DAEMON_PREPARATION_ERROR,
+            eventMessage: controlledMessage ?? REDACTED_DAEMON_PREPARATION_ERROR,
+        });
+        return false;
+    }
+    await input.startDaemon();
+    return true;
+}