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.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
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()
}
})
})