@automaton-labs/aib 0.0.1

package/scripts/provision-runtime.cjs

@@ -0,0 +1,299 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const http = require("node:http");
+const https = require("node:https");
+const { spawnSync } = require("node:child_process");
+
+const packageRoot = path.resolve(__dirname, "..");
+const runtimesDir = path.join(packageRoot, "runtimes");
+const packageJson = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+const platformKey = `${process.platform}-${process.arch}`;
+
+const options = parseArgs(process.argv.slice(2));
+
+main().catch((error) => {
+  if (!options.quiet) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  }
+  process.exitCode = 1;
+});
+
+async function main() {
+  if (runtimeComplete()) {
+    if (!options.quiet) {
+      process.stdout.write(`runtime ready: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}\n`);
+    }
+    return;
+  }
+
+  const source = options.archive
+    ?? process.env.AIB_RUNTIME_ARCHIVE
+    ?? process.env.npm_config_aib_runtime_archive
+    ?? null;
+  const url = options.url
+    ?? process.env.AIB_RUNTIME_URL
+    ?? process.env.npm_config_aib_runtime_url
+    ?? null;
+  const manifestSource = options.manifest
+    ?? process.env.AIB_RUNTIME_MANIFEST
+    ?? process.env.npm_config_aib_runtime_manifest
+    ?? null;
+  const manifestUrl = options.manifestUrl
+    ?? process.env.AIB_RUNTIME_MANIFEST_URL
+    ?? process.env.npm_config_aib_runtime_manifest_url
+    ?? defaultManifestUrl();
+
+  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");
+    }
+    return;
+  }
+
+  const resolution = source || url
+    ? { archivePath: source ? path.resolve(source) : await downloadRuntimeArchive(url), 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);
+  }
+
+  fs.mkdirSync(runtimesDir, { recursive: true });
+  extractRuntimeArchive(archivePath);
+
+  if (!runtimeComplete()) {
+    throw new Error(`Runtime archive did not provision a complete runtime under ${runtimesDir}`);
+  }
+
+  if (!options.quiet) {
+    process.stdout.write(`runtime provisioned: ${path.relative(process.cwd(), runtimesDir) || runtimesDir}\n`);
+  }
+}
+
+function parseArgs(argv) {
+  const parsed = {
+    archive: null,
+    url: null,
+    manifest: null,
+    manifestUrl: null,
+    sha256: null,
+    quiet: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const current = argv[index];
+    const next = argv[index + 1];
+    if (current === "--archive" && next) {
+      parsed.archive = next;
+      index += 1;
+      continue;
+    }
+    if (current === "--url" && next) {
+      parsed.url = next;
+      index += 1;
+      continue;
+    }
+    if (current === "--manifest" && next) {
+      parsed.manifest = next;
+      index += 1;
+      continue;
+    }
+    if (current === "--manifest-url" && next) {
+      parsed.manifestUrl = next;
+      index += 1;
+      continue;
+    }
+    if (current === "--sha256" && next) {
+      parsed.sha256 = next;
+      index += 1;
+      continue;
+    }
+    if (current === "--quiet") {
+      parsed.quiet = true;
+      continue;
+    }
+    throw new Error(`Unknown argument: ${current}`);
+  }
+  return parsed;
+}
+
+async function resolveFromManifest(manifestSource, manifestUrl) {
+  const manifest = manifestSource
+    ? JSON.parse(fs.readFileSync(path.resolve(manifestSource), "utf8"))
+    : await downloadJson(manifestUrl);
+  const artifact = manifest?.artifacts?.[platformKey];
+  if (!artifact || typeof artifact !== "object") {
+    throw new Error(`Runtime manifest does not contain an artifact for ${platformKey}`);
+  }
+  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) {
+    throw new Error(`Runtime manifest artifact for ${platformKey} has no url or local file.`);
+  }
+  return {
+    archivePath,
+    expectedSha256: typeof artifact.sha256 === "string" ? artifact.sha256 : null
+  };
+}
+
+async function downloadJson(url) {
+  const filePath = await downloadRuntimeArchive(url);
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+function defaultManifestUrl() {
+  const version = packageJson.version;
+  if (!version) {
+    return null;
+  }
+  return `https://github.com/ratiomark/aib-runtime/releases/download/v${version}/aib-runtime-manifest.json`;
+}
+
+function runtimeComplete() {
+  return fs.existsSync(path.join(runtimesDir, "code-server", "node_modules", "code-server", "out", "node", "entry.js"))
+    && Boolean(findPackagedBrowserRuntime())
+    && Boolean(findPackagedNodeRuntime());
+}
+
+function findPackagedNodeRuntime() {
+  const platformDir = nodeRuntimePlatformDir();
+  if (!platformDir) {
+    return null;
+  }
+  const candidate = process.platform === "win32"
+    ? path.join(runtimesDir, "node", platformDir, "node.exe")
+    : path.join(runtimesDir, "node", platformDir, "bin", "node");
+  return fs.existsSync(candidate) ? candidate : null;
+}
+
+function nodeRuntimePlatformDir() {
+  if (process.platform === "win32" && process.arch === "x64") {
+    return "win-x64";
+  }
+  if (process.platform === "linux" && process.arch === "x64") {
+    return "linux-x64";
+  }
+  if (process.platform === "linux" && process.arch === "arm64") {
+    return "linux-arm64";
+  }
+  if (process.platform === "darwin" && process.arch === "x64") {
+    return "darwin-x64";
+  }
+  if (process.platform === "darwin" && process.arch === "arm64") {
+    return "darwin-arm64";
+  }
+  return null;
+}
+
+function findPackagedBrowserRuntime() {
+  const roots = [
+    path.join(runtimesDir, "browser"),
+    path.join(runtimesDir, "chrome"),
+    path.join(runtimesDir, "chromium")
+  ];
+  const executableNames = process.platform === "win32"
+    ? new Set(["chrome.exe", "chromium.exe", "msedge.exe"])
+    : new Set(["chrome", "chromium"]);
+  for (const root of roots) {
+    const found = findFirstExecutable(root, executableNames, 5);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function findFirstExecutable(root, executableNames, maxDepth) {
+  if (!fs.existsSync(root) || maxDepth < 0) {
+    return null;
+  }
+  let entries;
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  for (const entry of entries) {
+    const entryPath = path.join(root, entry.name);
+    if (entry.isFile() && executableNames.has(entry.name)) {
+      return entryPath;
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const found = findFirstExecutable(path.join(root, entry.name), executableNames, maxDepth - 1);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+
+function extractRuntimeArchive(archivePath) {
+  const result = spawnSync("tar", ["-xzf", archivePath, "-C", packageRoot], {
+    cwd: packageRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+    timeout: 600_000
+  });
+  if (result.status !== 0) {
+    throw new Error(`Failed to extract runtime archive: ${result.stderr || result.stdout || result.error?.message || `status ${result.status}`}`);
+  }
+}
+
+function assertSha256(filePath, expectedSha256) {
+  const hash = crypto.createHash("sha256");
+  hash.update(fs.readFileSync(filePath));
+  const actual = hash.digest("hex");
+  if (actual.toLowerCase() !== String(expectedSha256).toLowerCase()) {
+    throw new Error(`Runtime archive checksum mismatch: expected ${expectedSha256}, got ${actual}`);
+  }
+}
+
+function downloadRuntimeArchive(url) {
+  return new Promise((resolve, reject) => {
+    if (!url) {
+      reject(new Error("Runtime URL is empty."));
+      return;
+    }
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "aib-runtime-"));
+    const targetPath = path.join(tempDir, path.basename(new URL(url).pathname) || "runtime.tgz");
+    const file = fs.createWriteStream(targetPath);
+    const client = url.startsWith("https:") ? https : http;
+    const request = client.get(url, (response) => {
+      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);
+        return;
+      }
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.rmSync(targetPath, { force: true });
+        reject(new Error(`Runtime download failed with HTTP ${response.statusCode}: ${url}`));
+        return;
+      }
+      response.pipe(file);
+      file.on("finish", () => {
+        file.close(() => resolve(targetPath));
+      });
+    });
+    request.on("error", (error) => {
+      file.close();
+      fs.rmSync(targetPath, { force: true });
+      reject(error);
+    });
+  });
+}