@vocoder/cli 0.9.0 → 0.11.0

package/dist/bin.mjs

@@ -2,756 +2,36 @@
 import { createRequire as __createRequire } from 'module'; const require = __createRequire(import.meta.url);
 import {
   StringExtractor,
+  VocoderAPI,
+  VocoderAPIError,
   buildInstallCommand,
+  clearAuthData,
   detectLocalEcosystem,
   getPackagesToInstall,
   getSetupSnippets,
-  loadVocoderConfig
-} from "./chunk-IZN5HVYD.mjs";
+  loadVocoderConfig,
+  readAuthData,
+  writeAuthData
+} from "./chunk-XF3KGGYQ.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 } : {}
-    }));
-  }
-  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 } : {}
-        })
-      },
-      "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;
@@ -764,7 +44,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'
 
@@ -782,121 +62,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";
@@ -1182,7 +354,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";
@@ -1213,14 +385,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();
@@ -1230,7 +402,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();
@@ -1916,6 +1088,119 @@ async function runProjectAppCreate(params) {
   }
 }
 
+// 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;
+    }
+  }
+  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/workspace.ts
 import * as p4 from "@clack/prompts";
 import chalk5 from "chalk";
@@ -2109,10 +1394,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)) {
@@ -2122,7 +1407,7 @@ function writeApiKeyToEnv(apiKey) {
       updated = `${content}${sep}${keyLine}
 `;
     }
-    writeFileSync3(envPath, updated);
+    writeFileSync2(envPath, updated);
     return true;
   } catch {
     return false;
@@ -2399,7 +1684,7 @@ async function init(options = {}) {
     let userName;
     let authOrganizationId;
     const stored = readAuthData();
-    if (stored && stored.apiUrl === apiUrl) {
+    if (stored) {
       const verified = await verifyStoredToken(api, stored.token);
       if (verified && !("userGone" in verified)) {
         p5.log.success(`Authenticated as ${chalk6.bold(verified.email)}`);
@@ -2427,7 +1712,6 @@ async function init(options = {}) {
         authOrganizationId = authResult.organizationId;
         writeAuthData({
           token: userToken,
-          apiUrl,
           userId: authResult.userId,
           email: userEmail,
           name: userName,
@@ -2448,7 +1732,6 @@ async function init(options = {}) {
       authOrganizationId = authResult.organizationId;
       writeAuthData({
         token: userToken,
-        apiUrl,
         userId: authResult.userId,
         email: userEmail,
         name: userName,
@@ -2880,8 +2163,8 @@ async function logout(options = {}) {
 
 // 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 { 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 chalk8 from "chalk";
 
@@ -3162,7 +2445,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]));
@@ -3189,7 +2472,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;
@@ -3203,10 +2486,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) {
@@ -3325,7 +2608,8 @@ function buildStringEntries(extractedStrings) {
         key: str.key,
         text: str.text,
         ...str.context ? { context: str.context } : {},
-        ...str.formality ? { formality: str.formality } : {}
+        ...str.formality ? { formality: str.formality } : {},
+        ...str.uiRole ? { uiRole: str.uiRole } : {}
       });
       continue;
     }
@@ -3374,9 +2658,7 @@ async function sync(options = {}) {
   }
   const spinner4 = p8.spinner();
   try {
-    spinner4.start("Detecting branch");
     const branch = detectBranch(options.branch);
-    spinner4.stop(`Branch: ${chalk8.cyan(branch)}`);
     spinner4.start("Loading project configuration");
     const localConfig = {
       apiKey: mergedConfig.apiKey,
@@ -3391,14 +2673,17 @@ async function sync(options = {}) {
       policyDefaultMaxWaitMs: apiConfig.syncPolicy.defaultMaxWaitMs,
       fallbackTimeoutMs: 6e4
     });
+    const fileConfig = loadVocoderConfig(process.cwd());
     const config = {
       ...localConfig,
       ...apiConfig,
       includePattern: mergedConfig.includePattern,
       excludePattern: mergedConfig.excludePattern,
-      timeout: waitTimeoutMs
+      timeout: waitTimeoutMs,
+      ...fileConfig?.appIndustry ? { appIndustry: fileConfig.appIndustry } : {},
+      ...fileConfig?.formality ? { formality: fileConfig.formality } : {}
     };
-    spinner4.stop("Project configuration loaded");
+    spinner4.stop(`Branch: ${chalk8.cyan(branch)}`);
     if (!options.force && !isTargetBranch(branch, config.targetBranches)) {
       p8.log.warn(
         `Skipping translations (${chalk8.cyan(branch)} is not a target branch)`
@@ -3487,19 +2772,20 @@ async function sync(options = {}) {
         requestedMode,
         requestedMaxWaitMs: waitTimeoutMs,
         clientRunId: randomUUID(),
-        force: options.force
+        force: options.force,
+        // Sync appIndustry from vocoder.config.ts to ProjectApp on every push
+        ...config.appIndustry ? { appIndustry: config.appIndustry } : {}
       },
       repoIdentity ? { ...repoIdentity, commitSha } : { commitSha }
     );
-    spinner4.stop(
-      `Submitted to API - Batch ${chalk8.cyan(batchResponse.batchId)}`
-    );
+    spinner4.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`);
@@ -3508,24 +2794,17 @@ async function sync(options = {}) {
       }
     }
     if (batchResponse.status === "UP_TO_DATE" && batchResponse.noChanges) {
-      p8.log.success("No changes detected - strings are up to date");
-    }
-    p8.log.info(`New strings: ${chalk8.cyan(batchResponse.newStrings)}`);
-    if (batchResponse.deletedStrings && batchResponse.deletedStrings > 0) {
-      p8.log.info(
-        `Deleted strings: ${chalk8.yellow(batchResponse.deletedStrings)} (archived)`
-      );
-    }
-    p8.log.info(`Total strings: ${chalk8.cyan(batchResponse.totalStrings)}`);
-    if (batchResponse.newStrings === 0) {
-      p8.log.success("No new strings - using existing translations");
+      p8.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`);
     } else {
-      p8.log.info(
-        `Syncing to ${config.targetLocales.length} locales (${config.targetLocales.join(", ")})`
-      );
-      if (batchResponse.estimatedTime) {
-        p8.log.info(`Estimated time: ~${batchResponse.estimatedTime}s`);
+      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}`);
     }
     let artifacts = null;
     if (batchResponse.translations) {
@@ -3536,7 +2815,8 @@ async function sync(options = {}) {
     }
     let waitError = null;
     if (!artifacts && (effectiveMode === "required" || effectiveMode === "best-effort")) {
-      spinner4.start(`Waiting for translations (max ${waitTimeoutMs}ms)`);
+      const waitTimeoutSecs = Math.round(waitTimeoutMs / 1e3);
+      spinner4.start(`Waiting for translations (max ${waitTimeoutSecs}s)`);
       let lastProgress = 0;
       try {
         const completion = await api.waitForCompletion(