blun-king-cli 5.3.7 → 6.0.0

package/bin/blun.js

@@ -0,0 +1,100 @@
+#!/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');
+
+  switch (command) {
+    case 'version':
+    case '--version':
+    case '-v':
+      console.log('@blun/cli v' + pkg.version);
+      break;
+
+    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 version       Show version',
+        'blun help          Show this help'
+      ].join('\n'), 'cyan');
+      break;
+
+    case 'login':
+      try { await auth.login(); } catch (e) { ui.renderResponse(e.message, 'error'); process.exit(1); }
+      break;
+
+    case 'logout':
+      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);
+      }
+      break;
+
+    case 'ask': {
+      const question = args.slice(1).join(' ');
+      if (!question) { console.error('Usage: blun ask "your question"'); process.exit(1); }
+      try {
+        auth.ensureAuth();
+        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);
+      }
+      break;
+    }
+
+    case 'status':
+      try {
+        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);
+      }
+      break;
+
+    case 'chat':
+    default: {
+      const { startChat } = require('../lib/chat');
+      await startChat();
+      break;
+    }
+  }
+}
+
+main().catch((e) => { console.error('Fatal:', e.message); process.exit(1); });

package/lib/auth.js

@@ -0,0 +1,162 @@
+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 });
+}
+
+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; }
+}
+
+function isAuthenticated() {
+  return getStoredCredentials() !== null;
+}
+
+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) {
+  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();
+  });
+}
+
+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;
+    }
+
+    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 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 }
+  });
+
+  if (res.status !== 200 || !res.data.valid) {
+    throw new Error('Invalid API key: ' + (res.data.message || 'validation failed'));
+  }
+
+  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;
+}
+
+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);
+  }
+}
+
+module.exports = { login, loginWithApiKey, logout, getStoredCredentials, isAuthenticated, getAuthHeader, ensureAuth };

package/lib/chat.js

@@ -0,0 +1,82 @@
+const readline = require('readline');
+const ui = require('./ui');
+const auth = require('./auth');
+const client = require('./client');
+
+async function startChat() {
+  ui.renderBanner();
+
+  try {
+    auth.ensureAuth();
+  } catch (e) {
+    ui.renderResponse(e.message, 'error');
+    process.exit(1);
+  }
+
+  const creds = auth.getStoredCredentials();
+  ui.renderResponse('Connected as ' + (creds.name || creds.email || 'user') + ' | Plan: ' + (creds.plan || 'free'), 'system');
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: ui.renderPrompt(creds.name || 'user', 'auto'),
+    terminal: true
+  });
+
+  console.log('  Type /help for commands, /exit to quit.\n');
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    const input = line.trim();
+    if (!input) { rl.prompt(); return; }
+
+    if (input === '/exit' || input === '/quit') {
+      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 === '/help') {
+      ui.renderBox('Chat Commands', [
+        '/exit   - Exit chat',
+        '/clear  - Clear screen',
+        '/status - Show token usage & uptime',
+        '/help   - Show this help'
+      ].join('\n'), 'cyan');
+      rl.prompt();
+      return;
+    }
+
+    const spinner = ui.renderSpinner('Thinking...');
+    try {
+      const res = await client.sendMessage(input);
+      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);
+        }
+      } else {
+        ui.renderResponse('Error: ' + JSON.stringify(res.data), 'error');
+      }
+    } catch (e) {
+      ui.stopSpinner(false, e.message);
+      ui.renderResponse('Request failed: ' + e.message, 'error');
+    }
+    rl.prompt();
+  });
+
+  rl.on('close', () => { console.log(''); process.exit(0); });
+}
+
+module.exports = { startChat };

package/lib/client.js

