@openchambery/web 1.19.0-beta.36 → 1.19.0-beta.37

package/server/lib/notifications/apns-runtime.test.js

@@ -2,6 +2,7 @@ import crypto from 'node:crypto';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 
 import { createApnsRuntime } from './apns-runtime.js';
+import { resolveEffectiveRelayUrl } from '../relay/service.js';
 
 // A real P-256 key so the ES256 signing path (direct mode) runs for real.
 const { privateKey } = crypto.generateKeyPairSync('ec', { namedCurve: 'P-256' });
@@ -38,6 +39,7 @@ const makeDeps = (overrides = {}) => {
     APNS_TOKENS_FILE_PATH: '/tmp/apns-tokens.json',
     readSettingsFromDiskMigrated: vi.fn(async () => settings),
     writeSettingsToDisk: vi.fn(async (next) => { settings = next; }),
+    resolveEffectiveRelayUrl: async () => resolveEffectiveRelayUrl({ settings }),
     ...overrides,
   };
 };
@@ -69,6 +71,7 @@ afterEach(() => {
   vi.unstubAllGlobals();
   delete process.env.OPENCHAMBER_PUSH_RELAY_URL;
   delete process.env.OPENCHAMBER_PUSH_RELAY_DISABLED;
+  delete process.env.OPENCHAMBER_RELAY_URL;
 });
 
 describe('apns runtime relay mode (default)', () => {
@@ -193,4 +196,160 @@ describe('apns runtime direct fallback (relay disabled)', () => {
     expect(JSON.parse(Buffer.from(parts[0], 'base64url').toString())).toEqual({ alg: 'ES256', kid: 'KEY123' });
     expect(JSON.parse(Buffer.from(parts[1], 'base64url').toString()).iss).toBe('TEAM123');
   });
+
+  it('does not register tokens with the push relay in direct mode', async () => {
+    process.env.OPENCHAMBER_PUSH_RELAY_DISABLED = 'true';
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true }));
+    vi.stubGlobal('fetch', fetchMock);
+    const http2 = {
+      connect: () => ({
+        on: () => {},
+        close: () => {},
+        request: (headers) => {
+          const listeners = {};
+          const req = {
+            on: (event, cb) => { listeners[event] = cb; return req; },
+            setEncoding: () => req,
+            end: () => {
+              queueMicrotask(() => {
+                listeners.response?.({ ':status': '200' });
+                listeners.end?.();
+              });
+            },
+          };
+          return req;
+        },
+      }),
+    };
+    const runtime = createApnsRuntime(
+      makeDeps({ http2, readSettingsFromDiskMigrated: vi.fn(async () => ({ apnsConfig: APNS_CONFIG })) }),
+    );
+    await runtime.addOrUpdateApnsToken('s', 'tokenDirect');
+    await runtime.sendApnsToAllUiSessions({ title: 't', body: 'b' });
+    await expect(runtime.reRegisterAllTokens()).resolves.toEqual({ attempted: 0, succeeded: 0, failed: 0 });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
+
+describe('apns runtime push relay derivation and re-register', () => {
+  const registerUrls = (fetchMock) =>
+    fetchMock.mock.calls.filter(isRegister).map(([url]) => url);
+  const sendUrls = (fetchMock) =>
+    fetchMock.mock.calls.filter(([url]) => String(url).endsWith('/v1/push/send')).map(([url]) => url);
+
+  it('prefers OPENCHAMBER_PUSH_RELAY_URL over derived relay URLs', async () => {
+    process.env.OPENCHAMBER_RELAY_URL = 'wss://env.example/ws';
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://explicit.test/v1/push/send';
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    let settings = { privateRelay: { enabled: true, relayUrl: 'wss://settings.example/ws' } };
+    const runtime = createApnsRuntime(makeDeps({
+      readSettingsFromDiskMigrated: async () => settings,
+      writeSettingsToDisk: async (next) => { settings = next; },
+      resolveEffectiveRelayUrl: async () => resolveEffectiveRelayUrl({ settings }),
+    }));
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+    expect(registerUrls(fetchMock)).toEqual(['https://explicit.test/v1/push/register-token']);
+  });
+
+  it('derives the push send URL from settings then env relay URLs', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+
+    let settings = { privateRelay: { enabled: true, relayUrl: 'wss://settings.example/custom' } };
+    const runtime = createApnsRuntime(makeDeps({
+      readSettingsFromDiskMigrated: async () => settings,
+      writeSettingsToDisk: async (next) => { settings = next; },
+      resolveEffectiveRelayUrl: async () => resolveEffectiveRelayUrl({ settings }),
+    }));
+
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+    expect(registerUrls(fetchMock)).toEqual(['https://settings.example/v1/push/register-token']);
+
+    fetchMock.mockClear();
+    process.env.OPENCHAMBER_RELAY_URL = 'wss://env.example/ws';
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+    expect(registerUrls(fetchMock)).toEqual(['https://env.example/v1/push/register-token']);
+  });
+
+  it('defaults to the hosted relay push endpoint', async () => {
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    const runtime = createApnsRuntime(makeDeps());
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+    expect(registerUrls(fetchMock)).toEqual(['https://relay.openchamber.dev/v1/push/register-token']);
+  });
+
+  it('re-registers persisted tokens against the current relay', async () => {
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay-a.test/v1/push/send';
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    const runtime = createApnsRuntime(makeDeps());
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+    await runtime.addOrUpdateApnsToken('s2', 'tokenB');
+    await runtime.addOrUpdateApnsToken('s3', 'tokenA');
+
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay-b.test/v1/push/send';
+    fetchMock.mockClear();
+    await expect(runtime.reRegisterAllTokens()).resolves.toEqual({
+      attempted: 2,
+      succeeded: 2,
+      failed: 0,
+    });
+    expect(registerUrls(fetchMock).every((url) => url === 'https://relay-b.test/v1/push/register-token')).toBe(true);
+    expect(registerUrls(fetchMock)).toHaveLength(2);
+    expect(sendUrls(fetchMock)).toEqual([]);
+  });
+
+  it('registers with the new relay before the first send after a switch', async () => {
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay-a.test/v1/push/send';
+    const fetchMock = vi.fn(async () => jsonResponse({ ok: true, results: [] }));
+    vi.stubGlobal('fetch', fetchMock);
+    const runtime = createApnsRuntime(makeDeps());
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay-b.test/v1/push/send';
+    fetchMock.mockClear();
+    await runtime.sendApnsToAllUiSessions({ title: 't', body: 'b' });
+
+    expect(fetchMock.mock.calls.map(([url]) => url)).toEqual([
+      'https://relay-b.test/v1/push/register-token',
+      'https://relay-b.test/v1/push/send',
+    ]);
+  });
+
+  it('sends only tokens that registered successfully after a partial failure', async () => {
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay-a.test/v1/push/send';
+    const fetchMock = vi.fn(async (url, init) => {
+      if (String(url).endsWith('/register-token')) {
+        const body = JSON.parse(init.body);
+        if (body.token === 'tokenB') return jsonResponse({ error: true }, 500);
+        return jsonResponse({ ok: true });
+      }
+      return jsonResponse({ results: [] });
+    });
+    vi.stubGlobal('fetch', fetchMock);
+    const runtime = createApnsRuntime(makeDeps());
+    await runtime.addOrUpdateApnsToken('s1', 'tokenA');
+    await runtime.addOrUpdateApnsToken('s2', 'tokenB');
+
+    process.env.OPENCHAMBER_PUSH_RELAY_URL = 'https://relay-b.test/v1/push/send';
+    fetchMock.mockClear();
+    await runtime.sendApnsToAllUiSessions({ title: 't', body: 'b' });
+
+    const registerBodies = fetchMock.mock.calls
+      .filter(isRegister)
+      .map(([, init]) => JSON.parse(init.body).token)
+      .sort();
+    expect(registerBodies).toEqual(['tokenA', 'tokenB']);
+    expect(sendUrls(fetchMock)).toEqual(['https://relay-b.test/v1/push/send']);
+    expect(JSON.parse(fetchMock.mock.calls.find(([url]) => String(url).endsWith('/v1/push/send'))[1].body).tokens).toEqual(['tokenA']);
+
+    fetchMock.mockClear();
+    await runtime.sendApnsToAllUiSessions({ title: 't', body: 'b' });
+    const retryRegister = fetchMock.mock.calls.filter(isRegister).map(([, init]) => JSON.parse(init.body).token);
+    expect(retryRegister).toEqual(['tokenB']);
+    expect(JSON.parse(fetchMock.mock.calls.find(([url]) => String(url).endsWith('/v1/push/send'))[1].body).tokens).toEqual(['tokenA']);
+  });
 });

