@vocoder/cli 0.10.0 → 0.12.0

package/dist/{chunk-73U4VZYP.mjs → chunk-XUCVAFBG.mjs}

@@ -43568,6 +43568,730 @@ var require_brace_expansion = __commonJS({
   }
 });
 
+// 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(path2, init = {}, errorPrefix) {
+    const response = await fetch(`${this.apiUrl}${path2}`, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        ...init.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(text) {
+    let hash = 2166136261;
+    for (let i = 0; i < text.length; i++) {
+      hash ^= text.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((text) => ({
+        key: this.stableTextKey(text),
+        text
+      }));
+    }
+    return entries.map((entry, index) => ({
+      key: entry.key || this.stableTextKey(`${entry.text}:${index}`),
+      text: entry.text,
+      ...entry.context ? { context: entry.context } : {},
+      ...entry.formality ? { formality: entry.formality } : {},
+      ...entry.uiRole ? { uiRole: entry.uiRole } : {}
+    }));
+  }
+  async submitTranslation(branch, entries, targetLocales, options, repoIdentity) {
+    const stringEntries = this.normalizeStringEntries(entries);
+    const strings = stringEntries.map((entry) => entry.text);
+    const crypto = await import("crypto");
+    const sortedStrings = [...strings].sort();
+    const stringsHash = crypto.createHash("sha256").update(JSON.stringify(sortedStrings)).digest("hex");
+    return this.request(
+      "/api/cli/sync",
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          branch,
+          stringEntries,
+          targetLocales,
+          ...options?.force ? {} : { stringsHash },
+          ...options?.requestedMode ? { requestedMode: options.requestedMode } : {},
+          ...typeof options?.requestedMaxWaitMs === "number" ? { requestedMaxWaitMs: options.requestedMaxWaitMs } : {},
+          ...options?.clientRunId ? { clientRunId: options.clientRunId } : {},
+          ...repoIdentity?.repoCanonical ? { repoCanonical: repoIdentity.repoCanonical } : {},
+          ...repoIdentity?.repoAppDir !== void 0 ? { repoAppDir: repoIdentity.repoAppDir } : {},
+          ...repoIdentity?.commitSha ? { commitSha: repoIdentity.commitSha } : {},
+          ...options?.appIndustry ? { appIndustry: options.appIndustry } : {}
+        })
+      },
+      "Translation submission failed"
+    );
+  }
+  /**
+   * Check translation status
+   */
+  async getTranslationStatus(batchId) {
+    return this.request(
+      `/api/cli/sync/status/${batchId}`,
+      {},
+      "Failed to check translation status"
+    );
+  }
+  async getTranslationSnapshot(params) {
+    const search = new URLSearchParams();
+    search.set("branch", params.branch);
+    for (const locale of params.targetLocales) {
+      search.append("targetLocale", locale);
+    }
+    return this.request(
+      `/api/cli/sync/snapshot?${search.toString()}`,
+      {},
+      "Failed to fetch translation snapshot"
+    );
+  }
+  /**
+   * Wait for translation to complete with polling
+   */
+  async waitForCompletion(batchId, timeout = 6e4, onProgress) {
+    const startTime = Date.now();
+    const pollInterval = 1e3;
+    while (Date.now() - startTime < timeout) {
+      const status = await this.getTranslationStatus(batchId);
+      if (onProgress) {
+        onProgress(status.progress);
+      }
+      if (status.status === "COMPLETED") {
+        if (!status.translations) {
+          throw new Error("Translation completed but no translations returned");
+        }
+        return {
+          translations: status.translations,
+          localeMetadata: status.localeMetadata
+        };
+      }
+      if (status.status === "FAILED") {
+        throw new Error(
+          `Translation failed: ${status.errorMessage || "Unknown error"}`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 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 ───────────────────────────────────────────────────────────────────
+  /**
+   * Add a target locale to the project.
+   * Idempotent: returns the current list unchanged if the locale is already configured.
+   * Project determined from API key.
+   *
+   * @throws {VocoderAPIError} status 422 for invalid/unsupported locale code
+   * @throws {VocoderAPIError} status 403 with limitError.limitType "target_locales" when plan limit reached
+   */
+  async addLocale(locale, repoCanonical) {
+    return this.request(
+      "/api/cli/project/locales",
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          locale,
+          ...repoCanonical ? { repoCanonical } : {}
+        })
+      },
+      "Failed to add locale"
+    );
+  }
+  /**
+   * Remove a target locale from the project.
+   * Idempotent: returns the current list unchanged if the locale is not configured.
+   * Project determined from API key.
+   *
+   * @throws {VocoderAPIError} on auth or server errors
+   */
+  async removeLocale(locale, repoCanonical) {
+    return this.request(
+      "/api/cli/project/locales",
+      {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          locale,
+          ...repoCanonical ? { repoCanonical } : {}
+        })
+      },
+      "Failed to remove locale"
+    );
+  }
+  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/detect-local.ts
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
@@ -43679,6 +44403,62 @@ function getPackagesToInstall(detection) {
   return { devPackages, runtimePackages };
 }
 
