@ouro.bot/cli 0.1.0-alpha.8 → 0.1.0-alpha.800

package/dist/senses/bluebubbles/model.js

@@ -0,0 +1,392 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlueBubblesIgnoredEventError = void 0;
+exports.describeBlueBubblesReaction = describeBlueBubblesReaction;
+exports.renderBlueBubblesReactionText = renderBlueBubblesReactionText;
+exports.normalizeBlueBubblesEvent = normalizeBlueBubblesEvent;
+const runtime_1 = require("../../nerves/runtime");
+const render_1 = require("../../heart/attachments/render");
+const bluebubbles_1 = require("../../heart/attachments/sources/bluebubbles");
+const IGNORABLE_GUIDLESS_EVENT_TYPES = new Set([
+    "chat-read-status-changed",
+]);
+class BlueBubblesIgnoredEventError extends Error {
+    eventType;
+    constructor(eventType, message) {
+        super(message);
+        this.name = "BlueBubblesIgnoredEventError";
+        this.eventType = eventType;
+    }
+}
+exports.BlueBubblesIgnoredEventError = BlueBubblesIgnoredEventError;
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readString(record, key) {
+    if (!record)
+        return undefined;
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function readNumber(record, key) {
+    if (!record)
+        return undefined;
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readBoolean(record, key) {
+    const value = record[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function normalizeHandle(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    if (trimmed.includes("@"))
+        return trimmed.toLowerCase();
+    const compact = trimmed.replace(/[^\d+]/g, "");
+    return compact || trimmed;
+}
+function extractChatIdentifierFromGuid(chatGuid) {
+    if (!chatGuid)
+        return undefined;
+    const parts = chatGuid.split(";");
+    return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
+}
+function buildChatRef(data, threadOriginatorGuid) {
+    void threadOriginatorGuid;
+    const chats = Array.isArray(data.chats) ? data.chats : [];
+    const chat = asRecord(chats[0]) ?? null;
+    const chatGuid = readString(chat, "guid");
+    const chatIdentifier = readString(chat, "chatIdentifier") ??
+        readString(chat, "identifier") ??
+        extractChatIdentifierFromGuid(chatGuid);
+    const displayName = readString(chat, "displayName")?.trim() || undefined;
+    const style = readNumber(chat, "style");
+    const isGroup = style === 43 || (chatGuid?.includes(";+;") ?? false) || Boolean(displayName);
+    const sessionKey = chatGuid?.trim()
+        ? `chat:${chatGuid.trim()}`
+        : `chat_identifier:${(chatIdentifier ?? "unknown").trim()}`;
+    // Extract participant handles from chat.participants (when available from BB API)
+    const rawParticipants = Array.isArray(chat?.participants) ? chat.participants : [];
+    const participantHandles = rawParticipants
+        .map((p) => {
+        const rec = asRecord(p);
+        const addr = readString(rec, "address") ?? readString(rec, "id");
+        return addr ? normalizeHandle(addr) : "";
+    })
+        .filter(Boolean);
+    return {
+        chatGuid: chatGuid?.trim() || undefined,
+        chatIdentifier: chatIdentifier?.trim() || undefined,
+        displayName,
+        isGroup,
+        sessionKey,
+        sendTarget: chatGuid?.trim()
+            ? { kind: "chat_guid", value: chatGuid.trim() }
+            : { kind: "chat_identifier", value: (chatIdentifier ?? "unknown").trim() },
+        participantHandles,
+    };
+}
+function extractSender(data, chat) {
+    const handle = asRecord(data.handle) ?? asRecord(data.sender) ?? null;
+    const observedRawId = readString(handle, "address") ??
+        readString(handle, "id") ??
+        readString(data, "senderId");
+    const observed = typeof observedRawId === "string" && observedRawId.trim().length > 0;
+    const rawId = observedRawId ??
+        chat.chatIdentifier ??
+        chat.chatGuid ??
+        "unknown";
+    const externalId = normalizeHandle(rawId);
+    const displayName = externalId || rawId || "Unknown";
+    return {
+        provider: "imessage-handle",
+        externalId,
+        rawId,
+        displayName,
+        observed,
+    };
+}
+function extractAttachments(data) {
+    const raw = Array.isArray(data.attachments) ? data.attachments : [];
+    return raw
+        .map((entry) => asRecord(entry))
+        .filter((entry) => entry !== null)
+        .map((entry) => ({
+        guid: readString(entry, "guid"),
+        mimeType: readString(entry, "mimeType"),
+        transferName: readString(entry, "transferName"),
+        totalBytes: readNumber(entry, "totalBytes"),
+        height: readNumber(entry, "height"),
+        width: readNumber(entry, "width"),
+    }));
+}
+function formatAttachmentText(attachments) {
+    if (attachments.length === 0)
+        return "";
+    const renderable = attachments
+        .filter((attachment) => typeof attachment.guid === "string" && attachment.guid.trim().length > 0)
+        .map((attachment) => (0, bluebubbles_1.buildBlueBubblesAttachmentRecord)(attachment));
+    if (renderable.length > 0) {
+        return (0, render_1.renderAttachmentBlock)(renderable);
+    }
+    const [first] = attachments;
+    return `[attachment: ${first.transferName?.trim() || "unknown"}]`;
+}
+function formatMessageText(data, attachments) {
+    const text = readString(data, "text")?.trim() ?? "";
+    const balloonBundleId = readString(data, "balloonBundleId")?.trim();
+    if (text) {
+        if (balloonBundleId === "com.apple.messages.URLBalloonProvider") {
+            return `${text}\n[link preview attached]`;
+        }
+        // B2 fix: when text and attachments both exist, append the attachment
+        // marker so downstream senses can see the guid/filename. Previously the
+        // marker was dropped whenever text was non-empty, which hid images from
+        // the agent when the user captioned a screenshot.
+        if (attachments.length > 0) {
+            return `${text}\n${formatAttachmentText(attachments)}`;
+        }
+        return text;
+    }
+    return formatAttachmentText(attachments);
+}
+function normalizeReactionName(value) {
+    // chat.db stores associated_message_type as an integer; BlueBubbles forwards it
+    // as either the integer, its decimal string, or a name ("love", "-love").
+    if (typeof value === "number") {
+        return Number.isFinite(value) && value !== 0 ? String(value) : undefined;
+    }
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.toLowerCase() : undefined;
+}
+/**
+ * iMessage tapbacks: associated_message_type 2000-2006 add a tapback, 3000-3006
+ * remove the same tapback. BlueBubbles may send either the code or the name.
+ */
+const REACTION_VOCABULARY = [
+    { code: 2000, name: "love", verb: "loved", noun: "love" },
+    { code: 2001, name: "like", verb: "liked", noun: "like" },
+    { code: 2002, name: "dislike", verb: "disliked", noun: "dislike" },
+    { code: 2003, name: "laugh", verb: "laughed at", noun: "laugh" },
+    { code: 2004, name: "emphasize", verb: "emphasized", noun: "emphasis" },
+    { code: 2005, name: "question", verb: "questioned", noun: "question" },
+    { code: 2006, name: "custom", verb: "reacted with custom emoji to", noun: "custom emoji" },
+];
+const REACTION_EXCERPT_MAX_LENGTH = 80;
+function describeBlueBubblesReaction(raw, rawTransportValue = raw) {
+    const stripped = raw.startsWith("-") ? raw.slice(1) : raw;
+    const code = /^\d+$/.test(stripped) ? Number(stripped) : undefined;
+    const removal = raw.startsWith("-") || (code !== undefined && code >= 3000 && code < 4000);
+    const action = removal ? "remove" : "add";
+    const entry = REACTION_VOCABULARY.find((candidate) => candidate.name === stripped || candidate.code === code || candidate.code + 1000 === code);
+    const canonicalValue = entry?.name ?? "unknown";
+    if (!entry)
+        return { raw, rawTransportValue, canonicalValue, action };
+    return {
+        raw,
+        rawTransportValue,
+        canonicalValue,
+        action,
+        verb: entry.verb,
+        noun: entry.noun,
+    };
+}
+function reactionExcerpt(text) {
+    return text.length > REACTION_EXCERPT_MAX_LENGTH
+        ? `${text.slice(0, REACTION_EXCERPT_MAX_LENGTH - 3)}...`
+        : text;
+}
+function reactionTargetPhrase(target) {
+    const text = target.text?.trim();
+    if (text) {
+        const owner = target.fromMe === true ? "your" : target.fromMe === false ? "their" : "a";
+        return `${owner} message: "${reactionExcerpt(text)}"`;
+    }
+    // Never hand the agent a bare "reacted with love" stub — say plainly that the
+    // referent is missing so it can ask instead of guessing what was approved.
+    return target.guid
+        ? `an unidentified message (target guid ${target.guid}; its text could not be resolved)`
+        : "an unidentified message (the reaction carried no target message reference)";
+}
+/**
+ * Render a reaction as speech the agent can act on: what the tapback was, whether
+ * it was added or removed, and which message it points at.
+ */
+function renderBlueBubblesReactionText(reaction, target) {
+    const phrase = reactionTargetPhrase(target);
+    if (reaction.action === "remove") {
+        const noun = reaction.noun ?? reaction.raw.replace(/^-/, "");
+        return `removed their ${noun} reaction from ${phrase}`;
+    }
+    return reaction.verb
+        ? `${reaction.verb} ${phrase}`
+        : `reacted with ${reaction.raw} to ${phrase}`;
+}
+function stripPartPrefix(guid) {
+    if (!guid)
+        return undefined;
+    const trimmed = guid.trim();
+    const marker = trimmed.lastIndexOf("/");
+    return marker >= 0 ? trimmed.slice(marker + 1) : trimmed;
+}
+// Reactions never reach here: `detectMutationType` returns "reaction" only when a
+// reaction name was decoded, and that same name produces the descriptor the caller
+// renders with `renderBlueBubblesReactionText` instead.
+function buildMutationText(mutationType, data) {
+    if (mutationType === "edit") {
+        const editedText = readString(data, "text")?.trim() ?? "";
+        return editedText ? `edited message: ${editedText}` : "edited a message";
+    }
+    if (mutationType === "unsend") {
+        return "unsent a message";
+    }
+    if (mutationType === "read") {
+        return "message marked as read";
+    }
+    return "message marked as delivered";
+}
+function detectMutationType(eventType, data, reactionName) {
+    if (reactionName)
+        return "reaction";
+    if (eventType === "updated-message") {
+        if (readNumber(data, "dateRetracted") !== undefined)
+            return "unsend";
+        if (readNumber(data, "dateEdited") !== undefined)
+            return "edit";
+        if (readNumber(data, "dateRead") !== undefined)
+            return "read";
+        if (readBoolean(data, "isDelivered") || readNumber(data, "dateDelivered") !== undefined)
+            return "delivery";
+    }
+    return null;
+}
+function readProviderRevision(data) {
+    const value = data.revision;
+    if (typeof value !== "string" && typeof value !== "number")
+        return undefined;
+    const normalized = String(value).trim();
+    return normalized || undefined;
+}
+function mutationEffectiveTimestamp(mutationType, data) {
+    if (mutationType === "reaction")
+        return readNumber(data, "dateCreated");
+    if (mutationType === "edit")
+        return readNumber(data, "dateEdited");
+    if (mutationType === "unsend")
+        return readNumber(data, "dateRetracted");
+    if (mutationType === "read")
+        return readNumber(data, "dateRead");
+    return readNumber(data, "dateDelivered");
+}
+function normalizeBlueBubblesEvent(payload) {
+    const envelope = asRecord(payload);
+    const eventType = readString(envelope, "type")?.trim() ?? "";
+    const data = asRecord(envelope?.data);
+    if (!eventType || !data) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_event_ignored",
+            message: "ignored invalid bluebubbles payload",
+            meta: { hasEnvelope: Boolean(envelope), eventType },
+        });
+        throw new Error("Invalid BlueBubbles payload");
+    }
+    const messageGuid = readString(data, "guid")?.trim();
+    if (!messageGuid) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_event_ignored",
+            message: "ignored bluebubbles payload without guid",
+            meta: { eventType },
+        });
+        if (IGNORABLE_GUIDLESS_EVENT_TYPES.has(eventType)) {
+            throw new BlueBubblesIgnoredEventError(eventType, `Ignored BlueBubbles event '${eventType}' without data.guid`);
+        }
+        throw new Error("BlueBubbles payload is missing data.guid");
+    }
+    const threadOriginatorGuid = readString(data, "threadOriginatorGuid")?.trim() || undefined;
+    const chat = buildChatRef(data, threadOriginatorGuid);
+    const sender = extractSender(data, chat);
+    const timestamp = readNumber(data, "dateCreated") ?? Date.now();
+    const fromMe = readBoolean(data, "isFromMe") ?? null;
+    const attachments = extractAttachments(data);
+    const reactionName = normalizeReactionName(data.associatedMessageType);
+    const reaction = reactionName
+        ? describeBlueBubblesReaction(reactionName, String(data.associatedMessageType))
+        : undefined;
+    const targetMessageGuid = reaction
+        ? stripPartPrefix(readString(data, "associatedMessageGuid"))
+        : undefined;
+    const mutationType = detectMutationType(eventType, data, reactionName);
+    const revision = mutationType ? readProviderRevision(data) : undefined;
+    const effectiveTimestamp = mutationType
+        ? mutationEffectiveTimestamp(mutationType, data)
+        : undefined;
+    const editedText = mutationType === "edit" ? readString(data, "text") : undefined;
+    const retractionTimestamp = mutationType === "unsend"
+        ? readNumber(data, "dateRetracted")
+        : undefined;
+    const requiresRepair = (readBoolean(data, "hasPayloadData") ?? false) ||
+        attachments.length > 0 ||
+        eventType === "updated-message";
+    const result = mutationType
+        ? {
+            kind: "mutation",
+            eventType,
+            mutationType,
+            messageGuid,
+            targetMessageGuid,
+            timestamp,
+            fromMe,
+            sender,
+            chat,
+            shouldNotifyAgent: mutationType === "reaction" || mutationType === "edit" || mutationType === "unsend",
+            textForAgent: reaction
+                ? renderBlueBubblesReactionText(reaction, { guid: targetMessageGuid })
+                : buildMutationText(mutationType, data),
+            requiresRepair,
+            ...(reaction ? { reaction } : {}),
+            ...(editedText !== undefined ? { editedText } : {}),
+            ...(revision ? { revision } : {}),
+            ...(effectiveTimestamp !== undefined ? { effectiveTimestamp } : {}),
+            ...(retractionTimestamp !== undefined ? { retractionTimestamp } : {}),
+        }
+        : {
+            kind: "message",
+            eventType,
+            messageGuid,
+            timestamp,
+            fromMe,
+            sender,
+            chat,
+            text: readString(data, "text") ?? "",
+            textForAgent: formatMessageText(data, attachments),
+            attachments,
+            balloonBundleId: readString(data, "balloonBundleId")?.trim() || undefined,
+            hasPayloadData: readBoolean(data, "hasPayloadData") ?? false,
+            requiresRepair,
+            threadOriginatorGuid,
+            replyToGuid: threadOriginatorGuid,
+        };
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_event_normalized",
+        message: "normalized bluebubbles event",
+        meta: {
+            eventType,
+            kind: result.kind,
+            mutationType: result.kind === "mutation" ? result.mutationType : null,
+            sessionKey: result.chat.sessionKey,
+            fromMe,
+        },
+    });
+    return result;
+}

