@memberjunction/remote-browser-selfhost 0.0.1 → 5.41.0

package/README.md

@@ -1,45 +1,94 @@
 # @memberjunction/remote-browser-selfhost
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@memberjunction/remote-browser-selfhost`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+The **Self-Hosted Chrome** backend driver for MemberJunction's Remote Browser channel. Instead of a
+browser-as-a-service, this backend has MJ orchestrate a **lightweight headless-Chrome container** (just
+Chrome started with a `--remote-debugging-port`) and connect to it over the Chrome DevTools Protocol.
+The shared CDP control kit does all the actual page driving, so this driver answers only one
+backend-specific question — *how do I obtain a CDP endpoint (and its live-view / release hooks) for a
+self-hosted Chrome container?* — behind an **injectable container-runner seam**, so it builds and
+unit-tests with **no container, no network, and no real browser**.
+
+See the [Realtime Bridges Guide](../../../../../guides/REALTIME_BRIDGES_GUIDE.md) and
+`/plans/realtime/realtime-bridges-architecture.md` (§4d-i, the Remote Browser channel) for the full
+architecture.
+
+## Install
+
+```bash
+npm install @memberjunction/remote-browser-selfhost
+```
+
+## What it provides
+
+- **`SelfHostRemoteBrowser`** — `@RegisterClass(BaseRemoteBrowserProvider, 'SelfHostRemoteBrowser')`.
+  A `MJ: AI Remote Browser Providers` row with `DriverClass = 'SelfHostRemoteBrowser'` resolves to this
+  driver via the `ClassFactory`. It extends `BaseCdpRemoteBrowserProvider` and implements only
+  `AcquireSession`; everything else (action mapping, capability gating, screencast, human takeover,
+  `Connect` / `Disconnect`) is inherited from `@memberjunction/remote-browser-cdp`.
+- **`IChromeContainerRunner`** — the **injectable orchestration seam** the driver depends on instead of a
+  real container orchestrator: `Acquire(opts)` → `{ CdpEndpoint, ViewerUrl, Release() }`.
+- **`SelfHostSessionBackend`** — the `ICdpSessionBackend` for a live session: `GetLiveViewUrl()` returns
+  the MJ-hosted viewer URL (backed by the inherited screencast), `InvokeNativeAIControl()` throws (no
+  native harness), and `Release()` tears down the container (idempotently).
+
+## Capability coverage (the Self-Hosted Chrome seed row)
+
+Seed row name **`Self-Hosted Chrome`**, `DriverClass = 'SelfHostRemoteBrowser'`.
+
+| Capability | Status |
+|---|---|
+| `RawCdpControl` | ✅ universal CDP substrate |
+| `LiveView` | ✅ MJ-hosted viewer URL backed by the inherited CDP screencast |
+| `HumanTakeover` | ✅ inherited grab-the-wheel input routing |
+| `ScreenStreaming` | ✅ |
+| `PersistentContext` | ✅ |
+| `MultiTab` | ✅ |
+| `FileDownloads` | ✅ |
+| `NativeAIControl` | ➖ self-host has no first-party AI-control harness — `InvokeNativeAIControl` throws `RemoteBrowserCapabilityNotSupportedError`; MJ's own computer-use loop drives the page |
+
+Unlike a browser-as-a-service, Self-Hosted Chrome has **no provider-hosted live view of its own**.
+`LiveView` is still supported because `GetLiveViewUrl()` returns an **MJ-hosted** viewer URL whose page
+renders the inherited CDP screencast frames — so it returns a URL rather than throwing.
+
+## Binding the real Chrome container runner (production)
+
+This package ships **without** a real container orchestrator — that is a deployment concern, so no Docker
+/ Kubernetes / Chrome-image wiring is hard-coded here. At startup, bind a factory that builds an
+`IChromeContainerRunner` which spins up a headless-Chrome container and returns its CDP endpoint plus an
+MJ-hosted viewer URL backed by the screencast:
+
+```typescript
+import { SelfHostRemoteBrowser, IChromeContainerRunner } from '@memberjunction/remote-browser-selfhost';
+
+SelfHostRemoteBrowser.SetContainerRunnerFactory(() => {
+    // Build a thin adapter over your real container orchestrator (Docker/K8s/…).
+    // Region/image/proxy arrive already resolved in the acquire options; never inline secrets.
+    const runner: IChromeContainerRunner = {
+        async Acquire(opts) {
+            // …start a headless-Chrome container with --remote-debugging-port,
+            //   stand up the MJ viewer page backed by the screencast,
+            //   and return the handle:
+            return {
+                CdpEndpoint, // ws://…/devtools/browser/…
+                ViewerUrl,   // MJ-hosted viewer backed by the inherited screencast
+                async Release() {
+                    // …stop + tear down the container
+                },
+            };
+        },
+    };
+    return runner;
+});
+```
+
+Until a factory is bound, `AcquireSession` throws an explicit *"bind a real Chrome container runner via
+SetContainerRunnerFactory"* error.
+
+## Testing
+
+Tests inject a `FakeChromeContainerRunner` via `SelfHostRemoteBrowser.SetContainerRunnerFactory(...)` —
+no container, no network, no real browser. Run them with:
+
+```bash
+npm run test
+```

package/dist/chrome-container-runner.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The injectable **Chrome-container-runner seam** — the orchestration boundary the
+ * {@link import('./selfhost-remote-browser.js').SelfHostRemoteBrowser} driver depends on to obtain a
+ * running headless-Chrome container exposing a CDP endpoint, plus the MJ-hosted live-view URL backed by
+ * the inherited screencast.
+ *
+ * It is declared as an interface (mirroring the bridge subsystem's `IZoomMeetingSdk` seam) so the driver
+ * builds and unit-tests against an in-memory **Fake runner** with **no container, no network, and no
+ * real browser**. Binding a real runner in production is a thin adapter that implements this interface;
+ * the driver and its tests do not change, and none of the orchestration SDK types leak into this package.
+ *
+ * ## Production binding (seam — bound at deployment)
+ * In production the runner spins up a lightweight headless-Chrome container (just Chrome started with a
+ * `--remote-debugging-port`), returns its CDP endpoint for the shared adapter to attach to, and returns
+ * an MJ-hosted viewer URL whose page is backed by the inherited CDP screencast frames. `Release()` stops
+ * and tears down that container.
+ *
+ * @see `base-cdp-remote-browser-provider.ts` (`@memberjunction/remote-browser-cdp`) — `AcquireSession`
+ *  returns the CDP endpoint this runner provides.
+ */
+/**
+ * The options handed to {@link IChromeContainerRunner.Acquire} for one session — the connection
+ * configuration the runner needs to size and launch its Chrome container. All fields are optional so a
+ * production runner can fall back to sensible defaults; the values flow from the provider context's
+ * opaque `Configuration` (credential references already resolved upstream; never inline secrets).
+ */
+export interface ChromeContainerAcquireOptions {
+    /** Optional viewport width hint for the launched Chrome, in pixels. */
+    ViewportWidth?: number;
+    /** Optional viewport height hint for the launched Chrome, in pixels. */
+    ViewportHeight?: number;
+    /**
+     * The full, opaque backend configuration record from the provider context (region, Chrome image,
+     * proxy settings, …). Typed as a record of unknown values rather than `any` so the boundary stays
+     * inspectable; a production runner narrows the fields it understands.
+     */
+    Configuration?: Record<string, unknown>;
+}
+/**
+ * The handle a {@link IChromeContainerRunner.Acquire} call returns: the CDP endpoint the shared adapter
+ * attaches to, the MJ-hosted viewer URL for human live-view, and the teardown hook for the container
+ * behind them.
+ */
+export interface ChromeContainerHandle {
+    /**
+     * The Chrome DevTools Protocol connect endpoint of the launched container (e.g. a
+     * `ws://…/devtools/browser/…` URL). The shared provider attaches to this over CDP.
+     */
+    CdpEndpoint: string;
+    /**
+     * The MJ-hosted, embeddable live-view URL whose page renders the inherited CDP screencast frames.
+     * Self-host has no first-party hosted live view; this is MJ's own viewer backed by the screencast.
+     */
+    ViewerUrl: string;
+    /**
+     * Tears down the Chrome container behind {@link CdpEndpoint} / {@link ViewerUrl}. Should be
+     * idempotent and non-throwing for an already-released container so teardown is safe to run more than
+     * once.
+     *
+     * @returns A promise that resolves once the container has been torn down.
+     */
+    Release(): Promise<void>;
+}
+/**
+ * The minimal Chrome-container orchestration surface the
+ * {@link import('./selfhost-remote-browser.js').SelfHostRemoteBrowser} driver depends on. Production binds
+ * this to a real container orchestrator; tests inject a `FakeChromeContainerRunner`.
+ */
+export interface IChromeContainerRunner {
+    /**
+     * Launches (or leases) a headless-Chrome container for one session and returns its CDP endpoint, the
+     * MJ-hosted viewer URL, and the teardown hook.
+     *
+     * @param opts The connection configuration for this session (viewport hints + opaque backend config).
+     * @returns A promise resolving to the running container's handle.
+     */
+    Acquire(opts: ChromeContainerAcquireOptions): Promise<ChromeContainerHandle>;
+}
+/**
+ * A factory that constructs an {@link IChromeContainerRunner} — the creation seam (mirroring the bridge
+ * subsystem's SDK-factory pattern). Production supplies a factory that builds the real container-runner
+ * adapter; tests supply one that returns a `FakeChromeContainerRunner`.
+ *
+ * @returns The Chrome-container runner the driver acquires sessions through.
+ */
+export type ChromeContainerRunnerFactory = () => IChromeContainerRunner;
+//# sourceMappingURL=chrome-container-runner.d.ts.map

