@enclave-run/sdk 0.0.0-dev.5 → 0.1.0

package/dist/index.mjs

@@ -60,7 +60,7 @@ import createClient from "openapi-fetch";
 import platform2 from "platform";
 
 // package.json
-var version = "0.0.0-dev.5";
+var version = "0.1.0";
 
 // src/utils.ts
 import platform from "platform";
@@ -102,12 +102,6 @@ async function sha256(data) {
 function timeoutToSeconds(timeout) {
   return Math.ceil(timeout / 1e3);
 }
-async function dynamicImport(module) {
-  if (runtime === "browser") {
-    throw new Error("Browser runtime is not supported for dynamic import");
-  }
-  return await import(module);
-}
 function ansiRegex({ onlyFirst = false } = {}) {
   const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
   const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
@@ -172,6 +166,13 @@ var OutcomeUnknownError = class extends SandboxError {
     this.cause = cause;
   }
 };
+var SandboxCreateFailedError = class extends SandboxError {
+  constructor(message, recovery) {
+    super(message);
+    this.name = "SandboxCreateFailedError";
+    this.recovery = recovery;
+  }
+};
 var SandboxCreateRejectedError = class extends SandboxError {
   constructor(message, recovery, reason, spilloverAllowed = false, capacityTier = "shared") {
     super(message);
@@ -286,11 +287,11 @@ function formatLog(log) {
   return JSON.parse(JSON.stringify(log));
 }
 function createRpcLogger(logger) {
-  function logEach(stream) {
+  function logEach(stream2) {
     return __asyncGenerator(this, null, function* () {
       var _a3;
       try {
-        for (var iter = __forAwait(stream), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
+        for (var iter = __forAwait(stream2), more, temp, error; more = !(temp = yield new __await(iter.next())).done; more = false) {
           const m = temp.value;
           (_a3 = logger.debug) == null ? void 0 : _a3.call(logger, "Response stream:", formatLog(m));
           yield m;
@@ -3529,8 +3530,9 @@ var SandboxApi = class {
         return operation.sandbox;
       }
       if (operation.state === "failed") {
-        throw new SandboxError(
-          (_b = (_a3 = operation.error) == null ? void 0 : _a3.message) != null ? _b : "Sandbox create failed after admission"
+        throw new SandboxCreateFailedError(
+          (_b = (_a3 = operation.error) == null ? void 0 : _a3.message) != null ? _b : "Sandbox create failed after admission",
+          recovery
         );
       }
       await new Promise((resolve) => setTimeout(resolve, 25));
@@ -4424,6 +4426,10 @@ var SandboxRegionScope = class {
   }
 };
 
+// src/template/buildApi.ts
+import fs2 from "fs";
+import stream from "stream";
+
 // src/template/logger.ts
 import chalk from "chalk";
 var LogEntry = class {
@@ -4545,16 +4551,30 @@ function defaultBuildLogger(options) {
 // src/template/utils.ts
 import crypto2 from "crypto";
 import fs from "fs";
+import os from "os";
 import path from "path";
 import url from "url";
 
 // src/template/consts.ts
 var FINALIZE_STEP_NAME = "finalize";
+var FILE_UPLOAD_TIMEOUT_MS = 36e5;
 var BASE_STEP_NAME = "base";
 var STACK_TRACE_DEPTH = 3;
 var RESOLVE_SYMLINKS = false;
 
 // src/template/utils.ts
+async function loadGlob() {
+  if (runtime === "browser") {
+    throw new Error("Browser runtime is not supported for local file copies");
+  }
+  return await import("glob");
+}
+async function loadTar() {
+  if (runtime === "browser") {
+    throw new Error("Browser runtime is not supported for local file copies");
+  }
+  return await import("tar");
+}
 function validateRelativePath(src, stackTrace) {
   if (path.isAbsolute(src)) {
     const error = new TemplateError(
@@ -4585,7 +4605,7 @@ function normalizePath(path2) {
   return path2.replace(/\\/g, "/");
 }
 async function getAllFilesInPath(src, contextPath, ignorePatterns, includeDirectories = true) {
-  const { glob } = await dynamicImport("glob");
+  const { glob } = await loadGlob();
   const files = /* @__PURE__ */ new Map();
   const globFiles = await glob(src, {
     ignore: ignorePatterns,
@@ -4701,32 +4721,48 @@ function getCallerDirectory(depth) {
 function padOctal(mode) {
   return mode.toString(8).padStart(4, "0");
 }
-async function tarFileStream(fileName, fileContextPath, ignorePatterns, resolveSymlinks) {
-  const { create } = await dynamicImport("tar");
+async function getTarArchiveInputs(fileName, fileContextPath, ignorePatterns) {
+  const { create } = await loadTar();
   const allFiles = await getAllFilesInPath(
     fileName,
     fileContextPath,
     ignorePatterns,
     true
   );
-  const filePaths = allFiles.map((file) => file.relativePosix());
-  return create(
-    {
-      gzip: true,
-      cwd: fileContextPath,
-      follow: resolveSymlinks,
-      noDirRecurse: true
-    },
-    filePaths
-  );
+  return {
+    create,
+    filePaths: allFiles.map((file) => file.relativePosix())
+  };
 }
-async function tarFileStreamUpload(fileName, fileContextPath, ignorePatterns, resolveSymlinks) {
-  return tarFileStream(
+async function spoolTarArchive(fileName, fileContextPath, ignorePatterns, resolveSymlinks) {
+  const { create, filePaths } = await getTarArchiveInputs(
     fileName,
     fileContextPath,
-    ignorePatterns,
-    resolveSymlinks
+    ignorePatterns
   );
+  const tmpDir = await fs.promises.mkdtemp(
+    path.join(os.tmpdir(), "enclave-template-")
+  );
+  const tarPath = path.join(tmpDir, "context.tar.gz");
+  const cleanup = () => fs.promises.rm(tmpDir, { recursive: true, force: true }).catch(() => {
+  });
+  try {
+    await create(
+      {
+        gzip: true,
+        cwd: fileContextPath,
+        follow: resolveSymlinks,
+        noDirRecurse: true,
+        file: tarPath
+      },
+      filePaths
+    );
+    const { size } = await fs.promises.stat(tarPath);
+    return { path: tarPath, size, cleanup };
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
 }
 function getBuildStepIndex(step, stackTracesLength) {
   if (step === BASE_STEP_NAME) {
@@ -4786,22 +4822,34 @@ async function getFileUploadLink(client, { templateID, filesHash }, stackTrace)
 }
 async function uploadFile(options, stackTrace) {
   const { fileName, url: url2, fileContextPath, ignorePatterns, resolveSymlinks } = options;
+  let cleanup;
+  let bodyStream;
   try {
-    const uploadStream = await tarFileStreamUpload(
+    const archive = await spoolTarArchive(
       fileName,
       fileContextPath,
       ignorePatterns,
       resolveSymlinks
     );
+    cleanup = archive.cleanup;
+    bodyStream = fs2.createReadStream(archive.path);
     const res = await fetch(url2, {
       method: "PUT",
-      // @ts-expect-error
-      body: uploadStream,
+      body: stream.Readable.toWeb(bodyStream),
+      headers: {
+        "Content-Length": archive.size.toString()
+      },
+      signal: AbortSignal.timeout(FILE_UPLOAD_TIMEOUT_MS),
+      // Node fetch requires duplex for a streaming request body, but the DOM
+      // RequestInit type does not expose it.
+      // @ts-expect-error Node fetch extension
       duplex: "half"
     });
     if (!res.ok) {
+      const responseDetails = (await res.text().catch(() => "")).slice(0, 4096);
+      const status = `${res.status} ${res.statusText}`.trim();
       throw new FileUploadError(
-        `Failed to upload file: ${res.statusText}`,
+        `Failed to upload file: ${status}${responseDetails ? ` - ${responseDetails}` : ""}`,
         stackTrace
       );
     }
@@ -4810,6 +4858,14 @@ async function uploadFile(options, stackTrace) {
       throw error;
     }
     throw new FileUploadError(`Failed to upload file: ${error}`, stackTrace);
+  } finally {
+    if (bodyStream && !bodyStream.closed) {
+      await new Promise((resolve) => {
+        bodyStream == null ? void 0 : bodyStream.once("close", resolve);
+        bodyStream == null ? void 0 : bodyStream.destroy();
+      });
+    }
+    await (cleanup == null ? void 0 : cleanup());
   }
 }
 async function triggerBuild(client, { templateID, buildID, template }) {
@@ -4998,7 +5054,7 @@ async function getTemplateTags(client, { templateID }) {
 import {
   DockerfileParser
 } from "dockerfile-ast";
-import fs2 from "fs";
+import fs3 from "fs";
 
 // src/template/readycmd.ts
 var ReadyCmd = class {
@@ -5035,8 +5091,8 @@ function waitForTimeout(timeout) {
 function parseDockerfile(dockerfileContentOrPath, templateBuilder) {
   let dockerfileContent;
   try {
-    if (fs2.existsSync(dockerfileContentOrPath) && fs2.statSync(dockerfileContentOrPath).isFile()) {
-      dockerfileContent = fs2.readFileSync(dockerfileContentOrPath, "utf-8");
+    if (fs3.existsSync(dockerfileContentOrPath) && fs3.statSync(dockerfileContentOrPath).isFile()) {
+      dockerfileContent = fs3.readFileSync(dockerfileContentOrPath, "utf-8");
     } else {
       dockerfileContent = dockerfileContentOrPath;
     }
@@ -6402,6 +6458,7 @@ export {
   ReadyCmd,
   RegionCapacityError,
   Sandbox,
+  SandboxCreateFailedError,
   SandboxCreateRejectedError,
   SandboxError,
   SandboxRegionScope,