@bctrl/sdk 1.0.1 → 1.0.3

package/dist/workspaces/client.d.ts

@@ -1,48 +0,0 @@
-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

@@ -1,222 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,2 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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 {};