package/dist/chrome-container-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chrome-container-runner.d.ts","sourceRoot":"","sources":["../src/chrome-container-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,6BAA6B;IAC1C,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,wEAAwE;IACxE,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IAClC;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;;;OAMG;IACH,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACnC;;;;;;OAMG;IACH,OAAO,CAAC,IAAI,EAAE,6BAA6B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAChF;AAED;;;;;;GAMG;AACH,MAAM,MAAM,4BAA4B,GAAG,MAAM,sBAAsB,CAAC"}

package/dist/chrome-container-runner.js

@@ -0,0 +1,22 @@
+/**
+ * The injectable **Chrome-container-runner seam** — the orchestration boundary the
+ * {@link import('./selfhost-remote-browser.js').SelfHostRemoteBrowser} driver depends on to obtain a
+ * running headless-Chrome container exposing a CDP endpoint, plus the MJ-hosted live-view URL backed by
+ * the inherited screencast.
+ *
+ * It is declared as an interface (mirroring the bridge subsystem's `IZoomMeetingSdk` seam) so the driver
+ * builds and unit-tests against an in-memory **Fake runner** with **no container, no network, and no
+ * real browser**. Binding a real runner in production is a thin adapter that implements this interface;
+ * the driver and its tests do not change, and none of the orchestration SDK types leak into this package.
+ *
+ * ## Production binding (seam — bound at deployment)
+ * In production the runner spins up a lightweight headless-Chrome container (just Chrome started with a
+ * `--remote-debugging-port`), returns its CDP endpoint for the shared adapter to attach to, and returns
+ * an MJ-hosted viewer URL whose page is backed by the inherited CDP screencast frames. `Release()` stops
+ * and tears down that container.
+ *
+ * @see `base-cdp-remote-browser-provider.ts` (`@memberjunction/remote-browser-cdp`) — `AcquireSession`
+ *  returns the CDP endpoint this runner provides.
+ */
+export {};
+//# sourceMappingURL=chrome-container-runner.js.map

package/dist/chrome-container-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chrome-container-runner.js","sourceRoot":"","sources":["../src/chrome-container-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@memberjunction/remote-browser-selfhost` — the Self-Hosted Chrome backend driver for the Remote
+ * Browser channel.
+ *
+ * Exports the driver, its injectable Chrome-container-runner seam, and the session backend, plus a
+ * static tree-shaking-prevention loader so the `ClassFactory` can resolve the
+ * `'SelfHostRemoteBrowser'` registration.
+ */
+export * from './chrome-container-runner.js';
+export * from './local-chrome-container-runner.js';
+export * from './selfhost-session-backend.js';
+export * from './selfhost-remote-browser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * `@memberjunction/remote-browser-selfhost` — the Self-Hosted Chrome backend driver for the Remote
+ * Browser channel.
+ *
+ * Exports the driver, its injectable Chrome-container-runner seam, and the session backend, plus a
+ * static tree-shaking-prevention loader so the `ClassFactory` can resolve the
+ * `'SelfHostRemoteBrowser'` registration.
+ */
+export * from './chrome-container-runner.js';
+export * from './local-chrome-container-runner.js';
+export * from './selfhost-session-backend.js';
+export * from './selfhost-remote-browser.js';
+import { LoadSelfHostRemoteBrowser } from './selfhost-remote-browser.js';
+// Static reference so bundlers cannot tree-shake the
+// @RegisterClass(BaseRemoteBrowserProvider, 'SelfHostRemoteBrowser') registration. Calling the no-op
+// here keeps the driver resolvable by the engine's ClassFactory.
+LoadSelfHostRemoteBrowser();
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAE1C,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAEtE,qDAAqD;AACrD,qGAAqG;AACrG,iEAAiE;AACjE,yBAAyB,EAAE,CAAC"}

package/dist/local-chrome-container-runner.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview The DEFAULT, zero-config {@link IChromeContainerRunner} for Self-Hosted Chrome: a LOCAL
+ * headless Chromium launched on this host (no Docker, no container orchestrator, no cloud account).
+ *
+ * It launches the Chromium that Playwright manages with a `--remote-debugging-port`, then returns the
+ * DevTools **CDP HTTP endpoint** (`http://127.0.0.1:<port>`) for the shared CDP adapter to attach to via
+ * `connectOverCDP`. `Release()` closes that Chromium. This is what makes
+ * `@memberjunction/remote-browser-selfhost` work out of the box — it is bound as the default factory at
+ * module load, so a deployment needs NO `SetContainerRunnerFactory` call and NO external service to drive
+ * a real browser. The seam stays open: a deployment that wants a real container backend still overrides it
+ * via `SetContainerRunnerFactory`.
+ *
+ * ## Why the CDP HTTP endpoint (not `browser.wsEndpoint()`)
+ * For a `chromium.launch()` browser, `browser.wsEndpoint()` is the **Playwright-protocol** endpoint, which
+ * `connectOverCDP` cannot attach to. The shared `BaseCdpRemoteBrowserProvider` always attaches via CDP, so
+ * the runner launches Chromium with `--remote-debugging-port=<port>` and hands back the raw DevTools HTTP
+ * endpoint, which `connectOverCDP` accepts directly.
+ *
+ * Playwright is a (peer) dependency only because of this default runner; it is imported lazily so a
+ * deployment that overrides the runner — or never starts a self-host session — pays nothing for it.
+ *
+ * @module @memberjunction/remote-browser-selfhost
+ * @author MemberJunction.com
+ */
+import { ChromeContainerAcquireOptions, ChromeContainerHandle, IChromeContainerRunner } from './chrome-container-runner.js';
+/**
+ * The default local-Chrome runner — launches a local headless Chromium via Playwright and exposes its
+ * real CDP HTTP endpoint. Stateless; one instance is shared process-wide (each {@link Acquire} launches
+ * its own browser and its {@link ChromeContainerHandle.Release} closes exactly that one).
+ */
+export declare class LocalChromeContainerRunner implements IChromeContainerRunner {
+    /**
+     * Launches a local headless Chromium and returns its CDP HTTP endpoint + teardown hook.
+     *
+     * @param opts Per-session viewport hints (and the opaque backend configuration, unused here).
+     * @returns A handle carrying the launched browser's CDP HTTP endpoint and a `Release` that closes it.
+     * @throws When Playwright is not installed, or the browser fails to launch / expose a CDP endpoint.
+     */
+    Acquire(opts: ChromeContainerAcquireOptions): Promise<ChromeContainerHandle>;
+    /**
+     * Lazily imports Playwright's `chromium` launcher. Kept dynamic (the sanctioned optional-peer case) so
+     * the package builds and a non-self-host deployment pays nothing — but the error is explicit when a
+     * self-host session is actually started without Playwright installed.
+     *
+     * @returns Playwright's `chromium` browser type.
+     * @throws When the optional `playwright` peer dependency is not installed.
+     */
+    private loadChromium;
+    /**
+     * Builds the Chromium launch args: the chosen remote-debugging port (exposing a real CDP endpoint),
+     * bound to loopback, plus the resolved window size.
+     *
+     * @param opts The acquire options carrying optional viewport hints.
+     * @param port The remote-debugging port to expose CDP on.
+     * @returns The Chromium command-line args.
+     */
+    private launchArgs;
+    /**
+     * Polls Chromium's DevTools `/json/version` document until it is reachable (the browser has fully
+     * started its CDP server) or the readiness timeout elapses.
+     *
+     * @param cdpEndpoint The CDP HTTP base endpoint (`http://127.0.0.1:<port>`).
+     * @throws When the DevTools endpoint is not reachable within {@link DEVTOOLS_READY_TIMEOUT_MS}.
+     */
+    private waitForDevTools;
+    /**
+     * Reserves a free TCP port by binding an ephemeral server to loopback and reading the assigned port.
+     * There is an unavoidable (tiny) race between releasing the port and Chromium binding it; on a single
+     * host this is acceptable for the default runner.
+     *
+     * @returns A free TCP port on loopback.
+     */
+    private findFreePort;
+    /** Closes a browser, swallowing any teardown error so `Release` (and failure cleanup) never throws. */
+    private closeQuietly;
+    /** A cancellable-free delay used between DevTools readiness polls. */
+    private delay;
+}
+//# sourceMappingURL=local-chrome-container-runner.d.ts.map

