@tapi-dev/sdk 0.1.0

package/dist/catalog.d.ts

@@ -0,0 +1,7 @@
+import type { HttpClient } from "./client";
+import type { SdkCatalog } from "./types";
+export declare class CatalogResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    get(): Promise<SdkCatalog>;
+}

package/dist/catalog.js

@@ -0,0 +1,9 @@
+export class CatalogResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    get() {
+        return this.http.get("/api/sdk/v1/catalog");
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import type { TapiClientOptions } from "./types";
+export declare class HttpClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly appId?;
+    private readonly fetchImpl;
+    constructor(options: TapiClientOptions);
+    get<T>(path: string): Promise<T>;
+    post<T>(path: string, body?: unknown): Promise<T>;
+    private request;
+}

package/dist/client.js

@@ -0,0 +1,50 @@
+import { TapiError } from "./errors";
+export class HttpClient {
+    baseUrl;
+    apiKey;
+    appId;
+    fetchImpl;
+    constructor(options) {
+        this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+        this.apiKey = options.apiKey;
+        this.appId = options.appId;
+        this.fetchImpl = options.fetch ?? fetch;
+    }
+    async get(path) {
+        return this.request("GET", path);
+    }
+    async post(path, body) {
+        return this.request("POST", path, body);
+    }
+    async request(method, path, body) {
+        const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            method,
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+                ...(this.appId ? { "X-Tapi-App": this.appId } : {}),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const payload = await readJson(response);
+        if (!response.ok) {
+            const detail = isRecord(payload) ? payload.detail ?? payload.error ?? payload : payload;
+            throw new TapiError(`tapi request failed: ${response.status}`, {
+                status: response.status,
+                code: isRecord(detail) && typeof detail.code === "string" ? detail.code : "http_error",
+                details: detail,
+            });
+        }
+        return payload;
+    }
+}
+async function readJson(response) {
+    const text = await response.text();
+    if (!text) {
+        return {};
+    }
+    return JSON.parse(text);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/errors.d.ts

@@ -0,0 +1,10 @@
+export declare class TapiError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly details: unknown;
+    constructor(message: string, options: {
+        status: number;
+        code?: string;
+        details?: unknown;
+    });
+}

package/dist/errors.js

@@ -0,0 +1,12 @@
+export class TapiError extends Error {
+    status;
+    code;
+    details;
+    constructor(message, options) {
+        super(message);
+        this.name = "TapiError";
+        this.status = options.status;
+        this.code = options.code ?? "tapi_error";
+        this.details = options.details;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+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";
+export declare class TapiClient {
+    readonly catalog: CatalogResource;
+    readonly runners: RunnersResource;
+    readonly runs: RunsResource;
+    readonly runtime: RuntimeResource;
+    readonly websiteApis: WebsiteApisResource;
+    constructor(options: TapiClientOptions);
+}
+export * from "./errors";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,23 @@
+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";
+export class TapiClient {
+    catalog;
+    runners;
+    runs;
+    runtime;
+    websiteApis;
+    constructor(options) {
+        const http = new HttpClient(options);
+        this.catalog = new CatalogResource(http);
+        this.runners = new RunnersResource(http);
+        this.runs = new RunsResource(http);
+        this.runtime = new RuntimeResource(http);
+        this.websiteApis = new WebsiteApisResource(http);
+    }
+}
+export * from "./errors";
+export * from "./types";

package/dist/runners.d.ts

@@ -0,0 +1,9 @@
+import type { HttpClient } from "./client";
+import type { TapiRunner } from "./types";
+export declare class RunnersResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    list(): Promise<{
+        runners: TapiRunner[];
+    }>;
+}

package/dist/runners.js

@@ -0,0 +1,9 @@
+export class RunnersResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list() {
+        return this.http.get("/api/sdk/v1/runners");
+    }
+}

package/dist/runs.d.ts

