shiva-code 0.8.13 → 0.8.15

package/dist/chunk-VVP3NTOY.js

@@ -1,3437 +0,0 @@
-import {
-  colors,
-  log
-} from "./chunk-5RLMQDLT.js";
-import {
-  api
-} from "./chunk-KB6M24M3.js";
-import {
-  clearAuth,
-  getConfig,
-  isAuthenticated,
-  setAuth
-} from "./chunk-OP4HYQZZ.js";
-import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
-
-// src/commands/auth/login.ts
-import { Command } from "commander";
-import inquirer2 from "inquirer";
-
-// src/services/auth/auth.ts
-import inquirer from "inquirer";
-import open from "open";
-import http from "http";
-import { URL } from "url";
-
-// src/services/auth/two-factor.ts
-import * as crypto from "crypto";
-function generateSecret(length = 20) {
-  const buffer = crypto.randomBytes(length);
-  return base32Encode(buffer);
-}
-function base32Encode(buffer) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-  let result = "";
-  let bits = 0;
-  let value = 0;
-  for (let i = 0; i < buffer.length; i++) {
-    value = value << 8 | buffer[i];
-    bits += 8;
-    while (bits >= 5) {
-      result += alphabet[value >>> bits - 5 & 31];
-      bits -= 5;
-    }
-  }
-  if (bits > 0) {
-    result += alphabet[value << 5 - bits & 31];
-  }
-  return result;
-}
-function base32Decode(encoded) {
-  const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
-  const lookup = /* @__PURE__ */ new Map();
-  for (let i = 0; i < alphabet.length; i++) {
-    lookup.set(alphabet[i], i);
-  }
-  const bytes = [];
-  let bits = 0;
-  let value = 0;
-  for (const char of encoded.toUpperCase()) {
-    if (char === "=") continue;
-    const index = lookup.get(char);
-    if (index === void 0) continue;
-    value = value << 5 | index;
-    bits += 5;
-    if (bits >= 8) {
-      bytes.push(value >>> bits - 8 & 255);
-      bits -= 8;
-    }
-  }
-  return Buffer.from(bytes);
-}
-function generateTOTP(secret, timeStep = 30) {
-  const time = Math.floor(Date.now() / 1e3 / timeStep);
-  const key = base32Decode(secret);
-  const counter = Buffer.alloc(8);
-  counter.writeBigUInt64BE(BigInt(time));
-  const hmac = crypto.createHmac("sha1", key);
-  hmac.update(counter);
-  const hash = hmac.digest();
-  const offset = hash[hash.length - 1] & 15;
-  const code = ((hash[offset] & 127) << 24 | (hash[offset + 1] & 255) << 16 | (hash[offset + 2] & 255) << 8 | hash[offset + 3] & 255) % 1e6;
-  return code.toString().padStart(6, "0");
-}
-function verifyTOTP(secret, code, timeStep = 30) {
-  for (let i = -1; i <= 1; i++) {
-    const time = Math.floor(Date.now() / 1e3 / timeStep) + i;
-    const expectedCode = generateTOTPForTime(secret, time, timeStep);
-    if (expectedCode === code) {
-      return true;
-    }
-  }
-  return false;
-}
-function generateTOTPForTime(secret, time, timeStep) {
-  const key = base32Decode(secret);
-  const counter = Buffer.alloc(8);
-  counter.writeBigUInt64BE(BigInt(time));
-  const hmac = crypto.createHmac("sha1", key);
-  hmac.update(counter);
-  const hash = hmac.digest();
-  const offset = hash[hash.length - 1] & 15;
-  const code = ((hash[offset] & 127) << 24 | (hash[offset + 1] & 255) << 16 | (hash[offset + 2] & 255) << 8 | hash[offset + 3] & 255) % 1e6;
-  return code.toString().padStart(6, "0");
-}
-function generateOtpAuthUrl(secret, email, issuer = "SHIVA Code") {
-  const encodedIssuer = encodeURIComponent(issuer);
-  const encodedEmail = encodeURIComponent(email);
-  return `otpauth://totp/${encodedIssuer}:${encodedEmail}?secret=${secret}&issuer=${encodedIssuer}&algorithm=SHA1&digits=6&period=30`;
-}
-function generateBackupCodes(count = 10) {
-  const codes = [];
-  for (let i = 0; i < count; i++) {
-    const buffer = crypto.randomBytes(6);
-    const code = buffer.toString("hex").toUpperCase();
-    codes.push(`${code.slice(0, 3)}-${code.slice(3, 6)}-${code.slice(6, 9)}-${code.slice(9, 12)}`);
-  }
-  return codes;
-}
-function generateDeviceFingerprint() {
-  const os = __require("os");
-  const components = [
-    os.hostname(),
-    os.platform(),
-    os.arch(),
-    os.cpus()[0]?.model || "unknown",
-    os.userInfo().username
-  ];
-  const fingerprint = crypto.createHash("sha256").update(components.join("|")).digest("hex").slice(0, 32);
-  return fingerprint;
-}
-function getDeviceName() {
-  const os = __require("os");
-  const hostname = os.hostname();
-  const platform = os.platform();
-  const platformNames = {
-    darwin: "macOS",
-    linux: "Linux",
-    win32: "Windows"
-  };
-  return `${hostname} (${platformNames[platform] || platform})`;
-}
-var TwoFactorService = class {
-  /**
-   * Start 2FA setup - generate secret and QR code
-   */
-  async startSetup(email) {
-    try {
-      const response = await api.setup2FA();
-      if (!response.setup) {
-        throw new Error(response.message || "2FA-Setup fehlgeschlagen");
-      }
-      return response.setup;
-    } catch (error) {
-      const secret = generateSecret();
-      const otpAuthUrl = generateOtpAuthUrl(secret, email);
-      const backupCodes = generateBackupCodes();
-      return {
-        secret,
-        qrCodeDataUrl: otpAuthUrl,
-        // In real implementation, would be a data URL
-        backupCodes
-      };
-    }
-  }
-  /**
-   * Verify TOTP code and complete setup
-   */
-  async verifySetup(code) {
-    try {
-      const response = await api.verify2FA(code);
-      return response.success;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Verify TOTP code during login
-   */
-  async verifyCode(code) {
-    try {
-      const response = await api.verify2FACode(code);
-      return response.success;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Verify backup code
-   */
-  async verifyBackupCode(code) {
-    try {
-      const response = await api.verifyBackupCode(code);
-      return response.success;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Get 2FA status
-   */
-  async getStatus() {
-    try {
-      const response = await api.get2FAStatus();
-      return response;
-    } catch (error) {
-      return {
-        enabled: false,
-        backupCodesRemaining: 0
-      };
-    }
-  }
-  /**
-   * Disable 2FA
-   */
-  async disable(code) {
-    try {
-      const response = await api.disable2FA(code);
-      return response.success;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Generate new backup codes
-   */
-  async regenerateBackupCodes() {
-    try {
-      const response = await api.regenerateBackupCodes();
-      return response.codes;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Verify TOTP code locally (for testing)
-   */
-  verifyLocal(secret, code) {
-    return verifyTOTP(secret, code);
-  }
-  /**
-   * Generate TOTP code locally (for testing)
-   */
-  generateLocal(secret) {
-    return generateTOTP(secret);
-  }
-};
-var DeviceTrustService = class {
-  /**
-   * Get current device fingerprint
-   */
-  getFingerprint() {
-    return generateDeviceFingerprint();
-  }
-  /**
-   * Get current device name
-   */
-  getDeviceName() {
-    return getDeviceName();
-  }
-  /**
-   * Register current device as trusted
-   */
-  async trustDevice(name) {
-    const fingerprint = this.getFingerprint();
-    const deviceName = name || this.getDeviceName();
-    try {
-      const response = await api.trustDevice({
-        name: deviceName,
-        fingerprint
-      });
-      return response.device;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Check if current device is trusted
-   */
-  async isDeviceTrusted() {
-    const fingerprint = this.getFingerprint();
-    try {
-      const devices = await api.getDevices();
-      return devices.devices.some((d) => d.fingerprint === fingerprint);
-    } catch (error) {
-      return false;
-    }
-  }
-  /**
-   * List all trusted devices
-   */
-  async listDevices() {
-    try {
-      const response = await api.getDevices();
-      const currentFingerprint = this.getFingerprint();
-      return response.devices.map((d) => ({
-        ...d,
-        isCurrent: d.fingerprint === currentFingerprint
-      }));
-    } catch (error) {
-      return [];
-    }
-  }
-  /**
-   * Revoke a trusted device
-   */
-  async revokeDevice(deviceId) {
-    try {
-      const response = await api.revokeDevice(deviceId);
-      return response.success;
-    } catch (error) {
-      throw error;
-    }
-  }
-  /**
-   * Revoke all devices except current
-   */
-  async revokeAllDevices() {
-    try {
-      const response = await api.revokeAllDevices();
-      return response.revokedCount;
-    } catch (error) {
-      throw error;
-    }
-  }
-};
-var twoFactorService = new TwoFactorService();
-var deviceTrustService = new DeviceTrustService();
-function displayQRCode(url) {
-  log.newline();
-  log.info("Scan diesen QR-Code mit deiner Authenticator App:");
-  log.newline();
-  log.dim("(QR-Code-Anzeige erfordert qrcode-terminal Paket)");
-  log.newline();
-  log.plain(`URL: ${url}`);
-  log.newline();
-}
-function displayBackupCodes(codes) {
-  log.newline();
-  console.log(colors.orange.bold("Backup-Codes (speichern!)"));
-  console.log(colors.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  log.newline();
-  for (let i = 0; i < codes.length; i++) {
-    console.log(`  ${i + 1}. ${codes[i]}`);
-  }
-  log.newline();
-  log.warn("Diese Codes k\xF6nnen nur einmal verwendet werden!");
-  log.dim("Speichere sie an einem sicheren Ort.");
-  log.newline();
-}
-function displayDevices(devices) {
-  log.newline();
-  console.log(colors.orange.bold("Vertrauensw\xFCrdige Ger\xE4te"));
-  console.log(colors.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-  log.newline();
-  if (devices.length === 0) {
-    log.dim("Keine Ger\xE4te registriert");
-    return;
-  }
-  for (const device of devices) {
-    const current = device.isCurrent ? colors.green(" (aktuell)") : "";
-    console.log(`  ${device.name}${current}`);
-    log.dim(`    ID: ${device.id}`);
-    log.dim(`    Zuletzt: ${formatRelativeTime(device.lastUsed)}`);
-    if (device.expiresAt) {
-      log.dim(`    L\xE4uft ab: ${formatRelativeTime(device.expiresAt)}`);
-    } else {
-      log.dim("    L\xE4uft ab: nie");
-    }
-    log.newline();
-  }
-}
-function formatRelativeTime(dateStr) {
-  const date = new Date(dateStr);
-  const now = /* @__PURE__ */ new Date();
-  const diffMs = now.getTime() - date.getTime();
-  const diffSec = Math.floor(diffMs / 1e3);
-  const diffMin = Math.floor(diffSec / 60);
-  const diffHour = Math.floor(diffMin / 60);
-  const diffDay = Math.floor(diffHour / 24);
-  if (diffSec < 60) return "gerade eben";
-  if (diffMin < 60) return `vor ${diffMin} Minuten`;
-  if (diffHour < 24) return `vor ${diffHour} Stunden`;
-  if (diffDay < 30) return `vor ${diffDay} Tagen`;
-  return date.toLocaleDateString("de-DE");
-}
-
-// src/services/auth/auth.ts
-var PORT_RANGE_START = 9876;
-var PORT_RANGE_END = 9886;
-async function loginWithOtp(email) {
-  try {
-    log.info(`Sende Login-Code an ${email}...`);
-    const otpResponse = await api.requestOtp(email);
-    if (!otpResponse.success) {
-      log.error(otpResponse.message || "Fehler beim Senden des Codes");
-      return false;
-    }
-    log.success("Code wurde gesendet!");
-    log.dim(`Verbleibende Versuche: ${otpResponse.remainingAttempts}`);
-    log.newline();
-    const { otp } = await inquirer.prompt([
-      {
-        type: "input",
-        name: "otp",
-        message: "Code eingeben:",
-        validate: (input) => {
-          if (!/^\d{6}$/.test(input)) {
-            return "Bitte gib den 6-stelligen Code ein";
-          }
-          return true;
-        }
-      }
-    ]);
-    const authResponse = await api.verifyOtp(otpResponse.token, otp);
-    if (authResponse.requires2FA && authResponse.tempToken) {
-      log.newline();
-      log.info("2FA ist aktiviert. Bitte verifiziere dich.");
-      log.newline();
-      const result = await handle2FALoginFlow(authResponse.tempToken, authResponse.email || email);
-      return result;
-    }
-    if (!authResponse.success || !authResponse.token || !authResponse.user) {
-      log.error(authResponse.message || "Ung\xFCltiger Code");
-      return false;
-    }
-    setAuth(authResponse.token, authResponse.user);
-    log.newline();
-    log.success(`Angemeldet als ${authResponse.user.email} (${authResponse.user.tier.toUpperCase()})`);
-    return true;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unbekannter Fehler";
-    log.error(`Login fehlgeschlagen: ${message}`);
-    return false;
-  }
-}
-async function handle2FALoginFlow(tempToken, email) {
-  const MAX_ATTEMPTS = 3;
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-    const { code } = await inquirer.prompt([{
-      type: "input",
-      name: "code",
-      message: "2FA-Code (6 Ziffern oder Backup-Code):",
-      validate: (input) => {
-        if (/^\d{6}$/.test(input) || /^[A-Za-z0-9-]+$/.test(input)) {
-          return true;
-        }
-        return "Bitte gib einen g\xFCltigen Code ein";
-      }
-    }]);
-    const { rememberDevice } = await inquirer.prompt([{
-      type: "confirm",
-      name: "rememberDevice",
-      message: "Diesem Ger\xE4t vertrauen?",
-      default: true
-    }]);
-    try {
-      const result = await api.validate2FALogin({
-        tempToken,
-        code,
-        rememberDevice
-      });
-      if (result.success && result.token && result.user) {
-        setAuth(result.token, result.user);
-        if (result.method === "backup" && result.backupCodesRemaining !== void 0) {
-          log.warn(`Backup-Code verwendet. Noch ${result.backupCodesRemaining} Codes \xFCbrig.`);
-        }
-        log.newline();
-        log.success(`Angemeldet als ${result.user.email} (${result.user.tier.toUpperCase()})`);
-        return true;
-      }
-      if (attempt < MAX_ATTEMPTS) {
-        log.error(`Ung\xFCltiger Code. Noch ${MAX_ATTEMPTS - attempt} Versuche.`);
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Verifizierung fehlgeschlagen";
-      if (message.includes("expired") || message.includes("abgelaufen")) {
-        log.error("2FA-Token abgelaufen. Bitte erneut anmelden.");
-        return false;
-      }
-      if (attempt < MAX_ATTEMPTS) {
-        log.error(`${message}. Noch ${MAX_ATTEMPTS - attempt} Versuche.`);
-      }
-    }
-  }
-  log.error("2FA-Verifizierung fehlgeschlagen");
-  return false;
-}
-async function findAvailablePort() {
-  for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
-    const isAvailable = await checkPort(port);
-    if (isAvailable) {
-      return port;
-    }
-  }
-  throw new Error("Kein freier Port f\xFCr Callback-Server gefunden");
-}
-function checkPort(port) {
-  return new Promise((resolve) => {
-    const server = http.createServer();
-    server.once("error", () => resolve(false));
-    server.once("listening", () => {
-      server.close();
-      resolve(true);
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-function getCallbackHtml(type, data) {
-  const baseStyles = `
-    * { margin: 0; padding: 0; box-sizing: border-box; }
-    body {
-      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
-      min-height: 100vh;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 50%, #16213e 100%);
-      color: #fff;
-    }
-    .container {
-      text-align: center;
-      padding: 3rem;
-      max-width: 420px;
-    }
-    .logo {
-      width: 80px;
-      height: 80px;
-      margin: 0 auto 1.5rem;
-      background: linear-gradient(135deg, #f97316 0%, #ea580c 100%);
-      border-radius: 20px;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-      box-shadow: 0 10px 40px rgba(249, 115, 22, 0.3);
-    }
-    .logo svg {
-      width: 48px;
-      height: 48px;
-    }
-    h1 {
-      font-size: 1.75rem;
-      font-weight: 700;
-      margin-bottom: 0.75rem;
-    }
-    .subtitle {
-      color: #9ca3af;
-      font-size: 1rem;
-      line-height: 1.5;
-    }
-    .email {
-      color: #f97316;
-      font-weight: 600;
-    }
-    .status-icon {
-      width: 64px;
-      height: 64px;
-      margin: 0 auto 1.5rem;
-      border-radius: 50%;
-      display: flex;
-      align-items: center;
-      justify-content: center;
-    }
-    .status-icon.success {
-      background: linear-gradient(135deg, #22c55e 0%, #16a34a 100%);
-      box-shadow: 0 10px 40px rgba(34, 197, 94, 0.3);
-    }
-    .status-icon.error {
-      background: linear-gradient(135deg, #ef4444 0%, #dc2626 100%);
-      box-shadow: 0 10px 40px rgba(239, 68, 68, 0.3);
-    }
-    .status-icon svg {
-      width: 32px;
-      height: 32px;
-    }
-    .spinner {
-      width: 48px;
-      height: 48px;
-      margin: 0 auto 1.5rem;
-      border: 3px solid rgba(249, 115, 22, 0.2);
-      border-top-color: #f97316;
-      border-radius: 50%;
-      animation: spin 1s linear infinite;
-    }
-    @keyframes spin {
-      to { transform: rotate(360deg); }
-    }
-    .hint {
-      margin-top: 1.5rem;
-      padding-top: 1.5rem;
-      border-top: 1px solid rgba(255, 255, 255, 0.1);
-      color: #6b7280;
-      font-size: 0.875rem;
-    }
-  `;
-  const shivaLogo = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/></svg>`;
-  const checkIcon = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"><polyline points="20 6 9 17 4 12"/></svg>`;
-  const xIcon = `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"><line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/></svg>`;
-  if (type === "success") {
-    return `<!DOCTYPE html>
-<html lang="de">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>SHIVA CLI - Angemeldet</title>
-  <style>${baseStyles}</style>
-</head>
-<body>
-  <div class="container">
-    <div class="status-icon success">${checkIcon}</div>
-    <h1>Erfolgreich angemeldet!</h1>
-    <p class="subtitle">Willkommen zur\xFCck, <span class="email">${data.email}</span></p>
-    <p class="hint">Du kannst dieses Fenster jetzt schlie\xDFen und zum Terminal zur\xFCckkehren.</p>
-  </div>
-  <script>setTimeout(() => window.close(), 3000);</script>
-</body>
-</html>`;
-  }
-  if (type === "error") {
-    return `<!DOCTYPE html>
-<html lang="de">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>SHIVA CLI - Fehler</title>
-  <style>${baseStyles}</style>
-</head>
-<body>
-  <div class="container">
-    <div class="status-icon error">${xIcon}</div>
-    <h1>Anmeldung fehlgeschlagen</h1>
-    <p class="subtitle">${data.message || "Ein unbekannter Fehler ist aufgetreten."}</p>
-    <p class="hint">Du kannst dieses Fenster schlie\xDFen und es erneut versuchen.</p>
-  </div>
-</body>
-</html>`;
-  }
-  return `<!DOCTYPE html>
-<html lang="de">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>SHIVA CLI</title>
-  <style>${baseStyles}</style>
-</head>
-<body>
-  <div class="container">
-    <div class="logo">${shivaLogo}</div>
-    <div class="spinner"></div>
-    <h1>SHIVA CLI</h1>
-    <p class="subtitle">Warte auf Login-Callback...</p>
-  </div>
-</body>
-</html>`;
-}
-function startCallbackServer(port) {
-  return new Promise((resolve, reject) => {
-    const server = http.createServer((req, res) => {
-      const url = new URL(req.url || "/", `http://127.0.0.1:${port}`);
-      if (url.pathname === "/callback") {
-        const token = url.searchParams.get("token");
-        const userId = url.searchParams.get("userId");
-        const email = url.searchParams.get("email");
-        const tier = url.searchParams.get("tier");
-        const error = url.searchParams.get("error");
-        if (error) {
-          res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-          res.end(getCallbackHtml("error", { message: error }));
-          server.close();
-          reject(new Error(error));
-          return;
-        }
-        if (!token || !userId || !email) {
-          res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-          res.end(getCallbackHtml("error", { message: "Token oder Benutzer-Daten fehlen." }));
-          server.close();
-          reject(new Error("Ung\xFCltige Callback-Parameter"));
-          return;
-        }
-        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-        res.end(getCallbackHtml("success", { email }));
-        server.close();
-        resolve({
-          token,
-          user: {
-            id: parseInt(userId, 10),
-            email,
-            tier: tier || "free"
-          }
-        });
-        return;
-      }
-      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      res.end(getCallbackHtml("waiting", {}));
-    });
-    const timeout = setTimeout(() => {
-      server.close();
-      reject(new Error("Login-Timeout - keine Antwort erhalten"));
-    }, 12e4);
-    server.once("close", () => {
-      clearTimeout(timeout);
-    });
-    server.once("error", (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-async function loginWithBrowser() {
-  const config = getConfig();
-  try {
-    const port = await findAvailablePort();
-    const callbackUrl = `http://127.0.0.1:${port}/callback`;
-    const baseUrl = config.apiEndpoint.replace("/api", "");
-    const loginUrl = `${baseUrl}/auth/cli-login?callback=${encodeURIComponent(callbackUrl)}`;
-    const serverPromise = startCallbackServer(port);
-    log.newline();
-    log.info("\xD6ffne Browser zur Anmeldung...");
-    try {
-      await open(loginUrl);
-    } catch {
-    }
-    log.newline();
-    log.plain("Bitte \xF6ffne diese URL in deinem Browser um die Anmeldung abzuschlie\xDFen:");
-    log.newline();
-    console.log(`  ${colors.cyan(loginUrl)}`);
-    log.newline();
-    log.dim("Warte auf Anmeldung... (Timeout: 2 Minuten)");
-    log.newline();
-    const result = await serverPromise;
-    setAuth(result.token, result.user);
-    try {
-      const tfaStatus = await twoFactorService.getStatus();
-      if (tfaStatus.enabled) {
-        log.newline();
-        log.info("2FA ist aktiviert. Bitte verifiziere dich.");
-        log.newline();
-        const isDeviceTrusted = await deviceTrustService.isDeviceTrusted();
-        if (!isDeviceTrusted) {
-          const verified = await prompt2FAVerification();
-          if (!verified) {
-            clearAuth();
-            log.error("2FA-Verifizierung fehlgeschlagen");
-            return false;
-          }
-          const { trustDevice } = await inquirer.prompt([{
-            type: "confirm",
-            name: "trustDevice",
-            message: "Diesem Ger\xE4t vertrauen?",
-            default: true
-          }]);
-          if (trustDevice) {
-            try {
-              await deviceTrustService.trustDevice();
-              log.success("Ger\xE4t als vertrauensw\xFCrdig markiert");
-            } catch {
-            }
-          }
-        } else {
-          log.dim("Ger\xE4t ist vertrauensw\xFCrdig - 2FA \xFCbersprungen");
-        }
-      }
-    } catch {
-    }
-    log.success(`Angemeldet als ${result.user.email} (${result.user.tier.toUpperCase()})`);
-    return true;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unbekannter Fehler";
-    log.error(`Login fehlgeschlagen: ${message}`);
-    log.newline();
-    log.info("Fallback: Manueller Token-Eintrag");
-    const loginUrl = `${config.apiEndpoint.replace("/api", "")}/auth/cli-login`;
-    log.dim(`URL: ${loginUrl}`);
-    log.newline();
-    const { useManual } = await inquirer.prompt([{
-      type: "confirm",
-      name: "useManual",
-      message: "Token manuell eingeben?",
-      default: true
-    }]);
-    if (!useManual) {
-      return false;
-    }
-    try {
-      await open(loginUrl);
-    } catch {
-      log.dim("Browser konnte nicht ge\xF6ffnet werden");
-      log.dim(`\xD6ffne manuell: ${loginUrl}`);
-    }
-    const { token } = await inquirer.prompt([{
-      type: "password",
-      name: "token",
-      message: "Token:",
-      mask: "*"
-    }]);
-    if (!token) {
-      log.error("Kein Token eingegeben");
-      return false;
-    }
-    setAuth(token, { id: 0, email: "", tier: "free" });
-    try {
-      const response = await api.getCurrentUser();
-      setAuth(token, response.user);
-      log.success(`Angemeldet als ${response.user.email}`);
-      return true;
-    } catch {
-      clearAuth();
-      log.error("Ung\xFCltiger Token");
-      return false;
-    }
-  }
-}
-function logout() {
-  clearAuth();
-  log.success("Abgemeldet");
-}
-async function prompt2FAVerification() {
-  const MAX_ATTEMPTS = 3;
-  for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
-    const { method } = await inquirer.prompt([{
-      type: "list",
-      name: "method",
-      message: "Verifizierungsmethode:",
-      choices: [
-        { name: "Authenticator App Code", value: "totp" },
-        { name: "Backup Code", value: "backup" },
-        { name: "Abbrechen", value: "cancel" }
-      ]
-    }]);
-    if (method === "cancel") {
-      return false;
-    }
-    const promptMessage = method === "totp" ? "6-stelliger Code aus deiner Authenticator App:" : "Backup-Code (Format: XXX-XXX-XXX-XXX):";
-    const { code } = await inquirer.prompt([{
-      type: "input",
-      name: "code",
-      message: promptMessage,
-      validate: (input) => {
-        if (method === "totp") {
-          return /^\d{6}$/.test(input) || "Bitte gib einen 6-stelligen Code ein";
-        }
-        return input.length > 0 || "Bitte gib einen Backup-Code ein";
-      }
-    }]);
-    try {
-      let verified = false;
-      if (method === "totp") {
-        verified = await twoFactorService.verifyCode(code);
-      } else {
-        verified = await twoFactorService.verifyBackupCode(code);
-      }
-      if (verified) {
-        log.success("2FA-Verifizierung erfolgreich");
-        return true;
-      }
-    } catch (error) {
-    }
-    if (attempt < MAX_ATTEMPTS) {
-      log.error(`Ung\xFCltiger Code. Noch ${MAX_ATTEMPTS - attempt} Versuche.`);
-    }
-  }
-  return false;
-}
-
-// src/i18n/locales/de.json
-var de_default = {
-  common: {
-    yes: "Ja",
-    no: "Nein",
-    cancel: "Abbrechen",
-    confirm: "Bestatigen",
-    success: "Erfolgreich!",
-    failed: "Fehlgeschlagen",
-    loading: "Laden...",
-    goodbye: "Auf Wiedersehen!",
-    cancelled: "Abgebrochen.",
-    continue: "Fortfahren",
-    back: "Zuruck",
-    save: "Speichern",
-    delete: "Loschen",
-    edit: "Bearbeiten",
-    create: "Erstellen",
-    open: "Offnen",
-    close: "Schliessen",
-    search: "Suchen",
-    filter: "Filtern",
-    all: "Alle",
-    none: "Keine",
-    unknown: "Unbekannt",
-    enabled: "Aktiviert",
-    disabled: "Deaktiviert",
-    total: "Gesamt",
-    date: "Datum",
-    time: "Zeit",
-    name: "Name",
-    value: "Wert",
-    type: "Typ",
-    status: "Status",
-    description: "Beschreibung",
-    actions: "Aktionen",
-    settings: "Einstellungen",
-    help: "Hilfe",
-    version: "Version",
-    forceOption: "Ohne Bestatigung",
-    pressAnyKey: "Beliebige Taste drucken um fortzufahren..."
-  },
-  auth: {
-    notLoggedIn: "Nicht angemeldet",
-    loginWith: "Anmelden mit: shiva login",
-    loginSuccess: "Erfolgreich angemeldet!",
-    logoutSuccess: "Erfolgreich abgemeldet.",
-    alreadyLoggedIn: "Bereits angemeldet als {email}",
-    loginCancelled: "Login abgebrochen.",
-    otpSent: "Login-Code wurde gesendet.",
-    otpInvalid: "Ungultiger Code.",
-    enterEmail: "Email-Adresse:",
-    enterOtp: "Login-Code eingeben:",
-    reloginQuestion: "Mochtest du dich neu anmelden?",
-    invalidEmail: "Bitte gib eine gultige Email-Adresse ein",
-    twoFactorEnabled: "2FA aktiviert.",
-    twoFactorDisabled: "2FA deaktiviert.",
-    invalidToken: "Ungultiger Token."
-  },
-  errors: {
-    unknown: "Ein unbekannter Fehler ist aufgetreten",
-    network: "Netzwerkfehler. Prufe deine Verbindung.",
-    notFound: "Nicht gefunden: {item}",
-    permissionDenied: "Keine Berechtigung",
-    apiError: "API-Fehler",
-    fileNotFound: "Datei nicht gefunden: {file}",
-    invalidFormat: "Ungultiges Format",
-    alreadyExists: "Existiert bereits: {item}",
-    notSupported: "Nicht unterstutzt",
-    timeout: "Zeituberschreitung",
-    invalidInput: "Ungultige Eingabe",
-    clipboardFailed: "Zwischenablage-Fehler"
-  },
-  commands: {
-    login: {
-      description: "Mit shiva.li anmelden",
-      emailOption: "Email-Adresse fur OTP-Login",
-      otpOption: "OTP-Login statt Browser verwenden"
-    },
-    logout: {
-      description: "Von shiva.li abmelden"
-    },
-    secrets: {
-      description: "API Keys und Secrets verwalten (Cloud Vault)",
-      vault: "SHIVA Secrets Vault",
-      global: "Global:",
-      projectSpecific: "Projekt-spezifisch:",
-      noSecrets: "Keine Secrets gespeichert",
-      addHint: "Secret hinzufugen: shiva secrets add <KEY> <VALUE>",
-      listDesc: "Alle Secrets anzeigen",
-      addDesc: "Secret hinzufugen",
-      removeDesc: "Secret entfernen",
-      getDesc: "Secret-Wert anzeigen (maskiert)",
-      envDesc: "Secrets als .env Format ausgeben",
-      importDesc: ".env Datei in Vault importieren",
-      exportDesc: "Secrets exportieren",
-      saved: 'Secret "{key}" gespeichert!',
-      deleted: 'Secret "{key}" geloscht',
-      copied: 'Secret "{key}" in Zwischenablage kopiert',
-      autoCleared: "Wird nach 30 Sekunden automatisch geloscht...",
-      invalidName: "Ungultiger Secret-Name",
-      nameFormat: "Format: GROSSBUCHSTABEN_MIT_UNTERSTRICHEN",
-      valueRequired: "Wert erforderlich",
-      confirmSave: "Secret speichern?",
-      confirmDelete: 'Secret "{key}" wirklich loschen?',
-      loadingSecrets: "Lade Secrets...",
-      savingSecret: "Speichere Secret...",
-      deletingSecret: "Losche Secret...",
-      exportingSecrets: "Exportiere Secrets...",
-      importingSecrets: "Importiere Secrets...",
-      fileContainsSensitive: "Diese Datei enthalt sensible Daten!",
-      addToGitignore: "Zur .gitignore hinzufugen!",
-      secretsImported: "{count} Secret(s) erfolgreich importiert",
-      secretsFailed: "{count} Secret(s) fehlgeschlagen",
-      noValidSecrets: "Keine gultigen Secrets in Datei gefunden",
-      dryRunInfo: "Dry-run: Keine Anderungen vorgenommen",
-      showValue: "Wert anzeigen?",
-      revealWarning: "Secret-Werte werden im Terminal angezeigt!",
-      revealHint: "Vollstandiger Wert mit --reveal oder -r anzeigen",
-      secretsToImport: "Secrets zum Import"
-    },
-    remember: {
-      description: "Memory in der Cloud speichern",
-      saved: "Memory gespeichert!",
-      category: "Kategorie: {category}"
-    },
-    search: {
-      description: "In Memories suchen",
-      header: "SHIVA Code - Suche",
-      noResults: "Keine Ergebnisse gefunden",
-      enterQuery: "Suchbegriff eingeben:",
-      searching: "Suche...",
-      resultsFound: "{count} Ergebnis(se) gefunden"
-    },
-    forget: {
-      description: "Memories loschen (GDPR)",
-      header: "SHIVA Code - Forget",
-      warning: "WARNUNG: Alle Memories loschen",
-      confirmDelete: "Memories wirklich loschen?",
-      deleted: "Memories geloscht",
-      selectMemories: "Memories zum Loschen auswahlen:"
-    },
-    sessions: {
-      description: "Alle Claude Code Sessions auflisten",
-      header: "SHIVA Code - Sessions",
-      noSessions: "Keine Sessions gefunden.",
-      branch: "Branch",
-      messages: "Nachrichten",
-      selectSession: "Session auswahlen:"
-    },
-    resume: {
-      description: "Session fortsetzen",
-      selectSession: "Session zum Fortsetzen auswahlen:",
-      starting: "Starte Session..."
-    },
-    restore: {
-      description: "Crashed Session wiederherstellen",
-      selectSession: "Session zum Wiederherstellen auswahlen:",
-      restored: "Session wiederhergestellt"
-    },
-    start: {
-      description: "Mehrere Projekte starten",
-      selectProjects: "Projekte zum Starten auswahlen:",
-      starting: "Starte {count} Projekt(e)...",
-      dockerMode: "Docker-Modus",
-      sandboxMode: "Sandbox-Modus"
-    },
-    init: {
-      description: "Projekt fur SHIVA Code initialisieren",
-      detected: "Erkannt",
-      initialized: "Projekt initialisiert!",
-      alreadyInitialized: "Projekt bereits initialisiert",
-      confirmInit: "Projekt initialisieren?",
-      creatingProject: "Erstelle Projekt..."
-    },
-    sync: {
-      description: "Projekt mit Cloud synchronisieren",
-      synced: "Synchronisiert",
-      batchSync: "SHIVA Code - Batch Sync",
-      syncing: "Synchronisiere...",
-      noChanges: "Keine Anderungen"
-    },
-    status: {
-      description: "Projekt-Status anzeigen",
-      header: "SHIVA Code - Status",
-      notInitialized: "Projekt nicht initialisiert. Nutze: shiva init"
-    },
-    projects: {
-      description: "Alle Projekte auflisten",
-      header: "SHIVA Code - Projekte",
-      noProjects: "Keine Projekte gefunden."
-    },
-    connect: {
-      description: "Projekt mit Cloud verbinden",
-      connected: "Projekt verbunden",
-      selectProject: "Projekt auswahlen:"
-    },
-    disconnect: {
-      description: "Projekt von Cloud trennen",
-      disconnected: "Projekt getrennt"
-    },
-    config: {
-      description: "Einstellungen verwalten",
-      header: "SHIVA Konfiguration",
-      claudeHeader: "Claude Code Einstellungen",
-      syncHeader: "Settings Sync Status",
-      featuresHeader: "Feature-Flags",
-      getDesc: "Einstellung anzeigen",
-      setDesc: "Einstellung setzen",
-      listDesc: "Alle Einstellungen anzeigen",
-      resetDesc: "Einstellungen zurucksetzen",
-      updated: "Einstellung aktualisiert",
-      currentValue: "Aktueller Wert: {value}",
-      invalidKey: "Ungultige Einstellung: {key}",
-      invalidValue: "Ungultiger Wert: {value}",
-      languageSet: "Sprache auf {lang} gesetzt",
-      invalidLanguage: "Ungultige Sprache. Verfugbar: {valid}"
-    },
-    issues: {
-      description: "GitHub Issues anzeigen",
-      header: "GitHub Issues",
-      noIssues: "Keine Issues gefunden",
-      selectIssue: "Issue auswahlen:",
-      creating: "Erstelle Issue..."
-    },
-    prs: {
-      description: "Pull Requests anzeigen",
-      header: "Pull Requests",
-      noPRs: "Keine Pull Requests gefunden",
-      selectPR: "PR auswahlen:"
-    },
-    github: {
-      description: "GitHub Integration",
-      header: "GitHub",
-      notInstalled: "GitHub CLI (gh) nicht installiert",
-      notAuthenticated: "GitHub CLI nicht authentifiziert",
-      notGitRepo: "Kein Git Repository",
-      notGithubRepo: "Kein GitHub Repository",
-      statusDesc: "GitHub Status anzeigen",
-      loginDesc: "Bei GitHub anmelden",
-      initDesc: "GitHub Repository initialisieren"
-    },
-    doctor: {
-      description: "System-Check",
-      header: "SHIVA Code - Doctor",
-      checking: "Prufe System...",
-      allGood: "Alles in Ordnung!",
-      issuesFound: "{count} Problem(e) gefunden"
-    },
-    stats: {
-      description: "Analytics anzeigen",
-      header: "SHIVA Code - Statistiken",
-      loading: "Lade Statistiken..."
-    },
-    upgrade: {
-      description: "SHIVA aktualisieren",
-      checking: "Prufe auf Updates...",
-      upToDate: "SHIVA ist aktuell (Version {version})",
-      newVersion: "Neue Version verfugbar: {version}",
-      upgrading: "Aktualisiere...",
-      upgraded: "SHIVA auf Version {version} aktualisiert"
-    },
-    telemetry: {
-      description: "Telemetrie-Einstellungen",
-      enabled: "Telemetrie aktiviert",
-      disabled: "Telemetrie deaktiviert"
-    },
-    completions: {
-      description: "Shell-Completions installieren",
-      installed: "Completions installiert fur {shell}",
-      installHint: "Starte deine Shell neu fur die Anderungen"
-    },
-    docker: {
-      description: "Docker-Modus verwalten",
-      header: "SHIVA Code - Docker",
-      notAvailable: "Docker ist nicht verfugbar",
-      starting: "Docker-Container wird gestartet...",
-      started: "Docker-Container gestartet",
-      stopped: "Docker-Container gestoppt",
-      statusDesc: "Docker-Status anzeigen",
-      startDesc: "Docker-Container starten",
-      stopDesc: "Docker-Container stoppen",
-      logsDesc: "Docker-Logs anzeigen"
-    },
-    sandbox: {
-      description: "Sandbox verwalten",
-      header: "SHIVA Code - Sandbox",
-      created: "Sandbox erstellt",
-      applied: "Sandbox-Anderungen ubernommen",
-      discarded: "Sandbox verworfen",
-      listDesc: "Alle Sandboxes anzeigen",
-      createDesc: "Neue Sandbox erstellen",
-      applyDesc: "Sandbox-Anderungen ubernehmen",
-      discardDesc: "Sandbox verwerfen"
-    },
-    workflow: {
-      description: "Workflows verwalten",
-      header: "SHIVA Code - Workflows"
-    },
-    hook: {
-      description: "Hooks verwalten",
-      header: "SHIVA Code - Hooks"
-    },
-    package: {
-      description: "Projekt-Gruppen verwalten",
-      header: "SHIVA Code - Packages",
-      noPackages: "Keine Packages gefunden",
-      createDesc: "Neues Package erstellen",
-      listDesc: "Alle Packages anzeigen",
-      addDesc: "Projekt zu Package hinzufugen",
-      removeDesc: "Projekt aus Package entfernen",
-      deleteDesc: "Package loschen",
-      created: 'Package "{name}" erstellt',
-      deleted: 'Package "{name}" geloscht',
-      projectAdded: "Projekt zu Package hinzugefugt",
-      projectRemoved: "Projekt aus Package entfernt"
-    },
-    context: {
-      description: "Context anzeigen",
-      header: "SHIVA Code - Context",
-      noContext: "Kein Context gefunden"
-    },
-    tags: {
-      description: "Session-Tags verwalten",
-      header: "SHIVA Code - Tags",
-      noTags: "Keine Tags gefunden"
-    },
-    export: {
-      description: "Sessions exportieren",
-      header: "SHIVA Code - Export",
-      exported: "Exportiert nach {file}",
-      selectFormat: "Format auswahlen:"
-    },
-    import: {
-      description: "Sessions importieren",
-      header: "SHIVA Code - Import",
-      imported: "{count} Session(s) importiert",
-      selectFile: "Datei auswahlen:"
-    },
-    user: {
-      description: "Benutzer-Informationen",
-      header: "SHIVA Code - Benutzer"
-    },
-    welcome: {
-      description: "Willkommen-Nachricht anzeigen"
-    },
-    validate: {
-      description: "Projekt validieren",
-      header: "SHIVA Code - Validierung",
-      valid: "Projekt ist gultig",
-      invalid: "Projekt ist ungultig"
-    },
-    scan: {
-      description: "Package auf Sicherheit prufen",
-      header: "SHIVA Code - Security Scan",
-      scanning: "Scanne...",
-      noIssues: "Keine Sicherheitsprobleme gefunden",
-      issuesFound: "{count} Sicherheitsproblem(e) gefunden"
-    },
-    security: {
-      description: "Sicherheitseinstellungen",
-      header: "SHIVA Code - Security"
-    },
-    secureToken: {
-      description: "Token sicher speichern"
-    },
-    project: {
-      description: "Projekt-Informationen",
-      header: "SHIVA Code - Projekt"
-    },
-    repair: {
-      description: "Projekt reparieren",
-      header: "SHIVA Code - Repair",
-      repaired: "Projekt repariert"
-    },
-    help: {
-      description: "Hilfe und Dokumentation",
-      header: "SHIVA Code - Hilfe",
-      topics: "Themen:",
-      quickstart: "Schnellstart",
-      commands: "Commands Ubersicht",
-      memory: "Memory System",
-      secrets: "Secrets Verwaltung",
-      troubleshooting: "Problemlosung",
-      onlineHelp: "Online Hilfe offnen"
-    }
-  },
-  controlStation: {
-    title: "SHIVA Control Station",
-    selection: "Auswahl:",
-    navigate: "navigate",
-    sessions: "Sessions",
-    sessionsDesc: "Alle anzeigen",
-    packages: "Packages",
-    packagesDesc: "Verwalten",
-    issues: "Issues",
-    issuesDesc: "GitHub Issues",
-    prs: "PRs",
-    prsDesc: "Pull Requests",
-    config: "Config",
-    configDesc: "Einstellungen",
-    help: "Hilfe",
-    helpDesc: "Dokumentation",
-    quit: "Beenden",
-    noSessionsFound: "Keine Sessions gefunden.",
-    startClaudeHint: "Starte Claude Code in einem Projekt",
-    orCreatePackage: 'Oder: shiva package create "Name"',
-    startingSession: "Starte Session in {project}...",
-    startingPackage: "Starte Package {name}...",
-    unknownCommand: "Unbekannter Befehl: {command}",
-    didYouMean: "Meintest du vielleicht:",
-    projects: "Projekte",
-    claudeNotInstalled: "Claude Code nicht installiert",
-    claudeInstallHint: "curl -fsSL https://claude.ai/install.sh | bash"
-  },
-  help: {
-    quickstart: {
-      title: "Schnellstart",
-      content: [
-        "1. shiva login     - Anmelden",
-        "2. shiva init      - Projekt initialisieren",
-        "3. shiva           - Control Station offnen",
-        "4. shiva remember  - Memory speichern",
-        "5. shiva secrets   - Secrets verwalten"
-      ]
-    },
-    commandsOverview: {
-      title: "Commands Ubersicht",
-      sessionManagement: "Session-Verwaltung",
-      githubIntegration: "GitHub Integration",
-      memoryContext: "Memory & Context",
-      dockerIntegration: "Docker Integration",
-      security: "Security",
-      projectManagement: "Projekt-Verwaltung",
-      system: "System"
-    },
-    memorySystem: {
-      title: "Memory System",
-      description: "SHIVA speichert Informationen persistent in der Cloud.",
-      categories: {
-        identity: "User-Identitat (Name, Rolle)",
-        preference: "Praferenzen (Code-Style)",
-        convention: "Projekt-Konventionen",
-        solution: "Geloste Probleme",
-        task: "Aufgaben",
-        context: "Projekt-Kontext"
-      }
-    },
-    secretsManagement: {
-      title: "Secrets Verwaltung",
-      description: "Sichere Speicherung von API Keys und Secrets in der Cloud.",
-      features: [
-        "Ende-zu-Ende verschlusselt",
-        "Automatische Injektion in Sessions",
-        "Projekt-spezifische und globale Secrets",
-        "Import/Export von .env Dateien"
-      ]
-    },
-    troubleshooting: {
-      title: "Problemlosung",
-      commonIssues: {
-        notLoggedIn: "Nicht angemeldet",
-        notLoggedInSolution: "Nutze 'shiva login' zum Anmelden",
-        claudeNotFound: "Claude Code nicht gefunden",
-        claudeNotFoundSolution: "Installiere Claude Code mit dem offiziellen Installer",
-        networkError: "Netzwerkfehler",
-        networkErrorSolution: "Prufe deine Internetverbindung",
-        permissionDenied: "Keine Berechtigung",
-        permissionDeniedSolution: "Prufe Dateiberechtigungen oder starte mit sudo"
-      }
-    }
-  },
-  time: {
-    justNow: "gerade eben",
-    minutesAgo: "vor {count} Minute(n)",
-    hoursAgo: "vor {count} Stunde(n)",
-    daysAgo: "vor {count} Tag(en)",
-    weeksAgo: "vor {count} Woche(n)",
-    monthsAgo: "vor {count} Monat(en)"
-  },
-  onboarding: {
-    welcome: "Willkommen bei SHIVA Code!",
-    subtitle: "Macht Claude Code persistent",
-    selectLanguage: "Sprache wahlen:",
-    claudeCode: "Claude Code",
-    claudeNotFound: "Claude Code nicht gefunden",
-    claudeNotFoundDesc: "SHIVA erweitert Claude Code mit persistentem Speicher. Du brauchst Claude Code um SHIVA nutzen zu konnen.",
-    installation: "Installation:",
-    moreInfo: "Mehr Infos:",
-    continueAnyway: "Trotzdem fortfahren?",
-    restartAfterInstall: "Starte nach Installation erneut: shiva",
-    found: "Gefunden",
-    display: "Darstellung",
-    darkMode: "Dark Mode",
-    lightMode: "Light Mode",
-    recommended: "(empfohlen)",
-    themeSaved: "Theme gespeichert",
-    account: "Account",
-    accountFeatures: "Mit einem Account bekommst du:",
-    cloudSync: "Cloud-Sync fur Memories",
-    crossDeviceSessions: "Sessions zwischen Geraten",
-    secretsVault: "Secrets Vault (verschlusselt)",
-    loginNow: "Jetzt anmelden?",
-    openBrowser: "Offne Browser...",
-    loginLater: "Spater: shiva login",
-    integration: "Integration",
-    autoIntegration: "SHIVA integriert sich automatisch mit Claude Code:",
-    loadMemoriesOnStart: "Memories beim Start laden",
-    saveMemoriesOnExit: "Memories beim Beenden speichern",
-    enableAutoIntegration: "Auto-Integration aktivieren?",
-    hooksInstalled: "Hooks installiert",
-    hooksFailed: "Hook-Installation fehlgeschlagen",
-    hooksLater: "Spater: shiva hook install",
-    setupComplete: "Setup abgeschlossen!",
-    nextSteps: "Nachste Schritte:",
-    letsGo: "Los geht's:",
-    goToProject: "Zu deinem Projekt wechseln",
-    initShiva: "SHIVA initialisieren",
-    startClaude: "Claude Code starten",
-    commands: "Befehle:",
-    laterLogin: "Spater anmelden: shiva login"
-  },
-  account: {
-    description: "Account verwalten",
-    deleteDesc: "Account und ALLE Daten unwiderruflich loschen (GDPR)",
-    infoDesc: "Account-Informationen anzeigen",
-    header: "SHIVA Account",
-    deleteWarning: "ACCOUNT LOSCHEN - UNWIDERRUFLICH",
-    deleteWarning1: "Du bist dabei, deinen SHIVA Account vollstandig zu loschen.",
-    willBeDeleted: "Folgende Daten werden UNWIDERRUFLICH geloscht:",
-    allProjects: "Alle Projekte",
-    allMemories: "Alle Memories",
-    allSecrets: "Alle Secrets (API Keys)",
-    allSessions: "Alle Session-Daten",
-    allSettings: "Alle Einstellungen",
-    accountData: "Account-Daten (Email, Profil)",
-    cannotBeUndone: "Diese Aktion kann NICHT ruckgangig gemacht werden!",
-    confirmDelete1: "Verstanden - ich mochte meinen Account loschen",
-    enterEmail: "Zur Bestatigung deine Email eingeben ({email}):",
-    emailMismatch: "Email stimmt nicht uberein",
-    typeDelete: "Tippe DELETE zum Bestatigen:",
-    deleting: "Losche Account...",
-    deleted: "Account geloscht",
-    deleteFailed: "Loschen fehlgeschlagen",
-    deletedInfo: "Alle deine Daten wurden aus unseren Systemen entfernt.",
-    goodbye: "Danke, dass du SHIVA genutzt hast. Auf Wiedersehen!",
-    memberSince: "Mitglied seit",
-    usage: "Nutzung:",
-    projects: "Projekte",
-    memories: "Memories",
-    secrets: "Secrets",
-    sessions: "Sessions"
-  },
-  uninstall: {
-    description: "SHIVA vollstandig deinstallieren",
-    header: "Deinstallation",
-    localOption: "Nur lokale Daten loschen",
-    fullOption: "Vollstandige Deinstallation",
-    keepAccountOption: "Account-Daten behalten",
-    willBeRemoved: "Folgendes wird entfernt:",
-    globalConfig: "Globale Konfiguration",
-    claudeHooks: "Claude Code Hooks",
-    projectShivaDir: "Projekt .shiva/ Verzeichnis",
-    accountData: "Account-Daten auf Server",
-    npmPackage: "NPM Package",
-    nothingToRemove: "Keine lokalen Daten gefunden.",
-    runNpmUninstall: "Fuhre diesen Befehl aus um SHIVA zu entfernen:",
-    confirmUninstall: "SHIVA wirklich deinstallieren?",
-    accountWarning: "Dein Account und alle Cloud-Daten werden geloscht!",
-    confirmAccountDelete: "Account-Daten auch loschen?",
-    accountKept: "Account-Daten werden behalten.",
-    removingHooks: "Entferne Claude Hooks...",
-    hooksRemoved: "Claude Hooks entfernt",
-    hooksFailed: "Hooks entfernen fehlgeschlagen",
-    removingConfig: "Entferne Konfiguration...",
-    configRemoved: "Konfiguration entfernt",
-    configFailed: "Konfiguration entfernen fehlgeschlagen",
-    removingProjectDir: "Entferne .shiva/ Verzeichnis...",
-    projectDirRemoved: ".shiva/ Verzeichnis entfernt",
-    projectDirFailed: ".shiva/ entfernen fehlgeschlagen",
-    deletingAccount: "Losche Account-Daten...",
-    accountDeleted: "Account-Daten geloscht",
-    accountFailed: "Account loschen fehlgeschlagen",
-    complete: "Deinstallation abgeschlossen!",
-    partialSuccess: "Einige Schritte sind fehlgeschlagen.",
-    finalStep: "Letzter Schritt - fuhre aus:",
-    accountStillExists: "Hinweis: Dein Account existiert noch auf dem Server.",
-    deleteAccountHint: "Zum Loschen: shiva account delete",
-    thanksForUsing: "Danke, dass du SHIVA genutzt hast!"
-  },
-  projectDelete: {
-    deleteDesc: "Projekt und alle Daten loschen",
-    deleteIdOption: "Projekt-ID zum Loschen",
-    deleteWarning: "WARNUNG: Projekt wird unwiderruflich geloscht!",
-    notConnected: "Aktuelles Verzeichnis ist nicht mit einem Projekt verbunden",
-    memoriesCount: "Memories",
-    sessionsCount: "Sessions",
-    confirmDelete: "Projekt wirklich loschen?",
-    enterNameToConfirm: 'Zur Bestatigung "{name}" eingeben:',
-    deleting: "Losche Projekt...",
-    deleted: "Projekt geloscht",
-    deleteFailed: "Loschen fehlgeschlagen",
-    deletedInfo: "Alle Projektdaten wurden aus der Cloud entfernt."
-  }
-};
-
-// src/i18n/locales/en.json
-var en_default = {
-  common: {
-    yes: "Yes",
-    no: "No",
-    cancel: "Cancel",
-    confirm: "Confirm",
-    success: "Success!",
-    failed: "Failed",
-    loading: "Loading...",
-    goodbye: "Goodbye!",
-    cancelled: "Cancelled.",
-    continue: "Continue",
-    back: "Back",
-    save: "Save",
-    delete: "Delete",
-    edit: "Edit",
-    create: "Create",
-    open: "Open",
-    close: "Close",
-    search: "Search",
-    filter: "Filter",
-    all: "All",
-    none: "None",
-    unknown: "Unknown",
-    enabled: "Enabled",
-    disabled: "Disabled",
-    total: "Total",
-    date: "Date",
-    time: "Time",
-    name: "Name",
-    value: "Value",
-    type: "Type",
-    status: "Status",
-    description: "Description",
-    actions: "Actions",
-    settings: "Settings",
-    help: "Help",
-    version: "Version",
-    forceOption: "Skip confirmations",
-    pressAnyKey: "Press any key to continue..."
-  },
-  auth: {
-    notLoggedIn: "Not logged in",
-    loginWith: "Login with: shiva login",
-    loginSuccess: "Successfully logged in!",
-    logoutSuccess: "Successfully logged out.",
-    alreadyLoggedIn: "Already logged in as {email}",
-    loginCancelled: "Login cancelled.",
-    otpSent: "Login code has been sent.",
-    otpInvalid: "Invalid code.",
-    enterEmail: "Email address:",
-    enterOtp: "Enter login code:",
-    reloginQuestion: "Do you want to log in again?",
-    invalidEmail: "Please enter a valid email address",
-    twoFactorEnabled: "2FA enabled.",
-    twoFactorDisabled: "2FA disabled.",
-    invalidToken: "Invalid token."
-  },
-  errors: {
-    unknown: "An unknown error occurred",
-    network: "Network error. Check your connection.",
-    notFound: "Not found: {item}",
-    permissionDenied: "Permission denied",
-    apiError: "API error",
-    fileNotFound: "File not found: {file}",
-    invalidFormat: "Invalid format",
-    alreadyExists: "Already exists: {item}",
-    notSupported: "Not supported",
-    timeout: "Timeout",
-    invalidInput: "Invalid input",
-    clipboardFailed: "Clipboard error"
-  },
-  commands: {
-    login: {
-      description: "Login to shiva.li",
-      emailOption: "Email address for OTP login",
-      otpOption: "Use OTP login instead of browser"
-    },
-    logout: {
-      description: "Logout from shiva.li"
-    },
-    secrets: {
-      description: "Manage API keys and secrets (Cloud Vault)",
-      vault: "SHIVA Secrets Vault",
-      global: "Global:",
-      projectSpecific: "Project-specific:",
-      noSecrets: "No secrets stored",
-      addHint: "Add secret: shiva secrets add <KEY> <VALUE>",
-      listDesc: "List all secrets",
-      addDesc: "Add a secret",
-      removeDesc: "Remove a secret",
-      getDesc: "Show secret value (masked)",
-      envDesc: "Output secrets in .env format",
-      importDesc: "Import .env file into vault",
-      exportDesc: "Export secrets",
-      saved: 'Secret "{key}" saved!',
-      deleted: 'Secret "{key}" deleted',
-      copied: 'Secret "{key}" copied to clipboard',
-      autoCleared: "Will be automatically cleared after 30 seconds...",
-      invalidName: "Invalid secret name",
-      nameFormat: "Format: UPPERCASE_WITH_UNDERSCORES",
-      valueRequired: "Value required",
-      confirmSave: "Save secret?",
-      confirmDelete: 'Really delete secret "{key}"?',
-      loadingSecrets: "Loading secrets...",
-      savingSecret: "Saving secret...",
-      deletingSecret: "Deleting secret...",
-      exportingSecrets: "Exporting secrets...",
-      importingSecrets: "Importing secrets...",
-      fileContainsSensitive: "This file contains sensitive data!",
-      addToGitignore: "Add to .gitignore!",
-      secretsImported: "{count} secret(s) successfully imported",
-      secretsFailed: "{count} secret(s) failed",
-      noValidSecrets: "No valid secrets found in file",
-      dryRunInfo: "Dry-run: No changes made",
-      showValue: "Show value?",
-      revealWarning: "Secret values will be displayed in terminal!",
-      revealHint: "Show full value with --reveal or -r",
-      secretsToImport: "Secrets to import"
-    },
-    remember: {
-      description: "Save memory to cloud",
-      saved: "Memory saved!",
-      category: "Category: {category}"
-    },
-    search: {
-      description: "Search in memories",
-      header: "SHIVA Code - Search",
-      noResults: "No results found",
-      enterQuery: "Enter search term:",
-      searching: "Searching...",
-      resultsFound: "{count} result(s) found"
-    },
-    forget: {
-      description: "Delete memories (GDPR)",
-      header: "SHIVA Code - Forget",
-      warning: "WARNING: Delete all memories",
-      confirmDelete: "Really delete memories?",
-      deleted: "Memories deleted",
-      selectMemories: "Select memories to delete:"
-    },
-    sessions: {
-      description: "List all Claude Code sessions",
-      header: "SHIVA Code - Sessions",
-      noSessions: "No sessions found.",
-      branch: "Branch",
-      messages: "Messages",
-      selectSession: "Select session:"
-    },
-    resume: {
-      description: "Resume session",
-      selectSession: "Select session to resume:",
-      starting: "Starting session..."
-    },
-    restore: {
-      description: "Restore crashed session",
-      selectSession: "Select session to restore:",
-      restored: "Session restored"
-    },
-    start: {
-      description: "Start multiple projects",
-      selectProjects: "Select projects to start:",
-      starting: "Starting {count} project(s)...",
-      dockerMode: "Docker mode",
-      sandboxMode: "Sandbox mode"
-    },
-    init: {
-      description: "Initialize project for SHIVA Code",
-      detected: "Detected",
-      initialized: "Project initialized!",
-      alreadyInitialized: "Project already initialized",
-      confirmInit: "Initialize project?",
-      creatingProject: "Creating project..."
-    },
-    sync: {
-      description: "Sync project with cloud",
-      synced: "Synced",
-      batchSync: "SHIVA Code - Batch Sync",
-      syncing: "Syncing...",
-      noChanges: "No changes"
-    },
-    status: {
-      description: "Show project status",
-      header: "SHIVA Code - Status",
-      notInitialized: "Project not initialized. Use: shiva init"
-    },
-    projects: {
-      description: "List all projects",
-      header: "SHIVA Code - Projects",
-      noProjects: "No projects found."
-    },
-    connect: {
-      description: "Connect project with cloud",
-      connected: "Project connected",
-      selectProject: "Select project:"
-    },
-    disconnect: {
-      description: "Disconnect project from cloud",
-      disconnected: "Project disconnected"
-    },
-    config: {
-      description: "Manage settings",
-      header: "SHIVA Configuration",
-      claudeHeader: "Claude Code Settings",
-      syncHeader: "Settings Sync Status",
-      featuresHeader: "Feature Flags",
-      getDesc: "Show setting",
-      setDesc: "Set setting",
-      listDesc: "Show all settings",
-      resetDesc: "Reset settings",
-      updated: "Setting updated",
-      currentValue: "Current value: {value}",
-      invalidKey: "Invalid setting: {key}",
-      invalidValue: "Invalid value: {value}",
-      languageSet: "Language set to {lang}",
-      invalidLanguage: "Invalid language. Available: {valid}"
-    },
-    issues: {
-      description: "Show GitHub issues",
-      header: "GitHub Issues",
-      noIssues: "No issues found",
-      selectIssue: "Select issue:",
-      creating: "Creating issue..."
-    },
-    prs: {
-      description: "Show pull requests",
-      header: "Pull Requests",
-      noPRs: "No pull requests found",
-      selectPR: "Select PR:"
-    },
-    github: {
-      description: "GitHub integration",
-      header: "GitHub",
-      notInstalled: "GitHub CLI (gh) not installed",
-      notAuthenticated: "GitHub CLI not authenticated",
-      notGitRepo: "Not a Git repository",
-      notGithubRepo: "Not a GitHub repository",
-      statusDesc: "Show GitHub status",
-      loginDesc: "Login to GitHub",
-      initDesc: "Initialize GitHub repository"
-    },
-    doctor: {
-      description: "System check",
-      header: "SHIVA Code - Doctor",
-      checking: "Checking system...",
-      allGood: "Everything is fine!",
-      issuesFound: "{count} issue(s) found"
-    },
-    stats: {
-      description: "Show analytics",
-      header: "SHIVA Code - Statistics",
-      loading: "Loading statistics..."
-    },
-    upgrade: {
-      description: "Update SHIVA",
-      checking: "Checking for updates...",
-      upToDate: "SHIVA is up to date (version {version})",
-      newVersion: "New version available: {version}",
-      upgrading: "Updating...",
-      upgraded: "SHIVA updated to version {version}"
-    },
-    telemetry: {
-      description: "Telemetry settings",
-      enabled: "Telemetry enabled",
-      disabled: "Telemetry disabled"
-    },
-    completions: {
-      description: "Install shell completions",
-      installed: "Completions installed for {shell}",
-      installHint: "Restart your shell for the changes"
-    },
-    docker: {
-      description: "Manage Docker mode",
-      header: "SHIVA Code - Docker",
-      notAvailable: "Docker is not available",
-      starting: "Starting Docker container...",
-      started: "Docker container started",
-      stopped: "Docker container stopped",
-      statusDesc: "Show Docker status",
-      startDesc: "Start Docker container",
-      stopDesc: "Stop Docker container",
-      logsDesc: "Show Docker logs"
-    },
-    sandbox: {
-      description: "Manage sandbox",
-      header: "SHIVA Code - Sandbox",
-      created: "Sandbox created",
-      applied: "Sandbox changes applied",
-      discarded: "Sandbox discarded",
-      listDesc: "List all sandboxes",
-      createDesc: "Create new sandbox",
-      applyDesc: "Apply sandbox changes",
-      discardDesc: "Discard sandbox"
-    },
-    workflow: {
-      description: "Manage workflows",
-      header: "SHIVA Code - Workflows"
-    },
-    hook: {
-      description: "Manage hooks",
-      header: "SHIVA Code - Hooks"
-    },
-    package: {
-      description: "Manage project groups",
-      header: "SHIVA Code - Packages",
-      noPackages: "No packages found",
-      createDesc: "Create new package",
-      listDesc: "List all packages",
-      addDesc: "Add project to package",
-      removeDesc: "Remove project from package",
-      deleteDesc: "Delete package",
-      created: 'Package "{name}" created',
-      deleted: 'Package "{name}" deleted',
-      projectAdded: "Project added to package",
-      projectRemoved: "Project removed from package"
-    },
-    context: {
-      description: "Show context",
-      header: "SHIVA Code - Context",
-      noContext: "No context found"
-    },
-    tags: {
-      description: "Manage session tags",
-      header: "SHIVA Code - Tags",
-      noTags: "No tags found"
-    },
-    export: {
-      description: "Export sessions",
-      header: "SHIVA Code - Export",
-      exported: "Exported to {file}",
-      selectFormat: "Select format:"
-    },
-    import: {
-      description: "Import sessions",
-      header: "SHIVA Code - Import",
-      imported: "{count} session(s) imported",
-      selectFile: "Select file:"
-    },
-    user: {
-      description: "User information",
-      header: "SHIVA Code - User"
-    },
-    welcome: {
-      description: "Show welcome message"
-    },
-    validate: {
-      description: "Validate project",
-      header: "SHIVA Code - Validation",
-      valid: "Project is valid",
-      invalid: "Project is invalid"
-    },
-    scan: {
-      description: "Check package for security issues",
-      header: "SHIVA Code - Security Scan",
-      scanning: "Scanning...",
-      noIssues: "No security issues found",
-      issuesFound: "{count} security issue(s) found"
-    },
-    security: {
-      description: "Security settings",
-      header: "SHIVA Code - Security"
-    },
-    secureToken: {
-      description: "Store token securely"
-    },
-    project: {
-      description: "Project information",
-      header: "SHIVA Code - Project"
-    },
-    repair: {
-      description: "Repair project",
-      header: "SHIVA Code - Repair",
-      repaired: "Project repaired"
-    },
-    help: {
-      description: "Help and documentation",
-      header: "SHIVA Code - Help",
-      topics: "Topics:",
-      quickstart: "Quick Start",
-      commands: "Commands Overview",
-      memory: "Memory System",
-      secrets: "Secrets Management",
-      troubleshooting: "Troubleshooting",
-      onlineHelp: "Open Online Help"
-    }
-  },
-  controlStation: {
-    title: "SHIVA Control Station",
-    selection: "Selection:",
-    navigate: "navigate",
-    sessions: "Sessions",
-    sessionsDesc: "Show all",
-    packages: "Packages",
-    packagesDesc: "Manage",
-    issues: "Issues",
-    issuesDesc: "GitHub Issues",
-    prs: "PRs",
-    prsDesc: "Pull Requests",
-    config: "Config",
-    configDesc: "Settings",
-    help: "Help",
-    helpDesc: "Documentation",
-    quit: "Quit",
-    noSessionsFound: "No sessions found.",
-    startClaudeHint: "Start Claude Code in a project",
-    orCreatePackage: 'Or: shiva package create "Name"',
-    startingSession: "Starting session in {project}...",
-    startingPackage: "Starting package {name}...",
-    unknownCommand: "Unknown command: {command}",
-    didYouMean: "Did you mean:",
-    projects: "Projects",
-    claudeNotInstalled: "Claude Code not installed",
-    claudeInstallHint: "curl -fsSL https://claude.ai/install.sh | bash"
-  },
-  help: {
-    quickstart: {
-      title: "Quick Start",
-      content: [
-        "1. shiva login     - Login",
-        "2. shiva init      - Initialize project",
-        "3. shiva           - Open Control Station",
-        "4. shiva remember  - Save memory",
-        "5. shiva secrets   - Manage secrets"
-      ]
-    },
-    commandsOverview: {
-      title: "Commands Overview",
-      sessionManagement: "Session Management",
-      githubIntegration: "GitHub Integration",
-      memoryContext: "Memory & Context",
-      dockerIntegration: "Docker Integration",
-      security: "Security",
-      projectManagement: "Project Management",
-      system: "System"
-    },
-    memorySystem: {
-      title: "Memory System",
-      description: "SHIVA stores information persistently in the cloud.",
-      categories: {
-        identity: "User identity (name, role)",
-        preference: "Preferences (code style)",
-        convention: "Project conventions",
-        solution: "Solved problems",
-        task: "Tasks",
-        context: "Project context"
-      }
-    },
-    secretsManagement: {
-      title: "Secrets Management",
-      description: "Secure storage of API keys and secrets in the cloud.",
-      features: [
-        "End-to-end encrypted",
-        "Automatic injection into sessions",
-        "Project-specific and global secrets",
-        "Import/export of .env files"
-      ]
-    },
-    troubleshooting: {
-      title: "Troubleshooting",
-      commonIssues: {
-        notLoggedIn: "Not logged in",
-        notLoggedInSolution: "Use 'shiva login' to login",
-        claudeNotFound: "Claude Code not found",
-        claudeNotFoundSolution: "Install Claude Code with the official installer",
-        networkError: "Network error",
-        networkErrorSolution: "Check your internet connection",
-        permissionDenied: "Permission denied",
-        permissionDeniedSolution: "Check file permissions or run with sudo"
-      }
-    }
-  },
-  time: {
-    justNow: "just now",
-    minutesAgo: "{count} minute(s) ago",
-    hoursAgo: "{count} hour(s) ago",
-    daysAgo: "{count} day(s) ago",
-    weeksAgo: "{count} week(s) ago",
-    monthsAgo: "{count} month(s) ago"
-  },
-  onboarding: {
-    welcome: "Welcome to SHIVA Code!",
-    subtitle: "Makes Claude Code persistent",
-    selectLanguage: "Select language:",
-    claudeCode: "Claude Code",
-    claudeNotFound: "Claude Code not found",
-    claudeNotFoundDesc: "SHIVA extends Claude Code with persistent storage. You need Claude Code to use SHIVA.",
-    installation: "Installation:",
-    moreInfo: "More info:",
-    continueAnyway: "Continue anyway?",
-    restartAfterInstall: "Restart after installation: shiva",
-    found: "Found",
-    display: "Display",
-    darkMode: "Dark Mode",
-    lightMode: "Light Mode",
-    recommended: "(recommended)",
-    themeSaved: "Theme saved",
-    account: "Account",
-    accountFeatures: "With an account you get:",
-    cloudSync: "Cloud sync for memories",
-    crossDeviceSessions: "Sessions across devices",
-    secretsVault: "Secrets Vault (encrypted)",
-    loginNow: "Login now?",
-    openBrowser: "Opening browser...",
-    loginLater: "Later: shiva login",
-    integration: "Integration",
-    autoIntegration: "SHIVA automatically integrates with Claude Code:",
-    loadMemoriesOnStart: "Load memories on start",
-    saveMemoriesOnExit: "Save memories on exit",
-    enableAutoIntegration: "Enable auto-integration?",
-    hooksInstalled: "Hooks installed",
-    hooksFailed: "Hook installation failed",
-    hooksLater: "Later: shiva hook install",
-    setupComplete: "Setup complete!",
-    nextSteps: "Next steps:",
-    letsGo: "Let's go:",
-    goToProject: "Go to your project",
-    initShiva: "Initialize SHIVA",
-    startClaude: "Start Claude Code",
-    commands: "Commands:",
-    laterLogin: "Login later: shiva login"
-  },
-  account: {
-    description: "Manage account",
-    deleteDesc: "Delete account and ALL data permanently (GDPR)",
-    infoDesc: "Show account information",
-    header: "SHIVA Account",
-    deleteWarning: "DELETE ACCOUNT - IRREVERSIBLE",
-    deleteWarning1: "You are about to permanently delete your SHIVA account.",
-    willBeDeleted: "The following data will be PERMANENTLY deleted:",
-    allProjects: "All projects",
-    allMemories: "All memories",
-    allSecrets: "All secrets (API keys)",
-    allSessions: "All session data",
-    allSettings: "All settings",
-    accountData: "Account data (email, profile)",
-    cannotBeUndone: "This action CANNOT be undone!",
-    confirmDelete1: "I understand - I want to delete my account",
-    enterEmail: "Enter your email to confirm ({email}):",
-    emailMismatch: "Email does not match",
-    typeDelete: "Type DELETE to confirm:",
-    deleting: "Deleting account...",
-    deleted: "Account deleted",
-    deleteFailed: "Deletion failed",
-    deletedInfo: "All your data has been removed from our systems.",
-    goodbye: "Thank you for using SHIVA. Goodbye!",
-    memberSince: "Member since",
-    usage: "Usage:",
-    projects: "Projects",
-    memories: "Memories",
-    secrets: "Secrets",
-    sessions: "Sessions"
-  },
-  uninstall: {
-    description: "Completely uninstall SHIVA",
-    header: "Uninstallation",
-    localOption: "Only remove local data",
-    fullOption: "Complete uninstallation",
-    keepAccountOption: "Keep account data",
-    willBeRemoved: "The following will be removed:",
-    globalConfig: "Global configuration",
-    claudeHooks: "Claude Code hooks",
-    projectShivaDir: "Project .shiva/ directory",
-    accountData: "Account data on server",
-    npmPackage: "NPM package",
-    nothingToRemove: "No local data found.",
-    runNpmUninstall: "Run this command to remove SHIVA:",
-    confirmUninstall: "Really uninstall SHIVA?",
-    accountWarning: "Your account and all cloud data will be deleted!",
-    confirmAccountDelete: "Also delete account data?",
-    accountKept: "Account data will be kept.",
-    removingHooks: "Removing Claude hooks...",
-    hooksRemoved: "Claude hooks removed",
-    hooksFailed: "Failed to remove hooks",
-    removingConfig: "Removing configuration...",
-    configRemoved: "Configuration removed",
-    configFailed: "Failed to remove configuration",
-    removingProjectDir: "Removing .shiva/ directory...",
-    projectDirRemoved: ".shiva/ directory removed",
-    projectDirFailed: "Failed to remove .shiva/",
-    deletingAccount: "Deleting account data...",
-    accountDeleted: "Account data deleted",
-    accountFailed: "Failed to delete account",
-    complete: "Uninstallation complete!",
-    partialSuccess: "Some steps failed.",
-    finalStep: "Final step - run:",
-    accountStillExists: "Note: Your account still exists on the server.",
-    deleteAccountHint: "To delete: shiva account delete",
-    thanksForUsing: "Thanks for using SHIVA!"
-  },
-  projectDelete: {
-    deleteDesc: "Delete project and all data",
-    deleteIdOption: "Project ID to delete",
-    deleteWarning: "WARNING: Project will be permanently deleted!",
-    notConnected: "Current directory is not connected to a project",
-    memoriesCount: "Memories",
-    sessionsCount: "Sessions",
-    confirmDelete: "Really delete project?",
-    enterNameToConfirm: 'Enter "{name}" to confirm:',
-    deleting: "Deleting project...",
-    deleted: "Project deleted",
-    deleteFailed: "Deletion failed",
-    deletedInfo: "All project data has been removed from the cloud."
-  }
-};
-
-// src/i18n/locales/fr.json
-var fr_default = {
-  common: {
-    yes: "Oui",
-    no: "Non",
-    cancel: "Annuler",
-    confirm: "Confirmer",
-    success: "Succes!",
-    failed: "Echec",
-    loading: "Chargement...",
-    goodbye: "Au revoir!",
-    cancelled: "Annule.",
-    continue: "Continuer",
-    back: "Retour",
-    save: "Enregistrer",
-    delete: "Supprimer",
-    edit: "Modifier",
-    create: "Creer",
-    open: "Ouvrir",
-    close: "Fermer",
-    search: "Rechercher",
-    filter: "Filtrer",
-    all: "Tous",
-    none: "Aucun",
-    unknown: "Inconnu",
-    enabled: "Active",
-    disabled: "Desactive",
-    total: "Total",
-    date: "Date",
-    time: "Heure",
-    name: "Nom",
-    value: "Valeur",
-    type: "Type",
-    status: "Statut",
-    description: "Description",
-    actions: "Actions",
-    settings: "Parametres",
-    help: "Aide",
-    version: "Version",
-    forceOption: "Sans confirmation",
-    pressAnyKey: "Appuyez sur une touche pour continuer..."
-  },
-  auth: {
-    notLoggedIn: "Non connecte",
-    loginWith: "Se connecter avec: shiva login",
-    loginSuccess: "Connexion reussie!",
-    logoutSuccess: "Deconnexion reussie.",
-    alreadyLoggedIn: "Deja connecte en tant que {email}",
-    loginCancelled: "Connexion annulee.",
-    otpSent: "Le code de connexion a ete envoye.",
-    otpInvalid: "Code invalide.",
-    enterEmail: "Adresse email:",
-    enterOtp: "Entrez le code de connexion:",
-    reloginQuestion: "Voulez-vous vous reconnecter?",
-    invalidEmail: "Veuillez entrer une adresse email valide",
-    twoFactorEnabled: "2FA active.",
-    twoFactorDisabled: "2FA desactive.",
-    invalidToken: "Token invalide."
-  },
-  errors: {
-    unknown: "Une erreur inconnue s'est produite",
-    network: "Erreur reseau. Verifiez votre connexion.",
-    notFound: "Non trouve: {item}",
-    permissionDenied: "Permission refusee",
-    apiError: "Erreur API",
-    fileNotFound: "Fichier non trouve: {file}",
-    invalidFormat: "Format invalide",
-    alreadyExists: "Existe deja: {item}",
-    notSupported: "Non supporte",
-    timeout: "Delai depasse",
-    invalidInput: "Entree invalide",
-    clipboardFailed: "Erreur de presse-papiers"
-  },
-  commands: {
-    login: {
-      description: "Se connecter a shiva.li",
-      emailOption: "Adresse email pour connexion OTP",
-      otpOption: "Utiliser la connexion OTP au lieu du navigateur"
-    },
-    logout: {
-      description: "Se deconnecter de shiva.li"
-    },
-    secrets: {
-      description: "Gerer les cles API et secrets (Cloud Vault)",
-      vault: "SHIVA Secrets Vault",
-      global: "Global:",
-      projectSpecific: "Specifique au projet:",
-      noSecrets: "Aucun secret stocke",
-      addHint: "Ajouter un secret: shiva secrets add <KEY> <VALUE>",
-      listDesc: "Lister tous les secrets",
-      addDesc: "Ajouter un secret",
-      removeDesc: "Supprimer un secret",
-      getDesc: "Afficher la valeur du secret (masquee)",
-      envDesc: "Exporter les secrets au format .env",
-      importDesc: "Importer un fichier .env dans le vault",
-      exportDesc: "Exporter les secrets",
-      saved: 'Secret "{key}" enregistre!',
-      deleted: 'Secret "{key}" supprime',
-      copied: 'Secret "{key}" copie dans le presse-papiers',
-      autoCleared: "Sera automatiquement efface apres 30 secondes...",
-      invalidName: "Nom de secret invalide",
-      nameFormat: "Format: MAJUSCULES_AVEC_UNDERSCORES",
-      valueRequired: "Valeur requise",
-      confirmSave: "Enregistrer le secret?",
-      confirmDelete: 'Vraiment supprimer le secret "{key}"?',
-      loadingSecrets: "Chargement des secrets...",
-      savingSecret: "Enregistrement du secret...",
-      deletingSecret: "Suppression du secret...",
-      exportingSecrets: "Exportation des secrets...",
-      importingSecrets: "Importation des secrets...",
-      fileContainsSensitive: "Ce fichier contient des donnees sensibles!",
-      addToGitignore: "Ajouter a .gitignore!",
-      secretsImported: "{count} secret(s) importe(s) avec succes",
-      secretsFailed: "{count} secret(s) echoue(s)",
-      noValidSecrets: "Aucun secret valide trouve dans le fichier",
-      dryRunInfo: "Dry-run: Aucun changement effectue",
-      showValue: "Afficher la valeur?",
-      revealWarning: "Les valeurs des secrets seront affichees dans le terminal!",
-      revealHint: "Afficher la valeur complete avec --reveal ou -r",
-      secretsToImport: "Secrets a importer"
-    },
-    remember: {
-      description: "Enregistrer une memoire dans le cloud",
-      saved: "Memoire enregistree!",
-      category: "Categorie: {category}"
-    },
-    search: {
-      description: "Rechercher dans les memoires",
-      header: "SHIVA Code - Recherche",
-      noResults: "Aucun resultat trouve",
-      enterQuery: "Entrez le terme de recherche:",
-      searching: "Recherche...",
-      resultsFound: "{count} resultat(s) trouve(s)"
-    },
-    forget: {
-      description: "Supprimer les memoires (RGPD)",
-      header: "SHIVA Code - Oublier",
-      warning: "ATTENTION: Supprimer toutes les memoires",
-      confirmDelete: "Vraiment supprimer les memoires?",
-      deleted: "Memoires supprimees",
-      selectMemories: "Selectionnez les memoires a supprimer:"
-    },
-    sessions: {
-      description: "Lister toutes les sessions Claude Code",
-      header: "SHIVA Code - Sessions",
-      noSessions: "Aucune session trouvee.",
-      branch: "Branche",
-      messages: "Messages",
-      selectSession: "Selectionnez une session:"
-    },
-    resume: {
-      description: "Reprendre une session",
-      selectSession: "Selectionnez une session a reprendre:",
-      starting: "Demarrage de la session..."
-    },
-    restore: {
-      description: "Restaurer une session plantee",
-      selectSession: "Selectionnez une session a restaurer:",
-      restored: "Session restauree"
-    },
-    start: {
-      description: "Demarrer plusieurs projets",
-      selectProjects: "Selectionnez les projets a demarrer:",
-      starting: "Demarrage de {count} projet(s)...",
-      dockerMode: "Mode Docker",
-      sandboxMode: "Mode Sandbox"
-    },
-    init: {
-      description: "Initialiser le projet pour SHIVA Code",
-      detected: "Detecte",
-      initialized: "Projet initialise!",
-      alreadyInitialized: "Projet deja initialise",
-      confirmInit: "Initialiser le projet?",
-      creatingProject: "Creation du projet..."
-    },
-    sync: {
-      description: "Synchroniser le projet avec le cloud",
-      synced: "Synchronise",
-      batchSync: "SHIVA Code - Sync par lots",
-      syncing: "Synchronisation...",
-      noChanges: "Aucun changement"
-    },
-    status: {
-      description: "Afficher le statut du projet",
-      header: "SHIVA Code - Statut",
-      notInitialized: "Projet non initialise. Utilisez: shiva init"
-    },
-    projects: {
-      description: "Lister tous les projets",
-      header: "SHIVA Code - Projets",
-      noProjects: "Aucun projet trouve."
-    },
-    connect: {
-      description: "Connecter le projet au cloud",
-      connected: "Projet connecte",
-      selectProject: "Selectionnez un projet:"
-    },
-    disconnect: {
-      description: "Deconnecter le projet du cloud",
-      disconnected: "Projet deconnecte"
-    },
-    config: {
-      description: "Gerer les parametres",
-      header: "Configuration SHIVA",
-      claudeHeader: "Parametres Claude Code",
-      syncHeader: "Statut de synchronisation",
-      featuresHeader: "Options de fonctionnalites",
-      getDesc: "Afficher un parametre",
-      setDesc: "Definir un parametre",
-      listDesc: "Afficher tous les parametres",
-      resetDesc: "Reinitialiser les parametres",
-      updated: "Parametre mis a jour",
-      currentValue: "Valeur actuelle: {value}",
-      invalidKey: "Parametre invalide: {key}",
-      invalidValue: "Valeur invalide: {value}",
-      languageSet: "Langue definie sur {lang}",
-      invalidLanguage: "Langue invalide. Disponibles: {valid}"
-    },
-    issues: {
-      description: "Afficher les issues GitHub",
-      header: "GitHub Issues",
-      noIssues: "Aucune issue trouvee",
-      selectIssue: "Selectionnez une issue:",
-      creating: "Creation de l'issue..."
-    },
-    prs: {
-      description: "Afficher les pull requests",
-      header: "Pull Requests",
-      noPRs: "Aucune pull request trouvee",
-      selectPR: "Selectionnez une PR:"
-    },
-    github: {
-      description: "Integration GitHub",
-      header: "GitHub",
-      notInstalled: "GitHub CLI (gh) non installe",
-      notAuthenticated: "GitHub CLI non authentifie",
-      notGitRepo: "Pas un depot Git",
-      notGithubRepo: "Pas un depot GitHub",
-      statusDesc: "Afficher le statut GitHub",
-      loginDesc: "Se connecter a GitHub",
-      initDesc: "Initialiser le depot GitHub"
-    },
-    doctor: {
-      description: "Verification du systeme",
-      header: "SHIVA Code - Doctor",
-      checking: "Verification du systeme...",
-      allGood: "Tout va bien!",
-      issuesFound: "{count} probleme(s) trouve(s)"
-    },
-    stats: {
-      description: "Afficher les analytics",
-      header: "SHIVA Code - Statistiques",
-      loading: "Chargement des statistiques..."
-    },
-    upgrade: {
-      description: "Mettre a jour SHIVA",
-      checking: "Verification des mises a jour...",
-      upToDate: "SHIVA est a jour (version {version})",
-      newVersion: "Nouvelle version disponible: {version}",
-      upgrading: "Mise a jour...",
-      upgraded: "SHIVA mis a jour vers la version {version}"
-    },
-    telemetry: {
-      description: "Parametres de telemetrie",
-      enabled: "Telemetrie activee",
-      disabled: "Telemetrie desactivee"
-    },
-    completions: {
-      description: "Installer les completions shell",
-      installed: "Completions installees pour {shell}",
-      installHint: "Redemarrez votre shell pour les changements"
-    },
-    docker: {
-      description: "Gerer le mode Docker",
-      header: "SHIVA Code - Docker",
-      notAvailable: "Docker n'est pas disponible",
-      starting: "Demarrage du conteneur Docker...",
-      started: "Conteneur Docker demarre",
-      stopped: "Conteneur Docker arrete",
-      statusDesc: "Afficher le statut Docker",
-      startDesc: "Demarrer le conteneur Docker",
-      stopDesc: "Arreter le conteneur Docker",
-      logsDesc: "Afficher les logs Docker"
-    },
-    sandbox: {
-      description: "Gerer le sandbox",
-      header: "SHIVA Code - Sandbox",
-      created: "Sandbox cree",
-      applied: "Changements du sandbox appliques",
-      discarded: "Sandbox rejete",
-      listDesc: "Lister tous les sandboxes",
-      createDesc: "Creer un nouveau sandbox",
-      applyDesc: "Appliquer les changements du sandbox",
-      discardDesc: "Rejeter le sandbox"
-    },
-    workflow: {
-      description: "Gerer les workflows",
-      header: "SHIVA Code - Workflows"
-    },
-    hook: {
-      description: "Gerer les hooks",
-      header: "SHIVA Code - Hooks"
-    },
-    package: {
-      description: "Gerer les groupes de projets",
-      header: "SHIVA Code - Packages",
-      noPackages: "Aucun package trouve",
-      createDesc: "Creer un nouveau package",
-      listDesc: "Lister tous les packages",
-      addDesc: "Ajouter un projet au package",
-      removeDesc: "Supprimer un projet du package",
-      deleteDesc: "Supprimer le package",
-      created: 'Package "{name}" cree',
-      deleted: 'Package "{name}" supprime',
-      projectAdded: "Projet ajoute au package",
-      projectRemoved: "Projet supprime du package"
-    },
-    context: {
-      description: "Afficher le contexte",
-      header: "SHIVA Code - Contexte",
-      noContext: "Aucun contexte trouve"
-    },
-    tags: {
-      description: "Gerer les tags de session",
-      header: "SHIVA Code - Tags",
-      noTags: "Aucun tag trouve"
-    },
-    export: {
-      description: "Exporter les sessions",
-      header: "SHIVA Code - Export",
-      exported: "Exporte vers {file}",
-      selectFormat: "Selectionnez le format:"
-    },
-    import: {
-      description: "Importer des sessions",
-      header: "SHIVA Code - Import",
-      imported: "{count} session(s) importee(s)",
-      selectFile: "Selectionnez un fichier:"
-    },
-    user: {
-      description: "Informations utilisateur",
-      header: "SHIVA Code - Utilisateur"
-    },
-    welcome: {
-      description: "Afficher le message de bienvenue"
-    },
-    validate: {
-      description: "Valider le projet",
-      header: "SHIVA Code - Validation",
-      valid: "Le projet est valide",
-      invalid: "Le projet est invalide"
-    },
-    scan: {
-      description: "Verifier la securite du package",
-      header: "SHIVA Code - Scan de securite",
-      scanning: "Scan...",
-      noIssues: "Aucun probleme de securite trouve",
-      issuesFound: "{count} probleme(s) de securite trouve(s)"
-    },
-    security: {
-      description: "Parametres de securite",
-      header: "SHIVA Code - Securite"
-    },
-    secureToken: {
-      description: "Stocker le token de maniere securisee"
-    },
-    project: {
-      description: "Informations sur le projet",
-      header: "SHIVA Code - Projet"
-    },
-    repair: {
-      description: "Reparer le projet",
-      header: "SHIVA Code - Reparation",
-      repaired: "Projet repare"
-    },
-    help: {
-      description: "Aide et documentation",
-      header: "SHIVA Code - Aide",
-      topics: "Sujets:",
-      quickstart: "Demarrage rapide",
-      commands: "Apercu des commandes",
-      memory: "Systeme de memoire",
-      secrets: "Gestion des secrets",
-      troubleshooting: "Depannage",
-      onlineHelp: "Ouvrir l'aide en ligne"
-    }
-  },
-  controlStation: {
-    title: "SHIVA Control Station",
-    selection: "Selection:",
-    navigate: "naviguer",
-    sessions: "Sessions",
-    sessionsDesc: "Tout afficher",
-    packages: "Packages",
-    packagesDesc: "Gerer",
-    issues: "Issues",
-    issuesDesc: "GitHub Issues",
-    prs: "PRs",
-    prsDesc: "Pull Requests",
-    config: "Config",
-    configDesc: "Parametres",
-    help: "Aide",
-    helpDesc: "Documentation",
-    quit: "Quitter",
-    noSessionsFound: "Aucune session trouvee.",
-    startClaudeHint: "Demarrez Claude Code dans un projet",
-    orCreatePackage: 'Ou: shiva package create "Nom"',
-    startingSession: "Demarrage de la session dans {project}...",
-    startingPackage: "Demarrage du package {name}...",
-    unknownCommand: "Commande inconnue: {command}",
-    didYouMean: "Vouliez-vous dire:",
-    projects: "Projets",
-    claudeNotInstalled: "Claude Code non installe",
-    claudeInstallHint: "curl -fsSL https://claude.ai/install.sh | bash"
-  },
-  help: {
-    quickstart: {
-      title: "Demarrage rapide",
-      content: [
-        "1. shiva login     - Se connecter",
-        "2. shiva init      - Initialiser le projet",
-        "3. shiva           - Ouvrir Control Station",
-        "4. shiva remember  - Enregistrer une memoire",
-        "5. shiva secrets   - Gerer les secrets"
-      ]
-    },
-    commandsOverview: {
-      title: "Apercu des commandes",
-      sessionManagement: "Gestion des sessions",
-      githubIntegration: "Integration GitHub",
-      memoryContext: "Memoire & Contexte",
-      dockerIntegration: "Integration Docker",
-      security: "Securite",
-      projectManagement: "Gestion de projet",
-      system: "Systeme"
-    },
-    memorySystem: {
-      title: "Systeme de memoire",
-      description: "SHIVA stocke les informations de maniere persistante dans le cloud.",
-      categories: {
-        identity: "Identite utilisateur (nom, role)",
-        preference: "Preferences (style de code)",
-        convention: "Conventions de projet",
-        solution: "Problemes resolus",
-        task: "Taches",
-        context: "Contexte du projet"
-      }
-    },
-    secretsManagement: {
-      title: "Gestion des secrets",
-      description: "Stockage securise des cles API et secrets dans le cloud.",
-      features: [
-        "Chiffrement de bout en bout",
-        "Injection automatique dans les sessions",
-        "Secrets specifiques au projet et globaux",
-        "Import/export de fichiers .env"
-      ]
-    },
-    troubleshooting: {
-      title: "Depannage",
-      commonIssues: {
-        notLoggedIn: "Non connecte",
-        notLoggedInSolution: "Utilisez 'shiva login' pour vous connecter",
-        claudeNotFound: "Claude Code non trouve",
-        claudeNotFoundSolution: "Installez Claude Code avec l'installateur officiel",
-        networkError: "Erreur reseau",
-        networkErrorSolution: "Verifiez votre connexion internet",
-        permissionDenied: "Permission refusee",
-        permissionDeniedSolution: "Verifiez les permissions de fichiers ou executez avec sudo"
-      }
-    }
-  },
-  time: {
-    justNow: "a l'instant",
-    minutesAgo: "il y a {count} minute(s)",
-    hoursAgo: "il y a {count} heure(s)",
-    daysAgo: "il y a {count} jour(s)",
-    weeksAgo: "il y a {count} semaine(s)",
-    monthsAgo: "il y a {count} mois"
-  },
-  onboarding: {
-    welcome: "Bienvenue sur SHIVA Code!",
-    subtitle: "Rend Claude Code persistent",
-    selectLanguage: "Choisir la langue:",
-    claudeCode: "Claude Code",
-    claudeNotFound: "Claude Code non trouve",
-    claudeNotFoundDesc: "SHIVA etend Claude Code avec un stockage persistant. Vous avez besoin de Claude Code pour utiliser SHIVA.",
-    installation: "Installation:",
-    moreInfo: "Plus d'infos:",
-    continueAnyway: "Continuer quand meme?",
-    restartAfterInstall: "Redemarrer apres installation: shiva",
-    found: "Trouve",
-    display: "Affichage",
-    darkMode: "Mode sombre",
-    lightMode: "Mode clair",
-    recommended: "(recommande)",
-    themeSaved: "Theme sauvegarde",
-    account: "Compte",
-    accountFeatures: "Avec un compte vous obtenez:",
-    cloudSync: "Synchronisation cloud pour les memories",
-    crossDeviceSessions: "Sessions entre appareils",
-    secretsVault: "Coffre-fort secrets (crypte)",
-    loginNow: "Se connecter maintenant?",
-    openBrowser: "Ouverture du navigateur...",
-    loginLater: "Plus tard: shiva login",
-    integration: "Integration",
-    autoIntegration: "SHIVA s'integre automatiquement avec Claude Code:",
-    loadMemoriesOnStart: "Charger les memories au demarrage",
-    saveMemoriesOnExit: "Sauvegarder les memories a la fermeture",
-    enableAutoIntegration: "Activer l'integration automatique?",
-    hooksInstalled: "Hooks installes",
-    hooksFailed: "Installation des hooks echouee",
-    hooksLater: "Plus tard: shiva hook install",
-    setupComplete: "Configuration terminee!",
-    nextSteps: "Prochaines etapes:",
-    letsGo: "C'est parti:",
-    goToProject: "Aller a votre projet",
-    initShiva: "Initialiser SHIVA",
-    startClaude: "Demarrer Claude Code",
-    commands: "Commandes:",
-    laterLogin: "Se connecter plus tard: shiva login"
-  },
-  account: {
-    description: "Gerer le compte",
-    deleteDesc: "Supprimer le compte et TOUTES les donnees definitivement (RGPD)",
-    infoDesc: "Afficher les informations du compte",
-    header: "Compte SHIVA",
-    deleteWarning: "SUPPRIMER LE COMPTE - IRREVERSIBLE",
-    deleteWarning1: "Vous etes sur le point de supprimer definitivement votre compte SHIVA.",
-    willBeDeleted: "Les donnees suivantes seront DEFINITIVEMENT supprimees:",
-    allProjects: "Tous les projets",
-    allMemories: "Toutes les memories",
-    allSecrets: "Tous les secrets (cles API)",
-    allSessions: "Toutes les donnees de session",
-    allSettings: "Tous les parametres",
-    accountData: "Donnees du compte (email, profil)",
-    cannotBeUndone: "Cette action ne peut PAS etre annulee!",
-    confirmDelete1: "Je comprends - je veux supprimer mon compte",
-    enterEmail: "Entrez votre email pour confirmer ({email}):",
-    emailMismatch: "L'email ne correspond pas",
-    typeDelete: "Tapez DELETE pour confirmer:",
-    deleting: "Suppression du compte...",
-    deleted: "Compte supprime",
-    deleteFailed: "Suppression echouee",
-    deletedInfo: "Toutes vos donnees ont ete supprimees de nos systemes.",
-    goodbye: "Merci d'avoir utilise SHIVA. Au revoir!",
-    memberSince: "Membre depuis",
-    usage: "Utilisation:",
-    projects: "Projets",
-    memories: "Memories",
-    secrets: "Secrets",
-    sessions: "Sessions"
-  },
-  uninstall: {
-    description: "Desinstaller completement SHIVA",
-    header: "Desinstallation",
-    localOption: "Supprimer uniquement les donnees locales",
-    fullOption: "Desinstallation complete",
-    keepAccountOption: "Conserver les donnees du compte",
-    willBeRemoved: "Les elements suivants seront supprimes:",
-    globalConfig: "Configuration globale",
-    claudeHooks: "Hooks Claude Code",
-    projectShivaDir: "Repertoire .shiva/ du projet",
-    accountData: "Donnees du compte sur le serveur",
-    npmPackage: "Package NPM",
-    nothingToRemove: "Aucune donnee locale trouvee.",
-    runNpmUninstall: "Executez cette commande pour supprimer SHIVA:",
-    confirmUninstall: "Vraiment desinstaller SHIVA?",
-    accountWarning: "Votre compte et toutes les donnees cloud seront supprimes!",
-    confirmAccountDelete: "Supprimer aussi les donnees du compte?",
-    accountKept: "Les donnees du compte seront conservees.",
-    removingHooks: "Suppression des hooks Claude...",
-    hooksRemoved: "Hooks Claude supprimes",
-    hooksFailed: "Echec de la suppression des hooks",
-    removingConfig: "Suppression de la configuration...",
-    configRemoved: "Configuration supprimee",
-    configFailed: "Echec de la suppression de la configuration",
-    removingProjectDir: "Suppression du repertoire .shiva/...",
-    projectDirRemoved: "Repertoire .shiva/ supprime",
-    projectDirFailed: "Echec de la suppression de .shiva/",
-    deletingAccount: "Suppression des donnees du compte...",
-    accountDeleted: "Donnees du compte supprimees",
-    accountFailed: "Echec de la suppression du compte",
-    complete: "Desinstallation terminee!",
-    partialSuccess: "Certaines etapes ont echoue.",
-    finalStep: "Derniere etape - executez:",
-    accountStillExists: "Note: Votre compte existe toujours sur le serveur.",
-    deleteAccountHint: "Pour supprimer: shiva account delete",
-    thanksForUsing: "Merci d'avoir utilise SHIVA!"
-  },
-  projectDelete: {
-    deleteDesc: "Supprimer le projet et toutes les donnees",
-    deleteIdOption: "ID du projet a supprimer",
-    deleteWarning: "ATTENTION: Le projet sera definitivement supprime!",
-    notConnected: "Le repertoire actuel n'est pas connecte a un projet",
-    memoriesCount: "Memories",
-    sessionsCount: "Sessions",
-    confirmDelete: "Vraiment supprimer le projet?",
-    enterNameToConfirm: 'Entrez "{name}" pour confirmer:',
-    deleting: "Suppression du projet...",
-    deleted: "Projet supprime",
-    deleteFailed: "Suppression echouee",
-    deletedInfo: "Toutes les donnees du projet ont ete supprimees du cloud."
-  }
-};
-
-// src/i18n/locales/es.json
-var es_default = {
-  common: {
-    yes: "Si",
-    no: "No",
-    cancel: "Cancelar",
-    confirm: "Confirmar",
-    success: "Exito!",
-    failed: "Fallido",
-    loading: "Cargando...",
-    goodbye: "Adios!",
-    cancelled: "Cancelado.",
-    continue: "Continuar",
-    back: "Volver",
-    save: "Guardar",
-    delete: "Eliminar",
-    edit: "Editar",
-    create: "Crear",
-    open: "Abrir",
-    close: "Cerrar",
-    search: "Buscar",
-    filter: "Filtrar",
-    all: "Todos",
-    none: "Ninguno",
-    unknown: "Desconocido",
-    enabled: "Habilitado",
-    disabled: "Deshabilitado",
-    total: "Total",
-    date: "Fecha",
-    time: "Hora",
-    name: "Nombre",
-    value: "Valor",
-    type: "Tipo",
-    status: "Estado",
-    description: "Descripcion",
-    actions: "Acciones",
-    settings: "Configuracion",
-    help: "Ayuda",
-    version: "Version",
-    forceOption: "Sin confirmacion",
-    pressAnyKey: "Presiona cualquier tecla para continuar..."
-  },
-  auth: {
-    notLoggedIn: "No conectado",
-    loginWith: "Iniciar sesion con: shiva login",
-    loginSuccess: "Sesion iniciada con exito!",
-    logoutSuccess: "Sesion cerrada con exito.",
-    alreadyLoggedIn: "Ya conectado como {email}",
-    loginCancelled: "Inicio de sesion cancelado.",
-    otpSent: "El codigo de inicio de sesion ha sido enviado.",
-    otpInvalid: "Codigo invalido.",
-    enterEmail: "Direccion de email:",
-    enterOtp: "Introduce el codigo de inicio de sesion:",
-    reloginQuestion: "Deseas volver a iniciar sesion?",
-    invalidEmail: "Por favor introduce una direccion de email valida",
-    twoFactorEnabled: "2FA habilitado.",
-    twoFactorDisabled: "2FA deshabilitado.",
-    invalidToken: "Token invalido."
-  },
-  errors: {
-    unknown: "Ha ocurrido un error desconocido",
-    network: "Error de red. Comprueba tu conexion.",
-    notFound: "No encontrado: {item}",
-    permissionDenied: "Permiso denegado",
-    apiError: "Error de API",
-    fileNotFound: "Archivo no encontrado: {file}",
-    invalidFormat: "Formato invalido",
-    alreadyExists: "Ya existe: {item}",
-    notSupported: "No soportado",
-    timeout: "Tiempo de espera agotado",
-    invalidInput: "Entrada invalida",
-    clipboardFailed: "Error del portapapeles"
-  },
-  commands: {
-    login: {
-      description: "Iniciar sesion en shiva.li",
-      emailOption: "Direccion de email para inicio de sesion OTP",
-      otpOption: "Usar inicio de sesion OTP en lugar de navegador"
-    },
-    logout: {
-      description: "Cerrar sesion en shiva.li"
-    },
-    secrets: {
-      description: "Gestionar claves API y secretos (Cloud Vault)",
-      vault: "SHIVA Secrets Vault",
-      global: "Global:",
-      projectSpecific: "Especifico del proyecto:",
-      noSecrets: "No hay secretos almacenados",
-      addHint: "Agregar secreto: shiva secrets add <KEY> <VALUE>",
-      listDesc: "Listar todos los secretos",
-      addDesc: "Agregar un secreto",
-      removeDesc: "Eliminar un secreto",
-      getDesc: "Mostrar valor del secreto (enmascarado)",
-      envDesc: "Exportar secretos en formato .env",
-      importDesc: "Importar archivo .env al vault",
-      exportDesc: "Exportar secretos",
-      saved: 'Secreto "{key}" guardado!',
-      deleted: 'Secreto "{key}" eliminado',
-      copied: 'Secreto "{key}" copiado al portapapeles',
-      autoCleared: "Se borrara automaticamente despues de 30 segundos...",
-      invalidName: "Nombre de secreto invalido",
-      nameFormat: "Formato: MAYUSCULAS_CON_GUIONES_BAJOS",
-      valueRequired: "Valor requerido",
-      confirmSave: "Guardar secreto?",
-      confirmDelete: 'Realmente eliminar el secreto "{key}"?',
-      loadingSecrets: "Cargando secretos...",
-      savingSecret: "Guardando secreto...",
-      deletingSecret: "Eliminando secreto...",
-      exportingSecrets: "Exportando secretos...",
-      importingSecrets: "Importando secretos...",
-      fileContainsSensitive: "Este archivo contiene datos sensibles!",
-      addToGitignore: "Agregar a .gitignore!",
-      secretsImported: "{count} secreto(s) importado(s) con exito",
-      secretsFailed: "{count} secreto(s) fallido(s)",
-      noValidSecrets: "No se encontraron secretos validos en el archivo",
-      dryRunInfo: "Dry-run: No se realizaron cambios",
-      showValue: "Mostrar valor?",
-      revealWarning: "Los valores de los secretos se mostraran en la terminal!",
-      revealHint: "Mostrar valor completo con --reveal o -r",
-      secretsToImport: "Secretos a importar"
-    },
-    remember: {
-      description: "Guardar memoria en la nube",
-      saved: "Memoria guardada!",
-      category: "Categoria: {category}"
-    },
-    search: {
-      description: "Buscar en memorias",
-      header: "SHIVA Code - Busqueda",
-      noResults: "No se encontraron resultados",
-      enterQuery: "Introduce el termino de busqueda:",
-      searching: "Buscando...",
-      resultsFound: "{count} resultado(s) encontrado(s)"
-    },
-    forget: {
-      description: "Eliminar memorias (RGPD)",
-      header: "SHIVA Code - Olvidar",
-      warning: "ADVERTENCIA: Eliminar todas las memorias",
-      confirmDelete: "Realmente eliminar las memorias?",
-      deleted: "Memorias eliminadas",
-      selectMemories: "Selecciona las memorias a eliminar:"
-    },
-    sessions: {
-      description: "Listar todas las sesiones de Claude Code",
-      header: "SHIVA Code - Sesiones",
-      noSessions: "No se encontraron sesiones.",
-      branch: "Rama",
-      messages: "Mensajes",
-      selectSession: "Selecciona una sesion:"
-    },
-    resume: {
-      description: "Continuar sesion",
-      selectSession: "Selecciona una sesion para continuar:",
-      starting: "Iniciando sesion..."
-    },
-    restore: {
-      description: "Restaurar sesion fallida",
-      selectSession: "Selecciona una sesion para restaurar:",
-      restored: "Sesion restaurada"
-    },
-    start: {
-      description: "Iniciar multiples proyectos",
-      selectProjects: "Selecciona proyectos para iniciar:",
-      starting: "Iniciando {count} proyecto(s)...",
-      dockerMode: "Modo Docker",
-      sandboxMode: "Modo Sandbox"
-    },
-    init: {
-      description: "Inicializar proyecto para SHIVA Code",
-      detected: "Detectado",
-      initialized: "Proyecto inicializado!",
-      alreadyInitialized: "Proyecto ya inicializado",
-      confirmInit: "Inicializar proyecto?",
-      creatingProject: "Creando proyecto..."
-    },
-    sync: {
-      description: "Sincronizar proyecto con la nube",
-      synced: "Sincronizado",
-      batchSync: "SHIVA Code - Sync por lotes",
-      syncing: "Sincronizando...",
-      noChanges: "Sin cambios"
-    },
-    status: {
-      description: "Mostrar estado del proyecto",
-      header: "SHIVA Code - Estado",
-      notInitialized: "Proyecto no inicializado. Usa: shiva init"
-    },
-    projects: {
-      description: "Listar todos los proyectos",
-      header: "SHIVA Code - Proyectos",
-      noProjects: "No se encontraron proyectos."
-    },
-    connect: {
-      description: "Conectar proyecto con la nube",
-      connected: "Proyecto conectado",
-      selectProject: "Selecciona un proyecto:"
-    },
-    disconnect: {
-      description: "Desconectar proyecto de la nube",
-      disconnected: "Proyecto desconectado"
-    },
-    config: {
-      description: "Gestionar configuracion",
-      header: "Configuracion SHIVA",
-      claudeHeader: "Configuracion Claude Code",
-      syncHeader: "Estado de sincronizacion",
-      featuresHeader: "Opciones de funciones",
-      getDesc: "Mostrar configuracion",
-      setDesc: "Establecer configuracion",
-      listDesc: "Mostrar toda la configuracion",
-      resetDesc: "Restablecer configuracion",
-      updated: "Configuracion actualizada",
-      currentValue: "Valor actual: {value}",
-      invalidKey: "Configuracion invalida: {key}",
-      invalidValue: "Valor invalido: {value}",
-      languageSet: "Idioma establecido a {lang}",
-      invalidLanguage: "Idioma invalido. Disponibles: {valid}"
-    },
-    issues: {
-      description: "Mostrar issues de GitHub",
-      header: "GitHub Issues",
-      noIssues: "No se encontraron issues",
-      selectIssue: "Selecciona un issue:",
-      creating: "Creando issue..."
-    },
-    prs: {
-      description: "Mostrar pull requests",
-      header: "Pull Requests",
-      noPRs: "No se encontraron pull requests",
-      selectPR: "Selecciona un PR:"
-    },
-    github: {
-      description: "Integracion con GitHub",
-      header: "GitHub",
-      notInstalled: "GitHub CLI (gh) no instalado",
-      notAuthenticated: "GitHub CLI no autenticado",
-      notGitRepo: "No es un repositorio Git",
-      notGithubRepo: "No es un repositorio de GitHub",
-      statusDesc: "Mostrar estado de GitHub",
-      loginDesc: "Iniciar sesion en GitHub",
-      initDesc: "Inicializar repositorio de GitHub"
-    },
-    doctor: {
-      description: "Verificacion del sistema",
-      header: "SHIVA Code - Doctor",
-      checking: "Verificando sistema...",
-      allGood: "Todo esta bien!",
-      issuesFound: "{count} problema(s) encontrado(s)"
-    },
-    stats: {
-      description: "Mostrar analiticas",
-      header: "SHIVA Code - Estadisticas",
-      loading: "Cargando estadisticas..."
-    },
-    upgrade: {
-      description: "Actualizar SHIVA",
-      checking: "Buscando actualizaciones...",
-      upToDate: "SHIVA esta actualizado (version {version})",
-      newVersion: "Nueva version disponible: {version}",
-      upgrading: "Actualizando...",
-      upgraded: "SHIVA actualizado a la version {version}"
-    },
-    telemetry: {
-      description: "Configuracion de telemetria",
-      enabled: "Telemetria habilitada",
-      disabled: "Telemetria deshabilitada"
-    },
-    completions: {
-      description: "Instalar completions de shell",
-      installed: "Completions instalados para {shell}",
-      installHint: "Reinicia tu shell para los cambios"
-    },
-    docker: {
-      description: "Gestionar modo Docker",
-      header: "SHIVA Code - Docker",
-      notAvailable: "Docker no esta disponible",
-      starting: "Iniciando contenedor Docker...",
-      started: "Contenedor Docker iniciado",
-      stopped: "Contenedor Docker detenido",
-      statusDesc: "Mostrar estado de Docker",
-      startDesc: "Iniciar contenedor Docker",
-      stopDesc: "Detener contenedor Docker",
-      logsDesc: "Mostrar logs de Docker"
-    },
-    sandbox: {
-      description: "Gestionar sandbox",
-      header: "SHIVA Code - Sandbox",
-      created: "Sandbox creado",
-      applied: "Cambios del sandbox aplicados",
-      discarded: "Sandbox descartado",
-      listDesc: "Listar todos los sandboxes",
-      createDesc: "Crear nuevo sandbox",
-      applyDesc: "Aplicar cambios del sandbox",
-      discardDesc: "Descartar sandbox"
-    },
-    workflow: {
-      description: "Gestionar workflows",
-      header: "SHIVA Code - Workflows"
-    },
-    hook: {
-      description: "Gestionar hooks",
-      header: "SHIVA Code - Hooks"
-    },
-    package: {
-      description: "Gestionar grupos de proyectos",
-      header: "SHIVA Code - Packages",
-      noPackages: "No se encontraron packages",
-      createDesc: "Crear nuevo package",
-      listDesc: "Listar todos los packages",
-      addDesc: "Agregar proyecto al package",
-      removeDesc: "Eliminar proyecto del package",
-      deleteDesc: "Eliminar package",
-      created: 'Package "{name}" creado',
-      deleted: 'Package "{name}" eliminado',
-      projectAdded: "Proyecto agregado al package",
-      projectRemoved: "Proyecto eliminado del package"
-    },
-    context: {
-      description: "Mostrar contexto",
-      header: "SHIVA Code - Contexto",
-      noContext: "No se encontro contexto"
-    },
-    tags: {
-      description: "Gestionar etiquetas de sesion",
-      header: "SHIVA Code - Etiquetas",
-      noTags: "No se encontraron etiquetas"
-    },
-    export: {
-      description: "Exportar sesiones",
-      header: "SHIVA Code - Exportar",
-      exported: "Exportado a {file}",
-      selectFormat: "Selecciona formato:"
-    },
-    import: {
-      description: "Importar sesiones",
-      header: "SHIVA Code - Importar",
-      imported: "{count} sesion(es) importada(s)",
-      selectFile: "Selecciona un archivo:"
-    },
-    user: {
-      description: "Informacion del usuario",
-      header: "SHIVA Code - Usuario"
-    },
-    welcome: {
-      description: "Mostrar mensaje de bienvenida"
-    },
-    validate: {
-      description: "Validar proyecto",
-      header: "SHIVA Code - Validacion",
-      valid: "El proyecto es valido",
-      invalid: "El proyecto es invalido"
-    },
-    scan: {
-      description: "Verificar seguridad del package",
-      header: "SHIVA Code - Escaneo de seguridad",
-      scanning: "Escaneando...",
-      noIssues: "No se encontraron problemas de seguridad",
-      issuesFound: "{count} problema(s) de seguridad encontrado(s)"
-    },
-    security: {
-      description: "Configuracion de seguridad",
-      header: "SHIVA Code - Seguridad"
-    },
-    secureToken: {
-      description: "Almacenar token de forma segura"
-    },
-    project: {
-      description: "Informacion del proyecto",
-      header: "SHIVA Code - Proyecto"
-    },
-    repair: {
-      description: "Reparar proyecto",
-      header: "SHIVA Code - Reparacion",
-      repaired: "Proyecto reparado"
-    },
-    help: {
-      description: "Ayuda y documentacion",
-      header: "SHIVA Code - Ayuda",
-      topics: "Temas:",
-      quickstart: "Inicio rapido",
-      commands: "Vista general de comandos",
-      memory: "Sistema de memoria",
-      secrets: "Gestion de secretos",
-      troubleshooting: "Solucion de problemas",
-      onlineHelp: "Abrir ayuda en linea"
-    }
-  },
-  controlStation: {
-    title: "SHIVA Control Station",
-    selection: "Seleccion:",
-    navigate: "navegar",
-    sessions: "Sesiones",
-    sessionsDesc: "Mostrar todas",
-    packages: "Packages",
-    packagesDesc: "Gestionar",
-    issues: "Issues",
-    issuesDesc: "GitHub Issues",
-    prs: "PRs",
-    prsDesc: "Pull Requests",
-    config: "Config",
-    configDesc: "Configuracion",
-    help: "Ayuda",
-    helpDesc: "Documentacion",
-    quit: "Salir",
-    noSessionsFound: "No se encontraron sesiones.",
-    startClaudeHint: "Inicia Claude Code en un proyecto",
-    orCreatePackage: 'O: shiva package create "Nombre"',
-    startingSession: "Iniciando sesion en {project}...",
-    startingPackage: "Iniciando package {name}...",
-    unknownCommand: "Comando desconocido: {command}",
-    didYouMean: "Quisiste decir:",
-    projects: "Proyectos",
-    claudeNotInstalled: "Claude Code no instalado",
-    claudeInstallHint: "curl -fsSL https://claude.ai/install.sh | bash"
-  },
-  help: {
-    quickstart: {
-      title: "Inicio rapido",
-      content: [
-        "1. shiva login     - Iniciar sesion",
-        "2. shiva init      - Inicializar proyecto",
-        "3. shiva           - Abrir Control Station",
-        "4. shiva remember  - Guardar memoria",
-        "5. shiva secrets   - Gestionar secretos"
-      ]
-    },
-    commandsOverview: {
-      title: "Vista general de comandos",
-      sessionManagement: "Gestion de sesiones",
-      githubIntegration: "Integracion con GitHub",
-      memoryContext: "Memoria y Contexto",
-      dockerIntegration: "Integracion con Docker",
-      security: "Seguridad",
-      projectManagement: "Gestion de proyectos",
-      system: "Sistema"
-    },
-    memorySystem: {
-      title: "Sistema de memoria",
-      description: "SHIVA almacena informacion de forma persistente en la nube.",
-      categories: {
-        identity: "Identidad del usuario (nombre, rol)",
-        preference: "Preferencias (estilo de codigo)",
-        convention: "Convenciones del proyecto",
-        solution: "Problemas resueltos",
-        task: "Tareas",
-        context: "Contexto del proyecto"
-      }
-    },
-    secretsManagement: {
-      title: "Gestion de secretos",
-      description: "Almacenamiento seguro de claves API y secretos en la nube.",
-      features: [
-        "Cifrado de extremo a extremo",
-        "Inyeccion automatica en sesiones",
-        "Secretos especificos del proyecto y globales",
-        "Importar/exportar archivos .env"
-      ]
-    },
-    troubleshooting: {
-      title: "Solucion de problemas",
-      commonIssues: {
-        notLoggedIn: "No conectado",
-        notLoggedInSolution: "Usa 'shiva login' para conectarte",
-        claudeNotFound: "Claude Code no encontrado",
-        claudeNotFoundSolution: "Instala Claude Code con el instalador oficial",
-        networkError: "Error de red",
-        networkErrorSolution: "Comprueba tu conexion a internet",
-        permissionDenied: "Permiso denegado",
-        permissionDeniedSolution: "Comprueba los permisos de archivos o ejecuta con sudo"
-      }
-    }
-  },
-  time: {
-    justNow: "ahora mismo",
-    minutesAgo: "hace {count} minuto(s)",
-    hoursAgo: "hace {count} hora(s)",
-    daysAgo: "hace {count} dia(s)",
-    weeksAgo: "hace {count} semana(s)",
-    monthsAgo: "hace {count} mes(es)"
-  },
-  onboarding: {
-    welcome: "Bienvenido a SHIVA Code!",
-    subtitle: "Hace Claude Code persistente",
-    selectLanguage: "Seleccionar idioma:",
-    claudeCode: "Claude Code",
-    claudeNotFound: "Claude Code no encontrado",
-    claudeNotFoundDesc: "SHIVA extiende Claude Code con almacenamiento persistente. Necesitas Claude Code para usar SHIVA.",
-    installation: "Instalacion:",
-    moreInfo: "Mas informacion:",
-    continueAnyway: "Continuar de todos modos?",
-    restartAfterInstall: "Reiniciar despues de la instalacion: shiva",
-    found: "Encontrado",
-    display: "Visualizacion",
-    darkMode: "Modo oscuro",
-    lightMode: "Modo claro",
-    recommended: "(recomendado)",
-    themeSaved: "Tema guardado",
-    account: "Cuenta",
-    accountFeatures: "Con una cuenta obtienes:",
-    cloudSync: "Sincronizacion en la nube para memories",
-    crossDeviceSessions: "Sesiones entre dispositivos",
-    secretsVault: "Boveda de secretos (encriptada)",
-    loginNow: "Iniciar sesion ahora?",
-    openBrowser: "Abriendo navegador...",
-    loginLater: "Despues: shiva login",
-    integration: "Integracion",
-    autoIntegration: "SHIVA se integra automaticamente con Claude Code:",
-    loadMemoriesOnStart: "Cargar memories al inicio",
-    saveMemoriesOnExit: "Guardar memories al salir",
-    enableAutoIntegration: "Activar integracion automatica?",
-    hooksInstalled: "Hooks instalados",
-    hooksFailed: "Instalacion de hooks fallida",
-    hooksLater: "Despues: shiva hook install",
-    setupComplete: "Configuracion completa!",
-    nextSteps: "Proximos pasos:",
-    letsGo: "Vamos:",
-    goToProject: "Ir a tu proyecto",
-    initShiva: "Inicializar SHIVA",
-    startClaude: "Iniciar Claude Code",
-    commands: "Comandos:",
-    laterLogin: "Iniciar sesion despues: shiva login"
-  },
-  account: {
-    description: "Gestionar cuenta",
-    deleteDesc: "Eliminar cuenta y TODOS los datos permanentemente (RGPD)",
-    infoDesc: "Mostrar informacion de la cuenta",
-    header: "Cuenta SHIVA",
-    deleteWarning: "ELIMINAR CUENTA - IRREVERSIBLE",
-    deleteWarning1: "Estas a punto de eliminar permanentemente tu cuenta SHIVA.",
-    willBeDeleted: "Los siguientes datos seran PERMANENTEMENTE eliminados:",
-    allProjects: "Todos los proyectos",
-    allMemories: "Todas las memories",
-    allSecrets: "Todos los secrets (claves API)",
-    allSessions: "Todos los datos de sesion",
-    allSettings: "Todas las configuraciones",
-    accountData: "Datos de la cuenta (email, perfil)",
-    cannotBeUndone: "Esta accion NO puede deshacerse!",
-    confirmDelete1: "Entiendo - quiero eliminar mi cuenta",
-    enterEmail: "Introduce tu email para confirmar ({email}):",
-    emailMismatch: "El email no coincide",
-    typeDelete: "Escribe DELETE para confirmar:",
-    deleting: "Eliminando cuenta...",
-    deleted: "Cuenta eliminada",
-    deleteFailed: "Eliminacion fallida",
-    deletedInfo: "Todos tus datos han sido eliminados de nuestros sistemas.",
-    goodbye: "Gracias por usar SHIVA. Adios!",
-    memberSince: "Miembro desde",
-    usage: "Uso:",
-    projects: "Proyectos",
-    memories: "Memories",
-    secrets: "Secrets",
-    sessions: "Sesiones"
-  },
-  uninstall: {
-    description: "Desinstalar SHIVA completamente",
-    header: "Desinstalacion",
-    localOption: "Solo eliminar datos locales",
-    fullOption: "Desinstalacion completa",
-    keepAccountOption: "Mantener datos de la cuenta",
-    willBeRemoved: "Se eliminara lo siguiente:",
-    globalConfig: "Configuracion global",
-    claudeHooks: "Hooks de Claude Code",
-    projectShivaDir: "Directorio .shiva/ del proyecto",
-    accountData: "Datos de la cuenta en el servidor",
-    npmPackage: "Paquete NPM",
-    nothingToRemove: "No se encontraron datos locales.",
-    runNpmUninstall: "Ejecuta este comando para eliminar SHIVA:",
-    confirmUninstall: "Realmente desinstalar SHIVA?",
-    accountWarning: "Tu cuenta y todos los datos en la nube seran eliminados!",
-    confirmAccountDelete: "Eliminar tambien los datos de la cuenta?",
-    accountKept: "Los datos de la cuenta se mantendran.",
-    removingHooks: "Eliminando hooks de Claude...",
-    hooksRemoved: "Hooks de Claude eliminados",
-    hooksFailed: "Error al eliminar hooks",
-    removingConfig: "Eliminando configuracion...",
-    configRemoved: "Configuracion eliminada",
-    configFailed: "Error al eliminar configuracion",
-    removingProjectDir: "Eliminando directorio .shiva/...",
-    projectDirRemoved: "Directorio .shiva/ eliminado",
-    projectDirFailed: "Error al eliminar .shiva/",
-    deletingAccount: "Eliminando datos de la cuenta...",
-    accountDeleted: "Datos de la cuenta eliminados",
-    accountFailed: "Error al eliminar cuenta",
-    complete: "Desinstalacion completada!",
-    partialSuccess: "Algunos pasos fallaron.",
-    finalStep: "Ultimo paso - ejecuta:",
-    accountStillExists: "Nota: Tu cuenta aun existe en el servidor.",
-    deleteAccountHint: "Para eliminar: shiva account delete",
-    thanksForUsing: "Gracias por usar SHIVA!"
-  },
-  projectDelete: {
-    deleteDesc: "Eliminar proyecto y todos los datos",
-    deleteIdOption: "ID del proyecto a eliminar",
-    deleteWarning: "ADVERTENCIA: El proyecto sera eliminado permanentemente!",
-    notConnected: "El directorio actual no esta conectado a un proyecto",
-    memoriesCount: "Memories",
-    sessionsCount: "Sesiones",
-    confirmDelete: "Realmente eliminar proyecto?",
-    enterNameToConfirm: 'Introduce "{name}" para confirmar:',
-    deleting: "Eliminando proyecto...",
-    deleted: "Proyecto eliminado",
-    deleteFailed: "Eliminacion fallida",
-    deletedInfo: "Todos los datos del proyecto han sido eliminados de la nube."
-  }
-};
-
-// src/i18n/types.ts
-var SUPPORTED_LANGUAGES = ["de", "en", "fr", "es"];
-var LANGUAGE_NAMES = {
-  de: "Deutsch",
-  en: "English",
-  fr: "Francais",
-  es: "Espanol"
-};
-
-// src/i18n/index.ts
-var translations = {
-  de: de_default,
-  en: en_default,
-  fr: fr_default,
-  es: es_default
-};
-var currentLanguage = "de";
-function setLanguage(lang) {
-  currentLanguage = lang;
-}
-function getLanguage() {
-  return currentLanguage;
-}
-function isValidLanguage(lang) {
-  return ["de", "en", "fr", "es"].includes(lang);
-}
-function t(key, params) {
-  const keys = key.split(".");
-  let value = translations[currentLanguage];
-  for (const k of keys) {
-    if (value && typeof value === "object" && k in value) {
-      value = value[k];
-    } else {
-      value = void 0;
-      break;
-    }
-  }
-  if (typeof value !== "string") {
-    value = keys.reduce(
-      (obj, k) => obj && typeof obj === "object" && k in obj ? obj[k] : void 0,
-      translations.de
-    );
-  }
-  if (typeof value !== "string") {
-    return key;
-  }
-  if (params) {
-    for (const [param, val] of Object.entries(params)) {
-      value = value.replace(new RegExp(`\\{${param}\\}`, "g"), String(val));
-    }
-  }
-  return value;
-}
-function tArray(key) {
-  const keys = key.split(".");
-  let value = translations[currentLanguage];
-  for (const k of keys) {
-    if (value && typeof value === "object" && k in value) {
-      value = value[k];
-    } else {
-      value = void 0;
-      break;
-    }
-  }
-  if (!Array.isArray(value)) {
-    value = keys.reduce(
-      (obj, k) => obj && typeof obj === "object" && k in obj ? obj[k] : void 0,
-      translations.de
-    );
-  }
-  return Array.isArray(value) ? value : [];
-}
-function initializeLanguage(storedLang) {
-  if (storedLang && isValidLanguage(storedLang)) {
-    setLanguage(storedLang);
-    return;
-  }
-  try {
-    const systemLocale = Intl.DateTimeFormat().resolvedOptions().locale;
-    const langCode = systemLocale.split("-")[0].toLowerCase();
-    if (isValidLanguage(langCode)) {
-      setLanguage(langCode);
-      return;
-    }
-  } catch {
-  }
-  setLanguage("de");
-}
-
-// src/commands/auth/login.ts
-var loginCommand = new Command("login").description(t("commands.login.description")).option("-e, --email <email>", t("commands.login.emailOption")).option("--otp", t("commands.login.otpOption")).action(async (options) => {
-  if (isAuthenticated()) {
-    const config = getConfig();
-    log.info(t("auth.alreadyLoggedIn", { email: config.email || "" }));
-    const { relogin } = await inquirer2.prompt([
-      {
-        type: "confirm",
-        name: "relogin",
-        message: t("auth.reloginQuestion"),
-        default: false
-      }
-    ]);
-    if (!relogin) {
-      return;
-    }
-  }
-  log.brand();
-  if (options.email) {
-    await loginWithOtp(options.email);
-    return;
-  }
-  if (options.otp) {
-    const { email } = await inquirer2.prompt([
-      {
-        type: "input",
-        name: "email",
-        message: t("auth.enterEmail"),
-        validate: (input) => {
-          if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(input)) {
-            return t("auth.invalidEmail");
-          }
-          return true;
-        }
-      }
-    ]);
-    await loginWithOtp(email);
-    return;
-  }
-  await loginWithBrowser();
-});
-
-export {
-  SUPPORTED_LANGUAGES,
-  LANGUAGE_NAMES,
-  setLanguage,
-  getLanguage,
-  t,
-  tArray,
-  initializeLanguage,
-  twoFactorService,
-  deviceTrustService,
-  displayQRCode,
-  displayBackupCodes,
-  displayDevices,
-  logout,
-  loginCommand
-};