package/dist/local-chrome-container-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-chrome-container-runner.d.ts","sourceRoot":"","sources":["../src/local-chrome-container-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,OAAO,EACH,6BAA6B,EAC7B,qBAAqB,EACrB,sBAAsB,EACzB,MAAM,2BAA2B,CAAC;AAYnC;;;;GAIG;AACH,qBAAa,0BAA2B,YAAW,sBAAsB;IACrE;;;;;;OAMG;IACU,OAAO,CAAC,IAAI,EAAE,6BAA6B,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAyBzF;;;;;;;OAOG;YACW,YAAY;IAa1B;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAUlB;;;;;;OAMG;YACW,eAAe;IAoB7B;;;;;;OAMG;IACH,OAAO,CAAC,YAAY;IAgBpB,uGAAuG;YACzF,YAAY;IAQ1B,sEAAsE;IACtE,OAAO,CAAC,KAAK;CAGhB"}

package/dist/local-chrome-container-runner.js

@@ -0,0 +1,170 @@
+/**
+ * @fileoverview The DEFAULT, zero-config {@link IChromeContainerRunner} for Self-Hosted Chrome: a LOCAL
+ * headless Chromium launched on this host (no Docker, no container orchestrator, no cloud account).
+ *
+ * It launches the Chromium that Playwright manages with a `--remote-debugging-port`, then returns the
+ * DevTools **CDP HTTP endpoint** (`http://127.0.0.1:<port>`) for the shared CDP adapter to attach to via
+ * `connectOverCDP`. `Release()` closes that Chromium. This is what makes
+ * `@memberjunction/remote-browser-selfhost` work out of the box — it is bound as the default factory at
+ * module load, so a deployment needs NO `SetContainerRunnerFactory` call and NO external service to drive
+ * a real browser. The seam stays open: a deployment that wants a real container backend still overrides it
+ * via `SetContainerRunnerFactory`.
+ *
+ * ## Why the CDP HTTP endpoint (not `browser.wsEndpoint()`)
+ * For a `chromium.launch()` browser, `browser.wsEndpoint()` is the **Playwright-protocol** endpoint, which
+ * `connectOverCDP` cannot attach to. The shared `BaseCdpRemoteBrowserProvider` always attaches via CDP, so
+ * the runner launches Chromium with `--remote-debugging-port=<port>` and hands back the raw DevTools HTTP
+ * endpoint, which `connectOverCDP` accepts directly.
+ *
+ * Playwright is a (peer) dependency only because of this default runner; it is imported lazily so a
+ * deployment that overrides the runner — or never starts a self-host session — pays nothing for it.
+ *
+ * @module @memberjunction/remote-browser-selfhost
+ * @author MemberJunction.com
+ */
+import { createServer } from 'node:net';
+/** Default viewport when the acquire options carry no hint. */
+const DEFAULT_VIEWPORT_WIDTH = 1280;
+/** Default viewport when the acquire options carry no hint. */
+const DEFAULT_VIEWPORT_HEIGHT = 800;
+/** How long to wait for Chromium's DevTools endpoint to become reachable, in ms. */
+const DEVTOOLS_READY_TIMEOUT_MS = 10_000;
+/** Poll interval while waiting for the DevTools endpoint, in ms. */
+const DEVTOOLS_POLL_INTERVAL_MS = 100;
+/**
+ * The default local-Chrome runner — launches a local headless Chromium via Playwright and exposes its
+ * real CDP HTTP endpoint. Stateless; one instance is shared process-wide (each {@link Acquire} launches
+ * its own browser and its {@link ChromeContainerHandle.Release} closes exactly that one).
+ */
+export class LocalChromeContainerRunner {
+    /**
+     * Launches a local headless Chromium and returns its CDP HTTP endpoint + teardown hook.
+     *
+     * @param opts Per-session viewport hints (and the opaque backend configuration, unused here).
+     * @returns A handle carrying the launched browser's CDP HTTP endpoint and a `Release` that closes it.
+     * @throws When Playwright is not installed, or the browser fails to launch / expose a CDP endpoint.
+     */
+    async Acquire(opts) {
+        const chromium = await this.loadChromium();
+        const port = await this.findFreePort();
+        const browser = await chromium.launch({
+            headless: true,
+            args: this.launchArgs(opts, port),
+        });
+        const cdpEndpoint = `http://127.0.0.1:${port}`;
+        try {
+            await this.waitForDevTools(cdpEndpoint);
+        }
+        catch (err) {
+            await this.closeQuietly(browser);
+            throw err;
+        }
+        return {
+            CdpEndpoint: cdpEndpoint,
+            // Self-host's local runner has no first-party hosted viewer; the MJ live view is backed by the
+            // inherited CDP screencast. Surface the CDP endpoint as the (non-navigable) viewer reference.
+            ViewerUrl: cdpEndpoint,
+            Release: async () => {
+                await this.closeQuietly(browser);
+            },
+        };
+    }
+    /**
+     * Lazily imports Playwright's `chromium` launcher. Kept dynamic (the sanctioned optional-peer case) so
+     * the package builds and a non-self-host deployment pays nothing — but the error is explicit when a
+     * self-host session is actually started without Playwright installed.
+     *
+     * @returns Playwright's `chromium` browser type.
+     * @throws When the optional `playwright` peer dependency is not installed.
+     */
+    async loadChromium() {
+        try {
+            const { chromium } = await import('playwright');
+            return chromium;
+        }
+        catch {
+            throw new Error('The default Self-Hosted Chrome runner needs Playwright, but it is not installed. ' +
+                "Install it with 'npm install playwright' (and run 'npx playwright install chromium'), " +
+                'or bind a real container runner via SelfHostRemoteBrowser.SetContainerRunnerFactory(...).');
+        }
+    }
+    /**
+     * Builds the Chromium launch args: the chosen remote-debugging port (exposing a real CDP endpoint),
+     * bound to loopback, plus the resolved window size.
+     *
+     * @param opts The acquire options carrying optional viewport hints.
+     * @param port The remote-debugging port to expose CDP on.
+     * @returns The Chromium command-line args.
+     */
+    launchArgs(opts, port) {
+        const width = opts.ViewportWidth ?? DEFAULT_VIEWPORT_WIDTH;
+        const height = opts.ViewportHeight ?? DEFAULT_VIEWPORT_HEIGHT;
+        return [
+            `--remote-debugging-port=${port}`,
+            '--remote-debugging-address=127.0.0.1',
+            `--window-size=${width},${height}`,
+        ];
+    }
+    /**
+     * Polls Chromium's DevTools `/json/version` document until it is reachable (the browser has fully
+     * started its CDP server) or the readiness timeout elapses.
+     *
+     * @param cdpEndpoint The CDP HTTP base endpoint (`http://127.0.0.1:<port>`).
+     * @throws When the DevTools endpoint is not reachable within {@link DEVTOOLS_READY_TIMEOUT_MS}.
+     */
+    async waitForDevTools(cdpEndpoint) {
+        const deadline = Date.now() + DEVTOOLS_READY_TIMEOUT_MS;
+        let lastError;
+        while (Date.now() < deadline) {
+            try {
+                const response = await fetch(`${cdpEndpoint}/json/version`);
+                if (response.ok) {
+                    return;
+                }
+            }
+            catch (err) {
+                lastError = err;
+            }
+            await this.delay(DEVTOOLS_POLL_INTERVAL_MS);
+        }
+        throw new Error(`Local Chromium did not expose a CDP endpoint at ${cdpEndpoint} within ${DEVTOOLS_READY_TIMEOUT_MS}ms` +
+            (lastError instanceof Error ? `: ${lastError.message}` : '.'));
+    }
+    /**
+     * Reserves a free TCP port by binding an ephemeral server to loopback and reading the assigned port.
+     * There is an unavoidable (tiny) race between releasing the port and Chromium binding it; on a single
+     * host this is acceptable for the default runner.
+     *
+     * @returns A free TCP port on loopback.
+     */
+    findFreePort() {
+        return new Promise((resolve, reject) => {
+            const server = createServer();
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', () => {
+                const address = server.address();
+                if (address && typeof address === 'object') {
+                    const { port } = address;
+                    server.close(() => resolve(port));
+                }
+                else {
+                    server.close(() => reject(new Error('Failed to reserve a free port for local Chromium.')));
+                }
+            });
+        });
+    }
+    /** Closes a browser, swallowing any teardown error so `Release` (and failure cleanup) never throws. */
+    async closeQuietly(browser) {
+        try {
+            await browser.close();
+        }
+        catch {
+            // best-effort teardown — a browser that already exited is a benign no-op
+        }
+    }
+    /** A cancellable-free delay used between DevTools readiness polls. */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+}
+//# sourceMappingURL=local-chrome-container-runner.js.map

