@computesdk/quilt 1.0.1

package/dist/index.js

@@ -0,0 +1,635 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  quilt: () => quilt
+});
+module.exports = __toCommonJS(index_exports);
+var import_provider = require("@computesdk/provider");
+var PROVIDER = "quilt";
+var DEFAULT_IMAGE = "prod";
+var DEFAULT_TIMEOUT_MS = 3e5;
+var DEFAULT_POLL_INTERVAL_MS = 1e3;
+function getEnv(name) {
+  return typeof process !== "undefined" ? process.env?.[name] : void 0;
+}
+function resolveConfig(config) {
+  const baseUrl = config.baseUrl ?? getEnv("QUILT_BASE_URL") ?? getEnv("QUILT_API_BASE_URL");
+  if (!baseUrl) {
+    throw new Error(
+      "Missing Quilt base URL.\n\nPass it: quilt({ baseUrl: 'https://backend.example.com' })\nOr set QUILT_BASE_URL in your environment."
+    );
+  }
+  const apiKey = config.apiKey ?? getEnv("QUILT_API_KEY");
+  const accessToken = config.accessToken ?? getEnv("QUILT_ACCESS_TOKEN");
+  if (!apiKey && !accessToken) {
+    throw new Error(
+      "Missing Quilt credentials.\n\nProvide apiKey or accessToken in config:\n  quilt({ baseUrl: 'https://backend.example.com', apiKey: 'xxx' })\nOr set QUILT_API_KEY or QUILT_ACCESS_TOKEN in your environment."
+    );
+  }
+  const tenantId = config.tenantId ?? getEnv("QUILT_TENANT_ID");
+  const timeoutFromEnv = getEnv("QUILT_TIMEOUT_MS");
+  const pollFromEnv = getEnv("QUILT_POLL_INTERVAL_MS");
+  const ttlFromEnv = getEnv("QUILT_PUBLISHED_SERVICE_TTL_SECS");
+  const authModeFromEnv = getEnv("QUILT_PUBLISHED_SERVICE_AUTH_MODE");
+  return {
+    baseUrl: baseUrl.replace(/\/+$/, ""),
+    authMode: apiKey ? "apiKey" : "accessToken",
+    authToken: apiKey ?? accessToken ?? "",
+    tenantId,
+    image: config.image ?? getEnv("QUILT_IMAGE") ?? DEFAULT_IMAGE,
+    timeout: config.timeout ?? parseOptionalInt(timeoutFromEnv) ?? DEFAULT_TIMEOUT_MS,
+    publishedServiceAuthMode: config.publishedServiceAuthMode ?? (authModeFromEnv === "public" ? "public" : "service_token"),
+    publishedServiceTtlSecs: config.publishedServiceTtlSecs ?? parseOptionalInt(ttlFromEnv) ?? void 0,
+    pollIntervalMs: config.pollIntervalMs ?? parseOptionalInt(pollFromEnv) ?? DEFAULT_POLL_INTERVAL_MS
+  };
+}
+function parseOptionalInt(value) {
+  if (!value) return void 0;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function buildHeaders(config, includeTenantHeader = false) {
+  const headers = {
+    Accept: "application/json"
+  };
+  if (config.authMode === "apiKey") {
+    headers["X-Api-Key"] = config.authToken;
+  } else {
+    headers.Authorization = `Bearer ${config.authToken}`;
+  }
+  if (includeTenantHeader) {
+    if (!config.tenantId) {
+      throw new Error(
+        "Quilt snapshot operations require tenantId.\n\nPass it: quilt({ tenantId: 'tenant_123', ... })\nOr set QUILT_TENANT_ID in your environment."
+      );
+    }
+    headers["X-Tenant-Id"] = config.tenantId;
+  }
+  return headers;
+}
+async function requestJson(config, path, init = {}, options = {}) {
+  const headers = {
+    ...buildHeaders(config, options.includeTenantHeader),
+    ...init.headers || {}
+  };
+  const response = await fetch(`${config.baseUrl}${path}`, {
+    ...init,
+    headers
+  });
+  if (options.allow404 && response.status === 404) {
+    return null;
+  }
+  if (!response.ok) {
+    throw await buildHttpError(response, path);
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  return await response.json();
+}
+async function requestNoContent(config, path, init = {}, options = {}) {
+  const headers = {
+    ...buildHeaders(config, options.includeTenantHeader),
+    ...init.headers || {}
+  };
+  const response = await fetch(`${config.baseUrl}${path}`, {
+    ...init,
+    headers
+  });
+  if (options.allow404 && response.status === 404) {
+    return;
+  }
+  if (!response.ok) {
+    throw await buildHttpError(response, path);
+  }
+}
+async function buildHttpError(response, path) {
+  let detail = `${response.status} ${response.statusText}`;
+  try {
+    const body = await response.json();
+    if (body && typeof body === "object") {
+      const record = body;
+      detail = typeof record.error === "string" && record.error || typeof record.message === "string" && record.message || detail;
+    }
+  } catch {
+    try {
+      const text = await response.text();
+      if (text) detail = text;
+    } catch {
+    }
+  }
+  return new Error(`Quilt API request failed for ${path}: ${detail}`);
+}
+function buildExecCommand(command, options) {
+  let fullCommand = command;
+  if (options?.env && Object.keys(options.env).length > 0) {
+    const envPrefix = Object.entries(options.env).map(([key, value]) => {
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+        throw new Error(`Invalid environment variable name "${key}".`);
+      }
+      return `${key}="${(0, import_provider.escapeShellArg)(String(value))}"`;
+    }).join(" ");
+    fullCommand = `${envPrefix} ${fullCommand}`;
+  }
+  if (options?.background) {
+    fullCommand = `nohup ${fullCommand} > /dev/null 2>&1 &`;
+  }
+  return fullCommand;
+}
+function mapStatus(state) {
+  switch (state) {
+    case "error":
+      return "error";
+    case "created":
+    case "starting":
+    case "running":
+      return "running";
+    case "exited":
+    default:
+      return "stopped";
+  }
+}
+function parseDate(value) {
+  if (typeof value === "number") return new Date(value * 1e3);
+  if (typeof value === "string") return new Date(value);
+  return /* @__PURE__ */ new Date();
+}
+function normalizeFileEntries(stdout) {
+  return stdout.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("total ")).flatMap((line) => {
+    const parts = line.split(/\s+/);
+    if (parts.length < 9) return [];
+    const name = parts.slice(8).join(" ");
+    if (name === "." || name === "..") return [];
+    return [
+      {
+        name,
+        type: parts[0]?.startsWith("d") ? "directory" : "file",
+        size: Number.parseInt(parts[4] ?? "0", 10) || 0,
+        modified: /* @__PURE__ */ new Date()
+      }
+    ];
+  });
+}
+async function pollOperation(config, operationId, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const operation = await requestJson(
+      config,
+      `/api/operations/${encodeURIComponent(operationId)}`
+    );
+    if (!operation) {
+      throw new Error(`Quilt operation ${operationId} disappeared while polling.`);
+    }
+    const status = operation.status ?? "";
+    if (status === "succeeded") return operation;
+    if (status === "failed" || status === "error" || status === "cancelled") {
+      throw new Error(
+        `Quilt operation ${operationId} failed: ${operation.error_message ?? operation.error ?? operation.message ?? status}`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, config.pollIntervalMs));
+  }
+  throw new Error(`Timed out waiting for Quilt operation ${operationId}.`);
+}
+function requireOperationId(envelope, context) {
+  const operationId = envelope?.operation_id;
+  if (!operationId) {
+    throw new Error(`Quilt ${context} did not return an operation_id.`);
+  }
+  return operationId;
+}
+async function getContainerById(config, sandboxId) {
+  return requestJson(
+    config,
+    `/api/containers/${encodeURIComponent(sandboxId)}`,
+    void 0,
+    { allow404: true }
+  );
+}
+function resolveSnapshotResultId(operation) {
+  if (operation.snapshot_id) return operation.snapshot_id;
+  if (operation.target_resource_type === "snapshot" && operation.target_resource_id) {
+    return operation.target_resource_id;
+  }
+  const result = operation.result ?? {};
+  const snapshotId = result["snapshot_id"];
+  return typeof snapshotId === "string" ? snapshotId : null;
+}
+function resolveContainerResultId(operation) {
+  if (operation.container_id) return operation.container_id;
+  if (operation.target_resource_type === "container" && operation.target_resource_id) {
+    return operation.target_resource_id;
+  }
+  const result = operation.result ?? {};
+  const directId = result["container_id"];
+  if (typeof directId === "string") return directId;
+  const results = result["results"];
+  if (Array.isArray(results) && results.length > 0) {
+    const first = results[0];
+    if (first && typeof first === "object" && typeof first.container_id === "string") {
+      return first.container_id;
+    }
+  }
+  return null;
+}
+async function createPublishedService(handle, port, protocol) {
+  const wantsWebSocket = protocol === "ws" || protocol === "wss";
+  const existing = await requestJson(
+    handle.config,
+    `/api/containers/${encodeURIComponent(handle.sandboxId)}/services`
+  );
+  const match = existing?.services?.find((service) => {
+    if (service.target_port !== port) return false;
+    if (wantsWebSocket && !service.enable_websockets) return false;
+    return true;
+  });
+  if (match) return match;
+  const created = await requestJson(
+    handle.config,
+    `/api/containers/${encodeURIComponent(handle.sandboxId)}/services`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name: `computesdk-${port}`,
+        target_port: port,
+        protocol: "http",
+        enable_websockets: wantsWebSocket,
+        auth_mode: handle.config.publishedServiceAuthMode,
+        ...handle.config.publishedServiceTtlSecs ? { ttl_secs: handle.config.publishedServiceTtlSecs } : {}
+      })
+    }
+  );
+  if (!created) {
+    throw new Error(`Failed to create Quilt published service for port ${port}.`);
+  }
+  return created;
+}
+var quilt = (0, import_provider.defineProvider)({
+  name: PROVIDER,
+  methods: {
+    sandbox: {
+      create: async (config, options) => {
+        const resolved = resolveConfig(config);
+        const {
+          timeout: requestedTimeout,
+          envs,
+          metadata,
+          templateId,
+          snapshotId,
+          name,
+          namespace: _namespace,
+          sandboxId: _sandboxId,
+          directory,
+          signal: _signal,
+          ...providerOptions
+        } = options || {};
+        if (snapshotId) {
+          const unsupportedKeys = ["envs", "templateId", "directory"];
+          if (envs || templateId || directory) {
+            throw new Error(
+              `Quilt snapshot clone does not support ${unsupportedKeys.join(", ")} create options in one request.`
+            );
+          }
+          const cloneEnvelope = await requestJson(
+            resolved,
+            `/api/snapshots/${encodeURIComponent(snapshotId)}/clone`,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify({
+                resume_policy: "immediate",
+                ...name ? { name } : {},
+                ...metadata ? { labels: stringifyRecord(metadata) } : {}
+              })
+            },
+            { includeTenantHeader: true }
+          );
+          const operation = await pollOperation(
+            resolved,
+            requireOperationId(cloneEnvelope, "snapshot clone"),
+            requestedTimeout ?? resolved.timeout
+          );
+          const containerId = resolveContainerResultId(operation);
+          if (!containerId) {
+            throw new Error(`Quilt snapshot clone completed without a container ID.`);
+          }
+          const container2 = await getContainerById(resolved, containerId);
+          if (!container2) {
+            throw new Error(`Quilt cloned container ${containerId} was not found after creation.`);
+          }
+          return {
+            sandbox: {
+              config: resolved,
+              sandboxId: containerId,
+              container: container2
+            },
+            sandboxId: containerId
+          };
+        }
+        const createBody = {
+          name: name ?? `computesdk-${crypto.randomUUID().slice(0, 8)}`,
+          image: typeof providerOptions.image === "string" ? providerOptions.image : typeof templateId === "string" ? templateId : resolved.image,
+          ...envs && Object.keys(envs).length > 0 ? { environment: envs } : {},
+          ...metadata ? { labels: stringifyRecord(metadata) } : {},
+          ...directory ? { working_directory: directory } : {},
+          ...providerOptions
+        };
+        const container = await requestJson(resolved, "/api/containers", {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(createBody)
+        });
+        if (!container?.container_id) {
+          throw new Error("Quilt container create did not return a container_id.");
+        }
+        return {
+          sandbox: {
+            config: resolved,
+            sandboxId: container.container_id,
+            container
+          },
+          sandboxId: container.container_id
+        };
+      },
+      getById: async (config, sandboxId) => {
+        const resolved = resolveConfig(config);
+        const container = await getContainerById(resolved, sandboxId);
+        if (!container) return null;
+        return {
+          sandbox: {
+            config: resolved,
+            sandboxId,
+            container
+          },
+          sandboxId
+        };
+      },
+      list: async (config) => {
+        const resolved = resolveConfig(config);
+        const sandboxes = [];
+        let cursor = void 0;
+        while (true) {
+          const query = new URLSearchParams();
+          if (cursor) query.set("cursor", cursor);
+          const response = await requestJson(resolved, `/api/containers${query.toString() ? `?${query.toString()}` : ""}`);
+          for (const container of response?.containers ?? []) {
+            if (!container.container_id) continue;
+            sandboxes.push({
+              sandbox: {
+                config: resolved,
+                sandboxId: container.container_id,
+                container
+              },
+              sandboxId: container.container_id
+            });
+          }
+          if (!response?.pagination?.has_next || !response.pagination.next_cursor) {
+            break;
+          }
+          cursor = response.pagination.next_cursor;
+        }
+        return sandboxes;
+      },
+      destroy: async (config, sandboxId) => {
+        const resolved = resolveConfig(config);
+        await requestNoContent(
+          resolved,
+          `/api/containers/${encodeURIComponent(sandboxId)}`,
+          { method: "DELETE" },
+          { allow404: true }
+        );
+      },
+      runCommand: async (handle, command, options) => {
+        const startTime = Date.now();
+        const fullCommand = buildExecCommand(command, options);
+        const response = await requestJson(handle.config, `/api/containers/${encodeURIComponent(handle.sandboxId)}/exec`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            command: ["/bin/sh", "-lc", fullCommand],
+            ...options?.cwd ? { workdir: options.cwd } : {},
+            ...options?.timeout ? { timeout_ms: options.timeout } : {}
+          })
+        });
+        const stdout = response?.stdout ?? "";
+        const stderr = response?.stderr ?? "";
+        if (options?.onStdout && stdout) options.onStdout(stdout);
+        if (options?.onStderr && stderr) options.onStderr(stderr);
+        return {
+          stdout,
+          stderr,
+          exitCode: response?.timed_out ? 124 : response?.exit_code ?? 0,
+          durationMs: Date.now() - startTime
+        };
+      },
+      getInfo: async (handle) => {
+        const container = await getContainerById(handle.config, handle.sandboxId) ?? handle.container;
+        return {
+          id: handle.sandboxId,
+          provider: PROVIDER,
+          status: mapStatus(container.state),
+          createdAt: parseDate(container.created_at),
+          timeout: handle.config.timeout,
+          metadata: {
+            name: container.name,
+            tenantId: container.tenant_id,
+            ipAddress: container.ip_address,
+            execReady: container.exec_ready,
+            networkReady: container.network_ready,
+            state: container.state
+          }
+        };
+      },
+      getUrl: async (handle, options) => {
+        const service = await createPublishedService(handle, options.port, options.protocol);
+        if (options.protocol === "ws" || options.protocol === "wss") {
+          const url2 = service.websocket_url;
+          if (!url2) {
+            throw new Error(`Quilt service ${service.service_id} does not expose a websocket URL.`);
+          }
+          if (options.protocol === "ws") {
+            const parsed = new URL(url2);
+            parsed.protocol = "ws:";
+            return parsed.toString();
+          }
+          return url2;
+        }
+        const url = service.public_url;
+        if (!url) {
+          throw new Error(`Quilt service ${service.service_id} did not return a public URL.`);
+        }
+        if (options.protocol === "http") {
+          const parsed = new URL(url);
+          parsed.protocol = "http:";
+          return parsed.toString();
+        }
+        return url;
+      },
+      filesystem: {
+        readFile: async (handle, path, runCommand) => {
+          const result = await runCommand(
+            handle,
+            `test -f "${(0, import_provider.escapeShellArg)(path)}" && base64 < "${(0, import_provider.escapeShellArg)(path)}" | tr -d '\\n'`
+          );
+          if (result.exitCode !== 0) {
+            throw new Error(`File not found or unreadable: ${path}`);
+          }
+          return Buffer.from(result.stdout, "base64").toString("utf8");
+        },
+        writeFile: async (handle, path, content, runCommand) => {
+          const parentDir = path.includes("/") ? path.slice(0, path.lastIndexOf("/")) || "/" : ".";
+          const encoded = Buffer.from(content).toString("base64");
+          const result = await runCommand(
+            handle,
+            `mkdir -p "${(0, import_provider.escapeShellArg)(parentDir)}" && echo "${encoded}" | base64 -d > "${(0, import_provider.escapeShellArg)(path)}"`
+          );
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to write file ${path}: ${result.stderr}`);
+          }
+        },
+        mkdir: async (handle, path, runCommand) => {
+          const result = await runCommand(handle, `mkdir -p "${(0, import_provider.escapeShellArg)(path)}"`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
+          }
+        },
+        readdir: async (handle, path, runCommand) => {
+          const result = await runCommand(handle, `ls -la "${(0, import_provider.escapeShellArg)(path)}"`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
+          }
+          return normalizeFileEntries(result.stdout);
+        },
+        exists: async (handle, path, runCommand) => {
+          const result = await runCommand(handle, `test -e "${(0, import_provider.escapeShellArg)(path)}"`);
+          return result.exitCode === 0;
+        },
+        remove: async (handle, path, runCommand) => {
+          const result = await runCommand(handle, `rm -rf "${(0, import_provider.escapeShellArg)(path)}"`);
+          if (result.exitCode !== 0) {
+            throw new Error(`Failed to remove ${path}: ${result.stderr}`);
+          }
+        }
+      },
+      getInstance: (handle) => handle
+    },
+    snapshot: {
+      create: async (config, sandboxId, options) => {
+        const resolved = resolveConfig(config);
+        const envelope = await requestJson(
+          resolved,
+          `/api/containers/${encodeURIComponent(sandboxId)}/snapshot`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              consistency_mode: "crash-consistent",
+              network_mode: "reset",
+              volume_mode: "exclude",
+              labels: {
+                ...options?.metadata ? stringifyRecord(options.metadata) : {},
+                ...options?.name ? { "computesdk:name": options.name } : {}
+              }
+            })
+          },
+          { includeTenantHeader: true }
+        );
+        const operation = await pollOperation(
+          resolved,
+          requireOperationId(envelope, "snapshot create"),
+          resolved.timeout
+        );
+        const snapshotId = resolveSnapshotResultId(operation);
+        if (!snapshotId) {
+          throw new Error(`Quilt snapshot create completed without a snapshot ID.`);
+        }
+        const snapshot = await requestJson(
+          resolved,
+          `/api/snapshots/${encodeURIComponent(snapshotId)}`,
+          void 0,
+          { includeTenantHeader: true }
+        );
+        if (!snapshot) {
+          throw new Error(`Quilt snapshot ${snapshotId} was not found after creation.`);
+        }
+        return mapSnapshot(snapshot);
+      },
+      list: async (config, options) => {
+        const resolved = resolveConfig(config);
+        const query = new URLSearchParams();
+        if (options?.sandboxId) {
+          query.set("container_id", options.sandboxId);
+        }
+        const response = await requestJson(
+          resolved,
+          `/api/snapshots${query.toString() ? `?${query.toString()}` : ""}`,
+          void 0,
+          { includeTenantHeader: true }
+        );
+        return (response?.snapshots ?? []).map(mapSnapshot);
+      },
+      delete: async (config, snapshotId) => {
+        const resolved = resolveConfig(config);
+        await requestNoContent(
+          resolved,
+          `/api/snapshots/${encodeURIComponent(snapshotId)}`,
+          { method: "DELETE" },
+          { includeTenantHeader: true, allow404: true }
+        );
+      }
+    }
+  }
+});
+function stringifyRecord(input) {
+  return Object.fromEntries(
+    Object.entries(input).map(([key, value]) => [key, typeof value === "string" ? value : JSON.stringify(value)])
+  );
+}
+function mapSnapshot(snapshot) {
+  return {
+    id: snapshot.snapshot_id,
+    provider: PROVIDER,
+    createdAt: parseDate(snapshot.created_at),
+    metadata: {
+      sourceContainerId: snapshot.source_container_id,
+      pinned: snapshot.pinned ?? false,
+      labels: snapshot.labels ?? {},
+      expiresAt: snapshot.expires_at ?? null
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  quilt
+});
+//# sourceMappingURL=index.js.map