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

package/dist/senses/bluebubbles/outbound-state.js

@@ -0,0 +1,308 @@
+"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.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION = void 0;
+exports.blueBubblesOutboundRecordPath = blueBubblesOutboundRecordPath;
+exports.buildBlueBubblesRouteProof = buildBlueBubblesRouteProof;
+exports.buildBlueBubblesAttachmentProof = buildBlueBubblesAttachmentProof;
+exports.readBlueBubblesOutboundRecord = readBlueBubblesOutboundRecord;
+exports.readBlueBubblesOutboundRecordByIdempotencyKey = readBlueBubblesOutboundRecordByIdempotencyKey;
+exports.reserveBlueBubblesOutbound = reserveBlueBubblesOutbound;
+exports.markBlueBubblesOutboundAccepted = markBlueBubblesOutboundAccepted;
+exports.markBlueBubblesOutboundEnqueued = markBlueBubblesOutboundEnqueued;
+exports.markBlueBubblesOutboundLocalVisible = markBlueBubblesOutboundLocalVisible;
+exports.markBlueBubblesOutboundDelivered = markBlueBubblesOutboundDelivered;
+exports.markBlueBubblesOutboundFailed = markBlueBubblesOutboundFailed;
+exports.markBlueBubblesOutboundPendingManualVerification = markBlueBubblesOutboundPendingManualVerification;
+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.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION = "bluebubbles-outbound-state/v1";
+function sha256Hex(input) {
+    return (0, node_crypto_1.createHash)("sha256").update(input).digest("hex");
+}
+function hash(input) {
+    return `sha256:${sha256Hex(canonicalJson(input))}`;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map((entry) => canonicalJson(entry)).join(",")}]`;
+    if (value && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function nowIso(input) {
+    return input ?? new Date().toISOString();
+}
+function recordIdFor(idempotencyKey) {
+    return `bbout_${sha256Hex(`bluebubbles-outbound:${idempotencyKey}`).slice(0, 32)}`;
+}
+function normalizeText(value) {
+    return value.trim().replace(/\s+/g, " ");
+}
+function endpointOrigin(serverUrl) {
+    const parsed = new URL(serverUrl);
+    return parsed.origin;
+}
+function blueBubblesOutboundDir(agentRoot) {
+    return path.join(agentRoot, "state", "bluebubbles", "outbound");
+}
+function blueBubblesOutboundRecordPath(agentRoot, recordId) {
+    return path.join(blueBubblesOutboundDir(agentRoot), `${recordId}.json`);
+}
+function buildBlueBubblesRouteProof(chat) {
+    const participantHandles = [...chat.participantHandles].sort();
+    const base = {
+        chatGuid: chat.chatGuid?.trim() || null,
+        chatIdentifier: chat.chatIdentifier?.trim() || null,
+        sendTarget: chat.sendTarget,
+        sessionKey: chat.sessionKey,
+        isGroup: chat.isGroup,
+        participantHandles,
+    };
+    return {
+        chatGuid: base.chatGuid,
+        chatIdentifier: base.chatIdentifier,
+        sendTarget: base.sendTarget,
+        sessionKey: base.sessionKey,
+        isGroup: base.isGroup,
+        participantHandlesHash: hash(participantHandles),
+        routeHash: hash(base),
+        rawParticipantHandlesStored: false,
+    };
+}
+function buildBlueBubblesAttachmentProof(input) {
+    const proof = {
+        endpointOrigin: endpointOrigin(input.serverUrl),
+        accountId: input.accountId?.trim() || null,
+    };
+    return {
+        ...proof,
+        identityHash: hash(proof),
+        secretStored: false,
+    };
+}
+function buildRecord(input) {
+    const createdAt = nowIso(input.now);
+    const idempotencyKey = input.idempotencyKey.trim();
+    const text = normalizeText(input.text);
+    return {
+        schemaVersion: 1,
+        policyVersion: exports.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION,
+        recordId: recordIdFor(idempotencyKey),
+        idempotencyKey,
+        idempotencyHash: hash(idempotencyKey),
+        status: "reserved",
+        createdAt,
+        updatedAt: createdAt,
+        tempGuid: input.tempGuid.trim(),
+        routeProof: buildBlueBubblesRouteProof(input.chat),
+        attachmentProof: buildBlueBubblesAttachmentProof(input.attachment),
+        textHash: hash(text),
+        textLength: text.length,
+        ...(input.replyToMessageGuid?.trim() ? { replyToMessageGuidHash: hash(input.replyToMessageGuid.trim()) } : {}),
+        contentStored: false,
+    };
+}
+function writeJsonAtomic(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+    fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+    fs.renameSync(tmp, filePath);
+}
+function readJson(filePath) {
+    if (!fs.existsSync(filePath))
+        return null;
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+}
+function isOutboundRecord(value) {
+    const row = value;
+    return !!row
+        && row.schemaVersion === 1
+        && row.policyVersion === exports.BLUEBUBBLES_OUTBOUND_STATE_POLICY_VERSION
+        && typeof row.recordId === "string"
+        && typeof row.idempotencyKey === "string"
+        && typeof row.idempotencyHash === "string"
+        && typeof row.status === "string"
+        && typeof row.createdAt === "string"
+        && typeof row.updatedAt === "string"
+        && typeof row.tempGuid === "string"
+        && typeof row.textHash === "string"
+        && typeof row.textLength === "number"
+        && row.contentStored === false;
+}
+function readBlueBubblesOutboundRecord(agentRoot, recordId) {
+    try {
+        const parsed = readJson(blueBubblesOutboundRecordPath(agentRoot, recordId));
+        return isOutboundRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readBlueBubblesOutboundRecordByIdempotencyKey(agentRoot, idempotencyKey) {
+    return readBlueBubblesOutboundRecord(agentRoot, recordIdFor(idempotencyKey.trim()));
+}
+function writeBlueBubblesOutboundRecord(agentRoot, record) {
+    writeJsonAtomic(blueBubblesOutboundRecordPath(agentRoot, record.recordId), record);
+    return record;
+}
+function identityMatches(left, right) {
+    return left.routeProof.routeHash === right.routeProof.routeHash
+        && left.attachmentProof.identityHash === right.attachmentProof.identityHash
+        && left.textHash === right.textHash
+        && left.replyToMessageGuidHash === right.replyToMessageGuidHash;
+}
+function emitDuplicate(record) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_outbound_duplicate",
+        message: "duplicate bluebubbles outbound reservation suppressed",
+        meta: { recordId: record.recordId, status: record.status },
+    });
+}
+function markPendingManualVerification(agentRoot, record, decidedAt, reason) {
+    const updated = writeBlueBubblesOutboundRecord(agentRoot, {
+        ...record,
+        status: "pending-manual-verification",
+        updatedAt: decidedAt,
+        manualVerificationReason: reason,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_outbound_pending_manual_verification",
+        message: "bluebubbles outbound requires manual verification",
+        meta: { recordId: updated.recordId, reason },
+    });
+    return updated;
+}
+function reserveBlueBubblesOutbound(input) {
+    const record = buildRecord(input);
+    const filePath = blueBubblesOutboundRecordPath(input.agentRoot, record.recordId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    try {
+        const fd = fs.openSync(filePath, "wx");
+        try {
+            fs.writeFileSync(fd, `${JSON.stringify(record, null, 2)}\n`, "utf-8");
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_outbound_reserved",
+            message: "reserved bluebubbles outbound idempotency key",
+            meta: { recordId: record.recordId, textLength: record.textLength },
+        });
+        return { status: "reserved", record };
+    }
+    catch (error) {
+        /* v8 ignore next -- non-EEXIST filesystem failures are rethrown fail-closed; hard to trigger portably after mkdir succeeds @preserve */
+        if (!isNodeFileExistsError(error))
+            throw error;
+        const existing = readBlueBubblesOutboundRecord(input.agentRoot, record.recordId);
+        if (!existing)
+            throw new Error(`bluebubbles outbound reservation is unreadable: ${record.recordId}`);
+        if (identityMatches(existing, record)) {
+            emitDuplicate(existing);
+            return { status: "duplicate", record: existing };
+        }
+        const updated = markPendingManualVerification(input.agentRoot, existing, nowIso(input.now), "identity-proof-mismatch");
+        return { status: "pending-manual-verification", reason: "identity-proof-mismatch", record: updated };
+    }
+}
+function isNodeFileExistsError(error) {
+    return typeof error === "object" && error !== null && error.code === "EEXIST";
+}
+function updateStatus(agentRoot, recordId, status, updatedAt, patch) {
+    const existing = readBlueBubblesOutboundRecord(agentRoot, recordId);
+    if (!existing)
+        throw new Error(`bluebubbles outbound record not found: ${recordId}`);
+    const updated = writeBlueBubblesOutboundRecord(agentRoot, {
+        ...existing,
+        ...patch,
+        status,
+        updatedAt,
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_outbound_state_changed",
+        message: "bluebubbles outbound state changed",
+        meta: { recordId, status },
+    });
+    return updated;
+}
+function markBlueBubblesOutboundAccepted(input) {
+    return updateStatus(input.agentRoot, input.recordId, "accepted", input.acceptedAt, {
+        acceptedAt: input.acceptedAt,
+        ...(input.messageGuid?.trim() ? { messageGuid: input.messageGuid.trim() } : {}),
+    });
+}
+function markBlueBubblesOutboundEnqueued(input) {
+    return updateStatus(input.agentRoot, input.recordId, "enqueued", input.enqueuedAt, {
+        enqueuedAt: input.enqueuedAt,
+        messageGuid: input.messageGuid.trim(),
+    });
+}
+function markBlueBubblesOutboundLocalVisible(input) {
+    return updateStatus(input.agentRoot, input.recordId, "local-visible", input.visibleAt, {
+        localVisibleAt: input.visibleAt,
+        messageGuid: input.messageGuid.trim(),
+        ...(input.tempGuid?.trim() ? { tempGuid: input.tempGuid.trim() } : {}),
+    });
+}
+function markBlueBubblesOutboundDelivered(input) {
+    return updateStatus(input.agentRoot, input.recordId, "delivered", input.deliveredAt, {
+        deliveredAt: input.deliveredAt,
+        ...(input.messageGuid?.trim() ? { messageGuid: input.messageGuid.trim() } : {}),
+    });
+}
+function markBlueBubblesOutboundFailed(input) {
+    return updateStatus(input.agentRoot, input.recordId, "failed", input.failedAt, {
+        failedAt: input.failedAt,
+        failureReason: input.reason.slice(0, 500),
+    });
+}
+function markBlueBubblesOutboundPendingManualVerification(input) {
+    const existing = readBlueBubblesOutboundRecord(input.agentRoot, input.recordId);
+    if (!existing)
+        throw new Error(`bluebubbles outbound record not found: ${input.recordId}`);
+    return markPendingManualVerification(input.agentRoot, existing, input.decidedAt, input.reason);
+}

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;
+}