@serfab/cadre-host 0.7.1

package/src/auth/__tests__/trust-circle-integration.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { generatePrivateKey, getPublicKey } from '@optimystic/quereus-plugin-crypto';
+import { generateKeyPair } from '@libp2p/crypto/keys';
+import { peerIdFromPrivateKey } from '@libp2p/peer-id';
+import { CadreNode } from '@serfab/cadre-core';
+
+import { TrustCircleService } from '../trust-circle.js';
+import { TrustCircleStore } from '../trust-circle-store.js';
+
+/**
+ * End-to-end integration test: stand up a real host CadreNode with a real
+ * Quereus control DB and exercise the full TrustCircleService issue → redeem
+ * → list → remove cycle. The "phone" peerId is derived from a fresh Ed25519
+ * key (no second libp2p node) since the test only validates host-side state.
+ *
+ * This replaces the mock CadreNodeLike in trust-circle.test.ts with the real
+ * CadreNode to validate that:
+ *  - `acceptPhone` (called from redeemInvite with a sparse reconstructed
+ *    invite) actually inserts a CadrePeer row;
+ *  - `list()` picks up the new peer via the canonical CadrePeer query;
+ *  - `removeMember` deletes the row from CadrePeer via the
+ *    DELETE-with-context syntax that cadre-core trusts from
+ *    `quereus/docs/sql.md`.
+ */
+describe('TrustCircleService — real CadreNode integration', () => {
+  let tmpRoot: string;
+  let host: CadreNode;
+  let store: TrustCircleStore;
+  let service: TrustCircleService;
+  let hostAuthorityPrivateKey: string;
+  let hostAuthorityPublicKey: string;
+
+  beforeEach(async () => {
+    tmpRoot = mkdtempSync(join(tmpdir(), 'cadre-host-tc-int-'));
+
+    hostAuthorityPrivateKey = generatePrivateKey('ed25519', 'base64url') as string;
+    hostAuthorityPublicKey = getPublicKey(
+      hostAuthorityPrivateKey,
+      'ed25519',
+      'base64url',
+      'base64url'
+    ) as string;
+
+    const baseId = Math.random().toString(36).slice(2);
+
+    host = new CadreNode({
+      controlNetwork: { partyId: `host-${baseId}`, bootstrapNodes: [] },
+      profile: 'transaction'
+    });
+
+    await host.start();
+
+    const db = host.getControlDatabase();
+    expect(db).not.toBeNull();
+    await db!.insertAuthorityKey(hostAuthorityPublicKey);
+
+    host.initializeSeedBootstrap(hostAuthorityPrivateKey);
+
+    store = new TrustCircleStore(tmpRoot);
+    service = new TrustCircleService({ cadreNode: host, store });
+  }, 60_000);
+
+  afterEach(async () => {
+    try { await host.stop(); } catch { /* ignore */ }
+    try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('completes the full issue → redeem → list → remove cycle', async () => {
+    // Derive a shape-valid peerId from a fresh Ed25519 key — same pattern as
+    // packages/cadre-core/test/seed-bootstrap.spec.ts. The AuthorizedInsert
+    // constraint only checks the signature over digest(PeerId,…); peerId
+    // *liveness* doesn't matter for the host-side CRUD path under test.
+    const phoneKey = await generateKeyPair('Ed25519');
+    const phonePeerId = peerIdFromPrivateKey(phoneKey).toString();
+
+    // Issue
+    const issued = await service.issueInvite({ label: "Mom's phone" });
+    expect(issued.token).toBeTruthy();
+    expect(issued.encodedInvite).toBeTruthy();
+
+    // Redeem — this calls host.acceptPhone() with the sparse reconstructed
+    // invite, which in turn calls authorizePeer and inserts CadrePeer.
+    const redeemed = await service.redeemInvite({
+      token: issued.token,
+      peerId: phonePeerId
+    });
+    expect(redeemed).toEqual({ peerId: phonePeerId, label: "Mom's phone" });
+
+    // Verify directly against the control DB: the row is there.
+    expect(await isInCadrePeer(host, phonePeerId)).toBe(true);
+
+    // List — should see the peer once, labelled.
+    const snap = await service.list();
+    expect(snap.members).toHaveLength(1);
+    expect(snap.members[0]!.peerId).toBe(phonePeerId);
+    expect(snap.members[0]!.label).toBe("Mom's phone");
+    expect(snap.pending).toHaveLength(0);
+
+    // Remove
+    await service.removeMember(phonePeerId);
+
+    // CadrePeer row is gone (validates DELETE-with-context end-to-end).
+    expect(await isInCadrePeer(host, phonePeerId)).toBe(false);
+
+    // Local label is gone.
+    expect(store.getMember(phonePeerId)).toBeUndefined();
+
+    // list() reflects the removal.
+    const afterRemove = await service.list();
+    expect(afterRemove.members).toHaveLength(0);
+  }, 90_000);
+});
+
+async function isInCadrePeer(node: CadreNode, peerId: string): Promise<boolean> {
+  const db = node.getControlDatabase();
+  if (!db) return false;
+  const inner = db.getDatabase();
+  for await (const row of inner.eval(
+    'select PeerId from CadreControl.CadrePeer where PeerId = ?',
+    [peerId]
+  )) {
+    if (row.PeerId === peerId) return true;
+  }
+  return false;
+}

package/src/auth/__tests__/trust-circle-store.test.ts

@@ -0,0 +1,115 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import { TrustCircleStore } from '../trust-circle-store.js';
+import { TrustCircleError } from '../types.js';
+
+let tmpRoot: string;
+
+beforeEach(() => {
+  tmpRoot = mkdtempSync(join(tmpdir(), 'cadre-host-tc-store-'));
+});
+
+afterEach(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe('TrustCircleStore', () => {
+  it('returns empty state when file is missing', () => {
+    const store = new TrustCircleStore(tmpRoot);
+    expect(store.listMembers()).toEqual([]);
+    expect(store.listPending()).toEqual([]);
+  });
+
+  it('round-trips members through save/load', () => {
+    const store = new TrustCircleStore(tmpRoot);
+    store.addMember({
+      peerId: '12D3KooWAlice',
+      label: "Alice's phone",
+      addedAt: '2025-01-01T00:00:00.000Z',
+    });
+    store.addMember({
+      peerId: '12D3KooWBob',
+      label: 'Bob laptop',
+      addedAt: '2025-01-02T00:00:00.000Z',
+      self: true,
+    });
+
+    // Fresh instance reads from disk.
+    const reread = new TrustCircleStore(tmpRoot);
+    const members = reread.listMembers();
+    expect(members).toHaveLength(2);
+    expect(reread.getMember('12D3KooWAlice')).toMatchObject({ label: "Alice's phone" });
+    expect(reread.getMember('12D3KooWBob')?.self).toBe(true);
+  });
+
+  it('round-trips pending invites', () => {
+    const store = new TrustCircleStore(tmpRoot);
+    store.addPending({
+      token: 'token-A',
+      label: 'Mom',
+      createdAt: '2025-01-01T00:00:00.000Z',
+      expiresAt: '2025-01-02T00:00:00.000Z',
+    });
+    store.addPending({
+      token: 'token-B',
+      label: 'Dad',
+      createdAt: '2025-01-02T00:00:00.000Z',
+    });
+
+    const reread = new TrustCircleStore(tmpRoot);
+    expect(reread.listPending()).toHaveLength(2);
+    expect(reread.getPending('token-A')?.label).toBe('Mom');
+    expect(reread.getPending('token-B')?.expiresAt).toBeUndefined();
+  });
+
+  it('removes members and pending invites', () => {
+    const store = new TrustCircleStore(tmpRoot);
+    store.addMember({ peerId: 'p1', label: 'one', addedAt: 't' });
+    store.addPending({ token: 'tok', label: 'two', createdAt: 't' });
+
+    expect(store.removeMember('p1')).toBe(true);
+    expect(store.removeMember('p1')).toBe(false);
+    expect(store.removePending('tok')).toBe(true);
+    expect(store.removePending('tok')).toBe(false);
+
+    const reread = new TrustCircleStore(tmpRoot);
+    expect(reread.listMembers()).toEqual([]);
+    expect(reread.listPending()).toEqual([]);
+  });
+
+  it('writes through a temp file (atomic rename)', () => {
+    const store = new TrustCircleStore(tmpRoot);
+    store.addMember({ peerId: 'p1', label: 'one', addedAt: 't' });
+
+    // After save, no .tmp residue should remain.
+    expect(existsSync(join(tmpRoot, 'trust-circle.json'))).toBe(true);
+    expect(existsSync(join(tmpRoot, 'trust-circle.json.tmp'))).toBe(false);
+  });
+
+  it('throws on malformed file rather than silently wiping', () => {
+    writeFileSync(join(tmpRoot, 'trust-circle.json'), 'not json', 'utf8');
+    const store = new TrustCircleStore(tmpRoot);
+    expect(() => store.load()).toThrow(TrustCircleError);
+  });
+
+  it('throws on file with wrong shape', () => {
+    writeFileSync(
+      join(tmpRoot, 'trust-circle.json'),
+      JSON.stringify({ version: 99, foo: 'bar' }),
+      'utf8',
+    );
+    const store = new TrustCircleStore(tmpRoot);
+    expect(() => store.load()).toThrow(TrustCircleError);
+  });
+
+  it('persists version field in saved JSON', () => {
+    const store = new TrustCircleStore(tmpRoot);
+    store.addMember({ peerId: 'p1', label: 'one', addedAt: 't' });
+    const raw = JSON.parse(readFileSync(join(tmpRoot, 'trust-circle.json'), 'utf8'));
+    expect(raw.version).toBe(1);
+    expect(raw.members.p1.label).toBe('one');
+  });
+});

package/src/auth/__tests__/trust-circle.test.ts

@@ -0,0 +1,334 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+import type { CadreInvite } from '@serfab/cadre-core';
+
+import { TrustCircleService, createTrustCircleHandlers } from '../trust-circle.js';
+import { TrustCircleStore } from '../trust-circle-store.js';
+import { TrustCircleError } from '../types.js';
+import type { CadreNodeLike } from '../trust-circle.js';
+
+/**
+ * Minimal in-memory mock of CadreNode + ControlDatabase. Records calls so
+ * assertions can verify the auth + redemption flow without standing up a
+ * real libp2p control network.
+ */
+class MockCadreNode implements CadreNodeLike {
+  readonly authorizedPeers = new Set<string>();
+  readonly issuedInvites: Array<{ token?: string; expiresIn?: number }> = [];
+  readonly accepted: Array<{ phonePeerId: string; token?: string }> = [];
+  readonly removed: string[] = [];
+
+  /** Toggle to make acceptPhone reject. */
+  acceptShouldThrow: Error | null = null;
+  /** Toggle to make getControlDatabase return null (simulate offline). */
+  dbAvailable = true;
+
+  async createInvite(token?: string, expiresIn?: number) {
+    this.issuedInvites.push({ token, expiresIn });
+    const invite: CadreInvite = {
+      partyId: 'party-test',
+      authorityAddrs: ['/ip4/127.0.0.1/tcp/4001'],
+      token,
+      createdAt: Date.now(),
+      ...(expiresIn ? { expiresAt: Date.now() + expiresIn } : {}),
+    };
+    return { invite, encodedInvite: 'enc:' + JSON.stringify(invite) };
+  }
+
+  async acceptPhone(options: { phonePeerId: string; token?: string }, _issuedInvite?: CadreInvite) {
+    if (this.acceptShouldThrow) throw this.acceptShouldThrow;
+    this.accepted.push({ ...options });
+    this.authorizedPeers.add(options.phonePeerId);
+  }
+
+  async removePeer(peerId: string) {
+    this.removed.push(peerId);
+    this.authorizedPeers.delete(peerId);
+  }
+
+  encodeInvite(invite: CadreInvite): string {
+    return 'enc:' + JSON.stringify(invite);
+  }
+
+  getControlDatabase() {
+    if (!this.dbAvailable) return null;
+    const peers = this.authorizedPeers;
+    return {
+      getDatabase: () => ({
+        async *eval(_sql: string, params?: unknown[]) {
+          if (params && params.length > 0) {
+            const target = params[0] as string;
+            if (peers.has(target)) yield { PeerId: target };
+            return;
+          }
+          for (const p of peers) yield { PeerId: p };
+        },
+      }),
+    } as unknown as ReturnType<CadreNodeLike['getControlDatabase']>;
+  }
+}
+
+let tmpRoot: string;
+let cadreNode: MockCadreNode;
+let store: TrustCircleStore;
+let service: TrustCircleService;
+
+beforeEach(() => {
+  tmpRoot = mkdtempSync(join(tmpdir(), 'cadre-host-tc-svc-'));
+  cadreNode = new MockCadreNode();
+  store = new TrustCircleStore(tmpRoot);
+  service = new TrustCircleService({ cadreNode, store });
+});
+
+afterEach(() => {
+  try { rmSync(tmpRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+describe('TrustCircleService.issueInvite', () => {
+  it('creates a pending row, returns an encoded invite, and uses default TTL', async () => {
+    const result = await service.issueInvite({ label: "Mom's phone" });
+
+    expect(result.token).toBeTruthy();
+    expect(result.encodedInvite.startsWith('enc:')).toBe(true);
+    expect(result.expiresAt).toBeInstanceOf(Date);
+
+    const pending = store.getPending(result.token);
+    expect(pending).toBeDefined();
+    expect(pending!.label).toBe("Mom's phone");
+    expect(pending!.expiresAt).toBe(result.expiresAt!.toISOString());
+
+    expect(cadreNode.issuedInvites).toHaveLength(1);
+    expect(cadreNode.issuedInvites[0]!.token).toBe(result.token);
+  });
+
+  it('rejects empty / whitespace labels', async () => {
+    await expect(service.issueInvite({ label: '   ' })).rejects.toBeInstanceOf(TrustCircleError);
+    await expect(service.issueInvite({ label: '' })).rejects.toBeInstanceOf(TrustCircleError);
+  });
+
+  it('honours custom ttl', async () => {
+    const start = Date.now();
+    const ttlMs = 5 * 60 * 1000;
+    const result = await service.issueInvite({ label: 'Carol', ttlMs });
+    const expiresMs = result.expiresAt!.getTime();
+    expect(expiresMs - start).toBeGreaterThanOrEqual(ttlMs - 50);
+    expect(expiresMs - start).toBeLessThanOrEqual(ttlMs + 500);
+  });
+
+  it('rejects non-positive ttl', async () => {
+    await expect(service.issueInvite({ label: 'X', ttlMs: 0 })).rejects.toBeInstanceOf(TrustCircleError);
+    await expect(service.issueInvite({ label: 'X', ttlMs: -1 })).rejects.toBeInstanceOf(TrustCircleError);
+  });
+});
+
+describe('TrustCircleService.redeemInvite', () => {
+  it('happy path: authorises peer, consumes pending, writes member', async () => {
+    const { token } = await service.issueInvite({ label: "Mom's phone" });
+
+    const result = await service.redeemInvite({ token, peerId: '12D3KooWMom' });
+    expect(result).toEqual({ peerId: '12D3KooWMom', label: "Mom's phone" });
+
+    expect(cadreNode.accepted).toHaveLength(1);
+    expect(cadreNode.accepted[0]).toMatchObject({ phonePeerId: '12D3KooWMom', token });
+    expect(cadreNode.authorizedPeers.has('12D3KooWMom')).toBe(true);
+
+    expect(store.getPending(token)).toBeUndefined();
+    expect(store.getMember('12D3KooWMom')?.label).toBe("Mom's phone");
+  });
+
+  it('rejects unknown token', async () => {
+    await expect(service.redeemInvite({ token: 'nope', peerId: 'p1' }))
+      .rejects.toMatchObject({ code: 'already_redeemed' });
+    expect(cadreNode.accepted).toHaveLength(0);
+  });
+
+  it('rejects expired invite and reaps the pending row', async () => {
+    let clock = new Date('2025-01-01T00:00:00Z');
+    const svc = new TrustCircleService({ cadreNode, store, now: () => clock });
+    const { token } = await svc.issueInvite({ label: 'Dad', ttlMs: 60_000 });
+
+    // Move clock past expiry.
+    clock = new Date('2025-01-02T00:00:00Z');
+
+    await expect(svc.redeemInvite({ token, peerId: 'p1' }))
+      .rejects.toMatchObject({ code: 'expired' });
+    expect(store.getPending(token)).toBeUndefined();
+    expect(cadreNode.accepted).toHaveLength(0);
+  });
+
+  it('double-redeem: second attempt is rejected because pending was consumed', async () => {
+    const { token } = await service.issueInvite({ label: 'Carol' });
+
+    await service.redeemInvite({ token, peerId: 'pA' });
+    await expect(service.redeemInvite({ token, peerId: 'pB' }))
+      .rejects.toMatchObject({ code: 'already_redeemed' });
+
+    // The second attempt must NOT have authorised pB.
+    expect(cadreNode.authorizedPeers.has('pB')).toBe(false);
+  });
+
+  it('requires both token and peerId', async () => {
+    await expect(service.redeemInvite({ token: '', peerId: 'p1' }))
+      .rejects.toBeInstanceOf(TrustCircleError);
+    await expect(service.redeemInvite({ token: 't', peerId: '' }))
+      .rejects.toBeInstanceOf(TrustCircleError);
+  });
+
+  it('claims pending atomically so a concurrent second call cannot also redeem', async () => {
+    const { token } = await service.issueInvite({ label: 'Race' });
+
+    // Block acceptPhone until we release it, simulating the async window
+    // between getPending() and removePending() under naive ordering.
+    let release!: () => void;
+    const gate = new Promise<void>((r) => { release = r; });
+    const originalAccept = cadreNode.acceptPhone.bind(cadreNode);
+    cadreNode.acceptPhone = async (options, issued) => {
+      await gate;
+      await originalAccept(options, issued);
+    };
+
+    const first = service.redeemInvite({ token, peerId: 'pA' });
+    const second = service.redeemInvite({ token, peerId: 'pB' });
+
+    // The second call must be rejected synchronously (before the gate opens)
+    // because the pending row was already claimed by `first`.
+    await expect(second).rejects.toMatchObject({ code: 'already_redeemed' });
+
+    release();
+    await expect(first).resolves.toMatchObject({ peerId: 'pA' });
+
+    // Only one peer was authorized.
+    expect(cadreNode.authorizedPeers.has('pA')).toBe(true);
+    expect(cadreNode.authorizedPeers.has('pB')).toBe(false);
+  });
+});
+
+describe('TrustCircleService.issueInvite — label length', () => {
+  it('rejects labels over 200 characters', async () => {
+    await expect(service.issueInvite({ label: 'a'.repeat(201) }))
+      .rejects.toMatchObject({ code: 'invalid_label' });
+  });
+
+  it('accepts labels at the 200-character limit', async () => {
+    await expect(service.issueInvite({ label: 'a'.repeat(200) }))
+      .resolves.toBeDefined();
+  });
+});
+
+describe('TrustCircleService.revokePending', () => {
+  it('removes a pending row and prevents subsequent redemption', async () => {
+    const { token } = await service.issueInvite({ label: 'Eve' });
+    await service.revokePending(token);
+    expect(store.getPending(token)).toBeUndefined();
+
+    await expect(service.redeemInvite({ token, peerId: 'p1' }))
+      .rejects.toMatchObject({ code: 'already_redeemed' });
+  });
+
+  it('throws not_found for an unknown token', async () => {
+    await expect(service.revokePending('nope'))
+      .rejects.toMatchObject({ code: 'not_found' });
+  });
+});
+
+describe('TrustCircleService.removeMember', () => {
+  it('removes from CadrePeer and the local label store', async () => {
+    const { token } = await service.issueInvite({ label: 'Frank' });
+    await service.redeemInvite({ token, peerId: 'pF' });
+
+    await service.removeMember('pF');
+    expect(cadreNode.removed).toEqual(['pF']);
+    expect(cadreNode.authorizedPeers.has('pF')).toBe(false);
+    expect(store.getMember('pF')).toBeUndefined();
+  });
+
+  it('throws not_found for an unknown peer', async () => {
+    await expect(service.removeMember('unknown'))
+      .rejects.toMatchObject({ code: 'not_found' });
+  });
+
+  it('removes a control-only peer (CadrePeer row without a local label)', async () => {
+    cadreNode.authorizedPeers.add('pCtrlOnly');
+    expect(store.getMember('pCtrlOnly')).toBeUndefined();
+
+    await service.removeMember('pCtrlOnly');
+    expect(cadreNode.removed).toEqual(['pCtrlOnly']);
+    expect(cadreNode.authorizedPeers.has('pCtrlOnly')).toBe(false);
+  });
+});
+
+describe('TrustCircleService.isMember', () => {
+  it('reads from the CadrePeer table', async () => {
+    expect(await service.isMember('pX')).toBe(false);
+    cadreNode.authorizedPeers.add('pX');
+    expect(await service.isMember('pX')).toBe(true);
+  });
+});
+
+describe('TrustCircleService.list', () => {
+  it('joins CadrePeer with local labels and prunes orphan labels', async () => {
+    // Pre-seed a label whose peer is NOT in CadrePeer — should be pruned.
+    store.addMember({ peerId: 'orphan', label: 'ghost', addedAt: 't' });
+
+    const r1 = await service.issueInvite({ label: 'Alice' });
+    await service.redeemInvite({ token: r1.token, peerId: 'pA' });
+    const r2 = await service.issueInvite({ label: 'Bob' });
+    await service.redeemInvite({ token: r2.token, peerId: 'pB' });
+    // A still-pending invite that should appear in `pending`.
+    const r3 = await service.issueInvite({ label: 'Carol' });
+
+    const snap = await service.list();
+
+    expect(snap.members.map(m => m.peerId).sort()).toEqual(['pA', 'pB']);
+    expect(snap.members.find(m => m.peerId === 'pA')?.label).toBe('Alice');
+    expect(snap.members.find(m => m.peerId === 'pB')?.label).toBe('Bob');
+    expect(snap.pending.map(p => p.token)).toContain(r3.token);
+
+    expect(store.getMember('orphan')).toBeUndefined();
+  });
+
+  it('falls back to local labels when control DB is unavailable', async () => {
+    store.addMember({ peerId: 'pZ', label: 'Zoe', addedAt: 't' });
+    cadreNode.dbAvailable = false;
+
+    const snap = await service.list();
+    expect(snap.members.some(m => m.peerId === 'pZ' && m.label === 'Zoe')).toBe(true);
+    // Orphan check is skipped when DB is unavailable.
+    expect(store.getMember('pZ')).toBeDefined();
+  });
+
+  it('shows unlabelled CadrePeer rows with peerId as label', async () => {
+    cadreNode.authorizedPeers.add('unlabeled-peer');
+    const snap = await service.list();
+    const entry = snap.members.find(m => m.peerId === 'unlabeled-peer');
+    expect(entry?.label).toBe('unlabeled-peer');
+  });
+});
+
+describe('createTrustCircleHandlers', () => {
+  it('exposes the HTTP-handler surface', async () => {
+    const handlers = createTrustCircleHandlers(service);
+
+    const issued = await handlers.postInvite({ label: 'Pat' });
+    expect(issued.encodedInvite.startsWith('enc:')).toBe(true);
+    expect(typeof issued.token).toBe('string');
+    expect(issued.expiresAt).toBeTruthy();
+
+    let snap = await handlers.listTrustCircle();
+    expect(snap.pending.map(p => p.token)).toContain(issued.token);
+    expect(snap.members).toEqual([]);
+
+    await handlers.deleteInvite(issued.token);
+    snap = await handlers.listTrustCircle();
+    expect(snap.pending).toEqual([]);
+  });
+
+  it('postInvite rejects missing label', async () => {
+    const handlers = createTrustCircleHandlers(service);
+    await expect(handlers.postInvite({ label: undefined as unknown as string }))
+      .rejects.toMatchObject({ code: 'invalid_label' });
+  });
+});

package/src/auth/duration.ts

@@ -0,0 +1,33 @@
+/**
+ * Tiny duration parser for invite TTLs.
+ *
+ * Accepts a single value+unit token: `30s`, `5m`, `24h`, `7d`, `2w`.
+ * Whitespace is allowed around it. Bare numbers are treated as milliseconds.
+ *
+ * Returns the duration in milliseconds. Throws on unparseable input.
+ */
+const UNIT_MULTIPLIERS: Record<string, number> = {
+  ms: 1,
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000,
+  w: 7 * 24 * 60 * 60 * 1000,
+};
+
+const DURATION_RE = /^(\d+(?:\.\d+)?)\s*(ms|s|m|h|d|w)?$/;
+
+export function parseDuration(input: string): number {
+  const trimmed = input.trim();
+  const match = DURATION_RE.exec(trimmed);
+  if (!match) {
+    throw new Error(`Invalid duration: ${JSON.stringify(input)} (expected e.g. "24h", "7d", "30m")`);
+  }
+  const value = parseFloat(match[1]!);
+  const unit = match[2] ?? 'ms';
+  const multiplier = UNIT_MULTIPLIERS[unit];
+  if (multiplier === undefined) {
+    throw new Error(`Unknown duration unit: ${unit}`);
+  }
+  return Math.round(value * multiplier);
+}

package/src/auth/index.ts

@@ -0,0 +1,19 @@
+/**
+ * Trust-circle auth for cadre-host. See ./trust-circle.ts and ./types.ts.
+ */
+
+export { TrustCircleService, createTrustCircleHandlers, DEFAULT_INVITE_TTL_MS } from './trust-circle.js';
+export type { TrustCircleServiceOptions, CadreNodeLike } from './trust-circle.js';
+export { TrustCircleStore } from './trust-circle-store.js';
+export { parseDuration } from './duration.js';
+export {
+  TrustCircleError,
+} from './types.js';
+export type {
+  TrustCircleMember,
+  PendingInvite,
+  TrustCircleFile,
+  TrustCircleSnapshot,
+  TrustCircleHandlers,
+  TrustCircleErrorCode,
+} from './types.js';