import { describe, test, expect, beforeEach, mock } from 'bun:test' import { mockConfigModule } from './helpers/mock-config' // Mock config before any module imports mock.module('../config', () => mockConfigModule()) import { Hono } from 'hono' import type { Database } from 'bun:sqlite' import { randomUUID } from 'node:crypto' import { tmpdir } from 'node:os' import { resolve } from 'node:path' import v1Sessions from '../routes/v1/sessions' import webSessions from '../routes/web/sessions' import { storeReset, storeCreateEnvironment, storeIssueAttachCode, storeConsumeAttachCode, storeAttachCodesSize, } from '../store' import { initDatabase, resetDbSingleton, getDb } from '../db/sqlite' import { issueSessionToken } from '../auth/session' import { createUserDirectly } from './helpers/fixtures' import { createSession } from '../services/session' import { storeBindSession } from '../store' /** * Session Attach P3 — one-time attach codes: * * - POST /web/sessions/:id/attach-code (session manager) mints a code. * - POST /v1/sessions/attach-code/exchange redeems it WITHOUT manage * rights (the code IS the authorization) and dispatches the attach. * - Codes are single-use; unknown/expired codes are rejected. */ function freshDb(): Database { try { resetDbSingleton() } catch {} const path = resolve( tmpdir(), `rcs-attach-code-${randomUUID().replace(/-/g, '').slice(0, 8)}.db`, ) return initDatabase(path) } function createUser(db: Database): { id: string; username: string } { const username = `user_${randomUUID().slice(0, 6)}` const user = createUserDirectly(db, { username, role: 'member' }) return { id: user.id, username: user.username } } function rctAuth(userId: string): string { return `Bearer ${issueSessionToken(userId, getDb()).accessToken}` } const ADMIN_KEY = { Authorization: 'Bearer test-api-key' } const JSON_HDRS = { 'Content-Type': 'application/json' } function createApp() { const app = new Hono() app.route('/v1/sessions', v1Sessions) app.route('/web', webSessions) return app } describe('attach codes', () => { let app: Hono let db: Database let owner: { id: string; username: string } let envId: string let sessionId: string beforeEach(() => { db = freshDb() storeReset() app = createApp() owner = createUser(db) const env = storeCreateEnvironment({ secret: 'test-api-key', machineName: 'mac1', ownerUserId: owner.id, }) envId = env.id const session = createSession({ environment_id: null, title: 'Web session', source: 'web', }) sessionId = session.id storeBindSession(sessionId, owner.id, 'user') }) test('mint → exchange → attached, without manage rights on the redeemer', async () => { const mint = await app.request(`/web/sessions/${sessionId}/attach-code`, { method: 'POST', headers: { Authorization: rctAuth(owner.id) }, }) expect(mint.status).toBe(201) const { code, attach_command } = (await mint.json()) as { code: string attach_command: string } expect(code.startsWith('atc_')).toBe(true) expect(attach_command).toContain(code) // Redeem with a BARE admin API key (no user identity at all — the // no-rights case the code flow exists for). const exchange = await app.request('/v1/sessions/attach-code/exchange', { method: 'POST', headers: { ...JSON_HDRS, ...ADMIN_KEY }, body: JSON.stringify({ code, environment_id: envId }), }) expect(exchange.status).toBe(200) const body = (await exchange.json()) as { status: string session_id: string } expect(body.session_id).toBe(sessionId) }) test('codes are single-use: second exchange → 403', async () => { const { code } = (await ( await app.request(`/web/sessions/${sessionId}/attach-code`, { method: 'POST', headers: { Authorization: rctAuth(owner.id) }, }) ).json()) as { code: string } const redeem = (codeValue: string) => app.request('/v1/sessions/attach-code/exchange', { method: 'POST', headers: { ...JSON_HDRS, ...ADMIN_KEY }, body: JSON.stringify({ code: codeValue, environment_id: envId }), }) const first = await redeem(code) expect(first.status).toBe(200) const second = await redeem(code) expect(second.status).toBe(403) const body = (await second.json()) as { error: { type: string } } expect(body.error.type).toBe('invalid_attach_code') }) test('unknown and expired codes → 403 invalid_attach_code', async () => { const res = await app.request('/v1/sessions/attach-code/exchange', { method: 'POST', headers: { ...JSON_HDRS, ...ADMIN_KEY }, body: JSON.stringify({ code: 'atc_nonexistent', environment_id: envId, }), }) expect(res.status).toBe(403) expect(((await res.json()) as { error: { type: string } }).error.type).toBe( 'invalid_attach_code', ) const expired = storeIssueAttachCode(sessionId, -1000) const res2 = await app.request('/v1/sessions/attach-code/exchange', { method: 'POST', headers: { ...JSON_HDRS, ...ADMIN_KEY }, body: JSON.stringify({ code: expired.code, environment_id: envId }), }) expect(res2.status).toBe(403) }) test('storeConsumeAttachCode: returns null for unknown, record for known', () => { expect(storeConsumeAttachCode('atc_missing')).toBeNull() const record = storeIssueAttachCode(sessionId) expect(storeConsumeAttachCode(record.code)?.sessionId).toBe(sessionId) // Consumed — second call fails. expect(storeConsumeAttachCode(record.code)).toBeNull() }) test('unconsumed expired codes are swept on the next issue (memory hygiene)', () => { expect(storeAttachCodesSize()).toBe(0) // Expired immediately and never presented — consume() would never see it. storeIssueAttachCode(sessionId, -1000) expect(storeAttachCodesSize()).toBe(1) // The next issue sweeps it instead of letting it accumulate forever. const live = storeIssueAttachCode(sessionId) expect(storeAttachCodesSize()).toBe(1) expect(storeConsumeAttachCode(live.code)?.sessionId).toBe(sessionId) }) test('missing code or environment_id → 400', async () => { const res = await app.request('/v1/sessions/attach-code/exchange', { method: 'POST', headers: { ...JSON_HDRS, ...ADMIN_KEY }, body: JSON.stringify({ environment_id: envId }), }) expect(res.status).toBe(400) }) })