@tapi-dev/sdk 0.1.17 → 0.1.21

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { CatalogResource } from "./catalog.js";
 import { RunnersResource } from "./runners.js";
 import { RunsResource } from "./runs.js";
 import { RuntimeResource } from "./runtime.js";
+import { SessionsResource } from "./sessions.js";
 import { TriggersResource } from "./triggers.js";
 import type { TapiClientOptions } from "./types.js";
 import { WebsiteApisResource } from "./website-apis.js";
@@ -12,10 +13,13 @@ export declare class TapiClient {
     readonly runners: RunnersResource;
     readonly runs: RunsResource;
     readonly runtime: RuntimeResource;
+    readonly sessions: SessionsResource;
     readonly triggers: TriggersResource;
     readonly websiteApis: WebsiteApisResource;
     constructor(options: TapiClientOptions);
 }
 export * from "./errors.js";
+export * from "./late-input.js";
+export * from "./sessions.js";
 export * from "./types.js";
 export * from "./workspace.js";

package/dist/index.js

@@ -4,6 +4,7 @@ import { CatalogResource } from "./catalog.js";
 import { RunnersResource } from "./runners.js";
 import { RunsResource } from "./runs.js";
 import { RuntimeResource } from "./runtime.js";
+import { SessionsResource } from "./sessions.js";
 import { TriggersResource } from "./triggers.js";
 import { WebsiteApisResource } from "./website-apis.js";
 export class TapiClient {
@@ -12,6 +13,7 @@ export class TapiClient {
     runners;
     runs;
     runtime;
+    sessions;
     triggers;
     websiteApis;
     constructor(options) {
@@ -21,10 +23,13 @@ export class TapiClient {
         this.runners = new RunnersResource(http);
         this.runs = new RunsResource(http);
         this.runtime = new RuntimeResource(http, options);
+        this.sessions = new SessionsResource(http);
         this.triggers = new TriggersResource(http);
-        this.websiteApis = new WebsiteApisResource(http);
+        this.websiteApis = new WebsiteApisResource(http, options);
     }
 }
 export * from "./errors.js";
+export * from "./late-input.js";
+export * from "./sessions.js";
 export * from "./types.js";
 export * from "./workspace.js";

package/dist/late-input.d.ts

@@ -0,0 +1,24 @@
+export interface LateInputOptions<T> {
+    resolve?: () => T | Promise<T>;
+    timeoutMs?: number;
+}
+export interface LateInput<T = unknown> {
+    readonly __tapiLateInput: true;
+    set(value: T): Promise<void>;
+    waitForProvides(): Promise<void>;
+}
+type Provider = (runId: string, inputKey: string, value: unknown) => Promise<unknown>;
+export declare function lateInput<T = unknown>(options?: LateInputOptions<T>): LateInput<T>;
+export declare function isLateInput(value: unknown): value is LateInput<unknown>;
+export declare function serializeInputs(inputs: Record<string, unknown> | undefined): {
+    bodyInputs: Record<string, unknown> | undefined;
+    lateInputs: Array<{
+        key: string;
+        input: LateInput<unknown>;
+    }>;
+};
+export declare function attachLateInputs(lateInputs: Array<{
+    key: string;
+    input: LateInput<unknown>;
+}>, runId: string, provider: Provider): void;
+export {};

package/dist/late-input.js

@@ -0,0 +1,112 @@
+class TapiLateInput {
+    __tapiLateInput = true;
+    timeoutMs;
+    resolver;
+    resolverStarted = false;
+    resolverPromise;
+    hasResolverError = false;
+    resolverError;
+    resolved = false;
+    resolvedValue;
+    bindings = [];
+    providePromises = [];
+    constructor(options = {}) {
+        this.resolver = options.resolve;
+        this.timeoutMs = options.timeoutMs;
+    }
+    async set(value) {
+        if (this.resolved) {
+            throw new Error("late input has already been set");
+        }
+        this.resolved = true;
+        this.resolvedValue = value;
+        this.provide(value);
+        await Promise.all(this.providePromises);
+    }
+    provide(value) {
+        for (const binding of this.bindings) {
+            this.providePromises.push(binding.provider(binding.runId, binding.inputKey, value));
+        }
+    }
+    async waitForProvides() {
+        if (this.resolverPromise) {
+            await this.resolverPromise;
+        }
+        if (this.hasResolverError) {
+            throw this.resolverError;
+        }
+        await Promise.all(this.providePromises);
+    }
+    attach(binding) {
+        this.bindings.push(binding);
+        if (this.resolved) {
+            this.provide(this.resolvedValue);
+            return;
+        }
+        this.startResolver();
+    }
+    toWire() {
+        return {
+            __tapiLateInput: true,
+            ...(typeof this.timeoutMs === "number" ? { timeoutMs: this.timeoutMs } : {}),
+        };
+    }
+    startResolver() {
+        if (!this.resolver || this.resolverStarted) {
+            return;
+        }
+        this.resolverStarted = true;
+        let resolverClaimedValue = false;
+        this.resolverPromise = Promise.resolve()
+            .then(() => this.resolver?.())
+            .then(async (value) => {
+            if (this.resolved) {
+                return;
+            }
+            resolverClaimedValue = true;
+            this.resolved = true;
+            this.resolvedValue = value;
+            this.provide(this.resolvedValue);
+            await Promise.all(this.providePromises);
+        })
+            .catch((error) => {
+            if (resolverClaimedValue || !this.resolved) {
+                this.hasResolverError = true;
+                this.resolverError = error;
+            }
+        });
+    }
+}
+export function lateInput(options = {}) {
+    return new TapiLateInput(options);
+}
+export function isLateInput(value) {
+    return Boolean(value
+        && typeof value === "object"
+        && value.__tapiLateInput === true
+        && typeof value.set === "function");
+}
+export function serializeInputs(inputs) {
+    if (inputs === undefined) {
+        return { bodyInputs: undefined, lateInputs: [] };
+    }
+    const bodyInputs = {};
+    const lateInputs = [];
+    for (const [key, value] of Object.entries(inputs)) {
+        if (isLateInput(value)) {
+            const late = value;
+            bodyInputs[key] = late.toWire();
+            lateInputs.push({ key, input: value });
+        }
+        else {
+            bodyInputs[key] = value;
+        }
+    }
+    return { bodyInputs, lateInputs };
+}
+export function attachLateInputs(lateInputs, runId, provider) {
+    for (const item of lateInputs) {
+        const late = item.input;
+        late.attach({ runId, inputKey: item.key, provider });
+    }
+}

package/dist/runs.d.ts

@@ -5,6 +5,7 @@ export declare class RunsResource {
     constructor(http: HttpClient);
     get(runId: string): Promise<TapiRun>;
     cancel(runId: string): Promise<TapiRun>;
+    provideInput(runId: string, inputKey: string, value: unknown): Promise<TapiRun>;
     wait(runId: string, options?: {
         intervalMs?: number;
         timeoutMs?: number;

package/dist/runs.js

@@ -9,6 +9,9 @@ export class RunsResource {
     cancel(runId) {
         return this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/cancel`);
     }
+    provideInput(runId, inputKey, value) {
+        return this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/inputs/${encodeURIComponent(inputKey)}`, { value });
+    }
     async wait(runId, options = {}) {
         const intervalMs = options.intervalMs ?? 1000;
         const deadline = Date.now() + (options.timeoutMs ?? 300000);

package/dist/sessions.d.ts

@@ -0,0 +1,10 @@
+import type { HttpClient } from "./client.js";
+import type { TapiDevSessionsList } from "./types.js";
+export interface TapiDevSessionsListOptions {
+    site?: string;
+}
+export declare class SessionsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(options?: TapiDevSessionsListOptions): Promise<TapiDevSessionsList>;
+}

package/dist/sessions.js

@@ -0,0 +1,14 @@
+export class SessionsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(options = {}) {
+        const params = new URLSearchParams();
+        if (options.site) {
+            params.set("site", options.site);
+        }
+        const query = params.toString();
+        return this.http.get(`/api/sdk/v1/dev/sessions${query ? `?${query}` : ""}`);
+    }
+}

package/dist/types.d.ts

@@ -1,14 +1,16 @@
-export type RunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "needs_developer_attention";
+import type { LateInput } from "./late-input.js";
+export type RunStatus = "queued" | "running" | "waiting_for_input" | "completed" | "failed" | "cancelled" | "needs_developer_attention";
 export interface TapiClientOptions {
     baseUrl: string;
     apiKey: string;
     projectId?: string;
+    dev?: boolean;
     fetch?: typeof fetch;
     localControlUrl?: string;
     webSocket?: LocalWebSocketConstructor;
 }
 export interface WebsiteApiRunRequest {
-    inputs?: Record<string, unknown>;
+    inputs?: Record<string, unknown | LateInput<unknown>>;
     runtime?: RuntimeRunOptions;
     priority?: number;
     runnerId?: string;
@@ -156,6 +158,8 @@ export interface WebsiteApiOperation {
     version?: string;
     status?: string;
     publishedAt?: string | null;
+    variant?: "desktop" | "mobile" | string;
+    runtime?: RuntimeRunOptions | Record<string, unknown>;
     inputs: WebsiteApiInputContract[];
     outputs?: WebsiteApiOutputContract[];
     inputSchema?: Record<string, unknown>;
@@ -218,10 +222,51 @@ export interface TapiRun {
     result?: Record<string, unknown> | null;
     error?: Record<string, unknown> | null;
     runtime?: RuntimeRunOptions | Record<string, unknown> | null;
+    waitingInput?: WebsiteApiWaitingInput | null;
+    pendingInputs?: WebsiteApiWaitingInput[];
     createdAt?: string;
     updatedAt?: string;
     [key: string]: unknown;
 }
+export type TapiDevSessionStatus = "queued" | "running" | "waiting_for_input" | "awaiting_takeover" | "needs_developer_attention" | "completed" | "failed" | "cancelled" | string;
+export interface TapiDevSession {
+    id: string;
+    projectId: string;
+    sitemap: string;
+    site?: string;
+    apiName: string;
+    requestKey: string;
+    status: TapiDevSessionStatus;
+    stateId?: number | null;
+    stateLabel?: string;
+    currentUrl?: string;
+    profileRef?: string;
+    runtimeSessionId?: string;
+    deviceId?: string;
+    live: boolean;
+    openable: boolean;
+    dev: boolean;
+    updatedAt?: string;
+    createdAt?: string;
+    [key: string]: unknown;
+}
+export interface TapiDevSessionGroup {
+    sitemap: string;
+    sessions: TapiDevSession[];
+}
+export interface TapiDevSessionsList {
+    projectId: string;
+    groups: TapiDevSessionGroup[];
+}
+export interface WebsiteApiWaitingInput {
+    key: string;
+    label?: string;
+    stateId?: number;
+    actionId?: string;
+    control?: string;
+    timeoutMs?: number;
+    [key: string]: unknown;
+}
 export interface TapiRunner {
     id: string;
     status: string;
@@ -322,6 +367,8 @@ export interface SdkCatalogRequest {
     status: string;
     operation?: string;
     sdkName?: string;
+    variant?: "desktop" | "mobile" | string;
+    runtime?: RuntimeRunOptions | Record<string, unknown>;
     inputs?: WebsiteApiInputContract[];
     inputSchema?: Record<string, unknown>;
     outputSchema?: Record<string, unknown>;

package/dist/website-apis.d.ts

@@ -1,8 +1,10 @@
 import type { HttpClient } from "./client.js";
 import type { CloudBatchRun, CloudRunQuote, TapiRun, WebsiteApiCloudBatchRequest, WebsiteApiCloudQuoteRequest, WebsiteApiOperation, WebsiteApiRunRequest } from "./types.js";
+import type { TapiClientOptions } from "./types.js";
 export declare class WebsiteApisResource {
     private readonly http;
-    constructor(http: HttpClient);
+    private readonly dev;
+    constructor(http: HttpClient, options: TapiClientOptions);
     run(apiRequest: string, request?: WebsiteApiRunRequest): Promise<TapiRun>;
     quoteCloud(apiRequest: string, request?: WebsiteApiCloudQuoteRequest): Promise<CloudRunQuote>;
     runCloud(apiRequest: string, request?: WebsiteApiRunRequest & {

package/dist/website-apis.js

@@ -1,12 +1,25 @@
 import { TapiError } from "./errors.js";
+import { attachLateInputs, serializeInputs } from "./late-input.js";
 export class WebsiteApisResource {
     http;
-    constructor(http) {
+    dev;
+    constructor(http, options) {
         this.http = http;
+        this.dev = options.dev === true;
     }
-    run(apiRequest, request = {}) {
+    async run(apiRequest, request = {}) {
         const { apiName, requestKey } = splitApiRequest(apiRequest);
-        return this.http.post(`/api/sdk/v1/website-apis/${encodeURIComponent(apiName)}/requests/${encodeURIComponent(requestKey)}/runs`, request);
+        const { bodyInputs, lateInputs } = serializeInputs(request.inputs);
+        const body = {
+            ...request,
+            ...(bodyInputs === undefined ? {} : { inputs: bodyInputs }),
+            ...(this.dev ? { dev: true } : {}),
+        };
+        const run = await this.http.post(`/api/sdk/v1/website-apis/${encodeURIComponent(apiName)}/requests/${encodeURIComponent(requestKey)}/runs`, body);
+        if (run.id && lateInputs.length > 0) {
+            attachLateInputs(lateInputs, run.id, (runId, inputKey, value) => this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/inputs/${encodeURIComponent(inputKey)}`, { value }));
+        }
+        return run;
     }
     quoteCloud(apiRequest, request = {}) {
         const { apiName, requestKey } = splitApiRequest(apiRequest);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tapi-dev/sdk",
-  "version": "0.1.17",
+  "version": "0.1.21",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",