@ouro.bot/cli 0.1.0-alpha.723 → 0.1.0-alpha.725

package/dist/rsvp/outbound-state.js

@@ -34,6 +34,8 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = void 0;
+exports.classifyRsvpSendBoundary = classifyRsvpSendBoundary;
+exports.executeRsvpSendBoundary = executeRsvpSendBoundary;
 exports.readRsvpOutboundState = readRsvpOutboundState;
 exports.ensureRsvpOutboundState = ensureRsvpOutboundState;
 exports.writeRsvpBaseline = writeRsvpBaseline;
@@ -42,11 +44,369 @@ exports.recordRsvpOutboundAttempt = recordRsvpOutboundAttempt;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
+const habit_lifecycle_1 = require("../heart/habits/habit-lifecycle");
+const habit_parser_1 = require("../heart/habits/habit-parser");
 const runtime_1 = require("../nerves/runtime");
 exports.RSVP_OUTBOUND_STATE_POLICY_VERSION = "rsvp-outbound-state/v1";
+const AMBIGUOUS_HTTP_STATUSES = new Set([408, 409, 425, 429]);
+const retainedRsvpSendLeases = new Map();
+function classifyRsvpSendBoundary(observation) {
+    if (!observation.transportInvoked)
+        return "not_crossed";
+    const messageGuid = observation.messageGuid?.trim() ?? "";
+    if (observation.httpStatus !== null
+        && observation.httpStatus >= 200
+        && observation.httpStatus <= 299
+        && messageGuid.length > 0)
+        return "crossed";
+    if (observation.httpStatus !== null
+        && observation.httpStatus >= 400
+        && observation.httpStatus <= 499
+        && !AMBIGUOUS_HTTP_STATUSES.has(observation.httpStatus))
+        return "not_crossed";
+    return "crossing_unknown";
+}
 function sha256Hex(input) {
     return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
 }
