@ouro.bot/cli 0.1.0-alpha.696 → 0.1.0-alpha.698

package/dist/rsvp/config.js

@@ -0,0 +1,327 @@
+"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.RSVP_CONFIG_POLICY_VERSION = void 0;
+exports.rsvpConfigPath = rsvpConfigPath;
+exports.readRsvpConfig = readRsvpConfig;
+exports.writeRsvpConfig = writeRsvpConfig;
+exports.validateRsvpReadiness = validateRsvpReadiness;
+exports.importLegacyRsvpConfig = importLegacyRsvpConfig;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../nerves/runtime");
+const runtime_credentials_1 = require("../heart/runtime-credentials");
+exports.RSVP_CONFIG_POLICY_VERSION = "rsvp-config/v1";
+function rsvpConfigPath(agentRoot) {
+    return path.join(agentRoot, "rsvp", "config.json");
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function text(value) {
+    return typeof value === "string" ? value.trim() : "";
+}
+function idText(value) {
+    if (typeof value === "string" || typeof value === "number")
+        return String(value).trim();
+    return "";
+}
+function optionalText(value) {
+    const normalized = text(value);
+    return normalized || undefined;
+}
+function parseRsvpConfig(value) {
+    if (!isRecord(value))
+        return null;
+    if (value.schemaVersion !== 1)
+        return null;
+    if (value.policyVersion !== exports.RSVP_CONFIG_POLICY_VERSION)
+        return null;
+    if (typeof value.agent !== "string")
+        return null;
+    if (value.mode !== "shadow" && value.mode !== "live")
+        return null;
+    const source = isRecord(value.source) ? value.source : null;
+    if (!source || source.kind !== "aisleplanner")
+        return null;
+    if (typeof source.weddingId !== "string" || typeof source.eventId !== "string")
+        return null;
+    const credentialRef = isRecord(value.credentialRef) ? value.credentialRef : null;
+    if (!credentialRef
+        || credentialRef.runtimeConfigItem !== "runtime/config"
+        || credentialRef.runtimeConfigPath !== "rsvp.aisleplanner")
+        return null;
+    const route = isRecord(value.bluebubblesRoute) ? value.bluebubblesRoute : null;
+    if (!route || typeof route.chatGuid !== "string")
+        return null;
+    if (route.chatIdentifier !== undefined && typeof route.chatIdentifier !== "string")
+        return null;
+    if (route.accountId !== undefined && typeof route.accountId !== "string")
+        return null;
+    const cutover = value.cutover === undefined ? undefined : isRecord(value.cutover) ? value.cutover : null;
+    if (cutover === null)
+        return null;
+    if (cutover && typeof cutover.legacyRoot !== "string")
+        return null;
+    return value;
+}
+function readRsvpConfig(agentRoot) {
+    const configPath = rsvpConfigPath(agentRoot);
+    if (!fs.existsSync(configPath)) {
+        return { ok: false, reason: "missing", path: configPath, message: "missing native RSVP config" };
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        const config = parseRsvpConfig(parsed);
+        if (!config) {
+            return { ok: false, reason: "malformed", path: configPath, message: "native RSVP config is malformed" };
+        }
+        return { ok: true, config, path: configPath };
+    }
+    catch {
+        return { ok: false, reason: "malformed", path: configPath, message: "native RSVP config is not valid JSON" };
+    }
+}
+function writeRsvpConfig(agentRoot, config) {
+    const configPath = rsvpConfigPath(agentRoot);
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.config_written",
+        message: "wrote native RSVP config",
+        meta: { agent: config.agent, mode: config.mode, configPath },
+    });
+    return configPath;
+}
+function check(id, status, actor, detail) {
+    return { id, status, actor, detail };
+}
+function runtimeRsvpConfig(runtimeConfig) {
+    if (!runtimeConfig.ok)
+        return null;
+    const rsvp = isRecord(runtimeConfig.config.rsvp) ? runtimeConfig.config.rsvp : null;
+    return isRecord(rsvp?.aisleplanner) ? rsvp.aisleplanner : null;
+}
+function resolveCredentials(runtimeConfig) {
+    const aisleplanner = runtimeRsvpConfig(runtimeConfig);
+    const username = text(aisleplanner?.username);
+    const password = text(aisleplanner?.password);
+    return username && password ? { username, password } : null;
+}
+function bluebubblesAttachmentReady(machineRuntimeConfig) {
+    if (!machineRuntimeConfig?.ok)
+        return false;
+    const bluebubbles = isRecord(machineRuntimeConfig.config.bluebubbles) ? machineRuntimeConfig.config.bluebubbles : null;
+    return !!text(bluebubbles?.serverUrl) && !!text(bluebubbles?.password);
+}
+function redacted(config, runtimeConfig, machineRuntimeConfig) {
+    return {
+        config,
+        credentials: {
+            itemPath: runtimeConfig.itemPath,
+            aisleplanner: resolveCredentials(runtimeConfig) ? "present" : "missing",
+        },
+        bluebubblesAttachment: {
+            itemPath: machineRuntimeConfig?.itemPath ?? "missing",
+            status: bluebubblesAttachmentReady(machineRuntimeConfig) ? "present" : "missing",
+        },
+    };
+}
+function validateRsvpReadiness(input) {
+    const configResult = input.config ?? readRsvpConfig(input.agentRoot);
+    const checks = [];
+    let config;
+    if (!configResult.ok) {
+        checks.push(check("rsvp.native_config", "fail", "agent-runnable", `${configResult.message}: ${configResult.path}`));
+        return {
+            status: "blocked",
+            checks,
+            redacted: redacted(undefined, input.runtimeConfig, input.machineRuntimeConfig),
+        };
+    }
+    config = configResult.config;
+    checks.push(check("rsvp.native_config", "pass", "agent-runnable", configResult.path));
+    const missingSource = [];
+    if (!text(config.source.weddingId))
+        missingSource.push("weddingId");
+    if (!text(config.source.eventId))
+        missingSource.push("eventId");
+    checks.push(missingSource.length === 0
+        ? check("rsvp.aisleplanner_source", "pass", "agent-runnable", `${config.source.weddingId}/${config.source.eventId}`)
+        : check("rsvp.aisleplanner_source", "fail", "agent-runnable", `missing ${missingSource.join("/")}`));
+    const credentials = resolveCredentials(input.runtimeConfig);
+    if (credentials) {
+        checks.push(check("rsvp.aisleplanner_credentials", "pass", "human-required", `${input.runtimeConfig.itemPath}: present`));
+    }
+    else if (input.runtimeConfig.ok) {
+        checks.push(check("rsvp.aisleplanner_credentials", "fail", "human-required", `${input.runtimeConfig.itemPath}: missing rsvp.aisleplanner username/password`));
+    }
+    else {
+        checks.push(check("rsvp.aisleplanner_credentials", "fail", "human-required", `${input.runtimeConfig.itemPath}: ${input.runtimeConfig.error}`));
+    }
+    const chatGuid = text(config.bluebubblesRoute.chatGuid);
+    checks.push(chatGuid
+        ? check("rsvp.bluebubbles_route", "pass", "agent-runnable", chatGuid)
+        : check("rsvp.bluebubbles_route", "fail", "agent-runnable", "missing bluebubblesRoute.chatGuid"));
+    if (bluebubblesAttachmentReady(input.machineRuntimeConfig)) {
+        checks.push(check("rsvp.bluebubbles_attachment", "pass", "agent-runnable", `${input.machineRuntimeConfig.itemPath}: present`));
+    }
+    else if (input.machineRuntimeConfig?.ok) {
+        checks.push(check("rsvp.bluebubbles_attachment", "fail", "agent-runnable", `${input.machineRuntimeConfig.itemPath}: missing bluebubbles.serverUrl/password`));
+    }
+    else {
+        checks.push(check("rsvp.bluebubbles_attachment", "fail", "agent-runnable", `${input.machineRuntimeConfig?.itemPath ?? "machine runtime/config"}: ${input.machineRuntimeConfig?.error ?? "missing"}`));
+    }
+    const status = checks.every((entry) => entry.status === "pass") ? "ready" : "blocked";
+    const base = {
+        status,
+        checks,
+        config,
+        redacted: redacted(config, input.runtimeConfig, input.machineRuntimeConfig),
+    };
+    return status === "ready" && credentials
+        ? { ...base, status: "ready", credentials }
+        : { ...base, status: "blocked" };
+}
+function fail(reason, actor, message) {
+    return { ok: false, reason, actor, message };
+}
+function redactKnownSecrets(message, secrets) {
+    let redactedMessage = message;
+    for (const secret of secrets.filter((value) => value.length > 0)) {
+        redactedMessage = redactedMessage.split(secret).join("[redacted]");
+    }
+    return redactedMessage;
+}
+function readLegacyConfig(legacyRoot) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.join(legacyRoot, "config.json"), "utf-8"));
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function legacyConfigExists(legacyRoot) {
+    return fs.existsSync(path.join(legacyRoot, "config.json"));
+}
+async function importLegacyRsvpConfig(input) {
+    if (!input.confirm) {
+        return fail("confirmation_required", "human-required", "legacy RSVP config import requires explicit confirmation");
+    }
+    if (!legacyConfigExists(input.legacyRoot)) {
+        return fail("missing_legacy_config", "agent-runnable", "legacy RSVP config.json is missing");
+    }
+    const legacy = readLegacyConfig(input.legacyRoot);
+    if (!legacy)
+        return fail("malformed_legacy_config", "agent-runnable", "legacy RSVP config.json is malformed");
+    const aisleplanner = isRecord(legacy.aisleplanner) ? legacy.aisleplanner : null;
+    const bluebubbles = isRecord(legacy.bluebubbles) ? legacy.bluebubbles : null;
+    const username = text(aisleplanner?.username);
+    const password = text(aisleplanner?.password);
+    if (!username || !password) {
+        return fail("missing_secret", "human-required", "legacy RSVP config is missing AislePlanner username/password");
+    }
+    const weddingId = idText(aisleplanner?.wedding_id);
+    const eventId = idText(aisleplanner?.event_id);
+    const chatGuid = text(bluebubbles?.chat_guid);
+    if (!weddingId || !eventId || !chatGuid) {
+        return fail("missing_coordinates", "agent-runnable", "legacy RSVP config is missing wedding_id/event_id/bluebubbles.chat_guid");
+    }
+    const now = input.now ?? new Date();
+    const merge = input.mergeRuntimeConfig ?? runtime_credentials_1.mergeRuntimeCredentialConfig;
+    let runtimeConfig;
+    try {
+        runtimeConfig = await merge(input.agent, {
+            rsvp: {
+                aisleplanner: {
+                    username,
+                    password,
+                },
+            },
+        }, now);
+    }
+    catch (error) {
+        const message = redactKnownSecrets(String(error), [username, password]);
+        return fail("vault_unavailable", "human-required", `could not write AislePlanner credentials to runtime/config: ${message}`);
+    }
+    const nativeConfig = {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_CONFIG_POLICY_VERSION,
+        agent: input.agent,
+        mode: input.mode,
+        source: {
+            kind: "aisleplanner",
+            weddingId,
+            eventId,
+        },
+        credentialRef: {
+            runtimeConfigItem: "runtime/config",
+            runtimeConfigPath: "rsvp.aisleplanner",
+        },
+        bluebubblesRoute: {
+            chatGuid,
+            ...(optionalText(bluebubbles?.account_id) ? { accountId: optionalText(bluebubbles?.account_id) } : {}),
+        },
+        cutover: {
+            legacyRoot: input.legacyRoot,
+        },
+    };
+    let configPath;
+    try {
+        configPath = writeRsvpConfig(input.agentRoot, nativeConfig);
+    }
+    catch (error) {
+        const message = String(error);
+        return fail("write_failed", "agent-runnable", `could not write native RSVP config: ${message}`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.legacy_config_imported",
+        message: "imported legacy RSVP config into native config and runtime credentials",
+        meta: { agent: input.agent, mode: input.mode, configPath, runtimeConfigItem: runtimeConfig.itemPath },
+    });
+    return {
+        ok: true,
+        configPath,
+        runtimeConfigItem: runtimeConfig.itemPath,
+        redactedConfig: {
+            source: nativeConfig.source,
+            bluebubblesRoute: nativeConfig.bluebubblesRoute,
+            mode: nativeConfig.mode,
+        },
+    };
+}