userdispatch 0.1.0

package/dist/index.js

@@ -0,0 +1,713 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { intro as intro2, outro as outro2 } from "@clack/prompts";
+
+// src/commands/init.ts
+import { intro, log as log7 } from "@clack/prompts";
+
+// src/steps/auth.ts
+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(flags2) {
+  const s = spinner();
+  let token = flags2.token;
+  if (!token) {
+    const authUrl = `${PROD_URL}/cli/auth`;
+    log.step("Step 1 of 6 \u2014 Authenticate");
+    log.info("Opening your browser to sign in with Google.");
+    log.info("After signing in, copy the token shown on screen and paste it here.");
+    openBrowser(authUrl);
+    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 (email) {
+      log.info(`Signed in as ${email}`);
+    }
+    if (org) {
+      log.info(`Organization: ${org.name} (${org.slug})`);
+    } else {
+      log.info("No organization found \u2014 we'll create one next.");
+    }
+    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
+import { text as text2, 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, "");
+}
+async function promptForValue(message, defaultValue, placeholder) {
+  const result = await text2({
+    message,
+    defaultValue,
+    placeholder: placeholder || defaultValue,
+    validate(value) {
+      if (!value.trim()) return "This field is required.";
+    }
+  });
+  if (isCancel2(result)) {
+    log2.warn("Setup cancelled.");
+    process.exit(0);
+  }
+  return result.trim();
+}
+async function setupStep(auth, flags2 = {}) {
+  const s = spinner2();
+  log2.step("Step 2 of 6 \u2014 Set up your organization and app");
+  let orgName;
+  let orgSlug;
+  if (!auth.org) {
+    if (flags2.ci && flags2.org) {
+      orgName = flags2.org;
+      orgSlug = slugify(flags2.org);
+    } else {
+      orgName = await promptForValue("Organization name:", "My Organization");
+      orgSlug = await promptForValue("Organization slug:", slugify(orgName));
+    }
+  } else {
+    log2.info(`Using organization: ${auth.org.name}`);
+  }
+  const defaultAppName = basename(process.cwd());
+  let appName;
+  let appSlug;
+  if (flags2.ci && flags2.app) {
+    appName = flags2.app;
+    appSlug = slugify(flags2.app);
+  } else {
+    appName = await promptForValue("App name:", defaultAppName);
+    appSlug = await promptForValue("App slug:", slugify(appName));
+  }
+  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) {
+      if (err.status === 409) {
+        log2.error(`Conflict: ${err.message}. Try a different name or slug.`);
+      } else {
+        log2.error(err.message);
+      }
+    } else if (err instanceof Error) {
+      log2.error(err.message);
+    }
+    process.exit(1);
+  }
+}
+
+// src/steps/widget.ts
+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: "Claude Desktop",
+      id: "claude-desktop",
+      configPath: join(home, "Library/Application Support/Claude/claude_desktop_config.json"),
+      detected: existsSync(join(home, "Library/Application Support/Claude"))
+    },
+    {
+      name: "VS Code Copilot",
+      id: "vscode",
+      configPath: join(cwd, ".vscode/mcp.json"),
+      detected: existsSync(join(cwd, ".vscode"))
+    }
+  ];
+  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, flags2 = {}) {
+  const cwd = process.cwd();
+  const s = spinner3();
+  const pm = detectPackageManager(cwd);
+  const detection = detectFramework(cwd);
+  log3.step("Step 3 of 6 \u2014 Install widget");
+  log3.info(`Detected framework: ${detection.label}`);
+  let installed = false;
+  if (!isAlreadyInstalled(cwd)) {
+    let shouldInstall;
+    if (flags2.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:");
+      log3.info(`  <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:");
+    log3.info(`  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:");
+    log3.info(`  <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
+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`;
+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 configureMcp(agent, token, cwd) {
+  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, flags2 = {}) {
+  const cwd = process.cwd();
+  const agents = detectAgents(cwd);
+  const detected = agents.filter((a) => a.detected);
+  log4.step("Step 4 of 6 \u2014 Configure MCP for your coding agent");
+  if (detected.length === 0) {
+    log4.info("No coding agents detected. You can configure MCP manually later.");
+    return { configured: [], skipped: true };
+  }
+  let selected;
+  if (flags2.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}`);
+  }
+  return { configured: selected, skipped: false };
+}
+
+// src/steps/verify.ts
+import { spinner as spinner5, log as log5 } from "@clack/prompts";
+async function verifyStep(apiKey) {
+  const s = spinner5();
+  log5.step("Step 5 of 6 \u2014 Verify connection");
+  s.start("Sending a test submission to your dashboard...");
+  try {
+    await apiSubmission(
+      "/v1/submissions",
+      {
+        type: "feedback",
+        subject: "Setup complete",
+        message: "Test submission from npx userdispatch init.",
+        metadata: { source: "cli-init", test: true }
+      },
+      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
+import { note, outro, log as log6 } from "@clack/prompts";
+function summaryStep(result) {
+  const { setup, widget, mcp, verified, modifiedFiles } = result;
+  log6.step("Step 6 of 6 \u2014 Summary");
+  const maskedKey = setup.app.apiKey.slice(0, 7) + "..." + setup.app.apiKey.slice(-4);
+  const lines = [];
+  lines.push(`Organization:  ${setup.org.name} (${setup.org.slug})`);
+  lines.push(`App:           ${setup.app.name} (${setup.app.slug})`);
+  lines.push(`API Key:       ${maskedKey}`);
+  lines.push("");
+  if (widget.installed) {
+    lines.push(`SDK:           installed via ${widget.packageManager}`);
+  }
+  if (widget.injected && widget.file) {
+    lines.push(`Widget:        injected into ${widget.file}`);
+  } else if (!widget.injected) {
+    lines.push(`Widget:        manual setup needed`);
+  }
+  if (mcp.configured.length > 0) {
+    const names = mcp.configured.map((a) => a.name).join(", ");
+    lines.push(`MCP:           configured for ${names}`);
+  }
+  lines.push(`Test:          ${verified ? "passed" : "skipped (check dashboard)"}`);
+  if (modifiedFiles.length > 0) {
+    lines.push("");
+    lines.push("Files modified:");
+    for (const f of modifiedFiles) {
+      lines.push(`  ${f}`);
+    }
+  }
+  note(lines.join("\n"), "Setup Summary");
+  const nextSteps = [
+    `Dashboard:     ${PROD_URL}/org/${setup.org.slug}/dashboard`,
+    `Submissions:   ${PROD_URL}/org/${setup.org.slug}/submissions`,
+    "",
+    "Next steps:",
+    "  1. Start your dev server \u2014 the widget appears bottom-right",
+    "  2. Submit feedback through the widget",
+    '  3. Open Claude Code and try: "Show me my recent submissions"'
+  ].join("\n");
+  note(nextSteps, "What's Next");
+  outro("You're all set! Happy building.");
+}
+
+// src/commands/init.ts
+async function initCommand(flags2) {
+  intro("UserDispatch Setup");
+  const auth = await authStep(flags2);
+  const setup = await setupStep(auth, flags2);
+  const modifiedFiles = [];
+  let widget;
+  try {
+    widget = await widgetStep(setup.app.apiKey, flags2);
+    if (widget.file) modifiedFiles.push(widget.file);
+  } catch (err) {
+    log7.warn(`Widget setup encountered an issue: ${err instanceof Error ? err.message : String(err)}`);
+    widget = {
+      installed: false,
+      injected: false,
+      framework: "unknown",
+      packageManager: "npm"
+    };
+  }
+  let mcp;
+  try {
+    mcp = await mcpStep(auth.token, flags2);
+    for (const agent of mcp.configured) {
+      modifiedFiles.push(agent.configPath);
+    }
+  } catch (err) {
+    log7.warn(`MCP setup encountered an issue: ${err instanceof Error ? err.message : String(err)}`);
+    mcp = { configured: [], skipped: true };
+  }
+  let verified = false;
+  try {
+    verified = await verifyStep(setup.app.apiKey);
+  } catch (err) {
+    log7.warn(`Verification encountered an issue: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  summaryStep({
+    auth,
+    setup,
+    widget,
+    mcp,
+    verified,
+    modifiedFiles
+  });
+}
+
+// src/lib/args.ts
+function parseArgs(argv) {
+  const flags2 = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--ci") {
+      flags2.ci = true;
+      continue;
+    }
+    const next = argv[i + 1];
+    if (arg === "--token" && next) {
+      flags2.token = next;
+      i++;
+    } else if (arg === "--org" && next) {
+      flags2.org = next;
+      i++;
+    } else if (arg === "--app" && next) {
+      flags2.app = next;
+      i++;
+    } else if (arg === "--framework" && next) {
+      flags2.framework = next;
+      i++;
+    } else if (arg === "--agent" && next) {
+      flags2.agent = next;
+      i++;
+    } else if (arg.startsWith("--token=")) {
+      flags2.token = arg.split("=")[1];
+    } else if (arg.startsWith("--org=")) {
+      flags2.org = arg.split("=")[1];
+    } else if (arg.startsWith("--app=")) {
+      flags2.app = arg.split("=")[1];
+    } else if (arg.startsWith("--framework=")) {
+      flags2.framework = arg.split("=")[1];
+    } else if (arg.startsWith("--agent=")) {
+      flags2.agent = arg.split("=")[1];
+    }
+  }
+  return flags2;
+}
+
+// src/index.ts
+var args = process.argv.slice(2);
+var command = args.find((a) => !a.startsWith("--"));
+var flags = parseArgs(args);
+if (command === "init" || !command) {
+  await initCommand(flags);
+} else {
+  intro2("UserDispatch");
+  outro2(`Unknown command: ${command}. Use "userdispatch init" to get started.`);
+  process.exit(1);
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "userdispatch",
+  "version": "0.1.0",
+  "description": "CLI installer for UserDispatch feedback widget + MCP server",
+  "bin": {
+    "userdispatch": "dist/index.js"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node18 --clean",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.9.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "tsx": "^4.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}