@vibelet/cli 0.1.35 → 0.1.37

package/src/push-store.test.ts

@@ -0,0 +1,89 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { PushStore } from './push-store.js';
+
+test('PushStore overwrites the previous token for the same device', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-1', 'ExponentPushToken[expo-go]');
+    store.register('device-1', 'ExponentPushToken[vibelet]');
+
+    assert.deepEqual(store.listTokens(), ['ExponentPushToken[vibelet]']);
+
+    const persisted = JSON.parse(await readFile(pushSubscriptionsPath, 'utf8'));
+    assert.equal(persisted.length, 1);
+    assert.equal(persisted[0].deviceId, 'device-1');
+    assert.equal(persisted[0].pushToken, 'ExponentPushToken[vibelet]');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('PushStore de-duplicates tokens reused by a different device', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-expo-go', 'ExponentPushToken[shared]');
+    store.register('device-vibelet', 'ExponentPushToken[shared]');
+
+    assert.deepEqual(store.list(), [
+      {
+        deviceId: 'device-vibelet',
+        pushToken: 'ExponentPushToken[shared]',
+        platform: 'expo',
+        createdAt: store.list()[0]?.createdAt,
+        updatedAt: store.list()[0]?.updatedAt,
+      },
+    ]);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('PushStore unregister only removes the matching device token', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-1', 'ExponentPushToken[one]');
+    store.register('device-2', 'ExponentPushToken[two]');
+
+    assert.equal(store.unregister('device-1', 'ExponentPushToken[two]'), false);
+    assert.deepEqual(store.listTokens(), ['ExponentPushToken[two]', 'ExponentPushToken[one]']);
+
+    assert.equal(store.unregister('device-1', 'ExponentPushToken[one]'), true);
+    assert.deepEqual(store.listTokens(), ['ExponentPushToken[two]']);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('PushStore unregisterToken removes stale subscriptions by token', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-1', 'ExponentPushToken[stale]');
+    store.register('device-2', 'ExponentPushToken[live]');
+
+    assert.equal(store.unregisterToken('ExponentPushToken[missing]'), false);
+    assert.equal(store.unregisterToken('ExponentPushToken[stale]'), true);
+    assert.deepEqual(store.listTokens(), ['ExponentPushToken[live]']);
+
+    const persisted = JSON.parse(await readFile(pushSubscriptionsPath, 'utf8'));
+    assert.equal(persisted.length, 1);
+    assert.equal(persisted[0].pushToken, 'ExponentPushToken[live]');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/src/push-store.ts

@@ -0,0 +1,126 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname } from 'path';
+import { PUSH_SUBSCRIPTIONS_PATH } from './paths.js';
+
+export interface PushSubscriptionRecord {
+  deviceId: string;
+  pushToken: string;
+  platform: 'expo';
+  createdAt: string;
+  updatedAt: string;
+  lastSentAt?: string;
+}
+
+function isPushSubscriptionRecord(entry: unknown): entry is PushSubscriptionRecord {
+  return Boolean(
+    entry
+      && typeof entry === 'object'
+      && typeof (entry as PushSubscriptionRecord).deviceId === 'string'
+      && typeof (entry as PushSubscriptionRecord).pushToken === 'string'
+      && (entry as PushSubscriptionRecord).platform === 'expo'
+      && typeof (entry as PushSubscriptionRecord).createdAt === 'string'
+      && typeof (entry as PushSubscriptionRecord).updatedAt === 'string'
+      && (
+        typeof (entry as PushSubscriptionRecord).lastSentAt === 'string'
+        || typeof (entry as PushSubscriptionRecord).lastSentAt === 'undefined'
+      )
+  );
+}
+
+function readRecords(pushSubscriptionsPath: string): PushSubscriptionRecord[] {
+  try {
+    const raw = readFileSync(pushSubscriptionsPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isPushSubscriptionRecord);
+  } catch {
+    return [];
+  }
+}
+
+function writeRecords(pushSubscriptionsPath: string, records: PushSubscriptionRecord[]): void {
+  mkdirSync(dirname(pushSubscriptionsPath), { recursive: true });
+  writeFileSync(pushSubscriptionsPath, JSON.stringify(records, null, 2) + '\n', 'utf8');
+}
+
+export class PushStore {
+  private records: PushSubscriptionRecord[];
+
+  constructor(private readonly pushSubscriptionsPath = PUSH_SUBSCRIPTIONS_PATH) {
+    this.records = readRecords(pushSubscriptionsPath);
+  }
+
+  list(): PushSubscriptionRecord[] {
+    return this.records.map((record) => ({ ...record }));
+  }
+
+  listTokens(): string[] {
+    return this.records.map((record) => record.pushToken);
+  }
+
+  count(): number {
+    return this.records.length;
+  }
+
+  register(deviceId: string, pushToken: string): void {
+    const now = new Date().toISOString();
+    const existingRecord = this.records.find((record) => record.deviceId === deviceId);
+    const nextRecord: PushSubscriptionRecord = {
+      deviceId,
+      pushToken,
+      platform: 'expo',
+      createdAt: existingRecord?.createdAt ?? now,
+      updatedAt: now,
+      ...(existingRecord?.lastSentAt ? { lastSentAt: existingRecord.lastSentAt } : {}),
+    };
+
+    this.records = [
+      nextRecord,
+      ...this.records.filter((record) => record.deviceId !== deviceId && record.pushToken !== pushToken),
+    ];
+
+    writeRecords(this.pushSubscriptionsPath, this.records);
+  }
+
+  unregister(deviceId: string, pushToken: string): boolean {
+    const nextRecords = this.records.filter(
+      (record) => !(record.deviceId === deviceId && record.pushToken === pushToken),
+    );
+    if (nextRecords.length === this.records.length) {
+      return false;
+    }
+    this.records = nextRecords;
+    writeRecords(this.pushSubscriptionsPath, this.records);
+    return true;
+  }
+
+  unregisterToken(pushToken: string): boolean {
+    const nextRecords = this.records.filter((record) => record.pushToken !== pushToken);
+    if (nextRecords.length === this.records.length) {
+      return false;
+    }
+    this.records = nextRecords;
+    writeRecords(this.pushSubscriptionsPath, this.records);
+    return true;
+  }
+
+  markSent(pushTokens: string[]): void {
+    if (pushTokens.length === 0) return;
+    const touched = new Set(pushTokens);
+    const now = new Date().toISOString();
+    let didChange = false;
+    for (const record of this.records) {
+      if (!touched.has(record.pushToken)) continue;
+      record.lastSentAt = now;
+      didChange = true;
+    }
+    if (didChange) {
+      writeRecords(this.pushSubscriptionsPath, this.records);
+    }
+  }
+
+  reset(): void {
+    this.records = [];
+    writeRecords(this.pushSubscriptionsPath, this.records);
+  }
+}

package/src/push.test.ts

@@ -0,0 +1,234 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  collectExpoPushReceiptResults,
+  collectSuccessfulExpoPushTokens,
+  createPushSender,
+  shouldRemoveTokenForExpoError,
+} from './push.js';
+import { PushStore } from './push-store.js';
+
+test('collectSuccessfulExpoPushTokens returns only ok tokens', () => {
+  const result = collectSuccessfulExpoPushTokens(
+    {
+      data: [
+        { status: 'ok', id: 'ticket-1' },
+        { status: 'error', message: 'bad token', details: { error: 'DeviceNotRegistered' } },
+        { status: 'ok', id: 'ticket-3' },
+      ],
+    },
+    ['ExponentPushToken[a]', 'ExponentPushToken[b]', 'ExponentPushToken[c]'],
+  );
+
+  assert.deepEqual(result.successfulTokens, ['ExponentPushToken[a]', 'ExponentPushToken[c]']);
+  assert.deepEqual(result.ticketErrors, [
+    {
+      token: 'ExponentPushToken[b]',
+      ticket: { status: 'error', message: 'bad token', details: { error: 'DeviceNotRegistered' } },
+    },
+  ]);
+});
+
+test('collectSuccessfulExpoPushTokens handles invalid credentials response', () => {
+  const result = collectSuccessfulExpoPushTokens(
+    {
+      data: [
+        {
+          status: 'error',
+          message: 'Could not find APNs credentials.',
+          details: { error: 'InvalidCredentials' },
+        },
+      ],
+    },
+    ['ExponentPushToken[a]'],
+  );
+
+  assert.deepEqual(result.successfulTokens, []);
+  assert.deepEqual(result.ticketErrors, [
+    {
+      token: 'ExponentPushToken[a]',
+      ticket: {
+        status: 'error',
+        message: 'Could not find APNs credentials.',
+        details: { error: 'InvalidCredentials' },
+      },
+    },
+  ]);
+});
+
+test('collectSuccessfulExpoPushTokens ignores unreadable payloads', () => {
+  const result = collectSuccessfulExpoPushTokens({}, ['ExponentPushToken[a]']);
+
+  assert.deepEqual(result.successfulTokens, []);
+  assert.deepEqual(result.ticketErrors, []);
+});
+
+test('collectExpoPushReceiptResults keeps unresolved ids and returns receipt errors', () => {
+  const result = collectExpoPushReceiptResults(
+    {
+      data: {
+        'ticket-live': { status: 'ok' },
+        'ticket-dead': { status: 'error', message: 'gone', details: { error: 'DeviceNotRegistered' } },
+      },
+    },
+    new Map([
+      ['ticket-live', 'ExponentPushToken[live]'],
+      ['ticket-dead', 'ExponentPushToken[dead]'],
+      ['ticket-pending', 'ExponentPushToken[pending]'],
+    ]),
+  );
+
+  assert.deepEqual(result.pendingTicketIds, ['ticket-pending']);
+  assert.deepEqual(result.receiptErrors, [
+    {
+      token: 'ExponentPushToken[dead]',
+      receipt: { status: 'error', message: 'gone', details: { error: 'DeviceNotRegistered' } },
+    },
+  ]);
+});
+
+test('shouldRemoveTokenForExpoError only removes unregistered devices', () => {
+  assert.equal(shouldRemoveTokenForExpoError('DeviceNotRegistered'), true);
+  assert.equal(shouldRemoveTokenForExpoError('InvalidCredentials'), false);
+  assert.equal(shouldRemoveTokenForExpoError(undefined), false);
+});
+
+test('sendPush removes DeviceNotRegistered tokens reported by receipts', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-dead', 'ExponentPushToken[dead]');
+    store.register('device-live', 'ExponentPushToken[live]');
+
+    const requests: Array<{ url: string; body?: string }> = [];
+    const sendPush = createPushSender({
+      pushStore: store,
+      sleepImpl: async () => {},
+      fetchImpl: async (url, init) => {
+        requests.push({ url, body: init?.body });
+        if (url.endsWith('/push/send')) {
+          return {
+            ok: true,
+            status: 200,
+            statusText: 'OK',
+            json: async () => ({
+              data: [
+                { status: 'ok', id: 'ticket-live' },
+                { status: 'ok', id: 'ticket-dead' },
+              ],
+            }),
+          };
+        }
+
+        return {
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          json: async () => ({
+            data: {
+              'ticket-live': { status: 'ok' },
+              'ticket-dead': {
+                status: 'error',
+                message: 'unregistered',
+                details: { error: 'DeviceNotRegistered' },
+              },
+            },
+          }),
+        };
+      },
+    });
+
+    await sendPush('Hello', 'World');
+
+    assert.equal(requests.length, 2);
+    assert.deepEqual(store.listTokens(), ['ExponentPushToken[live]']);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('sendPush removes DeviceNotRegistered tokens reported by send tickets', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-dead', 'ExponentPushToken[dead]');
+    store.register('device-live', 'ExponentPushToken[live]');
+
+    const sendPush = createPushSender({
+      pushStore: store,
+      sleepImpl: async () => {},
+      fetchImpl: async () => ({
+        ok: true,
+        status: 200,
+        statusText: 'OK',
+        json: async () => ({
+          data: [
+            { status: 'ok', id: 'ticket-live' },
+            {
+              status: 'error',
+              message: 'unregistered',
+              details: { error: 'DeviceNotRegistered' },
+            },
+          ],
+        }),
+      }),
+    });
+
+    await sendPush('Hello', 'World');
+
+    assert.deepEqual(store.listTokens(), ['ExponentPushToken[live]']);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('sendPush attaches approval categoryId for approval_request events', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'vibelet-push-'));
+  const pushSubscriptionsPath = join(dir, 'push-subscriptions.json');
+
+  try {
+    const store = new PushStore(pushSubscriptionsPath);
+    store.register('device-1', 'ExponentPushToken[live]');
+
+    const requests: Array<{ url: string; body?: string }> = [];
+    const sendPush = createPushSender({
+      pushStore: store,
+      sleepImpl: async () => {},
+      fetchImpl: async (url, init) => {
+        requests.push({ url, body: init?.body });
+        return {
+          ok: true,
+          status: 200,
+          statusText: 'OK',
+          json: async () => ({
+            data: [
+              { status: 'ok', id: 'ticket-live' },
+            ],
+          }),
+        };
+      },
+    });
+
+    await sendPush('Approval required', 'Inspect the build process', {
+      daemonId: 'daemon-1',
+      canonicalHost: 'daemon.local',
+      sessionId: 'session-1',
+      agent: 'codex',
+      eventType: 'approval_request',
+      requestId: 'req-1',
+    });
+
+    const payload = JSON.parse(requests[0]?.body ?? '[]');
+    assert.equal(payload.length, 1);
+    assert.equal(payload[0].categoryId, 'vibelet.approvalRequest.v1');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});