@bctrl/sdk 1.0.1 → 1.0.2

package/dist/invocations.js

@@ -0,0 +1,66 @@
+export class V2InvocationResource {
+    http;
+    data;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+    }
+    get id() {
+        return this.data.id;
+    }
+    refresh() {
+        return this.http
+            .request(`/invocations/${encodeURIComponent(this.id)}`)
+            .then((response) => response.data);
+    }
+    wait(request) {
+        return this.http.request(`/invocations/${encodeURIComponent(this.id)}/wait`, {
+            method: 'POST',
+            body: request ?? {},
+        });
+    }
+    cancel() {
+        return this.http
+            .request(`/invocations/${encodeURIComponent(this.id)}/cancel`, {
+            method: 'POST',
+        })
+            .then((response) => response.data);
+    }
+}
+export class V2InvocationsClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async get(id) {
+        const response = await this.http.request(`/invocations/${encodeURIComponent(id)}`);
+        return new V2InvocationResource(this.http, response.data);
+    }
+    wait(id, request) {
+        return this.http.request(`/invocations/${encodeURIComponent(id)}/wait`, {
+            method: 'POST',
+            body: request ?? {},
+        });
+    }
+    async cancel(id) {
+        const response = await this.http.request(`/invocations/${encodeURIComponent(id)}/cancel`, {
+            method: 'POST',
+        });
+        return new V2InvocationResource(this.http, response.data);
+    }
+}
+export class V2RuntimeInvocationsClient {
+    http;
+    runtimeId;
+    constructor(http, runtimeId) {
+        this.http = http;
+        this.runtimeId = runtimeId;
+    }
+    async create(request) {
+        const response = await this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/invocations`, {
+            method: 'POST',
+            body: request,
+        });
+        return new V2InvocationResource(this.http, response.data);
+    }
+}

package/dist/pagination.d.ts

@@ -0,0 +1,2 @@
+import type { V2ListEnvelope, V2PageQuery } from './types.js';
+export declare function iterateV2Pages<T, Q extends V2PageQuery>(initialQuery: Q, fetchPage: (query: Q) => Promise<V2ListEnvelope<T>>): AsyncGenerator<T, void, undefined>;

package/dist/pagination.js

@@ -0,0 +1,13 @@
+export async function* iterateV2Pages(initialQuery, fetchPage) {
+    let cursor = initialQuery.cursor;
+    for (;;) {
+        const page = await fetchPage({ ...initialQuery, cursor });
+        for (const item of page.data) {
+            yield item;
+        }
+        if (!page.nextCursor) {
+            return;
+        }
+        cursor = page.nextCursor;
+    }
+}

package/dist/runs.d.ts

@@ -0,0 +1,38 @@
+import type { V2HttpClient } from './http.js';
+import { V2RunFilesClient } from './files.js';
+import type { V2ListEnvelope, V2Run, V2RunCommand, V2RunCommandsListQuery, V2RunEvent, V2RunEventsListQuery, V2RunEventsWaitRequest, V2RunEventsWaitResponse, V2RunListQuery, V2RunLiveRequest, V2RunLiveResponse, V2RunRecordingRequest, V2RunRecordingResponse } from './types.js';
+export declare class V2RunEventsClient {
+    private readonly http;
+    private readonly runId;
+    constructor(http: V2HttpClient, runId: string);
+    list(query?: V2RunEventsListQuery): Promise<V2ListEnvelope<V2RunEvent>>;
+    iter(query?: V2RunEventsListQuery): AsyncGenerator<V2RunEvent, void, undefined>;
+    wait(request?: V2RunEventsWaitRequest): Promise<V2RunEventsWaitResponse>;
+    streamUrl(query?: Pick<V2RunEventsListQuery, 'type' | 'category' | 'connectionId'>): string;
+}
+export declare class V2RunCommandsClient {
+    private readonly http;
+    private readonly runId;
+    constructor(http: V2HttpClient, runId: string);
+    list(query?: V2RunCommandsListQuery): Promise<V2ListEnvelope<V2RunCommand>>;
+    iter(query?: V2RunCommandsListQuery): AsyncGenerator<V2RunCommand, void, undefined>;
+}
+export declare class V2RunResource {
+    private readonly http;
+    readonly data: V2Run;
+    readonly events: V2RunEventsClient;
+    readonly commands: V2RunCommandsClient;
+    readonly files: V2RunFilesClient;
+    constructor(http: V2HttpClient, data: V2Run);
+    get id(): string;
+    refresh(): Promise<V2RunResource>;
+    live(request?: V2RunLiveRequest): Promise<V2RunLiveResponse>;
+    recording(request?: V2RunRecordingRequest): Promise<V2RunRecordingResponse>;
+}
+export declare class V2RunsClient {
+    private readonly http;
+    constructor(http: V2HttpClient);
+    list(query?: V2RunListQuery): Promise<V2ListEnvelope<V2Run>>;
+    iter(query?: V2RunListQuery): AsyncGenerator<V2Run, void, undefined>;
+    get(id: string): Promise<V2RunResource>;
+}

package/dist/runs.js

@@ -0,0 +1,99 @@
+import { iterateV2Pages } from './pagination.js';
+import { V2RunFilesClient } from './files.js';
+export class V2RunEventsClient {
+    http;
+    runId;
+    constructor(http, runId) {
+        this.http = http;
+        this.runId = runId;
+    }
+    list(query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/events`, { query });
+    }
+    iter(query = {}) {
+        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    wait(request) {
+        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/events/wait`, {
+            method: 'POST',
+            body: request ?? {},
+        });
+    }
+    streamUrl(query = {}) {
+        const url = new URL(`${this.http.baseUrl}/runs/${encodeURIComponent(this.runId)}/events/stream`);
+        for (const [key, value] of Object.entries(query)) {
+            if (value === undefined)
+                continue;
+            if (Array.isArray(value)) {
+                for (const item of value)
+                    url.searchParams.append(key, item);
+            }
+            else {
+                url.searchParams.set(key, value);
+            }
+        }
+        return url.toString();
+    }
+}
+export class V2RunCommandsClient {
+    http;
+    runId;
+    constructor(http, runId) {
+        this.http = http;
+        this.runId = runId;
+    }
+    list(query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/commands`, { query });
+    }
+    iter(query = {}) {
+        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+}
+export class V2RunResource {
+    http;
+    data;
+    events;
+    commands;
+    files;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+        this.events = new V2RunEventsClient(http, data.id);
+        this.commands = new V2RunCommandsClient(http, data.id);
+        this.files = new V2RunFilesClient(http, data.id);
+    }
+    get id() {
+        return this.data.id;
+    }
+    refresh() {
+        return new V2RunsClient(this.http).get(this.id);
+    }
+    live(request) {
+        return this.http.request(`/runs/${encodeURIComponent(this.id)}/live`, {
+            method: 'POST',
+            body: request ?? {},
+        });
+    }
+    recording(request) {
+        return this.http.request(`/runs/${encodeURIComponent(this.id)}/recording`, {
+            method: 'POST',
+            body: request ?? {},
+        });
+    }
+}
+export class V2RunsClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}) {
+        return this.http.request('/runs', { query });
+    }
+    iter(query = {}) {
+        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    async get(id) {
+        const run = await this.http.request(`/runs/${encodeURIComponent(id)}`);
+        return new V2RunResource(this.http, run);
+    }
+}