@@ -0,0 +1,12 @@
+import type { HttpClient } from "./client";
+import type { TapiRun } from "./types";
+export declare class RunsResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    get(runId: string): Promise<TapiRun>;
+    cancel(runId: string): Promise<TapiRun>;
+    wait(runId: string, options?: {
+        intervalMs?: number;
+        timeoutMs?: number;
+    }): Promise<TapiRun>;
+}

package/dist/runs.js

@@ -0,0 +1,24 @@
+export class RunsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    get(runId) {
+        return this.http.get(`/api/sdk/v1/runs/${encodeURIComponent(runId)}`);
+    }
+    cancel(runId) {
+        return this.http.post(`/api/sdk/v1/runs/${encodeURIComponent(runId)}/cancel`);
+    }
+    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", "needs_developer_attention"].includes(run.status)) {
+                return run;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error(`timed out waiting for run ${runId}`);
+    }
+}

package/dist/runtime.d.ts

@@ -0,0 +1,7 @@
+import type { HttpClient } from "./client";
+import type { RuntimeRequirements } from "./types";
+export declare class RuntimeResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    requirements(): Promise<RuntimeRequirements>;
+}

package/dist/runtime.js

@@ -0,0 +1,9 @@
+export class RuntimeResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    requirements() {
+        return this.http.get("/api/sdk/v1/runtime/requirements");
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+export type RunStatus = "queued" | "running" | "completed" | "failed" | "cancelled" | "needs_developer_attention";
+export interface TapiClientOptions {
+    baseUrl: string;
+    apiKey: string;
+    appId?: string;
+    fetch?: typeof fetch;
+}
+export interface WebsiteApiRunRequest {
+    inputs?: Record<string, unknown>;
+    priority?: number;
+    runnerId?: string;
+    idempotencyKey?: string;
+}
+export interface TapiRun {
+    id: string;
+    status: RunStatus;
+    apiName?: string;
+    requestKey?: string;
+    result?: Record<string, unknown> | null;
+    error?: Record<string, unknown> | null;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+export interface TapiRunner {
+    id: string;
+    status: string;
+    name?: string;
+    online?: boolean;
+    [key: string]: unknown;
+}
+export interface RuntimeRequirements {
+    daemonRequired: boolean;
+    localControlUrl?: string;
+    windowsServiceName?: string;
+    [key: string]: unknown;
+}
+export interface SdkCatalogRequest {
+    key: string;
+    status: string;
+    inputs?: unknown[];
+    responseSchema?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface SdkCatalogApi {
+    name: string;
+    version: string;
+    site?: string;
+    requests: SdkCatalogRequest[];
+    [key: string]: unknown;
+}
+export interface SdkCatalog {
+    apis: SdkCatalogApi[];
+    [key: string]: unknown;
+}

package/dist/types.js

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

package/dist/website-apis.d.ts

@@ -0,0 +1,7 @@
+import type { HttpClient } from "./client";
+import type { TapiRun, WebsiteApiRunRequest } from "./types";
+export declare class WebsiteApisResource {
+    private readonly http;
+    constructor(http: HttpClient);
+    run(apiRequest: string, request?: WebsiteApiRunRequest): Promise<TapiRun>;
+}

package/dist/website-apis.js

@@ -0,0 +1,21 @@
+export class WebsiteApisResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    run(apiRequest, request = {}) {
+        const { apiName, requestKey } = splitApiRequest(apiRequest);
+        return this.http.post(`/api/sdk/v1/website-apis/${encodeURIComponent(apiName)}/requests/${encodeURIComponent(requestKey)}/runs`, request);
+    }
+}
+function splitApiRequest(value) {
+    const text = value.trim();
+    const index = text.lastIndexOf(".");
+    if (index <= 0 || index === text.length - 1) {
+        throw new Error("api request must be formatted as '<apiName>.<requestKey>'");
+    }
+    return {
+        apiName: text.slice(0, index),
+        requestKey: text.slice(index + 1),
+    };
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@tapi-dev/sdk",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm test && npm run build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "typescript": "^5.5.0",
+    "vitest": "^2.0.0"
+  }
+}