ace-tool-rs 0.1.8 → 0.1.9

package/README.md

@@ -1,88 +1,77 @@
-# ace-tool-rs npm shim
+# ace-tool-rs
 
-This npm package provides a convenient way to install and run `ace-tool-rs` via npm/npx.
+MCP server for codebase indexing, semantic search, and prompt enhancement.
 
-## How It Works
-
-This is a **shim package** that automatically downloads the appropriate pre-built binary for your platform from GitHub Releases when first run. The binary is cached locally for subsequent invocations.
-
-## Quick Start
+## Installation
 
 ```bash
-# Run directly with npx (no installation needed)
-npx ace-tool-rs --base-url <API_URL> --token <AUTH_TOKEN>
-
-# Or install globally
+# Install globally
 npm install -g ace-tool-rs
-ace-tool-rs --base-url <API_URL> --token <AUTH_TOKEN>
-```
 
-## Supported Platforms
+# Or run directly with npx
+npx ace-tool-rs --help
+```
 
-| Platform | Architecture | Status |
-|----------|--------------|--------|
-| Windows  | x64          | Supported |
-| macOS    | x64, ARM64   | Supported (universal binary) |
-| Linux    | x64          | Supported |
+## How It Works
 
-## Cache Location
+This package uses platform-specific optional dependencies to provide pre-built binaries. When you install `ace-tool-rs`, npm automatically downloads the correct binary for your platform.
 
-Downloaded binaries are cached in platform-specific directories:
+### Supported Platforms
 
-| Platform | Cache Path |
-|----------|------------|
-| Windows  | `%LOCALAPPDATA%\ace-tool-rs\<version>\` |
-| macOS    | `~/Library/Caches/ace-tool-rs/<version>/` |
-| Linux    | `$XDG_CACHE_HOME/ace-tool-rs/<version>/` or `~/.cache/ace-tool-rs/<version>/` |
+| Platform | Architecture | Package |
+|----------|--------------|---------|
+| macOS    | x64, ARM64   | `@ace-tool-rs/darwin-universal` |
+| Linux    | x64          | `@ace-tool-rs/linux-x64` |
+| Linux    | ARM64        | `@ace-tool-rs/linux-arm64` |
+| Windows  | x64          | `@ace-tool-rs/win32-x64` |
+| Windows  | ARM64        | `@ace-tool-rs/win32-arm64` |
 
-The cache is versioned, so upgrading the npm package will download a new binary matching that version.
+## Usage
 
-## Environment Variables
+```bash
+ace-tool-rs --base-url <API_URL> --token <AUTH_TOKEN>
+```
 
-| Variable | Description |
-|----------|-------------|
-| `GITHUB_TOKEN` | GitHub personal access token to avoid rate limits when downloading |
+## Troubleshooting
 
-## Requirements
+### Binary not found
 
-- Node.js 14.14.0 or later
-- `tar` command (Linux/macOS) or PowerShell 5.0+ (Windows) for extraction
+If the platform-specific package failed to install, you can install it manually:
 
-## Troubleshooting
+```bash
+# For Linux x64
+npm install @ace-tool-rs/linux-x64
 
-### Download Fails
+# For macOS
+npm install @ace-tool-rs/darwin-universal
 