package/dist/local-chrome-container-runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-chrome-container-runner.js","sourceRoot":"","sources":["../src/local-chrome-container-runner.ts"],"names":[],"mappings":"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"}

package/dist/selfhost-remote-browser.d.ts

@@ -0,0 +1,89 @@
+/**
+ * @fileoverview `SelfHostRemoteBrowser` — the Self-Hosted Chrome backend driver for the Remote Browser
+ * channel. It connects the shared CDP control kit
+ * ({@link BaseCdpRemoteBrowserProvider}) to a lightweight, MJ-orchestrated headless-Chrome container.
+ *
+ * The driver itself is intentionally trivial: the shared kit implements the entire generic path
+ * (Connect/Disconnect, adapter-attach over CDP, action mapping, screencast, human takeover, capability
+ * gating). This driver fills the ONE backend-specific hook — {@link AcquireSession} — by leasing a Chrome
+ * container through an injectable {@link IChromeContainerRunner} seam and wrapping its handle in a
+ * {@link SelfHostSessionBackend}.
+ *
+ * Capability coverage (per the `MJ: AI Remote Browser Providers` seed row "Self-Hosted Chrome"):
+ * RawCdpControl, LiveView, HumanTakeover, ScreenStreaming, PersistentContext, MultiTab, FileDownloads —
+ * and explicitly NOT NativeAIControl (self-host has no first-party AI harness).
+ *
+ * @module @memberjunction/remote-browser-selfhost
+ * @author MemberJunction.com
+ */
+import { RemoteBrowserProviderContext } from '@memberjunction/remote-browser-base';
+import { AcquiredCdpSession, BaseCdpRemoteBrowserProvider } from '@memberjunction/remote-browser-cdp';
+import { ChromeContainerRunnerFactory } from './chrome-container-runner.js';
+/**
+ * The `DriverClass` key {@link SelfHostRemoteBrowser} registers under. A `MJ: AI Remote Browser Providers`
+ * row with `DriverClass = 'SelfHostRemoteBrowser'` resolves to this driver via the `ClassFactory`.
+ */
+export declare const SELF_HOST_REMOTE_BROWSER_DRIVER_CLASS = "SelfHostRemoteBrowser";
+/**
+ * The Self-Hosted Chrome Remote Browser driver. Subclasses {@link BaseCdpRemoteBrowserProvider} and
+ * implements only {@link AcquireSession}; all connect/disconnect orchestration, action mapping, and
+ * capability gating are inherited.
+ *
+ * Construct via the default constructor (the engine's `ClassFactory` path). By default it uses a
+ * {@link LocalChromeContainerRunner} (local headless Chromium) so it works with no external service. The
+ * container-runner seam is bound process-wide via the static {@link SetContainerRunnerFactory} — mirroring
+ * how bridge drivers bind their real SDK — so a deployment that wants a real container backend overrides
+ * the default once at startup and every resolved driver instance shares it.
+ *
+ * Registered via `@RegisterClass(BaseRemoteBrowserProvider, 'SelfHostRemoteBrowser')`.
+ */
+export declare class SelfHostRemoteBrowser extends BaseCdpRemoteBrowserProvider {
+    /**
+     * The process-wide Chrome-container-runner factory. Defaults to {@link defaultContainerRunnerFactory}
+     * (a local headless Chromium); a deployment overrides it via {@link SetContainerRunnerFactory}.
+     */
+    private static containerRunnerFactory;
+    /**
+     * Overrides the {@link ChromeContainerRunnerFactory} every {@link SelfHostRemoteBrowser} instance uses
+     * to acquire its Chrome container — the override seam, mirroring how bridge drivers bind their real
+     * SDK. The default is a local-Chromium runner, so this is only needed to point self-host at a real
+     * container backend; tests call it with a factory that returns a fake runner.
+     *
+     * @param factory The factory that constructs the Chrome-container runner.
+     */
+    static SetContainerRunnerFactory(factory: ChromeContainerRunnerFactory): void;
+    /**
+     * Acquires a CDP endpoint by leasing a headless-Chrome container through the bound runner, then wraps
+     * the container handle in a {@link SelfHostSessionBackend}. The shared base attaches its adapter to
+     * the returned endpoint and delegates the backend-specific concerns (live view / native-AI / release)
+     * to the backend.
+     *
+     * @param ctx The provider context (features, configuration, control mode, context user).
+     * @returns A promise resolving to the acquired CDP endpoint + Self-Hosted Chrome backend hooks.
+     */
+    protected AcquireSession(ctx: RemoteBrowserProviderContext): Promise<AcquiredCdpSession>;
+    /**
+     * Builds the {@link ChromeContainerAcquireOptions} for a session from the provider context — carrying
+     * the optional viewport hints and the full opaque backend configuration through to the runner.
+     *
+     * @param ctx The provider context whose `Configuration` may carry viewport + backend hints.
+     * @returns The acquire options to hand the Chrome-container runner.
+     */
+    private buildAcquireOptions;
+    /**
+     * Reads an optional numeric value from the opaque, backend-specific `Configuration` record without
+     * resorting to `any`. Returns `undefined` when the key is absent or not a finite number.
+     *
+     * @param configuration The opaque configuration record (or undefined).
+     * @param key The key to read.
+     * @returns The numeric value, or `undefined` when absent/non-numeric.
+     */
+    private readNumberOption;
+}
+/**
+ * Tree-shaking-prevention loader. Modern bundlers cannot see the `@RegisterClass` dynamic registration of
+ * {@link SelfHostRemoteBrowser} and may eliminate it. Import and call this no-op from a static code path
+ * (the package entry point does) so the `ClassFactory` can resolve `'SelfHostRemoteBrowser'`.
+ */
+export declare function LoadSelfHostRemoteBrowser(): void;
+//# sourceMappingURL=selfhost-remote-browser.d.ts.map

