amxx-builder 1.5.1

package/src/progress.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { emit, EVENTS } = require('./events');
+
+const BAR_LEN = 20;
+
+function formatBar(ratio) {
+  const filled = Math.round(ratio * BAR_LEN);
+  return '\u2588'.repeat(filled) + '\u2591'.repeat(BAR_LEN - filled);
+}
+
+function formatPct(ratio) {
+  const pct = Math.round(ratio * 100);
+  return `${pct}%`.padStart(4);
+}
+
+let _enabled = true;
+
+/**
+ * Disable progress bars entirely — createBar() returns a noop.
+ * Used by the MCP server: bars write \r/control chars to stdout,
+ * which would corrupt the JSON-RPC stream.
+ */
+function setEnabled(v) {
+  _enabled = !!v;
+}
+
+/**
+ * Simple in-place progress bar using only \r (carriage return).
+ * Works in all terminals — no ANSI escape sequences.
+ *
+ * Designed for downloads and archiving where there is no
+ * interleaved stdout output. Each update overwrites the same line.
+ */
+function createBar(total, label) {
+  if (!_enabled) return { update() {}, stop() {} };
+
+  const stream = process.stdout;
+  let lastLen = 0;
+
+  function writeLine(val) {
+    const ratio = val / total;
+    const bar   = formatBar(ratio);
+    const pct   = formatPct(ratio);
+    const line  = `${label} ${bar} ${pct} (${val}/${total})`;
+
+    if (lastLen > 0) stream.write('\r' + ' '.repeat(lastLen) + '\r');
+    stream.write(line);
+    lastLen = line.length;
+
+    emit(EVENTS.PROGRESS, { label, current: val, total });
+  }
+
+  writeLine(0);
+
+  return {
+    update(val) { writeLine(val); },
+    stop() {
+      if (lastLen > 0) stream.write('\r' + ' '.repeat(lastLen) + '\r');
+      stream.write('\n');
+      emit(EVENTS.PROGRESS, { label, current: total, total, done: true });
+    },
+  };
+}
+
+module.exports = { createBar, setEnabled };

package/src/rcon.js