+function lifecycleNowIso(deps) {
+    return (deps.now?.() ?? new Date()).toISOString();
+}
+function lifecycleErrorCode(error, fallback) {
+    return error instanceof habit_lifecycle_1.HabitLifecycleError ? error.code : fallback;
+}
+function emitBoundaryTelemetry(event) {
+    try {
+        (0, runtime_1.emitNervesEvent)(event);
+    }
+    catch {
+        // Observability must never mutate or obscure the durable transport boundary.
+    }
+}
+function failedBoundaryResult(operationId, errorCode, options = {}) {
+    const boundaryState = options.boundaryState ?? "not_crossed";
+    return {
+        ok: false,
+        operationId,
+        boundaryState,
+        transportInvoked: options.transportInvoked ?? false,
+        replayed: options.replayed ?? false,
+        transportResult: {
+            httpStatus: null,
+            messageGuid: null,
+            errorCode,
+        },
+        errorCode,
+    };
+}
+function currentHabitStatus(agentRoot, habitId, deps) {
+    const definitionPath = path.join(agentRoot, "habits", `${habitId}.md`);
+    try {
+        return (0, habit_parser_1.parseHabitFile)((deps.fs ?? fs).readFileSync(definitionPath, "utf8"), definitionPath).status;
+    }
+    catch (error) {
+        return (0, habit_parser_1.createDegradedHabitFile)(definitionPath, "read_error", "", String(error)).status;
+    }
+}
+function cancellationFencesSend(agentRoot, habitId, deps) {
+    return (0, habit_lifecycle_1.listHabitLifecycleJournals)({ agentRoot, habitId }, deps).some((journal) => (journal.operationKind === "cancel" && journal.generation >= 1));
+}
+function terminalBoundaryResult(journal, replayed, errorCode) {
+    const boundaryState = journal.boundaryState;
+    const transportResult = journal.transportResult;
+    const failureCode = errorCode ?? transportResult.errorCode ?? undefined;
+    return {
+        ok: boundaryState === "crossed",
+        operationId: journal.operationId,
+        boundaryState,
+        transportInvoked: journal.transportInvokedAt !== null,
+        replayed,
+        transportResult,
+        ...(boundaryState === "crossed" || failureCode === undefined ? {} : { errorCode: failureCode }),
+    };
+}
+function emitBoundaryClassified(habitId, operationId, boundaryState, transportInvoked) {
+    emitBoundaryTelemetry({
+        component: "rsvp",
+        event: "habit_send_boundary_classified",
+        message: "classified RSVP habit send boundary",
+        meta: { habitId, operationId, boundaryState, transportInvoked },
+    });
+}
+function persistBoundaryClassification(input) {
+    const boundaryState = classifyRsvpSendBoundary(input.observation);
+    const classifiedAt = lifecycleNowIso(input.deps);
+    let terminal;
+    let resultErrorCode = input.errorCode;
+    try {
+        terminal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(input.intent, {
+            state: boundaryState,
+            at: classifiedAt,
+            transportInvokedAt: input.observation.transportInvoked ? input.transportInvokedAt : null,
+            transportResult: {
+                httpStatus: input.observation.httpStatus,
+                messageGuid: input.observation.messageGuid,
+                errorCode: input.observation.errorCode,
+            },
+        });
+        (0, habit_lifecycle_1.writeHabitLifecycleJournal)(input.lease, terminal, input.deps);
+    }
+    catch {
+        const fallbackError = "classification_durability_unknown";
+        const fallbackBoundaryState = input.observation.transportInvoked
+            ? "crossing_unknown"
+            : "not_crossed";
+        terminal = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(input.intent, {
+            state: fallbackBoundaryState,
+            at: classifiedAt,
+            transportInvokedAt: input.observation.transportInvoked
+                ? input.transportInvokedAt ?? input.intent.intentAt
+                : null,
+            transportResult: {
+                httpStatus: input.observation.httpStatus,
+                messageGuid: input.observation.messageGuid,
+                errorCode: fallbackError,
+            },
+        });
+        try {
+            (0, habit_lifecycle_1.writeHabitLifecycleJournal)(input.lease, terminal, input.deps);
+        }
+        catch {
+            // The caller still reports the only safe classification when terminal durability cannot be proven.
+        }
+        resultErrorCode = fallbackError;
+    }
+    emitBoundaryClassified(input.lease.habitId, input.lease.operationId, terminal.boundaryState, terminal.transportInvokedAt !== null);
+    return terminalBoundaryResult(terminal, input.replayed, resultErrorCode);
+}
+function rsvpSendLeaseKey(agentRoot, habitId, operationId) {
+    return JSON.stringify([path.resolve(agentRoot), habitId, operationId]);
+}
+async function releaseRsvpSendLease(leaseKey, lease, deps) {
+    const lifecycle = deps.lifecycle ?? {};
+    const release = deps.releaseLifecycleLock ?? habit_lifecycle_1.releaseHabitLifecycleLock;
+    const attempts = Math.floor(habit_lifecycle_1.HABIT_LIFECYCLE_TIMEOUT_MS / habit_lifecycle_1.HABIT_LIFECYCLE_POLL_MS) + 1;
+    const wait = lifecycle.sleep ?? ((milliseconds) => new Promise((resolve) => {
+        setTimeout(resolve, milliseconds);
+    }));
+    for (let attempt = 0; attempt < attempts; attempt += 1) {
+        try {
+            if (release(lease, lifecycle)) {
+                retainedRsvpSendLeases.delete(leaseKey);
+                return true;
+            }
+        }
+        catch {
+            retainedRsvpSendLeases.set(leaseKey, lease);
+            return false;
+        }
+        if (attempt + 1 < attempts)
+            await wait(habit_lifecycle_1.HABIT_LIFECYCLE_POLL_MS);
+    }
+    retainedRsvpSendLeases.set(leaseKey, lease);
+    return false;
+}
+function transportErrorObservation(error, transportInvoked) {
+    const record = error && typeof error === "object" ? error : {};
+    const declaredInvoked = record.transportInvoked === true;
+    const httpStatus = typeof record.httpStatus === "number" && Number.isInteger(record.httpStatus)
+        ? record.httpStatus
+        : null;
+    const name = typeof record.name === "string" ? record.name : "";
+    const errorCode = typeof record.errorCode === "string" && record.errorCode.trim().length > 0
+        ? record.errorCode.trim()
+        : name === "TimeoutError"
+            ? "timeout"
+            : name === "AbortError"
+                ? "abort"
+                : error instanceof TypeError
+                    ? "socket"
+                    : transportInvoked || declaredInvoked
+                        ? "transport_error"
+                        : "validation";
+    return {
+        transportInvoked: transportInvoked || declaredInvoked,
+        httpStatus,
+        messageGuid: null,
+        errorCode,
+    };
+}
+async function executeRsvpSendBoundary(input, deps = {}) {
+    const lifecycle = deps.lifecycle ?? {};
+    const operation = (0, habit_lifecycle_1.buildHabitSendOperation)({
+        habitId: input.habitId,
+        outboundIdempotencyKey: input.outboundIdempotencyKey,
+    });
+    if (input.noSend)
+        return failedBoundaryResult(operation.operationId, "immutable_no_send");
+    const leaseKey = rsvpSendLeaseKey(input.agentRoot, input.habitId, operation.operationId);
+    let lease = retainedRsvpSendLeases.get(leaseKey);
+    try {
+        if (lease && !(0, habit_lifecycle_1.habitLifecycleLeaseIsCurrent)(lease, lifecycle)) {
+            retainedRsvpSendLeases.delete(leaseKey);
+            lease = undefined;
+        }
+        if (!lease) {
+            const lock = await (0, habit_lifecycle_1.acquireHabitLifecycleLock)({
+                agentRoot: input.agentRoot,
+                habitId: input.habitId,
+                operationId: operation.operationId,
+            }, lifecycle);
+            if (lock.status === "timeout") {
+                return failedBoundaryResult(operation.operationId, lock.error);
+            }
+            lease = lock.lease;
+        }
+    }
+    catch (error) {
+        return failedBoundaryResult(operation.operationId, lifecycleErrorCode(error, "lifecycle_lock_failed"));
+    }
+    const activeLease = lease;
+    let transportInvoked = false;
+    let transportInvokedAt = null;
+    let intent = null;
+    const markTransportInvoked = () => {
+        if (transportInvoked)
+            return;
+        transportInvoked = true;
+        transportInvokedAt = lifecycleNowIso(lifecycle);
+        emitBoundaryTelemetry({
+            component: "rsvp",
+            event: "habit_transport_invoked",
+            message: "invoked RSVP habit transport",
+            meta: { habitId: input.habitId, operationId: operation.operationId },
+        });
+    };
+    const boundaryResult = await (async () => {
+        try {
+            const existing = (0, habit_lifecycle_1.readHabitLifecycleJournal)({
+                agentRoot: input.agentRoot,
+                habitId: input.habitId,
+                operationId: operation.operationId,
+            }, lifecycle);
+            if (existing?.state === "not_crossed"
+                || existing?.state === "crossing_unknown"
+                || existing?.state === "crossed")
+                return terminalBoundaryResult(existing, true);
+            if (existing?.state === "send_intent") {
+                return persistBoundaryClassification({
+                    lease: activeLease,
+                    intent: existing,
+                    observation: {
+                        transportInvoked: true,
+                        httpStatus: null,
+                        messageGuid: null,
+                        errorCode: "recovered_unclassified_send_intent",
+                    },
+                    transportInvokedAt: existing.intentAt,
+                    replayed: true,
+                    deps: lifecycle,
+                    errorCode: "recovered_unclassified_send_intent",
+                });
+            }
+            const status = currentHabitStatus(input.agentRoot, input.habitId, lifecycle);
+            if (status !== "active") {
+                return failedBoundaryResult(operation.operationId, `habit_status_${status}`);
+            }
+            if (cancellationFencesSend(input.agentRoot, input.habitId, lifecycle)) {
+                return failedBoundaryResult(operation.operationId, "cancellation_pending");
+            }
+            intent = existing ?? (0, habit_lifecycle_1.createHabitLifecycleJournal)({
+                habitId: input.habitId,
+                operationId: operation.operationId,
+                operationKind: "send",
+                updatedAt: lifecycleNowIso(lifecycle),
+            });
+            if (existing === null)
+                (0, habit_lifecycle_1.writeHabitLifecycleJournal)(activeLease, intent, lifecycle);
+            intent = (0, habit_lifecycle_1.transitionHabitLifecycleJournal)(intent, {
+                state: "send_intent",
+                at: lifecycleNowIso(lifecycle),
+            });
+            try {
+                (0, habit_lifecycle_1.writeHabitLifecycleJournal)(activeLease, intent, lifecycle);
+            }
+            catch (error) {
+                const visible = (0, habit_lifecycle_1.readHabitLifecycleJournal)({
+                    agentRoot: input.agentRoot,
+                    habitId: input.habitId,
+                    operationId: operation.operationId,
+                }, lifecycle);
+                if (visible?.state === "send_intent") {
+                    return persistBoundaryClassification({
+                        lease: activeLease,
+                        intent: visible,
+                        observation: {
+                            transportInvoked: false,
+                            httpStatus: null,
+                            messageGuid: null,
+                            errorCode: lifecycleErrorCode(error, "lifecycle_write_failed"),
+                        },
+                        transportInvokedAt: null,
+                        replayed: false,
+                        deps: lifecycle,
+                        errorCode: lifecycleErrorCode(error, "lifecycle_write_failed"),
+                    });
+                }
+                return failedBoundaryResult(operation.operationId, lifecycleErrorCode(error, "lifecycle_write_failed"));
+            }
+            emitBoundaryTelemetry({
+                component: "rsvp",
+                event: "habit_send_intent",
+                message: "recorded durable RSVP habit send intent",
+                meta: { habitId: input.habitId, operationId: operation.operationId },
+            });
+            let observation;
+            try {
+                const result = await input.invokeTransport(markTransportInvoked);
+                const messageGuid = result?.messageGuid?.trim() || null;
+                if (messageGuid !== null && !transportInvoked)
+                    markTransportInvoked();
+                observation = {
+                    transportInvoked,
+                    httpStatus: typeof result?.httpStatus === "number" ? result.httpStatus : 200,
+                    messageGuid,
+                    errorCode: messageGuid === null ? "missing_message_guid" : null,
+                };
+            }
+            catch (error) {
+                observation = transportErrorObservation(error, transportInvoked);
+                if (observation.transportInvoked && !transportInvoked)
+                    markTransportInvoked();
+            }
+            return persistBoundaryClassification({
+                lease: activeLease,
+                intent,
+                observation,
+                transportInvokedAt,
+                replayed: false,
+                deps: lifecycle,
+            });
+        }
+        catch (error) {
+            const errorCode = lifecycleErrorCode(error, "send_boundary_failed");
+            return failedBoundaryResult(operation.operationId, errorCode, {
+                transportInvoked,
+                boundaryState: transportInvoked ? "crossing_unknown" : "not_crossed",
+            });
+        }
+    })();
+    let released = false;
+    try {
+        released = await releaseRsvpSendLease(leaseKey, activeLease, deps);
+    }
+    catch {
+        retainedRsvpSendLeases.set(leaseKey, activeLease);
+    }
+    if (!released) {
+        return {
+            ...boundaryResult,
+            ok: false,
+            errorCode: "lifecycle_lock_release_failed",
+        };
+    }
+    return boundaryResult;
+}
 function hashString(input) {
     return `sha256:${sha256Hex(input)}`;
 }

