crossmate

push-worker.js (9632B)

---

 export class PushRegistry {
   constructor(state, env) {
     this.state = state;
     this.env = env;
     this.cachedJWT = null;
     this.cachedJWTExpiresAt = 0;
   }
 
   async fetch(request) {
     const url = new URL(request.url);
     const auth = this.authenticate(request);
     if (!auth.ok) {
       return new Response(auth.message, { status: auth.status });
     }
 
     if (url.pathname === "/register" && request.method === "POST") {
       return this.handleRegister(request);
     }
     if (url.pathname === "/register" && request.method === "DELETE") {
       return this.handleUnregister(request);
     }
     if (url.pathname === "/publish" && request.method === "POST") {
       return this.handlePublish(request);
     }
     return new Response("Not found", { status: 404 });
   }
 
   authenticate(request) {
     const header = request.headers.get("Authorization") || "";
     const expected = `Bearer ${this.env.PUSH_BEARER || ""}`;
     if (!this.env.PUSH_BEARER) {
       return { ok: false, status: 500, message: "Worker missing PUSH_BEARER" };
     }
     if (!timingSafeEqual(header, expected)) {
       return { ok: false, status: 401, message: "Bad bearer" };
     }
     return { ok: true };
   }
 
   async handleRegister(request) {
     const body = await readJSON(request);
     if (!body) return badRequest("Body must be JSON");
     const { deviceID, token, environment, addresses } = body;
     if (!deviceID || !token || !Array.isArray(addresses)) {
       return badRequest("deviceID, token, addresses required");
     }
     if (environment !== "sandbox" && environment !== "production") {
       return badRequest("environment must be 'sandbox' or 'production'");
     }
     // Bind this device's APNs token to each per-(account, game) address it
     // knows. The address is the lookup key; identity never reaches the worker.
     const updatedAt = Date.now();
     for (const address of addresses) {
       if (typeof address !== "string" || address.length === 0) continue;
       await this.state.storage.put(`addr:${address}:${deviceID}`, {
         token,
         environment,
         updatedAt
       });
     }
     return new Response(null, { status: 204 });
   }
 
   async handleUnregister(request) {
     const body = await readJSON(request);
     if (!body) return badRequest("Body must be JSON");
     const { deviceID, addresses } = body;
     if (!deviceID || !Array.isArray(addresses)) {
       return badRequest("deviceID and addresses required");
     }
     for (const address of addresses) {
       if (typeof address !== "string" || address.length === 0) continue;
       await this.state.storage.delete(`addr:${address}:${deviceID}`);
     }
     return new Response(null, { status: 204 });
   }
 
   async handlePublish(request) {
     const body = await readJSON(request);
     if (!body) return badRequest("Body must be JSON");
     const {
       kind,
       addressees,
       gameID,
       fromAuthorID,
       senderDeviceID,
       readAt,
       title,
       alertBody,
       background
     } = body;
     if (!kind || !Array.isArray(addressees) || addressees.length === 0) {
       return badRequest("kind and non-empty addressees required");
     }
 
     const targets = await this.resolveTargets(addressees, senderDeviceID);
     if (targets.length === 0) {
       return Response.json({ delivered: 0, removed: 0, failed: 0 });
     }
 
     let delivered = 0;
     let removed = 0;
     let failed = 0;
     for (const target of targets) {
       const result = await this.sendOne(target, {
         kind,
         gameID,
         fromAuthorID,
         senderDeviceID,
         readAt,
         title,
         body: target.body || alertBody,
         payload: target.payload,
         background: background === true
       });
       if (result === "ok") delivered += 1;
       else if (result === "drop") {
         await this.state.storage.delete(`addr:${target.address}:${target.deviceID}`);
         removed += 1;
       } else {
         failed += 1;
       }
     }
     return Response.json({ delivered, removed, failed });
   }
 
   async resolveTargets(addressees, senderDeviceID) {
     const targets = [];
     for (const addressee of addressees) {
       if (!addressee || !addressee.address) continue;
       const body = typeof addressee.body === "string" ? addressee.body : undefined;
       // Opaque, app-encoded semantics (base64 JSON of `PushPayload`). The
       // worker never inspects it — it just forwards it into the APNs userInfo
       // so the notification service extension can decode it. Keeping it opaque
       // is what lets the app evolve notification meaning without a worker deploy.
       const payload = typeof addressee.payload === "string" ? addressee.payload : undefined;
       const prefix = `addr:${addressee.address}:`;
       const map = await this.state.storage.list({ prefix });
       for (const [key, value] of map) {
         const deviceID = key.slice(prefix.length);
         if (senderDeviceID && deviceID === senderDeviceID) continue;
         targets.push({
           address: addressee.address,
           deviceID,
           body,
           payload,
           ...value
         });
       }
     }
     return targets;
   }
 
   async sendOne(target, message) {
     const topic = this.env.APNS_TOPIC || "net.inqk.crossmate";
     const host = target.environment === "sandbox"
       ? "api.sandbox.push.apple.com"
       : "api.push.apple.com";
     const jwt = await this.providerJWT();
     const alert = {};
     if (message.title) alert.title = message.title;
     if (message.body) alert.body = message.body;
     const apnsPayload = {
       aps: message.background
         ? { "content-available": 1 }
         : { alert, sound: "default", "mutable-content": 1 },
       kind: message.kind
     };
     if (message.gameID) apnsPayload.gameID = message.gameID;
     if (message.fromAuthorID) apnsPayload.fromAuthorID = message.fromAuthorID;
     if (message.senderDeviceID) apnsPayload.senderDeviceID = message.senderDeviceID;
     if (message.readAt) apnsPayload.readAt = message.readAt;
     // Forward the opaque app payload verbatim when present. Absent for older
     // app builds, which the extension handles by falling back to `kind`.
     if (message.payload) apnsPayload.payload = message.payload;
 
     const response = await fetch(`https://${host}/3/device/${target.token}`, {
       method: "POST",
       headers: {
         authorization: `bearer ${jwt}`,
         "apns-topic": topic,
         "apns-push-type": message.background ? "background" : "alert",
         "apns-priority": message.background ? "5" : "10",
         "apns-expiration": "0",
         "content-type": "application/json"
       },
       body: JSON.stringify(apnsPayload)
     });
 
     if (response.status === 200) return "ok";
     if (response.status === 410) return "drop";
     if (response.status === 400) {
       const text = await response.text();
       if (text.includes("BadDeviceToken") || text.includes("DeviceTokenNotForTopic")) {
         return "drop";
       }
     }
     return "fail";
   }
 
   async providerJWT() {
     const nowSeconds = Math.floor(Date.now() / 1000);
     if (this.cachedJWT && nowSeconds < this.cachedJWTExpiresAt - 60) {
       return this.cachedJWT;
     }
     const jwt = await signProviderJWT({
       keyPEM: this.env.APNS_KEY,
       keyID: this.env.APNS_KEY_ID,
       teamID: this.env.APNS_TEAM_ID,
       issuedAt: nowSeconds
     });
     this.cachedJWT = jwt;
     // Refresh well before APNs' 1-hour ceiling; the rate-limit floor is ~20 min.
     this.cachedJWTExpiresAt = nowSeconds + 40 * 60;
     return jwt;
   }
 }
 
 export default {
   async fetch(request, env) {
     const url = new URL(request.url);
     if (url.pathname === "/health") {
       return new Response("ok");
     }
     const id = env.PUSH_REGISTRY.idFromName("registry");
     return env.PUSH_REGISTRY.get(id).fetch(request);
   }
 };
 
 async function readJSON(request) {
   try {
     return await request.json();
   } catch {
     return null;
   }
 }
 
 function badRequest(message) {
   return new Response(message, { status: 400 });
 }
 
 async function signProviderJWT({ keyPEM, keyID, teamID, issuedAt }) {
   if (!keyPEM || !keyID || !teamID) {
     throw new Error("APNS_KEY, APNS_KEY_ID, APNS_TEAM_ID must all be set");
   }
   const key = await importP8(keyPEM);
   const header = base64URLEncode(new TextEncoder().encode(JSON.stringify({
     alg: "ES256",
     kid: keyID
   })));
   const claims = base64URLEncode(new TextEncoder().encode(JSON.stringify({
     iss: teamID,
     iat: issuedAt
   })));
   const signingInput = `${header}.${claims}`;
   const signature = await crypto.subtle.sign(
     { name: "ECDSA", hash: "SHA-256" },
     key,
     new TextEncoder().encode(signingInput)
   );
   return `${signingInput}.${base64URLEncode(new Uint8Array(signature))}`;
 }
 
 async function importP8(pem) {
   const stripped = pem
     .replace(/-----BEGIN PRIVATE KEY-----/g, "")
     .replace(/-----END PRIVATE KEY-----/g, "")
     .replace(/\s+/g, "");
   const der = Uint8Array.from(atob(stripped), (char) => char.charCodeAt(0));
   return crypto.subtle.importKey(
     "pkcs8",
     der,
     { name: "ECDSA", namedCurve: "P-256" },
     false,
     ["sign"]
   );
 }
 
 function base64URLEncode(bytes) {
   let binary = "";
   for (const byte of bytes) {
     binary += String.fromCharCode(byte);
   }
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
 }
 
 function timingSafeEqual(a, b) {
   const left = new TextEncoder().encode(a);
   const right = new TextEncoder().encode(b);
   if (left.length !== right.length) return false;
   let diff = 0;
   for (let index = 0; index < left.length; index += 1) {
     diff |= left[index] ^ right[index];
   }
   return diff === 0;
 }