@ouro.bot/cli 0.1.0-alpha.27 → 0.1.0-alpha.28

package/changelog.json

@@ -1,6 +1,14 @@
 {
   "_note": "This changelog is maintained as part of the PR/version-bump workflow. Agent-curated, not auto-generated. Agents read this file directly via read_file to understand what changed between versions.",
   "versions": [
+    {
+      "version": "0.1.0-alpha.28",
+      "changes": [
+        "Bare npx ouro.bot now stays aligned with the current alpha CLI track because the published ouro.bot wrapper is version-locked and republished alongside the CLI instead of lagging behind it.",
+        "Slugger no longer re-opens active iMessage task threads with generic greetings like 'hiya' when work is already in motion; fresh idle conversations can still start warmly.",
+        "BlueBubbles voice notes now use a harness-managed whisper.cpp transcription path for the current OpenAI, Anthropic, and MiniMax runtime contracts, including automatic local provisioning and truthful error notices when transcription cannot complete."
+      ]
+    },
     {
       "version": "0.1.0-alpha.27",
       "changes": [

package/dist/heart/daemon/wrapper-publish-guard.js

@@ -7,6 +7,26 @@ function wrapperPackageChanged(changedFiles) {
 }
 function assessWrapperPublishSync(input) {
     let result;
+    if (input.localVersion !== input.cliVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper version ${input.localVersion} must match @ouro.bot/cli version ${input.cliVersion}`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: {
+                changed: wrapperPackageChanged(input.changedFiles),
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
+        });
+        return result;
+    }
     if (!wrapperPackageChanged(input.changedFiles)) {
         result = {
             ok: true,
@@ -16,7 +36,13 @@ function assessWrapperPublishSync(input) {
             component: "daemon",
             event: "daemon.wrapper_publish_guard_checked",
             message: "evaluated wrapper publish sync",
-            meta: { changed: false, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+            meta: {
+                changed: false,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
         });
         return result;
     }
@@ -30,7 +56,13 @@ function assessWrapperPublishSync(input) {
             component: "daemon",
             event: "daemon.wrapper_publish_guard_checked",
             message: "evaluated wrapper publish sync",
-            meta: { changed: true, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+            meta: {
+                changed: true,
+                localVersion: input.localVersion,
+                cliVersion: input.cliVersion,
+                publishedVersion: input.publishedVersion,
+                ok: result.ok,
+            },
         });
         return result;
     }
@@ -42,7 +74,13 @@ function assessWrapperPublishSync(input) {
         component: "daemon",
         event: "daemon.wrapper_publish_guard_checked",
         message: "evaluated wrapper publish sync",
-        meta: { changed: true, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+        meta: {
+            changed: true,
+            localVersion: input.localVersion,
+            cliVersion: input.cliVersion,
+            publishedVersion: input.publishedVersion,
+            ok: result.ok,
+        },
     });
     return result;
 }

package/dist/mind/first-impressions.js

@@ -37,7 +37,8 @@ function getFirstImpressions(friend) {
     lines.push("- what do they do outside of work that they care about?");
     lines.push("i don't ask all of these at once -- i weave them into conversation naturally, one or two at a time, and i genuinely follow up on what they share.");
     lines.push("i introduce what i can do -- i have tools, integrations, and skills that can help them. i mention these naturally as they become relevant.");
-    lines.push("if my friend hasn't asked me to do something specific, or i've already finished what they asked for, that's my cue to turn the tables -- i ask them questions about themselves, what they're into, what they need. no idle small talk; i'm on a mission to get to know them.");
+    lines.push("if we're already in motion on a task, thread, or follow-up, i do not reset with a generic opener like 'hiya' or 'what do ya need help with?'. i continue directly or ask the specific next question.");
+    lines.push("only when the conversation is genuinely fresh and idle, with no active ask or thread in flight, a light opener is okay.");
     lines.push("i save everything i learn immediately with save_friend_note -- names, roles, preferences, projects, anything. the bar is low: if i learned it, i save it.");
     return lines.join("\n");
 }

package/dist/senses/bluebubbles-client.js

@@ -196,7 +196,8 @@ function extractRepairData(payload) {
     return asRecord(record?.data) ?? record;
 }
 function providerSupportsAudioInput(provider) {
-    return provider === "azure" || provider === "openai-codex";
+    void provider;
+    return false;
 }
 async function resolveChatGuid(chat, config, channelConfig) {
     return chat.chatGuid

package/dist/senses/bluebubbles-media.js

@@ -62,6 +62,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(os.homedir(), ".agentstate", "tools", "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 +113,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 +271,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.27",
+  "version": "0.1.0-alpha.28",
   "main": "dist/heart/daemon/ouro-entry.js",
   "bin": {
     "cli": "dist/heart/daemon/ouro-bot-entry.js",