package/dist/senses/bluebubbles/client.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueBubblesSendError = void 0;
 exports.createBlueBubblesClient = createBlueBubblesClient;
 const node_crypto_1 = require("node:crypto");
 const config_1 = require("../../heart/config");
@@ -43,6 +44,21 @@ const minimax_1 = require("../../heart/providers/minimax");
 const minimax_vlm_1 = require("../../heart/providers/minimax-vlm");
 const model_1 = require("./model");
 const media_1 = require("./media");
+class BlueBubblesSendError extends Error {
+    httpStatus;
+    status;
+    errorCode;
+    transportInvoked;
+    constructor(input) {
+        super(input.message, input.cause === undefined ? undefined : { cause: input.cause });
+        this.name = "BlueBubblesSendError";
+        this.httpStatus = input.httpStatus;
+        this.status = input.httpStatus;
+        this.errorCode = input.errorCode;
+        this.transportInvoked = input.transportInvoked;
+    }
+}
+exports.BlueBubblesSendError = BlueBubblesSendError;
 function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
     const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
     const url = new URL(endpoint.replace(/^\//, ""), root);
@@ -94,6 +110,28 @@ async function parseJsonBody(response) {
 function describeCaughtValue(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function sendTransportErrorCode(error) {
+    if (error instanceof Error && error.name === "TimeoutError")
+        return "timeout";
+    if (error instanceof Error && error.name === "AbortError")
+        return "abort";
+    if (error instanceof TypeError)
+        return "socket";
+    return "transport_error";
+}
+function emitBlueBubblesSendError(input) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "error",
+        component: "senses",
+        event: "senses.bluebubbles_send_error",
+        message: "bluebubbles send failed",
+        meta: {
+            status: input.status,
+            errorCode: input.errorCode,
+            reason: input.reason,
+        },
+    });
+}
 function buildRepairUrl(baseUrl, messageGuid, password) {
     const url = buildBlueBubblesApiUrl(baseUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}`, password);
     const parsed = new URL(url);
@@ -290,27 +328,62 @@ function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(),
                     hasReplyTarget: Boolean(params.replyToMessageGuid?.trim()),
                 },
             });
-            const response = await fetch(url, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
-            });
+            const requestTimeoutSignal = AbortSignal.timeout(channelConfig.requestTimeoutMs);
+            params.onTransportInvocation?.();
+            let response;
+            try {
+                response = await fetch(url, {
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
+                    body: JSON.stringify(body),
+                    redirect: "manual",
+                    signal: params.signal
+                        ? AbortSignal.any([params.signal, requestTimeoutSignal])
+                        : requestTimeoutSignal,
+                });
+            }
+            catch (error) {
+                const errorCode = sendTransportErrorCode(error);
+                const reason = describeCaughtValue(error);
+                emitBlueBubblesSendError({ status: null, errorCode, reason });
+                throw new BlueBubblesSendError({
+                    message: `BlueBubbles send failed (${errorCode}): ${reason}`,
+                    httpStatus: null,
+                    errorCode,
+                    transportInvoked: true,
+                    cause: error,
+                });
+            }
             if (!response.ok) {
                 const errorText = await response.text().catch(() => "");
-                (0, runtime_1.emitNervesEvent)({
-                    level: "error",
-                    component: "senses",
-                    event: "senses.bluebubbles_send_error",
-                    message: "bluebubbles send failed",
-                    meta: {
-                        status: response.status,
-                        reason: errorText || "unknown",
-                    },
+                const reason = errorText || "unknown";
+                const errorCode = `http_${response.status}`;
+                emitBlueBubblesSendError({ status: response.status, errorCode, reason });
+                throw new BlueBubblesSendError({
+                    message: `BlueBubbles send failed (${response.status}): ${reason}`,
+                    httpStatus: response.status,
+                    errorCode,
+                    transportInvoked: true,
                 });
-                throw new Error(`BlueBubbles send failed (${response.status}): ${errorText || "unknown"}`);
             }
-            const payload = await parseJsonBody(response);
+            const rawPayload = await response.text();
+            let payload = null;
+            if (rawPayload.trim()) {
+                try {
+                    payload = JSON.parse(rawPayload);
+                }
+                catch (error) {
+                    const errorCode = "malformed_response";
+                    emitBlueBubblesSendError({ status: response.status, errorCode, reason: errorCode });
+                    throw new BlueBubblesSendError({
+                        message: `BlueBubbles send failed (${response.status}): malformed response`,
+                        httpStatus: response.status,
+                        errorCode,
+                        transportInvoked: true,
+                        cause: error,
+                    });
+                }
+            }
             const messageGuid = extractMessageGuid(payload);
             (0, runtime_1.emitNervesEvent)({
                 component: "senses",

package/dist/senses/bluebubbles/inbound-log.js

@@ -91,6 +91,7 @@ function recordBlueBubblesInbound(agentName, event, source) {
             chatIdentifier: event.chat.chatIdentifier ?? null,
             sessionKey: event.chat.sessionKey,
             textForAgent: event.textForAgent,
+            fromMe: event.fromMe,
             source,
         }) + "\n", "utf-8");
     }