@tokenoftrust/storefront-runner 1.4.2-rc.0 → 2.0.0

package/apps/storefront/scripts/dogfood-v84-nonportable-routes.ts

@@ -0,0 +1,73 @@
+/** Fixed-input clean-clone replay for all eight v84 nonportable dispositions. */
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import {
+  MANAGED_ANALYTICS_SCHEMA_VERSION,
+  platformAdapterCatalog,
+  type GetAdapterDefinitionRequest,
+  type GetAdapterDefinitionResponse,
+} from "@tot/public-runtime";
+import { buildV84CloneMigrationEvidence } from "../src/lib/apps/v84CloneMigrationEvidence.js";
+import { buildV84NonportableRouteDogfood } from "../src/lib/apps/v84NonportableRouteDogfood.js";
+
+if (process.argv.length !== 2) {
+  process.stderr.write("refused: fixed-input dogfood command accepts no arguments\n");
+  process.exit(64);
+}
+
+const fixturePath = fileURLToPath(new URL(
+  "../../../packages/public-runtime/tests/gtm-migration/fixtures/gtm-sample-container-v84.redacted.json",
+  import.meta.url,
+));
+const fixture = readFileSync(fixturePath, "utf8");
+const EXPECTED_FIXTURE_SHA256 = "57d28f3ed5da4215599bfb4b74f984d8b0cd8bf7d8b31e0e1172877308e9b688";
+const definitions = platformAdapterCatalog().map((card) => ({
+  schemaVersion: MANAGED_ANALYTICS_SCHEMA_VERSION,
+  adapterId: card.adapterId,
+  adapterVersion: "1.0.0",
+  displayName: card.name,
+  description: card.purpose,
+  availability: "available" as const,
+  configuration: [{
+    key: "destinationId", label: card.idLabel,
+    description: "Public destination identifier used by this reviewed adapter.",
+    kind: "string" as const, required: true,
+  }],
+  eventTypes: [...card.eventTypes],
+  consentPurposes: [...card.consentPurposes],
+  collectionOrigins: [...card.cspOrigins].sort(),
+}));
+const catalogAdapterIds = definitions.map((item) => item.adapterId);
+const catalog = {
+  async getAdapterDefinition(request: GetAdapterDefinitionRequest): Promise<GetAdapterDefinitionResponse> {
+    const found = definitions.find((item) => item.adapterId === request.query.adapterId);
+    if (!found) return { apiVersion: "v1", requestId: "req-dogfood-missing", error: { code: "not_found", message: "The requested adapter was not found." } };
+    return { apiVersion: "v1", requestId: "req-dogfood-catalog", data: found };
+  },
+};
+
+const run = async () => {
+  const imported = await buildV84CloneMigrationEvidence(fixture, catalog);
+  return buildV84NonportableRouteDogfood(imported, catalogAdapterIds);
+};
+const sourceSha256Before = createHash("sha256").update(fixture).digest("hex");
+if (sourceSha256Before !== EXPECTED_FIXTURE_SHA256) throw new Error("The fixed v84 fixture changed.");
+const first = await run();
+const second = await run();
+const sourceSha256After = createHash("sha256").update(readFileSync(fixturePath, "utf8")).digest("hex");
+const canonicalFirst = JSON.stringify(first);
+const canonicalSecond = JSON.stringify(second);
+if (canonicalFirst !== canonicalSecond || sourceSha256Before !== sourceSha256After) {
+  throw new Error("The clean-clone replay was not deterministic or source-read-only.");
+}
+process.stdout.write(`${JSON.stringify({
+  ...first,
+  cleanCloneReplay: {
+    runs: 2,
+    exactReplay: true,
+    sourceSha256Before,
+    sourceSha256After,
+    ledgerSha256: createHash("sha256").update(canonicalFirst).digest("hex"),
+  },
+}, null, 2)}\n`);

package/apps/storefront/scripts/fixed-v84-native-install-producer.ts

@@ -0,0 +1,79 @@
+/** Load the already-reviewed fixed native-install diagnostic as an inert JSON artifact. */
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export const FIXED_V84_NATIVE_INSTALL_CLI_SHA256 =
+  "a95ae6b248d50bc034287e307997df6745d02638f1094c09cfecac4da6680b44" as const;
+
+const PRODUCER_FAILURE = "The fixed native-install evidence producer failed safely.";
+const PRODUCER_TIMEOUT_MS = 20_000;
+const PRODUCER_PATH = fileURLToPath(new URL("./install-v84-native-through-ws1.ts", import.meta.url));
+const PRODUCER_BOOTSTRAP_PATH = fileURLToPath(
+  new URL("./run-fixed-v84-native-install-producer.mjs", import.meta.url),
+);
+
+interface ProducerResult {
+  readonly status: number | null;
+  readonly signal: NodeJS.Signals | null;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly error?: unknown;
+}
+
+interface ProducerDependencies {
+  readonly readSource: (path: string) => string;
+  readonly run: (
+    command: string,
+    args: readonly string[],
+    options: {
+      readonly encoding: "utf8";
+      readonly env: Readonly<Record<string, string>>;
+      readonly timeout: number;
+      readonly maxBuffer: number;
+    },
+  ) => ProducerResult;
+}
+
+const dependencies: ProducerDependencies = {
+  readSource: (path) => readFileSync(path, "utf8"),
+  run: (command, args, options) => spawnSync(command, [...args], options),
+};
+
+/**
+ * Run the fixed no-argument producer and return only its parsed JSON value.
+ * Every filesystem/process/output failure collapses to one stable, path-free error.
+ */
+export function readFixedV84NativeInstallEvidence(
+  deps: ProducerDependencies = dependencies,
+): unknown {
+  try {
+    const source = deps.readSource(PRODUCER_PATH);
+    if (createHash("sha256").update(source).digest("hex") !== FIXED_V84_NATIVE_INSTALL_CLI_SHA256) {
+      throw new Error(PRODUCER_FAILURE);
+    }
+    const result = deps.run(
+      process.execPath,
+      [PRODUCER_BOOTSTRAP_PATH],
+      {
+        encoding: "utf8",
+        env: {},
+        timeout: PRODUCER_TIMEOUT_MS,
+        maxBuffer: 16 * 1024 * 1024,
+      },
+    );
+    if (
+      result.error !== undefined ||
+      result.status !== 0 ||
+      result.signal !== null ||
+      result.stderr !== "" ||
+      result.stdout.length === 0
+    ) {
+      throw new Error(PRODUCER_FAILURE);
+    }
+    return JSON.parse(result.stdout) as unknown;
+  } catch {
+    throw new Error(PRODUCER_FAILURE);
+  }
+}