@mandors/cli 0.0.14 → 0.0.17

package/README.md

@@ -69,20 +69,120 @@ Mandor provides:
 
 ## Installation
 
-### From Source
+Mandor can be installed via curl, npm, or built from source.
 
+### Option 1: curl (Recommended for macOS/Linux)
+
+The fastest way to install Mandor on macOS or Linux:
+
+```bash
+# Install latest stable version (to ~/.local/bin)
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh
+
+# Install to custom directory
+curl -fsSL https://raw.githubusercontent.com/sanxzy/mandor/main/scripts/install.sh | sh -s -- --prefix /usr/local/bin
+
+# Install latest prerelease (beta versions)
+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.16
+```
+
+**Default install location:** `$HOME/.local/bin/mandor`
+
+**Add to PATH:**
+```bash
+# For bash
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc && source ~/.bashrc
+
+# For zsh
+echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc && source ~/.zshrc
+```
+
+**Verify installation:**
+```bash
+mandor --help
+```
+
+### Option 2: NPM (Cross-platform)
+
+Install via npm for macOS, Linux, or Windows:
+
+```bash
+# Install globally
+npm install -g @mandor/cli
+
+# Verify installation
+mandor --help
+```
+
+**Or use npx to run without installing:**
 ```bash
-git clone https://github.com/budisantoso/mandor.git
+npx @mandor/cli init "My Project"
+```
+
+**Programmatic usage:**
+```javascript
+const mandor = require('@mandor/cli');
+
+const cli = new mandor.Mandor({ json: true, cwd: '/project/path' });
+await cli.init('My Project');
+await cli.projectCreate('api', { name: 'API Service' });
+const tasks = await cli.taskList({ project: 'api', status: 'pending' });
+```
+
+### Option 3: From Source
+
+Build from Go source code:
+
+```bash
+# Clone repository
+git clone https://github.com/sanxzy/mandor.git
 cd mandor
+
+# Build binary
 go build -o build/mandor ./cmd/mandor
+
+# Install to system
 sudo mv build/mandor /usr/local/bin/
+
+# Verify
+mandor --help
 ```
 
-### From NPM
+### Platform Support
+
+| Method | macOS | Linux | Windows |
+|--------|-------|-------|---------|
+| curl | ✅ arm64, x64 | ✅ arm64, x64 | ❌ |
+| npm | ✅ arm64, x64 | ✅ arm64, x64 | ✅ arm64, x64 |
+| Source | ✅ | ✅ | ✅ |
+
+### Troubleshooting
+
+**curl: command not found**
+Install curl: `brew install curl` (macOS) or `sudo apt install curl` (Linux)
+
+**mandor: command not found**
+Ensure the install directory is in your PATH (see above)
 
+**Permission denied**
 ```bash
-npm install -g @mandor/cli
+# Fix permissions for ~/.local/bin
+chmod +x ~/.local/bin/mandor
+```
+
+**NPM permission errors**
+```bash
+# Use npx (no install)
 npx @mandor/cli init "My Project"
+
+# Or fix npm global permissions
+mkdir -p ~/.npm-global
+npm config set prefix '~/.npm-global'
+echo 'export PATH=~/.npm-global/bin:$PATH' >> ~/.bashrc
+source ~/.bashrc
 ```
 
 ---

package/npm/lib/install.js

@@ -1,154 +1,108 @@
 /**
  * @fileoverview Post-install hook for Mandor CLI
- * @description Handles binary download and caching during npm install
- * @version 0.0.1
+ * @description Downloads binary from GitHub releases during npm install
+ * @version 0.0.3
  */
 
-const { downloadBinary, getCurrentPlatform } = require('./download');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const { execSync } = require('child_process');
+
+const REPO = 'sanxzy/mandor';
+const GITHUB_API = 'https://api.github.com';
+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
+  };
+}
 
