@bctrl/sdk 1.0.4 → 1.0.6

package/dist/proxyTypes.d.ts

@@ -0,0 +1,119 @@
+export type V1ProxyProtocol = 'http' | 'socks5';
+export type V1ProxyDnsResolution = 'local' | 'proxy';
+export type V1ProxyType = 'custom' | 'managed-rotating' | 'managed-static';
+export type V1ManagedRotatingPreference = 'balanced' | 'speed' | 'quality' | 'coverage';
+export type V1ManagedRotatingRotation = 'sticky' | 'rotating';
+export type V1ManagedRotatingDevice = 'windows' | 'macos' | 'linux' | 'android' | 'ios';
+export interface V1ProxyBase {
+    id: string;
+    name: string;
+    subaccountId?: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface V1ManagedRotatingProxyConfig {
+    protocol?: V1ProxyProtocol;
+    dnsResolution?: V1ProxyDnsResolution;
+    ipFamily?: 'dual-stack' | 'ipv4-only';
+    preference?: V1ManagedRotatingPreference;
+    rotation?: V1ManagedRotatingRotation;
+    stickyKey?: string;
+    country?: string;
+    region?: string;
+    state?: string;
+    city?: string;
+    isp?: string;
+    geoStrict?: boolean;
+    device?: V1ManagedRotatingDevice;
+    deviceStrict?: boolean;
+}
+export type V1Proxy = (V1ProxyBase & {
+    type: 'custom';
+    protocol: V1ProxyProtocol;
+    dnsResolution?: V1ProxyDnsResolution;
+    host: string;
+    port: number;
+    username?: string | null;
+    hasPassword: boolean;
+}) | (V1ProxyBase & V1ManagedRotatingProxyConfig & {
+    type: 'managed-rotating';
+}) | (V1ProxyBase & {
+    type: 'managed-static';
+    status: 'provisioning' | 'active' | 'expired' | 'renewal_failed';
+    poolId: string;
+    autoRenew: boolean;
+    assignedIp?: string;
+    location?: {
+        country: string;
+        city?: string;
+    };
+    expiresAt?: string;
+    renewsAt?: string | null;
+    pricing?: {
+        priceCredits: number;
+        termDays: number;
+    };
+});
+export type V1ProxyCreateRequest = {
+    type: 'custom';
+    name?: string;
+    url?: string;
+    protocol?: V1ProxyProtocol;
+    dnsResolution?: V1ProxyDnsResolution;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+} | ({
+    type: 'managed-rotating';
+    name?: string;
+} & V1ManagedRotatingProxyConfig) | {
+    type: 'managed-static';
+    name?: string;
+    poolId: string;
+    autoRenew?: boolean;
+};
+export interface V1ProxyUpdateRequest extends Partial<V1ManagedRotatingProxyConfig> {
+    name?: string;
+    url?: string;
+    protocol?: V1ProxyProtocol;
+    dnsResolution?: V1ProxyDnsResolution;
+    host?: string;
+    port?: number;
+    username?: string | null;
+    password?: string | null;
+    autoRenew?: boolean;
+}
+interface V1ProxyPageQuery {
+    cursor?: string;
+    limit?: number;
+}
+export interface V1ProxyListQuery extends V1ProxyPageQuery {
+}
+export interface V1ProxyDeleteResponse {
+    id: string;
+    deleted: true;
+}
+export interface V1ProxyTestResponse {
+    ok: boolean;
+    latencyMs?: number;
+    error?: string;
+    httpStatus?: number | null;
+    exitIp?: string | null;
+    country?: string | null;
+}
+export interface V1ProxyPool {
+    id: string;
+    label: string;
+    country: string;
+    category: 'tickets' | 'sneakers' | 'social' | 'retail';
+    termDays: number;
+    priceCredits: number;
+    availableCount: number;
+}
+export interface V1ProxyPoolListQuery extends V1ProxyPageQuery {
+    country?: string;
+    category?: V1ProxyPool['category'];
+    available?: boolean;
+}
+export {};

package/dist/proxyTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/runs.d.ts

@@ -1,40 +1,44 @@
-import type { V1HttpClient } from './http.js';
-import { V1RunFilesClient } from './files.js';
-import type { V1ListEnvelope, V1Run, V1RunCommand, V1RunCommandsListQuery, V1RunEvent, V1RunEventsListQuery, V1RunEventsWaitRequest, V1RunEventsWaitResponse, V1RunListQuery, V1RunLiveRequest, V1RunLiveResponse, V1RunRecordingRequest, V1RunRecordingResponse, V1RuntimeStartRun, V1RunUsage } from './types.js';
-export declare class V1RunEventsClient {
+import { type V1HttpClient, type V1IdempotencyOptions } from './http.js';
+import type { V1ListEnvelope, V1File, V1InvocationSummary, V1Run, V1RunEvent, V1RunEventsListQuery, V1RunListQuery, V1RunLiveRequest, V1RunLiveResponse, V1RunRecordingRequest, V1RunRecordingResponse, V1RunActivityItem, V1RunActivityListQuery, V1RunFilesExportRequest, V1RunFilesListQuery, V1RunInvocationsListQuery, V1RunUsage } from './types.js';
+export declare class V1RunsClient {
+    private readonly http;
+    readonly events: V1RunEventsNamespaceClient;
+    readonly activity: V1RunActivityNamespaceClient;
+    readonly files: V1RunFilesNamespaceClient;
+    readonly invocations: V1RunInvocationsNamespaceClient;
+    constructor(http: V1HttpClient);
+    list(query?: V1RunListQuery): Promise<V1ListEnvelope<V1Run>>;
+    iter(query?: V1RunListQuery): AsyncGenerator<V1Run, void, undefined>;
+    get(id: string): Promise<V1Run>;
+    usage(id: string): Promise<V1RunUsage>;
+    live(id: string, request?: V1RunLiveRequest): Promise<V1RunLiveResponse>;
+    recording(id: string, request?: V1RunRecordingRequest): Promise<V1RunRecordingResponse>;
+}
+export declare class V1RunEventsNamespaceClient {
     private readonly http;
-    private readonly runId;
-    constructor(http: V1HttpClient, runId: string);
-    list(query?: V1RunEventsListQuery): Promise<V1ListEnvelope<V1RunEvent>>;
-    iter(query?: V1RunEventsListQuery): AsyncGenerator<V1RunEvent, void, undefined>;
-    wait(request?: V1RunEventsWaitRequest): Promise<V1RunEventsWaitResponse>;
-    streamUrl(query?: Pick<V1RunEventsListQuery, 'type' | 'category' | 'connectionId'>): string;
+    constructor(http: V1HttpClient);
+    list(runId: string, query?: V1RunEventsListQuery): Promise<V1ListEnvelope<V1RunEvent>>;
+    iter(runId: string, query?: V1RunEventsListQuery): AsyncGenerator<V1RunEvent, void, undefined>;
+    streamUrl(runId: string, query?: Pick<V1RunEventsListQuery, 'type' | 'status' | 'pageId' | 'contextId'>): string;
 }
-export declare class V1RunCommandsClient {
+export declare class V1RunActivityNamespaceClient {
     private readonly http;
-    private readonly runId;
-    constructor(http: V1HttpClient, runId: string);
-    list(query?: V1RunCommandsListQuery): Promise<V1ListEnvelope<V1RunCommand>>;
-    iter(query?: V1RunCommandsListQuery): AsyncGenerator<V1RunCommand, void, undefined>;
+    constructor(http: V1HttpClient);
+    list(runId: string, query?: V1RunActivityListQuery): Promise<V1ListEnvelope<V1RunActivityItem>>;
+    iter(runId: string, query?: V1RunActivityListQuery): AsyncGenerator<V1RunActivityItem, void, undefined>;
+    streamUrl(runId: string, query?: V1RunActivityListQuery): string;
 }
-export declare class V1RunResource {
+export declare class V1RunFilesNamespaceClient {
     private readonly http;
-    readonly data: V1Run | V1RuntimeStartRun;
-    readonly events: V1RunEventsClient;
-    readonly commands: V1RunCommandsClient;
-    readonly files: V1RunFilesClient;
-    constructor(http: V1HttpClient, data: V1Run | V1RuntimeStartRun);
-    get id(): string;
-    refresh(): Promise<V1RunResource>;
-    live(request?: V1RunLiveRequest): Promise<V1RunLiveResponse>;
-    recording(request?: V1RunRecordingRequest): Promise<V1RunRecordingResponse>;
-    usage(): Promise<V1RunUsage>;
+    constructor(http: V1HttpClient);
+    list(runId: string, query?: V1RunFilesListQuery): Promise<V1ListEnvelope<V1File>>;
+    iter(runId: string, query?: V1RunFilesListQuery): AsyncGenerator<V1File, void, undefined>;
+    export(runId: string, request?: V1RunFilesExportRequest, options?: V1IdempotencyOptions): Promise<V1File>;
 }
-export declare class V1RunsClient {
+export declare class V1RunInvocationsNamespaceClient {
     private readonly http;
     constructor(http: V1HttpClient);
-    list(query?: V1RunListQuery): Promise<V1ListEnvelope<V1Run>>;
-    iter(query?: V1RunListQuery): AsyncGenerator<V1Run, void, undefined>;
-    get(id: string): Promise<V1RunResource>;
-    usage(id: string): Promise<V1RunUsage>;
+    list(runId: string, query?: V1RunInvocationsListQuery): Promise<V1ListEnvelope<V1InvocationSummary>>;
+    iter(runId: string, query?: V1RunInvocationsListQuery): AsyncGenerator<V1InvocationSummary, void, undefined>;
+    get(runId: string, invocationId: string): Promise<import("./types.js").V1Invocation>;
 }

package/dist/runs.js

@@ -1,6 +1,6 @@
+import { v1IdempotencyHeaders } from './http.js';
 import { iterateV1Pages } from './pagination.js';
-import { V1RunFilesClient } from './files.js';
-export class V1RunEventsClient {
+class V1RunEventsClient {
     http;
     runId;
     constructor(http, runId) {
@@ -13,12 +13,6 @@ export class V1RunEventsClient {
     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)) {
@@ -35,7 +29,7 @@ export class V1RunEventsClient {
         return url.toString();
     }
 }
-export class V1RunCommandsClient {
+class V1RunActivityClient {
     http;
     runId;
     constructor(http, runId) {
@@ -43,63 +37,126 @@ export class V1RunCommandsClient {
         this.runId = runId;
     }
     list(query = {}) {
-        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/commands`, { query });
+        return this.http.request(`/runs/${encodeURIComponent(this.runId)}/activity`, { query });
     }
     iter(query = {}) {
         return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
+    streamUrl(query = {}) {
+        const url = new URL(`${this.http.baseUrl}/runs/${encodeURIComponent(this.runId)}/activity/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, String(item));
+            }
+            else {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        return url.toString();
+    }
 }
-export class V1RunResource {
+export class V1RunsClient {
     http;
-    data;
     events;
-    commands;
+    activity;
     files;
-    constructor(http, data) {
+    invocations;
+    constructor(http) {
         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);
+        this.events = new V1RunEventsNamespaceClient(http);
+        this.activity = new V1RunActivityNamespaceClient(http);
+        this.files = new V1RunFilesNamespaceClient(http);
+        this.invocations = new V1RunInvocationsNamespaceClient(http);
+    }
+    list(query = {}) {
+        return this.http.request('/runs', { query });
+    }
+    iter(query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
     }
-    get id() {
-        return this.data.id;
+    get(id) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}`);
     }
-    refresh() {
-        return new V1RunsClient(this.http).get(this.id);
+    usage(id) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
     }
-    live(request) {
-        return this.http.request(`/runs/${encodeURIComponent(this.id)}/live`, {
+    live(id, request) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/live`, {
             method: 'POST',
             body: request ?? {},
         });
     }
-    recording(request) {
-        return this.http.request(`/runs/${encodeURIComponent(this.id)}/recording`, {
+    recording(id, request) {
+        return this.http.request(`/runs/${encodeURIComponent(id)}/recording`, {
             method: 'POST',
             body: request ?? {},
         });
     }
-    usage() {
-        return this.http.request(`/runs/${encodeURIComponent(this.id)}/usage`);
+}
+export class V1RunEventsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runId, query = {}) {
+        return new V1RunEventsClient(this.http, runId).list(query);
+    }
+    iter(runId, query = {}) {
+        return new V1RunEventsClient(this.http, runId).iter(query);
+    }
+    streamUrl(runId, query = {}) {
+        return new V1RunEventsClient(this.http, runId).streamUrl(query);
     }
 }
-export class V1RunsClient {
+export class V1RunActivityNamespaceClient {
     http;
     constructor(http) {
         this.http = http;
     }
-    list(query = {}) {
-        return this.http.request('/runs', { query });
+    list(runId, query = {}) {
+        return new V1RunActivityClient(this.http, runId).list(query);
     }
-    iter(query = {}) {
-        return iterateV1Pages(query, (pageQuery) => this.list(pageQuery));
+    iter(runId, query = {}) {
+        return new V1RunActivityClient(this.http, runId).iter(query);
     }
-    async get(id) {
-        const run = await this.http.request(`/runs/${encodeURIComponent(id)}`);
-        return new V1RunResource(this.http, run);
+    streamUrl(runId, query = {}) {
+        return new V1RunActivityClient(this.http, runId).streamUrl(query);
     }
-    usage(id) {
-        return this.http.request(`/runs/${encodeURIComponent(id)}/usage`);
+}
+export class V1RunFilesNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runId, query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/files`, { query });
+    }
+    iter(runId, query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
+    }
+    export(runId, request = {}, options) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/files/export`, {
+            method: 'POST',
+            body: request,
+            headers: v1IdempotencyHeaders(options),
+        });
+    }
+}
+export class V1RunInvocationsNamespaceClient {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(runId, query = {}) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/invocations`, { query });
+    }
+    iter(runId, query = {}) {
+        return iterateV1Pages(query, (pageQuery) => this.list(runId, pageQuery));
+    }
+    get(runId, invocationId) {
+        return this.http.request(`/runs/${encodeURIComponent(runId)}/invocations/${encodeURIComponent(invocationId)}`);
     }
 }

package/dist/runtimes.d.ts

@@ -1,49 +1,50 @@
-import type { V1HttpClient } from './http.js';
-import { V1RuntimeInvocationsClient } from './invocations.js';
-import { V1RunResource } from './runs.js';
-import type { V1ListEnvelope, V1File, V1Runtime, V1RuntimeCreateRequest, V1RuntimeFileCollectRequest, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeFileUploadResponse, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RuntimeStartBrowser, V1RuntimeStartRuntime, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
-export type V1RuntimeStartResult = {
-    runtime: V1RuntimeResource;
-    run: V1RunResource;
-    browser: V1RuntimeStartBrowser;
-};
-export declare class V1RuntimeRunsClient {
+import { type V1HttpClient, type V1IdempotencyOptions } from './http.js';
+import { V1RuntimeInvocationsNamespaceClient } from './invocations.js';
+import type { V1ListEnvelope, V1File, V1Runtime, V1RuntimeCreateRequest, V1RuntimeDeleteResponse, V1RuntimeFileCollectRequest, V1RuntimeFilesListQuery, V1RuntimeFileStageRequest, V1RuntimeFileUploadRequest, V1RuntimeStagedFile, V1RuntimeListQuery, V1RuntimeRunListQuery, V1RuntimeStartResponse, V1RuntimeStopResponse, V1RuntimeTarget, V1RuntimeTargetCreateRequest, V1RuntimeUpdateRequest, V1RunSummary, V1SpaceRuntimeCreateRequest } from './types.js';
+export type V1RuntimeStartResult = V1RuntimeStartResponse;
+export declare class V1RuntimesClient {
     private readonly http;
-    private readonly runtimeId;
-    constructor(http: V1HttpClient, runtimeId: string);
-    list(query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
-    iter(query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
+    readonly files: V1RuntimeFilesNamespaceClient;
+    readonly runs: V1RuntimeRunsNamespaceClient;
+    readonly invocations: V1RuntimeInvocationsNamespaceClient;
+    readonly targets: V1RuntimeTargetsNamespaceClient;
+    constructor(http: V1HttpClient);
+    list(query?: V1RuntimeListQuery): Promise<V1ListEnvelope<V1Runtime>>;
+    iter(query?: V1RuntimeListQuery): AsyncGenerator<V1Runtime, void, undefined>;
+    create(request: V1RuntimeCreateRequest): Promise<V1Runtime>;
+    createInSpace(spaceId: string, request: V1SpaceRuntimeCreateRequest): Promise<V1Runtime>;
+    update(id: string, request: V1RuntimeUpdateRequest): Promise<V1Runtime>;
+    delete(id: string, options?: {
+        force?: boolean;
+    }): Promise<V1RuntimeDeleteResponse>;
+    get(id: string): Promise<V1Runtime>;
+    stop(id: string): Promise<V1RuntimeStopResponse>;
+    start(id: string, options?: V1IdempotencyOptions): Promise<V1RuntimeStartResult>;
 }
-export declare class V1RuntimeFilesClient {
+export declare class V1RuntimeRunsNamespaceClient {
     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>;
+    constructor(http: V1HttpClient);
+    list(runtimeId: string, query?: V1RuntimeRunListQuery): Promise<V1ListEnvelope<V1RunSummary>>;
+    iter(runtimeId: string, query?: V1RuntimeRunListQuery): AsyncGenerator<V1RunSummary, void, undefined>;
 }
-export declare class V1RuntimeResource {
+export declare class V1RuntimeFilesNamespaceClient {
     private readonly http;
-    readonly data: V1Runtime | V1RuntimeStartRuntime;
-    readonly files: V1RuntimeFilesClient;
-    readonly runs: V1RuntimeRunsClient;
-    readonly invocations: V1RuntimeInvocationsClient;
-    constructor(http: V1HttpClient, data: V1Runtime | V1RuntimeStartRuntime);
-    get id(): string;
-    get activeRunId(): string | null;
-    refresh(): Promise<V1RuntimeResource>;
-    start(): Promise<V1RuntimeStartResult>;
-    stop(): Promise<V1Runtime>;
-    run(): Promise<V1RunResource>;
+    constructor(http: V1HttpClient);
+    list(runtimeId: string, query?: V1RuntimeFilesListQuery): Promise<V1ListEnvelope<V1File>>;
+    iter(runtimeId: string, query?: V1RuntimeFilesListQuery): AsyncGenerator<V1File, void, undefined>;
+    upload(runtimeId: string, request: V1RuntimeFileUploadRequest): Promise<V1RuntimeStagedFile>;
+    stage(runtimeId: string, request: V1RuntimeFileStageRequest): Promise<V1RuntimeStagedFile>;
+    collect(runtimeId: string, request: V1RuntimeFileCollectRequest): Promise<V1File>;
 }
-export declare class V1RuntimesClient {
+export declare class V1RuntimeTargetsNamespaceClient {
     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<V1RuntimeStartResult>;
+    list(runtimeId: string): Promise<V1ListEnvelope<V1RuntimeTarget>>;
+    create(runtimeId: string, request?: V1RuntimeTargetCreateRequest): Promise<V1RuntimeTarget>;
+    get(runtimeId: string, targetId: string): Promise<V1RuntimeTarget>;
+    activate(runtimeId: string, targetId: string): Promise<V1RuntimeTarget>;
+    delete(runtimeId: string, targetId: string): Promise<{
+        id: string;
+        deleted: boolean;
+    }>;
 }