package/dist/selfhost-remote-browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfhost-remote-browser.d.ts","sourceRoot":"","sources":["../src/selfhost-remote-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EAA6B,4BAA4B,EAAE,MAAM,qCAAqC,CAAC;AAC9G,OAAO,EAAE,kBAAkB,EAAE,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AACtG,OAAO,EAEH,4BAA4B,EAE/B,MAAM,2BAA2B,CAAC;AAInC;;;GAGG;AACH,eAAO,MAAM,qCAAqC,0BAA0B,CAAC;AAa7E;;;;;;;;;;;;GAYG;AACH,qBACa,qBAAsB,SAAQ,4BAA4B;IACnE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAA+D;IAEpG;;;;;;;OAOG;WACW,yBAAyB,CAAC,OAAO,EAAE,4BAA4B,GAAG,IAAI;IAIpF;;;;;;;;OAQG;cACa,cAAc,CAAC,GAAG,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAa9F;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;CAO3B;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}

package/dist/selfhost-remote-browser.js

@@ -0,0 +1,135 @@
+/**
+ * @fileoverview `SelfHostRemoteBrowser` — the Self-Hosted Chrome backend driver for the Remote Browser
+ * channel. It connects the shared CDP control kit
+ * ({@link BaseCdpRemoteBrowserProvider}) to a lightweight, MJ-orchestrated headless-Chrome container.
+ *
+ * The driver itself is intentionally trivial: the shared kit implements the entire generic path
+ * (Connect/Disconnect, adapter-attach over CDP, action mapping, screencast, human takeover, capability
+ * gating). This driver fills the ONE backend-specific hook — {@link AcquireSession} — by leasing a Chrome
+ * container through an injectable {@link IChromeContainerRunner} seam and wrapping its handle in a
+ * {@link SelfHostSessionBackend}.
+ *
+ * Capability coverage (per the `MJ: AI Remote Browser Providers` seed row "Self-Hosted Chrome"):
+ * RawCdpControl, LiveView, HumanTakeover, ScreenStreaming, PersistentContext, MultiTab, FileDownloads —
+ * and explicitly NOT NativeAIControl (self-host has no first-party AI harness).
+ *
+ * @module @memberjunction/remote-browser-selfhost
+ * @author MemberJunction.com
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SelfHostRemoteBrowser_1;
+import { RegisterClass } from '@memberjunction/global';
+import { BaseRemoteBrowserProvider } from '@memberjunction/remote-browser-base';
+import { BaseCdpRemoteBrowserProvider } from '@memberjunction/remote-browser-cdp';
+import { LocalChromeContainerRunner } from './local-chrome-container-runner.js';
+import { SelfHostSessionBackend } from './selfhost-session-backend.js';
+/**
+ * The `DriverClass` key {@link SelfHostRemoteBrowser} registers under. A `MJ: AI Remote Browser Providers`
+ * row with `DriverClass = 'SelfHostRemoteBrowser'` resolves to this driver via the `ClassFactory`.
+ */
+export const SELF_HOST_REMOTE_BROWSER_DRIVER_CLASS = 'SelfHostRemoteBrowser';
+/**
+ * The DEFAULT Chrome-container-runner factory: a {@link LocalChromeContainerRunner} that launches a local
+ * headless Chromium via Playwright (no Docker, no container orchestrator, no cloud account). This makes
+ * Self-Hosted Chrome work OUT OF THE BOX — a deployment needs no `SetContainerRunnerFactory` call and no
+ * external service to drive a real browser. A deployment that wants a real container backend overrides it
+ * via {@link SelfHostRemoteBrowser.SetContainerRunnerFactory}; tests inject a `FakeChromeContainerRunner`.
+ *
+ * @returns A {@link LocalChromeContainerRunner}.
+ */
+const defaultContainerRunnerFactory = () => new LocalChromeContainerRunner();
+/**
+ * The Self-Hosted Chrome Remote Browser driver. Subclasses {@link BaseCdpRemoteBrowserProvider} and
+ * implements only {@link AcquireSession}; all connect/disconnect orchestration, action mapping, and
+ * capability gating are inherited.
+ *
+ * Construct via the default constructor (the engine's `ClassFactory` path). By default it uses a
+ * {@link LocalChromeContainerRunner} (local headless Chromium) so it works with no external service. The
+ * container-runner seam is bound process-wide via the static {@link SetContainerRunnerFactory} — mirroring
+ * how bridge drivers bind their real SDK — so a deployment that wants a real container backend overrides
+ * the default once at startup and every resolved driver instance shares it.
+ *
+ * Registered via `@RegisterClass(BaseRemoteBrowserProvider, 'SelfHostRemoteBrowser')`.
+ */
+let SelfHostRemoteBrowser = class SelfHostRemoteBrowser extends BaseCdpRemoteBrowserProvider {
+    static { SelfHostRemoteBrowser_1 = this; }
+    /**
+     * The process-wide Chrome-container-runner factory. Defaults to {@link defaultContainerRunnerFactory}
+     * (a local headless Chromium); a deployment overrides it via {@link SetContainerRunnerFactory}.
+     */
+    static { this.containerRunnerFactory = defaultContainerRunnerFactory; }
+    /**
+     * Overrides the {@link ChromeContainerRunnerFactory} every {@link SelfHostRemoteBrowser} instance uses
+     * to acquire its Chrome container — the override seam, mirroring how bridge drivers bind their real
+     * SDK. The default is a local-Chromium runner, so this is only needed to point self-host at a real
+     * container backend; tests call it with a factory that returns a fake runner.
+     *
+     * @param factory The factory that constructs the Chrome-container runner.
+     */
+    static SetContainerRunnerFactory(factory) {
+        SelfHostRemoteBrowser_1.containerRunnerFactory = factory;
+    }
+    /**
+     * Acquires a CDP endpoint by leasing a headless-Chrome container through the bound runner, then wraps
+     * the container handle in a {@link SelfHostSessionBackend}. The shared base attaches its adapter to
+     * the returned endpoint and delegates the backend-specific concerns (live view / native-AI / release)
+     * to the backend.
+     *
+     * @param ctx The provider context (features, configuration, control mode, context user).
+     * @returns A promise resolving to the acquired CDP endpoint + Self-Hosted Chrome backend hooks.
+     */
+    async AcquireSession(ctx) {
+        this.applyContext(ctx);
+        const runner = SelfHostRemoteBrowser_1.containerRunnerFactory();
+        const options = this.buildAcquireOptions(ctx);
+        const handle = await runner.Acquire(options);
+        return {
+            CdpEndpoint: handle.CdpEndpoint,
+            Backend: new SelfHostSessionBackend(handle),
+        };
+    }
+    /**
+     * Builds the {@link ChromeContainerAcquireOptions} for a session from the provider context — carrying
+     * the optional viewport hints and the full opaque backend configuration through to the runner.
+     *
+     * @param ctx The provider context whose `Configuration` may carry viewport + backend hints.
+     * @returns The acquire options to hand the Chrome-container runner.
+     */
+    buildAcquireOptions(ctx) {
+        return {
+            ViewportWidth: this.readNumberOption(ctx.Configuration, 'ViewportWidth'),
+            ViewportHeight: this.readNumberOption(ctx.Configuration, 'ViewportHeight'),
+            Configuration: ctx.Configuration,
+        };
+    }
+    /**
+     * Reads an optional numeric value from the opaque, backend-specific `Configuration` record without
+     * resorting to `any`. Returns `undefined` when the key is absent or not a finite number.
+     *
+     * @param configuration The opaque configuration record (or undefined).
+     * @param key The key to read.
+     * @returns The numeric value, or `undefined` when absent/non-numeric.
+     */
+    readNumberOption(configuration, key) {
+        const value = configuration?.[key];
+        return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+    }
+};
+SelfHostRemoteBrowser = SelfHostRemoteBrowser_1 = __decorate([
+    RegisterClass(BaseRemoteBrowserProvider, SELF_HOST_REMOTE_BROWSER_DRIVER_CLASS)
+], SelfHostRemoteBrowser);
+export { SelfHostRemoteBrowser };
+/**
+ * Tree-shaking-prevention loader. Modern bundlers cannot see the `@RegisterClass` dynamic registration of
+ * {@link SelfHostRemoteBrowser} and may eliminate it. Import and call this no-op from a static code path
+ * (the package entry point does) so the `ClassFactory` can resolve `'SelfHostRemoteBrowser'`.
+ */
+export function LoadSelfHostRemoteBrowser() {
+    // Intentionally empty — referencing the module is what prevents tree-shaking.
+}
+//# sourceMappingURL=selfhost-remote-browser.js.map

