@vocoder/cli 0.1.20 → 0.1.22

package/dist/bin.mjs

@@ -12,6 +12,8 @@ import { Command } from "commander";
 
 // src/commands/init.ts
 import { execSync as execSync3, spawn as spawn2 } from "child_process";
+import { existsSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join2 } from "path";
 import * as p5 from "@clack/prompts";
 import chalk6 from "chalk";
 import { config as loadEnv } from "dotenv";
@@ -593,6 +595,25 @@ var VocoderAPI = class {
       });
     }
     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 ──────────────────────────────────────────────────────────
@@ -1619,17 +1640,16 @@ async function runProjectCreate(params) {
   const { api, userToken, organizationId, repoCanonical } = params;
   const projectName = (params.defaultName ?? "my-project").trim();
   p3.log.success(`Project: ${chalk4.bold(projectName)}`);
-  let rawLocales;
+  let sourceLocales;
   try {
-    rawLocales = await api.listLocales(userToken);
+    ({ sourceLocales } = await api.listLocales(userToken));
   } catch {
     p3.log.error(
       "Failed to fetch supported locales. Check your connection and try again."
     );
     return null;
   }
-  const languageOptions = buildLanguageOptions(rawLocales);
-  const localeOptions = buildLocaleOptions(rawLocales);
+  const languageOptions = buildLanguageOptions(sourceLocales);
   let appDir;
   if (params.defaultAppDir) {
     appDir = params.defaultAppDir;
@@ -1656,6 +1676,16 @@ async function runProjectCreate(params) {
     params.defaultSourceLocale ?? "en"
   );
   if (sourceLocale === null) return null;
+  let compatibleTargets;
+  try {
+    compatibleTargets = await api.listCompatibleLocales(userToken, sourceLocale);
+  } catch {
+    p3.log.error(
+      "Failed to fetch compatible target locales. Check your connection and try again."
+    );
+    return null;
+  }
+  const localeOptions = buildLocaleOptions(compatibleTargets);
   const targetOptions = localeOptions.filter(
     (opt) => opt.bcp47 !== sourceLocale
   );
@@ -1714,17 +1744,16 @@ async function runProjectCreate(params) {
 async function runProjectAppCreate(params) {
   const { api, userToken, projectId, projectName, repoCanonical } = params;
   const existingScopes = new Set(params.existingApps.map((a) => a.appDir));
-  let rawLocales;
+  let sourceLocales;
   try {
-    rawLocales = await api.listLocales(userToken);
+    ({ sourceLocales } = await api.listLocales(userToken));
   } catch {
     p3.log.error(
       "Failed to fetch supported locales. Check your connection and try again."
     );
     return null;
   }
-  const languageOptions = buildLanguageOptions(rawLocales);
-  const localeOptions = buildLocaleOptions(rawLocales);
+  const languageOptions = buildLanguageOptions(sourceLocales);
   let appDir;
   if (params.defaultAppDir && !existingScopes.has(params.defaultAppDir)) {
     appDir = params.defaultAppDir;
@@ -1761,7 +1790,16 @@ async function runProjectAppCreate(params) {
     "en"
   );
   if (sourceLocale === null) return null;
-  const targetOptions = localeOptions.filter(
+  let compatibleTargets;
+  try {
+    compatibleTargets = await api.listCompatibleLocales(userToken, sourceLocale);
+  } catch {
+    p3.log.error(
+      "Failed to fetch compatible target locales. Check your connection and try again."
+    );
+    return null;
+  }
+  const targetOptions = buildLocaleOptions(compatibleTargets).filter(
     (opt) => opt.bcp47 !== sourceLocale
   );
   const targetLocales = await searchMultiSelectLocales(
@@ -1955,62 +1993,74 @@ function runScaffold(params) {
     sourceLocale,
     targetBranches
   });
-  let stepNum = 1;
+  const steps = [];
   if (snippets.pluginStep) {
-    p5.log.message("");
-    p5.log.step(
-      `${chalk6.bold(`Step ${stepNum}:`)} Add the plugin to ${chalk6.cyan(snippets.pluginStep.file)}`
-    );
-    printCodeBlock(snippets.pluginStep.code);
-    stepNum++;
+    steps.push({
+      label: snippets.pluginStep.file,
+      hint: "register the build plugin so Vocoder can extract your strings",
+      code: snippets.pluginStep.code
+    });
   }
   if (snippets.providerStep) {
+    steps.push({
+      label: snippets.providerStep.file,
+      hint: "wrap your app so translations load at runtime",
+      code: snippets.providerStep.code
+    });
+  }
+  steps.push({
+    label: "wrap translatable text",
+    hint: "mark strings for extraction \u2014 Vocoder picks these up on push",
+    code: snippets.wrapStep.code
+  });
+  p5.log.message("");
+  p5.log.message(chalk6.bold("Finish setup in your code"));
+  p5.log.message("");
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
     p5.log.step(
-      `${chalk6.bold(`Step ${stepNum}:`)} Add the provider to ${chalk6.cyan(snippets.providerStep.file)}`
+      `${chalk6.bold(step.label)}  ${chalk6.dim(`\u2014 ${step.hint}`)}`
     );
-    printCodeBlock(snippets.providerStep.code);
-    stepNum++;
+    printCodeBlock(step.code);
+    if (i < steps.length - 1) p5.log.message("");
   }
-  p5.log.step(`${chalk6.bold(`Step ${stepNum}:`)} Wrap translatable strings`);
-  printCodeBlock(snippets.wrapStep.code);
   p5.log.message("");
-  for (const line of snippets.whatsNext.split("\n")) {
-    p5.log.success(line);
+  const branchList = targetBranches.length > 0 ? targetBranches.map((b) => chalk6.cyan(b)).join(" or ") : chalk6.cyan("your target branch");
+  p5.log.success(
+    `Push to ${branchList} to trigger your first translation run.`
+  );
+  p5.log.message(chalk6.gray("  Docs: https://vocoder.app/docs/getting-started"));
+}
+function writeApiKeyToEnv(apiKey) {
+  const envPath = join2(process.cwd(), ".env");
+  if (!existsSync(envPath)) return false;
+  try {
+    const content = readFileSync2(envPath, "utf-8");
+    const keyLine = `VOCODER_API_KEY=${apiKey}`;
+    let updated;
+    if (/^VOCODER_API_KEY=/m.test(content)) {
+      updated = content.replace(/^VOCODER_API_KEY=.*/m, keyLine);
+    } else {
+      const sep = content.length > 0 && !content.endsWith("\n") ? "\n" : "";
+      updated = `${content}${sep}${keyLine}
+`;
+    }
+    writeFileSync2(envPath, updated);
+    return true;
+  } catch {
+    return false;
   }
 }
-function printMcpSetup(apiKey) {
-  const addCommand = `claude mcp add --scope project --transport stdio \\
-  --env VOCODER_API_KEY=${apiKey} \\
-  vocoder -- npx -y @vocoder/mcp`;
-  const teamConfig = JSON.stringify(
-    {
-      mcpServers: {
-        vocoder: {
-          type: "stdio",
-          command: "npx",
-          args: ["-y", "@vocoder/mcp"],
-          // biome-ignore lint/suspicious/noTemplateCurlyInString: MCP config template, not a JS template literal
-          env: { VOCODER_API_KEY: "${env:VOCODER_API_KEY}" }
-        }
-      }
-    },
-    null,
-    2
-  );
-  p5.log.message("");
-  p5.log.message(chalk6.bold("Use Vocoder with Claude Code"));
-  p5.log.message("Run this to add the MCP server to your project:");
-  p5.log.message("");
-  printCodeBlock(addCommand);
+function printApiKey(apiKey) {
+  const saved = writeApiKeyToEnv(apiKey);
   p5.log.message("");
-  p5.log.message(
-    "To share with your team, commit " + chalk6.cyan(".mcp.json") + " with an env var reference"
-  );
-  p5.log.message("so each developer supplies their own key:");
-  p5.log.message("");
-  printCodeBlock(teamConfig);
-  p5.log.message("");
-  p5.log.message(chalk6.gray("Setup instructions: https://vocoder.app/docs/mcp"));
+  p5.log.message(chalk6.bold("Your API Key"));
+  printCodeBlock(`VOCODER_API_KEY=${apiKey}`);
+  if (saved) {
+    p5.log.success(chalk6.dim("Saved to .env"));
+  } else {
+    p5.log.message(chalk6.dim("  Add the above to your .env file"));
+  }
 }
 function printCodeBlock(code) {
   const lines = code.split("\n");
@@ -2234,7 +2284,7 @@ async function init(options = {}) {
               exactMatch.projectId
             );
             spinner4.stop("New API key generated");
-            printMcpSetup(apiKey);
+            printApiKey(apiKey);
           } catch (err) {
             spinner4.stop("Failed to generate key");
             const msg = err instanceof Error ? err.message : String(err);
@@ -2709,7 +2759,7 @@ Translations won't run automatically until you grant access.
       sourceLocale: projectResult.sourceLocale,
       targetBranches: projectResult.targetBranches
     });
-    printMcpSetup(projectResult.apiKey);
+    printApiKey(projectResult.apiKey);
     p5.outro("You're all set.");
     return 0;
   } catch (error) {
@@ -2747,9 +2797,9 @@ async function logout(options = {}) {
 
 // src/commands/sync.ts
 import { createHash, randomUUID } from "crypto";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join2 } from "path";
-import * as p7 from "@clack/prompts";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join3 } from "path";
+import * as p8 from "@clack/prompts";
 import chalk8 from "chalk";
 
 // src/utils/branch.ts
@@ -2819,6 +2869,7 @@ function matchBranchPattern(branch, pattern) {
 }
 
 // src/utils/config.ts
+import * as p7 from "@clack/prompts";
 import chalk7 from "chalk";
 import { config as loadEnv2 } from "dotenv";
 loadEnv2();
@@ -2896,7 +2947,7 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
     excludePattern = cliOptions.exclude;
     configSources.excludePattern = "CLI flag";
   } else if (envExcludePattern) {
-    excludePattern = envExcludePattern.split(",").map((p9) => p9.trim()).filter(Boolean);
+    excludePattern = envExcludePattern.split(",").map((p10) => p10.trim()).filter(Boolean);
     configSources.excludePattern = "environment";
   } else {
     excludePattern = defaults.excludePattern;
@@ -2944,24 +2995,16 @@ async function getMergedConfig(cliOptions, verbose = false, _startDir) {
     configSources.noFallback = "environment";
   }
   if (verbose) {
-    console.log(chalk7.dim("\n   Configuration sources:"));
-    console.log(
-      chalk7.dim(`     Include patterns: ${configSources.includePattern}`)
-    );
-    if (excludePattern.length > 0) {
-      console.log(
-        chalk7.dim(`     Exclude patterns: ${configSources.excludePattern}`)
-      );
-    }
-    console.log(chalk7.dim(`     API key: ${configSources.apiKey}`));
-    console.log(chalk7.dim(`     API URL: ${configSources.apiUrl}
-`));
-    console.log(chalk7.dim(`     Sync mode: ${configSources.mode}`));
-    if (maxWaitMs) {
-      console.log(chalk7.dim(`     Max wait: ${configSources.maxWaitMs}`));
-    }
-    console.log(chalk7.dim(`     No fallback: ${configSources.noFallback}
-`));
+    const lines = [
+      `Include patterns: ${chalk7.cyan(configSources.includePattern)}`,
+      ...excludePattern.length > 0 ? [`Exclude patterns: ${chalk7.cyan(configSources.excludePattern)}`] : [],
+      `API key:          ${chalk7.cyan(configSources.apiKey)}`,
+      `API URL:          ${chalk7.cyan(configSources.apiUrl)}`,
+      `Sync mode:        ${chalk7.cyan(configSources.mode)}`,
+      ...maxWaitMs ? [`Max wait:         ${chalk7.cyan(String(configSources.maxWaitMs))}`] : [],
+      `No fallback:      ${chalk7.cyan(String(configSources.noFallback))}`
+    ];
+    p7.note(lines.join("\n"), "Configuration sources");
   }
   return {
     includePattern,
@@ -2982,9 +3025,9 @@ function computeStringsHash(texts) {
 }
 function readCachedStringsHash(projectRoot, branch) {
   const filePath = getCacheFilePath(projectRoot, branch);
-  if (!existsSync(filePath)) return null;
+  if (!existsSync2(filePath)) return null;
   try {
-    const raw = JSON.parse(readFileSync2(filePath, "utf-8"));
+    const raw = JSON.parse(readFileSync3(filePath, "utf-8"));
     if (isRecord(raw) && typeof raw.stringsHash === "string")
       return raw.stringsHash;
   } catch {
@@ -3036,7 +3079,7 @@ function parseTranslations(value) {
 }
 function getCacheFilePath(projectRoot, branch) {
   const branchHash = createHash("sha1").update(branch).digest("hex").slice(0, 12);
-  return join2(
+  return join3(
     projectRoot,
     "node_modules",
     ".vocoder",
@@ -3049,11 +3092,11 @@ function readLocalSnapshotCache(params) {
   const candidateBranches = params.branch === "main" ? ["main"] : [params.branch, "main"];
   for (const candidateBranch of candidateBranches) {
     const cacheFilePath = getCacheFilePath(params.projectRoot, candidateBranch);
-    if (!existsSync(cacheFilePath)) {
+    if (!existsSync2(cacheFilePath)) {
       continue;
     }
     try {
-      const raw = readFileSync2(cacheFilePath, "utf-8");
+      const raw = readFileSync3(cacheFilePath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!isRecord(parsed)) {
         continue;
@@ -3079,7 +3122,7 @@ function readLocalSnapshotCache(params) {
 function writeLocalSnapshotCache(params) {
   const cacheFilePath = getCacheFilePath(params.projectRoot, params.branch);
   mkdirSync2(
-    join2(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"),
+    join3(params.projectRoot, "node_modules", ".vocoder", "cache", "sync"),
     {
       recursive: true
     }
@@ -3096,7 +3139,7 @@ function writeLocalSnapshotCache(params) {
     ...params.localeMetadata ? { localeMetadata: params.localeMetadata } : {},
     translations: params.translations
   };
-  writeFileSync2(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
+  writeFileSync3(cacheFilePath, JSON.stringify(payload, null, 2), "utf-8");
   return cacheFilePath;
 }
 function resolveEffectiveModeFromPolicy(params) {
@@ -3250,8 +3293,8 @@ async function fetchApiSnapshot(api, params) {
 async function sync(options = {}) {
   const startTime = Date.now();
   const projectRoot = process.cwd();
-  p7.intro("Vocoder Sync");
-  const spinner4 = p7.spinner();
+  p8.intro("Vocoder Sync");
+  const spinner4 = p8.spinner();
   try {
     spinner4.start("Detecting branch");
     const branch = detectBranch(options.branch);
@@ -3280,12 +3323,12 @@ async function sync(options = {}) {
     };
     spinner4.stop("Project configuration loaded");
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
-      p7.log.warn(
+      p8.log.warn(
         `Skipping translations (${chalk8.cyan(branch)} is not a target branch)`
       );
-      p7.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
-      p7.log.info("Use --force to translate anyway");
-      p7.outro("");
+      p8.log.info(`Target branches: ${config.targetBranches.join(", ")}`);
+      p8.log.info("Use --force to translate anyway");
+      p8.outro("");
       return 0;
     }
     const patternsDisplay = Array.isArray(config.includePattern) ? config.includePattern.join(", ") : config.includePattern;
@@ -3298,10 +3341,10 @@ async function sync(options = {}) {
     );
     if (extractedStrings.length === 0) {
       spinner4.stop("No translatable strings found");
-      p7.log.warn(
+      p8.log.warn(
         "Make sure you are wrapping translatable strings with Vocoder"
       );
-      p7.outro("");
+      p8.outro("");
       return 0;
     }
     spinner4.stop(
@@ -3312,10 +3355,10 @@ async function sync(options = {}) {
       if (extractedStrings.length > 5) {
         sampleLines.push(`  ... and ${extractedStrings.length - 5} more`);
       }
-      p7.note(sampleLines.join("\n"), "Sample strings");
+      p8.note(sampleLines.join("\n"), "Sample strings");
     }
     if (options.dryRun) {
-      p7.note(
+      p8.note(
         [
           `Strings: ${extractedStrings.length}`,
           `Branch: ${branch}`,
@@ -3326,12 +3369,12 @@ async function sync(options = {}) {
         ].join("\n"),
         "Dry run - would translate"
       );
-      p7.outro("No API calls made.");
+      p8.outro("No API calls made.");
       return 0;
     }
     const repoIdentity = resolveGitRepositoryIdentity();
     if (!repoIdentity && options.verbose) {
-      p7.log.warn(
+      p8.log.warn(
         "Could not detect git remote origin. Sync will continue without repo metadata."
       );
     }
@@ -3339,16 +3382,32 @@ async function sync(options = {}) {
     const stringEntries = buildStringEntries(extractedStrings);
     const sourceStrings = stringEntries.map((entry) => entry.text);
     if (options.verbose && stringEntries.length !== extractedStrings.length) {
-      p7.log.info(
+      p8.log.info(
         `Deduped ${extractedStrings.length} extracted entries into ${stringEntries.length} unique source strings`
       );
     }
     const currentHash = computeStringsHash(sourceStrings);
     if (!options.force) {
       const cachedHash = readCachedStringsHash(projectRoot, branch);
+      if (options.verbose) {
+        const cacheFile = getCacheFilePath(projectRoot, branch);
+        if (cachedHash) {
+          p8.log.info(
+            `Local cache: ${chalk8.dim(cacheFile)}
+  cached hash ${chalk8.cyan(cachedHash.slice(0, 8))}\u2026 vs current ${chalk8.cyan(currentHash.slice(0, 8))}\u2026 \u2014 ${cachedHash === currentHash ? chalk8.green("match") : chalk8.yellow("changed")}`
+          );
+        } else {
+          p8.log.info(`No local cache found at ${chalk8.dim(cacheFile)} \u2014 will submit to API`);
+        }
+      }
       if (cachedHash && cachedHash === currentHash) {
+        if (options.verbose) {
+          p8.log.info(
+            "Skipping API submission \u2014 delete node_modules/.vocoder to force a fresh sync"
+          );
+        }
         const duration2 = ((Date.now() - startTime) / 1e3).toFixed(1);
-        p7.outro(`Up to date (${duration2}s)`);
+        p8.outro(`Up to date (${duration2}s)`);
         return 0;
       }
     }
@@ -3373,31 +3432,31 @@ async function sync(options = {}) {
       policy: config.syncPolicy
     });
     if (options.verbose) {
-      p7.log.info(`Requested mode: ${requestedMode}`);
-      p7.log.info(`Effective mode: ${effectiveMode}`);
-      p7.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
+      p8.log.info(`Requested mode: ${requestedMode}`);
+      p8.log.info(`Effective mode: ${effectiveMode}`);
+      p8.log.info(`Wait timeout: ${waitTimeoutMs}ms`);
       if (batchResponse.queueStatus) {
-        p7.log.info(`Queue status: ${batchResponse.queueStatus}`);
+        p8.log.info(`Queue status: ${batchResponse.queueStatus}`);
       }
     }
     if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      p7.log.success("No changes detected - strings are up to date");
+      p8.log.success("No changes detected - strings are up to date");
     }
-    p7.log.info(`New strings: ${chalk8.cyan(batchResponse.newStrings)}`);
+    p8.log.info(`New strings: ${chalk8.cyan(batchResponse.newStrings)}`);
     if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
-      p7.log.info(
+      p8.log.info(
         `Deleted strings: ${chalk8.yellow(batchResponse.deletedStrings)} (archived)`
       );
     }
-    p7.log.info(`Total strings: ${chalk8.cyan(batchResponse.totalStrings)}`);
+    p8.log.info(`Total strings: ${chalk8.cyan(batchResponse.totalStrings)}`);
     if (batchResponse.newStrings === 0) {
-      p7.log.success("No new strings - using existing translations");
+      p8.log.success("No new strings - using existing translations");
     } else {
-      p7.log.info(
+      p8.log.info(
         `Syncing to ${config.targetLocales.length} locales (${config.targetLocales.join(", ")})`
       );
       if (batchResponse.estimatedTime) {
-        p7.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
+        p8.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
       }
     }
     let artifacts = null;
@@ -3435,7 +3494,7 @@ async function sync(options = {}) {
         if (effectiveMode === "required") {
           throw waitError;
         }
-        p7.log.warn(`Best-effort wait ended early: ${waitError.message}`);
+        p8.log.warn(`Best-effort wait ended early: ${waitError.message}`);
       }
     }
     if (!artifacts) {
@@ -3469,7 +3528,7 @@ async function sync(options = {}) {
           spinner4.stop("Failed to fetch API snapshot");
           if (options.verbose) {
             const message = error instanceof Error ? error.message : "Unknown snapshot fetch error";
-            p7.log.warn(`Snapshot fetch error: ${message}`);
+            p8.log.warn(`Snapshot fetch error: ${message}`);
           }
         }
       }
@@ -3503,61 +3562,61 @@ async function sync(options = {}) {
         completedAt: artifacts.completedAt ?? (artifacts.source === "fresh" ? (/* @__PURE__ */ new Date()).toISOString() : null)
       });
       if (options.verbose) {
-        p7.log.info(`Cached snapshot: ${cachePath}`);
+        p8.log.info(`Cached snapshot: ${cachePath}`);
       }
     } catch (error) {
       if (options.verbose) {
         const message = error instanceof Error ? error.message : "Unknown cache write error";
-        p7.log.warn(`Failed to write local snapshot cache: ${message}`);
+        p8.log.warn(`Failed to write local snapshot cache: ${message}`);
       }
     }
     if (artifacts.source !== "fresh") {
       const sourceLabel = artifacts.source === "local-cache" ? "local cached snapshot" : "completed API snapshot";
-      p7.log.warn(
+      p8.log.warn(
         `Using ${sourceLabel}. New strings may appear after the background sync completes.`
       );
     }
     const duration = ((Date.now() - startTime) / 1e3).toFixed(1);
-    p7.outro(`Sync complete! (${duration}s)`);
+    p8.outro(`Sync complete! (${duration}s)`);
     return 0;
   } catch (error) {
     spinner4.stop();
     if (error instanceof VocoderAPIError && error.syncPolicyError) {
-      p7.log.error(error.syncPolicyError.message);
+      p8.log.error(error.syncPolicyError.message);
       const guidance = getSyncPolicyErrorGuidance(error.syncPolicyError);
       for (const line of guidance) {
-        p7.log.info(line);
+        p8.log.info(line);
       }
       return 1;
     }
     if (error instanceof VocoderAPIError && error.limitError) {
       const { limitError } = error;
-      p7.log.error(limitError.message);
+      p8.log.error(limitError.message);
       const guidance = getLimitErrorGuidance(limitError);
       for (const line of guidance) {
-        p7.log.info(line);
+        p8.log.info(line);
       }
       return 1;
     }
     if (error instanceof Error) {
-      p7.log.error(error.message);
+      p8.log.error(error.message);
       if (error.message.includes("VOCODER_API_KEY")) {
-        p7.log.warn(
+        p8.log.warn(
           "VOCODER_API_KEY is only needed for `vocoder sync` (CLI push)."
         );
-        p7.log.info("  Create one at: https://vocoder.app/dashboard");
-        p7.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
-        p7.log.info("");
-        p7.log.info(
+        p8.log.info("  Create one at: https://vocoder.app/dashboard");
+        p8.log.info('  Then: export VOCODER_API_KEY="vc_..." or add it to .env');
+        p8.log.info("");
+        p8.log.info(
           "  Note: If you use @vocoder/unplugin, `vocoder sync` is optional."
         );
-        p7.log.info("  Translations are fetched automatically at build time.");
+        p8.log.info("  Translations are fetched automatically at build time.");
       } else if (error.message.includes("git branch")) {
-        p7.log.warn("Run from a git repository, or use:");
-        p7.log.info("  vocoder sync --branch main");
+        p8.log.warn("Run from a git repository, or use:");
+        p8.log.info("  vocoder sync --branch main");
       }
       if (options.verbose) {
-        p7.log.info(`Full error: ${error.stack ?? error}`);
+        p8.log.info(`Full error: ${error.stack ?? error}`);
       }
     }
     return 1;
@@ -3565,26 +3624,26 @@ async function sync(options = {}) {
 }
 
 // src/commands/whoami.ts
-import * as p8 from "@clack/prompts";
+import * as p9 from "@clack/prompts";
 import chalk9 from "chalk";
 async function whoami(options = {}) {
   const stored = readAuthData();
   if (!stored) {
-    p8.log.info("Not logged in. Run `vocoder init` to authenticate.");
+    p9.log.info("Not logged in. Run `vocoder init` to authenticate.");
     return 1;
   }
   const apiUrl = options.apiUrl ?? stored.apiUrl ?? "https://vocoder.app";
   const api = new VocoderAPI({ apiUrl, apiKey: "" });
   try {
     const info = await api.getCliUserInfo(stored.token);
-    p8.log.info(`Logged in as ${chalk9.bold(info.email)}`);
+    p9.log.info(`Logged in as ${chalk9.bold(info.email)}`);
     if (info.name) {
-      p8.log.info(`Name: ${info.name}`);
+      p9.log.info(`Name: ${info.name}`);
     }
-    p8.log.info(`API: ${apiUrl}`);
+    p9.log.info(`API: ${apiUrl}`);
     return 0;
   } catch {
-    p8.log.error(
+    p9.log.error(
       "Stored credentials are invalid or expired. Run `vocoder init` to re-authenticate."
     );
     return 1;