@yuriai/relay-server 0.0.0-stage → 0.1.0

package/src/push/schema.js

@@ -0,0 +1,230 @@
+import { b64urlExact, parsePublicJwk } from './crypto.js';
+
+export const IOS_TOKEN = /^[0-9a-fA-F]{64}$/;
+export const JSON_BODY_BYTES = 16 * 1024;
+export const APNS_PAYLOAD_BYTES = 4096;
+export const MAX_TOKENS_PER_REQUEST = 100;
+export const MAX_TITLE_BYTES = 256;
+export const MAX_BODY_BYTES = 1024;
+export const MAX_COLLAPSE_ID_BYTES = 64;
+export const MAX_DATA_ENTRIES = 16;
+export const MAX_DATA_KEY_BYTES = 64;
+export const MAX_DATA_VALUE_BYTES = 256;
+export const MAX_DATA_TOTAL_BYTES = 2048;
+export const LIVE_ACTIVITY_KIND = 'liveactivity';
+export const LIVE_ACTIVITY_EVENTS = new Set(['update', 'end']);
+export const LIVE_ACTIVITY_STATUSES = new Set(['working', 'tool', 'retry', 'input', 'permission', 'stale', 'complete', 'error']);
+export const LIVE_ACTIVITY_CONTENT_KEYS = new Set([
+  'status',
+  'eventVersion',
+  'updatedAt',
+  'endedAt',
+  'title',
+  'workingCount',
+  'items',
+]);
+const MAX_LIVE_ACTIVITY_ITEMS = 4;
+const MAX_LIVE_ACTIVITY_ITEM_TITLE = 80;
+const MAX_LIVE_ACTIVITY_ITEM_SESSION = 128;
+
+const bytes = (value) => Buffer.byteLength(value, 'utf8');
+const isSafeInt = (value) => typeof value === 'number' && Number.isSafeInteger(value);
+const isFiniteNumber = (value) => typeof value === 'number' && Number.isFinite(value);
+
+export const isIosToken = (value) => typeof value === 'string' && IOS_TOKEN.test(value);
+
+const parseTs = (value) => (isSafeInt(value) ? value : null);
+const parseSig = (value) => b64urlExact(value, 64);
+
+const parseData = (value) => {
+  if (value === undefined) return {};
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const entries = Object.entries(value);
+  if (entries.length > MAX_DATA_ENTRIES) return null;
+  let total = 0;
+  const data = {};
+  for (const [key, entry] of entries) {
+    if (typeof key !== 'string' || key.length === 0 || key === 'aps' || typeof entry !== 'string') return null;
+    const keyBytes = bytes(key);
+    const valueBytes = bytes(entry);
+    if (keyBytes > MAX_DATA_KEY_BYTES || valueBytes > MAX_DATA_VALUE_BYTES) return null;
+    total += keyBytes + valueBytes;
+    if (total > MAX_DATA_TOTAL_BYTES) return null;
+    data[key] = entry;
+  }
+  return data;
+};
+
+export const buildApnsPayload = ({ title, body, badge, collapseId, data }) => {
+  const alert = { title };
+  if (body) alert.body = body;
+  const aps = { alert, sound: 'default', 'mutable-content': 1 };
+  if (badge !== undefined) aps.badge = badge;
+  if (collapseId) aps['thread-id'] = collapseId;
+  return Object.keys(data).length > 0 ? { aps, ...data } : { aps };
+};
+
+export const buildLiveActivityPayload = ({ event, contentState, dismissalDate, staleDate, timestamp }) => {
+  const aps = { timestamp, event, 'content-state': contentState };
+  if (event === 'end' && dismissalDate !== undefined) aps['dismissal-date'] = dismissalDate;
+  if (event === 'update' && staleDate !== undefined) aps['stale-date'] = staleDate;
+  return { aps };
+};
+
+const uniqueTokens = (tokens) => {
+  const unique = [];
+  const seen = new Set();
+  for (const token of tokens) {
+    if (seen.has(token)) continue;
+    seen.add(token);
+    unique.push(token);
+  }
+  return unique;
+};
+
+const parseLiveActivityItems = (value) => {
+  if (value === undefined) return undefined;
+  if (!Array.isArray(value) || value.length > MAX_LIVE_ACTIVITY_ITEMS) return null;
+  const items = [];
+  for (const raw of value) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const sessionID = typeof raw.sessionID === 'string'
+      ? raw.sessionID
+      : (typeof raw.sessionId === 'string' ? raw.sessionId : '');
+    if (!sessionID || sessionID.length > MAX_LIVE_ACTIVITY_ITEM_SESSION) return null;
+    if (typeof raw.status !== 'string' || !LIVE_ACTIVITY_STATUSES.has(raw.status)) return null;
+    if (!isFiniteNumber(raw.startedAt)) return null;
+    const title = typeof raw.title === 'string' ? raw.title.slice(0, MAX_LIVE_ACTIVITY_ITEM_TITLE) : '';
+    const item = { sessionID, title, status: raw.status, startedAt: raw.startedAt };
+    if (raw.endedAt !== undefined) {
+      if (!isFiniteNumber(raw.endedAt)) return null;
+      item.endedAt = raw.endedAt;
+    }
+    items.push(item);
+  }
+  return items;
+};
+
+const parseContentState = (value, event) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
+  const keys = Object.keys(value);
+  if (keys.length === 0 || keys.some((key) => !LIVE_ACTIVITY_CONTENT_KEYS.has(key))) return null;
+  if (typeof value.status !== 'string' || !LIVE_ACTIVITY_STATUSES.has(value.status)) return null;
+  if (!isSafeInt(value.eventVersion) || !isFiniteNumber(value.updatedAt)) return null;
+  if (event === 'end' && !isFiniteNumber(value.endedAt)) return null;
+  if (value.endedAt !== undefined && !isFiniteNumber(value.endedAt)) return null;
+  if (value.title !== undefined && (typeof value.title !== 'string' || value.title.length > MAX_LIVE_ACTIVITY_ITEM_TITLE)) {
+    return null;
+  }
+  if (value.workingCount !== undefined && (!isSafeInt(value.workingCount) || value.workingCount < 0)) {
+    return null;
+  }
+  const items = parseLiveActivityItems(value.items);
+  if (items === null) return null;
+  const contentState = { status: value.status, eventVersion: value.eventVersion, updatedAt: value.updatedAt };
+  if (value.endedAt !== undefined) contentState.endedAt = value.endedAt;
+  if (value.title !== undefined) contentState.title = value.title;
+  if (value.workingCount !== undefined) contentState.workingCount = value.workingCount;
+  if (items !== undefined) contentState.items = items;
+  return contentState;
+};
+
+export const validateRegisterBody = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { error: 'invalid_request' };
+  if (body.platform === 'android') return { error: 'unsupported_platform' };
+  if (body.platform !== 'ios') return { error: 'invalid_request' };
+  if (!isIosToken(body.token)) return { error: 'invalid_request' };
+  const jwk = parsePublicJwk(body.publicKeyJwk);
+  const ts = parseTs(body.ts);
+  const sig = parseSig(body.sig);
+  if (!jwk || ts === null || !sig) return { error: 'invalid_request' };
+  return { value: { token: body.token, platform: 'ios', publicKeyJwk: jwk, ts, sig } };
+};
+
+export const validateLiveActivityRegisterBody = (body) => {
+  const parsed = validateRegisterBody(body);
+  if (parsed.error) return parsed;
+  if (body.kind !== LIVE_ACTIVITY_KIND) return { error: 'invalid_request' };
+  return { value: { ...parsed.value, kind: LIVE_ACTIVITY_KIND } };
+};
+
+export const validateSendBody = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { error: 'invalid_request' };
+  const tokens = body.tokens;
+  if (!Array.isArray(tokens) || tokens.length < 1 || tokens.length > MAX_TOKENS_PER_REQUEST) return { error: 'invalid_request' };
+  if (tokens.some((token) => !isIosToken(token))) return { error: 'invalid_request' };
+  if (typeof body.title !== 'string' || body.title.length === 0 || bytes(body.title) > MAX_TITLE_BYTES) return { error: 'invalid_request' };
+  if (body.body !== undefined && (typeof body.body !== 'string' || bytes(body.body) > MAX_BODY_BYTES)) return { error: 'invalid_request' };
+  if (body.badge !== undefined && (!isSafeInt(body.badge) || body.badge < 0)) return { error: 'invalid_request' };
+  if (body.collapseId !== undefined && (typeof body.collapseId !== 'string' || bytes(body.collapseId) > MAX_COLLAPSE_ID_BYTES)) return { error: 'invalid_request' };
+  if (body.env !== undefined && body.env !== 'production' && body.env !== 'sandbox') return { error: 'invalid_request' };
+  const jwk = parsePublicJwk(body.publicKeyJwk);
+  const ts = parseTs(body.ts);
+  const sig = parseSig(body.sig);
+  const data = parseData(body.data);
+  if (!jwk || ts === null || !sig || !data) return { error: 'invalid_request' };
+  const unique = uniqueTokens(tokens);
+  const payload = buildApnsPayload({
+    title: body.title,
+    body: body.body ?? '',
+    badge: body.badge,
+    collapseId: body.collapseId,
+    data,
+  });
+  if (bytes(JSON.stringify(payload)) > APNS_PAYLOAD_BYTES) return { error: 'invalid_request' };
+  return {
+    value: {
+      tokens,
+      uniqueTokens: unique,
+      title: body.title,
+      body: typeof body.body === 'string' ? body.body : '',
+      badge: body.badge,
+      collapseId: body.collapseId || undefined,
+      env: body.env === 'production' ? 'production' : 'sandbox',
+      publicKeyJwk: jwk,
+      ts,
+      sig,
+      payload,
+    },
+  };
+};
+
+export const validateLiveActivityBody = (body) => {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { error: 'invalid_request' };
+  const tokens = body.tokens;
+  if (!Array.isArray(tokens) || tokens.length < 1 || tokens.length > MAX_TOKENS_PER_REQUEST) return { error: 'invalid_request' };
+  if (tokens.some((token) => !isIosToken(token))) return { error: 'invalid_request' };
+  if (typeof body.event !== 'string' || !LIVE_ACTIVITY_EVENTS.has(body.event)) return { error: 'invalid_request' };
+  const contentState = parseContentState(body.contentState, body.event);
+  if (!contentState) return { error: 'invalid_request' };
+  if (body.dismissalDate !== undefined && !isSafeInt(body.dismissalDate)) return { error: 'invalid_request' };
+  if (body.staleDate !== undefined && !isSafeInt(body.staleDate)) return { error: 'invalid_request' };
+  if (body.env !== undefined && body.env !== 'production' && body.env !== 'sandbox') return { error: 'invalid_request' };
+  const jwk = parsePublicJwk(body.publicKeyJwk);
+  const ts = parseTs(body.ts);
+  const sig = parseSig(body.sig);
+  if (!jwk || ts === null || !sig) return { error: 'invalid_request' };
+  const payload = buildLiveActivityPayload({
+    event: body.event,
+    contentState,
+    dismissalDate: body.dismissalDate,
+    staleDate: body.staleDate,
+    timestamp: 1_000_000_000,
+  });
+  if (bytes(JSON.stringify(payload)) > APNS_PAYLOAD_BYTES) return { error: 'invalid_request' };
+  return {
+    value: {
+      tokens,
+      uniqueTokens: uniqueTokens(tokens),
+      event: body.event,
+      contentState,
+      dismissalDate: body.dismissalDate,
+      staleDate: body.staleDate,
+      env: body.env === 'production' ? 'production' : 'sandbox',
+      publicKeyJwk: jwk,
+      ts,
+      sig,
+      payload,
+    },
+  };
+};