-If automatic download fails, you can:
+# For Windows x64
+npm install @ace-tool-rs/win32-x64
+```
 
-1. **Manual download**: Download the appropriate binary from [GitHub Releases](https://github.com/missdeer/ace-tool-rs/releases) and place it in the cache directory.
+### Alternative installation
 
-2. **Install via Cargo**: If you have Rust installed:
-   ```bash
-   cargo install ace-tool-rs
-   ```
+If you have Rust installed, you can build from source:
 
-3. **Set GITHUB_TOKEN**: If you're hitting GitHub API rate limits:
-   ```bash
-   export GITHUB_TOKEN=your_github_token
-   npx ace-tool-rs --base-url <API_URL> --token <AUTH_TOKEN>
-   ```
+```bash
+cargo install ace-tool-rs
+```
 
-### Binary Not Found After Extraction
+## License
 
-Ensure your system has the required extraction tools:
-- **Windows**: PowerShell 5.0+ with `Expand-Archive` cmdlet
-- **Linux/macOS**: `tar` command
+GPL-3.0-only
 
-## How the Shim Works
+For commercial use, please contact missdeer@gmail.com for licensing options.
 
-1. On first run, checks if the binary exists in the cache directory
-2. If not found, queries GitHub API for the release matching the npm package version
-3. Downloads the platform-appropriate archive (`.zip` for Windows, `.tar.gz` for others)
-4. Extracts the binary to the cache directory
-5. Executes the binary with all provided arguments
+## Verifying Downloads
 
-## License
+Each GitHub release includes a `SHA256SUMS` file for integrity verification:
 
-This package is part of [ace-tool-rs](https://github.com/missdeer/ace-tool-rs) and is licensed under GPL-3.0.
+```bash
+# Download the binary and checksum file
+curl -LO https://github.com/missdeer/ace-tool-rs/releases/latest/download/ace-tool-rs_Linux_x86_64.tar.gz
+curl -LO https://github.com/missdeer/ace-tool-rs/releases/latest/download/SHA256SUMS
 
