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

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

@@ -0,0 +1,133 @@
+"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.getBlueBubblesProcessedLogPath = getBlueBubblesProcessedLogPath;
+exports.hasProcessedBlueBubblesMessage = hasProcessedBlueBubblesMessage;
+exports.hasProcessedBlueBubblesMessageGuid = hasProcessedBlueBubblesMessageGuid;
+exports.recordProcessedBlueBubblesMessage = recordProcessedBlueBubblesMessage;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+function getBlueBubblesProcessedLogPath(agentName, sessionKey) {
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "processed", `${(0, config_1.sanitizeKey)(sessionKey)}.ndjson`);
+}
+function readEntries(filePath) {
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        return raw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => JSON.parse(line))
+            .filter((entry) => typeof entry.messageGuid === "string" && typeof entry.sessionKey === "string");
+    }
+    catch {
+        return [];
+    }
+}
+function readAllEntries(agentName) {
+    const processedDir = path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "processed");
+    try {
+        return fs.readdirSync(processedDir)
+            .filter((name) => name.endsWith(".ndjson"))
+            .sort()
+            .flatMap((name) => readEntries(path.join(processedDir, name)));
+    }
+    catch {
+        return [];
+    }
+}
+function isCompletedProcessedEntry(entry) {
+    return entry.outcome !== "recovery-timeout";
+}
+function hasProcessedBlueBubblesMessage(agentName, sessionKey, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    const filePath = getBlueBubblesProcessedLogPath(agentName, sessionKey);
+    return readEntries(filePath).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
+}
+function hasProcessedBlueBubblesMessageGuid(agentName, messageGuid) {
+    if (!messageGuid.trim())
+        return false;
+    return readAllEntries(agentName).some((entry) => entry.messageGuid === messageGuid && isCompletedProcessedEntry(entry));
+}
+function recordProcessedBlueBubblesMessage(agentName, event, source, outcome) {
+    const filePath = getBlueBubblesProcessedLogPath(agentName, event.chat.sessionKey);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        if (event.messageGuid.trim() && readEntries(filePath).some((entry) => (entry.messageGuid === event.messageGuid
+            && isCompletedProcessedEntry(entry)))) {
+            return filePath;
+        }
+        fs.appendFileSync(filePath, JSON.stringify({
+            recordedAt: new Date().toISOString(),
+            messageGuid: event.messageGuid,
+            sessionKey: event.chat.sessionKey,
+            source,
+            outcome,
+        }) + "\n", "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_processed_log_error",
+            message: "failed to record bluebubbles processed sidecar log",
+            meta: {
+                agentName,
+                messageGuid: event.messageGuid,
+                sessionKey: event.chat.sessionKey,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return filePath;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_processed_logged",
+        message: "recorded handled bluebubbles message to processed sidecar log",
+        meta: {
+            agentName,
+            messageGuid: event.messageGuid,
+            sessionKey: event.chat.sessionKey,
+            source,
+            outcome,
+            path: filePath,
+        },
+    });
+    return filePath;
+}

package/dist/senses/bluebubbles/reaction-policy.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyBlueBubblesReaction = classifyBlueBubblesReaction;
+const runtime_1 = require("../../nerves/runtime");
+const POSITIVE_REACTIONS = new Set([
+    "love",
+    "like",
+    "laugh",
+    "emphasize",
+]);
+function classifyBlueBubblesReaction(input) {
+    let decision;
+    if (input.fromMe) {
+        decision = { route: "capture_only", outcome: "ignored_self" };
+    }
+    else if (input.action === "remove") {
+        decision = { route: "capture_only", outcome: "capture_only_removal" };
+    }
+    else if (POSITIVE_REACTIONS.has(input.canonicalValue)) {
+        decision = { route: "capture_only", outcome: "capture_only_positive" };
+    }
+    else if (input.canonicalValue === "custom") {
+        decision = { route: "capture_only", outcome: "capture_only_custom" };
+    }
+    else if (input.canonicalValue === "unknown") {
+        decision = { route: "capture_only", outcome: "capture_only_unknown" };
+    }
+    else if (input.canonicalValue === "question") {
+        decision = { route: "capture_only", outcome: "capture_only_question" };
+    }
+    else {
+        decision = { route: "capture_only", outcome: "capture_only_negative" };
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_reaction_policy_evaluated",
+        message: "evaluated bluebubbles reaction routing policy",
+        meta: {
+            action: input.action,
+            canonicalValue: input.canonicalValue,
+            fromMe: input.fromMe,
+            route: decision.route,
+            outcome: decision.outcome,
+        },
+    });
+    return decision;
+}

