@btatum5/codex-bridge 0.1.0 → 1.3.3

package/src/push-notification-completion-dedupe.js

@@ -0,0 +1,147 @@
+// FILE: push-notification-completion-dedupe.js
+// Purpose: Owns duplicate-suppression state for completion pushes emitted by the bridge.
+// Layer: Bridge helper
+// Exports: createPushNotificationCompletionDedupe
+// Depends on: none
+
+const DEFAULT_SENT_DEDUPE_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_STATUS_FALLBACK_TTL_MS = 5_000;
+
+function createPushNotificationCompletionDedupe({
+  now = () => Date.now(),
+  sentDedupeTTLms = DEFAULT_SENT_DEDUPE_TTL_MS,
+  statusFallbackTTLms = DEFAULT_STATUS_FALLBACK_TTL_MS,
+} = {}) {
+  const sentDedupeKeys = new Map();
+  const pendingDedupeKeys = new Set();
+  const recentTurnScopedCompletionsByThread = new Map();
+
+  function clearForNewRun(threadId) {
+    if (!readString(threadId)) {
+      return;
+    }
+
+    recentTurnScopedCompletionsByThread.delete(threadId);
+  }
+
+  // Thread-level terminal events are only a fallback when we have not already sent a turn-scoped completion.
+  function shouldSuppressThreadStatusFallback({ threadId, turnId, result } = {}) {
+    if (readString(turnId)) {
+      return false;
+    }
+
+    pruneRecentTurnScopedCompletions();
+    const previous = recentTurnScopedCompletionsByThread.get(readString(threadId));
+    return previous?.result === result;
+  }
+
+  function hasActiveDedupeKey(dedupeKey) {
+    const normalizedKey = readString(dedupeKey);
+    if (!normalizedKey) {
+      return false;
+    }
+
+    pruneSentDedupeKeys();
+    return sentDedupeKeys.has(normalizedKey) || pendingDedupeKeys.has(normalizedKey);
+  }
+
+  function beginNotification({ dedupeKey, threadId, turnId, result } = {}) {
+    const normalizedKey = readString(dedupeKey);
+    if (!normalizedKey) {
+      return;
+    }
+
+    pendingDedupeKeys.add(normalizedKey);
+    if (readString(turnId)) {
+      rememberTurnScopedCompletion(threadId, result);
+    }
+  }
+
+  function commitNotification({ dedupeKey, threadId, turnId, result } = {}) {
+    const normalizedKey = readString(dedupeKey);
+    if (normalizedKey) {
+      sentDedupeKeys.set(normalizedKey, now());
+      pendingDedupeKeys.delete(normalizedKey);
+    }
+
+    if (readString(turnId)) {
+      rememberTurnScopedCompletion(threadId, result);
+    }
+  }
+
+  function abortNotification({ dedupeKey, threadId, turnId, result } = {}) {
+    const normalizedKey = readString(dedupeKey);
+    if (normalizedKey) {
+      pendingDedupeKeys.delete(normalizedKey);
+    }
+
+    const normalizedThreadId = readString(threadId);
+    if (!readString(turnId) || !normalizedThreadId) {
+      return;
+    }
+
+    const previous = recentTurnScopedCompletionsByThread.get(normalizedThreadId);
+    if (previous?.result === result) {
+      recentTurnScopedCompletionsByThread.delete(normalizedThreadId);
+    }
+  }
+
+  // Exposed for focused tests so we can prove dedupe state stays bounded.
+  function debugState() {
+    pruneSentDedupeKeys();
+    pruneRecentTurnScopedCompletions();
+    return {
+      sentDedupeKeys: sentDedupeKeys.size,
+      pendingDedupeKeys: pendingDedupeKeys.size,
+      recentThreadFallbacks: recentTurnScopedCompletionsByThread.size,
+    };
+  }
+
+  function rememberTurnScopedCompletion(threadId, result) {
+    const normalizedThreadId = readString(threadId);
+    if (!normalizedThreadId) {
+      return;
+    }
+
+    recentTurnScopedCompletionsByThread.set(normalizedThreadId, {
+      result,
+      timestamp: now(),
+    });
+  }
+
+  function pruneSentDedupeKeys() {
+    const cutoff = now() - sentDedupeTTLms;
+    for (const [dedupeKey, timestamp] of sentDedupeKeys.entries()) {
+      if (timestamp < cutoff) {
+        sentDedupeKeys.delete(dedupeKey);
+      }
+    }
+  }
+
+  function pruneRecentTurnScopedCompletions() {
+    const cutoff = now() - statusFallbackTTLms;
+    for (const [threadId, entry] of recentTurnScopedCompletionsByThread.entries()) {
+      if (entry.timestamp < cutoff) {
+        recentTurnScopedCompletionsByThread.delete(threadId);
+      }
+    }
+  }
+
+  return {
+    abortNotification,
+    beginNotification,
+    clearForNewRun,
+    commitNotification,
+    debugState,
+    hasActiveDedupeKey,
+    shouldSuppressThreadStatusFallback,
+  };
+}
+
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+module.exports = {
+  createPushNotificationCompletionDedupe,
+};