package/dist/senses/{bluebubbles-mutation-log.js → bluebubbles/mutation-log.js}

@@ -35,15 +35,15 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getBlueBubblesMutationLogPath = getBlueBubblesMutationLogPath;
 exports.recordBlueBubblesMutation = recordBlueBubblesMutation;
+exports.listRecordedBlueBubblesMutations = listRecordedBlueBubblesMutations;
+exports.listBlueBubblesRecoveryCandidates = listBlueBubblesRecoveryCandidates;
 const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
-const runtime_1 = require("../nerves/runtime");
-function sanitizeKey(key) {
-    return key.replace(/[/:]/g, "_");
-}
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const config_1 = require("../../heart/config");
 function getBlueBubblesMutationLogPath(agentName, sessionKey) {
-    return path.join(os.homedir(), ".agentstate", agentName, "senses", "bluebubbles", "mutations", `${sanitizeKey(sessionKey)}.ndjson`);
+    return path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "mutations", `${(0, config_1.sanitizeKey)(sessionKey)}.ndjson`);
 }
 function recordBlueBubblesMutation(agentName, event) {
     const filePath = getBlueBubblesMutationLogPath(agentName, event.chat.sessionKey);
@@ -74,3 +74,54 @@ function recordBlueBubblesMutation(agentName, event) {
     });
     return filePath;
 }
