/** * @fileoverview The home screen's foreign-session block: the wide scan is * one-shot, and an adoption failure says what the server said. * * Containers and ssh hosts cost a `docker exec` or a full ssh handshake each, * with a ~12s timeout. Riding them along on the 8s poll stacked connections on * a slow host, so the wide scan now runs only when the user asks. That makes a * second property load-bearing: the periodic poll's payload cannot contain * those rows, so they are kept apart and merged — assert only "the request was * right" and the real failure (the next tick wiping the container rows off the * list) sails through. * * Port: none. */ import { describe, it, expect, vi } from 'vitest'; import { readFileSync } from 'node:fs'; import { fileURLToPath } from 'node:url'; import vm from 'node:vm'; const SRC = readFileSync(fileURLToPath(new URL('../src/web/public/foreign-sessions.js', import.meta.url)), 'utf8'); function stubEl(): Record { const el: Record = { children: [] as unknown[], dataset: {}, disabled: false, textContent: '', title: '', type: '', className: '', hidden: false, classList: { add() {}, remove() {}, contains: () => false }, appendChild(c: unknown) { (el.children as unknown[]).push(c); return c; }, setAttribute() {}, }; Object.defineProperty(el, 'innerHTML', { get: () => '', set: () => void (el.children = []) }); return el; } /** The module is a classic script that mixes into CodemanApp.prototype. */ function loadApp() { const host = stubEl(); const ctx: Record = { console, Date, Number, Array, Object, JSON, Math, String, setInterval: () => 1, clearInterval() {}, codemanT: null, document: { createElement: () => stubEl(), getElementById: (id: string) => (id === 'foreignSessions' ? host : null), addEventListener() {}, }, CodemanApp: function () {} as unknown, }; vm.createContext(ctx); vm.runInContext(SRC, ctx); const Ctor = ctx.CodemanApp as { prototype: object }; return Object.create(Ctor.prototype) as Record & { toggleForeignScanRemote(): void; rescanForeignWide(): void; loadForeignSessions(o?: { wide?: boolean }): Promise; adoptForeignSession(id: string, el?: unknown): Promise; _allForeignRows(): Array<{ id: string }>; renderAllForeignSessions(): void; }; } const LOCAL = { id: 'L1', location: 'local', sessionName: 'work', mode: 'claude' }; const DOCKER = { id: 'D1', location: 'docker', sessionName: 'inbox', mode: 'codex' }; describe('the wide scan is one-shot', () => { function wired() { const app = loadApp(); const calls: string[] = []; app._apiJson = vi.fn(async (path: string) => { calls.push(path); return path.includes('docker=1') ? { sessions: [LOCAL, DOCKER], notes: [], canScanWide: true } : { sessions: [LOCAL], notes: [], canScanWide: true }; }); return { app, calls }; } it('fetches containers and hosts once when the toggle goes on', async () => { const { app, calls } = wired(); app.toggleForeignScanRemote(); // Wait on the STATE, not on the call count: the stub pushes its path before // it resolves, so a call-count wait returns while the rows are still unset. await vi.waitFor(() => expect(app._allForeignRows()).toHaveLength(2)); expect(calls[0]).toContain('docker=1'); expect(calls[0]).toContain('remote=1'); expect(app._allForeignRows().map((r) => r.id)).toEqual(['L1', 'D1']); }); it('keeps the periodic poll local-only, and the container row survives it', async () => { // Both halves matter. The first is the cost fix; the second is what makes it // usable — a local-only payload has no container rows in it. const { app, calls } = wired(); app.toggleForeignScanRemote(); await vi.waitFor(() => expect(app._allForeignRows()).toHaveLength(2)); await app.loadForeignSessions(); // the interval's call shape expect(calls[1]).toBe('/api/mux/foreign'); expect(app._allForeignRows().map((r) => r.id)).toEqual(['L1', 'D1']); }); it('discards the wide rows when the toggle goes off', async () => { // Nothing re-confirms them, so leaving them up would show a container // session that may be long gone. const { app, calls } = wired(); app.toggleForeignScanRemote(); await vi.waitFor(() => expect(app._allForeignRows()).toHaveLength(2)); app.toggleForeignScanRemote(); expect(app._allForeignRows().map((r) => r.id)).toEqual(['L1']); }); it('Rescan re-runs the wide scan, and does nothing while the toggle is off', async () => { const { app, calls } = wired(); app.rescanForeignWide(); expect(calls).toHaveLength(0); app.toggleForeignScanRemote(); await vi.waitFor(() => expect(app._allForeignRows()).toHaveLength(2)); app.rescanForeignWide(); await vi.waitFor(() => expect(calls).toHaveLength(2)); expect(calls[1]).toContain('docker=1'); }); }); describe('an adoption failure reports what the server said', () => { function adoptHarness(status: number, body: unknown) { const app = loadApp(); const toasts: string[] = []; app.showToast = (msg: string) => void toasts.push(msg); app._api = vi.fn(async () => ({ ok: status < 400, status, json: async () => body })); app._apiJson = vi.fn(async () => ({ sessions: [], notes: [], canScanWide: false })); app._onSessionCreated = vi.fn(); app.selectSession = vi.fn(async () => {}); return { app, toasts }; } it('shows "could not reach it" verbatim instead of "that session is gone"', async () => { // The server deliberately tells two different stories. `_apiJson` folds a // non-2xx to null, which collapsed both into one message and reported a // live remote session as deleted every time the link flickered. const msg = 'Could not reach it just now (ssh box: timeout). It may still be running — try again.'; const { app, toasts } = adoptHarness(404, { success: false, error: msg, errorCode: 'NOT_FOUND' }); await app.adoptForeignSession('cand-1'); expect(toasts[0]).toBe(msg); }); it('still shows the gone message when that is what the server said', async () => { const msg = 'That tmux session is no longer there. Refresh the list and try again.'; const { app, toasts } = adoptHarness(404, { success: false, error: msg, errorCode: 'NOT_FOUND' }); await app.adoptForeignSession('cand-1'); expect(toasts[0]).toBe(msg); }); it('falls back to its own wording when the server sent no readable body', async () => { const app = loadApp(); const toasts: string[] = []; app.showToast = (msg: string) => void toasts.push(msg); app._api = vi.fn(async () => null); // network failure app._apiJson = vi.fn(async () => ({ sessions: [], notes: [], canScanWide: false })); await app.adoptForeignSession('cand-1'); expect(toasts[0]).toMatch(/Could not open that session/); }); it('goes through the app’s normal create path on success', async () => { const session = { id: 'new-1' }; const { app } = adoptHarness(200, { success: true, data: { session } }); await app.adoptForeignSession('cand-1'); expect(app._onSessionCreated).toHaveBeenCalledWith(session); expect(app.selectSession).toHaveBeenCalledWith('new-1'); }); });