anveesa 0.2.2 → 0.2.3

package/Cargo.lock

@@ -54,7 +54,7 @@ dependencies = [
 
 [[package]]
 name = "anveesa"
-version = "0.2.0"
+version = "0.2.3"
 dependencies = [
  "anyhow",
  "base64",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "anveesa"
-version = "0.2.0"
+version = "0.2.3"
 edition = "2024"
 default-run = "anveesa"
 

package/README.md

@@ -10,17 +10,19 @@ Anveesa can be published as an npm package via a Node.js wrapper that invokes th
 ### Install from npm
 
 ```bash
-npm install -g anveesa-cli
+npm install -g anveesa
 ```
 
 ### Build and publish
 
 ```bash
-npm run build
+git tag v$(node -p "require('./package.json').version")
+git push origin main --tags
 npm publish
 ```
 
-See `package.json` in the root directory for build scripts and npm configuration.
+Wait for the GitHub release binary workflow to finish before publishing to npm.
+See `npm-publish.md` for the full release checklist.
 
 - `openai-compatible`: HTTP chat completions providers such as OpenRouter and other compatible gateways.
 - `command`: local CLIs such as Codex, Copilot, and Claude Code, where Anveesa spawns a command and passes the prompt.

package/bin/anveesa.js

@@ -8,14 +8,14 @@ function findBinary() {
   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;
-
-  // Also check for target/release (dev mode)
+  // Prefer the latest local release build in a development checkout.
   const devPath = path.join(__dirname, '..', 'target', 'release', 'anveesa' + ext);
   if (fs.existsSync(devPath)) return devPath;
 
+  // Installed npm packages keep the downloaded binary in the package bin/ directory.
+  const bundled = path.join(__dirname, 'anveesa' + ext);
+  if (fs.existsSync(bundled)) return bundled;
+
   // 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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anveesa",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "A terminal CLI that wraps AI providers (OpenAI-compatible APIs and local CLIs) into a single unified command",
   "main": "bin/anveesa.js",
   "bin": {
@@ -12,13 +12,12 @@
     "prepublishOnly": "npm run build"
   },
   "files": [
-    "bin/",
-    "scripts/",
+    "bin/anveesa.js",
+    "scripts/install.js",
     "Cargo.toml",
     "Cargo.lock",
     "src/",
-    "README.md",
-    ".github/"
+    "README.md"
   ],
   "keywords": [
     "ai",

package/scripts/install.js

@@ -8,11 +8,12 @@
 const fs = require('fs');
 const path = require('path');
 const https = require('https');
-const { execSync } = require('child_process');
+const { execFileSync } = require('child_process');
 
 const PACKAGE = require(path.join(__dirname, '..', 'package.json'));
 const REPO = 'pandhuwibowo/anveesa-cli';
 const BIN_DIR = path.join(__dirname, '..', 'bin');
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
 
 function getPlatformInfo() {
   const platform = process.platform;
@@ -32,6 +33,14 @@ function getPlatformInfo() {
   return null;
 }
 
+function getExecutableName() {
+  return process.platform === 'win32' ? 'anveesa.exe' : 'anveesa';
+}
+
+function getBinaryPath() {
+  return path.join(BIN_DIR, getExecutableName());
+}
+
 function getBinaryUrl() {
   const info = getPlatformInfo();
   if (!info) return null;
@@ -39,31 +48,47 @@ function getBinaryUrl() {
   return `https://github.com/${REPO}/releases/download/v${version}/anveesa-${version}-${info.target}.tar.gz`;
 }
 
-function download(url, dest) {
+function download(url, dest, redirects = 0) {
   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}`));
+    const request = https.get(url, {
+      headers: { 'User-Agent': `anveesa-install/${PACKAGE.version}` },
+    }, (res) => {
+      if (REDIRECT_STATUSES.has(res.statusCode)) {
+        res.resume();
+        if (!res.headers.location) {
+          reject(new Error(`HTTP ${res.statusCode} without Location header`));
+          return;
+        }
+        if (redirects >= 5) {
+          reject(new Error('too many redirects'));
+          return;
+        }
+
+        const nextUrl = new URL(res.headers.location, url).toString();
+        resolve(download(nextUrl, dest, redirects + 1));
+        return;
       }
+
+      if (res.statusCode !== 200) {
+        res.resume();
+        reject(new Error(res.statusCode === 404 ? '404' : `HTTP ${res.statusCode}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(dest);
+      file.on('finish', () => { file.close(resolve); });
+      file.on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+      res.pipe(file);
     }).on('error', (err) => {
       fs.unlink(dest, () => {});
       reject(err);
     });
+    request.setTimeout(30000, () => {
+      request.destroy(new Error('download timed out'));
+    });
   });
 }
 
@@ -76,18 +101,23 @@ async function tryDownloadBinary() {
 
   console.log('⬇ Downloading prebuilt binary for', process.platform, process.arch);
 
+  const tarPath = path.join(__dirname, 'anveesa-bin.tar.gz');
   try {
-    const tarPath = path.join(__dirname, 'anveesa-bin.tar.gz');
+    if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
     await download(url, tarPath);
 
     // Extract
-    execSync(`tar xzf "${tarPath}" -C "${BIN_DIR}"`, { stdio: 'inherit' });
+    execFileSync('tar', ['xzf', tarPath, '-C', BIN_DIR], { stdio: 'inherit' });
     fs.unlinkSync(tarPath);
 
     // Make executable
-    const binary = path.join(BIN_DIR, 'anveesa');
+    const binary = getBinaryPath();
     if (fs.existsSync(binary)) {
-      fs.chmodSync(binary, 0o755);
+      if (process.platform !== 'win32') fs.chmodSync(binary, 0o755);
+    } else {
+      console.log('⚠ Downloaded archive did not contain', getExecutableName());
+      return false;
     }
 
     console.log('✓ Binary downloaded successfully');
@@ -96,6 +126,7 @@ async function tryDownloadBinary() {
     if (e.message === '404') {
       console.log('ℹ No prebuilt binary for this version yet');
     }
+    fs.unlink(tarPath, () => {});
     return false;
   }
 }
@@ -103,29 +134,45 @@ async function tryDownloadBinary() {
 function tryBuildFromSource() {
   try {
     console.log('⚙ Building from source (requires Rust)...');
-    execSync('cargo build --release', { cwd: path.join(__dirname, '..'), stdio: 'inherit' });
+    execFileSync('cargo', ['build', '--release'], { cwd: path.join(__dirname, '..'), stdio: 'inherit' });
 
-    const src = path.join(__dirname, '..', 'target', 'release', 'anveesa');
-    const dest = path.join(BIN_DIR, 'anveesa');
+    const src = path.join(__dirname, '..', 'target', 'release', getExecutableName());
+    const dest = getBinaryPath();
 
     if (fs.existsSync(src)) {
       if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
       fs.copyFileSync(src, dest);
-      fs.chmodSync(dest, 0o755);
+      if (process.platform !== 'win32') fs.chmodSync(dest, 0o755);
       console.log('✓ Built from source successfully');
       return true;
     }
   } catch (e) {
-    console.log('⚠ Build from source failed (Rust not installed?)');
+    if (e.code === 'ENOENT') {
+      console.log('⚠ Build from source failed: cargo was not found');
+    } else {
+      console.log('⚠ Build from source failed');
+    }
   }
   return false;
 }
 
+function hasUsableExistingBinary() {
+  const existing = getBinaryPath();
+  if (!fs.existsSync(existing)) return false;
+
+  try {
+    if (process.platform !== 'win32') fs.chmodSync(existing, 0o755);
+    execFileSync(existing, ['--help'], { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch (e) {
+    console.log('ℹ Existing anveesa binary is not usable on this platform; replacing it');
+    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)) {
+  if (hasUsableExistingBinary()) {
     console.log('✓ anveesa binary already installed');
     return;
   }
@@ -139,6 +186,12 @@ async function install() {
   console.error('');
   console.error('✗ Could not install anveesa binary.');
   console.error('');
+  const url = getBinaryUrl();
+  if (url) {
+    console.error(`No prebuilt binary was available for anveesa v${PACKAGE.version}:`);
+    console.error(`  ${url}`);
+    console.error('');
+  }
   console.error('Install Rust: https://rustup.rs/');
   console.error('Then run: npm install -g anveesa');
   console.error('');
@@ -147,4 +200,4 @@ async function install() {
   process.exit(1);
 }
 
-install();
+install();

package/src/lib.rs

@@ -16,6 +16,7 @@ use clap::{CommandFactory, Parser};
 use serde::{Deserialize, Serialize};
 use tokio::sync::mpsc;
 
+#[cfg(target_os = "macos")]
 use base64::{Engine, engine::general_purpose::STANDARD as BASE64};
 
 use crate::{
@@ -968,11 +969,13 @@ impl PromptBuffer {
     }
 }
 
+#[cfg(unix)]
 struct RawPromptMode {
     fd: i32,
     saved: libc::termios,
 }
 
+#[cfg(unix)]
 impl RawPromptMode {
     fn enter() -> Result<Self> {
         let fd = libc::STDIN_FILENO;
@@ -1001,6 +1004,7 @@ impl RawPromptMode {
     }
 }
 
+#[cfg(unix)]
 impl Drop for RawPromptMode {
     fn drop(&mut self) {
         print!("\x1b[?2004l");
@@ -1012,6 +1016,16 @@ impl Drop for RawPromptMode {
     }
 }
 
+#[cfg(not(unix))]
+struct RawPromptMode;
+
+#[cfg(not(unix))]
+impl RawPromptMode {
+    fn enter() -> Result<Self> {
+        Ok(Self)
+    }
+}
+
 fn read_prompt_line(label: &str, width: usize, paste_count: &mut usize) -> Result<PromptRead> {
     let _raw_mode = RawPromptMode::enter()?;
     let mut input = io::stdin().lock();

package/src/provider/openai_compatible.rs

@@ -668,7 +668,7 @@ async fn stream_response(
 
     loop {
         let chunk_result = response.chunk().await;
-        
+
         match chunk_result {
             Ok(Some(chunk)) => {
                 consecutive_errors = 0; // Reset error counter on successful read
@@ -689,7 +689,10 @@ async fn stream_response(
                 consecutive_errors += 1;
                 if consecutive_errors >= MAX_CONSECUTIVE_ERRORS {
                     // Log the error but don't fail the whole request
-                    eprintln!("\n[warning: stream interrupted after {} consecutive errors]", consecutive_errors);
+                    eprintln!(
+                        "\n[warning: stream interrupted after {} consecutive errors]",
+                        consecutive_errors
+                    );
                     break;
                 }
                 // Try to continue reading - transient network hiccups happen

package/.github/workflows/release.yml

@@ -1,68 +0,0 @@
-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 }}