@mandors/cli 0.0.13 → 0.0.16

package/README.md

@@ -69,22 +69,58 @@ Mandor provides:
 
 ## Installation
 
-### From Source
+Choose one of the following methods:
+
+### Option 1: curl (Recommended)
 
 ```bash
-git clone https://github.com/budisantoso/mandor.git
-cd mandor
-go build -o build/mandor ./cmd/mandor
-sudo mv build/mandor /usr/local/bin/
+# Install latest stable version
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh
+
+# Or install to custom directory
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --prefix ~/bin
+
+# Install latest prerelease
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --prerelease
+
+# Install specific version
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --version v0.0.14
+```
+
+Default install location: `$HOME/.local/bin/mandor`
+
+Add to PATH if needed:
+```bash
+export PATH="$HOME/.local/bin:$PATH"
 ```
 
-### From NPM
+### Option 2: NPM
 
 ```bash
+# Install globally
 npm install -g @mandor/cli
+
+# Or use npx without installing
 npx @mandor/cli init "My Project"
 ```
 
+### Option 3: From Source
+
+```bash
+git clone https://github.com/sanxzy/mandor.git
+cd mandor
+go build -o build/mandor ./cmd/mandor
+sudo mv build/mandor /usr/local/bin/
+```
+
+### Platform Support
+
+| Method | macOS | Linux | Windows |
+|--------|-------|-------|---------|
+| curl | ✅ arm64, x64 | ✅ arm64, x64 | ❌ |
+| NPM | ✅ arm64, x64 | ✅ arm64, x64 | ✅ arm64, x64 |
+| Source | ✅ | ✅ | ✅ |
+
 ---
 
 ## Quick Start

package/npm/lib/install.js

@@ -1,144 +1,118 @@
 /**
  * @fileoverview Post-install hook for Mandor CLI
- * @description Handles binary download and caching during npm install
- * @version 0.0.1
+ * @description Handles binary extraction during npm install
+ * @version 0.0.2
  */
 
-const { downloadBinary, getCurrentPlatform } = require('./download');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execSync } = require('child_process');
 
-/** @type {string} Cache directory for binaries */
-const CACHE_DIR = path.join(__dirname, '..', '.cache');
-
-/** @type {string} Bundled binaries directory */
+const REPO = 'sanxzy/mandor';
+const GITHUB_API = 'https://api.github.com';
 const BUNDLE_DIR = path.join(__dirname, '..', 'binaries');
