anveesa 0.2.0 → 0.2.1

package/.github/workflows/release.yml

@@ -0,0 +1,68 @@
+name: Release Binaries
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+          - os: ubuntu-latest
+            target: aarch64-unknown-linux-gnu
+          - os: macos-latest
+            target: x86_64-apple-darwin
+          - os: macos-latest
+            target: aarch64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust
+        uses: dtolnay/rust-action@stable
+        with:
+          targets: ${{ matrix.target }}
+
+      - name: Install cross-compilation tools (Linux ARM64)
+        if: matrix.target == 'aarch64-unknown-linux-gnu'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu
+          echo 'CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc' >> $GITHUB_ENV
+
+      - name: Build
+        run: cargo build --release --target ${{ matrix.target }}
+
+      - name: Package binary
+        shell: bash
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          BIN_DIR=release-artifacts
+          mkdir -p $BIN_DIR
+          
+          if [[ "${{ matrix.os }}" == "windows-latest" ]]; then
+            cp target/${{ matrix.target }}/release/anveesa.exe $BIN_DIR/anveesa.exe
+            cd $BIN_DIR && tar czf ../anveesa-$VERSION-${{ matrix.target }}.tar.gz anveesa.exe
+          else
+            cp target/${{ matrix.target }}/release/anveesa $BIN_DIR/anveesa
+            chmod +x $BIN_DIR/anveesa
+            cd $BIN_DIR && tar czf ../anveesa-$VERSION-${{ matrix.target }}.tar.gz anveesa
+          fi
+
+      - name: Upload to Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: anveesa-*.tar.gz
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/bin/anveesa.js

@@ -1,37 +1,24 @@
 #!/usr/bin/env node
 
-const { execFile } = require('child_process');
+const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-// Cari binary di beberapa kemungkinan lokasi
 function findBinary() {
-  const candidates = [
-    // Installed via npm (global) - binary di samping script
-    path.join(__dirname, 'target', 'release', 'anveesa'),
-    path.join(__dirname, 'target', 'debug', 'anveesa'),
-    // Installed via npm local (node_modules/.bin)
-    path.join(__dirname, '..', '..', 'target', 'release', 'anveesa'),
-    path.join(__dirname, '..', '..', 'target', 'debug', 'anveesa'),
-    // Development mode (cargo build)
-    path.join(process.cwd(), 'target', 'release', 'anveesa'),
-    path.join(process.cwd(), 'target', 'debug', 'anveesa'),
-  ];
+  const platform = process.platform;
+  const ext = platform === 'win32' ? '.exe' : '';
+
+  // Binary is shipped in the package bin/ directory
+  const bundled = path.join(__dirname, 'anveesa' + ext);
+  if (fs.existsSync(bundled)) return bundled;
 
-  for (const p of candidates) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
+  // Also check for target/release (dev mode)
+  const devPath = path.join(__dirname, '..', 'target', 'release', 'anveesa' + ext);
+  if (fs.existsSync(devPath)) return devPath;
 
-  // Cek PATH environment
-  const paths = process.env.PATH.split(path.delimiter);
-  for (const p of paths) {
-    const full = path.join(p, 'anveesa');
-    if (fs.existsSync(full)) {
-      return full;
-    }
-  }
+  // Check if there's a sibling directory with the binary
+  const sibling = path.join(__dirname, 'target', 'release', 'anveesa' + ext);
+  if (fs.existsSync(sibling)) return sibling;
 
   return null;
 }
@@ -41,15 +28,11 @@ const binaryPath = findBinary();
 if (!binaryPath) {
   console.error('❌ anveesa binary not found.');
   console.error('');
-  console.error('Build the Rust binary first:');
-  console.error('  cd ' + __dirname + ' && npm run build');
-  console.error('  # or: cargo build --release');
-  console.error('');
+  console.error('Try reinstalling: npm install -g anveesa');
+  console.error('Or build from source: cargo build --release');
   process.exit(1);
 }
 