package/dist/selfhost-remote-browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfhost-remote-browser.js","sourceRoot":"","sources":["../src/selfhost-remote-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;;;;;;;;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,yBAAyB,EAAgC,MAAM,qCAAqC,CAAC;AAC9G,OAAO,EAAsB,4BAA4B,EAAE,MAAM,oCAAoC,CAAC;AAMtG,OAAO,EAAE,0BAA0B,EAAE,MAAM,iCAAiC,CAAC;AAC7E,OAAO,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC;AAEpE;;;GAGG;AACH,MAAM,CAAC,MAAM,qCAAqC,GAAG,uBAAuB,CAAC;AAE7E;;;;;;;;GAQG;AACH,MAAM,6BAA6B,GAAiC,GAAG,EAAE,CAAC,IAAI,0BAA0B,EAAE,CAAC;AAE3G;;;;;;;;;;;;GAYG;AAEI,IAAM,qBAAqB,GAA3B,MAAM,qBAAsB,SAAQ,4BAA4B;;IACnE;;;OAGG;aACY,2BAAsB,GAAiC,6BAA6B,AAA9D,CAA+D;IAEpG;;;;;;;OAOG;IACI,MAAM,CAAC,yBAAyB,CAAC,OAAqC;QACzE,uBAAqB,CAAC,sBAAsB,GAAG,OAAO,CAAC;IAC3D,CAAC;IAED;;;;;;;;OAQG;IACO,KAAK,CAAC,cAAc,CAAC,GAAiC;QAC5D,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;QAEvB,MAAM,MAAM,GAA2B,uBAAqB,CAAC,sBAAsB,EAAE,CAAC;QACtF,MAAM,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,CAAC;QAC9C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAE7C,OAAO;YACH,WAAW,EAAE,MAAM,CAAC,WAAW;YAC/B,OAAO,EAAE,IAAI,sBAAsB,CAAC,MAAM,CAAC;SAC9C,CAAC;IACN,CAAC;IAED;;;;;;OAMG;IACK,mBAAmB,CAAC,GAAiC;QACzD,OAAO;YACH,aAAa,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,EAAE,eAAe,CAAC;YACxE,cAAc,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,aAAa,EAAE,gBAAgB,CAAC;YAC1E,aAAa,EAAE,GAAG,CAAC,aAAa;SACnC,CAAC;IACN,CAAC;IAED;;;;;;;OAOG;IACK,gBAAgB,CACpB,aAAkD,EAClD,GAAW;QAEX,MAAM,KAAK,GAAG,aAAa,EAAE,CAAC,GAAG,CAAC,CAAC;QACnC,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;IACnF,CAAC;;AAtEQ,qBAAqB;IADjC,aAAa,CAAC,yBAAyB,EAAE,qCAAqC,CAAC;GACnE,qBAAqB,CAuEjC;;AAED;;;;GAIG;AACH,MAAM,UAAU,yBAAyB;IACrC,8EAA8E;AAClF,CAAC"}

package/dist/selfhost-session-backend.d.ts

