chainlesschain 0.37.6 → 0.37.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chainlesschain",
-  "version": "0.37.6",
+  "version": "0.37.8",
   "description": "CLI for ChainlessChain - install, configure, and manage your personal AI management system",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourname/chainlesschain.git",
+    "url": "https://github.com/chainlesschain/chainlesschain.git",
     "directory": "packages/cli"
   },
   "homepage": "https://www.chainlesschain.com",

package/src/constants.js

@@ -9,7 +9,7 @@ const pkg = require(join(__dirname, "..", "package.json"));
 
 export const VERSION = pkg.version;
 
-export const GITHUB_OWNER = "yourname";
+export const GITHUB_OWNER = "chainlesschain";
 export const GITHUB_REPO = "chainlesschain";
 export const GITHUB_API_BASE = `https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO}`;
 export const GITHUB_RELEASES_URL = `${GITHUB_API_BASE}/releases`;
@@ -69,14 +69,7 @@ export const EDITIONS = {
   },
 };
 
-export const BINARY_NAMES = {
-  win32: { x64: "chainlesschain-desktop-vue-{version}-win-x64.exe" },
-  darwin: {
-    x64: "chainlesschain-desktop-vue-{version}-mac-x64.dmg",
-    arm64: "chainlesschain-desktop-vue-{version}-mac-arm64.dmg",
-  },
-  linux: { x64: "chainlesschain-desktop-vue-{version}-linux-x64.deb" },
-};
+// Asset matching is now done by platform patterns in downloader.js
 
 export const CONFIG_DIR_NAME = ".chainlesschain";
 

package/src/lib/downloader.js

@@ -1,30 +1,48 @@
-import { createWriteStream, existsSync, unlinkSync } from "node:fs";
+import {
+  createWriteStream,
+  existsSync,
+  unlinkSync,
+  readdirSync,
+  chmodSync,
+} from "node:fs";
 import { join } from "node:path";
 import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
+import { execSync } from "node:child_process";
 import ora from "ora";
 import { GITHUB_RELEASES_URL } from "../constants.js";
 import { getBinDir, ensureDir } from "./paths.js";
-import { getBinaryName } from "./platform.js";
-import { verifySha256 } from "./checksum.js";
+import { getPlatform, getArch } from "./platform.js";
 import logger from "./logger.js";
 
