blun-king-cli 6.2.0 → 6.2.1

package/bin/blun.js

@@ -1,35 +1,43 @@
 #!/usr/bin/env node
 const path = require("path");
 const pkg = require("../package.json");
+
 const args = process.argv.slice(2);
 const command = args[0] || "chat";
 
 async function main() {
   const ui = require("../lib/ui");
   const auth = require("../lib/auth");
+  const client = require("../lib/client");
   const workspace = require("../lib/workspace");
 
   switch (command) {
-    case "version": case "--version": case "-v":
-      console.log("blun-king-cli v" + pkg.version);
+    case "version":
+    case "--version":
+    case "-v":
+      console.log("@blun/cli v" + pkg.version);
       break;
 
-    case "help": case "--help": case "-h":
+    case "help":
+    case "--help":
+    case "-h":
       ui.renderBanner();
       ui.renderBox("BLUN CLI Commands", [
-        "blun                Start interactive chat",
-        "blun chat            Interactive chat mode",
-        "blun ask \"...\"       One-shot question",
-        "blun login           Login with email + password",
-        "blun register        Create new account",
-        "blun logout          Remove credentials",
-        "blun auth --api-key  Authenticate with API key",
-        "blun keys create     Create new API key",
-        "blun keys list       List your API keys",
-        "blun status          System health check",
-        "blun init            Initialize BLUN project",
-        "blun version         Show version",
-        "blun help            Show this help"
+        "blun              Start interactive chat (default)",
+        "blun chat          Interactive chat mode",
+        'blun ask \"...\"     One-shot question',
+        "blun login         Login with email + password",
+        "blun register      Register new account",
+        "blun logout        Remove stored credentials",
+        "blun auth --api-key KEY   Authenticate with API key",
+        "blun keys list     List your API keys",
+        "blun keys create   Create a new API key",
+        "blun whoami        Show current user info",
+        "blun settings      Show/change settings",
+        "blun status        Show system health",
+        "blun init          Initialize BLUN project in current dir",
+        "blun version       Show version",
+        "blun help          Show this help"
       ].join("\n"), "cyan");
       break;
 
@@ -45,68 +53,121 @@ async function main() {
       auth.logout();
       break;
 
-    case "auth":
-      if (args[1] === "--api-key" && args[2]) {
-        try { await auth.loginWithApiKey(args[2]); } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
-      } else { console.error("Usage: blun auth --api-key <KEY>"); process.exit(1); }
+    case "whoami":
+      try { await auth.whoami(); } catch (e) { ui.renderResponse(e.message, "error"); }
       break;
 
     case "keys":
-      if (args[1] === "create") { try { await auth.createApiKey(args[2]); } catch (e) { ui.renderResponse(e.message, "error"); } }
-      else if (args[1] === "list") { try { await auth.listApiKeys(); } catch (e) { ui.renderResponse(e.message, "error"); } }
-      else { console.log("Usage: blun keys create | blun keys list"); }
+      if (args[1] === "create") {
+        try { await auth.createApiKey(args[2]); } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
+      } else if (args[1] === "list" || !args[1]) {
+        try { await auth.listApiKeys(); } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
+      } else {
+        console.error("Usage: blun keys [list|create]");
+        process.exit(1);
+      }
+      break;
+    case "settings": {
+      const chalk = require("chalk");
+      const s = auth.getSettings();
+      console.log(chalk.bold.cyan("\n  Current Settings:"));
+      console.log(chalk.white("  Model:    ") + (s.model || "auto"));
+      console.log(chalk.white("  Language: ") + (s.language || "de"));
+      console.log(chalk.white("  Voice:    ") + (s.voice ? "on" : "off"));
+      console.log("");
+      const action = await auth.promptMenu("Change Setting", [
+        { label: "Model", value: "model" },
+        { label: "Language (de/en)", value: "language" },
+        { label: "Voice on/off", value: "voice" },
+        { label: "Exit", value: "exit" }
+      ]);
+      if (action === "model") {
+        const m = await auth.promptMenu("Select Model", [
+          { label: "Auto", value: "auto" }, { label: "Gemma 4", value: "gemma4" },
+          { label: "Claude", value: "claude" }, { label: "Llama", value: "llama" }
+        ]);
+        if (m) { s.model = m; auth.saveSettings(s); console.log(chalk.green("  Model set to: " + m)); }
+      } else if (action === "language") {
+        const l = await auth.prompt(chalk.green("  Language (de/en): "));
+        if (l) { s.language = l; auth.saveSettings(s); console.log(chalk.green("  Language set to: " + l)); }
+      } else if (action === "voice") {
+        s.voice = !s.voice; auth.saveSettings(s); console.log(chalk.green("  Voice: " + (s.voice ? "on" : "off")));
+      }
+      break;
+    }
+
+    case "auth":
+      if (args[1] === "--api-key" && args[2]) {
+        try { await auth.loginWithApiKey(args[2]); } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
+      } else {
+        console.error("Usage: blun auth --api-key <KEY>");
+        process.exit(1);
+      }
       break;
 
     case "ask": {
       const question = args.slice(1).join(" ");
-      if (!question) { console.error("Usage: blun ask \"your question\""); process.exit(1); }
-      if (!auth.isAuthenticated()) { console.log("Not logged in. Starting auth..."); await auth.showWelcomeMenu(); }
+      if (!question) { console.error('Usage: blun ask \"your question\"'); process.exit(1); }
+      if (!auth.isAuthenticated()) {
+        ui.renderResponse("Not logged in. Run: blun login", "error"); process.exit(1);
+      }
+      const spinner = ui.renderSpinner("Thinking...");
       try {
-        const client = require("../lib/client");
-        const spinner = ui.renderSpinner("Thinking...");
         const res = await client.sendMessage(question);
         ui.stopSpinner(true);
-        const text = res.data?.response || res.data?.text || res.data?.message || JSON.stringify(res.data);
+        const text = (res.data && (res.data.response || res.data.text || res.data.message)) || JSON.stringify(res.data);
         ui.renderResponse(text, "agent");
-      } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
+      } catch (e) {
+        ui.stopSpinner(false);
+        ui.renderResponse(e.message, "error");
+        process.exit(1);
+      }
       break;
     }
 
     case "status":
       try {
-        const client = require("../lib/client");
         const spinner = ui.renderSpinner("Checking health...");
         const res = await client.getHealth();
         ui.stopSpinner(true);
         if (res.status === 200 && typeof res.data === "object") {
-          ui.renderTable(["Metric", "Value"], Object.entries(res.data).map(([k, v]) => [k, typeof v === "object" ? JSON.stringify(v) : String(v)]));
-        } else { ui.renderResponse("Health: " + res.status, "error"); }
-      } catch (e) { ui.renderResponse("Health failed: " + e.message, "error"); }
+          ui.renderTable(
+            ["Metric", "Value"],
+            Object.entries(res.data).map(([k, v]) => [k, typeof v === "object" ? JSON.stringify(v) : String(v)])
+          );
+        } else {
+          ui.renderResponse("Health check returned: " + res.status, "error");
+        }
+      } catch (e) {
+        ui.renderResponse("Health check failed: " + e.message, "error");
+        process.exit(1);
+      }
       break;
 
     case "init":
       workspace.initProject(process.cwd());
       break;
 
