@automaton-labs/aib 0.0.2 → 0.0.3

package/dist/help/help-meta.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": 1,
   "helpVersion": "0.1.0",
-  "generatedAt": "2026-05-25T01:01:46+03:00",
-  "sourceCommit": "51c652c",
+  "generatedAt": "2026-05-25T01:16:44+03:00",
+  "sourceCommit": "682a840",
   "contentHash": "sha256:fa654cee3287525d7a9dce2fd8d4fa159138898ee4b7c8ebf6fed43bde58074a",
   "topics": {
     "help-format": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@automaton-labs/aib",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "CLI for discovering and calling the local aib IDE extension runtime.",
   "publishConfig": {
     "access": "public"

package/scripts/postinstall.cjs

@@ -6,14 +6,15 @@ const { spawnSync } = require("node:child_process");
 const packageRoot = path.resolve(__dirname, "..");
 
 runBestEffort(path.join(__dirname, "install-windows-launcher.cjs"));
-runBestEffort(path.join(__dirname, "provision-runtime.cjs"), ["--quiet"]);
+runBestEffort(path.join(__dirname, "provision-runtime.cjs"), [], { inheritOutput: process.env.AIB_POSTINSTALL_QUIET !== "1" });
 
-function runBestEffort(scriptPath, args = []) {
+function runBestEffort(scriptPath, args = [], options = {}) {
+  const inheritOutput = options.inheritOutput === true;
   const result = spawnSync(process.execPath, [scriptPath, ...args], {
     cwd: packageRoot,
     env: process.env,
     encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
+    stdio: inheritOutput ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "pipe"],
     windowsHide: true
   });
 
@@ -22,7 +23,7 @@ function runBestEffort(scriptPath, args = []) {
   }
 
   if (process.env.AIB_POSTINSTALL_STRICT === "1") {
-    process.stderr.write(result.stderr || result.stdout || `postinstall helper failed: ${scriptPath}\n`);
+    process.stderr.write(result?.stderr || result?.stdout || `postinstall helper failed: ${scriptPath}\n`);
     process.exit(result.status ?? 1);
   }
 }

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) {
@@ -25,7 +26,7 @@ main().catch((error) => {
 async function main() {
   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,23 +50,26 @@ 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 }
+    ? { archivePath: source ? path.resolve(source) : 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);
   }
 
   fs.mkdirSync(runtimesDir, { recursive: true });
+  reporter.info("aib runtime: extracting archive");
   extractRuntimeArchive(archivePath);
 
   if (!runtimeComplete()) {
@@ -73,7 +77,7 @@ async function main() {
   }
 
   if (!options.quiet) {
-    process.stdout.write(`runtime provisioned: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}\n`);
+    reporter.info(`aib runtime provisioned: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}`);
   }
 }
 
@@ -124,6 +128,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);
@@ -146,7 +151,7 @@ async function resolveFromManifest(manifestSource, manifestUrl) {
 }
 
 async function downloadJson(url) {
-  const filePath = await downloadRuntimeArchive(url);
+  const filePath = await downloadRuntimeArchive(url, "runtime manifest");
   return JSON.parse(fs.readFileSync(filePath, "utf8"));
 }
 
@@ -262,7 +267,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,7 +281,7 @@ 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);
+        downloadRuntimeArchive(new URL(response.headers.location, url).toString(), label).then(resolve, reject);
         return;
       }
       if (response.statusCode !== 200) {
@@ -285,9 +290,15 @@ function downloadRuntimeArchive(url) {
         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(targetPath);
+        });
       });
     });
     request.on("error", (error) => {
@@ -297,3 +308,70 @@ function downloadRuntimeArchive(url) {
     });
   });
 }
+
+function createReporter(enabled) {
+  const stream = process.stderr;
+  const useCarriageReturn = Boolean(stream.isTTY);
+  return {
+    info(message) {
+      if (!enabled) {
+        return;
+      }
+      stream.write(`${message}\n`);
+    },
+    startProgress(label, totalBytes) {
+      if (!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) {
+          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`);
+      };
+      write(true);
+      return {
+        add(byteCount) {
+          downloadedBytes += byteCount;
+          write(false);
+        },
+        done() {
+          if (ended) {
+            return;
+          }
+          ended = true;
+          write(true);
+          stream.write(useCarriageReturn ? "\n" : "");
+        }
+      };
+    }
+  };
+}
+
+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]}`;
+}