@vocoder/cli 0.10.0 → 0.12.0

package/dist/bin.mjs

@@ -2,759 +2,37 @@
 import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
 import {
   StringExtractor,
+  VocoderAPI,
+  VocoderAPIError,
   buildInstallCommand,
+  clearAuthData,
   detectLocalEcosystem,
   getPackagesToInstall,
   getSetupSnippets,
-  loadVocoderConfig
-} from "./chunk-73U4VZYP.mjs";
+  loadVocoderConfig,
+  readAuthData,
+  verifyStoredAuth,
+  writeAuthData
+} from "./chunk-XUCVAFBG.mjs";
 
 // src/bin.ts
 import { Command } from "commander";
 
 // src/commands/init.ts
-import { execSync as execSync3, spawn as spawn2 } from "child_process";
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
 import * as p5 from "@clack/prompts";
-import chalk6 from "chalk";
-import { config as loadEnv } from "dotenv";
-
-// src/utils/api.ts
-function isLimitErrorResponse(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return typeof candidate.errorCode === "string" && typeof candidate.limitType === "string" && typeof candidate.planId === "string" && typeof candidate.current === "number" && typeof candidate.required === "number" && typeof candidate.upgradeUrl === "string" && typeof candidate.message === "string";
-}
-function isSyncPolicyErrorResponse(value) {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const candidate = value;
-  return (candidate.errorCode === "BRANCH_NOT_ALLOWED" || candidate.errorCode === "PROJECT_REPOSITORY_MISMATCH") && typeof candidate.message === "string";
-}
-function extractErrorMessage(payload, fallback) {
-  if (!payload || typeof payload !== "object") {
-    return fallback;
-  }
-  const candidate = payload;
-  if (typeof candidate.message === "string") {
-    return candidate.message;
-  }
-  if (typeof candidate.error === "string") {
-    return candidate.error;
-  }
-  return fallback;
-}
-function parsePayload(raw) {
-  if (raw.length === 0) {
-    return null;
-  }
-  const trimmed = raw.trimStart();
-  if (trimmed.startsWith("<!DOCTYPE") || trimmed.startsWith("<html")) {
-    return {
-      message: "Unexpected response from server (received HTML). Check your network connection or try again."
-    };
-  }
-  try {
-    return JSON.parse(raw);
-  } catch {
-    return { message: raw };
-  }
-}
-async function readPayload(response) {
-  if (typeof response.text === "function") {
-    const raw = await response.text();
-    return parsePayload(raw);
-  }
-  if (typeof response.json === "function") {
-    return response.json();
-  }
-  return null;
-}
-var VocoderAPIError = class extends Error {
-  constructor(params) {
-    super(params.message);
-    this.name = "VocoderAPIError";
-    this.status = params.status;
-    this.payload = params.payload;
-    this.limitError = params.limitError ?? null;
-    this.syncPolicyError = params.syncPolicyError ?? null;
-  }
-};
-var VocoderAPI = class {
-  constructor(config) {
-    this.apiUrl = config.apiUrl;
-    this.apiKey = config.apiKey;
-  }
-  async request(path, init2 = {}, errorPrefix) {
-    const response = await fetch(`${this.apiUrl}${path}`, {
-      ...init2,
-      headers: {
-        Authorization: `Bearer ${this.apiKey}`,
-        ...init2.headers ?? {}
-      }
-    });
-    const payload = await readPayload(response);
-    if (!response.ok) {
-      const limitError = isLimitErrorResponse(payload) ? payload : null;
-      const syncPolicyError = isSyncPolicyErrorResponse(payload) ? payload : null;
-      const baseMessage = extractErrorMessage(
-        payload,
-        `Request failed with status ${response.status}`
-      );
-      throw new VocoderAPIError({
-        message: errorPrefix ? `${errorPrefix}: ${baseMessage}` : baseMessage,
-        status: response.status,
-        payload,
-        limitError,
-        syncPolicyError
-      });
-    }
-    return payload;
-  }
-  /**
-   * Fetch project configuration from API
-   * Project is determined from the API key
-   */
-  async getProjectConfig() {
-    const data = await this.request("/api/cli/config", {}, "Failed to fetch project config");
-    return {
-      projectName: data.projectName,
-      organizationName: data.organizationName,
-      shortCode: data.shortCode,
-      sourceLocale: data.sourceLocale,
-      targetLocales: data.targetLocales,
-      targetBranches: data.targetBranches ?? ["main"],
-      primaryBranch: data.primaryBranch,
-      syncPolicy: {
-        blockingBranches: data.syncPolicy?.blockingBranches ?? [
-          "main",
-          "master"
-        ],
-        blockingMode: data.syncPolicy?.blockingMode ?? "required",
-        nonBlockingMode: data.syncPolicy?.nonBlockingMode ?? "best-effort",
-        defaultMaxWaitMs: data.syncPolicy?.defaultMaxWaitMs ?? 6e4
-      }
-    };
-  }
-  /**
-   * Submit strings for translation
-   * Project is determined from the API key
-   */
-  stableTextKey(text2) {
-    let hash = 2166136261;
-    for (let i = 0; i < text2.length; i++) {
-      hash ^= text2.charCodeAt(i);
-      hash = Math.imul(hash, 16777619);
-    }
-    return `SK_TEXT_${(hash >>> 0).toString(16).toUpperCase().padStart(8, "0")}`;
-  }
-  normalizeStringEntries(entries) {
-    if (entries.length === 0) {
-      return [];
-    }
-    const first = entries[0];
-    if (typeof first === "string") {
-      return entries.map((text2) => ({
-        key: this.stableTextKey(text2),
-        text: text2
-      }));
-    }
-    return entries.map((entry, index) => ({
-      key: entry.key || this.stableTextKey(`${entry.text}:${index}`),
-      text: entry.text,
-      ...entry.context ? { context: entry.context } : {},
-      ...entry.formality ? { formality: entry.formality } : {},
-      ...entry.uiRole ? { uiRole: entry.uiRole } : {},
-      ...entry.featureArea ? { featureArea: entry.featureArea } : {}
-    }));
-  }
-  async submitTranslation(branch, entries, targetLocales, options, repoIdentity) {
-    const stringEntries = this.normalizeStringEntries(entries);
-    const strings = stringEntries.map((entry) => entry.text);
-    const crypto = await import("crypto");
-    const sortedStrings = [...strings].sort();
-    const stringsHash = crypto.createHash("sha256").update(JSON.stringify(sortedStrings)).digest("hex");
-    return this.request(
-      "/api/cli/sync",
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          branch,
-          stringEntries,
-          targetLocales,
-          ...options?.force ? {} : { stringsHash },
-          ...options?.requestedMode ? { requestedMode: options.requestedMode } : {},
-          ...typeof options?.requestedMaxWaitMs === "number" ? { requestedMaxWaitMs: options.requestedMaxWaitMs } : {},
-          ...options?.clientRunId ? { clientRunId: options.clientRunId } : {},
-          ...repoIdentity?.repoCanonical ? { repoCanonical: repoIdentity.repoCanonical } : {},
-          ...repoIdentity?.repoAppDir !== void 0 ? { repoAppDir: repoIdentity.repoAppDir } : {},
-          ...repoIdentity?.commitSha ? { commitSha: repoIdentity.commitSha } : {},
-          ...options?.appIndustry ? { appIndustry: options.appIndustry } : {}
-        })
-      },
-      "Translation submission failed"
-    );
-  }
-  /**
-   * Check translation status
-   */
-  async getTranslationStatus(batchId) {
-    return this.request(
-      `/api/cli/sync/status/${batchId}`,
-      {},
-      "Failed to check translation status"
-    );
-  }
-  async getTranslationSnapshot(params) {
-    const search = new URLSearchParams();
-    search.set("branch", params.branch);
-    for (const locale of params.targetLocales) {
-      search.append("targetLocale", locale);
-    }
-    return this.request(
-      `/api/cli/sync/snapshot?${search.toString()}`,
-      {},
-      "Failed to fetch translation snapshot"
-    );
-  }
-  /**
-   * Wait for translation to complete with polling
-   */
-  async waitForCompletion(batchId, timeout = 6e4, onProgress) {
-    const startTime = Date.now();
-    const pollInterval = 1e3;
-    while (Date.now() - startTime < timeout) {
-      const status = await this.getTranslationStatus(batchId);
-      if (onProgress) {
-        onProgress(status.progress);
-      }
-      if (status.status === "COMPLETED") {
-        if (!status.translations) {
-          throw new Error("Translation completed but no translations returned");
-        }
-        return {
-          translations: status.translations,
-          localeMetadata: status.localeMetadata
-        };
-      }
-      if (status.status === "FAILED") {
-        throw new Error(
-          `Translation failed: ${status.errorMessage || "Unknown error"}`
-        );
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
-    }
-    throw new Error(`Translation timeout after ${timeout}ms`);
-  }
-  async startInitSession(input) {
-    const response = await fetch(`${this.apiUrl}/api/cli/init/start`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(input)
-    });
-    const payload = await readPayload(response);
-    if (!response.ok) {
-      throw new VocoderAPIError({
-        message: extractErrorMessage(
-          payload,
-          `Failed to start init session (${response.status})`
-        ),
-        status: response.status,
-        payload
-      });
-    }
-    return payload;
-  }
-  async getInitSessionStatus(params) {
-    const response = await fetch(
-      `${this.apiUrl}/api/cli/init/status/${params.sessionId}`,
-      {
-        headers: {
-          Authorization: `Bearer ${params.pollToken}`
-        }
-      }
-    );
-    const payload = await readPayload(response);
-    if (!response.ok) {
-      throw new VocoderAPIError({
-        message: extractErrorMessage(
-          payload,
-          `Failed to get init status (${response.status})`
-        ),
-        status: response.status,
-        payload
-      });
-    }
-    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, params) {
-    const url = new URL(`${this.apiUrl}/api/cli/workspaces`);
-    if (params?.repo) url.searchParams.set("repo", params.repo);
-    const response = await fetch(url.toString(), {
-      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;
-  }
-  async listProjects(userToken, organizationId) {
-    const url = new URL(`${this.apiUrl}/api/cli/projects`);
-    url.searchParams.set("organizationId", organizationId);
-    const response = await fetch(url.toString(), {
-      headers: { Authorization: `Bearer ${userToken}` }
-    });
-    const payload = await readPayload(response);
-    if (!response.ok) {
-      throw new VocoderAPIError({
-        message: extractErrorMessage(
-          payload,
-          `Failed to list projects (${response.status})`
-        ),
-        status: response.status,
-        payload
-      });
-    }
-    const result = payload;
-    return result.projects;
-  }
-  async regenerateProjectApiKey(userToken, projectId) {
-    const response = await fetch(
-      `${this.apiUrl}/api/cli/project/regenerate-key`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${userToken}`
-        },
-        body: JSON.stringify({ projectId })
-      }
-    );
-    const payload = await readPayload(response);
-    if (!response.ok) {
-      throw new VocoderAPIError({
-        message: extractErrorMessage(
-          payload,
-          `Failed to regenerate API key (${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;
-  }
-  async listCompatibleLocales(userToken, sourceLocale) {
-    const url = `${this.apiUrl}/api/cli/locales/compatible?source=${encodeURIComponent(sourceLocale)}`;
-    const response = await fetch(url, {
-      headers: { Authorization: `Bearer ${userToken}` }
-    });
-    const payload = await readPayload(response);
-    if (!response.ok) {
-      throw new VocoderAPIError({
-        message: extractErrorMessage(
-          payload,
-          `Failed to list compatible 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 all project apps for a given repo. Returns info about exact matches,
-   * existing apps in other scopes, and whether a whole-repo app exists.
-   * No auth required.
-   */
-  async lookupProjectByRepo(params) {
-    try {
-      const response = await fetch(`${this.apiUrl}/api/cli/init/lookup`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          repo: params.repoCanonical,
-          appDir: params.appDir
-        })
-      });
-      if (!response.ok) {
-        return { exactMatch: null, existingApps: [], hasWholeRepoApp: false };
-      }
-      const data = await response.json();
-      return {
-        exactMatch: data.exactMatch ?? null,
-        existingApps: data.existingApps ?? [],
-        hasWholeRepoApp: data.hasWholeRepoApp ?? false
-      };
-    } catch {
-      return { exactMatch: null, existingApps: [], hasWholeRepoApp: false };
-    }
-  }
-  /**
-   * Add a new ProjectApp to an existing project (monorepo: new app directory).
-   * Does not check plan limits — no new project is created.
-   */
-  async createProjectApp(userToken, params) {
-    const response = await fetch(`${this.apiUrl}/api/cli/project/apps`, {
-      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 app (${response.status})`
-        ),
-        status: response.status,
-        payload
-      });
-    }
-    return payload;
-  }
-};
-
-// 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 {
-  }
-}
+import { execSync as execSync3, spawn as spawn2 } from "child_process";
+import { existsSync as existsSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
 
 // src/utils/write-config.ts
-import { existsSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync, writeFileSync } from "fs";
+import { join } from "path";
 function findExistingConfig(cwd = process.cwd()) {
   for (const name of [
     "vocoder.config.ts",
     "vocoder.config.js",
     "vocoder.config.json"
   ]) {
-    const candidate = join2(cwd, name);
+    const candidate = join(cwd, name);
     if (existsSync(candidate)) return candidate;
   }
   return null;
@@ -767,7 +45,7 @@ function writeVocoderConfig(options) {
   } = options;
   if (findExistingConfig(cwd)) return null;
   const ext = useTypeScript ? "ts" : "js";
-  const configPath = join2(cwd, `vocoder.config.${ext}`);
+  const configPath = join(cwd, `vocoder.config.${ext}`);
   const branchesStr = targetBranches.map((b) => `'${b}'`).join(", ");
   const content = `import { defineConfig } from '@vocoder/config'
 
@@ -785,121 +63,13 @@ export default defineConfig({
 })
 `;
   try {
-    writeFileSync2(configPath, content, "utf-8");
+    writeFileSync(configPath, content, "utf-8");
     return `vocoder.config.${ext}`;
   } catch {
     return null;
   }
 }
 
-// src/utils/git-identity.ts
-import { execSync } from "child_process";
-import { relative, resolve } from "path";
-var SHA_REGEX = /^[0-9a-f]{40}$/i;
-function detectCommitSha() {
-  if (process.env.VOCODER_COMMIT_SHA && SHA_REGEX.test(process.env.VOCODER_COMMIT_SHA)) {
-    return process.env.VOCODER_COMMIT_SHA;
-  }
-  const knownSha = process.env.GITHUB_SHA || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CI_COMMIT_SHA || process.env.BITBUCKET_COMMIT || process.env.CIRCLE_SHA1 || process.env.RENDER_GIT_COMMIT;
-  if (knownSha && SHA_REGEX.test(knownSha)) return knownSha;
-  return safeExec("git rev-parse HEAD");
-}
-function safeExec(command) {
-  try {
-    const output = execSync(command, {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "ignore"]
-    }).trim();
-    return output.length > 0 ? output : null;
-  } catch {
-    return null;
-  }
-}
-function normalizePath(pathname) {
-  const cleaned = pathname.replace(/^\/+/, "").replace(/\.git$/i, "").trim();
-  if (!cleaned || !cleaned.includes("/")) {
-    return null;
-  }
-  return cleaned;
-}
-function parseRemoteUrl(remoteUrl) {
-  const trimmed = remoteUrl.trim();
-  if (!trimmed) {
-    return null;
-  }
-  if (!trimmed.includes("://")) {
-    const scpMatch = trimmed.match(/^(?:.+@)?([^:]+):(.+)$/);
-    if (scpMatch) {
-      const host = (scpMatch[1] || "").toLowerCase();
-      const ownerRepoPath = normalizePath(scpMatch[2] || "");
-      if (!host || !ownerRepoPath) {
-        return null;
-      }
-      return { host, ownerRepoPath };
-    }
-    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 repoAppDir = "";
-  if (repositoryRoot) {
-    const relativePath = relative(
-      resolve(repositoryRoot),
-      resolve(currentDirectory)
-    ).replace(/\\/g, "/").trim();
-    if (relativePath && relativePath !== "." && !relativePath.startsWith("..")) {
-      repoAppDir = relativePath;
-    }
-  }
-  return {
-    repoCanonical: toCanonical(parsed.host, parsed.ownerRepoPath),
-    repoAppDir
-  };
-}
-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/github-connect.ts
 import { spawn } from "child_process";
 import * as p from "@clack/prompts";
@@ -1185,7 +355,7 @@ import * as p3 from "@clack/prompts";
 import chalk4 from "chalk";
 
 // src/utils/branch-select.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync } from "child_process";
 import { isCancel as isCancel2, Prompt } from "@clack/core";
 import chalk2 from "chalk";
 var S_BAR = "\u2502";
@@ -1216,14 +386,14 @@ function symbol(state) {
 function detectGitBranches(cwd) {
   const workDir = cwd ?? process.cwd();
   try {
-    const localOut = execSync2("git branch", {
+    const localOut = execSync("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", {
+      const remoteOut = execSync("git branch -r", {
         cwd: workDir,
         stdio: "pipe"
       }).toString();
@@ -1233,7 +403,7 @@ function detectGitBranches(cwd) {
     const branches = [.../* @__PURE__ */ new Set([...localBranches, ...remoteBranches])].sort();
     let defaultBranch = "main";
     try {
-      const ref = execSync2("git symbolic-ref refs/remotes/origin/HEAD", {
+      const ref = execSync("git symbolic-ref refs/remotes/origin/HEAD", {
         cwd: workDir,
         stdio: "pipe"
       }).toString().trim();
@@ -1870,53 +1040,166 @@ async function runProjectAppCreate(params) {
       "No target languages selected \u2014 you can add them later from the dashboard."
     );
   }
-  const detectedApp = detectGitBranches();
-  let appPushBranches = [];
-  {
-    let initial = [detectedApp.defaultBranch];
-    while (appPushBranches.length === 0) {
-      const result = await filterableBranchSelect({
-        message: "Which branches should trigger translations?",
-        branches: detectedApp.branches,
-        defaultBranch: detectedApp.defaultBranch,
-        initialValues: initial
-      });
-      if (result === null) return null;
-      if (result.length === 0) {
-        p3.log.warn("At least one branch is required.");
-        initial = [detectedApp.defaultBranch];
-      } else {
-        appPushBranches = result;
-      }
+  const detectedApp = detectGitBranches();
+  let appPushBranches = [];
+  {
+    let initial = [detectedApp.defaultBranch];
+    while (appPushBranches.length === 0) {
+      const result = await filterableBranchSelect({
+        message: "Which branches should trigger translations?",
+        branches: detectedApp.branches,
+        defaultBranch: detectedApp.defaultBranch,
+        initialValues: initial
+      });
+      if (result === null) return null;
+      if (result.length === 0) {
+        p3.log.warn("At least one branch is required.");
+        initial = [detectedApp.defaultBranch];
+      } else {
+        appPushBranches = result;
+      }
+    }
+  }
+  const targetBranches = appPushBranches;
+  try {
+    const result = await api.createProjectApp(userToken, {
+      projectId,
+      appDir,
+      sourceLocale,
+      targetLocales,
+      targetBranches,
+      repoCanonical: repoCanonical ?? ""
+    });
+    p3.log.success(
+      `App ${chalk4.bold(appDir)} added to ${chalk4.bold(projectName)}!`
+    );
+    return {
+      projectId: result.projectId,
+      projectName: result.projectName,
+      apiKey: result.apiKey,
+      appDir: result.appDir,
+      sourceLocale,
+      targetLocales,
+      targetBranches
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    p3.log.error(`Failed to add app: ${message}`);
+    return null;
+  }
+}
+
+// src/commands/init.ts
+import chalk6 from "chalk";
+import { join as join2 } from "path";
+import { config as loadEnv } from "dotenv";
+
+// src/utils/git-identity.ts
+import { execSync as execSync2 } from "child_process";
+import { relative, resolve } from "path";
+var SHA_REGEX = /^[0-9a-f]{40}$/i;
+function detectCommitSha() {
+  if (process.env.VOCODER_COMMIT_SHA && SHA_REGEX.test(process.env.VOCODER_COMMIT_SHA)) {
+    return process.env.VOCODER_COMMIT_SHA;
+  }
+  const knownSha = process.env.GITHUB_SHA || process.env.VERCEL_GIT_COMMIT_SHA || process.env.CI_COMMIT_SHA || process.env.BITBUCKET_COMMIT || process.env.CIRCLE_SHA1 || process.env.RENDER_GIT_COMMIT;
+  if (knownSha && SHA_REGEX.test(knownSha)) return knownSha;
+  return safeExec("git rev-parse HEAD");
+}
+function safeExec(command) {
+  try {
+    const output = execSync2(command, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"]
+    }).trim();
+    return output.length > 0 ? output : null;
+  } catch {
+    return null;
+  }
+}
+function normalizePath(pathname) {
+  const cleaned = pathname.replace(/^\/+/, "").replace(/\.git$/i, "").trim();
+  if (!cleaned || !cleaned.includes("/")) {
+    return null;
+  }
+  return cleaned;
+}
+function parseRemoteUrl(remoteUrl) {
+  const trimmed = remoteUrl.trim();
+  if (!trimmed) {
+    return null;
+  }
+  if (!trimmed.includes("://")) {
+    const scpMatch = trimmed.match(/^(?:.+@)?([^:]+):(.+)$/);
+    if (scpMatch) {
+      const host = (scpMatch[1] || "").toLowerCase();
+      const ownerRepoPath = normalizePath(scpMatch[2] || "");
+      if (!host || !ownerRepoPath) {
+        return null;
+      }
+      return { host, ownerRepoPath };
+    }
+    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 repoAppDir = "";
+  if (repositoryRoot) {
+    const relativePath = relative(
+      resolve(repositoryRoot),
+      resolve(currentDirectory)
+    ).replace(/\\/g, "/").trim();
+    if (relativePath && relativePath !== "." && !relativePath.startsWith("..")) {
+      repoAppDir = relativePath;
     }
   }
-  const targetBranches = appPushBranches;
-  try {
-    const result = await api.createProjectApp(userToken, {
-      projectId,
-      appDir,
-      sourceLocale,
-      targetLocales,
-      targetBranches,
-      repoCanonical: repoCanonical ?? ""
-    });
-    p3.log.success(
-      `App ${chalk4.bold(appDir)} added to ${chalk4.bold(projectName)}!`
+  return {
+    repoCanonical: toCanonical(parsed.host, parsed.ownerRepoPath),
+    repoAppDir
+  };
+}
+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 {
-      projectId: result.projectId,
-      projectName: result.projectName,
-      apiKey: result.apiKey,
-      appDir: result.appDir,
-      sourceLocale,
-      targetLocales,
-      targetBranches
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    p3.log.error(`Failed to add app: ${message}`);
-    return null;
   }
+  return { identity, warnings };
 }
 
 // src/utils/workspace.ts
@@ -2112,10 +1395,10 @@ function runScaffold(params) {
   p5.log.message(chalk6.gray("  Docs: https://vocoder.app/docs/getting-started"));
 }
 function writeApiKeyToEnv(apiKey) {
-  const envPath = join3(process.cwd(), ".env");
+  const envPath = join2(process.cwd(), ".env");
   if (!existsSync2(envPath)) return false;
   try {
-    const content = readFileSync2(envPath, "utf-8");
+    const content = readFileSync(envPath, "utf-8");
     const keyLine = `VOCODER_API_KEY=${apiKey}`;
     let updated;
     if (/^VOCODER_API_KEY=/m.test(content)) {
@@ -2125,7 +1408,7 @@ function writeApiKeyToEnv(apiKey) {
       updated = `${content}${sep}${keyLine}
 `;
     }
-    writeFileSync3(envPath, updated);
+    writeFileSync2(envPath, updated);
     return true;
   } catch {
     return false;
@@ -2165,17 +1448,6 @@ function printCodeBlock(code) {
 `
   );
 }
-async function verifyStoredToken(api, token) {
-  try {
-    return await api.getCliUserInfo(token);
-  } catch (err) {
-    clearAuthData();
-    if (err instanceof VocoderAPIError && err.status === 404) {
-      return { userGone: true };
-    }
-    return null;
-  }
-}
 async function runAuthFlow(api, options, reauth = false, repoCanonical) {
   let server = null;
   if (!options.ci) {
@@ -2356,17 +1628,17 @@ async function init(options = {}) {
             true
           );
           if (!authResult) return 1;
-          const spinner4 = p5.spinner();
-          spinner4.start("Generating new API key...");
+          const spinner7 = p5.spinner();
+          spinner7.start("Generating new API key...");
           try {
             const { apiKey } = await anonApi2.regenerateProjectApiKey(
               authResult.token,
               exactMatch.projectId
             );
-            spinner4.stop("New API key generated");
+            spinner7.stop("New API key generated");
             printApiKey(apiKey);
           } catch (err) {
-            spinner4.stop("Failed to generate key");
+            spinner7.stop("Failed to generate key");
             const msg = err instanceof Error ? err.message : String(err);
             p5.log.error(`Could not generate API key: ${msg}`);
             p5.log.info("Try again or generate one from the dashboard.");
@@ -2401,47 +1673,23 @@ async function init(options = {}) {
     let userEmail;
     let userName;
     let authOrganizationId;
-    const stored = readAuthData();
-    if (stored && stored.apiUrl === apiUrl) {
-      const verified = await verifyStoredToken(api, stored.token);
-      if (verified && !("userGone" in verified)) {
-        p5.log.success(`Authenticated as ${chalk6.bold(verified.email)}`);
-        userToken = stored.token;
-        userEmail = verified.email;
-        userName = verified.name;
-      } else {
-        const isFirstTime = verified !== null && "userGone" in verified;
-        if (isFirstTime) {
-          p5.log.warn("Account not found \u2014 starting fresh setup");
-        } else {
-          p5.log.warn("Stored credentials expired \u2014 signing in again");
-        }
-        const authResult = await runAuthFlow(
-          api,
-          options,
-          /* reauth */
-          !isFirstTime,
-          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()
-        });
-      }
+    const storedAuth = await verifyStoredAuth(api);
+    if (storedAuth.status === "valid") {
+      p5.log.success(`Authenticated as ${chalk6.bold(storedAuth.email)}`);
+      userToken = storedAuth.token;
+      userEmail = storedAuth.email;
+      userName = storedAuth.name;
     } else {
+      const reauth = storedAuth.status === "expired";
+      if (reauth) {
+        p5.log.warn("Stored credentials expired \u2014 signing in again");
+      } else if (storedAuth.status === "gone") {
+        p5.log.warn("Account not found \u2014 starting fresh setup");
+      }
       const authResult = await runAuthFlow(
         api,
         options,
-        false,
+        reauth,
         identity?.repoCanonical
       );
       if (!authResult) return 1;
@@ -2451,7 +1699,6 @@ async function init(options = {}) {
       authOrganizationId = authResult.organizationId;
       writeAuthData({
         token: userToken,
-        apiUrl,
         userId: authResult.userId,
         email: userEmail,
         name: userName,
@@ -2862,30 +2109,16 @@ Translations won't run automatically until you grant access.
   }
 }
 
-// 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/locales.ts
+import * as p8 from "@clack/prompts";
+import chalk9 from "chalk";
+import { config as loadEnv3 } from "dotenv";
 
 // src/commands/sync.ts
 import { createHash, randomUUID } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync4 } from "fs";
-import { join as join4 } from "path";
-import * as p8 from "@clack/prompts";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+import * as p7 from "@clack/prompts";
 import chalk8 from "chalk";
 
 // src/utils/branch.ts
@@ -2955,7 +2188,7 @@ function matchBranchPattern(branch, pattern) {
 }
 
 // src/utils/config.ts
-import * as p7 from "@clack/prompts";
+import * as p6 from "@clack/prompts";
 import chalk7 from "chalk";
 import { config as loadEnv2 } from "dotenv";
 loadEnv2();
@@ -3014,7 +2247,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
   };
   const fileConfig = loadVocoderConfig(process.cwd());
   if (!fileConfig) {
-    p7.log.warn(
+    p6.log.warn(
       `No ${chalk7.cyan("vocoder.config.ts")} found \u2014 run ${chalk7.cyan("npx @vocoder/cli init")} to generate one.`
     );
   }
@@ -3045,7 +2278,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
     excludePattern = fileConfig.exclude;
     configSources.excludePattern = "vocoder.config";
   } else if (envExcludePattern) {
-    excludePattern = envExcludePattern.split(",").map((p10) => p10.trim()).filter(Boolean);
+    excludePattern = envExcludePattern.split(",").map((p14) => p14.trim()).filter(Boolean);
     configSources.excludePattern = "environment";
   } else {
     excludePattern = defaults.excludePattern;
@@ -3102,7 +2335,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
       ...maxWaitMs ? [`Max wait:         ${chalk7.cyan(String(configSources.maxWaitMs))}`] : [],
       `No fallback:      ${chalk7.cyan(String(configSources.noFallback))}`
     ];
-    p7.note(lines.join("\n"), "Configuration sources");
+    p6.note(lines.join("\n"), "Configuration sources");
   }
   return {
     includePattern,
@@ -3165,7 +2398,7 @@ function parseTranslations(value) {
   return Object.keys(translations).length > 0 ? translations : null;
 }
 function getCacheFilePath(projectRoot, fingerprint) {
-  return join4(projectRoot, "node_modules", ".vocoder", "cache", `${fingerprint}.json`);
+  return join3(projectRoot, "node_modules", ".vocoder", "cache", `${fingerprint}.json`);
 }
 function buildTranslationData(params) {
   const textToHash = new Map(params.stringEntries.map((e) => [e.text, e.key]));
@@ -3192,7 +2425,7 @@ function readLocalCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.fingerprint);
   if (!existsSync3(cacheFilePath)) return null;
   try {
-    const raw = readFileSync3(cacheFilePath, "utf-8");
+    const raw = readFileSync2(cacheFilePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!isRecord(parsed)) return null;
     const inner = isRecord(parsed.config) ? parsed : null;
@@ -3206,10 +2439,10 @@ function readLocalCache(params) {
   }
 }
 function writeCache(params) {
-  const cacheDir = join4(params.projectRoot, "node_modules", ".vocoder", "cache");
-  mkdirSync2(cacheDir, { recursive: true });
+  const cacheDir = join3(params.projectRoot, "node_modules", ".vocoder", "cache");
+  mkdirSync(cacheDir, { recursive: true });
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.fingerprint);
-  writeFileSync4(cacheFilePath, JSON.stringify(params.data), "utf-8");
+  writeFileSync3(cacheFilePath, JSON.stringify(params.data), "utf-8");
   return cacheFilePath;
 }
 function resolveEffectiveModeFromPolicy(params) {
@@ -3280,6 +2513,13 @@ function getLimitErrorGuidance(limitError) {
       `Upgrade plan: ${limitError.upgradeUrl}`
     ];
   }
+  if (limitError.limitType === "target_locales") {
+    return [
+      `Current target locales: ${limitError.current}`,
+      `Plan limit: ${limitError.current} (${limitError.planId})`,
+      `Upgrade plan: ${limitError.upgradeUrl}`
+    ];
+  }
   return [
     `Plan: ${limitError.planId}`,
     `Current: ${limitError.current}`,
@@ -3329,8 +2569,7 @@ function buildStringEntries(extractedStrings) {
         text: str.text,
         ...str.context ? { context: str.context } : {},
         ...str.formality ? { formality: str.formality } : {},
-        ...str.uiRole ? { uiRole: str.uiRole } : {},
-        ...str.featureArea ? { featureArea: str.featureArea } : {}
+        ...str.uiRole ? { uiRole: str.uiRole } : {}
       });
       continue;
     }
@@ -3365,22 +2604,22 @@ async function fetchApiSnapshot(api, params) {
 async function sync(options = {}) {
   const startTime = Date.now();
   const projectRoot = process.cwd();
-  p8.intro("Vocoder Sync");
+  p7.intro("Vocoder Sync");
   const mergedConfig = await getMergedConfig(options, options.verbose);
   if (!mergedConfig.apiKey) {
-    p8.log.warn("No API key found. Run init to get started:");
-    p8.log.info("  npx @vocoder/cli init");
-    p8.log.info("");
-    p8.log.info(
+    p7.log.warn("No API key found. Run init to get started:");
+    p7.log.info("  npx @vocoder/cli init");
+    p7.log.info("");
+    p7.log.info(
       "  Or add your key to .env: VOCODER_API_KEY=vcp_..."
     );
-    p8.outro("Run `npx @vocoder/cli init` to set up your project.");
+    p7.outro("Run `npx @vocoder/cli init` to set up your project.");
     return 1;
   }
-  const spinner4 = p8.spinner();
+  const spinner7 = p7.spinner();
   try {
     const branch = detectBranch(options.branch);
-    spinner4.start("Loading project configuration");
+    spinner7.start("Loading project configuration");
     const localConfig = {
       apiKey: mergedConfig.apiKey,
       apiUrl: mergedConfig.apiUrl || "https://vocoder.app"
@@ -3404,18 +2643,18 @@ async function sync(options = {}) {
       ...fileConfig?.appIndustry ? { appIndustry: fileConfig.appIndustry } : {},
       ...fileConfig?.formality ? { formality: fileConfig.formality } : {}
     };
-    spinner4.stop(`Branch: ${chalk8.cyan(branch)}`);
+    spinner7.stop(`Branch: ${chalk8.cyan(branch)}`);
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
-      p8.log.warn(
+      p7.log.warn(
         `Skipping translations (${chalk8.cyan(branch)} is not a target branch)`
       );
-      p8.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
-      p8.log.info("Use --force to translate anyway");
-      p8.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.includePattern) ? config.includePattern.join(", ") : config.includePattern;
-    spinner4.start(`Extracting strings from ${patternsDisplay}`);
+    spinner7.start(`Extracting strings from ${patternsDisplay}`);
     const extractor = new StringExtractor();
     const extractedStrings = await extractor.extractFromProject(
       config.includePattern,
@@ -3423,14 +2662,14 @@ async function sync(options = {}) {
       config.excludePattern
     );
     if (extractedStrings.length === 0) {
-      spinner4.stop("No translatable strings found");
-      p8.log.warn(
+      spinner7.stop("No translatable strings found");
+      p7.log.warn(
         "Make sure you are wrapping translatable strings with Vocoder"
       );
-      p8.outro("");
+      p7.outro("");
       return 0;
     }
-    spinner4.stop(
+    spinner7.stop(
       `Extracted ${chalk8.cyan(extractedStrings.length)} strings from ${chalk8.cyan(patternsDisplay)}`
     );
     if (options.verbose) {
@@ -3438,10 +2677,10 @@ async function sync(options = {}) {
       if (extractedStrings.length > 5) {
         sampleLines.push(`  ... and ${extractedStrings.length - 5} more`);
       }
-      p8.note(sampleLines.join("\n"), "Sample strings");
+      p7.note(sampleLines.join("\n"), "Sample strings");
     }
     if (options.dryRun) {
-      p8.note(
+      p7.note(
         [
           `Strings: ${extractedStrings.length}`,
           `Branch: ${branch}`,
@@ -3452,12 +2691,12 @@ async function sync(options = {}) {
         ].join("\n"),
         "Dry run - would translate"
       );
-      p8.outro("No API calls made.");
+      p7.outro("No API calls made.");
       return 0;
     }
     const repoIdentity = resolveGitRepositoryIdentity();
     if (!repoIdentity && options.verbose) {
-      p8.log.warn(
+      p7.log.warn(
         "Could not detect git remote origin. Sync will continue without repo metadata."
       );
     }
@@ -3465,7 +2704,7 @@ async function sync(options = {}) {
     const stringEntries = buildStringEntries(extractedStrings);
     const sourceStrings = stringEntries.map((entry) => entry.text);
     if (options.verbose && stringEntries.length !== extractedStrings.length) {
-      p8.log.info(
+      p7.log.info(
         `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
       );
     }
@@ -3474,17 +2713,17 @@ async function sync(options = {}) {
       const cacheFile = getCacheFilePath(projectRoot, fingerprint);
       if (existsSync3(cacheFile)) {
         if (options.verbose) {
-          p8.log.info(`Cache hit: ${chalk8.dim(cacheFile)} (fingerprint ${chalk8.cyan(fingerprint)})`);
+          p7.log.info(`Cache hit: ${chalk8.dim(cacheFile)} (fingerprint ${chalk8.cyan(fingerprint)})`);
         }
         const duration2 = ((Date.now() - startTime) / 1e3).toFixed(1);
-        p8.outro(`Up to date (${duration2}s)`);
+        p7.outro(`Up to date (${duration2}s)`);
         return 0;
       }
       if (options.verbose) {
-        p8.log.info(`No cache for fingerprint ${chalk8.cyan(fingerprint)} \u2014 will submit to API`);
+        p7.log.info(`No cache for fingerprint ${chalk8.cyan(fingerprint)} \u2014 will submit to API`);
       }
     }
-    spinner4.start("Submitting strings to Vocoder API");
+    spinner7.start("Submitting strings to Vocoder API");
     const batchResponse = await api.submitTranslation(
       branch,
       stringEntries,
@@ -3499,33 +2738,33 @@ async function sync(options = {}) {
       },
       repoIdentity ? { ...repoIdentity, commitSha } : { commitSha }
     );
-    spinner4.stop("Strings submitted");
+    spinner7.stop("Strings submitted");
     const effectiveMode = batchResponse.effectiveMode ?? resolveEffectiveModeFromPolicy({
       branch,
       requestedMode,
       policy: config.syncPolicy
     });
     if (options.verbose) {
-      p8.log.info(`Batch: ${chalk8.dim(batchResponse.batchId)}`);
-      p8.log.info(`Requested mode: ${requestedMode}`);
-      p8.log.info(`Effective mode: ${effectiveMode}`);
-      p8.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
+      p7.log.info(`Batch: ${chalk8.dim(batchResponse.batchId)}`);
+      p7.log.info(`Requested mode: ${requestedMode}`);
+      p7.log.info(`Effective mode: ${effectiveMode}`);
+      p7.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
       if (batchResponse.queueStatus) {
-        p8.log.info(`Queue status: ${batchResponse.queueStatus}`);
+        p7.log.info(`Queue status: ${batchResponse.queueStatus}`);
       }
     }
     if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      p8.log.success(`Up to date \u2014 ${chalk8.cyan(batchResponse.totalStrings)} strings, no changes`);
+      p7.log.success(`Up to date \u2014 ${chalk8.cyan(batchResponse.totalStrings)} strings, no changes`);
     } else if (batchResponse.newStrings === 0) {
       const archivedNote = batchResponse.deletedStrings && batchResponse.deletedStrings > 0 ? `, ${chalk8.yellow(batchResponse.deletedStrings)} archived` : "";
-      p8.log.success(`No new strings \u2014 ${chalk8.cyan(batchResponse.totalStrings)} total${archivedNote}, using existing translations`);
+      p7.log.success(`No new strings \u2014 ${chalk8.cyan(batchResponse.totalStrings)} total${archivedNote}, using existing translations`);
     } else {
       const statParts = [`${chalk8.cyan(batchResponse.newStrings)} new, ${chalk8.cyan(batchResponse.totalStrings)} total`];
       if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
         statParts.push(`${chalk8.yellow(batchResponse.deletedStrings)} archived`);
       }
       const estTime = batchResponse.estimatedTime ? ` (~${batchResponse.estimatedTime}s)` : "";
-      p8.log.info(`${statParts.join(", ")} \u2192 syncing to ${config.targetLocales.join(", ")}${estTime}`);
+      p7.log.info(`${statParts.join(", ")} \u2192 syncing to ${config.targetLocales.join(", ")}${estTime}`);
     }
     let artifacts = null;
     if (batchResponse.translations) {
@@ -3537,7 +2776,7 @@ async function sync(options = {}) {
     let waitError = null;
     if (!artifacts && (effectiveMode === "required" || effectiveMode === "best-effort")) {
       const waitTimeoutSecs = Math.round(waitTimeoutMs / 1e3);
-      spinner4.start(`Waiting for translations (max ${waitTimeoutSecs}s)`);
+      spinner7.start(`Waiting for translations (max ${waitTimeoutSecs}s)`);
       let lastProgress = 0;
       try {
         const completion = await api.waitForCompletion(
@@ -3546,7 +2785,7 @@ async function sync(options = {}) {
           (progress) => {
             const percent = Math.round(progress * 100);
             if (percent > lastProgress) {
-              spinner4.message(`Translating... ${percent}%`);
+              spinner7.message(`Translating... ${percent}%`);
               lastProgress = percent;
             }
           }
@@ -3556,14 +2795,14 @@ async function sync(options = {}) {
           translations: completion.translations,
           localeMetadata: completion.localeMetadata
         };
-        spinner4.stop("Translations complete");
+        spinner7.stop("Translations complete");
       } catch (error) {
-        spinner4.stop("Translation wait incomplete");
+        spinner7.stop("Translation wait incomplete");
         waitError = error instanceof Error ? error : new Error(String(error));
         if (effectiveMode === "required") {
           throw waitError;
         }
-        p8.log.warn(`Best-effort wait ended early: ${waitError.message}`);
+        p7.log.warn(`Best-effort wait ended early: ${waitError.message}`);
       }
     }
     if (!artifacts) {
@@ -3572,14 +2811,14 @@ async function sync(options = {}) {
           "Fresh translations are not available and fallback is disabled (--no-fallback)."
         );
       }
-      spinner4.start("Loading fallback translations");
+      spinner7.start("Loading fallback translations");
       const localFallback = readLocalCache({
         projectRoot,
         fingerprint
       });
       if (localFallback) {
         artifacts = localFallback;
-        spinner4.stop(`Using local cached snapshot (${fingerprint})`);
+        spinner7.stop(`Using local cached snapshot (${fingerprint})`);
       } else {
         try {
           const apiSnapshot = await fetchApiSnapshot(api, {
@@ -3588,15 +2827,15 @@ async function sync(options = {}) {
           });
           if (apiSnapshot) {
             artifacts = apiSnapshot;
-            spinner4.stop("Using latest completed API snapshot");
+            spinner7.stop("Using latest completed API snapshot");
           } else {
-            spinner4.stop("No completed API snapshot available");
+            spinner7.stop("No completed API snapshot available");
           }
         } catch (error) {
-          spinner4.stop("Failed to fetch API snapshot");
+          spinner7.stop("Failed to fetch API snapshot");
           if (options.verbose) {
             const message = error instanceof Error ? error.message : "Unknown snapshot fetch error";
-            p8.log.warn(`Snapshot fetch error: ${message}`);
+            p7.log.warn(`Snapshot fetch error: ${message}`);
           }
         }
       }
@@ -3628,85 +2867,433 @@ async function sync(options = {}) {
       });
       const cachePath = writeCache({ projectRoot, fingerprint, data });
       if (options.verbose) {
-        p8.log.info(`Cache written: ${cachePath}`);
+        p7.log.info(`Cache written: ${cachePath}`);
       }
     } catch (error) {
       if (options.verbose) {
         const message = error instanceof Error ? error.message : "Unknown cache write error";
-        p8.log.warn(`Failed to write cache: ${message}`);
+        p7.log.warn(`Failed to write cache: ${message}`);
       }
     }
     if (artifacts.source !== "fresh") {
       const sourceLabel = artifacts.source === "local-cache" ? "local cached snapshot" : "completed API snapshot";
-      p8.log.warn(
+      p7.log.warn(
         `Using ${sourceLabel}. New strings may appear after the background sync completes.`
       );
     }
     const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p8.outro(`Sync complete! (${duration}s)`);
+    p7.outro(`Sync complete! (${duration}s)`);
     return 0;
   } catch (error) {
-    spinner4.stop();
+    spinner7.stop();
     if (error instanceof VocoderAPIError && error.syncPolicyError) {
-      p8.log.error(error.syncPolicyError.message);
+      p7.log.error(error.syncPolicyError.message);
       const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
       for (const line of guidance) {
-        p8.log.info(line);
+        p7.log.info(line);
       }
       return 1;
     }
     if (error instanceof VocoderAPIError && error.limitError) {
       const { limitError } = error;
-      p8.log.error(limitError.message);
+      p7.log.error(limitError.message);
       const guidance = getLimitErrorGuidance(limitError);
       for (const line of guidance) {
-        p8.log.info(line);
+        p7.log.info(line);
       }
       return 1;
     }
     if (error instanceof Error) {
-      p8.log.error(error.message);
+      p7.log.error(error.message);
       const isInvalidKey = error.message.toLowerCase().includes("invalid api key") || error instanceof VocoderAPIError && error.status === 401;
       if (isInvalidKey) {
-        p8.log.warn(
+        p7.log.warn(
           "API key rejected \u2014 the project may have been deleted or the key revoked."
         );
-        p8.log.info(
+        p7.log.info(
           "  Run `npx @vocoder/cli init` to create a new project and key."
         );
       } else if (error.message.includes("git branch")) {
-        p8.log.warn("Run from a git repository, or use:");
-        p8.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) {
-        p8.log.info(`Full error: ${error.stack ?? error}`);
+        p7.log.info(`Full error: ${error.stack ?? error}`);
       }
     }
     return 1;
   }
 }
 
-// src/commands/whoami.ts
+// src/commands/locales.ts
+loadEnv3();
+function getApiConfig(options) {
+  const apiKey = process.env.VOCODER_API_KEY;
+  if (!apiKey) {
+    p8.log.error(
+      "VOCODER_API_KEY is not set. Run `npx @vocoder/cli init` to set up your project."
+    );
+    return null;
+  }
+  return {
+    apiKey,
+    apiUrl: options.apiUrl ?? process.env.VOCODER_API_URL ?? "https://vocoder.app"
+  };
+}
+async function listProjectLocales(options = {}) {
+  const config = getApiConfig(options);
+  if (!config) return 1;
+  const api = new VocoderAPI(config);
+  try {
+    const projectConfig2 = await api.getProjectConfig();
+    p8.log.info(
+      `Source locale:  ${chalk9.cyan(projectConfig2.sourceLocale)}`
+    );
+    if (projectConfig2.targetLocales.length === 0) {
+      p8.log.info("Target locales: (none configured)");
+    } else {
+      p8.log.info(
+        `Target locales: ${projectConfig2.targetLocales.map((l) => chalk9.cyan(l)).join(", ")}`
+      );
+    }
+    return 0;
+  } catch (error) {
+    p8.log.error(
+      error instanceof Error ? error.message : "Failed to fetch project locales."
+    );
+    return 1;
+  }
+}
+async function addLocales(locales, options = {}) {
+  if (locales.length === 0) {
+    p8.log.error("No locale codes provided.");
+    return 1;
+  }
+  const config = getApiConfig(options);
+  if (!config) return 1;
+  const api = new VocoderAPI(config);
+  let lastTargetLocales = [];
+  let hadError = false;
+  for (const locale of locales) {
+    const spinner7 = p8.spinner();
+    spinner7.start(`Adding ${locale}\u2026`);
+    try {
+      const result = await api.addLocale(locale);
+      lastTargetLocales = result.targetLocales;
+      spinner7.stop(`Added ${chalk9.cyan(locale)}`);
+    } catch (error) {
+      spinner7.stop(`Failed to add ${chalk9.red(locale)}`);
+      hadError = true;
+      if (error instanceof VocoderAPIError && error.limitError) {
+        const { limitError } = error;
+        p8.log.error(limitError.message);
+        for (const line of getLimitErrorGuidance(limitError)) {
+          p8.log.info(line);
+        }
+        break;
+      }
+      p8.log.error(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  if (lastTargetLocales.length > 0) {
+    p8.log.info(
+      `Target locales now: ${lastTargetLocales.map((l) => chalk9.cyan(l)).join(", ")}`
+    );
+  }
+  return hadError ? 1 : 0;
+}
+async function removeLocales(locales, options = {}) {
+  if (locales.length === 0) {
+    p8.log.error("No locale codes provided.");
+    return 1;
+  }
+  const config = getApiConfig(options);
+  if (!config) return 1;
+  const api = new VocoderAPI(config);
+  let lastTargetLocales = [];
+  let hadError = false;
+  for (const locale of locales) {
+    const spinner7 = p8.spinner();
+    spinner7.start(`Removing ${locale}\u2026`);
+    try {
+      const result = await api.removeLocale(locale);
+      lastTargetLocales = result.targetLocales;
+      spinner7.stop(`Removed ${chalk9.cyan(locale)}`);
+    } catch (error) {
+      spinner7.stop(`Failed to remove ${chalk9.red(locale)}`);
+      hadError = true;
+      p8.log.error(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+  if (lastTargetLocales.length > 0) {
+    p8.log.info(
+      `Target locales now: ${lastTargetLocales.map((l) => chalk9.cyan(l)).join(", ")}`
+    );
+  } else if (!hadError) {
+    p8.log.info("Target locales now: (none configured)");
+  }
+  return hadError ? 1 : 0;
+}
+async function listSupportedLocales(options = {}) {
+  const config = getApiConfig(options);
+  if (!config) return 1;
+  const api = new VocoderAPI(config);
+  try {
+    const result = await api.listLocales(config.apiKey);
+    p8.log.info(chalk9.bold("Source locales:"));
+    printLocaleTable(result.sourceLocales);
+    p8.log.info("");
+    p8.log.info(chalk9.bold("Target locales:"));
+    printLocaleTable(result.targetLocales);
+    return 0;
+  } catch (error) {
+    p8.log.error(
+      error instanceof Error ? error.message : "Failed to fetch supported locales."
+    );
+    return 1;
+  }
+}
+function printLocaleTable(locales) {
+  for (const locale of locales) {
+    const native = locale.nativeName && locale.nativeName !== locale.name ? ` (${locale.nativeName})` : "";
+    p8.log.info(`  ${chalk9.cyan(locale.code.padEnd(10))} ${locale.name}${native}`);
+  }
+}
+
+// src/commands/logout.ts
 import * as p9 from "@clack/prompts";
-import chalk9 from "chalk";
+async function logout(options = {}) {
+  const stored = readAuthData();
+  if (!stored) {
+    p9.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();
+  p9.log.success(`Logged out (was ${stored.email})`);
+  return 0;
+}
+
+// src/commands/project-config.ts
+import * as p10 from "@clack/prompts";
+import chalk10 from "chalk";
+import { config as loadEnv4 } from "dotenv";
+loadEnv4();
+async function projectConfig(options = {}) {
+  const apiKey = process.env.VOCODER_API_KEY;
+  if (!apiKey) {
+    p10.log.error(
+      "VOCODER_API_KEY is not set. Run `npx @vocoder/cli init` to set up your project."
+    );
+    return 1;
+  }
+  const apiUrl = options.apiUrl ?? process.env.VOCODER_API_URL ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiKey, apiUrl });
+  try {
+    const config = await api.getProjectConfig();
+    const lines = [
+      `Project:         ${chalk10.bold(config.projectName)}`,
+      `Organization:    ${config.organizationName}`,
+      `Source locale:   ${chalk10.cyan(config.sourceLocale)}`,
+      `Target locales:  ${config.targetLocales.length > 0 ? config.targetLocales.map((l) => chalk10.cyan(l)).join(", ") : chalk10.dim("(none)")}`,
+      `Target branches: ${config.targetBranches.map((b) => chalk10.cyan(b)).join(", ")}`,
+      ...config.primaryBranch ? [`Primary branch:  ${chalk10.cyan(config.primaryBranch)}`] : [],
+      `Sync policy:`,
+      `  Blocking branches: ${config.syncPolicy.blockingBranches.map((b) => chalk10.cyan(b)).join(", ")}`,
+      `  Blocking mode:     ${chalk10.cyan(config.syncPolicy.blockingMode)}`,
+      `  Non-blocking mode: ${chalk10.cyan(config.syncPolicy.nonBlockingMode)}`,
+      `  Max wait:          ${chalk10.cyan(String(config.syncPolicy.defaultMaxWaitMs))} ms`
+    ];
+    p10.note(lines.join("\n"), `${config.projectName} \u2014 project config`);
+    return 0;
+  } catch (error) {
+    p10.log.error(
+      error instanceof Error ? error.message : "Failed to fetch project config."
+    );
+    return 1;
+  }
+}
+
+// src/commands/translations.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync4 } from "fs";
+import { join as join4 } from "path";
+import * as p11 from "@clack/prompts";
+import chalk11 from "chalk";
+import { config as loadEnv5 } from "dotenv";
+loadEnv5();
+async function getTranslations(options = {}) {
+  const apiKey = process.env.VOCODER_API_KEY;
+  if (!apiKey) {
+    p11.log.error(
+      "VOCODER_API_KEY is not set. Run `npx @vocoder/cli init` to set up your project."
+    );
+    return 1;
+  }
+  const apiUrl = options.apiUrl ?? process.env.VOCODER_API_URL ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiKey, apiUrl });
+  let branch;
+  try {
+    branch = detectBranch(options.branch);
+  } catch (error) {
+    p11.log.error(
+      error instanceof Error ? error.message : "Failed to detect branch."
+    );
+    return 1;
+  }
+  const spinner7 = p11.spinner();
+  spinner7.start(`Fetching translations for ${chalk11.cyan(branch)}\u2026`);
+  try {
+    const projectConfig2 = await api.getProjectConfig();
+    const targetLocales = options.locale ? [options.locale] : projectConfig2.targetLocales;
+    if (targetLocales.length === 0) {
+      spinner7.stop("No target locales configured.");
+      p11.log.info("Add target locales with `vocoder locales add <code>`.");
+      return 1;
+    }
+    const snapshot = await api.getTranslationSnapshot({ branch, targetLocales });
+    spinner7.stop(`Fetched translations for ${chalk11.cyan(branch)}`);
+    if (snapshot.status === "NOT_FOUND") {
+      p11.log.warn(
+        `No translation snapshot found for branch "${branch}". Run \`vocoder sync\` to generate one.`
+      );
+      return 1;
+    }
+    const translations = snapshot.translations ?? {};
+    if (options.output) {
+      writeLocaleFiles(translations, options.output);
+    } else {
+      process.stdout.write(JSON.stringify(translations, null, 2));
+      process.stdout.write("\n");
+    }
+    return 0;
+  } catch (error) {
+    spinner7.stop("Failed to fetch translations.");
+    p11.log.error(
+      error instanceof Error ? error.message : "Unknown error."
+    );
+    return 1;
+  }
+}
+function writeLocaleFiles(translations, outputDir) {
+  mkdirSync2(outputDir, { recursive: true });
+  for (const [locale, strings] of Object.entries(translations)) {
+    const filePath = join4(outputDir, `${locale}.json`);
+    writeFileSync4(filePath, JSON.stringify(strings, null, 2) + "\n", "utf-8");
+    p11.log.success(`Wrote ${chalk11.cyan(filePath)}`);
+  }
+}
+
+// src/commands/create-project.ts
+import * as p12 from "@clack/prompts";
+import chalk12 from "chalk";
+import { config as loadEnv6 } from "dotenv";
+loadEnv6();
+async function createProject(options) {
+  const authData = readAuthData();
+  if (!authData) {
+    p12.log.error(
+      "Not logged in. Run `npx @vocoder/cli init` to authenticate first."
+    );
+    return 1;
+  }
+  const apiUrl = options.apiUrl ?? process.env.VOCODER_API_URL ?? "https://vocoder.app";
+  const api = new VocoderAPI({ apiKey: "", apiUrl });
+  let repoCanonical;
+  let appDir = options.appDir ?? ".";
+  if (options.repo) {
+    repoCanonical = options.repo;
+  } else {
+    const identity = resolveGitRepositoryIdentity();
+    if (identity) {
+      repoCanonical = identity.repoCanonical;
+      if (!options.appDir && identity.repoAppDir) {
+        appDir = identity.repoAppDir;
+      }
+    } else {
+      p12.log.warn(
+        "Could not detect a git remote. The project will be created without repo binding \u2014 sync-on-push will not function until a repository is connected via the Vocoder dashboard."
+      );
+    }
+  }
+  const targetLocales = options.targetLocales ? options.targetLocales.split(",").map((l) => l.trim()).filter(Boolean) : [];
+  const targetBranches = options.targetBranches ? options.targetBranches.split(",").map((b) => b.trim()).filter(Boolean) : ["main"];
+  const spinner7 = p12.spinner();
+  spinner7.start(`Creating project "${options.name}"\u2026`);
+  try {
+    const result = await api.createProject(authData.token, {
+      organizationId: options.workspace,
+      name: options.name,
+      sourceLocale: options.sourceLocale,
+      targetLocales,
+      targetBranches,
+      appDirs: [appDir],
+      ...repoCanonical ? { repoCanonical } : {}
+    });
+    spinner7.stop(`Created project ${chalk12.bold(result.projectName)}`);
+    const lines = [
+      `Project ID:     ${result.projectId}`,
+      `Source locale:  ${chalk12.cyan(result.sourceLocale)}`,
+      `Target locales: ${result.targetLocales.length > 0 ? result.targetLocales.map((l) => chalk12.cyan(l)).join(", ") : chalk12.dim("(none)")}`,
+      `Branches:       ${result.targetBranches.map((b) => chalk12.cyan(b)).join(", ")}`,
+      ...repoCanonical ? [`Repository:     ${chalk12.cyan(repoCanonical)}${appDir !== "." ? ` (${appDir})` : ""}`] : [],
+      "",
+      `Add this to your .env file:`,
+      `  ${chalk12.bold("VOCODER_API_KEY")}=${chalk12.cyan(result.apiKey)}`
+    ];
+    p12.note(lines.join("\n"), "Project created");
+    if (!result.repositoryBound && repoCanonical) {
+      p12.log.warn(
+        `Repository "${repoCanonical}" was not automatically connected. Ensure your GitHub App installation covers this repository.`
+      );
+    }
+    return 0;
+  } catch (error) {
+    spinner7.stop("Failed to create project.");
+    if (error instanceof VocoderAPIError && error.limitError) {
+      const { limitError } = error;
+      p12.log.error(limitError.message);
+      for (const line of getLimitErrorGuidance(limitError)) {
+        p12.log.info(line);
+      }
+      return 1;
+    }
+    p12.log.error(
+      error instanceof Error ? error.message : "Unknown error."
+    );
+    return 1;
+  }
+}
+
+// src/commands/whoami.ts
+import * as p13 from "@clack/prompts";
+import chalk13 from "chalk";
 async function whoami(options = {}) {
   const stored = readAuthData();
   if (!stored) {
-    p9.log.info("Not logged in. Run `vocoder init` to authenticate.");
+    p13.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);
-    p9.log.info(`Logged in as ${chalk9.bold(info.email)}`);
+    p13.log.info(`Logged in as ${chalk13.bold(info.email)}`);
     if (info.name) {
-      p9.log.info(`Name: ${info.name}`);
+      p13.log.info(`Name: ${info.name}`);
     }
-    p9.log.info(`API: ${apiUrl}`);
+    p13.log.info(`API: ${apiUrl}`);
     return 0;
   } catch {
-    p9.log.error(
+    p13.log.error(
       "Stored credentials are invalid or expired. Run `vocoder init` to re-authenticate."
     );
     return 1;
@@ -3738,5 +3325,38 @@ program.command("sync").description("Extract strings and sync translations").opt
 });
 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));
+var localesCmd = program.command("locales").description("Manage project target locales").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(listProjectLocales, options));
+localesCmd.command("add <codes...>").description("Add one or more target locales by BCP 47 code (e.g. fr de pt-BR)").option("--api-url <url>", "Override Vocoder API URL").action(
+  (codes, options) => runCommand((opts) => addLocales(codes, opts), options)
+);
+localesCmd.command("remove <codes...>").description("Remove one or more target locales by BCP 47 code").option("--api-url <url>", "Override Vocoder API URL").action(
+  (codes, options) => runCommand((opts) => removeLocales(codes, opts), options)
+);
+localesCmd.command("supported").description("List all locales supported by Vocoder").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(listSupportedLocales, options));
+program.command("project").description("Show current project configuration").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(projectConfig, options));
+program.command("translations").description("Download the current translation snapshot").option("--branch <branch>", "Git branch (auto-detected if omitted)").option("--locale <locale>", "Fetch a specific locale only").option("--output <dir>", "Write locale JSON files to this directory").option("--api-url <url>", "Override Vocoder API URL").action((options) => runCommand(getTranslations, options));
+program.command("create-project").description("Create a new Vocoder project (requires prior `vocoder init`)").requiredOption("--name <name>", "Project display name").requiredOption("--source-locale <code>", "Source language BCP 47 code (e.g. en)").requiredOption("--workspace <org-id>", "Workspace organization ID").option(
+  "--target-locales <codes>",
+  "Comma-separated target locale codes (e.g. fr,de,pt-BR)"
+).option(
+  "--target-branches <branches>",
+  "Comma-separated branch names to sync (default: main)"
+).option(
+  "--repo <canonical>",
+  "Git repo canonical (e.g. github:owner/repo). Auto-detected from git remote if omitted."
+).option(
+  "--app-dir <path>",
+  "App directory within the repo for monorepos (default: .)"
+).option("--api-url <url>", "Override Vocoder API URL").action((options) => {
+  const translated = {
+    ...options,
+    // Commander camelCases dashed options
+    sourceLocale: options.sourceLocale,
+    targetLocales: options.targetLocales,
+    targetBranches: options.targetBranches,
+    workspace: options.workspace
+  };
+  return runCommand(createProject, translated);
+});
 program.parse(process.argv);
 //# sourceMappingURL=bin.mjs.map