amxx-builder 1.5.1

package/src/commands/watch.js

@@ -0,0 +1,209 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const logger                = require('../logger');
+const { parseManifest, resolveGithubToken } = require('../manifest');
+const { fetchCompiler }     = require('../compiler-fetcher');
+const { compileSingle, applyPluginRule } = require('../compiler');
+const { deployBuild, deployPlugin, deployFile, removeDeployedFile } = require('../deployer');
+const { sendRconForPlugins } = require('../rcon');
+const { DepGraph }           = require('../dep-graph');
+const { startWatch }         = require('../watcher');
+const { fetchRepo, resolveRepoRefs } = require('../repo-fetcher');
+const { resolveDeps, repoKey } = require('../deps-resolver');
+const { resolveManifestPath, loadEnv } = require('./shared');
+const { runBuild } = require('./build');
+const { subscribeCompiledRendering } = require('./compile-renderer');
+
+// Render compiler 'compiled' events (previously direct stdout/stderr writes).
+subscribeCompiledRendering();
+
+async function runWatch(options) {
+  const manifestPath = resolveManifestPath(options.manifest);
+  const buildDir     = path.resolve(options.buildDir || './build');
+  const doDeploy     = options.deploy !== false;
+
+  loadEnv(manifestPath);
+
+  logger.info('Running initial build...');
+  await runBuild({ manifest: manifestPath, buildDir: options.buildDir });
+
+  if (options.verbose) logger.setVerbose(true);
+
+  // Mutable watch state — rebuilt after every manifest-triggered full rebuild
+  // so the compiler version, include dirs and dep graph never go stale.
+  let state = null;
+
+  async function buildWatchState() {
+    const manifest = parseManifest(manifestPath);
+    const { compilerPath, includeDir: compilerIncludeDir } = await fetchCompiler(manifest.amxmodx.version);
+
+    // Include dirs come from the same single-source helpers as the build
+    // pipeline (src/build-service.js): clone manifest repos (cache-only — the
+    // initial build just populated the clone cache), then resolveDeps collects
+    // dep .inc files into build/_includes/ and returns those dirs; the compiler
+    // bundle is appended last (deps before stdlib, matching the real build).
+    const repoLocalDirs = {};
+    if (manifest.repos.length > 0) {
+      await resolveRepoRefs(manifest.repos, (repo) => resolveGithubToken(manifest, repo));
+      const cloneJobs = new Map();
+      for (const repoConfig of manifest.repos) {
+        const key = repoKey(repoConfig);
+        if (!cloneJobs.has(key)) {
+          cloneJobs.set(key,
+            fetchRepo(repoConfig.repo, repoConfig._resolvedRef, resolveGithubToken(manifest, repoConfig.repo), true, manifest.github.ssh)
+          );
+        }
+      }
+      const cloned = await Promise.all(
+        [...cloneJobs.entries()].map(async ([key, p]) => ({ key, dir: await p }))
+      );
+      for (const { key, dir } of cloned) repoLocalDirs[key] = dir;
+    }
+
+    const depsIncludeDirs = await resolveDeps(manifest, repoLocalDirs, true, buildDir);
+    const includeDirs = compilerIncludeDir ? [...depsIncludeDirs, compilerIncludeDir] : depsIncludeDirs;
+
+    const manifestDir      = path.dirname(path.resolve(manifestPath));
+    const scriptingRootDir = path.join(manifestDir, manifest.amxmodx.dir, 'scripting');
+
+    const localIncDir = path.join(scriptingRootDir, 'include');
+    const collectedIncDir = path.join(buildDir, 'amxmodx', 'scripting', 'include');
+    const graphIncludeDirs = [
+      scriptingRootDir,
+      ...(fs.existsSync(localIncDir)     ? [localIncDir]     : []),
+      ...(fs.existsSync(collectedIncDir) ? [collectedIncDir] : []),
+      ...includeDirs,
+    ];
+    const depGraph = new DepGraph(graphIncludeDirs);
+
+    const glob = require('fast-glob');
+    if (fs.existsSync(scriptingRootDir)) {
+      const smaFiles = await glob('**/*.sma', { cwd: scriptingRootDir, absolute: true });
+      for (const f of smaFiles) depGraph.parseFile(f);
+      logger.dim(`  Dep graph: ${smaFiles.length} .sma file(s) indexed`);
+    }
+
+    return { manifest, compilerPath, includeDirs, scriptingRootDir, manifestDir, depGraph };
+  }
+
+  state = await buildWatchState();
+
+  if (doDeploy && state.manifest.deploy.path) {
+    await deployBuild(state.manifest, buildDir, { incremental: true });
+  }
+
+  // Serialize incremental work; full rebuilds flush the queue before wiping build/.
+  let queue = Promise.resolve();
+  const enqueue = (fn) => {
+    queue = queue.then(() => fn()).catch((err) => logger.error(`Watch task error: ${err.message}`));
+    return queue;
+  };
+  const flushQueue = () => queue.catch(() => {});
+
+  const handlers = {
+    onSmaChange(smaPath) {
+      return enqueue(async () => {
+        state.depGraph.update(smaPath);
+        const smaRel = path.relative(state.scriptingRootDir, smaPath).split(path.sep).join('/');
+        const pluginRule = applyPluginRule(smaRel, state.manifest.pluginRules, state.manifest.globalPostfix);
+        if (!pluginRule) {
+          logger.dim(`  Skipped by plugin rule: ${smaRel}`);
+          return;
+        }
+        const amxxName = await compileSingle(state.manifest, smaPath, state.compilerPath, state.includeDirs, buildDir, state.scriptingRootDir);
+        if (!amxxName) return;
+        if (doDeploy && state.manifest.deploy.path) {
+          deployPlugin(state.manifest, buildDir, amxxName);
+          const pluginName = path.basename(amxxName).replace(/\.amxx$/, '');
+          await sendRconForPlugins(state.manifest.deploy, [pluginName]);
+        }
+      });
+    },
+
+    onIncChange(incPath) {
+      return enqueue(async () => {
+        state.depGraph.update(incPath);
+        const affected = state.depGraph.getSmasDependingOn(incPath);
+
+        if (affected.size === 0) {
+          logger.dim(`  No plugins depend on ${path.relative(state.manifestDir, incPath)}, skipping`);
+          return;
+        }
+
+        try {
+          const compiled = [];
+          for (const smaPath of affected) {
+            const smaRel = path.relative(state.scriptingRootDir, smaPath).split(path.sep).join('/');
+            const pluginRule = applyPluginRule(smaRel, state.manifest.pluginRules, state.manifest.globalPostfix);
+            if (!pluginRule) {
+              logger.dim(`  Skipped by plugin rule: ${smaRel}`);
+              continue;
+            }
+            const amxxName = await compileSingle(state.manifest, smaPath, state.compilerPath, state.includeDirs, buildDir, state.scriptingRootDir);
+            if (amxxName) compiled.push(amxxName);
+          }
+          if (doDeploy && state.manifest.deploy.path) {
+            const pluginNames = [];
+            for (const amxxName of compiled) {
+              deployPlugin(state.manifest, buildDir, amxxName);
+              pluginNames.push(path.basename(amxxName).replace(/\.amxx$/, ''));
+            }
+            await sendRconForPlugins(state.manifest.deploy, pluginNames);
+          }
+        } catch (err) {
+          logger.error(err.message);
+        }
+      });
+    },
+
+    onFileChange(relPath, section) {
+      return enqueue(() => {
+        if (doDeploy && state.manifest.deploy.path) {
+          deployFile(state.manifest, buildDir, relPath, section);
+        }
+      });
+    },
+
+    onFileDelete(relPath, section) {
+      return enqueue(() => {
+        if (doDeploy && state.manifest.deploy.path) {
+          removeDeployedFile(state.manifest, buildDir, relPath, section);
+        }
+      });
+    },
+
+    onManifestChange() {
+      return (async () => {
+        try {
+          await flushQueue(); // let in-flight compiles finish before build/ is wiped
+          logger.info('Rebuilding...');
+          await runBuild({ manifest: manifestPath, buildDir: options.buildDir });
+          state = await buildWatchState();
+          if (doDeploy && state.manifest.deploy.path) {
+            await deployBuild(state.manifest, buildDir, { incremental: true });
+            const pluginNames = gatherPluginNames(buildDir);
+            await sendRconForPlugins(state.manifest.deploy, pluginNames);
+          }
+          logger.warn('Note: if new watch paths were added, restart amxb watch to pick them up');
+        } catch (err) {
+          logger.error(err.message);
+        }
+      })();
+    },
+  };
+
+  startWatch(state.manifest, manifestPath, handlers);
+}
+
+function gatherPluginNames(buildDir) {
+  const pluginsDir = path.join(buildDir, 'amxmodx', 'plugins');
+  if (!fs.existsSync(pluginsDir)) return [];
+  return fs.readdirSync(pluginsDir)
+    .filter(f => f.endsWith('.amxx'))
+    .map(f => f.replace(/\.amxx$/, ''));
+}
+
+module.exports = { runWatch };

