amxx-builder 1.5.1

package/src/build-plan.js

@@ -0,0 +1,101 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const glob = require('fast-glob');
+
+/**
+ * Structured build plan — mirrors what printDryRun shows, but as data.
+ * Single source of truth for the CLI dry-run command and the MCP build_plan /
+ * resolve_assets tools.
+ *
+ * @param {object} manifest - fully resolved manifest (parseManifest output)
+ * @param {object} [options]
+ * @param {boolean} [options.detailedAssets=false] - when true, `assets` entries
+ *   carry the richer per-source shape ({ type, map, source, cache }, plus a
+ *   glob-listed `files` set for local sources) needed by resolve_assets.
+ *   Default keeps the compact CLI dry-run / build_plan shape.
+ * @param {boolean} [options.listLocal=true] - when detailedAssets and listLocal
+ *   are true, local sources get a `files` array listing the assets/ contents.
+ */
+function buildPlanData(manifest, options = {}) {
+  const detailed  = options.detailedAssets === true;
+  const listLocal = options.listLocal !== false;
+  const out = manifest.output;
+  const expand = (tpl) => tpl.replaceAll('{name}', manifest.name).replaceAll('{version}', manifest.version);
+
+  return {
+    name: manifest.name,
+    version: manifest.version,
+    compiler: {
+      version: manifest.amxmodx.version || 'latest',
+      dir: manifest.amxmodx.dir,
+      platform: manifest.platform || null,
+      defines: manifest.amxmodx.defines,
+    },
+    repos: manifest.repos.map((r) => ({
+      repo: r.repo,
+      ref: r.ref || 'default branch',
+      amxmodx_dir: r.amxmodx_dir,
+      deps_override: r.deps_override || null,
+    })),
+    globalDeps: manifest.globalDeps.map((d) => ({
+      source: d.source,
+      repo: d.repo,
+      ref: d.ref,
+      include_path: d.include_path || null,
+      asset: d.asset ?? null,
+    })),
+    assets: manifest.assets.sources.map((s) => {
+      if (detailed) {
+        if (s.type === 'amxmodx') {
+          return {
+            type: 'amxmodx',
+            map: s.map,
+            source: `amxmodx ${manifest.amxmodx.version || 'latest'} (${manifest.platform || 'host'})`,
+          };
+        }
+        if (s.type === 'release') {
+          return {
+            type: 'release',
+            map: s.map,
+            source: `${s.repo}@${s.ref}`,
+            asset: s.asset ?? null,
+            cache: 'global',
+          };
+        }
+        if (s.type === 'local') {
+          const entry = { type: 'local', map: s.map, source: 'assets/ (next to manifest)' };
+          if (listLocal) {
+            const dir = path.join(path.dirname(manifest._path), 'assets');
+            entry.files = fs.existsSync(dir)
+              ? glob.sync('**/*', { cwd: dir, dot: false }).sort()
+              : [];
+          }
+          return entry;
+        }
+        return { type: 'url', map: s.map, source: s.url, cache: s.cache || 'none' };
+      }
+      if (s.type === 'amxmodx') {
+        return { type: 'amxmodx', version: manifest.amxmodx.version || 'latest', platform: manifest.platform || 'host' };
+      }
+      if (s.type === 'release') {
+        return { type: 'release', repo: s.repo, ref: s.ref, asset: s.asset ?? null, cache: s.cache || 'global' };
+      }
+      if (s.type === 'local') return { type: 'local', source: 'assets/' };
+      return { type: 'url', url: s.url, cache: s.cache || 'none' };
+    }),
+    output: {
+      pack: out.pack,
+      target: out.pack === false
+        ? `${path.join(path.resolve(out.dir), expand(out.amxmodx_path))}/`
+        : path.join(path.resolve(out.dir), expand(out.archive_name)),
+      amxmodx_path: expand(out.amxmodx_path) + '/',
+      assets_path: out.assets_path ? expand(out.assets_path) + '/' : null,
+      generate_ini: out.generate_ini,
+      on_conflict: out.on_conflict,
+    },
+  };
+}
+
+module.exports = { buildPlanData };

package/src/build-service.js