package/dist/runtimes.d.ts

@@ -0,0 +1,73 @@
+import type { V2HttpClient } from './http.js';
+import { V2RuntimeInvocationsClient } from './invocations.js';
+import { V2RunResource } from './runs.js';
+import type { V2ListEnvelope, V2File, V2Runtime, V2RuntimeConnection, V2RuntimeConnectionCreateOptions, V2RuntimeConnectionCreateResponse, V2RuntimeCreateRequest, V2RuntimeFileCollectRequest, V2RuntimeFileStageRequest, V2RuntimeFileUploadRequest, V2RuntimeFileUploadResponse, V2RuntimeStagedFile, V2RuntimeListQuery, V2RuntimeRunListQuery, V2RunSummary, V2SpaceRuntimeCreateRequest } from './types.js';
+export declare class V2RuntimeConnectionResource {
+    private readonly http;
+    private readonly runtimeId;
+    readonly data: V2RuntimeConnectionCreateResponse;
+    constructor(http: V2HttpClient, runtimeId: string, data: V2RuntimeConnectionCreateResponse);
+    get id(): string;
+    get endpoint(): V2RuntimeConnectionCreateResponse['endpoint'];
+    get wsUrl(): string | undefined;
+    close(): Promise<V2RuntimeConnection>;
+}
+export declare class V2RuntimeConnectionsClient {
+    private readonly http;
+    private readonly runtimeId;
+    constructor(http: V2HttpClient, runtimeId: string);
+    create(request?: V2RuntimeConnectionCreateOptions): Promise<V2RuntimeConnectionResource>;
+    list(query?: {
+        status?: string | string[];
+        limit?: number;
+    }): Promise<V2ListEnvelope<V2RuntimeConnection>>;
+    delete(connectionId: string): Promise<V2RuntimeConnection>;
+}
+export declare class V2RuntimeRunsClient {
+    private readonly http;
+    private readonly runtimeId;
+    constructor(http: V2HttpClient, runtimeId: string);
+    list(query?: V2RuntimeRunListQuery): Promise<V2ListEnvelope<V2RunSummary>>;
+    iter(query?: V2RuntimeRunListQuery): AsyncGenerator<V2RunSummary, void, undefined>;
+}
+export declare class V2RuntimeFilesClient {
+    private readonly http;
+    private readonly runtimeId;
+    constructor(http: V2HttpClient, runtimeId: string);
+    upload(request: V2RuntimeFileUploadRequest): Promise<V2RuntimeFileUploadResponse>;
+    stage(request: V2RuntimeFileStageRequest): Promise<V2RuntimeStagedFile>;
+    collect(request: V2RuntimeFileCollectRequest): Promise<V2File>;
+}
+export declare class V2RuntimeResource {
+    private readonly http;
+    readonly data: V2Runtime;
+    readonly connections: V2RuntimeConnectionsClient;
+    readonly files: V2RuntimeFilesClient;
+    readonly runs: V2RuntimeRunsClient;
+    readonly invocations: V2RuntimeInvocationsClient;
+    constructor(http: V2HttpClient, data: V2Runtime);
+    get id(): string;
+    get activeRunId(): string | null;
+    refresh(): Promise<V2RuntimeResource>;
+    connect(request?: V2RuntimeConnectionCreateOptions): Promise<V2RuntimeConnectionResource>;
+    start(): Promise<{
+        runtime: V2RuntimeResource;
+        run: V2RunResource;
+    }>;
+    stop(): Promise<V2Runtime>;
+    run(): Promise<V2RunResource>;
+}
+export declare class V2RuntimesClient {
+    private readonly http;
+    constructor(http: V2HttpClient);
+    list(query?: V2RuntimeListQuery): Promise<V2ListEnvelope<V2Runtime>>;
+    iter(query?: V2RuntimeListQuery): AsyncGenerator<V2Runtime, void, undefined>;
+    create(request: V2RuntimeCreateRequest): Promise<V2RuntimeResource>;
+    createInSpace(spaceId: string, request: V2SpaceRuntimeCreateRequest): Promise<V2RuntimeResource>;
+    get(id: string): Promise<V2RuntimeResource>;
+    stop(id: string): Promise<V2Runtime>;
+    start(id: string): Promise<{
+        runtime: V2RuntimeResource;
+        run: V2RunResource;
+    }>;
+}