-// Spawn the Rust binary with proper TTY support
-const { spawn } = require('child_process');
 const args = process.argv.slice(2);
 const child = spawn(binaryPath, args, {
   cwd: process.cwd(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {
@@ -8,9 +8,8 @@
   },
   "scripts": {
     "build": "cargo build --release",
-    "install": "node scripts/install.js",
-    "prepublishOnly": "npm run build",
-    "install:bin": "cargo build --release"
+    "postinstall": "node scripts/install.js",
+    "prepublishOnly": "npm run build"
   },
   "files": [
     "bin/",
@@ -18,16 +17,25 @@
     "Cargo.toml",
     "Cargo.lock",
     "src/",
-    "README.md"
+    "README.md",
+    ".github/"
+  ],
+  "keywords": [
+    "ai",
+    "cli",
+    "terminal",
+    "rust",
+    "openai",
+    "agent",
+    "copilot"
   ],
-  "keywords": ["ai", "cli", "terminal", "rust", "openai", "agent", "copilot"],
   "license": "MIT",
   "engines": {
     "node": ">=16"
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/pandhuwibowo/anveesa-cli.git"
+    "url": "git+https://github.com/pandhuwibowo/anveesa-cli.git"
   },
   "homepage": "https://github.com/pandhuwibowo/anveesa-cli",
   "bugs": {

package/scripts/install.js

@@ -7,66 +7,141 @@
 
 const fs = require('fs');
 const path = require('path');
+const https = require('https');
 const { execSync } = require('child_process');
 
-function getBinaryPath() {
-  const pkgDir = __dirname;
-  const possiblePaths = [
-    path.join(pkgDir, '..', 'target', 'debug', 'anveesa'),
-    path.join(pkgDir, '..', 'target', 'release', 'anveesa'),
-    path.join(pkgDir, 'target', 'debug', 'anveesa'),
-    path.join(pkgDir, 'target', 'release', 'anveesa'),
-  ];
-  
-  for (const p of possiblePaths) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
-  
+const PACKAGE = require(path.join(__dirname, '..', 'package.json'));
+const REPO = 'pandhuwibowo/anveesa-cli';
+const BIN_DIR = path.join(__dirname, 'bin');
+
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  if (platform === 'darwin' && arch === 'arm64')
+    return { platform: 'macos', target: 'aarch64-apple-darwin', ext: '' };
+  if (platform === 'darwin' && arch === 'x64')
+    return { platform: 'macos', target: 'x86_64-apple-darwin', ext: '' };
+  if (platform === 'linux' && arch === 'x64')
+    return { platform: 'linux', target: 'x86_64-unknown-linux-gnu', ext: '' };
+  if (platform === 'linux' && arch === 'arm64')
+    return { platform: 'linux', target: 'aarch64-unknown-linux-gnu', ext: '' };
+  if (platform === 'win32' && arch === 'x64')
+    return { platform: 'windows', target: 'x86_64-pc-windows-msvc', ext: '.exe' };
+
   return null;
 }
 
-function checkAndInstall() {
-  const binaryPath = getBinaryPath();
-  
-  if (binaryPath) {
-    console.log('✓ Anveesa binary found at:', binaryPath);
-    console.log('✓ Installation complete!');
-    return true;
-  } else {
-    // Try to build automatically
-    try {
-      console.log('⚙ Building anveesa binary from source...');
-      execSync('cargo build --release', {
-        cwd: path.join(__dirname, '..'),
-        stdio: 'inherit'
-      });
-      const rebuilt = getBinaryPath();
-      if (rebuilt) {
-        console.log('✓ Binary built successfully at:', rebuilt);
-        console.log('✓ Installation complete!');
-        return true;
+function getBinaryUrl() {
+  const info = getPlatformInfo();
+  if (!info) return null;
+  const version = PACKAGE.version;
+  return `https://github.com/${REPO}/releases/download/v${version}/anveesa-${version}-${info.target}.tar.gz`;
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, { followAllRedirects: true }, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        https.get(res.headers.location, (res2) => {
+          res2.pipe(file);
+          file.on('finish', () => { file.close(); resolve(); });
+        }).on('error', reject);
+      } else if (res.statusCode === 200) {
+        res.pipe(file);
+        file.on('finish', () => { file.close(); resolve(); });
+      } else if (res.statusCode === 404) {
+        file.close();
+        fs.unlink(dest, () => {});
+        reject(new Error('404'));
+      } else {
+        file.close();
+        fs.unlink(dest, () => {});
+        reject(new Error(`HTTP ${res.statusCode}`));
       }
-    } catch (e) {
-      // cargo not available or build failed
+    }).on('error', (err) => {
+      fs.unlink(dest, () => {});
+      reject(err);
+    });
+  });
+}
+
+async function tryDownloadBinary() {
+  const url = getBinaryUrl();
+  if (!url) {
+    console.log('⚠ Unsupported platform:', process.platform, process.arch);
+    return false;
+  }
+
+  console.log('⬇ Downloading prebuilt binary for', process.platform, process.arch);
+
+  try {
+    const tarPath = path.join(__dirname, 'anveesa-bin.tar.gz');
+    await download(url, tarPath);
+
+    // Extract
+    execSync(`tar xzf "${tarPath}" -C "${BIN_DIR}"`, { stdio: 'inherit' });
+    fs.unlinkSync(tarPath);
+
+    // Make executable
+    const binary = path.join(BIN_DIR, 'anveesa');
+    if (fs.existsSync(binary)) {
+      fs.chmodSync(binary, 0o755);
     }
 
-    console.error('✗ Anveesa binary not found and could not be built.');
-    console.error('');
-    console.error('Make sure Rust is installed: https://rustup.rs/');
-    console.error('Then run:');
-    console.error('  cargo build --release');
+    console.log('✓ Binary downloaded successfully');
+    return true;
+  } catch (e) {
+    if (e.message === '404') {
+      console.log('ℹ No prebuilt binary for this version yet');
+    }
     return false;
   }
 }
 
-// If run directly
-if (require.main === module) {
-  checkAndInstall();
+function tryBuildFromSource() {
+  try {
+    console.log('⚙ Building from source (requires Rust)...');
+    execSync('cargo build --release', { cwd: path.join(__dirname, '..'), stdio: 'inherit' });
+
+    const src = path.join(__dirname, '..', 'target', 'release', 'anveesa');
+    const dest = path.join(BIN_DIR, 'anveesa');
+
+    if (fs.existsSync(src)) {
+      if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+      fs.copyFileSync(src, dest);
+      fs.chmodSync(dest, 0o755);
+      console.log('✓ Built from source successfully');
+      return true;
+    }
+  } catch (e) {
+    console.log('⚠ Build from source failed (Rust not installed?)');
+  }
+  return false;
+}
+
+async function install() {
+  // Check if binary already exists
+  const existing = path.join(BIN_DIR, 'anveesa');
+  const existingExe = path.join(BIN_DIR, 'anveesa.exe');
+  if (fs.existsSync(existing) || fs.existsSync(existingExe)) {
+    console.log('✓ anveesa binary already installed');
+    return;
+  }
+
+  // Try download first
+  if (await tryDownloadBinary()) return;
+
+  // Fallback to build from source
+  if (tryBuildFromSource()) return;
+
+  console.error('');
+  console.error('✗ Could not install anveesa binary.');
+  console.error('');
+  console.error('Install Rust: https://rustup.rs/');
+  console.error('Then run: npm install -g anveesa');
+  process.exit(1);
 }
 
-module.exports = {
-  getBinaryPath,
-  checkAndInstall
-};
+install();