@userreason/wizard 0.0.0-stage → 0.2.0

package/dist/bin.js

@@ -0,0 +1,764 @@
+#!/usr/bin/env node
+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 {
+  offerAgentNote,
+  planAgentNote
+} from "./chunk-KV6GSBTQ.js";
+import {
+  offerAgentSkill,
+  planAgentSkill
+} from "./chunk-5Z5J6PY5.js";
+import {
+  offerCliAccess
+} from "./chunk-HACTNBV3.js";
+import {
+  offerGlobalCli
+} from "./chunk-JD5U4U26.js";
+import {
+  ensureCurrentWizard,
+  wizardVersion
+} from "./chunk-6CJ4ANMN.js";
+import {
+  Cancelled,
+  Terminal,
+  approvalStatus,
+  clean,
+  normalizeOrigin,
+  openBrowser
+} from "./chunk-SJVLAYGG.js";
+import {
+  BrowserConnectionUnavailable,
+  compatibilityCredentials,
+  connectInstallation,
+  memoryCredentials
+} from "./chunk-3RDJORRS.js";
+import {
+  clearInstallation,
+  resolveInstallation,
+  saveInstallation,
+  savedInstallation
+} from "./chunk-FC7PZNYW.js";
+import {
+  applyIntegration,
+  detectInstallation,
+  integrationAdditions,
+  integrationPreview,
+  planIntegration
+} from "./chunk-6DCCEVPD.js";
+import {
+  SdkInstallError,
+  cliCommand,
+  cliInstallCommand,
+  devCommand,
+  hasCompatibleCli,
+  hasCompatibleSdk,
+  inspectProject,
+  installCli,
+  installSdk,
+  sdkInstallCommand,
+  verifyConfiguration,
+  writeIntegration
+} from "./chunk-YMSGDC4B.js";
+import "./chunk-OEGNGGZ2.js";
+import {
+  ApiError,
+  AuthenticationError,
+  UserReasonClient,
+  apiUrl,
+  credentialStoreKind,
+  detectAgentHarness,
+  login,
+  packageProfile,
+  resolveConfig,
+  resolveCredentials,
+  saveConfig,
+  uuid
+} from "./chunk-GGARVSPT.js";
+import "./chunk-WL3NOIM6.js";
+
+// src/bin.ts
+import { parseArgs } from "node:util";
+import { randomUUID } from "node:crypto";
+var help = `UserReason installation wizard
+
+userreason-wizard [--directory PATH] [--origin URL]
+
+--workspace UUID / --workspace-name NAME
+--site UUID / --site-name NAME
+--environment development|production (customer site environment)
+--api-environment development|production (UserReason API/login; default ${packageProfile().apiEnvironment})
+--framework react|next|vue|vanilla
+--skip-install (advanced: prepare without installing SDK/CLI packages)
+--install (force an SDK/CLI reinstall)
+--refresh (update SDK/CLI packages without browser onboarding)
+--integrate / --skip-integrate
+--global-cli / --skip-global-cli (optional global CLI install; also supported with --refresh)
+--cli-access / --skip-cli-access (optional ongoing CLI authorization)
+--agent-note / --skip-agent-note (optional note in existing AGENTS.md or CLAUDE.md)
+--agent-skill / --skip-agent-skill (optional feedback skill in .agents/skills/userreason)
+--yes (accept installation/root edits; global CLI, access and agent guidance need explicit flags; browser approval remains required)
+--dry-run (print the plan, as JSON with --json; nothing is signed in, written or installed)
+--diff (show the full patch for the application edit and the proposed guidance text)
+--interactive (ask questions even when an agent harness or CI is detected)
+--no-color (also NO_COLOR)
+--no-open (print the browser link without opening it)
+--session-only (keep compatibility login only in memory; do not persist credentials)
+--force (replace differing generated files)
+--debug (show package-manager logs), --json (structured result only on stdout)
+--dev (compatibility alias for --api-environment development)
+--credential-store file|keychain (default file; UR_CREDENTIAL_STORE also supported)
+--client-id CLIENT_ID, --api-url ORIGIN
+
+The SDK and project-local CLI install automatically, unless compatible versions are already installed.
+Domains are unrestricted by default; --origin optionally adds an exact restriction.
+Bare hostnames are accepted; explicit HTTP localhost restrictions require --environment development.
+Reruns detect SDK initialization and resume unfinished installations from local wizard state. Legacy userreason.config.json is still readable.
+Prompts are off when stdin or stdout is not a terminal, with --yes or --json, in CI, and in agent harnesses (--interactive overrides the last two).
+`;
+var nameError = (value) => !value.trim() || value.trim().length > 240 ? "Enter a name between 1 and 240 characters." : void 0;
+var currentStep = "Reading wizard options";
+var activeTerminal;
+var frameworkLabel = (framework) => framework === "next" ? "Next.js" : framework;
+var lowerFirst = (value) => value.charAt(0).toLowerCase() + value.slice(1);
+async function main() {
+  const { values } = parseArgs({
+    allowPositionals: false,
+    options: {
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" },
+      dev: { type: "boolean" },
+      "api-environment": { type: "string" },
+      yes: { type: "boolean" },
+      install: { type: "boolean" },
+      refresh: { type: "boolean" },
+      "skip-install": { type: "boolean" },
+      integrate: { type: "boolean" },
+      "skip-integrate": { type: "boolean" },
+      "agent-note": { type: "boolean" },
+      "skip-agent-note": { type: "boolean" },
+      "agent-skill": { type: "boolean" },
+      "skip-agent-skill": { type: "boolean" },
+      "global-cli": { type: "boolean" },
+      "skip-global-cli": { type: "boolean" },
+      "cli-access": { type: "boolean" },
+      "skip-cli-access": { type: "boolean" },
+      "dry-run": { type: "boolean" },
+      diff: { type: "boolean" },
+      interactive: { type: "boolean" },
+      "no-color": { type: "boolean" },
+      "no-open": { type: "boolean" },
+      "session-only": { type: "boolean" },
+      force: { type: "boolean" },
+      debug: { type: "boolean" },
+      json: { type: "boolean" },
+      directory: { type: "string" },
+      origin: { type: "string" },
+      workspace: { type: "string" },
+      "workspace-name": { type: "string" },
+      site: { type: "string" },
+      "site-name": { type: "string" },
+      environment: { type: "string" },
+      framework: { type: "string" },
+      "credential-store": { type: "string" },
+      "client-id": { type: "string" },
+      "api-url": { type: "string" }
+    }
+  });
+  const version = await wizardVersion();
+  if (values.version) {
+    process.stdout.write(version + "\n");
+    return;
+  }
+  if (values.help) {
+    process.stdout.write(help);
+    return;
+  }
+  if (values["credential-store"] !== void 0) credentialStoreKind(values["credential-store"]);
+  if (values["api-environment"] !== void 0 && !["production", "development"].includes(values["api-environment"]))
+    throw new Error("API environment must be development or production");
+  if (values.dev && values["api-environment"] === "production")
+    throw new Error("Conflicting API environments: --dev selects development. Remove --dev or use --api-environment development.");
+  const embeddedProfile = packageProfile();
+  const apiEnvironment = values["api-environment"] ?? (values.dev ? "development" : embeddedProfile.apiEnvironment);
+  const developmentApi = apiEnvironment === "development";
+  const newSiteEnvironment = values.environment ?? apiEnvironment;
+  if (values["global-cli"] && values["skip-global-cli"]) throw new Error("Choose --global-cli or --skip-global-cli");
+  if (values["global-cli"] && values["skip-install"]) throw new Error("--global-cli requires project package installation; omit --skip-install");
+  if (values["cli-access"] && values["skip-cli-access"]) throw new Error("Choose --cli-access or --skip-cli-access");
+  if (values["cli-access"] && values["session-only"]) throw new Error("Ongoing CLI access requires persistent credentials; omit --session-only");
+  if (values.install && values["skip-install"]) throw new Error("Choose either --install or --skip-install");
+  if (values["dry-run"] && values.refresh) throw new Error("Choose either --dry-run or --refresh");
+  if (values.refresh && (values["skip-install"] || values.workspace || values.site || values["workspace-name"] || values["site-name"]))
+    throw new Error("--refresh updates packages in an existing integration; omit setup/resource flags and --skip-install");
+  if (values.integrate && values["skip-integrate"])
+    throw new Error("Choose either --integrate or --skip-integrate");
+  if (values["agent-note"] && values["skip-agent-note"])
+    throw new Error("Choose either --agent-note or --skip-agent-note");
+  if (values["agent-skill"] && values["skip-agent-skill"])
+    throw new Error("Choose either --agent-skill or --skip-agent-skill");
+  if (values.workspace && values["workspace-name"])
+    throw new Error("Choose an existing workspace or a new workspace name");
+  if (values.site && values["site-name"]) throw new Error("Choose an existing site or a new site name");
+  if (values.framework && !["react", "next", "vue", "vanilla"].includes(values.framework))
+    throw new Error("Unsupported framework");
+  if (values.environment && !["production", "development"].includes(values.environment))
+    throw new Error("Site environment must be development or production");
+  if (values.origin !== void 0)
+    normalizeOrigin(values.origin, values.environment === "production" ? "production" : "development");
+  for (const value of [values["workspace-name"], values["site-name"]])
+    if (value !== void 0 && nameError(value)) throw new Error(nameError(value));
+  currentStep = "Checking the current wizard build";
+  const startup = await ensureCurrentWizard(embeddedProfile, version, { onRestart: (message) => process.stderr.write(message + "\n") });
+  if (startup.exitCode !== void 0) {
+    process.exitCode = startup.exitCode;
+    return;
+  }
+  const profile = startup.profile;
+  const harness = detectAgentHarness();
+  const tty = Boolean(process.stdin.isTTY && process.stdout.isTTY && process.env.TERM !== "dumb");
+  const explicitlyQuiet = Boolean(values.yes || values.json);
+  const interactive = tty && !explicitlyQuiet && (!harness || Boolean(values.interactive));
+  const terminal = new Terminal(interactive, Boolean(values.json), { color: !values["no-color"] });
+  activeTerminal = terminal;
+  const { c, S } = terminal.kit;
+  const dot = ` ${S.dot} `;
+  const environmentNote = developmentApi ? `development API${newSiteEnvironment !== apiEnvironment ? `, new sites are ${newSiteEnvironment}` : ""}` : newSiteEnvironment !== apiEnvironment ? `new sites are ${newSiteEnvironment}` : void 0;
+  terminal.header({
+    mode: values.refresh ? "refresh" : "setup",
+    version,
+    detail: [
+      ...profile.kind === "local-development" ? [`dev build ${profile.buildId.slice(0, 12)} (sdk ${profile.sdkVersion}, cli ${profile.cliVersion})`] : [],
+      ...environmentNote ? [environmentNote] : []
+    ]
+  });
+  if (!interactive) terminal.info(`API environment: ${apiEnvironment}${dot}Site environment for new sites: ${newSiteEnvironment}`);
+  if (tty && harness && !explicitlyQuiet && !values.interactive)
+    terminal.info(`Agent session detected (${harness})${dot}${c.muted("prompts are off, flags decide")}`);
+  currentStep = "Inspecting the project";
+  const project = await inspectProject(
+    values.directory ?? process.cwd(),
+    values.framework
+  );
+  terminal.info(`${clean(project.name)} ${c.muted(`(${frameworkLabel(project.framework)}, ${project.packageManager})`)}`);
+  if (values.refresh) {
+    currentStep = "Refreshing UserReason packages";
+    const existing = await detectInstallation(project);
+    if (!existing) throw new Error("No UserReason initialization found. Run the wizard without --refresh to set up this application.");
+    const expectedApi = developmentApi ? "https://api-dev.userreason.com" : "https://api.userreason.com";
+    if (existing.apiBaseUrl !== expectedApi && !values["api-url"])
+      throw new Error("The existing integration uses a different API. Select its --api-environment or pass its --api-url before refreshing.");
+    if (values["api-url"] && existing.apiBaseUrl !== apiUrl(values["api-url"])) throw new Error("The existing integration uses a different API URL.");
+    const options = { profile, verbose: values.debug, onWarning: (message) => terminal.warn(message) };
+    const updated = [];
+    const started = Date.now();
+    await terminal.task("Updating UserReason packages", async () => {
+      if (!await hasCompatibleSdk(project, profile) || values.install) {
+        await installSdk(project, options);
+        updated.push("@userreason/js");
+      }
+      if (!await hasCompatibleCli(project, profile) || values.install) {
+        await installCli(project, options);
+        updated.push("@userreason/cli");
+      }
+    }, () => updated.length ? `Updated ${updated.map((name) => c.code(name)).join(", ")} ${c.muted(`(${project.packageManager}, ${Math.max(1, Math.round((Date.now() - started) / 1e3))}s)`)}` : "UserReason packages are already current");
+    const globalCli2 = await offerGlobalCli(project, terminal, { installed: true, requested: values["global-cli"], skip: !values["global-cli"], force: values.install, verbose: values.debug, profile, preview: Boolean(values.diff) });
+    const agentNote2 = await offerAgentNote(project, terminal, { installed: true, requested: values["agent-note"], skip: !values["agent-note"], preview: Boolean(values.diff) });
+    const agentSkill2 = await offerAgentSkill(project, terminal, { installed: true, requested: values["agent-skill"], skip: !values["agent-skill"], preview: Boolean(values.diff) });
+    const cliAccess2 = values["cli-access"] ? await offerCliAccess(await resolveConfig({ development: developmentApi, apiUrl: existing.apiBaseUrl, clientId: values["client-id"], credentialStore: values["credential-store"] }), terminal, { installed: true, requested: true, noOpen: values["no-open"], development: developmentApi, preview: Boolean(values.diff) }) : { status: "skipped" };
+    const untouched = [!values["global-cli"] && ["global command", "--global-cli"], !values["agent-note"] && ["AGENTS.md note", "--agent-note"], !values["agent-skill"] && ["agent skill", "--agent-skill"], !values["cli-access"] && ["CLI access", "--cli-access"]].filter(Boolean);
+    terminal.block("Ready", [
+      c.muted("Reload or restart your app to load the updated SDK."),
+      ...untouched.length ? [c.muted(`Not touched (${untouched.map(([name]) => name).join(", ")})`), `${c.muted("Add")} ${c.code(untouched.map(([, flag]) => flag).join(" "))} ${c.muted("to include them")}`] : []
+    ], { kind: "done" });
+    if (values.json) process.stdout.write(JSON.stringify({
+      global_cli: globalCli2,
+      cli_access: cliAccess2,
+      refreshed: true,
+      sdk_installed: true,
+      cli_installed: true,
+      api_environment: apiEnvironment,
+      wizard_version: version,
+      sdk_required_version: profile.sdkVersion,
+      cli_required_version: profile.cliVersion,
+      build_id: profile.buildId,
+      agent_note: agentNote2,
+      agent_skill: agentSkill2
+    }) + "\n");
+    return;
+  }
+  currentStep = "Preparing the application integration";
+  const plan = values["skip-integrate"] ? void 0 : await planIntegration(project);
+  if (plan && plan.status !== "ready") terminal.info(plan.reason);
+  const sdkCurrent = await hasCompatibleSdk(project, profile), cliCurrent = await hasCompatibleCli(project, profile);
+  const packages = [!sdkCurrent || values.install ? "@userreason/js" : "", !cliCurrent || values.install ? "@userreason/cli" : ""].filter(Boolean);
+  if (values["dry-run"]) {
+    currentStep = "Planning without changes";
+    const additions2 = plan ? integrationAdditions(plan) : void 0;
+    const note = values["skip-agent-note"] ? void 0 : await planAgentNote(project, { beforeInstall: true }).catch(() => void 0);
+    const skill = values["skip-agent-skill"] ? void 0 : await planAgentSkill(project).catch(() => void 0);
+    const steps = [
+      { action: "approve", needs: "browser" },
+      ...packages.length ? [{ action: "install", packages }] : [],
+      ...additions2 ? [{ action: "edit", file: additions2.path, status: "ready", added_lines: additions2.added.length, flag: "--integrate", recommended: true }] : [],
+      ...note && "path" in note ? [{ action: "write", file: note.file, flag: "--agent-note", status: "ready", recommended: true }] : [],
+      ...skill && "files" in skill ? [{ action: "write", file: ".agents/skills/userreason", flag: "--agent-skill", status: "ready", recommended: true }] : [],
+      ...!values["skip-cli-access"] && !values["session-only"] ? [{ action: "authorize", flag: "--cli-access", needs: "browser", recommended: true }] : [],
+      ...!values["skip-global-cli"] && !values["skip-install"] ? [{ action: "install_global", flag: "--global-cli", recommended: false }] : []
+    ];
+    const launcher = profile.kind === "local-development" ? `npx -y --prefer-online --registry=${profile.registry} @userreason/wizard@latest` : "npx -y @userreason/wizard@latest";
+    const run = [launcher, "--yes", ...steps.filter((step) => "recommended" in step && step.recommended && "flag" in step && step.flag && step.action !== "authorize").map((step) => step.flag)].join(" ");
+    if (values.json) {
+      process.stdout.write(JSON.stringify({
+        dry_run: true,
+        project: { framework: project.framework, package_manager: project.packageManager, name: project.name },
+        steps,
+        site: "Pass --site UUID to use an existing site, or --site-name NAME to create one.",
+        run
+      }, null, 2) + "\n");
+    } else {
+      terminal.info(`Dry run${dot}${c.muted("nothing is signed in, written or installed")}`);
+      terminal.block("Plan", terminal.kit.cols(steps.map((step) => {
+        const what = "file" in step ? String(step.file) : "packages" in step && step.packages ? step.packages.join(" ") : "needs" in step ? String(step.needs) : "";
+        const flag = "flag" in step && step.flag ? `(${step.flag})` : "";
+        const label = "recommended" in step ? step.recommended ? "recommended" : "optional" : "";
+        return [c.code(step.action), [[what, flag].filter(Boolean).join(" "), label].filter(Boolean).join(dot)];
+      })), { kind: "next", each: true });
+      terminal.block("Run it", [c.code(run)], { kind: "next", each: true });
+    }
+    return;
+  }
+  currentStep = "Discovering authentication configuration";
+  const config = await resolveConfig({
+    development: developmentApi,
+    apiUrl: values["api-url"],
+    clientId: values["client-id"],
+    credentialStore: values["credential-store"]
+  });
+  let resumeStorageBlocked = false;
+  const warnResumeStorage = () => {
+    if (resumeStorageBlocked) return;
+    resumeStorageBlocked = true;
+    terminal.warn(`Resume details can't be saved
+  ${c.muted("If setup is interrupted, choose the same workspace and site on rerun.")}`);
+  };
+  currentStep = "Reading saved installation details";
+  const saved = !values["workspace-name"] && !values["site-name"] && !(values.workspace && values.site) ? await savedInstallation(project, config.apiUrl, warnResumeStorage) : void 0;
+  if (saved && saved.apiBaseUrl !== config.apiUrl && !values.force)
+    throw new Error(
+      "Saved installation belongs to a different API. Review the configuration and use --force to replace it."
+    );
+  let workspaceChoice = values.workspace ? uuid(values.workspace) : saved?.workspaceId;
+  const siteChoice = values.site ? uuid(values.site) : saved?.siteId;
+  const resumed = Boolean(saved && !values.workspace && !values.site);
+  if (siteChoice && !workspaceChoice) {
+    currentStep = "Resolving the existing site";
+    const origin = values.origin ? normalizeOrigin(values.origin, newSiteEnvironment === "development" ? "development" : "production") : void 0;
+    workspaceChoice = (await resolveInstallation({ siteId: siteChoice, apiBaseUrl: config.apiUrl }, origin)).workspaceId;
+  }
+  let credentials = resolveCredentials(config), client = new UserReasonClient(config, credentials), connection;
+  const open = async (url) => !values["no-open"] && await openBrowser(url);
+  const approvalWait = async (label, url, note) => {
+    const opened = await open(url);
+    if (opened && values.debug) terminal.info(url);
+    const text = opened ? label : "Open this link to approve";
+    return terminal.waiting(note ? `${text}${dot}${note}` : text, opened ? {} : { link: url });
+  };
+  const deviceSignIn = async () => {
+    let waiting2;
+    await login(config, credentials, async (device) => {
+      waiting2 = await approvalWait("Sign in in the browser", device.verificationUriComplete, `${c.muted("code")} ${c.code(device.userCode)}`);
+    });
+    waiting2?.stop("Signed in");
+  };
+  let waiting;
+  let unrestrictedOrigins = false;
+  currentStep = "Connecting browser sign-in and approval";
+  try {
+    connection = await connectInstallation(
+      config,
+      {
+        projectName: project.name.slice(0, 240),
+        workspaceId: workspaceChoice,
+        workspaceName: values["workspace-name"],
+        siteId: siteChoice
+      },
+      async (url, code) => {
+        const note = code ? `${c.muted("code")} ${c.code(code)}` : void 0;
+        const opened = await open(url);
+        if (opened && values.debug) terminal.info(url);
+        const label = opened ? "Approve in the browser" : "Open this link to approve";
+        waiting = terminal.waiting(note ? `${label}${dot}${note}` : label, opened ? {} : { link: url });
+        const progressNote = note ? `${dot}${note}` : "";
+        approvalProgress = (value) => waiting?.update(`${value.phase === "waiting" ? label : approvalStatus(value)}${progressNote}`);
+      },
+      {
+        onCapabilities: (value) => {
+          unrestrictedOrigins = value.unrestrictedOrigins;
+        },
+        onProgress: (value) => approvalProgress?.(value)
+      }
+    );
+    waiting?.stop();
+    credentials = memoryCredentials(connection.session);
+    client = new UserReasonClient(config, credentials, {
+      lock: (operation) => operation()
+    });
+  } catch (error) {
+    waiting?.stop();
+    if (!(error instanceof BrowserConnectionUnavailable)) throw error;
+    terminal.info(`This API uses the earlier sign-in flow${dot}${c.muted("installation approval opens after sign-in")}`);
+    const compatibility = await compatibilityCredentials(
+      credentials,
+      Boolean(values["session-only"]),
+      async (error2) => {
+        terminal.warn(error2.message);
+        if (!terminal.interactive)
+          throw new Error(
+            "The selected credential store is unavailable. Rerun with --session-only to keep login only in memory."
+          );
+        return terminal.confirm("Keep this session in memory only? No credentials will be saved.");
+      }
+    );
+    credentials = compatibility.credentials;
+    client = new UserReasonClient(
+      config,
+      credentials,
+      compatibility.sessionOnly ? { lock: (operation) => operation() } : {}
+    );
+    if (compatibility.sessionOnly) terminal.info("Login is kept only in memory for this run.");
+    if (!compatibility.session) {
+      await deviceSignIn();
+      if (!compatibility.sessionOnly) await saveConfig(config, developmentApi);
+    }
+  }
+  const approve = async (workspaceId, creation = true) => {
+    const request = await client.requestGrant({
+      workspaceId,
+      scopes: [
+        ...!workspaceId ? ["workspace:create"] : [],
+        "workspace:read",
+        "site:read",
+        ...creation ? ["site:create"] : []
+      ]
+    });
+    if (request.status === "approved") return request;
+    const pending = request.approval_url ? await approvalWait("Approve installation in the browser", request.approval_url) : terminal.waiting("Waiting for installation approval");
+    try {
+      const granted = await client.waitForGrant(request.id);
+      pending.stop("Installation approved");
+      return granted;
+    } catch (error) {
+      pending.stop();
+      throw error;
+    }
+  };
+  const authorized = async (operation, workspaceId) => {
+    try {
+      return await operation();
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 403 || !["authorization_required", "grant_required"].includes(error.code) || connection)
+        throw error;
+      await approve(workspaceId, !siteChoice);
+      return operation();
+    }
+  };
+  currentStep = "Loading the approved account";
+  let account;
+  try {
+    account = await client.account();
+  } catch (error) {
+    if (!(error instanceof AuthenticationError) || error.code !== "invalid_grant") throw error;
+    await deviceSignIn();
+    account = await client.account();
+  }
+  const who = connection ? clean(connection.session.email) : void 0;
+  let selectedWorkspace;
+  const approvedWorkspace = connection?.workspaceId ?? workspaceChoice;
+  if (approvedWorkspace) {
+    selectedWorkspace = account.workspaces.find((item) => item.id === approvedWorkspace);
+    if (!selectedWorkspace && !connection) {
+      await approve(approvedWorkspace, !siteChoice);
+      account = await client.account();
+      selectedWorkspace = account.workspaces.find((item) => item.id === approvedWorkspace);
+    }
+    if (!selectedWorkspace) throw new Error("The selected workspace is not available to this installation");
+    if (who) terminal.success(`Signed in as ${who} ${c.muted(`(workspace ${clean(selectedWorkspace.name)})`)}`);
+  } else {
+    if (who) terminal.success(`Signed in as ${who}`);
+    if (!connection?.workspaceName && !values["workspace-name"] && account.workspaces.length) {
+      const selected = await terminal.select(
+        "Workspace",
+        [
+          ...account.workspaces.map((item) => ({
+            value: item.id,
+            label: item.name
+          })),
+          { value: "new", label: "New workspace" }
+        ],
+        account.workspaces[0]?.id
+      );
+      selectedWorkspace = account.workspaces.find((item) => item.id === selected);
+    }
+  }
+  if (!who && selectedWorkspace) terminal.success(`Workspace: ${clean(selectedWorkspace.name)}`);
+  let selectedSite;
+  currentStep = "Selecting the workspace and site";
+  const siteDetail = (item) => `${item.environment}, ${item.allowed_origins.map(clean).join(", ") || "any domain"}`;
+  if (selectedWorkspace) {
+    const sites = await authorized(() => client.sites(selectedWorkspace.id), selectedWorkspace.id);
+    if (siteChoice) {
+      selectedSite = sites.find((item) => item.id === siteChoice);
+      if (!selectedSite) throw new Error("The selected site is not available in this workspace");
+      terminal.info(resumed ? `Resuming an interrupted setup${dot}${c.muted(`${clean(selectedWorkspace.name)} ${S.arrow} ${clean(selectedSite.name)}`)}` : `Site ${c.code(clean(selectedSite.name))} ${c.muted(`(${siteDetail(selectedSite)})`)}`);
+    } else if (!values["site-name"] && sites.length) {
+      const width = Math.max(...sites.map((item) => clean(item.name).length));
+      const selected = await terminal.select(
+        "Site",
+        [
+          ...sites.map((item) => ({
+            value: item.id,
+            label: `${clean(item.name).padEnd(width)}  ${c.muted(siteDetail(item))}`
+          })),
+          { value: "new", label: "New site" }
+        ],
+        sites[0]?.id
+      );
+      selectedSite = sites.find((item) => item.id === selected);
+    }
+  }
+  const environment = selectedSite?.environment ?? newSiteEnvironment;
+  if (environment !== "production" && environment !== "development")
+    throw new Error("Invalid site environment");
+  const validateOrigin = (value) => {
+    try {
+      const normalized = normalizeOrigin(value, environment);
+      if (selectedSite?.allowed_origins.length && !selectedSite.allowed_origins.includes(normalized))
+        return `This site allows ${selectedSite.allowed_origins.join(", ")}. Choose one or add your origin through the dashboard.`;
+    } catch (error) {
+      return error instanceof Error ? error.message : "Enter a valid app origin";
+    }
+  };
+  const rawOrigin = values.origin ?? selectedSite?.allowed_origins[0];
+  const invalidOrigin = rawOrigin ? validateOrigin(rawOrigin) : void 0;
+  if (invalidOrigin) throw new Error(invalidOrigin);
+  const hostOrigin = rawOrigin ? normalizeOrigin(rawOrigin, environment) : void 0;
+  if (!selectedSite && !hostOrigin && !unrestrictedOrigins)
+    throw new Error("This API has not enabled domain-free installation yet. Deploy the updated UserReason Worker, or use --origin to configure an explicit restriction. No workspace or site was created.");
+  const siteName = selectedSite?.name ?? values["site-name"] ?? await terminal.text("Site name", project.name.slice(0, 240), nameError);
+  const workspaceName = selectedWorkspace?.name ?? connection?.workspaceName ?? values["workspace-name"] ?? await terminal.text("New workspace name", void 0, nameError);
+  if (nameError(siteName) || nameError(workspaceName))
+    throw new Error("Workspace and site names must contain 1\u2013240 characters");
+  const workspaceIds = selectedWorkspace ? void 0 : { requestId: randomUUID(), workspaceId: randomUUID() };
+  const siteIds = selectedSite ? void 0 : { requestId: randomUUID(), siteId: randomUUID() };
+  const installation = {
+    workspaceId: selectedWorkspace?.id ?? workspaceIds.workspaceId,
+    siteId: selectedSite?.id ?? siteIds.siteId,
+    apiBaseUrl: config.apiUrl
+  };
+  currentStep = "Preparing the application integration";
+  const reviewed = values["skip-integrate"] ? void 0 : await planIntegration(project, installation);
+  const additions = reviewed ? integrationAdditions(reviewed) : void 0;
+  const legacyNext = project.framework === "next" && !project.nextInstrumentation && plan?.status !== "integrated";
+  const noteProbe = values["skip-agent-note"] ? void 0 : await planAgentNote(project, { beforeInstall: true }).catch(() => void 0);
+  const skillProbe = values["skip-agent-skill"] ? void 0 : await planAgentSkill(project).catch(() => void 0);
+  const inPlace = [
+    noteProbe && !("path" in noteProbe) && noteProbe.status === "already_present" ? `${noteProbe.file ?? "AGENTS.md"} note` : "",
+    skillProbe && !("files" in skillProbe) && skillProbe.status === "already_present" ? "Agent skill" : ""
+  ].filter(Boolean);
+  if (inPlace.length) terminal.info(`Already in place${dot}${c.muted(inPlace.join(", "))}`);
+  const installRow = packages.length ? `${c.muted("install")}  ${c.code(packages.join("  "))}` : c.muted(`nothing to install${dot}@userreason/js and @userreason/cli are current`);
+  if (reviewed?.status === "ready" && additions) {
+    if (values.diff) terminal.note(integrationPreview(reviewed), `Diff${dot}${additions.path}`);
+    else terminal.block("Changes", [
+      additions.created ? `${c.code(additions.path)} ${c.muted("(new file)")}` : `${c.code(additions.path)}${c.muted(`:${additions.line}`)}`,
+      ...additions.added.map((line) => `${c.good("+")} ${clean(line)}`),
+      ...legacyNext ? [`${c.code(`userreason.client.${project.typescript ? "tsx" : "jsx"}`)} ${c.muted("(new file, generated)")}`] : [],
+      installRow
+    ]);
+  } else terminal.block("Changes", [reviewed?.status === "integrated" && !packages.length ? c.muted(`nothing to edit${dot}@userreason/js and @userreason/cli are current`) : installRow]);
+  const extras = [];
+  if (reviewed?.status === "ready" && additions) extras.push({ value: "edit", label: `${additions.created ? "Create" : "Edit"} ${additions.path}`, hint: "add UserReason.init", initial: true });
+  if (noteProbe && "path" in noteProbe) extras.push({ value: "note", label: `${noteProbe.file} ${noteProbe.replacement ? "note update" : "note"}`, hint: "user-feedback guidance", initial: true });
+  if (skillProbe && "files" in skillProbe) extras.push({ value: "skill", label: skillProbe.update ? "Agent skill update" : "Agent skill", hint: ".agents/skills/userreason", initial: true });
+  if (!values["skip-cli-access"] && !values["session-only"]) extras.push({ value: "access", label: "Ongoing CLI access", hint: "second approval (90 days)", initial: true });
+  if (!values["skip-global-cli"] && !values["skip-install"]) extras.push({ value: "global", label: "Global userreason command", hint: `optional${dot}npm i -g, replaces the current global CLI`, initial: Boolean(values["global-cli"]) });
+  const picked = interactive ? new Set(extras.length ? await terminal.multiselect(`Set up ${c.muted(`${dot.trim()} recommended steps are selected`)}`, extras, extras.filter((item) => item.initial).map((item) => item.value)) : []) : void 0;
+  const integrate = Boolean(reviewed?.status === "ready" && (picked ? picked.has("edit") : values.integrate || values.yes));
+  const choice = (key, flag, skipFlag) => picked ? { requested: picked.has(key), skip: !picked.has(key) } : { requested: Boolean(values[flag]), skip: skipFlag };
+  const noteChoice = choice("note", "agent-note", Boolean(values["skip-agent-note"]));
+  const skillChoice = choice("skill", "agent-skill", Boolean(values["skip-agent-skill"]));
+  const globalChoice = choice("global", "global-cli", Boolean(values["skip-global-cli"] || values["skip-install"]));
+  const accessChoice = choice("access", "cli-access", Boolean(values["skip-cli-access"] || values["session-only"]));
+  terminal.cancelState = "some steps are done; rerun the wizard to continue";
+  if (!selectedWorkspace) {
+    currentStep = "Creating the workspace";
+    try {
+      selectedWorkspace = await client.createWorkspace(workspaceName, workspaceIds);
+    } catch (error) {
+      if (!(error instanceof ApiError) || error.status !== 403 || connection || !["authorization_required", "grant_required"].includes(error.code))
+        throw error;
+      const granted = await approve();
+      account = await client.account();
+      const grant = account.grants.find(
+        (item) => item && typeof item === "object" && "id" in item && item.id === granted.grant_id
+      );
+      if (grant?.workspace_id)
+        throw new Error(
+          "An existing workspace was selected in the browser. Rerun the wizard to choose its site."
+        );
+      selectedWorkspace = await client.createWorkspace(workspaceName, workspaceIds);
+    }
+    terminal.success(`Created workspace ${c.code(clean(selectedWorkspace.name))}`);
+  }
+  if (!selectedSite) {
+    currentStep = "Creating the site";
+    selectedSite = await authorized(
+      () => client.createSite({
+        workspaceId: selectedWorkspace.id,
+        name: siteName,
+        environment,
+        origins: hostOrigin ? [hostOrigin] : [],
+        requestId: siteIds.requestId,
+        siteId: siteIds.siteId
+      }),
+      selectedWorkspace.id
+    );
+    terminal.success(`Created site ${c.code(clean(selectedSite.name))}`);
+  }
+  currentStep = "Saving optional installation resume details";
+  if (!await saveInstallation(project.directory, installation)) warnResumeStorage();
+  currentStep = "Preparing initialization files";
+  const generated = await writeIntegration(project, installation, values.force, legacyNext);
+  const existingPlan = plan?.status === "integrated" ? reviewed : plan;
+  if (existingPlan?.status === "manual") terminal.warn(existingPlan.reason);
+  let sdkInstalled = sdkCurrent;
+  let cliInstalled = cliCurrent;
+  const shouldInstall = !values["skip-install"] && Boolean(values.install || !sdkInstalled);
+  const shouldInstallCli = !values["skip-install"] && Boolean(values.install || !cliInstalled);
+  let installFailed = false;
+  if (shouldInstall || shouldInstallCli) {
+    currentStep = "Installing the SDK and CLI";
+    const warnings = [];
+    const failures = [];
+    const started = Date.now();
+    const installed = [];
+    await terminal.task("Installing @userreason/js, @userreason/cli", async () => {
+      if (shouldInstall) {
+        try {
+          await installSdk(project, { profile, verbose: values.debug, onWarning: (message) => {
+            warnings.push(message);
+          } });
+          sdkInstalled = true;
+          installed.push("@userreason/js");
+        } catch (error) {
+          if (!(error instanceof SdkInstallError)) throw error;
+          failures.push({ error, command: sdkInstallCommand(project), title: "Install SDK manually" });
+          return;
+        }
+      }
+      if (shouldInstallCli) {
+        try {
+          await installCli(project, { profile, verbose: values.debug, onWarning: (message) => {
+            warnings.push(message);
+          } });
+          cliInstalled = true;
+          installed.push("@userreason/cli");
+        } catch (error) {
+          if (!(error instanceof SdkInstallError)) throw error;
+          failures.push({ error, command: cliInstallCommand(project, profile), title: "Install CLI manually" });
+        }
+      }
+    }, () => installed.length ? `Installed ${installed.map((name) => c.code(name)).join(", ")} ${c.muted(`(${project.packageManager}${Date.now() - started >= 2e3 ? `, ${Math.round((Date.now() - started) / 1e3)}s` : ""})`)}` : void 0);
+    for (const message of warnings) terminal.warn(message);
+    for (const failure of failures) {
+      installFailed = true;
+      process.exitCode = 1;
+      terminal.error(failure.error.message);
+      terminal.note(`${failure.command}
+
+Then rerun the wizard. Your saved workspace and site will be reused.`, failure.title);
+    }
+  } else if (sdkInstalled) terminal.success(`UserReason packages already installed ${c.muted("(compatible versions)")}`);
+  if (integrate && reviewed && !installFailed) {
+    currentStep = "Applying the application initialization";
+    const concrete = await planIntegration(project, installation);
+    if (reviewed.status !== "ready" || concrete.status !== "ready" || concrete.path !== reviewed.path || concrete.before !== reviewed.before || concrete.after !== reviewed.after)
+      throw new Error("The application entry changed after the preview. Rerun to review it again.");
+    await applyIntegration(concrete);
+    if (concrete.before === null) generated.files.push(concrete.path);
+    terminal.success(`${concrete.before === null ? "Created" : "Edited"} ${c.code(additions?.path ?? "")}`);
+  }
+  const integrated = Boolean(integrate && !installFailed || existingPlan?.status === "integrated");
+  if (!integrated && !installFailed) terminal.note(generated.instruction, "Application integration");
+  currentStep = "Checking site configuration";
+  const verification = await terminal.task(
+    "Checking site configuration",
+    () => verifyConfiguration(installation, hostOrigin ?? "https://installation.userreason.invalid"),
+    "Site configuration reachable"
+  );
+  if (integrated && sdkInstalled && !installFailed) {
+    currentStep = "Clearing optional installation resume details";
+    if (!await clearInstallation(project.directory, config.apiUrl) && !resumeStorageBlocked)
+      terminal.warn("Setup is complete, but optional resume storage could not be cleared. The installed application initialization takes precedence on reruns.");
+  }
+  const completed = integrated && sdkInstalled && cliInstalled && !installFailed;
+  if (picked && !completed && !installFailed && (picked.has("note") || picked.has("skill")))
+    terminal.warn("The note and skill wait for an initialized SDK. Rerun with the entry edit selected, or apply the initialization yourself first.");
+  currentStep = "Offering the optional user feedback note";
+  const agentNote = await offerAgentNote(project, terminal, { installed: completed, ...noteChoice, preview: Boolean(values.diff) });
+  currentStep = "Offering the optional feedback agent skill";
+  const agentSkill = await offerAgentSkill(project, terminal, { installed: completed, ...skillChoice, preview: Boolean(values.diff) });
+  currentStep = "Offering the optional global CLI";
+  const globalCli = await offerGlobalCli(project, terminal, { installed: cliInstalled && !installFailed, ...globalChoice, force: values.install, verbose: values.debug, profile, preview: Boolean(values.diff) });
+  currentStep = "Offering ongoing CLI access";
+  const cliAccess = await offerCliAccess(config, terminal, { installed: cliInstalled && !installFailed, ...accessChoice, noOpen: values["no-open"], development: developmentApi, preview: Boolean(values.diff) });
+  const nextStep = installFailed ? `Run ${sdkInstalled ? cliInstallCommand(project, profile) : sdkInstallCommand(project, profile)} in your normal terminal, then rerun the wizard to finish setup.` : integrated ? "Start your app and open it in the browser to connect the SDK." : generated.instruction;
+  const siteLine = `${clean(selectedWorkspace.name)} ${S.arrow} ${clean(selectedSite.name)} ${c.muted(`(${siteDetail(selectedSite)})`)}`;
+  terminal.block(installFailed ? "Saved" : "Ready", [c.muted(installFailed ? "SDK installation is pending. After installing, rerun the wizard; your site is reused." : "SDK not connected yet. Start your app to connect it.")], { suffix: siteLine, kind: installFailed ? "warn" : "done" });
+  const start = devCommand(project);
+  const nextRows = installFailed ? [[c.code(sdkInstalled ? cliInstallCommand(project, profile) : sdkInstallCommand(project, profile)), "then rerun the wizard"]] : [
+    ...start ? [[c.code(start), "start your app"]] : [],
+    ...cliInstalled ? [[c.code(`${cliCommand(project)} prompt list`), "surveys for this site"], [c.code(`${cliCommand(project)} login --open`), `connect a teammate (after ${project.packageManager} install)`]] : []
+  ];
+  if (nextRows.length) terminal.block("Next steps", terminal.kit.cols(nextRows), { kind: "next", each: true });
+  if (values.json)
+    process.stdout.write(
+      JSON.stringify({
+        global_cli: globalCli,
+        cli_access: cliAccess,
+        workspace: selectedWorkspace,
+        site: selectedSite,
+        framework: project.framework,
+        api_environment: apiEnvironment,
+        files: generated.files,
+        sdk_installed: sdkInstalled,
+        cli_installed: cliInstalled,
+        ...installFailed ? { sdk_install_command: sdkInstallCommand(project, profile), cli_install_command: cliInstallCommand(project, profile), installation_pending: true } : {},
+        wizard_version: version,
+        sdk_required_version: profile.sdkVersion,
+        cli_required_version: profile.cliVersion,
+        integrated,
+        agent_note: agentNote,
+        agent_skill: agentSkill,
+        verification,
+        next_step: nextStep
+      }) + "\n"
+    );
+}
+var approvalProgress;
+main().catch((error) => {
+  const detail = error instanceof Error ? error.message : "Installation failed";
+  if (error instanceof Cancelled) {
+    if (activeTerminal) activeTerminal.cancelled();
+    process.stderr.write(detail + "\n");
+    process.exitCode = 130;
+    return;
+  }
+  const message = `${currentStep}: ${detail}`;
+  if (process.argv.includes("--json"))
+    process.stdout.write(JSON.stringify({ error: "wizard_failed", step: currentStep, message }) + "\n");
+  else if (activeTerminal?.interactive)
+    activeTerminal.error(clean(detail), [`while ${lowerFirst(currentStep)}`]);
+  else process.stderr.write(message + "\n");
+  process.exitCode = 1;
+});