clusterflux-public/scripts/acceptance-report.js

#!/usr/bin/env node

const cp = require("child_process");
const fs = require("fs");
const os = require("os");
const path = require("path");

const repo = path.resolve(__dirname, "..");
const mode = process.argv[2] || "public";

function commandOutput(command, args = []) {
  try {
    return cp
      .execFileSync(command, args, {
        cwd: repo,
        encoding: "utf8",
        stdio: ["ignore", "pipe", "pipe"]
      })
      .trim();
  } catch (_) {
    return null;
  }
}

function packageJson() {
  return JSON.parse(
    fs.readFileSync(path.join(repo, "vscode-extension/package.json"), "utf8")
  );
}

function firstCommandOutput(candidates) {
  for (const [command, args] of candidates) {
    const output = commandOutput(command, args);
    if (output) {
      return { command, version: output };
    }
  }
  return null;
}

function podmanReport() {
  const version = commandOutput("podman", ["--version"]);
  if (!version) {
    return {
      status: "incomplete",
      version: null,
      rootless: null,
      incomplete_reason: "podman command is unavailable"
    };
  }
  const rootless = commandOutput("podman", [
    "info",
    "--format",
    "{{.Host.Security.Rootless}}"
  ]);
  if (!rootless) {
    return {
      status: "incomplete",
      version,
      rootless: null,
      incomplete_reason: "podman info did not report rootless status"
    };
  }
  if (rootless !== "true") {
    return {
      status: "incomplete",
      version,
      rootless,
      incomplete_reason: "podman is not running in rootless mode"
    };
  }
  return {
    status: "available",
    version,
    rootless,
    incomplete_reason: null
  };
}

const extensionPackage = packageJson();
const sourceCommit =
  process.env.DISASMER_ACCEPTANCE_COMMIT || commandOutput("git", ["rev-parse", "HEAD"]);
const browserVersion = firstCommandOutput([
  ["chromium", ["--version"]],
  ["chromium-browser", ["--version"]],
  ["google-chrome", ["--version"]],
  ["firefox", ["--version"]]
]);
const report = {
  kind: "disasmer_acceptance_environment",
  mode,
  commit: sourceCommit,
  tree_status: (commandOutput("git", ["status", "--short"]) || "")
    .split("\n")
    .filter(Boolean),
  generated_at: new Date().toISOString(),
  os: {
    platform: os.platform(),
    release: os.release(),
    kernel: os.release(),
    arch: os.arch()
  },
  rust: {
    rustc: commandOutput("rustc", ["--version"]),
    cargo: commandOutput("cargo", ["--version"])
  },
  node: {
    version: process.version
  },
  podman: podmanReport(),
  postgres: {
    version:
      commandOutput("postgres", ["--version"]) ||
      commandOutput("psql", ["--version"])
  },
  browser_harness: {
    version: browserVersion && browserVersion.version,
    command: browserVersion && browserVersion.command,
    configured: process.env.DISASMER_BROWSER_HARNESS || "not-configured"
  },
  vscode_harness: {
    smokes: [
      "scripts/vscode-extension-smoke.js",
      "scripts/vscode-f5-smoke.js"
    ],
    engine: extensionPackage.engines && extensionPackage.engines.vscode,
    extension_version: extensionPackage.version
  },
  windows_validation: process.env.DISASMER_WINDOWS_VALIDATION || "not-run"
};

const outDir = path.join(repo, "target/acceptance");
fs.mkdirSync(outDir, { recursive: true });
fs.writeFileSync(
  path.join(outDir, `${mode}-environment.json`),
  `${JSON.stringify(report, null, 2)}\n`
);

console.log(JSON.stringify(report, null, 2));