@ouro.bot/cli 0.1.0-alpha.5 → 0.1.0-alpha.500

package/dist/senses/bluebubbles/client.js

@@ -0,0 +1,685 @@
+"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.createBlueBubblesClient = createBlueBubblesClient;
+const node_crypto_1 = require("node:crypto");
+const config_1 = require("../../heart/config");
+const identity_1 = require("../../heart/identity");
+const bluebubbles_health_diagnostics_1 = require("../../heart/daemon/bluebubbles-health-diagnostics");
+const runtime_1 = require("../../nerves/runtime");
+const minimax_1 = require("../../heart/providers/minimax");
+const minimax_vlm_1 = require("../../heart/providers/minimax-vlm");
+const model_1 = require("./model");
+const media_1 = require("./media");
+function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
+    const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    const url = new URL(endpoint.replace(/^\//, ""), root);
+    url.searchParams.set("password", password);
+    return url.toString();
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function readString(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function extractMessageGuid(payload) {
+    if (!payload || typeof payload !== "object")
+        return undefined;
+    const record = payload;
+    const data = record.data && typeof record.data === "object" && !Array.isArray(record.data)
+        ? record.data
+        : null;
+    const candidates = [
+        record.messageGuid,
+        record.messageId,
+        record.guid,
+        data?.messageGuid,
+        data?.messageId,
+        data?.guid,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+async function parseJsonBody(response) {
+    const raw = await response.text();
+    if (!raw.trim())
+        return null;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function describeCaughtValue(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function buildRepairUrl(baseUrl, messageGuid, password) {
+    const url = buildBlueBubblesApiUrl(baseUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}`, password);
+    const parsed = new URL(url);
+    parsed.searchParams.set("with", "attachments,payloadData,chats,messageSummaryInfo");
+    return parsed.toString();
+}
+function extractChatIdentifierFromGuid(chatGuid) {
+    const parts = chatGuid.split(";");
+    return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
+}
+function extractChatGuid(value) {
+    const record = asRecord(value);
+    const candidates = [
+        record?.chatGuid,
+        record?.guid,
+        record?.chat_guid,
+        record?.identifier,
+        record?.chatIdentifier,
+        record?.chat_identifier,
+    ];
+    for (const candidate of candidates) {
+        if (typeof candidate === "string" && candidate.trim()) {
+            return candidate.trim();
+        }
+    }
+    return undefined;
+}
+function extractQueriedChatIdentifier(chat, chatGuid) {
+    const explicitIdentifier = readString(chat, "chatIdentifier")
+        ?? readString(chat, "identifier")
+        ?? readString(chat, "chat_identifier");
+    if (explicitIdentifier) {
+        return explicitIdentifier;
+    }
+    return extractChatIdentifierFromGuid(chatGuid);
+}
+function extractChatQueryRows(payload) {
+    const record = asRecord(payload);
+    const data = Array.isArray(record?.data) ? record.data : payload;
+    if (!Array.isArray(data)) {
+        return [];
+    }
+    return data.map((entry) => asRecord(entry)).filter((entry) => entry !== null);
+}
+function extractMessageQueryRows(payload) {
+    const record = asRecord(payload);
+    const data = asRecord(record?.data);
+    const rows = Array.isArray(record?.data) ? record.data
+        : Array.isArray(data?.messages) ? data.messages
+            : Array.isArray(data?.results) ? data.results
+                : Array.isArray(record?.messages) ? record.messages
+                    : Array.isArray(payload) ? payload
+                        : [];
+    return rows.map((entry) => asRecord(entry)).filter((entry) => entry !== null);
+}
+async function resolveChatGuidForIdentifier(config, channelConfig, chatIdentifier) {
+    const trimmedIdentifier = chatIdentifier.trim();
+    if (!trimmedIdentifier)
+        return undefined;
+    const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/chat/query", config.password);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            limit: 500,
+            offset: 0,
+            with: ["participants"],
+        }),
+        signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+    });
+    if (!response.ok) {
+        return undefined;
+    }
+    const payload = await parseJsonBody(response);
+    const rows = extractChatQueryRows(payload);
+    for (const row of rows) {
+        const guid = extractChatGuid(row);
+        if (!guid)
+            continue;
+        const identifier = extractQueriedChatIdentifier(row, guid);
+        if (identifier === trimmedIdentifier || guid === trimmedIdentifier) {
+            return guid;
+        }
+    }
+    return undefined;
+}
+function collectPreviewStrings(value, out, depth = 0) {
+    if (depth > 4 || out.length >= 4)
+        return;
+    if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed)
+            out.push(trimmed);
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const entry of value)
+            collectPreviewStrings(entry, out, depth + 1);
+        return;
+    }
+    const record = asRecord(value);
+    if (!record)
+        return;
+    const preferredKeys = ["title", "summary", "subtitle", "previewText", "siteName", "host", "url"];
+    for (const key of preferredKeys) {
+        if (out.length >= 4)
+            break;
+        collectPreviewStrings(record[key], out, depth + 1);
+    }
+}
+function extractLinkPreviewText(data) {
+    const values = [];
+    collectPreviewStrings(data.payloadData, values);
+    collectPreviewStrings(data.messageSummaryInfo, values);
+    const unique = [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+    if (unique.length === 0)
+        return undefined;
+    return unique.slice(0, 2).join(" — ");
+}
+function applyRepairNotice(event, notice) {
+    return {
+        ...event,
+        requiresRepair: false,
+        repairNotice: notice,
+    };
+}
+function hasRecoverableMessageContent(event) {
+    return event.kind === "message"
+        && (event.textForAgent.trim().length > 0
+            || event.attachments.length > 0
+            || event.hasPayloadData);
+}
+function hydrateTextForAgent(event, rawData) {
+    if (event.kind !== "message") {
+        return { ...event, requiresRepair: false };
+    }
+    if (event.balloonBundleId !== "com.apple.messages.URLBalloonProvider") {
+        return { ...event, requiresRepair: false };
+    }
+    const previewText = extractLinkPreviewText(rawData);
+    if (!previewText) {
+        return { ...event, requiresRepair: false };
+    }
+    const base = event.text.trim();
+    const textForAgent = base
+        ? `${base}\n[link preview: ${previewText}]`
+        : `[link preview: ${previewText}]`;
+    return {
+        ...event,
+        textForAgent,
+        requiresRepair: false,
+    };
+}
+function extractRepairData(payload) {
+    const record = asRecord(payload);
+    return asRecord(record?.data) ?? record;
+}
+function providerSupportsAudioInput(provider) {
+    void provider;
+    return false;
+}
+async function resolveChatGuid(chat, config, channelConfig) {
+    return chat.chatGuid
+        ?? await resolveChatGuidForIdentifier(config, channelConfig, chat.chatIdentifier ?? "");
+}
+function createBlueBubblesClient(config = (0, config_1.getBlueBubblesConfig)(), channelConfig = (0, config_1.getBlueBubblesChannelConfig)()) {
+    return {
+        async sendText(params) {
+            const trimmedText = params.text.trim();
+            if (!trimmedText) {
+                throw new Error("BlueBubbles send requires non-empty text.");
+            }
+            const resolvedChatGuid = await resolveChatGuid(params.chat, config, channelConfig);
+            if (!resolvedChatGuid) {
+                throw new Error("BlueBubbles send currently requires chat.chatGuid from the inbound event.");
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/text", config.password);
+            const body = {
+                chatGuid: resolvedChatGuid,
+                tempGuid: (0, node_crypto_1.randomUUID)(),
+                message: trimmedText,
+            };
+            if (params.replyToMessageGuid?.trim()) {
+                body.method = "private-api";
+                body.selectedMessageGuid = params.replyToMessageGuid.trim();
+                body.partIndex = 0;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_send_start",
+                message: "sending bluebubbles message",
+                meta: {
+                    chatGuid: resolvedChatGuid,
+                    hasReplyTarget: Boolean(params.replyToMessageGuid?.trim()),
+                },
+            });
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "error",
+                    component: "senses",
+                    event: "senses.bluebubbles_send_error",
+                    message: "bluebubbles send failed",
+                    meta: {
+                        status: response.status,
+                        reason: errorText || "unknown",
+                    },
+                });
+                throw new Error(`BlueBubbles send failed (${response.status}): ${errorText || "unknown"}`);
+            }
+            const payload = await parseJsonBody(response);
+            const messageGuid = extractMessageGuid(payload);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_send_end",
+                message: "bluebubbles message sent",
+                meta: {
+                    chatGuid: resolvedChatGuid,
+                    messageGuid: messageGuid ?? null,
+                },
+            });
+            return { messageGuid };
+        },
+        async editMessage(params) {
+            const messageGuid = params.messageGuid.trim();
+            const text = params.text.trim();
+            if (!messageGuid) {
+                throw new Error("BlueBubbles edit requires messageGuid.");
+            }
+            if (!text) {
+                throw new Error("BlueBubbles edit requires non-empty text.");
+            }
+            const editTimeoutMs = Math.max(channelConfig.requestTimeoutMs, 120000);
+            const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/message/${encodeURIComponent(messageGuid)}/edit`, config.password);
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    editedMessage: text,
+                    backwardsCompatibilityMessage: params.backwardsCompatibilityMessage ?? `Edited to: ${text}`,
+                    partIndex: typeof params.partIndex === "number" ? params.partIndex : 0,
+                }),
+                signal: AbortSignal.timeout(editTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`BlueBubbles edit failed (${response.status}): ${errorText || "unknown"}`);
+            }
+        },
+        async setTyping(chat, typing) {
+            const resolvedChatGuid = await resolveChatGuid(chat, config, channelConfig);
+            if (!resolvedChatGuid) {
+                return;
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/chat/${encodeURIComponent(resolvedChatGuid)}/typing`, config.password);
+            const response = await fetch(url, {
+                method: typing ? "POST" : "DELETE",
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`BlueBubbles typing failed (${response.status}): ${errorText || "unknown"}`);
+            }
+        },
+        async markChatRead(chat) {
+            const resolvedChatGuid = await resolveChatGuid(chat, config, channelConfig);
+            if (!resolvedChatGuid) {
+                return;
+            }
+            const url = buildBlueBubblesApiUrl(config.serverUrl, `/api/v1/chat/${encodeURIComponent(resolvedChatGuid)}/read`, config.password);
+            const response = await fetch(url, {
+                method: "POST",
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                throw new Error(`BlueBubbles read failed (${response.status}): ${errorText || "unknown"}`);
+            }
+        },
+        async checkHealth() {
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_healthcheck_start",
+                message: "probing bluebubbles upstream health",
+                meta: { serverUrl: config.serverUrl },
+            });
+            const result = await (0, bluebubbles_health_diagnostics_1.probeBlueBubblesHealth)({
+                serverUrl: config.serverUrl,
+                password: config.password,
+                requestTimeoutMs: channelConfig.requestTimeoutMs,
+                fetchImpl: fetch,
+            });
+            if (!result.ok) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_healthcheck_error",
+                    message: "bluebubbles upstream health probe failed",
+                    meta: {
+                        serverUrl: config.serverUrl,
+                        status: result.status,
+                        reason: result.reason,
+                        classification: result.classification,
+                        detail: (0, bluebubbles_health_diagnostics_1.redactBlueBubblesHealthDetailForNerves)(result.detail),
+                    },
+                });
+                throw new Error(result.detail);
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_healthcheck_end",
+                message: "bluebubbles upstream health probe succeeded",
+                meta: { serverUrl: config.serverUrl },
+            });
+        },
+        async listRecentMessages(params = {}) {
+            const limit = Math.max(1, Math.min(100, Math.floor(params.limit ?? 50)));
+            const offset = Math.max(0, Math.floor(params.offset ?? 0));
+            const url = buildBlueBubblesApiUrl(config.serverUrl, "/api/v1/message/query", config.password);
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_query_recent_start",
+                message: "querying recent bluebubbles messages",
+                meta: { limit, offset },
+            });
+            const response = await fetch(url, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    limit,
+                    offset,
+                    sort: "DESC",
+                    with: ["chats", "attachments", "payloadData", "messageSummaryInfo"],
+                }),
+                signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+            });
+            if (!response.ok) {
+                const errorText = await response.text().catch(() => "");
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_query_recent_error",
+                    message: "bluebubbles recent message query failed",
+                    meta: {
+                        status: response.status,
+                        reason: errorText || "unknown",
+                    },
+                });
+                throw new Error(`BlueBubbles recent message query failed (${response.status}): ${errorText || "unknown"}`);
+            }
+            const payload = await parseJsonBody(response);
+            const rows = extractMessageQueryRows(payload);
+            const messages = [];
+            for (const row of rows) {
+                try {
+                    messages.push((0, model_1.normalizeBlueBubblesEvent)({ type: "new-message", data: row }));
+                }
+                catch (error) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_query_recent_skip",
+                        message: "skipped unusable bluebubbles recent message row",
+                        meta: {
+                            reason: describeCaughtValue(error),
+                        },
+                    });
+                }
+            }
+            (0, runtime_1.emitNervesEvent)({
+                component: "senses",
+                event: "senses.bluebubbles_query_recent_end",
+                message: "queried recent bluebubbles messages",
+                meta: {
+                    rows: rows.length,
+                    normalized: messages.length,
+                },
+            });
+            return messages;
+        },
+        async repairEvent(event) {
+            if (!event.requiresRepair) {
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_skipped",
+                    message: "bluebubbles event repair skipped",
+                    meta: {
+                        kind: event.kind,
+                        messageGuid: event.messageGuid,
+                    },
+                });
+                return event;
+            }
+            (0, runtime_1.emitNervesEvent)({
+                level: "warn",
+                component: "senses",
+                event: "senses.bluebubbles_repair_start",
+                message: "repairing bluebubbles event by guid",
+                meta: {
+                    kind: event.kind,
+                    messageGuid: event.messageGuid,
+                    eventType: event.eventType,
+                },
+            });
+            const url = buildRepairUrl(config.serverUrl, event.messageGuid, config.password);
+            try {
+                const response = await fetch(url, {
+                    method: "GET",
+                    signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+                });
+                if (!response.ok) {
+                    const errorText = await response.text().catch(() => "");
+                    const repaired = applyRepairNotice(event, `BlueBubbles repair failed: ${errorText || `HTTP ${response.status}`}`);
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_repair_error",
+                        message: "bluebubbles repair request failed",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                            status: response.status,
+                            reason: errorText || "unknown",
+                        },
+                    });
+                    return repaired;
+                }
+                const payload = await parseJsonBody(response);
+                const data = extractRepairData(payload);
+                if (!data || typeof data.guid !== "string") {
+                    const repaired = applyRepairNotice(event, "BlueBubbles repair failed: invalid message payload");
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_repair_error",
+                        message: "bluebubbles repair returned unusable payload",
+                        meta: {
+                            messageGuid: event.messageGuid,
+                        },
+                    });
+                    return repaired;
+                }
+                const normalized = (0, model_1.normalizeBlueBubblesEvent)({
+                    type: event.eventType,
+                    data,
+                });
+                const recoveredMessage = event.kind === "mutation"
+                    && !event.shouldNotifyAgent
+                    ? (0, model_1.normalizeBlueBubblesEvent)({
+                        type: "new-message",
+                        data,
+                    })
+                    : null;
+                let hydrated = recoveredMessage && hasRecoverableMessageContent(recoveredMessage)
+                    ? hydrateTextForAgent(recoveredMessage, data)
+                    : hydrateTextForAgent(normalized, data);
+                if (hydrated.kind === "message" &&
+                    hydrated.balloonBundleId !== "com.apple.messages.URLBalloonProvider" &&
+                    hydrated.attachments.length > 0) {
+                    const agentConfig = (0, identity_1.loadAgentConfig)();
+                    const chatModel = agentConfig.humanFacing.model;
+                    const chatProvider = agentConfig.humanFacing.provider;
+                    const vlmDescribe = async (params) => {
+                        if (chatProvider !== "minimax") {
+                            throw new Error("VLM fallback requires a minimax credential for this agent — " +
+                                "configure one or switch to a vision-capable chat model");
+                        }
+                        const { readProviderCredentialRecord } = await Promise.resolve().then(() => __importStar(require("../../heart/provider-credentials")));
+                        const credential = await readProviderCredentialRecord((0, identity_1.getAgentName)(), "minimax");
+                        const apiKey = credential.ok ? credential.record.credentials.apiKey : undefined;
+                        if (!apiKey) {
+                            throw new Error("VLM fallback: minimax API key not found in the agent vault — " +
+                                "run `ouro auth --agent <agent> --provider minimax`");
+                        }
+                        return (0, minimax_vlm_1.minimaxVlmDescribe)({
+                            apiKey: String(apiKey),
+                            prompt: params.prompt,
+                            imageDataUrl: params.imageDataUrl,
+                            baseURL: minimax_1.MINIMAX_PROVIDER_BASE_URL,
+                            attachmentGuid: params.attachmentGuid,
+                            mimeType: params.mimeType,
+                            chatModel: params.chatModel,
+                        });
+                    };
+                    // VLM prompt context wants the user's raw inbound text — NOT
+                    // the agent-facing rendering, which now carries the attachment
+                    // marker after the B2 fix. Pull it from the source payload.
+                    const rawUserText = typeof data.text === "string"
+                        ? (data.text).trim()
+                        : "";
+                    const media = await (0, media_1.hydrateBlueBubblesAttachments)(hydrated.attachments, config, channelConfig, {
+                        preferAudioInput: providerSupportsAudioInput(chatProvider),
+                        chatModel,
+                        vlmDescribe,
+                        userText: rawUserText,
+                    });
+                    const transcriptSuffix = media.transcriptAdditions.map((entry) => `[${entry}]`).join("\n");
+                    const noticeSuffix = media.notices.map((entry) => `[${entry}]`).join("\n");
+                    const combinedSuffix = [transcriptSuffix, noticeSuffix].filter(Boolean).join("\n");
+                    hydrated = {
+                        ...hydrated,
+                        inputPartsForAgent: media.inputParts.length > 0 ? media.inputParts : undefined,
+                        textForAgent: [hydrated.textForAgent, combinedSuffix].filter(Boolean).join("\n"),
+                    };
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_end",
+                    message: "bluebubbles event repaired",
+                    meta: {
+                        kind: hydrated.kind,
+                        messageGuid: hydrated.messageGuid,
+                        repairedFrom: event.kind,
+                        promotedFromMutation: event.kind === "mutation" && hydrated.kind === "message",
+                    },
+                });
+                return hydrated;
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_repair_error",
+                    message: "bluebubbles repair threw",
+                    meta: {
+                        messageGuid: event.messageGuid,
+                        reason,
+                    },
+                });
+                return applyRepairNotice(event, `BlueBubbles repair failed: ${reason}`);
+            }
+        },
+        async getMessageText(messageGuid) {
+            const url = buildRepairUrl(config.serverUrl, messageGuid, config.password);
+            try {
+                const response = await fetch(url, {
+                    method: "GET",
+                    signal: AbortSignal.timeout(channelConfig.requestTimeoutMs),
+                });
+                if (!response.ok) {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_get_message_text_error",
+                        message: "failed to fetch message text",
+                        meta: { messageGuid, status: response.status },
+                    });
+                    return null;
+                }
+                const payload = await parseJsonBody(response);
+                const data = extractRepairData(payload);
+                if (!data || typeof data.text !== "string") {
+                    (0, runtime_1.emitNervesEvent)({
+                        level: "warn",
+                        component: "senses",
+                        event: "senses.bluebubbles_get_message_text_error",
+                        message: "message payload missing text field",
+                        meta: { messageGuid, hasData: !!data, textType: data ? typeof data.text : "n/a" },
+                    });
+                    return null;
+                }
+                (0, runtime_1.emitNervesEvent)({
+                    component: "senses",
+                    event: "senses.bluebubbles_get_message_text",
+                    message: "fetched message text by guid",
+                    meta: { messageGuid },
+                });
+                return data.text.trim() || null;
+            }
+            catch (error) {
+                (0, runtime_1.emitNervesEvent)({
+                    level: "warn",
+                    component: "senses",
+                    event: "senses.bluebubbles_get_message_text_error",
+                    message: "exception fetching message text",
+                    meta: { messageGuid, reason: error instanceof Error ? error.message : String(error) },
+                });
+                return null;
+            }
+        },
+    };
+}