feat(test): add Playwright e2e tests with mock IPC layer

21 tests across sidebar, composer, chat, overlays, and tabs. Mock IPC
intercepts all Tauri invoke commands with in-memory state. Includes
simulated streaming response for send-and-receive test.

Author: Swofty-Developments

.gitignore

@@ -25,3 +25,5 @@ Thumbs.db
 
 # App data
 .codeforge/
+playwright-report/
+test-results/

crates/tauri-app/frontend/e2e/chat.spec.ts

@@ -0,0 +1,94 @@
+import { test, expect } from "@playwright/test";
+import { injectMockIPC, seedData, gotoApp, selectThread, sendMessageAndWait } from "./helpers";
+
+test.beforeEach(async ({ page }) => {
+  await injectMockIPC(page);
+});
+
+test.describe("Chat area", () => {
+  test('shows "New conversation" when thread is open with no messages', async ({ page }) => {
+    await seedData(page, [
+      { name: "Proj", path: "/tmp/p", threads: [{ title: "Empty Thread" }] },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Empty Thread");
+
+    const empty = page.locator(".chat-empty");
+    await expect(empty).toBeVisible();
+    await expect(empty).toContainText("New conversation");
+  });
+
+  test("renders messages for a thread", async ({ page }) => {
+    await seedData(page, [
+      {
+        name: "Proj",
+        path: "/tmp/p",
+        threads: [
+          {
+            title: "Chat Thread",
+            messages: [
+              { role: "user", content: "What is Rust?" },
+              { role: "assistant", content: "Rust is a systems programming language." },
+            ],
+          },
+        ],
+      },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Chat Thread");
+
+    // Wait for messages to render
+    await expect(page.locator(".message")).toHaveCount(2);
+  });
+
+  test("messages have correct role classes", async ({ page }) => {
+    await seedData(page, [
+      {
+        name: "Proj",
+        path: "/tmp/p",
+        threads: [
+          {
+            title: "Role Thread",
+            messages: [
+              { role: "user", content: "Hello" },
+              { role: "assistant", content: "Hi there" },
+              { role: "system", content: "System notice" },
+            ],
+          },
+        ],
+      },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Role Thread");
+
+    await expect(page.locator(".message")).toHaveCount(3);
+    await expect(page.locator(".message-user")).toHaveCount(1);
+    await expect(page.locator(".message-assistant")).toHaveCount(1);
+    await expect(page.locator(".message-system")).toHaveCount(1);
+  });
+
+  test("sending a message shows user bubble and streams assistant response", async ({ page }) => {
+    await seedData(page, [
+      { name: "Proj", path: "/tmp/p", threads: [{ title: "Send Test" }] },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Send Test");
+
+    // Send a message — the mock IPC will emit streaming events
+    await sendMessageAndWait(page, "Hello Claude!");
+
+    // User message should appear
+    const userMsg = page.locator(".message-user");
+    await expect(userMsg).toHaveCount(1);
+    await expect(userMsg).toContainText("Hello Claude!");
+
+    // Assistant response should appear (streamed via mock agent events)
+    const assistantMsg = page.locator(".message-assistant");
+    await expect(assistantMsg).toHaveCount(1);
+    // The mock responds with: 'This is a mock response to: "Hello Claude!"'
+    await expect(assistantMsg).toContainText("mock response");
+
+    // Streaming should be done — no cursor visible
+    await expect(page.locator(".cursor")).toHaveCount(0);
+  });
+});

crates/tauri-app/frontend/e2e/composer.spec.ts

@@ -0,0 +1,69 @@
+import { test, expect } from "@playwright/test";
+import { injectMockIPC, seedData, gotoApp, selectThread, typeInComposer } from "./helpers";
+
+test.beforeEach(async ({ page }) => {
+  await injectMockIPC(page);
+});
+
+test.describe("Composer", () => {
+  test("shows when a thread is active", async ({ page }) => {
+    await seedData(page, [
+      { name: "Proj", path: "/tmp/p", threads: [{ title: "Active Thread" }] },
+    ]);
+    await gotoApp(page);
+
+    // Composer should not be visible when no thread is selected
+    await expect(page.locator(".composer-wrapper")).toHaveCount(0);
+
+    // Select the thread
+    await selectThread(page, "Active Thread");
+
+    // Now the composer should appear
+    await expect(page.locator(".composer-wrapper")).toBeVisible();
+  });
+
+  test("can type in composer textarea", async ({ page }) => {
+    await seedData(page, [
+      { name: "Proj", path: "/tmp/p", threads: [{ title: "Typing Test" }] },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Typing Test");
+
+    await typeInComposer(page, "Hello, world!");
+
+    const input = page.locator(".composer-input");
+    await expect(input).toHaveValue("Hello, world!");
+  });
+
+  test("send button is visible", async ({ page }) => {
+    await seedData(page, [
+      { name: "Proj", path: "/tmp/p", threads: [{ title: "Send Test" }] },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Send Test");
+
+    const sendBtn = page.locator(".send-btn");
+    await expect(sendBtn).toBeVisible();
+  });
+
+  test("provider picker button works", async ({ page }) => {
+    await seedData(page, [
+      { name: "Proj", path: "/tmp/p", threads: [{ title: "Provider Test" }] },
+    ]);
+    await gotoApp(page);
+    await selectThread(page, "Provider Test");
+
+    // The provider pill is the first .meta-pill
+    const providerPill = page.locator(".meta-pill").first();
+    await expect(providerPill).toBeVisible();
+    await expect(providerPill).toContainText("Claude Code");
+
+    // Click it to open the provider picker
+    await providerPill.click();
+
+    // The provider picker overlay should now be visible
+    // (ProviderPicker component renders when providerPickerOpen is true)
+    // We just verify the click didn't error and the pill is still there
+    await expect(providerPill).toBeVisible();
+  });
+});