@@ -0,0 +1,65 @@
+const https = require('https');
+const auth = require('./auth');
+
+const BASE_HOST = 'blun.ai';
+
+function request(method, urlPath, body) {
+  return new Promise((resolve, reject) => {
+    const authHeader = auth.getAuthHeader() || {};
+    const headers = { 'Content-Type': 'application/json', ...authHeader };
+    const req = https.request({ hostname: BASE_HOST, path: urlPath, method, headers }, (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();
+  });
+}
+
+async function sendMessage(message, options) {
+  options = options || {};
+  const body = { message, model: options.model || 'auto', stream: false };
+  return request('POST', '/api/king/chat', body);
+}
+
+async function sendMessageStream(message, options) {
+  options = options || {};
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ message, model: options.model || 'auto', stream: true });
+    const authHeader = auth.getAuthHeader() || {};
+    const headers = { 'Content-Type': 'application/json', ...authHeader };
+    const req = https.request({ hostname: BASE_HOST, path: '/api/king/chat', method: 'POST', headers }, (res) => {
+      let fullText = '';
+      res.on('data', (chunk) => {
+        const lines = chunk.toString().split('\n');
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            try {
+              const parsed = JSON.parse(line.slice(6));
+              if (parsed.text) {
+                fullText += parsed.text;
+                if (options.onChunk) options.onChunk(parsed.text);
+              }
+              if (parsed.usage && options.onUsage) options.onUsage(parsed.usage);
+            } catch {}
+          }
+        }
+      });
+      res.on('end', () => resolve({ text: fullText }));
+    });
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+async function getHealth() {
+  return request('GET', '/api/monitoring/health');
+}
+
+module.exports = { sendMessage, sendMessageStream, getHealth };

package/lib/ui.js

