@vocoder/cli 0.11.0 → 0.12.0

package/dist/bin.mjs

@@ -11,8 +11,9 @@ import {
   getSetupSnippets,
   loadVocoderConfig,
   readAuthData,
+  verifyStoredAuth,
   writeAuthData
-} from "./chunk-XF3KGGYQ.mjs";
+} from "./chunk-XUCVAFBG.mjs";
 
 // src/bin.ts
 import { Command } from "commander";
@@ -1447,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) {
@@ -1638,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.");
@@ -1683,46 +1673,23 @@ async function init(options = {}) {
     let userEmail;
     let userName;
     let authOrganizationId;
-    const stored = readAuthData();
-    if (stored) {
-      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,
-          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;
@@ -2142,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, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join3 } from "path";
-import * as p8 from "@clack/prompts";
+import * as p7 from "@clack/prompts";
 import chalk8 from "chalk";
 
 // src/utils/branch.ts
@@ -2235,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();
@@ -2294,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.`
     );
   }
@@ -2325,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;
@@ -2382,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,
@@ -2560,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}`,
@@ -2644,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"
@@ -2683,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,
@@ -2702,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) {
@@ -2717,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}`,
@@ -2731,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."
       );
     }
@@ -2744,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`
       );
     }
@@ -2753,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,
@@ -2778,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) {
@@ -2816,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(
@@ -2825,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;
             }
           }
@@ -2835,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) {
@@ -2851,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, {
@@ -2867,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}`);
           }
         }
       }
@@ -2907,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;
@@ -3017,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