package/src/push/server.js

@@ -0,0 +1,104 @@
+import http from 'node:http';
+
+import { normalizePushRelayOptions, formatPushRelayUrl } from './config.js';
+import { createPushRelayHandler } from './handler.js';
+
+const STOP_DEADLINE_MS = 5_500;
+
+export const createPushRelayServer = (options = {}) => {
+  const config = normalizePushRelayOptions(options);
+  const clock = { now: Date.now, setTimeout, clearTimeout, setInterval, clearInterval, setImmediate, ...config.clock };
+  const handler = createPushRelayHandler({ ...options, claimHealthEndpoints: true });
+  let server = null; let startPromise = null; let stopPromise = null; let abortStart = null; let state = 'idle'; let generation = 0;
+
+  const start = () => {
+    if (state === 'running') return Promise.resolve();
+    if (state === 'stopping') return stopPromise.then(() => start());
+    if (startPromise) return startPromise;
+    state = 'starting';
+    const localGeneration = ++generation;
+    const localServer = http.createServer((request, response) => {
+      handler.handleRequest(request, response);
+    });
+    server = localServer;
+    startPromise = new Promise((resolve, rejectStart) => {
+      const failStart = (error) => {
+        if (localGeneration !== generation) return;
+        localServer.off('listening', ready);
+        cleanupStart();
+        rejectStart(error);
+      };
+      const ready = async () => {
+        localServer.off('error', failStart);
+        if (localGeneration !== generation || state !== 'starting') return;
+        try { await handler.activate(); } catch (error) { failStart(error); await handler.deactivate(); return; }
+        if (localGeneration !== generation || state !== 'starting') { await handler.deactivate(); return; }
+        state = 'running';
+        resolve();
+      };
+      const cleanupStart = () => {
+        localServer.close();
+        if (server === localServer) server = null;
+        state = 'stopped';
+      };
+      abortStart = () => {
+        if (state === 'starting') { cleanupStart(); rejectStart(new Error('push relay stopped during start')); }
+      };
+      localServer.once('error', failStart);
+      localServer.once('listening', ready);
+      localServer.listen(config.port, config.host);
+    }).finally(() => { startPromise = null; abortStart = null; });
+    return startPromise;
+  };
+
+  const stop = () => {
+    if (stopPromise) return stopPromise;
+    if (state === 'idle' || state === 'stopped') { state = 'stopped'; return Promise.resolve(); }
+    if (state === 'starting') abortStart?.();
+    state = 'stopping';
+    generation += 1;
+    const localServer = server;
+    stopPromise = Promise.resolve().then(async () => {
+      let deadlineTimer = null;
+      try {
+        const closed = new Promise((resolve) => {
+          if (!localServer) { resolve(); return; }
+          localServer.close(() => resolve());
+          try { localServer.closeIdleConnections?.(); } catch { /* ignore */ }
+        });
+        const deactivated = handler.deactivate();
+        const graceful = Promise.all([closed, deactivated]);
+        const deadline = new Promise((resolve) => {
+          deadlineTimer = clock.setTimeout(() => resolve('deadline'), STOP_DEADLINE_MS);
+        });
+        const winner = await Promise.race([graceful.then(() => 'graceful'), deadline]);
+        if (winner === 'deadline') {
+          try { localServer?.closeAllConnections?.(); } catch { /* ignore */ }
+          await deactivated;
+        }
+      } finally {
+        if (deadlineTimer !== null) try { clock.clearTimeout(deadlineTimer); } catch { /* ignore */ }
+      }
+      if (server === localServer) { server = null; state = 'stopped'; }
+      stopPromise = null;
+    });
+    return stopPromise;
+  };
+
+  return {
+    start,
+    stop,
+    address: () => server?.address(),
+    get url() {
+      const address = server?.address();
+      return address && typeof address === 'object' ? formatPushRelayUrl(config.host, address.port) : null;
+    },
+    getSnapshot: () => ({ ...handler.getSnapshot(), state }),
+  };
+};
+
+export const startPushRelayServer = async (options) => {
+  const server = createPushRelayServer(options);
+  await server.start();
+  return server;
+};

