@automaton-labs/aib 0.0.2 → 0.0.4

package/scripts/provision-runtime.cjs

@@ -14,6 +14,7 @@ const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.j
 const platformKey = `${process.platform}-${process.arch}`;
 
 const options = parseArgs(process.argv.slice(2));
+const reporter = createReporter(!options.quiet);
 
 main().catch((error) => {
   if (!options.quiet) {
@@ -23,9 +24,11 @@ main().catch((error) => {
 });
 
 async function main() {
+  cleanupOldTempDownloads();
+
   if (runtimeComplete()) {
     if (!options.quiet) {
-      process.stdout.write(`runtime ready: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}\n`);
+      reporter.info(`aib runtime ready: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}`);
     }
     return;
   }
@@ -49,31 +52,38 @@ async function main() {
 
   if (!source && !url && !manifestSource && !manifestUrl) {
     if (!options.quiet) {
-      process.stdout.write("runtime not provisioned: set AIB_RUNTIME_ARCHIVE, AIB_RUNTIME_URL, AIB_RUNTIME_MANIFEST, or AIB_RUNTIME_MANIFEST_URL\n");
+      reporter.info("aib runtime not provisioned: set AIB_RUNTIME_ARCHIVE, AIB_RUNTIME_URL, AIB_RUNTIME_MANIFEST, or AIB_RUNTIME_MANIFEST_URL");
     }
     return;
   }
 
+  reporter.info(`aib runtime: provisioning ${platformKey}`);
   const resolution = source || url
-    ? { archivePath: source ? path.resolve(source) : await downloadRuntimeArchive(url), expectedSha256: options.sha256 ?? process.env.AIB_RUNTIME_SHA256 ?? null }
+    ? { ...(source ? { archivePath: path.resolve(source), tempDir: null } : await downloadRuntimeArchive(url, "runtime archive")), expectedSha256: options.sha256 ?? process.env.AIB_RUNTIME_SHA256 ?? null }
     : await resolveFromManifest(manifestSource, manifestUrl);
   const archivePath = resolution.archivePath;
-  if (!fs.existsSync(archivePath)) {
-    throw new Error(`Runtime archive not found: ${archivePath}`);
-  }
-  if (resolution.expectedSha256) {
-    assertSha256(archivePath, resolution.expectedSha256);
-  }
+  try {
+    if (!fs.existsSync(archivePath)) {
+      throw new Error(`Runtime archive not found: ${archivePath}`);
+    }
+    if (resolution.expectedSha256) {
+      reporter.info("aib runtime: verifying checksum");
+      assertSha256(archivePath, resolution.expectedSha256);
+    }
 
-  fs.mkdirSync(runtimesDir, { recursive: true });
-  extractRuntimeArchive(archivePath);
+    fs.mkdirSync(runtimesDir, { recursive: true });
+    reporter.info("aib runtime: extracting archive");
+    extractRuntimeArchive(archivePath);
 
-  if (!runtimeComplete()) {
-    throw new Error(`Runtime archive did not provision a complete runtime under ${runtimesDir}`);
+    if (!runtimeComplete()) {
+      throw new Error(`Runtime archive did not provision a complete runtime under ${runtimesDir}`);
+    }
+  } finally {
+    cleanupOwnedTempDownload(resolution.tempDir);
   }
 
   if (!options.quiet) {
-    process.stdout.write(`runtime provisioned: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}\n`);
+    reporter.info("aib runtime: ready");
   }
 }
 
@@ -124,6 +134,7 @@ function parseArgs(argv) {
 }
 
 async function resolveFromManifest(manifestSource, manifestUrl) {
+  reporter.info("aib runtime: resolving manifest");
   const manifest = manifestSource
     ? JSON.parse(fs.readFileSync(path.resolve(manifestSource), "utf8"))
     : await downloadJson(manifestUrl);
@@ -133,21 +144,72 @@ async function resolveFromManifest(manifestSource, manifestUrl) {
   }
   const archivePath = artifact.file && manifestSource
     ? path.resolve(path.dirname(path.resolve(manifestSource)), String(artifact.file))
-    : artifact.url
-      ? await downloadRuntimeArchive(String(artifact.url))
-      : null;
-  if (!archivePath) {
+    : null;
+  const downloaded = !archivePath && artifact.url
+    ? await downloadRuntimeArchive(String(artifact.url))
+    : null;
+  const resolvedArchivePath = archivePath ?? downloaded?.archivePath ?? null;
+  const tempDir = downloaded?.tempDir ?? null;
+  if (!resolvedArchivePath) {
     throw new Error(`Runtime manifest artifact for ${platformKey} has no url or local file.`);
   }
   return {
-    archivePath,
+    archivePath: resolvedArchivePath,
+    tempDir,
     expectedSha256: typeof artifact.sha256 === "string" ? artifact.sha256 : null
   };
 }
 
 async function downloadJson(url) {
-  const filePath = await downloadRuntimeArchive(url);
-  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  const download = await downloadRuntimeArchive(url, "runtime manifest");
+  try {
+    return JSON.parse(fs.readFileSync(download.archivePath, "utf8"));
+  } finally {
+    cleanupOwnedTempDownload(download.tempDir);
+  }
+}
+
+function cleanupOldTempDownloads() {
+  const cutoffMs = Date.now() - 24 * 60 * 60 * 1000;
+  let entries = [];
+  try {
+    entries = fs.readdirSync(os.tmpdir(), { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory() || !entry.name.startsWith("aib-runtime-")) {
+      continue;
+    }
+    const tempDir = path.join(os.tmpdir(), entry.name);
+    try {
+      const stat = fs.statSync(tempDir);
+      if (stat.mtimeMs < cutoffMs) {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      }
+    } catch {
+      // Best-effort cleanup only.
+    }
+  }
+}
+
+function cleanupOwnedTempDownload(tempDir) {
+  if (!tempDir) {
+    return;
+  }
+  try {
+    const resolvedTemp = path.resolve(tempDir);
+    const resolvedOsTemp = path.resolve(os.tmpdir());
+    const relative = path.relative(resolvedOsTemp, resolvedTemp);
+    if (path.basename(resolvedTemp).startsWith("aib-runtime-")
+      && relative
+      && !relative.startsWith("..")
+      && !path.isAbsolute(relative)) {
+      fs.rmSync(resolvedTemp, { recursive: true, force: true });
+    }
+  } catch {
+    // Best-effort cleanup only.
+  }
 }
 
 function defaultManifestUrl() {
@@ -262,7 +324,7 @@ function assertSha256(filePath, expectedSha256) {
   }
 }
 
-function downloadRuntimeArchive(url) {
+function downloadRuntimeArchive(url, label = "runtime archive") {
   return new Promise((resolve, reject) => {
     if (!url) {
       reject(new Error("Runtime URL is empty."));
@@ -276,24 +338,98 @@ function downloadRuntimeArchive(url) {
       if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
         file.close();
         fs.rmSync(targetPath, { force: true });
-        downloadRuntimeArchive(new URL(response.headers.location, url).toString()).then(resolve, reject);
+        cleanupOwnedTempDownload(tempDir);
+        downloadRuntimeArchive(new URL(response.headers.location, url).toString(), label).then(resolve, reject);
         return;
       }
       if (response.statusCode !== 200) {
         file.close();
         fs.rmSync(targetPath, { force: true });
+        cleanupOwnedTempDownload(tempDir);
         reject(new Error(`Runtime download failed with HTTP ${response.statusCode}: ${url}`));
         return;
       }
+      const totalBytes = Number.parseInt(String(response.headers["content-length"] ?? ""), 10);
+      const progress = reporter.startProgress(`aib runtime: downloading ${label}`, Number.isFinite(totalBytes) ? totalBytes : null);
+      response.on("data", (chunk) => progress.add(chunk.length));
       response.pipe(file);
       file.on("finish", () => {
-        file.close(() => resolve(targetPath));
+        file.close(() => {
+          progress.done();
+          resolve({ archivePath: targetPath, tempDir });
+        });
       });
     });
     request.on("error", (error) => {
       file.close();
       fs.rmSync(targetPath, { force: true });
+      cleanupOwnedTempDownload(tempDir);
       reject(error);
     });
   });
 }
+
+function createReporter(enabled) {
+  const stream = process.stderr;
+  return {
+    info(message) {
+      if (!enabled) {
+        return;
+      }
+      stream.write(`${message}\n`);
+    },
+    startProgress(label, totalBytes) {
+      if (!enabled) {
+        return { add() {}, done() {} };
+      }
+      let downloadedBytes = 0;
+      let ended = false;
+      let nextPercent = 10;
+      const totalKnown = Number.isFinite(totalBytes) && totalBytes > 0;
+      const showPercentProgress = totalKnown && totalBytes >= 1024 * 1024;
+      stream.write(totalKnown
+        ? `${label} ${formatBytes(totalBytes)}\n`
+        : `${label}\n`);
+      const writeProgress = () => {
+        if (!showPercentProgress) {
+          return;
+        }
+        const percent = Math.floor(Math.min(100, (downloadedBytes / totalBytes) * 100));
+        while (percent >= nextPercent && nextPercent <= 100) {
+          const thresholdBytes = Math.min(totalBytes, Math.round((totalBytes * nextPercent) / 100));
+          stream.write(`aib runtime: ${nextPercent}% ${formatBytes(thresholdBytes)} / ${formatBytes(totalBytes)}\n`);
+          nextPercent += 10;
+        }
+      };
+      return {
+        add(byteCount) {
+          downloadedBytes += byteCount;
+          writeProgress();
+        },
+        done() {
+          if (ended) {
+            return;
+          }
+          ended = true;
+          downloadedBytes = Math.max(downloadedBytes, totalBytes ?? downloadedBytes);
+          writeProgress();
+        }
+      };
+    }
+  };
+}
+
+function formatBytes(bytes) {
+  if (!Number.isFinite(bytes) || bytes < 0) {
+    return "0 B";
+  }
+  const units = ["B", "KB", "MB", "GB"];
+  let value = bytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < units.length - 1) {
+    value /= 1024;
+    unitIndex += 1;
+  }
+  const digits = value >= 100 || unitIndex === 0 ? 0 : value >= 10 ? 1 : 2;
+  return `${value.toFixed(digits)} ${units[unitIndex]}`;
+}