@chro-ai/cli 0.1.1 → 0.1.4

package/bin/cli.js

@@ -2,10 +2,12 @@
 "use strict";
 
 const { execSync, spawn } = require("child_process");
-const path = require("path");
+const crypto = require("crypto");
 const fs = require("fs");
 const https = require("https");
 const http = require("http");
+const path = require("path");
+const os = require("os");
 const {
   assertPublicUrlConfigured,
   getPlatformDir,
@@ -13,12 +15,12 @@ const {
   R2_PUBLIC_URL,
 } = require("./platform");
 
-const platformDir = getPlatformDir();
-const extractDir = path.join(__dirname, "..", "dist", platformDir);
-
-fs.mkdirSync(extractDir, { recursive: true });
+const CACHE_DIR = path.join(os.homedir(), ".chro", "bin");
+const LOCAL_DIST_DIR = path.join(__dirname, "..", "dist");
+const LOCAL_DEV_MODE =
+  fs.existsSync(LOCAL_DIST_DIR) || process.env.CHRO_LOCAL === "1";
 
-function download(url) {
+function fetchJson(url) {
   return new Promise((resolve, reject) => {
     const client = url.startsWith("https") ? https : http;
     client
@@ -28,46 +30,145 @@ function download(url) {
           res.statusCode < 400 &&
           res.headers.location
         ) {
-          return download(res.headers.location).then(resolve, reject);
+          return fetchJson(res.headers.location).then(resolve, reject);
         }
         if (res.statusCode !== 200) {
-          reject(new Error(`HTTP ${res.statusCode} for ${url}`));
-          res.resume();
-          return;
+          return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
         }
-        resolve(res);
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            resolve(JSON.parse(data));
+          } catch {
+            reject(new Error(`Failed to parse JSON from ${url}`));
+          }
+        });
       })
       .on("error", reject);
   });
 }
 
-async function ensureBinaryZip(baseName) {
-  const zipPath = path.join(extractDir, `${baseName}.zip`);
-  if (fs.existsSync(zipPath)) return;
+function downloadFile(url, destPath, expectedSha256) {
+  const tempPath = destPath + ".tmp";
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(tempPath);
+    const hash = crypto.createHash("sha256");
+
+    const cleanup = () => {
+      try {
+        fs.unlinkSync(tempPath);
+      } catch {}
+    };
+
+    const client = url.startsWith("https") ? https : http;
+    client
+      .get(url, (res) => {
+        if (
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          file.close();
+          cleanup();
+          return downloadFile(res.headers.location, destPath, expectedSha256)
+            .then(resolve)
+            .catch(reject);
+        }
+
+        if (res.statusCode !== 200) {
+          file.close();
+          cleanup();
+          return reject(
+            new Error(`HTTP ${res.statusCode} downloading ${url}`),
+          );
+        }
+
+        res.on("data", (chunk) => {
+          hash.update(chunk);
+        });
+        res.pipe(file);
+
+        file.on("finish", () => {
+          file.close();
+          const actualSha256 = hash.digest("hex");
+          if (expectedSha256 && actualSha256 !== expectedSha256) {
+            cleanup();
+            reject(
+              new Error(
+                `Checksum mismatch: expected ${expectedSha256}, got ${actualSha256}`,
+              ),
+            );
+          } else {
+            try {
+              fs.renameSync(tempPath, destPath);
+              resolve(destPath);
+            } catch (err) {
+              cleanup();
+              reject(err);
+            }
+          }
+        });
+      })
+      .on("error", (err) => {
+        file.close();
+        cleanup();
+        reject(err);
+      });
+  });
+}
+
+async function ensureBinaryZip(platformDir, binaryName) {
+  // Local dev mode: use binaries from npx-cli/dist/
+  if (LOCAL_DEV_MODE) {
+    const localZipPath = path.join(
+      LOCAL_DIST_DIR,
+      platformDir,
+      `${binaryName}.zip`,
+    );
+    if (fs.existsSync(localZipPath)) {
+      return localZipPath;
+    }
+    throw new Error(
+      `Local binary not found: ${localZipPath}\n` +
+        "Run ./local-build.sh first to build the binaries.",
+    );
+  }
 
   assertPublicUrlConfigured();
 
   const version = require("../package.json").version;
-  const url = `${R2_PUBLIC_URL}/releases/v${version}/${platformDir}/${baseName}.zip`;
-  console.log("Binary not found locally. Downloading from R2...");
-
-  const res = await download(url);
-  const file = fs.createWriteStream(zipPath);
-  await new Promise((resolve, reject) => {
-    res.pipe(file);
-    file.on("finish", () => file.close(resolve));
-    file.on("error", (err) => {
-      fs.unlink(zipPath, () => {});
-      reject(err);
-    });
-  });
-  console.log("Download complete.");
+  const tag = `v${version}`;
+  const cacheDir = path.join(CACHE_DIR, tag, platformDir);
+  const zipPath = path.join(cacheDir, `${binaryName}.zip`);
+
+  if (fs.existsSync(zipPath)) return zipPath;
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  console.log("Fetching binary manifest...");
+  const manifest = await fetchJson(
+    `${R2_PUBLIC_URL}/releases/${tag}/manifest.json`,
+  );
+  const binaryInfo = manifest.platforms?.[platformDir]?.[binaryName];
+
+  if (!binaryInfo) {
+    throw new Error(
+      `Binary ${binaryName} not available for ${platformDir}`,
+    );
+  }
+
+  const url = `${R2_PUBLIC_URL}/releases/${tag}/${platformDir}/${binaryName}.zip`;
+  console.log(`Downloading binary for ${platformDir}...`);
+  await downloadFile(url, zipPath, binaryInfo.sha256);
+  console.log("Download complete. Checksum verified.");
+
+  return zipPath;
 }
 
