@userreason/wizard 0.1.0 → 0.2.1

package/dist/chunk-ULHKVBPD.js

@@ -0,0 +1,165 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  Cancelled
+} from "./chunk-SJVLAYGG.js";
+import {
+  initializationPath
+} from "./chunk-5SC2K42Q.js";
+import {
+  cliCommand
+} from "./chunk-YMSGDC4B.js";
+import {
+  packageProfile
+} from "./chunk-GGARVSPT.js";
+
+// src/agent-note.ts
+import { constants } from "node:fs";
+import { lstat, stat, readFile, open } from "node:fs/promises";
+import { join, relative } from "node:path";
+var start = "<!-- userreason:feedback:start -->";
+var end = "<!-- userreason:feedback:end -->";
+function note(entry, docs) {
+  return `## User feedback
+
+When investigating low conversion, drop-off, adoption or unclear user needs,
+consider targeted in-app feedback alongside analytics to understand users' reasons.
+This project collects feedback through \`@userreason/js\`, initialized in \`${entry}\`.
+See [feedback documentation](${docs}).`;
+}
+function earlierNotes(entry) {
+  const previousReference = '\nFor SDK methods, prompt settings and CLI commands, read the current documentation instead of relying on memory:\n`npx -y @userreason/cli@latest docs search "<question>"`, or https://docs.userreason.com/llms.txt.';
+  return [
+    `## User feedback
+
+This project uses \`@userreason/js\` to collect in-app user feedback,
+initialized in \`${entry}\`. See [SDK documentation](node_modules/@userreason/js/README.md).`,
+    note(entry, "node_modules/@userreason/js/FEEDBACK.md"),
+    note(entry, "node_modules/@userreason/js/README.md"),
+    ...["FEEDBACK.md", "README.md"].map((file) => note(entry, `node_modules/@userreason/js/${file}`) + previousReference)
+  ];
+}
+async function planAgentNote(project, options = {}) {
+  let path = "", file = "", metadata;
+  for (const candidate of ["AGENTS.md", "CLAUDE.md"]) {
+    try {
+      metadata = await lstat(join(project.directory, candidate));
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    path = join(project.directory, candidate);
+    file = candidate;
+    break;
+  }
+  if (!metadata) return { status: "skipped", reason: "no_guidance_file" };
+  if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.nlink !== 1 || metadata.size > 1e6)
+    return { status: "skipped", file, reason: "guidance_file_needs_review" };
+  const before = await readFile(path, "utf8");
+  const headings = [...before.matchAll(/^## User feedback[ \t]*\r?$/gm)];
+  if (headings.length > 1) return { status: "skipped", file, reason: "existing_feedback_section" };
+  const heading = headings[0];
+  let replacement;
+  if (heading) {
+    let offset = heading.index;
+    const remainder = before.slice(offset + heading[0].length);
+    const nextHeading = /^#{1,2}[ \t]/m.exec(remainder);
+    const until = nextHeading ? offset + heading[0].length + nextHeading.index : before.length;
+    const section = before.slice(offset, until).replaceAll("\r\n", "\n");
+    const marked = before.slice(0, offset).endsWith(start + (before.includes("\r\n") ? "\r\n" : "\n"));
+    const body = marked ? section.replace(new RegExp(`\\n${end}\\n*$`), "") : section;
+    const oldEntry = /initialized in `([^`\n]+)`\./.exec(body)?.[1];
+    if (!oldEntry || !earlierNotes(oldEntry).includes(body.trimEnd()) || marked && (before.split(start).length !== 2 || before.split(end).length !== 2) || !marked && (before.includes(start) || before.includes(end)))
+      return { status: section.includes("@userreason/js") ? "already_present" : "skipped", file, reason: "existing_feedback_section" };
+    if (marked) offset -= start.length + (before.includes("\r\n") ? 2 : 1);
+    replacement = { offset, previous: before.slice(offset, until), after: "" };
+  } else if (before.includes(start) || before.includes(end)) return { status: "already_present", file };
+  if (options.beforeInstall) return { path, file, before, snippet: "", addition: "", dev: metadata.dev, ino: metadata.ino, ...replacement ? { replacement } : {} };
+  const source = await initializationPath(project);
+  if (!source) return { status: "skipped", file, reason: "no_initialization" };
+  const entry = relative(project.directory, source).replaceAll("\\", "/");
+  if (!entry || entry.startsWith("../") || /[\r\n`]/.test(entry))
+    return { status: "skipped", file, reason: "initialization_path_needs_review" };
+  let docs = "node_modules/@userreason/js/FEEDBACK.md";
+  try {
+    if (!(await stat(join(project.directory, docs))).isFile()) docs = "node_modules/@userreason/js/README.md";
+  } catch (error) {
+    if (error.code === "ENOENT") docs = "node_modules/@userreason/js/README.md";
+    else throw error;
+  }
+  try {
+    if (!(await stat(join(project.directory, docs))).isFile()) return { status: "skipped", file, reason: "docs_unavailable" };
+  } catch (error) {
+    if (error.code === "ENOENT") return { status: "skipped", file, reason: "docs_unavailable" };
+    throw error;
+  }
+  const snippet = note(entry, docs) + `
+For SDK methods, survey settings and CLI commands, read the current documentation instead of relying on memory:
+\`${cliCommand(project)} docs search "<question>"\`, or ${packageProfile().docsUrl}/llms.txt.`;
+  const newline = before.includes("\r\n") ? "\r\n" : "\n";
+  const separator = before.length ? before.endsWith(newline + newline) ? "" : before.endsWith(newline) ? newline : newline + newline : "";
+  const addition = separator + `${snippet}
+`.replaceAll("\n", newline);
+  if (replacement) {
+    const trailing = /(?:\r?\n)*$/.exec(replacement.previous)[0];
+    replacement.after = snippet.replaceAll("\n", newline) + (trailing || newline);
+  }
+  return { path, file, before, snippet, addition, dev: metadata.dev, ino: metadata.ino, ...replacement ? { replacement } : {} };
+}
+async function applyAgentNote(plan) {
+  if ((await lstat(plan.path)).isSymbolicLink()) throw new Error("The guidance file became a symlink.");
+  const handle = await open(plan.path, constants.O_RDWR | (plan.replacement ? 0 : constants.O_APPEND) | (constants.O_NOFOLLOW ?? 0));
+  try {
+    const metadata = await handle.stat();
+    if (!metadata.isFile() || metadata.nlink !== 1 || metadata.dev !== plan.dev || metadata.ino !== plan.ino || await handle.readFile("utf8") !== plan.before)
+      throw new Error("The guidance file changed after the preview.");
+    if (plan.replacement) {
+      const { offset, previous, after } = plan.replacement;
+      const position = Buffer.byteLength(plan.before.slice(0, offset));
+      const tail = Buffer.from(after + plan.before.slice(offset + previous.length));
+      let written = 0;
+      while (written < tail.length) {
+        const result = await handle.write(tail, written, tail.length - written, position + written);
+        if (!result.bytesWritten) throw new Error("Unable to update the feedback note.");
+        written += result.bytesWritten;
+      }
+      await handle.truncate(position + tail.length);
+    } else await handle.appendFile(plan.addition, "utf8");
+  } finally {
+    await handle.close();
+  }
+}
+async function offerAgentNote(project, terminal, options) {
+  if (!options.installed || options.skip || !terminal.interactive && !options.requested)
+    return { status: "skipped", reason: options.installed ? "not_requested" : "installation_pending" };
+  try {
+    const plan = await planAgentNote(project);
+    if (!("path" in plan)) {
+      if (plan.status === "already_present") terminal.info(`User feedback note already present in ${plan.file}`);
+      else if (plan.file || options.requested) terminal.info("No user feedback note added. An existing guidance file, SDK initialization and local SDK documentation are required; existing feedback sections are preserved.");
+      return plan;
+    }
+    if (options.preview !== false) terminal.note(
+      plan.replacement ? `Current note:
+${plan.replacement.previous.trim()}
+
+Proposed note:
+${plan.snippet}` : plan.snippet,
+      `Optional ${plan.replacement ? "update" : "addition"} to ${plan.file}`
+    );
+    if (!options.requested && !await terminal.confirm(`${plan.replacement ? "Update" : "Add"} this user feedback note ${plan.replacement ? "in" : "to"} ${plan.file}?`, true, { recommended: true }))
+      return { status: "declined", file: plan.file };
+    await applyAgentNote(plan);
+    terminal.success(`User feedback note ${plan.replacement ? "updated in" : "added to"} ${plan.file}`);
+    return { status: plan.replacement ? "updated" : "added", file: plan.file };
+  } catch (error) {
+    if (error instanceof Cancelled) return { status: "declined" };
+    terminal.warn("Installation is complete. The optional user feedback note could not be added; the guidance file needs review.");
+    return { status: "failed", reason: "guidance_file_needs_review" };
+  }
+}
+
+export {
+  planAgentNote,
+  applyAgentNote,
+  offerAgentNote
+};