package/dist/runtimes.js

@@ -0,0 +1,205 @@
+import { BctrlValidationError } from './errors.js';
+import { V2RuntimeInvocationsClient } from './invocations.js';
+import { iterateV2Pages } from './pagination.js';
+import { V2RunResource } from './runs.js';
+export class V2RuntimeConnectionResource {
+    http;
+    runtimeId;
+    data;
+    constructor(http, runtimeId, data) {
+        this.http = http;
+        this.runtimeId = runtimeId;
+        this.data = data;
+    }
+    get id() {
+        return this.data.id;
+    }
+    get endpoint() {
+        return this.data.endpoint;
+    }
+    get wsUrl() {
+        return this.data.endpoint.type === 'websocket' ? this.data.endpoint.url : undefined;
+    }
+    close() {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(this.id)}`, { method: 'DELETE' });
+    }
+}
+export class V2RuntimeConnectionsClient {
+    http;
+    runtimeId;
+    constructor(http, runtimeId) {
+        this.http = http;
+        this.runtimeId = runtimeId;
+    }
+    async create(request = {}) {
+        const response = await this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections`, {
+            method: 'POST',
+            body: {
+                protocol: request.protocol ?? 'cdp',
+                ...request,
+            },
+        });
+        return new V2RuntimeConnectionResource(this.http, this.runtimeId, response);
+    }
+    list(query = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections`, { query });
+    }
+    delete(connectionId) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(connectionId)}`, { method: 'DELETE' });
+    }
+}
+export class V2RuntimeRunsClient {
+    http;
+    runtimeId;
+    constructor(http, runtimeId) {
+        this.http = http;
+        this.runtimeId = runtimeId;
+    }
+    list(query = {}) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/runs`, { query });
+    }
+    iter(query = {}) {
+        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+}
+export class V2RuntimeFilesClient {
+    http;
+    runtimeId;
+    constructor(http, runtimeId) {
+        this.http = http;
+        this.runtimeId = runtimeId;
+    }
+    async upload(request) {
+        const form = new FormData();
+        if (request.name) {
+            form.set('file', request.file, request.name);
+            form.set('name', request.name);
+        }
+        else {
+            form.set('file', request.file);
+        }
+        if (request.storagePath)
+            form.set('storagePath', request.storagePath);
+        if (request.metadata)
+            form.set('metadata', JSON.stringify(request.metadata));
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/upload`, {
+            method: 'POST',
+            body: form,
+        });
+    }
+    stage(request) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/stage`, {
+            method: 'POST',
+            body: request,
+        });
+    }
+    collect(request) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/files/collect`, {
+            method: 'POST',
+            body: request,
+        });
+    }
+}
+export class V2RuntimeResource {
+    http;
+    data;
+    connections;
+    files;
+    runs;
+    invocations;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+        this.connections = new V2RuntimeConnectionsClient(http, data.id);
+        this.files = new V2RuntimeFilesClient(http, data.id);
+        this.runs = new V2RuntimeRunsClient(http, data.id);
+        this.invocations = new V2RuntimeInvocationsClient(http, data.id);
+    }
+    get id() {
+        return this.data.id;
+    }
+    get activeRunId() {
+        return this.data.activeRunId;
+    }
+    refresh() {
+        return new V2RuntimesClient(this.http).get(this.id);
+    }
+    async connect(request) {
+        return this.connections.create(request);
+    }
+    async start() {
+        const response = await this.http.request(`/runtimes/${encodeURIComponent(this.id)}/start`, { method: 'POST' });
+        return {
+            runtime: new V2RuntimeResource(this.http, response.runtime),
+            run: new V2RunResource(this.http, response.run),
+        };
+    }
+    stop() {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.id)}/stop`, {
+            method: 'POST',
+        });
+    }
+    async run() {
+        const runtime = await this.refresh();
+        if (!runtime.activeRunId) {
+            throw new BctrlValidationError('Runtime does not have an active run yet', 'runtime.no_active_run', {
+                runtimeId: this.id,
+            });
+        }
+        const run = await this.http.request(`/runs/${encodeURIComponent(runtime.activeRunId)}`);
+        return new V2RunResource(this.http, run);
+    }
+}
+function validateRuntimeCreateRequest(request) {
+    const profileBacked = request.config?.browser?.profile === true;
+    if (!profileBacked)
+        return;
+    if (!request.name?.trim()) {
+        throw new BctrlValidationError('name is required when config.browser.profile is true', 'runtime.profile_name_required');
+    }
+    const unsupported = ['stealth', 'proxy', 'fingerprint', 'extensions'].filter((key) => request.config?.[key] !== undefined);
+    if (unsupported.length > 0) {
+        throw new BctrlValidationError('Only config.browser.profile and config.lifecycle are supported for profile-backed browser runtimes', 'runtime.profile_config_unsupported', { unsupported });
+    }
+}
+export class V2RuntimesClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}) {
+        return this.http.request('/runtimes', { query });
+    }
+    iter(query = {}) {
+        return iterateV2Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    async create(request) {
+        validateRuntimeCreateRequest(request);
+        const runtime = await this.http.request('/runtimes', {
+            method: 'POST',
+            body: request,
+        });
+        return new V2RuntimeResource(this.http, runtime);
+    }
+    async createInSpace(spaceId, request) {
+        validateRuntimeCreateRequest(request);
+        const runtime = await this.http.request('/runtimes', {
+            method: 'POST',
+            body: { ...request, spaceId },
+        });
+        return new V2RuntimeResource(this.http, runtime);
+    }
+    async get(id) {
+        const runtime = await this.http.request(`/runtimes/${encodeURIComponent(id)}`);
+        return new V2RuntimeResource(this.http, runtime);
+    }
+    stop(id) {
+        return this.http.request(`/runtimes/${encodeURIComponent(id)}/stop`, {
+            method: 'POST',
+        });
+    }
+    async start(id) {
+        const runtime = await this.get(id);
+        return runtime.start();
+    }
+}

package/dist/spaces.d.ts

@@ -0,0 +1,41 @@
+import { V2SpaceBrowsersClient } from './browsers.js';
+import type { V2HttpClient } from './http.js';
+import { V2RuntimeResource, V2RuntimesClient } from './runtimes.js';
+import type { V2ListEnvelope, V2RuntimeListQuery, V2Space, V2SpaceCreateRequest, V2SpaceEnvironment, V2SpaceEnvironmentUpdateRequest, V2SpaceRuntimeCreateRequest, V2SpaceUpdateRequest } from './types.js';
+export declare class V2SpaceEnvironmentClient {
+    private readonly http;
+    private readonly spaceId;
+    constructor(http: V2HttpClient, spaceId: string);
+    get(): Promise<V2SpaceEnvironment>;
+    update(request: V2SpaceEnvironmentUpdateRequest): Promise<V2SpaceEnvironment>;
+}
+export declare class V2SpaceRuntimesClient {
+    private readonly http;
+    private readonly spaceId;
+    constructor(http: V2HttpClient, spaceId: string);
+    list(query?: Omit<V2RuntimeListQuery, 'spaceId'>): ReturnType<V2RuntimesClient['list']>;
+    iter(query?: Omit<V2RuntimeListQuery, 'spaceId'>): ReturnType<V2RuntimesClient['iter']>;
+    create(request: V2SpaceRuntimeCreateRequest): Promise<V2RuntimeResource>;
+    get(runtimeId: string): Promise<V2RuntimeResource>;
+    stop(runtimeId: string): ReturnType<V2RuntimesClient['stop']>;
+}
+export declare class V2SpaceResource {
+    private readonly http;
+    readonly data: V2Space;
+    readonly environment: V2SpaceEnvironmentClient;
+    readonly runtimes: V2SpaceRuntimesClient;
+    readonly browsers: V2SpaceBrowsersClient;
+    constructor(http: V2HttpClient, data: V2Space);
+    get id(): string;
+    refresh(): Promise<V2SpaceResource>;
+    update(request: V2SpaceUpdateRequest): Promise<V2SpaceResource>;
+}
+export declare class V2SpacesClient {
+    private readonly http;
+    constructor(http: V2HttpClient);
+    list(): Promise<V2ListEnvelope<V2Space>>;
+    iter(): AsyncGenerator<V2Space, void, undefined>;
+    create(request: V2SpaceCreateRequest): Promise<V2SpaceResource>;
+    get(id: string): Promise<V2SpaceResource>;
+    update(id: string, request: V2SpaceUpdateRequest): Promise<V2SpaceResource>;
+}

package/dist/spaces.js

@@ -0,0 +1,96 @@
+import { V2SpaceBrowsersClient } from './browsers.js';
+import { iterateV2Pages } from './pagination.js';
+import { V2RuntimesClient } from './runtimes.js';
+export class V2SpaceEnvironmentClient {
+    http;
+    spaceId;
+    constructor(http, spaceId) {
+        this.http = http;
+        this.spaceId = spaceId;
+    }
+    get() {
+        return this.http.request(`/spaces/${encodeURIComponent(this.spaceId)}/environment`);
+    }
+    update(request) {
+        return this.http.request(`/spaces/${encodeURIComponent(this.spaceId)}/environment`, {
+            method: 'PATCH',
+            body: request,
+        });
+    }
+}
+export class V2SpaceRuntimesClient {
+    http;
+    spaceId;
+    constructor(http, spaceId) {
+        this.http = http;
+        this.spaceId = spaceId;
+    }
+    list(query = {}) {
+        return new V2RuntimesClient(this.http).list({ ...query, spaceId: this.spaceId });
+    }
+    iter(query = {}) {
+        return new V2RuntimesClient(this.http).iter({ ...query, spaceId: this.spaceId });
+    }
+    async create(request) {
+        return new V2RuntimesClient(this.http).createInSpace(this.spaceId, request);
+    }
+    async get(runtimeId) {
+        return new V2RuntimesClient(this.http).get(runtimeId);
+    }
+    stop(runtimeId) {
+        return new V2RuntimesClient(this.http).stop(runtimeId);
+    }
+}
+export class V2SpaceResource {
+    http;
+    data;
+    environment;
+    runtimes;
+    browsers;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+        this.environment = new V2SpaceEnvironmentClient(http, data.id);
+        this.runtimes = new V2SpaceRuntimesClient(http, data.id);
+        this.browsers = new V2SpaceBrowsersClient(http, data.id);
+    }
+    get id() {
+        return this.data.id;
+    }
+    refresh() {
+        return new V2SpacesClient(this.http).get(this.id);
+    }
+    async update(request) {
+        return new V2SpacesClient(this.http).update(this.id, request);
+    }
+}
+export class V2SpacesClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list() {
+        return this.http.request('/spaces');
+    }
+    iter() {
+        return iterateV2Pages({}, () => this.list());
+    }
+    async create(request) {
+        const space = await this.http.request('/spaces', {
+            method: 'POST',
+            body: request,
+        });
+        return new V2SpaceResource(this.http, space);
+    }
+    async get(id) {
+        const space = await this.http.request(`/spaces/${encodeURIComponent(id)}`);
+        return new V2SpaceResource(this.http, space);
+    }
+    async update(id, request) {
+        const space = await this.http.request(`/spaces/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: request,
+        });
+        return new V2SpaceResource(this.http, space);
+    }
+}