package/src/compile-utils.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+
+/**
+ * Unified compiler spawn. Interface-agnostic core helper (used by the CLI build,
+ * watch mode and the MCP compile tool).
+ *
+ * ALWAYS resolves — never rejects:
+ *  - on spawn error (ENOENT etc.): { status: 1, output: String(err.message) }
+ *  - on close (including non-zero exit): { status: code, output: stdout+stderr merged }
+ *
+ * On linux, prepends the compiler's directory to LD_LIBRARY_PATH (32-bit
+ * amxxpc needs its bundled libs). windowsHide: true keeps a console from
+ * flashing on Windows.
+ */
+function spawnCompiler(cmd, args, { maxBuffer = 10 * 1024 * 1024 } = {}) {
+  return new Promise((resolve) => {
+    const env = { ...process.env };
+    if (process.platform === 'linux') {
+      const compilerDir = path.dirname(cmd);
+      env.LD_LIBRARY_PATH = env.LD_LIBRARY_PATH
+        ? `${compilerDir}:${env.LD_LIBRARY_PATH}`
+        : compilerDir;
+    }
+    execFile(cmd, args, { env, windowsHide: true, maxBuffer }, (err, stdout, stderr) => {
+      if (err) {
+        // execFile sets err.code to a number when the process ran and exited
+        // non-zero (or was signal-killed → null); string codes (ENOENT, …)
+        // and ERR_CHILD_PROCESS_STDIO_MAXBUFFER are spawn/runtime failures.
+        if (typeof err.code === 'number') {
+          resolve({ status: err.code, output: String(stdout || '') + String(stderr || '') });
+        } else {
+          resolve({ status: 1, output: String(err.message || err) });
+        }
+        return;
+      }
+      resolve({ status: 0, output: String(stdout || '') + String(stderr || '') });
+    });
+  });
+}
+
+/**
+ * Assembles the `-i<dir>` compiler include-flag array in the canonical order:
+ * scripting dir → local include/ (if it exists) → collected include dir (if it
+ * exists) → each entry of includeDirs. Single source of truth for both the CLI
+ * build paths and the MCP compile tool.
+ */
+function buildIncludeArgs({ scriptingDir, localIncDir, collectedIncDir, includeDirs }) {
+  const includes = [];
+  includes.push(`-i${scriptingDir}`);
+  if (localIncDir && fs.existsSync(localIncDir))     includes.push(`-i${localIncDir}`);
+  if (collectedIncDir && fs.existsSync(collectedIncDir)) includes.push(`-i${collectedIncDir}`);
+  for (const d of (includeDirs || []))               includes.push(`-i${d}`);
+  return includes;
+}
+
+/** Turns manifest defines (e.g. ['DEBUG']) into `-DDEBUG` compiler flags. */
+function buildDefineArgs(defines) {
+  return (defines || []).map((d) => `-D${d}`);
+}
+
+module.exports = { spawnCompiler, buildIncludeArgs, buildDefineArgs };