-/** @type {string} Cache directory for binaries */
-const CACHE_DIR = path.join(__dirname, '..', '.cache');
+async function getLatestVersion(prerelease = false) {
+  const url = prerelease
+    ? `${GITHUB_API}/repos/${REPO}/releases`
+    : `${GITHUB_API}/repos/${REPO}/releases/latest`;
 
-/** @type {string} Bundled binaries directory */
-const BUNDLE_DIR = path.join(__dirname, '..', 'binaries');
+  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, platform === 'win32' ? 'mandor.exe' : '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 version = 'latest';
-  const cacheDir = path.join(os.homedir(), '.mandor', 'bin', `${version}-${osArch}`);
-  const dest = path.join(cacheDir, 'mandor');
-
-  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 (fs.existsSync(binaryPath)) {
+    console.log(`Using cached binary: ${binaryPath}`);
+    return binaryPath;
   }
 
-  // Check if tarball exists
-  if (!fs.existsSync(tarball)) {
-    console.log(`DEBUG: No tarball found at: ${tarball}`);
-    return null;
-  }
+  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);
 
-  console.log(`DEBUG: Extracting tarball: ${tarball}`);
-
-  if (!fs.existsSync(cacheDir)) {
-    fs.mkdirSync(cacheDir, { recursive: true });
+  const response = await fetch(downloadUrl);
+  if (!response.ok) {
+    fs.rmSync(tempDir, { recursive: true });
+    throw new Error(`Download failed: ${response.statusText} (${downloadUrl})`);
   }
 
-  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 file = fs.createWriteStream(tarball);
+  await new Promise((resolve, reject) => {
+    response.body.pipe(file);
+    file.on('finish', resolve);
+    file.on('error', reject);
+  });
 
-/**
- * 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;
-
-  const files = fs.readdirSync(CACHE_DIR);
-  let removed = 0;
-
-  for (const file of files) {
-    const filePath = path.join(CACHE_DIR, file);
-    const stats = fs.statSync(filePath);
-
-    // 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 => {
+  const prerelease = process.argv.includes('--prerelease') || process.argv.includes('-p');
+  install({ prerelease }).catch(error => {
     console.error('Failed to install Mandor:', error.message);
     process.exit(1);
   });
 }
 
-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/npm/scripts/build.js

@@ -1,7 +1,7 @@
 /**
  * @fileoverview Cross-platform build script for Mandor binaries
  * @description Compiles Go binaries for all supported platforms and creates distribution archives
- * @version 0.0.1
+ * @version 0.0.2
  */
 
 const { execSync } = require('child_process');
@@ -9,13 +9,11 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-/**
- * @typedef {Object} PlatformConfig
- * @property {string} os - Operating system (darwin, linux, win32)
- * @property {string} arch - Architecture (x64, arm64)
- */
+const ROOT_DIR = path.join(__dirname, '..', '..');
+const BINARIES_DIR = path.join(ROOT_DIR, 'binaries');
+const NPM_DIR = path.join(ROOT_DIR, 'npm');
+const NPM_BINARIES_DIR = path.join(NPM_DIR, 'binaries');
 
-/** @type {PlatformConfig[]} All supported platform configurations */
 const PLATFORMS = [
   { os: 'darwin', arch: 'x64' },
   { os: 'darwin', arch: 'arm64' },
@@ -25,118 +23,105 @@ const PLATFORMS = [
   { os: 'win32', arch: 'arm64' }
 ];
 
-/**
- * Builds the Mandor binary for a specific platform
- * @param {PlatformConfig} platform - Platform configuration
- * @param {string} sourceDir - Source directory containing Go code
- * @returns {string|null} Path to the compiled binary, or null if unsupported
- * @example
- * const binaryPath = buildForPlatform({ os: 'darwin', arch: 'arm64' }, './cmd/mandor');
- */
-function buildForPlatform(platform, sourceDir) {
+function buildForPlatform(platform) {
   const { os, arch } = platform;
-  const outputDir = path.join(__dirname, '..', 'binaries', `${os}-${arch}`);
-  const outputPath = path.join(outputDir, os === 'win32' ? 'mandor.exe' : 'mandor');
+  const outputDir = path.join(BINARIES_DIR, `${os}-${arch}`);
+  const binaryName = os === 'win32' ? 'mandor.exe' : 'mandor';
+  const outputPath = path.join(outputDir, binaryName);
 
   fs.mkdirSync(outputDir, { recursive: true });
 
   console.log(`Building for ${os}-${arch}...`);
 
   try {
-    execSync(`GOOS=${os} GOARCH=${arch} go build -o "${outputPath}" ${sourceDir}`, {
+    execSync(`GOOS=${os} GOARCH=${arch} go build -o "${outputPath}" ./cmd/mandor`, {
       stdio: 'pipe',
       shell: process.platform === 'win32'
     });
     return outputPath;
   } catch (error) {
-    // Check stderr for unsupported pair message
     const stderr = error.stderr ? error.stderr.toString() : '';
     if (stderr.includes('unsupported GOOS/GOARCH pair')) {
-      console.log(`  ⊘ Not supported on this system`);
+      console.log(`  Not supported on this system`);
       return null;
     }
-    console.error(`  ✗ Build failed:`, error.message);
+    console.error(`  Build failed:`, error.message);
     throw error;
   }
 }
 
-/**
- * Creates a distribution archive for a platform
- * @param {PlatformConfig} platform - Platform configuration
- * @returns {string|null} Path to the archive file, or null if binary doesn't exist
- * @example
- * const archivePath = createArchive({ os: 'linux', arch: 'x64' });
- */
 function createArchive(platform) {
   const { os, arch } = platform;
-  const sourceDir = path.join(__dirname, '..', 'binaries', `${os}-${arch}`);
+  const sourceDir = path.join(BINARIES_DIR, `${os}-${arch}`);
+  const binaryName = os === 'win32' ? 'mandor.exe' : 'mandor';
 
-  // Check if binary exists
-  const binaryExists = fs.existsSync(path.join(sourceDir, os === 'win32' ? 'mandor.exe' : 'mandor'));
-  if (!binaryExists) {
+  if (!fs.existsSync(path.join(sourceDir, binaryName))) {
     return null;
   }
 
-  const archivePath = path.join(__dirname, '..', 'binaries', `${os}-${arch}.tar.gz`);
+  const archivePath = path.join(BINARIES_DIR, `${os}-${arch}.tar.gz`);
+
+  try {
+    execSync(`tar -czf "${archivePath}" -C "${sourceDir}" .`, {
+      stdio: 'pipe',
+      shell: true
+    });
+    return archivePath;
+  } catch (error) {
+    console.error(`  Failed to create archive:`, error.message);
+    return null;
+  }
+}
 
-  console.log(`Creating archive for ${os}-${arch}...`);
+function copyToNpm() {
+  fs.mkdirSync(NPM_BINARIES_DIR, { recursive: true });
 
-  execSync(`tar -czf "${archivePath}" -C "${sourceDir}" .`, {
-    stdio: 'inherit',
-    shell: true
-  });
+  for (const platform of PLATFORMS) {
+    const { os, arch } = platform;
+    const archivePath = path.join(BINARIES_DIR, `${os}-${arch}.tar.gz`);
+    const destPath = path.join(NPM_BINARIES_DIR, `${os}-${arch}.tar.gz`);
 
-  return archivePath;
+    if (fs.existsSync(archivePath)) {
+      fs.cpSync(archivePath, destPath);
+      console.log(`Copied ${os}-${arch}.tar.gz to npm/`);
+    }
+  }
 }
 
-/**
- * Main build function - attempts to build all platforms
- * @returns {Object[]} Build results for each successfully built platform
- * @example
- * const results = mainBuild();
- * console.log(`Built ${results.length} platforms`);
- */
-function mainBuild() {
-  const sourceDir = path.join(__dirname, '..', '..', 'cmd', 'mandor');
-  const results = [];
-  const unsupported = [];
+function cleanBuildDirs() {
+  if (fs.existsSync(BINARIES_DIR)) {
+    for (const entry of fs.readdirSync(BINARIES_DIR)) {
+      if (entry.endsWith('.tar.gz')) {
+        fs.unlinkSync(path.join(BINARIES_DIR, entry));
+      }
+    }
+  }
+}
 
+function mainBuild() {
   console.log(`Running on: ${os.platform()}/${os.arch()}`);
   console.log('Building cross-platform binaries...\n');
 
-  // Build all platforms
+  cleanBuildDirs();
+  fs.mkdirSync(NPM_BINARIES_DIR, { recursive: true });
+
+  const results = [];
+  const unsupported = [];
+
   for (const platform of PLATFORMS) {
-    const binaryPath = buildForPlatform(platform, sourceDir);
+    const binaryPath = buildForPlatform(platform);
     if (binaryPath) {
-      results.push({
-        platform: platform.os,
-        arch: platform.arch,
-        binaryPath,
-        status: 'built'
-      });
-      console.log(`  ✓ Built successfully\n`);
+      results.push({ platform: platform.os, arch: platform.arch, binaryPath, status: 'built' });
+      console.log(`  Built successfully\n`);
     } else {
-      unsupported.push({
-        platform: platform.os,
-        arch: platform.arch,
-        status: 'unsupported'
-      });
+      unsupported.push({ platform: platform.os, arch: platform.arch, status: 'unsupported' });
     }
   }
 
-  // Create archives for successfully built platforms
-  const archiveResults = [];
   for (const platform of PLATFORMS) {
     const archivePath = createArchive(platform);
     if (archivePath) {
       const stats = fs.statSync(archivePath);
-      archiveResults.push({
-        platform: platform.os,
-        arch: platform.arch,
-        archivePath,
-        archiveSize: stats.size
-      });
-
       const existing = results.find(r => r.platform === platform.os && r.arch === platform.arch);
       if (existing) {
         existing.archivePath = archivePath;
@@ -145,10 +130,12 @@ function mainBuild() {
     }
   }
 
-  // Summary
+  console.log('Copying archives to npm/binaries/ for npm package...');
+  copyToNpm();
+
   console.log('─'.repeat(50));
   console.log(`Build complete!`);
-  console.log(`  Built: ${archiveResults.length} platforms`);
+  console.log(`  Built: ${results.length} platforms`);
   console.log(`  Unsupported: ${unsupported.length} platforms`);
 
   if (unsupported.length > 0) {
@@ -158,10 +145,12 @@ function mainBuild() {
     });
   }
 
-  return archiveResults;
+  console.log(`\nArchives location: ${BINARIES_DIR}/`);
+  console.log(`NPM package binaries: ${NPM_BINARIES_DIR}/`);
+
+  return results;
 }
 
-// Run if executed directly
 if (require.main === module) {
   const results = mainBuild();
   if (results.length > 0) {
@@ -170,14 +159,7 @@ if (require.main === module) {
       Platform: `${r.platform}/${r.arch}`,
       'Archive Size': `${(r.archiveSize / 1024).toFixed(1)} KB`
     })));
-
-    console.log('Archives location: npm/binaries/');
   }
 }
 
-module.exports = {
-  PLATFORMS,
-  buildForPlatform,
-  createArchive,
-  mainBuild
-};
+module.exports = { PLATFORMS, buildForPlatform, createArchive, mainBuild, copyToNpm };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandors/cli",
-  "version": "0.0.14",
+  "version": "0.0.17",
   "description": "Event-based task manager CLI for AI agent workflows",
   "main": "npm/lib/index.js",
   "bin": {
@@ -19,9 +19,7 @@
     "node": ">=16.0.0"
   },
   "scripts": {
-    "postinstall": "node npm/lib/install.js",
-    "prepublishOnly": "npm run build",
-    "preversion": "npm run build",
+    "postinstall": "node npm/lib/install.js --prerelease",
     "build": "node npm/scripts/build.js",
     "build:darwin:x64": "GOOS=darwin GOARCH=x64 go build -o binaries/darwin-x64/mandor ./cmd/mandor",
     "build:darwin:arm64": "GOOS=darwin GOARCH=arm64 go build -o binaries/darwin-arm64/mandor ./cmd/mandor",

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