userdispatch 0.2.0 → 0.3.0

package/dist/init-DQZBIX7E.js

@@ -0,0 +1,1007 @@
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-JSBRDJBE.js";
+
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS({
+  "node_modules/picocolors/picocolors.js"(exports, module) {
+    "use strict";
+    var p = process || {};
+    var argv = p.argv || [];
+    var env = p.env || {};
+    var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+    var formatter = (open, close, replace = open) => (input) => {
+      let string = "" + input, index = string.indexOf(close, open.length);
+      return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+    };
+    var replaceClose = (string, close, replace, index) => {
+      let result = "", cursor = 0;
+      do {
+        result += string.substring(cursor, index) + replace;
+        cursor = index + close.length;
+        index = string.indexOf(close, cursor);
+      } while (~index);
+      return result + string.substring(cursor);
+    };
+    var createColors = (enabled = isColorSupported) => {
+      let f = enabled ? formatter : () => String;
+      return {
+        isColorSupported: enabled,
+        reset: f("\x1B[0m", "\x1B[0m"),
+        bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+        dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+        italic: f("\x1B[3m", "\x1B[23m"),
+        underline: f("\x1B[4m", "\x1B[24m"),
+        inverse: f("\x1B[7m", "\x1B[27m"),
+        hidden: f("\x1B[8m", "\x1B[28m"),
+        strikethrough: f("\x1B[9m", "\x1B[29m"),
+        black: f("\x1B[30m", "\x1B[39m"),
+        red: f("\x1B[31m", "\x1B[39m"),
+        green: f("\x1B[32m", "\x1B[39m"),
+        yellow: f("\x1B[33m", "\x1B[39m"),
+        blue: f("\x1B[34m", "\x1B[39m"),
+        magenta: f("\x1B[35m", "\x1B[39m"),
+        cyan: f("\x1B[36m", "\x1B[39m"),
+        white: f("\x1B[37m", "\x1B[39m"),
+        gray: f("\x1B[90m", "\x1B[39m"),
+        bgBlack: f("\x1B[40m", "\x1B[49m"),
+        bgRed: f("\x1B[41m", "\x1B[49m"),
+        bgGreen: f("\x1B[42m", "\x1B[49m"),
+        bgYellow: f("\x1B[43m", "\x1B[49m"),
+        bgBlue: f("\x1B[44m", "\x1B[49m"),
+        bgMagenta: f("\x1B[45m", "\x1B[49m"),
+        bgCyan: f("\x1B[46m", "\x1B[49m"),
+        bgWhite: f("\x1B[47m", "\x1B[49m"),
+        blackBright: f("\x1B[90m", "\x1B[39m"),
+        redBright: f("\x1B[91m", "\x1B[39m"),
+        greenBright: f("\x1B[92m", "\x1B[39m"),
+        yellowBright: f("\x1B[93m", "\x1B[39m"),
+        blueBright: f("\x1B[94m", "\x1B[39m"),
+        magentaBright: f("\x1B[95m", "\x1B[39m"),
+        cyanBright: f("\x1B[96m", "\x1B[39m"),
+        whiteBright: f("\x1B[97m", "\x1B[39m"),
+        bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+        bgRedBright: f("\x1B[101m", "\x1B[49m"),
+        bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+        bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+        bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+        bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+        bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+        bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+      };
+    };
+    module.exports = createColors();
+    module.exports.createColors = createColors;
+  }
+});
+
+// src/commands/init.ts
+var import_picocolors7 = __toESM(require_picocolors(), 1);
+import { intro, log as log7 } from "@clack/prompts";
+
+// src/steps/auth.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
+import { text, spinner, log, isCancel } from "@clack/prompts";
+import { exec } from "child_process";
+import { platform } from "os";
+
+// src/lib/config.ts
+var PROD_URL = process.env.USERDISPATCH_API_URL || "https://userdispatch.com";
+var API_BASE = `${PROD_URL}/api`;
+
+// src/lib/api.ts
+var ApiError = class extends Error {
+  constructor(status, body) {
+    super(body.error || `HTTP ${status}`);
+    this.status = status;
+    this.body = body;
+    this.name = "ApiError";
+  }
+};
+async function request(path, options) {
+  const url = `${API_BASE}${path}`;
+  const res = await fetch(url, options);
+  const body = await res.json().catch(() => ({ error: "Invalid JSON response" }));
+  if (!res.ok) {
+    throw new ApiError(res.status, body);
+  }
+  return body;
+}
+async function apiGet(path, token) {
+  return request(path, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json"
+    }
+  });
+}
+async function apiPost(path, body, token) {
+  return request(path, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+}
+async function apiSubmission(path, body, apiKey) {
+  return request(path, {
+    method: "POST",
+    headers: {
+      "X-API-Key": apiKey,
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+}
+
+// src/steps/auth.ts
+function openBrowser(url) {
+  const os = platform();
+  const cmd = os === "darwin" ? "open" : os === "win32" ? "start" : "xdg-open";
+  exec(`${cmd} "${url}"`, (err) => {
+    if (err) {
+      log.warn(`Could not open browser. Please visit:
+  ${url}`);
+    }
+  });
+}
+async function validateToken(token) {
+  try {
+    const res = await apiGet("/cli/auth", token);
+    return { email: res.data.email || "", org: res.data.org };
+  } catch (err) {
+    if (err instanceof ApiError && err.status === 401) {
+      throw new Error("Invalid token. Please try again.");
+    }
+    throw err;
+  }
+}
+async function authStep(flags) {
+  const s = spinner();
+  let token = flags.token;
+  if (!token) {
+    const authUrl = `${PROD_URL}/cli/auth`;
+    log.step(import_picocolors.default.bold("Step 1 of 6 \u2014 Authenticate"));
+    log.info("Sign in to link this project to your UserDispatch account. Opening your browser now...");
+    openBrowser(authUrl);
+    log.info("After signing in, copy the token and paste it below.");
+    const result = await text({
+      message: "Paste your token here (starts with ud_):",
+      placeholder: "ud_...",
+      validate(value) {
+        if (!value.trim()) return "Token is required.";
+        if (!value.trim().startsWith("ud_")) return 'Token should start with "ud_".';
+      }
+    });
+    if (isCancel(result)) {
+      log.warn("Setup cancelled.");
+      process.exit(0);
+    }
+    token = result.trim();
+  }
+  s.start("Validating token...");
+  try {
+    const { email, org } = await validateToken(token);
+    s.stop("Token validated.");
+    if (org) {
+      log.info(`Signed in as ${email}`);
+      log.info(`Organization: ${org.name} (${org.slug})`);
+    } else {
+      log.info(`Signed in as ${email}`);
+      log.info("No organization yet \u2014 we'll create one in the next step.");
+    }
+    return { token, email, org };
+  } catch (err) {
+    s.stop("Token validation failed.");
+    if (err instanceof Error) {
+      log.error(err.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/steps/setup.ts
+var import_picocolors2 = __toESM(require_picocolors(), 1);
+import { text as text2, select, spinner as spinner2, log as log2, isCancel as isCancel2 } from "@clack/prompts";
+import { basename } from "path";
+function slugify(str) {
+  return str.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toTitleCase(str) {
+  return str.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+async function promptForValue(message, defaultValue, placeholder) {
+  const result = await text2({
+    message,
+    defaultValue,
+    placeholder: placeholder || defaultValue,
+    validate(value) {
+      if (!value.trim() && !defaultValue) return "This field is required.";
+    }
+  });
+  if (isCancel2(result)) {
+    log2.warn("Setup cancelled.");
+    process.exit(0);
+  }
+  return result.trim() || defaultValue;
+}
+async function setupStep(auth, flags = {}) {
+  const s = spinner2();
+  const hasOrg = Boolean(auth.org);
+  const stepTitle = hasOrg ? "Step 2 of 6 \u2014 Create app" : "Step 2 of 6 \u2014 Create organization & app";
+  log2.step(import_picocolors2.default.bold(stepTitle));
+  let orgName;
+  let orgSlug;
+  if (!auth.org) {
+    if (flags.ci && flags.org) {
+      orgName = flags.org;
+      orgSlug = slugify(flags.org);
+    } else {
+      log2.info("Your team or company name. This is the top-level account that holds all your apps.");
+      orgName = await promptForValue("Organization name:", "My Organization");
+      log2.info("URL-friendly identifier \u2014 your dashboard will be at userdispatch.com/org/<slug>.");
+      orgSlug = await promptForValue("Organization slug:", slugify(orgName));
+    }
+  } else {
+    log2.info(`Using organization: ${import_picocolors2.default.bold(auth.org.name)}`);
+  }
+  const defaultAppName = toTitleCase(basename(process.cwd()));
+  let appName;
+  let appSlug;
+  if (flags.ci && flags.app) {
+    appName = flags.app;
+    appSlug = slugify(flags.app);
+  } else {
+    log2.info("Name your app \u2014 this label appears in the feedback widget and your dashboard.");
+    appName = await promptForValue("App name:", defaultAppName);
+    log2.info("URL-friendly identifier \u2014 feedback form will be at userdispatch.com/f/<org>/<app-slug>.");
+    appSlug = await promptForValue("App slug:", slugify(appName));
+  }
+  const MAX_ATTEMPTS = 3;
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    s.start("Creating your setup...");
+    try {
+      const body = {
+        appName,
+        appSlug
+      };
+      if (orgName) body.orgName = orgName;
+      if (orgSlug) body.orgSlug = orgSlug;
+      const res = await apiPost("/cli/setup", body, auth.token);
+      s.stop("Setup complete.");
+      const { org, app, isNewOrg } = res.data;
+      if (isNewOrg) {
+        log2.info(`Created organization: ${org.name} (${org.slug})`);
+      }
+      log2.info(`Created app: ${app.name} (${app.slug})`);
+      return { org, app, isNewOrg };
+    } catch (err) {
+      s.stop("Setup failed.");
+      if (err instanceof ApiError && err.status === 409) {
+        const conflictBody = err.body;
+        if (conflictBody.existing) {
+          const existing = conflictBody.existing;
+          const conflictOrg = conflictBody.org;
+          if (flags.ci) {
+            log2.info(`App "${existing.slug}" already exists \u2014 using it.`);
+            const org = conflictOrg || auth.org;
+            return {
+              org,
+              app: { id: existing.id, name: existing.name, slug: existing.slug, apiKey: existing.apiKey },
+              isNewOrg: false
+            };
+          }
+          const action = await select({
+            message: `App "${existing.slug}" already exists in this organization.`,
+            options: [
+              { value: "use", label: "Use existing app", hint: existing.name },
+              { value: "rename", label: "Enter a different name" }
+            ]
+          });
+          if (isCancel2(action)) {
+            log2.warn("Setup cancelled.");
+            process.exit(0);
+          }
+          if (action === "use") {
+            const org = conflictOrg || auth.org;
+            return {
+              org,
+              app: { id: existing.id, name: existing.name, slug: existing.slug, apiKey: existing.apiKey },
+              isNewOrg: false
+            };
+          }
+          appName = await promptForValue("App name:", defaultAppName);
+          appSlug = await promptForValue("App slug:", slugify(appName));
+          continue;
+        }
+        log2.warn(`${err.message}. Please choose a different slug.`);
+        if (orgName) {
+          orgSlug = await promptForValue("Organization slug:", slugify(orgName));
+          continue;
+        }
+      }
+      if (err instanceof ApiError) {
+        log2.error(err.message);
+      } else if (err instanceof Error) {
+        log2.error(err.message);
+      }
+      process.exit(1);
+    }
+  }
+  log2.error("Too many conflicts. Please try again.");
+  process.exit(1);
+}
+
+// src/steps/widget.ts
+var import_picocolors3 = __toESM(require_picocolors(), 1);
+import { spinner as spinner3, log as log3, confirm, isCancel as isCancel3 } from "@clack/prompts";
+import { execSync } from "child_process";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// src/lib/detect.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function detectPackageManager(cwd = process.cwd()) {
+  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
+  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function detectFramework(cwd = process.cwd()) {
+  const pkgPath = join(cwd, "package.json");
+  let deps = {};
+  if (existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    } catch {
+    }
+  }
+  if (deps["next"]) {
+    if (existsSync(join(cwd, "app/layout.tsx")) || existsSync(join(cwd, "app/layout.jsx"))) {
+      return { framework: "next-app", label: "Next.js (App Router)", layoutFile: join(cwd, "app/layout.tsx") };
+    }
+    if (existsSync(join(cwd, "src/app/layout.tsx")) || existsSync(join(cwd, "src/app/layout.jsx"))) {
+      return { framework: "next-app", label: "Next.js (App Router)", layoutFile: join(cwd, "src/app/layout.tsx") };
+    }
+    if (existsSync(join(cwd, "pages/_document.tsx")) || existsSync(join(cwd, "pages/_document.jsx"))) {
+      return { framework: "next-pages", label: "Next.js (Pages Router)", layoutFile: join(cwd, "pages/_document.tsx") };
+    }
+    return { framework: "next-app", label: "Next.js", layoutFile: void 0 };
+  }
+  if (deps["vite"]) {
+    return { framework: "vite", label: "Vite", layoutFile: join(cwd, "index.html") };
+  }
+  if (deps["react-scripts"]) {
+    return { framework: "cra", label: "Create React App", layoutFile: join(cwd, "public/index.html") };
+  }
+  if (deps["nuxt"]) {
+    return { framework: "nuxt", label: "Nuxt", layoutFile: join(cwd, "nuxt.config.ts") };
+  }
+  if (deps["@sveltejs/kit"]) {
+    return { framework: "sveltekit", label: "SvelteKit", layoutFile: join(cwd, "src/app.html") };
+  }
+  if (deps["astro"]) {
+    return { framework: "astro", label: "Astro", layoutFile: void 0 };
+  }
+  if (existsSync(join(cwd, "index.html"))) {
+    return { framework: "static", label: "Static HTML", layoutFile: join(cwd, "index.html") };
+  }
+  return { framework: "unknown", label: "Unknown", layoutFile: void 0 };
+}
+function detectAgents(cwd = process.cwd()) {
+  const home = homedir();
+  const agents = [
+    {
+      name: "Claude Code",
+      id: "claude-code",
+      configPath: join(cwd, ".mcp.json"),
+      detected: true
+      // always offer Claude Code
+    },
+    {
+      name: "Cursor",
+      id: "cursor",
+      configPath: join(cwd, ".cursor/mcp.json"),
+      detected: existsSync(join(cwd, ".cursor"))
+    },
+    {
+      name: "Windsurf",
+      id: "windsurf",
+      configPath: join(home, ".codeium/windsurf/mcp_config.json"),
+      detected: existsSync(join(home, ".codeium/windsurf"))
+    },
+    {
+      name: "VS Code Copilot",
+      id: "vscode",
+      configPath: join(cwd, ".vscode/mcp.json"),
+      detected: existsSync(join(cwd, ".vscode"))
+    },
+    {
+      name: "Codex",
+      id: "codex",
+      configPath: join(cwd, ".codex/config.toml"),
+      detected: existsSync(join(cwd, ".codex"))
+    }
+  ];
+  return agents;
+}
+
+// src/steps/widget.ts
+var WIDGET_URL = `${PROD_URL}/widget.js`;
+function installCommand(pm, pkg) {
+  switch (pm) {
+    case "bun":
+      return `bun add ${pkg}`;
+    case "pnpm":
+      return `pnpm add ${pkg}`;
+    case "yarn":
+      return `yarn add ${pkg}`;
+    default:
+      return `npm install ${pkg}`;
+  }
+}
+function isAlreadyInstalled(cwd) {
+  const pkgPath = join2(cwd, "package.json");
+  if (!existsSync2(pkgPath)) return false;
+  try {
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+    const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return !!allDeps["@userdispatch/sdk"];
+  } catch {
+    return false;
+  }
+}
+function fileContainsWidget(filePath) {
+  if (!existsSync2(filePath)) return false;
+  const content = readFileSync2(filePath, "utf-8");
+  return content.includes("userdispatch.com/widget.js") || content.includes("userdispatch/widget");
+}
+function injectNextAppRouter(filePath, apiKey) {
+  if (!existsSync2(filePath)) return false;
+  let content = readFileSync2(filePath, "utf-8");
+  if (fileContainsWidget(filePath)) {
+    log3.info("Widget already present in layout file \u2014 skipping injection.");
+    return false;
+  }
+  if (!content.includes("from 'next/script'") && !content.includes('from "next/script"')) {
+    const lastImportIndex = content.lastIndexOf("import ");
+    if (lastImportIndex !== -1) {
+      const endOfImport = content.indexOf("\n", lastImportIndex);
+      const importLine = `
+import Script from "next/script";`;
+      content = content.slice(0, endOfImport + 1) + importLine + content.slice(endOfImport + 1);
+    }
+  }
+  const scriptTag = `        <Script src="${WIDGET_URL}" data-api-key="${apiKey}" strategy="afterInteractive" />`;
+  const bodyCloseIndex = content.lastIndexOf("</body>");
+  if (bodyCloseIndex === -1) {
+    log3.warn("Could not find </body> tag in layout file.");
+    return false;
+  }
+  content = content.slice(0, bodyCloseIndex) + scriptTag + "\n" + content.slice(bodyCloseIndex);
+  writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+function injectHtmlFile(filePath, apiKey) {
+  if (!existsSync2(filePath)) return false;
+  let content = readFileSync2(filePath, "utf-8");
+  if (fileContainsWidget(filePath)) {
+    log3.info("Widget already present \u2014 skipping injection.");
+    return false;
+  }
+  const scriptTag = `    <script src="${WIDGET_URL}" data-api-key="${apiKey}" defer></script>`;
+  const bodyCloseIndex = content.lastIndexOf("</body>");
+  if (bodyCloseIndex === -1) {
+    log3.warn("Could not find </body> tag in file.");
+    return false;
+  }
+  content = content.slice(0, bodyCloseIndex) + scriptTag + "\n" + content.slice(bodyCloseIndex);
+  writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+async function widgetStep(apiKey, flags = {}) {
+  const cwd = process.cwd();
+  const s = spinner3();
+  const pm = detectPackageManager(cwd);
+  const detection = detectFramework(cwd);
+  log3.step(import_picocolors3.default.bold("Step 3 of 6 \u2014 Install widget"));
+  log3.info(`Add the feedback widget to your app.
+Detected framework: ${detection.label}`);
+  let installed = false;
+  if (!isAlreadyInstalled(cwd)) {
+    let shouldInstall;
+    if (flags.ci) {
+      shouldInstall = true;
+    } else {
+      shouldInstall = await confirm({
+        message: "Install @userdispatch/sdk? (TypeScript SDK for sending feedback from your code)",
+        initialValue: true
+      });
+      if (isCancel3(shouldInstall)) {
+        log3.warn("Setup cancelled.");
+        process.exit(0);
+      }
+    }
+    if (shouldInstall) {
+      s.start(`Installing @userdispatch/sdk via ${pm}...`);
+      try {
+        execSync(installCommand(pm, "@userdispatch/sdk"), {
+          cwd,
+          stdio: "pipe"
+        });
+        s.stop("SDK installed.");
+        installed = true;
+      } catch {
+        s.stop("SDK installation failed \u2014 you can install it manually later.");
+      }
+    }
+  } else {
+    log3.info("@userdispatch/sdk already installed.");
+    installed = true;
+  }
+  let injected = false;
+  const { framework, layoutFile } = detection;
+  if (!layoutFile || !existsSync2(layoutFile)) {
+    if (framework === "unknown") {
+      log3.info(`Could not detect framework. Add the widget manually:
+  <script src="${WIDGET_URL}" data-api-key="${apiKey}" defer></script>`);
+    } else {
+      log3.info(`No layout file found for ${detection.label}. Add the widget manually.`);
+    }
+    return { installed, injected: false, framework, packageManager: pm };
+  }
+  if (framework === "next-app") {
+    injected = injectNextAppRouter(layoutFile, apiKey);
+  } else if (["vite", "cra", "sveltekit", "static"].includes(framework)) {
+    injected = injectHtmlFile(layoutFile, apiKey);
+  } else if (framework === "nuxt") {
+    log3.info(`For Nuxt, add the widget script to your nuxt.config.ts:
+  app: { head: { script: [{ src: "${WIDGET_URL}", "data-api-key": "${apiKey}", defer: true }] } }`);
+  } else if (framework === "next-pages") {
+    injected = injectHtmlFile(layoutFile, apiKey);
+  } else {
+    log3.info(`Add the widget manually:
+  <script src="${WIDGET_URL}" data-api-key="${apiKey}" defer></script>`);
+  }
+  if (injected) {
+    log3.success(`Widget injected into ${layoutFile}`);
+  }
+  return { installed, injected, framework, file: injected ? layoutFile : void 0, packageManager: pm };
+}
+
+// src/steps/mcp.ts
+var import_picocolors4 = __toESM(require_picocolors(), 1);
+import { multiselect, spinner as spinner4, log as log4, isCancel as isCancel4 } from "@clack/prompts";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync } from "fs";
+import { dirname, relative } from "path";
+var MCP_URL = `${PROD_URL}/api/mcp`;
+var DOCS_URL = `${PROD_URL}/docs/mcp`;
+function readJsonFile(filePath) {
+  if (!existsSync3(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync3(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(filePath, data) {
+  const dir = dirname(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync2(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function addToGitignore(cwd, entry) {
+  const gitignorePath = `${cwd}/.gitignore`;
+  if (!existsSync3(gitignorePath)) return;
+  const content = readFileSync3(gitignorePath, "utf-8");
+  if (content.includes(entry)) return;
+  const newline = content.endsWith("\n") ? "" : "\n";
+  writeFileSync2(gitignorePath, content + newline + entry + "\n", "utf-8");
+}
+function configureCodexMcp(agent, token, cwd) {
+  const dir = dirname(agent.configPath);
+  if (!existsSync3(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let content = "";
+  if (existsSync3(agent.configPath)) {
+    content = readFileSync3(agent.configPath, "utf-8");
+  }
+  const section = `[mcp_servers.userdispatch]
+url = "${MCP_URL}"
+http_headers = { "Authorization" = "Bearer ${token}" }`;
+  const sectionRegex = /\[mcp_servers\.userdispatch\][^\[]*/s;
+  if (sectionRegex.test(content)) {
+    content = content.replace(sectionRegex, section + "\n");
+  } else {
+    const newline = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+    content = content + newline + "\n" + section + "\n";
+  }
+  writeFileSync2(agent.configPath, content, "utf-8");
+  const relPath = relative(cwd, agent.configPath);
+  if (!relPath.startsWith("..") && !relPath.startsWith("/")) {
+    addToGitignore(cwd, relPath);
+  }
+}
+function configureMcp(agent, token, cwd) {
+  if (agent.id === "codex") {
+    configureCodexMcp(agent, token, cwd);
+    return;
+  }
+  const config = readJsonFile(agent.configPath);
+  const mcpServers = config.mcpServers ?? {};
+  mcpServers["userdispatch"] = {
+    url: MCP_URL,
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  };
+  config.mcpServers = mcpServers;
+  writeJsonFile(agent.configPath, config);
+  const relPath = relative(cwd, agent.configPath);
+  if (!relPath.startsWith("..") && !relPath.startsWith("/")) {
+    addToGitignore(cwd, relPath);
+  }
+}
+async function mcpStep(token, flags = {}) {
+  const cwd = process.cwd();
+  const agents = detectAgents(cwd);
+  const detected = agents.filter((a) => a.detected);
+  log4.step(import_picocolors4.default.bold("Step 4 of 6 \u2014 Connect the DispatchAgent MCP Server"));
+  log4.info("The DispatchAgent MCP Server lets your coding agent triage bugs, reply to users, and generate weekly digests.");
+  if (detected.length === 0) {
+    log4.info(`No coding agents detected. You can configure MCP manually later: ${import_picocolors4.default.underline(DOCS_URL)}`);
+    return { configured: [], skipped: true };
+  }
+  let selected;
+  if (flags.ci) {
+    selected = detected;
+    log4.info(`Configuring MCP for ${detected.map((a) => a.name).join(", ")}...`);
+  } else if (detected.length === 1) {
+    selected = detected;
+    log4.info(`Configuring MCP for ${detected[0].name}...`);
+  } else {
+    const result = await multiselect({
+      message: "Which coding agents should we configure?",
+      options: detected.map((a) => ({
+        value: a.id,
+        label: a.name,
+        hint: a.configPath
+      })),
+      initialValues: detected.map((a) => a.id)
+    });
+    if (isCancel4(result)) {
+      log4.warn("Setup cancelled.");
+      process.exit(0);
+    }
+    selected = detected.filter((a) => result.includes(a.id));
+  }
+  if (selected.length === 0) {
+    log4.info("Skipped MCP configuration.");
+    return { configured: [], skipped: true };
+  }
+  const s = spinner4();
+  s.start("Configuring MCP servers...");
+  for (const agent of selected) {
+    configureMcp(agent, token, cwd);
+  }
+  s.stop("MCP servers configured.");
+  for (const agent of selected) {
+    log4.info(`  ${agent.name}: ${agent.configPath}`);
+  }
+  log4.info(`Manual setup & docs: ${import_picocolors4.default.underline(DOCS_URL)}`);
+  return { configured: selected, skipped: false };
+}
+
+// src/steps/verify.ts
+var import_picocolors5 = __toESM(require_picocolors(), 1);
+import { spinner as spinner5, log as log5 } from "@clack/prompts";
+async function verifyStep(ctx) {
+  const s = spinner5();
+  log5.step(import_picocolors5.default.bold("Step 5 of 6 \u2014 Verify connection"));
+  log5.info("Sending a test submission to confirm everything is wired up.");
+  s.start("Sending test submission...");
+  const agentNames = ctx.mcp.configured.map((a) => a.name).join(", ") || "none";
+  try {
+    await apiSubmission(
+      "/v1/submissions",
+      {
+        type: "feedback",
+        subject: "Welcome to UserDispatch!",
+        message: `Setup complete for ${ctx.setup.app.name} (${ctx.setup.org.name}).
+
+Configured agents: ${agentNames}.
+
+Try replying to this submission from your dashboard or coding agent to see it in action.`,
+        metadata: { source: "cli-init", agents: agentNames, version: "0.3.0" }
+      },
+      ctx.apiKey
+    );
+    s.stop("Test submission sent \u2014 check your dashboard to see it.");
+    return true;
+  } catch (err) {
+    s.stop("Test submission failed.");
+    if (err instanceof ApiError) {
+      log5.warn(`Could not send test submission: ${err.message}`);
+    } else if (err instanceof Error) {
+      log5.warn(`Could not send test submission: ${err.message}`);
+    }
+    return false;
+  }
+}
+
+// src/steps/summary.ts
+var import_picocolors6 = __toESM(require_picocolors(), 1);
+import { note, outro, log as log6 } from "@clack/prompts";
+import { exec as exec2 } from "child_process";
+import { platform as platform2 } from "os";
+
+// src/lib/agent-guides.ts
+var guides = {
+  "claude-code": {
+    name: "Claude Code",
+    restart: "Restart Claude Code (or start a new conversation) to load the MCP server.",
+    prompts: [
+      "Show me my recent submissions",
+      "Triage open bugs and suggest priorities",
+      "Draft a reply to the latest feedback",
+      "Generate a weekly feedback digest"
+    ],
+    tip: "Claude Code can read, reply, and update statuses \u2014 all from your terminal."
+  },
+  cursor: {
+    name: "Cursor",
+    restart: "Restart Cursor to load MCP. Check Settings > MCP Servers to confirm.",
+    prompts: [
+      "@userdispatch Show me my recent submissions",
+      "@userdispatch Triage open bugs and suggest priorities",
+      "@userdispatch Draft a reply to the latest feedback",
+      "@userdispatch Generate a weekly feedback digest"
+    ],
+    tip: "Cursor can read, reply, and update statuses right from the editor."
+  },
+  windsurf: {
+    name: "Windsurf",
+    restart: "Restart Windsurf to load the MCP server.",
+    prompts: [
+      "Show me my recent submissions",
+      "Triage open bugs and suggest priorities",
+      "Draft a reply to the latest feedback",
+      "Generate a weekly feedback digest"
+    ],
+    tip: "Windsurf can read, reply, and update statuses from your editor."
+  },
+  codex: {
+    name: "Codex",
+    restart: "Restart Codex or open a new session to load the MCP server.",
+    prompts: [
+      "Show me my recent submissions",
+      "Triage open bugs and suggest priorities",
+      "Draft a reply to the latest feedback",
+      "Generate a weekly feedback digest"
+    ],
+    tip: "Codex can read, reply, and update statuses from your terminal."
+  },
+  vscode: {
+    name: "VS Code Copilot",
+    restart: "Reload VS Code (Cmd+Shift+P > Reload Window) to pick up MCP.",
+    prompts: [
+      "Show me my recent submissions",
+      "Triage open bugs and suggest priorities",
+      "Draft a reply to the latest feedback",
+      "Generate a weekly feedback digest"
+    ],
+    tip: "VS Code Copilot can read, reply, and update statuses from the editor."
+  }
+};
+function getAgentGuide(agentId) {
+  return guides[agentId];
+}
+
+// src/steps/summary.ts
+function openBrowser2(url) {
+  const os = platform2();
+  const cmd = os === "darwin" ? "open" : os === "win32" ? "start" : "xdg-open";
+  exec2(`${cmd} "${url}"`, () => {
+  });
+}
+function summaryStep(result) {
+  const { setup, widget, mcp, verified } = result;
+  log6.step(import_picocolors6.default.bold("Step 6 of 6 \u2014 Summary"));
+  const maskedKey = setup.app.apiKey ? setup.app.apiKey.slice(0, 7) + "..." + setup.app.apiKey.slice(-4) : "N/A";
+  const statusLines = [];
+  statusLines.push(`Organization   ${setup.org.name} (${setup.org.slug})`);
+  statusLines.push(`App            ${setup.app.name} (${setup.app.slug})`);
+  statusLines.push(`API Key        ${maskedKey}`);
+  statusLines.push("");
+  if (widget.installed) {
+    statusLines.push(`${import_picocolors6.default.green("\u2713")}  SDK installed via ${widget.packageManager}`);
+  }
+  if (widget.injected && widget.file) {
+    statusLines.push(`${import_picocolors6.default.green("\u2713")}  Widget injected into ${widget.file}`);
+  } else if (!widget.injected) {
+    statusLines.push(`\u25CB  Widget: manual setup needed`);
+  }
+  if (mcp.configured.length > 0) {
+    const names = mcp.configured.map((a) => a.name).join(", ");
+    statusLines.push(`${import_picocolors6.default.green("\u2713")}  MCP configured for ${names}`);
+  }
+  statusLines.push(`${verified ? import_picocolors6.default.green("\u2713") : "\u25CB"}  Connection ${verified ? "verified" : "not verified"}`);
+  note(statusLines.join("\n"), "Setup Complete");
+  const nextLines = [];
+  nextLines.push("Links");
+  nextLines.push(`  Dashboard:      ${PROD_URL}/org/${setup.org.slug}/dashboard`);
+  nextLines.push(`  Submissions:    ${PROD_URL}/org/${setup.org.slug}/submissions`);
+  nextLines.push(`  Feedback form:  ${PROD_URL}/f/${setup.org.slug}/${setup.app.slug}`);
+  if (mcp.configured.length > 0) {
+    const primaryAgent = mcp.configured[0];
+    const guide = getAgentGuide(primaryAgent.id);
+    if (guide) {
+      nextLines.push("");
+      nextLines.push(`Get started with ${guide.name}`);
+      nextLines.push("");
+      nextLines.push(`  1. ${guide.restart}`);
+      nextLines.push("  2. Try these prompts:");
+      nextLines.push("");
+      for (const prompt of guide.prompts) {
+        nextLines.push(`     > "${prompt}"`);
+      }
+      nextLines.push("");
+      nextLines.push(`Tip: ${guide.tip}`);
+    }
+  } else {
+    nextLines.push("");
+    nextLines.push("Get started");
+    nextLines.push("");
+    nextLines.push("  1. Start your dev server \u2014 the widget appears bottom-right");
+    nextLines.push("  2. Submit feedback through the widget");
+    nextLines.push("  3. Check your dashboard to see submissions");
+  }
+  note(nextLines.join("\n"), "What's Next");
+  if (process.stdin.isTTY) {
+    const submissionsUrl = `${PROD_URL}/org/${setup.org.slug}/submissions`;
+    openBrowser2(submissionsUrl);
+    outro("Submissions page opened in your browser. Happy building!");
+  } else {
+    outro("Setup complete. Happy building!");
+  }
+}
+
+// src/lib/sentry.ts
+import * as Sentry from "@sentry/node";
+var SENTRY_DSN = "https://9611a3d31c8f0b5d8049c23924d0d4ad@o4510882392899584.ingest.us.sentry.io/4510965084127232";
+var SENSITIVE_PATTERNS = [/ud_[a-zA-Z0-9_-]+/g, /pk_[a-zA-Z0-9_-]+/g, /[^\s@]+@[^\s@]+\.[^\s@]+/g];
+function scrubSensitive(str) {
+  let result = str;
+  for (const pattern of SENSITIVE_PATTERNS) {
+    result = result.replace(pattern, "[REDACTED]");
+  }
+  return result;
+}
+function initSentry() {
+  Sentry.init({
+    dsn: SENTRY_DSN,
+    environment: process.env.NODE_ENV || "production",
+    release: `userdispatch-cli@${process.env.npm_package_version || "unknown"}`,
+    beforeSend(event) {
+      if (event.exception?.values) {
+        for (const ex of event.exception.values) {
+          if (ex.value) ex.value = scrubSensitive(ex.value);
+        }
+      }
+      if (event.breadcrumbs) {
+        for (const crumb of event.breadcrumbs) {
+          if (crumb.message) crumb.message = scrubSensitive(crumb.message);
+          if (crumb.data) {
+            for (const [key, val] of Object.entries(crumb.data)) {
+              if (typeof val === "string") {
+                crumb.data[key] = scrubSensitive(val);
+              }
+            }
+          }
+        }
+      }
+      return event;
+    }
+  });
+}
+function captureCliError(err, context) {
+  const safeContext = { ...context };
+  delete safeContext.token;
+  delete safeContext.apiKey;
+  delete safeContext.email;
+  Sentry.withScope((scope) => {
+    scope.setTag("cli_step", String(safeContext.step || "unknown"));
+    scope.setContext("cli", {
+      ...safeContext,
+      platform: process.platform,
+      arch: process.arch
+    });
+    if (err instanceof Error) {
+      Sentry.captureException(err);
+    } else {
+      Sentry.captureMessage(String(err), "error");
+    }
+  });
+}
+
+// src/commands/init.ts
+async function initCommand(flags) {
+  initSentry();
+  console.log(`
+${import_picocolors7.default.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+  ${import_picocolors7.default.bold("UserDispatch")}
+  ${import_picocolors7.default.dim("Gather customer feedback in under 60s")}
+${import_picocolors7.default.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")}
+`);
+  intro("Setup Wizard");
+  log7.info("This wizard will authenticate you, create your app, install the widget, and connect your coding agent through the DispatchAgent MCP Server.");
+  let currentStep = "init";
+  try {
+    currentStep = "auth";
+    const auth = await authStep(flags);
+    currentStep = "setup";
+    const setup = await setupStep(auth, flags);
+    const modifiedFiles = [];
+    currentStep = "widget";
+    let widget;
+    try {
+      widget = await widgetStep(setup.app.apiKey, flags);
+      if (widget.file) modifiedFiles.push(widget.file);
+    } catch (err) {
+      captureCliError(err, { step: "widget", framework: flags.framework, nodeVersion: process.version });
+      log7.warn(`Widget setup encountered an issue: ${err instanceof Error ? err.message : String(err)}`);
+      widget = {
+        installed: false,
+        injected: false,
+        framework: "unknown",
+        packageManager: "npm"
+      };
+    }
+    currentStep = "mcp";
+    let mcp;
+    try {
+      mcp = await mcpStep(auth.token, flags);
+      for (const agent of mcp.configured) {
+        modifiedFiles.push(agent.configPath);
+      }
+    } catch (err) {
+      captureCliError(err, { step: "mcp", nodeVersion: process.version });
+      log7.warn(`MCP setup encountered an issue: ${err instanceof Error ? err.message : String(err)}`);
+      mcp = { configured: [], skipped: true };
+    }
+    currentStep = "verify";
+    let verified = false;
+    try {
+      verified = await verifyStep({ apiKey: setup.app.apiKey, setup, mcp });
+    } catch (err) {
+      captureCliError(err, { step: "verify", nodeVersion: process.version });
+      log7.warn(`Verification encountered an issue: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    currentStep = "summary";
+    summaryStep({
+      auth,
+      setup,
+      widget,
+      mcp,
+      verified,
+      modifiedFiles
+    });
+  } catch (err) {
+    captureCliError(err, { step: currentStep, nodeVersion: process.version });
+    throw err;
+  }
+}
+export {
+  initCommand
+};