@ouro.bot/cli 0.1.0-alpha.727 → 0.1.0-alpha.728

package/dist/heart/versioning/ouro-path-installer.js

@@ -39,28 +39,20 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const runtime_1 = require("../../nerves/runtime");
-const WRAPPER_SCRIPT = `#!/bin/sh
-# Check for dev mode — if dev-config.json exists, dispatch to the dev repo
-# Skip dev dispatch for "up" command (explicitly returns to production)
-DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
-if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
-  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
-  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
-  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
-    exec node "$DEV_ENTRY" "$@"
-  fi
-fi
-# Fall back to installed version
-ENTRY="$HOME/.ouro-cli/CurrentVersion/node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js"
-if [ ! -e "$ENTRY" ]; then
-  echo "ouro not installed. Run: npx ouro.bot@latest" >&2
-  exit 1
-fi
-exec node "$ENTRY" "$@"
-`;
-function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync) {
+const ouro_recovery_launcher_1 = require("./ouro-recovery-launcher");
+const WRAPPER_SCRIPT = ouro_recovery_launcher_1.OURO_WRAPPER_SCRIPT;
+function writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync, renameSync, existsSync, readFileSync) {
+    const assets = (0, ouro_recovery_launcher_1.resolveOuroRecoveryLauncherAssets)();
     mkdirSync(path.dirname(scriptPath), { recursive: true });
-    writeFileSync(scriptPath, WRAPPER_SCRIPT, { mode: 0o755 });
+    const launcherPath = path.join(path.dirname(scriptPath), "ouro-launcher.js");
+    const launcherTempPath = `${launcherPath}.next-${process.pid}`;
+    writeFileSync(launcherTempPath, assets.launcherScript, { mode: 0o755 });
+    chmodSync(launcherTempPath, 0o755);
+    renameSync(launcherTempPath, launcherPath);
+    if (existsSync(launcherPath) && readFileSync(launcherPath, "utf8") !== assets.launcherScript) {
+        throw new Error("failed to verify installed Ouro recovery launcher");
+    }
+    writeFileSync(scriptPath, assets.wrapperScript, { mode: 0o755 });
     chmodSync(scriptPath, 0o755);
 }
 function detectShellProfile(homeDir, shell, platform) {
@@ -106,6 +98,16 @@ function isWrapperCurrent(scriptPath, existsSync, readFileSync) {
         return false;
     }
 }