package/src/push/store-worker.js

@@ -0,0 +1,15 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import { createTokenStore } from './store.js';
+
+const store = createTokenStore(workerData.databasePath, { busyTimeoutMs: 250 });
+parentPort.postMessage({ rows: store.entries(workerData.maxTokens) });
+parentPort.on('message', ({ id, operation, args }) => {
+  try {
+    if (operation === 'upsert') store.upsert(...args);
+    else if (operation === 'delete') store.delete(...args);
+    else throw new Error('invalid operation');
+    parentPort.postMessage({ id, ok: true });
+  } catch {
+    parentPort.postMessage({ id, ok: false });
+  }
+});

package/src/push/store.js

@@ -0,0 +1,60 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+
+const SCHEMA = `CREATE TABLE IF NOT EXISTS push_tokens (
+  token TEXT PRIMARY KEY,
+  server_id TEXT NOT NULL,
+  platform TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+) STRICT`;
+
+export const createTokenStore = (databasePath, { busyTimeoutMs = 5_000 } = {}) => {
+  if (typeof databasePath !== 'string' || databasePath.length === 0 || databasePath.includes('\0')) {
+    throw new RangeError('invalid database path');
+  }
+  if (databasePath !== ':memory:') {
+    fs.mkdirSync(path.dirname(path.resolve(databasePath)), { recursive: true });
+  }
+  const db = new DatabaseSync(databasePath, { timeout: busyTimeoutMs });
+  db.exec('PRAGMA journal_mode = WAL');
+  db.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+  db.exec(SCHEMA);
+  const getStmt = db.prepare('SELECT server_id AS serverId, platform, updated_at AS updatedAt FROM push_tokens WHERE token = ?');
+  const upsertStmt = db.prepare(`INSERT INTO push_tokens (token, server_id, platform, updated_at) VALUES (?, ?, ?, ?)
+    ON CONFLICT(token) DO UPDATE SET server_id = excluded.server_id, platform = excluded.platform, updated_at = excluded.updated_at`);
+  const deleteStmt = db.prepare('DELETE FROM push_tokens WHERE token = ?');
+  const countStmt = db.prepare('SELECT COUNT(*) AS n FROM push_tokens');
+  let closed = false;
+  const assertOpen = () => { if (closed) throw new Error('token store closed'); };
+  return {
+    entries(maxTokens) {
+      assertOpen();
+      const rows = db.prepare('SELECT token, server_id AS serverId, platform, updated_at AS updatedAt FROM push_tokens LIMIT ?').all(maxTokens + 1);
+      if (rows.length > maxTokens) throw new Error('token capacity exceeded');
+      return rows;
+    },
+    get(token) {
+      assertOpen();
+      const row = getStmt.get(token);
+      return row ? { serverId: row.serverId, platform: row.platform, updatedAt: row.updatedAt } : null;
+    },
+    upsert(token, serverId, platform, updatedAt) {
+      assertOpen();
+      upsertStmt.run(token, serverId, platform, updatedAt);
+    },
+    delete(token) {
+      assertOpen();
+      deleteStmt.run(token);
+    },
+    count() {
+      assertOpen();
+      return Number(countStmt.get().n);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      try { db.close(); } catch { /* already closed */ }
+    },
+  };
+};