@init.computer/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,77 @@
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+export type JsonObject = { [key: string]: JsonValue | undefined };
+
+export type InitClientOptions = {
+  apiKey?: string;
+  baseUrl?: string;
+  fetch?: typeof fetch;
+};
+
+export type RequestOptions = {
+  method?: string;
+  requestFormat?: "json" | "multipart/form-data";
+  headers?: HeadersInit;
+};
+
+export class InitApiError extends Error {
+  status?: number;
+  response?: unknown;
+  details?: unknown;
+  constructor(message: string, options?: { status?: number; response?: unknown; details?: unknown });
+}
+
+export type ResourceClient = {
+  list<T = unknown>(query?: JsonObject): Promise<T>;
+  get<T = unknown>(id: string): Promise<T>;
+  update<T = unknown>(id: string, patch: JsonObject): Promise<T>;
+  edit<T = unknown>(resourceId: string, request: JsonObject): Promise<T>;
+  versions<T = unknown>(id: string): Promise<T>;
+  activateVersion<T = unknown>(id: string, versionId: string): Promise<T>;
+};
+
+export type DirectoryClient = {
+  list<T = unknown>(query?: JsonObject): Promise<T>;
+  create<T = unknown>(input: JsonObject): Promise<T>;
+  get<T = unknown>(id: string): Promise<T>;
+  update<T = unknown>(id: string, patch: JsonObject): Promise<T>;
+  delete<T = unknown>(id: string): Promise<T>;
+  addResources<T = unknown>(id: string, resourceIds: string[]): Promise<T>;
+  removeResource<T = unknown>(id: string, resourceId: string): Promise<T>;
+};
+
+export type DaemonClient = {
+  list<T = unknown>(query?: JsonObject): Promise<T>;
+  create<T = unknown>(input: JsonObject): Promise<T>;
+  get<T = unknown>(id: string): Promise<T>;
+  pause<T = unknown>(id: string): Promise<T>;
+  resume<T = unknown>(id: string): Promise<T>;
+  stop<T = unknown>(id: string): Promise<T>;
+  run<T = unknown>(id: string): Promise<T>;
+};
+
+export type PackageClient = {
+  list<T = unknown>(query?: JsonObject): Promise<T>;
+};
+
+export class InitClient {
+  constructor(options?: InitClientOptions);
+  baseUrl: string;
+  apiKey?: string;
+  resource: ResourceClient;
+  directory: DirectoryClient;
+  daemon: DaemonClient;
+  pkg: PackageClient;
+  withApiKey(apiKey: string): InitClient;
+  generate<T = unknown>(request: JsonObject): Promise<T>;
+  run<T = unknown>(route: string, input?: JsonObject | FormData, options?: RequestOptions & { version?: number }): Promise<T>;
+  request<T = unknown>(path: string, options?: RequestOptions & { body?: unknown }): Promise<T>;
+}
+
+export function createClient(options?: InitClientOptions): InitClient;

package/dist/index.js

