@vex-chat/spire 2.4.0 → 2.5.0

package/src/__tests__/notifyFanout.spec.ts

@@ -8,6 +8,8 @@ import type { ClientManager } from "../ClientManager.ts";
 import type { Database, NotificationSubscription } from "../Database.ts";
 import type { BaseMsg } from "@vex-chat/types";
 
+import { generateKeyPairSync } from "node:crypto";
+
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import { NotificationService } from "../NotificationService.ts";
@@ -535,6 +537,140 @@ describe("Spire notify fanout", () => {
         });
     });
 
+    it("sends Expo callWake pushes with opaque call data", async () => {
+        const callSubscription: NotificationSubscription = {
+            ...subscription,
+            events: ["callWake"],
+            subscriptionID: "sub-call",
+        };
+        const fetchMock = vi.fn().mockResolvedValueOnce({
+            json: () =>
+                Promise.resolve({
+                    data: [{ id: "receipt-a", status: "ok" }],
+                }),
+            ok: true,
+        });
+        vi.stubGlobal("fetch", fetchMock);
+
+        const { db } = createSpireHarness([], [callSubscription]);
+        const service = new NotificationService(db, [], () => {});
+
+        await service["notifyPush"]({
+            data: {
+                callID: "call-1",
+                expiresAt: "2026-06-05T12:01:00.000Z",
+                mailID: "mail-1",
+                mailNonce: "abcd",
+            },
+            deviceID: callSubscription.deviceID,
+            event: "callWake",
+            transmissionID: "00000000-0000-0000-0000-000000000017",
+            userID: callSubscription.userID,
+        });
+
+        const init = fetchMock.mock.calls[0]?.[1] as
+            | undefined
+            | { body?: unknown };
+        const messages = JSON.parse(String(init?.body)) as Array<{
+            body?: string;
+            data?: Record<string, unknown>;
+            title?: string;
+        }>;
+        expect(messages[0]?.title).toBe("Incoming Vex call");
+        expect(messages[0]?.body).toBe("Incoming voice call.");
+        expect(messages[0]?.data).toMatchObject({
+            callID: "call-1",
+            event: "callWake",
+            expiresAt: "2026-06-05T12:01:00.000Z",
+            mailID: "mail-1",
+            mailNonce: "abcd",
+            transmissionID: "00000000-0000-0000-0000-000000000017",
+        });
+        expect(messages[0]?.data).not.toHaveProperty("callerUserID");
+        expect(messages[0]?.data).not.toHaveProperty("sdp");
+    });
+
+    it("sends FCM call pushes as high-priority opaque data", async () => {
+        const { privateKey } = generateKeyPairSync("rsa", {
+            modulusLength: 2048,
+        });
+        const fcmSubscription: NotificationSubscription = {
+            ...subscription,
+            channel: "fcmCall",
+            events: ["callWake"],
+            platform: "android",
+            subscriptionID: "sub-fcm",
+            token: "fcm-token",
+        };
+        const fetchMock = vi
+            .fn()
+            .mockResolvedValueOnce({
+                json: () => Promise.resolve({ access_token: "access-token" }),
+                ok: true,
+            })
+            .mockResolvedValueOnce({
+                ok: true,
+            });
+        vi.stubGlobal("fetch", fetchMock);
+
+        process.env["SPIRE_FCM_CLIENT_EMAIL"] = "spire@example.invalid";
+        process.env["SPIRE_FCM_PRIVATE_KEY"] = privateKey.export({
+            format: "pem",
+            type: "pkcs8",
+        });
+        process.env["SPIRE_FCM_PROJECT_ID"] = "vex-test";
+        try {
+            const { db } = createSpireHarness([], [fcmSubscription]);
+            const service = new NotificationService(db, [], () => {});
+
+            await service["notifyPush"]({
+                data: {
+                    callID: "call-fcm",
+                    expiresAt: "2026-06-05T12:01:00.000Z",
+                    mailID: "mail-fcm",
+                    mailNonce: "beef",
+                },
+                deviceID: fcmSubscription.deviceID,
+                event: "callWake",
+                transmissionID: "00000000-0000-0000-0000-000000000018",
+                userID: fcmSubscription.userID,
+            });
+        } finally {
+            delete process.env["SPIRE_FCM_CLIENT_EMAIL"];
+            delete process.env["SPIRE_FCM_PRIVATE_KEY"];
+            delete process.env["SPIRE_FCM_PROJECT_ID"];
+        }
+
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(fetchMock.mock.calls[0]?.[0]).toBe(
+            "https://oauth2.googleapis.com/token",
+        );
+        expect(fetchMock.mock.calls[1]?.[0]).toBe(
+            "https://fcm.googleapis.com/v1/projects/vex-test/messages:send",
+        );
+        const init = fetchMock.mock.calls[1]?.[1] as
+            | undefined
+            | { body?: unknown };
+        const body = JSON.parse(String(init?.body)) as {
+            message?: {
+                android?: { priority?: string; ttl?: string };
+                data?: Record<string, string>;
+                token?: string;
+            };
+        };
+        expect(body.message?.token).toBe("fcm-token");
+        expect(body.message?.android?.priority).toBe("HIGH");
+        expect(body.message?.data).toMatchObject({
+            callID: "call-fcm",
+            event: "callWake",
+            mailID: "mail-fcm",
+            mailNonce: "beef",
+            transmissionID: "00000000-0000-0000-0000-000000000018",
+        });
+        expect(body.message?.data).not.toHaveProperty("callerUserID");
+        expect(body.message?.data).not.toHaveProperty("sdp");
+    });
+
     it("requests the default sound for iOS visible Expo pushes only", async () => {
         const iosSubscription: NotificationSubscription = {
             ...subscription,

package/src/server/callWake.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2020-2026 Vex Heavy Industries LLC
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ * Commercial licenses available at vex.wtf
+ */
+
+import type { MailWS } from "@vex-chat/types";
+
+import { XUtils } from "@vex-chat/crypto";
+
+export interface CallWakeDispatchData {
+    callID: string;
+    expiresAt?: string | undefined;
+    mailID: string;
+    mailNonce: string;
+}
+
+export function callWakeDispatchData(
+    mail: MailWS,
+): CallWakeDispatchData | null {
+    if (mail.notify?.event !== "callWake") {
+        return null;
+    }
+    return {
+        callID: mail.notify.callID,
+        ...(mail.notify.expiresAt ? { expiresAt: mail.notify.expiresAt } : {}),
+        mailID: mail.mailID,
+        mailNonce: XUtils.encodeHex(new Uint8Array(mail.nonce)),
+    };
+}