blun-king-cli 6.1.0 → 6.2.0

package/bin/blun.js

@@ -1,38 +1,35 @@
 #!/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/cli v" + pkg.version);
+    case "version": case "--version": case "-v":
+      console.log("blun-king-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 (default)",
-        "blun chat          Interactive chat mode",
-        "blun ask \"...\"     One-shot question",
-        "blun login         Device login flow",
-        "blun logout        Remove stored credentials",
-        "blun auth --api-key KEY   Authenticate with API key",
-        "blun status        Show system health",
-        "blun init           Initialize BLUN project in current dir",
-        "blun version       Show version",
-        "blun help          Show this help"
+        "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"
       ].join("\n"), "cyan");
       break;
 
@@ -40,6 +37,10 @@ async function main() {
       try { await auth.login(); } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
       break;
 
+    case "register":
+      try { await auth.register(); } catch (e) { ui.renderResponse(e.message, "error"); process.exit(1); }
+      break;
+
     case "logout":
       auth.logout();
       break;
@@ -47,79 +48,67 @@ async function main() {
     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);
-      }
+      } else { console.error("Usage: blun auth --api-key <KEY>"); process.exit(1); }
+      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"); }
       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(); }
       try {
-        auth.ensureAuth();
+        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);
         ui.renderResponse(text, "agent");
-      } catch (e) {
-        ui.renderResponse(e.message, "error");
-        process.exit(1);
-      }
+      } catch (e) { 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") {
-          const d = res.data;
-          ui.renderTable(
-            ["Metric", "Value"],
-            Object.entries(d).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);
-      }
+          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"); }
       break;
 
     case "init":
       workspace.initProject(process.cwd());
       break;
 
-    case "chat":
-    default: {
-      // Determine initial folder: path arg or cwd
+    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
       let initialFolder = process.cwd();
       if (command !== "chat" && command !== undefined) {
-        // default case — command might be a path
-        try {
-          const fs = require("fs");
-          const resolved = path.resolve(command);
-          if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-            initialFolder = resolved;
-          }
-        } catch {}
+        try { const fs = require("fs"); const r = path.resolve(command); if (fs.existsSync(r) && fs.statSync(r).isDirectory()) initialFolder = r; } catch {}
       }
-      // Also check args[1] for "blun chat /path"
       if (args[1]) {
-        try {
-          const fs = require("fs");
-          const resolved = path.resolve(args[1]);
-          if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
-            initialFolder = resolved;
-          }
-        } catch {}
+        try { const fs = require("fs"); const r = path.resolve(args[1]); if (fs.existsSync(r) && fs.statSync(r).isDirectory()) initialFolder = r; } catch {}
       }
 
-      // Workspace trust flow
       const trustedFolder = await workspace.selectFolder(initialFolder);
       process.chdir(trustedFolder);
       workspace.loadProjectConfig(trustedFolder);
@@ -131,4 +120,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,162 +1,103 @@
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-const https = require('https');
-const { execSync } = require('child_process');
-
-const CREDS_DIR = path.join(os.homedir(), '.blun');
-const CREDS_FILE = path.join(CREDS_DIR, 'credentials.json');
-const BASE_URL = 'blun.ai';
-
-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 });
-}
-
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+const https = require("https");
+const readline = require("readline");
+
+const CREDS_DIR = path.join(os.homedir(), ".blun");
+const CREDS_FILE = path.join(CREDS_DIR, "credentials.json");
+const BASE = "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 getStoredCredentials() {
-  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()) {
-      console.error('[BLUN Auth] Token expired. Please run: blun login');
-      return null;
-    }
-    return data;
-  } catch { return null; }
+  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; }
 }
