npm - @vocoder/cli - Versions diffs - 0.1.6 → 0.1.7 - Mend

@vocoder/cli 0.1.6 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (9) hide show

package/README.md +192 -13
package/dist/bin.mjs +1717 -778
package/dist/bin.mjs.map +1 -1
package/dist/chunk-OC5N5C5X.mjs +546 -0
package/dist/chunk-OC5N5C5X.mjs.map +1 -0
package/dist/lib.d.mts +175 -0
package/dist/lib.mjs +15 -0
package/dist/lib.mjs.map +1 -0
package/package.json +8 -1

package/dist/bin.mjs CHANGED Viewed

@@ -1,11 +1,320 @@
 #!/usr/bin/env node
+import {
+  StringExtractor,
+  buildInstallCommand,
+  detectLocalEcosystem,
+  getPackagesToInstall,
+  getSetupSnippets
+} from "./chunk-OC5N5C5X.mjs";
 // src/bin.ts
 import { Command } from "commander";
 // src/commands/init.ts
+import * as p5 from "@clack/prompts";
+// src/utils/auth-store.ts
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function getAuthFilePath() {
+  return join(homedir(), ".config", "vocoder", "auth.json");
+}
+function readAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const data = parsed;
+    if (typeof data.token !== "string" || typeof data.apiUrl !== "string" || typeof data.userId !== "string" || typeof data.email !== "string" || typeof data.createdAt !== "string") {
+      return null;
+    }
+    return {
+      token: data.token,
+      apiUrl: data.apiUrl,
+      userId: data.userId,
+      email: data.email,
+      name: typeof data.name === "string" ? data.name : null,
+      createdAt: data.createdAt
+    };
+  } catch {
+    return null;
+  }
+}
+function writeAuthData(data) {
+  const filePath = getAuthFilePath();
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  writeFileSync(filePath, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function clearAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+// src/utils/github-connect.ts
 import * as p from "@clack/prompts";
 import chalk from "chalk";
+import { spawn } from "child_process";
+// src/utils/local-server.ts
+import { createServer } from "http";
+import { URL as URL2 } from "url";
+function startCallbackServer() {
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    let callbackResolve = null;
+    let callbackReject = null;
+    const callbackPromise = new Promise((res, rej) => {
+      callbackResolve = res;
+      callbackReject = rej;
+    });
+    const server = createServer((req, res) => {
+      if (!req.url) {
+        res.writeHead(400);
+        res.end();
+        return;
+      }
+      let pathname;
+      let params;
+      try {
+        const parsed = new URL2(req.url, "http://localhost");
+        pathname = parsed.pathname;
+        params = Object.fromEntries(parsed.searchParams.entries());
+      } catch {
+        res.writeHead(400);
+        res.end("Bad request");
+        return;
+      }
+      if (pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(
+        '<!DOCTYPE html><html><head><title>Authenticated</title></head><body style="font-family:sans-serif;text-align:center;padding:3rem;"><h2>Authenticated</h2><p>Return to your terminal to continue. You can close this tab.</p></body></html>'
+      );
+      if (callbackResolve) {
+        callbackResolve(params);
+        callbackResolve = null;
+      }
+      setImmediate(() => server.close());
+    });
+    server.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        if (callbackReject) callbackReject(err);
+        reject(err);
+      }
+    });
+    server.listen(0, "127.0.0.1", () => {
+      if (settled) return;
+      settled = true;
+      const port = server.address().port;
+      resolve2({
+        port,
+        waitForCallback: () => callbackPromise,
+        close: () => server.close()
+      });
+    });
+  });
+}
+// src/utils/github-connect.ts
+async function tryOpenBrowser(url) {
+  if (!process.stdout.isTTY || process.env.CI === "true") {
+    return false;
+  }
+  const platform = process.platform;
+  let command;
+  let args;
+  if (platform === "darwin") {
+    command = "open";
+    args = [url];
+  } else if (platform === "win32") {
+    command = "rundll32";
+    args = ["url.dll,FileProtocolHandler", url];
+  } else {
+    command = "xdg-open";
+    args = [url];
+  }
+  return new Promise((resolve2) => {
+    try {
+      const child = spawn(command, args, {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      });
+      let settled = false;
+      child.once("spawn", () => {
+        if (settled) return;
+        settled = true;
+        child.unref();
+        resolve2(true);
+      });
+      child.once("error", () => {
+        if (settled) return;
+        settled = true;
+        resolve2(false);
+      });
+      setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        resolve2(false);
+      }, 300);
+    } catch {
+      resolve2(false);
+    }
+  });
+}
+async function runGitHubInstallFlow(params) {
+  let server = null;
+  try {
+    server = await startCallbackServer();
+  } catch {
+  }
+  const { installUrl } = await params.api.startCliGitHubInstall(params.userToken, {
+    organizationId: params.organizationId,
+    callbackPort: server?.port
+  });
+  p.log.info("Opening GitHub to install the Vocoder App...");
+  p.note(installUrl, "Install URL");
+  if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
+    const shouldOpen = params.yes ? true : await p.confirm({ message: "Open in your browser?" });
+    if (p.isCancel(shouldOpen)) {
+      server?.close();
+      return null;
+    }
+    if (shouldOpen) {
+      const opened = await tryOpenBrowser(installUrl);
+      if (!opened) {
+        p.log.info("Could not open a browser automatically. Use the URL above.");
+      }
+    }
+  }
+  const connectSpinner = p.spinner();
+  connectSpinner.start("Waiting for GitHub App installation...");
+  if (server) {
+    try {
+      const params_timeout = 15 * 60 * 1e3;
+      const callbackParams = await Promise.race([
+        server.waitForCallback(),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), params_timeout))
+      ]);
+      server.close();
+      if (!callbackParams) {
+        connectSpinner.stop("GitHub App installation timed out");
+        p.log.error("The installation flow timed out. Run `vocoder init` again.");
+        return null;
+      }
+      if (callbackParams.error) {
+        connectSpinner.stop("GitHub App installation failed");
+        p.log.error(callbackParams.error);
+        return null;
+      }
+      const { organizationId, connectionLabel, workspace_created } = callbackParams;
+      if (!organizationId || !connectionLabel) {
+        connectSpinner.stop("GitHub App installation incomplete");
+        p.log.error("Missing organization or connection data from callback.");
+        return null;
+      }
+      connectSpinner.stop(`Connected to GitHub as ${chalk.bold(connectionLabel)}`);
+      const orgName = workspace_created ? connectionLabel : organizationId;
+      return {
+        organizationId,
+        organizationName: orgName,
+        connectionLabel
+      };
+    } catch {
+      server.close();
+      connectSpinner.stop("GitHub App installation failed");
+      return null;
+    }
+  }
+  connectSpinner.stop("Could not detect GitHub App installation automatically");
+  p.log.warn("Complete the installation in your browser, then run `vocoder init` again.");
+  return null;
+}
+async function runGitHubDiscoveryFlow(params) {
+  let server = null;
+  try {
+    server = await startCallbackServer();
+  } catch {
+  }
+  const { oauthUrl } = await params.api.startCliGitHubOAuth(params.userToken, {
+    organizationId: params.organizationId,
+    callbackPort: server?.port
+  });
+  p.log.info("Opening GitHub to authorize your account...");
+  p.note("Complete authorization in your browser.");
+  if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
+    const shouldOpen = params.yes ? true : await p.confirm({ message: "Open in your browser?" });
+    if (p.isCancel(shouldOpen)) {
+      server?.close();
+      return null;
+    }
+    if (shouldOpen) {
+      const opened = await tryOpenBrowser(oauthUrl);
+      if (!opened) {
+        p.log.info(`Could not open browser automatically. Visit: ${oauthUrl}`);
+      }
+    }
+  }
+  const oauthSpinner = p.spinner();
+  oauthSpinner.start("Waiting for GitHub authorization...");
+  if (server) {
+    try {
+      const timeoutMs = 10 * 60 * 1e3;
+      const callbackParams = await Promise.race([
+        server.waitForCallback(),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), timeoutMs))
+      ]);
+      server.close();
+      if (!callbackParams) {
+        oauthSpinner.stop("GitHub authorization timed out");
+        return null;
+      }
+      if (callbackParams.error) {
+        oauthSpinner.stop("GitHub authorization failed");
+        p.log.error(callbackParams.error);
+        return null;
+      }
+    } catch {
+      server.close();
+      oauthSpinner.stop("GitHub authorization failed");
+      return null;
+    }
+  }
+  oauthSpinner.stop("GitHub account authorized");
+  const discoveryResult = await params.api.getCliGitHubDiscovery(params.userToken);
+  return discoveryResult.installations;
+}
+async function selectGitHubInstallation(installations, canInstallNew) {
+  const options = installations.map((inst) => ({
+    value: String(inst.installationId),
+    label: inst.accountLogin,
+    hint: [
+      inst.accountType === "Organization" ? "organization" : "personal",
+      inst.conflictLabel ? `connected to ${inst.conflictLabel}` : "",
+      inst.isSuspended ? "suspended" : ""
+    ].filter(Boolean).join(" \xB7 ") || void 0
+  }));
+  if (canInstallNew) {
+    options.push({ value: "install_new", label: "Install on a new account" });
+  }
+  const selected = await p.select({
+    message: "Select a GitHub installation",
+    options
+  });
+  if (p.isCancel(selected)) return null;
+  if (selected === "install_new") return "install_new";
+  return Number(selected);
+}
 // src/utils/api.ts
 function isLimitErrorResponse(value) {
@@ -255,6 +564,245 @@ var VocoderAPI = class {
     }
     return payload;
   }