@@ -0,0 +1,102 @@
+/**
+ * `SelfHostSessionBackend` — the Self-Hosted Chrome implementation of the {@link ICdpSessionBackend} hook
+ * surface the shared CDP session delegates its three backend-specific concerns to (hosted live-view URL,
+ * native-AI delegation, backend release).
+ *
+ * It wraps the {@link ChromeContainerHandle} returned by the
+ * {@link import('./chrome-container-runner.js').IChromeContainerRunner} and answers exactly the
+ * Self-Hosted Chrome capability profile (per the `MJ: AI Remote Browser Providers` seed row
+ * "Self-Hosted Chrome" / `DriverClass = 'SelfHostRemoteBrowser'`):
+ * - **LiveView** is supported → {@link GetLiveViewUrl} returns the runner's MJ-hosted viewer URL (backed
+ *   by the inherited CDP screencast). It does NOT throw — the seed marks LiveView supported.
+ * - **NativeAIControl** is NOT supported → {@link InvokeNativeAIControl} throws
+ *   {@link RemoteBrowserCapabilityNotSupportedError}; self-host has no first-party AI harness, so MJ's own
+ *   computer-use loop drives the page.
+ * - **Release** always tears down the underlying container handle.
+ *
+ * @module @memberjunction/remote-browser-selfhost
+ * @author MemberJunction.com
+ */
+import { RemoteBrowserActionResult, RemoteBrowserAudioChunk } from '@memberjunction/remote-browser-base';
+import { ICdpAudioCaptureHandle, ICdpSessionBackend } from '@memberjunction/remote-browser-cdp';
+import { PlaywrightBrowserAdapter } from '@memberjunction/computer-use';
+import { ChromeContainerHandle } from './chrome-container-runner.js';
+/**
+ * The backend display name carried in capability-error messages from this backend, matching the seed
+ * row's `Name`.
+ */
+export declare const SELF_HOST_PROVIDER_NAME = "Self-Hosted Chrome";
+/**
+ * Self-Hosted Chrome's {@link ICdpSessionBackend}. Constructed by
+ * {@link import('./selfhost-remote-browser.js').SelfHostRemoteBrowser.AcquireSession} around the running
+ * container handle.
+ */
+export declare class SelfHostSessionBackend implements ICdpSessionBackend {
+    /**
+     * The running Chrome container handle this backend wraps — the source of the live-view URL and the
+     * teardown hook.
+     */
+    private readonly containerHandle;
+    /** Guards {@link Release} so the container is torn down at most once even if called repeatedly. */
+    private released;
+    /**
+     * Constructs a {@link SelfHostSessionBackend} around a running container handle.
+     *
+     * @param containerHandle The handle returned by the Chrome-container runner's `Acquire`.
+     */
+    constructor(containerHandle: ChromeContainerHandle);
+    /**
+     * Begins capturing the browser's tab audio (Self-Hosted Chrome supports it) by delegating to the
+     * shared adapter's in-page `MediaRecorder` capture mechanism, mapping each computer-use
+     * {@link AudioCaptureChunk} to the Base {@link RemoteBrowserAudioChunk}. The returned handle's
+     * `Stop` stops the adapter capture.
+     *
+     * Implementing this method is what advertises the audio capability for this backend (v1 gates audio
+     * by backend implementation, not a metadata flag) — so {@link CdpRemoteBrowserSession.StartAudioStream}
+     * starts rather than throws for Self-Hosted Chrome.
+     *
+     * @param adapter The connected Playwright/CDP adapter driving this session.
+     * @param onChunk Callback invoked with each captured audio chunk (Base shape).
+     * @returns A promise resolving to a handle whose `Stop` tears the capture down.
+     */
+    StartAudioCapture(adapter: PlaywrightBrowserAdapter, onChunk: (chunk: RemoteBrowserAudioChunk) => void): Promise<ICdpAudioCaptureHandle>;
+    /**
+     * Maps a computer-use {@link AudioCaptureChunk} to the Base {@link RemoteBrowserAudioChunk}. The two
+     * shapes are field-identical; this keeps the Base/CDP layers free of any computer-use dependency on the
+     * audio path.
+     *
+     * @param chunk The computer-use audio chunk.
+     * @returns The equivalent Base audio chunk.
+     */
+    private mapAudioChunk;
+    /**
+     * Returns the MJ-hosted, embeddable live-view URL — the runner's viewer page, whose frames come from
+     * the inherited CDP screencast. Self-host has no provider-hosted live view of its own, so this is
+     * MJ's own viewer backed by the screencast (the documented production binding seam).
+     *
+     * Does NOT throw: the seed row marks LiveView supported for Self-Hosted Chrome.
+     *
+     * @returns A promise resolving to the MJ-hosted viewer URL.
+     */
+    GetLiveViewUrl(): Promise<string>;
+    /**
+     * Always throws {@link RemoteBrowserCapabilityNotSupportedError}: Self-Hosted Chrome has no
+     * first-party AI-control harness, so high-level intents are driven by MJ's own computer-use loop
+     * rather than delegated to the backend. Matches the seed row, which does not enable
+     * `NativeAIControl`.
+     *
+     * @param _intent The natural-language intent — ignored; the call is unconditionally unsupported.
+     * @returns Never returns; always rejects.
+     * @throws {RemoteBrowserCapabilityNotSupportedError} unconditionally.
+     */
+    InvokeNativeAIControl(_intent: string): Promise<RemoteBrowserActionResult>;
+    /**
+     * Tears down the Chrome container behind this session by delegating to the container handle's
+     * `Release`. Idempotent — a second call after a successful release is a no-op, so teardown is safe to
+     * run from both the session's `Close()` and the provider's `Disconnect()`.
+     *
+     * @returns A promise that resolves once the container has been released.
+     */
+    Release(): Promise<void>;
+}
+//# sourceMappingURL=selfhost-session-backend.d.ts.map

package/dist/selfhost-session-backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfhost-session-backend.d.ts","sourceRoot":"","sources":["../src/selfhost-session-backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EACH,yBAAyB,EACzB,uBAAuB,EAE1B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAChG,OAAO,EAAqB,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC3F,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,uBAAuB,uBAAuB,CAAC;AAQ5D;;;;GAIG;AACH,qBAAa,sBAAuB,YAAW,kBAAkB;IAC7D;;;OAGG;IACH,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAwB;IAExD,mGAAmG;IACnG,OAAO,CAAC,QAAQ,CAAkB;IAElC;;;;OAIG;gBACS,eAAe,EAAE,qBAAqB;IAIlD;;;;;;;;;;;;;OAaG;IACU,iBAAiB,CAC1B,OAAO,EAAE,wBAAwB,EACjC,OAAO,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,GAClD,OAAO,CAAC,sBAAsB,CAAC;IASlC;;;;;;;OAOG;IACH,OAAO,CAAC,aAAa;IAWrB;;;;;;;;OAQG;IACU,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAI9C;;;;;;;;;OASG;IACU,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAOvF;;;;;;OAMG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAOxC"}

package/dist/selfhost-session-backend.js

