amxx-builder 1.5.1

package/src/cli.js

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+'use strict';
+
+const { program } = require('commander');
+
+const logger = require('./logger');
+const { checkForUpdate } = require('./update-check');
+
+const { runBuild }            = require('./commands/build');
+const { runClean }            = require('./commands/clean');
+const { runDeploy }           = require('./commands/deploy');
+const { runWatch }            = require('./commands/watch');
+const { runCacheInfo, runCacheClean } = require('./commands/cache');
+const { runDoctor }           = require('./commands/doctor');
+const { runDepsTree }         = require('./commands/deps-tree');
+const { runResolveManifest }  = require('./commands/resolve-manifest');
+const { runValidate }         = require('./commands/validate');
+const { runReleases }         = require('./commands/releases');
+const { runInit, runInitInteractive } = require('./commands/init');
+const { runMcp }                     = require('./commands/mcp');
+const { runServe }                   = require('./commands/serve');
+
+program
+  .name('amxx-builder')
+  .description('Build and package AMX Mod X server plugins')
+  .version(require('../package.json').version);
+
+// ─── Update check ──────────────────────────────────────────────────────────────
+
+program.hook('preAction', async () => {
+  // The MCP server and the serve JSON-RPC server own stdout; an update notice
+  // would corrupt the protocol stream.
+  if (program.args[0] === 'mcp' || program.args[0] === 'serve') return;
+  try {
+    const latest = await checkForUpdate();
+    if (latest) {
+      logger.info(`Доступна новая версия: ${latest} (текущая: ${require('../package.json').version})`);
+      logger.dim(`  Обновить: npm install -g github:AmxxModularEcosystem/amxx-builder`);
+    }
+  } catch { /* update check never blocks */ }
+});
+
+// ─── build ────────────────────────────────────────────────────────────────────
+
+program
+  .command('build')
+  .description('Build plugins from manifest')
+  .option('--manifest <path>',       'Path to manifest file (default: amxbuild.yml, fallback: manifest.yml)')
+  .option('--build-dir <path>',     'Override build staging directory (default: ./build)')
+  .option('--set <key=value...>',    'Override manifest field (e.g. --set version=1.2.3 --set output.archive_name="{name}-{version}.zip")')
+  .option('--define <flag...>',     'Add compiler define, e.g. --define DEBUG --define "VERSION=1.2.3" (appends to amxmodx.defines)')
+  .option('--no-fetch',             'Use cached repos without re-cloning')
+  .option('--no-archive',           'Compile only, skip archiving')
+  .option('--dry-run',              'Show plan without executing')
+  .option('--verbose',              'Show detailed output (compiler commands, per-file copies, include dirs)')
+  .action(async (options) => {
+    try {
+      await runBuild(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── clean ────────────────────────────────────────────────────────────────────
+
+program
+  .command('clean')
+  .description('Clean build directory and repo clone cache')
+  .option('--build-dir <path>', 'Override build staging directory (default: ./build)')
+  .option('--all', 'Also clean compiler cache')
+  .action(async (options) => {
+    try {
+      await runClean(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── cache ────────────────────────────────────────────────────────────────────
+
+const cacheCmd = program
+  .command('cache')
+  .description('Manage the local cache');
+
+cacheCmd
+  .command('info', { isDefault: true })
+  .description('Show cache contents and disk usage')
+  .option('--manifest <path>', 'Show local .amxb-cache/ for this manifest')
+  .action((options) => {
+    try {
+      runCacheInfo(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+cacheCmd
+  .command('clean')
+  .description('Remove cached files')
+  .option('--compiler', 'Clean compiler cache (amxxpc binaries)')
+  .option('--repos',    'Clean repository clones')
+  .option('--deps',     'Clean release dependency clones')
+  .option('--all',      'Clean all caches')
+  .action((options) => {
+    try {
+      runCacheClean(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── deps-tree ────────────────────────────────────────────────────────────────
+
+program
+  .command('deps-tree')
+  .description('Show recursive dependency tree for manifest or inline deps')
+  .option('--manifest <path>', 'Path to manifest file')
+  .option('--depth <n>',       'Max recursion depth (0 = unlimited)', parseInt)
+  .option('--json',            'Output as JSON instead of tree view')
+  .option('--cycle-only',      'Show only cycles')
+  .option('--no-fetch',        'Use cached repos without re-cloning')
+  .action(async (options) => {
+    try {
+      await runDepsTree(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── resolve-manifest ──────────────────────────────────────────────────────────
+
+program
+  .command('resolve-manifest')
+  .description('Parse and fully resolve manifest (defaults + overrides)')
+  .option('--manifest <path>', 'Path to manifest file')
+  .option('--set <key=value...>', 'Override manifest field (dot notation)')
+  .option('--define <flag...>', 'Add compiler define')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      await runResolveManifest(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── validate ──────────────────────────────────────────────────────────────────
+
+program
+  .command('validate')
+  .description('Validate manifest and show diagnostics')
+  .option('--manifest <path>', 'Path to manifest file')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    try {
+      await runValidate(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── releases ──────────────────────────────────────────────────────────────────
+
+program
+  .command('releases')
+  .description('List GitHub releases or tags for a repository')
+  .argument('<repo>', 'Repository in format owner/repo')
+  .option('--limit <n>', 'Max results (default: 10)', parseInt)
+  .option('--tags', 'List git tags instead of releases')
+  .option('--assets', 'Include asset details')
+  .option('--json', 'Output as JSON')
+  .action(async (repo, options) => {
+    try {
+      await runReleases(repo, options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── deploy ───────────────────────────────────────────────────────────────────
+
+program
+  .command('deploy')
+  .description('Deploy build output to the server directory')
+  .option('--manifest <path>',  'Path to manifest file')
+  .option('--build-dir <path>', 'Build staging directory (default: ./build)')
+  .option('--incremental',      'Only copy files newer than the destination')
+  .option('--build',            'Run a full build before deploying')
+  .action(async (options) => {
+    try {
+      await runDeploy(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── watch ────────────────────────────────────────────────────────────────────
+
+program
+  .command('watch')
+  .description('Watch local files and incrementally build + deploy on changes')
+  .option('--manifest <path>',  'Path to manifest file')
+  .option('--build-dir <path>', 'Build staging directory (default: ./build)')
+  .option('--no-deploy',        'Watch and rebuild only, skip deploy')
+  .action(async (options) => {
+    try {
+      await runWatch(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── doctor ───────────────────────────────────────────────────────────────────
+
+program
+  .command('doctor')
+  .description('Check system health and validate manifest')
+  .option('--manifest <path>', 'Path to manifest file to validate')
+  .action(async (options) => {
+    try {
+      await runDoctor(options);
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── init ─────────────────────────────────────────────────────────────────────
+
+program
+  .command('init')
+  .description('Scaffold a new plugin project in the current directory')
+  .option('--name <name>',   'Package name (default: current directory name)')
+  .option('--workflow',      'Generate .github/workflows/ci.yml')
+  .option('--ci',           'Alias for --workflow')
+  .option('--plugin <name>', 'Create amxmodx/scripting/<name>.sma')
+  .option('--gitignore',     'Create .gitignore')
+  .option('--opencode',      'Create .opencode/opencode.json with MCP config (amxb mcp)')
+  .option('--deploy',        'Create .env with deploy stubs (AMXB_DEPLOY_*)')
+  .option('--script',        'Create build.bat and build.sh quick-build scripts')
+  .option('-i, --interactive', 'Interactive mode with prompts')
+  .action(async (options) => {
+    try {
+      if (options.interactive) {
+        await runInitInteractive(options);
+      } else {
+        runInit(options);
+      }
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── mcp ──────────────────────────────────────────────────────────────────────
+
+program
+  .command('mcp')
+  .description('Start the MCP (Model Context Protocol) server for AMXX dependency resolution (stdio transport)')
+  .action(async () => {
+    try {
+      await runMcp();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── serve ───────────────────────────────────────────────────────────────────
+
+program
+  .command('serve')
+  .description('Start JSON-RPC server for editor integration (stdio)')
+  .action(async () => {
+    try {
+      await runServe();
+    } catch (err) {
+      logger.error(err.message);
+      process.exit(1);
+    }
+  });
+
+// ─── version ───────────────────────────────────────────────────────────────────
+
+program
+  .command('version')
+  .description('Show current version')
+  .action(() => {
+    console.log(require('../package.json').version);
+  });
+
+program.parse(process.argv);

package/src/collector.js

@@ -0,0 +1,89 @@
+const fs   = require('fs');
+const path = require('path');
+const glob = require('fast-glob');
+const logger = require('./logger');
+const { repoKey } = require('./deps-resolver');
+
+/**
+ * Copies everything from each repo's amxmodx_dir into build/amxmodx/,
+ * then merges local amxmodx/ and assets/ directories (next to amxbuild.yml).
+ *
+ * .sma files ARE copied as-is (like any other file); the compiler step
+ * recompiles them and overwrites the .amxx outputs. Exclude sources from a
+ * repo via its exclude_files patterns if they should not be shipped.
+ *
+ * Repo-vs-repo file conflicts are handled according to output.on_conflict:
+ *   last_wins  (default) — later repo in list wins, warning emitted
+ *   first_wins           — first repo wins, later duplicates skipped with warning
+ *   error                — build fails on first conflict
+ *
+ * Local amxmodx/ always wins over repo files (intentional override layer, no warning).
+ */
+async function collectAll(manifest, repoLocalDirs, buildDir) {
+  const onConflict      = manifest.output.on_conflict;
+  const amxmodxBuildDir = path.join(buildDir, 'amxmodx');
+  fs.mkdirSync(amxmodxBuildDir, { recursive: true });
+
+  const origins = new Map(); // rel path → repo label (conflict tracking)
+
+  // Copy from each remote repo
+  for (const repoConfig of manifest.repos) {
+    const repoDir = repoLocalDirs[repoKey(repoConfig)];
+    const srcDir  = path.join(repoDir, repoConfig.amxmodx_dir);
+
+    if (!fs.existsSync(srcDir)) {
+      logger.warn(`${repoConfig.repo}: amxmodx dir not found: ${repoConfig.amxmodx_dir}/`);
+      continue;
+    }
+
+    const files = await glob(['**/*', ...repoConfig.exclude_files.map((p) => `!${p}`)], {
+      cwd: srcDir,
+      onlyFiles: true,
+    });
+
+    let copied = 0;
+    for (const f of files) {
+      if (origins.has(f)) {
+        const prev = origins.get(f);
+        if (onConflict === 'error') {
+          throw new Error(`File conflict: "${f}" — provided by both "${prev}" and "${repoConfig.repo}"`);
+        }
+        if (onConflict === 'first_wins') {
+          logger.warn(`Conflict (kept "${prev}"): ${f}`);
+          continue;
+        }
+        // last_wins (default)
+        logger.warn(`Conflict (overwriting "${prev}"): ${f}`);
+      }
+      const dest = path.join(amxmodxBuildDir, f);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(path.join(srcDir, f), dest);
+      origins.set(f, repoConfig.repo);
+      logger.verbose(`    + ${f}`);
+      copied++;
+    }
+
+    logger.dim(`  ${repoConfig.repo}: ${copied}/${files.length} files from ${repoConfig.amxmodx_dir}/`);
+  }
+
+  // Merge local amxmodx/ dir — always wins over repo files (intentional override layer)
+  const manifestDir     = path.dirname(manifest._path);
+  const localAmxmodxDir = path.join(manifestDir, manifest.amxmodx.dir);
+
+  if (fs.existsSync(localAmxmodxDir)) {
+    const files = await glob('**/*', {
+      cwd: localAmxmodxDir,
+      onlyFiles: true,
+      ignore: [],
+    });
+    for (const f of files) {
+      const dest = path.join(amxmodxBuildDir, f);
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.copyFileSync(path.join(localAmxmodxDir, f), dest);
+    }
+    if (files.length) logger.info(`Local ${manifest.amxmodx.dir}/: ${files.length} files merged`);
+  }
+
+}
+
+module.exports = { collectAll };

package/src/commands/build.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const logger = require('../logger');
+const { parseManifest, applyOverrides } = require('../manifest');
+const { resolveManifestPath, loadEnv } = require('./shared');
+const { printDryRun } = require('./dry-run');
+const { subscribeCompiledRendering } = require('./compile-renderer');
+const { runBuild } = require('../build-service');
+const { on, EVENTS } = require('../events');
+
+// Render compiler 'compiled' events (previously direct stdout/stderr writes).
+subscribeCompiledRendering();
+
+// Render build-service 'done' events (previously a direct logger.success at the
+// end of the CLI runBuild). Keeps the final `Done in Xs` message byte-identical.
+let doneSubscribed = false;
+function subscribeDoneRendering() {
+  if (doneSubscribed) return;
+  doneSubscribed = true;
+  on(EVENTS.DONE, (payload) => {
+    if (payload && payload.ok && payload.message) logger.success(payload.message);
+  });
+}
+subscribeDoneRendering();
+
+async function runBuildCLI(options) {
+  if (options.verbose) logger.setVerbose(true);
+
+  const manifestPath = resolveManifestPath(options.manifest);
+  loadEnv(manifestPath);
+
+  const manifest = parseManifest(manifestPath);
+  if (options.set?.length)    applyOverrides(manifest, options.set);
+  if (options.define?.length) manifest.amxmodx.defines.push(...options.define);
+  logger.info(`Manifest: ${manifest.name} v${manifest.version}`);
+
+  if (options.dryRun) {
+    printDryRun(manifest);
+    return;
+  }
+
+  await runBuild(manifest, {
+    buildDir: options.buildDir,
+    fetch:    options.fetch,
+    archive:  options.archive,
+  });
+}
+
+module.exports = { runBuild: runBuildCLI };

package/src/commands/cache.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const logger    = require('../logger');
+const { getCacheInfo, dirSize, fmtSize, parseCacheKey } = require('../cache-info');
+const { getCacheDir } = require('../cache-dir');
+
+function runCacheInfo(options = {}) {
+  const manifestPath = options.manifest ? path.resolve(options.manifest) : undefined;
+  const info = getCacheInfo(manifestPath);
+
+  logger.info(`Cache: ${info.cacheDir} (${info.totalSizeHuman} total)`);
+
+  if (info.totalSize === 0) {
+    logger.dim('  (empty)');
+    return;
+  }
+
+  if (info.compiler.versions.length) {
+    logger.info('\nCompiler (amxxpc):');
+    for (const ver of info.compiler.versions) {
+      for (const [platform, size] of Object.entries(ver.platforms)) {
+        logger.dim(`  ${ver.version.padEnd(14)} ${platform.padEnd(10)} ${fmtSize(size)}`);
+      }
+    }
+  }
+
+  if (info.repos.count) {
+    logger.info(`\nRepos (${info.repos.count}, ${info.repos.totalSizeHuman} total):`);
+    for (const e of info.repos.entries) {
+      const label = parseCacheKey(e.key);
+      logger.dim(`  ${label.padEnd(52)} ${fmtSize(e.size)}`);
+    }
+  }
+
+  if (info.releaseDeps.count) {
+    logger.info(`\nRelease deps (${info.releaseDeps.count}, ${info.releaseDeps.totalSizeHuman} total):`);
+    for (const e of info.releaseDeps.entries) {
+      const label = parseCacheKey(e.key);
+      logger.dim(`  ${label.padEnd(52)} ${fmtSize(e.size)}`);
+    }
+  }
+
+  if (info.localAssetCache) {
+    logger.info(`\nLocal asset cache (${info.localAssetCache.count}, ${info.localAssetCache.totalSizeHuman}):`);
+    logger.dim(`  ${info.localAssetCache.path}`);
+  }
+}
+
+function runCacheClean(options) {
+  const { all, compiler, repos, deps } = options;
+
+  if (!all && !compiler && !repos && !deps) {
+    logger.error('Specify what to clean: --compiler, --repos, --deps, or --all');
+    process.exit(1);
+  }
+
+  const cacheRoot = getCacheDir();
+  const targets = [];
+  if (all || compiler) targets.push({ dir: path.join(cacheRoot, 'amxxpc'),       label: 'compiler' });
+  if (all || repos)    targets.push({ dir: path.join(cacheRoot, 'repos'),         label: 'repos' });
+  if (all || deps)     targets.push({ dir: path.join(cacheRoot, 'release-deps'),  label: 'release deps' });
+
+  for (const { dir, label } of targets) {
+    if (!fs.existsSync(dir)) {
+      logger.dim(`  ${label}: already empty`);
+      continue;
+    }
+    const freed = dirSize(dir);
+    fs.rmSync(dir, { recursive: true, force: true });
+    logger.success(`Cleaned ${label} (${fmtSize(freed)} freed)`);
+  }
+}
+
+module.exports = { runCacheInfo, runCacheClean };

package/src/commands/clean.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const logger    = require('../logger');
+const { getCacheDir } = require('../cache-dir');
+
+async function runClean(options) {
+  const buildDir     = path.resolve(options.buildDir || './build');
+  const reposDir     = path.join(getCacheDir(), 'repos');
+  const releasesDir  = path.join(getCacheDir(), 'release-deps');
+  const compDir      = path.join(getCacheDir(), 'amxxpc');
+
+  if (fs.existsSync(buildDir)) {
+    fs.rmSync(buildDir, { recursive: true, force: true });
+    logger.info(`Cleaned: ${buildDir}`);
+  }
+  if (fs.existsSync(reposDir)) {
+    fs.rmSync(reposDir, { recursive: true, force: true });
+    logger.info(`Cleaned: ${reposDir}`);
+  }
+  if (fs.existsSync(releasesDir)) {
+    fs.rmSync(releasesDir, { recursive: true, force: true });
+    logger.info(`Cleaned: ${releasesDir}`);
+  }
+  if (options.all && fs.existsSync(compDir)) {
+    fs.rmSync(compDir, { recursive: true, force: true });
+    logger.info(`Cleaned: ${compDir}`);
+  }
+}
+
+module.exports = { runClean };

package/src/commands/compile-renderer.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const chalk  = require('chalk');
+const logger = require('../logger');
+const { on, EVENTS } = require('../events');
+
+let subscribed = false;
+
+function dots(filename) {
+  return chalk.dim(' ' + '.'.repeat(Math.max(1, 42 - filename.length)) + ' ');
+}
+
+/**
+ * Renders a single EVENTS.COMPILED payload exactly as src/compiler.js used to
+ * write it directly:
+ *  - ok:    `[amxx-builder]   <baseName> <dots> OK` on stdout
+ *           (logger.info adds the `[amxx-builder] ` prefix + trailing newline;
+ *            the leading `  ` yields the original 3-space gap)
+ *  - !ok:   `[amxx-builder] FAILED: <baseName>` + verbatim compiler output on stderr
+ */
+function renderCompiled(payload) {
+  const { baseName, ok, output } = payload;
+  if (ok) {
+    logger.info(`  ${baseName} ${dots(baseName)} ${chalk.green('OK')}`);
+  } else {
+    logger.error(`FAILED: ${baseName}`);
+    const out = (output || '').trim();
+    if (out) logger.rawError(out + '\n');
+  }
+}
+
+function subscribeCompiledRendering() {
+  if (subscribed) return;
+  subscribed = true;
+  on(EVENTS.COMPILED, renderCompiled);
+}
+
+module.exports = { subscribeCompiledRendering, renderCompiled, dots };

package/src/commands/deploy.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const logger              = require('../logger');
+const { parseManifest }   = require('../manifest');
+const { deployBuild }     = require('../deployer');
+const { sendRconForPlugins } = require('../rcon');
+const { resolveManifestPath, loadEnv } = require('./shared');
+const { runBuild } = require('./build');
+
+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$/, ''));
+}
+
+async function runDeploy(options) {
+  const manifestPath = resolveManifestPath(options.manifest);
+  const buildDir     = path.resolve(options.buildDir || './build');
+
+  loadEnv(manifestPath);
+
+  if (options.build) {
+    await runBuild({ ...options, manifest: manifestPath });
+  } else if (!fs.existsSync(buildDir)) {
+    throw new Error(`Build directory not found: ${buildDir}\n  → Run "amxb build" first, or use "amxb deploy --build"`);
+  }
+
+  const manifest = parseManifest(manifestPath);
+  await deployBuild(manifest, buildDir, { incremental: options.incremental || false });
+
+  const pluginNames = gatherPluginNames(buildDir);
+  await sendRconForPlugins(manifest.deploy, pluginNames);
+}
+
+module.exports = { runDeploy };