package/dist/senses/bluebubbles/replay.js

@@ -0,0 +1,284 @@
+"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.replayBlueBubblesFixture = replayBlueBubblesFixture;
+exports.replayJuly9BlueBubblesContextFixture = replayJuly9BlueBubblesContextFixture;
+exports.replayBlueBubblesMessage = replayBlueBubblesMessage;
+exports.formatBlueBubblesReplayText = formatBlueBubblesReplayText;
+const fs = __importStar(require("node:fs"));
+const render_1 = require("../../heart/attachments/render");
+const bluebubbles_1 = require("../../heart/attachments/sources/bluebubbles");
+const machine_identity_1 = require("../../heart/machine-identity");
+const identity_1 = require("../../heart/identity");
+const runtime_credentials_1 = require("../../heart/runtime-credentials");
+const runtime_1 = require("../../nerves/runtime");
+const client_1 = require("./client");
+const model_1 = require("./model");
+function buildReplayHint(probeEventType, event) {
+    if (probeEventType === "updated-message"
+        && event.kind === "mutation"
+        && (event.mutationType === "read" || event.mutationType === "delivery")) {
+        return "replay resolved to a state-only mutation; rerun with --event-type new-message to inspect the original message payload.";
+    }
+    return undefined;
+}
+function isRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function requiredString(record, key) {
+    const value = record[key];
+    if (typeof value !== "string" || value.trim().length === 0)
+        throw new Error(`bluebubbles fixture missing ${key}`);
+    return value.trim();
+}
+async function replayBlueBubblesFixture(input) {
+    const fixture = input.fixture;
+    if (fixture.schemaVersion !== 1 || fixture.policyVersion !== "bluebubbles-replay/v1") {
+        throw new Error("unsupported BlueBubbles replay fixture");
+    }
+    const expected = isRecord(fixture.expected) ? fixture.expected : null;
+    const privacy = isRecord(fixture.privacy) ? fixture.privacy : null;
+    if (!expected || !privacy || privacy.rawTranscriptStored !== false || privacy.searchIndex !== false || privacy.vectorIndex !== false) {
+        throw new Error("BlueBubbles replay fixture must be minimized and private");
+    }
+    const result = {
+        sideEffect: false,
+        contextPacketHash: requiredString(expected, "contextPacketHash"),
+        modelInputHash: requiredString(expected, "modelInputHash"),
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_fixture_replayed",
+        message: "replayed bluebubbles fixture offline",
+        meta: { contextPacketHash: result.contextPacketHash, modelInputHash: result.modelInputHash },
+    });
+    return result;
+}
+function readJsonManifest(filePath) {
+    const parsed = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    if (!isRecord(parsed))
+        throw new Error("replay manifest must be an object");
+    return parsed;
+}
+function manifestExpected(manifest) {
+    const expected = isRecord(manifest.expected) ? manifest.expected : null;
+    if (!expected)
+        throw new Error("July 9 replay manifest missing expected block");
+    return expected;
+}
+function july9PrivacyViolations(manifest) {
+    const privacy = isRecord(manifest.privacy) ? manifest.privacy : null;
+    if (!privacy)
+        return ["privacy"];
+    const violations = [];
+    if (privacy.rawLiveTranscriptStored !== false)
+        violations.push("rawLiveTranscriptStored");
+    if (privacy.credentialsStored !== false)
+        violations.push("credentialsStored");
+    if (privacy.searchIndex !== false)
+        violations.push("searchIndex");
+    if (privacy.vectorIndex !== false)
+        violations.push("vectorIndex");
+    return violations;
+}
+function assertJuly9ReplayPrivacy(manifest) {
+    const violations = july9PrivacyViolations(manifest);
+    if (violations.length > 0) {
+        throw new Error(`July 9 replay fixture must be repo-safe and non-indexed: ${violations.join(", ")}`);
+    }
+}
+function manifestMessages(manifest) {
+    const conversation = isRecord(manifest.conversation) ? manifest.conversation : null;
+    const messages = conversation && Array.isArray(conversation.messages) ? conversation.messages : [];
+    return messages.filter(isRecord);
+}
+function optionalString(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function messageLine(message) {
+    const timestamp = optionalString(message, "timestamp");
+    const author = optionalString(message, "authorLabel");
+    const body = optionalString(message, "body");
+    if (!timestamp || !author || !body)
+        return null;
+    return `[${timestamp}] ${author}: ${body}`;
+}
+async function replayJuly9BlueBubblesContextFixture(input) {
+    const manifest = readJsonManifest(input.manifestPath);
+    if (manifest.schemaVersion !== 1 || manifest.policyVersion !== "july-9-rsvp-regression/v1") {
+        throw new Error("unsupported July 9 replay manifest");
+    }
+    assertJuly9ReplayPrivacy(manifest);
+    const expected = manifestExpected(manifest);
+    const modelInput = manifestMessages(manifest)
+        .map(messageLine)
+        .filter((line) => !!line)
+        .join("\n\n");
+    const result = {
+        sideEffect: false,
+        contextPacketHash: requiredString(expected, "contextPacketHash"),
+        renderedModelInputHash: requiredString(expected, "renderedModelInputHash"),
+        modelInput,
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_july9_fixture_replayed",
+        message: "replayed July 9 BlueBubbles context fixture",
+        meta: {
+            contextPacketHash: result.contextPacketHash,
+            renderedModelInputHash: result.renderedModelInputHash,
+            messageCount: manifestMessages(manifest).length,
+        },
+    });
+    return result;
+}
+async function replayBlueBubblesMessage(params, deps = {}) {
+    const agentName = params.agentName.trim();
+    const messageGuid = params.messageGuid.trim();
+    const eventType = params.eventType ?? "new-message";
+    if (!agentName) {
+        throw new Error("bluebubbles replay requires agentName");
+    }
+    if (!messageGuid) {
+        throw new Error("bluebubbles replay requires messageGuid");
+    }
+    const setReplayAgentName = deps.setAgentName ?? identity_1.setAgentName;
+    const resetReplayIdentity = deps.resetIdentity ?? identity_1.resetIdentity;
+    const normalizeEvent = deps.normalizeEvent ?? model_1.normalizeBlueBubblesEvent;
+    const loadMachineId = deps.loadMachineId ?? (() => (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId);
+    const refreshMachineRuntimeConfig = deps.refreshMachineRuntimeConfig ?? runtime_credentials_1.refreshMachineRuntimeCredentialConfig;
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_replay_start",
+        message: "starting bluebubbles historical replay",
+        meta: {
+            agentName,
+            messageGuid,
+            eventType,
+        },
+    });
+    setReplayAgentName(agentName);
+    try {
+        if (!deps.createClient) {
+            const machineId = loadMachineId();
+            await refreshMachineRuntimeConfig(agentName, machineId, { preserveCachedOnFailure: true });
+        }
+        const client = deps.createClient ? deps.createClient() : (0, client_1.createBlueBubblesClient)();
+        const probe = normalizeEvent({
+            type: eventType,
+            data: {
+                guid: messageGuid,
+                hasPayloadData: true,
+            },
+        });
+        const event = await client.repairEvent(probe);
+        const attachmentRecords = event.kind === "message"
+            ? event.attachments
+                .filter((attachment) => typeof attachment.guid === "string" && attachment.guid.trim().length > 0)
+                .map((attachment) => (0, bluebubbles_1.buildBlueBubblesAttachmentRecord)(attachment))
+            : [];
+        const result = {
+            probe: {
+                agentName,
+                messageGuid,
+                eventType,
+            },
+            event,
+            attachmentIds: attachmentRecords.map((attachment) => attachment.id),
+            attachmentBlock: (0, render_1.renderAttachmentBlock)(attachmentRecords),
+            ...(buildReplayHint(eventType, event) ? { hint: buildReplayHint(eventType, event) } : {}),
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_replay_end",
+            message: "completed bluebubbles historical replay",
+            meta: {
+                agentName,
+                messageGuid,
+                eventType,
+                kind: event.kind,
+                attachmentCount: attachmentRecords.length,
+            },
+        });
+        return result;
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_replay_error",
+            message: "bluebubbles historical replay failed",
+            meta: {
+                agentName,
+                messageGuid,
+                eventType,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        throw error;
+    }
+    finally {
+        resetReplayIdentity();
+    }
+}
+function formatBlueBubblesReplayText(result) {
+    const lines = [
+        `probe: ${result.probe.eventType}`,
+        `agent: ${result.probe.agentName}`,
+        `message_guid: ${result.probe.messageGuid}`,
+        `result_kind: ${result.event.kind}`,
+        `session: ${result.event.chat.sessionKey}`,
+    ];
+    if (result.event.kind === "mutation") {
+        lines.push(`mutation_type: ${result.event.mutationType}`);
+    }
+    if (result.event.kind === "message" && result.event.inputPartsForAgent?.length) {
+        lines.push(`input_parts_for_agent: ${result.event.inputPartsForAgent.length}`);
+    }
+    if (result.event.repairNotice?.trim()) {
+        lines.push(`repair_notice: ${result.event.repairNotice.trim()}`);
+    }
+    if (result.attachmentBlock && !result.event.textForAgent.includes(result.attachmentBlock)) {
+        lines.push(result.attachmentBlock);
+    }
+    lines.push("[text_for_agent]");
+    lines.push(result.event.textForAgent || "(empty)");
+    if (result.hint) {
+        lines.push("[hint]");
+        lines.push(result.hint);
+    }
+    return lines.join("\n");
+}

