@rimori/playwright-testing 0.3.5 → 0.3.6-next.1

package/dist/core/RimoriE2ETestEnvironment.d.ts

@@ -0,0 +1,48 @@
+import { Browser, Page } from '@playwright/test';
+interface RimoriE2ETestEnvironmentOptions {
+    browser: Browser;
+    pluginId: string;
+}
+interface Exercise {
+    title: string;
+    description: string;
+    pluginId: string;
+    actionKey: string;
+    parameters?: Record<string, unknown>;
+}
+export interface Onboarding {
+    motivation_type?: string;
+    preferred_genre?: string;
+    target_country?: string;
+    target_city?: string;
+}
+interface SetupOptions {
+    onboarding?: Onboarding;
+    exercises?: Array<Exercise>;
+    studyPlan?: {
+        complete: boolean;
+    };
+}
+export declare class RimoriE2ETestEnvironment {
+    private browser;
+    private pluginId;
+    private persistentUserContext;
+    private tempUserContext;
+    private testUserEmail;
+    private existingUserEmail;
+    private authToken;
+    constructor(options: RimoriE2ETestEnvironmentOptions);
+    setup({ onboarding, exercises, studyPlan }?: SetupOptions): Promise<void>;
+    getTempUserPage(): Promise<Page>;
+    getPersistUserPage(): Promise<Page>;
+    getTempUserEmail(): string;
+    getPersistUserEmail(): string;
+    private createTestUserViaApi;
+    private deleteTestUserViaApi;
+    private setupConsoleLogging;
+    private setSessionFromMagicLink;
+    private completeOnboarding;
+    private completeExerciseSetup;
+    private completeStudyPlanCreation;
+}
+export {};