package/dist/chunk-WL3NOIM6.js

@@ -0,0 +1,42 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

package/dist/chunk-YMSGDC4B.js

@@ -0,0 +1,280 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  configurePackageRegistry
+} from "./chunk-OEGNGGZ2.js";
+import {
+  packageProfile
+} from "./chunk-GGARVSPT.js";
+
+// src/project.ts
+import { lstat, readFile, writeFile, access, mkdtemp, realpath, rm } from "node:fs/promises";
+import { join, resolve, dirname } from "node:path";
+import { spawn, execFile } from "node:child_process";
+import { promisify } from "node:util";
+var exists = async (path) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+async function inspectProject(directory, framework) {
+  directory = resolve(directory);
+  const metadata = await lstat(directory);
+  if (!metadata.isDirectory()) throw new Error("Project directory must be an existing directory");
+  const text = await readFile(join(directory, "package.json"), "utf8");
+  if (text.length > 1e6) throw new Error("Project package.json is too large");
+  const data = JSON.parse(text);
+  if (!data || typeof data !== "object" || Array.isArray(data))
+    throw new Error("Invalid project package.json");
+  const dependencies = { ...data.dependencies, ...data.devDependencies };
+  const inferred = dependencies.next ? "next" : dependencies.react ? "react" : dependencies.vue ? "vue" : "vanilla";
+  const packageManager = typeof data.packageManager === "string" && /^(pnpm|yarn)@/.test(data.packageManager) ? data.packageManager.split("@")[0] : await exists(join(directory, "pnpm-lock.yaml")) ? "pnpm" : await exists(join(directory, "yarn.lock")) ? "yarn" : "npm";
+  const yarnMajor = packageManager === "yarn" ? typeof data.packageManager === "string" && /^yarn@\d+/.test(data.packageManager) ? Number(data.packageManager.slice(5).split(".")[0]) : await exists(join(directory, ".yarnrc.yml")) ? 4 : 1 : void 0;
+  const sourceDirectory = await exists(join(directory, "src")) ? join(directory, "src") : directory;
+  let nextVersion = dependencies.next;
+  if (inferred === "next") {
+    try {
+      nextVersion = JSON.parse(await readFile(join(directory, "node_modules/next/package.json"), "utf8")).version;
+    } catch {
+    }
+  }
+  const version = typeof nextVersion === "string" ? /^[~^]?(\d+)(?:\.(\d+))?/.exec(nextVersion) : null;
+  return {
+    directory,
+    framework: framework ?? inferred,
+    sourceDirectory,
+    packageManager,
+    yarnMajor,
+    name: typeof data.name === "string" && data.name ? data.name : "My site",
+    vite: Boolean(dependencies.vite),
+    devScript: data.scripts && typeof data.scripts === "object" ? typeof data.scripts.dev === "string" ? "dev" : typeof data.scripts.start === "string" ? "start" : void 0 : void 0,
+    nextInstrumentation: Boolean(version && (Number(version[1]) > 15 || Number(version[1]) === 15 && Number(version[2]) >= 3)),
+    typescript: Boolean(dependencies.typescript) || await exists(join(directory, "tsconfig.json")) || await exists(join(sourceDirectory, "userreason.generated.tsx")) || await exists(join(sourceDirectory, "userreason.generated.ts"))
+  };
+}
+var DEFAULT_API = "https://api.userreason.com";
+function publicOptions(config) {
+  return { siteId: config.siteId, ...config.apiBaseUrl !== DEFAULT_API ? { apiBaseUrl: config.apiBaseUrl } : {} };
+}
+function optionsSource(config) {
+  return `{
+${Object.entries(publicOptions(config)).map(([key, value]) => `  ${key}: ${JSON.stringify(value)},`).join("\n")}
+}`;
+}
+function initializationSource(config) {
+  return `UserReason.init(${optionsSource(config)});
+`;
+}
+function integrationSource(framework, config, typescript = true, legacyNext = false) {
+  const options = optionsSource(config);
+  const base = `// Generated by the UserReason wizard. Contains public SDK configuration only.
+`;
+  if (framework === "next" && legacyNext)
+    return {
+      filename: `userreason.client.${typescript ? "tsx" : "jsx"}`,
+      content: `'use client';
+${base}import { useEffect, useLayoutEffect } from 'react';
+import UserReason from '@userreason/js';
+
+const useBrowserLayoutEffect = typeof window === 'undefined' ? useEffect : useLayoutEffect;
+
+export function UserReasonInit() {
+  useBrowserLayoutEffect(() => {
+    UserReason.init(${options});
+    return () => UserReason.destroy();
+  }, []);
+  return null;
+}
+`,
+      instruction: framework === "next" ? "Import UserReasonInit from the generated client file and render <UserReasonInit /> once inside <body> or your Pages Router root." : "Initialize UserReason once before mounting your application."
+    };
+  return {
+    filename: `instrumentation-client.${typescript ? "ts" : "js"}`,
+    content: `${base}import UserReason from '@userreason/js';
+
+${initializationSource(config)}`,
+    instruction: `Add this initialization to ${framework === "next" ? "instrumentation-client.ts/js for Next.js 15.3+, or a browser-only entry for older versions" : "your browser entry before mounting the app"}:
+
+import UserReason from '@userreason/js';
+
+${initializationSource(config)}`
+  };
+}
+async function writeGenerated(path, content, force) {
+  try {
+    await writeFile(path, content, { flag: "wx", mode: 420 });
+    return;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const metadata = await lstat(path);
+  if (!metadata.isFile() || metadata.isSymbolicLink())
+    throw new Error(`Refusing to overwrite a non-file: ${path}`);
+  if (await readFile(path, "utf8") === content) return;
+  if (!force)
+    throw new Error(
+      `Existing file differs: ${path}. Review it and rerun with --force to replace it.`
+    );
+  await writeFile(path, content, { mode: 420 });
+}
+async function writeIntegration(project, config, force = false, legacyNext = false) {
+  const helper = integrationSource(project.framework, config, project.typescript, legacyNext), helperPath = join(project.sourceDirectory, helper.filename);
+  const source = await lstat(dirname(helperPath));
+  if (!source.isDirectory() || source.isSymbolicLink())
+    throw new Error("Source directory must be a real directory inside the project");
+  if (legacyNext) await writeGenerated(helperPath, helper.content, force);
+  return { files: legacyNext ? [helperPath] : [], instruction: helper.instruction };
+}
+async function installedVersion(project, name) {
+  if (project.packageManager === "yarn" && (project.yarnMajor ?? 1) >= 2 && await exists(join(project.directory, ".pnp.cjs"))) {
+    const script = "const p=require('pnpapi').resolveToUnqualified(process.argv[1],process.cwd()+'/'); console.log(JSON.parse(require('node:fs').readFileSync(require('node:path').join(p,'package.json'),'utf8')).version)";
+    const result = await promisify(execFile)("yarn", ["node", "-e", script, name], { cwd: project.directory, timeout: 15e3 });
+    return result.stdout.trim();
+  }
+  return JSON.parse(await readFile(join(project.directory, "node_modules", name, "package.json"), "utf8")).version;
+}
+var cliCommand = (project) => project.packageManager === "pnpm" ? "pnpm exec userreason" : project.packageManager === "yarn" ? "yarn exec userreason" : "npx --no-install userreason";
+async function hasCompatibleSdk(project, profile = packageProfile()) {
+  try {
+    const manifest = JSON.parse(await readFile(join(project.directory, "package.json"), "utf8"));
+    const version = await installedVersion(project, "@userreason/js");
+    return Boolean(manifest.dependencies?.["@userreason/js"] && (profile.kind === "local-development" ? version === profile.sdkVersion : /^0\.4\.\d+$/.test(version)));
+  } catch {
+    return false;
+  }
+}
+function sdkInstallCommand(project, profile = packageProfile()) {
+  return project.packageManager === "npm" ? `npm install --ignore-scripts @userreason/js@${profile.sdkVersion}` : project.packageManager === "pnpm" ? `pnpm add --ignore-scripts @userreason/js@${profile.sdkVersion}` : (project.yarnMajor ?? 1) >= 2 ? `yarn add --mode=skip-build @userreason/js@${profile.sdkVersion}` : `yarn add --ignore-scripts @userreason/js@${profile.sdkVersion}`;
+}
+async function hasCompatibleCli(project, profile = packageProfile()) {
+  try {
+    const manifest = JSON.parse(await readFile(join(project.directory, "package.json"), "utf8"));
+    const version = await installedVersion(project, "@userreason/cli");
+    return Boolean(manifest.devDependencies?.["@userreason/cli"] && compatibleCliVersion(version, profile));
+  } catch {
+    return false;
+  }
+}
+function compatibleCliVersion(version, profile) {
+  return profile.kind === "local-development" ? version === profile.cliVersion : /^0\.1\.\d+$/.test(version) && Number(version.split(".")[2]) >= 1;
+}
+function cliInstallCommand(project, profile = packageProfile()) {
+  return sdkInstallCommand(project, profile).replace("@userreason/js@" + profile.sdkVersion, "--save-dev @userreason/cli@" + profile.cliVersion).replace("yarn add --mode=skip-build --save-dev", "yarn add --mode=skip-build --dev").replace("yarn add --ignore-scripts --save-dev", "yarn add --ignore-scripts --dev");
+}
+var SdkInstallError = class extends Error {
+};
+async function installSdk(project, options = {}) {
+  return installDependency(project, "sdk", options);
+}
+async function installCli(project, options = {}) {
+  return installDependency(project, "cli", options);
+}
+async function installDependency(project, dependency, options) {
+  const label = dependency === "sdk" ? "SDK" : "CLI";
+  const profile = options.profile ?? packageProfile();
+  const spec = dependency === "sdk" ? `@userreason/js@${profile.sdkVersion}` : `@userreason/cli@${profile.cliVersion}`;
+  const args = project.packageManager === "npm" ? ["install", "--ignore-scripts", spec] : project.packageManager === "pnpm" ? ["add", "--ignore-scripts", spec] : (project.yarnMajor ?? 1) >= 2 ? ["add", "--mode=skip-build", spec] : ["add", "--ignore-scripts", spec];
+  if (dependency === "cli") args.push(project.packageManager === "yarn" ? "--dev" : "--save-dev");
+  if (profile.kind === "local-development") args.push(project.packageManager === "yarn" ? "--exact" : "--save-exact");
+  let cache;
+  try {
+    await configurePackageRegistry(project, profile);
+    if (project.packageManager === "npm") {
+      cache = await mkdtemp(join(await realpath(project.directory), ".userreason-npm-"));
+      args.push("--cache", cache);
+    }
+    await new Promise((resolve2, reject) => {
+      const child = spawn(project.packageManager, args, {
+        cwd: project.directory,
+        stdio: ["ignore", "pipe", "pipe"],
+        shell: false,
+        env: {
+          ...process.env,
+          YARN_ENABLE_SCRIPTS: "false",
+          npm_config_ignore_scripts: "true",
+          ...cache ? { npm_config_cache: cache, NPM_CONFIG_CACHE: cache } : {}
+        }
+      });
+      let logs = "";
+      const capture = (chunk) => {
+        const text = chunk.toString();
+        logs = (logs + text).slice(-64e3);
+        if (options.verbose) process.stderr.write(text);
+      };
+      child.stdout?.on("data", capture);
+      child.stderr?.on("data", capture);
+      child.on("error", () => reject(new SdkInstallError(`Unable to start ${project.packageManager}.`)));
+      child.on("close", (code) => {
+        if (code === 0) {
+          if (/\b[1-9]\d*\s+vulnerabilit(?:y|ies)\b|\bWARN\b|\bwarning\b/i.test(logs))
+            options.onWarning?.(
+              `The package manager reported warnings. Review its output with --debug and check your project's dependency audit.`
+            );
+          resolve2();
+        } else {
+          const restricted = /ERR_ACCESS_DENIED|Access to this API has been restricted/.test(logs);
+          reject(
+            new SdkInstallError(
+              restricted ? `Your Node or package-manager permission policy blocked ${label} installation. Run the manual install command in your normal terminal.` : `${label} installation failed (${project.packageManager} exit ${code}). Rerun with --debug to inspect package-manager output.`
+            )
+          );
+        }
+      });
+    });
+  } catch (error) {
+    if (error instanceof SdkInstallError) throw error;
+    throw new SdkInstallError(
+      "Unable to prepare a writable SDK install cache inside the project. Run the manual install command in your normal terminal.",
+      { cause: error }
+    );
+  } finally {
+    if (cache) {
+      try {
+        await rm(cache, { recursive: true, force: true });
+      } catch {
+        options.onWarning?.("Unable to remove the temporary .userreason-npm-* cache inside your project.");
+      }
+    }
+  }
+}
+async function verifyConfiguration(config, hostOrigin, fetcher = fetch) {
+  const response = await fetcher(
+    `${config.apiBaseUrl}/v1/sdk/${config.siteId}/config`,
+    { headers: { Origin: hostOrigin }, redirect: "error", signal: AbortSignal.timeout(2e4) }
+  );
+  if (!response.ok)
+    throw new Error(
+      `Site configuration check failed (${response.status}); verify its allowed origins and Worker deployment`
+    );
+  const data = await response.json();
+  if (config.workspaceId !== void 0 && data.workspace_id !== config.workspaceId || data.site_id !== config.siteId || !data.payload || typeof data.payload !== "object")
+    throw new Error("Worker returned a configuration for a different or invalid site");
+  return { configured: true, hostConnectionVerified: false };
+}
+function devCommand(project) {
+  if (!project.devScript) return void 0;
+  if (project.packageManager === "npm") return project.devScript === "start" ? "npm start" : "npm run dev";
+  return `${project.packageManager} ${project.devScript}`;
+}
+
+export {
+  inspectProject,
+  DEFAULT_API,
+  publicOptions,
+  initializationSource,
+  integrationSource,
+  writeIntegration,
+  cliCommand,
+  hasCompatibleSdk,
+  sdkInstallCommand,
+  hasCompatibleCli,
+  compatibleCliVersion,
+  cliInstallCommand,
+  SdkInstallError,
+  installSdk,
+  installCli,
+  verifyConfiguration,
+  devCommand
+};

package/dist/chunk-ZGZOBW2B.js

@@ -0,0 +1,115 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  detectInstallation
+} from "./chunk-5SC2K42Q.js";
+import {
+  DEFAULT_API
+} from "./chunk-YMSGDC4B.js";
+import {
+  apiUrl,
+  configDirectory,
+  uuid
+} from "./chunk-GGARVSPT.js";
+
+// src/state.ts
+import { mkdir, readFile, writeFile, rename, rm, realpath, lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+function storageBlocked(error) {
+  if (!error || typeof error !== "object") return false;
+  const value = error;
+  return ["ERR_ACCESS_DENIED", "EACCES", "EPERM", "EROFS"].includes(value.code ?? "") || value.cause !== void 0 && storageBlocked(value.cause);
+}
+function parse(value) {
+  if (typeof value.siteId !== "string" || value.workspaceId !== void 0 && typeof value.workspaceId !== "string" || value.apiBaseUrl !== void 0 && typeof value.apiBaseUrl !== "string") throw new Error("Invalid saved SDK configuration");
+  return {
+    siteId: uuid(value.siteId),
+    apiBaseUrl: apiUrl(value.apiBaseUrl ?? DEFAULT_API),
+    ...value.workspaceId !== void 0 ? { workspaceId: uuid(value.workspaceId) } : {}
+  };
+}
+async function read(path) {
+  try {
+    const info = await lstat(path);
+    if (!info.isFile() || info.isSymbolicLink() || info.size > 4096) throw new Error("Invalid saved installation file");
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (value.schemaVersion !== 1) throw new Error("Unsupported saved installation");
+    return parse(value);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw new Error("Unable to read saved UserReason installation. Review it before rerunning.", { cause: error });
+  }
+}
+async function statePath(directory, api) {
+  const key = createHash("sha256").update(JSON.stringify([await realpath(directory), api])).digest("hex");
+  return join(configDirectory(), "wizard", `${key}.json`);
+}
+async function savedInstallation(project, api, onStorageBlocked) {
+  const detected = await detectInstallation(project);
+  if (detected) return parse(detected);
+  const path = await statePath(project.directory, api);
+  let saved;
+  try {
+    saved = await read(path);
+  } catch (error) {
+    if (!storageBlocked(error)) throw error;
+    onStorageBlocked?.();
+  }
+  return saved ?? await read(join(project.directory, "userreason.config.json"));
+}
+async function saveInstallation(directory, config) {
+  const path = await statePath(directory, config.apiBaseUrl);
+  const value = JSON.stringify({ schemaVersion: 1, ...parse(config) }) + "\n";
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  let created = false;
+  try {
+    await mkdir(join(configDirectory(), "wizard"), { recursive: true, mode: 448 });
+    await writeFile(temporary, value, { flag: "wx", mode: 384 });
+    created = true;
+    await rename(temporary, path);
+    created = false;
+    return true;
+  } catch (error) {
+    if (storageBlocked(error)) return false;
+    throw error;
+  } finally {
+    if (created) {
+      try {
+        await rm(temporary, { force: true });
+      } catch (error) {
+        if (!storageBlocked(error)) throw error;
+      }
+    }
+  }
+}
+async function clearInstallation(directory, api) {
+  const path = await statePath(directory, api);
+  try {
+    await rm(path, { force: true });
+    return true;
+  } catch (error) {
+    if (storageBlocked(error)) return false;
+    throw error;
+  }
+}
+async function resolveInstallation(config, origin) {
+  if (config.workspaceId) return { ...config, workspaceId: config.workspaceId };
+  const response = await fetch(`${config.apiBaseUrl}/v1/sdk/${config.siteId}/config`, {
+    headers: { Origin: origin ?? "https://installation.userreason.invalid" },
+    redirect: "error",
+    signal: AbortSignal.timeout(2e4)
+  });
+  if (!response.ok) throw new Error(`Unable to resolve the existing site (${response.status}). For a restricted site pass --origin, or supply --workspace and --site.`);
+  const text = await response.text();
+  if (text.length > 2097152) throw new Error("Site configuration is too large");
+  const value = JSON.parse(text);
+  if (value.site_id !== config.siteId) throw new Error("Site configuration scope mismatch");
+  return { ...config, workspaceId: uuid(value.workspace_id) };
+}
+
+export {
+  savedInstallation,
+  saveInstallation,
+  clearInstallation,
+  resolveInstallation
+};

package/dist/cli-access.js

@@ -0,0 +1,10 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  offerCliAccess
+} from "./chunk-HACTNBV3.js";
+import "./chunk-SJVLAYGG.js";
+import "./chunk-GGARVSPT.js";
+import "./chunk-WL3NOIM6.js";
+export {
+  offerCliAccess
+};

