spectrum-cli 6.0.1 → 6.0.2

package/CHANGELOG.md

@@ -9,6 +9,14 @@ This is the changelog of the `spectrum-cli` npm package. Its version comes from
 `package.json`; the release commands use Git tags and `CHANGELOG.md` in the
 **target project** and do not update that project's `package.json`.
 
+## 🚀 [6.0.2] - 2026-10-29
+
+### Fixed
+
+- Ночной npm audit использует временный registry-scoped user config с Nexus credentials, сохраняет существующую конфигурацию и удаляет auth-файл после команды. Ошибки registry содержат исходный HTTP-код и сообщение без секретов.
+- Версия Node из runtime проверяется через Skopeo, rootless OCI unpack и запуск binary от непривилегированного uid в chroot. Сканирование больше не зависит от Buildah user/mount namespaces. Buildah остаётся инструментом сборки исправленного образа.
+- При ошибке проверки Node сохраняется уже полученный Trivy-отчёт; причины неполного сканирования выводятся в job log с удалением credentials.
+
 ## 🚀 [6.0.1] - 2026-10-29
 
 ### Fixed

package/README.md

@@ -612,6 +612,20 @@ npm pack --dry-run
 fixtures получены из прежнего Python-кода; исполняемый Python в пакет не входит.
 Публикация CLI, образов, компонентов и запуск живого pipeline — отдельные шаги.
 
+### npm registry и проверка runtime
+
+`NIGHTLY_NPM_REGISTRY` задаёт доверенный HTTPS registry для npm-команд ночного процесса. При наличии
+`NEXUS_USER` / `NEXUS_PASSWORD` CLI создаёт временный `.npmrc` с BASIC auth, ограниченной host/path этого registry.
+Существующий user config сохраняется, исходный файл не меняется. Временный файл имеет права `0600`, удаляется
+после команды и не входит в отчёт. URL registry передаётся CI-компонентом; значения инфраструктуры в CLI не зашиты.
+Ошибки npm сохраняют HTTP-код и причину, при этом credentials удаляются из диагностических сообщений.
+
+Для версии Node из runtime нужны Skopeo, umoci и chroot. CLI копирует выбранную платформу immutable OCI-образа,
+распаковывает rootfs в rootless-режиме и запускает только настроенный Node binary с `--version` от uid/gid 65534.
+Проверка требует доступный chroot (`CAP_SYS_CHROOT`), но не Buildah user/mount namespaces. Кросс-платформенный запуск
+требует binfmt/QEMU. Buildah нужен для пересборки runtime при автоматическом исправлении; отсутствие его нужных
+возможностей блокирует публикацию такого исправления и отражается в отчёте.
+
 ### Preflight для команд автоматизации
 
 Обязательные deployment-настройки задаются явно:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-cli",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "description": "🚀 Modern CLI for development workflow automation - release management, versioning, and changelog generation",
   "main": "index.js",
   "bin": {

package/src/automation/index.js

@@ -125,10 +125,19 @@ function exec(
     encoding: binary ? null : "utf8",
     windowsHide: true,
   });
