@threadbase-sh/streamer 1.47.3 → 1.48.0

package/dist/index.d.cts

@@ -1954,6 +1954,7 @@ declare class StreamerServer {
     private apnsClient;
     private liveActivityNotifier;
     private liveActivityRenewal;
+    private waitingInputNotifier;
     private discoveryCache;
     private discoveryInFlight;
     private cacheDir;
@@ -2008,6 +2009,18 @@ declare class StreamerServer {
      * on disk; neither it nor any device token is ever logged.
      */
     private initLiveActivityPush;
+    /**
+     * Bring up "your turn" notifications over Expo's relay (#528).
+     *
+     * Unconditional, unlike Live Activity push: Expo holds the app's APNs and FCM
+     * credentials, so a self-hosted streamer needs no credential of its own. The
+     * access token is optional and only relevant if the Expo project has enhanced
+     * security enabled — requiring one would lock out every self-hoster, since
+     * they do not own the project. It is never logged.
+     */
+    private initWaitingInputPush;
+    /** Whether any live socket is subscribed to this session — "someone is looking". */
+    private hasSessionSubscriber;
     /**
      * Classify sessions left behind by previous streamer runs (C1 Phase 3a).
      *

package/dist/index.d.ts

@@ -1954,6 +1954,7 @@ declare class StreamerServer {
     private apnsClient;
     private liveActivityNotifier;
     private liveActivityRenewal;
+    private waitingInputNotifier;
     private discoveryCache;
     private discoveryInFlight;
     private cacheDir;
@@ -2008,6 +2009,18 @@ declare class StreamerServer {
      * on disk; neither it nor any device token is ever logged.
      */
     private initLiveActivityPush;
+    /**
+     * Bring up "your turn" notifications over Expo's relay (#528).
+     *
+     * Unconditional, unlike Live Activity push: Expo holds the app's APNs and FCM
+     * credentials, so a self-hosted streamer needs no credential of its own. The
+     * access token is optional and only relevant if the Expo project has enhanced
+     * security enabled — requiring one would lock out every self-hoster, since
+     * they do not own the project. It is never logged.
+     */
+    private initWaitingInputPush;
+    /** Whether any live socket is subscribed to this session — "someone is looking". */
+    private hasSessionSubscriber;
     /**
      * Classify sessions left behind by previous streamer runs (C1 Phase 3a).
      *

package/dist/index.js

@@ -8415,10 +8415,10 @@ function fingerprintOf(ids) {
   return `sha256:${createHash3("sha256").update(sorted.join("\n")).digest("hex")}`;
 }
 var CacheIntegrityMonitor = class {
-  constructor(cache, wsHub, log8, cacheDir, rescan, runDuringReset) {
+  constructor(cache, wsHub, log10, cacheDir, rescan, runDuringReset) {
     this.cache = cache;
     this.wsHub = wsHub;
-    this.log = log8;
+    this.log = log10;
     this.cacheDir = cacheDir;
     this.rescan = rescan;
     this.runDuringReset = runDuringReset;
@@ -9217,6 +9217,101 @@ var ApnsClient = class {
   }
 };
 
+// src/services/push/expoPushSender.ts
+var log5 = getLogger("expo-push");
+var EXPO_PUSH_ENDPOINT = "https://exp.host/--/api/v2/push/send";
+var EXPO_PUSH_BATCH_SIZE = 100;
+var DEAD_TOKEN_ERROR = "DeviceNotRegistered";
+var ExpoPushSender = class {
+  /**
+   * @param accessToken Expo access token, when the project has enhanced
+   * security enabled. Optional on purpose: a self-hoster does not own the Expo
+   * project and cannot obtain one, so requiring it would break the deployment
+   * this transport exists to serve.
+   */
+  constructor(repo, accessToken) {
+    this.repo = repo;
+    this.accessToken = accessToken;
+  }
+  repo;
+  accessToken;
+  /**
+   * Send one message to every deliverable Expo token.
+   *
+   * Sends are independent: Expo returns a ticket per token in one response, so
+   * a dead device is recorded against its own row and never silences the other
+   * devices in the batch.
+   */
+  async send(message, now = Date.now()) {
+    const rows = this.repo.listDeliverable();
+    const outcome = { attempted: rows.length, succeeded: 0, retired: 0 };
+    if (rows.length === 0) return outcome;
+    for (let i = 0; i < rows.length; i += EXPO_PUSH_BATCH_SIZE) {
+      const chunk = rows.slice(i, i + EXPO_PUSH_BATCH_SIZE);
+      await this.sendChunk(chunk, message, now, outcome);
+    }
+    return outcome;
+  }
+  async sendChunk(rows, message, now, outcome) {
+    let payload;
+    try {
+      const res = await fetch(EXPO_PUSH_ENDPOINT, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/json",
+          ...this.accessToken && { authorization: `Bearer ${this.accessToken}` }
+        },
+        body: JSON.stringify(rows.map((row) => ({ to: row.token, ...message })))
+      });
+      if (!res.ok) {
+        const code = `HTTP_${res.status}`;
+        for (const row of rows) this.repo.recordFailure(row.token, code, now);
+        log5.warn("expo_push.request_rejected", {
+          event: "expo_push.request_rejected",
+          status: res.status,
+          tokens: rows.length
+        });
+        return;
+      }
+      payload = await res.json();
+    } catch (err) {
+      for (const row of rows) this.repo.recordFailure(row.token, "SendError", now);
+      log5.error("expo_push.send_failed", {
+        event: "expo_push.send_failed",
+        tokens: rows.length,
+        err: String(err)
+      });
+      return;
+    }
+    const tickets = payload?.data;
+    rows.forEach((row, index) => {
+      const ticket = Array.isArray(tickets) ? tickets[index] : void 0;
+      if (!ticket) {
+        this.repo.recordFailure(row.token, "NoTicket", now);
+        return;
+      }
+      if (ticket.status === "ok") {
+        this.repo.recordSuccess(row.token, now);
+        outcome.succeeded += 1;
+        return;
+      }
+      const code = ticket.details?.error ?? "PushError";
+      this.repo.recordFailure(row.token, code, now);
+      if (code === DEAD_TOKEN_ERROR) {
+        this.repo.revoke(row.token, now);
+        outcome.retired += 1;
+      }
+      log5.warn("expo_push.send_rejected", {
+        event: "expo_push.send_rejected",
+        code,
+        message: ticket.message,
+        retired: code === DEAD_TOKEN_ERROR
+      });
+    });
+  }
+};
+
 // src/services/push/liveActivityContentState.ts
 var LAST_OUTPUT_MAX_LENGTH = 90;
 function toLiveActivityStatus(status) {
@@ -9228,7 +9323,7 @@ function truncateLastOutput(raw) {
 }
 
 // src/services/push/liveActivityNotifier.ts
-var log5 = getLogger("live-activity");
+var log6 = getLogger("live-activity");
 function contentStateForSession(args) {
   const status = toLiveActivityStatus(args.session.status);
   if (!status) return null;
@@ -9288,7 +9383,7 @@ var LiveActivityNotifier = class {
       }
       await this.maybeSendName(session);
     } catch (err) {
-      log5.error("live_activity.notify_failed", {
+      log6.error("live_activity.notify_failed", {
         event: "live_activity.notify_failed",
         sessionId: session.id,
         status: session.status,
@@ -9310,7 +9405,7 @@ var LiveActivityNotifier = class {
     });
     this.openActivity.set(session.id, { sessionNameSent: session.sessionName != null });
     if (outcome.attempted > 0) {
-      log5.info("live_activity.updated", {
+      log6.info("live_activity.updated", {
         event: "live_activity.updated",
         sessionId: session.id,
         status: contentState.status,
@@ -9334,7 +9429,7 @@ var LiveActivityNotifier = class {
     });
     open2.sessionNameSent = true;
     if (outcome.attempted > 0) {
-      log5.info("live_activity.updated", {
+      log6.info("live_activity.updated", {
         event: "live_activity.updated",
         sessionId: session.id,
         status: contentState.status,
@@ -9353,7 +9448,7 @@ var LiveActivityNotifier = class {
     if (!contentState) return;
     const outcome = await this.sender.end({ sessionId: session.id, contentState });
     if (outcome.attempted > 0) {
-      log5.info("live_activity.ended", {
+      log6.info("live_activity.ended", {
         event: "live_activity.ended",
         sessionId: session.id,
         ...outcome
@@ -9367,7 +9462,7 @@ var LiveActivityNotifier = class {
 };
 
 // src/services/push/liveActivitySender.ts
-var log6 = getLogger("live-activity");
+var log7 = getLogger("live-activity");
 var ACTIVITY_MAX_LIFETIME_MS = 8 * 60 * 60 * 1e3;
 function buildActivityKitPayload(args) {
   return {
@@ -9431,7 +9526,7 @@ var LiveActivitySender = class {
     );
     for (const { row, result, error } of results) {
       if (error) {
-        log6.error("live_activity.send_failed", {
+        log7.error("live_activity.send_failed", {
           event: "live_activity.send_failed",
           sessionId: args.sessionId,
           activityId: row.activity_id,
@@ -9452,7 +9547,7 @@ var LiveActivitySender = class {
         this.repo.expire(row.token, now);
         outcome.retired += 1;
       }
-      log6.warn("live_activity.send_rejected", {
+      log7.warn("live_activity.send_rejected", {
         event: "live_activity.send_rejected",
         sessionId: args.sessionId,
         activityId: row.activity_id,
@@ -9497,7 +9592,7 @@ var LiveActivitySender = class {
 };
 
 // src/services/push/liveActivityRenewal.ts
-var log7 = getLogger("live-activity");
+var log8 = getLogger("live-activity");
 var RENEWAL_LEAD_MS = 30 * 60 * 1e3;
 var MAX_TIMER_MS = 60 * 60 * 1e3;
 function renewalDueAt(row) {
@@ -9545,7 +9640,7 @@ var LiveActivityRenewalScheduler = class {
         await this.renew(row, now);
       }
     } catch (err) {
-      log7.error("live_activity.renewal_sweep_failed", {
+      log8.error("live_activity.renewal_sweep_failed", {
         event: "live_activity.renewal_sweep_failed",
         err: String(err)
       });
@@ -9574,7 +9669,7 @@ var LiveActivityRenewalScheduler = class {
     if (!session || !status) {
       this.deps.repo.claimRenewal(row.token, now);
       this.deps.repo.expire(row.token, now);
-      log7.info("live_activity.renewal_skipped", {
+      log8.info("live_activity.renewal_skipped", {
         event: "live_activity.renewal_skipped",
         sessionId: row.session_id,
         activityId: row.activity_id,
@@ -9609,7 +9704,7 @@ var LiveActivityRenewalScheduler = class {
         startedAt,
         now
       });
-      log7.info("live_activity.renewed", {
+      log8.info("live_activity.renewed", {
         event: "live_activity.renewed",
         sessionId: session.id,
         activityId: row.activity_id,
@@ -9619,7 +9714,7 @@ var LiveActivityRenewalScheduler = class {
         replacementRequested: started
       });
     } catch (err) {
-      log7.error("live_activity.renewal_failed", {
+      log8.error("live_activity.renewal_failed", {
         event: "live_activity.renewal_failed",
         sessionId: session.id,
         activityId: row.activity_id,
@@ -9664,6 +9759,77 @@ var LiveActivityRenewalScheduler = class {
   }
 };
 
+// src/services/push/waitingInputNotifier.ts
+var log9 = getLogger("expo-push");
+function waitingInputMessage(session, serverId) {
+  return {
+    title: session.projectName || "Threadbase",
+    body: "Waiting for your input",
+    data: { sessionId: session.id, serverId }
+  };
+}
+var WaitingInputNotifier = class {
+  /**
+   * @param isWatched Whether a client is currently subscribed to this session
+   * over WebSocket. Mobile subscribes while the session screen is open and the
+   * socket dies when the app is backgrounded, so this is the available signal
+   * for "the user is already looking" — and a push to someone already reading
+   * the output is pure noise.
+   */
+  constructor(sender, serverId, isWatched) {
+    this.sender = sender;
+    this.serverId = serverId;
+    this.isWatched = isWatched;
+  }
+  sender;
+  serverId;
+  isWatched;
+  /** Sessions with a turn the user started that has not yet been answered. */
+  openTurn = /* @__PURE__ */ new Set();
+  /**
+   * React to a session status change.
+   *
+   * Fire-and-forget by design: a push must never delay or fail a session
+   * transition, so this returns a promise the caller may ignore and every error
+   * is logged rather than propagated.
+   */
+  async onStatusChange(session, previousStatus) {
+    try {
+      if (session.status === "running") {
+        if (previousStatus === "waiting_input") this.openTurn.add(session.id);
+        return;
+      }
+      if (session.status !== "waiting_input") {
+        this.openTurn.delete(session.id);
+        return;
+      }
+      if (!this.openTurn.delete(session.id)) return;
+      if (this.isWatched(session.id)) {
+        log9.debug("expo_push.suppressed_watched", {
+          event: "expo_push.suppressed_watched",
+          sessionId: session.id
+        });
+        return;
+      }
+      const outcome = await this.sender.send(waitingInputMessage(session, this.serverId));
+      if (outcome.attempted > 0) {
+        log9.info("expo_push.waiting_input", {
+          event: "expo_push.waiting_input",
+          sessionId: session.id,
+          ...outcome
+        });
+      }
+    } catch (err) {
+      log9.error("expo_push.notify_failed", {
+        event: "expo_push.notify_failed",
+        sessionId: session.id,
+        status: session.status,
+        err: String(err)
+      });
+    }
+  }
+};
+
 // src/services/questions/parseStatusLine.ts
 var MODEL_RE = /(Opus|Sonnet|Haiku|Fable)\s+[\d.]+(?:\s*\([^)]*\))?/;
 var EFFORT_RE = /●\s*([A-Za-z]+)\s*·\s*\/effort/;
@@ -10974,6 +11140,10 @@ var StreamerServer = class {
   apnsClient = null;
   liveActivityNotifier = null;
   liveActivityRenewal = null;
+  // "Your turn" notifications over Expo's relay (#528). Needs no credential of
+  // its own, so unlike the Live Activity path it is on wherever the cache DB
+  // opened — with no registered device it simply sends nothing.
+  waitingInputNotifier = null;
   discoveryCache = null;
   // Single-flight for process discovery. Mobile polls GET /api/sessions and
   // retries on timeout; without this, every concurrent request starts its own
@@ -11273,6 +11443,7 @@ var StreamerServer = class {
           this.wsHub.broadcast({ type: "session_update", session: resp });
         }
         void this.liveActivityNotifier?.onStatusChange(session, previousStatus);
+        void this.waitingInputNotifier?.onStatusChange(session, previousStatus);
         this.sessionStatusBus.emit(`status:${session.id}`, session.status, session);
       }
     });
@@ -11585,6 +11756,33 @@ var StreamerServer = class {
       topic: `${creds.bundleId}.push-type.liveactivity`
     });
   }
+  /**
+   * Bring up "your turn" notifications over Expo's relay (#528).
+   *
+   * Unconditional, unlike Live Activity push: Expo holds the app's APNs and FCM
+   * credentials, so a self-hosted streamer needs no credential of its own. The
+   * access token is optional and only relevant if the Expo project has enhanced
+   * security enabled — requiring one would lock out every self-hoster, since
+   * they do not own the project. It is never logged.
+   */
+  initWaitingInputPush(pushRepo) {
+    const sender = new ExpoPushSender(pushRepo, process.env.THREADBASE_EXPO_ACCESS_TOKEN);
+    const serverId = process.env.THREADBASE_INSTANCE_ID ?? hostname3();
+    this.waitingInputNotifier = new WaitingInputNotifier(
+      sender,
+      serverId,
+      (id) => this.hasSessionSubscriber(id)
+    );
+  }
+  /** Whether any live socket is subscribed to this session — "someone is looking". */
+  hasSessionSubscriber(sessionId) {
+    const subs = this.sessionSubscribers.get(sessionId);
+    if (!subs) return false;
+    for (const ws of subs) {
+      if (ws.readyState === ws.OPEN) return true;
+    }
+    return false;
+  }
   /**
    * Classify sessions left behind by previous streamer runs (C1 Phase 3a).
    *
@@ -12187,6 +12385,7 @@ var StreamerServer = class {
           this.pushRepo = new PushRepository(db);
           this.devicesRepo = new DevicesRepository(db);
           this.initLiveActivityPush(this.pushRepo);
+          this.initWaitingInputPush(this.pushRepo);
           this.cacheMonitor = new CacheIntegrityMonitor(
             this.cache,
             this.wsHub,