+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 isAuthenticated() {
-  return getStoredCredentials() !== null;
-}
+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 creds = getStoredCredentials();
-  if (!creds) return null;
-  return { Authorization: 'Bearer ' + creds.token };
-}
-
-function ensureAuth() {
-  if (!isAuthenticated()) {
-    throw new Error('Not authenticated. Run "blun login" or "blun auth --api-key <key>" first.');
-  }
-  return getStoredCredentials();
-}
-
-function httpsRequest(options, body) {
+function httpsReq(opts, body) {
   return new Promise((resolve, reject) => {
-    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();
+    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();
   });
 }
 
-function openBrowser(url) {
-  try {
-    const platform = process.platform;
-    if (platform === 'win32') execSync('start "" "' + url + '"', { stdio: 'ignore' });
-    else if (platform === 'darwin') execSync('open "' + url + '"', { stdio: 'ignore' });
-    else execSync('xdg-open "' + url + '"', { stdio: 'ignore' });
-  } catch {
-    console.log('Open this URL manually: ' + url);
-  }
-}
-
 async function login() {
-  console.log('[BLUN Auth] Starting device login flow...');
-  const startRes = await httpsRequest({
-    hostname: BASE_URL, path: '/api/king/auth/device/start',
-    method: 'POST', headers: { 'Content-Type': 'application/json' }
-  });
-
-  if (startRes.status !== 200 || !startRes.data.code) {
-    throw new Error('Failed to start device flow: ' + JSON.stringify(startRes.data));
-  }
-
-  const { code, verification_url } = startRes.data;
-  const url = verification_url || 'https://blun.ai/api/king/auth/device/start';
-
-  console.log('');
-  console.log('  Enter this code in your browser: ' + code);
-  console.log('  URL: ' + url);
-  console.log('');
-
-  openBrowser(url);
-  console.log('Waiting for approval...');
-
-  const maxAttempts = 120;
-  for (let i = 0; i < maxAttempts; i++) {
-    await new Promise(r => setTimeout(r, 2000));
-    const pollRes = await httpsRequest({
-      hostname: BASE_URL,
-      path: '/api/king/auth/device/poll?code=' + encodeURIComponent(code),
-      method: 'GET'
-    });
-
-    if (pollRes.status === 200 && pollRes.data.token) {
-      const creds = {
-        token: pollRes.data.token,
-        email: pollRes.data.email || '',
-        name: pollRes.data.name || '',
-        expires_at: pollRes.data.expires_at || '',
-        plan: pollRes.data.plan || 'free'
-      };
-      saveCredentials(creds);
-      console.log('[BLUN Auth] Login successful! Welcome, ' + (creds.name || creds.email || 'user'));
-      return creds;
-    }
+  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" };
+  saveCredentials(creds);
+  console.log(chalk.green("\n  Login successful! Welcome, " + (creds.name || creds.email)));
+  return creds;
+}
 
-    if (pollRes.data.status === 'denied' || pollRes.data.error === 'denied') {
-      throw new Error('Login denied by user.');
-    }
-  }
-  throw new Error('Login timed out after 4 minutes.');
+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"));
 }
 
 async function loginWithApiKey(apiKey) {
-  console.log('[BLUN Auth] Validating API key...');
-  const res = await httpsRequest({
-    hostname: BASE_URL, path: '/api/king/auth/validate',
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json', Authorization: 'Bearer ' + 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!"));
+}
 
-  if (res.status !== 200 || !res.data.valid) {
-    throw new Error('Invalid API key: ' + (res.data.message || 'validation failed'));
-  }
+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)));
+}
 
-  const creds = {
-    token: apiKey,
-    email: res.data.email || '',
-    name: res.data.name || '',
-    expires_at: res.data.expires_at || '',
-    plan: res.data.plan || 'free'
-  };
-  saveCredentials(creds);
-  console.log('[BLUN Auth] API key validated and saved.');
-  return creds;
+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"))); }
 }
 
-function logout() {
-  try {
-    if (fs.existsSync(CREDS_FILE)) fs.unlinkSync(CREDS_FILE);
-    console.log('[BLUN Auth] Logged out. Credentials removed.');
-  } catch (e) {
-    throw new Error('Failed to logout: ' + e.message);
-  }
+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();
 }
 
-module.exports = { login, loginWithApiKey, logout, getStoredCredentials, isAuthenticated, getAuthHeader, ensureAuth };
+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); } }
+
+module.exports = { login, register, loginWithApiKey, logout, createApiKey, listApiKeys, getStoredCredentials, isAuthenticated, getAuthHeader, ensureAuth, showWelcomeMenu };

package/lib/auth_test.js

@@ -0,0 +1,11 @@
+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 SETTINGS_FILE = path.join(CREDS_DIR, 'settings.json');
+const BASE_URL = 'blun.ai';

package/package.json

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