@bctrl/sdk 1.0.1

package/dist/workspaces/client.d.ts

@@ -0,0 +1,48 @@
+import type { BrowserRuntimeCreateRequest, Operation, OperationWaitRequest, OperationWaitResponse, Runtime, Workspace, WorkspaceArtifact, WorkspaceArtifactsListQuery, WorkspaceCreateRequest, WorkspaceExecuteRequest, WorkspaceExecuteResponse, WorkspaceHelpRequest, WorkspaceHelpResponse, WorkspaceStateQuery, WorkspaceStateResponse, RuntimeLiveEmbedRequest } from '../contracts/public-api.js';
+import { type BrowserRuntimeLiveEmbed, type BrowserRuntimeRecordingEmbed, RuntimeNamespace } from './browser-runtime.js';
+declare class WorkspaceOperationsClient {
+    private readonly workspaceClient;
+    constructor(workspaceClient: WorkspaceClient);
+    get(operationId: string): Promise<Operation>;
+    wait(operationId: string, request?: OperationWaitRequest): Promise<OperationWaitResponse>;
+    cancel(operationId: string): Promise<Operation>;
+}
+declare class WorkspaceArtifactsClient {
+    private readonly workspaceClient;
+    constructor(workspaceClient: WorkspaceClient);
+    list(query?: WorkspaceArtifactsListQuery): Promise<WorkspaceArtifact[]>;
+    get(artifactId: string): Promise<WorkspaceArtifact>;
+}
+export declare class WorkspaceClient {
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    readonly runtimes: RuntimeNamespace;
+    readonly operations: WorkspaceOperationsClient;
+    readonly artifacts: WorkspaceArtifactsClient;
+    private workspaceValue;
+    constructor(baseUrl: string, apiKey: string, workspace: Workspace);
+    get id(): string;
+    get name(): string;
+    get mounts(): Workspace['mounts'];
+    get workspace(): Workspace;
+    refresh(): Promise<Workspace>;
+    state(query?: WorkspaceStateQuery): Promise<WorkspaceStateResponse>;
+    help(request?: WorkspaceHelpRequest): Promise<WorkspaceHelpResponse>;
+    execute(request: WorkspaceExecuteRequest): Promise<WorkspaceExecuteResponse>;
+    createBrowserRuntime(request: BrowserRuntimeCreateRequest): Promise<Runtime>;
+    stopRuntime(alias: string): Promise<Runtime>;
+    getRuntime(alias: string): Promise<Runtime | null>;
+    private toAbsoluteUrl;
+    embedRuntimeLive(alias: string, request?: RuntimeLiveEmbedRequest): Promise<BrowserRuntimeLiveEmbed>;
+    embedRuntimeRecording(alias: string): Promise<BrowserRuntimeRecordingEmbed>;
+    listRuntimes(): Promise<Runtime[]>;
+}
+export declare class WorkspacesClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    create(request: WorkspaceCreateRequest): Promise<WorkspaceClient>;
+    open(id: string): Promise<WorkspaceClient>;
+    list(): Promise<Workspace[]>;
+}
+export {};

package/dist/workspaces/client.js