@@ -0,0 +1,196 @@
+const DEFAULT_BASE_URL = "https://api.init.computer";
+
+export class InitApiError extends Error {
+  constructor(message, { status, response, details } = {}) {
+    super(message);
+    this.name = "InitApiError";
+    this.status = status;
+    this.response = response;
+    this.details = details;
+  }
+}
+
+export class InitClient {
+  constructor(options = {}) {
+    const env = globalThis.process?.env || {};
+    this.baseUrl = stripTrailingSlash(options.baseUrl || env.INIT_API_BASE_URL || DEFAULT_BASE_URL);
+    this.apiKey = options.apiKey || env.INIT_API_KEY;
+    this.fetch = options.fetch || globalThis.fetch;
+    if (!this.fetch) {
+      throw new InitApiError("A fetch implementation is required.");
+    }
+    this.resource = {
+      list: (query = {}) => this.request(`/v1/resources${queryString(query)}`),
+      get: (id) => this.request(`/v1/resources/${encodeURIComponent(id)}`),
+      update: (id, patch) => this.request(`/v1/resources/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: patch,
+      }),
+      edit: (resourceId, request) => this.generate({ ...request, resource_id: resourceId }),
+      versions: (id) => this.request(`/v1/resources/${encodeURIComponent(id)}/versions`),
+      activateVersion: (id, versionId) => this.request(
+        `/v1/resources/${encodeURIComponent(id)}/versions/${encodeURIComponent(versionId)}/activate`,
+        { method: "POST" },
+      ),
+    };
+    this.directory = {
+      list: (query = {}) => this.request(`/v1/directories${queryString(query)}`),
+      create: (input) => this.request("/v1/directories", { method: "POST", body: input }),
+      get: (id) => this.request(`/v1/directories/${encodeURIComponent(id)}`),
+      update: (id, patch) => this.request(`/v1/directories/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: patch,
+      }),
+      delete: (id) => this.request(`/v1/directories/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+      }),
+      addResources: (id, resourceIds) => this.request(`/v1/directories/${encodeURIComponent(id)}/resources`, {
+        method: "POST",
+        body: { resource_ids: resourceIds },
+      }),
+      removeResource: (id, resourceId) => this.request(
+        `/v1/directories/${encodeURIComponent(id)}/resources/${encodeURIComponent(resourceId)}`,
+        { method: "DELETE" },
+      ),
+    };
+    this.daemon = {
+      list: (query = {}) => this.request(`/v1/daemons${queryString(query)}`),
+      create: (input) => this.request("/v1/daemons", { method: "POST", body: input }),
+      get: (id) => this.request(`/v1/daemons/${encodeURIComponent(id)}`),
+      pause: (id) => this.request(`/v1/daemons/${encodeURIComponent(id)}/pause`, { method: "POST" }),
+      resume: (id) => this.request(`/v1/daemons/${encodeURIComponent(id)}/resume`, { method: "POST" }),
+      stop: (id) => this.request(`/v1/daemons/${encodeURIComponent(id)}/stop`, { method: "POST" }),
+      run: (id) => this.request(`/v1/daemons/${encodeURIComponent(id)}/run`, { method: "POST" }),
+    };
+    this.pkg = {
+      list: (query = {}) => this.request(`/v1/packages${queryString(query)}`),
+    };
+  }
+
+  withApiKey(apiKey) {
+    return new InitClient({ baseUrl: this.baseUrl, apiKey, fetch: this.fetch });
+  }
+
+  async generate(request) {
+    return this.request("/v1/generate", {
+      method: "POST",
+      body: request,
+    });
+  }
+
+  async run(route, input = {}, options = {}) {
+    const path = normalizeRunPath(route, options.version);
+    return this.request(path, {
+      method: options.method || "POST",
+      body: input,
+      requestFormat: options.requestFormat,
+    });
+  }
+
+  async request(path, options = {}) {
+    const headers = new Headers(options.headers || {});
+    if (this.apiKey && !headers.has("authorization")) {
+      headers.set("authorization", `Bearer ${this.apiKey}`);
+    }
+
+    let body;
+    const requestFormat = options.requestFormat || inferRequestFormat(options.body);
+    if (options.body !== undefined && options.method !== "GET") {
+      if (requestFormat === "multipart/form-data") {
+        body = toFormData(options.body);
+      } else {
+        headers.set("content-type", "application/json");
+        body = JSON.stringify(options.body);
+      }
+    }
+
+    const response = await this.fetch(`${this.baseUrl}${path}`, {
+      method: options.method || "GET",
+      headers,
+      body,
+    });
+    const text = await response.text();
+    const payload = parseJson(text);
+    if (!response.ok || payload?.success === false) {
+      const firstError = Array.isArray(payload?.errors) ? payload.errors[0] : undefined;
+      throw new InitApiError(firstError?.message || response.statusText || "Init API request failed", {
+        status: response.status,
+        response: payload ?? text,
+        details: firstError?.details,
+      });
+    }
+    return payload ?? text;
+  }
+}
+
+export function createClient(options) {
+  return new InitClient(options);
+}
+
+function normalizeRunPath(route, version = 1) {
+  if (!route) {
+    throw new InitApiError("route is required.");
+  }
+  const raw = String(route);
+  if (raw.startsWith("http://") || raw.startsWith("https://")) {
+    const url = new URL(raw);
+    return `${url.pathname}${url.search}`;
+  }
+  if (raw.startsWith("/")) {
+    return raw;
+  }
+  if (/^v\d+\//.test(raw)) {
+    return `/${raw}`;
+  }
+  return `/v${version}/${raw}`;
+}
+
+function queryString(query) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value === undefined || value === null || value === "") continue;
+    params.set(key, String(value));
+  }
+  const text = params.toString();
+  return text ? `?${text}` : "";
+}
+
+function inferRequestFormat(body) {
+  if (typeof FormData !== "undefined" && body instanceof FormData) {
+    return "multipart/form-data";
+  }
+  return "json";
+}
+
+function toFormData(input) {
+  if (typeof FormData !== "undefined" && input instanceof FormData) {
+    return input;
+  }
+  const form = new FormData();
+  for (const [key, value] of Object.entries(input || {})) {
+    if (Array.isArray(value)) {
+      for (const item of value) form.append(key, formValue(item));
+    } else {
+      form.append(key, formValue(value));
+    }
+  }
+  return form;
+}
+
+function formValue(value) {
+  if (typeof Blob !== "undefined" && value instanceof Blob) return value;
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+
+function parseJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function stripTrailingSlash(value) {
+  return String(value).replace(/\/+$/, "");
+}

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@init.computer/sdk",
+  "version": "0.1.0",
+  "description": "Official JavaScript SDK for Init generated backend APIs.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED"
+}