@saluzi/saluzi-edu 0.2.62 → 0.2.64

package/packages/remote-control-server/src/__tests__/attach-wait.test.ts

@@ -0,0 +1,213 @@
+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 v1Environments from '../routes/v1/environments'
+import webEnvironments from '../routes/web/environments'
+import {
+  storeReset,
+  storeCreateEnvironment,
+  storeGetEnvironment,
+  storeUpdateEnvironment,
+  storeListActiveEnvironmentsWithTeam,
+} from '../store'
+import { initDatabase, resetDbSingleton, getDb } from '../db/sqlite'
+import { issueSessionToken } from '../auth/session'
+import { createUserDirectly } from './helpers/fixtures'
+import { createSession, archiveSession } from '../services/session'
+import { storeBindSession } from '../store'
+
+/**
+ * Session Attach P2 — wait mode:
+ *
+ * - POST /v1/environments/bridge persists session_mode:'attach'.
+ * - GET /v1/environments/:id/assignment returns the first open non-ACP
+ *   session on the env (assigned:false until the Web UI binds one).
+ * - GET /web/environments surfaces attach_waiting for waiting workers.
+ */
+
+function freshDb(): Database {
+  try {
+    resetDbSingleton()
+  } catch {}
+  const path = resolve(
+    tmpdir(),
+    `rcs-attach-wait-${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/environments', v1Environments)
+  app.route('/web', webEnvironments)
+  return app
+}
+
+describe('Session Attach wait mode', () => {
+  let app: Hono
+  let db: Database
+  let owner: { id: string; username: string }
+
+  beforeEach(() => {
+    db = freshDb()
+    storeReset()
+    app = createApp()
+    owner = createUser(db)
+  })
+
+  test('POST /bridge with session_mode=attach persists the mode', async () => {
+    const res = await app.request('/v1/environments/bridge', {
+      method: 'POST',
+      headers: { ...JSON_HDRS, ...ADMIN_KEY, 'X-User-Id': owner.username },
+      body: JSON.stringify({ machine_name: 'mac1', session_mode: 'attach' }),
+    })
+    expect(res.status).toBe(200)
+    const envId = ((await res.json()) as { environment_id: string })
+      .environment_id
+    expect(storeGetEnvironment(envId)?.sessionMode).toBe('attach')
+  })
+
+  test('POST /bridge without session_mode stays create-mode', async () => {
+    const res = await app.request('/v1/environments/bridge', {
+      method: 'POST',
+      headers: { ...JSON_HDRS, ...ADMIN_KEY, 'X-User-Id': owner.username },
+      body: JSON.stringify({ machine_name: 'mac1' }),
+    })
+    expect(res.status).toBe(200)
+    const envId = ((await res.json()) as { environment_id: string })
+      .environment_id
+    expect(storeGetEnvironment(envId)?.sessionMode ?? null).toBeNull()
+  })
+
+  test('assignment: unassigned env → assigned:false', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'mac1',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    // Age the heartbeat past the disconnect timeout, then verify the poll
+    // refreshes it (P0-2: without this the disconnect monitor kills the
+    // waiting env after 5 minutes and the CLI dead-waits its deadline).
+    const stale = new Date(Date.now() - 10 * 60 * 1000)
+    storeUpdateEnvironment(env.id, { lastPollAt: stale })
+    const before = storeGetEnvironment(env.id)?.lastPollAt?.getTime()
+
+    const res = await app.request(`/v1/environments/${env.id}/assignment`, {
+      headers: { ...ADMIN_KEY },
+    })
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ assigned: false })
+    const after = storeGetEnvironment(env.id)?.lastPollAt?.getTime()
+    expect(after).not.toBe(before)
+    expect(after ?? 0).toBeGreaterThan(stale.getTime())
+  })
+
+  test('assignment: session bound to the env (web attach) → assigned with session id', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'mac1',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    const session = createSession({
+      environment_id: env.id,
+      title: 'Team session',
+      source: 'web',
+    })
+    storeBindSession(session.id, owner.id, 'user')
+
+    const res = await app.request(`/v1/environments/${env.id}/assignment`, {
+      headers: { ...ADMIN_KEY },
+    })
+    expect(res.status).toBe(200)
+    const body = (await res.json()) as {
+      assigned: boolean
+      session_id?: string
+    }
+    expect(body.assigned).toBe(true)
+    expect(body.session_id).toBe(session.id)
+  })
+
+  test('assignment: archived sessions do not satisfy the assignment', async () => {
+    const env = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'mac1',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    const session = createSession({
+      environment_id: env.id,
+      title: 'Archived session',
+      source: 'web',
+    })
+    archiveSession(session.id)
+
+    const res = await app.request(`/v1/environments/${env.id}/assignment`, {
+      headers: { ...ADMIN_KEY },
+    })
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual({ assigned: false })
+  })
+
+  test('assignment: unknown env → 404', async () => {
+    const res = await app.request('/v1/environments/env_missing/assignment', {
+      headers: { ...ADMIN_KEY },
+    })
+    expect(res.status).toBe(404)
+  })
+
+  test('web environments exposes attach_waiting for waiting workers', async () => {
+    storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'waiting-cli',
+      ownerUserId: owner.id,
+      sessionMode: 'attach',
+    })
+    // A create-mode env with a bound session — never attach_waiting.
+    const busyEnv = storeCreateEnvironment({
+      secret: 'test-api-key',
+      machineName: 'busy-cli',
+      ownerUserId: owner.id,
+    })
+    createSession({
+      environment_id: busyEnv.id,
+      title: 's',
+      source: 'web',
+    })
+
+    const res = await app.request('/web/environments', {
+      headers: { Authorization: rctAuth(owner.id) },
+    })
+    expect(res.status).toBe(200)
+    const envs = (await res.json()) as Array<{
+      machine_name: string
+      attach_waiting?: boolean
+    }>
+    const waiting = envs.find(e => e.machine_name === 'waiting-cli')
+    const busy = envs.find(e => e.machine_name === 'busy-cli')
+    expect(waiting?.attach_waiting).toBe(true)
+    expect(busy?.attach_waiting ?? false).toBe(false)
+  })
+})