package/server/lib/relay/service.js

@@ -54,6 +54,25 @@ export const canonicalizeRelayUrl = (value) => {
   }
 };
 
+// Canonical ws(s) relay URL → Push send endpoint on the same host/port.
+// Always `/v1/push/send`; never derived from window/location.
+export const derivePushSendUrlFromRelayUrl = (value) => {
+  const canonical = canonicalizeRelayUrl(value);
+  if (!canonical) return null;
+  try {
+    const url = new URL(canonical);
+    url.protocol = url.protocol === 'wss:' ? 'https:' : 'http:';
+    url.pathname = '/v1/push/send';
+    url.username = '';
+    url.password = '';
+    url.hash = '';
+    url.search = '';
+    return url.toString();
+  } catch {
+    return null;
+  }
+};
+
 const normalizeRelayUrl = (value) => {
   if (typeof value !== 'string') return DEFAULT_RELAY_URL;
   return canonicalizeRelayUrl(value) ?? DEFAULT_RELAY_URL;
@@ -63,12 +82,16 @@ const normalizeRelayUrl = (value) => {
 // your own Cloudflare account/domain). When set and valid it overrides the
 // stored setting entirely, so the host connection, the pairing offer, and the
 // status all point at it — clients then inherit it from the offer automatically.
-const envRelayUrlOverride = () => {
-  const raw = process.env.OPENCHAMBER_RELAY_URL;
+const envRelayUrlOverride = (env = process.env) => {
+  const raw = env?.OPENCHAMBER_RELAY_URL;
   if (typeof raw !== 'string' || !raw.trim()) return null;
   return canonicalizeRelayUrl(raw);
 };
 
+// Env (`OPENCHAMBER_RELAY_URL`) → settings.privateRelay.relayUrl → DEFAULT_RELAY_URL.
+export const resolveEffectiveRelayUrl = ({ settings = null, env = process.env } = {}) =>
+  envRelayUrlOverride(env) ?? normalizeRelayUrl(settings?.privateRelay?.relayUrl);
+
 /**
  * @param {{
  *   crypto: typeof import('node:crypto'),
@@ -77,6 +100,7 @@ const envRelayUrlOverride = () => {
  *   getLocalPort: () => number,
  *   logger?: Pick<Console, 'warn'>,
  *   canHostRelay?: () => boolean,
+ *   onRelayUrlChanged?: () => Promise<void> | void,
  * }} deps
  */
 export const createRelayService = ({
@@ -98,6 +122,7 @@ export const createRelayService = ({
   // Host gate: false for non-host runtimes (dev server, ordinary CLI, VS Code, …).
   canHostRelay = () => isRelayHostRuntime(),
   logger = console,
+  onRelayUrlChanged = null,
 }) => {
   const identityRuntime = createRelayIdentityRuntime({ crypto, readSettingsFromDiskMigrated, writeSettingsToDisk, readSettingsStrict });
 
@@ -131,13 +156,22 @@ export const createRelayService = ({
     const override = envRelayUrlOverride();
     return {
       enabled: stored?.enabled === true,
-      relayUrl: override ?? normalizeRelayUrl(stored?.relayUrl),
+      relayUrl: resolveEffectiveRelayUrl({ settings }),
       // True when the endpoint is pinned by OPENCHAMBER_RELAY_URL (a self-hosted
       // relay); the stored setting is ignored while it is set.
       relayUrlLocked: override !== null,
     };
   };
 
+  const notifyRelayUrlChanged = async () => {
+    if (typeof onRelayUrlChanged !== 'function') return;
+    try {
+      await onRelayUrlChanged();
+    } catch (error) {
+      logger.warn(`[Relay] push token re-register failed: ${error?.message ?? error}`);
+    }
+  };
+
   const writeConfig = async (config) => {
     const settings = await readSettingsFromDiskMigrated();
     await writeSettingsToDisk({
@@ -365,6 +399,10 @@ export const createRelayService = ({
     if (!config.enabled || endpointChanged) {
       await writeConfig({ enabled: true, relayUrl });
     }
+    const next = await readConfig();
+    if (next.relayUrl !== config.relayUrl) {
+      await notifyRelayUrlChanged();
+    }
     if (endpointChanged) {
       // One Host identity can have only one live Relay control connection. A
       // custom endpoint therefore becomes the authoritative transport before
@@ -409,6 +447,10 @@ export const createRelayService = ({
           relayUrl = canonical;
         }
         await writeConfig({ enabled: true, relayUrl });
+        const next = await readConfig();
+        if (next.relayUrl !== current.relayUrl) {
+          await notifyRelayUrlChanged();
+        }
         if (hostClient) stop();
         // Explicit user action: take the machine's host claim like pairing does.
         await start(relayUrl, { claim: 'force' });

package/server/lib/relay/service.test.js

@@ -34,8 +34,10 @@ vi.mock('./host-client.js', () => ({
 import {
   createRelayService,
   DEFAULT_RELAY_URL,
+  derivePushSendUrlFromRelayUrl,
   isRelayHostRuntime,
   RELAY_HOST_DESKTOP_ONLY_MESSAGE,
+  resolveEffectiveRelayUrl,
 } from './service.js';
 
 const createSettingsHarness = () => {
@@ -60,6 +62,59 @@ const createTestRelayService = ({ canHostRelay = true, ...overrides } = {}) => {
   return { service, settings };
 };
 
+describe('derivePushSendUrlFromRelayUrl', () => {
+  it('converts wss and ws canonical relay URLs to the fixed push send path', () => {
+    expect(derivePushSendUrlFromRelayUrl('wss://relay.openchamber.dev/ws')).toBe(
+      'https://relay.openchamber.dev/v1/push/send',
+    );
+    expect(derivePushSendUrlFromRelayUrl('ws://127.0.0.1:8787/custom')).toBe(
+      'http://127.0.0.1:8787/v1/push/send',
+    );
+    expect(derivePushSendUrlFromRelayUrl('wss://relay.example:8443/any/path?token=secret#frag')).toBe(
+      'https://relay.example:8443/v1/push/send',
+    );
+  });
+
+  it('rejects userinfo and non-ws(s) URLs', () => {
+    expect(derivePushSendUrlFromRelayUrl('wss://user:pass@relay.example/ws')).toBeNull();
+    expect(derivePushSendUrlFromRelayUrl('https://relay.openchamber.dev/ws')).toBeNull();
+    expect(derivePushSendUrlFromRelayUrl('http://relay.example/v1/push/send')).toBeNull();
+    expect(derivePushSendUrlFromRelayUrl('')).toBeNull();
+    expect(derivePushSendUrlFromRelayUrl(null)).toBeNull();
+  });
+});
+
+describe('resolveEffectiveRelayUrl', () => {
+  afterEach(() => {
+    delete process.env.OPENCHAMBER_RELAY_URL;
+  });
+
+  it('prefers a valid env URL, then settings, then the default', () => {
+    expect(resolveEffectiveRelayUrl()).toBe(DEFAULT_RELAY_URL);
+    expect(
+      resolveEffectiveRelayUrl({
+        settings: { privateRelay: { relayUrl: 'wss://settings.example/ws' } },
+      }),
+    ).toBe('wss://settings.example/ws');
+
+    process.env.OPENCHAMBER_RELAY_URL = 'wss://env.example/ws?x=1#frag';
+    expect(
+      resolveEffectiveRelayUrl({
+        settings: { privateRelay: { relayUrl: 'wss://settings.example/ws' } },
+      }),
+    ).toBe('wss://env.example/ws');
+  });
+
+  it('ignores an invalid env URL and falls through to settings', () => {
+    process.env.OPENCHAMBER_RELAY_URL = 'https://not-a-relay.example/ws';
+    expect(
+      resolveEffectiveRelayUrl({
+        settings: { privateRelay: { relayUrl: 'wss://settings.example/ws' } },
+      }),
+    ).toBe('wss://settings.example/ws');
+  });
+});
+
 describe('relay service pairing endpoint', () => {
   afterEach(() => {
     relayMocks.starts.length = 0;
@@ -142,6 +197,68 @@ describe('relay service pairing endpoint', () => {
     });
     expect(relayMocks.starts).toEqual(['wss://relay.example/custom']);
   });
+
+  it('invokes onRelayUrlChanged only when the canonical URL actually changes', async () => {
+    const onRelayUrlChanged = vi.fn(async () => {});
+    const { service } = createTestRelayService({ onRelayUrlChanged });
+
+    await service.ensureEnabledForPairing();
+    expect(onRelayUrlChanged).not.toHaveBeenCalled();
+
+    await service.ensureEnabledForPairing('wss://relay.example/custom');
+    expect(onRelayUrlChanged).toHaveBeenCalledTimes(1);
+
+    await service.ensureEnabledForPairing('wss://relay.example/custom?x=1#frag');
+    expect(onRelayUrlChanged).toHaveBeenCalledTimes(1);
+
+    const app = express();
+    service.registerRoutes(app);
+    await request(app)
+      .post('/api/openchamber/relay/enable')
+      .send({ relayUrl: 'wss://relay.example/other' })
+      .expect(200);
+    expect(onRelayUrlChanged).toHaveBeenCalledTimes(2);
+
+    await request(app)
+      .post('/api/openchamber/relay/enable')
+      .send({ relayUrl: 'wss://relay.example/other' })
+      .expect(200);
+    expect(onRelayUrlChanged).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not invoke onRelayUrlChanged for an env-pinned relay and still uses the pin', async () => {
+    process.env.OPENCHAMBER_RELAY_URL = 'wss://pinned.example/ws';
+    const onRelayUrlChanged = vi.fn(async () => {});
+    const { service } = createTestRelayService({ onRelayUrlChanged });
+    const app = express();
+    service.registerRoutes(app);
+
+    const candidate = await service.ensureEnabledForPairing('wss://ignored.example/ws');
+    expect(candidate.relayUrl).toBe('wss://pinned.example/ws');
+    expect(onRelayUrlChanged).not.toHaveBeenCalled();
+
+    await request(app)
+      .post('/api/openchamber/relay/enable')
+      .send({ relayUrl: 'wss://ignored.example/ws' })
+      .expect(200);
+    expect(onRelayUrlChanged).not.toHaveBeenCalled();
+    expect((await service.getStatus()).relayUrl).toBe('wss://pinned.example/ws');
+  });
+
+  it('continues the relay switch when onRelayUrlChanged fails', async () => {
+    const onRelayUrlChanged = vi.fn(async () => {
+      throw new Error('push relay unavailable');
+    });
+    const logger = { warn: vi.fn() };
+    const { service } = createTestRelayService({ onRelayUrlChanged, logger });
+
+    await expect(service.ensureEnabledForPairing('wss://relay.example/custom')).resolves.toMatchObject({
+      relayUrl: 'wss://relay.example/custom',
+    });
+    expect(onRelayUrlChanged).toHaveBeenCalledTimes(1);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('push token re-register failed'));
+    expect(relayMocks.starts).toEqual(['wss://relay.example/custom']);
+  });
 });
 
 describe('relay host runtime gate', () => {