package/dist/core/RimoriE2ETestEnvironment.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RimoriE2ETestEnvironment = void 0;
+const dotenv_1 = require("dotenv");
+const study_plan_setup_1 = require("../helpers/e2e/study-plan-setup");
+const onboarding_1 = require("../helpers/e2e/onboarding");
+(0, dotenv_1.config)();
+const RIMORI_URL = 'https://dev-app.rimori.se';
+const BACKEND_URL = 'http://localhost:2800';
+class RimoriE2ETestEnvironment {
+    constructor(options) {
+        this.persistentUserContext = null;
+        this.tempUserContext = null;
+        this.testUserEmail = null;
+        this.existingUserEmail = null;
+        this.authToken = null;
+        this.browser = options.browser;
+        this.pluginId = options.pluginId;
+        this.authToken = process.env.RIMORI_TOKEN ?? '';
+        if (!this.authToken) {
+            throw new Error('RIMORI_TOKEN is not set as an environment variable.');
+        }
+    }
+    async setup({ onboarding, exercises, studyPlan } = {}) {
+        const onboardingData = {
+            motivation_type: onboarding?.motivation_type ?? 'accomplishment',
+            preferred_genre: onboarding?.preferred_genre ?? 'comedy',
+            target_country: onboarding?.target_country ?? 'SE',
+            target_city: onboarding?.target_city ?? 'Malmö',
+        };
+        // Step 1: Create both test users (temp + persist) via API
+        const { temp, persist } = await this.createTestUserViaApi();
+        this.testUserEmail = temp.email;
+        this.existingUserEmail = persist.email;
+        console.log(`[E2E] Test user (temp): ${temp.email}`);
+        console.log(`[E2E] Existing user (persist): ${persist.email}`);
+        this.tempUserContext = await this.browser.newContext({ baseURL: RIMORI_URL });
+        this.persistentUserContext = await this.browser.newContext({ baseURL: RIMORI_URL });
+        await this.setupConsoleLogging(this.tempUserContext, 'temp');
+        await this.setupConsoleLogging(this.persistentUserContext, 'persist');
+        console.log(`[E2E] Preparing existing user context`);
+        // Step 2: Set up existing user browser context with session via magic link
+        await this.setSessionFromMagicLink(this.persistentUserContext, persist.magicLink);
+        // Step 3: Run onboarding for existing user
+        await this.completeOnboarding(this.persistentUserContext, onboardingData);
+        console.log(`[E2E] Setting up test user context`);
+        // Step 4: Set up test user browser context with session via magic link
+        await this.setSessionFromMagicLink(this.tempUserContext, temp.magicLink);
+        // Delete test user when test user context is closed
+        this.tempUserContext.on('close', async () => {
+            await this.deleteTestUserViaApi(temp.email);
+            console.log(`[E2E] Deleted test user: ${temp.email}`);
+        });
+        // Step 5: Run onboarding for test user with e2e plugin flag
+        await this.completeOnboarding(this.tempUserContext, onboardingData, this.pluginId);
+        // Step 6: Add exercises if specified
+        if (exercises && exercises?.length > 0) {
+            console.log(`[E2E] Setting up exercises`);
+            await this.completeExerciseSetup(this.tempUserContext, exercises);
+        }
+        // Step 7: Complete study plan creation if specified
+        if (studyPlan?.complete) {
+            console.log(`[E2E] Setting up study plan`);
+            await this.completeStudyPlanCreation(this.tempUserContext);
+        }
+        console.log(`[E2E] Setup completed`);
+    }
+    async getTempUserPage() {
+        if (!this.tempUserContext) {
+            throw new Error('Test user context not initialized. Call setup() first.');
+        }
+        return this.tempUserContext.newPage();
+    }
+    async getPersistUserPage() {
+        if (!this.persistentUserContext) {
+            throw new Error('Existing user context not initialized. Call setup() first.');
+        }
+        return this.persistentUserContext.newPage();
+    }
+    getTempUserEmail() {
+        if (!this.testUserEmail) {
+            throw new Error('Test user not created. Call setup() first.');
+        }
+        return this.testUserEmail;
+    }
+    getPersistUserEmail() {
+        if (!this.existingUserEmail) {
+            throw new Error('Existing user not created. Call setup() first.');
+        }
+        return this.existingUserEmail;
+    }
+    async createTestUserViaApi() {
+        const response = await fetch(`${BACKEND_URL}/testing/test-user`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.authToken}`,
+            },
+            body: JSON.stringify({
+                plugin_id: this.pluginId,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to create test user: ${response.status} ${errorText}`);
+        }
+        return response.json();
+    }
+    async deleteTestUserViaApi(email) {
+        const response = await fetch(`${BACKEND_URL}/testing/test-user`, {
+            method: 'DELETE',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.authToken}`,
+            },
+            body: JSON.stringify({
+                plugin_id: this.pluginId,
+                email,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to delete test user: ${response.status} ${errorText}`);
+        }
+    }
+    async setupConsoleLogging(context, user) {
+        console.log(`[E2E] Setting up console logging for ${user}`);
+        context.on('console', (msg) => {
+            const logLevel = msg.type();
+            const logMessage = msg.text();
+            if (logLevel === 'debug')
+                return;
+            if (logMessage.includes('Download the React DevTools'))
+                return;
+            if (logMessage.includes('languageChanged en'))
+                return;
+            if (logMessage.includes('i18next: initialized {debug: true'))
+                return;
+            console.log(`[browser:${logLevel}] [${user}]`, logMessage);
+        });
+    }
+    async setSessionFromMagicLink(context, magicLink) {
+        const page = await context.newPage();
+        await page.goto(magicLink, { waitUntil: 'networkidle' });
+        await page.waitForTimeout(5000);
+        const url = page.url();
+        if (!url.includes('/dashboard') && !url.includes('/onboarding')) {
+            throw new Error(`Failed to set session from magic link: ${url}`);
+        }
+        await page.close();
+        console.log(`[E2E] Authentication completed`);
+    }
+    async completeOnboarding(context, onboarding, e2ePluginId) {
+        console.log(`[E2E] Starting onboarding`);
+        const page = await context.newPage();
+        await page.goto('/onboarding');
+        await page.waitForTimeout(5000);
+        const isOnboaded = page.url().includes('/dashboard');
+        if (!isOnboaded) {
+            console.log(`[E2E] Onboarding user`);
+            await (0, onboarding_1.completeOnboarding)(page, onboarding, e2ePluginId);
+            console.log(`[E2E] Onboarding completed`);
+        }
+        else {
+            console.log(`[E2E] User already onboarded`);
+        }
+        await page.close();
+    }
+    async completeExerciseSetup(context, exercises) {
+        const page = await context.newPage();
+        for (const exercise of exercises) {
+            const encoded = encodeURIComponent(JSON.stringify(exercise));
+            await page.goto(`${RIMORI_URL}/dashboard?flag-e2e-exercise=${encoded}`);
+            // Wait for the exercise to be created and the flag to be cleared from URL
+            await page.waitForURL((url) => !url.searchParams.has('flag-e2e-exercise'), { timeout: 15000 });
+        }
+        await page.close();
+    }
+    async completeStudyPlanCreation(context) {
+        const page = await context.newPage();
+        await (0, study_plan_setup_1.completeStudyPlanGettingStarted)(page);
+        await page.close();
+    }
+}
+exports.RimoriE2ETestEnvironment = RimoriE2ETestEnvironment;