-    case "chat": default: {
-      ui.renderBanner();
-
-      // Auth check - show welcome menu if not authenticated
-      if (!auth.isAuthenticated()) {
-        await auth.showWelcomeMenu();
-      } else {
-        const creds = auth.getStoredCredentials();
-        const chalk = require("chalk");
-        console.log(chalk.green("  Logged in as " + (creds.name || creds.email) + " (" + creds.plan + ")\n"));
-      }
-
-      // Workspace trust flow
+    case "chat":
+    default: {
       let initialFolder = process.cwd();
       if (command !== "chat" && command !== undefined) {
-        try { const fs = require("fs"); const r = path.resolve(command); if (fs.existsSync(r) && fs.statSync(r).isDirectory()) initialFolder = r; } catch {}
+        try {
+          const fs = require("fs");
+          const resolved = path.resolve(command);
+          if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+            initialFolder = resolved;
+          }
+        } catch {}
       }
       if (args[1]) {
-        try { const fs = require("fs"); const r = path.resolve(args[1]); if (fs.existsSync(r) && fs.statSync(r).isDirectory()) initialFolder = r; } catch {}
+        try {
+          const fs = require("fs");
+          const resolved = path.resolve(args[1]);
+          if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+            initialFolder = resolved;
+          }
+        } catch {}
       }
 
       const trustedFolder = await workspace.selectFolder(initialFolder);
