@contentsquare/wizard 2.0.0

package/dist/cli.js

@@ -0,0 +1,1187 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { Command } from "commander";
+
+// src/commands/status.ts
+import * as clack from "@clack/prompts";
+import chalk2 from "chalk";
+import path from "path";
+import fs from "fs";
+
+// src/commands/sorcerer.ts
+import chalk from "chalk";
+var SORCERER = chalk.magenta(`
+                    ____
+                  .'* *.'
+               __/_*_*(_
+              / _______ \\
+             _\\_)/___\\(_/_
+            / _((\\- -/))_ \\
+            \\ \\())(-)(()/ /
+             ' \\(((()))/ '
+            / ' \\)).))/ ' \\
+           / _ \\ - | - /_  \\
+          (   ( .;''';. .'  )
+          _\\"__ /    )\\ __"/_
+            \\/  \\   ' /  \\/
+             .'  '...' ' )
+              / /  |  \\ \\
+             / .   .   . \\
+            /   .     .   \\
+           /   /   |   \\   \\
+         .'   /    b    '.  '.
+     _.-'    /     Bb     '-. '-._
+ _.-'       |      BBb       '-.  '-.
+(________mrf\\____.dBBBb.________)____)
+`) + chalk.bold.magenta("\n         CS Sorcerer") + chalk.dim('\n  "Your tag shall be cast."\n');
+
+// src/commands/status.ts
+async function status(options) {
+  process.stdout.write(SORCERER + "\n");
+  const targetDir = path.resolve(options.dir);
+  const stateFile = path.join(targetDir, ".cs-wizard", "state.json");
+  if (!fs.existsSync(stateFile)) {
+    clack.log.error(
+      `No wizard state found. Run ${chalk2.cyan("npx @contentsquare/wizard start")} first.`
+    );
+    process.exit(1);
+  }
+  const state = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+  clack.intro(chalk2.bold("Contentsquare Wizard Status"));
+  clack.log.info(`Tag ID: ${chalk2.cyan(state.tagId ?? "unknown")}`);
+  if (state.projectId) {
+    clack.log.info(`Project ID: ${chalk2.cyan(state.projectId)}`);
+  }
+  clack.log.info("");
+  const report = readLastReport(targetDir);
+  if (!report) {
+    clack.log.warn("No verification run yet.");
+    clack.log.info(
+      `Run ${chalk2.cyan("npx @contentsquare/wizard verify")} to check the tag in a real browser.`
+    );
+    clack.outro("");
+    return;
+  }
+  const ok = chalk2.green("\u2713");
+  const no = chalk2.red("\u2717");
+  const warn = chalk2.yellow("!");
+  clack.log.step(chalk2.bold("Latest verification"));
+  clack.log.info(`URL: ${chalk2.cyan(report.url)}`);
+  clack.log.info(`${report.tagScriptLoaded ? ok : no} Tag script loaded`);
+  clack.log.info(
+    `${report.initialPageview ? ok : no} First pageview sent on load`
+  );
+  if (report.navigations.length === 0) {
+    clack.log.info(`${warn} No in-app route changes recorded`);
+  } else {
+    const icon = report.navigationsWithPageview === report.navigations.length ? ok : warn;
+    clack.log.info(
+      `${icon} Pageviews on navigation: ${report.navigationsWithPageview}/${report.navigations.length}`
+    );
+  }
+  clack.log.info(
+    report.cspViolations.length === 0 ? `${ok} No CSP violations` : `${no} CSP violations: ${report.cspViolations.length}`
+  );
+  clack.log.info("");
+  if (report.result === "pass") {
+    clack.log.success(chalk2.green("Result: pass"));
+  } else if (report.result === "pass-with-recommendation") {
+    clack.log.warn(chalk2.yellow("Result: pass with a recommendation"));
+    if (report.recommendation) clack.log.info(`  ${report.recommendation}`);
+  } else {
+    clack.log.error(chalk2.red("Result: fail"));
+  }
+  clack.outro("");
+}
+function readLastReport(targetDir) {
+  const reportFile = path.join(targetDir, ".cs-wizard", "last-report.json");
+  if (!fs.existsSync(reportFile)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(reportFile, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/verify/index.ts
+import * as clack4 from "@clack/prompts";
+import chalk7 from "chalk";
+import path5 from "path";
+import fs5 from "fs";
+
+// src/tools/state.ts
+import fs2 from "fs";
+import path2 from "path";
+var STATE_FILE = ".cs-wizard/state.json";
+function readState(dir) {
+  const stateFile = path2.join(dir, STATE_FILE);
+  if (fs2.existsSync(stateFile)) {
+    try {
+      return JSON.parse(fs2.readFileSync(stateFile, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/tools/tag-id.ts
+function isHashedTagId(value) {
+  return /^[0-9a-f]{10,20}$/.test(value.trim());
+}
+function validateTagId(value) {
+  return isHashedTagId(value) ? void 0 : "Tag ID is a lowercase hex string (~13 chars, e.g. 81c677ba742d7).";
+}
+function normalizeTagId(tagId) {
+  return tagId.trim().toLowerCase();
+}
+
+// src/commands/verify/logger.ts
+import * as clack2 from "@clack/prompts";
+function makeLogger(humanOutputToStderr) {
+  const stream = (chunk) => process.stderr.write(chunk);
+  if (humanOutputToStderr) {
+    const toErr = (m) => process.stderr.write(m + "\n");
+    return {
+      info: toErr,
+      step: toErr,
+      error: toErr,
+      success: toErr,
+      warn: toErr,
+      stream
+    };
+  }
+  return {
+    info: (m) => clack2.log.info(m),
+    step: (m) => clack2.log.step(m),
+    error: (m) => clack2.log.error(m),
+    success: (m) => clack2.log.success(m),
+    warn: (m) => clack2.log.warn(m),
+    stream
+  };
+}
+function fail(message) {
+  process.stderr.write(message + "\n");
+  process.exit(1);
+}
+function emitStdout(text3) {
+  process.stdout.write(text3);
+}
+
+// src/commands/verify/browser.ts
+import * as clack3 from "@clack/prompts";
+import chalk3 from "chalk";
+import { spawn } from "child_process";
+import { createRequire } from "module";
+import { chromium } from "playwright-core";
+
+// src/commands/verify/artifact.ts
+import path3 from "path";
+import fs3 from "fs";
+function writeArtifact(targetDir, fileName, data) {
+  try {
+    const dir = path3.join(targetDir, ".cs-wizard");
+    fs3.mkdirSync(dir, { recursive: true });
+    fs3.writeFileSync(path3.join(dir, fileName), JSON.stringify(data, null, 2));
+  } catch {
+  }
+}
+
+// src/commands/verify/browser.ts
+var PROXY_CERT_RE = /self.signed certificate|unable to (?:verify|get local issuer)|CERT_|SSL|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|getaddrinfo|tunneling socket|proxy/i;
+var BROWSER_FAILURE_EXIT_CODE = {
+  BROWSER_LAUNCH_FAILED: 1,
+  NO_BROWSER: 2,
+  MISSING_LIBS: 3,
+  BLOCKED_LAUNCH: 4,
+  NO_DISPLAY: 5
+};
+async function closeAndExit(browser, code) {
+  await browser.close().catch(() => {
+  });
+  process.exit(code);
+}
+async function acquireBrowser(options, log4, targetDir) {
+  let result = await tryLaunch();
+  if (result.browser) return result.browser;
+  let remedy = decideRemedy(result.attempts);
+  if (remedy === "missing-libs") {
+    failBrowser(
+      options,
+      log4,
+      targetDir,
+      "MISSING_LIBS",
+      result.attempts,
+      () => printMissingLibsHelp(log4, result.attempts)
+    );
+  }
+  if (remedy === "blocked") {
+    failBrowser(
+      options,
+      log4,
+      targetDir,
+      "BLOCKED_LAUNCH",
+      result.attempts,
+      () => printBlockedHelp(log4, result.attempts)
+    );
+  }
+  if (remedy === "missing") {
+    const install = await ensureBrowser(options, log4);
+    if (!install.ok) {
+      const attempts = result.attempts;
+      if (install.proxyHint) {
+        failBrowser(
+          options,
+          log4,
+          targetDir,
+          "NO_BROWSER",
+          attempts,
+          () => printProxyHelp(log4)
+        );
+      }
+      failBrowser(
+        options,
+        log4,
+        targetDir,
+        "NO_BROWSER",
+        attempts,
+        () => printBrowserHelp(log4, lastError(attempts))
+      );
+    }
+    result = await tryLaunch();
+    if (result.browser) return result.browser;
+    remedy = decideRemedy(result.attempts);
+    if (remedy === "missing-libs") {
+      failBrowser(
+        options,
+        log4,
+        targetDir,
+        "MISSING_LIBS",
+        result.attempts,
+        () => printMissingLibsHelp(log4, result.attempts)
+      );
+    }
+    failBrowser(
+      options,
+      log4,
+      targetDir,
+      "BROWSER_LAUNCH_FAILED",
+      result.attempts,
+      () => printBrowserHelp(log4, lastError(result.attempts))
+    );
+  }
+  failBrowser(
+    options,
+    log4,
+    targetDir,
+    "BROWSER_LAUNCH_FAILED",
+    result.attempts,
+    () => {
+      log4.error(`Could not launch a browser: ${lastError(result.attempts)}`);
+    }
+  );
+}
+async function tryLaunch() {
+  const configs = [
+    { label: "chrome", channel: "chrome" },
+    { label: "msedge", channel: "msedge" },
+    { label: "chromium" }
+    // bundled, if `playwright-core install chromium` was run
+  ];
+  const attempts = [];
+  for (const cfg of configs) {
+    try {
+      const browser = await chromium.launch({
+        headless: false,
+        ...cfg.channel ? { channel: cfg.channel } : {}
+      });
+      return { browser, attempts };
+    } catch (err) {
+      const message = err?.message ?? String(err);
+      attempts.push({
+        label: cfg.label,
+        channel: cfg.channel,
+        klass: classifyLaunchError(message),
+        message
+      });
+    }
+  }
+  return { browser: null, attempts };
+}
+function classifyLaunchError(message) {
+  if (/loading shared librar|libnss3|libnspr4|libatk|libgbm|libasound|libgtk|libx11|GLIBC/i.test(
+    message
+  ))
+    return "missing-libs";
+  if (/Executable doesn't exist|Chromium distribution|was not found|ENOENT|playwright install/i.test(
+    message
+  ))
+    return "missing";
+  if (/policy|enterprise|SingletonLock|ProcessSingleton|cannot create default profile|user data directory is already in use|DevToolsActivePort|Target page, context or browser has been closed/i.test(
+    message
+  ))
+    return "blocked";
+  return "unknown";
+}
+function decideRemedy(attempts) {
+  const chromiumAttempt = attempts.find((a) => a.label === "chromium");
+  if (chromiumAttempt?.klass === "missing") return "missing";
+  if (attempts.some((a) => a.klass === "missing-libs")) return "missing-libs";
+  if (attempts.every((a) => a.klass === "missing")) return "missing";
+  if (attempts.some((a) => a.klass === "blocked")) return "blocked";
+  return "unknown";
+}
+function lastError(attempts) {
+  return attempts[attempts.length - 1]?.message ?? "unknown error";
+}
+function isBrowserGoneError(message) {
+  return /Target (?:page, context or browser|closed)|browser has been closed|Browser closed|crash|disconnected/i.test(
+    message
+  );
+}
+function failBrowser(options, log4, targetDir, code, attempts, printHelp) {
+  writeBrowserFailure(targetDir, code, attempts);
+  printHelp();
+  if (options.json) {
+    emitStdout(JSON.stringify({ error: code }) + "\n");
+  }
+  process.exit(BROWSER_FAILURE_EXIT_CODE[code]);
+}
+function writeBrowserFailure(targetDir, code, attempts) {
+  writeArtifact(targetDir, "last-browser-error.json", {
+    error: code,
+    platform: `${process.platform} ${process.arch}`,
+    display: process.env.DISPLAY ?? null,
+    attempts: attempts.map((a) => ({
+      label: a.label,
+      class: a.klass,
+      message: a.message
+    })),
+    ts: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+function handleNoDisplay(options, log4, targetDir) {
+  writeBrowserFailure(targetDir, "NO_DISPLAY", []);
+  log4.error(
+    "No display detected. `verify` opens a real browser window and needs a desktop session."
+  );
+  log4.info(
+    "Run this on a machine with a graphical desktop \u2014 not a headless server or a plain SSH session."
+  );
+  if (options.json) emitStdout(JSON.stringify({ error: "NO_DISPLAY" }) + "\n");
+  process.exit(BROWSER_FAILURE_EXIT_CODE.NO_DISPLAY);
+}
+async function ensureBrowser(options, log4) {
+  if (!options.installBrowser) {
+    if (options.json) {
+      log4.error(
+        "NO_BROWSER: no Chrome/Edge/Chromium found. Get the user's consent, then re-run this exact command with --install-browser added."
+      );
+      return { ok: false, proxyHint: false };
+    }
+    const consent = await clack3.confirm({
+      message: "No browser found. Download the Chromium engine now? (~280 MB, one-time)",
+      initialValue: true
+    });
+    if (clack3.isCancel(consent) || !consent)
+      return { ok: false, proxyHint: false };
+  }
+  return installChromium(log4);
+}
+function installChromium(log4) {
+  const require2 = createRequire(import.meta.url);
+  let cliPath;
+  try {
+    cliPath = require2.resolve("playwright-core/cli.js");
+  } catch {
+    log4.error("Could not locate playwright-core CLI to install Chromium.");
+    return Promise.resolve({ ok: false, proxyHint: false });
+  }
+  log4.step("Downloading Chromium (one-time)\u2026");
+  return new Promise((resolve) => {
+    const child = spawn(process.execPath, [cliPath, "install", "chromium"], {
+      // Forward proxy / CA / mirror settings so corporate networks can download.
+      env: { ...process.env },
+      // Never inherit stdout: it is reserved for the JSON report in --json mode.
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    const onData = (chunk) => {
+      const text3 = chunk.toString();
+      output += text3;
+      log4.stream(text3);
+    };
+    child.stdout?.on("data", onData);
+    child.stderr?.on("data", onData);
+    child.on("error", (err) => {
+      output += String(err?.message ?? err);
+      resolve({ ok: false, proxyHint: PROXY_CERT_RE.test(output) });
+    });
+    child.on("close", (code) => {
+      resolve({
+        ok: code === 0,
+        proxyHint: code !== 0 && PROXY_CERT_RE.test(output)
+      });
+    });
+  });
+}
+function printBrowserHelp(log4, errMessage) {
+  log4.error("Could not launch a browser.");
+  log4.info("Install one of the following, then re-run:");
+  log4.info(
+    `  \u2022 Google Chrome (recommended) \u2014 ${chalk3.cyan("https://www.google.com/chrome/")}`
+  );
+  log4.info(
+    `  \u2022 or the bundled engine \u2014 ${chalk3.cyan("npx playwright-core install chromium")}`
+  );
+  log4.info(chalk3.dim(`(${errMessage})`));
+}
+function printMissingLibsHelp(log4, attempts) {
+  log4.error("A browser was found but is missing system libraries.");
+  log4.info("Install the libraries Chromium needs, then re-run:");
+  log4.info(`  ${chalk3.cyan("sudo npx playwright-core install-deps chromium")}`);
+  log4.info(chalk3.dim(`(${lastError(attempts)})`));
+}
+function printBlockedHelp(log4, attempts) {
+  log4.error("A browser was found but refused to launch.");
+  log4.info(
+    "This is usually an enterprise policy or a profile that is already in use."
+  );
+  log4.info("Try one of the following, then re-run:");
+  log4.info("  \u2022 Close all open Chrome/Edge windows and try again.");
+  log4.info(
+    `  \u2022 Or use a clean bundled engine \u2014 ${chalk3.cyan("npx playwright-core install chromium")}, then re-run with ${chalk3.cyan("--install-browser")}.`
+  );
+  log4.info(chalk3.dim(`(${lastError(attempts)})`));
+}
+function printProxyHelp(log4) {
+  log4.error(
+    "Could not download Chromium \u2014 this looks like a proxy or certificate issue."
+  );
+  log4.info("If you are behind a corporate proxy, set these and re-run:");
+  for (const line of proxyEnvExamples()) {
+    log4.info(
+      `  ${chalk3.cyan(line.command)}${line.note ? `  ${chalk3.dim(line.note)}` : ""}`
+    );
+  }
+}
+function proxyEnvExamples() {
+  const vars = [
+    { name: "HTTPS_PROXY", value: "http://your-proxy:port" },
+    { name: "NODE_EXTRA_CA_CERTS", value: "/path/to/corporate-ca.pem" },
+    {
+      name: "PLAYWRIGHT_DOWNLOAD_HOST",
+      value: "http://your-mirror",
+      note: "(if your org mirrors the browser CDN)"
+    }
+  ];
+  if (process.platform === "win32") {
+    return vars.map((v) => ({
+      command: `$env:${v.name}="${v.value}"`,
+      note: v.note
+    }));
+  }
+  return vars.map((v) => ({
+    command: `export ${v.name}=${v.value}`,
+    note: v.note
+  }));
+}
+
+// src/commands/verify/preflight.ts
+import chalk4 from "chalk";
+import path4 from "path";
+import fs4 from "fs";
+import os from "os";
+import { createRequire as createRequire2 } from "module";
+import { chromium as chromium2 } from "playwright-core";
+var PREFLIGHT_NO_BROWSER_EXIT_CODE = 2;
+async function runPreflight(targetDir, options, log4) {
+  const browsersPath = process.env.PLAYWRIGHT_BROWSERS_PATH ?? defaultBrowsersPath();
+  let bundledChromiumPath = null;
+  let bundledChromiumPresent = false;
+  try {
+    bundledChromiumPath = chromium2.executablePath();
+    bundledChromiumPresent = !!bundledChromiumPath && fs4.existsSync(bundledChromiumPath);
+  } catch {
+    bundledChromiumPath = null;
+  }
+  const systemChrome = await probeChannel("chrome");
+  const systemEdge = await probeChannel("msedge");
+  const bundledChromium = await probeChannel(void 0);
+  const anyOk = systemChrome.ok || systemEdge.ok || bundledChromium.ok;
+  const info = {
+    os: `${process.platform} ${process.arch}`,
+    node: process.version,
+    display: process.platform === "linux" ? process.env.DISPLAY ?? process.env.WAYLAND_DISPLAY ?? null : "n/a",
+    playwrightCoreVersion: readPlaywrightCoreVersion(),
+    browsersPath,
+    bundledChromiumPath,
+    bundledChromiumPresent,
+    systemChrome,
+    systemEdge,
+    bundledChromium,
+    anyBrowserAvailable: anyOk
+  };
+  writeArtifact(targetDir, "last-preflight.json", info);
+  if (options.json) {
+    emitStdout(JSON.stringify(info, null, 2) + "\n");
+    process.exit(anyOk ? 0 : PREFLIGHT_NO_BROWSER_EXIT_CODE);
+  }
+  log4.step(chalk4.bold("verify preflight"));
+  log4.info(`OS: ${info.os}  \u2022  Node: ${info.node}`);
+  log4.info(`Display: ${formatValue(info.display)}`);
+  log4.info(`playwright-core: ${formatValue(info.playwrightCoreVersion)}`);
+  log4.info(`Browsers cache: ${formatValue(browsersPath)}`);
+  log4.info(
+    `Bundled Chromium present: ${bundledChromiumPresent ? chalk4.green("yes") : chalk4.yellow("no")}`
+  );
+  log4.info(probeLine("System Chrome", systemChrome));
+  log4.info(probeLine("System Edge", systemEdge));
+  log4.info(probeLine("Bundled Chromium", bundledChromium));
+  log4.info("");
+  if (anyOk) {
+    log4.success(chalk4.green("A browser is available \u2014 verify should work."));
+  } else {
+    log4.warn(
+      chalk4.yellow(
+        "No working browser found. Run `verify --install-browser`, or install Google Chrome."
+      )
+    );
+  }
+  process.exit(anyOk ? 0 : PREFLIGHT_NO_BROWSER_EXIT_CODE);
+}
+async function probeChannel(channel) {
+  try {
+    const browser = await chromium2.launch({
+      headless: true,
+      ...channel ? { channel } : {}
+    });
+    const version = browser.version();
+    await browser.close().catch(() => {
+    });
+    return { ok: true, version };
+  } catch (err) {
+    return {
+      ok: false,
+      error: firstLine(err?.message ?? String(err))
+    };
+  }
+}
+function readPlaywrightCoreVersion() {
+  try {
+    const require2 = createRequire2(import.meta.url);
+    const pkgPath = require2.resolve("playwright-core/package.json");
+    return JSON.parse(fs4.readFileSync(pkgPath, "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+function defaultBrowsersPath() {
+  const home = os.homedir();
+  if (process.platform === "darwin")
+    return path4.join(home, "Library", "Caches", "ms-playwright");
+  if (process.platform === "win32")
+    return path4.join(home, "AppData", "Local", "ms-playwright");
+  return path4.join(home, ".cache", "ms-playwright");
+}
+function probeLine(label, probe) {
+  if (probe.ok)
+    return `${chalk4.green("\u2713")} ${label}: ${probe.version ?? "available"}`;
+  return `${chalk4.yellow("\u2717")} ${label}: ${chalk4.dim(probe.error ?? "unavailable")}`;
+}
+function firstLine(text3) {
+  return text3.split("\n")[0];
+}
+function formatValue(value) {
+  return value === null || value === void 0 || value === "" ? chalk4.dim("\u2014") : String(value);
+}
+
+// src/commands/verify/session.ts
+import chalk5 from "chalk";
+
+// src/commands/verify/inject.ts
+var NAV_BINDING = "__csWizardNav";
+var DONE_BINDING = "__csWizardDone";
+function historyHookScript() {
+  return `(() => {
+    const send = (type) => {
+      try { window.${NAV_BINDING}({ type, url: location.href }); } catch {}
+    };
+    for (const name of ['pushState', 'replaceState']) {
+      const orig = history[name];
+      history[name] = function () {
+        const r = orig.apply(this, arguments);
+        send(name);
+        return r;
+      };
+    }
+    window.addEventListener('popstate', () => send('popstate'));
+  })();`;
+}
+function overlayScript() {
+  return `(() => {
+    const ID = '__cs-wizard-overlay';
+    function mount() {
+      if (!document.body || document.getElementById(ID)) return;
+      const bar = document.createElement('div');
+      bar.id = ID;
+      bar.setAttribute('style', [
+        'position:fixed','left:50%','bottom:20px','transform:translateX(-50%)',
+        'z-index:2147483647','background:#1b1b2f','color:#fff',
+        'font:14px/1.4 system-ui,-apple-system,Segoe UI,sans-serif',
+        'padding:12px 16px','border-radius:10px','box-shadow:0 6px 24px rgba(0,0,0,.35)',
+        'display:flex','align-items:center','gap:14px','max-width:90vw'
+      ].join(';'));
+      const msg = document.createElement('span');
+      msg.innerHTML = '<strong>Contentsquare check running.</strong> Click around a few pages, then press Done.';
+      const btn = document.createElement('button');
+      btn.textContent = 'Done';
+      btn.setAttribute('style', [
+        'background:#6c5ce7','color:#fff','border:0','cursor:pointer',
+        'padding:8px 16px','border-radius:8px','font-weight:600','font-size:14px'
+      ].join(';'));
+      btn.onclick = () => {
+        btn.disabled = true;
+        btn.textContent = 'Finishing\u2026';
+        try { window.${DONE_BINDING}(); } catch {}
+      };
+      bar.appendChild(msg);
+      bar.appendChild(btn);
+      document.body.appendChild(bar);
+    }
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', mount);
+    } else {
+      mount();
+    }
+  })();`;
+}
+
+// src/commands/verify/session.ts
+var CS_DOMAIN = String.raw`contentsquare\.(net|com)`;
+var CS_HOST_RE = new RegExp(String.raw`(^|\.)${CS_DOMAIN}$`, "i");
+var CS_DOMAIN_RE = new RegExp(CS_DOMAIN, "i");
+var CSP_RE = /content-security-policy|refused to|violates the following|err_blocked_by_csp|blocked:csp/i;
+var TAG_SCRIPT_RE = /\/uxa\/[^/]+\.js(\?|$)/i;
+async function runVerifySession(browser, url, log4) {
+  const navEvents = [];
+  const csRequests = [];
+  const violations = [];
+  let signalDone = () => {
+  };
+  const doneClicked = new Promise((resolve) => {
+    signalDone = resolve;
+  });
+  let context;
+  try {
+    context = await browser.newContext();
+    await context.exposeBinding(
+      NAV_BINDING,
+      (_source, data) => {
+        navEvents.push({ type: data.type, url: data.url, ts: Date.now() });
+      }
+    );
+    await context.addInitScript(historyHookScript());
+    await context.exposeBinding(DONE_BINDING, () => signalDone());
+    await context.addInitScript(overlayScript());
+    context.on("request", (req) => recordCsRequest(req, csRequests));
+    context.on(
+      "requestfailed",
+      (req) => recordRequestViolation(req, violations)
+    );
+    const page = await context.newPage();
+    page.on(
+      "console",
+      (msg) => recordConsoleViolation(msg, violations)
+    );
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 3e4 });
+  } catch (err) {
+    const message = err?.message ?? String(err);
+    if (isBrowserGoneError(message)) {
+      log4.error(
+        `The browser closed before the page finished loading. (${message})`
+      );
+    } else {
+      log4.error(
+        `Could not load ${url}. Is the dev server running? (${message})`
+      );
+    }
+    return closeAndExit(browser, 1);
+  }
+  printBrowseInstructions(log4);
+  await waitForFinish(browser, context, doneClicked);
+  return { navEvents, csRequests, violations };
+}
+function recordCsRequest(req, out) {
+  const host = safeHost(req.url());
+  if (!host || !CS_HOST_RE.test(host)) return;
+  const kind = TAG_SCRIPT_RE.test(req.url()) ? "script" : "beacon";
+  out.push({ url: req.url(), ts: Date.now(), kind });
+}
+function recordRequestViolation(req, out) {
+  const host = safeHost(req.url());
+  if (!host || !CS_HOST_RE.test(host)) return;
+  const failure = req.failure()?.errorText ?? "";
+  if (CSP_RE.test(failure)) {
+    out.push({ source: "request", text: `${req.url()} \u2014 ${failure}` });
+  }
+}
+function recordConsoleViolation(msg, out) {
+  const text3 = msg.text();
+  if (CSP_RE.test(text3) && CS_DOMAIN_RE.test(text3)) {
+    out.push({ source: "console", text: text3 });
+  }
+}
+function printBrowseInstructions(log4) {
+  log4.info("");
+  log4.step(chalk5.bold("Browse your app now:"));
+  log4.info("  1. Wait a moment for the first page to settle.");
+  log4.info("  2. Click through a few in-app routes (and log in if needed).");
+  log4.info(
+    `  3. Click ${chalk5.bold("\u201CDone\u201D")} in the banner (or close the window) to see the report.`
+  );
+  log4.info("");
+}
+function waitForFinish(browser, context, doneClicked) {
+  return new Promise((resolve) => {
+    const finish = once(() => {
+      browser.close().catch(() => {
+      });
+      resolve();
+    });
+    const openPages = new Set(context.pages());
+    const watchPage = (p) => {
+      p.on("close", () => {
+        openPages.delete(p);
+        if (openPages.size === 0) finish();
+      });
+    };
+    context.pages().forEach(watchPage);
+    context.on("page", (p) => {
+      openPages.add(p);
+      watchPage(p);
+    });
+    doneClicked.then(finish);
+    browser.on("disconnected", finish);
+    context.on("close", finish);
+    process.once("SIGINT", finish);
+  });
+}
+function safeHost(u) {
+  try {
+    return new URL(u).hostname;
+  } catch {
+    return "";
+  }
+}
+function once(fn) {
+  let called = false;
+  return () => {
+    if (called) return;
+    called = true;
+    fn();
+  };
+}
+
+// src/commands/verify/analyze.ts
+var NAV_BEACON_WINDOW_MS = 6e3;
+var NAV_DEDUPE_WINDOW_MS = 400;
+var SPA_TRACKING_RECOMMENDATION = 'Some in-app route changes did not fire a pageview. If this is a single-page app, enable "Tracking URL Changes" in the Contentsquare app (Project and Users \u2192 Tracking URL Changes).';
+function analyze(input) {
+  const { url, projectId, tagId, navEvents, csRequests, violations } = input;
+  const scripts = csRequests.filter((r) => r.kind === "script");
+  const beacons = csRequests.filter((r) => r.kind === "beacon");
+  const tagScriptLoaded = scripts.length > 0;
+  const tagIdMismatch = tagScriptLoaded && !scripts.some((s) => s.url.includes(tagId));
+  const navs = dropHydrationNav(collapseDuplicateNavs(navEvents), url);
+  const firstNavTs = navs[0]?.ts ?? Infinity;
+  const initialPageview = beacons.some((b) => b.ts <= firstNavTs);
+  const navigations = navs.map((nav) => ({
+    url: nav.url,
+    type: nav.type,
+    pageviewFired: firedPageviewAfter(beacons, nav.ts)
+  }));
+  const navigationsWithPageview = navigations.filter(
+    (n) => n.pageviewFired
+  ).length;
+  const cspViolations = dedupe(violations, (v) => v.text);
+  const { result, recommendation } = gradeResult({
+    tagScriptLoaded,
+    initialPageview,
+    cspViolations,
+    navigations,
+    navigationsWithPageview
+  });
+  return {
+    url,
+    projectId,
+    tagId,
+    tagScriptLoaded,
+    tagIdMismatch,
+    initialPageview,
+    navigations,
+    navigationsWithPageview,
+    cspViolations,
+    result,
+    recommendation
+  };
+}
+function collapseDuplicateNavs(navEvents) {
+  const navs = [];
+  for (const ev of navEvents) {
+    const prev = navs[navs.length - 1];
+    if (prev && prev.url === ev.url && ev.ts - prev.ts < NAV_DEDUPE_WINDOW_MS)
+      continue;
+    navs.push(ev);
+  }
+  return navs;
+}
+function dropHydrationNav(navs, landingUrl) {
+  const sameUrl = (a, b) => a.replace(/\/+$/, "") === b.replace(/\/+$/, "");
+  return navs.length > 0 && sameUrl(navs[0].url, landingUrl) ? navs.slice(1) : navs;
+}
+function firedPageviewAfter(beacons, navTs) {
+  return beacons.some(
+    (b) => b.ts > navTs && b.ts <= navTs + NAV_BEACON_WINDOW_MS
+  );
+}
+function gradeResult(checks) {
+  const {
+    tagScriptLoaded,
+    initialPageview,
+    cspViolations,
+    navigations,
+    navigationsWithPageview
+  } = checks;
+  if (!tagScriptLoaded || !initialPageview)
+    return { result: "fail", recommendation: null };
+  if (cspViolations.length > 0) return { result: "fail", recommendation: null };
+  if (navigations.length > 0 && navigationsWithPageview < navigations.length) {
+    return {
+      result: "pass-with-recommendation",
+      recommendation: SPA_TRACKING_RECOMMENDATION
+    };
+  }
+  return { result: "pass", recommendation: null };
+}
+function dedupe(items, key) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of items) {
+    const k = key(item);
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(item);
+  }
+  return out;
+}
+
+// src/commands/verify/report.ts
+import chalk6 from "chalk";
+var MAX_CSP_VIOLATIONS_SHOWN = 8;
+function printHumanReport(r, log4) {
+  const ok = chalk6.green("\u2713");
+  const no = chalk6.red("\u2717");
+  const warn = chalk6.yellow("!");
+  log4.info("");
+  log4.step(chalk6.bold("Verification report"));
+  log4.info(`${r.tagScriptLoaded ? ok : no} Tag script loaded`);
+  if (r.tagIdMismatch) {
+    log4.info(
+      `${warn} Tag URL uses a different ID than ${chalk6.cyan(r.tagId)} \u2014 check the tag ID used at install.`
+    );
+  }
+  log4.info(`${r.initialPageview ? ok : no} First pageview sent on load`);
+  if (r.navigations.length === 0) {
+    log4.info(
+      `${warn} No in-app route changes were recorded \u2014 navigate a few routes to test SPA coverage.`
+    );
+  } else {
+    const icon = r.navigationsWithPageview === r.navigations.length ? ok : warn;
+    log4.info(
+      `${icon} Pageviews on navigation: ${r.navigationsWithPageview}/${r.navigations.length}`
+    );
+    for (const n of r.navigations) {
+      log4.info(`    ${n.pageviewFired ? ok : no} ${n.type} \u2192 ${n.url}`);
+    }
+  }
+  if (r.cspViolations.length > 0) {
+    log4.info(`${no} CSP violations (${r.cspViolations.length}):`);
+    for (const v of r.cspViolations.slice(0, MAX_CSP_VIOLATIONS_SHOWN)) {
+      log4.info(`    ${chalk6.dim("-")} ${v.text}`);
+    }
+  } else {
+    log4.info(`${ok} No CSP violations detected`);
+  }
+  log4.info("");
+  if (r.result === "pass") {
+    log4.success(chalk6.green("All checks passed."));
+  } else if (r.result === "pass-with-recommendation") {
+    log4.warn(chalk6.yellow("Passed with a recommendation:"));
+    log4.info(`  ${r.recommendation}`);
+  } else {
+    log4.error(chalk6.red("Some checks failed \u2014 see above."));
+  }
+}
+
+// src/commands/verify/index.ts
+async function verify(options) {
+  const targetDir = path5.resolve(options.dir);
+  const log4 = makeLogger(!!options.json);
+  if (options.preflight) {
+    await runPreflight(targetDir, options, log4);
+    return;
+  }
+  const tagId = await resolveTagId(options, targetDir);
+  const rawProjectId = readState(targetDir)?.projectId;
+  const projectId = rawProjectId !== null && rawProjectId !== void 0 ? String(rawProjectId).trim() : null;
+  const url = await resolveUrl(options);
+  log4.info(`Tag ID: ${chalk7.cyan(tagId)}`);
+  log4.info(`Opening: ${chalk7.cyan(url)}`);
+  if (process.platform === "linux" && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) {
+    handleNoDisplay(options, log4, targetDir);
+  }
+  const browser = await acquireBrowser(options, log4, targetDir);
+  const trace = await runVerifySession(browser, url, log4);
+  const report = analyze({ url, projectId, tagId, ...trace });
+  const reportPath = path5.join(targetDir, ".cs-wizard", "last-report.json");
+  fs5.mkdirSync(path5.dirname(reportPath), { recursive: true });
+  fs5.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+  if (options.json) {
+    emitStdout(JSON.stringify(report, null, 2) + "\n");
+    return closeAndExit(browser, report.result === "fail" ? 1 : 0);
+  }
+  printHumanReport(report, log4);
+  emitStdout(
+    "\n```json cs-wizard-report\n" + JSON.stringify(report) + "\n```\n"
+  );
+  return closeAndExit(browser, report.result === "fail" ? 1 : 0);
+}
+async function resolveTagId(options, targetDir) {
+  const state = readState(targetDir);
+  if (options.tagId) {
+    if (validateTagId(options.tagId)) {
+      fail(
+        `--tag-id must be the hashed tag ID (hex, ~13 chars, lowercase), got: ${options.tagId}`
+      );
+    }
+    return normalizeTagId(options.tagId);
+  }
+  if (state?.tagId) return state.tagId;
+  if (options.json) {
+    fail(
+      "No tag ID found. Run `wizard start` first, or pass --tag-id <hashed>."
+    );
+  }
+  const answer = await clack4.text({
+    message: "Enter your Contentsquare tag ID (hashed hex, e.g. 81c677ba742d7):",
+    placeholder: "81c677ba742d7",
+    validate: (v) => validateTagId(v)
+  });
+  if (clack4.isCancel(answer)) {
+    clack4.cancel("Verification cancelled.");
+    process.exit(0);
+  }
+  return normalizeTagId(answer);
+}
+async function resolveUrl(options) {
+  if (options.url) return options.url;
+  if (options.json) fail("No URL provided. Pass --url <app-url>.");
+  const answer = await clack4.text({
+    message: "What URL should I open? (start your dev server first)",
+    placeholder: "http://localhost:3000",
+    validate: (v) => /^https?:\/\//.test(v.trim()) ? void 0 : "Enter a full URL (http://\u2026)."
+  });
+  if (clack4.isCancel(answer)) {
+    clack4.cancel("Verification cancelled.");
+    process.exit(0);
+  }
+  return answer.trim();
+}
+
+// src/commands/start.ts
+import * as clack5 from "@clack/prompts";
+import chalk8 from "chalk";
+import { exec } from "child_process";
+import path6 from "path";
+import fs6 from "fs";
+import { fileURLToPath } from "url";
+var __dirname2 = path6.dirname(fileURLToPath(import.meta.url));
+var PACKAGE_ROOT = findPackageRoot(__dirname2);
+var SKILL_FILE = "wizard-web-tag-install.md";
+var SKILL_PATH = `.cs-wizard/skills/${SKILL_FILE}`;
+var SETUP_PROMPT = `Read and follow ${SKILL_PATH} \u2014 read it directly by path, it is gitignored so do not search for it.`;
+async function start(options) {
+  process.stdout.write(SORCERER + "\n");
+  clack5.intro(chalk8.bold("Contentsquare Wizard \u2014 Start"));
+  const targetDir = path6.resolve(options.dir);
+  const tagId = await resolveTagId2(targetDir, options);
+  clack5.log.info(`Tag ID: ${chalk8.cyan(tagId)}`);
+  const spinner2 = clack5.spinner();
+  spinner2.start("Setting up wizard skill...");
+  const wizardDir = path6.join(targetDir, ".cs-wizard");
+  const skillsDir = path6.join(wizardDir, "skills");
+  fs6.mkdirSync(skillsDir, { recursive: true });
+  fs6.copyFileSync(
+    path6.join(PACKAGE_ROOT, "skills", SKILL_FILE),
+    path6.join(skillsDir, SKILL_FILE)
+  );
+  spinner2.stop(`Copied skill to ${chalk8.cyan(SKILL_PATH)}`);
+  const state = readExistingConfig(targetDir) ?? {};
+  state.tagId = tagId;
+  state.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  fs6.writeFileSync(
+    path6.join(wizardDir, "state.json"),
+    JSON.stringify(state, null, 2)
+  );
+  ensureGitignore(targetDir);
+  clack5.log.success("Wizard ready!");
+  clack5.log.info("");
+  await showNextSteps();
+}
+async function resolveTagId2(targetDir, options) {
+  if (options.tagId) {
+    const err = validateTagId(options.tagId);
+    if (err) {
+      clack5.log.error(`Invalid --tag-id value: ${err}`);
+      process.exit(1);
+    }
+    return normalizeTagId(options.tagId);
+  }
+  const existing = readExistingConfig(targetDir);
+  if (existing?.tagId) {
+    const reuse = await clack5.confirm({
+      message: `Found existing tag ID ${chalk8.cyan(String(existing.tagId))}. Use it?`,
+      initialValue: true
+    });
+    if (clack5.isCancel(reuse)) {
+      clack5.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    if (reuse) {
+      return String(existing.tagId);
+    }
+  }
+  const response = await clack5.text({
+    message: "Enter your Contentsquare tag ID (hashed hex, e.g. 81c677ba742d7):",
+    placeholder: "81c677ba742d7",
+    validate: (v) => validateTagId(v)
+  });
+  if (clack5.isCancel(response)) {
+    clack5.cancel("Setup cancelled.");
+    process.exit(0);
+  }
+  return normalizeTagId(response);
+}
+async function showNextSteps() {
+  clack5.log.step(chalk8.bold("Next steps:"));
+  clack5.log.info(
+    "  1. Open your AI coding agent (Copilot, Cursor, Claude Code, etc.)"
+  );
+  const copied = await copyToClipboard(SETUP_PROMPT);
+  if (copied) {
+    clack5.log.success(
+      `  2. ${chalk8.bold.green("Prompt copied to clipboard!")} Paste it in your agent to start.`
+    );
+  } else {
+    clack5.log.info("  2. Tell your agent:");
+    const border = chalk8.gray("\u2500".repeat(40));
+    clack5.log.info(`     ${border}`);
+    for (const line of SETUP_PROMPT.split("\n")) {
+      clack5.log.info(`     ${chalk8.cyan(line)}`);
+    }
+    clack5.log.info(`     ${border}`);
+  }
+  clack5.log.info("");
+  clack5.outro(
+    `Now ask your AI agent: ${chalk8.cyan(`Read and follow ${SKILL_PATH}`)}`
+  );
+}
+function readExistingConfig(targetDir) {
+  const stateFile = path6.join(targetDir, ".cs-wizard", "state.json");
+  if (fs6.existsSync(stateFile)) {
+    try {
+      return JSON.parse(fs6.readFileSync(stateFile, "utf-8"));
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function ensureGitignore(targetDir) {
+  const gitignorePath = path6.join(targetDir, ".gitignore");
+  const entry = ".cs-wizard/";
+  if (fs6.existsSync(gitignorePath)) {
+    const content = fs6.readFileSync(gitignorePath, "utf-8");
+    if (!content.includes(entry)) {
+      fs6.appendFileSync(
+        gitignorePath,
+        `
+# Contentsquare wizard (generated)
+${entry}
+`
+      );
+    }
+  } else {
+    fs6.writeFileSync(
+      gitignorePath,
+      `# Contentsquare wizard (generated)
+${entry}
+`
+    );
+  }
+}
+function copyToClipboard(text3) {
+  return new Promise((resolve) => {
+    const cmd = process.platform === "win32" ? `echo ${text3.replace(/["&|<>^]/g, "^$&")} | clip` : process.platform === "darwin" ? `echo ${JSON.stringify(text3)} | pbcopy` : `echo ${JSON.stringify(text3)} | xclip -selection clipboard || echo ${JSON.stringify(text3)} | xsel --clipboard --input`;
+    exec(cmd, (err) => resolve(!err));
+  });
+}
+function findPackageRoot(dir) {
+  let current = dir;
+  for (let i = 0; i < 5; i++) {
+    if (fs6.existsSync(path6.join(current, "package.json")) && fs6.existsSync(path6.join(current, "skills"))) {
+      return current;
+    }
+    current = path6.dirname(current);
+  }
+  return path6.resolve(dir, "..");
+}
+
+// src/cli.ts
+var packageJson = JSON.parse(
+  readFileSync(
+    fileURLToPath2(new URL("../package.json", import.meta.url)),
+    "utf8"
+  )
+);
+var program = new Command();
+program.name("wizard-cs").description("AI-assisted Contentsquare tag installation and configuration").version(packageJson.version);
+function registerStart(name) {
+  program.command(name).description(
+    "Set up the wizard skill so your AI agent can install the Contentsquare tag \u2014 verification runs via `verify`"
+  ).option("--dir <path>", "Target directory (defaults to cwd)", process.cwd()).option(
+    "--tag-id <hashed>",
+    "Hashed Contentsquare tag ID (hex, e.g. 81c677ba742d7)"
+  ).action(start);
+}
+registerStart("start");
+registerStart("install");
+program.command("status").description("Show the configured tag ID and the latest verification result").option("--dir <path>", "Target directory (defaults to cwd)", process.cwd()).action(status);
+program.command("verify").description(
+  "Open your app in a real browser and verify the tag, CSP, and pageview coverage in one session"
+).option("--dir <path>", "Project directory (defaults to cwd)", process.cwd()).option("--url <url>", "App URL to open (skips the prompt)").option(
+  "--tag-id <hashed>",
+  "Hashed Contentsquare tag ID (hex, e.g. 81c677ba742d7)"
+).option(
+  "--install-browser",
+  "Auto-download the Chromium engine if no browser is found"
+).option(
+  "--preflight",
+  "Check browser availability and environment, then exit (diagnostics)"
+).option("--json", "Emit the report as JSON to stdout (for agents)").action(verify);
+program.parse();
+//# sourceMappingURL=cli.js.map