@metorial/cli-core 0.0.0-dev.6

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+type OutputTransform = (value: string) => string;
+type RunCLIOptions = {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    version?: string;
+    stdoutTransform?: OutputTransform;
+    stderrTransform?: OutputTransform;
+};
+declare function resolveCLIPath(version?: string): Promise<string>;
+declare function runCLI(args: string[], options?: RunCLIOptions): Promise<number>;
+declare function runCLIAndExit(args: string[], options?: RunCLIOptions): Promise<void>;
+declare function replaceOutput(searchValue: string, replaceValue: string): OutputTransform;
+declare function npmInstallEnvironment(packageName: string): NodeJS.ProcessEnv;
+
+export { type OutputTransform, type RunCLIOptions, npmInstallEnvironment, replaceOutput, resolveCLIPath, runCLI, runCLIAndExit };

package/dist/index.js

@@ -0,0 +1,314 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  npmInstallEnvironment: () => npmInstallEnvironment,
+  replaceOutput: () => replaceOutput,
+  resolveCLIPath: () => resolveCLIPath,
+  runCLI: () => runCLI,
+  runCLIAndExit: () => runCLIAndExit
+});
+module.exports = __toCommonJS(index_exports);
+var import_extract_zip = __toESM(require("extract-zip"));
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_os = __toESM(require("os"));
+var import_node_path = __toESM(require("path"));
+var tar = __toESM(require("tar"));
+
+// package.json
+var package_default = {
+  name: "@metorial/cli-core",
+  version: "0.0.0-dev.6",
+  description: "Runtime helpers for downloading and invoking the Metorial CLI",
+  license: "MIT",
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  files: [
+    "dist"
+  ],
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "tsup --config tsup.config.ts"
+  },
+  dependencies: {
+    "extract-zip": "^2.0.1",
+    tar: "^7.4.3"
+  }
+};
+
+// src/index.ts
+var DEFAULT_BASE_URL = "https://cli.metorial.com";
+async function resolveCLIPath(version) {
+  let tag = normalizeVersion(
+    version || process.env.METORIAL_CLI_VERSION || package_default.version
+  );
+  let spec = getPlatformSpec(tag);
+  let installDir = import_node_path.default.join(getCacheRoot(), "versions", tag);
+  let binaryPath = import_node_path.default.join(installDir, spec.binaryName);
+  if (await exists(binaryPath)) {
+    return binaryPath;
+  }
+  await downloadAndInstall({ tag, spec, installDir, binaryPath });
+  return binaryPath;
+}
+async function runCLI(args, options = {}) {
+  let binaryPath = await resolveCLIPath(options.version);
+  if (!options.stdoutTransform && !options.stderrTransform) {
+    return await spawnWithInheritedOutput(binaryPath, args, options);
+  }
+  return await spawnWithBufferedOutput(binaryPath, args, options);
+}
+async function runCLIAndExit(args, options = {}) {
+  let exitCode = await runCLI(args, options);
+  process.exit(exitCode);
+}
+function replaceOutput(searchValue, replaceValue) {
+  return (value) => value.replaceAll(searchValue, replaceValue);
+}
+function npmInstallEnvironment(packageName) {
+  return {
+    METORIAL_INSTALL_METHOD: "npm",
+    METORIAL_INSTALL_PM: detectNodePackageManager(__filename),
+    METORIAL_INSTALL_PACKAGE: packageName
+  };
+}
+async function downloadAndInstall(input) {
+  let tempDir = await makeTempDir(import_node_path.default.join(getCacheRoot(), "tmp"));
+  let archivePath = import_node_path.default.join(tempDir, input.spec.archiveName);
+  let checksumsPath = import_node_path.default.join(tempDir, "checksums.txt");
+  let extractDir = import_node_path.default.join(tempDir, "extract");
+  let baseUrl = `${(process.env.METORIAL_CLI_BASE_URL || DEFAULT_BASE_URL).replace(/\/$/, "")}/metorial-cli/${input.tag}`;
+  try {
+    await (0, import_promises.mkdir)(extractDir, { recursive: true });
+    await downloadFile(`${baseUrl}/${input.spec.archiveName}`, archivePath);
+    await downloadFile(`${baseUrl}/checksums.txt`, checksumsPath);
+    await verifyChecksum(checksumsPath, input.spec.archiveName, archivePath);
+    await extractArchive(archivePath, extractDir);
+    let extractedBinary = await findBinary(extractDir, input.spec.binaryName);
+    await (0, import_promises.mkdir)(input.installDir, { recursive: true });
+    await (0, import_promises.copyFile)(extractedBinary, input.binaryPath);
+    if (process.platform !== "win32") {
+      await (0, import_promises.chmod)(input.binaryPath, 493);
+    }
+  } finally {
+    await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
+  }
+}
+async function spawnWithInheritedOutput(binaryPath, args, options) {
+  return await new Promise((resolve, reject) => {
+    let child = (0, import_node_child_process.spawn)(binaryPath, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+}
+async function spawnWithBufferedOutput(binaryPath, args, options) {
+  return await new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    let child = (0, import_node_child_process.spawn)(binaryPath, args, {
+      cwd: options.cwd,
+      env: { ...process.env, ...options.env },
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      process.stdout.write(options.stdoutTransform ? options.stdoutTransform(stdout) : stdout);
+      process.stderr.write(options.stderrTransform ? options.stderrTransform(stderr) : stderr);
+      resolve(code ?? 1);
+    });
+  });
+}
+async function downloadFile(url, destinationPath) {
+  let response = await fetch(url, {
+    headers: {
+      "User-Agent": "metorial-cli-npm",
+      Accept: "*/*"
+    }
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`);
+  }
+  await (0, import_promises.writeFile)(destinationPath, Buffer.from(await response.arrayBuffer()));
+}
+async function verifyChecksum(checksumsPath, archiveName, archivePath) {
+  let checksums = await (0, import_promises.readFile)(checksumsPath, "utf8");
+  let expected = checksums.split("\n").map((line) => line.trim().split(/\s+/)).find((parts) => parts.length >= 2 && parts[1] === archiveName)?.[0];
+  if (!expected) {
+    throw new Error(`Checksum for ${archiveName} not found`);
+  }
+  let archiveBuffer = await (0, import_promises.readFile)(archivePath);
+  let actual = (0, import_node_crypto.createHash)("sha256").update(archiveBuffer).digest("hex");
+  if (actual !== expected) {
+    throw new Error(`Checksum verification failed for ${archiveName}`);
+  }
+}
+async function extractArchive(archivePath, extractDir) {
+  if (archivePath.endsWith(".zip")) {
+    await (0, import_extract_zip.default)(archivePath, { dir: extractDir });
+    return;
+  }
+  await tar.x({
+    file: archivePath,
+    cwd: extractDir
+  });
+}
+async function findBinary(rootDir, binaryName) {
+  let directPath = import_node_path.default.join(rootDir, binaryName);
+  if (await exists(directPath)) {
+    return directPath;
+  }
+  return await walkForBinary(rootDir, binaryName);
+}
+function getCacheRoot() {
+  if (process.env.METORIAL_CLI_CACHE_DIR) {
+    return process.env.METORIAL_CLI_CACHE_DIR;
+  }
+  return import_node_path.default.join(import_node_os.default.homedir(), ".metorial", "cli-npm");
+}
+function getPlatformSpec(tag) {
+  let goos = resolveGoOS();
+  let goarch = resolveGoArch();
+  let extension = goos === "windows" ? "zip" : "tar.gz";
+  let binaryName = goos === "windows" ? "metorial.exe" : "metorial";
+  return {
+    archiveName: `metorial_${tag.replace(/^v/, "")}_${goos}_${goarch}.${extension}`,
+    binaryName
+  };
+}
+function resolveGoOS() {
+  switch (process.platform) {
+    case "darwin":
+      return "darwin";
+    case "linux":
+      return "linux";
+    case "win32":
+      return "windows";
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+function resolveGoArch() {
+  switch (process.arch) {
+    case "x64":
+      return "amd64";
+    case "arm64":
+      return "arm64";
+    default:
+      throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+}
+function normalizeVersion(value) {
+  if (!value.trim()) {
+    throw new Error("Unable to resolve a CLI version");
+  }
+  return value.startsWith("v") ? value : `v${value}`;
+}
+async function makeTempDir(parentDir) {
+  let suffix = `${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+  let tempDir = import_node_path.default.join(parentDir, suffix);
+  await (0, import_promises.mkdir)(tempDir, { recursive: true });
+  return tempDir;
+}
+async function exists(filePath) {
+  try {
+    await (0, import_promises.access)(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function walkForBinary(rootDir, binaryName) {
+  let entries = await (0, import_promises.readdir)(rootDir, { withFileTypes: true });
+  for (let entry of entries) {
+    let entryPath = import_node_path.default.join(rootDir, entry.name);
+    if (entry.isFile() && entry.name === binaryName) {
+      return entryPath;
+    }
+    if (entry.isDirectory()) {
+      try {
+        return await walkForBinary(entryPath, binaryName);
+      } catch {
+        continue;
+      }
+    }
+  }
+  throw new Error(`Downloaded archive did not contain ${binaryName}`);
+}
+function detectNodePackageManager(fileName) {
+  let userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("pnpm/")) {
+    return "pnpm";
+  }
+  if (userAgent.startsWith("yarn/")) {
+    return "yarn";
+  }
+  if (userAgent.startsWith("bun/")) {
+    return "bun";
+  }
+  if (userAgent.startsWith("npm/")) {
+    return "npm";
+  }
+  let normalized = fileName.replaceAll("\\", "/").toLowerCase();
+  if (normalized.includes("/.bun/install/global/")) {
+    return "bun";
+  }
+  if (normalized.includes("/pnpm/global/") || normalized.includes("/pnpm-global/")) {
+    return "pnpm";
+  }
+  if (normalized.includes("/.config/yarn/global/") || normalized.includes("/.yarn/global/")) {
+    return "yarn";
+  }
+  return "npm";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  npmInstallEnvironment,
+  replaceOutput,
+  resolveCLIPath,
+  runCLI,
+  runCLIAndExit
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@metorial/cli-core",
+  "version": "0.0.0-dev.6",
+  "description": "Runtime helpers for downloading and invoking the Metorial CLI",
+  "license": "MIT",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsup --config tsup.config.ts"
+  },
+  "dependencies": {
+    "extract-zip": "^2.0.1",
+    "tar": "^7.4.3"
+  }
+}