@tapi-dev/sdk 0.1.5 → 0.1.7

package/dist/cloud-runs.d.ts

@@ -0,0 +1,22 @@
+import type { HttpClient } from "./client.js";
+import type { CloudBatchRun, CloudBalance, CloudCreditCheckout, CloudCreditCheckoutRequest, CloudRunEvent, CloudRunResults, CloudRunUser } from "./types.js";
+export declare class CloudRunsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    get(runId: string): Promise<CloudBatchRun>;
+    events(runId: string): Promise<{
+        events: CloudRunEvent[];
+    }>;
+    results(runId: string): Promise<CloudRunResults>;
+    cancel(runId: string): Promise<CloudBatchRun>;
+    balance(user?: CloudRunUser): Promise<CloudBalance>;
+    checkout(request: CloudCreditCheckoutRequest): Promise<CloudCreditCheckout>;
+    wait(runId: string, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<CloudBatchRun>;
+    stream(runId: string, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): AsyncGenerator<CloudRunEvent, void, unknown>;
+}

package/dist/cloud-runs.js

@@ -0,0 +1,71 @@
+export class CloudRunsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    get(runId) {
+        return this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}`);
+    }
+    events(runId) {
+        return this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/events`);
+    }
+    results(runId) {
+        return this.http.get(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/results`);
+    }
+    cancel(runId) {
+        return this.http.post(`/api/sdk/v1/cloud-runs/${encodeURIComponent(runId)}/cancel`);
+    }
+    balance(user) {
+        return this.http.get(`/api/sdk/v1/billing/cloud/balance${cloudUserQuery(user)}`);
+    }
+    checkout(request) {
+        return this.http.post("/api/sdk/v1/billing/cloud/checkout", request);
+    }
+    async wait(runId, options = {}) {
+        const intervalMs = options.intervalMs ?? 1000;
+        const deadline = Date.now() + (options.timeoutMs ?? 300000);
+        while (Date.now() <= deadline) {
+            const run = await this.get(runId);
+            if (["completed", "failed", "cancelled", "payment_required"].includes(run.status)) {
+                return run;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error(`timed out waiting for cloud run ${runId}`);
+    }
+    async *stream(runId, options = {}) {
+        const intervalMs = options.intervalMs ?? 1000;
+        const deadline = Date.now() + (options.timeoutMs ?? 300000);
+        const seen = new Set();
+        while (Date.now() <= deadline) {
+            const response = await this.events(runId);
+            for (const event of response.events) {
+                const key = `${event.type}:${event.itemIndex ?? ""}:${event.status ?? ""}:${event.updatedAt ?? ""}`;
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    yield event;
+                }
+            }
+            const run = await this.get(runId);
+            if (["completed", "failed", "cancelled", "payment_required"].includes(run.status)) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error(`timed out streaming cloud run ${runId}`);
+    }
+}
+function cloudUserQuery(user) {
+    if (!user) {
+        return "";
+    }
+    const params = new URLSearchParams();
+    if (user.externalUserId) {
+        params.set("externalUserId", user.externalUserId);
+    }
+    if (user.email) {
+        params.set("email", user.email);
+    }
+    const text = params.toString();
+    return text ? `?${text}` : "";
+}

package/dist/index.d.ts

@@ -1,16 +1,18 @@
-import { CatalogResource } from "./catalog";
-import { RunnersResource } from "./runners";
-import { RunsResource } from "./runs";
-import { RuntimeResource } from "./runtime";
-import type { TapiClientOptions } from "./types";
-import { WebsiteApisResource } from "./website-apis";
+import { CloudRunsResource } from "./cloud-runs.js";
+import { CatalogResource } from "./catalog.js";
+import { RunnersResource } from "./runners.js";
+import { RunsResource } from "./runs.js";
+import { RuntimeResource } from "./runtime.js";
+import type { TapiClientOptions } from "./types.js";
+import { WebsiteApisResource } from "./website-apis.js";
 export declare class TapiClient {
     readonly catalog: CatalogResource;
+    readonly cloudRuns: CloudRunsResource;
     readonly runners: RunnersResource;
     readonly runs: RunsResource;
     readonly runtime: RuntimeResource;
     readonly websiteApis: WebsiteApisResource;
     constructor(options: TapiClientOptions);
 }
-export * from "./errors";
-export * from "./types";
+export * from "./errors.js";
+export * from "./types.js";

package/dist/index.js

@@ -1,11 +1,13 @@
-import { HttpClient } from "./client";
-import { CatalogResource } from "./catalog";
-import { RunnersResource } from "./runners";
-import { RunsResource } from "./runs";
-import { RuntimeResource } from "./runtime";
-import { WebsiteApisResource } from "./website-apis";
+import { HttpClient } from "./client.js";
+import { CloudRunsResource } from "./cloud-runs.js";
+import { CatalogResource } from "./catalog.js";
+import { RunnersResource } from "./runners.js";
+import { RunsResource } from "./runs.js";
+import { RuntimeResource } from "./runtime.js";
+import { WebsiteApisResource } from "./website-apis.js";
 export class TapiClient {
     catalog;
+    cloudRuns;
     runners;
     runs;
     runtime;
@@ -13,11 +15,12 @@ export class TapiClient {
     constructor(options) {
         const http = new HttpClient(options);
         this.catalog = new CatalogResource(http);
+        this.cloudRuns = new CloudRunsResource(http);
         this.runners = new RunnersResource(http);
         this.runs = new RunsResource(http);
-        this.runtime = new RuntimeResource(http);
+        this.runtime = new RuntimeResource(http, options);
         this.websiteApis = new WebsiteApisResource(http);
     }
 }
-export * from "./errors";
-export * from "./types";
+export * from "./errors.js";
+export * from "./types.js";

package/dist/runners.d.ts

@@ -1,5 +1,5 @@
-import type { HttpClient } from "./client";
-import type { TapiRunner } from "./types";
+import type { HttpClient } from "./client.js";
+import type { TapiRunner } from "./types.js";
 export declare class RunnersResource {
     private readonly http;
     constructor(http: HttpClient);

package/dist/runs.d.ts

@@ -1,5 +1,5 @@
-import type { HttpClient } from "./client";
-import type { TapiRun } from "./types";
+import type { HttpClient } from "./client.js";
+import type { TapiRun } from "./types.js";
 export declare class RunsResource {
     private readonly http;
     constructor(http: HttpClient);

package/dist/runtime.d.ts

@@ -1,7 +1,41 @@
-import type { HttpClient } from "./client";
-import type { RuntimeRequirements } from "./types";
+import type { HttpClient } from "./client.js";
+import type { CreatePermProfileRequest, CreateRuntimeCloneRequest, LaunchPermProfileSetupRequest, LocalWebSocketConstructor, ProvisionTempProfilesRequest, PromoteTempProfileRequest, RuntimeProfileListResponse, RuntimeProfileResponse, RuntimeProfilesDestroyedResponse, RuntimeRequirements, TapiClientOptions } from "./types.js";
 export declare class RuntimeResource {
     private readonly http;
-    constructor(http: HttpClient);
+    readonly profiles: RuntimeProfilesResource;
+    readonly permProfiles: PermProfilesResource;
+    readonly tempProfiles: TempProfilesResource;
+    private readonly rpc;
+    constructor(http: HttpClient, options: TapiClientOptions);
     requirements(): Promise<RuntimeRequirements>;
 }
+export declare class RuntimeProfilesResource {
+    private readonly rpc;
+    constructor(rpc: LocalRuntimeRpc);
+    list(options?: {
+        includeClones?: boolean;
+    }): Promise<RuntimeProfileListResponse>;
+    destroy(profileRef: string): Promise<RuntimeProfilesDestroyedResponse>;
+    clone(request: string | CreateRuntimeCloneRequest): Promise<RuntimeProfileResponse>;
+}
+export declare class PermProfilesResource {
+    private readonly rpc;
+    constructor(rpc: LocalRuntimeRpc);
+    create(request: CreatePermProfileRequest): Promise<RuntimeProfileResponse>;
+    launchSetup(request: string | LaunchPermProfileSetupRequest): Promise<Record<string, unknown>>;
+}
+export declare class TempProfilesResource {
+    private readonly rpc;
+    constructor(rpc: LocalRuntimeRpc);
+    provisionMany(request?: ProvisionTempProfilesRequest): Promise<RuntimeProfileListResponse>;
+    promote(request: string | PromoteTempProfileRequest): Promise<RuntimeProfileResponse>;
+}
+declare class LocalRuntimeRpc {
+    private readonly url;
+    private readonly webSocketCtor?;
+    private nextId;
+    constructor(url: string, webSocketCtor?: LocalWebSocketConstructor | undefined);
+    request<T>(method: string, params?: object): Promise<T>;
+    private resolveWebSocket;
+}
+export {};

package/dist/runtime.js

@@ -1,9 +1,140 @@
 export class RuntimeResource {
     http;
-    constructor(http) {
+    profiles;
+    permProfiles;
+    tempProfiles;
+    rpc;
+    constructor(http, options) {
         this.http = http;
+        this.rpc = new LocalRuntimeRpc(options.localControlUrl ?? "ws://127.0.0.1:8765", options.webSocket);
+        this.profiles = new RuntimeProfilesResource(this.rpc);
+        this.permProfiles = new PermProfilesResource(this.rpc);
+        this.tempProfiles = new TempProfilesResource(this.rpc);
     }
     requirements() {
         return this.http.get("/api/sdk/v1/runtime/requirements");
     }
 }
+export class RuntimeProfilesResource {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    list(options = {}) {
+        return this.rpc.request("runtime.profiles.list", {
+            includeClones: options.includeClones === true,
+        });
+    }
+    destroy(profileRef) {
+        return this.rpc.request("runtime.profiles.destroy", { profileRef });
+    }
+    clone(request) {
+        const payload = typeof request === "string" ? { profileRef: request } : request;
+        return this.rpc.request("runtime.profiles.clone", payload);
+    }
+}
+export class PermProfilesResource {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    create(request) {
+        return this.rpc.request("runtime.perm_profiles.create", request);
+    }
+    launchSetup(request) {
+        const payload = typeof request === "string" ? { profileRef: request } : request;
+        return this.rpc.request("runtime.perm_profiles.launch_setup", payload);
+    }
+}
+export class TempProfilesResource {
+    rpc;
+    constructor(rpc) {
+        this.rpc = rpc;
+    }
+    provisionMany(request = {}) {
+        return this.rpc.request("runtime.temp_profiles.provision_many", request);
+    }
+    promote(request) {
+        const payload = typeof request === "string" ? { profileRef: request } : request;
+        return this.rpc.request("runtime.temp_profiles.promote", payload);
+    }
+}
+class LocalRuntimeRpc {
+    url;
+    webSocketCtor;
+    nextId = 1;
+    constructor(url, webSocketCtor) {
+        this.url = url;
+        this.webSocketCtor = webSocketCtor;
+    }
+    request(method, params = {}) {
+        const WebSocketCtor = this.resolveWebSocket();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const socket = new WebSocketCtor(this.url);
+            const finish = (fn) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                try {
+                    socket.close();
+                }
+                catch {
+                    // Ignore close failures; the RPC already has its outcome.
+                }
+                fn();
+            };
+            socket.onopen = () => {
+                socket.send(JSON.stringify({ id, method, params }));
+            };
+            socket.onmessage = (event) => {
+                let payload;
+                try {
+                    payload = JSON.parse(String(event.data));
+                }
+                catch (error) {
+                    finish(() => reject(error));
+                    return;
+                }
+                if (payload.id !== id) {
+                    return;
+                }
+                if (payload.error !== undefined) {
+                    finish(() => reject(new Error(formatRpcError(payload.error))));
+                    return;
+                }
+                finish(() => resolve(payload.result));
+            };
+            socket.onerror = () => {
+                finish(() => reject(new Error(`TAPI local runtime RPC failed: ${method}`)));
+            };
+            socket.onclose = () => {
+                if (!settled) {
+                    finish(() => reject(new Error(`TAPI local runtime closed before ${method} completed`)));
+                }
+            };
+        });
+    }
+    resolveWebSocket() {
+        if (this.webSocketCtor) {
+            return this.webSocketCtor;
+        }
+        const globalWebSocket = globalThis.WebSocket;
+        if (globalWebSocket) {
+            return globalWebSocket;
+        }
+        throw new Error("No WebSocket implementation is available. Pass { webSocket } to TapiClient to use local runtime profile APIs.");
+    }
+}
+function formatRpcError(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+    if (typeof error === "object" && error !== null) {
+        const record = error;
+        return String(record.message ?? record.error ?? JSON.stringify(record));
+    }
+    return String(error);
+}

package/dist/types.d.ts

@@ -4,12 +4,163 @@ export interface TapiClientOptions {
     apiKey: string;
     appId?: string;
     fetch?: typeof fetch;
+    localControlUrl?: string;
+    webSocket?: LocalWebSocketConstructor;
 }
 export interface WebsiteApiRunRequest {
     inputs?: Record<string, unknown>;
+    runtime?: RuntimeRunOptions;
     priority?: number;
     runnerId?: string;
     idempotencyKey?: string;
+    site?: string;
+}
+export interface CloudRunOptions {
+    windows?: boolean;
+    maxVms?: number;
+    chromePerVm?: number;
+    maxCostUsd?: number;
+    [key: string]: unknown;
+}
+export interface CloudRunUser {
+    externalUserId: string;
+    email?: string;
+}
+export interface CloudRunPaymentOptions {
+    successUrl?: string;
+    cancelUrl?: string;
+}
+export interface WebsiteApiCloudQuoteRequest {
+    inputs?: Array<Record<string, unknown>>;
+    cloud?: CloudRunOptions;
+    user?: CloudRunUser;
+    site?: string;
+}
+export interface WebsiteApiCloudBatchRequest {
+    inputs: Array<Record<string, unknown>>;
+    cloud?: CloudRunOptions;
+    user?: CloudRunUser;
+    payment?: CloudRunPaymentOptions;
+    site?: string;
+    idempotencyKey?: string;
+}
+export interface CloudRunQuote {
+    inputCount: number;
+    windows: boolean;
+    maxVms: number;
+    chromePerVm: number;
+    estimatedVms: number;
+    estimatedVmSeconds: number;
+    estimatedCostCents: number;
+    requiredBalanceCents: number;
+    currency: string;
+    maxCostUsd?: number | null;
+    withinMaxCost?: boolean;
+    billingEnabled?: boolean;
+    availableBalanceCents?: number | null;
+    minimumBalanceCents?: number;
+    user?: CloudRunUser;
+    [key: string]: unknown;
+}
+export interface CloudBatchRun {
+    id: string;
+    status: RunStatus | "payment_required" | "provisioning";
+    apiName?: string;
+    requestKey?: string;
+    site?: string;
+    inputCount?: number;
+    completedCount?: number;
+    failedCount?: number;
+    cancelledCount?: number;
+    cloud?: CloudRunOptions | Record<string, unknown>;
+    quote?: CloudRunQuote | Record<string, unknown>;
+    user?: CloudRunUser;
+    paymentRequired?: boolean;
+    checkoutUrl?: string | null;
+    checkoutSessionId?: string | null;
+    paymentProvider?: string;
+    paymentProviderEnabled?: boolean;
+    availableBalanceCents?: number;
+    requiredBalanceCents?: number;
+    reservationCents?: number;
+    actualCostCents?: number;
+    error?: Record<string, unknown> | null;
+    traceId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+export interface CloudRunEvent {
+    runId: string;
+    type: string;
+    status?: string;
+    itemIndex?: number;
+    traceId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+export interface CloudRunResultItem {
+    index: number;
+    status: string;
+    traceId?: string;
+    result?: Record<string, unknown> | null;
+    error?: Record<string, unknown> | null;
+    [key: string]: unknown;
+}
+export interface CloudRunResults {
+    runId: string;
+    status: string;
+    results: CloudRunResultItem[];
+}
+export interface CloudBalance {
+    balanceCents: number;
+    currency: string;
+    billingEnabled: boolean;
+    minimumBalanceCents: number;
+    user?: CloudRunUser;
+}
+export interface CloudCreditCheckoutRequest {
+    amountCents: number;
+    user?: CloudRunUser;
+    successUrl?: string;
+    cancelUrl?: string;
+}
+export interface CloudCreditCheckout {
+    checkoutUrl: string | null;
+    checkoutSessionId: string | null;
+    paymentProvider: "stripe" | string;
+    paymentProviderEnabled: boolean;
+}
+export interface WebsiteApiInputContract {
+    key: string;
+    label?: string;
+    type?: string;
+    valueType?: string;
+    control?: string;
+    options?: unknown[];
+    requiredWhen?: Record<string, unknown>;
+    default?: unknown;
+    [key: string]: unknown;
+}
+export interface WebsiteApiOutputContract {
+    key: string;
+    type?: string;
+    [key: string]: unknown;
+}
+export interface WebsiteApiOperation {
+    name: string;
+    namespace: string;
+    operation: string;
+    site?: string;
+    version?: string;
+    status?: string;
+    publishedAt?: string | null;
+    inputs: WebsiteApiInputContract[];
+    outputs?: WebsiteApiOutputContract[];
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    [key: string]: unknown;
 }
 export interface TapiRun {
     id: string;
@@ -18,6 +169,7 @@ export interface TapiRun {
     requestKey?: string;
     result?: Record<string, unknown> | null;
     error?: Record<string, unknown> | null;
+    runtime?: RuntimeRunOptions | Record<string, unknown> | null;
     createdAt?: string;
     updatedAt?: string;
     [key: string]: unknown;
@@ -38,10 +190,93 @@ export interface RuntimeRequirements {
     windowsServiceName?: string;
     [key: string]: unknown;
 }
+export type RuntimeProfileKind = "perm" | "temp" | "runtime_clone";
+export type OriginPolicyType = "home" | "direct" | "fixed_proxy";
+export interface OriginPolicy {
+    type: OriginPolicyType;
+    proxy?: string;
+    [key: string]: unknown;
+}
+export interface RuntimeProfile {
+    profileRef: string;
+    kind: RuntimeProfileKind;
+    displayName: string;
+    userDataDir?: string;
+    originPolicy: OriginPolicy;
+    templateRef?: string;
+    parentProfileRef?: string;
+    destroyOnRelease?: boolean;
+    ttlSeconds?: number | null;
+    state?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface RuntimeRunOptions {
+    profileRef?: string;
+    destroyOnRelease?: boolean;
+    [key: string]: unknown;
+}
+export interface CreatePermProfileRequest {
+    displayName: string;
+    originPolicy?: OriginPolicy | OriginPolicyType | string;
+    profileRef?: string;
+}
+export interface ProvisionTempProfilesRequest {
+    count?: number;
+    proxies?: string[];
+    templateRef?: string;
+    displayNamePrefix?: string;
+    destroyOnRelease?: boolean;
+    ttlSeconds?: number;
+}
+export interface PromoteTempProfileRequest {
+    profileRef: string;
+    displayName?: string;
+    originPolicy?: OriginPolicy | OriginPolicyType | string;
+}
+export interface CreateRuntimeCloneRequest {
+    profileRef: string;
+    site?: string;
+}
+export interface LaunchPermProfileSetupRequest {
+    profileRef: string;
+    windowBounds?: Record<string, number>;
+}
+export interface RuntimeProfileListResponse {
+    success: boolean;
+    profiles: RuntimeProfile[];
+}
+export interface RuntimeProfileResponse {
+    success: boolean;
+    profile: RuntimeProfile;
+}
+export interface RuntimeProfilesDestroyedResponse {
+    success: boolean;
+    destroyed: boolean;
+    profileRef: string;
+}
+export interface LocalWebSocketMessageEvent {
+    data: unknown;
+}
+export interface LocalWebSocketLike {
+    onopen: (() => void) | null;
+    onmessage: ((event: LocalWebSocketMessageEvent) => void) | null;
+    onerror: ((event: unknown) => void) | null;
+    onclose: ((event: unknown) => void) | null;
+    send(data: string): void;
+    close(): void;
+}
+export type LocalWebSocketConstructor = new (url: string) => LocalWebSocketLike;
 export interface SdkCatalogRequest {
     key: string;
     status: string;
-    inputs?: unknown[];
+    operation?: string;
+    sdkName?: string;
+    inputs?: WebsiteApiInputContract[];
+    inputSchema?: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
     responseSchema?: Record<string, unknown>;
     [key: string]: unknown;
 }

package/dist/website-apis.d.ts

@@ -1,7 +1,15 @@
-import type { HttpClient } from "./client";
-import type { TapiRun, WebsiteApiRunRequest } from "./types";
+import type { HttpClient } from "./client.js";
+import type { CloudBatchRun, CloudRunQuote, TapiRun, WebsiteApiCloudBatchRequest, WebsiteApiCloudQuoteRequest, WebsiteApiOperation, WebsiteApiRunRequest } from "./types.js";
 export declare class WebsiteApisResource {
     private readonly http;
     constructor(http: HttpClient);
     run(apiRequest: string, request?: WebsiteApiRunRequest): Promise<TapiRun>;
+    quoteCloud(apiRequest: string, request?: WebsiteApiCloudQuoteRequest): Promise<CloudRunQuote>;
+    runCloud(apiRequest: string, request?: WebsiteApiRunRequest & {
+        cloud?: WebsiteApiCloudBatchRequest["cloud"];
+        user?: WebsiteApiCloudBatchRequest["user"];
+        payment?: WebsiteApiCloudBatchRequest["payment"];
+    }): Promise<CloudBatchRun>;
+    runCloudBatch(apiRequest: string, request: WebsiteApiCloudBatchRequest): Promise<CloudBatchRun>;
+    describe(apiRequest: string): Promise<WebsiteApiOperation>;
 }