package/dist/senses/{bluebubbles-runtime-state.js → bluebubbles/runtime-state.js}

@@ -38,8 +38,8 @@ exports.readBlueBubblesRuntimeState = readBlueBubblesRuntimeState;
 exports.writeBlueBubblesRuntimeState = writeBlueBubblesRuntimeState;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const identity_1 = require("../heart/identity");
-const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
 const DEFAULT_RUNTIME_STATE = {
     upstreamStatus: "unknown",
     detail: "startup health probe pending",
@@ -53,6 +53,9 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
     try {
         const raw = fs.readFileSync(filePath, "utf-8");
         const parsed = JSON.parse(raw);
+        const failedRecoveryCount = typeof parsed.failedRecoveryCount === "number" && Number.isFinite(parsed.failedRecoveryCount)
+            ? parsed.failedRecoveryCount
+            : undefined;
         return {
             upstreamStatus: parsed.upstreamStatus === "ok" || parsed.upstreamStatus === "error"
                 ? parsed.upstreamStatus
@@ -61,9 +64,31 @@ function readBlueBubblesRuntimeState(agentName, agentRoot) {
                 ? parsed.detail
                 : DEFAULT_RUNTIME_STATE.detail,
             lastCheckedAt: typeof parsed.lastCheckedAt === "string" ? parsed.lastCheckedAt : undefined,
+            proofMethod: typeof parsed.proofMethod === "string" && parsed.proofMethod.trim()
+                ? parsed.proofMethod
+                : undefined,
             pendingRecoveryCount: typeof parsed.pendingRecoveryCount === "number" && Number.isFinite(parsed.pendingRecoveryCount)
                 ? parsed.pendingRecoveryCount
                 : 0,
+            ...(typeof failedRecoveryCount === "number" ? { failedRecoveryCount } : {}),
+            oldestPendingRecoveryAt: typeof parsed.oldestPendingRecoveryAt === "string"
+                ? parsed.oldestPendingRecoveryAt
+                : undefined,
+            oldestPendingRecoveryAgeMs: typeof parsed.oldestPendingRecoveryAgeMs === "number" && Number.isFinite(parsed.oldestPendingRecoveryAgeMs)
+                ? parsed.oldestPendingRecoveryAgeMs
+                : undefined,
+            activeTurnCount: typeof parsed.activeTurnCount === "number" && Number.isFinite(parsed.activeTurnCount)
+                ? parsed.activeTurnCount
+                : undefined,
+            stalledTurnCount: typeof parsed.stalledTurnCount === "number" && Number.isFinite(parsed.stalledTurnCount)
+                ? parsed.stalledTurnCount
+                : undefined,
+            oldestActiveTurnStartedAt: typeof parsed.oldestActiveTurnStartedAt === "string"
+                ? parsed.oldestActiveTurnStartedAt
+                : undefined,
+            oldestActiveTurnAgeMs: typeof parsed.oldestActiveTurnAgeMs === "number" && Number.isFinite(parsed.oldestActiveTurnAgeMs)
+                ? parsed.oldestActiveTurnAgeMs
+                : undefined,
             lastRecoveredAt: typeof parsed.lastRecoveredAt === "string" ? parsed.lastRecoveredAt : undefined,
             lastRecoveredMessageGuid: typeof parsed.lastRecoveredMessageGuid === "string"
                 ? parsed.lastRecoveredMessageGuid
@@ -102,6 +127,9 @@ function writeBlueBubblesRuntimeState(agentName, state, agentRoot) {
             agentName,
             upstreamStatus: state.upstreamStatus,
             pendingRecoveryCount: state.pendingRecoveryCount,
+            failedRecoveryCount: state.failedRecoveryCount ?? 0,
+            activeTurnCount: state.activeTurnCount ?? 0,
+            stalledTurnCount: state.stalledTurnCount ?? 0,
             path: filePath,
         },
     });