@nuucognition/ops-cli 0.0.0-stage → 0.1.0-dev.2

package/bin/node-guard.js

@@ -0,0 +1,61 @@
+// THE NODE.JS GUARD. ops needs Node.js 24 or newer (`engines.node` of
+// package.json; the bundle targets node24). npm only warns about `engines`,
+// so a global install on an older Node.js works, and the CLI then fails later
+// with an error that names no cause. The `ops` launcher (ops-prod.js) calls
+// this guard FIRST, before it imports a module of the build: on an older
+// Node.js the guard prints one refusal and exits 1.
+//
+// This file must parse and run on an old Node.js. Keep it plain JavaScript:
+// `var`, `function`, and string joins; no optional chaining, no `??`, no
+// class fields, no top-level await, and no import of a module of the build.
+// The model is bin/node-guard.js of the flint CLI.
+
+import { writeSync } from 'fs';
+
+var MINIMUM = [24, 0];
+var MINIMUM_TEXT = String(MINIMUM[0]);
+var DOWNLOAD = 'https://nodejs.org';
+
+/** True when `version` (`20.11.0`, with or without a `v`) is older than the minimum. */
+export function nodeTooOld(version) {
+  var parts = String(version).replace(/^v/, '').split('.');
+  var major = parseInt(parts[0], 10) || 0;
+  var minor = parseInt(parts[1], 10) || 0;
+  return major < MINIMUM[0] || (major === MINIMUM[0] && minor < MINIMUM[1]);
+}
+
+/** True when the arguments ask for JSON: `--json` before a `--` terminator. */
+function wantsJson(args) {
+  for (var i = 0; i < args.length; i += 1) {
+    if (args[i] === '--') return false;
+    if (args[i] === '--json') return true;
+  }
+  return false;
+}
+
+/**
+ * The refusal of an old Node.js, or null when the version is new enough.
+ * With `--json` the refusal is one error document on stderr, in the shape of
+ * the other errors of ops (`{"error": {code, message, exitCode, hints}}`).
+ * Else it is the error lines of ops on stderr: the reason and the next action.
+ */
+export function nodeGuardRefusal(version, args) {
+  if (!nodeTooOld(version)) return null;
+  var shown = String(version).replace(/^v/, '');
+  var message = 'ops needs Node.js ' + MINIMUM_TEXT + ' or newer. This is Node.js ' + shown + '.';
+  var hint = 'Install Node.js ' + MINIMUM_TEXT + ' or newer (' + DOWNLOAD + '), then run ops again.';
+  if (wantsJson(args)) {
+    var report = { code: 'node_too_old', message: message, exitCode: 1, hints: [hint], node: shown, minimum: MINIMUM_TEXT };
+    return { exitCode: 1, text: JSON.stringify({ error: report }, null, 2) + '\n' };
+  }
+  return { exitCode: 1, text: 'error node_too_old: ' + message + '\n  ' + hint + '\n' };
+}
+
+/** Refuse and exit 1 on a Node.js that is too old. Else do nothing. */
+export function guardNodeVersion() {
+  var refusal = nodeGuardRefusal(process.versions.node, process.argv.slice(2));
+  if (refusal === null) return;
+  // A write that completes before the exit.
+  writeSync(2, refusal.text);
+  process.exit(refusal.exitCode);
+}

package/bin/ops-prod.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+
+import { guardNodeVersion } from './node-guard.js';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+// The Node.js guard runs first (see node-guard.js): an older Node.js gets one
+// refusal before any module of the build loads. So this file imports no
+// module of the build statically.
+guardNodeVersion();
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, '..');
+const launcher = fileURLToPath(import.meta.url);
+const entrypoint = join(packageRoot, 'dist', 'index.js');
+
+// The `ops` launcher: the production build (`dist`, build mode baked as
+// production, so it always uses prod data). It is the one bin of the
+// published package.
+//
+// The two stamp checks below apply only in a source checkout (the package
+// has `src/`). An installed npm package has no `src/`, no cli-core, and no
+// bin/stale.js, so it skips them and runs no git command.
+if (existsSync(join(packageRoot, 'src'))) {
+  const { warnIfBuildStale } = await import('@nuucognition/cli-core/launch').catch(() => ({ warnIfBuildStale() {} }));
+  warnIfBuildStale({ cli: 'ops', distEntry: entrypoint, rebuildHint: 'Run: ndv build ops prod' });
+  // The prod bundle keeps its mode, so it never runs the source: when it is
+  // older than the source of this checkout, one warning says so (none under --json).
+  const stale = await import('./stale.js').catch(() => null);
+  const staleSha = stale ? stale.staleAgainstSource(packageRoot, join(packageRoot, 'dist')) : null;
+  if (staleSha && !stale.wantsJson()) {
+    process.stderr.write(`warning: the ops bundle (dist, built from ${staleSha.slice(0, 7)}) is older than the source of this checkout: a newer command can be missing. Next: ndv build ops prod\n`);
+  }
+}
+
+process.env.OPS_CLI_LAUNCHER = launcher;
+process.env.OPS_CLI_ENTRYPOINT = entrypoint;
+await import(pathToFileURL(entrypoint).href);

package/dist/.build-stamp.json

@@ -0,0 +1,7 @@
+{
+  "sha": null,
+  "tree": null,
+  "dirty": false,
+  "builtAt": "2026-10-22T22:40:35.315Z",
+  "mode": "prod"
+}