@cimplify/cli 0.15.3 → 0.16.0

package/dist/test-ZPBWV4VX.mjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+import { readinessScript, readinessGate, READINESS_GATE } from './chunk-47ZXSY47.mjs';
+import { runSession, prepareSession } from './chunk-TYV2SVFN.mjs';
+import { buildGates, frameGates, browserRequired } from './chunk-KMHORI4Y.mjs';
+import { CHECK_DEVICES, DEFAULT_FRAMES, loadScript, DEFAULT_DEVICE, compareImages, decodePng, encodePng, GOLDEN, parseDevice, DEFAULT_SEED } from './chunk-KNPYBZ6B.mjs';
+import { locateChromium } from './chunk-BYNE553A.mjs';
+import './chunk-NY4YT7O6.mjs';
+import './chunk-SF44L2OD.mjs';
+import './chunk-VSA44UKR.mjs';
+import './chunk-EGQIPYUN.mjs';
+import './chunk-SCKQ4XSD.mjs';
+import { buildLocal, workPath, requireInteractiveProject } from './chunk-CPBESPWK.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-5HP2INMY.mjs';
+import './chunk-JKECUAAV.mjs';
+import { formatFinding } from './chunk-THATLMEX.mjs';
+import './chunk-T4MW3PD4.mjs';
+import './chunk-KQNZKV6E.mjs';
+import { detectPackageManager } from './chunk-LNMITJ4Z.mjs';
+import './chunk-SAXGWS2K.mjs';
+import './chunk-G2ZEFSQJ.mjs';
+import { locateToolchain } from './chunk-ZUCDXRFI.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-AKACUJ3W.mjs';
+import './chunk-25ZPFHLF.mjs';
+import { formatDiagnostic } from './chunk-SGT5IJVW.mjs';
+import './chunk-LLRUOIMU.mjs';
+import { parseArgs, flagBool } from './chunk-XQAHREKO.mjs';
+import './chunk-CLQYPTJ2.mjs';
+import './chunk-TT4YI33G.mjs';
+import { failure, warn, info, dim, success, CliError, CLI_ERROR_CODE, result } from './chunk-KOD4GBQ5.mjs';
+import { spawn } from 'child_process';
+import { promises, existsSync } from 'fs';
+import path from 'path';
+
+var UI_GATE = "game UI";
+var VISUAL_GATE = "visual";
+var VISUAL_DIR = "test/visual";
+var GOLDEN_DIR = "goldens";
+var SCRIPT_EXTENSIONS = [".json", ".ts"];
+var CANVAS_PROFILE = "canvas";
+var GAME_API = "game_api";
+var REPORTED_FINDINGS = 12;
+var SEPARATOR = "; ";
+var DEFAULT_DEPS = {
+  prepare: prepareSession,
+  run: runSession,
+  browser: (setup) => {
+    const found = locateChromium([setup.toolchain.base, setup.toolchain.sdkDir]);
+    return typeof found === "string" ? found : null;
+  },
+  toolchain: (root) => locateToolchain(root) !== null
+};
+function gate(name, status, detail) {
+  return { name, status, detail };
+}
+function request(device, script, scriptPath) {
+  const parsed = parseDevice(device);
+  if (typeof parsed === "string") throw new Error(parsed);
+  return { device: parsed, backend: "swiftshader", seed: script?.seed ?? DEFAULT_SEED, scene: script?.scene ?? null, frame: DEFAULT_FRAMES, script, scriptPath, screenshots: true, inspect: true };
+}
+async function visualScripts(root) {
+  const dir = path.join(root, VISUAL_DIR);
+  if (!existsSync(dir)) return [];
+  const names = await promises.readdir(dir);
+  return names.filter((n) => SCRIPT_EXTENSIONS.includes(path.extname(n))).sort().map((n) => path.join(dir, n));
+}
+function goldenPath(root, script, capture, device) {
+  const base = path.basename(script, path.extname(script));
+  return path.join(root, VISUAL_DIR, GOLDEN_DIR, `${base}-${capture}-${device}.png`);
+}
+async function checkGate(setup, deps) {
+  const lines = [];
+  let findings = 0;
+  let exempted = 0;
+  let unresolved = 0;
+  for (const device of CHECK_DEVICES) {
+    const frames = await deps.run(setup, request(device, null, null));
+    for (const frame of frames) {
+      const report = frame.inspect;
+      if (report === null) continue;
+      findings += report.checks.findings.length;
+      exempted += report.checks.exempted.length;
+      unresolved += report.checks.unresolved.length;
+      for (const f of report.checks.findings) if (lines.length < REPORTED_FINDINGS) lines.push(`${device}: ${formatFinding(f)}`);
+      for (const invalid of report.checks.invalid_exemptions) lines.push(`${device}: ${invalid}`);
+      for (const problem of report.problems) if (lines.length < REPORTED_FINDINGS) lines.push(`${device}: ${problem}`);
+    }
+  }
+  const summary = `${findings} findings on ${CHECK_DEVICES.join(", ")} at frame ${DEFAULT_FRAMES} (${exempted} exempted with a reason, ${unresolved} contrast checks without a known background)`;
+  if (findings > 0) return gate(UI_GATE, "failed", [summary, ...lines].join(SEPARATOR));
+  return gate(UI_GATE, "passed", lines.length === 0 ? summary : [summary, ...lines].join(SEPARATOR));
+}
+async function visualGate(root, setup, options, deps) {
+  const scripts = await visualScripts(root);
+  if (scripts.length === 0) return gate(VISUAL_GATE, "skipped", `add input scripts under ${VISUAL_DIR}/ with capture steps to compare frames against goldens`);
+  const misses = [];
+  const written = [];
+  let compared = 0;
+  for (const file of scripts) {
+    const script = await loadScript(file);
+    for (const device of script.devices ?? [DEFAULT_DEVICE]) {
+      const frames = await deps.run(setup, request(device, script, path.relative(root, file)));
+      for (const frame of frames) {
+        const golden = goldenPath(root, file, frame.sidecar.name, device);
+        const label = path.relative(root, golden);
+        if (options.update) {
+          await promises.mkdir(path.dirname(golden), { recursive: true });
+          await promises.writeFile(golden, frame.png);
+          written.push(label);
+          continue;
+        }
+        if (!existsSync(golden)) {
+          misses.push(`${label} has no golden; run cimplify test --visual --update and commit it`);
+          continue;
+        }
+        compared++;
+        const diff = compareImages(decodePng(frame.png), decodePng(await promises.readFile(golden)));
+        if (diff.passed) continue;
+        const actual = workPath(root, "visual", `${path.basename(golden, ".png")}.actual.png`);
+        await promises.mkdir(path.dirname(actual), { recursive: true });
+        await promises.writeFile(actual, frame.png);
+        if (diff.diff !== null) await promises.writeFile(actual.replace(/\.actual\.png$/, ".diff.png"), encodePng(diff.diff));
+        misses.push(
+          diff.size_matches ? `${label}: mean ${diff.mean.toFixed(3)} (limit ${GOLDEN.mean}), outliers ${diff.outliers.toFixed(4)} (limit ${GOLDEN.outliers}); actual and diff in ${path.relative(root, path.dirname(actual))}` : `${label}: the capture is a different size from the golden`
+        );
+      }
+    }
+  }
+  if (options.update) return gate(VISUAL_GATE, "passed", `wrote ${written.length} goldens: ${written.join(", ")}`);
+  if (misses.length > 0) return gate(VISUAL_GATE, "failed", misses.join(SEPARATOR));
+  return gate(VISUAL_GATE, "passed", `${compared} captures match their goldens (mean <= ${GOLDEN.mean}, outliers <= ${GOLDEN.outliers})`);
+}
+async function uiGates(root, build, options, deps = DEFAULT_DEPS) {
+  const profile = build.result.manifest?.profile ?? null;
+  if (profile === null || profile.kind !== CANVAS_PROFILE || profile.game !== GAME_API) {
+    return options.visual ? [gate(VISUAL_GATE, "skipped", "visual goldens capture canvas games built on the game API")] : [];
+  }
+  const readiness = readinessScript(root) !== null;
+  const unavailable = (reason) => {
+    const status = browserRequired() ? "failed" : "skipped";
+    const names = options.visual ? [UI_GATE, VISUAL_GATE] : [UI_GATE];
+    if (readiness) names.push(READINESS_GATE);
+    return names.map((name) => gate(name, status, reason));
+  };
+  if (!deps.toolchain(root)) return unavailable("the pinned SDK is not installed, so the game cannot be served");
+  let setup;
+  try {
+    setup = await deps.prepare(root);
+  } catch (error) {
+    return [gate(UI_GATE, "failed", error.message)];
+  }
+  const missing = deps.browser(setup);
+  if (missing !== null) return unavailable(missing);
+  const out = [];
+  try {
+    out.push(await checkGate(setup, deps));
+  } catch (error) {
+    out.push(gate(UI_GATE, "failed", `the game could not be inspected: ${error.message}`));
+  }
+  if (options.visual) {
+    try {
+      out.push(await visualGate(root, setup, options, deps));
+    } catch (error) {
+      out.push(gate(VISUAL_GATE, "failed", `the visual captures did not run: ${error.message}`));
+    }
+  }
+  if (readiness) {
+    try {
+      out.push(await readinessGate(root, setup, deps.run));
+    } catch (error) {
+      out.push(gate(READINESS_GATE, "failed", `the readiness run did not complete: ${error.message}`));
+    }
+  }
+  return out;
+}
+
+// src/interactives/commands/test.ts
+var TEST_DIR = "test";
+var TEST_SCRIPT = "test";
+async function hasTestScript(root) {
+  try {
+    const pkg = JSON.parse(await promises.readFile(path.join(root, "package.json"), "utf8"));
+    return typeof pkg.scripts?.[TEST_SCRIPT] === "string";
+  } catch {
+    return false;
+  }
+}
+var runPackageTests = async (root) => {
+  if (!await hasTestScript(root)) return { name: "project tests", status: "skipped", detail: "package.json has no test script" };
+  const pm = await detectPackageManager(root);
+  const code = await new Promise((resolve, reject) => {
+    const child = spawn(pm, ["run", TEST_SCRIPT], { cwd: root, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("close", (c) => resolve(c ?? 1));
+  });
+  return code === 0 ? { name: "project tests", status: "passed", detail: `${pm} run ${TEST_SCRIPT}` } : { name: "project tests", status: "failed", detail: `${pm} run ${TEST_SCRIPT} exited with ${code}` };
+};
+async function testProject(root, options) {
+  const gates = [];
+  if (options.projectTests !== null) gates.push(await options.projectTests(root));
+  const local = await buildLocal(root);
+  for (const d of local.result.diagnostics) (d.severity === "error" ? failure : warn)(formatDiagnostic(d));
+  for (const g of buildGates(local.result)) gates.push(g);
+  const frames = await frameGates(workPath(root, TEST_DIR), local.result, locateToolchain(root));
+  for (const g of frames.gates) gates.push(g);
+  if (options.ui !== void 0 && options.ui !== null) for (const g of await options.ui(root, local)) gates.push(g);
+  return { ok: gates.every((g) => g.status !== "failed"), gates, lockUpdated: local.lockUpdated };
+}
+async function run(argv) {
+  const args = parseArgs(argv);
+  const root = process.cwd();
+  requireInteractiveProject(root, "test");
+  const visual = { visual: flagBool(args, "visual"), update: flagBool(args, "update") };
+  const report = await testProject(root, {
+    projectTests: flagBool(args, "skip-project-tests") ? null : runPackageTests,
+    ui: (dir, build) => uiGates(dir, build, visual)
+  });
+  if (report.lockUpdated) info(dim("Pinned newly used libraries in cimplify.lock"));
+  for (const g of report.gates) {
+    const line = `${g.name}: ${g.detail}`;
+    if (g.status === "passed") success(line);
+    else if (g.status === "failed") failure(line);
+    else info(dim(`${line} (skipped)`));
+  }
+  if (!report.ok) {
+    const failed = report.gates.filter((g) => g.status === "failed").map((g) => g.name);
+    throw new CliError(CLI_ERROR_CODE.BUILD_FAILED, `gates failed: ${failed.join(", ")}; admission would refuse this source set`, { details: report });
+  }
+  result(report);
+}
+
+export { run as default, runPackageTests, testProject };

package/dist/testers-A3LMXOJJ.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+import { remoteFromEnv } from './chunk-EGQIPYUN.mjs';
+import { readInteractiveId, remoteCall } from './chunk-SCKQ4XSD.mjs';
+import { requireInteractiveProject } from './chunk-CPBESPWK.mjs';
+import './chunk-VHK7WBO3.mjs';
+import './chunk-5HP2INMY.mjs';
+import './chunk-JKECUAAV.mjs';
+import './chunk-T4MW3PD4.mjs';
+import './chunk-KQNZKV6E.mjs';
+import './chunk-ZUCDXRFI.mjs';
+import './chunk-EYEMPIMP.mjs';
+import './chunk-AKACUJ3W.mjs';
+import './chunk-25ZPFHLF.mjs';
+import './chunk-SGT5IJVW.mjs';
+import { parseArgs } from './chunk-XQAHREKO.mjs';
+import './chunk-CLQYPTJ2.mjs';
+import './chunk-TT4YI33G.mjs';
+import { CliError, CLI_ERROR_CODE, success, info, dim, result } from './chunk-KOD4GBQ5.mjs';
+
+// src/interactives/commands/testers.ts
+var USAGE = "usage: cimplify testers add|remove <account_id>, or cimplify testers list";
+var ADD = "add";
+var REMOVE = "remove";
+var LIST = "list";
+function parseTesterCommand(positional) {
+  const [action, accountId] = positional;
+  if (action === LIST) return { action };
+  if ((action === ADD || action === REMOVE) && accountId) return { action, accountId };
+  throw new CliError(CLI_ERROR_CODE.INVALID_INPUT, USAGE);
+}
+async function manageTesters(root, remote, command) {
+  const id = await readInteractiveId(root);
+  if (command.action === ADD) await remoteCall(() => remote.addTester(id, command.accountId));
+  else if (command.action === REMOVE) await remoteCall(() => remote.removeTester(id, command.accountId));
+  return remoteCall(() => remote.testers(id));
+}
+async function run(argv) {
+  const command = parseTesterCommand(parseArgs(argv).positional);
+  const root = process.cwd();
+  requireInteractiveProject(root, "testers");
+  const testers = await manageTesters(root, await remoteFromEnv(), command);
+  if (command.action === ADD) success(`${command.accountId} can open the test channel`);
+  else if (command.action === REMOVE) success(`${command.accountId} no longer opens the test channel`);
+  for (const t of testers) info(`${t.accountId} ${dim(`added ${t.addedAt}`)}`);
+  if (testers.length === 0) info(dim("no testers; only you can open the test channel"));
+  result(testers);
+}
+
+export { run as default, manageTesters, parseTesterCommand };

package/dist/{unlink-H3BO3DOQ.mjs → unlink-4G4FE4RJ.mjs}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { clearProjectLink } from './chunk-MLE4MVYC.mjs';
-import { success, info, result } from './chunk-3QUK5BPY.mjs';
+import { clearProjectLink } from './chunk-TT4YI33G.mjs';
+import { success, info, result } from './chunk-KOD4GBQ5.mjs';
 
 // src/commands/unlink.ts
 async function run(_argv) {

package/dist/{update-FLY46XI3.mjs → update-GHKKM5FS.mjs}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { promptYesNo } from './chunk-TH4XENKH.mjs';
-import { package_default } from './chunk-3RPR33MO.mjs';
-import { parseArgs, flagBool, flagString } from './chunk-5KYR6WJB.mjs';
-import { success, bold, info, dim, result, failure, CliError, CLI_ERROR_CODE, step, isJsonMode } from './chunk-3QUK5BPY.mjs';
+import { promptYesNo } from './chunk-I4HNHPEM.mjs';
+import { package_default } from './chunk-DYWUPHV3.mjs';
+import { parseArgs, flagBool, flagString } from './chunk-XQAHREKO.mjs';
+import { success, bold, info, dim, result, failure, CliError, CLI_ERROR_CODE, step, isJsonMode } from './chunk-KOD4GBQ5.mjs';
 import { spawn } from 'child_process';
 import { basename, dirname } from 'path';
 

package/dist/{whoami-CQPPARRS.mjs → whoami-3QQN6G2A.mjs}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
-import { ApiClient } from './chunk-NYXA6X56.mjs';
-import { readAuth } from './chunk-MLE4MVYC.mjs';
-import { info, bold, dim, result } from './chunk-3QUK5BPY.mjs';
+import { ApiClient } from './chunk-CLQYPTJ2.mjs';
+import { readAuth } from './chunk-TT4YI33G.mjs';
+import { info, bold, dim, result } from './chunk-KOD4GBQ5.mjs';
 
 // src/commands/whoami.ts
 var ENDPOINT_AUTH_ME = "/v1/auth/cli/me";