@@ -0,0 +1,215 @@
+/**
+ * BLUN King CLI - Rich Terminal UI Module
+ * Task 11: Claude Code-style terminal experience
+ * CommonJS - chalk@4, ora@5, boxen@5
+ */
+
+var chalk = require("chalk");
+var ora = require("ora");
+var Table = require("cli-table3");
+var boxen = require("boxen");
+var gradient = require("gradient-string");
+var figlet = require("figlet");
+
+var activeSpinner = null;
+var startTime = Date.now();
+var totalTokens = 0;
+var totalCost = 0;
+
+var colors = {
+  user: chalk.cyan,
+  agent: chalk.green,
+  system: chalk.yellow,
+  error: chalk.red,
+  dim: chalk.gray,
+  accent: chalk.magenta,
+  bold: chalk.bold,
+  code: chalk.bgGray.white,
+};
+
+function renderBanner() {
+  var art;
+  try {
+    art = figlet.textSync("BLUN King", { font: "ANSI Shadow", horizontalLayout: "fitted" });
+  } catch (e) {
+    art = figlet.textSync("BLUN King", { font: "Standard" });
+  }
+  console.log(gradient.pastel.multiline(art));
+  console.log(chalk.dim("  " + "\u2500".repeat(53)));
+  console.log(
+    chalk.dim("  ") +
+      chalk.bold.white("BLUN King CLI") +
+      chalk.dim(" \u2502 ") +
+      chalk.green("v5.7.0") +
+      chalk.dim(" \u2502 ") +
+      chalk.yellow("Multi-KI Engine")
+  );
+  console.log(chalk.dim("  " + "\u2500".repeat(53) + "\n"));
+}
+
+function renderPrompt(username, model) {
+  var u = chalk.cyan.bold(username || "user");
+  var m = chalk.dim("[" + (model || "auto") + "]");
+  return chalk.dim("\u250c") + " " + u + " " + m + "\n" + chalk.dim("\u2514") + " " + chalk.green.bold("\u276f") + " ";
+}
+
+function renderResponse(text, type) {
+  var colorFn = colors[type] || colors.agent;
+  var labels = { user: "YOU", agent: "BLUN", system: "SYS", error: "ERR" };
+  var label = labels[type] || "BLUN";
+  var prefix = colorFn.bold("  [" + label + "] ");
+  var rendered = renderMarkdown(text);
+  var lines = rendered.split("\n");
+  lines.forEach(function (line, i) {
+    if (i === 0) {
+      console.log(prefix + colorFn(line));
+    } else {
+      console.log("        " + colorFn(line));
+    }
+  });
+  console.log();
+}
+
+function renderMarkdown(text) {
+  var out = text;
+  out = out.replace(/^### (.+)$/gm, function (_, h) { return chalk.bold.underline(h); });
+  out = out.replace(/^## (.+)$/gm, function (_, h) { return chalk.bold.yellow(h); });
+  out = out.replace(/^# (.+)$/gm, function (_, h) { return chalk.bold.magenta.underline(h); });
+  out = out.replace(/\*\*\*(.+?)\*\*\*/g, function (_, t) { return chalk.bold.italic(t); });
+  out = out.replace(/\*\*(.+?)\*\*/g, function (_, t) { return chalk.bold(t); });
+  out = out.replace(/\*(.+?)\*/g, function (_, t) { return chalk.italic(t); });
+  out = out.replace(/`([^`]+)`/g, function (_, c) { return chalk.bgGray.white(" " + c + " "); });
+  out = out.replace(/^(\s*)[-*] (.+)$/gm, function (_, sp, t) { return sp + chalk.green("\u25cf") + " " + t; });
+  out = out.replace(/^(\s*)\d+\. (.+)$/gm, function (_, sp, t) { return sp + chalk.yellow("\u25b8") + " " + t; });
+  return out;
+}
+
+function renderSpinner(message) {
+  if (activeSpinner) activeSpinner.stop();
+  activeSpinner = ora({
+    text: chalk.dim(message || "Thinking..."),
+    spinner: "dots",
+    color: "cyan",
+  }).start();
+  return activeSpinner;
+}
+
+function stopSpinner(success, message) {
+  if (!activeSpinner) return;
+  if (success === false) {
+    activeSpinner.fail(chalk.red(message || "Failed"));
+  } else {
+    activeSpinner.succeed(chalk.green(message || "Done"));
+  }
+  activeSpinner = null;
+}
+
+function renderTable(headers, rows) {
+  var table = new Table({
+    head: headers.map(function (h) { return chalk.cyan.bold(h); }),
+    chars: {
+      "top": "\u2500", "top-mid": "\u252c", "top-left": "\u250c", "top-right": "\u2510",
+      "bottom": "\u2500", "bottom-mid": "\u2534", "bottom-left": "\u2514", "bottom-right": "\u2518",
+      "left": "\u2502", "left-mid": "\u251c", "mid": "\u2500", "mid-mid": "\u253c",
+      "right": "\u2502", "right-mid": "\u2524", "middle": "\u2502",
+    },
+    style: { "padding-left": 1, "padding-right": 1 },
+  });
+  rows.forEach(function (r) { table.push(r); });
+  console.log(table.toString());
+  console.log();
+}
+
+function renderBox(title, content, color) {
+  var borderColor = color || "green";
+  var rendered = renderMarkdown(content);
+  console.log(
+    boxen(rendered, {
+      title: title ? chalk.bold(title) : undefined,
+      titleAlignment: "center",
+      padding: 1,
+      margin: { top: 0, bottom: 1, left: 2, right: 2 },
+      borderStyle: "round",
+      borderColor: borderColor,
+    })
+  );
+}
+
+function renderCodeBlock(code, language) {
+  var lang = language ? chalk.dim.italic(" " + language + " ") : "";
+  var lineLen = Math.max(1, 50 - (language || "").length);
+  console.log(chalk.dim("  \u250c\u2500\u2500") + lang + chalk.dim("\u2500".repeat(lineLen)));
+  code.split("\n").forEach(function (line) {
+    var highlighted = line;
+    highlighted = highlighted.replace(/"[^"]*"/g, function (m) { return chalk.yellow(m); });
+    highlighted = highlighted.replace(/'[^']*'/g, function (m) { return chalk.yellow(m); });
+    var kws = ["const","let","var","function","return","if","else","for","while","class","import","export","from","require","async","await","try","catch","throw","new"];
+    var kwRe = new RegExp("\b(" + kws.join("|") + ")\b", "g");
+    highlighted = highlighted.replace(kwRe, function (m) { return chalk.magenta(m); });
+    highlighted = highlighted.replace(/\b(\d+\.?\d*)\b/g, function (m) { return chalk.cyan(m); });
+    highlighted = highlighted.replace(/(\/\/.*)$/g, function (m) { return chalk.dim(m); });
+    console.log(chalk.dim("  \u2502 ") + highlighted);
+  });
+  console.log(chalk.dim("  \u2514" + "\u2500".repeat(54)));
+  console.log();
+}
+
+function renderStatusBar(stats) {
+  var s = stats || {};
+  var model = s.model || "auto";
+  var tokens = s.tokens || totalTokens;
+  var cost = s.cost || totalCost;
+  var elapsed = Math.floor((Date.now() - startTime) / 1000);
+  var mins = Math.floor(elapsed / 60);
+  var secs = elapsed % 60;
+  var uptime = mins + "m " + secs + "s";
+  var parts = [
+    chalk.bgCyan.black(" " + model + " "),
+    chalk.bgGreen.black(" Tokens: " + tokens.toLocaleString() + " "),
+    chalk.bgYellow.black(" Cost: $" + cost.toFixed(4) + " "),
+    chalk.bgMagenta.black(" Uptime: " + uptime + " "),
+  ];
+  var bar = parts.join(chalk.dim(" \u2502 "));
+  var width = process.stdout.columns || 80;
+  console.log(chalk.dim("\u2500".repeat(width)));
+  console.log(bar);
+  console.log(chalk.dim("\u2500".repeat(width)));
+}
+
+function renderProgress(current, total, label) {
+  var width = 40;
+  var pct = Math.min(1, current / total);
+  var filled = Math.round(width * pct);
+  var empty = width - filled;
+  var bar = chalk.green("\u2588".repeat(filled)) + chalk.dim("\u2591".repeat(empty));
+  var pctStr = chalk.bold(Math.round(pct * 100) + "%");
+  var lbl = label ? chalk.dim(" " + label) : "";
+  process.stdout.write("\r  " + bar + " " + pctStr + lbl + " (" + current + "/" + total + ")");
+  if (current >= total) console.log();
+}
+
+function addTokens(count, costPerToken) {
+  totalTokens += count;
+  totalCost += count * (costPerToken || 0);
+}
+
+function getStats() {
+  return { tokens: totalTokens, cost: totalCost, uptime: Date.now() - startTime };
+}
+
+module.exports = {
+  renderBanner: renderBanner,
+  renderPrompt: renderPrompt,
+  renderResponse: renderResponse,
+  renderSpinner: renderSpinner,
+  stopSpinner: stopSpinner,
+  renderTable: renderTable,
+  renderBox: renderBox,
+  renderCodeBlock: renderCodeBlock,
+  renderStatusBar: renderStatusBar,
+  renderProgress: renderProgress,
+  renderMarkdown: renderMarkdown,
+  addTokens: addTokens,
+  getStats: getStats,
+  colors: colors,
+};

package/package.json

@@ -1,23 +1,19 @@
 {
   "name": "blun-king-cli",
-  "version": "5.3.7",
-  "description": "BLUN King CLI — Your local AI assistant powered by Gemma4",
-  "type": "commonjs",
-  "bin": {
-    "blun": "./blun-cli.js"
-  },
-  "scripts": {
-    "start": "node api.js",
-    "cli": "node blun-cli.js",
-    "bot": "node bot.js",
-    "test": "node --test tests/*.test.js"
-  },
+  "version": "6.0.0",
+  "description": "BLUN AI Assistant - Command Line Interface",
+  "bin": { "blun": "./bin/blun.js" },
+  "files": ["bin/", "lib/", "README.md"],
+  "keywords": ["ai", "cli", "blun", "assistant"],
+  "author": "BLUN AI <info@blun.ai>",
+  "license": "MIT",
   "dependencies": {
-    "express": "^5.1.0",
-    "node-telegram-bot-api": "^0.66.0",
-    "playwright": "^1.53.0"
+    "chalk": "^4.1.2",
+    "ora": "^5.4.1",
+    "cli-table3": "^0.6.3",
+    "boxen": "^5.1.2",
+    "gradient-string": "^2.0.2",
+    "figlet": "^1.7.0"
   },
-  "keywords": ["ai", "cli", "blun", "gemma", "local-ai"],
-  "author": "BLUN AI",
-  "license": "MIT"
+  "engines": { "node": ">=18" }
 }