Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

14.8 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import {
  AUDIT_EVENT_RETENTION_MS,
  hashCredential,
  CONFIRM_RESULT_RETENTION_MS,
  RelayCredentialStore,
  type RelayIdentity
} from './credential-store.js'
import { openInMemoryRelayDatabase, type RelayDatabase } from './database.js'

const identity: RelayIdentity = { userId: 'user-1', relayHostId: 'abcdefghijklmnop' }
const DAY_MS = 24 * 60 * 60 * 1000
const NOW = 100 * DAY_MS

async function insertInvite(
  database: RelayDatabase,
  invite: { token: string; state: string; updatedAt: number; expiresAt?: number }
): Promise<void> {
  await database.query(
    `INSERT INTO relay_invites
     (user_id, relay_host_id, relay_device_id, token_hash, state, attempt_count,
      max_attempts, expires_at, created_at, updated_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
    [
      identity.userId,
      identity.relayHostId,
      `device-${invite.token}`,
      invite.token,
      invite.state,
      0,
      3,
      invite.expiresAt ?? NOW + DAY_MS,
      invite.updatedAt,
      invite.updatedAt
    ]
  )
}

async function remainingTokens(database: RelayDatabase): Promise<string[]> {
  const rows = await database.query(`SELECT token_hash FROM relay_invites ORDER BY token_hash`)
  return rows.map((row) => String(row.token_hash))
}

async function insertBasis(
  database: RelayDatabase,
  basis: { id: string; active: number; deadline: number }
): Promise<void> {
  await database.query(
    `INSERT INTO relay_connection_bases
     (basis_conn_id, user_id, relay_host_id, relay_device_id, owning_control_generation,
      credential_kind, deadline, active, created_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
    [
      basis.id,
      identity.userId,
      identity.relayHostId,
      'device-1',
      1,
      'invite',
      basis.deadline,
      basis.active,
      NOW
    ]
  )
}

async function insertDirectAuthorization(
  database: RelayDatabase,
  auth: { id: string; deadline: number; consumedAt: number | null }
): Promise<void> {
  await database.query(
    `INSERT INTO relay_direct_authorizations
     (direct_auth_id, user_id, relay_host_id, relay_device_id, owning_control_generation,
      deadline, consumed_at)
     VALUES (?, ?, ?, ?, ?, ?, ?)`,
    [auth.id, identity.userId, identity.relayHostId, 'device-1', 1, auth.deadline, auth.consumedAt]
  )
}

async function insertConfirmResult(
  database: RelayDatabase,
  result: { reqId: string; committedAt: number }
): Promise<void> {
  await database.query(
    `INSERT INTO relay_confirm_results
     (user_id, relay_host_id, req_id, basis_conn_id, tuple_json, result_json, committed_at)
     VALUES (?, ?, ?, 'basis-1', '{}', '{}', ?)`,
    [identity.userId, identity.relayHostId, result.reqId, result.committedAt]
  )
}

async function insertAuditEvent(
  database: RelayDatabase,
  event: { id: string; at: number }
): Promise<void> {
  await database.query(
    `INSERT INTO relay_audit_events (id, at, type, user_id, relay_host_id, detail_json)
     VALUES (?, ?, 'resume-confirmed', ?, ?, '{}')`,
    [event.id, event.at, identity.userId, identity.relayHostId]
  )
}

async function remainingIds(database: RelayDatabase, table: string, column: string): Promise<string[]> {
  const rows = await database.query(`SELECT ${column} FROM ${table} ORDER BY ${column}`)
  return rows.map((row) => String(row[column]))
}

describe('credential cleanup invite reaper', () => {
  it('deletes terminal invites past retention and keeps everything else', async () => {
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    const stale = NOW - 8 * DAY_MS
    const recent = NOW - 6 * DAY_MS
    for (const state of ['expired', 'consumed', 'invalidated']) {
      await insertInvite(database, { token: `stale-${state}`, state, updatedAt: stale })
      await insertInvite(database, { token: `recent-${state}`, state, updatedAt: recent })
    }

    await store.cleanup()

    expect(await remainingTokens(database)).toEqual([
      'recent-consumed',
      'recent-expired',
      'recent-invalidated'
    ])
    await database.close()
  })

  it('never deletes an invite that a reader could still consume, however old', async () => {
    // Old updated_at does not settle a live invite; state guard must prevent reaping it.
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    const ancient = NOW - 400 * DAY_MS
    for (const state of ['available', 'reserved', 'cooldown']) {
      await insertInvite(database, {
        token: `live-${state}`,
        state,
        updatedAt: ancient,
        expiresAt: NOW + DAY_MS
      })
    }

    await store.cleanup()

    expect(await remainingTokens(database)).toEqual(['live-available', 'live-cooldown', 'live-reserved'])
    await database.close()
  })

  it('bounds one cycle to a single batch and drains the rest on later cycles', async () => {
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    const stale = NOW - 30 * DAY_MS
    for (let index = 0; index < 5_002; index += 1) {
      await insertInvite(database, {
        token: `consumed-${String(index).padStart(5, '0')}`,
        state: 'consumed',
        updatedAt: stale
      })
    }

    await store.cleanup()
    expect(await remainingTokens(database)).toHaveLength(2)

    await store.cleanup()
    expect(await remainingTokens(database)).toEqual([])
    await database.close()
  })

  it('still expires credentials the sweep owns, and only those past their deadline', async () => {
    // Reaper follows sweep; ensure all five prior transitions still run.
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    await insertInvite(database, {
      token: 'lapsed',
      state: 'available',
      updatedAt: NOW,
      expiresAt: NOW - 1
    })
    await insertInvite(database, {
      token: 'current',
      state: 'available',
      updatedAt: NOW,
      expiresAt: NOW + DAY_MS
    })
    await database.query(
      `UPDATE relay_invites SET state = ?, reservation_expires_at = ? WHERE token_hash = ?`,
      ['reserved', NOW - 1, 'current']
    )
    await database.query(
      `INSERT INTO relay_connection_bases
       (basis_conn_id, user_id, relay_host_id, relay_device_id, owning_control_generation,
        credential_kind, deadline, active, created_at)
       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?), (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
      [
        'basis-lapsed', identity.userId, identity.relayHostId, 'device-1', 1, 'invite', NOW - 1, 1, NOW,
        'basis-live', identity.userId, identity.relayHostId, 'device-1', 1, 'invite', NOW + 1, 1, NOW
      ]
    )
    await store.recordDirectAuthorization({
      ...identity,
      relayDeviceId: 'device-1',
      directAuthId: 'direct-lapsed',
      owningControlGeneration: 1,
      deadline: NOW - 1
    })
    await store.recordDirectAuthorization({
      ...identity,
      relayDeviceId: 'device-1',
      directAuthId: 'direct-live',
      owningControlGeneration: 1,
      deadline: NOW + 1
    })
    await database.query(
      `INSERT INTO relay_rate_windows (scope_key, window_kind, window_started_at, count)
       VALUES (?, ?, ?, ?), (?, ?, ?, ?)`,
      ['scope', 'invite-mint', NOW - 2 * DAY_MS, 1, 'scope', 'invite-mint', NOW - 1, 1]
    )

    await store.cleanup()

    expect(
      await database.query(`SELECT token_hash, state FROM relay_invites ORDER BY token_hash`)
    ).toEqual([
      { token_hash: 'current', state: 'cooldown' },
      { token_hash: 'lapsed', state: 'expired' }
    ])
    expect(
      await database.query(`SELECT basis_conn_id, active FROM relay_connection_bases ORDER BY basis_conn_id`)
    ).toEqual([
      { basis_conn_id: 'basis-lapsed', active: 0 },
      { basis_conn_id: 'basis-live', active: 1 }
    ])
    expect(
      await database.query(
        `SELECT direct_auth_id FROM relay_direct_authorizations
         WHERE consumed_at IS NULL ORDER BY direct_auth_id`
      )
    ).toEqual([{ direct_auth_id: 'direct-live' }])
    expect(await database.query(`SELECT window_started_at FROM relay_rate_windows`)).toEqual([
      { window_started_at: NOW - 1 }
    ])
    await database.close()
  })

  it('reaps connection bases whose deadline passed over a day ago, and nothing else', async () => {
    // Passed deadlines make bases unusable regardless of active flag; active=0 provides an index range, not deletion safety.
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    await insertBasis(database, { id: 'stale-inactive', active: 0, deadline: NOW - 2 * DAY_MS })
    await insertBasis(database, { id: 'recent-inactive', active: 0, deadline: NOW - 60_000 })
    // Sweep deactivates this long-lived splice and reaps it immediately; no reader accepts its already-expired basis.
    await insertBasis(database, { id: 'stale-active', active: 1, deadline: NOW - 400 * DAY_MS })
    await insertBasis(database, { id: 'live-active', active: 1, deadline: NOW + DAY_MS })

    await store.cleanup()

    expect(await remainingIds(database, 'relay_connection_bases', 'basis_conn_id')).toEqual([
      'live-active',
      'recent-inactive'
    ])
    // The one row a reader can still use is untouched, active flag included.
    expect(
      await database.query(
        `SELECT active FROM relay_connection_bases WHERE basis_conn_id = 'live-active'`
      )
    ).toEqual([{ active: 1 }])
    await database.close()
  })

  it('reaps consumed direct authorizations past retention and never a pending one', async () => {
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    await insertDirectAuthorization(database, {
      id: 'stale-consumed',
      deadline: NOW - 2 * DAY_MS,
      consumedAt: NOW - 2 * DAY_MS
    })
    await insertDirectAuthorization(database, {
      id: 'recent-consumed',
      deadline: NOW - 60_000,
      consumedAt: NOW - 60_000
    })
    await insertDirectAuthorization(database, {
      id: 'pending-ancient',
      deadline: NOW + DAY_MS,
      consumedAt: null
    })

    await store.cleanup()

    expect(await remainingIds(database, 'relay_direct_authorizations', 'direct_auth_id')).toEqual([
      'pending-ancient',
      'recent-consumed'
    ])
    await database.close()
  })

  it('bounds each table to one batch per cycle', async () => {
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    for (let index = 0; index < 5_001; index += 1) {
      const id = String(index).padStart(5, '0')
      await insertBasis(database, { id: `basis-${id}`, active: 0, deadline: NOW - 2 * DAY_MS })
      await insertDirectAuthorization(database, {
        id: `auth-${id}`,
        deadline: NOW - 2 * DAY_MS,
        consumedAt: NOW - 2 * DAY_MS
      })
    }

    await store.cleanup()
    expect(await remainingIds(database, 'relay_connection_bases', 'basis_conn_id')).toHaveLength(1)
    expect(await remainingIds(database, 'relay_direct_authorizations', 'direct_auth_id')).toHaveLength(1)

    await store.cleanup()
    expect(await remainingIds(database, 'relay_connection_bases', 'basis_conn_id')).toEqual([])
    expect(await remainingIds(database, 'relay_direct_authorizations', 'direct_auth_id')).toEqual([])
    await database.close()
  })

  it('skips drained invite and authorization reaps until the pause ends', async () => {
    const database = await openInMemoryRelayDatabase()
    let now = NOW
    const store = new RelayCredentialStore(database, () => now)
    await store.cleanup()
    await insertInvite(database, { token: 'stale', state: 'consumed', updatedAt: NOW - 8 * DAY_MS })
    await insertDirectAuthorization(database, { id: 'stale', deadline: NOW, consumedAt: NOW - 2 * DAY_MS })

    now = NOW + 60_000
    await store.cleanup()
    expect(await remainingTokens(database)).toEqual(['stale'])
    expect(await remainingIds(database, 'relay_direct_authorizations', 'direct_auth_id')).toEqual(['stale'])

    now = NOW + 6 * 60_000
    await store.cleanup()
    expect(await remainingTokens(database)).toEqual([])
    expect(await remainingIds(database, 'relay_direct_authorizations', 'direct_auth_id')).toEqual([])
    await database.close()
  })

  it('reaps confirm results and audit events only past their retention windows', async () => {
    const database = await openInMemoryRelayDatabase()
    const store = new RelayCredentialStore(database, () => NOW)
    await insertConfirmResult(database, { reqId: 'confirm-old', committedAt: NOW - CONFIRM_RESULT_RETENTION_MS })
    await insertConfirmResult(database, {
      reqId: 'confirm-recent',
      committedAt: NOW - CONFIRM_RESULT_RETENTION_MS + 1
    })
    await insertAuditEvent(database, { id: 'audit-old', at: NOW - AUDIT_EVENT_RETENTION_MS })
    await insertAuditEvent(database, { id: 'audit-recent', at: NOW - AUDIT_EVENT_RETENTION_MS + 1 })

    await store.cleanup()

    expect(await remainingIds(database, 'relay_confirm_results', 'req_id')).toEqual(['confirm-recent'])
    expect(await remainingIds(database, 'relay_audit_events', 'id')).toEqual(['audit-recent'])
    await database.close()
  })

  it('still replays a confirm result inside retention', async () => {
    const database = await openInMemoryRelayDatabase()
    let now = NOW - DAY_MS
    const store = new RelayCredentialStore(database, () => now)
    try {
      const invite = await store.createInvite(identity, 'device-1')
      const reservation = await store.reserveCredential(identity.relayHostId, invite.inviteToken)
      if (!reservation) {
        throw new Error('invite did not reserve')
      }
      await store.recordConnectionBasis({
        ...reservation,
        basisConnId: 'invite-basis',
        owningControlGeneration: 1,
        deadline: reservation.leaseExpiresAt
      })
      await store.installCredential({
        ...identity,
        relayDeviceId: 'device-1',
        reqId: 'install-1',
        newResumeTokenHash: hashCredential('resume-token'),
        owningControlGeneration: 1,
        authorization: { mode: 'relay-basis', basisConnId: 'invite-basis' }
      })
      const resume = await store.reserveCredential(identity.relayHostId, 'resume-token')
      if (!resume) {
        throw new Error('resume did not reserve')
      }
      await store.recordConnectionBasis({
        ...resume,
        basisConnId: 'resume-basis',
        owningControlGeneration: 1,
        deadline: resume.leaseExpiresAt
      })
      const request = {
        ...identity,
        reqId: 'confirm-1',
        basisConnId: 'resume-basis',
        owningControlGeneration: 1
      }
      const confirmed = await store.confirmResume(request)
      expect(confirmed).toMatchObject({ renewed: true, acceptedAs: 'current' })
      now = NOW
      await store.cleanup()
      expect(await store.confirmResume(request)).toEqual(confirmed)
    } finally {
      await database.close()
    }
  })
})