@automaton-labs/aib 0.0.3 → 0.0.5

package/scripts/provision-runtime.cjs

@@ -24,6 +24,8 @@ main().catch((error) => {
 });
 
 async function main() {
+  cleanupOldTempDownloads();
+
   if (runtimeComplete()) {
     if (!options.quiet) {
       reporter.info(`aib runtime ready: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}`);
@@ -57,27 +59,31 @@ async function main() {
 
   reporter.info(`aib runtime: provisioning ${platformKey}`);
   const resolution = source || url
-    ? { archivePath: source ? path.resolve(source) : await downloadRuntimeArchive(url, "runtime archive"), 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) {
-    reporter.info("aib runtime: verifying checksum");
-    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 });
-  reporter.info("aib runtime: extracting archive");
-  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) {
-    reporter.info(`aib runtime provisioned: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}`);
+    reporter.info("aib runtime: ready");
   }
 }
 
@@ -138,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, "runtime manifest");
-  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() {
@@ -281,12 +338,14 @@ function downloadRuntimeArchive(url, label = "runtime archive") {
       if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
         file.close();
         fs.rmSync(targetPath, { force: true });
+        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;
       }
@@ -297,13 +356,14 @@ function downloadRuntimeArchive(url, label = "runtime archive") {
       file.on("finish", () => {
         file.close(() => {
           progress.done();
-          resolve(targetPath);
+          resolve({ archivePath: targetPath, tempDir });
         });
       });
     });
     request.on("error", (error) => {
       file.close();
       fs.rmSync(targetPath, { force: true });
+      cleanupOwnedTempDownload(tempDir);
       reject(error);
     });
   });
@@ -311,7 +371,6 @@ function downloadRuntimeArchive(url, label = "runtime archive") {
 
 function createReporter(enabled) {
   const stream = process.stderr;
-  const useCarriageReturn = Boolean(stream.isTTY);
   return {
     info(message) {
       if (!enabled) {
@@ -324,37 +383,36 @@ function createReporter(enabled) {
         return { add() {}, done() {} };
       }
       let downloadedBytes = 0;
-      let lastWriteMs = 0;
       let ended = false;
-      const startedMs = Date.now();
-      const minIntervalMs = useCarriageReturn ? 750 : 5000;
-      const write = (force = false) => {
-        const now = Date.now();
-        if (!force && now - lastWriteMs < minIntervalMs) {
+      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;
         }
-        lastWriteMs = now;
-        const percent = totalBytes ? Math.min(100, (downloadedBytes / totalBytes) * 100) : null;
-        const elapsedSeconds = Math.max(0.001, (now - startedMs) / 1000);
-        const rateBytes = downloadedBytes / elapsedSeconds;
-        const text = percent === null
-          ? `${label}: ${formatBytes(downloadedBytes)} downloaded (${formatBytes(rateBytes)}/s)`
-          : `${label}: ${percent.toFixed(1)}% ${formatBytes(downloadedBytes)} / ${formatBytes(totalBytes)} (${formatBytes(rateBytes)}/s)`;
-        stream.write(useCarriageReturn ? `\r${text}` : `${text}\n`);
+        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;
+        }
       };
-      write(true);
       return {
         add(byteCount) {
           downloadedBytes += byteCount;
-          write(false);
+          writeProgress();
         },
         done() {
           if (ended) {
             return;
           }
           ended = true;
-          write(true);
-          stream.write(useCarriageReturn ? "\n" : "");
+          downloadedBytes = Math.max(downloadedBytes, totalBytes ?? downloadedBytes);
+          writeProgress();
         }
       };
     }