@ouro.bot/cli 0.1.0-alpha.72 → 0.1.0-alpha.720

package/dist/rsvp/native-habit-runner.js

@@ -0,0 +1,322 @@
+"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.runNativeRsvpHabit = runNativeRsvpHabit;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const habit_parser_1 = require("../heart/habits/habit-parser");
+const habit_runtime_state_1 = require("../heart/habits/habit-runtime-state");
+const habit_session_1 = require("../heart/habits/habit-session");
+const run_ledger_1 = require("../heart/run-ledger");
+const spend_ledger_1 = require("./spend-ledger");
+const habit_policy_1 = require("./habit-policy");
+const runtime_1 = require("../nerves/runtime");
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function nowIso(now) {
+    const value = now ? now() : new Date();
+    return value instanceof Date ? value.toISOString() : value;
+}
+function nativeRunId(input) {
+    const digest = sha256Hex(JSON.stringify({
+        agent: input.agent,
+        habitName: input.habitName,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId ?? null,
+    })).slice(0, 24);
+    return `rsvp-${input.trigger}-${digest}`;
+}
+function noopCliDeps(input, agentRoot) {
+    return {
+        socketPath: "",
+        sendCommand: async () => ({ ok: false, error: "daemon socket unavailable in native RSVP habit runner" }),
+        startDaemonProcess: async () => ({ pid: null }),
+        writeStdout: () => undefined,
+        checkSocketAlive: async () => false,
+        cleanupStaleSocket: () => undefined,
+        fallbackPendingMessage: () => "daemon socket unavailable in native RSVP habit runner",
+        bundlesRoot: input.bundlesRoot,
+        agentBundleRoot: agentRoot,
+    };
+}
+async function defaultRunRefresh(command, deps) {
+    const { runRsvpCliCommand } = await Promise.resolve().then(() => __importStar(require("./cli")));
+    return runRsvpCliCommand(command, deps);
+}
+function parseRefreshPayload(text) {
+    const parsed = JSON.parse(text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("RSVP refresh returned a non-object payload");
+    }
+    return parsed;
+}
+function refreshCommandFor(input, sendAllowed, mode) {
+    return {
+        kind: "rsvp.refresh",
+        agent: input.agent,
+        habitName: input.habitName,
+        mode,
+        json: true,
+        ...(sendAllowed ? { allowSend: true } : { noSend: true }),
+    };
+}
+function permissionEnvelope(sendAllowed) {
+    return {
+        schemaVersion: 1,
+        canMessageOutward: sendAllowed,
+        returnRoutes: sendAllowed
+            ? [{ kind: "family", recipient: "family", status: "allowed" }]
+            : [],
+        deniedTools: sendAllowed ? [] : ["send_message", "surface"],
+        warnings: [],
+    };
+}
+function toolPolicy(sendAllowed) {
+    return {
+        requestedTools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        grantedTools: [...habit_policy_1.RSVP_HABIT_ALLOWED_TOOLS],
+        deniedTools: [],
+        outwardMessagingAllowed: sendAllowed,
+    };
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function refreshRecord(payload) {
+    const value = payload.refresh;
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function producedRefsFor(payload) {
+    if (payload.sendAllowed === true)
+        return [];
+    const snapshotId = stringField(refreshRecord(payload) ?? {}, "snapshotId");
+    return snapshotId ? [{ kind: "none", locator: `state/rsvp/snapshots/${snapshotId}.json` }] : [];
+}
+function surfaceAttemptsFor(payload, requestedSend, errorMessage) {
+    if (payload.sendAllowed === true) {
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "status",
+                result: "sent",
+            }];
+    }
+    if (requestedSend && errorMessage) {
+        return [{
+                recipient: "rsvp",
+                channel: "bluebubbles",
+                reason: "blocked",
+                result: "blocked",
+                error: errorMessage,
+            }];
+    }
+    return [];
+}
+function payloadError(payload) {
+    if (payload.ok === false || typeof payload.requires === "string") {
+        return stringField(payload, "message") ?? "RSVP refresh did not complete";
+    }
+    return null;
+}
+function recordNativeRunLedger(input) {
+    const target = {
+        habitName: input.habitName,
+        runId: input.runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId ?? null,
+        command: "rsvp.refresh",
+    };
+    const record = (0, run_ledger_1.createRunLedgerRecord)({
+        agent: input.agent,
+        triggerType: "habit",
+        sourceKind: "daemon",
+        senseOrHabit: input.habitName,
+        lifecycle: input.lifecycle,
+        startedAt: input.startedAt,
+        ...(input.endedAt ? { endedAt: input.endedAt } : {}),
+        ...(input.lifecycle === "completed" || input.lifecycle === "error"
+            ? { usage: (0, run_ledger_1.usageMetadataFromUsageData)(undefined, "none") }
+            : {}),
+        target,
+        idempotencyScope: target,
+        sessionRef: {
+            channel: "rsvp",
+            keyHash: `sha256:${sha256Hex(input.runId)}`,
+        },
+    });
+    (0, run_ledger_1.appendRunLedgerRecordNonFatal)(input.agentRoot, record);
+    try {
+        (0, spend_ledger_1.recordRsvpSpendLedgerRun)(input.agentRoot, record);
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_spend_ledger_error",
+            message: "failed to record native RSVP habit spend ledger row",
+            meta: { runId: input.runId, lifecycle: input.lifecycle, error: String(error) },
+        });
+    }
+}
+async function runNativeRsvpHabit(input) {
+    const agentRoot = path.join(input.bundlesRoot, `${input.agent}.ouro`);
+    const habitPath = path.join(agentRoot, "habits", `${input.habitName}.md`);
+    const startedAt = nowIso(input.now);
+    const runId = nativeRunId(input);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.native_habit_start",
+        message: "native RSVP habit starting",
+        meta: {
+            agent: input.agent,
+            habitName: input.habitName,
+            trigger: input.trigger,
+            occurrenceId: input.occurrenceId ?? null,
+            runId,
+        },
+    });
+    const habit = (0, habit_runtime_state_1.applyHabitRuntimeState)(agentRoot, (0, habit_parser_1.parseHabitFile)(fs.readFileSync(habitPath, "utf-8"), habitPath));
+    if (!habit.rsvp)
+        throw new Error(`RSVP habit metadata is required before native execution: ${input.habitName}`);
+    const policy = (0, habit_policy_1.rsvpHabitRuntimePolicy)(habit.rsvp);
+    const command = refreshCommandFor(input, policy.sendAllowed, habit.rsvp.mode);
+    const deps = noopCliDeps(input, agentRoot);
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        lifecycle: "started",
+    });
+    let payload;
+    let errorMessage = null;
+    try {
+        payload = parseRefreshPayload(await (input.runRefresh ?? defaultRunRefresh)(command, deps));
+        errorMessage = payloadError(payload);
+    }
+    catch (error) {
+        payload = {
+            ok: false,
+            command: "rsvp.refresh",
+            sideEffect: false,
+            agent: input.agent,
+            mode: habit.rsvp.mode,
+            message: error instanceof Error ? error.message : String(error),
+        };
+        errorMessage = stringField(payload, "message") ?? "RSVP refresh failed";
+    }
+    const endedAt = nowIso(input.now);
+    const lifecycle = errorMessage ? "error" : "completed";
+    const surfaceAttempts = surfaceAttemptsFor(payload, policy.sendAllowed, errorMessage);
+    const errors = errorMessage ? [errorMessage] : [];
+    recordNativeRunLedger({
+        agentRoot,
+        agent: input.agent,
+        habitName: input.habitName,
+        runId,
+        trigger: input.trigger,
+        occurrenceId: input.occurrenceId,
+        startedAt,
+        endedAt,
+        lifecycle,
+    });
+    const completion = (0, habit_session_1.completeHabitRun)({
+        agentRoot,
+        habit,
+        runId,
+        trigger: input.trigger,
+        startedAt,
+        endedAt,
+        operationId: `rsvp-native:${input.trigger}:${input.occurrenceId ?? runId}`,
+        permissionEnvelope: permissionEnvelope(policy.sendAllowed),
+        toolPolicy: toolPolicy(policy.sendAllowed),
+        producedRefs: producedRefsFor(payload),
+        surfaceAttempts,
+        errors,
+        summarySnapshot: {
+            summary: errorMessage
+                ? `Native RSVP habit failed: ${errorMessage}`
+                : "Native RSVP habit completed.",
+            decisions: [
+                `mode=${habit.rsvp.mode}`,
+                `sendAllowed=${String(policy.sendAllowed)}`,
+            ],
+            nextLikelyStep: null,
+        },
+    });
+    const ok = lifecycle === "completed" && completion.receiptWritten && completion.runtimeStateRecorded;
+    const message = ok
+        ? `native RSVP habit ${input.habitName} completed for ${input.agent}`
+        : `native RSVP habit ${input.habitName} failed for ${input.agent}: ${errorMessage ?? "runtime state was not recorded"}`;
+    const terminalEventMeta = {
+        agent: input.agent,
+        habitName: input.habitName,
+        trigger: input.trigger,
+        runId,
+        lifecycle,
+        receiptWritten: completion.receiptWritten,
+        runtimeStateRecorded: completion.runtimeStateRecorded,
+    };
+    if (lifecycle === "completed") {
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.native_habit_end",
+            message,
+            meta: terminalEventMeta,
+        });
+    }
+    else {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            component: "rsvp",
+            event: "rsvp.native_habit_error",
+            message,
+            meta: terminalEventMeta,
+        });
+    }
+    return {
+        ok,
+        message,
+        lifecycle,
+        runId,
+        payload,
+    };
+}