@@ -0,0 +1,222 @@
+import { fetchWithTimeout, parseErrorDetails, parseJsonResponse } from '../utils/http.js';
+import { SDK_VERSION } from '../version.js';
+import { RuntimeNamespace, } from './browser-runtime.js';
+function buildHeaders(apiKey, withJsonBody = false) {
+    const headers = {
+        'x-sdk-version': SDK_VERSION,
+        Authorization: `Bearer ${apiKey}`,
+    };
+    if (withJsonBody) {
+        headers['Content-Type'] = 'application/json';
+    }
+    return headers;
+}
+async function expectJson(response, context) {
+    if (!response.ok) {
+        const details = parseErrorDetails(await response.text());
+        throw new Error(`${context}: ${details.message}`);
+    }
+    return parseJsonResponse(response, context);
+}
+class WorkspaceOperationsClient {
+    workspaceClient;
+    constructor(workspaceClient) {
+        this.workspaceClient = workspaceClient;
+    }
+    async get(operationId) {
+        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/operations/${encodeURIComponent(operationId)}`, {
+            headers: buildHeaders(this.workspaceClient.apiKey),
+        });
+        return expectJson(response, 'Get operation');
+    }
+    async wait(operationId, request = {}) {
+        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/operations/${encodeURIComponent(operationId)}/wait`, {
+            method: 'POST',
+            headers: buildHeaders(this.workspaceClient.apiKey, true),
+            body: JSON.stringify(request),
+        }, (request.timeoutMs ?? 30_000) + 5_000);
+        return expectJson(response, 'Wait for operation');
+    }
+    async cancel(operationId) {
+        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/operations/${encodeURIComponent(operationId)}/cancel`, {
+            method: 'POST',
+            headers: buildHeaders(this.workspaceClient.apiKey),
+        });
+        return expectJson(response, 'Cancel operation');
+    }
+}
+class WorkspaceArtifactsClient {
+    workspaceClient;
+    constructor(workspaceClient) {
+        this.workspaceClient = workspaceClient;
+    }
+    async list(query = {}) {
+        const params = new URLSearchParams();
+        if (query.runtime)
+            params.set('runtime', query.runtime);
+        if (query.limit !== undefined)
+            params.set('limit', String(query.limit));
+        const suffix = params.toString() ? `?${params.toString()}` : '';
+        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/workspaces/${encodeURIComponent(this.workspaceClient.id)}/artifacts${suffix}`, {
+            headers: buildHeaders(this.workspaceClient.apiKey),
+        });
+        const data = await expectJson(response, 'List workspace artifacts');
+        return data.artifacts;
+    }
+    async get(artifactId) {
+        const response = await fetchWithTimeout(`${this.workspaceClient.baseUrl}/workspaces/${encodeURIComponent(this.workspaceClient.id)}/artifacts/${encodeURIComponent(artifactId)}`, {
+            headers: buildHeaders(this.workspaceClient.apiKey),
+        });
+        return expectJson(response, 'Get workspace artifact');
+    }
+}
+export class WorkspaceClient {
+    baseUrl;
+    apiKey;
+    runtimes;
+    operations;
+    artifacts;
+    workspaceValue;
+    constructor(baseUrl, apiKey, workspace) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+        this.workspaceValue = workspace;
+        this.runtimes = new RuntimeNamespace(this);
+        this.operations = new WorkspaceOperationsClient(this);
+        this.artifacts = new WorkspaceArtifactsClient(this);
+    }
+    get id() {
+        return this.workspaceValue.id;
+    }
+    get name() {
+        return this.workspaceValue.name;
+    }
+    get mounts() {
+        return this.workspaceValue.mounts;
+    }
+    get workspace() {
+        return this.workspaceValue;
+    }
+    async refresh() {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}`, {
+            headers: buildHeaders(this.apiKey),
+        });
+        this.workspaceValue = await expectJson(response, 'Get workspace');
+        return this.workspaceValue;
+    }
+    async state(query = {}) {
+        const params = new URLSearchParams();
+        if (query.runtime) {
+            params.set('runtime', query.runtime);
+        }
+        const suffix = params.toString() ? `?${params.toString()}` : '';
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/state${suffix}`, {
+            headers: buildHeaders(this.apiKey),
+        });
+        return expectJson(response, 'Workspace state');
+    }
+    async help(request = {}) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/help`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey, true),
+            body: JSON.stringify(request),
+        });
+        return expectJson(response, 'Workspace help');
+    }
+    async execute(request) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/execute`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey, true),
+            body: JSON.stringify(request),
+        });
+        return expectJson(response, 'Workspace execute');
+    }
+    async createBrowserRuntime(request) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/runtimes`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey, true),
+            body: JSON.stringify(request),
+        });
+        return expectJson(response, 'Create runtime');
+    }
+    async stopRuntime(alias) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/runtimes/${encodeURIComponent(alias)}/stop`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey),
+        });
+        return expectJson(response, 'Stop runtime');
+    }
+    async getRuntime(alias) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/runtimes/${encodeURIComponent(alias)}`, {
+            headers: buildHeaders(this.apiKey),
+        });
+        if (response.status === 404) {
+            return null;
+        }
+        return expectJson(response, 'Get runtime');
+    }
+    toAbsoluteUrl(pathOrUrl) {
+        return new URL(pathOrUrl, this.baseUrl).toString();
+    }
+    async embedRuntimeLive(alias, request = {}) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/runtimes/${encodeURIComponent(alias)}/embed/live`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey, true),
+            body: JSON.stringify(request),
+        });
+        const data = await expectJson(response, 'Mint live runtime embed');
+        return {
+            ...data,
+            iframeUrl: this.toAbsoluteUrl(data.iframeUrl),
+        };
+    }
+    async embedRuntimeRecording(alias) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/runtimes/${encodeURIComponent(alias)}/embed/recording`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey),
+        });
+        const data = await expectJson(response, 'Mint recording runtime embed');
+        return {
+            ...data,
+            iframeUrl: this.toAbsoluteUrl(data.iframeUrl),
+        };
+    }
+    async listRuntimes() {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(this.id)}/runtimes`, {
+            headers: buildHeaders(this.apiKey),
+        });
+        const data = await expectJson(response, 'List runtimes');
+        return data.runtimes;
+    }
+}
+export class WorkspacesClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async create(request) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces`, {
+            method: 'POST',
+            headers: buildHeaders(this.apiKey, true),
+            body: JSON.stringify(request),
+        });
+        const workspace = await expectJson(response, 'Create workspace');
+        return new WorkspaceClient(this.baseUrl, this.apiKey, workspace);
+    }
+    async open(id) {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces/${encodeURIComponent(id)}`, {
+            headers: buildHeaders(this.apiKey),
+        });
+        const workspace = await expectJson(response, 'Open workspace');
+        return new WorkspaceClient(this.baseUrl, this.apiKey, workspace);
+    }
+    async list() {
+        const response = await fetchWithTimeout(`${this.baseUrl}/workspaces`, {
+            headers: buildHeaders(this.apiKey),
+        });
+        const data = await expectJson(response, 'List workspaces');
+        return data.workspaces;
+    }
+}