-function extractAndRun(baseName, launch) {
+function extractAndRun(zipPath, extractDir, baseName, args) {
   const binName = getBinaryName(baseName);
   const binPath = path.join(extractDir, binName);
-  const zipPath = path.join(extractDir, `${baseName}.zip`);
 
   if (fs.existsSync(binPath)) {
     try {
@@ -81,7 +182,6 @@ function extractAndRun(baseName, launch) {
 
   if (!fs.existsSync(zipPath)) {
     console.error(`${baseName}.zip not found at: ${zipPath}`);
-    console.error(`Current platform: ${platformDir}`);
     process.exit(1);
   }
 
@@ -109,29 +209,29 @@ function extractAndRun(baseName, launch) {
     } catch {}
   }
 
-  return launch(binPath);
+  const proc = spawn(binPath, args, { stdio: "inherit" });
+  proc.on("exit", (code) => process.exit(code || 0));
+  proc.on("error", (error) => {
+    console.error("Failed to launch chro-server:", error.message);
+    process.exit(1);
+  });
+
+  if (process.platform !== "win32") {
+    process.on("SIGINT", () => proc.kill("SIGINT"));
+    process.on("SIGTERM", () => proc.kill("SIGTERM"));
+  }
 }
 
 const cliVersion = require("../package.json").version;
 console.log(`Starting chro v${cliVersion}...`);
 
+const platformDir = getPlatformDir();
 const args = process.argv.slice(2);
 
-ensureBinaryZip("chro-server")
-  .then(() => {
-    extractAndRun("chro-server", (binPath) => {
-      const proc = spawn(binPath, args, { stdio: "inherit" });
-      proc.on("exit", (code) => process.exit(code || 0));
-      proc.on("error", (error) => {
-        console.error("failed to launch chro-server:", error.message);
-        process.exit(1);
-      });
-
-      if (process.platform !== "win32") {
-        process.on("SIGINT", () => proc.kill("SIGINT"));
-        process.on("SIGTERM", () => proc.kill("SIGTERM"));
-      }
-    });
+ensureBinaryZip(platformDir, "chro-server")
+  .then((zipPath) => {
+    const extractDir = path.dirname(zipPath);
+    extractAndRun(zipPath, extractDir, "chro-server", args);
   })
   .catch((error) => {
     console.error(`Failed to obtain chro binary: ${error.message}`);

package/bin/platform.js

@@ -67,12 +67,8 @@ function getBinaryName(base) {
   return process.platform === "win32" ? `${base}.exe` : base;
 }
 
-function hasConfiguredPublicUrl() {
-  return R2_PUBLIC_URL.length > 0;
-}
-
 function assertPublicUrlConfigured() {
-  if (hasConfiguredPublicUrl()) return;
+  if (R2_PUBLIC_URL.length > 0) return;
 
   console.error("chro: R2 public URL is not configured.");
   console.error(
@@ -86,6 +82,5 @@ module.exports = {
   getEffectiveArch,
   getPlatformDir,
   getBinaryName,
-  hasConfiguredPublicUrl,
   R2_PUBLIC_URL,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chro-ai/cli",
-  "version": "0.1.1",
+  "version": "0.1.4",
   "description": "Chro CLI",
   "license": "Apache-2.0",
   "repository": {
@@ -14,9 +14,7 @@
   "bin": {
     "chro": "bin/cli.js"
   },
-  "scripts": {
-    "postinstall": "node bin/postinstall.js"
-  },
+  "scripts": {},
   "files": [
     "bin"
   ],

package/bin/postinstall.js

@@ -1,81 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-const https = require("https");
-const http = require("http");
-const fs = require("fs");
-const path = require("path");
-const {
-  getPlatformDir,
-  hasConfiguredPublicUrl,
-  R2_PUBLIC_URL,
-} = require("./platform");
-
-const version = require("../package.json").version;
-const platformDir = getPlatformDir();
-const distDir = path.join(__dirname, "..", "dist", platformDir);
-const zipPath = path.join(distDir, "chro-server.zip");
-
-function download(url) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith("https") ? https : http;
-    client
-      .get(url, (res) => {
-        if (
-          res.statusCode >= 300 &&
-          res.statusCode < 400 &&
-          res.headers.location
-        ) {
-          return download(res.headers.location).then(resolve, reject);
-        }
-        if (res.statusCode !== 200) {
-          reject(new Error(`HTTP ${res.statusCode} for ${url}`));
-          res.resume();
-          return;
-        }
-        resolve(res);
-      })
-      .on("error", reject);
-  });
-}
-
-async function main() {
-  if (!hasConfiguredPublicUrl()) {
-    console.warn("chro: R2 public URL is not configured");
-    console.warn("chro: binary will be downloaded on first run if R2_PUBLIC_URL is set");
-    return;
-  }
-
-  if (fs.existsSync(zipPath)) {
-    console.log(`chro: binary already present at ${zipPath}, skipping download`);
-    return;
-  }
-
-  const url = `${R2_PUBLIC_URL}/releases/v${version}/${platformDir}/chro-server.zip`;
-  console.log(`chro: downloading binary for ${platformDir}...`);
-
-  try {
-    fs.mkdirSync(distDir, { recursive: true });
-    const res = await download(url);
-    const file = fs.createWriteStream(zipPath);
-
-    await new Promise((resolve, reject) => {
-      res.pipe(file);
-      file.on("finish", () => file.close(resolve));
-      file.on("error", (err) => {
-        fs.unlink(zipPath, () => {});
-        reject(err);
-      });
-    });
-
-    console.log("chro: binary downloaded successfully");
-  } catch (err) {
-    console.warn(`chro: postinstall download failed: ${err.message}`);
-    console.warn("chro: binary will be downloaded on first run");
-    try {
-      fs.unlinkSync(zipPath);
-    } catch {}
-  }
-}
-
-main();