@ouro.bot/cli 0.1.0-alpha.2 → 0.1.0-alpha.20

package/dist/senses/bluebubbles.js

@@ -0,0 +1,421 @@
+"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 phrases_1 = require("../mind/phrases");
+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 debug_activity_1 = require("./debug-activity");
+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 buildInboundContent(event) {
+    const text = buildInboundText(event);
+    if (event.kind !== "message" || !event.inputPartsForAgent || event.inputPartsForAgent.length === 0) {
+        return text;
+    }
+    return [
+        { type: "text", text },
+        ...event.inputPartsForAgent,
+    ];
+}
+function createBlueBubblesCallbacks(client, chat, replyToMessageGuid) {
+    let textBuffer = "";
+    const phrases = (0, phrases_1.getPhrases)();
+    const activity = (0, debug_activity_1.createDebugActivityController)({
+        thinkingPhrases: phrases.thinking,
+        followupPhrases: phrases.followup,
+        transport: {
+            sendStatus: async (text) => {
+                const sent = await client.sendText({
+                    chat,
+                    text,
+                    replyToMessageGuid,
+                });
+                return sent.messageGuid;
+            },
+            editStatus: async (_messageGuid, text) => {
+                await client.sendText({
+                    chat,
+                    text,
+                    replyToMessageGuid,
+                });
+            },
+            setTyping: async (active) => {
+                await client.setTyping(chat, active);
+            },
+        },
+        onTransportError: (operation, error) => {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_activity_error",
+                message: "bluebubbles activity transport failed",
+                meta: {
+                    operation,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        },
+    });
+    return {
+        onModelStart() {
+            activity.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) {
+            activity.onTextChunk(text);
+            textBuffer += text;
+        },
+        onReasoningChunk(_text) { },
+        onToolStart(name, _args) {
+            activity.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) {
+            activity.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) {
+            activity.onError(error);
+            (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() {
+            await activity.drain();
+            const trimmed = textBuffer.trim();
+            if (!trimmed) {
+                await activity.finish();
+                return;
+            }
+            textBuffer = "";
+            await client.sendText({
+                chat,
+                text: trimmed,
+                replyToMessageGuid,
+            });
+            await activity.finish();
+        },
+        async finish() {
+            await activity.finish();
+        },
+    };
+}
+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,
+        codingFeedback: {
+            send: async (message) => {
+                await client.sendText({
+                    chat: event.chat,
+                    text: message,
+                    replyToMessageGuid: event.kind === "message" ? event.messageGuid : undefined,
+                });
+            },
+        },
+    };
+    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: buildInboundContent(event) });
+    const callbacks = createBlueBubblesCallbacks(client, event.chat, event.kind === "message" ? event.messageGuid : undefined);
+    const controller = new AbortController();
+    const agentOptions = {
+        toolContext,
+    };
+    try {
+        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);
+        try {
+            await client.markChatRead(event.chat);
+        }
+        catch (error) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_mark_read_error",
+                message: "failed to mark bluebubbles chat as read",
+                meta: {
+                    chatGuid: event.chat.chatGuid ?? null,
+                    reason: error instanceof Error ? error.message : String(error),
+                },
+            });
+        }
+        (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,
+        };
+    }
+    finally {
+        await callbacks.finish();
+    }
+}
+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;
+}