Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

apps/desktop/e2e/unread-dot-restart.spec.ts

@@ -0,0 +1,162 @@
+/**
+ * E2E test for PERSISTED unread state — the green "Finished — unread" dot
+ * must survive an app restart.
+ *
+ * Regression coverage for the reset-on-restart bug: the unread flag used to
+ * live only in the in-memory `$unreadFinishedSessionIds` atom, so closing and
+ * reopening the desktop app grayed out every green dot. The persisted layer
+ * (src/store/session-unread.ts) now rebuilds the dot from localStorage-backed
+ * finish markers + seen-count watermarks.
+ *
+ * The scenario uses TWO sessions on purpose: with a single session the app
+ * can reopen straight into it after a restart, which acks the session (the
+ * user is looking at it) and would mask the dot. Session A finishes in the
+ * background while session B is the selected one; the restart reopens into
+ * B, so A's dot is observable.
+ *
+ *  1. Session A: start a turn, hold its stream open.
+ *  2. Session B: new session, send a message, let it finish while SELECTED.
+ *  3. Release A's stream → its background finish paints A's green dot.
+ *  4. QUIT the app, relaunch on the SAME sandbox → A's dot must still be
+ *     there (previously it was lost).
+ *  5. Open session A → dot clears.
+ *  6. Restart once more → the cleared state must persist too (no zombie dot).
+ *
+ * Prerequisite: `npm run build` must have been run so dist/ exists.
+ */
+
+import { expect, type Page, test } from '@playwright/test'
+import { type ElectronApplication } from '@playwright/test'
+
+import {
+  buildAppEnv,
+  launchDesktop,
+  type MockBackendFixture,
+  setupMockBackend,
+  waitForAppReady,
+} from './fixtures'
+import { restartMockServer } from './mock-server'
+
+/** Finished-unread dot aria-label (from i18n en.ts). */
+const UNREAD_DOT_LABEL = 'Finished — unread'
+
+/** Held prompt — the mock pauses this stream until we release it, so the
+ *  turn is deterministically still running when we switch away. */
+const HELD_PROMPT = 'E2E unread restart: hold this stream until released.'
+/** Second session's prompt — completes normally while selected. */
+const SECOND_PROMPT = 'E2E unread restart: second session, read while open.'
+
+const unreadDots = (page: Page) => page.locator(`[aria-label="${UNREAD_DOT_LABEL}"]`)
+
+async function sendMessage(page: Page, text: string): Promise<void> {
+  const composer = page.locator('[contenteditable="true"]').first()
+  await composer.waitFor({ state: 'visible', timeout: 15_000 })
+  await composer.click()
+  await composer.type(text, { delay: 5 })
+  await page.keyboard.press('Enter')
+}
+
+test.describe('unread dot survives app restart', () => {
+  test.describe.configure({ mode: 'serial' })
+  // Three full app boots in one scenario — give it more than the global 90s.
+  test.setTimeout(300_000)
+
+  let fixture: MockBackendFixture
+  let app: ElectronApplication
+  let page: Page
+
+  test.beforeAll(async () => {
+    restartMockServer()
+    fixture = await setupMockBackend({
+      mockServer: { holdFirstStreamForPrompt: HELD_PROMPT },
+    })
+    app = fixture.app
+    page = fixture.page
+    await waitForAppReady(fixture, 120_000)
+  })
+
+  test.afterAll(async () => {
+    // The fixture's own app handle may already be closed by the restart
+    // steps — close whatever is current, then drop the sandbox + mock.
+    try {
+      await app?.close()
+    } catch {
+      // already closed
+    }
+
+    fixture?.mock.close()
+    fixture?.sandbox.cleanup()
+  })
+
+  /** Relaunch the desktop app against the SAME sandbox (same userData →
+   *  same localStorage, same HERMES_HOME → same session store). */
+  async function restartApp(): Promise<void> {
+    await app.close()
+
+    const relaunched = await launchDesktop(buildAppEnv(fixture.sandbox))
+    app = relaunched.app
+    page = relaunched.page
+    await waitForAppReady({ ...fixture, app, page }, 120_000)
+  }
+
+  test('green dot persists across restart and its clear persists too', async () => {
+    // ── 1. Session A: start a turn whose stream the mock holds open ────
+    await sendMessage(page, HELD_PROMPT)
+    await fixture.mock.waitForHeldStream()
+
+    // ── 2. Session B: complete a turn while SELECTED (stays read) ──────
+    await page.locator('button:has-text("New session")').first().click()
+    await sendMessage(page, SECOND_PROMPT)
+
+    // B's reply lands in the open transcript — this session is "read".
+    await page.waitForFunction(
+      () => (document.body.textContent ?? '').includes('Hello from the mock inference server'),
+      undefined,
+      { timeout: 30_000 },
+    )
+
+    // ── 3. Release A's stream → background finish paints A's dot ──────
+    fixture.mock.releaseHeldStream()
+
+    await expect
+      .poll(() => unreadDots(page).count(), {
+        timeout: 30_000,
+        message: 'green unread dot should appear after the background finish',
+      })
+      .toBeGreaterThan(0)
+
+    // ── 4. Restart the app — the dot must survive ──────────────────────
+    // The app reopens into session B (or a fresh draft), NOT session A, so
+    // A's dot is observable rather than being acked by the route restore.
+    await restartApp()
+
+    await expect
+      .poll(() => unreadDots(page).count(), {
+        timeout: 60_000,
+        message: 'green unread dot should be rebuilt from persisted state after restart',
+      })
+      .toBeGreaterThan(0)
+
+    // ── 5. Open session A — the dot clears ─────────────────────────────
+    // The dot sits inside A's sidebar row button; click that row.
+    await unreadDots(page)
+      .first()
+      .locator('xpath=ancestor::button[1]')
+      .click()
+
+    await expect
+      .poll(() => unreadDots(page).count(), {
+        timeout: 15_000,
+        message: 'opening the session should clear its unread dot',
+      })
+      .toBe(0)
+
+    // ── 6. Restart again — the CLEARED state must persist as well ──────
+    await restartApp()
+
+    // Give the sidebar a moment to load rows, then assert no dot returns.
+    await page.waitForSelector('[data-slot="sidebar"]', { timeout: 60_000 })
+    await page.waitForTimeout(5_000)
+    expect(await unreadDots(page).count(), 'acked session must stay read after restart').toBe(0)
+  })
+})