package/dist/rsvp/outbound-state.js

@@ -0,0 +1,268 @@
+"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_OUTBOUND_STATE_POLICY_VERSION = void 0;
+exports.readRsvpOutboundState = readRsvpOutboundState;
+exports.ensureRsvpOutboundState = ensureRsvpOutboundState;
+exports.writeRsvpBaseline = writeRsvpBaseline;
+exports.decideRsvpOutboundReport = decideRsvpOutboundReport;
+exports.recordRsvpOutboundAttempt = recordRsvpOutboundAttempt;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const runtime_1 = require("../nerves/runtime");
+exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = "rsvp-outbound-state/v1";
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function hashString(input) {
+    return `sha256:${sha256Hex(input)}`;
+}
+function rsvpOutboundStatePath(agentRoot) {
+    return path.join(agentRoot, "state", "rsvp", "outbound-state.json");
+}
+function emptyState(now) {
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+        updatedAt: now,
+        pendingReports: [],
+    };
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function reportHash(reportText) {
+    return hashString(reportText.trim().replace(/\s+/g, " "));
+}
+function idempotencyKeyFor(snapshot, reportText) {
+    return [
+        "rsvp-report",
+        snapshot.agent,
+        snapshot.source.weddingId,
+        snapshot.source.eventId,
+        snapshot.snapshotId,
+        reportHash(reportText).slice("sha256:".length, "sha256:".length + 16),
+    ].join(":");
+}
+function isBaseline(value) {
+    const row = value;
+    return !!row
+        && typeof row.snapshotId === "string"
+        && typeof row.contentHash === "string"
+        && typeof row.recordedAt === "string"
+        && typeof row.reason === "string";
+}
+function isPending(value) {
+    const row = value;
+    return !!row
+        && typeof row.snapshotId === "string"
+        && typeof row.contentHash === "string"
+        && typeof row.reportHash === "string"
+        && typeof row.reportLength === "number"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.bluebubblesRecordId === "string"
+        && typeof row.status === "string"
+        && typeof row.recordedAt === "string"
+        && typeof row.updatedAt === "string"
+        && row.contentStored === false;
+}
+function isState(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.RSVP_OUTBOUND_STATE_POLICY_VERSION
+        && typeof row.updatedAt === "string"
+        && (row.baseline === undefined || isBaseline(row.baseline))
+        && Array.isArray(row.pendingReports);
+}
+function readRsvpOutboundState(agentRoot) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (!fs.existsSync(filePath))
+        return emptyState(new Date().toISOString());
+    try {
+        const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+        if (!isState(parsed))
+            return emptyState(new Date().toISOString());
+        return {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: parsed.updatedAt,
+            ...(parsed.baseline ? { baseline: parsed.baseline } : {}),
+            pendingReports: parsed.pendingReports.filter(isPending),
+        };
+    }
+    catch {
+        return emptyState(new Date().toISOString());
+    }
+}
+function writeState(agentRoot, state) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(state, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+    return state;
+}
+function ensureRsvpOutboundState(agentRoot, now = new Date().toISOString()) {
+    const filePath = rsvpOutboundStatePath(agentRoot);
+    if (fs.existsSync(filePath))
+        return readRsvpOutboundState(agentRoot);
+    const state = writeState(agentRoot, emptyState(now));
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_state_initialized",
+        message: "initialized RSVP outbound state",
+        meta: { updatedAt: state.updatedAt },
+    });
+    return state;
+}
+function writeRsvpBaseline(input) {
+    const current = readRsvpOutboundState(input.agentRoot);
+    const state = writeState(input.agentRoot, {
+        schemaVersion: 1,
+        policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+        updatedAt: input.recordedAt,
+        baseline: {
+            snapshotId: input.snapshot.snapshotId,
+            contentHash: input.snapshot.contentHash,
+            recordedAt: input.recordedAt,
+            reason: input.reason,
+        },
+        pendingReports: current.pendingReports.filter((entry) => entry.snapshotId !== input.snapshot.snapshotId),
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_baseline_written",
+        message: "wrote RSVP outbound baseline",
+        meta: { snapshotId: input.snapshot.snapshotId, reason: input.reason },
+    });
+    return state;
+}
+function decideRsvpOutboundReport(input) {
+    const state = readRsvpOutboundState(input.agentRoot);
+    const idempotencyKey = idempotencyKeyFor(input.currentSnapshot, input.reportText);
+    const currentSnapshotId = input.currentSnapshot.snapshotId;
+    const report = reportHash(input.reportText);
+    if (state.baseline?.snapshotId === currentSnapshotId
+        && state.baseline.contentHash === input.currentSnapshot.contentHash) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "rsvp",
+            event: "rsvp.outbound_decision",
+            message: "decided RSVP report outbound action",
+            meta: { action: "skip", snapshotId: currentSnapshotId },
+        });
+        return {
+            action: "skip",
+            reason: "baseline-current",
+            currentSnapshotId,
+            idempotencyKey,
+            reportText: input.reportText,
+        };
+    }
+    const existingPending = state.pendingReports.find((entry) => entry.snapshotId === currentSnapshotId && entry.reportHash === report);
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_decision",
+        message: "decided RSVP report outbound action",
+        meta: { action: "send", snapshotId: currentSnapshotId, existingPending: Boolean(existingPending), now: nowIso(input.now) },
+    });
+    return {
+        action: "send",
+        currentSnapshotId,
+        idempotencyKey,
+        reportText: input.reportText,
+        ...(existingPending ? { existingPending } : {}),
+    };
+}
+function isAdvanceStatus(status) {
+    return status === "accepted" || status === "enqueued" || status === "local-visible" || status === "delivered";
+}
+function pendingReportFor(input) {
+    const normalized = input.reportText.trim().replace(/\s+/g, " ");
+    return {
+        snapshotId: input.currentSnapshot.snapshotId,
+        contentHash: input.currentSnapshot.contentHash,
+        reportHash: reportHash(input.reportText),
+        reportLength: normalized.length,
+        idempotencyKey: idempotencyKeyFor(input.currentSnapshot, input.reportText),
+        bluebubblesRecordId: input.bluebubblesRecord.recordId,
+        status: input.bluebubblesRecord.status,
+        ...(input.bluebubblesRecord.tempGuid?.trim() ? { tempGuid: input.bluebubblesRecord.tempGuid.trim() } : {}),
+        ...(input.bluebubblesRecord.messageGuid?.trim() ? { messageGuid: input.bluebubblesRecord.messageGuid.trim() } : {}),
+        recordedAt: input.recordedAt,
+        updatedAt: input.recordedAt,
+        contentStored: false,
+    };
+}
+function recordRsvpOutboundAttempt(input) {
+    const current = readRsvpOutboundState(input.agentRoot);
+    const pending = pendingReportFor(input);
+    const remainingPending = current.pendingReports.filter((entry) => entry.snapshotId !== pending.snapshotId || entry.reportHash !== pending.reportHash);
+    const state = isAdvanceStatus(input.bluebubblesRecord.status)
+        ? writeState(input.agentRoot, {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: input.recordedAt,
+            baseline: {
+                snapshotId: input.currentSnapshot.snapshotId,
+                contentHash: input.currentSnapshot.contentHash,
+                recordedAt: input.recordedAt,
+                reason: "bluebubbles-outbound-accepted",
+                bluebubblesRecordId: input.bluebubblesRecord.recordId,
+                advancedBy: input.bluebubblesRecord.status,
+            },
+            pendingReports: remainingPending,
+        })
+        : writeState(input.agentRoot, {
+            schemaVersion: 1,
+            policyVersion: exports.RSVP_OUTBOUND_STATE_POLICY_VERSION,
+            updatedAt: input.recordedAt,
+            ...(current.baseline ? { baseline: current.baseline } : {}),
+            pendingReports: [...remainingPending, pending],
+        });
+    (0, runtime_1.emitNervesEvent)({
+        component: "rsvp",
+        event: "rsvp.outbound_attempt_recorded",
+        message: "recorded RSVP outbound attempt",
+        meta: {
+            snapshotId: input.currentSnapshot.snapshotId,
+            bluebubblesRecordId: input.bluebubblesRecord.recordId,
+            status: input.bluebubblesRecord.status,
+            baselineAdvanced: isAdvanceStatus(input.bluebubblesRecord.status),
+        },
+    });
+    return state;
+}