@clickzetta/cz-cli 0.3.50 → 0.3.52

package/bin/platform.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execFileSync } = require("child_process");
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const zlib = require("zlib");
+
+const SUPPORTED_PACKAGES = new Set([
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-arm64",
+  "linux-x64",
+  "win32-x64",
+]);
+const DEFAULT_FALLBACK_ROOT = path.join(__dirname, "fallback");
+
+function normalizeArch(arch = os.arch()) {
+  if (arch === "x64" || arch === "amd64") return "x64";
+  if (arch === "arm64" || arch === "aarch64") return "arm64";
+  return null;
+}
+
+function getPlatformSpec({
+  platform = os.platform(),
+  arch = os.arch(),
+} = {}) {
+  const normalizedArch = normalizeArch(arch);
+  if (!normalizedArch) return null;
+  const packageTarget = `${platform}-${normalizedArch}`;
+  if (!SUPPORTED_PACKAGES.has(packageTarget)) return null;
+
+  return {
+    platform,
+    arch: normalizedArch,
+    binaryName: platform === "win32" ? "cz-cli.exe" : "cz-cli",
+    packageName: `@clickzetta/cz-cli-${packageTarget}`,
+  };
+}
+
+function resolvePackageDir(spec, resolve = require.resolve) {
+  try {
+    return path.dirname(resolve(`${spec.packageName}/package.json`));
+  } catch {
+    return null;
+  }
+}
+
+function resolveBinaryFromRoot(rootDir, spec, existsSync = fs.existsSync) {
+  if (!rootDir) return null;
+  const binPath = path.join(rootDir, spec.binaryName);
+  if (!existsSync(binPath)) return null;
+
+  return {
+    rootDir,
+    binPath,
+  };
+}
+
+function resolveInstalledBinary({
+  spec = getPlatformSpec(),
+  fallbackRoot = DEFAULT_FALLBACK_ROOT,
+  resolvePackageDirFn = resolvePackageDir,
+  existsSync = fs.existsSync,
+} = {}) {
+  if (!spec) return null;
+
+  const packageDir = resolvePackageDirFn(spec);
+  const packaged = resolveBinaryFromRoot(packageDir ? path.join(packageDir, "bin") : null, spec, existsSync);
+  if (packaged) return { ...packaged, source: "package" };
+
+  const fallback = resolveBinaryFromRoot(path.join(fallbackRoot, `${spec.platform}-${spec.arch}`), spec, existsSync);
+  if (fallback) return { ...fallback, source: "fallback" };
+
+  return null;
+}
+
+function parseOctal(buffer, start, end) {
+  const value = buffer.toString("utf8", start, end).replace(/\0.*$/, "").trim();
+  if (!value) return 0;
+  return Number.parseInt(value, 8);
+}
+
+function sanitizeRelativePath(relativePath) {
+  const normalized = path.posix.normalize(relativePath).replace(/^\/+/, "");
+  if (!normalized || normalized.startsWith("../") || normalized === "..") return null;
+  return normalized;
+}
+
+function extractBinFromTarball(archivePath, destinationDir) {
+  const archive = zlib.gunzipSync(fs.readFileSync(archivePath));
+  const resolvedDestinationDir = path.resolve(destinationDir);
+  let offset = 0;
+
+  while (offset + 512 <= archive.length) {
+    const header = archive.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+
+    const name = header.toString("utf8", 0, 100).replace(/\0.*$/, "");
+    const prefix = header.toString("utf8", 345, 500).replace(/\0.*$/, "");
+    const entryPath = sanitizeRelativePath(prefix ? `${prefix}/${name}` : name);
+    const type = String.fromCharCode(header[156] || 0);
+    const mode = parseOctal(header, 100, 108);
+    const size = parseOctal(header, 124, 136);
+    const dataStart = offset + 512;
+    const dataEnd = dataStart + size;
+    const relative = entryPath && entryPath.startsWith("package/bin/") ? sanitizeRelativePath(entryPath.slice(12)) : null;
+
+    if (relative) {
+      const targetPath = path.resolve(resolvedDestinationDir, relative);
+      if (!targetPath.startsWith(resolvedDestinationDir + path.sep) && targetPath !== resolvedDestinationDir) {
+        throw new Error(`Refusing to extract unsafe path: ${relative}`);
+      }
+
+      if (type === "5") {
+        fs.mkdirSync(targetPath, { recursive: true });
+      } else if (type === "\0" || type === "0") {
+        fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+        fs.writeFileSync(targetPath, archive.subarray(dataStart, dataEnd));
+        if (process.platform !== "win32") fs.chmodSync(targetPath, mode || 0o755);
+      }
+    }
+
+    offset = dataStart + Math.ceil(size / 512) * 512;
+  }
+}
+
+async function installFromNpmRegistry({
+  packageName,
+  version,
+  destinationDir,
+} = {}) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), "cz-cli-npm-pack-"));
+
+  try {
+    const packed = execFileSync("npm", ["pack", `${packageName}@${version}`, "--silent"], {
+      cwd: tempRoot,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    })
+      .trim()
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .pop();
+
+    if (!packed) throw new Error(`npm pack did not return a tarball name for ${packageName}@${version}`);
+
+    extractBinFromTarball(path.join(tempRoot, packed), destinationDir);
+  } catch (error) {
+    const detail =
+      error && typeof error === "object" && "stderr" in error && error.stderr
+        ? String(error.stderr).trim()
+        : error instanceof Error
+          ? error.message
+          : String(error);
+    throw new Error(`npm registry self-heal failed for ${packageName}@${version}: ${detail}`);
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+async function ensureInstalledBinary({
+  spec = getPlatformSpec(),
+  version = "latest",
+  fallbackRoot = DEFAULT_FALLBACK_ROOT,
+  resolvePackageDir: resolvePackageDirOverride,
+  existsSync = fs.existsSync,
+  installFromNpmRegistry: installFromNpmRegistryOverride = installFromNpmRegistry,
+} = {}) {
+  if (!spec) throw new Error(`Unsupported platform/arch: ${os.platform()}/${os.arch()}`);
+
+  const installed = resolveInstalledBinary({
+    spec,
+    fallbackRoot,
+    resolvePackageDirFn: resolvePackageDirOverride || resolvePackageDir,
+    existsSync,
+  });
+  if (installed) return installed;
+
+  const destinationDir = path.join(fallbackRoot, `${spec.platform}-${spec.arch}`);
+  fs.rmSync(destinationDir, { recursive: true, force: true });
+  fs.mkdirSync(destinationDir, { recursive: true });
+  await installFromNpmRegistryOverride({
+    packageName: spec.packageName,
+    version,
+    destinationDir,
+    binaryName: spec.binaryName,
+  });
+
+  const fallback = resolveInstalledBinary({
+    spec,
+    fallbackRoot,
+    resolvePackageDirFn: () => null,
+    existsSync,
+  });
+  if (fallback) return fallback;
+
+  throw new Error(
+    `Unable to install cz-cli binary for ${spec.platform}-${spec.arch} from package ${spec.packageName} or npm registry fallback.`,
+  );
+}
+
+module.exports = {
+  DEFAULT_FALLBACK_ROOT,
+  ensureInstalledBinary,
+  getPlatformSpec,
+  resolveInstalledBinary,
+};

package/bin/postinstall.js

@@ -3,15 +3,13 @@
 
 const { execFileSync } = require("child_process");
 const fs = require("fs");
-const path = require("path");
 const os = require("os");
+const path = require("path");
+const { DEFAULT_FALLBACK_ROOT, ensureInstalledBinary, getPlatformSpec } = require("./platform");
 
 const home = os.homedir();
-const platform = os.platform();
-const arch = os.arch() === "x64" ? "x64" : "arm64";
-const pkgName = `@clickzetta/cz-cli-${platform}-${arch}`;
-const binName = platform === "win32" ? "cz-cli.exe" : "cz-cli";
 const installFile = path.join(home, ".clickzetta", "install.json");
+const version = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "package.json"), "utf-8")).version;
 
 function detectPackageManager() {
   const userAgent = process.env.npm_config_user_agent || "";
@@ -22,17 +20,20 @@ function detectPackageManager() {
   return "npm";
 }
 
-try {
-  const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
-  const binPath = path.join(pkgDir, "bin", binName);
-  const skillsSrc = path.join(pkgDir, "bin", "skills");
-  if (!fs.existsSync(skillsSrc)) process.exit(0);
+async function main() {
+  const spec = getPlatformSpec();
+  if (!spec) return;
 
-  const skills = fs.readdirSync(skillsSrc).filter((name) =>
-    fs.statSync(path.join(skillsSrc, name)).isDirectory()
-  );
+  const installed = await ensureInstalledBinary({
+    spec,
+    version,
+    fallbackRoot: DEFAULT_FALLBACK_ROOT,
+  });
+  const skillsSrc = path.join(installed.rootDir, "skills");
+  const skills = fs.existsSync(skillsSrc)
+    ? fs.readdirSync(skillsSrc).filter((name) => fs.statSync(path.join(skillsSrc, name)).isDirectory())
+    : [];
 
-  // 1. cz-cli skill → external agent directories (subagent registration)
   const agentDirs = [
     path.join(home, ".claude", "skills"),
     path.join(home, ".kiro", "skills"),
@@ -50,7 +51,6 @@ try {
     }
   }
 
-  // Cleanup: fix cz-cli-v2 → cz-cli in existing skill files (bug introduced in 57a49fcdc)
   for (const dir of agentDirs) {
     const skillFile = path.join(dir, "cz-cli", "SKILL.md");
     try {
@@ -75,17 +75,17 @@ try {
     }
   }
 
-  // 2. All other skills → ~/.clickzetta/skills/.builtin/ (cz-cli managed, safe to overwrite)
   const internalDest = path.join(home, ".clickzetta", "skills", ".builtin");
   fs.mkdirSync(internalDest, { recursive: true });
 
-  // Migrate: remove legacy skills that were previously installed directly in ~/.clickzetta/skills/
   const legacyDir = path.join(home, ".clickzetta", "skills");
   for (const name of skills) {
     if (name === "cz-cli") continue;
     const legacy = path.join(legacyDir, name);
     if (fs.existsSync(legacy) && fs.statSync(legacy).isDirectory()) {
-      try { fs.rmSync(legacy, { recursive: true, force: true }); } catch (e) {}
+      try {
+        fs.rmSync(legacy, { recursive: true, force: true });
+      } catch (e) {}
     }
   }
 
@@ -100,14 +100,14 @@ try {
   }
 
   try {
-    execFileSync(binPath, [], {
+    execFileSync(installed.binPath, [], {
       stdio: "ignore",
       env: { ...process.env, CLICKZETTA_MIGRATE_PROFILES_ONLY: "1" },
     });
   } catch (e) {}
 
   try {
-    const version = execFileSync(binPath, ["--version"], {
+    const binaryVersion = execFileSync(installed.binPath, ["--version"], {
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf-8",
       env: process.env,
@@ -119,17 +119,24 @@ try {
         {
           version: 1,
           method: detectPackageManager(),
-          installed_path: binPath,
+          installed_path: installed.binPath,
           channel: "latest",
-          binary_version: version,
+          binary_version: binaryVersion,
           updated_at: new Date().toISOString(),
         },
         null,
-        2
+        2,
       ) + "\n",
-      "utf-8"
+      "utf-8",
     );
   } catch (e) {}
-} catch (e) {
-  // Non-fatal: don't block npm install
 }
+
+main().catch((error) => {
+  process.stderr.write(
+    `Failed to install cz-cli binary: ${error instanceof Error ? error.message : String(error)}\n`,
+  );
+  process.stderr.write("npm installed the launcher package, but the platform binary could not be prepared from npm.\n");
+  process.stderr.write("Check npm config for omit=optional / optional=false and ensure npm registry access works.\n");
+  process.exit(1);
+});

package/bin/run.js

@@ -2,22 +2,23 @@
 "use strict";
 
 const { execFileSync } = require("child_process");
-const path = require("path");
-const os = require("os");
+const { DEFAULT_FALLBACK_ROOT, getPlatformSpec, resolveInstalledBinary } = require("./platform");
 
-const platform = os.platform();
-const arch = os.arch() === "x64" ? "x64" : "arm64";
-const pkgName = `@clickzetta/cz-cli-${platform}-${arch}`;
-const binName = platform === "win32" ? "cz-cli.exe" : "cz-cli";
+const spec = getPlatformSpec();
 
 try {
-  const pkgDir = path.dirname(require.resolve(`${pkgName}/package.json`));
-  const binPath = path.join(pkgDir, "bin", binName);
-  execFileSync(binPath, process.argv.slice(2), { stdio: "inherit", env: process.env });
+  const installed = resolveInstalledBinary({
+    spec,
+    fallbackRoot: DEFAULT_FALLBACK_ROOT,
+  });
+  if (!installed) throw new Error("missing binary");
+
+  execFileSync(installed.binPath, process.argv.slice(2), { stdio: "inherit", env: process.env });
 } catch (e) {
   if (e.status !== undefined) process.exit(e.status);
-  console.error(`Error: Platform binary not found (${pkgName}).`);
-  console.error(`Fix: npm install -g @clickzetta/cz-cli@latest`);
-  console.error(`Or:  curl -fsSL https://github.com/clickzetta/cz-cli/releases/latest/download/install.sh | sh`);
+  console.error(`Error: Platform binary not found (${spec ? spec.packageName : "unsupported-platform"}).`);
+  console.error("Fix: reinstall with npm so postinstall can repair the platform binary from npm registry");
+  console.error("  npm install -g @clickzetta/cz-cli@latest --ignore-scripts=false");
+  console.error("If this still fails, check npm config for omit=optional / optional=false and registry access.");
   process.exit(1);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clickzetta/cz-cli",
-  "version": "0.3.50",
+  "version": "0.3.52",
   "description": "AI-Agent-friendly CLI for ClickZetta Lakehouse",
   "bin": {
     "cz-cli": "bin/run.js"
@@ -12,11 +12,11 @@
     "bin/"
   ],
   "optionalDependencies": {
-    "@clickzetta/cz-cli-darwin-arm64": "0.3.50",
-    "@clickzetta/cz-cli-darwin-x64": "0.3.50",
-    "@clickzetta/cz-cli-linux-arm64": "0.3.50",
-    "@clickzetta/cz-cli-linux-x64": "0.3.50",
-    "@clickzetta/cz-cli-win32-x64": "0.3.50"
+    "@clickzetta/cz-cli-darwin-arm64": "0.3.52",
+    "@clickzetta/cz-cli-darwin-x64": "0.3.52",
+    "@clickzetta/cz-cli-linux-arm64": "0.3.52",
+    "@clickzetta/cz-cli-linux-x64": "0.3.52",
+    "@clickzetta/cz-cli-win32-x64": "0.3.52"
   },
   "license": "MIT",
   "repository": {