@@ -0,0 +1,188 @@
+'use strict';
+
+/**
+ * Staged build orchestration — the single source of truth for the AMXX build
+ * pipeline. Interface-agnostic core: it emits structured lifecycle events on
+ * the shared event bus (src/events.js) and optionally via an `onEvent`
+ * callback; it never touches process.argv/stdout directly (rendering is the
+ * job of the calling interface).
+ *
+ * This is an EXTRACTION of the pipeline that used to live in
+ * src/commands/build.js — same core functions, same order, no new domain
+ * logic. Interfaces that need a full build (CLI `amxb build`, serve
+ * `build.start`, watch's manifest-triggered rebuild) call runBuild here.
+ *
+ * Event contract (emitted on the bus, plus delivered to `options.onEvent`):
+ *   EVENTS.STAGE   { stage, message }      — 'compiler'|'repos'|'deps'|
+ *                                            'collect'|'assets'|'compile'|
+ *                                            'ini'|'archive'
+ *   EVENTS.COMPILED { baseName, ok, ... }  — emitted by src/compiler.js during
+ *                                            the compile stage (not here)
+ *   EVENTS.PROGRESS { label, current, total } — emitted by src/progress.js
+ *                                            (downloads/archiving)
+ *   EVENTS.DONE    { ok: true, elapsed, noArchive?, message }
+ *   EVENTS.ERROR   { ok: false, message }
+ *
+ * Cancellation: pass an AbortSignal (`signal`) or an `isCancelled()` predicate.
+ * Checked between stages; a cancelled build throws an Error with
+ * `err.code === 'CANCELLED'`. The compile stage itself runs to completion and
+ * cannot be aborted mid-flight (each amxxpc invocation is atomic); cancellation
+ * only takes effect between stages.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const logger = require('./logger');
+const { emit, EVENTS } = require('./events');
+const { resolveGithubToken } = require('./manifest');
+const { fetchCompiler }  = require('./compiler-fetcher');
+const { fetchRepo, resolveRepoRefs } = require('./repo-fetcher');
+const { resolveDeps, repoKey } = require('./deps-resolver');
+const { compilePlugins } = require('./compiler');
+const { collectAll }     = require('./collector');
+const { fetchAssets }    = require('./asset-fetcher');
+const { buildIniFiles }  = require('./ini-builder');
+const { createArchive, copyOutput } = require('./archiver');
+
+/**
+ * Run the full build pipeline for an already-resolved manifest.
+ *
+ * @param {object} manifest - fully resolved manifest (parseManifest + any
+ *   applyOverrides/resolveManifest output). Manifest parsing is the caller's
+ *   job so every interface controls its own resolution boundary.
+ * @param {object} [options]
+ * @param {string}   [options.buildDir='./build'] - build staging directory
+ * @param {boolean}  [options.fetch=true]  - false skips cloning/downloads
+ * @param {boolean}  [options.archive=true] - false skips archiving/copying
+ * @param {function} [options.onEvent]      - optional callback, called with
+ *   every emitted event ({ type, ...payload }) in addition to the bus emit
+ * @param {AbortSignal} [options.signal]    - abort between stages
+ * @param {function} [options.isCancelled]  - () => boolean, checked between stages
+ * @returns {Promise<{ ok: true, elapsed: string, noArchive?: boolean }>}
+ * @throws {Error} on failure (after emitting EVENTS.ERROR); err.code ===
+ *   'CANCELLED' when the build was cancelled between stages.
+ */
+async function runBuild(manifest, options = {}) {
+  const buildStart = Date.now();
+
+  const buildDir   = path.resolve(options.buildDir || './build');
+  const noFetch    = options.fetch === false;
+  const noArchive  = options.archive === false;
+  const onEvent    = typeof options.onEvent === 'function' ? options.onEvent : null;
+
+  const emitEvent = (name, payload) => {
+    emit(name, payload);
+    if (onEvent) onEvent({ type: name, ...payload });
+  };
+
+  // The shared bus is a plain EventEmitter where an 'error' event with no
+  // subscriber throws ERR_UNHANDLED_ERROR. Subscribers (serve) receive the
+  // event normally; when nobody listens, swallow so the original error still
+  // propagates up to the caller unchanged.
+  const emitError = (payload) => {
+    try {
+      emitEvent(EVENTS.ERROR, payload);
+    } catch (_) { /* no subscriber — keep the original error surface */ }
+  };
+
+  // Cancellation is checked between stages. Compilation itself is atomic per
+  // plugin and runs to completion — cancellation only takes effect at the next
+  // stage boundary (documented in the module docstring).
+  const checkCancelled = () => {
+    const cancelled = typeof options.isCancelled === 'function'
+      ? options.isCancelled()
+      : !!(options.signal && options.signal.aborted);
+    if (cancelled) {
+      const err = new Error('Build cancelled');
+      err.code = 'CANCELLED';
+      throw err;
+    }
+  };
+
+  try {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+    fs.mkdirSync(buildDir, { recursive: true });
+
+    const hasRepos = manifest.repos.length > 0;
+
+    // ── 1. Compiler ─────────────────────────────────────────────────────────
+    emitEvent(EVENTS.STAGE, { stage: 'compiler', message: 'Fetching compiler' });
+    const { compilerPath, includeDir: compilerIncludeDir } = await fetchCompiler(manifest.amxmodx.version, { noFetch });
+    checkCancelled();
+
+    // ── 2. Repos — resolve refs + clone (deduped by repo@resolved_ref) ──────
+    const repoLocalDirs = {};
+    if (hasRepos) {
+      emitEvent(EVENTS.STAGE, { stage: 'repos', message: 'Resolving refs and cloning repos' });
+      await resolveRepoRefs(manifest.repos, (repo) => resolveGithubToken(manifest, repo));
+      checkCancelled();
+
+      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), noFetch, 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;
+      checkCancelled();
+    }
+
+    // ── 3. Deps — resolve + collect .inc ────────────────────────────────────
+    emitEvent(EVENTS.STAGE, { stage: 'deps', message: 'Resolving dependencies' });
+    const depsIncludeDirs = await resolveDeps(manifest, repoLocalDirs, noFetch, buildDir);
+    const includeDirs = compilerIncludeDir ? [...depsIncludeDirs, compilerIncludeDir] : depsIncludeDirs;
+    checkCancelled();
+
+    // ── 4. Collect — repos + local amxmodx + assets ─────────────────────────
+    emitEvent(EVENTS.STAGE, { stage: 'collect', message: 'Collecting files' });
+    await collectAll(manifest, repoLocalDirs, buildDir);
+
+    // ── 5. Fetch remote assets ──────────────────────────────────────────────
+    emitEvent(EVENTS.STAGE, { stage: 'assets', message: 'Fetching assets' });
+    await fetchAssets(manifest, buildDir, noFetch);
+    checkCancelled();
+
+    // ── 6. Compile — all .sma → .amxx (emits EVENTS.COMPILED per plugin) ────
+    emitEvent(EVENTS.STAGE, { stage: 'compile', message: 'Compiling plugins' });
+    const compiledPlugins = await compilePlugins(
+      manifest, repoLocalDirs, compilerPath, includeDirs, buildDir
+    );
+
+    // ── 7. Generate plugins-*.ini ───────────────────────────────────────────
+    if (manifest.output.generate_ini) {
+      emitEvent(EVENTS.STAGE, { stage: 'ini', message: 'Generating plugins ini files' });
+      buildIniFiles(compiledPlugins, buildDir);
+    }
+    checkCancelled();
+
+    // ── 8. Archive or copy output ───────────────────────────────────────────
+    if (noArchive) {
+      logger.info('--no-archive: skipping zip creation');
+      const elapsed = ((Date.now() - buildStart) / 1000).toFixed(1);
+      return { ok: true, elapsed, noArchive: true };
+    }
+
+    emitEvent(EVENTS.STAGE, { stage: 'archive', message: 'Archiving output' });
+    if (manifest.output.pack === false) {
+      copyOutput(manifest, buildDir);
+    } else {
+      await createArchive(manifest, buildDir);
+    }
+
+    const elapsed = ((Date.now() - buildStart) / 1000).toFixed(1);
+    emitEvent(EVENTS.DONE, { ok: true, elapsed, message: `Done in ${elapsed}s` });
+    return { ok: true, elapsed };
+  } catch (err) {
+    emitError({ ok: false, message: err.message });
+    throw err;
+  }
+}
+
+module.exports = { runBuild };

