@memberjunction/remote-browser-steel 0.0.1 → 5.41.0

package/README.md

@@ -1,45 +1,76 @@
 # @memberjunction/remote-browser-steel
 
-## ⚠️ IMPORTANT NOTICE ⚠️
+The **Steel** ([steel.dev](https://steel.dev)) backend driver for the MemberJunction Remote Browser
+channel.
 
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
+Steel is a browser-as-a-service: a CDP connect endpoint plus a hosted session viewer (with human
+takeover), stealth, proxy egress, session recording, persistent contexts, multi-tab, downloads, and
+CAPTCHA solving — but **no first-party AI-control harness**. Steel sessions are driven by MJ's own
+computer-use control (or OSS Stagehand-over-CDP). This package contributes the `SteelRemoteBrowser`
+driver that the channel resolves for the "Steel" provider metadata row.
 
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
+## How trivial the driver is
 
-## Purpose
+All Remote Browser backends drive the page **identically over CDP** — the shared
+[`@memberjunction/remote-browser-cdp`](../../Cdp) kit owns that entire control path (action translation,
+capability gating, screencast, human takeover, `Connect`/`Disconnect`, teardown). A driver subclasses
+`BaseCdpRemoteBrowserProvider` and fills in just **one hook**:
 
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@memberjunction/remote-browser-steel`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
+```ts
+protected async AcquireSession(ctx): Promise<{ CdpEndpoint: string; Backend: ICdpSessionBackend }>
+```
 
-## What is OIDC Trusted Publishing?
+`SteelRemoteBrowser.AcquireSession` calls the client's `CreateSession` and returns its CDP endpoint plus
+a small `ICdpSessionBackend`:
 
-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.
+| Backend hook | Steel mapping |
+| --- | --- |
+| `GetLiveViewUrl()` | the hosted session-viewer URL from `CreateSession` |
+| `InvokeNativeAIControl(intent)` | **throws** `RemoteBrowserCapabilityNotSupportedError('NativeAIControl', 'Steel')` — no first-party AI harness |
+| `Release()` | `client.ReleaseSession(...)` |
 
-## Setup Instructions
+## Capabilities
 
-To properly configure OIDC trusted publishing for this package:
+Mirrors the "Steel" seed row's `SupportedFeatures`: LiveView, HumanTakeover, ScreenStreaming, Stealth,
+ProxyEgress, SessionRecording, PersistentContext, MultiTab, FileDownloads, CaptchaSolving (plus
+`RawCdpControl`). **`NativeAIControl` is intentionally absent** — and the driver enforces that by throwing
+when it is invoked.
 
-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
+## The injectable client seam
 
-## DO NOT USE THIS PACKAGE
+All Steel I/O goes through `ISteelClient`, so this package builds and unit-tests with **no network, no
+real SDK, and no API keys**:
 
-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
+```ts
+export interface ISteelClient {
+    CreateSession(opts): Promise<{ SessionId: string; CdpEndpoint: string; SessionViewerUrl: string }>;
+    ReleaseSession(sessionId: string): Promise<void>;
+}
+```
 
-## More Information
+The default factory throws until you bind a real one — production must opt in explicitly:
 
-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)
+```ts
+import { SteelRemoteBrowser } from '@memberjunction/remote-browser-steel';
 
----
+SteelRemoteBrowser.SetClientFactory((config) => new MySteelClientAdapter(config));
+```
 
-**Maintained for OIDC setup purposes only**
+## Production binding
+
+Bind `ISteelClient` to the official **[`steel-sdk`](https://www.npmjs.com/package/steel-sdk)**:
+
+- `CreateSession` → `Steel.sessions.create(...)` (session id + CDP `websocketUrl` + `sessionViewerUrl`).
+- `ReleaseSession` → `Steel.sessions.release(id)`.
+
+Declare `steel-sdk` as an optional dependency wherever the production factory is bound — none of the SDK
+types leak into this package.
+
+## Install & build
+
+```bash
+npm install          # from the repo root
+cd packages/AI/RemoteBrowser/Providers/Steel
+npm run build
+npm run test
+```

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * `@memberjunction/remote-browser-steel` — the Steel ([steel.dev](https://steel.dev)) backend driver for
+ * the Remote Browser channel.
+ *
+ * Exports the injectable client seam ({@link ISteelClient} + factory types) and the driver
+ * ({@link SteelRemoteBrowser}), and statically anchors the driver's `@RegisterClass` registration so
+ * bundlers cannot tree-shake it away.
+ *
+ * @module @memberjunction/remote-browser-steel
+ */
+export * from './steel-client.js';
+export * from './steel-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;;;;;;;;;GASG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC"}

package/dist/index.js

@@ -0,0 +1,18 @@
+/**
+ * `@memberjunction/remote-browser-steel` — the Steel ([steel.dev](https://steel.dev)) backend driver for
+ * the Remote Browser channel.
+ *
+ * Exports the injectable client seam ({@link ISteelClient} + factory types) and the driver
+ * ({@link SteelRemoteBrowser}), and statically anchors the driver's `@RegisterClass` registration so
+ * bundlers cannot tree-shake it away.
+ *
+ * @module @memberjunction/remote-browser-steel
+ */
+export * from './steel-client.js';
+export * from './steel-remote-browser.js';
+import { LoadSteelRemoteBrowser } from './steel-remote-browser.js';
+// Static reference so bundlers cannot tree-shake the
+// @RegisterClass(BaseRemoteBrowserProvider, 'SteelRemoteBrowser') registration. Calling the no-op here
+// keeps the driver resolvable by the engine's ClassFactory.
+LoadSteelRemoteBrowser();
+//# 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;;;;;;;;;GASG;AAEH,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AAEvC,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,qDAAqD;AACrD,uGAAuG;AACvG,4DAA4D;AAC5D,sBAAsB,EAAE,CAAC"}

package/dist/steel-client.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The injectable **Steel service-client seam** — the minimal set of operations the
+ * {@link import('./steel-remote-browser.js').SteelRemoteBrowser} driver needs from Steel
+ * ([steel.dev](https://steel.dev)), declared as an interface so the driver builds and unit-tests against
+ * an in-memory fake with **no network, no real Steel SDK, and no API keys**.
+ *
+ * ## Production binding (at deployment)
+ * In production this interface is bound to the **`steel-sdk`** package. The named operations map to the
+ * SDK as follows:
+ * - {@link ISteelClient.CreateSession} → `Steel.sessions.create(...)`, returning the session id, its CDP
+ *   connect endpoint (`websocketUrl` / `connectUrl`), and the hosted session-viewer URL
+ *   (`sessionViewerUrl`).
+ * - {@link ISteelClient.ReleaseSession} → `Steel.sessions.release(id)`.
+ *
+ * Steel has **no first-party AI-control harness** — sessions are driven by MJ's own computer-use control
+ * (or OSS Stagehand-over-CDP) — so this seam intentionally has no `Act`-style operation; the driver
+ * throws `RemoteBrowserCapabilityNotSupportedError('NativeAIControl', 'Steel')` for native AI control,
+ * matching the seed row.
+ *
+ * Binding the real SDK is a thin adapter that implements this interface; the driver and its tests do not
+ * change. **None of the SDK types leak into this package** — declare `steel-sdk` as an optional
+ * dependency wherever the production factory is bound.
+ *
+ * @module @memberjunction/remote-browser-steel
+ * @author MemberJunction.com
+ */
+/**
+ * The session-creation options the driver passes through to the Steel client. Deliberately a thin,
+ * opaque pass-through of the resolved provider/session configuration (region, stealth/proxy settings,
+ * persistent-context id, …) — the driver does not interpret these; the bound client does. Never carries
+ * inline secrets: credentials resolve through MJ's credential system upstream.
+ */
+export interface SteelCreateSessionOptions {
+    /**
+     * The opaque, backend-specific configuration to create the session with (region, proxy, stealth,
+     * persistent-context id, …). Typed as a record of unknown values rather than `any` so it stays
+     * inspectable without losing type-safety at the boundary; the bound client narrows it.
+     */
+    Configuration?: Record<string, unknown>;
+}
+/**
+ * The handles the seam returns after a successful {@link ISteelClient.CreateSession}.
+ */
+export interface SteelSessionHandles {
+    /** The Steel session id — the durable external connection id, used to release the session. */
+    SessionId: string;
+    /**
+     * The Chrome DevTools Protocol connect endpoint for the created session. The shared CDP kit attaches
+     * the computer-use adapter to this over CDP.
+     */
+    CdpEndpoint: string;
+    /** The hosted, embeddable session-viewer URL so humans can watch (and take over) the browser. */
+    SessionViewerUrl: string;
+}
+/**
+ * The minimal Steel service surface the {@link import('./steel-remote-browser.js').SteelRemoteBrowser} driver
+ * depends on. Production binds this to the real `steel-sdk`; tests inject a `FakeSteelClient`.
+ */
+export interface ISteelClient {
+    /**
+     * Creates a new Steel session and returns its id, CDP connect endpoint, and hosted session-viewer
+     * URL.
+     *
+     * @param options The session-creation options (opaque resolved configuration).
+     * @returns The created session's handles.
+     */
+    CreateSession(options: SteelCreateSessionOptions): Promise<SteelSessionHandles>;
+    /**
+     * Releases a Steel session, freeing the backing browser. Should be idempotent / non-throwing for an
+     * already-released session so teardown is safe to run more than once.
+     *
+     * @param sessionId The Steel session id to release.
+     */
+    ReleaseSession(sessionId: string): Promise<void>;
+}
+/**
+ * A factory that constructs an {@link ISteelClient} for a session — the dependency-injection seam.
+ * Production supplies a factory that builds the real `steel-sdk` adapter from resolved config; tests
+ * supply one that returns a `FakeSteelClient`.
+ *
+ * @param config The resolved provider/session configuration (region, credential refs already resolved upstream).
+ * @returns The Steel client instance the driver creates and drives sessions with.
+ */
+export type SteelClientFactory = (config?: Record<string, unknown>) => ISteelClient;
+//# sourceMappingURL=steel-client.d.ts.map

package/dist/steel-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"steel-client.d.ts","sourceRoot":"","sources":["../src/steel-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACtC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,8FAA8F;IAC9F,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,iGAAiG;IACjG,gBAAgB,EAAE,MAAM,CAAC;CAC5B;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IACzB;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAEhF;;;;;OAKG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,YAAY,CAAC"}

package/dist/steel-client.js

@@ -0,0 +1,28 @@
+/**
+ * The injectable **Steel service-client seam** — the minimal set of operations the
+ * {@link import('./steel-remote-browser.js').SteelRemoteBrowser} driver needs from Steel
+ * ([steel.dev](https://steel.dev)), declared as an interface so the driver builds and unit-tests against
+ * an in-memory fake with **no network, no real Steel SDK, and no API keys**.
+ *
+ * ## Production binding (at deployment)
+ * In production this interface is bound to the **`steel-sdk`** package. The named operations map to the
+ * SDK as follows:
+ * - {@link ISteelClient.CreateSession} → `Steel.sessions.create(...)`, returning the session id, its CDP
+ *   connect endpoint (`websocketUrl` / `connectUrl`), and the hosted session-viewer URL
+ *   (`sessionViewerUrl`).
+ * - {@link ISteelClient.ReleaseSession} → `Steel.sessions.release(id)`.
+ *
+ * Steel has **no first-party AI-control harness** — sessions are driven by MJ's own computer-use control
+ * (or OSS Stagehand-over-CDP) — so this seam intentionally has no `Act`-style operation; the driver
+ * throws `RemoteBrowserCapabilityNotSupportedError('NativeAIControl', 'Steel')` for native AI control,
+ * matching the seed row.
+ *
+ * Binding the real SDK is a thin adapter that implements this interface; the driver and its tests do not
+ * change. **None of the SDK types leak into this package** — declare `steel-sdk` as an optional
+ * dependency wherever the production factory is bound.
+ *
+ * @module @memberjunction/remote-browser-steel
+ * @author MemberJunction.com
+ */
+export {};
+//# sourceMappingURL=steel-client.js.map

package/dist/steel-client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"steel-client.js","sourceRoot":"","sources":["../src/steel-client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG"}

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

@@ -0,0 +1,85 @@
+/**
+ * @fileoverview `SteelRemoteBrowser` — the Steel ([steel.dev](https://steel.dev)) backend driver for the
+ * MemberJunction Remote Browser channel. Steel is a browser-as-a-service with a CDP connect endpoint and
+ * a hosted session viewer (with human takeover), stealth, proxy egress, session recording, persistent
+ * contexts, multi-tab, downloads, and CAPTCHA solving — but **no first-party AI-control harness**.
+ *
+ * The driver is trivial by design: it subclasses {@link BaseCdpRemoteBrowserProvider} and fills in only
+ * the one backend-specific hook — {@link SteelRemoteBrowser.AcquireSession} — plus the small
+ * {@link ICdpSessionBackend} it returns. The shared CDP kit owns everything else (action translation,
+ * capability gating, screencast, human takeover, Connect/Disconnect orchestration, teardown).
+ *
+ * Because Steel has no native AI harness, the backend's `InvokeNativeAIControl` throws
+ * {@link RemoteBrowserCapabilityNotSupportedError} (the `NativeAIControl` capability is absent from the
+ * "Steel" seed row); Steel sessions are driven by MJ's own computer-use control instead.
+ *
+ * All Steel I/O goes through the injectable {@link ISteelClient} seam, so the driver builds and
+ * unit-tests with NO network, NO real Steel SDK, and NO API keys. Production binds the real `steel-sdk`
+ * via {@link SteelRemoteBrowser.SetClientFactory}.
+ *
+ * Registered via `@RegisterClass(BaseRemoteBrowserProvider, 'SteelRemoteBrowser')` — the `DriverClass`
+ * of the "Steel" provider metadata row.
+ *
+ * @module @memberjunction/remote-browser-steel
+ * @author MemberJunction.com
+ */
+import { RemoteBrowserProviderContext } from '@memberjunction/remote-browser-base';
+import { AcquiredCdpSession, BaseCdpRemoteBrowserProvider } from '@memberjunction/remote-browser-cdp';
+import { SteelClientFactory } from './steel-client.js';
+/**
+ * The `DriverClass` identifier this driver registers under — matches the "Steel" provider metadata
+ * row's `DriverClass` so the engine's `ClassFactory` resolves it.
+ */
+export declare const STEEL_DRIVER_CLASS = "SteelRemoteBrowser";
+/**
+ * The Steel backend driver. Subclasses {@link BaseCdpRemoteBrowserProvider}, implementing only the
+ * `AcquireSession` hook (and the backend it returns); all CDP control is inherited.
+ */
+export declare class SteelRemoteBrowser extends BaseCdpRemoteBrowserProvider {
+    /**
+     * The process-wide factory used to construct the Steel client for each session. Defaults to a
+     * factory that throws until {@link SteelRemoteBrowser.SetClientFactory} binds a real one.
+     */
+    private static clientFactory;
+    /**
+     * Binds the {@link SteelClientFactory} every {@link SteelRemoteBrowser} instance uses to construct its
+     * Steel client. Production binds a factory that builds the real `steel-sdk` adapter; tests bind one
+     * that returns a fake. The dependency-injection seam that keeps this package free of a hard
+     * SDK/network dependency.
+     *
+     * @param factory The factory to use for subsequently-opened sessions.
+     */
+    static SetClientFactory(factory: SteelClientFactory): void;
+    /**
+     * The Steel client for the live session, retained so the backend's `Release` can use it. `null`
+     * before {@link SteelRemoteBrowser.AcquireSession}.
+     */
+    private client;
+    /**
+     * Acquires a CDP session from Steel: constructs the client from the bound factory, creates a session,
+     * and returns its CDP endpoint plus the {@link ICdpSessionBackend} that answers Steel's live-view /
+     * native-AI / release concerns.
+     *
+     * @param ctx The provider context (features, configuration, control mode, context user).
+     * @returns The acquired CDP endpoint + Steel-specific backend hooks.
+     */
+    protected AcquireSession(ctx: RemoteBrowserProviderContext): Promise<AcquiredCdpSession>;
+    /**
+     * Builds the {@link ICdpSessionBackend} for a live Steel session, capturing the client, session id,
+     * and session-viewer URL the lifecycle-specific calls need. `InvokeNativeAIControl` always throws —
+     * Steel has no first-party AI harness.
+     *
+     * @param client The Steel client driving this session.
+     * @param sessionId The Steel session id.
+     * @param sessionViewerUrl The hosted session-viewer URL for the session.
+     * @returns The backend hooks the shared session delegates its backend-specific concerns to.
+     */
+    private buildBackend;
+}
+/**
+ * Tree-shaking-prevention loader. Modern bundlers cannot see the `@RegisterClass` dynamic registration,
+ * so a static reference to this no-op (called from `index.ts`) keeps the driver resolvable by the
+ * engine's `ClassFactory`.
+ */
+export declare function LoadSteelRemoteBrowser(): void;
+//# sourceMappingURL=steel-remote-browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"steel-remote-browser.d.ts","sourceRoot":"","sources":["../src/steel-remote-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAIH,4BAA4B,EAC/B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EACH,kBAAkB,EAClB,4BAA4B,EAE/B,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EAEH,kBAAkB,EACrB,MAAM,gBAAgB,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,kBAAkB,uBAAuB,CAAC;AAmBvD;;;GAGG;AACH,qBACa,kBAAmB,SAAQ,4BAA4B;IAChE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,aAAa,CAA4C;IAExE;;;;;;;OAOG;WACW,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAIjE;;;OAGG;IACH,OAAO,CAAC,MAAM,CAA6B;IAE3C;;;;;;;OAOG;cACa,cAAc,CAAC,GAAG,EAAE,4BAA4B,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAY9F;;;;;;;;;OASG;IACH,OAAO,CAAC,YAAY;CAgBvB;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C"}

package/dist/steel-remote-browser.js

@@ -0,0 +1,136 @@
+/**
+ * @fileoverview `SteelRemoteBrowser` — the Steel ([steel.dev](https://steel.dev)) backend driver for the
+ * MemberJunction Remote Browser channel. Steel is a browser-as-a-service with a CDP connect endpoint and
+ * a hosted session viewer (with human takeover), stealth, proxy egress, session recording, persistent
+ * contexts, multi-tab, downloads, and CAPTCHA solving — but **no first-party AI-control harness**.
+ *
+ * The driver is trivial by design: it subclasses {@link BaseCdpRemoteBrowserProvider} and fills in only
+ * the one backend-specific hook — {@link SteelRemoteBrowser.AcquireSession} — plus the small
+ * {@link ICdpSessionBackend} it returns. The shared CDP kit owns everything else (action translation,
+ * capability gating, screencast, human takeover, Connect/Disconnect orchestration, teardown).
+ *
+ * Because Steel has no native AI harness, the backend's `InvokeNativeAIControl` throws
+ * {@link RemoteBrowserCapabilityNotSupportedError} (the `NativeAIControl` capability is absent from the
+ * "Steel" seed row); Steel sessions are driven by MJ's own computer-use control instead.
+ *
+ * All Steel I/O goes through the injectable {@link ISteelClient} seam, so the driver builds and
+ * unit-tests with NO network, NO real Steel SDK, and NO API keys. Production binds the real `steel-sdk`
+ * via {@link SteelRemoteBrowser.SetClientFactory}.
+ *
+ * Registered via `@RegisterClass(BaseRemoteBrowserProvider, 'SteelRemoteBrowser')` — the `DriverClass`
+ * of the "Steel" provider metadata row.
+ *
+ * @module @memberjunction/remote-browser-steel
+ * @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 SteelRemoteBrowser_1;
+import { RegisterClass } from '@memberjunction/global';
+import { BaseRemoteBrowserProvider, RemoteBrowserCapabilityNotSupportedError, } from '@memberjunction/remote-browser-base';
+import { BaseCdpRemoteBrowserProvider, } from '@memberjunction/remote-browser-cdp';
+/**
+ * The `DriverClass` identifier this driver registers under — matches the "Steel" provider metadata
+ * row's `DriverClass` so the engine's `ClassFactory` resolves it.
+ */
+export const STEEL_DRIVER_CLASS = 'SteelRemoteBrowser';
+/** The backend display name used in capability-error messages for this driver. */
+const STEEL_PROVIDER_NAME = 'Steel';
+/**
+ * The default {@link SteelClientFactory}: refuses to run until a real factory is bound via
+ * {@link SteelRemoteBrowser.SetClientFactory}. This keeps the package free of any real SDK / network
+ * dependency — production must explicitly bind `steel-sdk`, and tests bind a fake.
+ *
+ * @throws {Error} always — instructing the caller to bind a real client factory.
+ */
+const defaultClientFactory = () => {
+    throw new Error('SteelRemoteBrowser has no Steel client bound. Call SteelRemoteBrowser.SetClientFactory(...) ' +
+        'to bind the real Steel client (steel-sdk) before opening a session.');
+};
+/**
+ * The Steel backend driver. Subclasses {@link BaseCdpRemoteBrowserProvider}, implementing only the
+ * `AcquireSession` hook (and the backend it returns); all CDP control is inherited.
+ */
+let SteelRemoteBrowser = class SteelRemoteBrowser extends BaseCdpRemoteBrowserProvider {
+    constructor() {
+        super(...arguments);
+        /**
+         * The Steel client for the live session, retained so the backend's `Release` can use it. `null`
+         * before {@link SteelRemoteBrowser.AcquireSession}.
+         */
+        this.client = null;
+    }
+    static { SteelRemoteBrowser_1 = this; }
+    /**
+     * The process-wide factory used to construct the Steel client for each session. Defaults to a
+     * factory that throws until {@link SteelRemoteBrowser.SetClientFactory} binds a real one.
+     */
+    static { this.clientFactory = defaultClientFactory; }
+    /**
+     * Binds the {@link SteelClientFactory} every {@link SteelRemoteBrowser} instance uses to construct its
+     * Steel client. Production binds a factory that builds the real `steel-sdk` adapter; tests bind one
+     * that returns a fake. The dependency-injection seam that keeps this package free of a hard
+     * SDK/network dependency.
+     *
+     * @param factory The factory to use for subsequently-opened sessions.
+     */
+    static SetClientFactory(factory) {
+        SteelRemoteBrowser_1.clientFactory = factory;
+    }
+    /**
+     * Acquires a CDP session from Steel: constructs the client from the bound factory, creates a session,
+     * and returns its CDP endpoint plus the {@link ICdpSessionBackend} that answers Steel's live-view /
+     * native-AI / release concerns.
+     *
+     * @param ctx The provider context (features, configuration, control mode, context user).
+     * @returns The acquired CDP endpoint + Steel-specific backend hooks.
+     */
+    async AcquireSession(ctx) {
+        const client = SteelRemoteBrowser_1.clientFactory(ctx.Configuration);
+        this.client = client;
+        const handles = await client.CreateSession({ Configuration: ctx.Configuration });
+        return {
+            CdpEndpoint: handles.CdpEndpoint,
+            Backend: this.buildBackend(client, handles.SessionId, handles.SessionViewerUrl),
+        };
+    }
+    /**
+     * Builds the {@link ICdpSessionBackend} for a live Steel session, capturing the client, session id,
+     * and session-viewer URL the lifecycle-specific calls need. `InvokeNativeAIControl` always throws —
+     * Steel has no first-party AI harness.
+     *
+     * @param client The Steel client driving this session.
+     * @param sessionId The Steel session id.
+     * @param sessionViewerUrl The hosted session-viewer URL for the session.
+     * @returns The backend hooks the shared session delegates its backend-specific concerns to.
+     */
+    buildBackend(client, sessionId, sessionViewerUrl) {
+        return {
+            GetLiveViewUrl: async () => sessionViewerUrl,
+            InvokeNativeAIControl: () => {
+                throw new RemoteBrowserCapabilityNotSupportedError('NativeAIControl', STEEL_PROVIDER_NAME);
+            },
+            Release: async () => {
+                await client.ReleaseSession(sessionId);
+                this.client = null;
+            },
+        };
+    }
+};
+SteelRemoteBrowser = SteelRemoteBrowser_1 = __decorate([
+    RegisterClass(BaseRemoteBrowserProvider, STEEL_DRIVER_CLASS)
+], SteelRemoteBrowser);
+export { SteelRemoteBrowser };
+/**
+ * Tree-shaking-prevention loader. Modern bundlers cannot see the `@RegisterClass` dynamic registration,
+ * so a static reference to this no-op (called from `index.ts`) keeps the driver resolvable by the
+ * engine's `ClassFactory`.
+ */
+export function LoadSteelRemoteBrowser() {
+    // Intentionally empty — exists only to anchor a static import of this module.
+}
+//# sourceMappingURL=steel-remote-browser.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"steel-remote-browser.js","sourceRoot":"","sources":["../src/steel-remote-browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;;;;;;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACH,yBAAyB,EAEzB,wCAAwC,GAE3C,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAEH,4BAA4B,GAE/B,MAAM,oCAAoC,CAAC;AAM5C;;;GAGG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAEvD,kFAAkF;AAClF,MAAM,mBAAmB,GAAG,OAAO,CAAC;AAEpC;;;;;;GAMG;AACH,MAAM,oBAAoB,GAAuB,GAAG,EAAE;IAClD,MAAM,IAAI,KAAK,CACX,8FAA8F;QAC1F,qEAAqE,CAC5E,CAAC;AACN,CAAC,CAAC;AAEF;;;GAGG;AAEI,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,4BAA4B;IAA7D;;QAmBH;;;WAGG;QACK,WAAM,GAAwB,IAAI,CAAC;IAgD/C,CAAC;;IAtEG;;;OAGG;aACY,kBAAa,GAAuB,oBAAoB,AAA3C,CAA4C;IAExE;;;;;;;OAOG;IACI,MAAM,CAAC,gBAAgB,CAAC,OAA2B;QACtD,oBAAkB,CAAC,aAAa,GAAG,OAAO,CAAC;IAC/C,CAAC;IAQD;;;;;;;OAOG;IACO,KAAK,CAAC,cAAc,CAAC,GAAiC;QAC5D,MAAM,MAAM,GAAG,oBAAkB,CAAC,aAAa,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QACnE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QAErB,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,EAAE,aAAa,EAAE,GAAG,CAAC,aAAa,EAAE,CAAC,CAAC;QAEjF,OAAO;YACH,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,OAAO,EAAE,IAAI,CAAC,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,gBAAgB,CAAC;SAClF,CAAC;IACN,CAAC;IAED;;;;;;;;;OASG;IACK,YAAY,CAChB,MAAoB,EACpB,SAAiB,EACjB,gBAAwB;QAExB,OAAO;YACH,cAAc,EAAE,KAAK,IAAqB,EAAE,CAAC,gBAAgB;YAC7D,qBAAqB,EAAE,GAAuC,EAAE;gBAC5D,MAAM,IAAI,wCAAwC,CAAC,iBAAiB,EAAE,mBAAmB,CAAC,CAAC;YAC/F,CAAC;YACD,OAAO,EAAE,KAAK,IAAmB,EAAE;gBAC/B,MAAM,MAAM,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;gBACvC,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;YACvB,CAAC;SACJ,CAAC;IACN,CAAC;;AAtEQ,kBAAkB;IAD9B,aAAa,CAAC,yBAAyB,EAAE,kBAAkB,CAAC;GAChD,kBAAkB,CAuE9B;;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB;IAClC,8EAA8E;AAClF,CAAC"}

package/package.json

@@ -1,10 +1,35 @@
 {
   "name": "@memberjunction/remote-browser-steel",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @memberjunction/remote-browser-steel",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "type": "module",
+  "version": "5.41.0",
+  "description": "MemberJunction: Steel (steel.dev) backend driver for the Remote Browser channel. Acquires a CDP session from Steel via an injectable client seam and exposes its hosted session-viewer URL. Steel has no first-party AI harness, so native AI control is unsupported (driven by MJ computer-use instead). Everything else is inherited from @memberjunction/remote-browser-cdp.",
+  "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/core": "5.41.0",
+    "@memberjunction/global": "5.41.0",
+    "@memberjunction/remote-browser-base": "5.41.0",
+    "@memberjunction/remote-browser-cdp": "5.41.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.10.11",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MemberJunction/MJ"
+  }
 }