-For commercial use, please contact missdeer@gmail.com for licensing options.
+# Verify the checksum
+sha256sum -c SHA256SUMS --ignore-missing
+```

package/package.json

@@ -1,7 +1,10 @@
 {
   "name": "ace-tool-rs",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "description": "MCP server for codebase indexing, semantic search, and prompt enhancement",
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/missdeer/ace-tool-rs.git"
@@ -25,7 +28,8 @@
     "ace-tool-rs": "run.js"
   },
   "files": [
-    "run.js"
+    "run.js",
+    "README.md"
   ],
   "engines": {
     "node": ">=14.14.0"
@@ -38,5 +42,12 @@
   "cpu": [
     "x64",
     "arm64"
-  ]
+  ],
+  "optionalDependencies": {
+    "@ace-tool-rs/darwin-universal": "0.1.9",
+    "@ace-tool-rs/linux-x64": "0.1.9",
+    "@ace-tool-rs/linux-arm64": "0.1.9",
+    "@ace-tool-rs/win32-x64": "0.1.9",
+    "@ace-tool-rs/win32-arm64": "0.1.9"
+  }
 }

package/run.js

@@ -2,545 +2,48 @@
 
 const { spawn } = require("child_process");
 const path = require("path");
-const fs = require("fs");
-const https = require("https");
 const os = require("os");
-const crypto = require("crypto");
 
-// Note: We do not use 'kexec' to replace the process because the available packages 
-// are largely unmaintained or have compatibility issues with modern Node.js versions.
-// Instead, we spawn the child and forward signals/stdio.
-// Crucially, we ensure the wrapper ONLY writes to stderr (logs, extraction output)
-// so that the Rust binary's stdout (MCP JSON-RPC) is the only thing on stdout.
-
-const PACKAGE_NAME = "ace-tool-rs";
-const REPO_OWNER = "missdeer";
-const REPO_NAME = "ace-tool-rs";
-const MAX_REDIRECTS = 10;
-const REQUEST_TIMEOUT = 60000; // 60 seconds
-const MAX_RETRIES = 3;
-const RETRY_DELAY = 1000; // 1 second
-
-// Helper for retry with exponential backoff
-async function withRetry(fn, retries = MAX_RETRIES) {
-  let lastError;
-  for (let attempt = 0; attempt < retries; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      // Don't retry on non-retryable errors
-      if (
-        err.message.includes("Unsupported") ||
-        err.message.includes("rate limit") ||
-        err.message.includes("404")
-      ) {
-        throw err;
-      }
-      if (attempt < retries - 1) {
-        const delay = RETRY_DELAY * Math.pow(2, attempt);
-        await new Promise((resolve) => setTimeout(resolve, delay));
-      }
-    }
-  }
-  throw lastError;
-}
-
-// Cache package version
-let cachedVersion = null;
-
-// Get package version from package.json
-function getPackageVersion() {
-  if (cachedVersion === null) {
-    cachedVersion = require("./package.json").version;
-  }
-  return cachedVersion;
-}
-
-// Get cache directory based on OS
-function getCacheDir() {
-  const homeDir = os.homedir();
-  const version = getPackageVersion();
-  let baseDir;
-
-  switch (process.platform) {
-    case "win32":
-      baseDir = path.join(
-        process.env.LOCALAPPDATA || path.join(homeDir, "AppData", "Local"),
-        PACKAGE_NAME
-      );
-      break;
-    case "darwin":
-      baseDir = path.join(homeDir, "Library", "Caches", PACKAGE_NAME);
-      break;
-    default:
-      baseDir = path.join(
-        process.env.XDG_CACHE_HOME || path.join(homeDir, ".cache"),
-        PACKAGE_NAME
-      );
-  }
-
-  // Include version in cache path to handle upgrades
-  return path.join(baseDir, version);
-}
-
-// Get asset name based on platform (matching release.yml)
-function getAssetName() {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  switch (platform) {
-    case "darwin":
-      // macOS uses universal binary (supports both x64 and arm64)
-      return "ace-tool-rs_Darwin_universal.tar.gz";
-    case "linux":
-      if (arch === "x64") {
-        return "ace-tool-rs_Linux_x86_64.tar.gz";
-      } else if (arch === "arm64") {
-        return "ace-tool-rs_Linux_aarch64.tar.gz";
-      }
-      throw new Error(
-        `Unsupported architecture: ${arch} on Linux. Only x64 and arm64 are supported.`
-      );
-    case "win32":
-      if (arch === "x64") {
-        return "ace-tool-rs_Windows_x86_64.zip";
-      } else if (arch === "arm64") {
-        return "ace-tool-rs_Windows_aarch64.zip";
-      }
-      throw new Error(
-        `Unsupported architecture: ${arch} on Windows. Only x64 and arm64 are supported.`
-      );
-    default:
-      throw new Error(`Unsupported platform: ${platform}`);
-  }
-}
-
-function getBinaryName() {
-  return process.platform === "win32" ? `${PACKAGE_NAME}.exe` : PACKAGE_NAME;
-}
-
-function httpsGet(url, options = {}, redirectCount = 0) {
-  return new Promise((resolve, reject) => {
-    if (redirectCount > MAX_REDIRECTS) {
-      reject(new Error("Too many redirects"));
-      return;
-    }
-
-    const req = https.get(url, options, (res) => {
-      // Handle redirects
-      if (
-        res.statusCode >= 300 &&
-        res.statusCode < 400 &&
-        res.headers.location
-      ) {
-        // Consume response to free up connection
-        res.resume();
-        const redirectUrl = res.headers.location;
-        // Only follow HTTPS redirects
-        if (!redirectUrl.startsWith("https://")) {
-          reject(new Error(`Insecure redirect to: ${redirectUrl}`));
-          return;
-        }
-        httpsGet(redirectUrl, options, redirectCount + 1)
-          .then(resolve)
-          .catch(reject);
-        return;
-      }
-
-      if (res.statusCode === 403) {
-        res.resume();
-        reject(
-          new Error(
-            "GitHub API rate limit exceeded. Please try again later or set GITHUB_TOKEN environment variable."
-          )
-        );
-        return;
-      }
-
-      if (res.statusCode !== 200) {
-        res.resume();
-        reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        return;
-      }
-
-      const chunks = [];
-      res.on("data", (chunk) => chunks.push(chunk));
-      res.on("end", () => resolve(Buffer.concat(chunks)));
-      res.on("error", reject);
-    });
-
-    req.on("error", reject);
-    req.setTimeout(REQUEST_TIMEOUT, () => {
-      req.destroy();
-      reject(new Error("Request timeout"));
-    });
-  });
-}
-
-// Parse JSON with helpful error message
-function parseJSON(data, context) {
-  try {
-    return JSON.parse(data.toString());
-  } catch (err) {
-    const preview = data.toString().slice(0, 200);
-    throw new Error(
-      `Failed to parse ${context} response. GitHub may be experiencing issues. Response preview: ${preview}`
-    );
-  }
-}
-
-async function getReleaseByTag(version) {
-  const tag = `v${version}`;
-  const url = `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/tags/${tag}`;
-  const options = {
-    headers: {
-      "User-Agent": PACKAGE_NAME,
-      Accept: "application/vnd.github.v3+json",
-      ...(process.env.GITHUB_TOKEN && {
-        Authorization: `token ${process.env.GITHUB_TOKEN}`,
-      }),
-    },
-  };
-
-  try {
-    const data = await httpsGet(url, options);
-    return parseJSON(data, "release");
-  } catch (error) {
-    // If the specific version tag doesn't exist, fall back to latest
-    if (error.message.includes("404")) {
-      console.error(
-        `Release v${version} not found, falling back to latest release...`
-      );
-      return getLatestRelease();
-    }
-    throw error;
-  }
-}
-
-async function getLatestRelease() {
-  const url = `https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest`;
-  const options = {
-    headers: {
-      "User-Agent": PACKAGE_NAME,
-      Accept: "application/vnd.github.v3+json",
-      ...(process.env.GITHUB_TOKEN && {
-        Authorization: `token ${process.env.GITHUB_TOKEN}`,
-      }),
-    },
-  };
-
-  const data = await httpsGet(url, options);
-  return parseJSON(data, "latest release");
-}
-
-function downloadToFile(url, destPath, options = {}, redirectCount = 0) {
-  return new Promise((resolve, reject) => {
-    if (redirectCount > MAX_REDIRECTS) {
-      reject(new Error("Too many redirects"));
-      return;
-    }
-
-    const file = fs.createWriteStream(destPath);
-    const req = https.get(url, options, (res) => {
-      // Handle redirects
-      if (
-        res.statusCode >= 300 &&
-        res.statusCode < 400 &&
-        res.headers.location
-      ) {
-        res.resume(); // Consume response
-        file.close(() => {
-          try {
-            fs.unlinkSync(destPath);
-          } catch {}
-          const redirectUrl = res.headers.location;
-          if (!redirectUrl.startsWith("https://")) {
-            reject(new Error(`Insecure redirect to: ${redirectUrl}`));
-            return;
-          }
-          downloadToFile(redirectUrl, destPath, options, redirectCount + 1)
-            .then(resolve)
-            .catch(reject);
-        });
-        return;
-      }
-
-      if (res.statusCode !== 200) {
-        res.resume(); // Consume response
-        file.close(() => {
-          try {
-            fs.unlinkSync(destPath);
-          } catch {}
-          reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
-        });
-        return;
-      }
-
-      res.pipe(file);
-      file.on("finish", () => {
-        file.close(() => resolve());
-      });
-      file.on("error", (err) => {
-        file.close(() => {
-          try {
-            fs.unlinkSync(destPath);
-          } catch {}
-          reject(err);
-        });
-      });
-    });
-
-    req.on("error", (err) => {
-      file.close(() => {
-        try {
-          fs.unlinkSync(destPath);
-        } catch {}
-        reject(err);
-      });
-    });
-
-    req.setTimeout(REQUEST_TIMEOUT, () => {
-      req.destroy();
-      file.close(() => {
-        try {
-          fs.unlinkSync(destPath);
-        } catch {}
-        reject(new Error("Download timeout"));
-      });
-    });
-  });
-}
-
-async function extractTarGz(archivePath, destDir) {
-  return new Promise((resolve, reject) => {
-    // Redirect stdout to stderr to prevent MCP corruption
-    const tar = spawn("tar", ["-xzf", archivePath, "-C", destDir], {
-      stdio: ["ignore", process.stderr, process.stderr],
-    });
-    tar.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`tar exited with code ${code}`));
-    });
-    tar.on("error", (err) => {
-      if (err.code === "ENOENT") {
-        reject(new Error("tar command not found. Please install tar."));
-      } else {
-        reject(err);
-      }
-    });
-  });
-}
-
-async function extractZip(archivePath, destDir) {
-  return new Promise((resolve, reject) => {
-    // Escape paths for PowerShell: escape backticks and single quotes
-    const escapePath = (p) => p.replace(/`/g, "``").replace(/'/g, "''");
-    // Redirect stdout to stderr to prevent MCP corruption
-    const unzipProcess = spawn(
-      "powershell",
-      [
-        "-NoProfile",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        `Expand-Archive -LiteralPath '${escapePath(archivePath)}' -DestinationPath '${escapePath(destDir)}' -Force`,
-      ],
-      { stdio: ["ignore", process.stderr, process.stderr] }
-    );
-    unzipProcess.on("close", (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`PowerShell Expand-Archive exited with code ${code}`));
-    });
-    unzipProcess.on("error", (err) => {
-      if (err.code === "ENOENT") {
-        reject(new Error("PowerShell not found. Please install PowerShell 5.0+."));
-      } else {
-        reject(err);
-      }
-    });
-  });
-}
-
-// Move file with fallback for cross-device moves
-function moveFile(src, dest) {
-  try {
-    fs.renameSync(src, dest);
-  } catch (err) {
-    if (err.code === "EXDEV") {
-      // Cross-device move: copy + delete
-      fs.copyFileSync(src, dest);
-      fs.unlinkSync(src);
-    } else {
-      throw err;
-    }
-  }
-}
-
-// Create a lock file to prevent concurrent downloads
-function acquireLock(lockPath) {
-  try {
-    fs.writeFileSync(lockPath, process.pid.toString(), { flag: "wx" });
-    return true;
-  } catch (err) {
-    if (err.code === "EEXIST") {
-      // Check if the process that created the lock is still running
-      try {
-        const pid = parseInt(fs.readFileSync(lockPath, "utf8"), 10);
-        try {
-          process.kill(pid, 0); // Check if process exists
-          return false; // Process is still running
-        } catch {
-          // Process is not running, remove stale lock
-          fs.unlinkSync(lockPath);
-          return acquireLock(lockPath);
-        }
-      } catch {
-        return false;
-      }
-    }
-    throw err;
-  }
-}
-
-function releaseLock(lockPath) {
-  try {
-    fs.unlinkSync(lockPath);
-  } catch {
-    // Ignore errors
-  }
-}
-
-async function downloadAndExtract(cacheDir) {
-  const assetName = getAssetName();
-  const binaryName = getBinaryName();
-  const binaryPath = path.join(cacheDir, binaryName);
-  const lockPath = path.join(cacheDir, ".lock");
-  const tempId = crypto.randomBytes(8).toString("hex");
-
-  // Ensure cache directory exists
-  fs.mkdirSync(cacheDir, { recursive: true });
-
-  // Try to acquire lock
-  if (!acquireLock(lockPath)) {
-    // Wait for other process to complete
-    console.error("Another process is downloading, waiting...");
-    let attempts = 0;
-    while (!fs.existsSync(binaryPath) && attempts < 60) {
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-      attempts++;
-    }
-    if (fs.existsSync(binaryPath)) {
-      return binaryPath;
-    }
-    throw new Error("Timeout waiting for download to complete");
+const PLATFORMS = {
+  "darwin-x64": "@ace-tool-rs/darwin-universal",
+  "darwin-arm64": "@ace-tool-rs/darwin-universal",
+  "linux-x64": "@ace-tool-rs/linux-x64",
+  "linux-arm64": "@ace-tool-rs/linux-arm64",
+  "win32-x64": "@ace-tool-rs/win32-x64",
+  "win32-arm64": "@ace-tool-rs/win32-arm64",
+};
+
+function getBinaryPath() {
+  const platformKey = `${process.platform}-${process.arch}`;
+  const pkgName = PLATFORMS[platformKey];
+
+  if (!pkgName) {
+    console.error(`Unsupported platform: ${process.platform}-${process.arch}`);
+    console.error("Supported platforms: " + Object.keys(PLATFORMS).join(", "));
+    process.exit(1);
   }
 
   try {
-    // Double check after acquiring lock
-    if (fs.existsSync(binaryPath)) {
-      return binaryPath;
-    }
-
-    // Get release for the specific version (with retry)
-    const version = getPackageVersion();
-    console.error(`Downloading ${PACKAGE_NAME} v${version}...`);
-
-    const release = await withRetry(() => getReleaseByTag(version));
-    const asset = release.assets.find((a) => a.name === assetName);
-
-    if (!asset) {
-      const availableAssets = release.assets.map((a) => a.name).join(", ");
-      throw new Error(
-        `No matching asset found: ${assetName}. Available: ${availableAssets}`
-      );
-    }
-
-    // Download to temporary file first
-    const tempArchive = path.join(cacheDir, `${tempId}-${assetName}`);
-    const tempExtractDir = path.join(cacheDir, `${tempId}-extract`);
-
-    const downloadOptions = {
-      headers: {
-        "User-Agent": PACKAGE_NAME,
-        Accept: "application/octet-stream",
-        ...(process.env.GITHUB_TOKEN && {
-          Authorization: `token ${process.env.GITHUB_TOKEN}`,
-        }),
-      },
-    };
-
-    await withRetry(() =>
-      downloadToFile(asset.browser_download_url, tempArchive, downloadOptions)
-    );
-
-    // Extract to temporary directory
-    console.error("Extracting...");
-    fs.mkdirSync(tempExtractDir, { recursive: true });
-
-    if (assetName.endsWith(".zip")) {
-      await extractZip(tempArchive, tempExtractDir);
-    } else {
-      await extractTarGz(tempArchive, tempExtractDir);
-    }
-
-    // Find the binary in the extracted directory
-    const extractedBinary = path.join(tempExtractDir, binaryName);
-    if (!fs.existsSync(extractedBinary)) {
-      throw new Error(
-        `Binary not found in archive. Expected: ${binaryName} in extracted contents.`
-      );
-    }
-
-    // Atomic move to final location (with cross-device fallback)
-    moveFile(extractedBinary, binaryPath);
-
-    // Make binary executable on Unix
-    if (process.platform !== "win32") {
-      fs.chmodSync(binaryPath, 0o755);
-    }
-
-    // Clean up
-    fs.unlinkSync(tempArchive);
-    fs.rmSync(tempExtractDir, { recursive: true, force: true });
-
-    console.error(`Installed ${PACKAGE_NAME} to ${binaryPath}`);
-    return binaryPath;
-  } catch (error) {
-    console.error(`Failed to download ${PACKAGE_NAME}: ${error.message}`);
+    const pkgPath = require.resolve(`${pkgName}/package.json`);
+    const binName = process.platform === "win32" ? "ace-tool-rs.exe" : "ace-tool-rs";
+    return path.join(path.dirname(pkgPath), "bin", binName);
+  } catch (e) {
+    console.error(`Failed to find platform package: ${pkgName}`);
+    console.error("This may happen if npm failed to install the optional dependency.");
     console.error("");
-    console.error("You can install manually:");
-    console.error(
-      "  1. Download from https://github.com/missdeer/ace-tool-rs/releases"
-    );
-    console.error(`  2. Place binary at: ${binaryPath}`);
+    console.error("Try reinstalling:");
+    console.error("  npm install ace-tool-rs");
     console.error("");
-    console.error("Or install via cargo:");
-    console.error("  cargo install ace-tool-rs");
+    console.error("Or install the platform package directly:");
+    console.error(`  npm install ${pkgName}`);
     process.exit(1);
-  } finally {
-    releaseLock(lockPath);
   }
 }
 
-async function run() {
-  const cacheDir = getCacheDir();
-  const binaryName = getBinaryName();
-  const binaryPath = path.join(cacheDir, binaryName);
-
-  // Check if binary exists in cache
-  if (!fs.existsSync(binaryPath)) {
-    await downloadAndExtract(cacheDir);
-  }
-
-  // Final check that binary exists
-  if (!fs.existsSync(binaryPath)) {
-    console.error(`Binary not found at ${binaryPath}`);
-    process.exit(1);
-  }
-
-  // Run the binary with all arguments
+function run() {
+  const binaryPath = getBinaryPath();
   const args = process.argv.slice(2);
+
   const child = spawn(binaryPath, args, {
     stdio: "inherit",
     env: process.env,
@@ -557,7 +60,7 @@ async function run() {
   });
 
   child.on("error", (error) => {
-    console.error(`Failed to start ${PACKAGE_NAME}: ${error.message}`);
+    console.error(`Failed to start ace-tool-rs: ${error.message}`);
     process.exit(1);
   });
 
@@ -569,7 +72,4 @@ async function run() {
   });
 }
 
-run().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
+run();