Skip to content

Fully autonomous AI Agents system capable of performing complex penetration testing tasks

feat(e2e): flow streaming/reconnect/lifecycle, entity CRUD, and cross-cutting specs

Sergey Kozyrenkob2990538a7f2
diff --git a/frontend/e2e/helpers/a11y.ts b/frontend/e2e/helpers/a11y.ts
new file mode 100644
index 00000000..6c61ea45
--- /dev/null
+++ b/frontend/e2e/helpers/a11y.ts
@@ -0,0 +1,31 @@
+import type { Page } from '@playwright/test';
+
+import AxeBuilder from '@axe-core/playwright';
+import { expect } from '@playwright/test';
+
+/**
+ * Known pre-existing violations, keyed by route, listing axe rule ids. An entry
+ * here is technical debt with a name — remove the line when the violation is
+ * fixed, never add one without a look at the actual finding.
+ */
+export type A11yAllowlist = Record<string, string[]>;
+
+const BLOCKING_IMPACTS = new Set(['critical', 'serious']);
+
+export const scanA11y = async (page: Page, route: string, allowlist: A11yAllowlist): Promise<void> => {
+ const allowed = new Set(allowlist[route] ?? []);
+ const results = await new AxeBuilder({ page }).withTags(['wcag2a', 'wcag2aa']).analyze();
+
+ const blocking = results.violations
+ .filter(({ id, impact }) => BLOCKING_IMPACTS.has(impact ?? '') && !allowed.has(id))
+ .map(({ id, impact, nodes }) => ({
+ id,
+ impact,
+ nodes: nodes.slice(0, 5).map((node) => ({
+ html: node.html.slice(0, 160),
+ target: node.target.join(' '),
+ })),
+ }));
+
+ expect(blocking, `axe critical/serious violations on ${route}`).toEqual([]);
+};
diff --git a/frontend/e2e/helpers/reconnect.ts b/frontend/e2e/helpers/reconnect.ts
new file mode 100644
index 00000000..268b72fd
--- /dev/null
+++ b/frontend/e2e/helpers/reconnect.ts
@@ -0,0 +1,13 @@
+import type { Page } from '@playwright/test';
+
+import type { MockWorld } from '../mocks/world.ts';
+
+/**
+ * Drops every live mock socket and fast-forwards the page clock past
+ * graphql-ws's jittered retryWait (1–4s for the first retry), so the reconnect
+ * happens deterministically instead of on a random timer.
+ */
+export const dropAndReconnect = async (page: Page, world: MockWorld): Promise<void> => {
+ world.dropSockets();
+ await page.clock.fastForward(5_000);
+};
diff --git a/frontend/e2e/helpers/subscriptions.ts b/frontend/e2e/helpers/subscriptions.ts
new file mode 100644
index 00000000..955fcf7d
--- /dev/null
+++ b/frontend/e2e/helpers/subscriptions.ts
@@ -0,0 +1,36 @@
+import type { Locator, TestInfo } from '@playwright/test';
+
+import { expect } from '@playwright/test';
+
+export const MESSAGE_ID_TESTID = 'flow-message-id';
+
+export const attachIdSet = async (testInfo: TestInfo, name: string, ids: string[]): Promise<void> => {
+ await testInfo.attach(name, {
+ body: JSON.stringify(ids, null, 2),
+ contentType: 'application/json',
+ });
+};
+
+export const extractMessageIds = async (panel: Locator): Promise<string[]> => {
+ const raw = await panel.getByTestId(MESSAGE_ID_TESTID).allTextContents();
+
+ return raw.map((text) => text.replace(/\D/g, '')).filter(Boolean);
+};
+
+export const assertNoDuplicates = (ids: string[]): void => {
+ const seen = new Set<string>();
+ const duplicates = ids.filter((id) => (seen.has(id) ? true : (seen.add(id), false)));
+
+ expect(duplicates, 'no message ID may render twice within a flow').toEqual([]);
+};
+
+/**
+ * Exact-set intersection, not range overlap: concurrent flows interleave global
+ * IDs, so only an empty intersection proves no cross-flow leak.
+ */
+export const assertDisjoint = (idsA: string[], idsB: string[]): void => {
+ const setB = new Set(idsB);
+ const shared = [...new Set(idsA)].filter((id) => setB.has(id));
+
+ expect(shared, 'flows must not share a single message ID').toEqual([]);
+};
diff --git a/frontend/e2e/helpers/terminal.ts b/frontend/e2e/helpers/terminal.ts
new file mode 100644
index 00000000..37952281
--- /dev/null
+++ b/frontend/e2e/helpers/terminal.ts
@@ -0,0 +1,38 @@
+import type { Page } from '@playwright/test';
+
+// Structural mirror of the XtermHostElement handle attached in
+// src/components/shared/terminal/use-xterm.ts — importing that module here
+// would drag vite-only ambient types into the e2e tsconfig program.
+interface XtermHost extends HTMLElement {
+ xterm?: {
+ buffer: {
+ active: {
+ getLine: (row: number) => undefined | { translateToString: (trim: boolean) => string };
+ length: number;
+ };
+ };
+ };
+}
+
+/** Reads the visible xterm buffer as plain text — the WebGL canvas has no DOM text to locate. */
+export const readTerminalBuffer = async (page: Page): Promise<string> =>
+ page
+ .locator('.xterm')
+ .first()
+ .evaluate((element) => {
+ const host = element.parentElement as null | XtermHost;
+ const terminal = host?.xterm;
+
+ if (!terminal) {
+ return '';
+ }
+
+ const buffer = terminal.buffer.active;
+ const lines: string[] = [];
+
+ for (let row = 0; row < buffer.length; row += 1) {
+ lines.push(buffer.getLine(row)?.translateToString(true) ?? '');
+ }
+
+ return lines.join('\n').trimEnd();
+ });
diff --git a/frontend/e2e/mocks/cassette.ts b/frontend/e2e/mocks/cassette.ts
index bcef1a47..3355d907 100644
--- a/frontend/e2e/mocks/cassette.ts
+++ b/frontend/e2e/mocks/cassette.ts
@@ -9,8 +9,25 @@ export interface Cassette {
export interface CassetteFrame {
delayMs?: number;
payload: GraphQLPayload;
+ /** Playback pauses until the flag is raised — chains a mutation to its subscription frame. */
+ whenFlag?: string;
}
+/**
+ * Generated types omit __typename (skipTypename), but Apollo's cache
+ * normalization and the subscription auto-merge need it at runtime — this adds
+ * it while keeping the compile-time field checking of the declared type.
+ */
+export const entity = <T extends object>(typename: string, value: T): T => ({ __typename: typename, ...value });
+
+/** Section-wise merge: an override replaces the base entry list per operation/path key. */
+export const mergeCassettes = (base: Cassette, override: Cassette): Cassette => ({
+ mutations: { ...base.mutations, ...override.mutations },
+ queries: { ...base.queries, ...override.queries },
+ rest: { ...base.rest, ...override.rest },
+ subscriptions: { ...base.subscriptions, ...override.subscriptions },
+});
+
export interface GraphQLCassetteEntry extends GraphQLPayload, WorldFlagged {
variables?: Record<string, unknown>;
}
diff --git a/frontend/e2e/mocks/cassettes/api-tokens.ts b/frontend/e2e/mocks/cassettes/api-tokens.ts
new file mode 100644
index 00000000..85dc4e6b
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/api-tokens.ts
@@ -0,0 +1,53 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type { ApiTokenFragmentFragment, ApiTokensDocument, ApiTokenWithSecretFragmentFragment } from '@/graphql/types';
+
+import { TokenStatus } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+const T = '2026-01-15T08:00:00Z';
+const THIRTY_DAYS_SECONDS = 30 * 24 * 60 * 60;
+
+const tokenFields = (id: string, name: string) => ({
+ createdAt: T,
+ id,
+ name,
+ roleId: '1',
+ status: TokenStatus.Active,
+ tokenId: `tok-${id}`,
+ ttl: THIRTY_DAYS_SECONDS,
+ updatedAt: T,
+ userId: '1',
+});
+
+const makeToken = (id: string, name: string): ApiTokenFragmentFragment => entity('APIToken', tokenFields(id, name));
+
+export const SEED_TOKEN = makeToken('1', 'E2E seed token');
+export const DOOMED_TOKEN = makeToken('2', 'E2E doomed token');
+export const CREATED_TOKEN = makeToken('3', 'E2E created token');
+export const CREATED_TOKEN_SECRET = 'e2e-fake-token-secret';
+
+export const CREATED_TOKEN_WITH_SECRET: ApiTokenWithSecretFragmentFragment = entity('APITokenWithSecret', {
+ ...tokenFields('3', 'E2E created token'),
+ token: CREATED_TOKEN_SECRET,
+});
+
+export const tokensList = (...tokens: ApiTokenFragmentFragment[]): ResultOf<typeof ApiTokensDocument> => ({
+ apiTokens: tokens,
+});
+
+export const apiTokensCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ apiTokens: [{ data: tokensList(SEED_TOKEN) }],
+ },
+ rest: baseRest(),
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/cassettes/base.ts b/frontend/e2e/mocks/cassettes/base.ts
new file mode 100644
index 00000000..6c7ede41
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/base.ts
@@ -0,0 +1,58 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type {
+ FlowsDocument,
+ FlowTemplatesDocument,
+ ProvidersDocument,
+ ResourcesDocument,
+ SettingsDocument,
+ SettingsUserDocument,
+} from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { authenticatedInfoEntry } from '../../fixtures/auth.ts';
+import { entity } from '../cassette.ts';
+
+const flows: ResultOf<typeof FlowsDocument> = { flows: [] };
+
+const flowTemplates: ResultOf<typeof FlowTemplatesDocument> = { flowTemplates: [] };
+
+const providers: ResultOf<typeof ProvidersDocument> = { providers: [] };
+
+// Normally cache-only (hydrated from REST), but refetchObservableQueries()
+// forces it onto the wire after a websocket reconnect.
+const resources: ResultOf<typeof ResourcesDocument> = { resources: [] };
+
+const settings: ResultOf<typeof SettingsDocument> = {
+ settings: entity('Settings', {
+ askUser: false,
+ assistantUseAgents: false,
+ debug: false,
+ dockerInside: false,
+ isDevelopMode: false,
+ version: 'e2e',
+ }),
+};
+
+const settingsUser: ResultOf<typeof SettingsUserDocument> = {
+ settingsUser: entity('UserPreferences', {
+ favoriteFlows: [],
+ id: '1',
+ }),
+};
+
+/** Everything the authenticated app shell requests on any page. */
+export const baseQueries = (): NonNullable<Cassette['queries']> => ({
+ flows: [{ data: flows }],
+ flowTemplates: [{ data: flowTemplates }],
+ providers: [{ data: providers }],
+ resources: [{ data: resources }],
+ settings: [{ data: settings }],
+ settingsUser: [{ data: settingsUser }],
+});
+
+export const baseRest = (): NonNullable<Cassette['rest']> => ({
+ 'GET /api/v1/info': [authenticatedInfoEntry()],
+ 'GET /api/v1/resources/': [{ body: { data: { items: [] }, status: 'success' } }],
+});
diff --git a/frontend/e2e/mocks/cassettes/flows.ts b/frontend/e2e/mocks/cassettes/flows.ts
new file mode 100644
index 00000000..b601d741
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/flows.ts
@@ -0,0 +1,152 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type {
+ AssistantsDocument,
+ FlowDocument,
+ FlowFragmentFragment,
+ MessageLogFragmentFragment,
+ TerminalLogFragmentFragment,
+} from '@/graphql/types';
+
+import { MessageLogType, ProviderType, ResultFormat, StatusType, TerminalLogType, TerminalType } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+const T = '2026-01-15T11:30:00Z';
+
+const provider = entity('Provider', { name: 'E2E Provider', type: ProviderType.Custom });
+
+const terminal = (id: string) =>
+ entity('Terminal', {
+ connected: true,
+ createdAt: T,
+ id,
+ image: 'debian:stable-slim',
+ name: `terminal-${id}`,
+ type: TerminalType.Primary,
+ });
+
+export const makeFlow = (id: string, title: string, status: StatusType = StatusType.Running): FlowFragmentFragment =>
+ entity('Flow', {
+ createdAt: T,
+ id,
+ provider,
+ status,
+ terminals: [terminal(id)],
+ title,
+ updatedAt: T,
+ });
+
+export const makeMessage = (id: string, flowId: string): MessageLogFragmentFragment =>
+ entity('MessageLog', {
+ createdAt: T,
+ flowId,
+ id,
+ message: `Message ${id} for flow ${flowId}`,
+ result: '',
+ resultFormat: ResultFormat.Plain,
+ subtaskId: null,
+ taskId: null,
+ thinking: null,
+ type: MessageLogType.Answer,
+ });
+
+export const FLOW_A = makeFlow('5', 'E2E Alpha');
+export const FLOW_B = makeFlow('6', 'E2E Beta');
+
+export const TERMINAL_OUTPUT = 'Linux e2e-sandbox 6.1.0 x86_64 GNU/Linux';
+
+const terminalLog = (id: string, type: TerminalLogType, text: string): TerminalLogFragmentFragment =>
+ entity('TerminalLog', {
+ createdAt: T,
+ flowId: '5',
+ id,
+ subtaskId: null,
+ taskId: null,
+ terminal: '5',
+ text,
+ type,
+ });
+
+const FLOW_A_TERMINAL_LOGS = [
+ terminalLog('301', TerminalLogType.Stdin, 'uname -a'),
+ terminalLog('302', TerminalLogType.Stdout, TERMINAL_OUTPUT),
+];
+
+export const FLOW_A_INITIAL_IDS = ['101', '102', '103'];
+export const FLOW_A_STREAMED_IDS = ['104', '105'];
+export const FLOW_A_RECONNECT_ID = '106';
+export const FLOW_B_INITIAL_IDS = ['201', '202'];
+export const FLOW_B_STREAMED_IDS = ['203', '204'];
+
+const messagesFor = (flowId: string, ids: string[]) => ids.map((id) => makeMessage(id, flowId));
+
+const flowQueryData = (
+ flow: FlowFragmentFragment,
+ messageLogs: MessageLogFragmentFragment[],
+ terminalLogs: TerminalLogFragmentFragment[] = [],
+): ResultOf<typeof FlowDocument> => ({
+ agentLogs: [],
+ flow,
+ messageLogs,
+ screenshots: [],
+ searchLogs: [],
+ tasks: [],
+ terminalLogs,
+ vectorStoreLogs: [],
+});
+
+const noAssistants: ResultOf<typeof AssistantsDocument> = { assistants: [] };
+
+const addedFrame = (message: MessageLogFragmentFragment, delayMs: number) => ({
+ delayMs,
+ payload: { data: { messageLogAdded: message } },
+});
+
+/**
+ * Two concurrent flows with disjoint message streams. The second `flow` entry
+ * for flow 5 is the post-reconnect reconcile response: everything delivered so
+ * far plus the message "missed" while the socket was down.
+ */
+export const flowsCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ assistants: [{ data: noAssistants }],
+ flow: [
+ {
+ data: flowQueryData(FLOW_A, messagesFor('5', FLOW_A_INITIAL_IDS), FLOW_A_TERMINAL_LOGS),
+ variables: { id: '5' },
+ },
+ {
+ data: flowQueryData(
+ FLOW_A,
+ messagesFor('5', [...FLOW_A_INITIAL_IDS, ...FLOW_A_STREAMED_IDS, FLOW_A_RECONNECT_ID]),
+ FLOW_A_TERMINAL_LOGS,
+ ),
+ variables: { id: '5' },
+ },
+ { data: flowQueryData(FLOW_B, messagesFor('6', FLOW_B_INITIAL_IDS)), variables: { id: '6' } },
+ ],
+ flows: [{ data: { flows: [FLOW_A, FLOW_B] } }],
+ },
+ rest: baseRest(),
+ subscriptions: {
+ messageLogAdded: [
+ {
+ frames: FLOW_A_STREAMED_IDS.map((id) => addedFrame(makeMessage(id, '5'), 80)),
+ variables: { flowId: '5' },
+ },
+ {
+ frames: FLOW_B_STREAMED_IDS.map((id) => addedFrame(makeMessage(id, '6'), 80)),
+ variables: { flowId: '6' },
+ },
+ ],
+ },
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/cassettes/knowledges.ts b/frontend/e2e/mocks/cassettes/knowledges.ts
new file mode 100644
index 00000000..27e55063
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/knowledges.ts
@@ -0,0 +1,45 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type { KnowledgeDocumentFragmentFragment, KnowledgeDocumentsDocument } from '@/graphql/types';
+
+import { KnowledgeAnswerType, KnowledgeDocType } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+export const makeKnowledge = (id: string, question: string): KnowledgeDocumentFragmentFragment =>
+ entity('KnowledgeDocument', {
+ answerType: KnowledgeAnswerType.Other,
+ codeLang: null,
+ content: `Content for ${question}`,
+ description: null,
+ docType: KnowledgeDocType.Answer,
+ flowId: null,
+ guideType: null,
+ id,
+ manual: true,
+ partSize: 1024,
+ question,
+ subtaskId: null,
+ taskId: null,
+ totalSize: 1024,
+ userId: '1',
+ });
+
+export const KNOWLEDGE_DOC = makeKnowledge('7', 'E2E Seed Question');
+
+const knowledgeDocuments: ResultOf<typeof KnowledgeDocumentsDocument> = { knowledgeDocuments: [KNOWLEDGE_DOC] };
+
+export const knowledgesCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ knowledgeDocuments: [{ data: knowledgeDocuments, variables: { withContent: false } }],
+ },
+ rest: baseRest(),
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/cassettes/smoke.ts b/frontend/e2e/mocks/cassettes/smoke.ts
index 3b69bd4b..a9f49407 100644
--- a/frontend/e2e/mocks/cassettes/smoke.ts
+++ b/frontend/e2e/mocks/cassettes/smoke.ts
@@ -1,66 +1,20 @@
-import type { ResultOf } from '@graphql-typed-document-node/core';
-
-import type {
- FlowsDocument,
- FlowTemplatesDocument,
- ProvidersDocument,
- SettingsDocument,
- SettingsUserDocument,
-} from '@/graphql/types';
-
import type { Cassette } from '../cassette.ts';
import { authenticatedInfoEntry, guestInfoEntry } from '../../fixtures/auth.ts';
-
-const flows: ResultOf<typeof FlowsDocument> = { flows: [] };
-
-const flowTemplates: ResultOf<typeof FlowTemplatesDocument> = { flowTemplates: [] };
-
-const providers: ResultOf<typeof ProvidersDocument> = { providers: [] };
-
-const settings: ResultOf<typeof SettingsDocument> = {
- settings: {
- askUser: false,
- assistantUseAgents: false,
- debug: false,
- dockerInside: false,
- isDevelopMode: false,
- version: 'e2e',
- },
-};
-
-const settingsUser: ResultOf<typeof SettingsUserDocument> = {
- settingsUser: {
- favoriteFlows: [],
- id: '1',
- },
-};
-
-const queries: Cassette['queries'] = {
- flows: [{ data: flows }],
- flowTemplates: [{ data: flowTemplates }],
- providers: [{ data: providers }],
- settings: [{ data: settings }],
- settingsUser: [{ data: settingsUser }],
-};
-
-const resourcesEntry = { body: { data: { items: [] }, status: 'success' } };
+import { baseQueries, baseRest } from './base.ts';
/** Seeded-session smoke: every request answers as an authenticated user. */
export const smokeCassette: Cassette = {
- queries,
- rest: {
- 'GET /api/v1/info': [authenticatedInfoEntry()],
- 'GET /api/v1/resources/': [resourcesEntry],
- },
+ queries: baseQueries(),
+ rest: baseRest(),
};
/** Login-form journey: /info serves guest until the login mutation raises the flag. */
export const loginJourneyCassette: Cassette = {
- queries,
+ queries: baseQueries(),
rest: {
+ ...baseRest(),
'GET /api/v1/info': [guestInfoEntry(), { ...authenticatedInfoEntry(), whenFlag: 'authenticated' }],
- 'GET /api/v1/resources/': [resourcesEntry],
'POST /api/v1/auth/login': [{ body: { data: {}, status: 'success' }, setFlag: 'authenticated' }],
},
};
diff --git a/frontend/e2e/mocks/cassettes/templates.ts b/frontend/e2e/mocks/cassettes/templates.ts
new file mode 100644
index 00000000..6e6f9a3d
--- /dev/null
+++ b/frontend/e2e/mocks/cassettes/templates.ts
@@ -0,0 +1,36 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type { FlowTemplateFragmentFragment, FlowTemplatesDocument } from '@/graphql/types';
+
+import type { Cassette } from '../cassette.ts';
+
+import { entity, mergeCassettes } from '../cassette.ts';
+import { baseQueries, baseRest } from './base.ts';
+
+const T = '2026-01-15T11:30:00Z';
+
+export const makeTemplate = (id: string, title: string, text: string): FlowTemplateFragmentFragment =>
+ entity('FlowTemplate', {
+ createdAt: T,
+ id,
+ text,
+ title,
+ updatedAt: T,
+ userId: '1',
+ });
+
+export const TEMPLATE_SEED = makeTemplate('11', 'E2E Seed Template', 'Scan the target and report findings');
+
+const flowTemplates: ResultOf<typeof FlowTemplatesDocument> = { flowTemplates: [TEMPLATE_SEED] };
+
+export const templatesCassette = (override: Cassette = {}): Cassette =>
+ mergeCassettes(
+ {
+ queries: {
+ ...baseQueries(),
+ flowTemplates: [{ data: flowTemplates }],
+ },
+ rest: baseRest(),
+ },
+ override,
+ );
diff --git a/frontend/e2e/mocks/world.ts b/frontend/e2e/mocks/world.ts
index 360db7e8..4f3ac9d2 100644
--- a/frontend/e2e/mocks/world.ts
+++ b/frontend/e2e/mocks/world.ts
@@ -2,7 +2,9 @@ import type { WebSocketRoute } from '@playwright/test';
import type {
Cassette,
+ CassetteFrame,
GraphQLCassetteEntry,
+ GraphQLPayload,
RestCassetteEntry,
SubscriptionCassetteEntry,
WorldFlagged,
@@ -12,20 +14,30 @@ const isSubsetMatch = (expected?: Record<string, unknown>, actual?: Record<strin
!expected ||
Object.entries(expected).every(([key, value]) => JSON.stringify(actual?.[key]) === JSON.stringify(value));
+const sleep = (delayMs: number) => new Promise<void>((resolve) => setTimeout(resolve, delayMs));
+
+export interface StreamSubscriber {
+ complete: () => void;
+ next: (payload: GraphQLPayload) => void;
+}
+
+interface StreamState {
+ cursor: number;
+ isDriving: boolean;
+ subscribers: Set<StreamSubscriber>;
+}
+
export class MockWorld {
readonly unmatched: string[] = [];
private readonly consumed = new Map<string, number>();
private readonly flags = new Set<string>();
- private readonly frameCursors = new Map<string, number>();
+ private readonly flagWaiters = new Map<string, Array<() => void>>();
private readonly sockets = new Set<WebSocketRoute>();
+ private readonly streams = new Map<string, StreamState>();
constructor(private readonly cassette: Cassette) {}
- advanceFrameCursor(streamKey: string): void {
- this.frameCursors.set(streamKey, this.frameCursor(streamKey) + 1);
- }
-
dropSockets(code = 1001, reason = 'e2e: forced drop'): void {
// 1001 is retryable for graphql-ws; 4400+/1011 would kill the client for good.
for (const socket of this.sockets) {
@@ -33,9 +45,18 @@ export class MockWorld {
}
}
- /** Frames already delivered for a stream survive reconnects — replay is delta-only, matching the real server. */
- frameCursor(streamKey: string): number {
- return this.frameCursors.get(streamKey) ?? 0;
+ /** Resolves once the flag is raised (immediately if it already is). */
+ flagRaised(flag: string): Promise<void> {
+ if (this.flags.has(flag)) {
+ return Promise.resolve();
+ }
+
+ return new Promise((resolve) => {
+ const waiters = this.flagWaiters.get(flag) ?? [];
+
+ waiters.push(resolve);
+ this.flagWaiters.set(flag, waiters);
+ });
}
matchGraphQL(operationName: string, variables?: Record<string, unknown>): GraphQLCassetteEntry | undefined {
@@ -87,10 +108,52 @@ export class MockWorld {
this.unmatched.push(description);
}
+ /**
+ * One driver per stream broadcasts each frame once to every current
+ * subscriber: duplicate subscribers (e.g. flowUpdated is opened by both the
+ * list and the detail provider) each get the frame, while a re-subscribe
+ * after a reconnect joins past the cursor — delta-only, like the real
+ * server. Returns an unsubscribe function.
+ */
+ subscribeStream(streamKey: string, entry: SubscriptionCassetteEntry, subscriber: StreamSubscriber): () => void {
+ const state = this.streams.get(streamKey) ?? { cursor: 0, isDriving: false, subscribers: new Set() };
+
+ this.streams.set(streamKey, state);
+ state.subscribers.add(subscriber);
+
+ if (!state.isDriving) {
+ state.isDriving = true;
+ void this.driveStream(state, entry.frames, entry.complete ?? false);
+ }
+
+ return () => state.subscribers.delete(subscriber);
+ }
+
unregisterSocket(socket: WebSocketRoute): void {
this.sockets.delete(socket);
}
+ private async driveStream(state: StreamState, frames: CassetteFrame[], shouldComplete: boolean): Promise<void> {
+ while (state.cursor < frames.length) {
+ const frame = frames[state.cursor] as CassetteFrame;
+
+ if (frame.whenFlag) {
+ await this.flagRaised(frame.whenFlag);
+ }
+
+ if (frame.delayMs) {
+ await sleep(frame.delayMs);
+ }
+
+ state.cursor += 1;
+ state.subscribers.forEach(({ next }) => next(frame.payload));
+ }
+
+ if (shouldComplete) {
+ state.subscribers.forEach(({ complete }) => complete());
+ }
+ }
+
/** Entries gated on an unraised flag are invisible; raised-flag entries outrank unflagged ones. */
private eligible<T extends WorldFlagged>(candidates?: T[]): T[] | undefined {
const open = candidates?.filter((entry) => !entry.whenFlag || this.flags.has(entry.whenFlag));
@@ -107,9 +170,15 @@ export class MockWorld {
const entry = candidates[Math.min(index, candidates.length - 1)] as T;
if (entry.setFlag) {
- this.flags.add(entry.setFlag);
+ this.raiseFlag(entry.setFlag);
}
return entry;
}
+
+ private raiseFlag(flag: string): void {
+ this.flags.add(flag);
+ this.flagWaiters.get(flag)?.forEach((resolve) => resolve());
+ this.flagWaiters.delete(flag);
+ }
}
diff --git a/frontend/e2e/mocks/ws-graphql.ts b/frontend/e2e/mocks/ws-graphql.ts
index c55c003a..d084e9be 100644
--- a/frontend/e2e/mocks/ws-graphql.ts
+++ b/frontend/e2e/mocks/ws-graphql.ts
@@ -19,7 +19,7 @@ export const installWsMock = async (page: Page, world: MockWorld): Promise<void>
await page.routeWebSocket('**/api/v1/graphql', (ws) => {
world.registerSocket(ws);
- const timers = new Set<ReturnType<typeof setTimeout>>();
+ const unsubscribes = new Map<string, () => void>();
let isOpen = true;
const send = (message: Record<string, unknown>) => {
@@ -28,19 +28,16 @@ export const installWsMock = async (page: Page, world: MockWorld): Promise<void>
}
};
- const schedule = (delayMs: number, action: () => void) => {
- const timer = setTimeout(() => {
- timers.delete(timer);
- action();
- }, delayMs);
-
- timers.add(timer);
- };
-
ws.onMessage((raw) => {
const message = JSON.parse(String(raw)) as ClientMessage;
switch (message.type) {
+ case 'complete': {
+ unsubscribes.get(message.id)?.();
+ unsubscribes.delete(message.id);
+ break;
+ }
+
case 'connection_init': {
// Ack immediately and never send any frame before it: a pre-ack frame
// throws inside graphql-ws, and this app's shouldRetry:()=>true turns
@@ -64,22 +61,13 @@ export const installWsMock = async (page: Page, world: MockWorld): Promise<void>
break;
}
- const { entry, streamKey } = match;
- const pending = entry.frames.slice(world.frameCursor(streamKey));
- let elapsed = 0;
-
- for (const frame of pending) {
- elapsed += frame.delayMs ?? 0;
- schedule(elapsed, () => {
- world.advanceFrameCursor(streamKey);
- send({ id, payload: frame.payload, type: 'next' });
- });
- }
-
- if (entry.complete) {
- schedule(elapsed, () => send({ id, type: 'complete' }));
- }
-
+ unsubscribes.set(
+ id,
+ world.subscribeStream(match.streamKey, match.entry, {
+ complete: () => send({ id, type: 'complete' }),
+ next: (framePayload) => send({ id, payload: framePayload, type: 'next' }),
+ }),
+ );
break;
}
@@ -91,12 +79,8 @@ export const installWsMock = async (page: Page, world: MockWorld): Promise<void>
ws.onClose(() => {
isOpen = false;
-
- for (const timer of timers) {
- clearTimeout(timer);
- }
-
- timers.clear();
+ unsubscribes.forEach((unsubscribe) => unsubscribe());
+ unsubscribes.clear();
world.unregisterSocket(ws);
});
});
diff --git a/frontend/e2e/specs/cross/a11y.spec.ts b/frontend/e2e/specs/cross/a11y.spec.ts
new file mode 100644
index 00000000..6ec62fcf
--- /dev/null
+++ b/frontend/e2e/specs/cross/a11y.spec.ts
@@ -0,0 +1,74 @@
+import type { A11yAllowlist } from '../../helpers/a11y.ts';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { scanA11y } from '../../helpers/a11y.ts';
+import { apiTokensCassette } from '../../mocks/cassettes/api-tokens.ts';
+import { flowsCassette } from '../../mocks/cassettes/flows.ts';
+import { knowledgesCassette } from '../../mocks/cassettes/knowledges.ts';
+import { loginJourneyCassette } from '../../mocks/cassettes/smoke.ts';
+import { templatesCassette } from '../../mocks/cassettes/templates.ts';
+
+const ALLOWLIST: A11yAllowlist = {
+ // Message metadata (date + ID) intentionally renders at 50% opacity — a
+ // design decision, not a regression; revisit with the design pass.
+ '/flows/:flowId': ['color-contrast'],
+};
+
+test.describe('a11y', { tag: '@cross' }, () => {
+ test.describe('login', () => {
+ test.use({ cassette: loginJourneyCassette, isAuthSeeded: false });
+
+ test('login page', async ({ page }) => {
+ await page.goto('/login');
+ await expect(page.getByRole('button', { name: 'Sign in' })).toBeVisible();
+ await scanA11y(page, '/login', ALLOWLIST);
+ });
+ });
+
+ test.describe('flows', () => {
+ test.use({ cassette: flowsCassette() });
+
+ test('flows list', async ({ page }) => {
+ await page.goto('/flows');
+ await expect(page.getByRole('row', { name: /E2E Alpha/ })).toBeVisible();
+ await scanA11y(page, '/flows', ALLOWLIST);
+ });
+
+ test('flow detail', async ({ page }) => {
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByRole('button', { name: 'Flow actions' })).toBeVisible();
+ await scanA11y(page, '/flows/:flowId', ALLOWLIST);
+ });
+ });
+
+ test.describe('templates', () => {
+ test.use({ cassette: templatesCassette() });
+
+ test('templates list', async ({ page }) => {
+ await page.goto('/templates');
+ await expect(page.getByRole('row', { name: /E2E Seed Template/ })).toBeVisible();
+ await scanA11y(page, '/templates', ALLOWLIST);
+ });
+ });
+
+ test.describe('knowledges', () => {
+ test.use({ cassette: knowledgesCassette() });
+
+ test('knowledges list', async ({ page }) => {
+ await page.goto('/knowledges');
+ await expect(page.getByRole('row', { name: /E2E Seed Question/ })).toBeVisible();
+ await scanA11y(page, '/knowledges', ALLOWLIST);
+ });
+ });
+
+ test.describe('api tokens', () => {
+ test.use({ cassette: apiTokensCassette() });
+
+ test('api tokens list', async ({ page }) => {
+ await page.goto('/settings/api-tokens');
+ await expect(page.getByRole('row', { name: /E2E seed token/ })).toBeVisible();
+ await scanA11y(page, '/settings/api-tokens', ALLOWLIST);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/cross/responsive.spec.ts b/frontend/e2e/specs/cross/responsive.spec.ts
new file mode 100644
index 00000000..022263a1
--- /dev/null
+++ b/frontend/e2e/specs/cross/responsive.spec.ts
@@ -0,0 +1,43 @@
+import { devices } from '@playwright/test';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { flowsCassette } from '../../mocks/cassettes/flows.ts';
+
+const hasHorizontalOverflow = () => document.documentElement.scrollWidth > document.documentElement.clientWidth + 1;
+
+const { defaultBrowserType: _defaultBrowserType, ...pixel7 } = devices['Pixel 7'];
+
+test.describe('responsive', { tag: '@cross' }, () => {
+ test.use({ cassette: flowsCassette() });
+
+ test.describe('mobile (real touch device profile)', () => {
+ test.use(pixel7);
+
+ test('collapses to the mobile shell without horizontal overflow', async ({ page, pageErrorLog }) => {
+ await page.goto('/flows');
+
+ await expect(page.getByRole('button', { name: 'Toggle Sidebar' })).toBeVisible();
+ expect(await page.evaluate(hasHorizontalOverflow)).toBe(false);
+
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByRole('button', { name: 'Flow actions' })).toBeVisible();
+ expect(await page.evaluate(hasHorizontalOverflow)).toBe(false);
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('split boundary', () => {
+ test('1280 shows the resizable split, 1279 merges into one tab row', async ({ page, pageErrorLog }) => {
+ await page.setViewportSize({ height: 800, width: 1280 });
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByRole('separator').first()).toBeVisible();
+
+ await page.setViewportSize({ height: 800, width: 1279 });
+ await expect(page.getByRole('separator')).toBeHidden();
+ expect(await page.evaluate(hasHorizontalOverflow)).toBe(false);
+ expectCleanPage(pageErrorLog);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/cross/themes.spec.ts b/frontend/e2e/specs/cross/themes.spec.ts
new file mode 100644
index 00000000..4c13af86
--- /dev/null
+++ b/frontend/e2e/specs/cross/themes.spec.ts
@@ -0,0 +1,33 @@
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { MESSAGE_ID_TESTID } from '../../helpers/subscriptions.ts';
+import { flowsCassette } from '../../mocks/cassettes/flows.ts';
+
+test.describe('themes', { tag: '@cross' }, () => {
+ test.use({ cassette: flowsCassette() });
+
+ test('renders the flow detail in seeded dark theme', async ({ page, pageErrorLog }) => {
+ await page.addInitScript(() => window.localStorage.setItem('theme', 'dark'));
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+
+ await expect(page.locator('html')).toHaveClass(/dark/);
+ await expect(page.getByTestId(MESSAGE_ID_TESTID).first()).toBeVisible();
+ await expect(page.locator('.xterm')).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+
+ test('switches themes from the sidebar user menu', async ({ page, pageErrorLog }) => {
+ await page.goto('/flows');
+
+ await expect(page.locator('html')).not.toHaveClass(/dark/);
+
+ await page.getByRole('button', { name: /admin@pentagi\.com/ }).click();
+ await page.getByRole('tab', { name: 'Dark theme' }).click();
+ await expect(page.locator('html')).toHaveClass(/dark/);
+
+ await page.getByRole('tab', { name: 'Light theme' }).click();
+ await expect(page.locator('html')).not.toHaveClass(/dark/);
+ expectCleanPage(pageErrorLog);
+ });
+});
diff --git a/frontend/e2e/specs/crud/api-tokens.spec.ts b/frontend/e2e/specs/crud/api-tokens.spec.ts
new file mode 100644
index 00000000..0b455718
--- /dev/null
+++ b/frontend/e2e/specs/crud/api-tokens.spec.ts
@@ -0,0 +1,103 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type { CreateApiTokenDocument, DeleteApiTokenDocument } from '@/graphql/types';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import {
+ apiTokensCassette,
+ CREATED_TOKEN,
+ CREATED_TOKEN_SECRET,
+ CREATED_TOKEN_WITH_SECRET,
+ DOOMED_TOKEN,
+ SEED_TOKEN,
+ tokensList,
+} from '../../mocks/cassettes/api-tokens.ts';
+
+test.describe('api tokens crud', { tag: '@crud' }, () => {
+ test.describe('create', () => {
+ const created: ResultOf<typeof CreateApiTokenDocument> = { createAPIToken: CREATED_TOKEN_WITH_SECRET };
+
+ test.use({
+ cassette: apiTokensCassette({
+ mutations: { createAPIToken: [{ data: created, setFlag: 'token-created' }] },
+ queries: {
+ apiTokens: [
+ { data: tokensList(SEED_TOKEN) },
+ { data: tokensList(SEED_TOKEN, CREATED_TOKEN), whenFlag: 'token-created' },
+ ],
+ },
+ }),
+ });
+
+ test('creates a token through the inline row and reveals the secret', async ({ page, pageErrorLog }) => {
+ await page.goto('/settings/api-tokens');
+
+ await expect(page.getByRole('row', { name: /E2E seed token/ })).toBeVisible();
+
+ await page.getByRole('button', { name: 'Create Token' }).click();
+ await page.getByPlaceholder('Token name (optional)').fill('E2E created token');
+
+ const submit = page.getByRole('button', { name: 'Submit' });
+
+ await expect(submit).toBeDisabled();
+
+ await page.getByRole('button', { name: 'Pick date' }).click();
+ await page.getByRole('button', { name: 'Tuesday, January 20th, 2026' }).click();
+ await page.keyboard.press('Escape');
+
+ await expect(submit).toBeEnabled();
+ await submit.click();
+
+ const dialog = page.getByRole('dialog');
+
+ await expect(dialog.getByText('API Token Created')).toBeVisible();
+ await expect(dialog.getByText(CREATED_TOKEN_SECRET)).toBeVisible();
+
+ await page.keyboard.press('Escape');
+
+ await expect(dialog).toBeHidden();
+ await expect(page.getByRole('row', { name: /E2E created token/ })).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('delete', () => {
+ const deleted: ResultOf<typeof DeleteApiTokenDocument> = { deleteAPIToken: true };
+
+ test.use({
+ cassette: apiTokensCassette({
+ mutations: {
+ deleteAPIToken: [
+ { data: deleted, setFlag: 'token-deleted', variables: { tokenId: DOOMED_TOKEN.tokenId } },
+ ],
+ },
+ queries: {
+ apiTokens: [
+ { data: tokensList(SEED_TOKEN, DOOMED_TOKEN) },
+ { data: tokensList(SEED_TOKEN), whenFlag: 'token-deleted' },
+ ],
+ },
+ }),
+ });
+
+ test('deletes a token via the row menu and the destructive confirm', async ({ page, pageErrorLog }) => {
+ await page.goto('/settings/api-tokens');
+
+ const doomedRow = page.getByRole('row', { name: /E2E doomed token/ });
+
+ await doomedRow.hover();
+ await doomedRow.getByRole('button', { name: 'Open menu' }).click();
+ await page.getByRole('menuitem', { name: 'Delete' }).click();
+
+ const dialog = page.getByRole('dialog');
+
+ await expect(dialog.getByText('Delete token')).toBeVisible();
+ await dialog.getByRole('button', { name: 'Delete' }).click();
+
+ await expect(doomedRow).toBeHidden();
+ await expect(page.getByRole('row', { name: /E2E seed token/ })).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/crud/knowledges.spec.ts b/frontend/e2e/specs/crud/knowledges.spec.ts
new file mode 100644
index 00000000..19906199
--- /dev/null
+++ b/frontend/e2e/specs/crud/knowledges.spec.ts
@@ -0,0 +1,110 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+import type { Page } from '@playwright/test';
+
+import type {
+ CreateKnowledgeDocumentDocument,
+ DeleteKnowledgeDocumentDocument,
+ KnowledgeDocumentDocument,
+} from '@/graphql/types';
+
+import { ResultType } from '@/graphql/types';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { KNOWLEDGE_DOC, knowledgesCassette, makeKnowledge } from '../../mocks/cassettes/knowledges.ts';
+
+const openNewKnowledgeForm = async (page: Page) => {
+ await page.goto('/knowledges');
+ await page.getByRole('button', { name: 'New Knowledge' }).click();
+
+ await expect(page).toHaveURL(/\/knowledges\/new$/);
+ await expect(page.getByRole('combobox', { name: 'Answer type' })).toBeVisible();
+};
+
+test.describe('knowledges crud', { tag: '@crud' }, () => {
+ test.describe('create validation', () => {
+ test.use({ cassette: knowledgesCassette() });
+
+ test('blocks submit until the answer type is picked', async ({ page, pageErrorLog }) => {
+ await openNewKnowledgeForm(page);
+ await page.getByRole('textbox', { name: 'Question' }).fill('What is the E2E answer?');
+ await page.getByRole('textbox', { name: 'Content' }).fill('E2E knowledge content');
+ await page.getByRole('button', { name: 'Create' }).click();
+
+ await expect(page.getByText('Answer type is required')).toBeVisible();
+ await expect(page).toHaveURL(/\/knowledges\/new$/);
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('create', () => {
+ const CREATED_DOC = makeKnowledge('301', 'What is the E2E answer?');
+ const created: ResultOf<typeof CreateKnowledgeDocumentDocument> = { createKnowledgeDocument: CREATED_DOC };
+ const detail: ResultOf<typeof KnowledgeDocumentDocument> = { knowledgeDocument: CREATED_DOC };
+
+ test.use({
+ cassette: knowledgesCassette({
+ mutations: { createKnowledgeDocument: [{ data: created }] },
+ queries: { knowledgeDocument: [{ data: detail, variables: { id: '301' } }] },
+ }),
+ });
+
+ test('creates a document and lands on its detail page', async ({ page, pageErrorLog }) => {
+ await openNewKnowledgeForm(page);
+ await page.getByRole('textbox', { name: 'Question' }).fill('What is the E2E answer?');
+ await page.getByRole('textbox', { name: 'Content' }).fill('E2E knowledge content');
+ await page.getByRole('combobox', { name: 'Answer type' }).click();
+ await page.getByRole('option', { name: 'other' }).click();
+ await page.getByRole('button', { name: 'Create' }).click();
+
+ await expect(page).toHaveURL(/\/knowledges\/301$/);
+ await expect(page.getByRole('textbox', { name: 'Question' })).toHaveValue('What is the E2E answer?');
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('delete', () => {
+ const deleted: ResultOf<typeof DeleteKnowledgeDocumentDocument> = {
+ deleteKnowledgeDocument: ResultType.Success,
+ };
+
+ test.use({
+ cassette: knowledgesCassette({
+ mutations: {
+ deleteKnowledgeDocument: [{ data: deleted, setFlag: 'knowledge-deleted', variables: { id: '7' } }],
+ },
+ subscriptions: {
+ knowledgeDocumentDeleted: [
+ {
+ frames: [
+ {
+ payload: { data: { knowledgeDocumentDeleted: KNOWLEDGE_DOC } },
+ whenFlag: 'knowledge-deleted',
+ },
+ ],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('deletes from the row menu and drops off the list', async ({ page, pageErrorLog }) => {
+ await page.goto('/knowledges');
+
+ const row = page.getByRole('row', { name: /E2E Seed Question/ });
+
+ await row.hover();
+ await row.getByRole('button', { name: 'Open menu' }).click();
+ await page.getByRole('menuitem', { name: 'Delete' }).click();
+
+ const dialog = page.getByRole('dialog');
+
+ await expect(dialog.getByRole('heading', { name: 'Delete knowledge document' })).toBeVisible();
+ await dialog.getByRole('button', { name: 'Delete' }).click();
+
+ await expect(page.getByRole('row', { name: /E2E Seed Question/ })).toBeHidden();
+ await expect(page.getByText('No knowledge documents yet')).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/crud/templates.spec.ts b/frontend/e2e/specs/crud/templates.spec.ts
new file mode 100644
index 00000000..44281d3b
--- /dev/null
+++ b/frontend/e2e/specs/crud/templates.spec.ts
@@ -0,0 +1,161 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type {
+ CreateFlowTemplateDocument,
+ DeleteFlowTemplateDocument,
+ UpdateFlowTemplateDocument,
+} from '@/graphql/types';
+
+import { ResultType } from '@/graphql/types';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { makeTemplate, TEMPLATE_SEED, templatesCassette } from '../../mocks/cassettes/templates.ts';
+
+test.describe('templates crud', { tag: '@crud' }, () => {
+ test.describe('create', () => {
+ const NEW_TITLE = 'E2E Created Template';
+ const NEW_TEXT = 'E2E created template body';
+ const createdTemplate = makeTemplate('12', NEW_TITLE, NEW_TEXT);
+ const created: ResultOf<typeof CreateFlowTemplateDocument> = { createFlowTemplate: createdTemplate };
+
+ test.use({
+ cassette: templatesCassette({
+ mutations: {
+ createFlowTemplate: [
+ {
+ data: created,
+ setFlag: 'template-created',
+ variables: { input: { text: NEW_TEXT, title: NEW_TITLE } },
+ },
+ ],
+ },
+ subscriptions: {
+ flowTemplateCreated: [
+ {
+ frames: [
+ {
+ payload: { data: { flowTemplateCreated: createdTemplate } },
+ whenFlag: 'template-created',
+ },
+ ],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('creates a template and the new row arrives via the created frame', async ({ page, pageErrorLog }) => {
+ await page.goto('/templates');
+
+ await expect(page.getByRole('row', { name: /E2E Seed Template/ })).toBeVisible();
+
+ await page.getByRole('button', { name: 'New Template' }).click();
+
+ await expect(page).toHaveURL(/\/templates\/new$/);
+
+ await page.getByLabel('Title').fill(NEW_TITLE);
+
+ // fill() mutates the contenteditable DOM directly and races ProseMirror's
+ // observer flush against the submit click; real key events apply synchronously.
+ const editor = page.getByRole('textbox', { name: 'Template content' });
+
+ await editor.click();
+ await editor.pressSequentially(NEW_TEXT);
+ await page.getByRole('button', { name: 'Create' }).click();
+
+ await expect(page).toHaveURL(/\/templates$/);
+ await expect(page.getByRole('row', { name: /E2E Created Template/ })).toBeVisible();
+ await expect(page.getByRole('row', { name: /E2E Seed Template/ })).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('rename', () => {
+ const renamed: ResultOf<typeof UpdateFlowTemplateDocument> = {
+ updateFlowTemplate: makeTemplate(TEMPLATE_SEED.id, 'E2E Renamed Template', TEMPLATE_SEED.text),
+ };
+
+ test.use({
+ cassette: templatesCassette({
+ mutations: {
+ updateFlowTemplate: [
+ {
+ data: renamed,
+ variables: {
+ input: { text: TEMPLATE_SEED.text, title: 'E2E Renamed Template' },
+ templateId: TEMPLATE_SEED.id,
+ },
+ },
+ ],
+ },
+ }),
+ });
+
+ test('renames inline from the row menu and the row shows the new title', async ({ page, pageErrorLog }) => {
+ await page.goto('/templates');
+
+ const row = page.getByRole('row', { name: /E2E Seed Template/ });
+
+ await row.hover();
+ await row.getByRole('button', { name: 'Open menu' }).click();
+ await page.getByRole('menuitem', { name: 'Rename' }).click();
+ await page.getByPlaceholder('Template title').fill('E2E Renamed Template');
+ await page.getByPlaceholder('Template title').press('Enter');
+
+ await expect(page.getByText('Template renamed successfully')).toBeVisible();
+ await expect(page.getByRole('row', { name: /E2E Renamed Template/ })).toBeVisible();
+ await expect(page.getByRole('row', { name: /E2E Seed Template/ })).toBeHidden();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+
+ test.describe('delete', () => {
+ const deleted: ResultOf<typeof DeleteFlowTemplateDocument> = { deleteFlowTemplate: ResultType.Success };
+
+ test.use({
+ cassette: templatesCassette({
+ mutations: {
+ deleteFlowTemplate: [
+ {
+ data: deleted,
+ setFlag: 'template-deleted',
+ variables: { templateId: TEMPLATE_SEED.id },
+ },
+ ],
+ },
+ subscriptions: {
+ flowTemplateDeleted: [
+ {
+ frames: [
+ {
+ payload: { data: { flowTemplateDeleted: TEMPLATE_SEED } },
+ whenFlag: 'template-deleted',
+ },
+ ],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('deletes via the confirm dialog and the row drops off the list', async ({ page, pageErrorLog }) => {
+ await page.goto('/templates');
+
+ const row = page.getByRole('row', { name: /E2E Seed Template/ });
+
+ await row.hover();
+ await row.getByRole('button', { name: 'Open menu' }).click();
+ await page.getByRole('menuitem', { name: 'Delete' }).click();
+
+ const dialog = page.getByRole('dialog');
+
+ await expect(dialog.getByText('Delete template')).toBeVisible();
+ await dialog.getByRole('button', { name: 'Delete' }).click();
+
+ await expect(page.getByRole('row', { name: /E2E Seed Template/ })).toBeHidden();
+ await expect(page.getByText('No templates yet')).toBeVisible();
+ expectCleanPage(pageErrorLog);
+ });
+ });
+});
diff --git a/frontend/e2e/specs/flows/lifecycle.spec.ts b/frontend/e2e/specs/flows/lifecycle.spec.ts
new file mode 100644
index 00000000..c175a354
--- /dev/null
+++ b/frontend/e2e/specs/flows/lifecycle.spec.ts
@@ -0,0 +1,165 @@
+import type { ResultOf } from '@graphql-typed-document-node/core';
+
+import type {
+ AddFavoriteFlowDocument,
+ DeleteFlowDocument,
+ FinishFlowDocument,
+ RenameFlowDocument,
+} from '@/graphql/types';
+
+import { ResultType, StatusType } from '@/graphql/types';
+
+import { expect, test } from '../../fixtures/test.ts';
+import { entity } from '../../mocks/cassette.ts';
+import { FLOW_A, flowsCassette, makeFlow } from '../../mocks/cassettes/flows.ts';
+
+const openFlowA = async (page: import('@playwright/test').Page) => {
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByRole('button', { name: 'Flow actions' })).toBeVisible();
+};
+
+test.describe('flow lifecycle', { tag: '@flows' }, () => {
+ test.describe('rename', () => {
+ const renamed: ResultOf<typeof RenameFlowDocument> = { renameFlow: ResultType.Success };
+
+ test.use({
+ cassette: flowsCassette({
+ mutations: { renameFlow: [{ data: renamed, setFlag: 'flow-renamed' }] },
+ subscriptions: {
+ flowUpdated: [
+ {
+ frames: [
+ {
+ payload: { data: { flowUpdated: makeFlow('5', 'E2E Alpha Renamed') } },
+ whenFlag: 'flow-renamed',
+ },
+ ],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('renames from the actions menu and the title persists', async ({ page }) => {
+ await openFlowA(page);
+ await page.getByRole('button', { name: 'Flow actions' }).click();
+ await page.getByRole('menuitem', { name: 'Rename' }).click();
+ await page.getByPlaceholder('Flow title').fill('E2E Alpha Renamed');
+ await page.getByPlaceholder('Flow title').press('Enter');
+
+ await expect(page.getByText('Flow renamed successfully')).toBeVisible();
+ await expect(page.locator('header').getByText('E2E Alpha Renamed', { exact: true })).toBeVisible();
+ });
+ });
+
+ test.describe('finish', () => {
+ const finished: ResultOf<typeof FinishFlowDocument> = { finishFlow: ResultType.Success };
+
+ test.use({
+ cassette: flowsCassette({
+ mutations: { finishFlow: [{ data: finished, setFlag: 'flow-finished' }] },
+ subscriptions: {
+ flowUpdated: [
+ {
+ frames: [
+ {
+ payload: {
+ data: { flowUpdated: makeFlow('5', 'E2E Alpha', StatusType.Finished) },
+ },
+ whenFlag: 'flow-finished',
+ },
+ ],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('finishes a running flow from the actions menu', async ({ page }) => {
+ await openFlowA(page);
+ await page.getByRole('button', { name: 'Flow actions' }).click();
+ await page.getByRole('menuitem', { name: 'Finish' }).click();
+
+ await expect(page.getByText('Flow finished successfully')).toBeVisible();
+
+ await page.getByRole('button', { name: 'Flow actions' }).click();
+
+ await expect(page.getByRole('menuitem', { name: 'Finish' })).toBeHidden();
+ });
+ });
+
+ test.describe('favorite', () => {
+ const favorited: ResultOf<typeof AddFavoriteFlowDocument> = { addFavoriteFlow: ResultType.Success };
+
+ // The star is useOptimistic and reverts once the mutation settles — the
+ // persisted state only arrives via the settingsUserUpdated frame.
+ test.use({
+ cassette: flowsCassette({
+ mutations: { addFavoriteFlow: [{ data: favorited, setFlag: 'flow-favorited' }] },
+ subscriptions: {
+ settingsUserUpdated: [
+ {
+ frames: [
+ {
+ payload: {
+ data: {
+ settingsUserUpdated: entity('UserPreferences', {
+ favoriteFlows: ['5'],
+ id: '1',
+ }),
+ },
+ },
+ whenFlag: 'flow-favorited',
+ },
+ ],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('toggles the favorite star', async ({ page }) => {
+ await openFlowA(page);
+
+ const star = page.locator('header').getByRole('button', { name: 'Toggle favorite' });
+
+ await expect(star).toHaveAttribute('aria-pressed', 'false');
+ await star.click();
+ await expect(star).toHaveAttribute('aria-pressed', 'true');
+ });
+ });
+
+ test.describe('delete', () => {
+ const deleted: ResultOf<typeof DeleteFlowDocument> = { deleteFlow: ResultType.Success };
+
+ test.use({
+ cassette: flowsCassette({
+ mutations: { deleteFlow: [{ data: deleted, setFlag: 'flow-deleted' }] },
+ subscriptions: {
+ flowDeleted: [
+ {
+ frames: [{ payload: { data: { flowDeleted: FLOW_A } }, whenFlag: 'flow-deleted' }],
+ },
+ ],
+ },
+ }),
+ });
+
+ test('deletes via the destructive confirm and drops off the list', async ({ page }) => {
+ await openFlowA(page);
+ await page.getByRole('button', { name: 'Flow actions' }).click();
+ await page.getByRole('menuitem', { name: 'Delete' }).click();
+
+ const dialog = page.getByRole('dialog');
+
+ await expect(dialog.getByText('Delete flow')).toBeVisible();
+ await dialog.getByRole('button', { name: 'Delete' }).click();
+
+ await expect(page.getByText('Flow deleted successfully')).toBeVisible();
+ await expect(page).toHaveURL(/\/flows$/);
+ await expect(page.getByRole('row', { name: /E2E Beta/ })).toBeVisible();
+ await expect(page.getByRole('row', { name: /E2E Alpha/ })).toBeHidden();
+ });
+ });
+});
diff --git a/frontend/e2e/specs/flows/reconnect.spec.ts b/frontend/e2e/specs/flows/reconnect.spec.ts
new file mode 100644
index 00000000..60faba14
--- /dev/null
+++ b/frontend/e2e/specs/flows/reconnect.spec.ts
@@ -0,0 +1,33 @@
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { dropAndReconnect } from '../../helpers/reconnect.ts';
+import { assertNoDuplicates, extractMessageIds, MESSAGE_ID_TESTID } from '../../helpers/subscriptions.ts';
+import {
+ FLOW_A_INITIAL_IDS,
+ FLOW_A_RECONNECT_ID,
+ FLOW_A_STREAMED_IDS,
+ flowsCassette,
+} from '../../mocks/cassettes/flows.ts';
+
+const BEFORE_DROP = [...FLOW_A_INITIAL_IDS, ...FLOW_A_STREAMED_IDS];
+const AFTER_RECONNECT = [...BEFORE_DROP, FLOW_A_RECONNECT_ID];
+
+test.describe('flow reconnect', { tag: ['@flows', '@smoke'] }, () => {
+ test.use({ cassette: flowsCassette() });
+
+ test('reconciles the missed delta exactly once after a socket drop', async ({ page, pageErrorLog, world }) => {
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByTestId(MESSAGE_ID_TESTID)).toHaveCount(BEFORE_DROP.length);
+
+ await dropAndReconnect(page, world);
+
+ await expect(page.getByTestId(MESSAGE_ID_TESTID)).toHaveCount(AFTER_RECONNECT.length);
+
+ const ids = await extractMessageIds(page.locator('body'));
+
+ assertNoDuplicates(ids);
+ expect([...ids].sort()).toEqual([...AFTER_RECONNECT].sort());
+ expectCleanPage(pageErrorLog);
+ });
+});
diff --git a/frontend/e2e/specs/flows/subscriptions.spec.ts b/frontend/e2e/specs/flows/subscriptions.spec.ts
new file mode 100644
index 00000000..79457b82
--- /dev/null
+++ b/frontend/e2e/specs/flows/subscriptions.spec.ts
@@ -0,0 +1,65 @@
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import {
+ assertDisjoint,
+ assertNoDuplicates,
+ attachIdSet,
+ extractMessageIds,
+ MESSAGE_ID_TESTID,
+} from '../../helpers/subscriptions.ts';
+import {
+ FLOW_A_INITIAL_IDS,
+ FLOW_A_STREAMED_IDS,
+ FLOW_B_INITIAL_IDS,
+ FLOW_B_STREAMED_IDS,
+ flowsCassette,
+} from '../../mocks/cassettes/flows.ts';
+
+const FLOW_A_IDS = [...FLOW_A_INITIAL_IDS, ...FLOW_A_STREAMED_IDS];
+const FLOW_B_IDS = [...FLOW_B_INITIAL_IDS, ...FLOW_B_STREAMED_IDS];
+
+test.describe('flow subscriptions', { tag: ['@flows', '@smoke'] }, () => {
+ test.use({ cassette: flowsCassette() });
+
+ test('streams messages without duplicates within a flow', async ({ page, pageErrorLog }, testInfo) => {
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+
+ await expect(page.getByTestId(MESSAGE_ID_TESTID)).toHaveCount(FLOW_A_IDS.length);
+
+ const ids = await extractMessageIds(page.locator('body'));
+
+ assertNoDuplicates(ids);
+ expect([...ids].sort()).toEqual([...FLOW_A_IDS].sort());
+ await attachIdSet(testInfo, 'flow-5-message-ids', ids);
+ expectCleanPage(pageErrorLog);
+ });
+
+ test('keeps concurrent flows exact-set disjoint across a round trip', async ({ page, pageErrorLog }, testInfo) => {
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByTestId(MESSAGE_ID_TESTID)).toHaveCount(FLOW_A_IDS.length);
+
+ const idsA = await extractMessageIds(page.locator('body'));
+
+ await page.goBack();
+ await page.getByRole('row', { name: /E2E Beta/ }).click();
+ await expect(page.getByTestId(MESSAGE_ID_TESTID)).toHaveCount(FLOW_B_IDS.length);
+
+ const idsB = await extractMessageIds(page.locator('body'));
+
+ assertNoDuplicates(idsB);
+ assertDisjoint(idsA, idsB);
+ await attachIdSet(testInfo, 'flow-5-message-ids', idsA);
+ await attachIdSet(testInfo, 'flow-6-message-ids', idsB);
+
+ await page.goBack();
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+ await expect(page.getByTestId(MESSAGE_ID_TESTID)).toHaveCount(FLOW_A_IDS.length);
+
+ const idsAgain = await extractMessageIds(page.locator('body'));
+
+ expect([...idsAgain].sort(), 'round trip must not change the set').toEqual([...idsA].sort());
+ expectCleanPage(pageErrorLog);
+ });
+});
diff --git a/frontend/e2e/specs/flows/terminal.spec.ts b/frontend/e2e/specs/flows/terminal.spec.ts
new file mode 100644
index 00000000..dcfa9300
--- /dev/null
+++ b/frontend/e2e/specs/flows/terminal.spec.ts
@@ -0,0 +1,20 @@
+import { expect, test } from '../../fixtures/test.ts';
+import { expectCleanPage } from '../../helpers/errors.ts';
+import { readTerminalBuffer } from '../../helpers/terminal.ts';
+import { flowsCassette, TERMINAL_OUTPUT } from '../../mocks/cassettes/flows.ts';
+
+test.describe('flow terminal', { tag: '@flows' }, () => {
+ test.use({ cassette: flowsCassette() });
+
+ test('renders sandbox output readable through the xterm buffer', async ({ page, pageErrorLog }) => {
+ await page.goto('/flows');
+ await page.getByRole('row', { name: /E2E Alpha/ }).click();
+
+ await expect(page.locator('.xterm')).toBeVisible();
+ await expect(async () => {
+ expect(await readTerminalBuffer(page)).toContain(TERMINAL_OUTPUT);
+ }).toPass();
+ expect(await readTerminalBuffer(page)).toContain('uname -a');
+ expectCleanPage(pageErrorLog);
+ });
+});
diff --git a/frontend/eslint.config.mjs b/frontend/eslint.config.mjs
index 06302f37..09aa9df5 100644
--- a/frontend/eslint.config.mjs
+++ b/frontend/eslint.config.mjs
@@ -2,6 +2,7 @@
import { FlatCompat } from '@eslint/eslintrc';
import js from '@eslint/js';
import perfectionist from 'eslint-plugin-perfectionist';
+import playwright from 'eslint-plugin-playwright';
const compat = new FlatCompat({
baseDirectory: import.meta.dirname,
@@ -92,6 +93,10 @@ const eslintConfig = [
rules: { 'no-restricted-syntax': 'off' },
},
perfectionist.configs['recommended-natural'],
+ {
+ ...playwright.configs['flat/recommended'],
+ files: ['e2e/**/*.ts'],
+ },
{
// Playwright fixtures take a `use` callback that the React hooks rule
// mistakes for a hook call; there is no React under e2e/.
diff --git a/frontend/package.json b/frontend/package.json
index 97e9214b..c905c7d2 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -94,6 +94,7 @@
"zod": "^4.4.3"
},
"devDependencies": {
+ "@axe-core/playwright": "^4.12.1",
"@eslint/eslintrc": "^3.3.5",
"@eslint/js": "^9.39.4",
"@graphql-codegen/cli": "^7.1.3",
@@ -117,6 +118,7 @@
"eslint": "^9.39.4",
"eslint-config-prettier": "^10.1.8",
"eslint-plugin-perfectionist": "^5.9.1",
+ "eslint-plugin-playwright": "^2.10.5",
"eslint-plugin-react": "^7.37.5",
"eslint-plugin-react-hooks": "^7.1.1",
"jsdom": "^29.1.1",
diff --git a/frontend/pnpm-lock.yaml b/frontend/pnpm-lock.yaml
index 78a2b3f5..17469df2 100644
--- a/frontend/pnpm-lock.yaml
+++ b/frontend/pnpm-lock.yaml
@@ -228,6 +228,9 @@ importers:
specifier: ^4.4.3
version: 4.4.3
devDependencies:
+ '@axe-core/playwright':
+ specifier: ^4.12.1
+ version: 4.12.1([email protected])
'@eslint/eslintrc':
specifier: ^3.3.5
version: 3.3.5
@@ -297,6 +300,9 @@ importers:
eslint-plugin-perfectionist:
specifier: ^5.9.1
+ eslint-plugin-playwright:
+ specifier: ^2.10.5
eslint-plugin-react:
specifier: ^7.37.5
@@ -385,6 +391,11 @@ packages:
'@asamuzakjp/[email protected]':
resolution: {integrity: sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==}
+ '@axe-core/[email protected]':
+ resolution: {integrity: sha512-rMd7xriptqKpP+w5265i4Hdkv2X5kbu6uiBi/B2I7uf3hieRBM3qDCfaKPtxfiYb2mKXfF+yLODJwIx+Jv1GDw==}
+ peerDependencies:
+ playwright-core: '>= 1.0.0'
+
resolution: {integrity: sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==}
engines: {node: '>=6.9.0'}
@@ -2702,6 +2713,10 @@ packages:
resolution: {integrity: sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ==}
engines: {node: '>= 0.4'}
+ resolution: {integrity: sha512-s7iGf5GaVMxEG0ENN9x+xTr7GFZCb1ZP/1uATUpCEK2X78nDB3RwbtFCo9pGAf9ru+VwoQ464DkaLEeRM08wJA==}
+ engines: {node: '>=4'}
+
resolution: {integrity: sha512-E32NzpYKp++W7XRe52rHiXV2ehxmh3wbdgO7MHeFM+vqxLBYHzt0ElkiImtOBxtOmyp0yoC8C6uESVV84Y2/hw==}
@@ -3259,6 +3274,12 @@ packages:
peerDependencies:
eslint: ^8.45.0 || ^9.0.0 || ^10.0.0
+ resolution: {integrity: sha512-4k+ml4cEd55kePUIW1WsCiOLDwZkAdPZPKMFulR83XpplCaVOTKHF6yvXLYixLtdVbkMjmKV5F3BaGuI3aH8aQ==}
+ engines: {node: '>=16.9.0'}
+ peerDependencies:
+ eslint: '>=8.40.0'
+
resolution: {integrity: sha512-f2I7Gw6JbvCexzIInuSbZpfdQ44D7iqdWX01FKLvrPgqxoE7oMj8clOfto8U6vYiz4yd5oKu39rRSVOe1zRu0g==}
engines: {node: '>=18'}
@@ -3519,6 +3540,10 @@ packages:
resolution: {integrity: sha512-oahGvuMGQlPw/ivIYBjVSrWAfWLBeku5tpPE2fOPLi+WHffIWbuh2tCjhyQhTBPMf5E9jDEH4FOmTYgYwbKwtQ==}
engines: {node: '>=18'}
+ resolution: {integrity: sha512-Czmyns5dUsq4seFBR/Kdydhmo8y9kC79hiSkPn0YcGtNnYWnrgt0vjrSjx9tspoDGWm2CMarffRuLjM4xUz8xg==}
+ engines: {node: '>=18'}
+
resolution: {integrity: sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==}
engines: {node: '>= 0.4'}
@@ -5655,6 +5680,11 @@ snapshots:
'@asamuzakjp/[email protected]': {}
+ dependencies:
+ axe-core: 4.12.1
+ playwright-core: 1.61.1
+
dependencies:
'@babel/helper-validator-identifier': 7.29.7
@@ -8148,6 +8178,8 @@ snapshots:
dependencies:
possible-typed-array-names: 1.1.0
+
dependencies:
follow-redirects: 1.16.0
@@ -8766,6 +8798,11 @@ snapshots:
- supports-color
- typescript
+ dependencies:
+ eslint: 9.39.4([email protected])
+ globals: 17.7.0
+
dependencies:
'@babel/core': 7.29.7
@@ -9065,6 +9102,8 @@ snapshots:
+
dependencies:
define-properties: 1.2.1
diff --git a/frontend/src/components/shared/terminal/use-xterm.ts b/frontend/src/components/shared/terminal/use-xterm.ts
index 072a87e5..94b48c92 100644
--- a/frontend/src/components/shared/terminal/use-xterm.ts
+++ b/frontend/src/components/shared/terminal/use-xterm.ts
@@ -38,6 +38,10 @@ export interface UseXtermResult {
* Requires Ctrl+Click (Cmd+Click on Mac) to open links per
* https://xtermjs.org/docs/guides/link-handling/
*/
+export interface XtermHostElement extends HTMLDivElement {
+ xterm?: Terminal;
+}
+
export function useXterm({ theme }: { theme: 'dark' | 'light' | 'system' }): UseXtermResult {
const containerRef = useRef<HTMLDivElement | null>(null);
const terminalRef = useRef<null | Terminal>(null);
@@ -171,6 +175,9 @@ export function useXterm({ theme }: { theme: 'dark' | 'light' | 'system' }): Use
});
terminalRef.current = terminal;
+ // The buffer is unreachable from the DOM (WebGL canvas) — this handle is
+ // how e2e asserts and devtools read terminal content.
+ (container as XtermHostElement).xterm = terminal;
const rafId = requestAnimationFrame(() => {
if (!mounted) {
@@ -226,6 +233,7 @@ export function useXterm({ theme }: { theme: 'dark' | 'light' | 'system' }): Use
}
terminalRef.current = null;
+ delete (container as XtermHostElement).xterm;
setSearchAddon(null);
setIsReady(false);
};
diff --git a/frontend/src/components/ui/data-table.tsx b/frontend/src/components/ui/data-table.tsx
index c75e464f..cb799e91 100644
--- a/frontend/src/components/ui/data-table.tsx
+++ b/frontend/src/components/ui/data-table.tsx
@@ -844,7 +844,10 @@ function DataTable<TData, TValue = unknown>({
}}
value={pageSizeValue}
>
- <SelectTrigger className="h-7 w-16 text-xs">
+ <SelectTrigger
+ aria-label="Rows per page"
+ className="h-7 w-16 text-xs"
+ >
<SelectValue />
</SelectTrigger>
<SelectContent
diff --git a/frontend/src/features/flows/messages/flow-message.tsx b/frontend/src/features/flows/messages/flow-message.tsx
index b0346545..7f8cb0e3 100644
--- a/frontend/src/features/flows/messages/flow-message.tsx
+++ b/frontend/src/features/flows/messages/flow-message.tsx
@@ -208,7 +208,12 @@ function FlowMessage({ log, searchValue = '' }: FlowMessageProps) {
<TooltipContent>Copy</TooltipContent>
</Tooltip>
<span className="text-muted-foreground/50">{formatDate(new Date(createdAt))}</span>
- <span className="text-muted-foreground/50">{log.id}</span>
+ <span
+ className="text-muted-foreground/50"
+ data-testid="flow-message-id"
+ >
+ {log.id}
+ </span>
</div>
</div>
);