shark-ai 0.0.2 → 0.2.1

package/dist/{chunk-B7PNFPUX.js → chunk-R3MIUNVD.js}

@@ -25,6 +25,280 @@ import { Command } from "commander";
 
 // src/ui/tui.ts
 import * as p from "@clack/prompts";
+
+// src/core/config-manager.ts
+import os2 from "os";
+import path2 from "path";
+import fs2 from "fs";
+
+// src/core/config/schema.ts
+import { z } from "zod";
+var ConfigSchema = z.object({
+  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  preferredStack: z.array(z.string()).default([]),
+  apiBaseUrl: z.string().optional(),
+  language: z.enum(["pt-br", "en-us", "es-es"]).default("pt-br"),
+  project: z.string().optional(),
+  environment: z.string().optional(),
+  activeRealm: z.string().optional()
+  // Currently logged-in realm
+});
+
+// src/core/config/sharkrc-loader.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { z as z2 } from "zod";
+var SharkRCFileSchema = z2.object({
+  project: z2.string().optional(),
+  environment: z2.string().optional(),
+  logLevel: z2.string().optional(),
+  language: z2.string().optional(),
+  preferredStack: z2.array(z2.string()).optional()
+  // Add other keys as needed from the main config
+}).passthrough();
+function loadFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return {};
+    }
+    const content = fs.readFileSync(filePath, "utf-8");
+    const json = JSON.parse(content);
+    const result = SharkRCFileSchema.safeParse(json);
+    if (result.success) {
+      return result.data;
+    } else {
+      console.warn(colors.warning(`\u26A0\uFE0F  Invalid config in ${filePath}: ${result.error.message}`));
+      return {};
+    }
+  } catch (error) {
+    console.warn(colors.warning(`\u26A0\uFE0F  Failed to read ${filePath}: ${error.message}`));
+    return {};
+  }
+}
+function loadSharkRC() {
+  const homeDir = os.homedir();
+  const currentDir = process.cwd();
+  const globalPath = path.join(homeDir, ".sharkrc");
+  const localPath = path.join(currentDir, ".sharkrc");
+  const globalConfig = loadFile(globalPath);
+  const localConfig = loadFile(localPath);
+  return {
+    ...globalConfig,
+    ...localConfig
+  };
+}
+function saveGlobalRC(configUpdates) {
+  const homeDir = os.homedir();
+  const globalPath = path.join(homeDir, ".sharkrc");
+  const currentConfig = loadFile(globalPath);
+  const newConfig = { ...currentConfig, ...configUpdates };
+  try {
+    fs.writeFileSync(globalPath, JSON.stringify(newConfig, null, 2), "utf-8");
+  } catch (error) {
+    throw new Error(`Failed to save global config to ${globalPath}: ${error.message}`);
+  }
+}
+
+// src/core/config-manager.ts
+var ConfigManager = class _ConfigManager {
+  static instance;
+  config = null;
+  constructor() {
+  }
+  static getInstance() {
+    if (!_ConfigManager.instance) {
+      _ConfigManager.instance = new _ConfigManager();
+    }
+    return _ConfigManager.instance;
+  }
+  getConfig() {
+    if (!this.config) {
+      this.config = this.loadConfig();
+    }
+    return this.config;
+  }
+  reloadConfig() {
+    this.config = this.loadConfig();
+  }
+  loadConfig() {
+    let mergedConfig = {};
+    const rcConfig = loadSharkRC();
+    mergedConfig = { ...mergedConfig, ...rcConfig };
+    const envConfig = this.loadEnvConfig();
+    mergedConfig = { ...mergedConfig, ...envConfig };
+    const parsed = ConfigSchema.safeParse(mergedConfig);
+    if (!parsed.success) {
+      console.warn("\u26A0\uFE0F Invalid configuration detected, falling back to defaults or partial config");
+      console.warn(parsed.error.message);
+      return ConfigSchema.parse({});
+    }
+    return parsed.data;
+  }
+  readJsonFile(filePath) {
+    try {
+      if (fs2.existsSync(filePath)) {
+        const content = fs2.readFileSync(filePath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch (error) {
+      console.warn(`Failed to read config file at ${filePath}`, error);
+    }
+    return {};
+  }
+  async set(key, value) {
+    if (!this.config) {
+      this.config = this.loadConfig();
+    }
+    this.config[key] = value;
+    const homeDir = os2.homedir();
+    const configPath = path2.join(homeDir, ".sharkrc");
+    try {
+      let currentFileConfig = {};
+      if (fs2.existsSync(configPath)) {
+        currentFileConfig = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+      }
+      const newConfig = { ...currentFileConfig, [key]: value };
+      fs2.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
+    } catch (error) {
+      console.error("Failed to save configuration:", error);
+    }
+  }
+  loadEnvConfig() {
+    const config = {};
+    if (process.env.SHARK_LOG_LEVEL) {
+      config.logLevel = process.env.SHARK_LOG_LEVEL;
+    }
+    if (process.env.SHARK_API_BASE_URL) {
+      config.apiBaseUrl = process.env.SHARK_API_BASE_URL;
+    }
+    if (process.env.SHARK_LANGUAGE) {
+      config.language = process.env.SHARK_LANGUAGE;
+    }
+    if (process.env.SHARK_PREFERRED_STACK) {
+      config.preferredStack = process.env.SHARK_PREFERRED_STACK.split(",").map((s) => s.trim());
+    }
+    return config;
+  }
+};
+
+// src/core/i18n/locales/en-us.ts
+var enUs = {
+  common: {
+    loading: "Loading...",
+    success: "Success",
+    error: "Error",
+    cancel: "Cancel",
+    operationCancelled: "Operation cancelled."
+  },
+  commands: {
+    config: {
+      title: "Shark AI Configuration",
+      selectAction: "What matches your needs?",
+      actions: {
+        language: "Set Language",
+        logLevel: "Log Level",
+        back: "Back"
+      },
+      selectLanguage: "Select language:",
+      languageUpdated: "Updated language to: {0}"
+    },
+    login: {
+      intro: "StackSpot Login",
+      alreadyLoggedIn: "You are already logged in",
+      success: "Successfully logged in!",
+      error: "Login failed"
+    }
+  }
+};
+
+// src/core/i18n/locales/es-es.ts
+var esEs = {
+  common: {
+    loading: "Cargando...",
+    success: "\xC9xito",
+    error: "Error",
+    cancel: "Cancelar",
+    operationCancelled: "Operaci\xF3n cancelada."
+  },
+  commands: {
+    config: {
+      title: "Configuraci\xF3n Shark AI",
+      selectAction: "\xBFQu\xE9 desea configurar?",
+      actions: {
+        language: "Cambiar Idioma",
+        logLevel: "Nivel de Log",
+        back: "Volver"
+      },
+      selectLanguage: "Seleccione el idioma:",
+      languageUpdated: "Idioma actualizado a: {0}"
+    },
+    login: {
+      intro: "Login StackSpot",
+      alreadyLoggedIn: "Ya has iniciado sesi\xF3n",
+      success: "\xA1Inicio de sesi\xF3n exitoso!",
+      error: "Error de inicio de sesi\xF3n"
+    }
+  }
+};
+
+// src/core/i18n/locales/pt-br.ts
+var ptBr = {
+  common: {
+    loading: "Carregando...",
+    success: "Sucesso",
+    error: "Erro",
+    cancel: "Cancelar",
+    operationCancelled: "Opera\xE7\xE3o cancelada."
+  },
+  commands: {
+    config: {
+      title: "Configura\xE7\xF5es do Shark AI",
+      selectAction: "O que voc\xEA deseja configurar?",
+      actions: {
+        language: "Alterar Idioma",
+        logLevel: "N\xEDvel de Log",
+        back: "Voltar"
+      },
+      selectLanguage: "Selecione o idioma:",
+      languageUpdated: "Idioma atualizado para: {0}"
+    },
+    login: {
+      intro: "Login StackSpot",
+      alreadyLoggedIn: "Voc\xEA j\xE1 est\xE1 logado",
+      success: "Login realizado com sucesso!",
+      error: "Falha no login"
+    }
+  }
+};
+
+// src/core/i18n/index.ts
+var locales = {
+  "pt-br": ptBr,
+  "en-us": enUs,
+  "es-es": esEs
+};
+function getNestedValue(obj, path5) {
+  return path5.split(".").reduce((acc, part) => acc && acc[part], obj);
+}
+function t(key, ...args) {
+  const config = ConfigManager.getInstance().getConfig();
+  const lang = config.language || "pt-br";
+  const normalizedLang = lang.toLowerCase();
+  const locale = locales[normalizedLang] || locales["pt-br"];
+  let template = getNestedValue(locale, key);
+  if (!template) {
+    template = getNestedValue(locales["pt-br"], key);
+  }
+  if (!template) {
+    return key;
+  }
+  return template.replace(/\{(\d+)\}/g, (match, index) => {
+    return typeof args[index] !== "undefined" ? args[index] : match;
+  });
+}
+
+// src/ui/tui.ts
 var tui = {
   intro(title) {
     p.intro(colors.inverse(` ${title} `));
@@ -74,7 +348,7 @@ var tui = {
    */
   handleCancel(value) {
     if (p.isCancel(value)) {
-      p.cancel("Operation cancelled.");
+      p.cancel(t("common.operationCancelled"));
       process.exit(0);
     }
   },
@@ -112,80 +386,97 @@ async function authenticate(realm, clientId, clientSecret) {
 }
 
 // src/core/auth/token-storage.ts
-import keytar from "keytar";
-var SERVICE_NAME = "shark-cli";
-var CHUNK_SIZE = 2500;
+import fs3 from "fs";
+import path3 from "path";
+import os3 from "os";
+var SHARK_DIR = ".shark-ai";
+var CREDENTIALS_FILE = "credentials.json";
 var tokenStorage = {
   /**
-   * Saves the access token for the given realm.
-   * Handles large tokens by splitting them into chunks if necessary.
+   * Get the secure file path
    */
-  async saveToken(realm, token) {
+  getFilePath() {
+    const homeDir = os3.homedir();
+    const sharkDir = path3.join(homeDir, SHARK_DIR);
+    if (!fs3.existsSync(sharkDir)) {
+      fs3.mkdirSync(sharkDir, { mode: 448 });
+    }
+    return path3.join(sharkDir, CREDENTIALS_FILE);
+  },
+  /**
+   * Reads the credentials file safely
+   */
+  readCredentials() {
+    const filePath = this.getFilePath();
     try {
-      await this.deleteToken(realm);
-      if (token.length <= CHUNK_SIZE) {
-        await keytar.setPassword(SERVICE_NAME, realm, token);
-      } else {
-        const chunks = [];
-        for (let i = 0; i < token.length; i += CHUNK_SIZE) {
-          chunks.push(token.slice(i, i + CHUNK_SIZE));
-        }
-        await keytar.setPassword(SERVICE_NAME, `${realm}_meta_chunks`, chunks.length.toString());
-        for (let i = 0; i < chunks.length; i++) {
-          await keytar.setPassword(SERVICE_NAME, `${realm}_chunk_${i}`, chunks[i]);
-        }
+      if (!fs3.existsSync(filePath)) {
+        return {};
       }
+      const content = fs3.readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
     } catch (error) {
-      throw new Error(`Failed to save token to OS Keychain. If on Linux, ensure 'libsecret' is installed.
-Original Error: ${error.message}`);
+      return {};
     }
   },
   /**
-   * Retrieves the access token for the given realm.
-   * Reassembles chunks if they exist.
+   * Save credentials to file with 600 permissions
    */
-  async getToken(realm) {
+  writeCredentials(creds) {
+    const filePath = this.getFilePath();
     try {
-      const meta = await keytar.getPassword(SERVICE_NAME, `${realm}_meta_chunks`);
-      if (meta) {
-        const count = parseInt(meta, 10);
-        let fullToken = "";
-        for (let i = 0; i < count; i++) {
-          const chunk = await keytar.getPassword(SERVICE_NAME, `${realm}_chunk_${i}`);
-          if (!chunk) return null;
-          fullToken += chunk;
-        }
-        return fullToken;
-      } else {
-        return await keytar.getPassword(SERVICE_NAME, realm);
-      }
+      fs3.writeFileSync(filePath, JSON.stringify(creds, null, 2), { mode: 384 });
     } catch (error) {
-      console.warn(`WARNING: Failed to access OS Keychain (${error.message}).`);
-      return null;
+      throw new Error(`Failed to save credentials to ${filePath}: ${error.message}`);
     }
   },
   /**
-   * Deletes the access token for the given realm.
-   * Cleans up all chunks.
+   * Saves the access token (and optional client credentials) for the given realm.
+   */
+  async saveToken(realm, token, clientId, clientKey, expiresIn) {
+    const creds = this.readCredentials();
+    const now = Math.floor(Date.now() / 1e3);
+    const expiresAt = expiresIn ? now + expiresIn : void 0;
+    creds[realm] = {
+      ...creds[realm],
+      // Preserve existing data if any
+      accessToken: token,
+      ...clientId && { clientId },
+      ...clientKey && { clientKey },
+      ...expiresAt && { expiresAt }
+    };
+    this.writeCredentials(creds);
+  },
+  /**
+   * Retrieves the access token for the given realm.
+   * Checks ENV var first (SHARK_ACCESS_TOKEN).
+   */
+  async getToken(realm) {
+    if (process.env.SHARK_ACCESS_TOKEN) {
+      return process.env.SHARK_ACCESS_TOKEN;
+    }
+    const creds = this.readCredentials();
+    const realmCreds = creds[realm];
+    if (!realmCreds) return null;
+    return realmCreds.accessToken;
+  },
+  /**
+   * Retrieves full credentials object (for refresh logic)
+   */
+  async getCredentials(realm) {
+    const creds = this.readCredentials();
+    return creds[realm] || null;
+  },
+  /**
+   * Deletes the access token/credentials for the given realm.
    */
   async deleteToken(realm) {
-    try {
-      const meta = await keytar.getPassword(SERVICE_NAME, `${realm}_meta_chunks`);
-      let deletedSomething = false;
-      if (meta) {
-        const count = parseInt(meta, 10);
-        for (let i = 0; i < count; i++) {
-          await keytar.deletePassword(SERVICE_NAME, `${realm}_chunk_${i}`);
-        }
-        await keytar.deletePassword(SERVICE_NAME, `${realm}_meta_chunks`);
-        deletedSomething = true;
-      }
-      const standardDelete = await keytar.deletePassword(SERVICE_NAME, realm);
-      return deletedSomething || standardDelete;
-    } catch (error) {
-      console.warn(`WARNING: Failed to delete from OS Keychain (${error.message}).`);
-      return false;
+    const creds = this.readCredentials();
+    if (creds[realm]) {
+      delete creds[realm];
+      this.writeCredentials(creds);
+      return true;
     }
+    return false;
   }
 };
 
@@ -236,167 +527,47 @@ var Connectivity = class _Connectivity {
 };
 var connectivity = Connectivity.getInstance();
 
-// src/core/config-manager.ts
-import os2 from "os";
-import path2 from "path";
-import fs2 from "fs";
-
-// src/core/config/schema.ts
-import { z } from "zod";
-var ConfigSchema = z.object({
-  logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
-  preferredStack: z.array(z.string()).default([]),
-  apiBaseUrl: z.string().optional(),
-  language: z.enum(["pt-br", "en-us"]).default("pt-br"),
-  project: z.string().optional(),
-  environment: z.string().optional(),
-  activeRealm: z.string().optional()
-  // Currently logged-in realm
-});
-
-// src/core/config/sharkrc-loader.ts
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { z as z2 } from "zod";
-var SharkRCFileSchema = z2.object({
-  project: z2.string().optional(),
-  environment: z2.string().optional(),
-  logLevel: z2.string().optional(),
-  language: z2.string().optional(),
-  preferredStack: z2.array(z2.string()).optional()
-  // Add other keys as needed from the main config
-}).passthrough();
-function loadFile(filePath) {
-  try {
-    if (!fs.existsSync(filePath)) {
-      return {};
-    }
-    const content = fs.readFileSync(filePath, "utf-8");
-    const json = JSON.parse(content);
-    const result = SharkRCFileSchema.safeParse(json);
-    if (result.success) {
-      return result.data;
-    } else {
-      console.warn(colors.warning(`\u26A0\uFE0F  Invalid config in ${filePath}: ${result.error.message}`));
-      return {};
-    }
-  } catch (error) {
-    console.warn(colors.warning(`\u26A0\uFE0F  Failed to read ${filePath}: ${error.message}`));
-    return {};
-  }
-}
-function loadSharkRC() {
-  const homeDir = os.homedir();
-  const currentDir = process.cwd();
-  const globalPath = path.join(homeDir, ".sharkrc");
-  const localPath = path.join(currentDir, ".sharkrc");
-  const globalConfig = loadFile(globalPath);
-  const localConfig = loadFile(localPath);
-  return {
-    ...globalConfig,
-    ...localConfig
-  };
-}
-function saveGlobalRC(configUpdates) {
-  const homeDir = os.homedir();
-  const globalPath = path.join(homeDir, ".sharkrc");
-  const currentConfig = loadFile(globalPath);
-  const newConfig = { ...currentConfig, ...configUpdates };
-  try {
-    fs.writeFileSync(globalPath, JSON.stringify(newConfig, null, 2), "utf-8");
-  } catch (error) {
-    throw new Error(`Failed to save global config to ${globalPath}: ${error.message}`);
-  }
-}
-
-// src/core/config-manager.ts
-var ConfigManager = class _ConfigManager {
-  static instance;
-  config = null;
-  constructor() {
-  }
-  static getInstance() {
-    if (!_ConfigManager.instance) {
-      _ConfigManager.instance = new _ConfigManager();
-    }
-    return _ConfigManager.instance;
-  }
-  getConfig() {
-    if (!this.config) {
-      this.config = this.loadConfig();
-    }
-    return this.config;
-  }
-  reloadConfig() {
-    this.config = this.loadConfig();
-  }
-  loadConfig() {
-    let mergedConfig = {};
-    const rcConfig = loadSharkRC();
-    mergedConfig = { ...mergedConfig, ...rcConfig };
-    const envConfig = this.loadEnvConfig();
-    mergedConfig = { ...mergedConfig, ...envConfig };
-    const parsed = ConfigSchema.safeParse(mergedConfig);
-    if (!parsed.success) {
-      console.warn("\u26A0\uFE0F Invalid configuration detected, falling back to defaults or partial config");
-      console.warn(parsed.error.message);
-      return ConfigSchema.parse({});
-    }
-    return parsed.data;
-  }
-  readJsonFile(filePath) {
+// src/core/debug/file-logger.ts
+import fs4 from "fs";
+import path4 from "path";
+var FileLogger = class {
+  static logPath = path4.resolve(process.cwd(), "shark-debug.log");
+  static enabled = true;
+  // Enabled by default for this debugging session
+  static init() {
     try {
-      if (fs2.existsSync(filePath)) {
-        const content = fs2.readFileSync(filePath, "utf-8");
-        return JSON.parse(content);
-      }
-    } catch (error) {
-      console.warn(`Failed to read config file at ${filePath}`, error);
+      fs4.writeFileSync(this.logPath, `--- Shark CLI Debug Log Started at ${(/* @__PURE__ */ new Date()).toISOString()} ---
+`);
+    } catch (e) {
+      console.error("Failed to initialize debug log:", e);
     }
-    return {};
   }
-  async set(key, value) {
-    if (!this.config) {
-      this.config = this.loadConfig();
-    }
-    this.config[key] = value;
-    const homeDir = os2.homedir();
-    const configPath = path2.join(homeDir, ".sharkrc");
+  static log(category, message, data) {
+    if (!this.enabled) return;
     try {
-      let currentFileConfig = {};
-      if (fs2.existsSync(configPath)) {
-        currentFileConfig = JSON.parse(fs2.readFileSync(configPath, "utf8"));
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      let logEntry = `[${timestamp}] [${category.toUpperCase()}] ${message}
+`;
+      if (data !== void 0) {
+        if (typeof data === "object") {
+          logEntry += JSON.stringify(data, null, 2) + "\n";
+        } else {
+          logEntry += String(data) + "\n";
+        }
       }
-      const newConfig = { ...currentFileConfig, [key]: value };
-      fs2.writeFileSync(configPath, JSON.stringify(newConfig, null, 2));
-    } catch (error) {
-      console.error("Failed to save configuration:", error);
-    }
-  }
-  loadEnvConfig() {
-    const config = {};
-    if (process.env.SHARK_LOG_LEVEL) {
-      config.logLevel = process.env.SHARK_LOG_LEVEL;
-    }
-    if (process.env.SHARK_API_BASE_URL) {
-      config.apiBaseUrl = process.env.SHARK_API_BASE_URL;
-    }
-    if (process.env.SHARK_LANGUAGE) {
-      config.language = process.env.SHARK_LANGUAGE;
+      logEntry += "-".repeat(40) + "\n";
+      fs4.appendFileSync(this.logPath, logEntry);
+    } catch (e) {
     }
-    if (process.env.SHARK_PREFERRED_STACK) {
-      config.preferredStack = process.env.SHARK_PREFERRED_STACK.split(",").map((s) => s.trim());
-    }
-    return config;
   }
 };
 
 // src/commands/login.ts
 var loginCommand = new Command("login").description("Authenticate with StackSpot").action(async () => {
   try {
+    FileLogger.init();
     await connectivity.requireOnline();
-    tui.intro("Shark CLI Login");
+    tui.intro(t("commands.login.intro"));
     const realm = await tui.text({
       message: "Account Realm (Slug)",
       placeholder: "e.g. stackspot-freemium",
@@ -437,18 +608,27 @@ var loginCommand = new Command("login").description("Authenticate with StackSpot
         clientId.trim(),
         clientKey.trim()
       );
-      await tokenStorage.saveToken(realm, tokens.access_token);
+      FileLogger.log("LOGIN", "Authentication success", { realm });
+      await tokenStorage.saveToken(
+        realm,
+        tokens.access_token,
+        clientId,
+        clientKey,
+        tokens.expires_in
+      );
       const configManager = ConfigManager.getInstance();
       await configManager.set("activeRealm", realm);
-      spinner2.stop("\u2705 Login successful");
-      tui.outro(`You are now authenticated as ${colors.primary(realm)}`);
+      spinner2.stop(t("commands.login.success"));
+      tui.outro(t("commands.login.success"));
     } catch (error) {
-      spinner2.stop("Authentication failed.", 1);
+      spinner2.stop(t("commands.login.error"), 1);
       tui.log.error(error.message);
+      FileLogger.log("LOGIN", "Authentication failed", error);
       process.exit(1);
     }
   } catch (error) {
     tui.log.error(error.message);
+    FileLogger.log("LOGIN", "Unexpected error", error);
     process.exit(1);
   }
 });
@@ -456,7 +636,7 @@ var loginCommand = new Command("login").description("Authenticate with StackSpot
 // src/commands/config.ts
 var configCommand = {
   action: async () => {
-    tui.intro("Shark configuration");
+    tui.intro(t("commands.config.title"));
     const manager = ConfigManager.getInstance();
     const currentConfig = manager.getConfig();
     tui.log.info(colors.dim("Current Configuration:"));
@@ -464,12 +644,12 @@ var configCommand = {
     tui.log.message(`\u2022 Language: ${colors.primary(currentConfig.language)}`);
     tui.log.message(`\u2022 Log Level: ${colors.primary(currentConfig.logLevel)}`);
     const action = await tui.select({
-      message: "What would you like to configure?",
+      message: t("commands.config.selectAction"),
       options: [
         { value: "project", label: "Set Default Project" },
-        { value: "language", label: "Set Language" },
-        { value: "logLevel", label: "Set Log Level" },
-        { value: "exit", label: "Exit" }
+        { value: "language", label: t("commands.config.actions.language") },
+        { value: "logLevel", label: t("commands.config.actions.logLevel") },
+        { value: "exit", label: t("commands.config.actions.back") }
       ]
     });
     if (tui.isCancel(action) || action === "exit") {
@@ -490,16 +670,17 @@ var configCommand = {
       }
       if (action === "language") {
         const lang = await tui.select({
-          message: "Select language:",
+          message: t("commands.config.selectLanguage"),
           options: [
-            { value: "pt-br", label: "Portuguese (Brazil)" },
-            { value: "en-us", label: "English (US)" }
+            { value: "pt-br", label: "Portugu\xEAs (Brasil)" },
+            { value: "en-us", label: "English (US)" },
+            { value: "es-es", label: "Espa\xF1ol" }
           ],
           initialValue: currentConfig.language
         });
         if (!tui.isCancel(lang)) {
           saveGlobalRC({ language: lang });
-          tui.log.success(`Updated language to: ${lang}`);
+          tui.log.success(t("commands.config.languageUpdated", lang));
         }
       }
       if (action === "logLevel") {
@@ -529,10 +710,11 @@ var configCommand = {
 
 export {
   colors,
+  ConfigManager,
   tui,
   tokenStorage,
-  ConfigManager,
+  FileLogger,
   loginCommand,
   configCommand
 };
-//# sourceMappingURL=chunk-B7PNFPUX.js.map
+//# sourceMappingURL=chunk-R3MIUNVD.js.map