package/src/compiler-fetcher.js

@@ -0,0 +1,327 @@
+const fs   = require('fs');
+const path = require('path');
+const axios = require('axios');
+// Default for API calls; download sites pass their own longer timeout.
+axios.defaults.timeout = 30000;
+const AdmZip = require('adm-zip');
+const chalk = require('chalk');
+const logger = require('./logger');
+const { getCacheDir } = require('./cache-dir');
+const { copyDirContents, safeExtractTar } = require('./fs-utils');
+const { withRetry } = require('./retry');
+
+const AMXX_DROP = 'https://www.amxmodx.org/amxxdrop/';
+
+const LATEST_VERSION_TTL_MS = 60 * 60 * 1000; // 1 hour — amxxdrop updates rarely
+
+let _latestMem   = null; // { version, at } — process-lifetime cache
+let _latestFetch = null; // in-flight promise, dedupes concurrent calls
+
+/**
+ * Ensures the amxxpc compiler is available locally.
+ * Downloads from amxmodx.org/amxxdrop/ (official nightly drop, no auth needed).
+ *
+ * Returns { compilerPath, includeDir } where includeDir points to the
+ * bundled standard includes (amxmodx.inc etc.) extracted alongside the binary.
+ */
+async function fetchCompiler(version, options = {}) {
+  const resolvedVersion = version || await fetchLatestVersion(options);
+  const platform        = getPlatform();
+  const cacheDir        = path.join(getCacheDir(), 'amxxpc', resolvedVersion, platform);
+  const binaryName      = platform === 'windows' ? 'amxxpc.exe' : 'amxxpc';
+  const binaryPath      = path.join(cacheDir, binaryName);
+  const includeDir      = path.join(cacheDir, 'include');
+
+  if (fs.existsSync(binaryPath)) {
+    logger.info(`Compiler: amxxpc ${resolvedVersion} (${process.platform}, cached)`);
+    return { compilerPath: binaryPath, includeDir: fs.existsSync(includeDir) ? includeDir : null };
+  }
+
+  const { major, minor, build } = parseVersion(resolvedVersion);
+  const downloadUrl = buildDownloadUrl(major, minor, build, platform);
+
+  logger.step(`Compiler: downloading amxxpc ${resolvedVersion} for ${platform}...`);
+  logger.dim(`  ${downloadUrl}`);
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const archivePath = path.join(cacheDir, path.basename(downloadUrl));
+
+  await downloadFile(downloadUrl, archivePath);
+  extractWithPrefix(archivePath, cacheDir, {
+    prefix: 'addons/amxmodx/scripting/',
+    onDone: (d) => makeBinaryExecutable(d, platform),
+  });
+  fs.rmSync(archivePath, { force: true });
+
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(
+      `amxxpc binary not found after extraction.\n` +
+      `Expected "${binaryName}" in ${cacheDir}.\n` +
+      `Archive: ${path.basename(downloadUrl)}`
+    );
+  }
+
+  logger.success(`Compiler: amxxpc ${resolvedVersion} ready`);
+  return { compilerPath: binaryPath, includeDir: fs.existsSync(includeDir) ? includeDir : null };
+}
+
+// "1.10.5428" → { major: '1', minor: '10', build: '5428' }
+function parseVersion(versionStr) {
+  const parts = String(versionStr).split('.');
+  if (parts.length !== 3) {
+    throw new Error(
+      `Invalid amxmodx version: "${versionStr}". ` +
+      `Expected major.minor.build format (e.g. "1.10.5428").`
+    );
+  }
+  return { major: parts[0], minor: parts[1], build: parts[2] };
+}
+
+// https://www.amxmodx.org/amxxdrop/1.10/amxmodx-1.10.0-git5428-base-windows.zip
+function buildDownloadUrl(major, minor, build, platform) {
+  const ext = platform === 'windows' ? 'zip' : 'tar.gz';
+  return `${AMXX_DROP}${major}.${minor}/amxmodx-${major}.${minor}.0-git${build}-base-${platform}.${ext}`;
+}
+
+async function fetchLatestVersion(options = {}) {
+  const { noFetch } = options;
+  const now = Date.now();
+
+  if (_latestMem && now - _latestMem.at < LATEST_VERSION_TTL_MS) {
+    return _latestMem.version;
+  }
+
+  const cacheFile = path.join(getCacheDir(), 'amxxpc', `.latest-version-${getPlatform()}`);
+  try {
+    const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+    if (cached && cached.version && now - cached.at < LATEST_VERSION_TTL_MS) {
+      _latestMem = cached;
+      return cached.version;
+    }
+  } catch (_) {} // no/invalid cache file — resolve from web
+
+  if (noFetch) {
+    throw new Error(
+      'Latest amxmodx version is not cached and no-fetch is set.\n' +
+      'Run once without --no-fetch (or set amxmodx.version explicitly) to populate the cache.'
+    );
+  }
+
+  if (_latestFetch) return _latestFetch;
+
+  _latestFetch = resolveLatestVersionFromWeb().then((version) => {
+    _latestMem = { version, at: Date.now() };
+    try {
+      fs.mkdirSync(path.dirname(cacheFile), { recursive: true });
+      fs.writeFileSync(cacheFile, JSON.stringify(_latestMem));
+    } catch (_) {} // cache write is best-effort
+    return version;
+  }).finally(() => {
+    _latestFetch = null;
+  });
+
+  return _latestFetch;
+}
+
+async function resolveLatestVersionFromWeb() {
+  logger.step('Compiler: resolving latest amxmodx version...');
+  const platform = getPlatform();
+
+  // 1 — list of major.minor dirs on the drop page
+  const { data: mainPage } = await axios.get(AMXX_DROP).catch((e) => {
+    throw new Error(`Failed to fetch ${AMXX_DROP}: ${e.message}\n  → Check your internet connection or set amxmodx.version explicitly`);
+  });
+
+  const mmPattern = /href="(\d+\.\d+)\/"/g;
+  const majorMinors = [];
+  let m;
+  while ((m = mmPattern.exec(mainPage)) !== null) majorMinors.push(m[1]);
+
+  if (!majorMinors.length) {
+    throw new Error(`No amxmodx version directories found at ${AMXX_DROP}`);
+  }
+
+  majorMinors.sort((a, b) => {
+    const [aMaj, aMin] = a.split('.').map(Number);
+    const [bMaj, bMin] = b.split('.').map(Number);
+    return aMaj !== bMaj ? aMaj - bMaj : aMin - bMin;
+  });
+  const latestMM = majorMinors[majorMinors.length - 1];
+
+  // 2 — find the highest build number for the current platform
+  const { data: dirPage } = await axios.get(`${AMXX_DROP}${latestMM}/`).catch((e) => {
+    throw new Error(`Failed to fetch ${AMXX_DROP}${latestMM}/: ${e.message}`);
+  });
+
+  const buildPattern = new RegExp(
+    `href="amxmodx-[\\d.]+-git(\\d+)-base-${platform}(?:\\.\\w+){1,2}"`,
+    'g'
+  );
+  const builds = [];
+  while ((m = buildPattern.exec(dirPage)) !== null) builds.push(parseInt(m[1], 10));
+
+  if (!builds.length) {
+    throw new Error(
+      `No amxmodx builds found for platform "${platform}" in ` +
+      `${AMXX_DROP}${latestMM}/`
+    );
+  }
+
+  builds.sort((a, b) => a - b);
+  const version = `${latestMM}.${builds[builds.length - 1]}`;
+  logger.dim(`  Latest: ${version}`);
+  return version;
+}
+
+/**
+ * Resolve the AMX Mod X version to use.
+ * Priority: explicit `version` option → manifest `amxmodx.version` → latest.
+ * Single source of truth shared by the CLI build, include-tree and the MCP
+ * amxmodx-include / resolve_include / compile_sma tools.
+ *
+ * @param {object|null} manifest - parsed manifest (pass null when absent or unparseable)
+ * @param {object} [options]
+ * @param {string} [options.version] - explicit version override (highest priority)
+ * @param {boolean} [options.noFetch] - skip network when resolving "latest"
+ * @returns {Promise<string>}
+ */
+async function resolveAmxmodxVersion(manifest, options = {}) {
+  const { version, noFetch } = options;
+  if (version) return version;
+  if (manifest && manifest.amxmodx && manifest.amxmodx.version) return manifest.amxmodx.version;
+  return fetchLatestVersion({ noFetch });
+}
+
+function getPlatform() {
+  return getHostPlatform();
+}
+
+function getHostPlatform() {
+  if (process.platform === 'win32')  return 'windows';
+  if (process.platform === 'darwin') return 'mac';
+  return 'linux';
+}
+
+/**
+ * Returns the path to the full amxmodx addons/ tree for the given target platform.
+ * Downloads and extracts the base package if not yet cached.
+ * Used by asset-fetcher when source: amxmodx is specified.
+ *
+ * The returned directory contains addons/amxmodx/{plugins,configs,modules,...}
+ */
+async function getAmxmodxFullDir(version, platform) {
+  const cacheDir = path.join(getCacheDir(), 'amxxpc', version, platform);
+  const sentinel = path.join(cacheDir, '.addons-extracted');
+
+  if (fs.existsSync(sentinel)) {
+    return cacheDir;
+  }
+
+  const { major, minor, build } = parseVersion(version);
+  const downloadUrl = buildDownloadUrl(major, minor, build, platform);
+
+  logger.step(`Assets: downloading amxmodx ${version} (${platform}) for asset extraction...`);
+  logger.dim(`  ${downloadUrl}`);
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const archivePath = path.join(cacheDir, path.basename(downloadUrl));
+
+  await downloadFile(downloadUrl, archivePath);
+  extractWithPrefix(archivePath, cacheDir, { prefix: 'addons/', destSubdir: 'addons' });
+  fs.rmSync(archivePath, { force: true });
+  const sentinelTmp = sentinel + '.tmp';
+  fs.writeFileSync(sentinelTmp, '');
+  fs.renameSync(sentinelTmp, sentinel);
+
+  logger.success(`Assets: amxmodx ${version} (${platform}) ready`);
+  return cacheDir;
+}
+
+/**
+ * Filtered extraction from an AMXX base archive.
+ *
+ * For .zip: iterates entries matching `prefix`, strips prefix, saves to destDir.
+ * For .tar.*: extracts to temp dir, finds `findDirName`, copies contents.
+ *
+ * @param {string} archivePath  — path to the archive
+ * @param {string} destDir      — destination directory
+ * @param {object} opts
+ * @param {string} opts.prefix      — entry path prefix to filter (zip) / find in tar
+ * @param {string} [opts.destSubdir] — optional sub-path under destDir for zip entries
+ * @param {string} [opts.tmpSuffix]  — suffix for temp extraction dir (default: prefix-derived)
+ * @param {function} [opts.onDone]   — called after extraction with (destDir)
+ */
+function extractWithPrefix(archivePath, destDir, opts) {
+  const { prefix, destSubdir, tmpSuffix, onDone } = opts;
+
+  if (archivePath.endsWith('.zip')) {
+    const zip = new AdmZip(archivePath);
+    for (const entry of zip.getEntries()) {
+      const name = entry.entryName.replace(/\\/g, '/');
+      if (entry.isDirectory || !name.startsWith(prefix)) continue;
+      const rel  = name.slice(prefix.length);
+      if (!rel || rel.split('/').includes('..')) continue; // zip-slip guard
+      const dest = destSubdir ? path.join(destDir, destSubdir, rel) : path.join(destDir, rel);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.writeFileSync(dest, entry.getData());
+    }
+  } else {
+    const findName = prefix.replace(/\/$/, '').split('/').pop();
+    const tmpDir   = destDir + '_' + (tmpSuffix || prefix.replace(/[\/]+/g, '_').replace(/_$/, ''));
+    try {
+      fs.mkdirSync(tmpDir, { recursive: true });
+      safeExtractTar(archivePath, tmpDir);
+      const src = findDir(tmpDir, findName);
+      if (!src) throw new Error(`${findName}/ dir not found in archive ${path.basename(archivePath)}`);
+      copyDirContents(src, destSubdir ? path.join(destDir, destSubdir) : destDir);
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+
+  if (onDone) onDone(destDir);
+}
+
+async function downloadFile(url, dest) {
+  const filename = path.basename(url);
+  const bar = require('./progress').createBar(100, `  ${chalk.cyan('Downloading')} ${(filename || 'file').padEnd(30)}`);
+
+  const response = await withRetry(
+    () => axios.get(url, {
+      responseType: 'arraybuffer',
+      maxRedirects: 5,
+      timeout: 600000, // large archives — allow slow links, still bound hangs
+      onDownloadProgress: (e) => {
+        if (bar && e.total) {
+          bar.update(Math.round(e.loaded / e.total * 100));
+        }
+      },
+    }),
+    { label: filename }
+  );
+  if (bar) bar.stop();
+  const part = dest + '.part';
+  fs.writeFileSync(part, Buffer.from(response.data));
+  fs.renameSync(part, dest);
+}
+
+function makeBinaryExecutable(destDir, platform) {
+  const binaryName = platform === 'windows' ? 'amxxpc.exe' : 'amxxpc';
+  const binaryPath = path.join(destDir, binaryName);
+  if (fs.existsSync(binaryPath) && platform !== 'windows') {
+    fs.chmodSync(binaryPath, 0o755);
+  }
+}
+
+function findDir(root, name) {
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const full = path.join(root, entry.name);
+    if (entry.name === name) return full;
+    const nested = findDir(full, name);
+    if (nested) return nested;
+  }
+  return null;
+}
+
+module.exports = { fetchCompiler, getAmxmodxFullDir, getHostPlatform, fetchLatestVersion, resolveAmxmodxVersion };