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

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.726",
+  "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"
     },