+function isRecoveryLauncherCurrent(scriptPath, existsSync, readFileSync) {
+    if (!existsSync(scriptPath))
+        return false;
+    try {
+        return readFileSync(scriptPath, "utf-8") === ouro_recovery_launcher_1.OURO_RECOVERY_LAUNCHER_SCRIPT;
+    }
+    catch {
+        return false;
+    }
+}
 function isOwnedOuroLauncherPath(resolvedPath) {
     const normalized = path.normalize(resolvedPath);
     return (normalized.includes(`${path.sep}node_modules${path.sep}@ouro.bot${path.sep}cli${path.sep}`) ||
@@ -116,7 +118,8 @@ function isOwnedOuroLauncherContent(content) {
         content.includes("ouro.bot@latest") ||
         content.includes("ouro.bot@alpha") ||
         content.includes('exec npx --yes ouro.bot "$@"') ||
-        content.includes("CurrentVersion/node_modules/@ouro.bot/cli"));
+        content.includes("CurrentVersion/node_modules/@ouro.bot/cli") ||
+        content.includes(".ouro-cli/bin/ouro-launcher.js"));
 }
 function canRepairShadowedLauncher(shadowPath, existsSync, readFileSync, realpathSync) {
     if (!existsSync(shadowPath))
@@ -236,6 +239,7 @@ function installOuroCommand(deps = {}) {
     const realpathSync = deps.realpathSync ?? fs.realpathSync;
     const lstatSync = deps.lstatSync ?? fs.lstatSync;
     const unlinkSync = deps.unlinkSync ?? fs.unlinkSync;
+    const renameSync = deps.renameSync ?? fs.renameSync;
     const envPath = deps.envPath ?? process.env.PATH ?? "";
     const shell = deps.shell ?? process.env.SHELL;
     /* v8 ignore stop */
@@ -254,9 +258,11 @@ function installOuroCommand(deps = {}) {
     }
     const binDir = path.join(homeDir, ".ouro-cli", "bin");
     const scriptPath = path.join(binDir, "ouro");
+    const recoveryLauncherPath = path.join(binDir, "ouro-launcher.js");
     const oldScriptPath = path.join(homeDir, ".local", "bin", "ouro");
     const resolvePath = () => diagnoseOuroPath({ homeDir, envPath, existsSync, readFileSync });
-    const modernCurrent = isWrapperCurrent(scriptPath, existsSync, readFileSync);
+    const modernCurrent = isWrapperCurrent(scriptPath, existsSync, readFileSync)
+        && isRecoveryLauncherCurrent(recoveryLauncherPath, existsSync, readFileSync);
     const oldExists = existsSync(oldScriptPath);
     const oldCurrent = oldExists && isWrapperCurrent(oldScriptPath, existsSync, readFileSync);
     // ── Repair old ~/.local/bin/ouro launcher ──
@@ -332,7 +338,7 @@ function installOuroCommand(deps = {}) {
     });
     try {
         if (!modernCurrent) {
-            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync);
+            writeWrapperScript(scriptPath, mkdirSync, writeFileSync, chmodSync, renameSync, existsSync, readFileSync);
         }
     }
     catch (error) {

package/dist/heart/versioning/ouro-recovery-launcher.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OURO_WRAPPER_SCRIPT = exports.OURO_RECOVERY_LAUNCHER_SCRIPT = void 0;
+exports.resolveOuroRecoveryLauncherAssets = resolveOuroRecoveryLauncherAssets;
+const runtime_1 = require("../../nerves/runtime");
+exports.OURO_RECOVERY_LAUNCHER_SCRIPT = `#!/usr/bin/env node
+"use strict";
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const cp = require("child_process");
+const home = path.join(os.homedir(), ".ouro-cli");
+const current = path.join(home, "CurrentVersion");
+const intentPath = path.join(home, "version-intent.json");
+const entryRel = "node_modules/@ouro.bot/cli/dist/heart/daemon/ouro-entry.js";
+let intent = null;
+try {
+  intent = JSON.parse(fs.readFileSync(intentPath, "utf8"));
+  if (intent.schemaVersion !== 1 || !["pinned", "latest"].includes(intent.mode) || !intent.targetVersion) throw new Error("invalid fields");
+} catch (error) {
+  if (error && error.code !== "ENOENT") {
+    process.stderr.write("invalid Ouro version intent: " + error.message + "\\n");
+    process.exit(1);
+  }
+}
+if (intent) {
+  const target = path.join(home, "versions", intent.targetVersion);
+  const targetEntry = path.join(target, entryRel);
+  if (!fs.existsSync(targetEntry)) {
+    process.stderr.write("Ouro version intent target is not installed: " + intent.targetVersion + "\\n");
+    process.exit(1);
+  }
+  let active = null;
+  try { active = path.basename(fs.readlinkSync(current)); } catch {}
+  if (active !== intent.targetVersion) {
+    const next = current + ".next-" + process.pid;
+    try { fs.unlinkSync(next); } catch {}
+    fs.symlinkSync(target, next);
+    fs.renameSync(next, current);
+  }
+}
+const entry = path.join(current, entryRel);
+if (!fs.existsSync(entry)) {
+  process.stderr.write("ouro not installed. Run: npx ouro.bot@latest\\n");
+  process.exit(1);
+}
+const result = cp.spawnSync(process.execPath, [entry, ...process.argv.slice(2)], { stdio: "inherit" });
+if (result.error) throw result.error;
+if (result.signal) process.kill(process.pid, result.signal);
+process.exit(result.status == null ? 1 : result.status);
+`;
+exports.OURO_WRAPPER_SCRIPT = `#!/bin/sh
+# Check for dev mode — if dev-config.json exists, dispatch to the dev repo.
+# Skip dev dispatch for "up" command (explicitly returns to production).
+DEV_CONFIG="$HOME/.ouro-cli/dev-config.json"
+if [ -f "$DEV_CONFIG" ] && [ "$1" != "up" ]; then
+  DEV_REPO=$(node -e "try{console.log(JSON.parse(require('fs').readFileSync('$DEV_CONFIG','utf-8')).repoPath)}catch{}" 2>/dev/null)
+  DEV_ENTRY="$DEV_REPO/dist/heart/daemon/ouro-entry.js"
+  if [ -n "$DEV_REPO" ] && [ -e "$DEV_ENTRY" ]; then
+    exec node "$DEV_ENTRY" "$@"
+  fi
+fi
+exec node "$HOME/.ouro-cli/bin/ouro-launcher.js" "$@"
+`;
+function resolveOuroRecoveryLauncherAssets() {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.ouro_recovery_launcher_assets_resolved",
+        message: "resolved stable CLI recovery launcher assets",
+        meta: { launcher: "ouro-launcher.js", wrapper: "ouro" },
+    });
+    return {
+        launcherScript: exports.OURO_RECOVERY_LAUNCHER_SCRIPT,
+        wrapperScript: exports.OURO_WRAPPER_SCRIPT,
+    };
+}