-  ensure(
-    !result.error && allowed.includes(result.status),
-    `${label || path.basename(args[0]) + " " + (args[1] || "")} failed (exit ${result.status})`,
-  );
+  if (result.error || !allowed.includes(result.status)) {
+    const error = new Error(
+      `${label || path.basename(args[0]) + " " + (args[1] || "")} failed (exit ${result.status})`,
+    );
+    // Keep subprocess output out of generic error messages and serialization.
+    // Callers that know their credential context can expose redacted diagnostics.
+    Object.defineProperties(error, {
+      stdout: { value: result.stdout },
+      stderr: { value: result.stderr },
+      status: { value: result.status },
+    });
+    throw error;
+  }
   return {
     stdout: result.stdout,
     stderr: result.stderr,

package/src/security/runtime.js

@@ -23,7 +23,41 @@ function run(args, cwd, options = {}, env = process.env) {
   if (args[0] === "npm")
     for (const key of ["NPM_TOKEN", "NODE_AUTH_TOKEN"])
       if (env[key]) clean[key] = env[key];
-  return exec(args, { cwd, ...options, env: clean });
+  try {
+    return exec(args, { cwd, ...options, env: clean });
+  } catch (error) {
+    const detail = diagnostic(error.stderr || "", env);
+    if (detail) error.message += ": " + detail;
+    throw error;
+  }
+}
+function diagnostic(value, env = process.env) {
+  let text = String(value || "");
+  const secrets = Object.entries(env)
+    .filter(
+      ([key, value]) =>
+        /TOKEN|PASSWORD|SECRET|MATTERMOST_HOOK/i.test(key) && value,
+    )
+    .map(([, value]) => String(value));
+  if (env.NEXUS_USER && env.NEXUS_PASSWORD)
+    secrets.push(
+      Buffer.from(env.NEXUS_USER + ":" + env.NEXUS_PASSWORD).toString("base64"),
+    );
+  for (const secret of secrets.sort((a, b) => b.length - a.length))
+    text = text.split(secret).join("[REDACTED]");
+  return text
+    .replace(/(https?:\/\/)[^\s/@]+:[^\s/@]+@/g, "$1[REDACTED]@")
+    .replace(
+      /([?&](?:token|access_token|auth|password)=)[^&\s]+/gi,
+      "$1[REDACTED]",
+    )
+    .replace(
+      /\b(Bearer|Basic)\s+(?!realm=)[A-Za-z0-9+/_=.-]+/gi,
+      "$1 [REDACTED]",
+    )
+    .replace(/[\r\n]+/g, " ")
+    .slice(0, 2000)
+    .trim();
 }
 async function registryAuth(env, action) {
   return temporary("nightly-registry-", async (directory) => {
@@ -56,6 +90,45 @@ async function registryAuth(env, action) {
         ).toString("base64"),
       };
     const runtime = { ...env };
+    if (env.NIGHTLY_NPM_REGISTRY && env.NIGHTLY_NPM_ENABLED !== "false") {
+      let registry;
+      try {
+        registry = new URL(env.NIGHTLY_NPM_REGISTRY);
+      } catch {
+        throw new Error("NIGHTLY_NPM_REGISTRY must be an HTTPS registry URL");
+      }
+      ensure(
+        registry.protocol === "https:" &&
+          !registry.username &&
+          !registry.password &&
+          !registry.search &&
+          !registry.hash,
+        "NIGHTLY_NPM_REGISTRY must be an HTTPS registry URL",
+      );
+      runtime.NPM_CONFIG_REGISTRY = registry.href;
+      if (env.NEXUS_USER && env.NEXUS_PASSWORD) {
+        const userconfig =
+          env.NPM_CONFIG_USERCONFIG ||
+          env.npm_config_userconfig ||
+          path.join(require("node:os").homedir(), ".npmrc");
+        const existing = fs.existsSync(userconfig)
+          ? fs.readFileSync(userconfig, "utf8")
+          : "";
+        const scope =
+          "//" + registry.host + registry.pathname.replace(/\/?$/, "/");
+        const auth = Buffer.from(
+          env.NEXUS_USER + ":" + env.NEXUS_PASSWORD,
+        ).toString("base64");
+        const file = path.join(directory, "npmrc");
+        fs.writeFileSync(
+          file,
+          existing.trimEnd() + "\n" + scope + ":_auth=" + auth + "\n",
+          { mode: 0o600 },
+        );
+        runtime.NPM_CONFIG_USERCONFIG = file;
+        delete runtime.npm_config_userconfig;
+      }
+    }
     if (Object.keys(auths).length) {
       const file = path.join(directory, "config.json");
       fs.writeFileSync(file, JSON.stringify({ auths }), { mode: 0o600 });
@@ -182,6 +255,7 @@ async function pages(api, location, query = {}) {
 }
 module.exports = {
   cleanEnv,
+  diagnostic,
   run,
   registryAuth,
   artifactRedirect,

package/src/security/scan.js

@@ -6,10 +6,12 @@ const {
   save,
   json,
   temporary,
+  temp,
+  remove,
   repositoryPath,
   DIGEST,
 } = require("../automation");
-const { run, API } = require("./runtime");
+const { run, API, diagnostic } = require("./runtime");
 const {
   npmFindings,
   trivyFindings,
@@ -67,12 +69,38 @@ class Scanner {
   }
   async auditNpm(root, evidence) {
     const proc = this.run(
-        ["npm", "audit", "--omit=dev", "--audit-level=high", "--json"],
-        root,
-        { allowed: [0, 1] },
-      ),
+      ["npm", "audit", "--omit=dev", "--audit-level=high", "--json"],
+      root,
+      { allowed: [0, 1] },
+    );
+    if (evidence)
+      save(evidence.replace(/\.json$/, "-command.json"), {
+        status: proc.status,
+        stderr: diagnostic(proc.stderr, this.env),
+      });
+    let report;
+    try {
       report = json(proc.stdout);
+    } catch {
+      throw new Error(
+        "npm audit returned invalid JSON" +
+          (proc.stderr ? ": " + diagnostic(proc.stderr, this.env) : ""),
+      );
+    }
     if (evidence) save(evidence, report);
+    if (!report || report.error || !report.vulnerabilities) {
+      const code = report?.statusCode || report?.error?.code || proc.status;
+      const detail = diagnostic(
+        report?.message ||
+          report?.error?.summary ||
+          report?.error?.detail ||
+          proc.stderr,
+        this.env,
+      );
+      throw new Error(
+        `npm audit returned no vulnerability report (${code})${detail ? ": " + detail : ""}`,
+      );
+    }
     const values = await npmFindings(report, this.deps.aliases);
     ensure(
       proc.status === 0 || values.length,
@@ -92,21 +120,45 @@ class Scanner {
     return image.split("@")[0] + "@" + digest;
   }
   nodeVersion(image, platform) {
-    const container = this.run([
-      "buildah",
-      "from",
-      "--platform",
-      platform,
-      image,
-    ]).stdout.trim();
+    ensure(
+      ["linux/amd64", "linux/arm64"].includes(platform),
+      "Unsupported runtime platform",
+    );
+    const directory = temp("nightly-node-");
+    const imagePath = path.join(directory, "image");
+    const bundle = path.join(directory, "bundle");
+    let failure;
     try {
+      this.run([
+        "skopeo",
+        "--override-os",
+        "linux",
+        "--override-arch",
+        platform.split("/")[1],
+        "copy",
+        "docker://" + image,
+        "oci:" + imagePath + ":runtime",
+      ]);
+      this.run([
+        "umoci",
+        "unpack",
+        "--rootless",
+        "--image",
+        imagePath + ":runtime",
+        bundle,
+      ]);
+      const binary = this.env.NIGHTLY_NODE_BINARY || "/nodejs/bin/node";
+      ensure(
+        path.posix.isAbsolute(binary) && !binary.split("/").includes(".."),
+        "Expected an absolute runtime Node binary path",
+      );
+      // Execute only the runtime binary, with its own libraries and an unprivileged uid.
+      // This does not need a container daemon, mount namespace or Buildah storage.
       const value = this.run([
-        "buildah",
-        "run",
-        "--isolation=chroot",
-        container,
-        "--",
-        this.env.NIGHTLY_NODE_BINARY || "/nodejs/bin/node",
+        "chroot",
+        "--userspec=65534:65534",
+        path.join(bundle, "rootfs"),
+        binary,
         "--version",
       ])
         .stdout.trim()
@@ -116,8 +168,16 @@ class Scanner {
         "Cannot determine runtime Node.js version",
       );
       return value;
+    } catch (error) {
+      failure = error;
+      throw error;
     } finally {
-      this.run(["buildah", "rm", container]);
+      try {
+        remove(directory);
+      } catch (cleanup) {
+        if (failure) failure.message += "; cleanup: " + cleanup.message;
+        else throw cleanup;
+      }
     }
   }
   async feed() {
@@ -125,7 +185,7 @@ class Scanner {
       ? this.deps.feed()
       : new API("https://raw.githubusercontent.com").get(NODE_FEED);
   }
-  async scanImage(image, platform, feed) {
+  async scanImage(image, platform, feed, evidence) {
     ensure(
       ["linux/amd64", "linux/arm64"].includes(platform),
       "Unsupported runtime platform",
@@ -155,6 +215,7 @@ class Scanner {
       ]);
       return read(filename);
     });
+    if (evidence) save(evidence, report);
     const values = trivyFindings(report);
     let version = null;
     if ((this.env.NIGHTLY_CHECK_NODE || "true") === "true") {
@@ -209,7 +270,7 @@ class Scanner {
       tools.push("npm");
     }
     if ((this.env.NIGHTLY_CHECK_NODE || "true") === "true")
-      tools.push("buildah");
+      tools.push("umoci", "chroot");
     (this.deps.checkExecutables || checkExecutables)(tools, this.env);
     const platforms = (this.env.NIGHTLY_PLATFORMS || "linux/amd64").split(",");
     ensure(
@@ -276,8 +337,12 @@ class Scanner {
           platforms = (this.env.NIGHTLY_PLATFORMS || "linux/amd64").split(",");
         report.runtime = { image, dockerfile, platforms };
         for (const [index, platform] of platforms.entries()) {
-          const [raw, values, version] = await this.scanImage(image, platform);
-          save(path.join(output, `runtime-${index}.json`), raw);
+          const [, values, version] = await this.scanImage(
+            image,
+            platform,
+            undefined,
+            path.join(output, `runtime-${index}.json`),
+          );
           report.runtime[platform] = { node: version };
           report.findings.push(...values);
         }
@@ -294,6 +359,8 @@ class Scanner {
         "NIGHTLY_SCAN_JOB_ID=" + this.env.CI_JOB_ID + "\n",
       );
     }
+    for (const error of report.errors)
+      console.error("ERROR security scan: " + diagnostic(error, this.env));
     return report.errors.length ? 1 : 0;
   }
 }