cli install

Author: Hendler

jacs/src/bin/cli.rs

@@ -139,12 +139,26 @@ fn wrap_quickstart_error_with_password_help(
     )))
 }
 
-fn install_jacs_mcp_via_cargo(version: Option<&str>, force: bool) -> Result<(), Box<dyn Error>> {
+fn install_jacs_mcp_via_cargo(
+    version: Option<&str>,
+    force: bool,
+    dry_run: bool,
+) -> Result<(), Box<dyn Error>> {
     let resolved_version = version
         .map(str::trim)
         .filter(|v| !v.is_empty())
         .unwrap_or(env!("CARGO_PKG_VERSION"));
 
+    if dry_run {
+        let force_suffix = if force { " --force" } else { "" };
+        println!("Dry run: MCP cargo install plan");
+        println!(
+            "  Command: cargo install jacs-mcp --locked --version {}{}",
+            resolved_version, force_suffix
+        );
+        return Ok(());
+    }
+
     let mut command = std::process::Command::new("cargo");
     command
         .arg("install")
@@ -1031,7 +1045,7 @@ pub fn main() -> Result<(), Box<dyn Error>> {
                         .arg(
                             Arg::new("dry-run")
                                 .long("dry-run")
-                                .help("Print prebuilt install plan without downloading")
+                                .help("Print install plan without downloading/installing")
                                 .action(ArgAction::SetTrue),
                         ),
                 )
@@ -1709,7 +1723,7 @@ pub fn main() -> Result<(), Box<dyn Error>> {
                 let dry_run = *install_matches.get_one::<bool>("dry-run").unwrap_or(&false);
 
                 if from_cargo {
-                    install_jacs_mcp_via_cargo(version, force)?;
+                    install_jacs_mcp_via_cargo(version, force, dry_run)?;
                 } else {
                     install_jacs_mcp_prebuilt(version, force, bin_dir, url_override, dry_run)?;
                 }

jacs/tests/cli_tests.rs

@@ -1130,6 +1130,22 @@ fn test_mcp_install_dry_run_custom_url() -> Result<(), Box<dyn Error>> {
     Ok(())
 }
 
+#[test]
+fn test_mcp_install_from_cargo_dry_run_shows_cargo_plan() -> Result<(), Box<dyn Error>> {
+    let mut cmd = Command::cargo_bin("jacs")?;
+    cmd.arg("mcp")
+        .arg("install")
+        .arg("--from-cargo")
+        .arg("--dry-run")
+        .arg("--version")
+        .arg("0.8.0");
+    cmd.assert()
+        .success()
+        .stdout(predicate::str::contains("Dry run: MCP cargo install plan"))
+        .stdout(predicate::str::contains("cargo install jacs-mcp --locked --version 0.8.0"));
+    Ok(())
+}
+
 #[test]
 fn test_mcp_run_missing_binary_shows_install_hint() -> Result<(), Box<dyn Error>> {
     let mut cmd = Command::cargo_bin("jacs")?;

jacsnpm/bin/jacs-cli.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function binaryPath() {
+  const binaryName = os.platform() === 'win32' ? 'jacs-cli.exe' : 'jacs-cli';
+  return path.join(__dirname, binaryName);
+}
+
+function runBinary(target, forwardedArgs) {
+  if (!fs.existsSync(target)) {
+    return false;
+  }
+
+  const result = spawnSync(target, forwardedArgs, { stdio: 'inherit' });
+  if (result.error) {
+    if (result.error.code === 'ENOENT') {
+      return false;
+    }
+    console.error(`[jacs] Failed to launch CLI binary: ${result.error.message}`);
+    process.exit(1);
+  }
+
+  if (typeof result.status === 'number') {
+    process.exit(result.status);
+  }
+
+  process.exit(1);
+}
+
+function runInstaller() {
+  const installer = path.join(__dirname, '..', 'scripts', 'install-cli.js');
+  spawnSync(process.execPath, [installer], { stdio: 'inherit' });
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  const target = binaryPath();
+
+  if (runBinary(target, args)) {
+    return;
+  }
+
+  runInstaller();
+
+  if (runBinary(target, args)) {
+    return;
+  }
+
+  console.error('[jacs] CLI binary is not available for this platform/environment.');
+  console.error('[jacs] The @hai.ai/jacs library APIs are still available.');
+  process.exit(1);
+}
+
+main();

jacsnpm/package-lock.json

@@ -76,7 +76,7 @@
     }
   },
   "bin": {
-    "jacs-cli": "./bin/jacs-cli"
+    "jacs-cli": "./bin/jacs-cli.js"
   },
   "scripts": {
     "postinstall": "node scripts/install-cli.js || true",

jacsnpm/package.json

@@ -116,7 +116,7 @@ async function main() {
     console.log(`[jacs]   cargo install jacs --features cli`);
     console.log(`[jacs]   OR download from https://github.com/${REPO}/releases`);
     // Clean up partial install
-    try { fs.rmSync(binDir, { recursive: true, force: true }); } catch (_) {}
+    try { fs.rmSync(binPath, { force: true }); } catch (_) {}
   } finally {
     try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch (_) {}
   }

jacsnpm/scripts/install-cli.js

@@ -0,0 +1,68 @@
+/**
+ * Tests for npm CLI install helpers.
+ */
+
+const { expect } = require('chai');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+
+function runNodeInline(jsCode) {
+  return spawnSync(process.execPath, ['-e', jsCode], {
+    cwd: ROOT,
+    encoding: 'utf8',
+  });
+}
+
+describe('CLI installer scripts', function () {
+  this.timeout(15000);
+
+  it('install-cli exits successfully on unsupported platforms', () => {
+    const result = runNodeInline(
+      "const os=require('os'); os.platform=()=> 'freebsd'; os.arch=()=> 'x64'; require('./scripts/install-cli.js');"
+    );
+
+    expect(result.status).to.equal(0);
+    expect(result.stdout).to.include('No prebuilt CLI binary for freebsd-x64');
+  });
+
+  it('install-cli exits successfully when download fails', () => {
+    const result = runNodeInline(
+      "const os=require('os'); os.platform=()=> 'darwin'; os.arch=()=> 'arm64'; const https=require('https'); const {EventEmitter}=require('events'); https.get=()=>{const req=new EventEmitter(); process.nextTick(()=>req.emit('error', new Error('simulated-download-failure'))); return req;}; require('./scripts/install-cli.js');"
+    );
+
+    expect(result.status).to.equal(0);
+    expect(result.stdout).to.include('Could not install CLI binary: simulated-download-failure');
+  });
+
+  it('bin shim forwards arguments to a local binary when present', () => {
+    if (process.platform === 'win32') {
+      this.skip();
+    }
+
+    const binName = process.platform === 'win32' ? 'jacs-cli.exe' : 'jacs-cli';
+    const binPath = path.join(ROOT, 'bin', binName);
+
+    fs.mkdirSync(path.dirname(binPath), { recursive: true });
+    fs.writeFileSync(binPath, '#!/usr/bin/env bash\necho shim-ok \"$@\"\n', { mode: 0o755 });
+
+    try {
+      const result = spawnSync(process.execPath, ['bin/jacs-cli.js', 'hello', 'world'], {
+        cwd: ROOT,
+        encoding: 'utf8',
+      });
+
+      expect(result.status).to.equal(0);
+      expect(result.stdout).to.include('shim-ok hello world');
+    } finally {
+      try {
+        fs.unlinkSync(binPath);
+      } catch (_) {
+        // no-op cleanup
+      }
+    }
+  });
+});

jacsnpm/test/install-cli.test.js

@@ -0,0 +1,45 @@
+"""Tests for the Python CLI launcher wrapper."""
+
+import types
+
+import pytest
+
+import jacs.cli_runner as cli_runner
+
+
+def test_platform_key_linux_x64(monkeypatch):
+    monkeypatch.setattr(cli_runner.platform, "system", lambda: "Linux")
+    monkeypatch.setattr(cli_runner.platform, "machine", lambda: "x86_64")
+    assert cli_runner._platform_key() == "linux-x64"
+
+
+def test_ensure_cli_returns_none_for_unsupported_platform(monkeypatch):
+    monkeypatch.setattr(cli_runner, "_platform_key", lambda: None)
+    assert cli_runner.ensure_cli() is None
+
+
+def test_main_exits_one_when_cli_unavailable(monkeypatch):
+    monkeypatch.setattr(cli_runner, "ensure_cli", lambda: None)
+
+    with pytest.raises(SystemExit) as exc:
+        cli_runner.main()
+
+    assert exc.value.code == 1
+
+
+def test_main_forwards_args_to_downloaded_cli(monkeypatch):
+    captured = {}
+    monkeypatch.setattr(cli_runner, "ensure_cli", lambda: "/tmp/fake-jacs-cli")
+
+    def fake_run(args):
+        captured["args"] = args
+        return types.SimpleNamespace(returncode=0)
+
+    monkeypatch.setattr(cli_runner.subprocess, "run", fake_run)
+    monkeypatch.setattr(cli_runner.sys, "argv", ["jacs", "mcp", "install", "--dry-run"])
+
+    with pytest.raises(SystemExit) as exc:
+        cli_runner.main()
+
+    assert exc.value.code == 0
+    assert captured["args"] == ["/tmp/fake-jacs-cli", "mcp", "install", "--dry-run"]