@sonenta/cli 0.3.0

package/dist/index.js

@@ -0,0 +1,964 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command15 } from "commander";
+
+// src/commands/export.ts
+import { promises as fs3 } from "fs";
+import { join as join2 } from "path";
+import { Command } from "commander";
+
+// src/config.ts
+import { promises as fs } from "fs";
+import { dirname, resolve } from "path";
+var CONFIG_FILENAME = "sonenta.config.json";
+var LEGACY_CONFIG_FILENAME = "verbumia.config.json";
+var warnedLegacy = false;
+async function findConfigPath(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    for (const name of [CONFIG_FILENAME, LEGACY_CONFIG_FILENAME]) {
+      const candidate = resolve(dir, name);
+      try {
+        await fs.access(candidate);
+        if (name === LEGACY_CONFIG_FILENAME && !warnedLegacy) {
+          warnedLegacy = true;
+          process.emitWarning(
+            `${LEGACY_CONFIG_FILENAME} is deprecated \u2014 rename it to ${CONFIG_FILENAME}. The legacy name still works for now.`,
+            { type: "DeprecationWarning" }
+          );
+        }
+        return candidate;
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function readConfig(startDir = process.cwd()) {
+  const path = await findConfigPath(startDir);
+  if (!path) return { path: null, config: {} };
+  const raw = await fs.readFile(path, "utf8");
+  const parsed = JSON.parse(raw);
+  return { path, config: parsed };
+}
+async function writeConfig(config, targetDir = process.cwd()) {
+  const path = resolve(targetDir, CONFIG_FILENAME);
+  await fs.writeFile(path, JSON.stringify(config, null, 2) + "\n", "utf8");
+  return path;
+}
+
+// src/credentials.ts
+import { promises as fs2 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var credentialsDir = () => join(homedir(), ".verbumia");
+var credentialsPath = () => join(credentialsDir(), "credentials");
+var EMPTY = { hosts: {} };
+async function readCredentials() {
+  try {
+    const raw = await fs2.readFile(credentialsPath(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || !parsed.hosts) {
+      return EMPTY;
+    }
+    return parsed;
+  } catch (err) {
+    if (err?.code === "ENOENT") return { hosts: {} };
+    throw err;
+  }
+}
+async function writeCredentials(creds) {
+  const dir = credentialsDir();
+  const path = credentialsPath();
+  await fs2.mkdir(dir, { recursive: true, mode: 448 });
+  const tmp = `${path}.tmp`;
+  await fs2.writeFile(tmp, JSON.stringify(creds, null, 2) + "\n", { mode: 384 });
+  await fs2.rename(tmp, path);
+  await fs2.chmod(path, 384);
+  await fs2.chmod(dir, 448).catch(() => {
+  });
+}
+async function setHostEntry(host, entry, options = {}) {
+  const creds = await readCredentials();
+  creds.hosts[host] = entry;
+  if (options.makeDefault || !creds.default) creds.default = host;
+  await writeCredentials(creds);
+}
+async function removeHost(host) {
+  const creds = await readCredentials();
+  if (!(host in creds.hosts)) return false;
+  delete creds.hosts[host];
+  if (creds.default === host) {
+    const remaining = Object.keys(creds.hosts);
+    creds.default = remaining[0];
+  }
+  await writeCredentials(creds);
+  return true;
+}
+function resolveHostEntry(creds, hostOverride) {
+  const host = hostOverride ?? creds.default;
+  if (!host) return null;
+  const entry = creds.hosts[host];
+  if (!entry) return null;
+  return { host, entry };
+}
+
+// src/api.ts
+async function resolveContext(opts = {}) {
+  const { config } = await readConfig(opts.cwd ?? process.cwd());
+  const creds = await readCredentials();
+  const host = opts.hostOverride ?? config.host ?? creds.default;
+  if (!host) {
+    throw new Error(
+      "No host configured. Run `sonenta login --host <url>` or add `host` to sonenta.config.json."
+    );
+  }
+  const envToken = process.env.SONENTA_TOKEN ?? process.env.VERBUMIA_TOKEN;
+  let apiKey = envToken && envToken.trim() ? envToken.trim() : void 0;
+  if (!apiKey) {
+    const resolved = resolveHostEntry(creds, host);
+    if (!resolved) {
+      throw new Error(
+        `No credentials for host ${host}. Set SONENTA_TOKEN or run \`sonenta login --host ${host}\`.`
+      );
+    }
+    apiKey = resolved.entry.api_key;
+  }
+  return {
+    host,
+    apiKey,
+    projectUuid: config.project_uuid,
+    versionSlug: config.version_slug ?? "main"
+  };
+}
+async function apiRequest(ctx, path, init = {}) {
+  const url = `${ctx.host.replace(/\/+$/, "")}${path}`;
+  const headers = new Headers(init.headers);
+  headers.set("Authorization", `ApiKey ${ctx.apiKey}`);
+  if (init.body && !headers.has("Content-Type")) {
+    headers.set("Content-Type", "application/json");
+  }
+  const res = await fetch(url, { ...init, headers });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`HTTP ${res.status} ${res.statusText} on ${path}: ${text.slice(0, 300)}`);
+  }
+  if (res.status === 204) return void 0;
+  return await res.json();
+}
+
+// src/i18next_tree.ts
+function unflatten(flat, sep = ".") {
+  const root = {};
+  for (const [k, v] of Object.entries(flat)) {
+    const parts = k.split(sep);
+    let node = root;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const p = parts[i];
+      const existing = node[p];
+      if (typeof existing !== "object" || existing === null) node[p] = {};
+      node = node[p];
+    }
+    node[parts[parts.length - 1]] = v;
+  }
+  return root;
+}
+function sortDeep(value) {
+  if (Array.isArray(value)) return value.map((v) => sortDeep(v));
+  if (value && typeof value === "object") {
+    const src = value;
+    const out = {};
+    for (const k of Object.keys(src).sort((a, b) => a.localeCompare(b))) out[k] = sortDeep(src[k]);
+    return out;
+  }
+  return value;
+}
+
+// src/mcp.ts
+function requireProject(ctx) {
+  if (!ctx.projectUuid) {
+    throw new Error(
+      "no project configured \u2014 run `sonenta init --project <uuid>` (or set project_uuid in sonenta.config.json)."
+    );
+  }
+  return ctx.projectUuid;
+}
+function projectBase(ctx) {
+  return `/v1/mcp/projects/${requireProject(ctx)}`;
+}
+async function listProjects(ctx, limit = 200) {
+  const data = await apiRequest(
+    ctx,
+    `/v1/mcp/projects?limit=${limit}`
+  );
+  return data.items ?? [];
+}
+async function getProjectInfo(ctx) {
+  const d = await apiRequest(ctx, projectBase(ctx));
+  const src = typeof d.source_language === "string" ? d.source_language : d.source_language?.code ?? "";
+  const langs = Array.isArray(d.languages) ? d.languages.map(
+    (l) => typeof l === "string" ? l : l.code ?? ""
+  ) : [];
+  const ns = Array.isArray(d.namespaces) ? d.namespaces.map(
+    (n) => typeof n === "string" ? n : n.slug ?? ""
+  ) : [];
+  return {
+    source_language: src,
+    languages: langs.filter(Boolean),
+    namespaces: ns.filter(Boolean)
+  };
+}
+async function listKeys(ctx, opts = {}) {
+  const out = [];
+  let cursor = null;
+  do {
+    const params = new URLSearchParams({ limit: "200" });
+    if (opts.languageCode) params.set("language_code", opts.languageCode);
+    if (opts.namespace) params.set("namespace", opts.namespace);
+    if (cursor) params.set("cursor", cursor);
+    const page = await apiRequest(
+      ctx,
+      `${projectBase(ctx)}/keys?${params.toString()}`
+    );
+    out.push(...page.items ?? []);
+    cursor = page.cursor_next ?? null;
+  } while (cursor);
+  return out;
+}
+async function importBundle(ctx, body) {
+  return apiRequest(ctx, `${projectBase(ctx)}/i18next/import`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+async function publishCdn(ctx, body) {
+  return apiRequest(ctx, `${projectBase(ctx)}/cdn/releases`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+function summariseImport(r) {
+  const lines = [
+    `keys:         ${r.keys_created} created, ${r.keys_reused} reused`,
+    `translations: ${r.translations_created} created, ${r.translations_updated} updated, ${r.translations_unchanged} unchanged`
+  ];
+  if (r.plural_keys_marked) lines.push(`plural keys:  ${r.plural_keys_marked} marked`);
+  if (r.errors?.length) {
+    lines.push(`errors:       ${r.errors.length}`);
+    for (const e of r.errors) lines.push(`  ! ${e.namespace}/${e.language_code}: ${e.code}`);
+  }
+  if (r.glossary_violations?.length) {
+    lines.push(`glossary:     ${r.glossary_violations.length} violation(s)`);
+    for (const g of r.glossary_violations) {
+      lines.push(`  \u26A0 ${g.namespace}/${g.language_code} ${g.key}: ${g.rule_type} "${g.term}"`);
+    }
+  }
+  return lines;
+}
+
+// src/commands/export.ts
+async function collect(ctx, languages, namespace) {
+  const out = {};
+  for (const lang of languages) {
+    const items = await listKeys(ctx, { languageCode: lang, namespace });
+    for (const it of items) {
+      const tr = it.translations?.find((t) => t.language_code === lang);
+      if (!tr || tr.value === "") continue;
+      (out[lang] ??= {})[it.namespace_slug] ??= {};
+      out[lang][it.namespace_slug][it.key_name] = tr.value;
+    }
+  }
+  return out;
+}
+var exportCommand = new Command("export").description(
+  "Export Verbumia translations as i18next JSON. Flat dot-notation by default (--nested for nested trees). Writes <out>/<lang>/<namespace>.json with --out, otherwise prints { locale: { namespace: tree } } to stdout."
+).option("--language <code>", "Restrict to a single language code").option("--namespace <slug>", "Restrict to a single namespace slug").option("--nested", "Emit nested JSON instead of flat dot-notation", false).option("--out <dir>", "Write files instead of printing to stdout").option("--host <url>", "Override host (otherwise from config/credentials)").action(
+  async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const languages = opts.language ? [opts.language] : (await getProjectInfo(ctx)).languages;
+    const collected = await collect(ctx, languages, opts.namespace);
+    const shape = (flat) => opts.nested ? sortDeep(unflatten(flat)) : sortDeep(flat);
+    if (opts.out) {
+      let files = 0;
+      for (const [lang, nss] of Object.entries(collected)) {
+        for (const [ns, flat] of Object.entries(nss)) {
+          const dir = join2(opts.out, lang);
+          await fs3.mkdir(dir, { recursive: true });
+          const p = join2(dir, `${ns}.json`);
+          await fs3.writeFile(p, JSON.stringify(shape(flat), null, 2) + "\n", "utf8");
+          console.log(`  ${p}  ${Object.keys(flat).length} keys`);
+          files++;
+        }
+      }
+      console.log(`exported ${files} file(s)`);
+      return;
+    }
+    const tree = {};
+    for (const [lang, nss] of Object.entries(collected)) {
+      tree[lang] = {};
+      for (const [ns, flat] of Object.entries(nss)) tree[lang][ns] = shape(flat);
+    }
+    process.stdout.write(JSON.stringify(tree, null, 2) + "\n");
+  }
+);
+
+// src/commands/import.ts
+import { promises as fs4 } from "fs";
+import { basename, dirname as dirname3 } from "path";
+import { Command as Command2 } from "commander";
+function resolveLangNs(filePath, optLang, optNs) {
+  const stem = basename(filePath).replace(/\.json$/i, "");
+  const parent = basename(dirname3(filePath));
+  const hasLangDir = parent !== "" && parent !== "." && parent !== "locales";
+  const lang = optLang ?? (hasLangDir ? parent : stem);
+  const ns = optNs ?? (hasLangDir ? stem : void 0);
+  if (!lang) throw new Error(`could not infer a language for ${filePath} \u2014 pass --language`);
+  if (!ns) {
+    throw new Error(
+      `could not infer a namespace for ${filePath} \u2014 pass --namespace, or lay files out as <lang>/<namespace>.json`
+    );
+  }
+  return { lang, ns };
+}
+async function readTree(filePath) {
+  const parsed = JSON.parse(await fs4.readFile(filePath, "utf8"));
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${filePath} is not a JSON object`);
+  }
+  return parsed;
+}
+function countLeaves(tree) {
+  let n = 0;
+  for (const v of Object.values(tree)) {
+    if (v && typeof v === "object" && !Array.isArray(v)) n += countLeaves(v);
+    else n += 1;
+  }
+  return n;
+}
+var importCommand = new Command2("import").description(
+  "Import i18next JSON file(s) into Verbumia in ONE call \u2014 creates missing keys and upserts translations (idempotent). Accepts nested or flat JSON. Language/namespace are inferred from the path (<lang>/<namespace>.json) or forced with --language / --namespace."
+).argument("<files...>", "i18next JSON file(s), e.g. locales/fr/common.json or fr.json").option("--language <code>", "Force the language code for every file").option("--namespace <slug>", "Force the namespace slug for every file").option("--status <status>", "draft | translated (default: translated)").option("--version <slug>", "Target version slug (default: production version)").option("--dry-run", "Print what would be imported without sending", false).option("--host <url>", "Override host (otherwise from config/credentials)").action(
+  async (files, opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const byNs = /* @__PURE__ */ new Map();
+    let totalLeaves = 0;
+    for (const f of files) {
+      const { lang, ns } = resolveLangNs(f, opts.language, opts.namespace);
+      const tree = await readTree(f);
+      totalLeaves += countLeaves(tree);
+      const langs = byNs.get(ns) ?? {};
+      if (langs[lang]) {
+        throw new Error(`two input files map to namespace=${ns} language=${lang} \u2014 merge them first`);
+      }
+      langs[lang] = tree;
+      byNs.set(ns, langs);
+      console.log(`  ${f}  ->  ${ns} / ${lang}`);
+    }
+    const body = {
+      namespaces: [...byNs.entries()].map(([namespace, translations]) => ({
+        namespace,
+        translations
+      }))
+    };
+    if (opts.status === "draft" || opts.status === "translated") body.status = opts.status;
+    if (opts.version) body.version = opts.version;
+    if (opts.dryRun) {
+      console.log(
+        `
+(dry-run) would import ${totalLeaves} value(s) across ${body.namespaces.length} namespace(s); nothing sent.`
+      );
+      return;
+    }
+    const report = await importBundle(ctx, body);
+    console.log("");
+    for (const line of summariseImport(report)) console.log(line);
+    if (report.errors?.length || report.glossary_violations?.length) process.exitCode = 1;
+  }
+);
+
+// src/commands/init.ts
+import { existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { Command as Command3 } from "commander";
+var initCommand = new Command3("init").description("Scaffold a sonenta.config.json in the current directory.").option("--host <url>", "API base URL", "https://api.sonenta.com").option("--project <uuid>", "Project UUID").option("--version <slug>", "Version slug (default: main)", "main").option("--force", "Overwrite an existing sonenta.config.json", false).action(
+  async (opts) => {
+    const path = resolve2(process.cwd(), CONFIG_FILENAME);
+    if (existsSync(path) && !opts.force) {
+      console.error(
+        `${CONFIG_FILENAME} already exists at ${path}. Pass --force to overwrite.`
+      );
+      process.exit(1);
+    }
+    const written = await writeConfig({
+      host: opts.host,
+      project_uuid: opts.project,
+      version_slug: opts.version
+    });
+    console.log(`Wrote ${written}`);
+    if (!opts.project) {
+      console.log(
+        "Tip: pass --project <uuid> to bind this directory to a specific project (or edit project_uuid in the file later)."
+      );
+    }
+  }
+);
+
+// src/commands/keys.ts
+import { Command as Command4 } from "commander";
+var keysCommand = new Command4("keys").description("Inspect translation keys for the current project.").addCommand(
+  new Command4("list").description("List keys for the configured project (addressed by namespace slug + key name).").option("--namespace <slug>", "Filter by namespace slug").option("--host <url>", "Override host (otherwise from config/credentials)").action(async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const items = await listKeys(ctx, { namespace: opts.namespace });
+    console.log(`total: ${items.length}`);
+    for (const k of items) console.log(`  ${k.namespace_slug}/${k.key_name}`);
+  })
+);
+
+// src/commands/login.ts
+import { Command as Command5 } from "commander";
+
+// src/prompt.ts
+import { createInterface } from "readline";
+async function promptLine(message) {
+  if (!process.stdin.isTTY) return "";
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await new Promise((resolve4) => {
+      rl.question(message, (answer) => resolve4(answer.trim()));
+    });
+  } finally {
+    rl.close();
+  }
+}
+var CTRL_C = 3;
+var BACKSPACE = 8;
+var DEL = 127;
+var CR = 13;
+var LF = 10;
+async function promptSecret(message) {
+  if (!process.stdin.isTTY) return "";
+  process.stdout.write(message);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  return await new Promise((resolve4) => {
+    let buffer = "";
+    const onData = (chunk) => {
+      for (const byte of chunk) {
+        if (byte === CR || byte === LF) {
+          process.stdout.write("\n");
+          process.stdin.removeListener("data", onData);
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          resolve4(buffer);
+          return;
+        }
+        if (byte === CTRL_C) {
+          process.stdout.write("\n");
+          process.stdin.removeListener("data", onData);
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.exit(130);
+        }
+        if (byte === BACKSPACE || byte === DEL) {
+          if (buffer.length > 0) {
+            buffer = buffer.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+          continue;
+        }
+        buffer += String.fromCharCode(byte);
+        process.stdout.write("*");
+      }
+    };
+    process.stdin.on("data", onData);
+  });
+}
+
+// src/commands/login.ts
+var TOKEN_REGEX = /^vrb_[a-z]+_[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+var loginCommand = new Command5("login").description(
+  "Store an API key for a host. Token resolution order: --token, SONENTA_TOKEN env, then interactive prompt (TTY only)."
+).option("--host <url>", "API base URL", "https://api.sonenta.com").option("--token <vrb_live_\u2026>", "API key token (prefix.secret form)").option("--email <email>", "User email associated with the token (optional)").option("--default", "Set this host as the default for future commands", false).action(async (opts) => {
+  let host = opts.host;
+  if (!host && process.stdin.isTTY) {
+    host = await promptLine("Host (default https://api.sonenta.com): ") || "https://api.sonenta.com";
+  }
+  let token = opts.token ?? (process.env.SONENTA_TOKEN ?? process.env.VERBUMIA_TOKEN) ?? "";
+  if (!token && process.stdin.isTTY) {
+    token = await promptSecret(`API token for ${host}: `);
+  }
+  if (!token) {
+    console.error(
+      "sonenta login: token required. Pass --token, set SONENTA_TOKEN, or run from a TTY for the interactive prompt."
+    );
+    process.exit(1);
+  }
+  if (!TOKEN_REGEX.test(token)) {
+    console.error(
+      "sonenta login: token shape doesn't match `vrb_<env>_<prefix>.<secret>`. Generate one in the dashboard at Org Settings \u2192 API Keys."
+    );
+    process.exit(1);
+  }
+  await setHostEntry(
+    host,
+    { api_key: token, user_email: opts.email },
+    { makeDefault: opts.default }
+  );
+  console.log(`Stored credentials for ${host}.`);
+});
+
+// src/commands/logout.ts
+import { Command as Command6 } from "commander";
+var logoutCommand = new Command6("logout").description("Remove stored credentials for a host (default: the current default host).").option("--host <url>", "Host to forget. Omit to forget the current default.").action(async (opts) => {
+  const creds = await readCredentials();
+  const target = opts.host ?? creds.default;
+  if (!target) {
+    console.log("Nothing to forget \u2014 no credentials stored.");
+    return;
+  }
+  const removed = await removeHost(target);
+  if (!removed) {
+    console.log(`No credentials stored for ${target}.`);
+    return;
+  }
+  console.log(`Forgot credentials for ${target}.`);
+});
+
+// src/commands/missing.ts
+import { Command as Command7 } from "commander";
+var missingCommand = new Command7("missing").description(
+  "List runtime-detected missing keys for the configured project. Requires the API key to carry the `mcp:*` scope."
+).option("--namespace <slug>", "Filter by namespace slug").option("--language <code>", "Filter by language code").option("--status <state>", "Filter by status (open|resolved|...)").option("--limit <n>", "Page size (1-200, default 50)", "50").option("--host <url>", "Override host (otherwise from config/credentials)").action(
+  async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    if (!ctx.projectUuid) {
+      console.error(
+        "sonenta missing: no project_uuid configured. Run `sonenta init --project <uuid>`."
+      );
+      process.exit(1);
+    }
+    const params = new URLSearchParams();
+    params.set("limit", opts.limit);
+    if (opts.namespace) params.set("namespace", opts.namespace);
+    if (opts.language) params.set("language_code", opts.language);
+    if (opts.status) params.set("status", opts.status);
+    const page = await apiRequest(
+      ctx,
+      `/v1/mcp/projects/${ctx.projectUuid}/missing-keys?${params.toString()}`
+    );
+    console.log(`total: ${page.total}`);
+    for (const m of page.items) {
+      const sample = m.source_value ? `  \u27F6  "${m.source_value}"` : "";
+      console.log(
+        `  ${m.namespace_slug}/${m.key}  (${m.language_code}, count=${m.count}, ${m.status})${sample}`
+      );
+    }
+    if (page.cursor_next) {
+      console.log(`(more \u2014 re-run with --cursor ${page.cursor_next})`);
+    }
+  }
+);
+
+// src/commands/projects.ts
+import { Command as Command8 } from "commander";
+var projectsCommand = new Command8("projects").description("Inspect Verbumia projects accessible to your API key.").addCommand(
+  new Command8("list").description("List the projects this API key can reach.").option("--host <url>", "Override host (otherwise from config/credentials)").action(async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const items = await listProjects(ctx);
+    if (items.length === 0) {
+      console.log("No projects visible to this key (scoped or revoked?).");
+      return;
+    }
+    for (const p of items) {
+      const slug = p.slug ? `  ${p.slug}` : "";
+      const src = p.source_language ? `  src=${p.source_language}` : "";
+      console.log(`  ${p.uuid}${slug}  ${p.name ?? ""}${src}`);
+    }
+  })
+);
+
+// src/commands/pull.ts
+import { Command as Command9 } from "commander";
+
+// src/locales.ts
+import { promises as fs5 } from "fs";
+import { join as join3, resolve as resolve3 } from "path";
+var DEFAULT_LOCALES_DIR = "locales";
+async function listLocaleFiles(rootDir) {
+  const root = resolve3(rootDir);
+  let langDirs;
+  try {
+    langDirs = await fs5.readdir(root);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const lang of langDirs) {
+    const langPath = join3(root, lang);
+    let stat;
+    try {
+      stat = await fs5.stat(langPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isDirectory()) continue;
+    const files = await fs5.readdir(langPath);
+    for (const f of files) {
+      if (!f.endsWith(".json")) continue;
+      out.push({ lang, namespace: f.replace(/\.json$/, ""), path: join3(langPath, f) });
+    }
+  }
+  return out;
+}
+async function readLocaleFile(path) {
+  const raw = await fs5.readFile(path, "utf8");
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${path} is not a flat object`);
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(parsed)) {
+    if (typeof v !== "string") {
+      throw new Error(`${path}: key "${k}" is not a string (V1 flat layout only)`);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+async function writeLocaleFile(rootDir, lang, namespace, values) {
+  const dir = join3(rootDir, lang);
+  await fs5.mkdir(dir, { recursive: true });
+  const path = join3(dir, `${namespace}.json`);
+  const sorted = Object.fromEntries(
+    Object.entries(values).sort(([a], [b]) => a.localeCompare(b))
+  );
+  await fs5.writeFile(path, JSON.stringify(sorted, null, 2) + "\n", "utf8");
+  return path;
+}
+function diffFlat(local, remote) {
+  const added = [];
+  const removed = [];
+  const changed = [];
+  let unchanged = 0;
+  for (const [k, v] of Object.entries(local)) {
+    if (!(k in remote)) {
+      added.push(k);
+    } else if (remote[k] !== v) {
+      changed.push({ key: k, local: v, remote: remote[k] });
+    } else {
+      unchanged++;
+    }
+  }
+  for (const k of Object.keys(remote)) {
+    if (!(k in local)) removed.push(k);
+  }
+  return { added, removed, changed, unchanged };
+}
+
+// src/commands/pull.ts
+var pullCommand = new Command9("pull").description(
+  "Pull translations from Verbumia into locales/<lang>/<namespace>.json (flat dot-notation). Overwrites local files \u2014 pair with `git status`."
+).option("--language <code>", "Restrict to a single language code").option("--namespace <slug>", "Restrict to a single namespace slug").option("--dest <dir>", "Output directory", DEFAULT_LOCALES_DIR).option("--host <url>", "Override host (otherwise from config/credentials)").action(
+  async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    let languages;
+    if (opts.language) {
+      languages = [opts.language];
+    } else {
+      languages = (await getProjectInfo(ctx)).languages;
+      if (languages.length === 0) {
+        console.error("sonenta pull: the project reports no languages.");
+        process.exit(1);
+      }
+    }
+    let totalKeys = 0;
+    let totalFiles = 0;
+    for (const lang of languages) {
+      const items = await listKeys(ctx, { languageCode: lang, namespace: opts.namespace });
+      const byNs = /* @__PURE__ */ new Map();
+      for (const it of items) {
+        const tr = it.translations?.find((t) => t.language_code === lang);
+        if (!tr || tr.value === "") continue;
+        const map = byNs.get(it.namespace_slug) ?? {};
+        map[it.key_name] = tr.value;
+        byNs.set(it.namespace_slug, map);
+      }
+      for (const [ns, map] of byNs) {
+        const path = await writeLocaleFile(opts.dest, lang, ns, map);
+        totalKeys += Object.keys(map).length;
+        totalFiles++;
+        console.log(`  ${path}  ${Object.keys(map).length} keys`);
+      }
+    }
+    console.log(`pulled ${totalKeys} translation(s) across ${totalFiles} file(s)`);
+  }
+);
+
+// src/commands/push.ts
+import { Command as Command10 } from "commander";
+var pushCommand = new Command10("push").description(
+  "Push the whole local locales/ tree to Verbumia in ONE import call \u2014 creates missing keys and upserts translations (idempotent). Reads locales/<lang>/<namespace>.json (flat dot-notation)."
+).option("--language <code>", "Restrict to a single language code").option("--namespace <slug>", "Restrict to a single namespace slug").option("--src <dir>", "Locales directory", DEFAULT_LOCALES_DIR).option("--status <status>", "draft | translated (default: translated)").option("--version <slug>", "Target version slug (default: production version)").option("--dry-run", "Print what would be pushed without sending", false).option("--host <url>", "Override host (otherwise from config/credentials)").action(
+  async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const files = (await listLocaleFiles(opts.src)).filter((f) => {
+      if (opts.language && f.lang !== opts.language) return false;
+      if (opts.namespace && f.namespace !== opts.namespace) return false;
+      return true;
+    });
+    if (files.length === 0) {
+      console.log(`No locale files found under ${opts.src}/`);
+      return;
+    }
+    const byNs = /* @__PURE__ */ new Map();
+    let totalKeys = 0;
+    for (const f of files) {
+      const flat = await readLocaleFile(f.path);
+      totalKeys += Object.keys(flat).length;
+      const langs = byNs.get(f.namespace) ?? {};
+      langs[f.lang] = flat;
+      byNs.set(f.namespace, langs);
+      console.log(`  ${f.lang}/${f.namespace}.json  ${Object.keys(flat).length} keys`);
+    }
+    const body = {
+      namespaces: [...byNs.entries()].map(([namespace, translations]) => ({
+        namespace,
+        translations
+      }))
+    };
+    if (opts.status === "draft" || opts.status === "translated") body.status = opts.status;
+    if (opts.version) body.version = opts.version;
+    if (opts.dryRun) {
+      console.log(
+        `
+(dry-run) would push ${totalKeys} key(s) across ${body.namespaces.length} namespace(s); nothing sent.`
+      );
+      return;
+    }
+    const report = await importBundle(ctx, body);
+    console.log("");
+    for (const line of summariseImport(report)) console.log(line);
+    if (report.errors?.length || report.glossary_violations?.length) process.exitCode = 1;
+  }
+);
+
+// src/commands/releases.ts
+import { Command as Command11 } from "commander";
+var releasesCommand = new Command11("releases").description("Manage CDN releases for the project.").addCommand(
+  new Command11("publish").description(
+    "Trigger a CDN release: build bundles for every (language, namespace) and push them to the public CDN. Idempotent \u2014 unchanged bundles are reused. Subscribed SDKs receive a live `translations_published` event."
+  ).option("--language <code>", "Restrict to one language (default: all)").option("--namespace <slug>", "Restrict to one namespace (default: all)").option("--version <slug>", "Version slug (default: production version)").option("--dry-run", "Print the planned release without publishing", false).option("--host <url>", "Override host (otherwise from config/credentials)").action(
+    async (opts) => {
+      const ctx = await resolveContext({ hostOverride: opts.host });
+      const scope = [
+        opts.language && `language=${opts.language}`,
+        opts.namespace && `namespace=${opts.namespace}`,
+        opts.version && `version=${opts.version}`
+      ].filter(Boolean).join(", ") || "ALL languages + namespaces";
+      if (opts.dryRun) {
+        console.log(`(dry-run) would publish a CDN release for ${scope}; nothing sent.`);
+        return;
+      }
+      const body = {};
+      if (opts.language) body.language_code = opts.language;
+      if (opts.namespace) body.namespace = opts.namespace;
+      if (opts.version) body.version_slug = opts.version;
+      const res = await publishCdn(ctx, body);
+      console.log(`published CDN release for ${scope}`);
+      console.log(JSON.stringify(res, null, 2));
+    }
+  )
+);
+
+// src/commands/snapshot.ts
+import { promises as fs6 } from "fs";
+import { Command as Command12 } from "commander";
+function bundleUrl(cdnBase, project, version, lang, ns) {
+  return `${cdnBase.replace(/\/+$/, "")}/p/${project}/${version}/latest/${lang}/${ns}.json`;
+}
+function renderSnapshot(bundles, meta, format) {
+  const json = JSON.stringify(bundles, null, 2);
+  if (format === "json") return json + "\n";
+  return `// Generated by \`sonenta snapshot\` \u2014 do not edit by hand.
+// Build-time fallback for @sonenta/react-i18next:
+//   import { bundles } from "./<this-file>";
+//   <VerbumiaProvider initialBundles={bundles} />
+export const bundles = ${json} as const;
+
+export const meta = ${JSON.stringify(meta, null, 2)} as const;
+
+export default bundles;
+`;
+}
+async function fetchBundle(url) {
+  const res = await fetch(url, { headers: { Accept: "application/json" } });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`HTTP ${res.status} fetching ${url}`);
+  return await res.json();
+}
+var snapshotCommand = new Command12("snapshot").description(
+  "Generate a build-time translations snapshot for @sonenta/react-i18next `initialBundles` (offline-first fallback). Fetches the PUBLIC CDN bundles (exactly what the SDK loads at runtime) and assembles Record<locale, Record<namespace, tree>>. Emits a .ts module (default) or .json."
+).option("--language <code>", "Restrict to a single language code").option("--namespace <slug>", "Restrict to a single namespace slug").option("--version <slug>", "Version slug (default: the configured version_slug)").option("--format <fmt>", "ts | json (default: ts)", "ts").option("--cdn <base>", "CDN base URL", "https://cdn.sonenta.com").option("--out <file>", "Write to a file instead of stdout").option("--host <url>", "Override host (used to discover languages/namespaces)").action(
+  async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const project = requireProject(ctx);
+    const version = opts.version ?? ctx.versionSlug;
+    let languages;
+    let namespaces;
+    if (opts.language && opts.namespace) {
+      languages = [opts.language];
+      namespaces = [opts.namespace];
+    } else {
+      const info = await getProjectInfo(ctx);
+      languages = opts.language ? [opts.language] : info.languages;
+      namespaces = opts.namespace ? [opts.namespace] : info.namespaces;
+      if (languages.length === 0 || namespaces.length === 0) {
+        throw new Error(
+          "could not enumerate languages/namespaces from project-info \u2014 pass --language and --namespace explicitly."
+        );
+      }
+    }
+    const bundles = {};
+    let fetched = 0;
+    let missing = 0;
+    for (const lang of languages) {
+      for (const ns of namespaces) {
+        const tree = await fetchBundle(bundleUrl(opts.cdn, project, version, lang, ns));
+        if (!tree) {
+          missing++;
+          continue;
+        }
+        (bundles[lang] ??= {})[ns] = tree;
+        fetched++;
+      }
+    }
+    const output = renderSnapshot(
+      bundles,
+      { project, version, cdn: opts.cdn.replace(/\/+$/, "") },
+      opts.format === "json" ? "json" : "ts"
+    );
+    if (opts.out) {
+      await fs6.writeFile(opts.out, output, "utf8");
+      console.log(
+        `wrote ${opts.out}: ${fetched} bundle(s)` + (missing ? `, ${missing} not published (404)` : "")
+      );
+    } else {
+      process.stdout.write(output);
+      if (missing) console.error(`(${missing} bundle(s) not published)`);
+    }
+  }
+);
+
+// src/commands/status.ts
+import { Command as Command13 } from "commander";
+var statusCommand = new Command13("status").description("Diff local locales/ against the remote project state.").option("--language <code>", "Restrict to one language code").option("--namespace <slug>", "Restrict to one namespace slug").option("--src <dir>", "Locales directory", DEFAULT_LOCALES_DIR).option("--host <url>", "Override host (otherwise from config/credentials)").action(
+  async (opts) => {
+    const ctx = await resolveContext({ hostOverride: opts.host });
+    const knownLangs = new Set((await getProjectInfo(ctx)).languages);
+    const files = (await listLocaleFiles(opts.src)).filter((f) => {
+      if (opts.language && f.lang !== opts.language) return false;
+      if (opts.namespace && f.namespace !== opts.namespace) return false;
+      return true;
+    });
+    const remoteByLang = /* @__PURE__ */ new Map();
+    async function remoteFor(ctx2, lang) {
+      const cached = remoteByLang.get(lang);
+      if (cached) return cached;
+      const m = /* @__PURE__ */ new Map();
+      for (const it of await listKeys(ctx2, { languageCode: lang })) {
+        const tr = it.translations?.find((t) => t.language_code === lang);
+        if (!tr || tr.value === "") continue;
+        const map = m.get(it.namespace_slug) ?? {};
+        map[it.key_name] = tr.value;
+        m.set(it.namespace_slug, map);
+      }
+      remoteByLang.set(lang, m);
+      return m;
+    }
+    let totalAdded = 0;
+    let totalRemoved = 0;
+    let totalChanged = 0;
+    let totalUnchanged = 0;
+    for (const f of files) {
+      if (knownLangs.size > 0 && !knownLangs.has(f.lang)) {
+        console.log(`! ${f.lang}/${f.namespace}.json \u2014 language not in project, skipped`);
+        continue;
+      }
+      const local = await readLocaleFile(f.path);
+      const remote = (await remoteFor(ctx, f.lang)).get(f.namespace) ?? {};
+      const d = diffFlat(local, remote);
+      totalAdded += d.added.length;
+      totalRemoved += d.removed.length;
+      totalChanged += d.changed.length;
+      totalUnchanged += d.unchanged;
+      if (d.added.length === 0 && d.removed.length === 0 && d.changed.length === 0) {
+        console.log(`= ${f.lang}/${f.namespace}.json  (in sync, ${d.unchanged} keys)`);
+        continue;
+      }
+      console.log(
+        `~ ${f.lang}/${f.namespace}.json  +${d.added.length} -${d.removed.length} ~${d.changed.length}`
+      );
+      for (const k of d.added) console.log(`    + ${k}`);
+      for (const k of d.removed) console.log(`    - ${k}  (remote-only \u2014 push leaves untouched)`);
+      for (const c of d.changed) console.log(`    ~ ${c.key}  "${c.local}" <- "${c.remote}"`);
+    }
+    console.log(
+      `summary: +${totalAdded} -${totalRemoved} ~${totalChanged}  unchanged=${totalUnchanged}`
+    );
+  }
+);
+
+// src/commands/whoami.ts
+import { Command as Command14 } from "commander";
+var whoamiCommand = new Command14("whoami").description("Show the configured default host + which API key is in use.").option("--host <url>", "Inspect a specific host instead of the default").action(async (opts) => {
+  const creds = await readCredentials();
+  if (!creds.default && Object.keys(creds.hosts).length === 0) {
+    console.log("Not logged in. Run `sonenta login --host <url> --token <\u2026>`.");
+    process.exit(1);
+  }
+  const target = opts.host ?? creds.default;
+  if (!target) {
+    console.log("No default host set.");
+    process.exit(1);
+  }
+  const entry = creds.hosts[target];
+  if (!entry) {
+    console.log(`No credentials stored for ${target}.`);
+    process.exit(1);
+  }
+  const masked = entry.api_key.replace(/\.[\s\S]+$/, ".\u2022\u2022\u2022");
+  const envOverride = (process.env.SONENTA_TOKEN ?? process.env.VERBUMIA_TOKEN)?.trim();
+  console.log(`host:      ${target}${target === creds.default ? "  (default)" : ""}`);
+  console.log(`api_key:   ${masked}${envOverride ? "  (overridden by SONENTA_TOKEN env)" : ""}`);
+  if (entry.user_email) console.log(`email:     ${entry.user_email}`);
+  const others = Object.keys(creds.hosts).filter((h) => h !== target);
+  if (others.length) {
+    console.log(`other:     ${others.join(", ")}`);
+  }
+});
+
+// src/index.ts
+var program = new Command15();
+program.name("sonenta").description("CLI for Sonenta translation management.").version("0.3.0");
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(initCommand);
+program.addCommand(projectsCommand);
+program.addCommand(keysCommand);
+program.addCommand(importCommand);
+program.addCommand(pushCommand);
+program.addCommand(pullCommand);
+program.addCommand(exportCommand);
+program.addCommand(statusCommand);
+program.addCommand(releasesCommand);
+program.addCommand(snapshotCommand);
+program.addCommand(missingCommand);
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : err);
+  process.exit(1);
+});
+//# sourceMappingURL=index.js.map