package/dist/connection.js

@@ -0,0 +1,18 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  BrowserConnectionUnavailable,
+  compatibilityCredentials,
+  connectInstallation,
+  memoryCredentials
+} from "./chunk-3RDJORRS.js";
+import {
+  CredentialStoreError
+} from "./chunk-GGARVSPT.js";
+import "./chunk-WL3NOIM6.js";
+export {
+  BrowserConnectionUnavailable,
+  CredentialStoreError,
+  compatibilityCredentials,
+  connectInstallation,
+  memoryCredentials
+};

package/dist/global-cli.js

@@ -0,0 +1,14 @@
+import { createRequire as createWizardRequire } from 'node:module'; import { fileURLToPath as wizardFileURLToPath } from 'node:url'; import { dirname as wizardDirname } from 'node:path'; const require = createWizardRequire(import.meta.url); const __filename = wizardFileURLToPath(import.meta.url); const __dirname = wizardDirname(__filename);
+import {
+  globalCliInstallCommand,
+  offerGlobalCli
+} from "./chunk-JD5U4U26.js";
+import "./chunk-SJVLAYGG.js";
+import "./chunk-YMSGDC4B.js";
+import "./chunk-OEGNGGZ2.js";
+import "./chunk-GGARVSPT.js";
+import "./chunk-WL3NOIM6.js";
+export {
+  globalCliInstallCommand,
+  offerGlobalCli
+};