@chro-ai/cli 0.1.0 → 0.1.3

package/bin/cli.js

@@ -1,26 +1,240 @@
 #!/usr/bin/env node
 "use strict";
 
-const { spawn } = require("child_process");
-const path = require("path");
+const { execSync, spawn } = require("child_process");
+const crypto = require("crypto");
 const fs = require("fs");
-const { getBinaryName } = require("./platform");
+const https = require("https");
+const http = require("http");
+const path = require("path");
+const os = require("os");
+const {
+  assertPublicUrlConfigured,
+  getPlatformDir,
+  getBinaryName,
+  R2_PUBLIC_URL,
+} = require("./platform");
+
+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 fetchJson(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 fetchJson(res.headers.location).then(resolve, reject);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+        }
+        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);
+  });
+}
+
+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 tag = `v${version}`;
+  const cacheDir = path.join(CACHE_DIR, tag, platformDir);
+  const zipPath = path.join(cacheDir, `${binaryName}.zip`);
 
-const binName = getBinaryName("chro");
-const localBinary = path.resolve(__dirname, "..", "..", "target", "release", binName);
+  if (fs.existsSync(zipPath)) return zipPath;
 
-if (!fs.existsSync(localBinary)) {
-  console.error("chro binary not found.");
-  console.error("Build it first with: cd apps/cli && cargo build --release");
-  console.error("This wrapper is scaffold-only; remote download is not wired yet.");
-  process.exit(1);
+  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(zipPath, extractDir, baseName, args) {
+  const binName = getBinaryName(baseName);
+  const binPath = path.join(extractDir, binName);
+
+  if (fs.existsSync(binPath)) {
+    try {
+      fs.unlinkSync(binPath);
+    } catch (err) {
+      if (process.env.CHRO_DEBUG) {
+        console.warn(`Warning: Could not delete existing binary: ${err.message}`);
+      }
+    }
+  }
+
+  if (!fs.existsSync(zipPath)) {
+    console.error(`${baseName}.zip not found at: ${zipPath}`);
+    process.exit(1);
+  }
+
+  const unzipCmd =
+    process.platform === "win32"
+      ? `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${extractDir}' -Force"`
+      : `unzip -qq -o "${zipPath}" -d "${extractDir}"`;
+
+  try {
+    execSync(unzipCmd, { stdio: "inherit" });
+  } catch (err) {
+    console.error("Extraction failed:", err.message);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(binPath)) {
+    console.error(`Extracted binary not found at: ${binPath}`);
+    console.error("This usually indicates a corrupt download. Please reinstall.");
+    process.exit(1);
+  }
+
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(binPath, 0o755);
+    } catch {}
+  }
+
+  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);
-const proc = spawn(localBinary, args, { stdio: "inherit" });
 
-proc.on("exit", (code) => process.exit(code || 0));
-proc.on("error", (error) => {
-  console.error("failed to launch chro:", error.message);
-  process.exit(1);
-});
+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}`);
+    console.error("Please check your network connection and try again.");
+    process.exit(1);
+  });

package/bin/platform.js

@@ -3,8 +3,16 @@
 
 const { execSync } = require("child_process");
 
-// Public binary host URL placeholder for future releases.
-const R2_PUBLIC_URL = "https://example.com/chro";
+const packageJson = require("../package.json");
+
+function normalizePublicUrl(value) {
+  if (typeof value !== "string") return "";
+  return value.trim().replace(/\/+$/, "");
+}
+
+const R2_PUBLIC_URL = normalizePublicUrl(
+  process.env.R2_PUBLIC_URL || packageJson.config?.r2PublicUrl,
+);
 
 function getEffectiveArch() {
   const platform = process.platform;
@@ -59,4 +67,20 @@ function getBinaryName(base) {
   return process.platform === "win32" ? `${base}.exe` : base;
 }
 
-module.exports = { getEffectiveArch, getPlatformDir, getBinaryName, R2_PUBLIC_URL };
+function assertPublicUrlConfigured() {
+  if (R2_PUBLIC_URL.length > 0) return;
+
+  console.error("chro: R2 public URL is not configured.");
+  console.error(
+    "Set R2_PUBLIC_URL or populate package.json config.r2PublicUrl before publishing.",
+  );
+  process.exit(1);
+}
+
+module.exports = {
+  assertPublicUrlConfigured,
+  getEffectiveArch,
+  getPlatformDir,
+  getBinaryName,
+  R2_PUBLIC_URL,
+};

package/package.json

@@ -1,25 +1,29 @@
 {
   "name": "@chro-ai/cli",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Chro CLI",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/n-asuy/chro"
   },
   "homepage": "https://chro-ai.com",
+  "config": {
+    "r2PublicUrl": "https://dl.chro-ai.com"
+  },
   "bin": {
     "chro": "bin/cli.js"
   },
-  "scripts": {
-    "postinstall": "node bin/postinstall.js"
-  },
+  "scripts": {},
   "files": [
     "bin"
   ],
   "engines": {
     "node": ">=18"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "cli",
     "skills",

package/bin/postinstall.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-console.log("chro: scaffold package installed");
-console.log("chro: remote binary download is not wired yet");