@ouro.bot/cli 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/senses/bluebubbles-model.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeBlueBubblesEvent = normalizeBlueBubblesEvent;
+const runtime_1 = require("../nerves/runtime");
+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) {
+    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 baseKey = chatGuid?.trim()
+        ? `chat:${chatGuid.trim()}`
+        : `chat_identifier:${(chatIdentifier ?? "unknown").trim()}`;
+    const sessionKey = threadOriginatorGuid?.trim()
+        ? `${baseKey}:thread:${threadOriginatorGuid.trim()}`
+        : baseKey;
+    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() },
+    };
+}
+function extractSender(data, chat) {
+    const handle = asRecord(data.handle) ?? asRecord(data.sender) ?? null;
+    const rawId = readString(handle, "address") ??
+        readString(handle, "id") ??
+        readString(data, "senderId") ??
+        chat.chatIdentifier ??
+        chat.chatGuid ??
+        "unknown";
+    const externalId = normalizeHandle(rawId);
+    const displayName = externalId || rawId || "Unknown";
+    return {
+        provider: "imessage-handle",
+        externalId,
+        rawId,
+        displayName,
+    };
+}
+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 [first] = attachments;
+    const mime = first.mimeType ?? "";
+    const label = mime.startsWith("image/")
+        ? "image attachment"
+        : mime.startsWith("audio/")
+            ? "audio attachment"
+            : "attachment";
+    const name = first.transferName ? `: ${first.transferName}` : "";
+    const dimensions = typeof first.width === "number" && typeof first.height === "number" && first.width > 0 && first.height > 0
+        ? ` (${first.width}x${first.height})`
+        : "";
+    return `[${label}${name}${dimensions}]`;
+}
+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]`;
+        }
+        return text;
+    }
+    return formatAttachmentText(attachments);
+}
+function normalizeReactionName(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed ? trimmed.toLowerCase() : undefined;
+}
+function stripPartPrefix(guid) {
+    if (!guid)
+        return undefined;
+    const trimmed = guid.trim();
+    const marker = trimmed.lastIndexOf("/");
+    return marker >= 0 ? trimmed.slice(marker + 1) : trimmed;
+}
+function buildMutationText(mutationType, data, reactionName) {
+    if (mutationType === "reaction") {
+        return `reacted with ${reactionName}`;
+    }
+    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"))
+            return "unsend";
+        if (readNumber(data, "dateEdited"))
+            return "edit";
+        if (readNumber(data, "dateRead"))
+            return "read";
+        if (readBoolean(data, "isDelivered") || readNumber(data, "dateDelivered"))
+            return "delivery";
+    }
+    return null;
+}
+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 },
+        });
+        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") ?? false;
+    const attachments = extractAttachments(data);
+    const reactionName = normalizeReactionName(data.associatedMessageType);
+    const mutationType = detectMutationType(eventType, data, reactionName);
+    const requiresRepair = (readBoolean(data, "hasPayloadData") ?? false) ||
+        attachments.length > 0 ||
+        eventType === "updated-message";
+    const result = mutationType
+        ? {
+            kind: "mutation",
+            eventType,
+            mutationType,
+            messageGuid,
+            targetMessageGuid: mutationType === "reaction"
+                ? stripPartPrefix(readString(data, "associatedMessageGuid"))
+                : undefined,
+            timestamp,
+            fromMe,
+            sender,
+            chat,
+            shouldNotifyAgent: mutationType === "reaction" || mutationType === "edit" || mutationType === "unsend",
+            textForAgent: buildMutationText(mutationType, data, reactionName),
+            requiresRepair,
+        }
+        : {
+            kind: "message",
+            eventType,
+            messageGuid,
+            timestamp,
+            fromMe,
+            sender,
+            chat,
+            text: readString(data, "text")?.trim() ?? "",
+            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

@@ -0,0 +1,76 @@
+"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.getBlueBubblesMutationLogPath = getBlueBubblesMutationLogPath;
+exports.recordBlueBubblesMutation = recordBlueBubblesMutation;
+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, "_");
+}
+function getBlueBubblesMutationLogPath(agentName, sessionKey) {
+    return path.join(os.homedir(), ".agentstate", agentName, "senses", "bluebubbles", "mutations", `${sanitizeKey(sessionKey)}.ndjson`);
+}
+function recordBlueBubblesMutation(agentName, event) {
+    const filePath = getBlueBubblesMutationLogPath(agentName, event.chat.sessionKey);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.appendFileSync(filePath, JSON.stringify({
+        recordedAt: new Date(event.timestamp).toISOString(),
+        eventType: event.eventType,
+        mutationType: event.mutationType,
+        messageGuid: event.messageGuid,
+        targetMessageGuid: event.targetMessageGuid ?? null,
+        chatGuid: event.chat.chatGuid ?? null,
+        chatIdentifier: event.chat.chatIdentifier ?? null,
+        sessionKey: event.chat.sessionKey,
+        shouldNotifyAgent: event.shouldNotifyAgent,
+        textForAgent: event.textForAgent,
+        fromMe: event.fromMe,
+    }) + "\n", "utf-8");
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_mutation_logged",
+        message: "recorded bluebubbles mutation to sidecar log",
+        meta: {
+            agentName,
+            mutationType: event.mutationType,
+            messageGuid: event.messageGuid,
+            path: filePath,
+        },
+    });
+    return filePath;
+}

package/dist/senses/bluebubbles.js

@@ -0,0 +1,332 @@
+"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.handleBlueBubblesEvent = handleBlueBubblesEvent;
+exports.createBlueBubblesWebhookHandler = createBlueBubblesWebhookHandler;
+exports.startBlueBubblesApp = startBlueBubblesApp;
+const http = __importStar(require("node:http"));
+const path = __importStar(require("node:path"));
+const core_1 = require("../heart/core");
+const config_1 = require("../heart/config");
+const identity_1 = require("../heart/identity");
+const context_1 = require("../mind/context");
+const tokens_1 = require("../mind/friends/tokens");
+const resolver_1 = require("../mind/friends/resolver");
+const store_file_1 = require("../mind/friends/store-file");
+const prompt_1 = require("../mind/prompt");
+const runtime_1 = require("../nerves/runtime");
+const bluebubbles_model_1 = require("./bluebubbles-model");
+const bluebubbles_client_1 = require("./bluebubbles-client");
+const bluebubbles_mutation_log_1 = require("./bluebubbles-mutation-log");
+const defaultDeps = {
+    getAgentName: identity_1.getAgentName,
+    buildSystem: prompt_1.buildSystem,
+    runAgent: core_1.runAgent,
+    loadSession: context_1.loadSession,
+    postTurn: context_1.postTurn,
+    sessionPath: config_1.sessionPath,
+    accumulateFriendTokens: tokens_1.accumulateFriendTokens,
+    createClient: () => (0, bluebubbles_client_1.createBlueBubblesClient)(),
+    recordMutation: bluebubbles_mutation_log_1.recordBlueBubblesMutation,
+    createFriendStore: () => new store_file_1.FileFriendStore(path.join((0, identity_1.getAgentRoot)(), "friends")),
+    createFriendResolver: (store, params) => new resolver_1.FriendResolver(store, params),
+    createServer: http.createServer,
+};
+function resolveFriendParams(event) {
+    if (event.chat.isGroup) {
+        const groupKey = event.chat.chatGuid ?? event.chat.chatIdentifier ?? event.sender.externalId;
+        return {
+            provider: "imessage-handle",
+            externalId: `group:${groupKey}`,
+            displayName: event.chat.displayName ?? "Unknown Group",
+            channel: "bluebubbles",
+        };
+    }
+    return {
+        provider: "imessage-handle",
+        externalId: event.sender.externalId || event.sender.rawId,
+        displayName: event.sender.displayName || "Unknown",
+        channel: "bluebubbles",
+    };
+}
+function buildInboundText(event) {
+    const baseText = event.repairNotice?.trim()
+        ? `${event.textForAgent}\n[${event.repairNotice.trim()}]`
+        : event.textForAgent;
+    if (!event.chat.isGroup)
+        return baseText;
+    if (event.kind === "mutation") {
+        return `${event.sender.displayName} ${baseText}`;
+    }
+    return `${event.sender.displayName}: ${baseText}`;
+}
+function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
+    let textBuffer = "";
+    return {
+        onModelStart() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_turn_start",
+                message: "bluebubbles turn started",
+                meta: { chatGuid: chat.chatGuid ?? null },
+            });
+        },
+        onModelStreamStart() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_stream_start",
+                message: "bluebubbles non-streaming response started",
+                meta: {},
+            });
+        },
+        onTextChunk(text) {
+            textBuffer += text;
+        },
+        onReasoningChunk(_text) { },
+        onToolStart(name, _args) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_tool_start",
+                message: "bluebubbles tool execution started",
+                meta: { name },
+            });
+        },
+        onToolEnd(name, summary, success) {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_tool_end",
+                message: "bluebubbles tool execution completed",
+                meta: { name, success, summary },
+            });
+        },
+        onError(error, severity) {
+            (0, runtime_1.emitNervesEvent)({
+                level: severity === "terminal" ? "error" : "warn",
+                component: "senses",
+                event: "senses.bluebubbles_turn_error",
+                message: "bluebubbles turn callback error",
+                meta: { severity, reason: error.message },
+            });
+        },
+        onClearText() {
+            textBuffer = "";
+        },
+        async flush() {
+            const trimmed = textBuffer.trim();
+            if (!trimmed) {
+                return;
+            }
+            textBuffer = "";
+            await client.sendText({
+                chat,
+                text: trimmed,
+                replyToMessageGuid,
+            });
+        },
+    };
+}
+async function readRequestBody(req) {
+    let body = "";
+    for await (const chunk of req) {
+        body += chunk.toString();
+    }
+    return body;
+}
+function writeJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json; charset=utf-8");
+    res.end(JSON.stringify(payload));
+}
+function isWebhookPasswordValid(url, expectedPassword) {
+    const provided = url.searchParams.get("password");
+    return !provided || provided === expectedPassword;
+}
+async function handleBlueBubblesEvent(payload, deps = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    const client = resolvedDeps.createClient();
+    const event = await client.repairEvent((0, bluebubbles_model_1.normalizeBlueBubblesEvent)(payload));
+    if (event.fromMe) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_from_me_ignored",
+            message: "ignored from-me bluebubbles event",
+            meta: {
+                messageGuid: event.messageGuid,
+                kind: event.kind,
+            },
+        });
+        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "from_me" };
+    }
+    if (event.kind === "mutation") {
+        try {
+            resolvedDeps.recordMutation(resolvedDeps.getAgentName(), event);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_mutation_log_error",
+                message: "failed recording bluebubbles mutation sidecar",
+                meta: {
+                    messageGuid: event.messageGuid,
+                    mutationType: event.mutationType,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+    }
+    if (event.kind === "mutation" && !event.shouldNotifyAgent) {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_state_mutation_recorded",
+            message: "recorded non-notify bluebubbles mutation",
+            meta: {
+                messageGuid: event.messageGuid,
+                mutationType: event.mutationType,
+            },
+        });
+        return { handled: true, notifiedAgent: false, kind: event.kind, reason: "mutation_state_only" };
+    }
+    const store = resolvedDeps.createFriendStore();
+    const resolver = resolvedDeps.createFriendResolver(store, resolveFriendParams(event));
+    const context = await resolver.resolve();
+    const toolContext = {
+        signin: async () => undefined,
+        friendStore: store,
+        summarize: (0, core_1.createSummarize)(),
+        context,
+    };
+    const friendId = context.friend.id;
+    const sessPath = resolvedDeps.sessionPath(friendId, "bluebubbles", event.chat.sessionKey);
+    const existing = resolvedDeps.loadSession(sessPath);
+    const messages = existing?.messages && existing.messages.length > 0
+        ? existing.messages
+        : [{ role: "system", content: await resolvedDeps.buildSystem("bluebubbles", undefined, context) }];
+    messages.push({ role: "user", content: buildInboundText(event) });
+    const callbacks = createBlueBubblesCallbacks(client, event.chat, event.kind === "message" ? event.messageGuid : undefined);
+    const controller = new AbortController();
+    const agentOptions = {
+        toolContext,
+    };
+    const result = await resolvedDeps.runAgent(messages, callbacks, "bluebubbles", controller.signal, agentOptions);
+    await callbacks.flush();
+    resolvedDeps.postTurn(messages, sessPath, result.usage);
+    await resolvedDeps.accumulateFriendTokens(store, friendId, result.usage);
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_turn_end",
+        message: "bluebubbles event handled",
+        meta: {
+            messageGuid: event.messageGuid,
+            kind: event.kind,
+            sessionKey: event.chat.sessionKey,
+        },
+    });
+    return {
+        handled: true,
+        notifiedAgent: true,
+        kind: event.kind,
+    };
+}
+function createBlueBubblesWebhookHandler(deps = {}) {
+    return async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
+        const runtimeConfig = (0, config_1.getBlueBubblesConfig)();
+        if (url.pathname !== channelConfig.webhookPath) {
+            writeJson(res, 404, { error: "Not found" });
+            return;
+        }
+        if (req.method !== "POST") {
+            writeJson(res, 405, { error: "Method not allowed" });
+            return;
+        }
+        if (!isWebhookPasswordValid(url, runtimeConfig.password)) {
+            writeJson(res, 401, { error: "Unauthorized" });
+            return;
+        }
+        let payload;
+        try {
+            const rawBody = await readRequestBody(req);
+            payload = JSON.parse(rawBody);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_webhook_bad_json",
+                message: "failed to parse bluebubbles webhook body",
+                meta: {
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            writeJson(res, 400, { error: "Invalid JSON body" });
+            return;
+        }
+        try {
+            const result = await handleBlueBubblesEvent(payload, deps);
+            writeJson(res, 200, result);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                component: "senses",
+                event: "senses.bluebubbles_webhook_error",
+                message: "bluebubbles webhook handling failed",
+                meta: {
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+            writeJson(res, 500, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    };
+}
+function startBlueBubblesApp(deps = {}) {
+    const resolvedDeps = { ...defaultDeps, ...deps };
+    resolvedDeps.createClient();
+    const channelConfig = (0, config_1.getBlueBubblesChannelConfig)();
+    const server = resolvedDeps.createServer(createBlueBubblesWebhookHandler(deps));
+    server.listen(channelConfig.port, () => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "channels",
+            event: "channel.app_started",
+            message: "BlueBubbles sense started",
+            meta: { port: channelConfig.port, webhookPath: channelConfig.webhookPath },
+        });
+    });
+    return server;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.0-alpha.6",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "ouro": "dist/heart/daemon/ouro-entry.js",
@@ -20,6 +20,7 @@
     "daemon": "tsc && node dist/heart/daemon/daemon-entry.js",
     "ouro": "tsc && node dist/heart/daemon/ouro-entry.js",
     "teams": "tsc && node dist/senses/teams-entry.js --agent ouroboros",
+    "bluebubbles": "tsc && node dist/senses/bluebubbles-entry.js --agent ouroboros",
     "test": "vitest run",
     "test:coverage:vitest": "vitest run --coverage",
     "test:coverage": "node scripts/run-coverage-gate.cjs",