package/src/cache-dir.js

@@ -0,0 +1,21 @@
+const path = require('path');
+const os   = require('os');
+
+function getCacheDir() {
+  if (process.env.AMXX_BUILDER_CACHE) {
+    return process.env.AMXX_BUILDER_CACHE;
+  }
+  if (process.platform === 'win32') {
+    const localAppData = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
+    return path.join(localAppData, 'amxx-builder');
+  }
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Caches', 'amxx-builder');
+  }
+  // Linux — follow the XDG spec when XDG_CACHE_HOME is set.
+  const xdg = process.env.XDG_CACHE_HOME;
+  if (xdg) return path.join(xdg, 'amxx-builder');
+  return path.join(os.homedir(), '.cache', 'amxx-builder');
+}
+
+module.exports = { getCacheDir };

package/src/cache-info.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { getCacheDir } = require('./cache-dir');
+const { formatBytes } = require('./format');
+
+// ─── Helpers ────────────────────────────────────────────────────────────────────
+
+function dirSize(dir) {
+  if (!fs.existsSync(dir)) return 0;
+  let total = 0;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isSymbolicLink()) continue; // avoid loops and broken links
+    const p = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      total += dirSize(p);
+    } else {
+      try { total += fs.statSync(p).size; } catch { /* unreadable file */ }
+    }
+  }
+  return total;
+}
+
+function fmtSize(bytes) {
+  return formatBytes(bytes);
+}
+
+function parseCacheKey(key) {
+  // owner__repo__ref  →  owner/repo @ ref
+  const parts = key.split('__');
+  if (parts.length < 3) return key;
+  return `${parts.slice(0, -1).join('/')} @ ${parts[parts.length - 1]}`;
+}
+
+// ─── Cache info ─────────────────────────────────────────────────────────────────
+
+function getCacheInfo(manifestPath) {
+  const cacheRoot = getCacheDir();
+  const totalSize = dirSize(cacheRoot);
+
+  const info = {
+    cacheDir: cacheRoot,
+    totalSize,
+    totalSizeHuman: fmtSize(totalSize),
+    compiler: scanCompilerCache(path.join(cacheRoot, 'amxxpc')),
+    repos: scanDirEntries(path.join(cacheRoot, 'repos'), parseCacheKey),
+    releaseDeps: scanDirEntries(path.join(cacheRoot, 'release-deps'), parseCacheKey),
+    localAssetCache: null,
+  };
+
+  // Local .amxb-cache/ next to manifest
+  if (manifestPath) {
+    const localDir = path.join(path.dirname(path.resolve(manifestPath)), '.amxb-cache', 'assets');
+    if (fs.existsSync(localDir)) {
+      const entries = fs.readdirSync(localDir, { withFileTypes: true }).filter(e => e.isDirectory());
+      info.localAssetCache = {
+        path: localDir,
+        count: entries.length,
+        totalSize: dirSize(localDir),
+        totalSizeHuman: fmtSize(dirSize(localDir)),
+      };
+    }
+  }
+
+  return info;
+}
+
+function scanCompilerCache(compDir) {
+  if (!fs.existsSync(compDir)) return { versions: [] };
+
+  const versions = fs.readdirSync(compDir, { withFileTypes: true })
+    .filter(e => e.isDirectory())
+    .map(e => {
+      const verDir = path.join(compDir, e.name);
+      const platforms = {};
+      for (const plat of fs.readdirSync(verDir, { withFileTypes: true }).filter(e => e.isDirectory())) {
+        platforms[plat.name] = dirSize(path.join(verDir, plat.name));
+      }
+      return { version: e.name, platforms };
+    });
+
+  return { versions };
+}
+
+function scanDirEntries(dir, labelFn) {
+  if (!fs.existsSync(dir)) return { count: 0, totalSize: 0, totalSizeHuman: '0 B', entries: [] };
+
+  const dirs = fs.readdirSync(dir, { withFileTypes: true }).filter(e => e.isDirectory());
+  const entries = dirs.map(e => {
+    const full = path.join(dir, e.name);
+    const size = dirSize(full);
+    return { key: e.name, label: labelFn(e.name), size };
+  });
+
+  return {
+    count: entries.length,
+    totalSize: dirSize(dir),
+    totalSizeHuman: fmtSize(dirSize(dir)),
+    entries,
+  };
+}
+
+module.exports = { getCacheInfo, dirSize, fmtSize, parseCacheKey };