blun-king-cli 1.2.0 → 1.4.0

package/bin/blun.js

@@ -108,7 +108,7 @@ function printHeader() {
   var line = BOX.h.repeat(w - 4);
   console.log("");
   console.log(C.brightBlue + "  " + BOX.tl + line + BOX.tr + C.reset);
-  console.log(C.brightBlue + "  " + BOX.v + C.reset + C.bold + C.brightWhite + "  " + BOX.bot + " BLUN KING CLI" + C.reset + C.dim + " v1.1" + C.reset + " ".repeat(Math.max(0, w - 24)) + C.brightBlue + BOX.v + C.reset);
+  console.log(C.brightBlue + "  " + BOX.v + C.reset + C.bold + C.brightWhite + "  " + BOX.bot + " BLUN KING CLI" + C.reset + C.dim + " v1.4" + C.reset + " ".repeat(Math.max(0, w - 24)) + C.brightBlue + BOX.v + C.reset);
   console.log(C.brightBlue + "  " + BOX.v + C.reset + C.gray + "  Premium KI — Local First — Autonom" + C.reset + " ".repeat(Math.max(0, w - 41)) + C.brightBlue + BOX.v + C.reset);
   console.log(C.brightBlue + "  " + BOX.v + line + BOX.v + C.reset);
   console.log(C.brightBlue + "  " + BOX.v + C.reset + C.gray + "  API    " + C.brightCyan + config.api.base_url + C.reset + " ".repeat(Math.max(0, w - 14 - config.api.base_url.length)) + C.brightBlue + BOX.v + C.reset);
@@ -121,6 +121,20 @@ function printHeader() {
   console.log("");
 }
 
+// ── Update Checker ──
+function checkForUpdates() {
+  try {
+    var currentVersion = "1.4.0";
+    try { currentVersion = require(path.join(__dirname, "..", "package.json")).version; } catch(e) {}
+    var latest = execSync("npm view blun-king-cli version 2>/dev/null", { encoding: "utf8", timeout: 5000 }).trim();
+    if (latest && latest !== currentVersion) {
+      console.log(C.yellow + C.bold + "  " + BOX.arrow + " Update available: " + currentVersion + " → " + latest + C.reset);
+      console.log(C.yellow + "    npm update -g blun-king-cli" + C.reset);
+      console.log("");
+    }
+  } catch(e) { /* silent */ }
+}
+
 function printAnswer(answer, meta) {
   console.log("");
   console.log(C.green + C.bold + "  " + BOX.bot + " BLUN King" + C.reset + (meta ? C.gray + "  " + BOX.dot + " " + meta + C.reset : ""));
@@ -199,6 +213,16 @@ async function handleCommand(input) {
       console.log("  /score <text>     Score a response");
       console.log("  /eval             Run eval suite");
       console.log("");
+      console.log(C.yellow + "  PLUGINS (MCP)" + C.reset);
+      console.log("  /plugin list      List installed plugins");
+      console.log("  /plugin add <cmd> Add MCP server (npm pkg or local path)");
+      console.log("  /plugin remove <n>Remove a plugin");
+      console.log("  /plugin run <n>   Start a plugin server");
+      console.log("  /plugin stop <n>  Stop a plugin server");
+      console.log("  /permissions      Show permission settings");
+      console.log("  /permissions allow-all  Allow all tool calls");
+      console.log("  /permissions ask        Ask before each tool call");
+      console.log("");
       console.log(C.yellow + "  SETTINGS" + C.reset);
       console.log("  /settings         Show all settings");
       console.log("  /set auth api     Switch to API key auth");
@@ -218,18 +242,45 @@ async function handleCommand(input) {
       console.log("  /write <file>     Write/create a file");
       console.log("  /init             Init project (AGENT.md, .gitignore, git init)");
       console.log("");
+      console.log(C.yellow + "  CONFIG" + C.reset);
+      console.log("  /config list      List all settings (all scopes)");
+      console.log("  /config get <key> Get a setting value");
+      console.log("  /config set <k> <v>  Set a value [--global|--project|--local]");
+      console.log("  /config add <k> <v>  Add to array setting");
+      console.log("  /config remove <k>   Remove setting");
+      console.log("");
+      console.log(C.yellow + "  HOOKS" + C.reset);
+      console.log("  /hooks list       List all hooks");
+      console.log("  /hooks add <trigger> <cmd>  Add hook (pre:chat, post:deploy...)");
+      console.log("  /hooks remove <trigger>     Remove hook");
+      console.log("");
+      console.log(C.yellow + "  AGENTS" + C.reset);
+      console.log("  /agents list      List subagents");
+      console.log("  /agents create <n>  Create new agent");
+      console.log("  /agents run <n> <task>  Run agent with task");
+      console.log("  /agents info <n>  Show agent details");
+      console.log("");
       console.log(C.yellow + "  SYSTEM" + C.reset);
       console.log("  /status           Runtime status");
       console.log("  /versions         Prompt versions");
       console.log("  /health           Quick health check");
+      console.log("  /doctor           Full system diagnostics");
+      console.log("  /model [name]     Show/switch model");
+      console.log("  /cost             Session cost estimate");
+      console.log("  /compact          Clear old context");
+      console.log("  /review           Review current git diff");
+      console.log("  /login key <k>    Login with API key");
+      console.log("  /logout           Logout");
       console.log("  /watchdog         Watchdog status");
-      console.log("  /watchdog on/off  Enable/disable watchdog");
       console.log("  /memory           Show local memory");
-      console.log("  /memory save <k>  Save to memory");
-      console.log("  /memory del <k>   Delete from memory");
       console.log("  /files            List workdir files");
       console.log("  /exit             Exit CLI");
       console.log("");
+      console.log(C.yellow + "  SHORTCUTS" + C.reset);
+      console.log("  !<cmd>            Run bash command directly");
+      console.log("  #<key>            Read memory entry");
+      console.log("  #save <k> <v>     Save to memory");
+      console.log("");
       break;
 
     case "/clear":
@@ -333,6 +384,67 @@ async function handleCommand(input) {
       cmdInit();
       break;
 
+    case "/plugin":
+    case "/mcp":
+      cmdPlugin(args);
+      break;
+
+    case "/permissions":
+      cmdPermissions(args);
+      break;
+
+    case "/config":
+      cmdConfig(args);
+      break;
+
+    case "/hooks":
+      cmdHooks(args);
+      break;
+
+    case "/agents":
+      cmdAgents(args);
+      break;
+
+    case "/doctor":
+      await cmdDoctor();
+      break;
+
+    case "/model":
+      cmdModel(args);
+      break;
+
+    case "/login":
+      cmdLogin(args);
+      break;
+
+    case "/logout":
+      cmdLogout();
+      break;
+
+    case "/compact":
+      cmdCompact();
+      break;
+
+    case "/review":
+      await cmdReview();
+      break;
+
+    case "/cost":
+      cmdCost();
+      break;
+
+    case "/agent":
+      await cmdAgent(args);
+      break;
+
+    case "/screenshot":
+      await cmdScreenshot(args);
+      break;
+
+    case "/render":
+      await cmdRender(args);
+      break;
+
     case "/exit":
     case "/quit":
     case "/q":
@@ -1072,6 +1184,777 @@ function cmdInit(args) {
   }
 }
 
+// ── Plugins (MCP-style) ──
+const PLUGINS_FILE = path.join(CONFIG_DIR, "plugins.json");
+const PERMISSIONS_FILE = path.join(CONFIG_DIR, "permissions.json");
+
+function loadPlugins() {
+  if (fs.existsSync(PLUGINS_FILE)) {
+    try { return JSON.parse(fs.readFileSync(PLUGINS_FILE, "utf8")); } catch(e) {}
+  }
+  return {};
+}
+
+function savePlugins(p) { fs.writeFileSync(PLUGINS_FILE, JSON.stringify(p, null, 2)); }
+
+function loadPermissions() {
+  if (fs.existsSync(PERMISSIONS_FILE)) {
+    try { return JSON.parse(fs.readFileSync(PERMISSIONS_FILE, "utf8")); } catch(e) {}
+  }
+  return { mode: "ask", allowed: [], denied: [] };
+}
+
+function savePermissions(p) { fs.writeFileSync(PERMISSIONS_FILE, JSON.stringify(p, null, 2)); }
+
+// Built-in plugin templates
+var PLUGIN_TEMPLATES = {
+  telegram: {
+    name: "telegram",
+    description: "Telegram Bot Bridge — send/receive messages",
+    type: "builtin",
+    config: { bot_token: "", chat_id: "" },
+    commands: ["/tg send <msg>", "/tg status"],
+    setup: ["bot_token", "chat_id"]
+  },
+  github: {
+    name: "github",
+    description: "GitHub Integration — repos, issues, PRs",
+    type: "builtin",
+    config: { token: "", default_repo: "" },
+    commands: ["/gh repos", "/gh issues", "/gh pr"],
+    setup: ["token"]
+  },
+  browser: {
+    name: "browser",
+    description: "Playwright Browser — screenshots, rendering, scraping",
+    type: "builtin",
+    config: {},
+    commands: ["/screenshot <url>", "/render <url>"],
+    setup: []
+  },
+  slack: {
+    name: "slack",
+    description: "Slack Webhook — send messages to channels",
+    type: "builtin",
+    config: { webhook_url: "" },
+    commands: ["/slack send <msg>"],
+    setup: ["webhook_url"]
+  },
+  docker: {
+    name: "docker",
+    description: "Docker Management — containers, images, logs",
+    type: "builtin",
+    config: { host: "localhost" },
+    commands: ["/docker ps", "/docker logs <container>"],
+    setup: []
+  }
+};
+
+function cmdPlugin(args) {
+  var plugins = loadPlugins();
+  var parts = (args || "").split(/\s+/);
+  var action = parts[0] || "list";
+
+  if (action === "list") {
+    console.log("");
+    console.log(C.bold + "  " + BOX.bot + " Installed Plugins:" + C.reset);
+    console.log(C.brightBlue + "  " + BOX.h.repeat(40) + C.reset);
+    var names = Object.keys(plugins);
+    if (names.length === 0) {
+      console.log(C.gray + "  (none installed)" + C.reset);
+    } else {
+      names.forEach(function(name) {
+        var p = plugins[name];
+        var status = p.running ? C.green + BOX.dot + " running" : C.gray + BOX.dot + " stopped";
+        console.log("  " + C.brightCyan + name + C.reset + " — " + (p.description || "") + "  " + status + C.reset);
+      });
+    }
+    console.log("");
+    console.log(C.gray + "  Available: " + Object.keys(PLUGIN_TEMPLATES).join(", ") + C.reset);
+    console.log(C.gray + "  Or add custom: /plugin add <npm-package> or /plugin add <path>" + C.reset);
+    console.log("");
+
+  } else if (action === "add" && parts[1]) {
+    var pluginName = parts[1];
+    if (PLUGIN_TEMPLATES[pluginName]) {
+      // Built-in plugin
+      var tmpl = PLUGIN_TEMPLATES[pluginName];
+      plugins[pluginName] = {
+        name: tmpl.name,
+        description: tmpl.description,
+        type: tmpl.type,
+        config: Object.assign({}, tmpl.config),
+        commands: tmpl.commands,
+        installed: new Date().toISOString(),
+        running: false
+      };
+
+      // If setup fields needed, prompt
+      if (tmpl.setup && tmpl.setup.length > 0) {
+        printInfo("Plugin '" + pluginName + "' needs configuration:");
+        tmpl.setup.forEach(function(field) {
+          printInfo("  Set with: /set plugin." + pluginName + "." + field + " <value>");
+        });
+      }
+
+      savePlugins(plugins);
+      printSuccess("Plugin '" + pluginName + "' installed!");
+    } else {
+      // Custom: npm package or local path
+      printInfo("Installing custom plugin: " + pluginName);
+      try {
+        execSync("npm install " + pluginName, { cwd: CONFIG_DIR, encoding: "utf8", stdio: "pipe" });
+        plugins[pluginName] = {
+          name: pluginName,
+          description: "Custom MCP server",
+          type: "npm",
+          config: {},
+          commands: [],
+          installed: new Date().toISOString(),
+          running: false
+        };
+        savePlugins(plugins);
+        printSuccess("Plugin '" + pluginName + "' installed via npm!");
+      } catch(e) {
+        printError("Install failed: " + e.message.slice(0, 200));
+      }
+    }
+
+  } else if (action === "remove" && parts[1]) {
+    delete plugins[parts[1]];
+    savePlugins(plugins);
+    printSuccess("Plugin '" + parts[1] + "' removed.");
+
+  } else if (action === "run" && parts[1]) {
+    if (!plugins[parts[1]]) { printError("Plugin not found: " + parts[1]); return; }
+    plugins[parts[1]].running = true;
+    savePlugins(plugins);
+    printSuccess("Plugin '" + parts[1] + "' started.");
+
+  } else if (action === "stop" && parts[1]) {
+    if (!plugins[parts[1]]) { printError("Plugin not found: " + parts[1]); return; }
+    plugins[parts[1]].running = false;
+    savePlugins(plugins);
+    printSuccess("Plugin '" + parts[1] + "' stopped.");
+
+  } else {
+    printError("Usage: /plugin list|add|remove|run|stop <name>");
+  }
+}
+
+function cmdPermissions(args) {
+  var perms = loadPermissions();
+  if (!args) {
+    console.log("");
+    console.log(C.bold + "  Permissions:" + C.reset);
+    console.log("  Mode: " + C.brightCyan + perms.mode + C.reset);
+    console.log("  Allowed: " + (perms.allowed.length > 0 ? perms.allowed.join(", ") : C.gray + "(none)" + C.reset));
+    console.log("  Denied: " + (perms.denied.length > 0 ? perms.denied.join(", ") : C.gray + "(none)" + C.reset));
+    console.log("");
+    console.log(C.gray + "  /permissions allow-all  — Skip all permission prompts" + C.reset);
+    console.log(C.gray + "  /permissions ask        — Ask before each tool call" + C.reset);
+    console.log("");
+  } else if (args === "allow-all") {
+    perms.mode = "allow-all";
+    savePermissions(perms);
+    printSuccess("Permission mode: allow-all (no prompts)");
+  } else if (args === "ask") {
+    perms.mode = "ask";
+    savePermissions(perms);
+    printSuccess("Permission mode: ask (prompt before each tool call)");
+  }
+}
+
+// ── Agent Loop (CLI wrapper) ──
+async function cmdAgent(args) {
+  if (!args) { printError("Usage: /agent <goal>"); return; }
+  try {
+    printUserMessage(args);
+    process.stdout.write(C.dim + "  " + BOX.bot + " working autonomously..." + C.reset);
+    var resp = await apiCall("POST", "/agent", { goal: args, verbose: true });
+    process.stdout.write("\r" + " ".repeat(50) + "\r");
+    if (resp.status !== 200) { printError(resp.data.error || "Error"); return; }
+    var d = resp.data;
+    var meta = d.steps_executed + " steps" + (d.files.length > 0 ? " " + BOX.dot + " " + d.files.length + " files" : "");
+    printAnswer(d.answer, meta);
+    if (d.files.length > 0) {
+      console.log(C.green + "  Files:" + C.reset);
+      d.files.forEach(function(f) { console.log("    " + C.brightCyan + f.name + C.reset + " → " + config.api.base_url + f.download); });
+      console.log("");
+    }
+  } catch(e) { printError(e.message); }
+}
+
+// ── Screenshot/Render (CLI wrapper) ──
+async function cmdScreenshot(args) {
+  if (!args) { printError("Usage: /screenshot <url>"); return; }
+  try {
+    printInfo("Taking screenshot of " + args + "...");
+    var resp = await apiCall("POST", "/screenshot", { url: args });
+    if (resp.status !== 200) { printError(resp.data.error || "Error"); return; }
+    printSuccess("Screenshot: " + resp.data.title);
+    console.log("  Download: " + C.brightCyan + config.api.base_url + resp.data.screenshot + C.reset);
+    console.log("");
+  } catch(e) { printError(e.message); }
+}
+
+async function cmdRender(args) {
+  if (!args) { printError("Usage: /render <url>"); return; }
+  try {
+    printInfo("Rendering " + args + " with Playwright...");
+    var resp = await apiCall("POST", "/render", { url: args });
+    if (resp.status !== 200) { printError(resp.data.error || "Error"); return; }
+    printSuccess("Rendered: " + resp.data.title + " (" + resp.data.html_length + " chars)");
+    if (resp.data.screenshot) console.log("  Screenshot: " + C.brightCyan + resp.data.screenshot + C.reset);
+    console.log("");
+  } catch(e) { printError(e.message); }
+}
+
+// ══════════════════════════════════════════════════
+// ── 1. SETTINGS REGISTRY (Multi-Scope) ──
+// ══════════════════════════════════════════════════
+// Scopes: Managed > CLI Args > Local > Project > User
+const SETTINGS_SCOPES = ["managed", "cli", "local", "project", "user"];
+const USER_SETTINGS_FILE = path.join(CONFIG_DIR, "settings.json");
+
+function findProjectRoot() {
+  var dir = config.workdir;
+  for (var i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(dir, ".blun"))) return dir;
+    if (fs.existsSync(path.join(dir, ".git"))) return dir;
+    var parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return config.workdir;
+}
+
+function loadScopedSettings(scope) {
+  var file;
+  if (scope === "user") file = USER_SETTINGS_FILE;
+  else if (scope === "project") file = path.join(findProjectRoot(), ".blun", "settings.json");
+  else if (scope === "local") file = path.join(findProjectRoot(), ".blun", "settings.local.json");
+  else if (scope === "managed") file = path.join(CONFIG_DIR, "managed-settings.json");
+  else return {};
+  if (file && fs.existsSync(file)) {
+    try { return JSON.parse(fs.readFileSync(file, "utf8")); } catch(e) {}
+  }
+  return {};
+}
+
+function saveScopedSettings(scope, data) {
+  var file;
+  if (scope === "user") file = USER_SETTINGS_FILE;
+  else if (scope === "project") {
+    var projDir = path.join(findProjectRoot(), ".blun");
+    if (!fs.existsSync(projDir)) fs.mkdirSync(projDir, { recursive: true });
+    file = path.join(projDir, "settings.json");
+  } else if (scope === "local") {
+    var projDir2 = path.join(findProjectRoot(), ".blun");
+    if (!fs.existsSync(projDir2)) fs.mkdirSync(projDir2, { recursive: true });
+    file = path.join(projDir2, "settings.local.json");
+  } else if (scope === "managed") file = path.join(CONFIG_DIR, "managed-settings.json");
+  else return;
+  fs.writeFileSync(file, JSON.stringify(data, null, 2));
+}
+
+// Resolve setting: highest priority scope wins
+function getSetting(key) {
+  for (var i = 0; i < SETTINGS_SCOPES.length; i++) {
+    var s = loadScopedSettings(SETTINGS_SCOPES[i]);
+    if (s[key] !== undefined) return { value: s[key], scope: SETTINGS_SCOPES[i] };
+  }
+  return { value: undefined, scope: null };
+}
+
+// All settings keys with defaults
+var SETTINGS_DEFAULTS = {
+  model: "blun-king-v100", language: "de", theme: "dark", outputStyle: "markdown",
+  effortLevel: "normal", fastMode: false, alwaysThinkingEnabled: false,
+  showThinkingSummaries: false, verbose: false, autoMode: false,
+  respectGitignore: true, includeCoAuthoredBy: true, cleanupPeriodDays: 30,
+  prefersReducedMotion: false, channelsEnabled: true,
+  "sandbox.enabled": false, "sandbox.autoAllowBashIfSandboxed": true,
+  "permissions.defaultMode": "ask",
+  "attribution.commit": true, "attribution.pr": true
+};
+
+function cmdConfig(args) {
+  var parts = (args || "").split(/\s+/);
+  var action = parts[0] || "list";
+  var scope = "user";
+
+  // Check for --global flag
+  var globalIdx = parts.indexOf("--global");
+  if (globalIdx !== -1) { scope = "user"; parts.splice(globalIdx, 1); }
+  var projectIdx = parts.indexOf("--project");
+  if (projectIdx !== -1) { scope = "project"; parts.splice(projectIdx, 1); }
+  var localIdx = parts.indexOf("--local");
+  if (localIdx !== -1) { scope = "local"; parts.splice(localIdx, 1); }
+
+  action = parts[0] || "list";
+  var key = parts[1];
+  var value = parts.slice(2).join(" ");
+
+  if (action === "list") {
+    console.log("");
+    console.log(C.bold + "  Settings Registry:" + C.reset);
+    console.log(C.brightBlue + "  " + BOX.h.repeat(50) + C.reset);
+    var allKeys = Object.keys(SETTINGS_DEFAULTS);
+    allKeys.forEach(function(k) {
+      var resolved = getSetting(k);
+      var val = resolved.value !== undefined ? resolved.value : SETTINGS_DEFAULTS[k];
+      var src = resolved.scope || "default";
+      console.log("  " + C.gray + k + C.reset + " = " + C.brightCyan + JSON.stringify(val) + C.reset + C.dim + " (" + src + ")" + C.reset);
+    });
+    // Also show custom keys from all scopes
+    SETTINGS_SCOPES.forEach(function(sc) {
+      var s = loadScopedSettings(sc);
+      Object.keys(s).forEach(function(k) {
+        if (!SETTINGS_DEFAULTS.hasOwnProperty(k)) {
+          console.log("  " + C.yellow + k + C.reset + " = " + C.brightCyan + JSON.stringify(s[k]) + C.reset + C.dim + " (" + sc + ")" + C.reset);
+        }
+      });
+    });
+    console.log("");
+
+  } else if (action === "get" && key) {
+    var resolved = getSetting(key);
+    if (resolved.value !== undefined) {
+      console.log(C.brightCyan + JSON.stringify(resolved.value) + C.reset + C.dim + " (from: " + resolved.scope + ")" + C.reset);
+    } else if (SETTINGS_DEFAULTS[key] !== undefined) {
+      console.log(C.brightCyan + JSON.stringify(SETTINGS_DEFAULTS[key]) + C.reset + C.dim + " (default)" + C.reset);
+    } else {
+      printInfo("Not set: " + key);
+    }
+
+  } else if (action === "set" && key) {
+    var s = loadScopedSettings(scope);
+    // Auto-parse value
+    var parsed = value;
+    if (value === "true") parsed = true;
+    else if (value === "false") parsed = false;
+    else if (/^\d+$/.test(value)) parsed = parseInt(value);
+    s[key] = parsed;
+    saveScopedSettings(scope, s);
+    printSuccess(key + " = " + JSON.stringify(parsed) + " (scope: " + scope + ")");
+
+  } else if (action === "add" && key && value) {
+    var s2 = loadScopedSettings(scope);
+    if (!Array.isArray(s2[key])) s2[key] = [];
+    s2[key].push(value);
+    saveScopedSettings(scope, s2);
+    printSuccess("Added '" + value + "' to " + key);
+
+  } else if (action === "remove" && key && value) {
+    var s3 = loadScopedSettings(scope);
+    if (Array.isArray(s3[key])) {
+      s3[key] = s3[key].filter(function(v) { return v !== value; });
+      saveScopedSettings(scope, s3);
+      printSuccess("Removed '" + value + "' from " + key);
+    } else {
+      delete s3[key];
+      saveScopedSettings(scope, s3);
+      printSuccess("Removed " + key);
+    }
+  } else {
+    printError("Usage: /config list|get|set|add|remove <key> [value] [--global|--project|--local]");
+  }
+}
+
+// ══════════════════════════════════════════════════
+// ── 2. SANDBOX ENGINE ──
+// ══════════════════════════════════════════════════
+function checkSandbox(action, target) {
+  var sandbox = getSetting("sandbox.enabled").value;
+  if (!sandbox) return { allowed: true };
+
+  var perms = loadPermissions();
+
+  if (action === "write") {
+    var denyWrite = getSetting("sandbox.filesystem.denyWrite").value || [];
+    var allowWrite = getSetting("sandbox.filesystem.allowWrite").value || [];
+    for (var i = 0; i < denyWrite.length; i++) {
+      if (target.includes(denyWrite[i])) return { allowed: false, reason: "denyWrite: " + denyWrite[i] };
+    }
+    if (allowWrite.length > 0) {
+      var ok = false;
+      for (var j = 0; j < allowWrite.length; j++) {
+        if (target.startsWith(allowWrite[j])) { ok = true; break; }
+      }
+      if (!ok) return { allowed: false, reason: "Not in allowWrite list" };
+    }
+  }
+
+  if (action === "read") {
+    var denyRead = getSetting("sandbox.filesystem.denyRead").value || [];
+    for (var k = 0; k < denyRead.length; k++) {
+      if (target.includes(denyRead[k])) return { allowed: false, reason: "denyRead: " + denyRead[k] };
+    }
+  }
+
+  if (action === "network") {
+    var allowedDomains = getSetting("sandbox.network.allowedDomains").value || [];
+    if (allowedDomains.length > 0) {
+      var domainOk = false;
+      for (var l = 0; l < allowedDomains.length; l++) {
+        if (target.includes(allowedDomains[l])) { domainOk = true; break; }
+      }
+      if (!domainOk) return { allowed: false, reason: "Domain not in allowedDomains" };
+    }
+  }
+
+  return { allowed: true };
+}
+
+// ══════════════════════════════════════════════════
+// ── 3. HOOKS ENGINE ──
+// ══════════════════════════════════════════════════
+const HOOKS_FILE = path.join(CONFIG_DIR, "hooks.json");
+
+function loadHooks() {
+  if (fs.existsSync(HOOKS_FILE)) {
+    try { return JSON.parse(fs.readFileSync(HOOKS_FILE, "utf8")); } catch(e) {}
+  }
+  return { pre: {}, post: {} };
+}
+
+function saveHooks(h) { fs.writeFileSync(HOOKS_FILE, JSON.stringify(h, null, 2)); }
+
+function runHook(phase, command) {
+  if (getSetting("disableAllHooks").value) return;
+  var hooks = loadHooks();
+  var list = (hooks[phase] || {})[command] || [];
+  for (var i = 0; i < list.length; i++) {
+    try {
+      if (list[i].type === "command") {
+        execSync(list[i].run, { cwd: config.workdir, encoding: "utf8", timeout: 10000, stdio: "pipe" });
+      } else if (list[i].type === "http") {
+        var allowed = getSetting("allowedHttpHookUrls").value || [];
+        if (allowed.length > 0 && !allowed.some(function(u) { return list[i].url.startsWith(u); })) continue;
+        execSync("curl -sX POST " + JSON.stringify(list[i].url) + " -d " + JSON.stringify(JSON.stringify({ event: phase + ":" + command })), { timeout: 5000, stdio: "pipe" });
+      }
+    } catch(e) { if (config.verbose) log("Hook error: " + e.message); }
+  }
+}
+
+function cmdHooks(args) {
+  var hooks = loadHooks();
+  var parts = (args || "").split(/\s+/);
+  var action = parts[0] || "list";
+
+  if (action === "list") {
+    console.log("");
+    console.log(C.bold + "  Hooks:" + C.reset);
+    ["pre", "post"].forEach(function(phase) {
+      var cmds = Object.keys(hooks[phase] || {});
+      if (cmds.length === 0) return;
+      console.log(C.yellow + "  " + phase + ":" + C.reset);
+      cmds.forEach(function(cmd) {
+        hooks[phase][cmd].forEach(function(h) {
+          console.log("    " + cmd + " → " + C.brightCyan + (h.run || h.url) + C.reset + C.dim + " (" + h.type + ")" + C.reset);
+        });
+      });
+    });
+    if (Object.keys(hooks.pre).length === 0 && Object.keys(hooks.post).length === 0) {
+      console.log(C.gray + "  (none)" + C.reset);
+    }
+    console.log("");
+
+  } else if (action === "add" && parts[1] && parts[2] && parts[3]) {
+    // /hooks add pre:chat "echo hello"
+    var trigger = parts[1].split(":");
+    var phase = trigger[0]; // pre or post
+    var cmd = trigger[1];
+    var run = parts.slice(2).join(" ");
+    if (!hooks[phase]) hooks[phase] = {};
+    if (!hooks[phase][cmd]) hooks[phase][cmd] = [];
+    hooks[phase][cmd].push({ type: "command", run: run });
+    saveHooks(hooks);
+    printSuccess("Hook added: " + phase + ":" + cmd + " → " + run);
+
+  } else if (action === "remove" && parts[1]) {
+    var trigger2 = parts[1].split(":");
+    if (hooks[trigger2[0]] && hooks[trigger2[0]][trigger2[1]]) {
+      delete hooks[trigger2[0]][trigger2[1]];
+      saveHooks(hooks);
+      printSuccess("Hook removed: " + parts[1]);
+    } else {
+      printError("Hook not found: " + parts[1]);
+    }
+  } else {
+    printError("Usage: /hooks list|add|remove  —  /hooks add pre:chat \"echo hello\"");
+  }
+}
+
+// ══════════════════════════════════════════════════
+// ── 4. SUBAGENTS ──
+// ══════════════════════════════════════════════════
+const AGENTS_DIR_USER = path.join(CONFIG_DIR, "agents");
+if (!fs.existsSync(AGENTS_DIR_USER)) fs.mkdirSync(AGENTS_DIR_USER, { recursive: true });
+
+function loadSubagents() {
+  var agents = [];
+  // User-level agents
+  [AGENTS_DIR_USER, path.join(findProjectRoot(), ".blun", "agents")].forEach(function(dir) {
+    if (!fs.existsSync(dir)) return;
+    fs.readdirSync(dir).forEach(function(f) {
+      if (!f.endsWith(".md")) return;
+      var content = fs.readFileSync(path.join(dir, f), "utf8");
+      var meta = {};
+      // Parse YAML frontmatter
+      var fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (fmMatch) {
+        fmMatch[1].split("\n").forEach(function(line) {
+          var kv = line.match(/^(\w+):\s*(.+)/);
+          if (kv) meta[kv[1]] = kv[2].trim();
+        });
+      }
+      agents.push({
+        name: meta.name || f.replace(".md", ""),
+        description: meta.description || "",
+        role: meta.role || "general",
+        tools: (meta.tools || "").split(",").map(function(t) { return t.trim(); }).filter(Boolean),
+        file: path.join(dir, f),
+        prompt: content.replace(/^---[\s\S]*?---\n*/, "").trim(),
+        scope: dir.includes(CONFIG_DIR) ? "user" : "project"
+      });
+    });
+  });
+  return agents;
+}
+
+function cmdAgents(args) {
+  var parts = (args || "").split(/\s+/);
+  var action = parts[0] || "list";
+
+  if (action === "list") {
+    var agents = loadSubagents();
+    console.log("");
+    console.log(C.bold + "  " + BOX.bot + " Subagents:" + C.reset);
+    console.log(C.brightBlue + "  " + BOX.h.repeat(40) + C.reset);
+    if (agents.length === 0) {
+      console.log(C.gray + "  (none) — Create .md files in ~/.blun/agents/ or .blun/agents/" + C.reset);
+    }
+    agents.forEach(function(a) {
+      console.log("  " + C.brightCyan + a.name + C.reset + " — " + a.description + C.dim + " (" + a.scope + ")" + C.reset);
+    });
+    console.log("");
+
+  } else if (action === "create" && parts[1]) {
+    var name = parts[1];
+    var desc = parts.slice(2).join(" ") || "Custom agent";
+    var agentFile = path.join(AGENTS_DIR_USER, name + ".md");
+    var content = "---\nname: " + name + "\ndescription: " + desc + "\nrole: general\ntools: chat,read,write\n---\n\nDu bist " + name + ", ein spezialisierter Agent bei BLUN King.\n\nDeine Aufgabe: " + desc + "\n";
+    fs.writeFileSync(agentFile, content);
+    printSuccess("Agent '" + name + "' created at " + agentFile);
+
+  } else if (action === "run" && parts[1]) {
+    var agents2 = loadSubagents();
+    var agent = agents2.find(function(a) { return a.name === parts[1]; });
+    if (!agent) { printError("Agent not found: " + parts[1]); return; }
+    var task = parts.slice(2).join(" ");
+    if (!task) { printError("Usage: /agents run <name> <task>"); return; }
+    // Run agent via API
+    printInfo("Running agent '" + agent.name + "'...");
+    apiCall("POST", "/agent", { goal: agent.prompt + "\n\nAKTUELLE AUFGABE: " + task }).then(function(resp) {
+      if (resp.status === 200) {
+        printAnswer(resp.data.answer, agent.name + " " + BOX.dot + " " + resp.data.steps_executed + " steps");
+      } else {
+        printError(resp.data.error || "Error");
+      }
+    }).catch(function(e) { printError(e.message); });
+
+  } else if (action === "info" && parts[1]) {
+    var agents3 = loadSubagents();
+    var a = agents3.find(function(a) { return a.name === parts[1]; });
+    if (!a) { printError("Agent not found: " + parts[1]); return; }
+    console.log("");
+    console.log(C.bold + "  Agent: " + a.name + C.reset);
+    console.log("  Description: " + a.description);
+    console.log("  Role: " + a.role);
+    console.log("  Tools: " + a.tools.join(", "));
+    console.log("  Scope: " + a.scope);
+    console.log("  File: " + a.file);
+    console.log(C.dim + "  " + BOX.h.repeat(30) + C.reset);
+    console.log(C.gray + a.prompt.slice(0, 300) + C.reset);
+    console.log("");
+
+  } else {
+    printError("Usage: /agents list|create|run|info <name>");
+  }
+}
+
+// ══════════════════════════════════════════════════
+// ── 5. SESSION HISTORY (per workdir) ──
+// ══════════════════════════════════════════════════
+const SESSIONS_DIR = path.join(CONFIG_DIR, "sessions");
+if (!fs.existsSync(SESSIONS_DIR)) fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+
+function getSessionFile() {
+  var hash = require("crypto").createHash("md5").update(config.workdir).digest("hex").slice(0, 8);
+  return path.join(SESSIONS_DIR, hash + ".json");
+}
+
+function loadSessionHistory() {
+  var f = getSessionFile();
+  if (fs.existsSync(f)) {
+    try { return JSON.parse(fs.readFileSync(f, "utf8")); } catch(e) {}
+  }
+  return { workdir: config.workdir, history: [], inputHistory: [] };
+}
+
+function saveSessionHistory(session) {
+  fs.writeFileSync(getSessionFile(), JSON.stringify(session, null, 2));
+}
+
+// ══════════════════════════════════════════════════
+// ── 6. COST TRACKING ──
+// ══════════════════════════════════════════════════
+var sessionCost = { requests: 0, inputTokensEst: 0, outputTokensEst: 0 };
+
+function cmdCost() {
+  console.log("");
+  console.log(C.bold + "  Session Cost Estimate:" + C.reset);
+  console.log("  Requests: " + C.brightCyan + sessionCost.requests + C.reset);
+  console.log("  Est. Input Tokens: " + C.brightCyan + sessionCost.inputTokensEst + C.reset);
+  console.log("  Est. Output Tokens: " + C.brightCyan + sessionCost.outputTokensEst + C.reset);
+  console.log("");
+}
+
+// ══════════════════════════════════════════════════
+// ── 7. /doctor — Diagnostics ──
+// ══════════════════════════════════════════════════
+async function cmdDoctor() {
+  console.log("");
+  console.log(C.bold + "  " + BOX.bot + " BLUN Doctor — System Check" + C.reset);
+  console.log(C.brightBlue + "  " + BOX.h.repeat(40) + C.reset);
+
+  // Config
+  var hasKey = config.auth.api_key && config.auth.api_key.length > 10;
+  console.log("  Config:     " + (fs.existsSync(CONFIG_FILE) ? C.green + "OK" : C.red + "MISSING") + C.reset);
+  console.log("  API Key:    " + (hasKey ? C.green + "OK" : C.red + "NOT SET") + C.reset);
+
+  // API
+  try {
+    var h = await apiCall("GET", "/health");
+    console.log("  API:        " + (h.status === 200 ? C.green + "OK (" + h.data.model + ")" : C.red + "ERROR " + h.status) + C.reset);
+  } catch(e) {
+    console.log("  API:        " + C.red + "UNREACHABLE" + C.reset);
+  }
+
+  // Git
+  try {
+    execSync("git --version", { stdio: "pipe" });
+    console.log("  Git:        " + C.green + "OK" + C.reset);
+  } catch(e) {
+    console.log("  Git:        " + C.red + "NOT FOUND" + C.reset);
+  }
+
+  // SSH
+  try {
+    execSync("ssh -V 2>&1", { stdio: "pipe" });
+    console.log("  SSH:        " + C.green + "OK" + C.reset);
+  } catch(e) {
+    console.log("  SSH:        " + C.red + "NOT FOUND" + C.reset);
+  }
+
+  // Node
+  console.log("  Node:       " + C.green + process.version + C.reset);
+  console.log("  Platform:   " + C.green + process.platform + C.reset);
+
+  // Plugins
+  var plugins = loadPlugins();
+  console.log("  Plugins:    " + C.brightCyan + Object.keys(plugins).length + " installed" + C.reset);
+
+  // Agents
+  var agents = loadSubagents();
+  console.log("  Agents:     " + C.brightCyan + agents.length + " loaded" + C.reset);
+
+  // Hooks
+  var hooks = loadHooks();
+  var hookCount = Object.keys(hooks.pre || {}).length + Object.keys(hooks.post || {}).length;
+  console.log("  Hooks:      " + C.brightCyan + hookCount + " registered" + C.reset);
+
+  // Memory
+  var memFiles = fs.existsSync(MEMORY_DIR) ? fs.readdirSync(MEMORY_DIR).length : 0;
+  console.log("  Memory:     " + C.brightCyan + memFiles + " entries" + C.reset);
+
+  // Disk
+  console.log("  Workdir:    " + C.brightCyan + config.workdir + C.reset);
+  console.log("");
+}
+
+// ══════════════════════════════════════════════════
+// ── 8. /model — Model switcher ──
+// ══════════════════════════════════════════════════
+function cmdModel(args) {
+  if (!args) {
+    console.log("");
+    console.log(C.bold + "  Current Model: " + C.brightCyan + config.model + C.reset);
+    console.log(C.gray + "  /model <name>  — Switch model" + C.reset);
+    console.log("");
+    return;
+  }
+  config.model = args.trim();
+  saveConfig(config);
+  printSuccess("Model switched to: " + config.model);
+}
+
+// ══════════════════════════════════════════════════
+// ── 9. /login /logout ──
+// ══════════════════════════════════════════════════
+function cmdLogin(args) {
+  if (args && args.startsWith("key ")) {
+    config.auth.api_key = args.slice(4).trim();
+    config.auth.type = "api_key";
+    saveConfig(config);
+    printSuccess("Logged in with API key.");
+  } else if (args === "oauth") {
+    printInfo("OAuth login not yet implemented. Use API key for now:");
+    printInfo("  /login key <your-api-key>");
+  } else {
+    console.log("");
+    console.log(C.bold + "  Login:" + C.reset);
+    console.log("  /login key <api-key>  — Login with API key");
+    console.log("  /login oauth          — Login with OAuth (coming soon)");
+    console.log("");
+  }
+}
+
+function cmdLogout() {
+  config.auth.api_key = "";
+  config.auth.oauth_token = "";
+  config.auth.oauth_expires = null;
+  saveConfig(config);
+  printSuccess("Logged out.");
+}
+
+// ══════════════════════════════════════════════════
+// ── 10. /compact — Clear context ──
+// ══════════════════════════════════════════════════
+function cmdCompact() {
+  var before = chatHistory.length;
+  chatHistory = chatHistory.slice(-4);
+  printSuccess("Context compacted: " + before + " → " + chatHistory.length + " messages");
+}
+
+// ══════════════════════════════════════════════════
+// ── 11. /review — Review current diff ──
+// ══════════════════════════════════════════════════
+async function cmdReview() {
+  try {
+    var diff = execSync("git diff", { cwd: config.workdir, encoding: "utf8", timeout: 10000 });
+    if (!diff.trim()) { printInfo("No changes to review."); return; }
+    printInfo("Sending diff for review...");
+    var resp = await apiCall("POST", "/chat", {
+      message: "Review diesen Git-Diff. Finde Bugs, Sicherheitsprobleme, Verbesserungen:\n\n```diff\n" + diff.slice(0, 8000) + "\n```"
+    });
+    if (resp.status === 200) printAnswer(resp.data.answer, "code-review");
+    else printError(resp.data.error || "Error");
+  } catch(e) { printError(e.message); }
+}
+
 // ── Main Loop ──
 async function main() {
   // Handle CLI args
@@ -1110,7 +1993,22 @@ async function main() {
   }
 
   // Interactive mode
+  // Workdir selection (like Claude Code)
+  if (!process.argv.includes("--no-workdir-prompt")) {
+    var cwdHasBlun = fs.existsSync(path.join(process.cwd(), ".blun"));
+    var cwdHasGit = fs.existsSync(path.join(process.cwd(), ".git"));
+    if (cwdHasBlun || cwdHasGit) {
+      config.workdir = process.cwd();
+    }
+    // Show workdir in header
+  }
+
   printHeader();
+  checkForUpdates();
+
+  // Load session history for this workdir
+  var session = loadSessionHistory();
+  chatHistory = session.history.slice(-20);
 
   // Health check
   try {
@@ -1127,7 +2025,9 @@ async function main() {
     "/generate", "/analyze", "/score", "/eval", "/settings", "/set",
     "/status", "/versions", "/health", "/watchdog", "/memory", "/files",
     "/sh", "/git", "/ssh", "/deploy", "/read", "/write", "/init",
-    "/screenshot", "/render", "/agent", "/exit"
+    "/screenshot", "/render", "/agent", "/plugin", "/mcp", "/permissions",
+    "/config", "/hooks", "/agents", "/doctor", "/model", "/login", "/logout",
+    "/compact", "/review", "/cost", "/exit"
   ];
 
   var rl = readline.createInterface({
@@ -1149,15 +2049,46 @@ async function main() {
     var input = line.trim();
     if (!input) { rl.prompt(); return; }
 
-    if (input.startsWith("/")) {
+    // ! prefix = direct bash
+    if (input.startsWith("!")) {
+      cmdShell(input.slice(1).trim());
+    }
+    // # prefix = memory shortcut
+    else if (input.startsWith("#save ")) {
+      var memParts = input.slice(6).split(/\s+/);
+      var memKey = memParts[0];
+      var memVal = memParts.slice(1).join(" ");
+      if (memKey && memVal) {
+        fs.writeFileSync(path.join(MEMORY_DIR, memKey + ".txt"), memVal);
+        printSuccess("Memory saved: " + memKey);
+      }
+    }
+    else if (input.startsWith("#") && !input.startsWith("#save")) {
+      var memKey2 = input.slice(1).trim();
+      var memFile = path.join(MEMORY_DIR, memKey2 + ".txt");
+      if (fs.existsSync(memFile)) {
+        console.log(C.brightCyan + fs.readFileSync(memFile, "utf8") + C.reset);
+      } else {
+        printError("Memory not found: " + memKey2);
+      }
+    }
+    // / prefix = command
+    else if (input.startsWith("/")) {
+      runHook("pre", input.split(/\s+/)[0].slice(1));
       await handleCommand(input);
-    } else {
+      runHook("post", input.split(/\s+/)[0].slice(1));
+    }
+    // plain text = chat
+    else {
       await sendChat(input);
     }
     rl.prompt();
   });
 
   rl.on("close", function() {
+    // Save session history
+    session.history = chatHistory.slice(-50);
+    saveSessionHistory(session);
     console.log(C.dim + "\nBye." + C.reset);
     process.exit(0);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "BLUN King CLI — Premium KI Console",
   "bin": {
     "blun": "./bin/blun.js"