@mearl/native-host 2.3.0 → 2.5.0

package/dist/agentbay-browser.d.ts

@@ -0,0 +1,91 @@
+/** AgentBay browser lifecycle and CDP endpoint resolution. */
+import { type DaemonRecord } from '@mearl/daemon-core';
+import type { BrowserLaunchParams } from '@mearl/browser-core';
+import { type TransferableCookie } from './cdp-backend/cookie-transfer.js';
+export declare const DEFAULT_AGENTBAY_IMAGE_ID = "imgc-0aae4rgl8kvagdv1j";
+export interface AgentBayBrowserRecord extends DaemonRecord {
+    pid: number;
+    browserId: string;
+    name: string;
+    sessionId: string;
+    imageId?: string;
+    accessUrl?: string;
+    createdAt: string;
+    copiedCookies?: {
+        domains: string[];
+        count: number;
+    };
+}
+export interface AgentBaySessionLike {
+    sessionId: string;
+    resourceUrl?: string;
+    browser: {
+        initializeAsync(options: Record<string, unknown>): Promise<boolean>;
+        getEndpointUrl(): Promise<string>;
+    };
+    delete(syncContext?: boolean): Promise<{
+        success: boolean;
+        errorMessage?: string;
+    }>;
+    keepAlive(): Promise<{
+        success?: boolean;
+        errorMessage?: string;
+    }>;
+}
+export interface AgentBayClientLike {
+    create(params: Record<string, unknown>): Promise<{
+        success: boolean;
+        session?: AgentBaySessionLike;
+        errorMessage?: string;
+    }>;
+    get(sessionId: string): Promise<{
+        success: boolean;
+        session?: AgentBaySessionLike;
+        errorMessage?: string;
+    }>;
+}
+export interface AgentBayBrowserSummary {
+    browserId: string;
+    name: string;
+    provider: 'agentbay';
+    headless: false;
+    persistent: false;
+    agentbaySessionId: string;
+    agentbayImageId?: string;
+    agentbayAccessUrl?: string;
+    createdAt: string;
+    copiedCookies?: AgentBayBrowserRecord['copiedCookies'];
+    running: boolean;
+}
+export interface AgentBayBrowserManagerDeps {
+    nativeHostScript: string;
+    exportCookies: (domains: string[]) => Promise<TransferableCookie[]>;
+    getBrowserUserAgent: () => Promise<string>;
+    log: (...args: any[]) => void;
+    createAgentBayClient?: (apiKey: string) => Promise<AgentBayClientLike>;
+    persistBrowserRecord?: (record: AgentBayBrowserRecord) => void;
+    resolveApiKey?: () => string;
+}
+interface AgentBayCdpClient {
+    sendCommand(method: string, params?: Record<string, any>, timeoutMs?: number): Promise<any>;
+    close(): void;
+}
+type ConnectAgentBayCdp = (endpoint: string) => Promise<AgentBayCdpClient>;
+interface AgentBayBrowserSessionInitOptions {
+    userAgent?: string;
+    connectCdp?: ConnectAgentBayCdp;
+}
+/** Stable managed-browser identity while keeping the cloud provider explicit. */
+export declare function agentBayBrowserId(name: string): string;
+export declare function resolveAgentBayApiKey(): string;
+export declare function resolveAgentBayImageId(value: unknown): string;
+export declare function normalizeDesktopUserAgent(value: unknown): string;
+export declare function normalizeAgentBayAccessUrl(value: unknown): string | undefined;
+export declare function hasAgentBayBrowser(selector: string): boolean;
+export declare function listAgentBayBrowsers(): AgentBayBrowserSummary[];
+export declare function resolveAgentBayEndpoint(sessionId: string): Promise<string>;
+export declare function keepAgentBaySessionAlive(sessionId: string): Promise<void>;
+export declare function initializeAgentBayBrowserSession(session: Pick<AgentBaySessionLike, 'browser'>, input: Pick<BrowserLaunchParams, 'url'>, cookies: TransferableCookie[], options?: AgentBayBrowserSessionInitOptions): Promise<number>;
+export declare function launchAgentBayBrowser(input: BrowserLaunchParams, deps: AgentBayBrowserManagerDeps): Promise<AgentBayBrowserSummary>;
+export declare function closeAgentBayBrowser(selector: string): Promise<Record<string, any>>;
+export {};

package/dist/browser-inventory.d.ts

@@ -1,7 +1,8 @@
 import type { BrowserListResult } from '@mearl/browser-core';
 import { type BrowserRecord } from './browser-registry.js';
 import { type ManagedBrowserSummary } from './managed-browser.js';
+import { type AgentBayBrowserSummary } from './agentbay-browser.js';
 type BrowserInventoryResult = Omit<BrowserListResult, 'defaultBrowserId'>;
-export declare function mergeBrowserInventory(connected: BrowserRecord[], managed: ManagedBrowserSummary[]): BrowserInventoryResult;
+export declare function mergeBrowserInventory(connected: BrowserRecord[], managed: Array<ManagedBrowserSummary | AgentBayBrowserSummary>): BrowserInventoryResult;
 export declare function listBrowserInventory(): BrowserInventoryResult;
 export {};

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

@@ -19,18 +19,23 @@ export interface PageSession {
         touch: boolean;
     };
 }
