// S10: preserve exact desktop-only drafts through relay→managed conversion, reconnect and restart; no draft bytes may enter the host profile. import { createHash } from 'node:crypto' import { mkdirSync, mkdtempSync, readdirSync, rmSync } from 'node:fs' import { tmpdir } from 'node:os' import path from 'node:path' import type { Page, TestInfo } from '@stablyai/playwright-test' import { expect, test } from './helpers/orca-app' import { activateManagedWorkspace, launchManagedWorkspace, managedEnvironmentId, relaunchManagedApp, skipUnlessManagedDockerHost, withManagedHost, type ManagedHostFixture } from './helpers/orcad-managed-workspace' import { reconnect } from './helpers/orcad-convert-flow' import { readPersistedProfileState } from './helpers/persisted-profile-state' skipUnlessManagedDockerHost() // A large markdown file opens in the source editor instead of the rich one. const VISIBLE_EDITOR = '.rich-markdown-editor, .monaco-editor .view-lines' type EditorVerdict = 'present' | 'dirty-only' | 'absent' type HostVerdict = { verdict: 'present' | 'mismatch' | 'absent'; where: string[] } function draftOf(marker: string, bytes: number): string { const lines: string[] = [] let length = 0 for (let line = 0; length < bytes; line += 1) { const text = `${marker} unsaved line ${line}\n` lines.push(text) length += text.length } return lines.join('').slice(0, bytes) } function sha256(text: string): string { return createHash('sha256').update(text, 'utf8').digest('hex') } /** Every string in `value` equal to, or carrying, the draft, by JSON path. */ function findDraft(value: unknown, draft: string, marker: string): HostVerdict { const exact: string[] = [] const partial: string[] = [] const walk = (node: unknown, at: string): void => { if (typeof node === 'string') { if (node === draft) { exact.push(at) } else if (node.includes(marker)) { partial.push(`${at} (${node.length} chars)`) } return } if (Array.isArray(node)) { node.forEach((child, index) => walk(child, `${at}[${index}]`)) return } if (node && typeof node === 'object') { for (const [key, child] of Object.entries(node)) { walk(child, at ? `${at}.${key}` : key) } } } walk(value, '') if (exact.length > 0) { return { verdict: 'present', where: exact } } return partial.length > 0 ? { verdict: 'mismatch', where: partial } : { verdict: 'absent', where: [] } } /** The managed server's committed profile, copied off the host so it is read as stored. */ function readHostProfiles(fixture: ManagedHostFixture): Record[] { const { host } = fixture const databases = host.exec!( `find / -xdev -name profile-state.db -path '*/profiles/*' 2>/dev/null || true` ) .split('\n') .map((line) => line.trim()) .filter(Boolean) const states: Record[] = [] for (const database of databases) { const profileDir = path.posix.dirname(database) const profileId = path.posix.basename(profileDir) const local = mkdtempSync(path.join(tmpdir(), 'orca-s10d-host-')) try { const profilesDir = path.join(local, 'profiles') mkdirSync(profilesDir, { recursive: true }) // The directory carries the WAL beside the database: committed rows may still sit there. host.copyFromHost!(profileDir, profilesDir) if (readdirSync(path.join(profilesDir, profileId)).includes('profile-state.db')) { states.push(readPersistedProfileState(local, profileId)) } } finally { rmSync(local, { recursive: true, force: true }) } } return states } async function readEditorVerdict( page: Page, filePath: string, draft: string ): Promise<{ verdict: EditorVerdict; detail: string }> { const seen = await page.evaluate( ({ filePath }) => { const state = window.__store?.getState() const files = (state?.openFiles ?? []).filter((file) => file.filePath === filePath) return files.map((file) => ({ id: file.id, worktreeId: file.worktreeId, isDirty: file.isDirty, draft: state?.editorDrafts[file.id] ?? null })) }, { filePath } ) const detail = JSON.stringify( seen.map(({ draft: content, ...rest }) => ({ ...rest, draftChars: content?.length ?? null, draftSha: content === null ? null : sha256(content) })) ) if (seen.some((file) => file.draft === draft)) { return { verdict: 'present', detail } } return { verdict: seen.some((file) => file.isDirty) ? 'dirty-only' : 'absent', detail } } function record(testInfo: TestInfo, label: string, line: string): void { console.log(`S10D-LIVE ${label} ${line}`) testInfo.annotations.push({ type: 'S10D-LIVE', description: `${label} ${line}` }) } for (const { label, bytes } of [ // Well inside the 768 KiB signed manifest. { label: 'inline', bytes: 2 * 1024 }, // Over the 768 KiB manifest budget, which an inline draft used to overflow. { label: 'large', bytes: 2 * 1024 * 1024 } ]) { test(`an unsaved ${label} editor draft survives conversion to a managed server`, async (// oxlint-disable-next-line no-empty-pattern -- This exercise owns its app launch. {}, testInfo) => { test.setTimeout(14 * 60_000) await withManagedHost(testInfo, async (fixture) => { const marker = `S10D_${label.toUpperCase()}_${Date.now()}` const draft = draftOf(marker, bytes) const { page, seeded } = await launchManagedWorkspace(fixture, { seed: { draftContent: draft } }) // A further reconnect: what the editor sees once the converted host is reached again. await reconnect(page, seeded.targetId) // The editor may hydrate the moved tab a moment after the reconnect settles. let editor = await readEditorVerdict(page, seeded.sessionFilePath, draft) await expect .poll( async () => { editor = await readEditorVerdict(page, seeded.sessionFilePath, draft) return editor.verdict }, { timeout: 30_000 } ) .toBe('present') .catch(() => {}) await expect(page.locator(VISIBLE_EDITOR).first()).toContainText(`${marker} unsaved line 0`, { timeout: 60_000 }) // A restart reads the draft back from this desktop's own record, now named for the server. const environmentId = await managedEnvironmentId(page, seeded.targetId) const restarted = await relaunchManagedApp(fixture) await activateManagedWorkspace(restarted, seeded.worktreeId, environmentId) let restored = await readEditorVerdict(restarted, seeded.sessionFilePath, draft) await expect .poll( async () => { restored = await readEditorVerdict(restarted, seeded.sessionFilePath, draft) return restored.verdict }, { timeout: 30_000 } ) .toBe('present') .catch(() => {}) await expect(restarted.locator(VISIBLE_EDITOR).first()).toContainText( `${marker} unsaved line 0`, { timeout: 60_000 } ) const profiles = readHostProfiles(fixture) expect(profiles.length, 'no committed server profile was read').toBeGreaterThan(0) const found = profiles.map((state) => findDraft(state, draft, marker)) const host: HostVerdict = found.find((entry) => entry.verdict !== 'absent') ?? { verdict: 'absent', where: [] } record( testInfo, label, `bytes=${draft.length} sha=${sha256(draft)} editor=${editor.verdict} ` + `restarted=${restored.verdict} host=${host.verdict} ` + `hostAt=${JSON.stringify(host.where)} editorFiles=${editor.detail}` ) await restarted.screenshot({ path: testInfo.outputPath(`editor-draft-${label}.png`) }) // Asserted after the record, so a miss still says where the draft did and did not go. expect(editor.verdict, `the desktop lost the ${label} draft`).toBe('present') expect(restored.verdict, `a restart lost the ${label} draft`).toBe('present') expect(host.verdict, `the ${label} draft left this desktop`).toBe('absent') }) }) }