@@ -120,4 +181,4 @@ async function main() {
   }
 }
 
-main().catch(e => { console.error("Fatal:", e.message); process.exit(1); });
+main().catch((e) => { console.error("Fatal:", e.message); process.exit(1); });

package/lib/auth.js

@@ -1,103 +1,217 @@
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-const https = require("https");
-const readline = require("readline");
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const https = require('https');
+const readline = require('readline');
+const chalk = require('chalk');
 
-const CREDS_DIR = path.join(os.homedir(), ".blun");
-const CREDS_FILE = path.join(CREDS_DIR, "credentials.json");
-const BASE = "blun.ai";
+const CREDS_DIR = path.join(os.homedir(), '.blun');
+const CREDS_FILE = path.join(CREDS_DIR, 'credentials.json');
+const SETTINGS_FILE = path.join(CREDS_DIR, 'settings.json');
+const BASE_URL = 'blun.ai';
 
-function ensureDir() { if (!fs.existsSync(CREDS_DIR)) fs.mkdirSync(CREDS_DIR, { mode: 0o700, recursive: true }); }
-function saveCredentials(c) { ensureDir(); fs.writeFileSync(CREDS_FILE, JSON.stringify(c, null, 2), { mode: 0o600 }); }
+function ensureDir() {
+  if (!fs.existsSync(CREDS_DIR)) fs.mkdirSync(CREDS_DIR, { mode: 0o700, recursive: true });
+}
+function saveCredentials(creds) { ensureDir(); fs.writeFileSync(CREDS_FILE, JSON.stringify(creds, null, 2), { mode: 0o600 }); }
 function getStoredCredentials() {
-  try { if (!fs.existsSync(CREDS_FILE)) return null; const d = JSON.parse(fs.readFileSync(CREDS_FILE, "utf8")); if (d.expires_at && new Date(d.expires_at) < new Date()) return null; return d; } catch { return null; }
+  try {
+    if (!fs.existsSync(CREDS_FILE)) return null;
+    const data = JSON.parse(fs.readFileSync(CREDS_FILE, 'utf8'));
+    if (data.expires_at && new Date(data.expires_at) < new Date()) return null;
+    return data;
+  } catch { return null; }
+}
+function getSettings() {
+  try {
+    if (!fs.existsSync(SETTINGS_FILE)) return { model: 'auto', language: 'de', voice: false };
+    return JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'));
+  } catch { return { model: 'auto', language: 'de', voice: false }; }
 }
+function saveSettings(s) { ensureDir(); fs.writeFileSync(SETTINGS_FILE, JSON.stringify(s, null, 2)); }
 function isAuthenticated() { return getStoredCredentials() !== null; }
-function getAuthHeader() { const c = getStoredCredentials(); if (!c) return null; return c.apiKey ? { "x-blun-key": c.token } : { Authorization: "Bearer " + c.token }; }
-function ensureAuth() { if (!isAuthenticated()) throw new Error("Not authenticated."); return getStoredCredentials(); }
-
-function ask(q) { const rl = readline.createInterface({ input: process.stdin, output: process.stdout }); return new Promise(r => rl.question(q, a => { rl.close(); r(a.trim()); })); }
+function getAuthHeader() {
+  const c = getStoredCredentials(); if (!c) return null;
+  if (c.apiKey) return { 'x-blun-key': c.apiKey };
+  return { Authorization: 'Bearer ' + c.token };
+}
+function ensureAuth() {
+  if (!isAuthenticated()) throw new Error('Not authenticated. Run "blun login" first.');
+  return getStoredCredentials();
+}
 
-function httpsReq(opts, body) {
+function httpsRequest(options, body) {
   return new Promise((resolve, reject) => {
-    const req = https.request(opts, res => { let d = ""; res.on("data", c => d += c); res.on("end", () => { try { resolve({ status: res.statusCode, data: JSON.parse(d) }); } catch { resolve({ status: res.statusCode, data: d }); } }); });
-    req.on("error", reject); if (body) req.write(JSON.stringify(body)); req.end();
+    const req = https.request(options, (res) => {
+      let data = ''; res.on('data', c => data += c);
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, data: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode, data }); }
+      });
+    }); req.on('error', reject);
+    if (body) req.write(JSON.stringify(body)); req.end();
+  });
+}
+
+function prompt(question) {
+  return new Promise(resolve => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, a => { rl.close(); resolve(a.trim()); });
   });
 }
 