@@ -0,0 +1,127 @@
+/**
+ * `SelfHostSessionBackend` — the Self-Hosted Chrome implementation of the {@link ICdpSessionBackend} hook
+ * surface the shared CDP session delegates its three backend-specific concerns to (hosted live-view URL,
+ * native-AI delegation, backend release).
+ *
+ * It wraps the {@link ChromeContainerHandle} returned by the
+ * {@link import('./chrome-container-runner.js').IChromeContainerRunner} and answers exactly the
+ * Self-Hosted Chrome capability profile (per the `MJ: AI Remote Browser Providers` seed row
+ * "Self-Hosted Chrome" / `DriverClass = 'SelfHostRemoteBrowser'`):
+ * - **LiveView** is supported → {@link GetLiveViewUrl} returns the runner's MJ-hosted viewer URL (backed
+ *   by the inherited CDP screencast). It does NOT throw — the seed marks LiveView supported.
+ * - **NativeAIControl** is NOT supported → {@link InvokeNativeAIControl} throws
+ *   {@link RemoteBrowserCapabilityNotSupportedError}; self-host has no first-party AI harness, so MJ's own
+ *   computer-use loop drives the page.
+ * - **Release** always tears down the underlying container handle.
+ *
+ * @module @memberjunction/remote-browser-selfhost
+ * @author MemberJunction.com
+ */
+import { RemoteBrowserCapabilityNotSupportedError, } from '@memberjunction/remote-browser-base';
+/**
+ * The backend display name carried in capability-error messages from this backend, matching the seed
+ * row's `Name`.
+ */
+export const SELF_HOST_PROVIDER_NAME = 'Self-Hosted Chrome';
+/**
+ * The capability key reported when {@link SelfHostSessionBackend.InvokeNativeAIControl} is invoked — the
+ * one feature Self-Hosted Chrome deliberately does not support.
+ */
+const NATIVE_AI_CONTROL_FEATURE = 'NativeAIControl';
+/**
+ * Self-Hosted Chrome's {@link ICdpSessionBackend}. Constructed by
+ * {@link import('./selfhost-remote-browser.js').SelfHostRemoteBrowser.AcquireSession} around the running
+ * container handle.
+ */
+export class SelfHostSessionBackend {
+    /**
+     * Constructs a {@link SelfHostSessionBackend} around a running container handle.
+     *
+     * @param containerHandle The handle returned by the Chrome-container runner's `Acquire`.
+     */
+    constructor(containerHandle) {
+        /** Guards {@link Release} so the container is torn down at most once even if called repeatedly. */
+        this.released = false;
+        this.containerHandle = containerHandle;
+    }
+    /**
+     * Begins capturing the browser's tab audio (Self-Hosted Chrome supports it) by delegating to the
+     * shared adapter's in-page `MediaRecorder` capture mechanism, mapping each computer-use
+     * {@link AudioCaptureChunk} to the Base {@link RemoteBrowserAudioChunk}. The returned handle's
+     * `Stop` stops the adapter capture.
+     *
+     * Implementing this method is what advertises the audio capability for this backend (v1 gates audio
+     * by backend implementation, not a metadata flag) — so {@link CdpRemoteBrowserSession.StartAudioStream}
+     * starts rather than throws for Self-Hosted Chrome.
+     *
+     * @param adapter The connected Playwright/CDP adapter driving this session.
+     * @param onChunk Callback invoked with each captured audio chunk (Base shape).
+     * @returns A promise resolving to a handle whose `Stop` tears the capture down.
+     */
+    async StartAudioCapture(adapter, onChunk) {
+        await adapter.StartAudioCapture((chunk) => onChunk(this.mapAudioChunk(chunk)));
+        return {
+            Stop: async () => {
+                await adapter.StopAudioCapture();
+            },
+        };
+    }
+    /**
+     * Maps a computer-use {@link AudioCaptureChunk} to the Base {@link RemoteBrowserAudioChunk}. The two
+     * shapes are field-identical; this keeps the Base/CDP layers free of any computer-use dependency on the
+     * audio path.
+     *
+     * @param chunk The computer-use audio chunk.
+     * @returns The equivalent Base audio chunk.
+     */
+    mapAudioChunk(chunk) {
+        return {
+            DataBase64: chunk.DataBase64,
+            Codec: chunk.Codec,
+            SampleRate: chunk.SampleRate,
+            Channels: chunk.Channels,
+            SequenceNumber: chunk.SequenceNumber,
+            DurationMs: chunk.DurationMs,
+        };
+    }
+    /**
+     * Returns the MJ-hosted, embeddable live-view URL — the runner's viewer page, whose frames come from
+     * the inherited CDP screencast. Self-host has no provider-hosted live view of its own, so this is
+     * MJ's own viewer backed by the screencast (the documented production binding seam).
+     *
+     * Does NOT throw: the seed row marks LiveView supported for Self-Hosted Chrome.
+     *
+     * @returns A promise resolving to the MJ-hosted viewer URL.
+     */
+    async GetLiveViewUrl() {
+        return this.containerHandle.ViewerUrl;
+    }
+    /**
+     * Always throws {@link RemoteBrowserCapabilityNotSupportedError}: Self-Hosted Chrome has no
+     * first-party AI-control harness, so high-level intents are driven by MJ's own computer-use loop
+     * rather than delegated to the backend. Matches the seed row, which does not enable
+     * `NativeAIControl`.
+     *
+     * @param _intent The natural-language intent — ignored; the call is unconditionally unsupported.
+     * @returns Never returns; always rejects.
+     * @throws {RemoteBrowserCapabilityNotSupportedError} unconditionally.
+     */
+    async InvokeNativeAIControl(_intent) {
+        throw new RemoteBrowserCapabilityNotSupportedError(NATIVE_AI_CONTROL_FEATURE, SELF_HOST_PROVIDER_NAME);
+    }
+    /**
+     * Tears down the Chrome container behind this session by delegating to the container handle's
+     * `Release`. Idempotent — a second call after a successful release is a no-op, so teardown is safe to
+     * run from both the session's `Close()` and the provider's `Disconnect()`.
+     *
+     * @returns A promise that resolves once the container has been released.
+     */
+    async Release() {
+        if (this.released) {
+            return;
+        }
+        this.released = true;
+        await this.containerHandle.Release();
+    }
+}
+//# sourceMappingURL=selfhost-session-backend.js.map

package/dist/selfhost-session-backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"selfhost-session-backend.js","sourceRoot":"","sources":["../src/selfhost-session-backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAGH,wCAAwC,GAC3C,MAAM,qCAAqC,CAAC;AAK7C;;;GAGG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,oBAAoB,CAAC;AAE5D;;;GAGG;AACH,MAAM,yBAAyB,GAAG,iBAAiB,CAAC;AAEpD;;;;GAIG;AACH,MAAM,OAAO,sBAAsB;IAU/B;;;;OAIG;IACH,YAAY,eAAsC;QARlD,mGAAmG;QAC3F,aAAQ,GAAY,KAAK,CAAC;QAQ9B,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;IAC3C,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,iBAAiB,CAC1B,OAAiC,EACjC,OAAiD;QAEjD,MAAM,OAAO,CAAC,iBAAiB,CAAC,CAAC,KAAwB,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAClG,OAAO;YACH,IAAI,EAAE,KAAK,IAAmB,EAAE;gBAC5B,MAAM,OAAO,CAAC,gBAAgB,EAAE,CAAC;YACrC,CAAC;SACJ,CAAC;IACN,CAAC;IAED;;;;;;;OAOG;IACK,aAAa,CAAC,KAAwB;QAC1C,OAAO;YACH,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,UAAU,EAAE,KAAK,CAAC,UAAU;YAC5B,QAAQ,EAAE,KAAK,CAAC,QAAQ;YACxB,cAAc,EAAE,KAAK,CAAC,cAAc;YACpC,UAAU,EAAE,KAAK,CAAC,UAAU;SAC/B,CAAC;IACN,CAAC;IAED;;;;;;;;OAQG;IACI,KAAK,CAAC,cAAc;QACvB,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;IAC1C,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,qBAAqB,CAAC,OAAe;QAC9C,MAAM,IAAI,wCAAwC,CAC9C,yBAAyB,EACzB,uBAAuB,CAC1B,CAAC;IACN,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,OAAO;QAChB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChB,OAAO;QACX,CAAC;QACD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;IACzC,CAAC;CACJ"}

package/package.json

@@ -1,10 +1,45 @@
 {
   "name": "@memberjunction/remote-browser-selfhost",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @memberjunction/remote-browser-selfhost",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "type": "module",
+  "version": "5.41.0",
+  "description": "MemberJunction: Self-Hosted Chrome backend driver for the Remote Browser channel. Connects the shared CDP control kit to a lightweight MJ-orchestrated headless-Chrome container (raw CDP control, MJ-hosted live view backed by the screencast, human takeover, screen streaming, persistent context, multi-tab, file downloads — no native AI control) via an injectable Chrome-container-runner seam, so the driver builds and unit-tests with no container, no network, and no real browser.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "scripts": {
+    "start": "ts-node-dev src/index.ts",
+    "build": "tsc && tsc-alias -f",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "author": "MemberJunction.com",
+  "license": "ISC",
+  "dependencies": {
+    "@memberjunction/computer-use": "5.41.0",
+    "@memberjunction/core": "5.41.0",
+    "@memberjunction/global": "5.41.0",
+    "@memberjunction/remote-browser-base": "5.41.0",
+    "@memberjunction/remote-browser-cdp": "5.41.0"
+  },
+  "peerDependencies": {
+    "playwright": ">=1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "playwright": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "24.10.11",
+    "playwright": "^1.40.0",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemberJunction/MJ"
+  }
 }