@@ -0,0 +1,103 @@
+'use strict';
+
+/**
+ * Minimal GoldSrc (HL1 / CS 1.6) UDP RCON client.
+ *
+ * Protocol:
+ *   1. Client → Server: \xff\xff\xff\xff challenge rcon\n
+ *   2. Server → Client: \xff\xff\xff\xff challenge rcon <number>\n
+ *   3. Client → Server: \xff\xff\xff\xff rcon <number> "<password>" "<command>"\n
+ *   4. Server → Client: \xff\xff\xff\xff <response>\n
+ */
+
+const dgram = require('dgram');
+const logger = require('./logger');
+
+const HL_HEADER = Buffer.from([0xff, 0xff, 0xff, 0xff]);
+
+function makePacket(str) {
+  return Buffer.concat([HL_HEADER, Buffer.from(str + '\n', 'utf8')]);
+}
+
+async function sendRcon({ host, port, password, command }, timeoutMs = 5000) {
+  if (typeof password === 'string' && password.includes('"')) {
+    throw new Error('RCON password must not contain double quotes');
+  }
+
+  return new Promise((resolve, reject) => {
+    const sock = dgram.createSocket('udp4');
+    let settled = false;
+
+    const done = (err, result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      sock.close(() => {});
+      err ? reject(err) : resolve(result);
+    };
+
+    const timer = setTimeout(
+      () => done(new Error(`RCON timeout (${host}:${port})`)),
+      timeoutMs
+    );
+
+    sock.on('error', done);
+
+    sock.on('message', (buf) => {
+      if (buf.length < 5) return;
+      // Strip null bytes (GoldSrc packets are null-terminated) then whitespace
+      const body = buf.slice(4).toString('utf8').replace(/\0/g, '').trim();
+
+      if (body.startsWith('challenge rcon ')) {
+        const challenge = body.split(' ')[2];
+        const cmd = makePacket(`rcon ${challenge} "${password}" "${command}"`);
+        sock.send(cmd, 0, cmd.length, port, host);
+        return;
+      }
+
+      // All non-challenge responses are print packets with a 1-byte type prefix — strip it
+      const text = body.slice(1).trim();
+      logger.verbose(`  RCON ← ${text}`);
+      done(null, text);
+    });
+
+    const req = makePacket('challenge rcon');
+    sock.send(req, 0, req.length, port, host);
+  });
+}
+
+/**
+ * Sends the deploy.rcon.command with {plugin} interpolated.
+ * No-ops silently if RCON is not configured.
+ */
+async function sendRconCommand(deployConfig, pluginName) {
+  const { host, port, password, command } = deployConfig.rcon;
+  if (!command || !host || !password) return;
+
+  const cmd = command.replace(/\{plugin\}/g, pluginName);
+  logger.step(`RCON → ${cmd}`);
+  try {
+    const response = await sendRcon({ host, port, password, command: cmd });
+    if (response) logger.dim(`  RCON response: ${response}`);
+  } catch (err) {
+    logger.warn(`RCON failed: ${err.message}`);
+  }
+}
+
+/**
+ * Sends RCON after deploying one or more plugins.
+ * If the command contains {plugin} — sends once per plugin name.
+ * Otherwise — sends the command once regardless of how many plugins were deployed.
+ */
+async function sendRconForPlugins(deployConfig, pluginNames) {
+  const command = deployConfig.rcon && deployConfig.rcon.command;
+  if (!command) return;
+
+  if (command.includes('{plugin}')) {
+    await Promise.all(pluginNames.map((name) => sendRconCommand(deployConfig, name)));
+  } else {
+    await sendRconCommand(deployConfig, '');
+  }
+}
+
+module.exports = { sendRcon, sendRconCommand, sendRconForPlugins };

package/src/release-fetcher.js