+function promptPassword(question) {
+  return new Promise(resolve => {
+    process.stdout.write(question); let pw = '';
+    const stdin = process.stdin; const wasRaw = stdin.isRaw;
+    if (stdin.setRawMode) stdin.setRawMode(true); stdin.resume();
+    const onData = (ch) => {
+      const c = ch.toString('utf8');
+      if (c === '\n' || c === '\r' || c === '\u0004') {
+        if (stdin.setRawMode) stdin.setRawMode(wasRaw || false);
+        stdin.removeListener('data', onData); process.stdout.write('\n'); resolve(pw);
+      } else if (c === '\u007f' || c === '\b') {
+        if (pw.length > 0) { pw = pw.slice(0, -1); process.stdout.write('\b \b'); }
+      } else if (c === '\u0003') { process.exit(0); }
+      else { pw += c; process.stdout.write('*'); }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+async function promptMenu(title, options) {
+  console.log(''); console.log(chalk.bold.cyan('  ' + title));
+  console.log(chalk.dim('  ' + '\u2500'.repeat(40)));
+  options.forEach((opt, i) => console.log(chalk.yellow('  ' + (i + 1) + ')') + ' ' + opt.label));
+  console.log('');
+  const answer = await prompt(chalk.green('  > '));
+  const idx = parseInt(answer, 10) - 1;
+  return (idx >= 0 && idx < options.length) ? options[idx].value : null;
+}
 async function login() {
-  const chalk = require("chalk");
-  console.log(chalk.cyan.bold("\n  BLUN Login\n"));
-  const email = await ask(chalk.white("  Email: "));
-  const password = await ask(chalk.white("  Password: "));
-  if (!email || !password) throw new Error("Email and password required.");
-  const res = await httpsReq({ hostname: BASE, path: "/api/king/auth/login", method: "POST", headers: { "Content-Type": "application/json" } }, { email, password });
-  if (res.status !== 200 || !res.data.token) throw new Error(res.data.error || res.data.message || "Login failed.");
-  const creds = { token: res.data.token, email: res.data.email || email, name: res.data.name || "", plan: res.data.plan || "free" };
+  console.log(chalk.bold.cyan('\n  BLUN Login\n'));
+  const email = await prompt(chalk.green('  Email: '));
+  const password = await promptPassword(chalk.green('  Password: '));
+  if (!email || !password) throw new Error('Email and password required.');
+  const res = await httpsRequest({
+    hostname: BASE_URL, path: '/api/king/auth/login',
+    method: 'POST', headers: { 'Content-Type': 'application/json' }
+  }, { email, password });
+  if (res.status !== 200 || !res.data.token) {
+    throw new Error('Login failed: ' + (res.data.message || res.data.error || JSON.stringify(res.data)));
+  }
+  const creds = {
+    token: res.data.token, email: res.data.email || email,
+    name: res.data.name || (res.data.user ? res.data.user.name : '') || '',
+    plan: res.data.plan || (res.data.user ? res.data.user.plan : '') || 'free'
+  };
   saveCredentials(creds);
-  console.log(chalk.green("\n  Login successful! Welcome, " + (creds.name || creds.email)));
+  console.log(chalk.green('\n  Login successful! Welcome, ' + (creds.name || creds.email)));
   return creds;
 }
 
 async function register() {
-  const chalk = require("chalk");
-  console.log(chalk.cyan.bold("\n  BLUN Registration\n"));
-  const name = await ask(chalk.white("  Name: "));
-  const email = await ask(chalk.white("  Email: "));
-  const password = await ask(chalk.white("  Password: "));
-  if (!email || !password || !name) throw new Error("All fields required.");
-  const res = await httpsReq({ hostname: BASE, path: "/api/king/auth/register", method: "POST", headers: { "Content-Type": "application/json" } }, { name, email, password });
-  if (res.status !== 200 && res.status !== 201) throw new Error(res.data.error || "Registration failed.");
-  if (res.data.token) { saveCredentials({ token: res.data.token, email, name, plan: "free" }); console.log(chalk.green("\n  Account created! You are logged in.")); }
-  else console.log(chalk.green("\n  Account created! Run: blun login"));
+  console.log(chalk.bold.cyan('\n  BLUN Registration\n'));
+  const name = await prompt(chalk.green('  Name: '));
+  const email = await prompt(chalk.green('  Email: '));
+  const password = await promptPassword(chalk.green('  Password: '));
+  if (!email || !password || !name) throw new Error('Name, email and password required.');
+  const res = await httpsRequest({
+    hostname: BASE_URL, path: '/api/king/auth/register',
+    method: 'POST', headers: { 'Content-Type': 'application/json' }
+  }, { name, email, password });
+  if (res.status !== 200 && res.status !== 201) {
+    throw new Error('Registration failed: ' + (res.data.message || res.data.error || JSON.stringify(res.data)));
+  }
+  if (res.data.token) {
+    const creds = { token: res.data.token, email: res.data.email || email, name: res.data.name || name, plan: res.data.plan || 'free' };
+    saveCredentials(creds); console.log(chalk.green('\n  Account created! Welcome, ' + name)); return creds;
+  }
+  console.log(chalk.green('\n  Account created! Please login with: blun login')); return null;
 }
 
 async function loginWithApiKey(apiKey) {
-  const chalk = require("chalk");
-  console.log(chalk.cyan("  Validating API key..."));
-  const res = await httpsReq({ hostname: BASE, path: "/api/king/auth/me", method: "GET", headers: { "x-blun-key": apiKey } });
-  if (res.status !== 200) throw new Error("Invalid API key.");
-  saveCredentials({ token: apiKey, apiKey: true, email: res.data.email || "", name: res.data.name || "", plan: res.data.plan || "free" });
-  console.log(chalk.green("  API key saved!"));
+  console.log(chalk.dim('  Validating API key...'));
+  const res = await httpsRequest({ hostname: BASE_URL, path: '/api/king/auth/me', method: 'GET', headers: { 'x-blun-key': apiKey } });
+  if (res.status !== 200) throw new Error('Invalid API key: ' + (res.data.message || 'validation failed'));
+  const creds = { apiKey, token: apiKey, email: res.data.email || '', name: res.data.name || '', plan: res.data.plan || 'free' };
+  saveCredentials(creds); console.log(chalk.green('  API key validated and saved.')); return creds;
 }
 
-async function createApiKey(keyName) {
-  const chalk = require("chalk"); const c = ensureAuth();
-  const name = keyName || await ask(chalk.white("  Key name: "));
-  const h = c.apiKey ? { "x-blun-key": c.token, "Content-Type": "application/json" } : { Authorization: "Bearer " + c.token, "Content-Type": "application/json" };
-  const res = await httpsReq({ hostname: BASE, path: "/api/king/auth/api-keys", method: "POST", headers: h }, { name });
-  if (res.status !== 200 && res.status !== 201) throw new Error(res.data.error || "Failed.");
-  console.log(chalk.green("\n  API Key created:")); console.log(chalk.yellow("  " + (res.data.api_key || res.data.apiKey || res.data.key)));
+async function createApiKey(name) {
+  ensureAuth();
+  const keyName = name || await prompt(chalk.green('  Key name: '));
+  const headers = { 'Content-Type': 'application/json' };
+  const ah = getAuthHeader(); if (ah) Object.assign(headers, ah);
+  const res = await httpsRequest({ hostname: BASE_URL, path: '/api/king/auth/api-keys', method: 'POST', headers }, { name: keyName });
+  if (res.status !== 200 && res.status !== 201) throw new Error('Failed to create key: ' + (res.data.message || JSON.stringify(res.data)));
+  console.log(chalk.green('\n  API Key created:'));
+  console.log(chalk.yellow('  ' + (res.data.key || res.data.apiKey || JSON.stringify(res.data))));
+  console.log(chalk.dim('  Save this key - it will not be shown again.\n'));
+  return res.data;
 }
-
 async function listApiKeys() {
-  const chalk = require("chalk"); const c = ensureAuth();
-  const h = c.apiKey ? { "x-blun-key": c.token } : { Authorization: "Bearer " + c.token };
-  const res = await httpsReq({ hostname: BASE, path: "/api/king/auth/api-keys", method: "GET", headers: h });
-  if (res.status !== 200) throw new Error("Failed.");
-  const keys = res.data.api_keys || [];
-  if (!keys.length) console.log(chalk.dim("\n  No API keys. Create: blun keys create"));
-  else { console.log(chalk.cyan.bold("\n  Your API Keys:")); keys.forEach((k, i) => console.log("  " + (i+1) + ". " + (k.name || k.id || "unnamed"))); }
+  ensureAuth();
+  const headers = {}; const ah = getAuthHeader(); if (ah) Object.assign(headers, ah);
+  const res = await httpsRequest({ hostname: BASE_URL, path: '/api/king/auth/api-keys', method: 'GET', headers });
+  if (res.status !== 200) throw new Error('Failed to list keys: ' + (res.data.message || JSON.stringify(res.data)));
+  const keys = res.data.keys || res.data || [];
+  if (keys.length === 0) { console.log(chalk.dim('\n  No API keys found. Create one with: blun keys create\n')); }
+  else {
+    console.log(chalk.bold.cyan('\n  Your API Keys:\n'));
+    keys.forEach((k, i) => console.log(chalk.yellow('  ' + (i+1) + ') ') + chalk.white(k.name || 'unnamed') + chalk.dim(' - ' + (k.prefix || k.id || '***'))));
+    console.log('');
+  }
+  return keys;
+}
+
+async function whoami() {
+  const creds = getStoredCredentials();
+  if (!creds) { console.log(chalk.dim('\n  Not logged in.\n')); return null; }
+  const headers = {}; const ah = getAuthHeader(); if (ah) Object.assign(headers, ah);
+  const res = await httpsRequest({ hostname: BASE_URL, path: '/api/king/auth/me', method: 'GET', headers });
+  if (res.status === 200) {
+    console.log(chalk.bold.cyan('\n  Current User:'));
+    console.log(chalk.white('  Name:  ') + (res.data.name || creds.name || '-'));
+    console.log(chalk.white('  Email: ') + (res.data.email || creds.email || '-'));
+    console.log(chalk.white('  Plan:  ') + (res.data.plan || creds.plan || 'free'));
+    console.log(''); return res.data;
+  } else {
+    console.log(chalk.yellow('\n  Stored: ') + (creds.name || creds.email || '-'));
+    console.log(''); return creds;
+  }
 }
 
 async function showWelcomeMenu() {
-  const chalk = require("chalk");
-  console.log(chalk.cyan.bold("\n  Welcome to BLUN CLI!\n"));
-  console.log(chalk.white("  1. Login (email + password)"));
-  console.log(chalk.white("  2. Register new account"));
-  console.log(chalk.white("  3. Enter API Key"));
-  console.log(chalk.white("  4. Continue without auth (local mode)"));
-  console.log(chalk.white("  5. Exit\n"));
-  const choice = await ask(chalk.cyan("  Choice [1-5]: "));
-  if (choice === "1") { await login(); return true; }
-  if (choice === "2") { await register(); return true; }
-  if (choice === "3") { const key = await ask(chalk.white("  API Key: ")); await loginWithApiKey(key); return true; }
-  if (choice === "4") { console.log(chalk.yellow("  Running in local mode (limited features).")); return true; }
-  if (choice === "5") { process.exit(0); }
-  console.log(chalk.red("  Invalid choice.")); return await showWelcomeMenu();
+  const choice = await promptMenu('Welcome to BLUN CLI!', [
+    { label: 'Login (email + password)', value: 'login' },
+    { label: 'Register new account', value: 'register' },
+    { label: 'Enter API Key', value: 'apikey' },
+    { label: 'Continue without auth (local mode)', value: 'local' },
+    { label: 'Exit', value: 'exit' }
+  ]);
+  switch (choice) {
+    case 'login': try { await login(); return true; } catch(e) { console.log(chalk.red('  ' + e.message)); return false; }
+    case 'register': try { await register(); return true; } catch(e) { console.log(chalk.red('  ' + e.message)); return false; }
+    case 'apikey': {
+      const key = await prompt(chalk.green('  API Key: '));
+      try { await loginWithApiKey(key); return true; } catch(e) { console.log(chalk.red('  ' + e.message)); return false; }
+    }
+    case 'local': console.log(chalk.yellow('\n  Running in local mode (limited functionality)\n')); return 'local';
+    case 'exit': process.exit(0);
+    default: return false;
+  }
 }
 
-function logout() { try { if (fs.existsSync(CREDS_FILE)) fs.unlinkSync(CREDS_FILE); console.log("  Logged out."); } catch (e) { throw new Error("Logout failed: " + e.message); } }
+function logout() {
+  try { if (fs.existsSync(CREDS_FILE)) fs.unlinkSync(CREDS_FILE); console.log(chalk.green('  Logged out.')); }
+  catch (e) { throw new Error('Failed to logout: ' + e.message); }
+}
 
-module.exports = { login, register, loginWithApiKey, logout, createApiKey, listApiKeys, getStoredCredentials, isAuthenticated, getAuthHeader, ensureAuth, showWelcomeMenu };
+module.exports = {
+  login, register, loginWithApiKey, logout,
+  getStoredCredentials, isAuthenticated, getAuthHeader, ensureAuth,
+  createApiKey, listApiKeys, whoami,
+  showWelcomeMenu, promptMenu, prompt,
+  getSettings, saveSettings
+};

package/lib/chat.js

@@ -1,25 +1,37 @@
 const readline = require('readline');
+const chalk = require('chalk');
 const ui = require('./ui');
 const auth = require('./auth');
 const client = require('./client');
 
+let localMode = false;
+
 async function startChat() {
   ui.renderBanner();
 
-  try {
-    auth.ensureAuth();
-  } catch (e) {
-    ui.renderResponse(e.message, 'error');
-    process.exit(1);
+  if (!auth.isAuthenticated()) {
+    const result = await auth.showWelcomeMenu();
+    if (result === false) {
+      console.log(chalk.yellow('  Auth failed. Showing menu again...\n'));
+      const retry = await auth.showWelcomeMenu();
+      if (retry === false) { process.exit(1); }
+      if (retry === 'local') localMode = true;
+    }
+    if (result === 'local') localMode = true;
   }
 
   const creds = auth.getStoredCredentials();
-  ui.renderResponse('Connected as ' + (creds.name || creds.email || 'user') + ' | Plan: ' + (creds.plan || 'free'), 'system');
+  if (creds) {
+    ui.renderResponse('Connected as ' + (creds.name || creds.email || 'user') + ' | Plan: ' + (creds.plan || 'free'), 'system');
+  } else if (localMode) {
+    ui.renderResponse('Local mode - no API calls available', 'system');
+  }
 
+  const settings = auth.getSettings();
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: ui.renderPrompt(creds.name || 'user', 'auto'),
+    prompt: ui.renderPrompt((creds ? creds.name : null) || 'local', settings.model || 'auto'),
     terminal: true
   });
 
@@ -31,47 +43,97 @@ async function startChat() {
     if (!input) { rl.prompt(); return; }
 
     if (input === '/exit' || input === '/quit') {
-      ui.renderResponse('Goodbye!', 'system');
-      process.exit(0);
+      ui.renderResponse('Goodbye!', 'system'); process.exit(0);
+    }
+    if (input === '/clear') { console.clear(); ui.renderBanner(); rl.prompt(); return; }
+    if (input === '/status') { ui.renderStatusBar(ui.getStats()); rl.prompt(); return; }
+    if (input === '/login') {
+      try { await auth.login(); localMode = false; ui.renderResponse('Logged in!', 'system'); }
+      catch(e) { ui.renderResponse(e.message, 'error'); }
+      rl.prompt(); return;
     }
-    if (input === '/clear') {
-      console.clear();
-      ui.renderBanner();
-      rl.prompt();
-      return;
+    if (input === '/whoami') {
+      try { await auth.whoami(); } catch(e) { ui.renderResponse(e.message, 'error'); }
+      rl.prompt(); return;
     }
-    if (input === '/status') {
-      ui.renderStatusBar(ui.getStats());
-      rl.prompt();
-      return;
+    if (input === '/keys') {
+      try { await auth.listApiKeys(); } catch(e) { ui.renderResponse(e.message, 'error'); }
+      rl.prompt(); return;
+    }    if (input === '/model') {
+      const s = auth.getSettings();
+      const choice = await auth.promptMenu('Select Model', [
+        { label: 'Auto (recommended)', value: 'auto' },
+        { label: 'Gemma 4', value: 'gemma4' },
+        { label: 'Claude', value: 'claude' },
+        { label: 'Llama', value: 'llama' }
+      ]);
+      if (choice) { s.model = choice; auth.saveSettings(s); ui.renderResponse('Model set to: ' + choice, 'system'); }
+      rl.prompt(); return;
+    }
+    if (input === '/settings') {
+      const s = auth.getSettings();
+      console.log(chalk.bold.cyan('\n  Current Settings:'));
+      console.log(chalk.white('  Model:    ') + (s.model || 'auto'));
+      console.log(chalk.white('  Language: ') + (s.language || 'de'));
+      console.log(chalk.white('  Voice:    ') + (s.voice ? 'on' : 'off'));
+      console.log('');
+      const action = await auth.promptMenu('Change Setting', [
+        { label: 'Model', value: 'model' },
+        { label: 'Language (de/en)', value: 'language' },
+        { label: 'Voice on/off', value: 'voice' },
+        { label: 'Back', value: 'back' }
+      ]);
+      if (action === 'model') {
+        const m = await auth.promptMenu('Select Model', [
+          { label: 'Auto', value: 'auto' }, { label: 'Gemma 4', value: 'gemma4' },
+          { label: 'Claude', value: 'claude' }, { label: 'Llama', value: 'llama' }
+        ]);
+        if (m) { s.model = m; auth.saveSettings(s); ui.renderResponse('Model: ' + m, 'system'); }
+      } else if (action === 'language') {
+        const l = await auth.prompt(chalk.green('  Language (de/en): '));
+        if (l) { s.language = l; auth.saveSettings(s); ui.renderResponse('Language: ' + l, 'system'); }
+      } else if (action === 'voice') {
+        s.voice = !s.voice; auth.saveSettings(s); ui.renderResponse('Voice: ' + (s.voice ? 'on' : 'off'), 'system');
+      }
+      rl.prompt(); return;
     }
     if (input === '/help') {
       ui.renderBox('Chat Commands', [
-        '/exit   - Exit chat',
-        '/clear  - Clear screen',
-        '/status - Show token usage & uptime',
-        '/help   - Show this help'
+        '/exit      Exit chat',
+        '/clear     Clear screen',
+        '/status    Show token usage & uptime',
+        '/login     Login from chat',
+        '/whoami    Show current user info',
+        '/keys      List API keys',
+        '/model     Switch AI model',
+        '/settings  Show/change settings',
+        '/help      Show this help'
       ].join('\n'), 'cyan');
-      rl.prompt();
-      return;
+      rl.prompt(); return;
+    }
+
+    if (localMode) {
+      ui.renderResponse('Local mode - cannot send messages. Use /login to authenticate.', 'error');
+      rl.prompt(); return;
     }
 
     const spinner = ui.renderSpinner('Thinking...');
     try {
-      const res = await client.sendMessage(input);
+      const settings = auth.getSettings();
+      const res = await client.sendMessage(input, { model: settings.model || 'auto' });
       ui.stopSpinner(true, 'Response received');
       if (res.status === 200 && res.data) {
         const text = res.data.response || res.data.text || res.data.message || JSON.stringify(res.data);
         ui.renderResponse(text, 'agent');
-        if (res.data.usage) {
-          ui.addTokens(res.data.usage.total_tokens || 0, 0.000003);
-        }
+        if (res.data.usage) ui.addTokens(res.data.usage.total_tokens || 0, 0.000003);
+      } else if (res.status === 401 || res.status === 403) {
+        ui.renderResponse('Auth error. Use /login to re-authenticate.', 'error');
       } else {
         ui.renderResponse('Error: ' + JSON.stringify(res.data), 'error');
       }
     } catch (e) {
       ui.stopSpinner(false, e.message);
-      ui.renderResponse('Request failed: ' + e.message, 'error');
+      ui.renderResponse('Request failed: ' + e.message + '\n  Try /login if auth expired.', 'error');
     }
     rl.prompt();
   });
@@ -79,4 +141,4 @@ async function startChat() {
   rl.on('close', () => { console.log(''); process.exit(0); });
 }
 
-module.exports = { startChat };
+module.exports = { startChat };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "6.2.0",
+  "version": "6.2.1",
   "description": "BLUN AI Assistant - Command Line Interface",
   "bin": { "blun": "./bin/blun.js" },
   "files": ["bin/", "lib/", "README.md"],