+// src/utils/auth-store.ts
+import { mkdirSync, readFileSync as readFileSync2, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2 } from "path";
+function getAuthFilePath() {
+  return join2(homedir(), ".config", "vocoder", "auth.json");
+}
+function readAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    const raw = readFileSync2(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const data = parsed;
+    if (typeof data.token !== "string" || typeof data.userId !== "string" || typeof data.email !== "string" || typeof data.createdAt !== "string") {
+      return null;
+    }
+    return {
+      token: data.token,
+      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 });
+}
+async function verifyStoredAuth(api) {
+  const stored = readAuthData();
+  if (!stored) return { status: "none" };
+  try {
+    const userInfo = await api.getCliUserInfo(stored.token);
+    return { status: "valid", token: stored.token, ...userInfo };
+  } catch (err) {
+    clearAuthData();
+    if (err instanceof VocoderAPIError && err.status === 404) {
+      return { status: "gone" };
+    }
+    return { status: "expired" };
+  }
+}
+function clearAuthData() {
+  const filePath = getAuthFilePath();
+  try {
+    unlinkSync(filePath);
+  } catch {
+  }
+}
+
 // src/utils/setup-snippets.ts
 function getSetupSnippets(params) {
   const { framework, ecosystem, sourceLocale } = params;
@@ -43840,28 +44620,28 @@ import { T } from '@vocoder/vue';
 // ../extractor/src/config.ts
 var import_parser = __toESM(require_lib());
 var import_traverse = __toESM(require_lib8());
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join3 } from "path";
 var traverse = import_traverse.default.default || import_traverse.default;
 function loadVocoderConfig(cwd) {
   const candidates = [
-    join2(cwd, "vocoder.config.ts"),
-    join2(cwd, "vocoder.config.js"),
-    join2(cwd, "vocoder.config.mjs"),
-    join2(cwd, "vocoder.config.cjs")
+    join3(cwd, "vocoder.config.ts"),
+    join3(cwd, "vocoder.config.js"),
+    join3(cwd, "vocoder.config.mjs"),
+    join3(cwd, "vocoder.config.cjs")
   ];
   for (const configPath of candidates) {
     if (!existsSync2(configPath)) continue;
     try {
-      const code = readFileSync2(configPath, "utf-8");
+      const code = readFileSync3(configPath, "utf-8");
       return parseConfigFromSource(code);
     } catch {
     }
   }
-  const jsonPath = join2(cwd, "vocoder.config.json");
+  const jsonPath = join3(cwd, "vocoder.config.json");
   if (existsSync2(jsonPath)) {
     try {
-      return JSON.parse(readFileSync2(jsonPath, "utf-8"));
+      return JSON.parse(readFileSync3(jsonPath, "utf-8"));
     } catch {
       return null;
     }
@@ -43922,7 +44702,7 @@ function extractFromObject(obj) {
 // ../extractor/src/index.ts
 var import_parser2 = __toESM(require_lib());
 var import_traverse2 = __toESM(require_lib8());
-import { readFileSync as readFileSync3 } from "fs";
+import { readFileSync as readFileSync4 } from "fs";
 import { relative as pathRelative } from "path";
 
 // ../../node_modules/.pnpm/minimatch@9.0.5/node_modules/minimatch/dist/esm/index.js
@@ -50399,7 +51179,7 @@ var StringExtractor = class {
     const sortedFiles = Array.from(allFiles).sort();
     for (const file of sortedFiles) {
       try {
-        const code = readFileSync3(file, "utf-8");
+        const code = readFileSync4(file, "utf-8");
         const relPath = pathRelative(projectRoot, file).split("\\").join("/");
         const strings = _extractFromContent(relPath, code);
         allStrings.push(...strings);
@@ -50481,25 +51261,6 @@ function detectUiRole(path2) {
   }
   return "unknown";
 }
-var FEATURE_PATTERNS = [
-  [/\/(checkout|cart|basket)/, "checkout"],
-  [/\/(auth|login|signup|sign-up|register|forgot|reset-password|verify)/, "auth"],
-  [/\/(onboarding|welcome|setup)/, "onboarding"],
-  [/\/(dashboard|overview|home)/, "dashboard"],
-  [/\/(settings|preferences|profile|account)/, "settings"],
-  [/\/(search|results|explore)/, "search"],
-  [/\/(product|item|detail|pdp)/, "product"],
-  [/\/(pricing|plans|billing|upgrade)/, "pricing"],
-  [/\/(admin|manage)/, "admin"],
-  [/\/(help|support|faq|docs)/, "support"]
-];
-function inferFeatureArea(filePath) {
-  const normalized = filePath.replace(/\\/g, "/").toLowerCase();
-  for (const [pattern, area] of FEATURE_PATTERNS) {
-    if (pattern.test(normalized)) return area;
-  }
-  return void 0;
-}
 function _extractFromContent(filePath, content) {
   const strings = [];
   try {
@@ -50573,7 +51334,6 @@ function _extractFromContent(filePath, content) {
         const line = path2.node.loc?.start.line || 0;
         const key = explicitKey && explicitKey.length > 0 ? explicitKey : generateMessageHash(text.trim(), context);
         const uiRole = detectUiRole(path2);
-        const featureArea = inferFeatureArea(filePath);
         strings.push({
           key,
           text: text.trim(),
@@ -50581,8 +51341,7 @@ function _extractFromContent(filePath, content) {
           line,
           context,
           formality,
-          uiRole: uiRole !== "unknown" ? uiRole : void 0,
-          featureArea
+          uiRole: uiRole !== "unknown" ? uiRole : void 0
         });
       },
       JSXElement: (path2) => {
@@ -50613,7 +51372,6 @@ function _extractFromContent(filePath, content) {
         const line = path2.node.loc?.start.line || 0;
         const key = id && id.trim().length > 0 ? id.trim() : generateMessageHash(text.trim(), context);
         const uiRole = detectUiRole(path2);
-        const featureArea = inferFeatureArea(filePath);
         strings.push({
           key,
           text: text.trim(),
@@ -50621,8 +51379,7 @@ function _extractFromContent(filePath, content) {
           line,
           context,
           formality,
-          uiRole: uiRole !== "unknown" ? uiRole : void 0,
-          featureArea
+          uiRole: uiRole !== "unknown" ? uiRole : void 0
         });
       }
     });
@@ -50730,11 +51487,17 @@ function deduplicateStrings(strings) {
 }
 
 export {
+  VocoderAPIError,
+  VocoderAPI,
   detectLocalEcosystem,
   buildInstallCommand,
   getPackagesToInstall,
+  readAuthData,
+  writeAuthData,
+  verifyStoredAuth,
+  clearAuthData,
   getSetupSnippets,
   loadVocoderConfig,
   StringExtractor
 };
-//# sourceMappingURL=chunk-73U4VZYP.mjs.map
+//# sourceMappingURL=chunk-XUCVAFBG.mjs.map