+// Platform-specific asset matching patterns
+const ASSET_PATTERNS = {
+  win32: { x64: /chainlesschain.*win32.*x64.*\.zip$/i },
+  darwin: {
+    x64: /chainlesschain.*darwin.*x64.*\.zip$/i,
+    arm64: /chainlesschain.*darwin.*arm64.*\.zip$/i,
+  },
+  linux: { x64: /chainlesschain.*linux.*x64.*\.zip$/i },
+};
+
 export async function downloadRelease(version, options = {}) {
-  const binaryName = getBinaryName(version);
   const binDir = ensureDir(getBinDir());
-  const destPath = join(binDir, binaryName);
 
-  if (existsSync(destPath) && !options.force) {
-    logger.info(`Binary already exists: ${binaryName}`);
-    return destPath;
+  // Check if we already have an extracted app
+  if (!options.force && hasExtractedApp(binDir)) {
+    logger.info("Application already installed");
+    return binDir;
   }
 
-  const releaseUrl =
-    options.url || (await resolveAssetUrl(version, binaryName));
-  const spinner = ora(`Downloading ${binaryName}...`).start();
+  const { url: assetUrl, name: assetName } = options.url
+    ? { url: options.url, name: "download.zip" }
+    : await resolveAssetUrl(version);
+
+  const destPath = join(binDir, assetName);
+  const spinner = ora(`Downloading ${assetName}...`).start();
 
   try {
-    const response = await fetch(releaseUrl, {
+    const response = await fetch(assetUrl, {
       headers: { Accept: "application/octet-stream" },
       redirect: "follow",
     });
@@ -52,7 +70,7 @@ export async function downloadRelease(version, options = {}) {
         downloadedBytes += value.byteLength;
         if (totalBytes > 0) {
           const pct = ((downloadedBytes / totalBytes) * 100).toFixed(1);
-          spinner.text = `Downloading ${binaryName}... ${pct}% (${formatBytes(downloadedBytes)}/${formatBytes(totalBytes)})`;
+          spinner.text = `Downloading ${assetName}... ${pct}% (${formatBytes(downloadedBytes)}/${formatBytes(totalBytes)})`;
         }
         controller.enqueue(value);
       },
@@ -62,23 +80,23 @@ export async function downloadRelease(version, options = {}) {
     await pipeline(nodeStream, createWriteStream(destPath));
 
     spinner.succeed(
-      `Downloaded ${binaryName} (${formatBytes(downloadedBytes)})`,
+      `Downloaded ${assetName} (${formatBytes(downloadedBytes)})`,
     );
 
-    if (options.checksum) {
-      const verifySpinner = ora("Verifying checksum...").start();
-      const result = await verifySha256(destPath, options.checksum);
-      if (!result.valid) {
+    // Extract zip
+    if (destPath.endsWith(".zip")) {
+      const extractSpinner = ora("Extracting...").start();
+      try {
+        extractZip(destPath, binDir);
         unlinkSync(destPath);
-        verifySpinner.fail("Checksum verification failed");
-        throw new Error(
-          `SHA256 mismatch: expected ${result.expected}, got ${result.actual}`,
-        );
+        extractSpinner.succeed("Extracted and ready");
+      } catch (err) {
+        extractSpinner.fail(`Extraction failed: ${err.message}`);
+        throw err;
       }
-      verifySpinner.succeed("Checksum verified");
     }
 
-    return destPath;
+    return binDir;
   } catch (err) {
     spinner.fail(`Download failed: ${err.message}`);
     if (existsSync(destPath)) {
@@ -88,27 +106,81 @@ export async function downloadRelease(version, options = {}) {
   }
 }
 
-async function resolveAssetUrl(version, binaryName) {
+async function resolveAssetUrl(version) {
+  // Try exact version first, then fall back to latest release
   const tagName = `v${version}`;
-  const url = `${GITHUB_RELEASES_URL}/tags/${tagName}`;
+  let release = await fetchRelease(`${GITHUB_RELEASES_URL}/tags/${tagName}`);
+
+  if (!release) {
+    logger.info(`Release ${tagName} not found, fetching latest release...`);
+    release = await fetchRelease(`${GITHUB_RELEASES_URL}/latest`);
+  }
+
+  if (!release) {
+    throw new Error("No releases found on GitHub");
+  }
+
+  logger.info(`Using release ${release.tag_name}`);
+
+  // Match asset by platform/arch pattern
+  const p = getPlatform();
+  const a = getArch();
+  const patterns = ASSET_PATTERNS[p];
+  if (!patterns) {
+    throw new Error(`Unsupported platform: ${p}`);
+  }
+  const pattern = patterns[a];
+  if (!pattern) {
+    throw new Error(`Unsupported architecture: ${a} on ${p}`);
+  }
+
+  const asset = release.assets.find((ast) => pattern.test(ast.name));
+  if (!asset) {
+    const available = release.assets.map((ast) => ast.name).join(", ");
+    throw new Error(
+      `No matching asset for ${p}/${a} in release ${release.tag_name}. Available: ${available}`,
+    );
+  }
 
+  return { url: asset.browser_download_url, name: asset.name };
+}
+
+async function fetchRelease(url) {
   const response = await fetch(url, {
     headers: { Accept: "application/vnd.github.v3+json" },
   });
+  if (!response.ok) return null;
+  return response.json();
+}
 
-  if (!response.ok) {
-    throw new Error(
-      `Failed to find release ${tagName}: HTTP ${response.status}`,
+function extractZip(zipPath, destDir) {
+  const p = getPlatform();
+  if (p === "win32") {
+    // Use PowerShell on Windows
+    execSync(
+      `powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`,
+      { stdio: "ignore" },
     );
+  } else {
+    execSync(`unzip -o "${zipPath}" -d "${destDir}"`, { stdio: "ignore" });
   }
+}
 
-  const release = await response.json();
-  const asset = release.assets.find((a) => a.name === binaryName);
-  if (!asset) {
-    throw new Error(`Asset ${binaryName} not found in release ${tagName}`);
+function hasExtractedApp(binDir) {
+  if (!existsSync(binDir)) return false;
+  try {
+    const files = readdirSync(binDir, { recursive: true });
+    return files.some(
+      (f) =>
+        (typeof f === "string" ? f : f.toString())
+          .toLowerCase()
+          .includes("chainlesschain") &&
+        ((typeof f === "string" ? f : f.toString()).endsWith(".exe") ||
+          !(typeof f === "string" ? f : f.toString()).includes(".")),
+    );
+  } catch {
+    return false;
   }
-
-  return asset.browser_download_url;
 }
 
 function formatBytes(bytes) {

package/src/lib/platform.js

@@ -1,5 +1,4 @@
 import { platform, arch } from "node:os";
-import { BINARY_NAMES } from "../constants.js";
 
 export function getPlatform() {
   return platform();
@@ -12,34 +11,6 @@ export function getArch() {
   return a;
 }
 
-export function getBinaryName(version) {
-  const p = getPlatform();
-  const a = getArch();
-  const platformBinaries = BINARY_NAMES[p];
-  if (!platformBinaries) {
-    throw new Error(`Unsupported platform: ${p}`);
-  }
-  const template = platformBinaries[a];
-  if (!template) {
-    throw new Error(`Unsupported architecture: ${a} on ${p}`);
-  }
-  return template.replace("{version}", version);
-}
-
-export function getBinaryExtension() {
-  const p = getPlatform();
-  switch (p) {
-    case "win32":
-      return ".exe";
-    case "darwin":
-      return ".dmg";
-    case "linux":
-      return ".deb";
-    default:
-      return "";
-  }
-}
-
 export function isWindows() {
   return getPlatform() === "win32";
 }

package/src/lib/process-manager.js

@@ -110,19 +110,40 @@ export function getAppPid() {
 function findExecutable(binDir, extension) {
   if (!existsSync(binDir)) return null;
   try {
-    const files = readdirSync(binDir);
-    const match = files.find((f) => {
-      const isChainless = f.toLowerCase().includes("chainlesschain");
-      if (extension) return isChainless && f.endsWith(extension);
-      return (
-        isChainless &&
-        !f.endsWith(".dmg") &&
-        !f.endsWith(".deb") &&
-        !f.endsWith(".sha256")
-      );
-    });
-    return match ? join(binDir, match) : null;
+    // Search recursively for the executable
+    const results = [];
+    searchDir(binDir, extension, results);
+    return results.length > 0 ? results[0] : null;
   } catch {
     return null;
   }
 }
+
+function searchDir(dir, extension, results) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      searchDir(fullPath, extension, results);
+    } else {
+      const name = entry.name.toLowerCase();
+      const isChainless = name.includes("chainlesschain");
+      if (!isChainless) continue;
+      if (extension && name.endsWith(extension)) {
+        results.push(fullPath);
+      } else if (
+        !extension &&
+        !name.endsWith(".dmg") &&
+        !name.endsWith(".deb") &&
+        !name.endsWith(".zip") &&
+        !name.endsWith(".sha256") &&
+        !name.endsWith(".dll") &&
+        !name.endsWith(".dat") &&
+        !name.endsWith(".pak") &&
+        !name.endsWith(".json")
+      ) {
+        results.push(fullPath);
+      }
+    }
+  }
+}