clusterflux-public/scripts/acceptance-evidence-contract-smoke.js

#!/usr/bin/env node

const assert = require("assert");
const fs = require("fs");
const path = require("path");

const repo = path.resolve(__dirname, "..");

function read(relativePath) {
  return fs.readFileSync(path.join(repo, relativePath), "utf8");
}

function expect(source, name, pattern) {
  assert.match(source, pattern, `missing acceptance evidence guard: ${name}`);
}

function expectGate(script, gateName) {
  assert(
    script.includes("node scripts/acceptance-evidence-contract-smoke.js"),
    `${gateName} must run acceptance-evidence-contract-smoke.js`
  );
}

const phase2 = read("acceptance_criteria_phase2.md");
const publicAcceptance = read("scripts/acceptance-public.sh");
const privateAcceptance = read("scripts/acceptance-private.sh");
const publicSplit = read("scripts/verify-public-split.sh");
const localServicesSmoke = read("scripts/local-services-smoke.js");
const nodeAttachSmoke = read("scripts/node-attach-smoke.js");
const cliLocalRunSmoke = read("scripts/cli-local-run-smoke.js");
const vscodeF5Smoke = read("scripts/vscode-f5-smoke.js");
const dapSmoke = read("scripts/dap-smoke.js");
const artifactDownloadSmoke = read("scripts/artifact-download-smoke.js");
const artifactExportSmoke = read("scripts/artifact-export-smoke.js");
const selfHostedCoordinatorSmoke = read("scripts/self-hosted-coordinator-smoke.js");
const publicLocalDemoMatrix = read("scripts/public-local-demo-matrix-smoke.js");
const publicOperatorCompatSmoke = fs.existsSync(
  path.join(repo, "private/hosted-policy/scripts/public-operator-compat-smoke.js")
)
  ? read("private/hosted-policy/scripts/public-operator-compat-smoke.js")
  : null;
const publicDryrunE2e = read("scripts/public-release-dryrun-e2e.js");
const finalDryrunEvidence = read("scripts/public-release-dryrun-final-evidence.js");

expect(
  phase2,
  "phase 2 rejects type-only acceptance",
  /- \[x\] \*\*Passed:\*\* A criterion cannot be accepted solely because a type, trait, schema, mock, or unit-level model exists\./
);

for (const [gateName, script] of [
  ["public acceptance", publicAcceptance],
  ["private acceptance", privateAcceptance],
  ["public split", publicSplit],
]) {
  expectGate(script, gateName);
}

expect(publicAcceptance, "public gate includes unit coverage", /cargo test --workspace/);
expect(publicAcceptance, "public gate includes binary build coverage", /cargo build --workspace --bins/);
expect(privateAcceptance, "private gate includes hosted unit coverage", /cargo test --manifest-path private\/hosted-policy\/Cargo\.toml/);
expect(publicSplit, "public split includes copied-tree unit coverage", /cargo test --workspace --manifest-path "\$tmp_dir\/Cargo\.toml"/);
expect(publicSplit, "public split includes copied-tree binary build coverage", /cargo build --workspace --bins --manifest-path "\$tmp_dir\/Cargo\.toml"/);

for (const [gateName, script] of [
  ["public acceptance", publicAcceptance],
  ["public split", publicSplit],
]) {
  for (const smoke of [
    "scripts/local-services-smoke.js",
    "scripts/node-attach-smoke.js",
    "scripts/cli-local-run-smoke.js",
    "scripts/vscode-f5-smoke.js",
    "scripts/dap-smoke.js",
    "scripts/artifact-download-smoke.js",
    "scripts/artifact-export-smoke.js",
    "scripts/public-local-demo-matrix-smoke.js",
  ]) {
    assert(script.includes(`node ${smoke}`), `${gateName} must run boundary smoke ${smoke}`);
  }
}

for (const smoke of [
  "private/hosted-policy/scripts/hosted-deployment-smoke.js",
  "private/hosted-policy/scripts/hosted-community-smoke.js",
  "private/hosted-policy/scripts/public-operator-compat-smoke.js",
  "private/hosted-policy/scripts/postgres-durable-smoke.js",
]) {
  assert(
    privateAcceptance.includes(`node ${smoke}`),
    `private acceptance must run hosted boundary smoke ${smoke}`
  );
}
assert(
  privateAcceptance.includes("node scripts/self-hosted-coordinator-smoke.js"),
  "private acceptance must run standalone public coordinator smoke"
);

