@a11ign/screenreader-fleet 0.4.2 → 0.5.0

package/dist/check-worker-code.mjs

@@ -5,7 +5,7 @@ import { execFileSync } from "node:child_process";
 import { errorText } from "@a11ign/screenreader-worker/error-text";
 import { fleetScriptPaths } from "./src_fleet-scripts_mjs.mjs";
 import { inventoryWorkerUrls, configuredWorkers, resolveWorkerPool } from "./fleet-env.mjs";
-import { expectedWorkerCode, remedyLines, codeDrift } from "./worker-code-check.mjs";
+import { remedyLines, codeDrift, resolveExpectedWorkerCode } from "./worker-code-check.mjs";
 import { refuseUnknownFlags } from "./cli-flags.mjs";
 import { requestJson } from "./worker-http.mjs";
 refuseUnknownFlags([], {
@@ -42,9 +42,9 @@ async function versionOf(url) {
     return response.json.code ?? "absent";
 }
 async function main() {
-    const expected = expectedWorkerCode();
+    const { code: expected, note } = await resolveExpectedWorkerCode();
     const { urls, source } = workerUrls();
-    console.log(`this checkout: ${expected}`);
+    console.log(`this checkout: ${expected}  (from ${note})`);
     if (!urls.length) {
         console.log("no worker configured, running locally, or listed in inventory.yml — nothing to compare");
         process.exit(0);

package/dist/worker-code-check.d.mts

@@ -1,3 +1,29 @@
+/**
+ * The hash every worker is expected to be serving, and WHERE IT CAME FROM. ONE function, asked by `a11ign-worker-code` and by
+ * `assertFleetRunsThisCheckout` alike, so the two cannot be given different hashers again (a11ign/a11ign#3781).
+ *
+ * With a layer clone present it is the CLONE's: the clone's own `code-version.mjs` over the clone's `src/`, which is what
+ * `layerCodeVersion("nvda-worker")` computes for the deploy and the lab, and what a guest is told to be on (`--layer-ref`). Asking the
+ * installed package instead made every worker read stale the first time a guest was deployed at a sha whose `.mjs` differed from the
+ * release, with a remedy ("redeploy") that could not clear it.
+ *
+ * With none it is the installed package's (a11ign/a11ign#3740: the one the package was RELEASED with, `codeVersion()` and no
+ * directory, because the built package's `workerSourceDir()` is `dist/` and holds none of the files a guest runs), and `source` and
+ * `note` say so, so a reading is never silent about which it was.
+ *
+ * ASYNC because the clone's hasher can only be imported dynamically, as `layerCodeVersion` does.
+ *
+ * @param {{ checkoutRoot?: string }} [options]
+ * @returns {Promise<{ code: string, source: "clone" | "installed", sourceDir: string, note: string }>}
+ */
+export function resolveExpectedWorkerCode({ checkoutRoot }?: {
+    checkoutRoot?: string;
+}): Promise<{
+    code: string;
+    source: "clone" | "installed";
+    sourceDir: string;
+    note: string;
+}>;
 /**
  * Refuse to capture with a fleet that is not running this checkout.
  *
@@ -10,15 +36,15 @@
  * A thin wrapper over `assertWorkersServe`, supplying the one thing only this file can compute: the hash.
  *
  * @param {string[]} workers
- * @param {{when?: string, allow?: boolean, read?: (url: string) => Promise<string|null>, bareMetalUrls?: string[]}} options
+ * @param {{when?: string, allow?: boolean, read?: (url: string) => Promise<string|null>, bareMetalUrls?: string[], checkoutRoot?: string}} options
  */
 export function assertFleetRunsThisCheckout(workers: string[], options?: {
     when?: string;
     allow?: boolean;
     read?: (url: string) => Promise<string | null>;
     bareMetalUrls?: string[];
+    checkoutRoot?: string;
 }): Promise<void>;
-export function expectedWorkerCode(): string;
 import { codeDrift } from "./code-drift.mjs";
 import { describeCodeDrift } from "./code-drift.mjs";
 import { describeEmptyPool } from "./code-drift.mjs";

package/dist/worker-code-check.mjs

@@ -1,5 +1,8 @@
 import { execFileSync } from "node:child_process";
 import { codeVersion, workerSourceDir } from "@a11ign/screenreader-worker/code-version";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
 import { requestJson } from "./worker-http.mjs";
 import { sandboxGitEnv } from "./src_git-safe-env_mjs.mjs";
 const HEALTH_TIMEOUT_MS = 15000;
@@ -119,11 +122,49 @@ async function assertWorkersServe(expected, workers, options) {
     process.stderr.write(refusal);
     process.exit(3);
 }
-const expectedWorkerCode = ()=>codeVersion();
+const NVDA_WORKER_LAYER = "nvda-worker";
+function layerClone(checkoutRoot) {
+    const manifestPath = join(checkoutRoot, "packages", "control", "layers.json");
+    if (!existsSync(manifestPath)) return {
+        absent: `no packages/control/layers.json under ${checkoutRoot}`
+    };
+    const layer = JSON.parse(readFileSync(manifestPath, "utf8")).layers?.[NVDA_WORKER_LAYER];
+    if (!layer?.path) return {
+        absent: `${manifestPath} does not declare "${NVDA_WORKER_LAYER}"`
+    };
+    const dir = resolve(checkoutRoot, layer.path);
+    return existsSync(dir) ? {
+        dir
+    } : {
+        absent: `no layer clone at ${dir}`
+    };
+}
+async function resolveExpectedWorkerCode({ checkoutRoot = process.cwd() } = {}) {
+    const clone = layerClone(checkoutRoot);
+    if ("absent" in clone) return {
+        code: codeVersion(),
+        source: "installed",
+        sourceDir: workerSourceDir(),
+        note: `the installed @a11ign/screenreader-worker (${clone.absent})`
+    };
+    const sourceDir = `${join(clone.dir, "src")}/`;
+    const hasher = await import(pathToFileURL(join(sourceDir, "code-version.mjs")).href);
+    return {
+        code: hasher.codeVersion(sourceDir),
+        source: "clone",
+        sourceDir,
+        note: `the layer clone at ${clone.dir}`
+    };
+}
 async function assertFleetRunsThisCheckout(workers, options = {}) {
-    return assertWorkersServe(expectedWorkerCode(), workers, {
-        ...options,
-        sourceDir: workerSourceDir()
+    const { checkoutRoot, ...rest } = options;
+    const expected = await resolveExpectedWorkerCode({
+        checkoutRoot
+    });
+    if (!options.allow) process.stdout.write(`Expected worker code ${expected.code}, from ${expected.note}.\n`);
+    return assertWorkersServe(expected.code, workers, {
+        ...rest,
+        sourceDir: expected.sourceDir
     });
 }
-export { assertFleetRunsThisCheckout, codeDrift, describeCodeDrift, describeEmptyPool, expectedWorkerCode, readWorkerCode, remedyLines, workerSourceDirty };
+export { assertFleetRunsThisCheckout, codeDrift, describeCodeDrift, describeEmptyPool, readWorkerCode, remedyLines, resolveExpectedWorkerCode, workerSourceDirty };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a11ign/screenreader-fleet",
-  "version": "0.4.2",
+  "version": "0.5.0",
   "description": "Host-side lifecycle, health and capacity for a fleet of Windows NVDA capture workers: lease one, judge whether it is degrading, and know how many the host can afford.",
   "license": "AGPL-3.0-or-later",
   "type": "module",