+function readBlueBubblesMutationRows(agentName) {
+    const rootDir = path.join((0, identity_1.getAgentRoot)(agentName), "state", "senses", "bluebubbles", "mutations");
+    let files;
+    try {
+        files = fs.readdirSync(rootDir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const file of files.filter((entry) => entry.endsWith(".ndjson")).sort()) {
+        const filePath = path.join(rootDir, file);
+        let raw = "";
+        try {
+            raw = fs.readFileSync(filePath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const entry = JSON.parse(trimmed);
+                if (typeof entry.messageGuid !== "string" || !entry.messageGuid.trim())
+                    continue;
+                entries.push(entry);
+            }
+            catch {
+                // Keep malformed legacy rows inert while retaining readable audit rows.
+            }
+        }
+    }
+    return entries;
+}
+function listRecordedBlueBubblesMutations(agentName) {
+    return readBlueBubblesMutationRows(agentName).filter((entry) => (typeof entry.sessionKey === "string" && entry.sessionKey.trim().length > 0));
+}
+function listBlueBubblesRecoveryCandidates(agentName) {
+    const deduped = new Map();
+    for (const entry of readBlueBubblesMutationRows(agentName)) {
+        if (entry.fromMe !== false
+            || entry.shouldNotifyAgent
+            || (entry.mutationType !== "read" && entry.mutationType !== "delivery")) {
+            continue;
+        }
+        deduped.set(entry.messageGuid, entry);
+    }
+    return [...deduped.values()].sort((left, right) => left.recordedAt.localeCompare(right.recordedAt));
+}