for (const [name, source, patterns] of [
  [
    "local services",
    localServicesSmoke,
    [/cp\.spawn/, /disasmer-coordinator/, /type: "create_node_enrollment_grant"/, /disasmer-node/],
  ],
  [
    "node attach",
    nodeAttachSmoke,
    [/cp\.spawn/, /"node"[\s\S]*"attach"/, /used_enrollment_exchange/, /runAttachedNodeWork/],
  ],
  [
    "CLI local run",
    cliLocalRunSmoke,
    [/cp\.spawn/, /disasmer[\s\S]*run/, /cli_process_started_node_process[\s\S]*true/],
  ],
  [
    "VS Code F5",
    vscodeF5Smoke,
    [
      /runtimeBackend[\s\S]*local-services/,
      /coordinator_task_events[\s\S]*value === 1/,
      /Source Locals/,
      /Task Args and Handles/,
      /unavailable-local-diagnostic/,
      /TaskHandle/,
      /linux_thread/,
      /linux_artifact/,
      /command_spec/,
      /stdout_tail/,
      /stderr_tail/,
    ],
  ],
  [
    "DAP",
    dapSmoke,
    [
      /runtimeBackend: "local-services"/,
      /threads[\s\S]*compile linux/,
      /send\("attach"/,
      /Source Locals/,
      /return_value/,
      /TaskHandle/,
      /linux_thread/,
      /linux_artifact/,
      /vfs_mounts/,
      /command_spec/,
      /stdout_tail/,
      /stderr_tail/,
    ],
  ],
  [
    "artifact download",
    artifactDownloadSmoke,
    [/create_artifact_download_link/, /open_artifact_download_stream/, /crossTenantOpen/],
  ],
  [
    "artifact export",
    artifactExportSmoke,
    [/export_artifact_to_node/, /node-export-receiver/, /coordinator_bulk_relay_allowed[\s\S]*false/],
  ],
  [
    "standalone public coordinator",
    selfHostedCoordinatorSmoke,
    [/disasmer-coordinator/, /standalone-public-coordinator/, /public-coordinator-compat\.json/],
  ],
  [
    "public local demo matrix",
    publicLocalDemoMatrix,
    [/scripts\/cli-install-smoke\.js/, /scripts\/node-attach-smoke\.js/, /scripts\/vscode-f5-smoke\.js/],
  ],
]) {
  for (const pattern of patterns) {
    expect(source, name, pattern);
  }
}

if (publicOperatorCompatSmoke) {
  for (const pattern of [
    /disasmer-hosted-service/,
    /"disasmer-cli"[\s\S]*"node"[\s\S]*"attach"/,
    /node_enrollment_exchanged/,
    /"disasmer-node"/,
    /node_capabilities_recorded/,
    /task_launched/,
    /poll_task_assignment/,
    /debug_command/,
    /task_log_recorded/,
    /vfs_metadata_recorded/,
    /public-operator-compat\.json/,
  ]) {
    expect(publicOperatorCompatSmoke, "public operator compatibility", pattern);
  }
}

for (const pattern of [
  /DISASMER_PUBLIC_RELEASE_DRYRUN_E2E/,
  /downloadReleaseAssets/,
  /verifyChecksums/,
  /git"[\s\S]*"clone"/,
  /defaultLoginPlan\.coordinator/,
  /--complete-browser-code/,
  /node_enrollment_exchanged/,
  /disasmerNode/,
  /launch_task/,
  /worker_assignment_poll_verified/,
  /validateStandalonePublicCoordinator/,
  /public_coordinator_validated/,
  /standalone-public-coordinator/,
  /task_recorded/,
  /list_task_events/,
  /create_artifact_download_link/,
  /vscode-f5-smoke\.js/,
  /downloaded_release_assets: true/,
  /vscode_debugger_verified: true/,
  /artifact_download_or_export_verified: true/,
  /public-release-dryrun-e2e\.json/,
]) {
  expect(publicDryrunE2e, "public release e2e evidence", pattern);
}

for (const pattern of [
  /public-release-dryrun-forgejo-release\.json/,
  /deployment-manifest\.json/,
  /public-release-dryrun-service\.json/,
  /public-operator-compat\.json/,
  /public-coordinator-compat\.json/,
  /public-release-dryrun-e2e\.json/,
  /coordinator_validation/,
  /downloaded_release_assets/,
  /vscode_debugger_verified/,
  /artifact_download_or_export_verified/,
  /public-release-dryrun-final\.json/,
]) {
  expect(finalDryrunEvidence, "public release final evidence", pattern);
}

console.log("Acceptance evidence contract smoke passed");