package/dist/core/RimoriTestEnvironment.d.ts

@@ -79,6 +79,19 @@ export declare class RimoriTestEnvironment {
      * Removes a one-time mock from the mocks array after it's been used.
      */
     private removeOneTimeMock;
+    /**
+     * Creates a wrapper around the Playwright Request object that provides backwards compatibility
+     * for matchers. The new rimori-client sends `messages` array instead of `instructions`,
+     * so this wrapper extracts the prompts from messages and provides them as `instructions`.
+     *
+     * The old API had a single `instructions` field which typically contained the user's specific
+     * instruction (what the AI should do). The new API splits this into:
+     * - systemPrompt (messages[0] with role='system'): High-level behavior instructions
+     * - userPrompt (messages[1] with role='user'): Specific task instruction
+     *
+     * For backwards compatibility, we concatenate all message contents into `instructions`.
+     */
+    private createBackwardsCompatibleRequest;
     private handleRoute;
     /**
      * Adds a supabase route to the supabase routes object.
@@ -216,21 +229,45 @@ export declare class RimoriTestEnvironment {
         triggerOnMainPanelAction: (payload: MainPanelAction) => Promise<void>;
     };
     readonly ai: {
+        /**
+         * Mocks a text response from the LLM endpoint.
+         * Since getText now uses streamObject internally with a { result: string } schema,
+         * the mock value should be the full response object.
+         *
+         * @param values - The response object to return. Should include { result: string } for getText calls.
+         * @param options - Optional mock options.
+         */
         mockGetText: (values: unknown, options?: MockOptions) => void;
         /**
          * Mocks a streaming text response from the LLM endpoint.
-         * The text will be formatted as SSE (Server-Sent Events) to simulate streaming.
+         * The new rimori-client's getSteamedText uses streamObject internally with { result: string } schema,
+         * so the text is wrapped in a result object.
          *
          * **Note**: Due to Playwright's route.fulfill() requiring a complete response body,
          * all SSE chunks are sent at once (no delays). The client will still parse it as SSE correctly.
          *
-         * @param text - The text to stream. Will be formatted as SSE chunks.
+         * @param text - The text to stream. Will be wrapped as { result: text } and formatted as SSE.
          * @param options - Optional mock options.
          */
         mockGetSteamedText: (text: string, options?: MockOptions) => void;
         mockGetVoice: (values: Buffer, options?: MockOptions) => void;
         mockGetTextFromVoice: (text: string, options?: MockOptions) => void;
+        /**
+         * Mocks an object response from the LLM endpoint.
+         * Since getObject now uses streamObject internally, this is a streaming response.
+         *
+         * @param value - The object to return from the LLM.
+         * @param options - Optional mock options.
+         */
         mockGetObject: (value: Record<string, unknown>, options?: MockOptions) => void;
+        /**
+         * Mocks a streaming object response from the LLM endpoint.
+         * Returns the object via SSE format with data: prefix.
+         *
+         * @param value - The object to stream from the LLM.
+         * @param options - Optional mock options.
+         */
+        mockGetStreamedObject: (value: Record<string, unknown>, options?: MockOptions) => void;
     };
     /**
      * Helpers for tracking browser audio playback in tests.

package/dist/core/RimoriTestEnvironment.js

@@ -47,7 +47,13 @@ class RimoriTestEnvironment {
                 this.addSupabaseRoute('plugin_settings', response, { ...options, method: 'POST' });
             },
             mockGetUserInfo: (userInfo, options) => {
-                this.addSupabaseRoute('/user-info', { ...this.rimoriInfo.profile, ...userInfo }, { ...options, delay: 0 });
+                // Update the rimoriInfo.profile so that MessageChannelSimulator returns the correct user info
+                this.rimoriInfo.profile = { ...this.rimoriInfo.profile, ...userInfo };
+                // Also update the MessageChannelSimulator if it exists (setup() has been called)
+                if (this.messageChannelSimulator) {
+                    this.messageChannelSimulator.setUserInfo(this.rimoriInfo.profile);
+                }
+                this.addSupabaseRoute('/user-info', this.rimoriInfo.profile, { ...options, delay: 0 });
             },
             mockGetPluginInfo: (pluginInfo, options) => {
                 this.addSupabaseRoute('/plugin-info', pluginInfo, options);
@@ -191,23 +197,31 @@ class RimoriTestEnvironment {
             },
         };
         this.ai = {
+            /**
+             * Mocks a text response from the LLM endpoint.
+             * Since getText now uses streamObject internally with a { result: string } schema,
+             * the mock value should be the full response object.
+             *
+             * @param values - The response object to return. Should include { result: string } for getText calls.
+             * @param options - Optional mock options.
+             */
             mockGetText: (values, options) => {
-                console.log('Mocking get text for mockGetText', values, options);
-                console.warn('mockGetText is not tested');
-                this.addBackendRoute('/llm-text', values, options);
+                this.addBackendRoute('/ai/llm', values, { ...options, isStreaming: true });
             },
             /**
              * Mocks a streaming text response from the LLM endpoint.
-             * The text will be formatted as SSE (Server-Sent Events) to simulate streaming.
+             * The new rimori-client's getSteamedText uses streamObject internally with { result: string } schema,
+             * so the text is wrapped in a result object.
              *
              * **Note**: Due to Playwright's route.fulfill() requiring a complete response body,
              * all SSE chunks are sent at once (no delays). The client will still parse it as SSE correctly.
              *
-             * @param text - The text to stream. Will be formatted as SSE chunks.
+             * @param text - The text to stream. Will be wrapped as { result: text } and formatted as SSE.
              * @param options - Optional mock options.
              */
             mockGetSteamedText: (text, options) => {
-                this.addBackendRoute('/ai/llm', text, { ...options, isStreaming: true });
+                // Wrap text in result object as the new client expects { result: string }
+                this.addBackendRoute('/ai/llm', { result: text }, { ...options, isStreaming: true });
             },
             mockGetVoice: (values, options) => {
                 this.addBackendRoute('/voice/tts', values, options);
@@ -215,8 +229,25 @@ class RimoriTestEnvironment {
             mockGetTextFromVoice: (text, options) => {
                 this.addBackendRoute('/voice/stt', text, options);
             },
+            /**
+             * Mocks an object response from the LLM endpoint.
+             * Since getObject now uses streamObject internally, this is a streaming response.
+             *
+             * @param value - The object to return from the LLM.
+             * @param options - Optional mock options.
+             */
             mockGetObject: (value, options) => {
-                this.addBackendRoute('/ai/llm-object', value, { ...options, method: 'POST' });
+                this.addBackendRoute('/ai/llm', value, { ...options, isStreaming: true });
+            },
+            /**
+             * Mocks a streaming object response from the LLM endpoint.
+             * Returns the object via SSE format with data: prefix.
+             *
+             * @param value - The object to stream from the LLM.
+             * @param options - Optional mock options.
+             */
+            mockGetStreamedObject: (value, options) => {
+                this.addBackendRoute('/ai/llm', value, { ...options, isStreaming: true });
             },
         };
         /**
@@ -767,6 +798,53 @@ class RimoriTestEnvironment {
             mocks.splice(index, 1);
         }
     }
+    /**
+     * Creates a wrapper around the Playwright Request object that provides backwards compatibility
+     * for matchers. The new rimori-client sends `messages` array instead of `instructions`,
+     * so this wrapper extracts the prompts from messages and provides them as `instructions`.
+     *
+     * The old API had a single `instructions` field which typically contained the user's specific
+     * instruction (what the AI should do). The new API splits this into:
+     * - systemPrompt (messages[0] with role='system'): High-level behavior instructions
+     * - userPrompt (messages[1] with role='user'): Specific task instruction
+     *
+     * For backwards compatibility, we concatenate all message contents into `instructions`.
+     */
+    createBackwardsCompatibleRequest(originalRequest) {
+        // Create a proxy that intercepts postDataJSON calls
+        return new Proxy(originalRequest, {
+            get(target, prop) {
+                if (prop === 'postDataJSON') {
+                    return () => {
+                        try {
+                            const body = target.postDataJSON();
+                            if (body && body.messages && Array.isArray(body.messages) && !body.instructions) {
+                                // Concatenate all message contents for backwards compatibility
+                                // This allows matchers to check for text that might be in either system or user prompts
+                                const allContent = body.messages
+                                    .map((m) => m.content || '')
+                                    .filter((content) => content.length > 0)
+                                    .join('\n');
+                                if (allContent) {
+                                    return { ...body, instructions: allContent };
+                                }
+                            }
+                            return body;
+                        }
+                        catch {
+                            return null;
+                        }
+                    };
+                }
+                // For all other properties, return the original value bound to the target
+                const value = target[prop];
+                if (typeof value === 'function') {
+                    return value.bind(target);
+                }
+                return value;
+            },
+        });
+    }
     async handleRoute(route, routes) {
         const request = route.request();
         const requestUrl = request.url();
@@ -780,6 +858,8 @@ class RimoriTestEnvironment {
             route.abort('not_found');
             return;
         }
+        // Create backwards-compatible request wrapper for matchers
+        const compatRequest = this.createBackwardsCompatibleRequest(request);
         // Find the first matching mock based on matcher function
         // Priority: mocks with matchers that match > mocks without matchers (as fallback)
         let matchingMock;
@@ -787,7 +867,8 @@ class RimoriTestEnvironment {
         for (const mock of mocks) {
             if (mock.options?.matcher) {
                 try {
-                    if (mock.options.matcher(request)) {
+                    // Use the backwards-compatible request wrapper for matchers
+                    if (mock.options.matcher(compatRequest)) {
                         matchingMock = mock;
                         break;
                     }
@@ -821,10 +902,19 @@ class RimoriTestEnvironment {
         if (typeof matchingMock.value === 'function') {
             responseValue = await matchingMock.value(request);
         }
-        // Handle streaming responses (for mockGetSteamedText)
+        // Handle streaming responses (for mockGetSteamedText and mockGetStreamedObject)
         // Since Playwright requires complete body, we format as SSE without delays
-        if (matchingMock.isStreaming && typeof responseValue === 'string') {
-            const body = this.formatAsSSE(responseValue);
+        if (matchingMock.isStreaming) {
+            let body;
+            if (typeof responseValue === 'string') {
+                // Text streaming (mockGetSteamedText)
+                body = this.formatAsSSE(responseValue);
+            }
+            else {
+                // Object streaming (mockGetStreamedObject)
+                // Format as SSE with JSON payload, followed by [DONE] marker
+                body = `data: ${JSON.stringify(responseValue)}\n\ndata: [DONE]\n\n`;
+            }
             return await route.fulfill({
                 status: 200,
                 headers: { 'Content-Type': 'text/event-stream' },

package/dist/helpers/e2e/onboarding.d.ts

@@ -0,0 +1,3 @@
+import { Page } from "@playwright/test";
+import { Onboarding } from "../../core/RimoriE2ETestEnvironment";
+export declare function completeOnboarding(page: Page, onboarding: Required<Onboarding>, e2ePluginId?: string): Promise<void>;

package/dist/helpers/e2e/onboarding.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeOnboarding = completeOnboarding;
+const test_1 = require("@playwright/test");
+async function completeOnboarding(page, onboarding, e2ePluginId) {
+    console.log(`[E2E] Onboarding user`);
+    console.log(`[E2E] E2E plugin ID: ${e2ePluginId}`);
+    console.log(`[E2E] Onboarding: ${JSON.stringify(onboarding)}`);
+    const url = e2ePluginId ? `/onboarding?flag-e2e-plugin-id=${e2ePluginId}` : `/onboarding`;
+    await page.goto(url, { waitUntil: 'networkidle' });
+    page.setDefaultTimeout(60000);
+    page.setDefaultNavigationTimeout(60000);
+    // Ensure we're on onboarding page
+    await (0, test_1.expect)(page).toHaveURL(/\/onboarding/);
+    // Step 1: Purpose/Long-term goal
+    const goalInput = page.locator('textarea, input[type="text"]');
+    await goalInput.waitFor({ state: 'visible' });
+    await goalInput.click();
+    await goalInput.fill("test goal");
+    const continueButton = page.getByRole('button', { name: /continue/i });
+    await (0, test_1.expect)(continueButton).toBeEnabled({ timeout: 10000 });
+    await continueButton.click();
+    // Step 2: Motivation type (auto-advances after selection)
+    // Wait for the motivation step heading to appear
+    const motivationHeading = page.getByText('What motivates you most?');
+    await (0, test_1.expect)(motivationHeading).toBeVisible({ timeout: 10000 });
+    const motivationOption = page.locator('label').filter({ hasText: '🏆Progress & Accomplishment' });
+    await (0, test_1.expect)(motivationOption).toBeVisible({ timeout: 10000 });
+    await motivationOption.click();
+    // Step 3: Genre preference (auto-advances after selection)
+    // Wait for the genre step heading to appear
+    const genreHeading = page.getByText('What kind of stories do you like most?');
+    await (0, test_1.expect)(genreHeading).toBeVisible({ timeout: 10000 });
+    const genreOption = page.locator('label').filter({ hasText: 'Comedy' });
+    await (0, test_1.expect)(genreOption).toBeVisible({ timeout: 10000 });
+    await genreOption.click();
+    // Step 4: Location
+    // Wait for the location step to appear
+    const countrySelect = page.getByLabel('Country');
+    await (0, test_1.expect)(countrySelect).toBeVisible({ timeout: 10000 });
+    await countrySelect.selectOption('SE');
+    await page.getByLabel('City (optional)').selectOption('Malmö');
+    await page.getByRole('button', { name: 'Continue' }).click();
+    // Step 5: Wait for setup completion
+    await (0, test_1.expect)(page.getByRole('heading', { name: 'Almost there!' })).toBeVisible({ timeout: 10000 });
+    await page.waitForURL('**/dashboard', { timeout: 120000 });
+    // await page.screenshot({ path: path.join(process.cwd(), 'playwright/dashboard.png') });
+    await (0, test_1.expect)(page.getByRole('heading', { name: "Today's Mission" })).toBeVisible({ timeout: 30000 });
+    await (0, test_1.expect)(page.getByRole('button', { name: 'Grammar', exact: true })).toBeVisible({ timeout: 60000 });
+    await (0, test_1.expect)(page.getByRole('heading', { name: 'Getting Started: Create your first study plan' })).toBeVisible({
+        timeout: 60000,
+    });
+    await (0, test_1.expect)(page.getByText('Train your first flashcard deck', { exact: true })).toBeVisible({ timeout: 200000 });
+    await (0, test_1.expect)(page.locator('iframe').contentFrame().getByRole('button', { name: 'Back to Plugins' })).toBeVisible({
+        timeout: 250000,
+    });
+}

package/dist/helpers/e2e/study-plan-setup.d.ts

@@ -0,0 +1,11 @@
+import { Page } from '@playwright/test';
+/**
+ * Navigates through the study plan getting-started flow on the dashboard.
+ * This clicks through the real UI: milestone planning (Submit Topics) and
+ * exercise creation (Save Exercises).
+ *
+ * Expects the page to already be on the dashboard with a "Getting Started" exercise visible.
+ *
+ * @param page - Playwright page instance, should be on the dashboard
+ */
+export declare function completeStudyPlanGettingStarted(page: Page): Promise<void>;

package/dist/helpers/e2e/study-plan-setup.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.completeStudyPlanGettingStarted = completeStudyPlanGettingStarted;
+const test_1 = require("@playwright/test");
+/**
+ * Navigates through the study plan getting-started flow on the dashboard.
+ * This clicks through the real UI: milestone planning (Submit Topics) and
+ * exercise creation (Save Exercises).
+ *
+ * Expects the page to already be on the dashboard with a "Getting Started" exercise visible.
+ *
+ * @param page - Playwright page instance, should be on the dashboard
+ */
+async function completeStudyPlanGettingStarted(page) {
+    page.goto('/dashboard');
+    await page.waitForTimeout(2000);
+    // Step 1: Find and click the Getting Started exercise card
+    const card = page.getByText('Getting Started: Create your first study plan', { exact: false });
+    await card.waitFor({ timeout: 10000, state: 'visible' }).catch(() => {
+        /* not visible within 10s, continue to early return below */
+    });
+    if (!(await card.isVisible())) {
+        page.close();
+        console.warn(`[E2E] Getting Started card not found, skipping study plan setup`);
+        return;
+    }
+    const gettingStartedCard = page.getByText('Start Exercise', { exact: false }).first();
+    await (0, test_1.expect)(gettingStartedCard).toBeVisible({ timeout: 30000 });
+    await gettingStartedCard.click();
+    // Wait for the study plan plugin iframe to load
+    const iframe = page.locator('iframe').first();
+    await (0, test_1.expect)(iframe).toBeVisible({ timeout: 30000 });
+    const frame = iframe.contentFrame();
+    // Step 2: Milestone Planning Stage
+    // Wait for the 3 milestone cards to appear (AI generates them)
+    await (0, test_1.expect)(frame.getByText('Week 1', { exact: false })).toBeVisible({ timeout: 180000 });
+    await (0, test_1.expect)(frame.getByText('Week 2', { exact: false })).toBeVisible({ timeout: 10000 });
+    await (0, test_1.expect)(frame.getByText('Week 3', { exact: false })).toBeVisible({ timeout: 10000 });
+    // Wait for "Submit Topics" button to be enabled and click it
+    const submitTopicsButton = frame.getByRole('button', { name: /submit topics/i });
+    await (0, test_1.expect)(submitTopicsButton).toBeEnabled({ timeout: 180000 });
+    await submitTopicsButton.click();
+    // Step 3: Exercise Creation Stage
+    // Wait for "Save Exercises" button to appear (AI generates all exercises)
+    const saveExercisesButton = frame.getByRole('button', { name: /save exercises/i });
+    await (0, test_1.expect)(saveExercisesButton).toBeVisible({ timeout: 300000 });
+    await (0, test_1.expect)(saveExercisesButton).toBeEnabled({ timeout: 30000 });
+    await saveExercisesButton.click();
+    // Wait for save to complete (button should disappear or page navigates)
+    await (0, test_1.expect)(saveExercisesButton).toBeHidden({ timeout: 30000 });
+    // Step 4: Verify completion - should be back on dashboard
+    // The "Getting Started" card should be gone and exercises should appear
+    await (0, test_1.expect)(page.getByText("Today's Mission", { exact: false })).toBeVisible({ timeout: 30000 });
+}

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './core/RimoriTestEnvironment';
+export * from './core/RimoriE2ETestEnvironment';

package/dist/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./core/RimoriTestEnvironment"), exports);
+__exportStar(require("./core/RimoriE2ETestEnvironment"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimori/playwright-testing",
-  "version": "0.3.5",
+  "version": "0.3.6-next.1",
   "description": "Playwright testing utilities for Rimori plugins and workers",
   "license": "Apache-2.0",
   "repository": {
@@ -21,13 +21,16 @@
     "test:ui": "playwright test --ui",
     "test:headed:debug": "playwright test --headed --debug"
   },
+  "dependencies": {
+    "dotenv": "^16.4.5"
+  },
   "peerDependencies": {
     "@playwright/test": "^1.40.0",
-    "@rimori/client": "^2.5.8"
+    "@rimori/client": "2.5.12-next.4"
   },
   "devDependencies": {
     "@playwright/test": "^1.40.0",
-    "@rimori/client": "^2.5.8",
+    "@rimori/client": "2.5.12-next.4",
     "@types/node": "^20.12.7",
     "rimraf": "^5.0.7",
     "typescript": "^5.7.2"