@chro-ai/cli 0.1.0 → 0.1.1

package/bin/cli.js

@@ -1,26 +1,140 @@
 #!/usr/bin/env node
 "use strict";
 
-const { spawn } = require("child_process");
+const { execSync, spawn } = require("child_process");
 const path = require("path");
 const fs = require("fs");
-const { getBinaryName } = require("./platform");
+const https = require("https");
+const http = require("http");
+const {
+  assertPublicUrlConfigured,
+  getPlatformDir,
+  getBinaryName,
+  R2_PUBLIC_URL,
+} = require("./platform");
 
-const binName = getBinaryName("chro");
-const localBinary = path.resolve(__dirname, "..", "..", "target", "release", binName);
+const platformDir = getPlatformDir();
+const extractDir = path.join(__dirname, "..", "dist", platformDir);
 
-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(extractDir, { recursive: true });
+
+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 ensureBinaryZip(baseName) {
+  const zipPath = path.join(extractDir, `${baseName}.zip`);
+  if (fs.existsSync(zipPath)) return;
+
+  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.");
+}
+
+function extractAndRun(baseName, launch) {
+  const binName = getBinaryName(baseName);
+  const binPath = path.join(extractDir, binName);
+  const zipPath = path.join(extractDir, `${baseName}.zip`);
+
+  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}`);
+    console.error(`Current platform: ${platformDir}`);
+    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 {}
+  }
+
+  return launch(binPath);
+}
+
+const cliVersion = require("../package.json").version;
+console.log(`Starting chro v${cliVersion}...`);
+
 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("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"));
+      }
+    });
+  })
+  .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,25 @@ function getBinaryName(base) {
   return process.platform === "win32" ? `${base}.exe` : base;
 }
 
-module.exports = { getEffectiveArch, getPlatformDir, getBinaryName, R2_PUBLIC_URL };
+function hasConfiguredPublicUrl() {
+  return R2_PUBLIC_URL.length > 0;
+}
+
+function assertPublicUrlConfigured() {
+  if (hasConfiguredPublicUrl()) 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,
+  hasConfiguredPublicUrl,
+  R2_PUBLIC_URL,
+};

package/bin/postinstall.js

@@ -1,5 +1,81 @@
 #!/usr/bin/env node
 "use strict";
 
-console.log("chro: scaffold package installed");
-console.log("chro: remote binary download is not wired yet");
+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();

package/package.json

@@ -1,13 +1,16 @@
 {
   "name": "@chro-ai/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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"
   },
@@ -20,6 +23,9 @@
   "engines": {
     "node": ">=18"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "keywords": [
     "cli",
     "skills",