package/dist/heart/versioning/version-intent.js

@@ -0,0 +1,114 @@
+"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.versionIntentPath = versionIntentPath;
+exports.readVersionIntent = readVersionIntent;
+exports.writeVersionIntent = writeVersionIntent;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+function versionIntentPath(homeDir = os.homedir()) {
+    return path.join(homeDir, ".ouro-cli", "version-intent.json");
+}
+function parseVersionIntent(raw) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("invalid version intent: malformed JSON");
+    }
+    if (!value
+        || typeof value !== "object"
+        || value.schemaVersion !== 1
+        || !["pinned", "latest"].includes(String(value.mode))
+        || typeof value.targetVersion !== "string"
+        || !value.targetVersion) {
+        throw new Error("invalid version intent: expected schemaVersion=1, mode, and targetVersion");
+    }
+    return value;
+}
+function readVersionIntent(deps = {}) {
+    const readFileSync = deps.readFileSync ?? fs.readFileSync;
+    try {
+        return parseVersionIntent(readFileSync(versionIntentPath(deps.homeDir), "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function writeVersionIntent(intent, deps = {}) {
+    const mkdirSync = deps.mkdirSync ?? fs.mkdirSync;
+    const writeFileSync = deps.writeFileSync ?? fs.writeFileSync;
+    const renameSync = deps.renameSync ?? fs.renameSync;
+    const unlinkSync = deps.unlinkSync ?? fs.unlinkSync;
+    const randomUUID = deps.randomUUID ?? (() => `${process.pid}-${Date.now()}`);
+    const destination = versionIntentPath(deps.homeDir);
+    const temporary = `${destination}.${randomUUID()}.tmp`;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.version_intent_write_start",
+        message: "writing CLI version intent",
+        meta: { mode: intent.mode, targetVersion: intent.targetVersion },
+    });
+    try {
+        mkdirSync(path.dirname(destination), { recursive: true });
+        writeFileSync(temporary, `${JSON.stringify(intent, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+        renameSync(temporary, destination);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.version_intent_write_end",
+            message: "CLI version intent written",
+            meta: { mode: intent.mode, targetVersion: intent.targetVersion },
+        });
+    }
+    catch (error) {
+        try {
+            unlinkSync(temporary);
+        }
+        catch { /* best-effort temporary cleanup */ }
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.version_intent_write_error",
+            level: "error",
+            message: "failed to write CLI version intent",
+            meta: { mode: intent.mode, targetVersion: intent.targetVersion, error: error instanceof Error ? error.message : String(error) },
+        });
+        throw error;
+    }
+}

package/dist/senses/bluebubbles/index.js

@@ -63,6 +63,7 @@ const node_crypto_1 = require("node:crypto");
 const core_1 = require("../../heart/core");
 const config_1 = require("../../heart/config");
 const identity_1 = require("../../heart/identity");
+const machine_identity_1 = require("../../heart/machine-identity");
 const runtime_cwd_1 = require("../../heart/runtime-cwd");
 const turn_coordinator_1 = require("../../heart/turn-coordinator");
 const context_1 = require("../../mind/context");
@@ -76,6 +77,7 @@ const proactive_content_guard_1 = require("../proactive-content-guard");
 const bluebubbles_meta_guard_1 = require("../bluebubbles-meta-guard");
 const model_1 = require("./model");
 const client_1 = require("./client");
+const webhook_registration_1 = require("./webhook-registration");
 const inbound_log_1 = require("./inbound-log");
 const mutation_log_1 = require("./mutation-log");
 const processed_log_1 = require("./processed-log");
@@ -3718,6 +3720,7 @@ function startBlueBubblesApp(deps = {}) {
     let recoveryPassRunning = false;
     let runtimeSyncRunning = false;
     let recoveryDelayTimer = null;
+    let webhookReconciler = null;
     let closed = false;
     function triggerRecoveryPass() {
         /* v8 ignore next -- close clears both recovery timers; guard covers an already-queued host callback @preserve */
@@ -3791,6 +3794,8 @@ function startBlueBubblesApp(deps = {}) {
     const recoveryTimer = setInterval(triggerRecoveryPass, BLUEBUBBLES_RECOVERY_PASS_INTERVAL_MS);
     server.on?.("close", () => {
         closed = true;
+        webhookReconciler?.close();
+        webhookReconciler = null;
         lifecycleController.abort(new Error("bluebubbles_runtime_shutdown"));
         clearInterval(runtimeTimer);
         clearInterval(recoveryTimer);
@@ -3800,6 +3805,17 @@ function startBlueBubblesApp(deps = {}) {
         }
     });
     server.listen(channelConfig.port, () => {
+        const blueBubblesConfig = (0, config_1.getBlueBubblesConfig)();
+        webhookReconciler = (0, webhook_registration_1.createBlueBubblesWebhookReconciler)({
+            serverUrl: blueBubblesConfig.serverUrl,
+            password: blueBubblesConfig.password,
+            callbackPort: channelConfig.port,
+            callbackPath: channelConfig.webhookPath,
+            agentName: resolvedDeps.getAgentName(),
+            machineId: (0, machine_identity_1.loadOrCreateMachineIdentity)().machineId,
+            requestTimeoutMs: channelConfig.requestTimeoutMs,
+            listenerReady: true,
+        });
         (0, runtime_1.emitNervesEvent)({
             component: "channels",
             event: "channel.app_started",

package/dist/senses/bluebubbles/webhook-registration.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLUEBUBBLES_WEBHOOK_RECONCILE_INTERVAL_MS = void 0;
+exports.blueBubblesWebhookOwnerToken = blueBubblesWebhookOwnerToken;
+exports.buildBlueBubblesWebhookCallbackUrl = buildBlueBubblesWebhookCallbackUrl;
+exports.sanitizeBlueBubblesWebhookText = sanitizeBlueBubblesWebhookText;
+exports.inspectBlueBubblesWebhookRegistration = inspectBlueBubblesWebhookRegistration;
+exports.reconcileBlueBubblesWebhookRegistration = reconcileBlueBubblesWebhookRegistration;
+exports.createBlueBubblesWebhookReconciler = createBlueBubblesWebhookReconciler;
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+exports.BLUEBUBBLES_WEBHOOK_RECONCILE_INTERVAL_MS = 180_000;
+function result(state, detail, counts = {}) {
+    return {
+        ok: state === "exact",
+        state,
+        changed: counts.changed ?? false,
+        ownedCount: counts.ownedCount ?? 0,
+        exactCount: counts.exactCount ?? 0,
+        detail,
+    };
+}
+function blueBubblesWebhookOwnerToken(agentName, machineId) {
+    return `v1_${(0, crypto_1.createHash)("sha256").update(`ouro-bluebubbles-webhook\0${agentName}\0${machineId}`).digest("hex").slice(0, 32)}`;
+}
+function buildBlueBubblesWebhookCallbackUrl(input) {
+    const callback = new URL(`http://127.0.0.1:${input.callbackPort}`);
+    callback.pathname = input.callbackPath.startsWith("/") ? input.callbackPath : `/${input.callbackPath}`;
+    callback.searchParams.set("password", input.password);
+    callback.searchParams.set("ouroWebhook", blueBubblesWebhookOwnerToken(input.agentName, input.machineId));
+    return callback.toString();
+}
+function apiUrl(input, id) {
+    const base = `${input.serverUrl.replace(/\/+$/, "")}/api/v1/webhook${id === undefined ? "" : `/${id}`}`;
+    const url = new URL(base);
+    url.searchParams.set("password", input.password);
+    return url.toString();
+}
+function sanitizeBlueBubblesWebhookText(text, input) {
+    const owner = blueBubblesWebhookOwnerToken(input.agentName, input.machineId);
+    return text
+        .replaceAll(input.password, "[redacted]")
+        .replaceAll(owner, "[redacted]")
+        .replace(/(https?:\/\/[^\s?]+)\?[^\s]*/g, "$1?[redacted]");
+}
+function isWebhook(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const row = value;
+    return Number.isInteger(row.id)
+        && typeof row.url === "string"
+        && Array.isArray(row.events)
+        && row.events.every((event) => typeof event === "string");
+}
+function ownedBy(urlText, owner) {
+    try {
+        return new URL(urlText).searchParams.get("ouroWebhook") === owner;
+    }
+    catch {
+        return false;
+    }
+}
+function exactUnmarked(urlText, desiredUrl) {
+    try {
+        const candidate = new URL(urlText);
+        const desired = new URL(desiredUrl);
+        if (candidate.searchParams.has("ouroWebhook"))
+            return false;
+        desired.searchParams.delete("ouroWebhook");
+        return candidate.toString() === desired.toString();
+    }
+    catch {
+        return false;
+    }
+}
+function exactHook(hook, desiredUrl) {
+    return hook.url === desiredUrl && hook.events.length === 1 && hook.events[0] === "*";
+}
+async function request(input, fetchImpl, method, id, body, signal) {
+    const timeoutSignal = AbortSignal.timeout(input.requestTimeoutMs);
+    return fetchImpl(apiUrl(input, id), {
+        method,
+        ...(body === undefined ? {} : {
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        }),
+        signal: signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal,
+    });
+}
+async function readHooks(input, fetchImpl, signal) {
+    try {
+        const response = await request(input, fetchImpl, "GET", undefined, undefined, signal);
+        if (response.status === 401 || response.status === 403) {
+            return result("auth-failed", `BlueBubbles rejected webhook credentials (HTTP ${response.status})`);
+        }
+        if (!response.ok)
+            return result("api-unreachable", `BlueBubbles webhook API returned HTTP ${response.status}`);
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            return result("malformed", "BlueBubbles webhook API returned invalid JSON");
+        }
+        const data = payload && typeof payload === "object" ? payload.data : undefined;
+        if (!Array.isArray(data) || !data.every(isWebhook)) {
+            return result("malformed", "BlueBubbles webhook API returned an invalid webhook list");
+        }
+        return { hooks: data };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return result("api-unreachable", sanitizeBlueBubblesWebhookText(detail, input));
+    }
+}
+function inspectHooks(hooks, input) {
+    const desired = buildBlueBubblesWebhookCallbackUrl(input);
+    const owner = blueBubblesWebhookOwnerToken(input.agentName, input.machineId);
+    const owned = hooks.filter((hook) => ownedBy(hook.url, owner));
+    const exact = owned.filter((hook) => exactHook(hook, desired));
+    if (owned.length === 1 && exact.length === 1) {
+        return result("exact", "one exact Ouro-owned BlueBubbles webhook is registered", {
+            ownedCount: 1,
+            exactCount: 1,
+        });
+    }
+    return result(owned.length === 0 ? "missing" : "drifted", owned.length === 0
+        ? "the Ouro-owned BlueBubbles webhook is missing"
+        : "the Ouro-owned BlueBubbles webhook registration is drifted", {
+        ownedCount: owned.length,
+        exactCount: exact.length,
+    });
+}
+async function inspectBlueBubblesWebhookRegistration(input, deps = {}) {
+    if (!input.listenerReady)
+        return result("listener-not-ready", "the local BlueBubbles listener is not ready");
+    const listed = await readHooks(input, deps.fetchImpl ?? fetch, deps.signal);
+    return "hooks" in listed ? inspectHooks(listed.hooks, input) : listed;
+}
+async function mutate(input, fetchImpl, method, id, signal) {
+    try {
+        const response = await request(input, fetchImpl, method, id, method === "POST" ? { url: buildBlueBubblesWebhookCallbackUrl(input), events: ["*"] } : undefined, signal);
+        if (!response.ok)
+            return { ok: false, detail: `HTTP ${response.status}` };
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, detail: sanitizeBlueBubblesWebhookText(error instanceof Error ? error.message : String(error), input) };
+    }
+}
+async function reconcileBlueBubblesWebhookRegistration(input, deps = {}) {
+    if (!input.listenerReady)
+        return result("listener-not-ready", "the local BlueBubbles listener is not ready");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const listed = await readHooks(input, fetchImpl, deps.signal);
+    if (!("hooks" in listed))
+        return listed;
+    const desired = buildBlueBubblesWebhookCallbackUrl(input);
+    const owner = blueBubblesWebhookOwnerToken(input.agentName, input.machineId);
+    const owned = listed.hooks.filter((hook) => ownedBy(hook.url, owner));
+    const exact = owned.filter((hook) => exactHook(hook, desired));
+    const keep = exact[0];
+    const stale = owned.filter((hook) => hook !== keep);
+    const adopt = keep ? [] : listed.hooks.filter((hook) => exactUnmarked(hook.url, desired)).slice(0, 1);
+    let changed = false;
+    if (!keep) {
+        const created = await mutate(input, fetchImpl, "POST", undefined, deps.signal);
+        if (!created.ok) {
+            return result(owned.length === 0 ? "missing" : "drifted", `could not create the desired webhook: ${created.detail}`, {
+                ownedCount: owned.length,
+                exactCount: exact.length,
+            });
+        }
+        changed = true;
+    }
+    for (const hook of [...stale, ...adopt]) {
+        const deleted = await mutate(input, fetchImpl, "DELETE", hook.id, deps.signal);
+        if (!deleted.ok) {
+            return result("drifted", `could not remove 1 stale owned registration: ${deleted.detail}`, {
+                ownedCount: owned.length,
+                exactCount: exact.length,
+                changed,
+            });
+        }
+        changed = true;
+    }
+    if (!changed)
+        return inspectHooks(listed.hooks, input);
+    const verified = await readHooks(input, fetchImpl, deps.signal);
+    if (!("hooks" in verified))
+        return { ...verified, changed };
+    return { ...inspectHooks(verified.hooks, input), changed };
+}
+function createBlueBubblesWebhookReconciler(input, deps = {}) {
+    const setIntervalImpl = deps.setIntervalImpl ?? ((callback, intervalMs) => setInterval(callback, intervalMs));
+    const clearIntervalImpl = deps.clearIntervalImpl ?? ((timer) => clearInterval(timer));
+    let closed = false;
+    let active = null;
+    const abortController = new AbortController();
+    const reconcileNow = () => {
+        if (closed)
+            return Promise.resolve(result("listener-not-ready", "the BlueBubbles webhook reconciler is closed"));
+        if (active)
+            return active;
+        active = reconcileBlueBubblesWebhookRegistration(input, { ...deps, signal: abortController.signal }).finally(() => { active = null; });
+        return active;
+    };
+    const timer = setIntervalImpl(() => { void reconcileNow(); }, exports.BLUEBUBBLES_WEBHOOK_RECONCILE_INTERVAL_MS);
+    void reconcileNow().then((outcome) => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_webhook_reconciled",
+            level: outcome.ok ? "info" : "warn",
+            message: "reconciled BlueBubbles webhook registration",
+            meta: { state: outcome.state, changed: outcome.changed },
+        });
+    });
+    return {
+        reconcileNow,
+        close: () => {
+            if (closed)
+                return;
+            closed = true;
+            clearIntervalImpl(timer);
+            abortController.abort(new Error("BlueBubbles webhook reconciliation closed"));
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ouro.bot/cli",
-  "version": "0.1.0-alpha.727",
+  "version": "0.1.0-alpha.728",
   "engines": {
     "node": ">=22"
   },
@@ -34,6 +34,7 @@
     "test": "vitest run",
     "test:integration": "npm run build && vitest run --config vitest.integration.config.ts",
     "test:e2e:package": "npm run build && node scripts/package-e2e.cjs",
+    "test:e2e:ouro-bot-package": "node scripts/ouro-bot-package-e2e.cjs",
     "test:e2e:real-smoke": "npm run build && node scripts/nightly-real-smoke.cjs",
     "typecheck:mailbox-ui": "tsc --noEmit -p packages/mailbox-ui/tsconfig.json",
     "test:mailbox-ui": "npm test --prefix packages/mailbox-ui",
@@ -67,7 +68,7 @@
     "better-sqlite3": "13.0.2",
     "fast-glob": "^3.3.3",
     "ink": "^3.2.0",
-    "mailparser": "^3.9.8",
+    "mailparser": "^3.9.15",
     "openai": "^6.27.0",
     "react": "^17.0.2",
     "semver": "^7.7.4",
@@ -93,6 +94,7 @@
     "vitest": "^4.1.8"
   },
   "overrides": {
+    "deepmerge-ts": "^8.0.1",
     "@microsoft/teams.apps": {
       "@azure/msal-node": "^5.2.2"
     },