Merge pull request #10 from AzemaViator/feat/persistent-context-launch

Feat: persistent context launch

Author: fiws

src/playwright.test.ts

@@ -2,6 +2,7 @@ import { assert, layer } from "@effect/vitest";
 import { Effect } from "effect";
 import { Playwright } from "effect-playwright";
 import { chromium } from "playwright-core";
+import type { PlaywrightBrowserContext } from "./browser-context";
 
 layer(Playwright.layer)("Playwright", (it) => {
   it.scoped("should launch a browser", () =>
@@ -38,6 +39,46 @@ layer(Playwright.layer)("Playwright", (it) => {
     }),
   );
 
+  it.scoped("should launch a persistent context", () =>
+    Effect.gen(function* () {
+      const playwright = yield* Playwright;
+      const context = yield* playwright.launchPersistentContext(chromium, "");
+      const page = yield* context.newPage;
+
+      yield* page.goto("data:text/html,<title>persistent-context</title>");
+      const title = yield* page.title;
+
+      assert(title === "persistent-context", "Expected title to match");
+      yield* context.close;
+    }),
+  );
+
+  it.scoped("should launch a persistent context and close with scope", () =>
+    Effect.gen(function* () {
+      const playwright = yield* Playwright;
+      let capturedContext: typeof PlaywrightBrowserContext.Service | undefined;
+
+      yield* Effect.gen(function* () {
+        const context = yield* playwright.launchPersistentContextScoped(
+          chromium,
+          "",
+        );
+        capturedContext = context;
+
+        const page = yield* context.newPage;
+        const content = yield* page.evaluate(() => "scoped-persistent");
+        assert(content === "scoped-persistent", "Expected content to match");
+      }).pipe(Effect.scoped);
+
+      assert(capturedContext !== undefined, "Expected captured context");
+      const error = yield* capturedContext.newPage.pipe(Effect.flip);
+      assert(
+        error._tag === "PlaywrightError",
+        "Expected failure after scoped close",
+      );
+    }),
+  );
+
   it.scoped("should fail to launch a browser with invalid path", () =>
     Effect.gen(function* () {
       const playwright = yield* Playwright;

src/playwright.ts

@@ -6,8 +6,13 @@ import {
 } from "playwright-core";
 
 import { type LaunchOptions, PlaywrightBrowser } from "./browser";
+import { PlaywrightBrowserContext } from "./browser-context";
 import { type PlaywrightError, wrapError } from "./errors";
 
+type LaunchPersistentContextOptions = Parameters<
+  BrowserType["launchPersistentContext"]
+>[1];
+
 /**
  * @category model
  * @since 0.1.0
@@ -72,6 +77,105 @@ export interface PlaywrightService {
     PlaywrightError,
     Scope.Scope
   >;
+  /**
+   * Launches a persistent browser context.
+   *
+   * Unlike {@link launchPersistentContextScoped}, this method does **not** close the
+   * context automatically when scope is closed. You are responsible for closing it.
+   *
+   * This launches a browser with a persistent profile under `userDataDir` and returns
+   * the single persistent context for that browser.
+   *
+   * Closing this context also closes the underlying browser process.
+   *
+   * ```ts
+   * import { Effect } from "effect";
+   * import { Playwright } from "effect-playwright";
+   * import { chromium } from "playwright-core";
+   *
+   * const program = Effect.gen(function* () {
+   *   const playwright = yield* Playwright;
+   *   const context = yield* playwright.launchPersistentContext(
+   *     chromium,
+   *     "./.playwright-profile",
+   *   );
+   *
+   *   const page = yield* context.newPage;
+   *   yield* page.goto("https://example.com");
+   *
+   *   // Closes the persistent context and browser process.
+   *   yield* context.close;
+   * });
+   *
+   * await Effect.runPromise(program);
+   * ```
+   *
+   * If you call this non-scoped variant inside a scope, add a finalizer for cleanup:
+   *
+   * ```ts
+   * const program = Effect.gen(function* () {
+   *   const playwright = yield* Playwright;
+   *   const context = yield* playwright.launchPersistentContext(
+   *     chromium,
+   *     "./.playwright-profile",
+   *   );
+   *
+   *   yield* Effect.addFinalizer(() => context.close.pipe(Effect.ignore));
+   * });
+   *
+   * await Effect.runPromise(program.pipe(Effect.scoped));
+   * ```
+   *
+   * @param browserType - The browser type to launch (e.g. chromium, firefox, webkit).
+   * @param userDataDir - Directory used for persistent browser profile data. Pass `""` for a temporary profile directory.
+   * @param options - Optional persistent context launch options.
+   * @since 0.2.4
+   */
+  launchPersistentContext: (
+    browserType: BrowserType,
+    userDataDir: string,
+    options?: LaunchPersistentContextOptions,
+  ) => Effect.Effect<typeof PlaywrightBrowserContext.Service, PlaywrightError>;
+  /**
+   * Launches a persistent browser context managed by a Scope.
+   *
+   * This automatically closes the persistent context (and therefore the browser process)
+   * when the scope is closed.
+   *
+   * ```ts
+   * import { Effect } from "effect";
+   * import { Playwright } from "effect-playwright";
+   * import { chromium } from "playwright-core";
+   *
+   * const program = Effect.gen(function* () {
+   *   const playwright = yield* Playwright;
+   *   const context = yield* playwright.launchPersistentContextScoped(
+   *     chromium,
+   *     "./.playwright-profile",
+   *   );
+   *
+   *   const page = yield* context.newPage;
+   *   yield* page.goto("https://example.com");
+   *   // Context/browser cleanup is automatic when scope closes.
+   * }).pipe(Effect.scoped);
+   *
+   * await Effect.runPromise(program);
+   * ```
+   *
+   * @param browserType - The browser type to launch (e.g. chromium, firefox, webkit).
+   * @param userDataDir - Directory used for persistent browser profile data. Pass `""` for a temporary profile directory.
+   * @param options - Optional persistent context launch options.
+   * @since 0.2.4
+   */
+  launchPersistentContextScoped: (
+    browserType: BrowserType,
+    userDataDir: string,
+    options?: LaunchPersistentContextOptions,
+  ) => Effect.Effect<
+    typeof PlaywrightBrowserContext.Service,
+    PlaywrightError,
+    Scope.Scope
+  >;
   /**
    * Connects to a browser instance via Chrome DevTools Protocol (CDP).
    *
@@ -163,6 +267,24 @@ const connectCDP: (
     return PlaywrightBrowser.make(browser);
   });
 
+const launchPersistentContext: (
+  browserType: BrowserType,
+  userDataDir: string,
+  options?: LaunchPersistentContextOptions,
+) => Effect.Effect<typeof PlaywrightBrowserContext.Service, PlaywrightError> =
+  Effect.fn(function* (
+    browserType: BrowserType,
+    userDataDir: string,
+    options?: LaunchPersistentContextOptions,
+  ) {
+    const rawContext = yield* Effect.tryPromise({
+      try: () => browserType.launchPersistentContext(userDataDir, options),
+      catch: wrapError,
+    });
+
+    return PlaywrightBrowserContext.make(rawContext);
+  });
+
 /**
  * @category tag
  * @since 0.1.0
@@ -179,6 +301,12 @@ export class Playwright extends Context.Tag(
       Effect.acquireRelease(launch(browserType, options), (browser) =>
         browser.close.pipe(Effect.ignore),
       ),
+    launchPersistentContext,
+    launchPersistentContextScoped: (browserType, userDataDir, options) =>
+      Effect.acquireRelease(
+        launchPersistentContext(browserType, userDataDir, options),
+        (context) => context.close.pipe(Effect.ignore),
+      ),
     connectCDP,
     connectCDPScoped: (cdpUrl, options) =>
       Effect.acquireRelease(connectCDP(cdpUrl, options), (browser) =>