@@ -0,0 +1,206 @@
+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 { safeExtractTar } = require('./fs-utils');
+const { withRetry } = require('./retry');
+const { resolveRefIfLatest } = require('./repo-fetcher');
+
+/**
+ * Downloads a GitHub release asset and extracts it locally.
+ * Returns the path to the directory that should be used as an include dir.
+ *
+ * Cache: <CACHE_DIR>/release-deps/<owner>__<repo>__<tag>/
+ *
+ * Asset selection (dep.asset):
+ *   null / undefined  — first .zip asset, falling back to assets[0]
+ *   number            — assets[N] by index
+ *   string            — first asset whose name matches the glob pattern (*, ?)
+ */
+async function fetchReleaseDep(dep, token, noFetch) {
+  const { repo, ref, include_path, asset: assetSelector } = dep;
+  const cacheDir = await ensureReleaseCacheDir(repo, ref, assetSelector, token, noFetch, 'Release dep');
+  return resolveIncludePath(cacheDir, include_path, repo);
+}
+
+/**
+ * Ensures the release is downloaded and extracted; returns the cache dir root.
+ * Used by asset-fetcher for source: release — shares the same cache as deps.
+ */
+async function getReleaseCacheDir(source, token, noFetch) {
+  const { repo, ref, asset: assetSelector } = source;
+  return ensureReleaseCacheDir(repo, ref, assetSelector, token, noFetch, 'Release asset');
+}
+
+async function ensureReleaseCacheDir(repo, ref, assetSelector, token, noFetch, label) {
+  const resolvedRef  = await resolveRefIfLatest(ref, repo, token);
+  // Include the asset selector in the key: the same repo@tag with different
+  // assets must not share a cache dir (first-extracted content would win).
+  const assetKey = assetSelector == null ? '' : '--' + String(assetSelector).replace(/[^a-zA-Z0-9._-]/g, '_');
+  // Lazy require: deps-resolver imports us, so a top-level import would cycle.
+  const { normalize } = require('./deps-resolver');
+  const cacheKey = normalize(repo).replace('/', '__') + '__' +
+    resolvedRef.replace(/[^a-zA-Z0-9._-]/g, '_') + assetKey;
+  const cacheDir     = path.join(getCacheDir(), 'release-deps', cacheKey);
+  const sentinelFile = path.join(cacheDir, '.extracted');
+
+  if (fs.existsSync(sentinelFile)) {
+    logger.dim(`  ${repo}@${resolvedRef} (release, cached)`);
+    return cacheDir;
+  }
+
+  if (noFetch) {
+    throw new Error(
+      `Release dep cache missing for ${repo}@${resolvedRef} and --no-fetch is set.\n` +
+      `Run without --no-fetch to populate the cache.`
+    );
+  }
+
+  logger.step(`${label}: ${repo} @ ${resolvedRef}`);
+
+  const headers = buildHeaders(token);
+  const release  = await fetchRelease(repo, resolvedRef, headers);
+  const asset    = selectAsset(release.assets, assetSelector, repo);
+
+  logger.dim(`  Asset: ${asset.name}`);
+
+  fs.mkdirSync(cacheDir, { recursive: true });
+  const archivePath = path.join(cacheDir, asset.name);
+
+  await downloadAsset(asset.browser_download_url, archivePath, headers);
+  extractArchive(archivePath, cacheDir);
+  fs.rmSync(archivePath, { force: true });
+  const sentinelTmp = sentinelFile + '.tmp';
+  fs.writeFileSync(sentinelTmp, resolvedRef, 'utf8');
+  fs.renameSync(sentinelTmp, sentinelFile);
+
+  logger.info(`${label}: ${repo}@${resolvedRef} ready`);
+  return cacheDir;
+}
+
+async function fetchRelease(repo, tag, headers) {
+  try {
+    const { data } = await axios.get(
+      `https://api.github.com/repos/${repo}/releases/tags/${tag}`,
+      { headers }
+    );
+    return data;
+  } catch (err) {
+    throw new Error(`Failed to fetch release "${tag}" for ${repo}: ${err.message}`);
+  }
+}
+
+function selectAsset(assets, selector, repo) {
+  if (!assets || !assets.length) {
+    throw new Error(`Release for ${repo} has no assets`);
+  }
+
+  if (selector == null) {
+    // Default: first .zip, then anything
+    return assets.find((a) => a.name.endsWith('.zip')) || assets[0];
+  }
+
+  if (typeof selector === 'number') {
+    if (selector >= assets.length) {
+      throw new Error(
+        `Asset index ${selector} out of range for ${repo} — ` +
+        `release has ${assets.length} asset(s)`
+      );
+    }
+    return assets[selector];
+  }
+
+  // String glob pattern
+  const matched = assets.find((a) => matchGlob(selector, a.name));
+  if (!matched) {
+    throw new Error(
+      `No asset matching "${selector}" in release for ${repo}.\n` +
+      `Available: ${assets.map((a) => a.name).join(', ')}`
+    );
+  }
+  return matched;
+}
+
+function matchGlob(pattern, name) {
+  const re = new RegExp(
+    '^' +
+    pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') +
+    '$'
+  );
+  return re.test(name);
+}
+
+function resolveIncludePath(cacheDir, includePath, repo) {
+  if (includePath) {
+    const full = path.join(cacheDir, includePath);
+    if (!fs.existsSync(full)) {
+      throw new Error(
+        `include_path "${includePath}" not found in extracted release for ${repo}`
+      );
+    }
+    return full;
+  }
+  // Auto-detect standard AMXX layouts
+  for (const candidate of ['addons/amxmodx/scripting/include', 'scripting/include', 'include']) {
+    const full = path.join(cacheDir, candidate);
+    if (fs.existsSync(full)) return full;
+  }
+  return cacheDir;
+}
+
+function buildHeaders(token) {
+  const h = { Accept: 'application/vnd.github+json' };
+  if (token) h['Authorization'] = `Bearer ${token}`;
+  return h;
+}
+
+async function downloadAsset(url, dest, headers) {
+  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, {
+      headers: { ...headers, Accept: 'application/octet-stream' },
+      responseType: 'arraybuffer',
+      maxRedirects: 5,
+      timeout: 600000, // large assets — 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 extractArchive(archivePath, destDir) {
+  if (archivePath.endsWith('.zip') || hasZipMagic(archivePath)) {
+    new AdmZip(archivePath).extractAllTo(destDir, true);
+  } else {
+    safeExtractTar(archivePath, destDir);
+  }
+}
+
+// ZIP archives start with "PK" — sniff the bytes so an asset named without
+// the .zip extension (redirects, CDNs) is still extracted correctly.
+function hasZipMagic(filePath) {
+  try {
+    const fd  = fs.openSync(filePath, 'r');
+    const buf = Buffer.alloc(2);
+    fs.readSync(fd, buf, 0, 2, 0);
+    fs.closeSync(fd);
+    return buf[0] === 0x50 && buf[1] === 0x4b;
+  } catch { return false; }
+}
+
+module.exports = { fetchReleaseDep, getReleaseCacheDir, downloadAsset };

package/src/release-lister.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const axios = require('axios');
+// Default for API calls; download sites pass their own longer timeout.
+axios.defaults.timeout = 30000;
+
+/**
+ * List releases for a GitHub repository.
+ *
+ * @param {string} repo — "owner/repo"
+ * @param {Object} [options]
+ * @param {string}  [options.token]          — GitHub PAT
+ * @param {number}  [options.limit=10]       — max releases to return
+ * @param {boolean} [options.includeAssets]  — include asset details per release
+ * @returns {Promise<Object[]>}
+ */
+async function listReleases(repo, options = {}) {
+  const { token, limit = 10, includeAssets = false } = options;
+  const headers = buildHeaders(token);
+  const perPage = Math.min(100, Math.max(1, limit)); // GitHub caps per_page at 100
+
+  const { data } = await axios.get(
+    `https://api.github.com/repos/${repo}/releases?per_page=${perPage}`,
+    { headers }
+  );
+
+  return data.map((r) => {
+    const entry = {
+      tagName: r.tag_name,
+      name: r.name || r.tag_name,
+      publishedAt: r.published_at,
+      prerelease: r.prerelease || false,
+    };
+
+    if (includeAssets && r.assets && r.assets.length > 0) {
+      entry.assets = r.assets.map((a) => ({
+        name: a.name,
+        size: a.size,
+        downloadCount: a.download_count,
+      }));
+    }
+
+    return entry;
+  });
+}
+
+/**
+ * List git tags for a GitHub repository.
+ * Useful for repos that don't publish GitHub Releases.
+ *
+ * @param {string} repo — "owner/repo"
+ * @param {Object} [options]
+ * @param {string} [options.token]     — GitHub PAT
+ * @param {number} [options.limit=10]  — max tags to return
+ * @returns {Promise<Object[]>}
+ */
+async function listTags(repo, options = {}) {
+  const { token, limit = 10 } = options;
+  const headers = buildHeaders(token);
+  const perPage = Math.min(100, Math.max(1, limit)); // GitHub caps per_page at 100
+
+  const { data } = await axios.get(
+    `https://api.github.com/repos/${repo}/tags?per_page=${perPage}`,
+    { headers }
+  );
+
+  return data.map((t) => ({
+    name: t.name,
+    commitSha: t.commit.sha,
+  }));
+}
+
+function buildHeaders(token) {
+  const h = { Accept: 'application/vnd.github+json' };
+  if (token) h['Authorization'] = `Bearer ${token}`;
+  return h;
+}
+
+module.exports = { listReleases, listTags };