+  // ── CLI Auth endpoints (no project API key needed) ──────────────────────────
+  /**
+   * Start a CLI auth session. Returns `{ sessionId, verificationUrl, expiresAt }`.
+   * `sessionId` is the raw poll token — keep it secret, used for polling.
+   */
+  async startCliAuthSession(callbackPort, repoCanonical) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...callbackPort != null ? { callbackPort } : {},
+        ...repoCanonical ? { repoCanonical } : {}
+      })
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start auth session (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Poll for CLI auth session completion.
+   * Returns `{ token }` on success, throws on failure/expiry.
+   * The server returns HTTP 202 while still pending.
+   */
+  async pollCliAuthSession(pollToken) {
+    const response = await fetch(
+      `${this.apiUrl}/api/cli/auth/session?session=${encodeURIComponent(pollToken)}`
+    );
+    const payload = await readPayload(response);
+    if (response.status === 202) {
+      return { status: "pending" };
+    }
+    if (response.status === 410) {
+      return {
+        status: "failed",
+        reason: extractErrorMessage(payload, "Auth session expired or failed")
+      };
+    }
+    if (!response.ok) {
+      return {
+        status: "failed",
+        reason: extractErrorMessage(payload, `Auth session error (${response.status})`)
+      };
+    }
+    const result = payload;
+    if (!result.token) {
+      return { status: "failed", reason: "No token in response" };
+    }
+    return {
+      status: "complete",
+      token: result.token,
+      ...result.organizationId ? { organizationId: result.organizationId } : {}
+    };
+  }
+  /**
+   * Validate a CLI user token and return the authenticated user's info.
+   * Used by the CLI to verify stored credentials on startup.
+   */
+  async getCliUserInfo(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/me`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Token validation failed (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Revoke the given CLI user token server-side.
+   */
+  async revokeCliToken(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/auth/token`, {
+      method: "DELETE",
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    if (!response.ok) {
+      const payload = await readPayload(response);
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Token revocation failed (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+  }
+  // ── Workspaces ────────────────────────────────────────────────────────────────
+  async listWorkspaces(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/workspaces`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to list workspaces (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── CLI GitHub endpoints ──────────────────────────────────────────────────────
+  async startCliGitHubInstall(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/install/start`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start GitHub install (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  /**
+   * Start the "link existing installation" discovery flow.
+   * Unlike startCliGitHubOAuth, this requires no bearer token — the Vocoder
+   * account is created from the OAuth code in the callback.
+   */
+  async startCliGitHubLinkSession(sessionId, callbackPort) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/oauth/link-start`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ sessionId, ...callbackPort != null ? { callbackPort } : {} })
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start GitHub link session (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async startCliGitHubOAuth(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/oauth/start`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to start GitHub OAuth (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async getCliGitHubDiscovery(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/discovery`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to fetch GitHub discovery (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  async claimCliGitHubInstallation(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/github/claim`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${userToken}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to claim GitHub installation (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── Locales ───────────────────────────────────────────────────────────────────
+  async listLocales(userToken) {
+    const response = await fetch(`${this.apiUrl}/api/cli/locales`, {
+      headers: { Authorization: `Bearer ${userToken}` }
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to list locales (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    const result = payload;
+    return result.locales;
+  }
+  // ── Project creation ──────────────────────────────────────────────────────────
+  async createProject(userToken, params) {
+    const response = await fetch(`${this.apiUrl}/api/cli/projects`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${userToken}`
+      },
+      body: JSON.stringify(params)
+    });
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new VocoderAPIError({
+        message: extractErrorMessage(payload, `Failed to create project (${response.status})`),
+        status: response.status,
+        payload
+      });
+    }
+    return payload;
+  }
+  // ── Project lookup ────────────────────────────────────────────────────────────
   /**
    * Look up whether a project already exists for a given repo + scope.
    * Returns { projectId, projectName, organizationName } or null if not found.
@@ -278,271 +826,10 @@ var VocoderAPI = class {
   }
 };
-// src/utils/detect-local.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-function detectLocalEcosystem(cwd = process.cwd()) {
-  const packageManager = detectPackageManager(cwd);
-  const pkg = readPackageJson(cwd);
-  if (!pkg) {
-    return {
-      ecosystem: null,
-      framework: null,
-      packageManager,
-      uiPackage: null,
-      hasUnplugin: false,
-      hasUiPackage: false,
-      sourceLocale: null
-    };
-  }
-  const allDeps = {
-    ...pkg.dependencies ?? {},
-    ...pkg.devDependencies ?? {}
-  };
-  const hasUnplugin = "@vocoder/unplugin" in allDeps;
-  const { ecosystem, framework, uiPackage } = detectFromDeps(allDeps, cwd);
-  const hasUiPackage = uiPackage !== null && uiPackage in allDeps;
-  return {
-    ecosystem,
-    framework,
-    packageManager,
-    uiPackage,
-    hasUnplugin,
-    hasUiPackage,
-    sourceLocale: null
-  };
-}
-function detectPackageManager(cwd) {
-  if (existsSync(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) return "bun";
-  if (existsSync(join(cwd, "yarn.lock"))) return "yarn";
-  return "npm";
-}
-function readPackageJson(cwd) {
-  const pkgPath = join(cwd, "package.json");
-  if (!existsSync(pkgPath)) return null;
-  try {
-    return JSON.parse(readFileSync(pkgPath, "utf-8"));
-  } catch {
-    return null;
-  }
-}
-function detectFromDeps(allDeps, cwd) {
-  if ("vue" in allDeps) {
-    const framework = "nuxt" in allDeps ? "nuxt" : null;
-    return { ecosystem: "vue", framework, uiPackage: "@vocoder/vue" };
-  }
-  if ("svelte" in allDeps) {
-    const framework = "@sveltejs/kit" in allDeps ? "sveltekit" : null;
-    return { ecosystem: "svelte", framework, uiPackage: "@vocoder/svelte" };
-  }
-  if ("@angular/core" in allDeps || existsSync(join(cwd, "angular.json"))) {
-    return { ecosystem: "angular", framework: "angular", uiPackage: "@vocoder/angular" };
-  }
-  if ("react" in allDeps) {
-    let framework = null;
-    if ("next" in allDeps) framework = "nextjs";
-    else if ("@remix-run/react" in allDeps) framework = "remix";
-    else if ("gatsby" in allDeps) framework = "gatsby";
-    else if ("vite" in allDeps) framework = "vite";
-    return { ecosystem: "react", framework, uiPackage: "@vocoder/react" };
-  }
-  return { ecosystem: null, framework: null, uiPackage: null };
-}
-function buildInstallCommand(packageManager, packages) {
-  if (packages.length === 0) return "";
-  const pkgList = packages.join(" ");
-  switch (packageManager) {
-    case "pnpm":
-      return `pnpm add ${pkgList}`;
-    case "yarn":
-      return `yarn add ${pkgList}`;
-    case "bun":
-      return `bun add ${pkgList}`;
-    default:
-      return `npm install ${pkgList}`;
-  }
-}
-function getPackagesToInstall(detection) {
-  const packages = [];
-  if (!detection.hasUnplugin) packages.push("@vocoder/unplugin");
-  if (detection.uiPackage && !detection.hasUiPackage) packages.push(detection.uiPackage);
-  return packages;
-}
-// src/utils/setup-snippets.ts
-function getSetupSnippets(params) {
-  const { framework, ecosystem, sourceLocale, translationTriggers } = params;
-  return {
-    pluginStep: getPluginSnippet(framework, ecosystem),
-    providerStep: getProviderSnippet(ecosystem, sourceLocale),
-    wrapStep: getWrapSnippet(ecosystem),
-    whatsNext: getWhatsNextMessage(translationTriggers)
-  };
-}
-function getPluginSnippet(framework, ecosystem) {
-  switch (framework) {
-    case "nextjs":
-      return {
-        file: "next.config.ts",
-        code: `import { withVocoder } from '@vocoder/unplugin/next';
-export default withVocoder({
-  // your existing Next.js config
-});`
-      };
-    case "vite":
-    case "remix":
-      return {
-        file: "vite.config.ts",
-        code: `import vocoder from '@vocoder/unplugin/vite';
-export default defineConfig({
-  plugins: [
-    vocoder(),
-    // your other plugins
-  ],
-});`
-      };
-    case "nuxt":
-      return {
-        file: "nuxt.config.ts",
-        code: `import vocoder from '@vocoder/unplugin/vite';
-export default defineNuxtConfig({
-  vite: {
-    plugins: [vocoder()],
-  },
-});`
-      };
-    case "sveltekit":
-      return {
-        file: "vite.config.ts",
-        code: `import vocoder from '@vocoder/unplugin/vite';
-import { sveltekit } from '@sveltejs/kit/vite';
-export default defineConfig({
-  plugins: [
-    sveltekit(),
-    vocoder(),
-  ],
-});`
-      };
-    case "gatsby":
-      return {
-        file: "gatsby-node.js",
-        code: `const vocoder = require('@vocoder/unplugin/webpack');
-exports.onCreateWebpackConfig = ({ actions }) => {
-  actions.setWebpackConfig({
-    plugins: [vocoder()],
-  });
-};`
-      };
-    case "angular":
-      return null;
-    // Angular CLI doesn't expose plugin config easily
-    default:
-      if (ecosystem) {
-        return {
-          file: "your bundler config",
-          code: `// Vite
-import vocoder from '@vocoder/unplugin/vite';
-// Webpack
-const vocoder = require('@vocoder/unplugin/webpack');
-// Add vocoder() to your plugins array`
-        };
-      }
-      return null;
-  }
-}
-function getProviderSnippet(ecosystem, sourceLocale) {
-  switch (ecosystem) {
-    case "react":
-      return {
-        file: "your root layout or App component",
-        code: `import { VocoderProvider } from '@vocoder/react';
-<VocoderProvider defaultLocale="${sourceLocale}">
-  {children}
-</VocoderProvider>`
-      };
-    case "vue":
-      return {
-        file: "your app entry",
-        code: `import { createVocoder } from '@vocoder/vue';
-const vocoder = createVocoder({
-  defaultLocale: '${sourceLocale}',
-});
-app.use(vocoder);`
-      };
-    case "svelte":
-      return {
-        file: "your root layout",
-        code: `<script>
-  import { VocoderProvider } from '@vocoder/svelte';
-</script>
-<VocoderProvider defaultLocale="${sourceLocale}">
-  <slot />
-</VocoderProvider>`
-      };
-    default:
-      return null;
-  }
-}
-function getWrapSnippet(ecosystem) {
-  switch (ecosystem) {
-    case "react":
-      return {
-        code: `import { T } from '@vocoder/react';
-<T>Hello, world!</T>`
-      };
-    case "vue":
-      return {
-        code: `<template>
-  <T>Hello, world!</T>
-</template>
-<script setup>
-import { T } from '@vocoder/vue';
-</script>`
-      };
-    case "svelte":
-      return {
-        code: `<script>
-  import { T } from '@vocoder/svelte';
-</script>
-<T>Hello, world!</T>`
-      };
-    default:
-      return {
-        code: `// Wrap translatable strings with <T>
-<T>Hello, world!</T>`
-      };
-  }
-}
-function getWhatsNextMessage(triggers) {
-  const parts = [];
-  if (triggers.includes("push")) {
-    parts.push("Push to a target branch to trigger translations.");
-  }
-  if (triggers.includes("pull_request")) {
-    parts.push("Open a pull request to trigger translations.");
-  }
-  if (triggers.includes("manual")) {
-    parts.push("Run `vocoder sync` to extract and translate.");
-  }
-  if (parts.length === 0) {
-    parts.push("Push to a target branch to trigger translations.");
-  }
-  return parts.join("\n");
-}
+// src/commands/init.ts
+import chalk6 from "chalk";
+import { execSync as execSync3 } from "child_process";
+import { config as loadEnv } from "dotenv";
 // src/utils/git-identity.ts
 import { execSync } from "child_process";
@@ -580,81 +867,623 @@ function parseRemoteUrl(remoteUrl) {
       }
       return { host, ownerRepoPath };
     }
-    return null;
+    return null;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    const host = parsed.hostname.toLowerCase();
+    const ownerRepoPath = normalizePath(decodeURIComponent(parsed.pathname));
+    if (!host || !ownerRepoPath) {
+      return null;
+    }
+    return { host, ownerRepoPath };
+  } catch {
+    return null;
+  }
+}
+function toCanonical(host, ownerRepoPath) {
+  if (host.includes("github.com")) {
+    return `github:${ownerRepoPath.toLowerCase()}`;
+  }
+  if (host.includes("gitlab.com")) {
+    return `gitlab:${ownerRepoPath.toLowerCase()}`;
+  }
+  if (host.includes("bitbucket.org")) {
+    return `bitbucket:${ownerRepoPath.toLowerCase()}`;
+  }
+  return `git:${host}/${ownerRepoPath.toLowerCase()}`;
+}
+function resolveGitRepositoryIdentity() {
+  const remoteUrl = safeExec("git config --get remote.origin.url");
+  if (!remoteUrl) {
+    return null;
+  }
+  const parsed = parseRemoteUrl(remoteUrl);
+  if (!parsed) {
+    return null;
+  }
+  const repositoryRoot = safeExec("git rev-parse --show-toplevel");
+  const currentDirectory = process.cwd();
+  let repoScopePath = "";
+  if (repositoryRoot) {
+    const relativePath = relative(resolve(repositoryRoot), resolve(currentDirectory)).replace(/\\/g, "/").trim();
+    if (relativePath && relativePath !== "." && !relativePath.startsWith("..")) {
+      repoScopePath = relativePath;
+    }
+  }
+  return {
+    repoCanonical: toCanonical(parsed.host, parsed.ownerRepoPath),
+    repoScopePath
+  };
+}
+function resolveGitContext() {
+  const warnings = [];
+  const identity = resolveGitRepositoryIdentity();
+  if (!identity) {
+    warnings.push(
+      "Could not detect git remote origin. Repo binding will be skipped until sync can detect it."
+    );
+  }
+  return { identity, warnings };
+}
+// src/utils/project-create.ts
+import * as p3 from "@clack/prompts";
+import chalk4 from "chalk";
+// src/utils/locale-search.ts
+import { Prompt, isCancel as isCancel2 } from "@clack/core";
+import * as p2 from "@clack/prompts";
+import chalk2 from "chalk";
+var S_BAR = "\u2502";
+var S_BAR_END = "\u2514";
+var S_ACTIVE = "\u25C6";
+var S_SUBMIT = "\u25C6";
+var S_CANCEL = "\u25A0";
+var S_ERROR = "\u25B2";
+var noColor = process.env.NO_COLOR === "1" || process.env.FORCE_COLOR === "0";
+var dim = (s) => noColor ? s : chalk2.gray(s);
+var cyan = (s) => noColor ? s : chalk2.cyan(s);
+var grn = (s) => noColor ? s : chalk2.green(s);
+var ylw = (s) => noColor ? s : chalk2.yellow(s);
+var red = (s) => noColor ? s : chalk2.red(s);
+var bld = (s) => noColor ? s : chalk2.bold(s);
+function symbol(state) {
+  switch (state) {
+    case "submit":
+      return grn(S_SUBMIT);
+    case "cancel":
+      return red(S_CANCEL);
+    case "error":
+      return ylw(S_ERROR);
+    default:
+      return cyan(S_ACTIVE);
+  }
+}
+var MAX_VISIBLE = 12;
+function filterLocales(options, query) {
+  if (!query.trim()) return options;
+  const lower = query.toLowerCase();
+  return options.filter(
+    (o) => o.bcp47.toLowerCase().includes(lower) || o.label.toLowerCase().includes(lower)
+  );
+}
+function buildList(filtered, cursor, scrollOffset, selected) {
+  const isMulti = selected !== null;
+  const end = Math.min(filtered.length, scrollOffset + MAX_VISIBLE);
+  const visibleLines = [];
+  for (let i = scrollOffset; i < end; i++) {
+    const opt = filtered[i];
+    const isCursor = i === cursor;
+    const isChecked = isMulti && selected.has(opt.bcp47);
+    const icon = isMulti ? isChecked ? isCursor ? grn("\u25FC") : "\u25FC" : isCursor ? grn("\u25FB") : dim("\u25FB") : isCursor ? grn("\u25CF") : dim("\u25CB");
+    visibleLines.push(`${cyan(S_BAR)}  ${icon}  ${isCursor ? bld(opt.label) : opt.label}`);
+  }
+  const hidden = filtered.length - (end - scrollOffset);
+  if (hidden > 0) visibleLines.push(dim(`${S_BAR}  ${hidden} more \u2014 keep typing to narrow`));
+  if (filtered.length === 0) visibleLines.push(dim(`${S_BAR}  No matches`));
+  if (isMulti && selected.size > 0) {
+    visibleLines.push(dim(`${S_BAR}  ${selected.size} selected \u2014 Enter to confirm`));
+  }
+  return visibleLines.join("\n");
+}
+async function runFilterablePrompt(opts) {
+  const { message, options, multi } = opts;
+  let filter = "";
+  let cursor = 0;
+  let scrollOffset = 0;
+  const selected = new Set(multi ? opts.initialValues ?? [] : []);
+  if (!multi && opts.initialValue) {
+    const idx = options.findIndex((o) => o.bcp47 === opts.initialValue);
+    if (idx >= 0) cursor = idx;
+  }
+  const getFiltered = () => filterLocales(options, filter);
+  const clampCursor = (filtered) => {
+    if (cursor >= filtered.length) cursor = Math.max(0, filtered.length - 1);
+    if (cursor < scrollOffset) scrollOffset = cursor;
+    if (cursor >= scrollOffset + MAX_VISIBLE) scrollOffset = cursor - MAX_VISIBLE + 1;
+    if (scrollOffset < 0) scrollOffset = 0;
+  };
+  const prompt = new Prompt(
+    {
+      initialValue: !multi ? options[cursor]?.bcp47 ?? null : null,
+      validate() {
+        const f = getFiltered();
+        if (multi && selected.size === 0) return "At least one target language is required.";
+        if (!multi && !f[cursor]) return "Please select a language.";
+        return void 0;
+      },
+      render() {
+        const filtered = getFiltered();
+        clampCursor(filtered);
+        const hdr = `${dim(S_BAR)}
+${symbol(this.state)}  ${message}
+`;
+        const hint = filter.length > 0 ? filter : dim("type to filter, \u2191\u2193 navigate" + (multi ? ", space select" : ""));
+        switch (this.state) {
+          case "submit": {
+            const val = multi ? Array.from(selected).map((id) => options.find((o) => o.bcp47 === id)?.label ?? id).join(", ") : options.find((o) => o.bcp47 === this.value)?.label ?? "";
+            return `${hdr}${dim(S_BAR)}  ${bld(val || dim("none"))}`;
+          }
+          case "cancel":
+            return `${hdr}${dim(S_BAR)}`;
+          case "error":
+            return [
+              hdr.trimEnd(),
+              `${ylw(S_BAR)}  ${dim("/")} ${hint}`,
+              buildList(filtered, cursor, scrollOffset, multi ? selected : null),
+              `${ylw(S_BAR_END)}  ${ylw(this.error)}`,
+              ""
+            ].join("\n");
+          default:
+            return [
+              hdr.trimEnd(),
+              `${cyan(S_BAR)}  ${dim("/")} ${hint}`,
+              buildList(filtered, cursor, scrollOffset, multi ? selected : null),
+              `${cyan(S_BAR_END)}`,
+              ""
+            ].join("\n");
+        }
+      }
+    },
+    false
+    // trackValue=false — we manage value manually
+  );
+  prompt.on("key", (key) => {
+    if (!key || key === " ") return;
+    const cp = key.codePointAt(0) ?? 0;
+    if (cp === 127 || cp === 8) {
+      filter = filter.slice(0, -1);
+      cursor = 0;
+      scrollOffset = 0;
+    } else if (cp >= 32 && cp !== 127) {
+      filter += key;
+      cursor = 0;
+      scrollOffset = 0;
+    }
+  });
+  prompt.on("cursor", (action) => {
+    const filtered = getFiltered();
+    switch (action) {
+      case "up":
+        cursor = Math.max(0, cursor - 1);
+        break;
+      case "down":
+        cursor = Math.min(Math.max(filtered.length - 1, 0), cursor + 1);
+        break;
+      case "space":
+        if (multi) {
+          const opt = filtered[cursor];
+          if (opt) {
+            if (selected.has(opt.bcp47)) selected.delete(opt.bcp47);
+            else selected.add(opt.bcp47);
+          }
+        }
+        break;
+    }
+    if (!multi) {
+      const opt = getFiltered()[cursor];
+      prompt.value = opt?.bcp47 ?? null;
+    }
+  });
+  prompt.on("finalize", () => {
+    if (prompt.state === "submit") {
+      if (multi) {
+        prompt.value = Array.from(selected);
+      } else {
+        const f = getFiltered();
+        prompt.value = f[cursor]?.bcp47 ?? null;
+      }
+    }
+  });
+  const result = await prompt.prompt();
+  if (isCancel2(result)) return null;
+  return result;
+}
+async function searchSelectLocale(options, message, initialValue) {
+  const result = await runFilterablePrompt({ message, options, multi: false, initialValue });
+  return typeof result === "string" ? result : null;
+}
+async function searchMultiSelectLocales(options, message, initialValues) {
+  const result = await runFilterablePrompt({ message, options, multi: true, initialValues });
+  if (result === null) return null;
+  const picks = result;
+  if (picks.length === 0) {
+    p2.log.warn("At least one target language is required. Please select at least one.");
+    return searchMultiSelectLocales(options, message, initialValues);
+  }
+  return picks;
+}
+// src/utils/branch-select.ts
+import { Prompt as Prompt2, isCancel as isCancel3 } from "@clack/core";
+import chalk3 from "chalk";
+import { execSync as execSync2 } from "child_process";
+var S_BAR2 = "\u2502";
+var S_BAR_END2 = "\u2514";
+var S_ACTIVE2 = "\u25C6";
+var S_SUBMIT2 = "\u25C6";
+var S_CANCEL2 = "\u25A0";
+var S_ERROR2 = "\u25B2";
+var noColor2 = process.env.NO_COLOR === "1" || process.env.FORCE_COLOR === "0";
+var dim2 = (s) => noColor2 ? s : chalk3.gray(s);
+var cyan2 = (s) => noColor2 ? s : chalk3.cyan(s);
+var grn2 = (s) => noColor2 ? s : chalk3.green(s);
+var ylw2 = (s) => noColor2 ? s : chalk3.yellow(s);
+var red2 = (s) => noColor2 ? s : chalk3.red(s);
+var bld2 = (s) => noColor2 ? s : chalk3.bold(s);
+function symbol2(state) {
+  switch (state) {
+    case "submit":
+      return grn2(S_SUBMIT2);
+    case "cancel":
+      return red2(S_CANCEL2);
+    case "error":
+      return ylw2(S_ERROR2);
+    default:
+      return cyan2(S_ACTIVE2);
+  }
+}
+function detectGitBranches(cwd) {
+  const workDir = cwd ?? process.cwd();
+  try {
+    const localOut = execSync2("git branch", { cwd: workDir, stdio: "pipe" }).toString();
+    const localBranches = localOut.split("\n").filter(Boolean).map((b) => b.replace(/^\*?\s*/, "").trim()).filter(Boolean);
+    let remoteBranches = [];
+    try {
+      const remoteOut = execSync2("git branch -r", { cwd: workDir, stdio: "pipe" }).toString();
+      remoteBranches = remoteOut.split("\n").map((b) => b.trim()).filter((b) => b && !b.includes("HEAD")).map((b) => b.replace(/^[^/]+\//, ""));
+    } catch {
+    }
+    const branches = [.../* @__PURE__ */ new Set([...localBranches, ...remoteBranches])].sort();
+    let defaultBranch = "main";
+    try {
+      const ref = execSync2("git symbolic-ref refs/remotes/origin/HEAD", { cwd: workDir, stdio: "pipe" }).toString().trim();
+      defaultBranch = ref.split("/").pop() ?? "main";
+    } catch {
+    }
+    return {
+      branches: branches.length > 0 ? branches : [defaultBranch],
+      defaultBranch
+    };
+  } catch {
+    return { branches: ["main"], defaultBranch: "main" };
+  }
+}
+var INVALID_CHARS = /[\s?^~:[\]\\]/;
+function validateBranchPattern(pattern) {
+  const t = pattern.trim();
+  if (!t) return "Pattern cannot be empty";
+  if (INVALID_CHARS.test(t)) return "Invalid characters \u2014 avoid spaces, ?, ^, ~, :, [, ], \\";
+  if (t.startsWith("/") || t.endsWith("/")) return "Cannot start or end with /";
+  if (t.includes("//")) return "Cannot contain //";
+  return null;
+}
+var MAX_VISIBLE2 = 10;
+function buildItems(branches, defaultBranch, customPatterns) {
+  const items = branches.map((b) => ({
+    value: b,
+    label: b === defaultBranch ? `${b} (default branch)` : b
+  }));
+  for (const pt of customPatterns) {
+    if (!branches.includes(pt)) {
+      items.push({ value: pt, label: pt, isCustom: true });
+    }
+  }
+  return items;
+}
+function filterItems(items, query) {
+  if (!query.trim()) return items;
+  const lower = query.toLowerCase();
+  return items.filter((i) => i.value.toLowerCase().includes(lower));
+}
+function buildList2(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor) {
+  const lines = [];
+  const end = Math.min(filtered.length, scrollOffset + MAX_VISIBLE2);
+  for (let i = scrollOffset; i < end; i++) {
+    const item = filtered[i];
+    const isCursor = i === cursor && !addCursor;
+    const isChecked = selected.has(item.value);
+    const icon = isChecked ? isCursor ? grn2("\u25FC") : "\u25FC" : isCursor ? grn2("\u25FB") : dim2("\u25FB");
+    let label = item.isCustom ? `${item.label} ${dim2("(custom)")}` : item.label;
+    if (isCursor) label = bld2(label);
+    lines.push(`${cyan2(S_BAR2)}  ${icon}  ${label}`);
+  }
+  const trimmed = filter.trim();
+  const allItems = [...filtered];
+  const isNewPattern = trimmed.length > 0 && !allItems.some((i) => i.value === trimmed) && !customPatterns.includes(trimmed);
+  if (isNewPattern) {
+    const err = validateBranchPattern(trimmed);
+    const icon = addCursor ? grn2("\u25FB") : dim2("\u25FB");
+    const label = err ? `${ylw2("+")}  ${dim2(`"${trimmed}" \u2014 ${err}`)}` : `${grn2("+")}  Add "${trimmed}" as branch pattern`;
+    lines.push(`${cyan2(S_BAR2)}  ${icon}  ${label}`);
+  } else if (filtered.length === 0 && trimmed.length === 0) {
+    lines.push(dim2(`${S_BAR2}  No branches detected`));
+  }
+  const hidden = filtered.length - (end - scrollOffset);
+  if (hidden > 0) lines.push(dim2(`${S_BAR2}  ${hidden} more`));
+  if (selected.size > 0) lines.push(dim2(`${S_BAR2}  ${selected.size} selected \u2014 Enter to confirm`));
+  return lines.join("\n");
+}
+async function filterableBranchSelect(params) {
+  const { message, branches, defaultBranch } = params;
+  let filter = "";
+  let cursor = 0;
+  let scrollOffset = 0;
+  let addCursor = false;
+  const customPatterns = [];
+  const selected = new Set(params.initialValues ?? [defaultBranch]);
+  const getItems = () => buildItems(branches, defaultBranch, customPatterns);
+  const getFiltered = () => filterItems(getItems(), filter);
+  const isNewPattern = () => {
+    const t = filter.trim();
+    if (!t) return false;
+    return !getItems().some((i) => i.value === t) && !customPatterns.includes(t);
+  };
+  const clampCursor = (filtered) => {
+    const hasAdd = isNewPattern();
+    const max = filtered.length - 1 + (hasAdd ? 1 : 0);
+    if (cursor > max && !addCursor) cursor = Math.max(0, max);
+    if (!addCursor) {
+      if (cursor < scrollOffset) scrollOffset = cursor;
+      if (cursor >= scrollOffset + MAX_VISIBLE2) scrollOffset = cursor - MAX_VISIBLE2 + 1;
+      if (scrollOffset < 0) scrollOffset = 0;
+    }
+  };
+  const prompt = new Prompt2(
+    {
+      validate() {
+        if (selected.size === 0) return "At least one branch is required.";
+        return void 0;
+      },
+      render() {
+        const filtered = getFiltered();
+        clampCursor(filtered);
+        const hdr = `${dim2(S_BAR2)}
+${symbol2(this.state)}  ${message}
+`;
+        const hint = filter.length > 0 ? filter : dim2("type to filter or add pattern, \u2191\u2193 navigate, space select");
+        switch (this.state) {
+          case "submit": {
+            const summary = selected.size > 0 ? bld2(Array.from(selected).join(", ")) : dim2("none");
+            return `${hdr}${dim2(S_BAR2)}  ${summary}`;
+          }
+          case "cancel":
+            return `${hdr}${dim2(S_BAR2)}`;
+          case "error":
+            return [
+              hdr.trimEnd(),
+              `${ylw2(S_BAR2)}  ${dim2("/")} ${hint}`,
+              buildList2(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor),
+              `${ylw2(S_BAR_END2)}  ${ylw2(this.error)}`,
+              ""
+            ].join("\n");
+          default:
+            return [
+              hdr.trimEnd(),
+              `${cyan2(S_BAR2)}  ${dim2("/")} ${hint}`,
+              buildList2(filtered, cursor, scrollOffset, selected, filter, customPatterns, addCursor),
+              `${cyan2(S_BAR_END2)}`,
+              ""
+            ].join("\n");
+        }
+      }
+    },
+    false
+  );
+  prompt.on("key", (key) => {
+    if (!key || key === " ") return;
+    const cp = key.codePointAt(0) ?? 0;
+    if (cp === 127 || cp === 8) {
+      filter = filter.slice(0, -1);
+      cursor = 0;
+      scrollOffset = 0;
+      addCursor = false;
+    } else if (cp >= 32 && cp !== 127) {
+      filter += key;
+      cursor = 0;
+      scrollOffset = 0;
+      addCursor = false;
+    }
+  });
+  prompt.on("cursor", (action) => {
+    const filtered = getFiltered();
+    const hasAdd = isNewPattern();
+    switch (action) {
+      case "up":
+        if (addCursor) {
+          addCursor = false;
+          cursor = Math.max(0, filtered.length - 1);
+        } else cursor = Math.max(0, cursor - 1);
+        break;
+      case "down":
+        if (!addCursor && cursor >= filtered.length - 1 && hasAdd) addCursor = true;
+        else if (!addCursor) cursor = Math.min(filtered.length - 1, cursor + 1);
+        break;
+      case "space":
+        if (addCursor) {
+          const t = filter.trim();
+          const err = validateBranchPattern(t);
+          if (!err) {
+            customPatterns.push(t);
+            selected.add(t);
+            filter = "";
+            cursor = 0;
+            scrollOffset = 0;
+            addCursor = false;
+          }
+        } else {
+          const item = filtered[cursor];
+          if (item) {
+            if (selected.has(item.value)) selected.delete(item.value);
+            else selected.add(item.value);
+          }
+        }
+        break;
+    }
+  });
+  prompt.on("finalize", () => {
+    if (prompt.state === "submit") {
+      prompt.value = Array.from(selected);
+    }
+  });
+  const result = await prompt.prompt();
+  if (isCancel3(result)) return null;
+  return result;
+}
+// src/utils/project-create.ts
+function buildLocaleOptions(locales) {
+  return locales.map((l) => ({
+    bcp47: l.code,
+    label: `${l.name} \u2014 ${l.code}`
+  }));
+}
+function buildLanguageOptions(locales) {
+  const byFamily = /* @__PURE__ */ new Map();
+  for (const l of locales) {
+    const family = l.code.split("-")[0].toLowerCase();
+    const opt = { bcp47: l.code, label: `${l.name} \u2014 ${l.code}` };
+    const existing = byFamily.get(family);
+    if (!existing || l.code.length < existing.bcp47.length) {
+      byFamily.set(family, opt);
+    }
   }
+  return Array.from(byFamily.values());
+}
+async function runProjectCreate(params) {
+  const { api, userToken, organizationId, repoCanonical } = params;
+  const projectName = (params.defaultName ?? "my-project").trim();
+  p3.log.success(`Project: ${chalk4.bold(projectName)}`);
+  let rawLocales;
   try {
-    const parsed = new URL(trimmed);
-    const host = parsed.hostname.toLowerCase();
-    const ownerRepoPath = normalizePath(decodeURIComponent(parsed.pathname));
-    if (!host || !ownerRepoPath) {
-      return null;
-    }
-    return { host, ownerRepoPath };
+    rawLocales = await api.listLocales(userToken);
   } catch {
+    p3.log.error("Failed to fetch supported locales. Check your connection and try again.");
     return null;
   }
-}
-function toCanonical(host, ownerRepoPath) {
-  if (host.includes("github.com")) {
-    return `github:${ownerRepoPath.toLowerCase()}`;
-  }
-  if (host.includes("gitlab.com")) {
-    return `gitlab:${ownerRepoPath.toLowerCase()}`;
-  }
-  if (host.includes("bitbucket.org")) {
-    return `bitbucket:${ownerRepoPath.toLowerCase()}`;
+  const languageOptions = buildLanguageOptions(rawLocales);
+  const localeOptions = buildLocaleOptions(rawLocales);
+  const sourceLocale = await searchSelectLocale(
+    languageOptions,
+    "Source language (the language your code is written in)",
+    params.defaultSourceLocale ?? "en"
+  );
+  if (sourceLocale === null) return null;
+  const targetOptions = localeOptions.filter((opt) => opt.bcp47 !== sourceLocale);
+  const targetLocales = await searchMultiSelectLocales(
+    targetOptions,
+    "Target languages (languages to translate into)"
+  );
+  if (targetLocales === null) return null;
+  if (targetLocales.length === 0) {
+    p3.log.warn("No target languages selected \u2014 you can add them later from the dashboard.");
+  }
+  const detected = detectGitBranches();
+  const initialBranches = params.defaultBranches?.length ? params.defaultBranches : [detected.defaultBranch];
+  let targetBranches = [];
+  {
+    let initial = initialBranches;
+    while (targetBranches.length === 0) {
+      const result = await filterableBranchSelect({
+        message: "Target branches (translations will run when you push to these)",
+        branches: detected.branches,
+        defaultBranch: detected.defaultBranch,
+        initialValues: initial
+      });
+      if (result === null) return null;
+      if (result.length === 0) {
+        p3.log.warn("At least one branch is required. Please select at least one.");
+        initial = [detected.defaultBranch];
+      } else {
+        targetBranches = result;
+      }
+    }
   }
-  return `git:${host}/${ownerRepoPath.toLowerCase()}`;
-}
-function resolveGitRepositoryIdentity() {
-  const remoteUrl = safeExec("git config --get remote.origin.url");
-  if (!remoteUrl) {
+  try {
+    const result = await api.createProject(userToken, {
+      organizationId,
+      name: projectName,
+      sourceLocale,
+      targetLocales,
+      targetBranches,
+      translationTriggers: ["push"],
+      scopePaths: [],
+      repoCanonical
+    });
+    p3.log.success(`Project ${chalk4.bold(result.projectName)} created!`);
+    return result;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    p3.log.error(`Failed to create project: ${message}`);
     return null;
   }
-  const parsed = parseRemoteUrl(remoteUrl);
-  if (!parsed) {
-    return null;
+}
+// src/utils/workspace.ts
+import * as p4 from "@clack/prompts";
+import chalk5 from "chalk";
+async function selectWorkspace(result) {
+  const { workspaces, canCreateWorkspace } = result;
+  if (workspaces.length === 0) {
+    return { action: "create" };
+  }
+  const options = workspaces.map((ws) => ({
+    value: ws.id,
+    label: ws.name,
+    hint: [
+      ws.projectCount > 0 ? `${ws.projectCount} project${ws.projectCount !== 1 ? "s" : ""}` : "",
+      ws.connectionLabel ? `GitHub: ${ws.connectionLabel}` : ""
+    ].filter(Boolean).join(" \xB7 ") || void 0
+  }));
+  if (canCreateWorkspace) {
+    options.push({ value: "create", label: "Create new workspace" });
+  }
+  const selected = await p4.select({
+    message: "Select workspace",
+    options
+  });
+  if (p4.isCancel(selected)) {
+    return { action: "cancelled" };
   }
-  const repositoryRoot = safeExec("git rev-parse --show-toplevel");
-  const currentDirectory = process.cwd();
-  let repoScopePath = "";
-  if (repositoryRoot) {
-    const relativePath = relative(resolve(repositoryRoot), resolve(currentDirectory)).replace(/\\/g, "/").trim();
-    if (relativePath && relativePath !== "." && !relativePath.startsWith("..")) {
-      repoScopePath = relativePath;
-    }
+  if (selected === "create") {
+    return { action: "create" };
   }
-  return {
-    repoCanonical: toCanonical(parsed.host, parsed.ownerRepoPath),
-    repoScopePath
-  };
-}
-function resolveGitContext() {
-  const warnings = [];
-  const identity = resolveGitRepositoryIdentity();
-  if (!identity) {
-    warnings.push(
-      "Could not detect git remote origin. Repo binding will be skipped until sync can detect it."
-    );
+  const workspace = workspaces.find((ws) => ws.id === selected);
+  if (!workspace) {
+    return { action: "cancelled" };
   }
-  return { identity, warnings };
+  return { action: "use", workspace };
 }
 // src/commands/init.ts
-import { config as loadEnv } from "dotenv";
-import { execSync as execSync2 } from "child_process";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 loadEnv();
 var SUBSCRIPTION_SETTINGS_PATH = "/dashboard/workspace/settings?tab=subscription";
-function parseTargetLocales(value) {
-  if (!value) return void 0;
-  const locales = value.split(",").map((locale) => locale.trim()).filter(Boolean);
-  return locales.length > 0 ? locales : void 0;
-}
 async function sleep(ms) {
   await new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-async function tryOpenBrowser(url) {
+async function tryOpenBrowser2(url) {
   if (!process.stdout.isTTY || process.env.CI === "true") {
     return false;
   }
@@ -672,7 +1501,7 @@ async function tryOpenBrowser(url) {
   }
   return await new Promise((resolve2) => {
     try {
-      const child = spawn(command, args, {
+      const child = spawn2(command, args, {
         detached: true,
         stdio: "ignore",
         windowsHide: true
@@ -707,35 +1536,35 @@ function getSubscriptionSettingsUrl(apiUrl) {
   return new URL(SUBSCRIPTION_SETTINGS_PATH, apiUrl).toString();
 }
 function printPlanLimitMessage(apiUrl, message) {
-  p.log.error(`You are over your plan limits.
+  p5.log.error(`You are over your plan limits.
    ${message}`);
-  p.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
+  p5.log.info(`Manage subscription: ${getSubscriptionSettingsUrl(apiUrl)}`);
 }
 function runScaffold(params) {
   const { projectName, organizationName, sourceLocale, translationTriggers } = params;
-  p.log.info(`Project:   ${chalk.bold(projectName)}`);
-  p.log.info(`Workspace: ${chalk.bold(organizationName)}`);
+  p5.log.info(`Project:   ${chalk6.bold(projectName)}`);
+  p5.log.info(`Workspace: ${chalk6.bold(organizationName)}`);
   const detection = detectLocalEcosystem();
   if (detection.ecosystem) {
     const frameworkLabel = detection.framework ?? detection.ecosystem;
     const pmLabel = detection.packageManager;
-    p.log.info(`Detected:  ${chalk.bold(frameworkLabel)} (${pmLabel})`);
+    p5.log.info(`Detected:  ${chalk6.bold(frameworkLabel)} (${pmLabel})`);
   }
   const packagesToInstall = getPackagesToInstall(detection);
   if (packagesToInstall.length > 0) {
     const installCmd = buildInstallCommand(detection.packageManager, packagesToInstall);
-    p.log.info("");
-    const installSpinner = p.spinner();
+    p5.log.info("");
+    const installSpinner = p5.spinner();
     installSpinner.start(`Installing ${packagesToInstall.join(", ")}...`);
     try {
-      execSync2(installCmd, { stdio: "pipe", cwd: process.cwd() });
+      execSync3(installCmd, { stdio: "pipe", cwd: process.cwd() });
       installSpinner.stop(`Installed ${packagesToInstall.join(", ")}`);
     } catch {
       installSpinner.stop("Package installation failed");
-      p.log.warn(`Run manually: ${chalk.cyan(installCmd)}`);
+      p5.log.warn(`Run manually: ${chalk6.cyan(installCmd)}`);
     }
   } else if (detection.ecosystem) {
-    p.log.info(`Packages:  ${chalk.green("already installed")}`);
+    p5.log.info(`Packages:  ${chalk6.green("already installed")}`);
   }
   const snippets = getSetupSnippets({
     framework: detection.framework,
@@ -745,162 +1574,517 @@ function runScaffold(params) {
   });
   let stepNum = 1;
   if (snippets.pluginStep) {
-    p.log.message("");
-    p.log.step(`${chalk.bold(`Step ${stepNum}:`)} Add the plugin to ${chalk.cyan(snippets.pluginStep.file)}`);
+    p5.log.message("");
+    p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Add the plugin to ${chalk6.cyan(snippets.pluginStep.file)}`);
     printCodeBlock(snippets.pluginStep.code);
     stepNum++;
   }
   if (snippets.providerStep) {
-    p.log.step(`${chalk.bold(`Step ${stepNum}:`)} Add the provider to ${chalk.cyan(snippets.providerStep.file)}`);
+    p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Add the provider to ${chalk6.cyan(snippets.providerStep.file)}`);
     printCodeBlock(snippets.providerStep.code);
     stepNum++;
   }
-  p.log.step(`${chalk.bold(`Step ${stepNum}:`)} Wrap translatable strings`);
+  p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Wrap translatable strings`);
   printCodeBlock(snippets.wrapStep.code);
-  p.log.message("");
+  p5.log.message("");
   for (const line of snippets.whatsNext.split("\n")) {
-    p.log.success(line);
+    p5.log.success(line);
   }
 }
+function printMcpSetup(apiKey) {
+  const addCommand = `claude mcp add --scope project --transport stdio \\
+  --env VOCODER_API_KEY=${apiKey} \\
+  vocoder -- npx -y @vocoder/mcp`;
+  const teamConfig = JSON.stringify(
+    {
+      mcpServers: {
+        vocoder: {
+          type: "stdio",
+          command: "npx",
+          args: ["-y", "@vocoder/mcp"],
+          env: { VOCODER_API_KEY: "${env:VOCODER_API_KEY}" }
+        }
+      }
+    },
+    null,
+    2
+  );
+  p5.log.message("");
+  p5.log.message(chalk6.bold("Use Vocoder with Claude Code"));
+  p5.log.message("Run this to add the MCP server to your project:");
+  p5.log.message("");
+  printCodeBlock(addCommand);
+  p5.log.message("");
+  p5.log.message("To share with your team, commit " + chalk6.cyan(".mcp.json") + " with an env var reference");
+  p5.log.message("so each developer supplies their own key:");
+  p5.log.message("");
+  printCodeBlock(teamConfig);
+  p5.log.message("");
+  p5.log.message(chalk6.gray("Setup instructions: https://vocoder.app/docs/mcp"));
+}
 function printCodeBlock(code) {
   const lines = code.split("\n");
   const maxLen = lines.reduce((max, line) => Math.max(max, line.length), 0);
-  const bar = chalk.gray("\u2502");
+  const bar = chalk6.gray("\u2502");
   const pad = (s) => s + " ".repeat(maxLen - s.length);
-  process.stdout.write(`${chalk.gray("\u2502")}
+  process.stdout.write(`${chalk6.gray("\u2502")}
 `);
-  process.stdout.write(`${chalk.gray("\u2502")}  ${chalk.gray("\u250C" + "\u2500".repeat(maxLen + 2) + "\u2510")}
+  process.stdout.write(`${chalk6.gray("\u2502")}  ${chalk6.gray("\u250C" + "\u2500".repeat(maxLen + 2) + "\u2510")}
 `);
   for (const line of lines) {
-    process.stdout.write(`${chalk.gray("\u2502")}  ${bar} ${pad(line)} ${bar}
+    process.stdout.write(`${chalk6.gray("\u2502")}  ${bar} ${pad(line)} ${bar}
+`);
+  }
+  process.stdout.write(`${chalk6.gray("\u2502")}  ${chalk6.gray("\u2514" + "\u2500".repeat(maxLen + 2) + "\u2518")}
 `);
+}
+async function verifyStoredToken(api, token) {
+  try {
+    return await api.getCliUserInfo(token);
+  } catch {
+    clearAuthData();
+    return null;
+  }
+}
+async function runAuthFlow(api, options, reauth = false, repoCanonical) {
+  let server = null;
+  if (!options.ci) {
+    try {
+      server = await startCallbackServer();
+    } catch {
+    }
   }
-  process.stdout.write(`${chalk.gray("\u2502")}  ${chalk.gray("\u2514" + "\u2500".repeat(maxLen + 2) + "\u2518")}
+  const session = await api.startCliAuthSession(server?.port, repoCanonical);
+  const browserUrl = reauth ? session.verificationUrl : session.installUrl ?? session.verificationUrl;
+  const expiresAt = new Date(session.expiresAt).getTime();
+  if (options.ci) {
+    process.stdout.write(`VOCODER_AUTH_URL: ${browserUrl}
 `);
+    process.stdout.write(`VOCODER_SESSION_ID: ${session.sessionId}
+`);
+  } else if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
+    if (reauth) {
+      if (!options.yes) {
+        const shouldOpen = await p5.confirm({ message: "Open your browser to sign in again?" });
+        if (p5.isCancel(shouldOpen)) {
+          server?.close();
+          p5.cancel("Setup cancelled.");
+          return null;
+        }
+        if (!shouldOpen) {
+          p5.log.info("Open the URL above manually in your browser to continue.");
+        } else {
+          const opened = await tryOpenBrowser2(browserUrl);
+          if (!opened) {
+            p5.note(browserUrl, "Sign In");
+            p5.log.info("Open the URL above manually to continue.");
+          }
+        }
+      } else {
+        await tryOpenBrowser2(browserUrl);
+      }
+    } else {
+      let isLinkFlow = false;
+      if (!options.yes) {
+        const connectChoice = await p5.select({
+          message: "Vocoder needs to be installed on your GitHub account to get started",
+          options: [
+            { value: "install", label: "Install GitHub App", hint: "recommended" },
+            { value: "link", label: "Already installed? Link your account" }
+          ]
+        });
+        if (p5.isCancel(connectChoice)) {
+          server?.close();
+          p5.cancel("Setup cancelled.");
+          return null;
+        }
+        isLinkFlow = connectChoice === "link";
+      }
+      let urlToOpen = browserUrl;
+      if (isLinkFlow) {
+        try {
+          const linkSession = await api.startCliGitHubLinkSession(
+            session.sessionId,
+            server?.port
+          );
+          urlToOpen = linkSession.oauthUrl;
+        } catch {
+          urlToOpen = browserUrl;
+        }
+      }
+      const opened = await tryOpenBrowser2(urlToOpen);
+      if (!opened) {
+        p5.log.warn("Could not open your browser automatically.");
+        p5.note(urlToOpen, "GitHub");
+        p5.log.info("Open the URL above to continue.");
+      }
+    }
+  }
+  const authSpinner = p5.spinner();
+  authSpinner.start("Waiting for GitHub authorization...");
+  let rawToken = null;
+  let callbackOrganizationId;
+  let callbackDiscoveryReady = false;
+  if (server) {
+    try {
+      const deadline = Math.min(expiresAt, Date.now() + 10 * 60 * 1e3);
+      const timeoutMs = deadline - Date.now();
+      const params = await Promise.race([
+        server.waitForCallback(),
+        new Promise((resolve2) => setTimeout(() => resolve2(null), timeoutMs))
+      ]);
+      if (params && typeof params.token === "string") {
+        rawToken = params.token;
+        if (typeof params.organizationId === "string" && params.organizationId) {
+          callbackOrganizationId = params.organizationId;
+        }
+        if (params.discovery_ready === "1") {
+          callbackDiscoveryReady = true;
+        }
+      }
+    } catch {
+    } finally {
+      server.close();
+    }
+  }
+  if (!rawToken) {
+    while (Date.now() < expiresAt) {
+      const result = await api.pollCliAuthSession(session.sessionId);
+      if (result.status === "complete") {
+        rawToken = result.token;
+        if (result.organizationId) {
+          callbackOrganizationId = result.organizationId;
+        }
+        break;
+      }
+      if (result.status === "failed") {
+        authSpinner.stop();
+        p5.log.error(result.reason);
+        return null;
+      }
+      await sleep(2e3);
+    }
+  }
+  if (!rawToken) {
+    authSpinner.stop();
+    p5.log.error("The authentication link expired. Run `vocoder init` again.");
+    return null;
+  }
+  const userInfo = await api.getCliUserInfo(rawToken);
+  authSpinner.stop();
+  p5.log.success(`Authenticated as ${chalk6.bold(userInfo.email)}`);
+  return { token: rawToken, ...userInfo, organizationId: callbackOrganizationId, discoveryReady: callbackDiscoveryReady };
 }
 async function init(options = {}) {
   const apiUrl = options.apiUrl || process.env.VOCODER_API_URL || "https://vocoder.app";
-  p.intro("Vocoder Setup");
-  const spinner3 = p.spinner();
+  p5.intro("Vocoder Setup");
   try {
     const gitContext = resolveGitContext();
     const identity = gitContext.identity;
     if (gitContext.warnings.length > 0) {
       for (const warning of gitContext.warnings) {
-        p.log.warn(warning);
+        p5.log.warn(warning);
       }
     }
     if (identity) {
-      spinner3.start("Checking for existing project...");
-      const api2 = new VocoderAPI({ apiUrl, apiKey: "" });
-      const existing = await api2.lookupProjectByRepo({
+      const anonApi = new VocoderAPI({ apiUrl, apiKey: "" });
+      const existing = await anonApi.lookupProjectByRepo({
         repoCanonical: identity.repoCanonical,
         scopePath: identity.repoScopePath
       });
       if (existing) {
-        spinner3.stop("Found existing project!");
-        p.outro("Vocoder is already set up for this repository.");
         runScaffold({
           projectName: existing.projectName,
           organizationName: existing.organizationName,
           sourceLocale: existing.sourceLocale ?? "en",
           translationTriggers: existing.translationTriggers ?? ["push"]
         });
+        p5.outro("Vocoder is already set up for this repository.");
         return 0;
       }
-      spinner3.stop("No existing project found for this repo.");
     }
-    spinner3.start("Creating setup session");
     const api = new VocoderAPI({ apiUrl, apiKey: "" });
-    const start = await api.startInitSession({
-      projectName: options.projectName,
-      sourceLocale: options.sourceLocale,
-      targetLocales: parseTargetLocales(options.targetLocales),
-      ...identity?.repoCanonical ? { repoCanonical: identity.repoCanonical } : {},
-      ...identity ? { repoScopePath: identity.repoScopePath } : {}
-    });
-    spinner3.stop("Setup session created");
-    const verificationUrlString = start.verificationUrl;
-    p.log.info("Create a project in your browser to continue.");
-    p.note(verificationUrlString, "Setup URL");
-    if (process.stdin.isTTY && process.stdout.isTTY && process.env.CI !== "true") {
-      const shouldOpen = options.yes ? true : await p.confirm({ message: "Open this URL in your browser?" });
-      if (p.isCancel(shouldOpen)) {
-        p.cancel("Setup cancelled.");
-        return 1;
-      }
-      if (shouldOpen) {
-        const opened = await tryOpenBrowser(verificationUrlString);
-        if (opened) {
-          p.log.info("Opened your browser.");
-        } else {
-          p.log.info("Could not open a browser automatically. Use the URL above.");
-        }
+    let userToken;
+    let userEmail;
+    let userName;
+    let authOrganizationId;
+    let authDiscoveryReady = false;
+    const stored = readAuthData();
+    if (stored && stored.apiUrl === apiUrl) {
+      const verified = await verifyStoredToken(api, stored.token);
+      if (verified) {
+        p5.log.success(`Authenticated as ${chalk6.bold(verified.email)}`);
+        userToken = stored.token;
+        userEmail = verified.email;
+        userName = verified.name;
+      } else {
+        p5.log.warn("Stored credentials expired \u2014 signing in again");
+        const authResult = await runAuthFlow(
+          api,
+          options,
+          /* reauth */
+          true
+        );
+        if (!authResult) return 1;
+        userToken = authResult.token;
+        userEmail = authResult.email;
+        userName = authResult.name;
+        authOrganizationId = authResult.organizationId;
+        authDiscoveryReady = authResult.discoveryReady ?? false;
+        writeAuthData({
+          token: userToken,
+          apiUrl,
+          userId: authResult.userId,
+          email: userEmail,
+          name: userName,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
       }
-    }
-    const expiresAt = new Date(start.expiresAt).getTime();
-    spinner3.start("Waiting for setup to complete...");
-    while (Date.now() < expiresAt) {
-      const status = await api.getInitSessionStatus({
-        sessionId: start.sessionId,
-        pollToken: start.poll.token
+    } else {
+      const authResult = await runAuthFlow(api, options, false, identity?.repoCanonical);
+      if (!authResult) return 1;
+      userToken = authResult.token;
+      userEmail = authResult.email;
+      userName = authResult.name;
+      authOrganizationId = authResult.organizationId;
+      writeAuthData({
+        token: userToken,
+        apiUrl,
+        userId: authResult.userId,
+        email: userEmail,
+        name: userName,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      if (status.status === "pending") {
-        const pendingMessage = status.message?.trim();
-        if (pendingMessage) {
-          spinner3.message(`Waiting for setup to complete... (${pendingMessage})`);
+    }
+    let selectedWorkspaceId;
+    let selectedWorkspaceName;
+    if (authOrganizationId) {
+      const workspaceData = await api.listWorkspaces(userToken);
+      const ws = workspaceData.workspaces.find((w) => w.id === authOrganizationId);
+      selectedWorkspaceId = authOrganizationId;
+      selectedWorkspaceName = ws?.name ?? userEmail;
+      p5.log.success(`Connected as ${chalk6.bold(userEmail)} \u2014 workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+    } else {
+      const discoveryResult = await api.getCliGitHubDiscovery(userToken).catch(() => null);
+      const cachedInstallations = discoveryResult?.installations ?? [];
+      if (cachedInstallations.length > 0) {
+        if (identity?.repoCanonical) {
+          const repoOwner = identity.repoCanonical.split(":")[1]?.split("/")[0]?.toLowerCase();
+          if (repoOwner) {
+            const hasMatchingAccount = cachedInstallations.some(
+              (i) => i.accountLogin.toLowerCase() === repoOwner
+            );
+            if (!hasMatchingAccount) {
+              p5.log.warn(
+                `None of your GitHub App installations belong to "${repoOwner}", the account that owns this repository.
+  The project will be created but translations won't trigger automatically.
+  To fix: install the Vocoder GitHub App on "${repoOwner}" instead.`
+              );
+            }
+          }
         }
-        await sleep((status.pollIntervalSeconds || start.poll.intervalSeconds) * 1e3);
-        continue;
-      }
-      if (status.status === "failed") {
-        spinner3.stop("Setup failed");
-        if (isPlanLimitFailure(status.message)) {
-          printPlanLimitMessage(apiUrl, status.message);
+        const validInstallations = cachedInstallations.filter(
+          (i) => !i.isSuspended && !i.conflictLabel
+        );
+        let selectedInstallationId = null;
+        if (validInstallations.length === 1 && cachedInstallations.length === 1) {
+          selectedInstallationId = validInstallations[0].installationId;
         } else {
-          p.log.error(status.message);
+          selectedInstallationId = await selectGitHubInstallation(
+            cachedInstallations.map((inst) => ({
+              installationId: inst.installationId,
+              accountLogin: inst.accountLogin,
+              accountType: inst.accountType,
+              isSuspended: inst.isSuspended,
+              conflictLabel: inst.conflictLabel
+            })),
+            false
+          );
         }
-        p.cancel("Setup could not be completed.");
-        return 1;
-      }
-      if (status.status === "completed") {
-        spinner3.stop("Setup complete!");
-        const { credentials } = status;
-        p.outro("Vocoder initialized successfully!");
-        runScaffold({
-          projectName: credentials.projectName,
-          organizationName: credentials.organizationName,
-          sourceLocale: credentials.sourceLocale,
-          translationTriggers: credentials.translationTriggers ?? ["push"]
+        if (selectedInstallationId === null || selectedInstallationId === "install_new") {
+          p5.cancel("Setup cancelled. Re-run `vocoder init` and choose Install GitHub App.");
+          return 1;
+        }
+        const claimResult = await api.claimCliGitHubInstallation(userToken, {
+          installationId: String(selectedInstallationId),
+          organizationId: null
         });
-        return 0;
+        selectedWorkspaceId = claimResult.organizationId;
+        selectedWorkspaceName = claimResult.organizationName;
+        p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+      } else {
+        const workspaceData = await api.listWorkspaces(userToken);
+        if (workspaceData.workspaces.length === 1 && !workspaceData.canCreateWorkspace) {
+          const ws = workspaceData.workspaces[0];
+          selectedWorkspaceId = ws.id;
+          selectedWorkspaceName = ws.name;
+          p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+        } else {
+          const workspaceResult = await selectWorkspace(workspaceData);
+          if (workspaceResult.action === "cancelled") {
+            p5.cancel("Setup cancelled.");
+            return 1;
+          }
+          if (workspaceResult.action === "use") {
+            selectedWorkspaceId = workspaceResult.workspace.id;
+            selectedWorkspaceName = workspaceResult.workspace.name;
+            p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+          } else {
+            const connectChoice = await p5.select({
+              message: "Connect your new workspace to GitHub",
+              options: [
+                { value: "install", label: "Install the Vocoder GitHub App" },
+                { value: "link", label: "Link an existing installation" }
+              ]
+            });
+            if (p5.isCancel(connectChoice)) {
+              p5.cancel("Setup cancelled.");
+              return 1;
+            }
+            if (connectChoice === "install") {
+              const connectResult = await runGitHubInstallFlow({
+                api,
+                userToken,
+                yes: options.yes
+              });
+              if (!connectResult) {
+                p5.log.error("GitHub App installation did not complete. Run `vocoder init` again.");
+                return 1;
+              }
+              selectedWorkspaceId = connectResult.organizationId;
+              selectedWorkspaceName = connectResult.organizationName;
+              p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+            } else {
+              const installations = await runGitHubDiscoveryFlow({
+                api,
+                userToken,
+                yes: options.yes
+              });
+              if (!installations) return 1;
+              if (installations.length === 0) {
+                p5.log.warn("No GitHub installations found. Install the Vocoder GitHub App first.");
+                const installNow = await p5.confirm({ message: "Open GitHub to install the App?" });
+                if (p5.isCancel(installNow) || !installNow) return 1;
+                const connectResult = await runGitHubInstallFlow({
+                  api,
+                  userToken,
+                  yes: options.yes
+                });
+                if (!connectResult) return 1;
+                selectedWorkspaceId = connectResult.organizationId;
+                selectedWorkspaceName = connectResult.organizationName;
+              } else {
+                const selectedInstallationId = await selectGitHubInstallation(
+                  installations.map((inst) => ({
+                    installationId: inst.installationId,
+                    accountLogin: inst.accountLogin,
+                    accountType: inst.accountType,
+                    isSuspended: inst.isSuspended,
+                    conflictLabel: inst.conflictLabel
+                  })),
+                  true
+                );
+                if (selectedInstallationId === null) {
+                  p5.cancel("Setup cancelled.");
+                  return 1;
+                }
+                if (selectedInstallationId === "install_new") {
+                  const connectResult = await runGitHubInstallFlow({
+                    api,
+                    userToken,
+                    yes: options.yes
+                  });
+                  if (!connectResult) return 1;
+                  selectedWorkspaceId = connectResult.organizationId;
+                  selectedWorkspaceName = connectResult.organizationName;
+                } else {
+                  const claimResult = await api.claimCliGitHubInstallation(userToken, {
+                    installationId: String(selectedInstallationId),
+                    organizationId: null
+                  });
+                  selectedWorkspaceId = claimResult.organizationId;
+                  selectedWorkspaceName = claimResult.organizationName;
+                }
+              }
+              p5.log.success(`Workspace: ${chalk6.bold(selectedWorkspaceName)}`);
+            }
+          }
+        }
       }
     }
-    spinner3.stop("Setup timed out");
-    p.log.error("Setup timed out. Run `vocoder init` again.");
-    p.cancel("Setup could not be completed.");
-    return 1;
+    const projectResult = await runProjectCreate({
+      api,
+      userToken,
+      organizationId: selectedWorkspaceId,
+      defaultName: identity?.repoCanonical ? identity.repoCanonical.split("/").pop() : void 0,
+      defaultSourceLocale: "en",
+      repoCanonical: identity?.repoCanonical,
+      defaultBranches: ["main"]
+    });
+    if (!projectResult) {
+      p5.log.error("Project creation failed. Run `vocoder init` again.");
+      return 1;
+    }
+    if (!projectResult.repositoryBound && identity?.repoCanonical) {
+      p5.log.warn(
+        `This repository isn't accessible to your GitHub App installation.
+Translations won't run automatically until you grant access.
+  To fix: go to your GitHub App installation settings and add this
+  repository to the allowed list, or switch to "All repositories".
+` + (projectResult.configureUrl ? `
+  ${chalk6.dim(projectResult.configureUrl)}
+` : "")
+      );
+    }
+    runScaffold({
+      projectName: projectResult.projectName,
+      organizationName: selectedWorkspaceName,
+      sourceLocale: projectResult.sourceLocale,
+      translationTriggers: projectResult.translationTriggers
+    });
+    printMcpSetup(projectResult.apiKey);
+    p5.outro("You're all set.");
+    return 0;
   } catch (error) {
-    spinner3.stop();
     if (error instanceof Error) {
       if (isPlanLimitFailure(error.message)) {
         printPlanLimitMessage(apiUrl, error.message);
         return 1;
       }
-      p.log.error(`Error: ${error.message}`);
+      p5.log.error(`Error: ${error.message}`);
     } else {
-      p.log.error("Unknown setup error");
+      p5.log.error("Unknown setup error");
     }
     return 1;
   }
 }
+// src/commands/logout.ts
+import * as p6 from "@clack/prompts";
+async function logout(options = {}) {
+  const stored = readAuthData();
+  if (!stored) {
+    p6.log.info("Not currently authenticated.");
+    return 0;
+  }
+  const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiUrl, apiKey: "" });
+  try {
+    await api.revokeCliToken(stored.token);
+  } catch {
+  }
+  clearAuthData();
+  p6.log.success(`Logged out (was ${stored.email})`);
+  return 0;
+}
 // src/commands/sync.ts
-import * as p2 from "@clack/prompts";
-import { createHash as createHash2, randomUUID } from "crypto";
+import * as p7 from "@clack/prompts";
+import { createHash, randomUUID } from "crypto";
 // src/utils/branch.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 var REGEX_SPECIAL_CHARS = /[.+?^${}()|[\]\\]/g;
 function escapeRegexChar(value) {
   return value.replace(REGEX_SPECIAL_CHARS, "\\$&");
@@ -922,7 +2106,7 @@ function detectBranch(override) {
     return envBranch;
   }
   try {
-    const branch = execSync3("git rev-parse --abbrev-ref HEAD", {
+    const branch = execSync4("git rev-parse --abbrev-ref HEAD", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -966,10 +2150,10 @@ function matchBranchPattern(branch, pattern) {
 }
 // src/commands/sync.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 // src/utils/config.ts
-import chalk2 from "chalk";
+import chalk7 from "chalk";
 import { config as loadEnv2 } from "dotenv";
 loadEnv2();
 function validateLocalConfig(config) {
@@ -1061,19 +2245,19 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
     configSources.noFallback = "environment";
   }
   if (verbose) {
-    console.log(chalk2.dim("\n   Configuration sources:"));
-    console.log(chalk2.dim(`     Include patterns: ${configSources.extractionPattern}`));
+    console.log(chalk7.dim("\n   Configuration sources:"));
+    console.log(chalk7.dim(`     Include patterns: ${configSources.extractionPattern}`));
     if (excludePattern.length > 0) {
-      console.log(chalk2.dim(`     Exclude patterns: ${configSources.excludePattern}`));
+      console.log(chalk7.dim(`     Exclude patterns: ${configSources.excludePattern}`));
     }
-    console.log(chalk2.dim(`     API key: ${configSources.apiKey}`));
-    console.log(chalk2.dim(`     API URL: ${configSources.apiUrl}
+    console.log(chalk7.dim(`     API key: ${configSources.apiKey}`));
+    console.log(chalk7.dim(`     API URL: ${configSources.apiUrl}
 `));
-    console.log(chalk2.dim(`     Sync mode: ${configSources.mode}`));
+    console.log(chalk7.dim(`     Sync mode: ${configSources.mode}`));
     if (maxWaitMs) {
-      console.log(chalk2.dim(`     Max wait: ${configSources.maxWaitMs}`));
+      console.log(chalk7.dim(`     Max wait: ${configSources.maxWaitMs}`));
     }
-    console.log(chalk2.dim(`     No fallback: ${configSources.noFallback}
+    console.log(chalk7.dim(`     No fallback: ${configSources.noFallback}
 `));
   }
   return {
@@ -1088,280 +2272,8 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
   };
 }
-// src/utils/extract.ts
-import { createHash } from "crypto";
-import { readFileSync as readFileSync2 } from "fs";
-import { parse } from "@babel/parser";
-import babelTraverse from "@babel/traverse";
-import { glob } from "glob";
-import { relative as pathRelative } from "path";
-var traverse = babelTraverse.default || babelTraverse;
-var StringExtractor = class {
-  /**
-   * Extract strings from all files matching the pattern(s)
-   *
-   * @param pattern - Glob pattern(s) to include
-   * @param projectRoot - Project root directory
-   * @param excludePattern - Glob pattern(s) to exclude (optional)
-   */
-  async extractFromProject(pattern, projectRoot = process.cwd(), excludePattern) {
-    const includePatterns = Array.isArray(pattern) ? pattern : [pattern];
-    const defaultIgnore = ["**/node_modules/**", "**/.next/**", "**/dist/**", "**/build/**"];
-    const ignorePatterns = excludePattern ? [...defaultIgnore, ...Array.isArray(excludePattern) ? excludePattern : [excludePattern]] : defaultIgnore;
-    const allFiles = /* @__PURE__ */ new Set();
-    for (const includePattern of includePatterns) {
-      const files = await glob(includePattern, {
-        cwd: projectRoot,
-        absolute: true,
-        ignore: ignorePatterns
-      });
-      files.forEach((file) => allFiles.add(file));
-    }
-    const allStrings = [];
-    const sortedFiles = Array.from(allFiles).sort();
-    for (const file of sortedFiles) {
-      try {
-        const strings = await this.extractFromFile(file, projectRoot);
-        allStrings.push(...strings);
-      } catch (error) {
-        console.warn(`Warning: Failed to extract from ${file}:`, error);
-      }
-    }
-    const unique = this.deduplicateStrings(allStrings);
-    return unique;
-  }
-  /**
-   * Extract strings from a single file
-   */
-  async extractFromFile(filePath, projectRoot) {
-    const code = readFileSync2(filePath, "utf-8");
-    const strings = [];
-    const relativeFilePath = pathRelative(projectRoot, filePath).split("\\").join("/");
-    try {
-      const ast = parse(code, {
-        sourceType: "module",
-        plugins: ["jsx", "typescript"]
-      });
-      const vocoderImports = /* @__PURE__ */ new Map();
-      const tFunctionNames = /* @__PURE__ */ new Set();
-      traverse(ast, {
-        // Track imports of <T> component and t function
-        ImportDeclaration: (path) => {
-          const source = path.node.source.value;
-          if (source === "@vocoder/react") {
-            path.node.specifiers.forEach((spec) => {
-              if (spec.type === "ImportSpecifier") {
-                const imported = spec.imported.type === "Identifier" ? spec.imported.name : null;
-                const local = spec.local.name;
-                if (imported === "T") {
-                  vocoderImports.set(local, "T");
-                }
-                if (imported === "t") {
-                  tFunctionNames.add(local);
-                }
-                if (imported === "useVocoder") {
-                }
-              }
-            });
-          }
-        },
-        // Track destructured 't' from useVocoder hook
-        VariableDeclarator: (path) => {
-          const init2 = path.node.init;
-          if (init2 && init2.type === "CallExpression" && init2.callee.type === "Identifier" && init2.callee.name === "useVocoder" && path.node.id.type === "ObjectPattern") {
-            path.node.id.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "t") {
-                const localName = prop.value.type === "Identifier" ? prop.value.name : "t";
-                tFunctionNames.add(localName);
-              }
-            });
-          }
-        },
-        // Extract from t() function calls
-        CallExpression: (path) => {
-          const callee = path.node.callee;
-          const isTFunction = callee.type === "Identifier" && tFunctionNames.has(callee.name);
-          if (!isTFunction) return;
-          const firstArg = path.node.arguments[0];
-          if (!firstArg) return;
-          let text = null;
-          if (firstArg.type === "StringLiteral") {
-            text = firstArg.value;
-          } else if (firstArg.type === "TemplateLiteral") {
-            text = this.extractTemplateText(firstArg);
-          }
-          if (!text || text.trim().length === 0) return;
-          const secondArg = path.node.arguments[1];
-          let context;
-          let formality;
-          let explicitKey;
-          if (secondArg && secondArg.type === "ObjectExpression") {
-            secondArg.properties.forEach((prop) => {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
-                if (prop.key.name === "context" && prop.value.type === "StringLiteral") {
-                  context = prop.value.value;
-                }
-                if (prop.key.name === "formality" && prop.value.type === "StringLiteral") {
-                  formality = prop.value.value;
-                }
-                if (prop.key.name === "id" && prop.value.type === "StringLiteral") {
-                  explicitKey = prop.value.value.trim();
-                }
-              }
-            });
-          }
-          const line = path.node.loc?.start.line || 0;
-          const column = path.node.loc?.start.column || 0;
-          const key = explicitKey && explicitKey.length > 0 ? explicitKey : this.generateStableKey({
-            filePath: relativeFilePath,
-            kind: "t-call",
-            line,
-            column
-          });
-          strings.push({
-            key,
-            text: text.trim(),
-            file: filePath,
-            line,
-            context,
-            formality
-          });
-        },
-        // Extract from JSX elements
-        JSXElement: (path) => {
-          const opening = path.node.openingElement;
-          const tagName = opening.name.type === "JSXIdentifier" ? opening.name.name : null;
-          if (!tagName) return;
-          const isTranslationComponent = vocoderImports.has(tagName);
-          if (!isTranslationComponent) return;
-          const msgAttribute = this.getStringAttribute(opening.attributes, "msg");
-          const text = msgAttribute || this.extractTextContent(path.node.children);
-          if (!text || text.trim().length === 0) return;
-          const id = this.getStringAttribute(opening.attributes, "id");
-          const context = this.getStringAttribute(opening.attributes, "context");
-          const formality = this.getStringAttribute(
-            opening.attributes,
-            "formality"
-          );
-          const line = path.node.loc?.start.line || 0;
-          const column = path.node.loc?.start.column || 0;
-          const key = id && id.trim().length > 0 ? id.trim() : this.generateStableKey({
-            filePath: relativeFilePath,
-            kind: "jsx",
-            line,
-            column
-          });
-          strings.push({
-            key,
-            text: text.trim(),
-            file: filePath,
-            line,
-            context,
-            formality
-          });
-        }
-      });
-    } catch (error) {
-      throw new Error(
-        `Failed to parse ${filePath}: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
-    }
-    return strings;
-  }
-  /**
-   * Extract text from template literal
-   * Converts template literals like `Hello ${name}` to `Hello {name}`
-   */
-  extractTemplateText(node) {
-    let text = "";
-    for (let i = 0; i < node.quasis.length; i++) {
-      const quasi = node.quasis[i];
-      text += quasi.value.raw;
-      if (i < node.expressions.length) {
-        const expr = node.expressions[i];
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else {
-          text += "{value}";
-        }
-      }
-    }
-    return text;
-  }
-  /**
-   * Extract text content from JSX children
-   */
-  extractTextContent(children) {
-    let text = "";
-    for (const child of children) {
-      if (child.type === "JSXText") {
-        text += child.value;
-      } else if (child.type === "JSXExpressionContainer") {
-        const expr = child.expression;
-        if (expr.type === "Identifier") {
-          text += `{${expr.name}}`;
-        } else if (expr.type === "StringLiteral") {
-          text += expr.value;
-        } else if (expr.type === "TemplateLiteral") {
-          text += this.extractTemplateText(expr);
-        }
-      }
-    }
-    return text;
-  }
-  /**
-   * Get string value from JSX attribute
-   * Handles both string literals and template literals
-   */
-  getStringAttribute(attributes, name) {
-    const attr = attributes.find(
-      (a) => a.type === "JSXAttribute" && a.name.name === name
-    );
-    if (!attr || !attr.value) return void 0;
-    if (attr.value.type === "StringLiteral") {
-      return attr.value.value;
-    }
-    if (attr.value.type === "JSXExpressionContainer") {
-      const expr = attr.value.expression;
-      if (expr.type === "TemplateLiteral") {
-        return this.extractTemplateText(expr);
-      }
-      if (expr.type === "StringLiteral") {
-        return expr.value;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Deduplicate strings (keep first occurrence)
-   */
-  deduplicateStrings(strings) {
-    const seen = /* @__PURE__ */ new Map();
-    const unique = [];
-    for (const str of strings) {
-      const dedupeKey = `${str.text}|${str.context || ""}|${str.formality || ""}`;
-      const existingIndex = seen.get(dedupeKey);
-      if (existingIndex === void 0) {
-        seen.set(dedupeKey, unique.length);
-        unique.push(str);
-        continue;
-      }
-      const existing = unique[existingIndex];
-      if (existing && str.key < existing.key) {
-        existing.key = str.key;
-      }
-    }
-    return unique;
-  }
-  generateStableKey(params) {
-    const payload = `${params.filePath}|${params.kind}|${params.line}:${params.column}`;
-    const digest = createHash("sha1").update(payload).digest("hex");
-    return `SK_${digest.slice(0, 24).toUpperCase()}`;
-  }
-};
 // src/commands/sync.ts
-import chalk3 from "chalk";
+import chalk8 from "chalk";
 import { join as join2 } from "path";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1408,7 +2320,7 @@ function parseTranslations(value) {
 }
 function getCacheFilePath(projectRoot, branch) {
   const slug = branch.replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40);
-  const branchHash = createHash2("sha1").update(branch).digest("hex").slice(0, 12);
+  const branchHash = createHash("sha1").update(branch).digest("hex").slice(0, 12);
   const filename = `${slug || "branch"}-${branchHash}.json`;
   return join2(projectRoot, "node_modules", ".vocoder", "cache", "sync", filename);
 }
@@ -1416,11 +2328,11 @@ function readLocalSnapshotCache(params) {
   const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
   for (const candidateBranch of candidateBranches) {
     const cacheFilePath = getCacheFilePath(params.projectRoot, candidateBranch);
-    if (!existsSync2(cacheFilePath)) {
+    if (!existsSync(cacheFilePath)) {
       continue;
     }
     try {
-      const raw = readFileSync3(cacheFilePath, "utf-8");
+      const raw = readFileSync2(cacheFilePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!isRecord(parsed)) {
         continue;
@@ -1446,7 +2358,7 @@ function readLocalSnapshotCache(params) {
 }
 function writeLocalSnapshotCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
-  mkdirSync(join2(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"), {
+  mkdirSync2(join2(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"), {
     recursive: true
   });
   const payload = {
@@ -1460,7 +2372,7 @@ function writeLocalSnapshotCache(params) {
     ...params.localeMetadata ? { localeMetadata: params.localeMetadata } : {},
     translations: params.translations
   };
-  writeFileSync(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync2(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
   return cacheFilePath;
 }
 function resolveEffectiveModeFromPolicy(params) {
@@ -1615,13 +2527,13 @@ async function fetchApiSnapshot(api, params) {
 async function sync(options = {}) {
   const startTime = Date.now();
   const projectRoot = process.cwd();
-  p2.intro("Vocoder Sync");
-  const spinner3 = p2.spinner();
+  p7.intro("Vocoder Sync");
+  const spinner4 = p7.spinner();
   try {
-    spinner3.start("Detecting branch");
+    spinner4.start("Detecting branch");
     const branch = detectBranch(options.branch);
-    spinner3.stop(`Branch: ${chalk3.cyan(branch)}`);
-    spinner3.start("Loading project configuration");
+    spinner4.stop(`Branch: ${chalk8.cyan(branch)}`);
+    spinner4.start("Loading project configuration");
     const mergedConfig = await getMergedConfig(options, options.verbose);
     const localConfig = {
       apiKey: mergedConfig.apiKey || "",
@@ -1643,18 +2555,18 @@ async function sync(options = {}) {
       excludePattern: mergedConfig.excludePattern,
       timeout: waitTimeoutMs
     };
-    spinner3.stop("Project configuration loaded");
+    spinner4.stop("Project configuration loaded");
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
-      p2.log.warn(
-        `Skipping translations (${chalk3.cyan(branch)} is not a target branch)`
+      p7.log.warn(
+        `Skipping translations (${chalk8.cyan(branch)} is not a target branch)`
       );
-      p2.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
-      p2.log.info("Use --force to translate anyway");
-      p2.outro("");
+      p7.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
+      p7.log.info("Use --force to translate anyway");
+      p7.outro("");
       return 0;
     }
     const patternsDisplay = Array.isArray(config.extractionPattern) ? config.extractionPattern.join(", ") : config.extractionPattern;
-    spinner3.start(`Extracting strings from ${patternsDisplay}`);
+    spinner4.start(`Extracting strings from ${patternsDisplay}`);
     const extractor = new StringExtractor();
     const extractedStrings = await extractor.extractFromProject(
       config.extractionPattern,
@@ -1662,23 +2574,23 @@ async function sync(options = {}) {
       config.excludePattern
     );
     if (extractedStrings.length === 0) {
-      spinner3.stop("No translatable strings found");
-      p2.log.warn("Make sure you are wrapping translatable strings with Vocoder");
-      p2.outro("");
+      spinner4.stop("No translatable strings found");
+      p7.log.warn("Make sure you are wrapping translatable strings with Vocoder");
+      p7.outro("");
       return 0;
     }
-    spinner3.stop(
-      `Extracted ${chalk3.cyan(extractedStrings.length)} strings from ${chalk3.cyan(patternsDisplay)}`
+    spinner4.stop(
+      `Extracted ${chalk8.cyan(extractedStrings.length)} strings from ${chalk8.cyan(patternsDisplay)}`
     );
     if (options.verbose) {
       const sampleLines = extractedStrings.slice(0, 5).map((s) => `  "${s.text}" (${s.file}:${s.line})`);
       if (extractedStrings.length > 5) {
         sampleLines.push(`  ... and ${extractedStrings.length - 5} more`);
       }
-      p2.note(sampleLines.join("\n"), "Sample strings");
+      p7.note(sampleLines.join("\n"), "Sample strings");
     }
     if (options.dryRun) {
-      p2.note(
+      p7.note(
         [
           `Strings: ${extractedStrings.length}`,
           `Branch: ${branch}`,
@@ -1689,23 +2601,23 @@ async function sync(options = {}) {
         ].join("\n"),
         "Dry run - would translate"
       );
-      p2.outro("No API calls made.");
+      p7.outro("No API calls made.");
       return 0;
     }
     const repoIdentity = resolveGitRepositoryIdentity();
     if (!repoIdentity && options.verbose) {
-      p2.log.warn(
+      p7.log.warn(
         "Could not detect git remote origin. Sync will continue without repo metadata."
       );
     }
     const stringEntries = buildStringEntries(extractedStrings);
     const sourceStrings = stringEntries.map((entry) => entry.text);
     if (options.verbose && stringEntries.length !== extractedStrings.length) {
-      p2.log.info(
+      p7.log.info(
         `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
       );
     }
-    spinner3.start("Submitting strings to Vocoder API");
+    spinner4.start("Submitting strings to Vocoder API");
     const batchResponse = await api.submitTranslation(
       branch,
       stringEntries,
@@ -1717,38 +2629,38 @@ async function sync(options = {}) {
       },
       repoIdentity ?? void 0
     );
-    spinner3.stop(`Submitted to API - Batch ${chalk3.cyan(batchResponse.batchId)}`);
+    spinner4.stop(`Submitted to API - Batch ${chalk8.cyan(batchResponse.batchId)}`);
     const effectiveMode = batchResponse.effectiveMode ?? resolveEffectiveModeFromPolicy({
       branch,
       requestedMode,
       policy: config.syncPolicy
     });
     if (options.verbose) {
-      p2.log.info(`Requested mode: ${requestedMode}`);
-      p2.log.info(`Effective mode: ${effectiveMode}`);
-      p2.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
+      p7.log.info(`Requested mode: ${requestedMode}`);
+      p7.log.info(`Effective mode: ${effectiveMode}`);
+      p7.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
       if (batchResponse.queueStatus) {
-        p2.log.info(`Queue status: ${batchResponse.queueStatus}`);
+        p7.log.info(`Queue status: ${batchResponse.queueStatus}`);
       }
     }
     if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      p2.log.success("No changes detected - strings are up to date");
+      p7.log.success("No changes detected - strings are up to date");
     }
-    p2.log.info(`New strings: ${chalk3.cyan(batchResponse.newStrings)}`);
+    p7.log.info(`New strings: ${chalk8.cyan(batchResponse.newStrings)}`);
     if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
-      p2.log.info(
-        `Deleted strings: ${chalk3.yellow(batchResponse.deletedStrings)} (archived)`
+      p7.log.info(
+        `Deleted strings: ${chalk8.yellow(batchResponse.deletedStrings)} (archived)`
       );
     }
-    p2.log.info(`Total strings: ${chalk3.cyan(batchResponse.totalStrings)}`);
+    p7.log.info(`Total strings: ${chalk8.cyan(batchResponse.totalStrings)}`);
     if (batchResponse.newStrings === 0) {
-      p2.log.success("No new strings - using existing translations");
+      p7.log.success("No new strings - using existing translations");
     } else {
-      p2.log.info(
+      p7.log.info(
         `Syncing to ${config.targetLocales.length} locales (${config.targetLocales.join(", ")})`
       );
       if (batchResponse.estimatedTime) {
-        p2.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
+        p7.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
       }
     }
     let artifacts = null;
@@ -1760,7 +2672,7 @@ async function sync(options = {}) {
     }
     let waitError = null;
     if (!artifacts && (effectiveMode === "required" || effectiveMode === "best-effort")) {
-      spinner3.start(`Waiting for translations (max ${waitTimeoutMs}ms)`);
+      spinner4.start(`Waiting for translations (max ${waitTimeoutMs}ms)`);
       let lastProgress = 0;
       try {
         const completion = await api.waitForCompletion(
@@ -1769,7 +2681,7 @@ async function sync(options = {}) {
           (progress) => {
             const percent = Math.round(progress * 100);
             if (percent > lastProgress) {
-              spinner3.message(`Translating... ${percent}%`);
+              spinner4.message(`Translating... ${percent}%`);
               lastProgress = percent;
             }
           }
@@ -1779,14 +2691,14 @@ async function sync(options = {}) {
           translations: completion.translations,
           localeMetadata: completion.localeMetadata
         };
-        spinner3.stop("Translations complete");
+        spinner4.stop("Translations complete");
       } catch (error) {
-        spinner3.stop("Translation wait incomplete");
+        spinner4.stop("Translation wait incomplete");
         waitError = error instanceof Error ? error : new Error(String(error));
         if (effectiveMode === "required") {
           throw waitError;
         }
-        p2.log.warn(`Best-effort wait ended early: ${waitError.message}`);
+        p7.log.warn(`Best-effort wait ended early: ${waitError.message}`);
       }
     }
     if (!artifacts) {
@@ -1795,7 +2707,7 @@ async function sync(options = {}) {
           "Fresh translations are not available and fallback is disabled (--no-fallback)."
         );
       }
-      spinner3.start("Loading fallback translations");
+      spinner4.start("Loading fallback translations");
       const localFallback = readLocalSnapshotCache({
         projectRoot,
         branch
@@ -1803,7 +2715,7 @@ async function sync(options = {}) {
       if (localFallback) {
         artifacts = localFallback;
         const cacheBranchLabel = localFallback.cacheBranch && localFallback.cacheBranch !== branch ? `${localFallback.cacheBranch} fallback` : localFallback.cacheBranch || branch;
-        spinner3.stop(`Using local cached snapshot (${cacheBranchLabel})`);
+        spinner4.stop(`Using local cached snapshot (${cacheBranchLabel})`);
       } else {
         try {
           const apiSnapshot = await fetchApiSnapshot(api, {
@@ -1812,15 +2724,15 @@ async function sync(options = {}) {
           });
           if (apiSnapshot) {
             artifacts = apiSnapshot;
-            spinner3.stop("Using latest completed API snapshot");
+            spinner4.stop("Using latest completed API snapshot");
           } else {
-            spinner3.stop("No completed API snapshot available");
+            spinner4.stop("No completed API snapshot available");
           }
         } catch (error) {
-          spinner3.stop("Failed to fetch API snapshot");
+          spinner4.stop("Failed to fetch API snapshot");
           if (options.verbose) {
             const message = error instanceof Error ? error.message : "Unknown snapshot fetch error";
-            p2.log.warn(`Snapshot fetch error: ${message}`);
+            p7.log.warn(`Snapshot fetch error: ${message}`);
           }
         }
       }
@@ -1853,81 +2765,108 @@ async function sync(options = {}) {
         completedAt: artifacts.completedAt ?? (artifacts.source === "fresh" ? (/* @__PURE__ */ new Date()).toISOString() : null)
       });
       if (options.verbose) {
-        p2.log.info(`Cached snapshot: ${cachePath}`);
+        p7.log.info(`Cached snapshot: ${cachePath}`);
       }
     } catch (error) {
       if (options.verbose) {
         const message = error instanceof Error ? error.message : "Unknown cache write error";
-        p2.log.warn(`Failed to write local snapshot cache: ${message}`);
+        p7.log.warn(`Failed to write local snapshot cache: ${message}`);
       }
     }
     if (artifacts.source !== "fresh") {
       const sourceLabel = artifacts.source === "local-cache" ? "local cached snapshot" : "completed API snapshot";
-      p2.log.warn(
+      p7.log.warn(
         `Using ${sourceLabel}. New strings may appear after the background sync completes.`
       );
     }
     const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p2.outro(`Sync complete! (${duration}s)`);
-    p2.log.info("Translations will be injected at build time by @vocoder/unplugin.");
-    p2.log.info("Just use <VocoderProvider> and <T> \u2014 no manual imports needed.");
+    p7.outro(`Sync complete! (${duration}s)`);
+    p7.log.info("Translations will be injected at build time by @vocoder/unplugin.");
+    p7.log.info("Just use <VocoderProvider> and <T> \u2014 no manual imports needed.");
     return 0;
   } catch (error) {
-    spinner3.stop();
+    spinner4.stop();
     if (error instanceof VocoderAPIError && error.syncPolicyError) {
-      p2.log.error(error.syncPolicyError.message);
+      p7.log.error(error.syncPolicyError.message);
       const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
       for (const line of guidance) {
-        p2.log.info(line);
+        p7.log.info(line);
       }
       return 1;
     }
     if (error instanceof VocoderAPIError && error.limitError) {
       const { limitError } = error;
-      p2.log.error(limitError.message);
+      p7.log.error(limitError.message);
       const guidance = getLimitErrorGuidance(limitError);
       for (const line of guidance) {
-        p2.log.info(line);
+        p7.log.info(line);
       }
       return 1;
     }
     if (error instanceof Error) {
-      p2.log.error(error.message);
+      p7.log.error(error.message);
       if (error.message.includes("VOCODER_API_KEY")) {
-        p2.log.warn("VOCODER_API_KEY is only needed for `vocoder sync` (CLI push).");
-        p2.log.info("  Create one at: https://vocoder.app/dashboard");
-        p2.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
-        p2.log.info("");
-        p2.log.info("  Note: If you use @vocoder/unplugin, `vocoder sync` is optional.");
-        p2.log.info("  Translations are fetched automatically at build time.");
+        p7.log.warn("VOCODER_API_KEY is only needed for `vocoder sync` (CLI push).");
+        p7.log.info("  Create one at: https://vocoder.app/dashboard");
+        p7.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
+        p7.log.info("");
+        p7.log.info("  Note: If you use @vocoder/unplugin, `vocoder sync` is optional.");
+        p7.log.info("  Translations are fetched automatically at build time.");
       } else if (error.message.includes("git branch")) {
-        p2.log.warn("Run from a git repository, or use:");
-        p2.log.info("  vocoder sync --branch main");
+        p7.log.warn("Run from a git repository, or use:");
+        p7.log.info("  vocoder sync --branch main");
       }
       if (options.verbose) {
-        p2.log.info(`Full error: ${error.stack ?? error}`);
+        p7.log.info(`Full error: ${error.stack ?? error}`);
       }
     }
     return 1;
   }
 }
+// src/commands/whoami.ts
+import * as p8 from "@clack/prompts";
+import chalk9 from "chalk";
+async function whoami(options = {}) {
+  const stored = readAuthData();
+  if (!stored) {
+    p8.log.info("Not logged in. Run `vocoder init` to authenticate.");
+    return 1;
+  }
+  const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiUrl, apiKey: "" });
+  try {
+    const info = await api.getCliUserInfo(stored.token);
+    p8.log.info(`Logged in as ${chalk9.bold(info.email)}`);
+    if (info.name) {
+      p8.log.info(`Name: ${info.name}`);
+    }
+    p8.log.info(`API: ${apiUrl}`);
+    return 0;
+  } catch {
+    p8.log.error("Stored credentials are invalid or expired. Run `vocoder init` to re-authenticate.");
+    return 1;
+  }
+}
 // src/bin.ts
 function collect(value, previous = []) {
   return previous.concat([value]);
 }
 async function runCommand(command, options) {
   const exitCode = await command(options);
-  process.exitCode = exitCode;
+  process.exit(exitCode);
 }
 var program = new Command();
 program.name("vocoder").description("Vocoder CLI - Project setup and string extraction").version("0.1.5");
-program.command("init").description("Authenticate and provision Vocoder for this project").option("--api-url <url>", "Override Vocoder API URL").option("--yes", "Allow overwriting existing local config values").option("--project-name <name>", "Starter project name to create").option("--source-locale <locale>", "Source locale for the starter project").option("--target-locales <list>", "Comma-separated target locales (e.g. es,fr,de)").action((options) => runCommand(init, options));
+program.command("init").description("Authenticate and provision Vocoder for this project").option("--api-url <url>", "Override Vocoder API URL").option("--yes", "Allow overwriting existing local config values").option("--ci", "Non-interactive mode: print auth URL to stdout, skip browser open").option("--project-name <name>", "Starter project name to create").option("--source-locale <locale>", "Source locale for the starter project").option("--target-locales <list>", "Comma-separated target locales (e.g. es,fr,de)").action((options) => runCommand(init, options));
 program.command("sync").description("Extract strings and sync translations").option("--branch <branch>", "Override detected branch").option("--mode <mode>", "Sync mode: auto, required, best-effort", "auto").option("--max-wait <ms>", "Max wait for translations (ms)").option("--force", "Force re-extraction even if no changes").option("--dry-run", "Preview without syncing").option("--no-fallback", "Disable fallback to cached translations").option("--include <pattern>", "Include glob pattern", collect, []).option("--exclude <pattern>", "Exclude glob pattern", collect, []).option("--verbose", "Detailed output").action((options) => {
   const translated = { ...options };
   if (options.maxWait) translated.maxWaitMs = Number(options.maxWait);
   if (options.fallback === false) translated.noFallback = true;
   return runCommand(sync, translated);
 });
+program.command("logout").description("Log out and remove stored credentials").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(logout, options));
+program.command("whoami").description("Show the currently authenticated user").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(whoami, options));
 program.parse(process.argv);
 //# sourceMappingURL=bin.mjs.map