@vibelet/cli 0.1.38 → 1.0.0

package/src/push-store.test.ts

@@ -1,89 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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 });
-  }
-});