@solarisdk/browser 0.1.3 → 0.1.4

package/dist/browser-session.d.ts

@@ -5,8 +5,14 @@ export declare class BrowserSession {
     private readonly client;
     readonly session: Session;
     private readonly browser;
+    /** The session's primary context — seeded with the attached profile's
+     *  storageState when there is one. See {@link context}. */
+    private readonly primaryContext?;
     private closed;
-    constructor(client: Solari, session: Session, browser: Browser);
+    constructor(client: Solari, session: Session, browser: Browser, 
+    /** The session's primary context — seeded with the attached profile's
+     *  storageState when there is one. See {@link context}. */
+    primaryContext?: BrowserContext | undefined);
     /** Session id. */
     get id(): string;
     /** Plan-tier deadline (ISO 8601 UTC); session auto-releases at this point. */
@@ -23,11 +29,28 @@ export declare class BrowserSession {
     isConnected(): boolean;
     /** Browser version string (e.g. `"Chromium/130.0.6723.31"`). */
     version(): string;
-    /** All open contexts. Sessions ship with a default context at `contexts()[0]`. */
+    /**
+     * The session's primary context — the one carrying the attached profile's
+     * cookies and localStorage. Use this (or {@link newPage}) rather than
+     * `contexts()[0]`, which is not guaranteed to be the seeded one.
+     */
+    get context(): BrowserContext | undefined;
+    /**
+     * All open contexts, straight from the browser.
+     *
+     * NOTE: this is NOT guaranteed to be non-empty, and `contexts()[0]` is NOT
+     * guaranteed to be the profile-seeded context — the pool only pre-creates an
+     * eager context when a proxy was requested. Prefer {@link context}.
+     */
     contexts(): BrowserContext[];
-    /** Open a fresh browser context. Most callers want `contexts()[0]` instead. */
+    /** Open an ADDITIONAL, empty browser context. This does NOT carry the
+     *  attached profile — use {@link context} for that. */
     newContext(options?: BrowserContextOptions): Promise<BrowserContext>;
-    /** Open a fresh page in a new context. */
+    /**
+     * Open a page in the session's primary context, so an attached profile's
+     * cookies/localStorage are actually present. Falls back to a browser-level
+     * page only when there is no primary context.
+     */
     newPage(): Promise<Page>;
     /** Close the browser and release the session. Idempotent. */
     close(): Promise<void>;

package/dist/browser-session.js

@@ -2,11 +2,16 @@ export class BrowserSession {
     client;
     session;
     browser;
+    primaryContext;
     closed = false;
-    constructor(client, session, browser) {
+    constructor(client, session, browser, 
+    /** The session's primary context — seeded with the attached profile's
+     *  storageState when there is one. See {@link context}. */
+    primaryContext) {
         this.client = client;
         this.session = session;
         this.browser = browser;
+        this.primaryContext = primaryContext;
     }
     /** Session id. */
     get id() {
@@ -40,16 +45,37 @@ export class BrowserSession {
     version() {
         return this.browser.version();
     }
-    /** All open contexts. Sessions ship with a default context at `contexts()[0]`. */
+    /**
+     * The session's primary context — the one carrying the attached profile's
+     * cookies and localStorage. Use this (or {@link newPage}) rather than
+     * `contexts()[0]`, which is not guaranteed to be the seeded one.
+     */
+    get context() {
+        return this.primaryContext;
+    }
+    /**
+     * All open contexts, straight from the browser.
+     *
+     * NOTE: this is NOT guaranteed to be non-empty, and `contexts()[0]` is NOT
+     * guaranteed to be the profile-seeded context — the pool only pre-creates an
+     * eager context when a proxy was requested. Prefer {@link context}.
+     */
     contexts() {
         return this.browser.contexts();
     }
-    /** Open a fresh browser context. Most callers want `contexts()[0]` instead. */
+    /** Open an ADDITIONAL, empty browser context. This does NOT carry the
+     *  attached profile — use {@link context} for that. */
     async newContext(options) {
         return this.browser.newContext(options);
     }
-    /** Open a fresh page in a new context. */
+    /**
+     * Open a page in the session's primary context, so an attached profile's
+     * cookies/localStorage are actually present. Falls back to a browser-level
+     * page only when there is no primary context.
+     */
     async newPage() {
+        if (this.primaryContext)
+            return this.primaryContext.newPage();
         return this.browser.newPage();
     }
     /** Close the browser and release the session. Idempotent. */

package/dist/index.d.ts

@@ -103,11 +103,6 @@ export interface CreateSessionOptions {
     stealth?: boolean;
     /** Enable managed captcha solving. Requires `stealth: true`. */
     captcha?: boolean;
-    /** Opt in to Cloudflare Web Bot Auth — sign every outbound HTTP
-     *  request with an Ed25519 key registered to our verified bot
-     *  directory. Independent of `stealth`. Silently inert if the
-     *  acquired slot has no signing key configured. */
-    webBotAuth?: boolean;
     /** Request managed proxy egress. Requires `stealth: true`.
      *
      *    proxy: "us"

package/dist/index.js

@@ -2,6 +2,39 @@ import { chromium } from "patchright-core";
 import { LocalProxy } from "./local-proxy.js";
 import { BrowserSession } from "./browser-session.js";
 export { BrowserSession } from "./browser-session.js";
+/**
+ * Narrow a {@link StorageState} to the shape `newContext({storageState})` wants.
+ *
+ * Our StorageState is deliberately permissive — every field optional, plus an
+ * index signature — because it doubles as the INPUT to `profiles.save()`, where
+ * callers hand-build partial objects. Playwright's parameter type requires the
+ * cookie fields to be present, so passing ours straight through is a TS2322 and
+ * callers were resorting to `as any`.
+ *
+ * Rather than tighten the public type (which would break anyone constructing a
+ * partial state to save), fill the defaults at this one seam. Values that are
+ * actually present always win; the defaults only cover fields the gateway
+ * omitted, and they match Playwright's own defaults for a host-only cookie.
+ */
+function toPlaywrightStorageState(state) {
+    return {
+        cookies: (state.cookies ?? []).map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain ?? "",
+            path: c.path ?? "/",
+            // -1 is Playwright's "session cookie" sentinel.
+            expires: c.expires ?? -1,
+            httpOnly: c.httpOnly ?? false,
+            secure: c.secure ?? false,
+            sameSite: c.sameSite ?? "Lax",
+        })),
+        origins: (state.origins ?? []).map((o) => ({
+            origin: o.origin,
+            localStorage: o.localStorage ?? [],
+        })),
+    };
+}
 export class SolariError extends Error {
     status;
     cause;
@@ -168,8 +201,6 @@ class SessionsResource {
             body.stealth = true;
         if (options?.captcha === true)
             body.captcha = true;
-        if (options?.webBotAuth === true)
-            body.webBotAuth = true;
         if (options?.proxy !== undefined)
             body.proxy = options.proxy;
         const res = await this.client.request("POST", "/sessions", Object.keys(body).length ? body : undefined);
@@ -322,7 +353,32 @@ export class Solari {
                 if (probeEnabled) {
                     await this._probeBrowserHealth(browser, probeTimeoutMs);
                 }
-                return new BrowserSession(this, session, browser);
+                // Materialise ONE primary context for the session.
+                //
+                // The gateway already fetches an attached profile's cookies +
+                // origins into session.storageState (and its own comment says it
+                // does so "so the SDK skips the newContext({storageState}) seed")
+                // — but the SDK never performed that seed, so every run wrote a
+                // new profile version and read none back. Seed it here.
+                //
+                // Also makes a context reliably available: the pool only
+                // pre-creates one when a proxy was requested, so on a plain
+                // launch() browser.contexts() was empty and contexts()[0]
+                // undefined — which the SDK's own docs pointed callers at.
+                const ctxOptions = {};
+                const tz = session.proxy?.timezoneId;
+                if (tz)
+                    ctxOptions.timezoneId = tz;
+                if (session.storageState) {
+                    ctxOptions.storageState = toPlaywrightStorageState(session.storageState);
+                }
+                const primary = 
+                // Reuse the pool's eager context only when we have nothing
+                // to seed — storageState can only be applied at creation.
+                !ctxOptions.storageState && browser.contexts().length > 0
+                    ? browser.contexts()[0]
+                    : await browser.newContext(ctxOptions);
+                return new BrowserSession(this, session, browser, primary);
             }
             catch (err) {
                 if (browser) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solarisdk/browser",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Official client SDK for Solari Browser.",
   "license": "Apache-2.0",
   "type": "module",