+const CACHE_DIR = path.join(os.homedir(), '.mandor', 'bin');
+
+function getPlatform() {
+  const platform = os.platform();
+  const arch = os.arch();
+  const platformMap = { darwin: 'darwin', linux: 'linux', win32: 'win32' };
+  const archMap = { x64: 'x64', arm64: 'arm64', amd64: 'x64', aarch64: 'arm64' };
+  return {
+    platform: platformMap[platform] || platform,
+    arch: archMap[arch] || arch
+  };
+}
+
+async function getLatestVersion(prerelease = false) {
+  const url = prerelease
+    ? `${GITHUB_API}/repos/${REPO}/releases`
+    : `${GITHUB_API}/repos/${REPO}/releases/latest`;
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch releases: ${response.statusText}`);
+  }
+  const data = await response.json();
+  const tagName = Array.isArray(data) ? data[0].tag_name : data.tag_name;
+  return tagName.replace(/^v/, '');
+}
 
-/**
- * Installs the Mandor binary for the current platform
- * @async
- * @param {Object} [options] - Installation options
- * @param {string} [options.version] - Version to install (default: 'latest')
- * @returns {Promise<string>} Path to the installed binary
- * @throws {Error} If download fails
- * @example
- * // Called automatically by npm postinstall
- * await install();
- */
 async function install(options = {}) {
+  const { platform, arch } = getPlatform();
   const version = options.version || 'latest';
-  const { platform, arch } = getCurrentPlatform();
-
-  console.log(`Installing Mandor ${version} for ${platform}-${arch}...`);
+  const prerelease = options.prerelease || false;
+  const osArch = `${platform}-${arch}`;
+  const assetName = `${osArch}.tar.gz`;
 
-  let binaryPath;
+  console.log('Mandor Installer');
+  console.log('================');
+  console.log(`OS: ${osArch}`);
 
-  // Try bundled binary first
-  const bundledPath = useBundledBinary(platform, arch);
-  if (bundledPath) {
-    console.log(`✓ Using bundled binary`);
-    binaryPath = bundledPath;
-  } else {
-    // Download from GitHub releases
-    binaryPath = await downloadBinary(version, platform, arch);
+  let installVersion = version;
+  if (version === 'latest') {
+    console.log(`Fetching latest ${prerelease ? 'prerelease' : 'release'}...`);
+    installVersion = await getLatestVersion(prerelease);
   }
 
-  console.log(`✓ Mandor installed: ${binaryPath}`);
+  console.log(`Version: ${installVersion}`);
+  console.log('');
 
-  return binaryPath;
-}
+  const cachePath = path.join(CACHE_DIR, installVersion, osArch);
+  const binaryPath = path.join(cachePath, 'mandor');
 
-/**
- * Uses bundled binary if available for current platform
- * @param {string} platform - Target platform
- * @param {string} arch - Target architecture
- * @returns {string|null} Path to binary or null if not bundled
- */
-function useBundledBinary(platform, arch) {
-  const osArch = `${platform}-${arch}`;
-  const tarball = path.join(BUNDLE_DIR, `${osArch}.tar.gz`);
-  const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
-  const dest = path.join(cacheDir, osArch);
-
-  console.log(`DEBUG: Looking for binary for ${osArch}`);
-  console.log(`DEBUG: BUNDLE_DIR: ${BUNDLE_DIR}`);
-  console.log(`DEBUG: Files in BUNDLE_DIR: ${fs.readdirSync(BUNDLE_DIR).join(', ')}`);
-
-  // First check if binary already exists in cache
-  if (fs.existsSync(dest)) {
-    console.log(`DEBUG: Using cached binary: ${dest}`);
-    return dest;
+  if (platform === 'win32') {
+    binaryPath = binaryPath + '.exe';
   }
 
-  // Check if tarball exists
-  if (!fs.existsSync(tarball)) {
-    console.log(`DEBUG: No tarball found at: ${tarball}`);
-    return null;
+  if (fs.existsSync(binaryPath)) {
+    console.log(`Using cached binary: ${binaryPath}`);
+    return binaryPath;
   }
 
-  console.log(`DEBUG: Extracting tarball: ${tarball}`);
-
-  if (!fs.existsSync(cacheDir)) {
-    fs.mkdirSync(cacheDir, { recursive: true });
-  }
-
-  try {
-    const { execSync } = require('child_process');
-    execSync(`tar -xzf "${tarball}" -C "${cacheDir}"`, { stdio: 'pipe' });
-    fs.chmodSync(dest, '755');
-    console.log(`DEBUG: Extracted to: ${dest}`);
-    return dest;
-  } catch (e) {
-    console.log(`DEBUG: Failed to extract tarball: ${e.message}`);
-    return null;
+  const bundledPath = path.join(BUNDLE_DIR, assetName);
+  if (fs.existsSync(bundledPath)) {
+    console.log(`Using bundled binary: ${bundledPath}`);
+    if (!fs.existsSync(cachePath)) {
+      fs.mkdirSync(cachePath, { recursive: true });
+    }
+    execSync(`tar -xzf "${bundledPath}" -C "${cachePath}"`, { stdio: 'inherit' });
+    fs.chmodSync(binaryPath, '755');
+    console.log(`Installed: ${binaryPath}`);
+    return binaryPath;
   }
-}
 
-/**
- * Cleans up old binary caches
- * @returns {number} Number of files removed
- * @example
- * const removed = cleanupCache();
- * console.log(`Removed ${removed} old binary files`);
- */
-function cleanupCache() {
-  if (!fs.existsSync(CACHE_DIR)) return 0;
+  console.log('Downloading from GitHub releases...');
+  const downloadUrl = `https://github.com/${REPO}/releases/download/v${installVersion}/${assetName}`;
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mandor-install-'));
+  const tarball = path.join(tempDir, assetName);
 
-  const files = fs.readdirSync(CACHE_DIR);
-  let removed = 0;
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.statusText} (${downloadUrl})`);
+  }
 
-  for (const file of files) {
-    const filePath = path.join(CACHE_DIR, file);
-    const stats = fs.statSync(filePath);
+  const file = fs.createWriteStream(tarball);
+  await new Promise((resolve, reject) => {
+    response.body.pipe(file);
+    file.on('finish', resolve);
+    file.on('error', reject);
+  });
 
-    // Remove files older than 30 days
-    const thirtyDaysAgo = Date.now() - (30 * 24 * 60 * 60 * 1000);
-    if (stats.mtimeMs < thirtyDaysAgo) {
-      fs.unlinkSync(filePath);
-      removed++;
-    }
+  if (!fs.existsSync(cachePath)) {
+    fs.mkdirSync(cachePath, { recursive: true });
   }
 
-  return removed;
-}
+  execSync(`tar -xzf "${tarball}" -C "${cachePath}"`, { stdio: 'inherit' });
+  fs.chmodSync(binaryPath, '755');
 
-/**
- * Gets the installed binary version
- * @returns {string|null} Version string or null if not installed
- * @example
- * const version = getInstalledVersion();
- * if (version) { console.log(`Using Mandor ${version}`); }
- */
-function getInstalledVersion() {
-  const versionPath = path.join(CACHE_DIR, 'version.txt');
-  if (fs.existsSync(versionPath)) {
-    return fs.readFileSync(versionPath, 'utf-8').trim();
-  }
-  return null;
+  fs.rmSync(tempDir, { recursive: true });
+
+  console.log(`Installed: ${binaryPath}`);
+  return binaryPath;
 }
 
-// Run install on postinstall
 if (require.main === module || process.env.npm_lifecycle_event === 'postinstall') {
   install().catch(error => {
     console.error('Failed to install Mandor:', error.message);
@@ -146,8 +120,4 @@ if (require.main === module || process.env.npm_lifecycle_event === 'postinstall'
   });
 }
 
-module.exports = {
-  install,
-  cleanupCache,
-  getInstalledVersion
-};
+module.exports = { install, getLatestVersion, getPlatform };

package/npm/lib/resolve.js

@@ -1,59 +1,22 @@
 /**
  * @fileoverview Version resolution module for Mandor CLI
  * @description Resolves the correct binary path based on version and platform
- * @version 0.0.1
+ * @version 0.0.2
  */
 
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
-const { downloadBinary, getCurrentPlatform, binaryExists } = require('./download');
+const { downloadBinary, getCurrentPlatform } = require('./download');
 
-/** @type {string} Default version to use */
+const REPO = 'sanxzy/mandor';
+const GITHUB_API = 'https://api.github.com';
 const DEFAULT_VERSION = 'latest';
 
-/**
- * Resolves the binary path for the requested version
- * @async
- * @param {Object} [options] - Resolution options
- * @param {string} [options.version] - Requested version (default: 'latest')
- * @param {boolean} [options.forceDownload] - Force re-download even if cached
- * @returns {Promise<string>} Path to the Mandor binary
- * @throws {Error} If binary cannot be resolved or downloaded
- * @example
- * const binaryPath = await resolve({ version: '1.0.0' });
- * console.log(`Using: ${binaryPath}`);
- */
-async function resolve(options = {}) {
-  const version = options.version || DEFAULT_VERSION;
-  const { platform, arch } = getCurrentPlatform();
-
-  // Check cache first
-  const cachedPath = getCachedBinary(version, platform, arch);
-  if (cachedPath && !options.forceDownload) {
-    return cachedPath;
-  }
-
-  // Download if not cached
-  const binaryPath = await downloadBinary(version, platform, arch);
-  cacheBinary(binaryPath, version, platform, arch);
-
-  return binaryPath;
-}
-
-/**
- * Gets the cached binary path for a specific version
- * @param {string} version - Version to look for
- * @param {string} platform - Target platform
- * @param {string} arch - Target architecture
- * @returns {string|null} Path to cached binary or null
- * @example
- * const cached = getCachedBinary('1.0.0', 'darwin', 'x64');
- */
 function getCachedBinary(version, platform, arch) {
-  const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
+  const osArch = `${platform}-${arch}`;
   const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
-  const binaryPath = path.join(cacheDir, `${version}-${platform}-${arch}`, binaryName);
+  const binaryPath = path.join(os.homedir(), '.mandor', 'bin', version, osArch, binaryName);
 
   if (fs.existsSync(binaryPath)) {
     return binaryPath;
@@ -61,18 +24,23 @@ function getCachedBinary(version, platform, arch) {
   return null;
 }
 
-/**
- * Caches a binary for future use
- * @param {string} binaryPath - Path to the binary
- * @param {string} version - Version identifier
- * @param {string} platform - Target platform
- * @param {string} arch - Target architecture
- * @returns {void}
- * @example
- * cacheBinary('/home/user/.mandor/bin/1.0.0-darwin-x64/mandor', '1.0.0', 'darwin', 'x64');
- */
+async function getLatestVersion(prerelease = false) {
+  const url = prerelease
+    ? `${GITHUB_API}/repos/${REPO}/releases`
+    : `${GITHUB_API}/repos/${REPO}/releases/latest`;
+
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch releases: ${response.statusText}`);
+  }
+  const data = await response.json();
+  const tagName = Array.isArray(data) ? data[0].tag_name : data.tag_name;
+  return tagName.replace(/^v/, '');
+}
+
 function cacheBinary(binaryPath, version, platform, arch) {
-  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', `${version}-${platform}-${arch}`);
+  const osArch = `${platform}-${arch}`;
+  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', version, osArch);
   fs.mkdirSync(cacheDir, { recursive: true });
 
   const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
@@ -82,13 +50,54 @@ function cacheBinary(binaryPath, version, platform, arch) {
   fs.chmodSync(destPath, '755');
 }
 
-/**
- * Lists all cached binary versions
- * @returns {Object[]} Array of cached binary info
- * @example
- * const cached = listCachedBinaries();
- * cached.forEach(b => console.log(`${b.version} (${b.platform}-${b.arch})`));
- */
+async function resolve(options = {}) {
+  const version = options.version || DEFAULT_VERSION;
+  const { platform, arch } = getCurrentPlatform();
+  const prerelease = options.prerelease || false;
+
+  let resolveVersion = version;
+  if (version === 'latest') {
+    resolveVersion = await getLatestVersion(prerelease);
+  }
+
+  const cachedPath = getCachedBinary(resolveVersion, platform, arch);
+  if (cachedPath && !options.forceDownload) {
+    return cachedPath;
+  }
+
+  const osArch = `${platform}-${arch}`;
+  const downloadUrl = `https://github.com/${REPO}/releases/download/v${resolveVersion}/${osArch}.tar.gz`;
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mandor-download-'));
+  const tarball = path.join(tempDir, `${osArch}.tar.gz`);
+
+  console.log(`Downloading Mandor ${resolveVersion}...`);
+
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    fs.rmSync(tempDir, { recursive: true });
+    throw new Error(`Download failed: ${response.statusText}`);
+  }
+
+  const file = fs.createWriteStream(tarball);
+  await new Promise((resolve, reject) => {
+    response.body.pipe(file);
+    file.on('finish', resolve);
+    file.on('error', reject);
+  });
+
+  const binaryName = platform === 'win32' ? 'mandor.exe' : 'mandor';
+  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', resolveVersion, osArch);
+  fs.mkdirSync(cacheDir, { recursive: true });
+
+  const { execSync } = require('child_process');
+  execSync(`tar -xzf "${tarball}" -C "${cacheDir}"`, { stdio: 'pipe' });
+  fs.chmodSync(path.join(cacheDir, binaryName), '755');
+
+  fs.rmSync(tempDir, { recursive: true });
+
+  return path.join(cacheDir, binaryName);
+}
+
 function listCachedBinaries() {
   const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
 
@@ -100,23 +109,24 @@ function listCachedBinaries() {
   const entries = fs.readdirSync(cacheDir);
 
   for (const entry of entries) {
-    const entryPath = path.join(cacheDir, entry);
-    if (fs.statSync(entryPath).isDirectory()) {
-      const [version, platform, arch] = entry.split('-');
-      versions.push({ version, platform, arch, path: entryPath });
+    const versionPath = path.join(cacheDir, entry);
+    if (fs.statSync(versionPath).isDirectory()) {
+      const subEntries = fs.readdirSync(versionPath);
+      for (const subEntry of subEntries) {
+        const subPath = path.join(versionPath, subEntry);
+        if (fs.statSync(subPath).isDirectory()) {
+          const parts = subEntry.split('-');
+          const arch = parts.pop();
+          const platform = parts.join('-');
+          versions.push({ version: entry, platform, arch, path: subPath });
+        }
+      }
     }
   }
 
   return versions;
 }
 
-/**
- * Clears all cached binaries
- * @returns {number} Number of binaries removed
- * @example
- * const removed = clearCache();
- * console.log(`Cleared ${removed} cached binaries`);
- */
 function clearCache() {
   const cacheDir = path.join(os.homedir(), '.mandor', 'bin');
 
@@ -144,5 +154,6 @@ module.exports = {
   cacheBinary,
   listCachedBinaries,
   clearCache,
-  DEFAULT_VERSION
+  DEFAULT_VERSION,
+  getLatestVersion
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandors/cli",
-  "version": "0.0.13",
+  "version": "0.0.16",
   "description": "Event-based task manager CLI for AI agent workflows",
   "main": "npm/lib/index.js",
   "bin": {

package/scripts/install.sh

@@ -0,0 +1,105 @@
+#!/bin/sh
+#
+# install.sh - Install Mandor CLI
+#
+# Usage:
+#   curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh
+#   curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --help
+#
+# Options:
+#   --prefix DIR     Install prefix (default: $HOME/.local)
+#   --version VER    Install specific version (default: latest)
+#   --prerelease     Install latest prerelease
+#   --help           Show this help
+#
+
+set -e
+
+REPO="sanxzy/mandor"
+INSTALL_DIR="${HOME}/.local/bin"
+VERSION="latest"
+PRERELEASE=""
+TAG="latest"
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --prefix)
+            INSTALL_DIR="$2"
+            shift 2
+            ;;
+        --version)
+            VERSION="$2"
+            shift 2
+            ;;
+        --prerelease)
+            PRERELEASE="1"
+            TAG="latest"
+            shift
+            ;;
+        --help|-h)
+            head -20 "$0"
+            exit 0
+            ;;
+    esac
+done
+
+OS=$(uname -s | tr '[:upper:]' '[:lower:]')
+ARCH=$(uname -m)
+case "$ARCH" in
+    x86_64|amd64) ARCH="x64" ;;
+    arm64|aarch64) ARCH="arm64" ;;
+esac
+
+case "$OS" in
+    darwin) ;;
+    linux) ;;
+    *)
+        echo "Unsupported OS: $OS"
+        exit 1
+        ;;
+esac
+
+echo "Mandor Installer"
+echo "================"
+echo "OS: $OS-$ARCH"
+
+if [ "$VERSION" = "latest" ]; then
+    if [ -n "$PRERELEASE" ]; then
+        echo "Fetching latest prerelease..."
+        VERSION=$(curl -s "https://api.github.com/repos/${REPO}/releases" | sed -n 's/.*"tag_name": *"\([^"]*\)".*/\1/p' | head -1)
+    else
+        echo "Fetching latest release..."
+        VERSION=$(curl -s "https://api.github.com/repos/${REPO}/releases/latest" | sed -n 's/.*"tag_name": *"\([^"]*\)".*/\1/p')
+    fi
+fi
+
+echo "Version: $VERSION"
+echo "Install dir: $INSTALL_DIR"
+echo ""
+
+ASSET_NAME="${OS}-${ARCH}.tar.gz"
+DOWNLOAD_URL="https://github.com/${REPO}/releases/download/${VERSION}/${ASSET_NAME}"
+TEMP_DIR=$(mktemp -d)
+TARFILE="${TEMP_DIR}/${ASSET_NAME}"
+
+echo "Downloading ${ASSET_NAME}..."
+if ! curl -fsSL -o "$TARFILE" "$DOWNLOAD_URL"; then
+    echo "Download failed: $DOWNLOAD_URL"
+    rm -rf "$TEMP_DIR"
+    exit 1
+fi
+
+echo "Extracting..."
+mkdir -p "$INSTALL_DIR"
+tar -xzf "$TARFILE" -C "$INSTALL_DIR"
+chmod 755 "${INSTALL_DIR}/mandor"
+
+rm -rf "$TEMP_DIR"
+
+echo ""
+echo "Installed: ${INSTALL_DIR}/mandor"
+echo ""
+
+if [ -d "$HOME/.local/bin" ]; then
+    echo "Add to PATH: export PATH=\"\$HOME/.local/bin:\$PATH\""
+fi