@bctrl/sdk 1.0.1 → 1.0.3

package/dist/runs.js

@@ -0,0 +1,105 @@
+import { iterateV1Pages } from './pagination.js';
+import { V1RunFilesClient } from './files.js';
+export class V1RunEventsClient {
+    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 iterateV1Pages(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 V1RunCommandsClient {
+    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 iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+}
+export class V1RunResource {
+    http;
+    data;
+    events;
+    commands;
+    files;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+        this.events = new V1RunEventsClient(http, data.id);
+        this.commands = new V1RunCommandsClient(http, data.id);
+        this.files = new V1RunFilesClient(http, data.id);
+    }
+    get id() {
+        return this.data.id;
+    }
+    refresh() {
+        return new V1RunsClient(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 ?? {},
+        });
+    }
+    usage() {
+        return this.http.request(`/runs/${encodeURIComponent(this.id)}/usage`);
+    }
+}
+export class V1RunsClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}) {
+        return this.http.request('/runs', { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    async get(id) {
+        const run = await this.http.request(`/runs/${encodeURIComponent(id)}`);
+        return new V1RunResource(this.http, run);
+    }
+    usage(id) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
+    }
+}

package/dist/runtimes.d.ts

@@ -0,0 +1,69 @@
+import type { V1HttpClient } from './http.js';
+import { V1RuntimeInvocationsClient } from './invocations.js';
+import { V1RunResource } from './runs.js';
+import type { V1ListEnvelope, V1File, V1Runtime, V1RuntimeConnection, V1RuntimeConnectionCreateOptions, V1RuntimeConnectionCreateResponse, V1RuntimeCreateRequest, V1RuntimeFileCollectRequest, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeFileUploadResponse, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
+export declare class V1RuntimeConnectionResource {
+    private readonly http;
+    private readonly runtimeId;
+    readonly data: V1RuntimeConnectionCreateResponse;
+    constructor(http: V1HttpClient, runtimeId: string, data: V1RuntimeConnectionCreateResponse);
+    get id(): string;
+    get endpoint(): V1RuntimeConnectionCreateResponse['endpoint'];
+    get wsUrl(): string | undefined;
+    close(): Promise<V1RuntimeConnection>;
+}
+export declare class V1RuntimeConnectionsClient {
+    private readonly http;
+    private readonly runtimeId;
+    constructor(http: V1HttpClient, runtimeId: string);
+    create(request?: V1RuntimeConnectionCreateOptions): Promise<V1RuntimeConnectionResource>;
+    delete(connectionId: string): Promise<V1RuntimeConnection>;
+}
+export declare class V1RuntimeRunsClient {
+    private readonly http;
+    private readonly runtimeId;
+    constructor(http: V1HttpClient, runtimeId: string);
+    list(query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
+    iter(query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
+}
+export declare class V1RuntimeFilesClient {
+    private readonly http;
+    private readonly runtimeId;
+    constructor(http: V1HttpClient, runtimeId: string);
+    upload(request: V1RuntimeFileUploadRequest): Promise<V1RuntimeFileUploadResponse>;
+    stage(request: V1RuntimeFileStageRequest): Promise<V1RuntimeStagedFile>;
+    collect(request: V1RuntimeFileCollectRequest): Promise<V1File>;
+}
+export declare class V1RuntimeResource {
+    private readonly http;
+    readonly data: V1Runtime;
+    readonly connections: V1RuntimeConnectionsClient;
+    readonly files: V1RuntimeFilesClient;
+    readonly runs: V1RuntimeRunsClient;
+    readonly invocations: V1RuntimeInvocationsClient;
+    constructor(http: V1HttpClient, data: V1Runtime);
+    get id(): string;
+    get activeRunId(): string | null;
+    refresh(): Promise<V1RuntimeResource>;
+    connect(request?: V1RuntimeConnectionCreateOptions): Promise<V1RuntimeConnectionResource>;
+    start(): Promise<{
+        runtime: V1RuntimeResource;
+        run: V1RunResource;
+    }>;
+    stop(): Promise<V1Runtime>;
+    run(): Promise<V1RunResource>;
+}
+export declare class V1RuntimesClient {
+    private readonly http;
+    constructor(http: V1HttpClient);
+    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1Runtime>>;
+    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1Runtime, void, undefined>;
+    create(request: V1RuntimeCreateRequest): Promise<V1RuntimeResource>;
+    createInSpace(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1RuntimeResource>;
+    get(id: string): Promise<V1RuntimeResource>;
+    stop(id: string): Promise<V1Runtime>;
+    start(id: string): Promise<{
+        runtime: V1RuntimeResource;
+        run: V1RunResource;
+    }>;
+}

package/dist/runtimes.js

@@ -0,0 +1,202 @@
+import { BctrlValidationError } from './errors.js';
+import { V1RuntimeInvocationsClient } from './invocations.js';
+import { iterateV1Pages } from './pagination.js';
+import { V1RunResource } from './runs.js';
+export class V1RuntimeConnectionResource {
+    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 V1RuntimeConnectionsClient {
+    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 V1RuntimeConnectionResource(this.http, this.runtimeId, response);
+    }
+    delete(connectionId) {
+        return this.http.request(`/runtimes/${encodeURIComponent(this.runtimeId)}/connections/${encodeURIComponent(connectionId)}`, { method: 'DELETE' });
+    }
+}
+export class V1RuntimeRunsClient {
+    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 iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+}
+export class V1RuntimeFilesClient {
+    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 V1RuntimeResource {
+    http;
+    data;
+    connections;
+    files;
+    runs;
+    invocations;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+        this.connections = new V1RuntimeConnectionsClient(http, data.id);
+        this.files = new V1RuntimeFilesClient(http, data.id);
+        this.runs = new V1RuntimeRunsClient(http, data.id);
+        this.invocations = new V1RuntimeInvocationsClient(http, data.id);
+    }
+    get id() {
+        return this.data.id;
+    }
+    get activeRunId() {
+        return this.data.activeRunId;
+    }
+    refresh() {
+        return new V1RuntimesClient(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 V1RuntimeResource(this.http, response.runtime),
+            run: new V1RunResource(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 V1RunResource(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 V1RuntimesClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(query = {}) {
+        return this.http.request('/runtimes', { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    }
+    async create(request) {
+        validateRuntimeCreateRequest(request);
+        const runtime = await this.http.request('/runtimes', {
+            method: 'POST',
+            body: request,
+        });
+        return new V1RuntimeResource(this.http, runtime);
+    }
+    async createInSpace(spaceId, request) {
+        validateRuntimeCreateRequest(request);
+        const runtime = await this.http.request('/runtimes', {
+            method: 'POST',
+            body: { ...request, spaceId },
+        });
+        return new V1RuntimeResource(this.http, runtime);
+    }
+    async get(id) {
+        const runtime = await this.http.request(`/runtimes/${encodeURIComponent(id)}`);
+        return new V1RuntimeResource(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,40 @@
+import type { V1HttpClient } from './http.js';
+import { V1RuntimeResource, V1RuntimesClient } from './runtimes.js';
+import type { V1ListEnvelope, V1RuntimeListQuery, V1Space, V1SpaceCreateRequest, V1SpaceEnvironment, V1SpaceEnvironmentUpdateRequest, V1SpaceRuntimeCreateRequest, V1SpaceUpdateRequest } from './types.js';
+export declare class V1SpaceEnvironmentClient {
+    private readonly http;
+    private readonly spaceId;
+    constructor(http: V1HttpClient, spaceId: string);
+    get(): Promise<V1SpaceEnvironment>;
+    update(request: V1SpaceEnvironmentUpdateRequest): Promise<V1SpaceEnvironment>;
+}
+export declare class V1SpaceRuntimesClient {
+    private readonly http;
+    private readonly spaceId;
+    constructor(http: V1HttpClient, spaceId: string);
+    list(query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['list']>;
+    iter(query?: Omit<V1RuntimeListQuery, 'spaceId'>): ReturnType<V1RuntimesClient['iter']>;
+    create(request: V1SpaceRuntimeCreateRequest): Promise<V1RuntimeResource>;
+    get(runtimeId: string): Promise<V1RuntimeResource>;
+    stop(runtimeId: string): ReturnType<V1RuntimesClient['stop']>;
+    start(runtimeId: string): ReturnType<V1RuntimesClient['start']>;
+}
+export declare class V1SpaceResource {
+    private readonly http;
+    readonly data: V1Space;
+    readonly environment: V1SpaceEnvironmentClient;
+    readonly runtimes: V1SpaceRuntimesClient;
+    constructor(http: V1HttpClient, data: V1Space);
+    get id(): string;
+    refresh(): Promise<V1SpaceResource>;
+    update(request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
+}
+export declare class V1SpacesClient {
+    private readonly http;
+    constructor(http: V1HttpClient);
+    list(): Promise<V1ListEnvelope<V1Space>>;
+    iter(): AsyncGenerator<V1Space, void, undefined>;
+    create(request: V1SpaceCreateRequest): Promise<V1SpaceResource>;
+    get(id: string): Promise<V1SpaceResource>;
+    update(id: string, request: V1SpaceUpdateRequest): Promise<V1SpaceResource>;
+}

package/dist/spaces.js

@@ -0,0 +1,96 @@
+import { iterateV1Pages } from './pagination.js';
+import { V1RuntimesClient } from './runtimes.js';
+export class V1SpaceEnvironmentClient {
+    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 V1SpaceRuntimesClient {
+    http;
+    spaceId;
+    constructor(http, spaceId) {
+        this.http = http;
+        this.spaceId = spaceId;
+    }
+    list(query = {}) {
+        return new V1RuntimesClient(this.http).list({ ...query, spaceId: this.spaceId });
+    }
+    iter(query = {}) {
+        return new V1RuntimesClient(this.http).iter({ ...query, spaceId: this.spaceId });
+    }
+    async create(request) {
+        return new V1RuntimesClient(this.http).createInSpace(this.spaceId, request);
+    }
+    async get(runtimeId) {
+        return new V1RuntimesClient(this.http).get(runtimeId);
+    }
+    stop(runtimeId) {
+        return new V1RuntimesClient(this.http).stop(runtimeId);
+    }
+    start(runtimeId) {
+        return new V1RuntimesClient(this.http).start(runtimeId);
+    }
+}
+export class V1SpaceResource {
+    http;
+    data;
+    environment;
+    runtimes;
+    constructor(http, data) {
+        this.http = http;
+        this.data = data;
+        this.environment = new V1SpaceEnvironmentClient(http, data.id);
+        this.runtimes = new V1SpaceRuntimesClient(http, data.id);
+    }
+    get id() {
+        return this.data.id;
+    }
+    refresh() {
+        return new V1SpacesClient(this.http).get(this.id);
+    }
+    async update(request) {
+        return new V1SpacesClient(this.http).update(this.id, request);
+    }
+}
+export class V1SpacesClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list() {
+        return this.http.request('/spaces');
+    }
+    iter() {
+        return iterateV1Pages({}, () => this.list());
+    }
+    async create(request) {
+        const space = await this.http.request('/spaces', {
+            method: 'POST',
+            body: request,
+        });
+        return new V1SpaceResource(this.http, space);
+    }
+    async get(id) {
+        const space = await this.http.request(`/spaces/${encodeURIComponent(id)}`);
+        return new V1SpaceResource(this.http, space);
+    }
+    async update(id, request) {
+        const space = await this.http.request(`/spaces/${encodeURIComponent(id)}`, {
+            method: 'PATCH',
+            body: request,
+        });
+        return new V1SpaceResource(this.http, space);
+    }
+}