package/dist/workspaces/index.d.ts

@@ -0,0 +1,2 @@
+export { WorkspaceClient, WorkspacesClient } from './client.js';
+export { BrowserRuntimeAccessor, BrowserRuntimeClient, BrowserRuntimeBuilder, PlaywrightBrowserRuntimeClient, PuppeteerBrowserRuntimeClient, StagehandBrowserRuntimeClient, SeleniumBrowserRuntimeClient, type BrowserRuntimeLiveEmbed, type BrowserRuntimeRecordingEmbed, type RuntimePuppeteerPage, type RuntimeRunRequest, type RuntimeStagehandPage, type AnyBrowserRuntimeClient, } from './browser-runtime.js';

package/dist/workspaces/index.js

@@ -0,0 +1,2 @@
+export { WorkspaceClient, WorkspacesClient } from './client.js';
+export { BrowserRuntimeAccessor, BrowserRuntimeClient, BrowserRuntimeBuilder, PlaywrightBrowserRuntimeClient, PuppeteerBrowserRuntimeClient, StagehandBrowserRuntimeClient, SeleniumBrowserRuntimeClient, } from './browser-runtime.js';

package/dist/workspaces/runtime-event-pump.d.ts

@@ -0,0 +1,65 @@
+import type { RuntimeEventsWaitRequest, RuntimeEventsWaitResponse } from '../contracts/public-api.js';
+type DialogAction = 'accept' | 'dismiss';
+interface EmitterLike {
+    emit(event: string, payload: unknown): boolean;
+    listenerCount(event: string): number;
+}
+interface ClosableEmitterLike extends EmitterLike {
+    markClosed?: () => void;
+}
+export type RuntimeEventMap = Record<string, string>;
+export interface RuntimePageEmitterRegistration {
+    pageId: string;
+    emitter: ClosableEmitterLike;
+    eventMap: RuntimeEventMap;
+    createPage?: (pageId: string) => unknown;
+    callDialogAction?: (dialogId: string, action: DialogAction, promptText?: string) => Promise<void>;
+}
+export interface RuntimeContextEmitterRegistration {
+    contextId: string;
+    emitter: EmitterLike;
+    eventMap: RuntimeEventMap;
+    createPage?: (pageId: string) => unknown;
+}
+export interface RuntimeEventPumpWaiter {
+    wait(request?: RuntimeEventsWaitRequest, options?: {
+        signal?: AbortSignal;
+    }): Promise<RuntimeEventsWaitResponse>;
+}
+export declare class RuntimeEventPump {
+    private readonly waiter;
+    private readonly pageEmitters;
+    private readonly pageEmitterRecords;
+    private readonly contextEmitters;
+    private readonly contextEmitterRecords;
+    private readonly activeBindingCounts;
+    private readonly activeBackendTypeCounts;
+    private activeBindingTotal;
+    private cursor;
+    private disposed;
+    private currentEventTypesKey;
+    private waitAbortController;
+    private waitPromise;
+    constructor(waiter: RuntimeEventPumpWaiter);
+    registerPageEmitter(registration: RuntimePageEmitterRegistration): void;
+    registerContextEmitter(registration: RuntimeContextEmitterRegistration): void;
+    close(): Promise<void>;
+    private bindingKey;
+    private activeBackendTypes;
+    private backendTypesKey;
+    private updateCursor;
+    private incrementBinding;
+    private decrementBinding;
+    private reconfigureLoopIfNeeded;
+    private ensureLoop;
+    private runWaitLoop;
+    private dispatchRuntimeEvent;
+    private dispatchPageEvent;
+    private dispatchContextEvent;
+    private unregisterPageEmitter;
+    private unregisterContextEmitter;
+    private createPageForEvent;
+    private buildPagePayload;
+    private buildContextPayload;
+}
+export {};