@chordra.ai/ctl 0.2.0 → 0.2.1

package/bin/chord-ctl

@@ -12,13 +12,10 @@ const path = require("node:path");
 const { TextDecoder } = require("node:util");
 const zlib = require("node:zlib");
 
-const PACKAGE_NAME = "@sys9/chord-cli";
-const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
 const BOOTSTRAP_SCHEMA = 2;
 const REQUEST_TIMEOUT_MS = 30_000;
 const MAX_URL_BYTES = 4096;
 const MAX_BOOTSTRAP_BYTES = 64 * 1024;
-const MAX_METADATA_BYTES = 1024 * 1024;
 const MAX_TARBALL_BYTES = 128 * 1024 * 1024;
 const MAX_ARCHIVE_BYTES = 512 * 1024 * 1024;
 const MAX_ENTRY_BYTES = 128 * 1024 * 1024;
@@ -27,13 +24,6 @@ const MAX_ARCHIVE_ENTRIES = 1024;
 const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 const ENVIRONMENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
 
-const PLATFORM_TAGS = {
-  "linux:x64": "linux-x64",
-  "linux:arm64": "linux-arm64",
-  "darwin:x64": "darwin-x64",
-  "darwin:arm64": "darwin-arm64",
-};
-
 const textDecoder = new TextDecoder("utf-8", { fatal: true });
 
 function isPlainObject(value) {
@@ -103,14 +93,6 @@ function parseHTTPURL(value, label, { allowPath = false, allowQuery = false } =
   return parsed;
 }
 
-function platformTag(platform = process.platform, arch = process.arch) {
-  const tag = PLATFORM_TAGS[platform + ":" + arch];
-  if (!tag) {
-    throw new Error("unsupported platform: " + platform + " (" + arch + ")");
-  }
-  return tag;
-}
-
 function isVersion(value) {
   return typeof value === "string" && value.length <= 128 && VERSION_PATTERN.test(value);
 }
@@ -133,14 +115,10 @@ function validateBootstrapResponse(payload) {
   if (!isPlainObject(payload)) {
     throw new Error("bootstrap response must be an object");
   }
-  if (payload.schema_version !== 1 && payload.schema_version !== BOOTSTRAP_SCHEMA) {
+  if (payload.schema_version !== BOOTSTRAP_SCHEMA) {
     throw new Error("unsupported bootstrap schema");
   }
-  const expectedKeys = ["approved_cli_version", "canonical_environment_id", "schema_version"];
-  if (payload.schema_version === BOOTSTRAP_SCHEMA) {
-    expectedKeys.push("release");
-  }
-  if (Object.keys(payload).sort().join(",") !== expectedKeys.sort().join(",")) {
+  if (Object.keys(payload).sort().join(",") !== "approved_cli_version,canonical_environment_id,release,schema_version") {
     throw new Error("bootstrap response has an invalid schema");
   }
   if (
@@ -152,9 +130,7 @@ function validateBootstrapResponse(payload) {
   if (!isVersion(payload.approved_cli_version)) {
     throw new Error("bootstrap response has an invalid version");
   }
-  const release = payload.schema_version === 1
-    ? { sources: ["npm"], version: payload.approved_cli_version }
-    : validateRelease(payload.release, payload.approved_cli_version);
+  const release = validateRelease(payload.release, payload.approved_cli_version);
   return {
     environmentID: payload.canonical_environment_id,
     version: payload.approved_cli_version,
@@ -166,17 +142,9 @@ function validateRelease(release, approvedVersion) {
   if (!isPlainObject(release) || release.version !== approvedVersion) {
     throw new Error("bootstrap release does not match the approved version");
   }
-  if (!Array.isArray(release.sources) || release.sources.length === 0 ||
-      release.sources.some((source) => source !== "npm" && source !== "native") ||
-      new Set(release.sources).size !== release.sources.length) {
+  if (!Array.isArray(release.sources) || release.sources.length !== 1 || release.sources[0] !== "native") {
     throw new Error("bootstrap release has invalid sources");
   }
-  if (!release.sources.includes("native")) {
-    if (Object.keys(release).sort().join(",") !== "sources,version") {
-      throw new Error("npm release has an invalid schema");
-    }
-    return release;
-  }
   if (Object.keys(release).sort().join(",") !== "archive,sources,version" || !isPlainObject(release.archive)) {
     throw new Error("native release has an invalid schema");
   }
@@ -282,7 +250,7 @@ function requestBytes(target, limit, label, accept) {
 
 async function fetchBootstrap(serverURL) {
   const server = parseHTTPURL(serverURL, "--server");
-  platformTag();
+  targetDirectory();
   const endpoint = new URL("/api/bootstrap", server);
   endpoint.searchParams.set("schema", String(BOOTSTRAP_SCHEMA));
   endpoint.searchParams.set("os", process.platform);
@@ -291,23 +259,9 @@ async function fetchBootstrap(serverURL) {
   return validateBootstrapResponse(parseJSON(body, "bootstrap response"));
 }
 
-function registryURL(environment = process.env) {
-  const hasOverride = Object.prototype.hasOwnProperty.call(environment, "CHORDRA_NPM_REGISTRY");
-  const value = hasOverride ? environment.CHORDRA_NPM_REGISTRY : DEFAULT_NPM_REGISTRY;
-  const registry = parseHTTPURL(value, "CHORDRA_NPM_REGISTRY", { allowPath: true });
-  if (!registry.pathname.endsWith("/")) {
-    registry.pathname += "/";
-  }
-  return registry;
-}
-
-function metadataURL(registry, version) {
-  return new URL("@sys9/chord-cli/" + encodeURIComponent(version), registry);
-}
-
 function parseIntegrity(value) {
   if (typeof value !== "string" || value.trim() === "") {
-    throw new Error("package metadata has an invalid sha512 integrity");
+    throw new Error("archive has an invalid sha512 integrity");
   }
   const digests = [];
   for (const token of value.trim().split(/\s+/)) {
@@ -316,58 +270,20 @@ function parseIntegrity(value) {
     }
     const encoded = token.slice("sha512-".length);
     if (!/^[A-Za-z0-9+/]+={0,2}$/.test(encoded)) {
-      throw new Error("package metadata has an invalid sha512 integrity");
+      throw new Error("archive has an invalid sha512 integrity");
     }
     const digest = Buffer.from(encoded, "base64");
     if (digest.length !== 64 || digest.toString("base64") !== encoded) {
-      throw new Error("package metadata has an invalid sha512 integrity");
+      throw new Error("archive has an invalid sha512 integrity");
     }
     digests.push(digest);
   }
   if (digests.length === 0) {
-    throw new Error("package metadata has an invalid sha512 integrity");
+    throw new Error("archive has an invalid sha512 integrity");
   }
   return digests;
 }
 
-function validatePackageMetadata(payload, expectedVersion, registry) {
-  if (!isPlainObject(payload) || payload.name !== PACKAGE_NAME || payload.version !== expectedVersion) {
-    throw new Error("package metadata does not describe the requested package version");
-  }
-  if (!isPlainObject(payload.dist)) {
-    throw new Error("package metadata has no dist object");
-  }
-  const integrity = parseIntegrity(payload.dist.integrity);
-  if (typeof payload.dist.tarball !== "string") {
-    throw new Error("package metadata has no tarball URL");
-  }
-  const tarball = parseHTTPURL(payload.dist.tarball, "package tarball", {
-    allowPath: true,
-    allowQuery: true,
-  });
-  if (tarball.origin !== registry.origin) {
-    throw new Error("package tarball origin does not match the registry");
-  }
-  return { integrity, tarball };
-}
-
-async function fetchPackage(registry, version) {
-  const metadata = metadataURL(registry, version);
-  const metadataBody = await requestBytes(
-    metadata,
-    MAX_METADATA_BYTES,
-    "package metadata request",
-    "application/json",
-  );
-  const packageInfo = validatePackageMetadata(parseJSON(metadataBody, "package metadata"), version, registry);
-  const tarballBody = await requestBytes(packageInfo.tarball, MAX_TARBALL_BYTES, "package tarball request");
-  const actual = crypto.createHash("sha512").update(tarballBody).digest();
-  if (!packageInfo.integrity.some((digest) => crypto.timingSafeEqual(actual, digest))) {
-    throw new Error("package tarball integrity mismatch");
-  }
-  return tarballBody;
-}
-
 function tarText(bytes, label) {
   const end = bytes.indexOf(0);
   const field = end === -1 ? bytes : bytes.subarray(0, end);
@@ -553,15 +469,15 @@ function parseTar(tar, target = targetDirectory()) {
   return entries;
 }
 
-function unpackPackage(tarball, target = targetDirectory()) {
+function unpackArchive(tarball, target = targetDirectory()) {
   let tar;
   try {
     tar = zlib.gunzipSync(tarball, { maxOutputLength: MAX_ARCHIVE_BYTES });
   } catch (error) {
     if (error && error.code === "ERR_BUFFER_TOO_LARGE") {
-      throw new Error("package tarball exceeds the uncompressed size limit");
+      throw new Error("archive exceeds the uncompressed size limit");
     }
-    throw new Error("package tarball is not a valid gzip archive: " + error.message);
+    throw new Error("archive is not a valid gzip archive: " + error.message);
   }
   return parseTar(tar, target);
 }
@@ -580,7 +496,7 @@ function materializeBinaries(entries) {
     return root;
   } catch (error) {
     fs.rmSync(root, { recursive: true, force: true });
-    throw new Error("could not materialize package binaries: " + error.message);
+    throw new Error("could not materialize release binaries: " + error.message);
   }
 }
 
@@ -609,36 +525,27 @@ function runRunner(root, serverURL, environmentID) {
   });
 }
 
-async function acquireRelease(release, environment) {
-  const failures = [];
-  for (const source of release.sources) {
-    try {
-      let tarball;
-      if (source === "native") {
-        const archive = release.archive;
-        tarball = await requestBytes(new URL(archive.url), archive.size, "native archive request");
-        if (tarball.length !== archive.size) {
-          throw new Error("archive size mismatch");
-        }
-        const actual = crypto.createHash("sha512").update(tarball).digest();
-        const expected = parseIntegrity(archive.integrity)[0];
-        if (!crypto.timingSafeEqual(actual, expected)) {
-          throw new Error("archive integrity mismatch");
-        }
-      } else {
-        tarball = await fetchPackage(registryURL(environment), release.version + "-" + platformTag());
-      }
-      return unpackPackage(tarball);
-    } catch (error) {
-      failures.push(source + ": " + error.message);
+async function acquireRelease(release) {
+  const archive = release.archive;
+  try {
+    const tarball = await requestBytes(new URL(archive.url), archive.size, "native archive request");
+    if (tarball.length !== archive.size) {
+      throw new Error("archive size mismatch");
     }
+    const actual = crypto.createHash("sha512").update(tarball).digest();
+    const expected = parseIntegrity(archive.integrity)[0];
+    if (!crypto.timingSafeEqual(actual, expected)) {
+      throw new Error("archive integrity mismatch");
+    }
+    return unpackArchive(tarball);
+  } catch (error) {
+    throw new Error("could not acquire approved CLI release: " + error.message);
   }
-  throw new Error("could not acquire approved CLI release: " + failures.join("; "));
 }
 
-async function setup(serverURL, environment = process.env) {
+async function setup(serverURL) {
   const bootstrap = await fetchBootstrap(serverURL);
-  const binaries = await acquireRelease(bootstrap.release, environment);
+  const binaries = await acquireRelease(bootstrap.release);
   const root = materializeBinaries(binaries);
   try {
     return await runRunner(root, serverURL, bootstrap.environmentID);
@@ -647,7 +554,7 @@ async function setup(serverURL, environment = process.env) {
   }
 }
 
-async function main(argv = process.argv.slice(2), environment = process.env) {
+async function main(argv = process.argv.slice(2)) {
   // npm treats engines as advisory by default. Enforce the same package-owned
   // floor before argument processing, network access, or native setup.
   const requirement = require("../package.json").engines.node;
@@ -669,7 +576,7 @@ async function main(argv = process.argv.slice(2), environment = process.env) {
     throw new Error("Node.js " + requirement + " is required; found " + process.versions.node + ". Upgrade Node.js and run setup again.");
   }
   const args = parseArguments(argv);
-  return setup(args.server, environment);
+  return setup(args.server);
 }
 
 if (require.main === module) {
@@ -688,18 +595,13 @@ if (require.main === module) {
 
 module.exports = {
   BOOTSTRAP_SCHEMA,
-  DEFAULT_NPM_REGISTRY,
   MAX_ARCHIVE_BYTES,
   MAX_BOOTSTRAP_BYTES,
   MAX_ENTRY_BYTES,
-  MAX_METADATA_BYTES,
   MAX_TARBALL_BYTES,
   parseArguments,
   parseTar,
-  platformTag,
-  registryURL,
   setup,
-  unpackPackage,
+  unpackArchive,
   validateBootstrapResponse,
-  validatePackageMetadata,
 };

package/package.json

@@ -1,12 +1,8 @@
 {
   "name": "@chordra.ai/ctl",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Transient Chordra Host setup bootstrap",
   "license": "UNLICENSED",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sys9-ai/chord.git"
-  },
   "publishConfig": {
     "access": "public"
   },