package/src/push-notification-service-client.js

@@ -0,0 +1,151 @@
+// FILE: push-notification-service-client.js
+// Purpose: Sends push registration and completion requests from the local Mac bridge to the configured notification service.
+// Layer: Bridge helper
+// Exports: createPushNotificationServiceClient
+// Depends on: global fetch
+
+const DEFAULT_PUSH_SERVICE_TIMEOUT_MS = 10_000;
+
+function createPushNotificationServiceClient({
+  baseUrl = "",
+  sessionId,
+  notificationSecret,
+  fetchImpl = globalThis.fetch,
+  logPrefix = "[codex-bridge]",
+  requestTimeoutMs = DEFAULT_PUSH_SERVICE_TIMEOUT_MS,
+} = {}) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+
+  async function registerDevice({
+    deviceToken,
+    alertsEnabled,
+    apnsEnvironment,
+  } = {}) {
+    return postJSON("/v1/push/session/register-device", {
+      sessionId,
+      notificationSecret,
+      deviceToken,
+      alertsEnabled,
+      apnsEnvironment,
+    });
+  }
+
+  async function notifyCompletion({
+    threadId,
+    turnId,
+    result,
+    title,
+    body,
+    dedupeKey,
+  } = {}) {
+    return postJSON("/v1/push/session/notify-completion", {
+      sessionId,
+      notificationSecret,
+      threadId,
+      turnId,
+      result,
+      title,
+      body,
+      dedupeKey,
+    });
+  }
+
+  async function postJSON(pathname, payload) {
+    if (!normalizedBaseUrl || typeof fetchImpl !== "function") {
+      return { ok: false, skipped: true };
+    }
+
+    const controller = typeof AbortController === "function" && requestTimeoutMs > 0
+      ? new AbortController()
+      : null;
+    const timeoutID = controller
+      ? setTimeout(() => {
+        controller.abort(createTimeoutAbortError(requestTimeoutMs));
+      }, requestTimeoutMs)
+      : null;
+
+    let response;
+    try {
+      response = await fetchImpl(`${normalizedBaseUrl}${pathname}`, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+        },
+        body: JSON.stringify(payload),
+        signal: controller?.signal,
+      });
+    } catch (error) {
+      if (isAbortError(error)) {
+        const timeoutError = new Error(`Push service request timed out after ${requestTimeoutMs}ms`);
+        timeoutError.code = "push_request_timeout";
+        throw timeoutError;
+      }
+      throw error;
+    } finally {
+      if (timeoutID) {
+        clearTimeout(timeoutID);
+      }
+    }
+
+    const responseText = await response.text();
+    const parsed = safeParseJSON(responseText);
+    if (!response.ok) {
+      const message = parsed?.error || parsed?.message || responseText || `HTTP ${response.status}`;
+      const error = new Error(message);
+      error.status = response.status;
+      throw error;
+    }
+
+    return parsed ?? { ok: true };
+  }
+
+  return {
+    hasConfiguredBaseUrl: Boolean(normalizedBaseUrl),
+    registerDevice,
+    notifyCompletion,
+    logUnavailable() {
+      if (!normalizedBaseUrl) {
+        console.log(`${logPrefix} push notifications disabled: no push service URL configured`);
+      }
+    },
+  };
+}
+
+function normalizeBaseUrl(value) {
+  if (typeof value !== "string") {
+    return "";
+  }
+
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return "";
+  }
+
+  return trimmed.replace(/\/+$/, "");
+}
+
+function createTimeoutAbortError(timeoutMs) {
+  const error = new Error(`Push service request timed out after ${timeoutMs}ms`);
+  error.name = "AbortError";
+  return error;
+}
+
+function isAbortError(error) {
+  return error?.name === "AbortError" || error?.code === "ABORT_ERR";
+}
+
+function safeParseJSON(value) {
+  if (!value || typeof value !== "string") {
+    return null;
+  }
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+
+module.exports = {
+  createPushNotificationServiceClient,
+};