very-happy-cli 0.2.177 → 0.2.179

package/dist/{attachmentLimits-Di1Z93lN.mjs → pushNotifications-BdFjDjQe.mjs}

@@ -1,5 +1,9 @@
 import { z } from 'zod';
-import { m as AgentVersionsSchema } from './index-DMy3OCBe.mjs';
+import { p as AgentVersionsSchema } from './index-DPOa4NhL.mjs';
+import axios from 'axios';
+import { l as logger } from './logger-BtVhHnD8.mjs';
+import { c as configuration } from './configuration-WMi4idBB.mjs';
+import { c as contentLogMetadata } from './contentLogMetadata-BlWI0egu.mjs';
 
 z.object({
   teamsVersion: z.number().int().positive().optional(),
@@ -254,7 +258,21 @@ z.object({
     idleMs: z.number(),
     rpcAvailable: z.boolean(),
     detectedAt: z.number()
-  }).passthrough().optional()
+  }).passthrough().optional(),
+  /**
+   * B-510: web panels declared in this machine's local settings.json
+   * (`webPanels`), normalized by webPanels/webPanels.ts. Read-only mirror —
+   * nothing on the web/server side can write the local declaration.
+   */
+  webPanels: z.object({
+    panels: z.array(z.object({
+      id: z.string(),
+      title: z.string(),
+      url: z.string(),
+      embed: z.boolean()
+    })),
+    updatedAt: z.number()
+  }).optional()
 });
 const MessageMetaSchema = z.object({
   sentFrom: z.string().optional(),
@@ -383,4 +401,286 @@ const MAX_CHAT_ATTACHMENT_SOURCE_BYTES = 50 * 1024 * 1024;
 const CHAT_ATTACHMENT_ENCRYPTION_OVERHEAD_BYTES = 40;
 const MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES = MAX_CHAT_ATTACHMENT_SOURCE_BYTES + CHAT_ATTACHMENT_ENCRYPTION_OVERHEAD_BYTES;
 
-export { AsyncLock as A, FileEventMessageSchema as F, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, UserMessageSchema as U, MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES as a };
+function getSessionTitle(metadata) {
+  const summaryText = metadata?.summary?.text?.trim();
+  if (summaryText) {
+    return summaryText;
+  }
+  const path = metadata?.path?.trim();
+  if (!path) {
+    return "Session";
+  }
+  const segments = path.split(/[\\/]/).filter(Boolean);
+  return segments[segments.length - 1] || "Session";
+}
+function getSessionNotificationUrl(data) {
+  const sessionId = data?.sessionId;
+  if (typeof sessionId !== "string") {
+    return null;
+  }
+  const trimmedSessionId = sessionId.trim();
+  if (!trimmedSessionId) {
+    return null;
+  }
+  return `/session/${encodeURIComponent(trimmedSessionId)}`;
+}
+function getSessionNotificationTitle(kind) {
+  switch (kind) {
+    case "done":
+      return "It's ready!";
+    case "permission":
+      return "Permission request";
+    case "question":
+      return "Clarification needed";
+    case "attention":
+      return "Needs you";
+  }
+}
+function getSessionNotificationBody(metadata) {
+  return getSessionTitle(metadata);
+}
+function getSessionNotificationCopy(kind, metadata) {
+  return {
+    title: getSessionNotificationTitle(kind),
+    body: getSessionNotificationBody(metadata)
+  };
+}
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expoLoad = null;
+  constructor(token, baseUrl = "https://api.cluster-fluster.com") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+  }
+  loadExpo() {
+    if (!this.expoLoad) {
+      const load = import('expo-server-sdk').then(({ Expo }) => ({ Expo, expo: new Expo() }));
+      load.catch(() => {
+        if (this.expoLoad === load) this.expoLoad = null;
+      });
+      this.expoLoad = load;
+    }
+    return this.expoLoad;
+  }
+  /**
+   * Fetch all push tokens for the authenticated user.
+   * Retries up to 3 times with exponential backoff on transient errors.
+   */
+  async fetchPushTokens() {
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await axios.get(
+          `${this.baseUrl}/v1/push-tokens`,
+          {
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+            }
+          }
+        );
+        logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+        response.data.tokens.forEach((token, index) => {
+          logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
+        });
+        return response.data.tokens;
+      } catch (error) {
+        logger.debug(`[PUSH] [ERROR] Failed to fetch push tokens (attempt ${attempt}/${maxAttempts}):`, error);
+        if (attempt < maxAttempts) {
+          const delay = 1e3 * Math.pow(2, attempt - 1);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    logger.debug("[PUSH] [ERROR] All push token fetch attempts failed");
+    return [];
+  }
+  /**
+   * Send push notification via Expo Push API with retry
+   * @param messages - Array of push messages to send
+   */
+  async sendPushNotifications(messages) {
+    logger.debug(`Sending ${messages.length} push notifications`);
+    const { Expo, expo } = await this.loadExpo();
+    const validMessages = messages.filter((message) => {
+      if (Array.isArray(message.to)) {
+        return message.to.every((token) => Expo.isExpoPushToken(token));
+      }
+      return Expo.isExpoPushToken(message.to);
+    });
+    if (validMessages.length === 0) {
+      logger.debug("No valid Expo push tokens found");
+      return;
+    }
+    const chunks = expo.chunkPushNotifications(validMessages);
+    for (const chunk of chunks) {
+      const startTime = Date.now();
+      const timeout = 3e5;
+      let attempt = 0;
+      while (true) {
+        try {
+          const ticketChunk = await expo.sendPushNotificationsAsync(chunk);
+          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
+          if (errors.length > 0) {
+            const errorDetails = errors.map((e) => ({ message: e.message, details: e.details }));
+            logger.debug("[PUSH] Some notifications failed:", errorDetails);
+          }
+          if (errors.length === ticketChunk.length) {
+            throw new Error("All push notifications in chunk failed");
+          }
+          break;
+        } catch (error) {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            break;
+          }
+          attempt++;
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          const remainingTime = timeout - elapsed;
+          const waitTime = Math.min(delay, remainingTime);
+          if (waitTime > 0) {
+            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+    }
+    logger.debug(`Push notifications sent successfully`);
+  }
+  /**
+   * Send a push notification to all registered devices for the user
+   * @param title - Notification title
+   * @param body - Notification body
+   * @param data - Additional data to send with the notification
+   */
+  sendToAllDevices(title, body, data) {
+    logger.debug("[PUSH] sendToAllDevices called:", {
+      title: contentLogMetadata(title),
+      body: contentLogMetadata(body),
+      dataKeyCount: data ? Object.keys(data).length : 0
+    });
+    (async () => {
+      try {
+        logger.debug("[PUSH] Fetching push tokens...");
+        const tokens = await this.fetchPushTokens();
+        logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
+        tokens.forEach((token, index) => {
+          logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
+        });
+        if (tokens.length === 0) {
+          logger.debug("No push tokens found for user");
+          return;
+        }
+        const messages = tokens.map((token, index) => {
+          logger.debug(`[PUSH] Creating message ${index + 1} for token`);
+          return {
+            to: token.token,
+            title,
+            body: body && body.length > 0 ? body : void 0,
+            data,
+            // TODO: For brutalist session artwork, attach rich media via a public HTTPS image URL.
+            // Bundled app asset paths / require(...) / local file paths will not work in push payloads.
+            // iOS also needs a Notification Service Extension to render richContent.image reliably.
+            sound: "default",
+            priority: "high"
+          };
+        });
+        logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        await this.sendPushNotifications(messages);
+        logger.debug("[PUSH] Push notifications sent successfully");
+      } catch (error) {
+        logger.debug("[PUSH] Error sending to all devices:", error);
+      }
+    })();
+  }
+  /**
+   * Routes session-event pushes through the server so it can apply
+   * presence-based suppression (active desktop/web, mobile foreground).
+   * Falls back to direct Expo send only when sessionId is missing — that
+   * shouldn't happen for session notifications but guards against regressions.
+   */
+  sendSessionNotification(params) {
+    const { title, body } = getSessionNotificationCopy(params.kind, params.metadata);
+    const sessionTitle = getSessionNotificationBody(params.metadata);
+    const url = getSessionNotificationUrl(params.data);
+    const payloadData = {
+      ...params.data,
+      kind: params.kind,
+      sessionTitle,
+      ...url ? { url } : {}
+    };
+    const sessionId = typeof params.data?.sessionId === "string" ? params.data.sessionId : null;
+    if (!sessionId) {
+      logger.debug("[PUSH] sendSessionNotification: missing sessionId, falling back to direct send");
+      this.sendToAllDevices(title, body, payloadData);
+      return;
+    }
+    void (async () => {
+      try {
+        await axios.post(
+          `${this.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/push-event`,
+          {
+            kind: params.kind,
+            title,
+            body,
+            data: payloadData
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+            },
+            timeout: 15e3
+          }
+        );
+        logger.debug(`[PUSH] sendSessionNotification dispatched via server (kind=${params.kind})`);
+      } catch (error) {
+        logger.debug("[PUSH] sendSessionNotification failed:", error);
+      }
+    })();
+  }
+  /**
+   * B-510 `request_human` / `very-happy attention --session`: an awaited
+   * push-event `attention` (title "Needs you", body = the reason, data.url =
+   * panel deep link or the session). A server that predates the kind answers
+   * 400; then the same push goes out as `question`, so the person is still
+   * reached (compat matrix in specs/2026-09-machine-web-panels.md).
+   */
+  async sendAttention(params) {
+    const post = (kind) => axios.post(
+      `${this.baseUrl}/v1/sessions/${encodeURIComponent(params.sessionId)}/push-event`,
+      {
+        kind,
+        title: getSessionNotificationTitle(kind),
+        body: params.reason,
+        data: { sessionId: params.sessionId, kind, url: params.url, reason: params.reason, ...params.sessionTitle ? { sessionTitle: params.sessionTitle } : {} }
+      },
+      {
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json",
+          "X-Happy-Client": `cli-daemon/${configuration.currentCliVersion}`
+        },
+        timeout: 15e3
+      }
+    );
+    try {
+      await post("attention");
+      return { sent: true, kind: "attention" };
+    } catch (error) {
+      if (error?.response?.status !== 400) return { sent: false, error: error?.response ? `HTTP ${error.response.status}` : String(error?.message ?? error) };
+    }
+    try {
+      await post("question");
+      return { sent: true, kind: "question" };
+    } catch (error) {
+      return { sent: false, error: error?.response ? `HTTP ${error.response.status}` : String(error?.message ?? error) };
+    }
+  }
+}
+
+export { AsyncLock as A, FileEventMessageSchema as F, MAX_CHAT_ATTACHMENT_SOURCE_BYTES as M, PushNotificationClient as P, UserMessageSchema as U, MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES as a, getSessionNotificationBody as g };