+export interface CdpSessionOptions {
+    port?: number;
+    userDataDir?: string;
+    endpointUrl?: string;
+    endpointResolver?: () => Promise<string>;
+}
 export declare class CdpSession {
     readonly port: number;
     readonly userDataDir?: string;
+    private readonly endpointUrl?;
+    private readonly endpointResolver?;
     private browserClient;
     private pageSessions;
     /** Virtual tabId counter → CDP targetId */
     private tabIdMap;
     private nextTabId;
-    constructor(options?: number | {
-        port?: number;
-        userDataDir?: string;
-    });
+    constructor(options?: number | CdpSessionOptions);
     getBrowserClient(): Promise<CdpClient>;
     /**
      * Get (or create) a page session.
@@ -58,6 +63,7 @@ export declare class CdpSession {
      * Used when HTTP /json is unavailable.
      */
     private pageWsUrl;
+    private isRemote;
     private findTargetByIdViaCdp;
     private findDefaultPageTargetViaCdp;
     private fetchVersionInfo;

package/dist/cdp-backend/client.d.ts

@@ -1,15 +1,5 @@
-/**
- * Minimal WebSocket-based CDP client for native-host (no external deps).
- * Uses node:http upgrade event + raw frame handling via node:net Socket.
- */
+/** WebSocket CDP client shared by local and remote browser sessions. */
 type EventCallback = (params: any) => void;
-/**
- * A virtual client that routes CDP messages through a specific sessionId
- * on a shared browser-level WebSocket connection.
- *
- * This is used for page-level commands when Chrome does not allow direct
- * connections to /devtools/page/... (e.g., when enabled via chrome://inspect).
- */
 export declare class CdpChildSession {
     private readonly parent;
     readonly sessionId: string;
@@ -20,28 +10,25 @@ export declare class CdpChildSession {
     close(): void;
 }
 export declare class CdpClient {
-    private socket;
-    private buffer;
+    private readonly socket;
     private nextId;
     private pending;
     private eventHandlers;
-    /** sessionId → method → callbacks (for multiplexed page sessions) */
     private sessionEventHandlers;
     private _closed;
     private constructor();
-    /** Create a child session client that routes through this connection via sessionId. */
+    static connect(wsUrl: string): Promise<CdpClient>;
     createChildSession(sessionId: string): CdpChildSession;
-    /** Send a command within a specific CDP session (multiplexed on this connection). */
     sendCommandInSession(sessionId: string, method: string, params?: Record<string, any>, timeoutMs?: number): Promise<any>;
-    /** Subscribe to events from a specific CDP session. */
     onSession(sessionId: string, method: string, callback: EventCallback): () => void;
-    static connect(wsUrl: string): Promise<CdpClient>;
-    private consumeFrames;
-    private handleMessage;
     sendCommand(method: string, params?: Record<string, any>, timeoutMs?: number): Promise<any>;
     on(method: string, callback: EventCallback): () => void;
-    private sendText;
     close(): void;
     get closed(): boolean;
+    private sendRequest;
+    private consumeMessage;
+    private handleMessage;
+    private handleClosed;
+    private rejectPending;
 }
 export {};

package/dist/cdp-backend/cookie-transfer.d.ts

@@ -18,8 +18,13 @@ export interface TransferableCookie {
         hasCrossSiteAncestor?: boolean;
     };
 }
+interface CookieCommandClient {
+    sendCommand(method: string, params?: Record<string, any>, timeoutMs?: number): Promise<any>;
+}
 export declare function normalizeCookieDomain(input: string): string;
 export declare function normalizeCookieDomains(inputs: unknown): string[];
 export declare function cookieMatchesDomain(cookieDomain: string, requestedDomain: string): boolean;
 export declare function cdpExportCookies(session: CdpSession, domains: string[]): Promise<TransferableCookie[]>;
 export declare function cdpImportCookies(session: CdpSession, cookies: TransferableCookie[]): Promise<number>;
+export declare function cdpImportCookiesWithClient(browser: CookieCommandClient, cookies: TransferableCookie[]): Promise<number>;
+export {};

package/dist/host-updater.d.ts

@@ -0,0 +1,39 @@
+import { type CommandRunner } from '@mearl/setup/process';
+export declare const NATIVE_HOST_UPDATE_TIMEOUT_MS: number;
+export type NativeHostUpdateError = 'lock-timeout' | 'network' | 'package-unavailable' | 'setup-failed' | 'timeout' | 'verification-failed' | 'unknown';
+export interface NativeHostUpdateCommand {
+    args: string[];
+}
+type UpdateLockRunner = <T>(targetVersion: string, operation: () => Promise<T>) => Promise<T>;
+export interface RunNativeHostUpdateOptions {
+    areTargetsInstalled?: (targetReleaseLine: string, environment: NodeJS.ProcessEnv) => Promise<boolean>;
+    environment?: NodeJS.ProcessEnv;
+    nodePath?: string;
+    packageBinDirectory?: string | null;
+    packageManagerCommand?: string | null;
+    packageRunner?: string;
+    platform?: NodeJS.Platform;
+    runner?: CommandRunner;
+    timeoutMs?: number;
+    updateLockPath?: string;
+    withUpdateLock?: UpdateLockRunner;
+}
+export interface NativeHostUpdateCoordinatorOptions {
+    hostVersion: string;
+    log: (...args: unknown[]) => void;
+    requestRestart: () => void | Promise<void>;
+    runUpdate: (targetVersion: string) => Promise<void>;
+}
+export declare class NativeHostUpdateFailure extends Error {
+    readonly updateError: NativeHostUpdateError;
+    constructor(updateError: NativeHostUpdateError, message: string);
+}
+export declare function nativeHostUpdateCommand(targetVersion: string): NativeHostUpdateCommand;
+export declare function runNativeHostUpdate(targetVersion: string, options?: RunNativeHostUpdateOptions): Promise<void>;
+export declare class NativeHostUpdateCoordinator {
+    #private;
+    private readonly options;
+    constructor(options: NativeHostUpdateCoordinatorOptions);
+    evaluate(extensionVersion: unknown, checkForUpdates: unknown): void;
+}
+export {};