@ouro.bot/cli 0.1.0-alpha.23 → 0.1.0-alpha.230

package/dist/senses/{bluebubbles-media.js → bluebubbles/media.js}

@@ -38,7 +38,8 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs/promises"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
-const runtime_1 = require("../nerves/runtime");
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../../heart/identity");
 const MAX_ATTACHMENT_BYTES = 8 * 1024 * 1024;
 const AUDIO_EXTENSIONS = new Set([".mp3", ".wav", ".m4a", ".caf", ".ogg"]);
 const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".gif", ".webp", ".heic", ".heif"]);
@@ -62,6 +63,12 @@ const AUDIO_INPUT_FORMAT_BY_EXTENSION = {
     ".wav": "wav",
     ".mp3": "mp3",
 };
+const WHISPER_CPP_FORMULA = "whisper-cpp";
+const WHISPER_CPP_MODEL_NAME = "ggml-base.en.bin";
+const WHISPER_CPP_MODEL_URL = `https://huggingface.co/ggerganov/whisper.cpp/resolve/main/${WHISPER_CPP_MODEL_NAME}`;
+const WHISPER_CPP_TOOLS_DIR = path.join((0, identity_1.getAgentToolsRoot)(), "whisper-cpp");
+const WHISPER_CPP_MODELS_DIR = path.join(WHISPER_CPP_TOOLS_DIR, "models");
+const WHISPER_CPP_MODEL_PATH = path.join(WHISPER_CPP_MODELS_DIR, WHISPER_CPP_MODEL_NAME);
 function buildBlueBubblesApiUrl(baseUrl, endpoint, password) {
     const root = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
     const url = new URL(endpoint.replace(/^\//, ""), root);
@@ -107,36 +114,123 @@ function audioFormatForInput(contentType, attachment) {
     const extension = path.extname(attachment?.transferName ?? "").toLowerCase();
     return AUDIO_INPUT_FORMAT_BY_CONTENT_TYPE[contentType ?? ""] ?? AUDIO_INPUT_FORMAT_BY_EXTENSION[extension];
 }
-async function transcribeAudioWithWhisper(params) {
+async function execFileText(file, args, timeout) {
+    return await new Promise((resolve, reject) => {
+        (0, node_child_process_1.execFile)(file, args, { timeout }, (error, stdout = "", stderr = "") => {
+            if (error) {
+                const detail = stderr.trim() || stdout.trim() || error.message;
+                reject(new Error(detail));
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveWhisperCppBinary(timeoutMs) {
+    try {
+        const existing = (await execFileText("which", ["whisper-cli"], timeoutMs)).trim();
+        if (existing) {
+            return existing;
+        }
+    }
+    catch {
+        // fall through to managed install
+    }
+    let prefix = "";
+    try {
+        prefix = (await execFileText("brew", ["--prefix", WHISPER_CPP_FORMULA], timeoutMs)).trim();
+        if (prefix) {
+            const candidate = path.join(prefix, "bin", "whisper-cli");
+            if (await pathExists(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    catch {
+        // fall through to managed install
+    }
+    await execFileText("brew", ["install", WHISPER_CPP_FORMULA], Math.max(timeoutMs, 300_000));
+    prefix = (await execFileText("brew", ["--prefix", WHISPER_CPP_FORMULA], timeoutMs)).trim();
+    if (!prefix) {
+        throw new Error("whisper.cpp installed but brew did not return a usable prefix");
+    }
+    const candidate = path.join(prefix, "bin", "whisper-cli");
+    if (!await pathExists(candidate)) {
+        throw new Error("whisper.cpp installed but whisper-cli binary is missing");
+    }
+    return candidate;
+}
+async function ensureWhisperCppModel(timeoutMs, fetchImpl) {
+    try {
+        await fs.access(WHISPER_CPP_MODEL_PATH);
+        return WHISPER_CPP_MODEL_PATH;
+    }
+    catch {
+        await fs.mkdir(WHISPER_CPP_MODELS_DIR, { recursive: true });
+        const response = await fetchImpl(WHISPER_CPP_MODEL_URL, {
+            method: "GET",
+            signal: AbortSignal.timeout(Math.max(timeoutMs, 300_000)),
+        });
+        if (!response.ok) {
+            throw new Error(`failed to download whisper.cpp model: HTTP ${response.status}`);
+        }
+        await fs.writeFile(WHISPER_CPP_MODEL_PATH, Buffer.from(await response.arrayBuffer()));
+        return WHISPER_CPP_MODEL_PATH;
+    }
+}
+async function convertAudioForWhisperCpp(sourcePath, outputPath, timeoutMs) {
+    try {
+        await execFileText("ffmpeg", ["-y", "-i", sourcePath, "-ar", "16000", "-ac", "1", "-c:a", "pcm_s16le", outputPath], Math.max(timeoutMs, 120_000));
+        return;
+    }
+    catch (ffmpegError) {
+        try {
+            await execFileText("afconvert", ["-f", "WAVE", "-d", "LEI16@16000", "-c", "1", sourcePath, outputPath], Math.max(timeoutMs, 120_000));
+            return;
+        }
+        catch (afconvertError) {
+            const ffmpegReason = ffmpegError.message;
+            const afconvertReason = afconvertError.message;
+            throw new Error(`failed to prepare audio for whisper.cpp (ffmpeg: ${ffmpegReason}; afconvert: ${afconvertReason})`);
+        }
+    }
+}
+async function transcribeAudioWithWhisperCpp(params, modelFetchImpl = fetch) {
     const workDir = await fs.mkdtemp(path.join(os.tmpdir(), "ouro-bb-audio-"));
     const filename = sanitizeFilename(describeAttachment(params.attachment));
     const extension = fileExtensionForAudio(params.attachment, params.contentType);
     const audioPath = path.join(workDir, `${path.parse(filename).name}${extension}`);
+    const wavPath = path.join(workDir, `${path.parse(audioPath).name}.wav`);
+    const outputBase = path.join(workDir, path.parse(audioPath).name);
     try {
         await fs.writeFile(audioPath, params.buffer);
-        await new Promise((resolve, reject) => {
-            (0, node_child_process_1.execFile)("whisper", [
-                audioPath,
-                "--model",
-                "turbo",
-                "--output_dir",
-                workDir,
-                "--output_format",
-                "json",
-                "--verbose",
-                "False",
-            ], { timeout: Math.max(params.timeoutMs, 120000) }, (error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
-        });
-        const transcriptPath = path.join(workDir, `${path.parse(audioPath).name}.json`);
+        const whisperCliPath = await resolveWhisperCppBinary(params.timeoutMs);
+        const modelPath = await ensureWhisperCppModel(params.timeoutMs, modelFetchImpl);
+        await convertAudioForWhisperCpp(audioPath, wavPath, params.timeoutMs);
+        await execFileText(whisperCliPath, ["-m", modelPath, "-f", wavPath, "-oj", "-of", outputBase], Math.max(params.timeoutMs, 120_000));
+        const transcriptPath = `${outputBase}.json`;
         const raw = await fs.readFile(transcriptPath, "utf8");
         const parsed = JSON.parse(raw);
-        return typeof parsed.text === "string" ? parsed.text.trim() : "";
+        if (typeof parsed.text === "string") {
+            return parsed.text.trim();
+        }
+        if (Array.isArray(parsed.transcription)) {
+            return parsed.transcription
+                .map((entry) => (typeof entry?.text === "string" ? entry.text.trim() : ""))
+                .filter(Boolean)
+                .join(" ")
+                .trim();
+        }
+        return "";
     }
     finally {
         await fs.rm(workDir, { recursive: true, force: true }).catch(() => undefined);
@@ -178,7 +272,8 @@ async function hydrateBlueBubblesAttachments(attachments, config, channelConfig,
         },
     });
     const fetchImpl = deps.fetchImpl ?? fetch;
-    const transcribeAudio = deps.transcribeAudio ?? transcribeAudioWithWhisper;
+    const modelFetchImpl = deps.modelFetchImpl ?? fetch;
+    const transcribeAudio = deps.transcribeAudio ?? ((params) => transcribeAudioWithWhisperCpp(params, modelFetchImpl));
     const preferAudioInput = deps.preferAudioInput ?? false;
     const inputParts = [];
     const transcriptAdditions = [];

package/dist/senses/{bluebubbles-model.js → bluebubbles/model.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeBlueBubblesEvent = normalizeBlueBubblesEvent;
-const runtime_1 = require("../nerves/runtime");
+const runtime_1 = require("../../nerves/runtime");
 function asRecord(value) {
     return value && typeof value === "object" && !Array.isArray(value)
         ? value
@@ -39,6 +39,7 @@ function extractChatIdentifierFromGuid(chatGuid) {
     return parts.length >= 3 ? parts[2]?.trim() || undefined : undefined;
 }
 function buildChatRef(data, threadOriginatorGuid) {
+    void threadOriginatorGuid;
     const chats = Array.isArray(data.chats) ? data.chats : [];
     const chat = asRecord(chats[0]) ?? null;
     const chatGuid = readString(chat, "guid");
@@ -48,12 +49,18 @@ function buildChatRef(data, threadOriginatorGuid) {
     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()
+    const sessionKey = chatGuid?.trim()
         ? `chat:${chatGuid.trim()}`
         : `chat_identifier:${(chatIdentifier ?? "unknown").trim()}`;
-    const sessionKey = threadOriginatorGuid?.trim()
-        ? `${baseKey}:thread:${threadOriginatorGuid.trim()}`
-        : baseKey;
+    // Extract participant handles from chat.participants (when available from BB API)
+    const rawParticipants = Array.isArray(chat?.participants) ? chat.participants : [];
+    const participantHandles = rawParticipants
+        .map((p) => {
+        const rec = asRecord(p);
+        const addr = readString(rec, "address") ?? readString(rec, "id");
+        return addr ? normalizeHandle(addr) : "";
+    })
+        .filter(Boolean);
     return {
         chatGuid: chatGuid?.trim() || undefined,
         chatIdentifier: chatIdentifier?.trim() || undefined,
@@ -63,6 +70,7 @@ function buildChatRef(data, threadOriginatorGuid) {
         sendTarget: chatGuid?.trim()
             ? { kind: "chat_guid", value: chatGuid.trim() }
             : { kind: "chat_identifier", value: (chatIdentifier ?? "unknown").trim() },
+        participantHandles,
     };
 }
 function extractSender(data, chat) {

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

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

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

@@ -0,0 +1,109 @@
+"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.getBlueBubblesRuntimeStatePath = getBlueBubblesRuntimeStatePath;
+exports.readBlueBubblesRuntimeState = readBlueBubblesRuntimeState;
+exports.writeBlueBubblesRuntimeState = writeBlueBubblesRuntimeState;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const identity_1 = require("../../heart/identity");
+const runtime_1 = require("../../nerves/runtime");
+const DEFAULT_RUNTIME_STATE = {
+    upstreamStatus: "unknown",
+    detail: "startup health probe pending",
+    pendingRecoveryCount: 0,
+};
+function getBlueBubblesRuntimeStatePath(agentName, agentRoot = (0, identity_1.getAgentRoot)(agentName)) {
+    return path.join(agentRoot, "state", "senses", "bluebubbles", "runtime.json");
+}
+function readBlueBubblesRuntimeState(agentName, agentRoot) {
+    const filePath = getBlueBubblesRuntimeStatePath(agentName, agentRoot);
+    try {
+        const raw = fs.readFileSync(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            upstreamStatus: parsed.upstreamStatus === "ok" || parsed.upstreamStatus === "error"
+                ? parsed.upstreamStatus
+                : "unknown",
+            detail: typeof parsed.detail === "string" && parsed.detail.trim()
+                ? parsed.detail
+                : DEFAULT_RUNTIME_STATE.detail,
+            lastCheckedAt: typeof parsed.lastCheckedAt === "string" ? parsed.lastCheckedAt : undefined,
+            pendingRecoveryCount: typeof parsed.pendingRecoveryCount === "number" && Number.isFinite(parsed.pendingRecoveryCount)
+                ? parsed.pendingRecoveryCount
+                : 0,
+            lastRecoveredAt: typeof parsed.lastRecoveredAt === "string" ? parsed.lastRecoveredAt : undefined,
+            lastRecoveredMessageGuid: typeof parsed.lastRecoveredMessageGuid === "string"
+                ? parsed.lastRecoveredMessageGuid
+                : undefined,
+        };
+    }
+    catch {
+        return { ...DEFAULT_RUNTIME_STATE };
+    }
+}
+function writeBlueBubblesRuntimeState(agentName, state, agentRoot) {
+    const filePath = getBlueBubblesRuntimeStatePath(agentName, agentRoot);
+    try {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, JSON.stringify(state, null, 2) + "\n", "utf-8");
+    }
+    catch (error) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_runtime_state_error",
+            message: "failed to write bluebubbles runtime state",
+            meta: {
+                agentName,
+                upstreamStatus: state.upstreamStatus,
+                reason: error instanceof Error ? error.message : String(error),
+            },
+        });
+        return filePath;
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.bluebubbles_runtime_state_written",
+        message: "wrote bluebubbles runtime state",
+        meta: {
+            agentName,
+            upstreamStatus: state.upstreamStatus,
+            pendingRecoveryCount: state.pendingRecoveryCount,
+            path: filePath,
+        },
+    });
+    return filePath;
+}

package/dist/senses/bluebubbles/session-cleanup.js

@@ -0,0 +1,72 @@
+"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.findObsoleteBlueBubblesThreadSessions = findObsoleteBlueBubblesThreadSessions;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const runtime_1 = require("../../nerves/runtime");
+function findObsoleteBlueBubblesThreadSessions(trunkSessionPath) {
+    const normalized = trunkSessionPath.trim();
+    if (!normalized.endsWith(".json"))
+        return [];
+    const trunkName = path.basename(normalized);
+    if (trunkName.includes("_thread_"))
+        return [];
+    if (!fs.existsSync(normalized))
+        return [];
+    const dir = path.dirname(normalized);
+    const prefix = trunkName.slice(0, -".json".length);
+    const threadLaneFiles = [];
+    for (const entry of fs.readdirSync(dir)) {
+        if (!entry.endsWith(".json"))
+            continue;
+        if (!entry.startsWith(`${prefix}_thread_`))
+            continue;
+        threadLaneFiles.push(path.join(dir, entry));
+    }
+    if (threadLaneFiles.length > 0) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "senses",
+            event: "senses.bluebubbles_thread_lane_artifacts_detected",
+            message: "detected obsolete bluebubbles thread-lane sessions",
+            meta: {
+                sessionPath: normalized,
+                artifactCount: threadLaneFiles.length,
+            },
+        });
+    }
+    return threadLaneFiles;
+}