package/dist/{attachmentLimits-DtFqqiwR.cjs → pushNotifications-DaLQUyi0.cjs}

@@ -1,7 +1,11 @@
 'use strict';
 
 var z = require('zod');
-var index = require('./index-De8L5lFK.cjs');
+var index = require('./index-C6O2vVjm.cjs');
+var axios = require('axios');
+var logger = require('./logger-C1GWx3gi.cjs');
+var configuration = require('./configuration-CMHZnp6G.cjs');
+var contentLogMetadata = require('./contentLogMetadata-ZSFk_NjQ.cjs');
 
 z.z.object({
   teamsVersion: z.z.number().int().positive().optional(),
@@ -256,7 +260,21 @@ z.z.object({
     idleMs: z.z.number(),
     rpcAvailable: z.z.boolean(),
     detectedAt: z.z.number()
-  }).passthrough().optional()
+  }).passthrough().optional(),
+  /**
+   * B-510: web panels declared in this machine's local settings.json
+   * (`webPanels`), normalized by webPanels/webPanels.ts. Read-only mirror —
+   * nothing on the web/server side can write the local declaration.
+   */
+  webPanels: z.z.object({
+    panels: z.z.array(z.z.object({
+      id: z.z.string(),
+      title: z.z.string(),
+      url: z.z.string(),
+      embed: z.z.boolean()
+    })),
+    updatedAt: z.z.number()
+  }).optional()
 });
 const MessageMetaSchema = z.z.object({
   sentFrom: z.z.string().optional(),
@@ -385,8 +403,292 @@ const MAX_CHAT_ATTACHMENT_SOURCE_BYTES = 50 * 1024 * 1024;
 const CHAT_ATTACHMENT_ENCRYPTION_OVERHEAD_BYTES = 40;
 const MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES = MAX_CHAT_ATTACHMENT_SOURCE_BYTES + CHAT_ATTACHMENT_ENCRYPTION_OVERHEAD_BYTES;
 
+function getSessionTitle(metadata) {
+  const summaryText = metadata?.summary?.text?.trim();
+  if (summaryText) {
+    return summaryText;
+  }
+  const path = metadata?.path?.trim();
+  if (!path) {
+    return "Session";
+  }
+  const segments = path.split(/[\\/]/).filter(Boolean);
+  return segments[segments.length - 1] || "Session";
+}
+function getSessionNotificationUrl(data) {
+  const sessionId = data?.sessionId;
+  if (typeof sessionId !== "string") {
+    return null;
+  }
+  const trimmedSessionId = sessionId.trim();
+  if (!trimmedSessionId) {
+    return null;
+  }
+  return `/session/${encodeURIComponent(trimmedSessionId)}`;
+}
+function getSessionNotificationTitle(kind) {
+  switch (kind) {
+    case "done":
+      return "It's ready!";
+    case "permission":
+      return "Permission request";
+    case "question":
+      return "Clarification needed";
+    case "attention":
+      return "Needs you";
+  }
+}
+function getSessionNotificationBody(metadata) {
+  return getSessionTitle(metadata);
+}
+function getSessionNotificationCopy(kind, metadata) {
+  return {
+    title: getSessionNotificationTitle(kind),
+    body: getSessionNotificationBody(metadata)
+  };
+}
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expoLoad = null;
+  constructor(token, baseUrl = "https://api.cluster-fluster.com") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+  }
+  loadExpo() {
+    if (!this.expoLoad) {
+      const load = import('expo-server-sdk').then(({ Expo }) => ({ Expo, expo: new Expo() }));
+      load.catch(() => {
+        if (this.expoLoad === load) this.expoLoad = null;
+      });
+      this.expoLoad = load;
+    }
+    return this.expoLoad;
+  }
+  /**
+   * Fetch all push tokens for the authenticated user.
+   * Retries up to 3 times with exponential backoff on transient errors.
+   */
+  async fetchPushTokens() {
+    const maxAttempts = 3;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const response = await axios.get(
+          `${this.baseUrl}/v1/push-tokens`,
+          {
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "X-Happy-Client": `cli-daemon/${configuration.configuration.currentCliVersion}`
+            }
+          }
+        );
+        logger.logger.debug(`Fetched ${response.data.tokens.length} push tokens`);
+        response.data.tokens.forEach((token, index) => {
+          logger.logger.debug(`[PUSH] Token ${index + 1}: id=${token.id}, created=${new Date(token.createdAt).toISOString()}, updated=${new Date(token.updatedAt).toISOString()}`);
+        });
+        return response.data.tokens;
+      } catch (error) {
+        logger.logger.debug(`[PUSH] [ERROR] Failed to fetch push tokens (attempt ${attempt}/${maxAttempts}):`, error);
+        if (attempt < maxAttempts) {
+          const delay = 1e3 * Math.pow(2, attempt - 1);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+    }
+    logger.logger.debug("[PUSH] [ERROR] All push token fetch attempts failed");
+    return [];
+  }
+  /**
+   * Send push notification via Expo Push API with retry
+   * @param messages - Array of push messages to send
+   */
+  async sendPushNotifications(messages) {
+    logger.logger.debug(`Sending ${messages.length} push notifications`);
+    const { Expo, expo } = await this.loadExpo();
+    const validMessages = messages.filter((message) => {
+      if (Array.isArray(message.to)) {
+        return message.to.every((token) => Expo.isExpoPushToken(token));
+      }
+      return Expo.isExpoPushToken(message.to);
+    });
+    if (validMessages.length === 0) {
+      logger.logger.debug("No valid Expo push tokens found");
+      return;
+    }
+    const chunks = expo.chunkPushNotifications(validMessages);
+    for (const chunk of chunks) {
+      const startTime = Date.now();
+      const timeout = 3e5;
+      let attempt = 0;
+      while (true) {
+        try {
+          const ticketChunk = await expo.sendPushNotificationsAsync(chunk);
+          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
+          if (errors.length > 0) {
+            const errorDetails = errors.map((e) => ({ message: e.message, details: e.details }));
+            logger.logger.debug("[PUSH] Some notifications failed:", errorDetails);
+          }
+          if (errors.length === ticketChunk.length) {
+            throw new Error("All push notifications in chunk failed");
+          }
+          break;
+        } catch (error) {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            logger.logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            break;
+          }
+          attempt++;
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          const remainingTime = timeout - elapsed;
+          const waitTime = Math.min(delay, remainingTime);
+          if (waitTime > 0) {
+            logger.logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+    }
+    logger.logger.debug(`Push notifications sent successfully`);
+  }
+  /**
+   * Send a push notification to all registered devices for the user
+   * @param title - Notification title
+   * @param body - Notification body
+   * @param data - Additional data to send with the notification
+   */
+  sendToAllDevices(title, body, data) {
+    logger.logger.debug("[PUSH] sendToAllDevices called:", {
+      title: contentLogMetadata.contentLogMetadata(title),
+      body: contentLogMetadata.contentLogMetadata(body),
+      dataKeyCount: data ? Object.keys(data).length : 0
+    });
+    (async () => {
+      try {
+        logger.logger.debug("[PUSH] Fetching push tokens...");
+        const tokens = await this.fetchPushTokens();
+        logger.logger.debug(`[PUSH] Fetched ${tokens.length} push tokens`);
+        tokens.forEach((token, index) => {
+          logger.logger.debug(`[PUSH] Using token ${index + 1}: id=${token.id}`);
+        });
+        if (tokens.length === 0) {
+          logger.logger.debug("No push tokens found for user");
+          return;
+        }
+        const messages = tokens.map((token, index) => {
+          logger.logger.debug(`[PUSH] Creating message ${index + 1} for token`);
+          return {
+            to: token.token,
+            title,
+            body: body && body.length > 0 ? body : void 0,
+            data,
+            // TODO: For brutalist session artwork, attach rich media via a public HTTPS image URL.
+            // Bundled app asset paths / require(...) / local file paths will not work in push payloads.
+            // iOS also needs a Notification Service Extension to render richContent.image reliably.
+            sound: "default",
+            priority: "high"
+          };
+        });
+        logger.logger.debug(`[PUSH] Sending ${messages.length} push notifications...`);
+        await this.sendPushNotifications(messages);
+        logger.logger.debug("[PUSH] Push notifications sent successfully");
+      } catch (error) {
+        logger.logger.debug("[PUSH] Error sending to all devices:", error);
+      }
+    })();
+  }
+  /**
+   * Routes session-event pushes through the server so it can apply
+   * presence-based suppression (active desktop/web, mobile foreground).
+   * Falls back to direct Expo send only when sessionId is missing — that
+   * shouldn't happen for session notifications but guards against regressions.
+   */
+  sendSessionNotification(params) {
+    const { title, body } = getSessionNotificationCopy(params.kind, params.metadata);
+    const sessionTitle = getSessionNotificationBody(params.metadata);
+    const url = getSessionNotificationUrl(params.data);
+    const payloadData = {
+      ...params.data,
+      kind: params.kind,
+      sessionTitle,
+      ...url ? { url } : {}
+    };
+    const sessionId = typeof params.data?.sessionId === "string" ? params.data.sessionId : null;
+    if (!sessionId) {
+      logger.logger.debug("[PUSH] sendSessionNotification: missing sessionId, falling back to direct send");
+      this.sendToAllDevices(title, body, payloadData);
+      return;
+    }
+    void (async () => {
+      try {
+        await axios.post(
+          `${this.baseUrl}/v1/sessions/${encodeURIComponent(sessionId)}/push-event`,
+          {
+            kind: params.kind,
+            title,
+            body,
+            data: payloadData
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.token}`,
+              "Content-Type": "application/json",
+              "X-Happy-Client": `cli-daemon/${configuration.configuration.currentCliVersion}`
+            },
+            timeout: 15e3
+          }
+        );
+        logger.logger.debug(`[PUSH] sendSessionNotification dispatched via server (kind=${params.kind})`);
+      } catch (error) {
+        logger.logger.debug("[PUSH] sendSessionNotification failed:", error);
+      }
+    })();
+  }
+  /**
+   * B-510 `request_human` / `very-happy attention --session`: an awaited
+   * push-event `attention` (title "Needs you", body = the reason, data.url =
+   * panel deep link or the session). A server that predates the kind answers
+   * 400; then the same push goes out as `question`, so the person is still
+   * reached (compat matrix in specs/2026-09-machine-web-panels.md).
+   */
+  async sendAttention(params) {
+    const post = (kind) => axios.post(
+      `${this.baseUrl}/v1/sessions/${encodeURIComponent(params.sessionId)}/push-event`,
+      {
+        kind,
+        title: getSessionNotificationTitle(kind),
+        body: params.reason,
+        data: { sessionId: params.sessionId, kind, url: params.url, reason: params.reason, ...params.sessionTitle ? { sessionTitle: params.sessionTitle } : {} }
+      },
+      {
+        headers: {
+          "Authorization": `Bearer ${this.token}`,
+          "Content-Type": "application/json",
+          "X-Happy-Client": `cli-daemon/${configuration.configuration.currentCliVersion}`
+        },
+        timeout: 15e3
+      }
+    );
+    try {
+      await post("attention");
+      return { sent: true, kind: "attention" };
+    } catch (error) {
+      if (error?.response?.status !== 400) return { sent: false, error: error?.response ? `HTTP ${error.response.status}` : String(error?.message ?? error) };
+    }
+    try {
+      await post("question");
+      return { sent: true, kind: "question" };
+    } catch (error) {
+      return { sent: false, error: error?.response ? `HTTP ${error.response.status}` : String(error?.message ?? error) };
+    }
+  }
+}
+
 exports.AsyncLock = AsyncLock;
 exports.FileEventMessageSchema = FileEventMessageSchema;
 exports.MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES = MAX_CHAT_ATTACHMENT_ENCRYPTED_BYTES;
 exports.MAX_CHAT_ATTACHMENT_SOURCE_BYTES = MAX_CHAT_ATTACHMENT_SOURCE_BYTES;
+exports.PushNotificationClient = PushNotificationClient;
 exports.UserMessageSchema = UserMessageSchema;
+exports.getSessionNotificationBody = getSessionNotificationBody;