blun-king-cli 5.3.6 → 5.4.0

package/blun-cli.js

@@ -7,6 +7,12 @@ const { execSync, spawn } = require("child_process");
 const https = require("https");
 const http = require("http");
 
+if (process.platform === "win32") {
+  try {
+    execSync("chcp 65001>nul", { stdio: "ignore", shell: process.env.ComSpec || "cmd.exe" });
+  } catch (e) {}
+}
+
 // ── Config ──
 var _rawHome = process.env.BLUN_HOME || process.env.REAL_HOME || require("os").homedir();
 // Strip .claude-telegram-profile suffix if present (Claude Code Telegram session override)
@@ -112,16 +118,15 @@ function apiCall(method, endpoint, body) {
   });
 }
 
-function downloadArtifactToWorkdir(downloadPath, filename) {
+function downloadBinary(urlOrPath) {
   return new Promise(function(resolve, reject) {
-    if (!downloadPath || !filename) return resolve(null);
-
-    var url = new URL(config.api.base_url + downloadPath);
+    var absolute = new URL(String(urlOrPath || ""), config.api.base_url).toString();
+    var url = new URL(absolute);
     var isHttps = url.protocol === "https:";
     var options = {
       hostname: url.hostname,
       port: url.port,
-      path: url.pathname + (url.search || ""),
+      path: url.pathname + url.search,
       method: "GET",
       headers: {},
       timeout: config.api.timeout
@@ -136,84 +141,158 @@ function downloadArtifactToWorkdir(downloadPath, filename) {
 
     var mod = isHttps ? https : http;
     var req = mod.request(options, function(res) {
-      if (res.statusCode !== 200) {
-        var errChunks = [];
-        res.on("data", function(c) { errChunks.push(c); });
-        res.on("end", function() {
-          reject(new Error("Artifact download failed: HTTP " + res.statusCode + (errChunks.length ? " " + Buffer.concat(errChunks).toString() : "")));
-        });
-        return;
-      }
-
-      var localPath = path.join(config.workdir, path.basename(filename));
-      var localDir = path.dirname(localPath);
-      if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
-      var out = fs.createWriteStream(localPath);
-
-      res.pipe(out);
-      out.on("finish", function() {
-        out.close(function() {
-          try {
-            var stat = fs.statSync(localPath);
-            resolve({
-              name: path.basename(localPath),
-              path: localPath,
-              size: stat.size
-            });
-          } catch (statErr) {
-            reject(statErr);
-          }
-        });
-      });
-      out.on("error", function(err) {
-        out.destroy();
-        reject(err);
+      var chunks = [];
+      res.on("data", function(c) { chunks.push(c); });
+      res.on("end", function() {
+        var buffer = Buffer.concat(chunks);
+        if ((res.statusCode || 500) >= 400) {
+          return reject(new Error("HTTP " + res.statusCode + " " + buffer.toString("utf8").slice(0, 400)));
+        }
+        resolve({ buffer: buffer, contentType: res.headers["content-type"] || "", url: absolute });
       });
     });
-
     req.on("error", function(e) { reject(e); });
-    req.on("timeout", function() { req.destroy(); reject(new Error("Artifact download timeout")); });
+    req.on("timeout", function() { req.destroy(); reject(new Error("Timeout")); });
     req.end();
   });
 }
 
-async function saveApiOutputs(receivedFiles, artifact) {
-  var saved = [];
-  var seen = new Set();
-
-  for (var fi = 0; fi < (receivedFiles || []).length; fi++) {
-    var f = receivedFiles[fi];
-    var relativeName = f && (f.name || f.path);
-    if (f && f.content && relativeName) {
-      var localPath = path.join(config.workdir, relativeName);
-      var localDir = path.dirname(localPath);
-      if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
-      fs.writeFileSync(localPath, f.content, "utf8");
-      var fileInfo = {
-        name: relativeName,
-        path: localPath,
-        size: typeof f.size === "number" ? f.size : Buffer.byteLength(String(f.content), "utf8")
-      };
-      saved.push(fileInfo);
-      seen.add(path.basename(relativeName));
+function ensureLocalDir(filePath) {
+  var dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function saveTextFileToWorkdir(fileName, content) {
+  var localPath = path.join(config.workdir, fileName);
+  ensureLocalDir(localPath);
+  fs.writeFileSync(localPath, content, "utf8");
+  return localPath;
+}
+
+function printSavedFiles(savedFiles) {
+  if (!savedFiles.length) return;
+  console.log(C.green + "  Dateien gespeichert:" + C.reset);
+  savedFiles.forEach(function(file) {
+    var sizeLabel = typeof file.size === "number" ? C.dim + " (" + file.size + " bytes)" + C.reset : "";
+    console.log("    " + C.brightCyan + file.path + C.reset + sizeLabel);
+  });
+  console.log("");
+}
+
+function rememberBrowserContext(snapshot, extra) {
+  var snap = snapshot || {};
+  lastBrowserContext = {
+    url: snap.url || (lastBrowserContext && lastBrowserContext.url) || "",
+    title: snap.title || (lastBrowserContext && lastBrowserContext.title) || "",
+    text: String(snap.text || (lastBrowserContext && lastBrowserContext.text) || "").slice(0, 2000),
+    updatedAt: new Date().toISOString()
+  };
+  if (extra && typeof extra === "object") {
+    Object.keys(extra).forEach(function(key) {
+      lastBrowserContext[key] = extra[key];
+    });
+  }
+  return lastBrowserContext;
+}
+
+function browserContextPrompt(input) {
+  if (!lastBrowserContext || !lastBrowserContext.url) return input;
+  return input + "\n\n[Browser-Kontext: " + (lastBrowserContext.title || lastBrowserContext.url) + " - " + String(lastBrowserContext.text || "").slice(0, 1000) + "\nURL: " + lastBrowserContext.url + "]";
+}
+
+function rememberBrowserAction(type, payload) {
+  lastBrowserAction = {
+    type: type,
+    payload: payload || {},
+    updatedAt: new Date().toISOString()
+  };
+  return lastBrowserAction;
+}
+
+async function saveArtifactToWorkdir(artifact, references) {
+  if (!artifact) return [];
+
+  var referenceList = Array.isArray(references) ? references : [];
+  var downloadUrl = artifact.download || artifact.url || "";
+  var fileName = artifact.filename || artifact.name || "";
+
+  if (!fileName && downloadUrl) {
+    try {
+      fileName = path.basename(new URL(downloadUrl, config.api.base_url).pathname) || "";
+    } catch (e) {}
+  }
+
+  if (!fileName) {
+    fileName = "artifact-" + Date.now();
+  }
+
+  var localPath = path.join(config.workdir, fileName);
+  ensureLocalDir(localPath);
+
+  if (artifact.content && !artifact.encoding) {
+    fs.writeFileSync(localPath, artifact.content, "utf8");
+    return [{ name: fileName, path: localPath, size: Buffer.byteLength(artifact.content, "utf8") }];
+  }
+
+  try {
+    if (!downloadUrl) throw new Error("No artifact download URL provided.");
+    var result = await downloadBinary(downloadUrl);
+    fs.writeFileSync(localPath, result.buffer);
+    return [{ name: fileName, path: localPath, size: result.buffer.length }];
+  } catch (downloadErr) {
+    var screenshotRef = referenceList.find(function(ref) { return ref && ref.url; });
+    if (/\.(png|jpg|jpeg|webp)$/i.test(fileName) && screenshotRef) {
+      var bc = require(path.join(__dirname, "browser-controller"));
+      try {
+        await bc.open(screenshotRef.url);
+        await bc.screenshot(localPath);
+        return [{ name: fileName, path: localPath, size: fs.statSync(localPath).size }];
+      } finally {
+        await bc.close().catch(function() {});
+      }
     }
+    throw new Error("Artifact download failed: " + downloadErr.message);
   }
+}
+
+async function saveApiOutputs(receivedFiles, artifact, references) {
+  var savedFiles = [];
+  var files = Array.isArray(receivedFiles) ? receivedFiles : [];
 
-  if (artifact && artifact.download && artifact.filename && !seen.has(path.basename(artifact.filename))) {
+  for (var fi = 0; fi < files.length; fi++) {
+    var f = files[fi];
+    if (f && f.content && f.name) {
+      var localPath = saveTextFileToWorkdir(f.name, f.content);
+      savedFiles.push({ name: f.name, path: localPath, size: f.size || Buffer.byteLength(f.content, "utf8") });
+    }
+  }
+
+  if (artifact) {
     try {
-      var downloaded = await downloadArtifactToWorkdir(artifact.download, artifact.filename);
-      if (downloaded) saved.push(downloaded);
+      var artifactFiles = await saveArtifactToWorkdir(artifact, references);
+      artifactFiles.forEach(function(file) {
+        if (!savedFiles.some(function(existing) { return existing.path === file.path; })) {
+          savedFiles.push(file);
+        }
+      });
     } catch (artifactErr) {
       printError("Artefakt konnte nicht lokal gespeichert werden: " + artifactErr.message);
     }
   }
 
-  return saved;
+  if (savedFiles.length) {
+    lastCreatedFiles = savedFiles.slice();
+    printSavedFiles(savedFiles);
+  }
+
+  return savedFiles;
 }
 
 // ── Chat History ──
 var chatHistory = [];
 var lastCreatedFiles = []; // Track files from last response for follow-up context
+var lastBrowserContext = null; // Persist browser follow-up context even after local browser closes
+var lastBrowserAction = null; // Repeatable local browser action state
 
 // ── Print Helpers ──
 function printHeader() {
@@ -655,6 +734,11 @@ async function handleCommand(input) {
       await cmdAgent(args);
       break;
 
+    case "/tg":
+    case "/telegram":
+      await cmdTelegram(args);
+      break;
+
     case "/screenshot":
       await cmdScreenshot(args);
       break;
@@ -734,7 +818,6 @@ async function sendChat(message) {
 
     var fullAnswer = "";
     var receivedFiles = [];
-    var receivedArtifact = null;
     var meta = "";
 
     try {
@@ -755,7 +838,6 @@ async function sendChat(message) {
 
       fullAnswer = resp.data.answer || "";
       receivedFiles = resp.data.files || [];
-      receivedArtifact = resp.data.artifact || null;
       var q = resp.data.quality || {};
       meta = (resp.data.task_type || "") + "/" + (resp.data.role || "") + " " + BOX.dot + " score: " + (q.score || "?") +
         (q.retried ? " " + BOX.dot + " retried" : "") +
@@ -779,18 +861,7 @@ async function sendChat(message) {
     sessionCost.inputTokensEst += inTok;
     sessionCost.outputTokensEst += outTok;
 
-    // ── Save received files to local workdir ──
-    var savedOutputs = await saveApiOutputs(receivedFiles, receivedArtifact);
-    if (savedOutputs.length > 0) {
-      console.log(C.green + "  \uD83D\uDCC1 Dateien gespeichert:" + C.reset);
-      lastCreatedFiles = [];
-      for (var fi = 0; fi < savedOutputs.length; fi++) {
-        var f = savedOutputs[fi];
-        console.log("    " + C.brightCyan + f.path + C.reset + C.dim + " (" + f.size + " bytes)" + C.reset);
-        lastCreatedFiles.push({ name: f.name, path: f.path, size: f.size });
-      }
-      console.log("");
-    }
+    await saveApiOutputs(receivedFiles, resp.data.artifact || null, resp.data.references || []);
 
     // Auto Memory Dream Mode
     dreamCounter++;
@@ -1100,6 +1171,20 @@ function cmdSet(args) {
       break;
 
     default:
+      if (key && key.startsWith("plugin.")) {
+        var pluginParts = key.split(".");
+        if (pluginParts.length === 3) {
+          var pName = pluginParts[1];
+          var pField = pluginParts[2];
+          var plugins = loadPlugins();
+          if (!plugins[pName]) { printError("Plugin '" + pName + "' not installed. /plugin add " + pName); break; }
+          if (!plugins[pName].config) plugins[pName].config = {};
+          plugins[pName].config[pField] = val;
+          savePlugins(plugins);
+          printSuccess("Plugin " + pName + "." + pField + " = " + (pField.includes("token") ? "***" + val.slice(-6) : val));
+          break;
+        }
+      }
       printError("Unknown setting. Use /settings to see all options.");
   }
 }
@@ -1638,6 +1723,7 @@ function cmdPlugin(args) {
     if (!plugins[parts[1]]) { printError("Plugin not found: " + parts[1]); return; }
     plugins[parts[1]].running = true;
     savePlugins(plugins);
+    if (parts[1] === "telegram") { ensureTgBot(); }
     printSuccess("Plugin '" + parts[1] + "' started.");
 
   } else if (action === "stop" && parts[1]) {
@@ -1651,6 +1737,134 @@ function cmdPlugin(args) {
   }
 }
 
+// ── Telegram Plugin ──
+var _tgBot = null;
+var _tgMessages = [];
+var _tgMaxMessages = 50;
+
+function getTgConfig() {
+  var plugins = loadPlugins();
+  var tg = plugins.telegram;
+  if (!tg || !tg.config) return null;
+  return tg.config;
+}
+
+function ensureTgBot() {
+  if (_tgBot) return _tgBot;
+  var cfg = getTgConfig();
+  if (!cfg || !cfg.bot_token) {
+    printError("Telegram not configured. Run: /plugin add telegram");
+    printInfo("Then set token: /set plugin.telegram.bot_token <YOUR_BOT_TOKEN>");
+    printInfo("And chat ID:   /set plugin.telegram.chat_id <YOUR_CHAT_ID>");
+    return null;
+  }
+  try {
+    var TelegramBot = require("node-telegram-bot-api");
+    _tgBot = new TelegramBot(cfg.bot_token, { polling: true });
+    _tgBot.on("message", function(msg) {
+      _tgMessages.push({
+        id: msg.message_id,
+        from: msg.from ? (msg.from.first_name || msg.from.username || "?") : "?",
+        text: msg.text || "(media)",
+        date: new Date(msg.date * 1000).toLocaleTimeString(),
+        chat_id: String(msg.chat.id)
+      });
+      if (_tgMessages.length > _tgMaxMessages) _tgMessages.shift();
+    });
+    printSuccess("Telegram Bot connected.");
+    return _tgBot;
+  } catch(e) {
+    printError("Telegram connection failed: " + e.message);
+    return null;
+  }
+}
+
+async function cmdTelegram(args) {
+  var parts = (args || "").trim().split(/\s+/);
+  var action = parts[0] || "status";
+
+  if (action === "status") {
+    var cfg = getTgConfig();
+    if (!cfg || !cfg.bot_token) {
+      printError("Telegram not configured.");
+      printInfo("  /plugin add telegram");
+      printInfo("  /set plugin.telegram.bot_token <TOKEN>");
+      printInfo("  /set plugin.telegram.chat_id <CHAT_ID>");
+    } else {
+      console.log("");
+      console.log(C.bold + "  Telegram Plugin" + C.reset);
+      console.log("  Token: " + C.green + (cfg.bot_token ? "***" + cfg.bot_token.slice(-6) : "not set") + C.reset);
+      console.log("  Chat:  " + C.green + (cfg.chat_id || "not set") + C.reset);
+      console.log("  Bot:   " + (_tgBot ? C.green + "connected" : C.red + "disconnected") + C.reset);
+      console.log("  Messages buffered: " + _tgMessages.length);
+      console.log("");
+    }
+
+  } else if (action === "connect" || action === "start") {
+    ensureTgBot();
+
+  } else if (action === "send") {
+    var cfg = getTgConfig();
+    if (!cfg || !cfg.chat_id) { printError("No chat_id set. /set plugin.telegram.chat_id <ID>"); return; }
+    var bot = ensureTgBot();
+    if (!bot) return;
+    var text = parts.slice(1).join(" ");
+    if (!text) { printError("Usage: /tg send <message>"); return; }
+    try {
+      await bot.sendMessage(cfg.chat_id, text);
+      printSuccess("Message sent.");
+    } catch(e) {
+      printError("Send failed: " + e.message);
+    }
+
+  } else if (action === "read" || action === "messages" || action === "inbox") {
+    if (_tgMessages.length === 0) {
+      printInfo("No messages yet. Connect first: /tg connect");
+      return;
+    }
+    console.log("");
+    console.log(C.bold + "  Last " + Math.min(_tgMessages.length, 20) + " messages:" + C.reset);
+    _tgMessages.slice(-20).forEach(function(m) {
+      console.log(C.dim + "  [" + m.date + "] " + C.reset + C.brightCyan + m.from + C.reset + ": " + m.text);
+    });
+    console.log("");
+
+  } else if (action === "disconnect" || action === "stop") {
+    if (_tgBot) {
+      _tgBot.stopPolling();
+      _tgBot = null;
+      printSuccess("Telegram disconnected.");
+    } else {
+      printInfo("Not connected.");
+    }
+
+  } else if (action === "file" || action === "photo") {
+    var cfg = getTgConfig();
+    if (!cfg || !cfg.chat_id) { printError("No chat_id set."); return; }
+    var bot = ensureTgBot();
+    if (!bot) return;
+    var filePath = parts.slice(1).join(" ");
+    if (!filePath || !fs.existsSync(filePath)) { printError("File not found: " + filePath); return; }
+    try {
+      await bot.sendDocument(cfg.chat_id, filePath);
+      printSuccess("File sent: " + path.basename(filePath));
+    } catch(e) {
+      printError("Send failed: " + e.message);
+    }
+
+  } else {
+    console.log("");
+    console.log(C.bold + "  Telegram Commands:" + C.reset);
+    console.log("  /tg status       Show connection status");
+    console.log("  /tg connect      Connect to Telegram");
+    console.log("  /tg send <msg>   Send a message");
+    console.log("  /tg read         Show received messages");
+    console.log("  /tg file <path>  Send a file/photo");
+    console.log("  /tg disconnect   Disconnect");
+    console.log("");
+  }
+}
+
 function cmdPermissions(args) {
   var perms = loadPermissions();
   if (!args) {
@@ -1714,17 +1928,10 @@ async function cmdAgent(args) {
       var d = resp.data;
       lastAnswer = d.answer || "";
 
-      // Save files locally to workspace — API now returns file contents
-      var savedStepOutputs = await saveApiOutputs(d.files || [], d.artifact || null);
-      if (savedStepOutputs.length > 0) {
-        for (var fi = 0; fi < savedStepOutputs.length; fi++) {
-          totalFiles.push({
-            name: savedStepOutputs[fi].name,
-            localPath: savedStepOutputs[fi].path,
-            size: savedStepOutputs[fi].size
-          });
-        }
-      }
+      var savedApiFiles = await saveApiOutputs(d.files || [], d.artifact || null, d.references || []);
+      savedApiFiles.forEach(function(file) {
+        totalFiles.push({ name: file.name, localPath: file.path, size: file.size });
+      });
 
       // If answer contains code blocks with filenames, extract and save them
       var codeBlockRe = /```(?:\w+)?\s*\n\/\/\s*(.+\.(?:html|css|js|json|md|txt|py))\n([\s\S]*?)```/g;
@@ -3157,23 +3364,157 @@ async function main() {
       await handleCommand(input);
       runHook("post", input.split(/\s+/)[0].slice(1));
     } else {
-      // Browser intent — natural language with URL → local Playwright
+      var lowerInput = String(input || "").toLowerCase();
+      var normalizedInput = String(input || "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+      var trimmedInput = String(input || "").trim();
       var urlMatch = input.match(/(https?:\/\/\S+)/i) || input.match(/\b((?:www\.)?[a-zA-Z0-9-]+\.[a-z]{2,}(?:\/\S*)?)\b/i);
-      var browserWords = /\b(öffne|open|schau|zeig|geh auf|gehen|navigate|browse|screenshot|bildschirmfoto|aufrufen|besuch|check|prüf|analysier)\b/i;
-      if (urlMatch && browserWords.test(input)) {
+      var screenshotish = /\b(screenshot|screen ?shot|scre+ns?h[o0]t|screesnhot|screnshot|bildschirmfoto|bild)\b/i;
+      var browserWords = /\b(offne|oeffne|open|schau|zeig|geh auf|gehen|navigate|browse|screenshot|bildschirmfoto|aufrufen|besuch|check|checken|pruef|analysier)\b/i;
+      var localBrowserRequest = /\b(browser|bowser|brwoser|broser|browserfenster|lokalen browser|local browser|auf meinem pc im browser|im browser|browser lokal|lokal im browser)\b/i.test(normalizedInput);
+      var looksLikeSearch = !urlMatch &&
+        trimmedInput.length > 1 &&
+        trimmedInput.length <= 80 &&
+        trimmedInput.split(/\s+/).length <= 5 &&
+        !/^(hi|hallo|hey|moin|servus|yo|sup|ok|ja|nein|danke|thanks|bye|tschuess|ciao)$/i.test(normalizedInput) &&
+          !/^(wo|was|wie|wer|wann|warum)\b/i.test(normalizedInput) &&
+          !/(screenshot|bildschirmfoto|png|datei|file|ordner|link|pfad|screesnhot|screnshot)\b/i.test(normalizedInput);
+      var browserFollowupRequest = !urlMatch &&
+        !!(lastBrowserContext && lastBrowserContext.url) &&
+        /^(und|auch|noch|dann|danach|davon|darunter|weiter|weiterhin)\b/i.test(normalizedInput);
+      var browserController = null;
+      var browserOpen = false;
+      try {
+        browserController = require(path.join(__dirname, "browser-controller"));
+        browserOpen = typeof browserController.isOpen === "function" && browserController.isOpen();
+      } catch (browserStateErr) {}
+
+      if (lastCreatedFiles.length > 0 &&
+          /(wo|welcher|welche|link|pfad|ordner|liegt|finde|zeig|anzeigen)/i.test(lowerInput) &&
+          /(screenshot|bild|png|datei|file)/i.test(lowerInput)) {
+        printInfo("Letzte gespeicherte Datei(en):");
+        printSavedFiles(lastCreatedFiles);
+      }
+      else if (!urlMatch &&
+          /\b(browser|browserfenster|lokalen browser|local browser|lokalen browsr|lokalen brwoser)\b/i.test(normalizedInput) &&
+          !/(screenshot|bildschirmfoto|png|bild)\b/i.test(normalizedInput)) {
+        try {
+          printInfo("Oeffne lokalen Browser...");
+          await browserController.open("about:blank");
+          rememberBrowserAction("open", { url: "about:blank" });
+          printSuccess("Lokaler Browser geoeffnet.");
+        } catch (bcOpenErr) {
+          printError("Lokaler Browser konnte nicht geoeffnet werden: " + bcOpenErr.message);
+        }
+      }
+      else if (!urlMatch && lastBrowserAction && /\b(nochmal|noch mal|erneut|wieder|same again|again)\b/i.test(normalizedInput)) {
+        try {
+          if (lastBrowserAction.type === "search" && lastBrowserAction.payload && lastBrowserAction.payload.query) {
+            printInfo("Suche im lokalen Browser: " + lastBrowserAction.payload.query);
+            var repeatSearchSnap = await browserController.search(lastBrowserAction.payload.query);
+            rememberBrowserContext(repeatSearchSnap, { query: lastBrowserAction.payload.query, source: "search_repeat" });
+            printSuccess(repeatSearchSnap.title || "Google-Suche geoeffnet.");
+            console.log("  " + C.gray + "URL: " + C.reset + repeatSearchSnap.url);
+          } else if (lastBrowserAction.type === "screenshot" && (browserOpen || (lastBrowserContext && lastBrowserContext.url))) {
+            var repeatSnap = browserOpen ? await browserController.snapshot() : await browserController.open(lastBrowserContext.url);
+            rememberBrowserContext(repeatSnap, { source: "snapshot_repeat" });
+            var repeatShot = path.join(config.workdir, "screenshot-" + Date.now() + ".png");
+            await browserController.screenshot(repeatShot);
+            lastCreatedFiles = [{ name: path.basename(repeatShot), path: repeatShot, size: fs.statSync(repeatShot).size }];
+            rememberBrowserAction("screenshot", { url: repeatSnap.url, path: repeatShot });
+            printSuccess("Screenshot gespeichert: " + repeatShot);
+            console.log("  " + C.gray + "URL: " + C.reset + repeatSnap.url);
+          } else if (lastBrowserAction.type === "open" && lastBrowserAction.payload && lastBrowserAction.payload.url) {
+            printInfo("Oeffne " + lastBrowserAction.payload.url + "...");
+            var repeatOpenSnap = await browserController.open(lastBrowserAction.payload.url);
+            rememberBrowserContext(repeatOpenSnap, { source: "open_repeat", requestedUrl: lastBrowserAction.payload.url });
+            printSuccess(repeatOpenSnap.title || lastBrowserAction.payload.url);
+            console.log("  " + C.gray + "URL: " + C.reset + repeatOpenSnap.url);
+          } else {
+            await sendChat(browserContextPrompt(input));
+          }
+        } catch (repeatErr) {
+          await sendChat(browserContextPrompt(input));
+        }
+      }
+      else if (!urlMatch && (browserOpen || (lastBrowserContext && lastBrowserContext.url)) && screenshotish.test(normalizedInput)) {
+        try {
+          var currentSnap = browserOpen ? await browserController.snapshot() : await browserController.open(lastBrowserContext.url);
+          rememberBrowserContext(currentSnap, { source: "snapshot_followup" });
+          var currentShot = path.join(config.workdir, "screenshot-" + Date.now() + ".png");
+          await browserController.screenshot(currentShot);
+          lastCreatedFiles = [{ name: path.basename(currentShot), path: currentShot, size: fs.statSync(currentShot).size }];
+          rememberBrowserAction("screenshot", { url: currentSnap.url, path: currentShot });
+          printSuccess("Screenshot der offenen Seite gespeichert: " + currentShot);
+          console.log("  " + C.gray + "URL: " + C.reset + currentSnap.url);
+        } catch (followErr) {
+          printError("Screenshot der offenen Seite fehlgeschlagen: " + followErr.message);
+        }
+      }
+      else if (!urlMatch && (browserOpen || (lastBrowserContext && lastBrowserContext.url)) && /(welche seite|wo bist du|welche url|url|was ist offen|wo gerade)/i.test(normalizedInput)) {
+        try {
+          var statusSnap = browserOpen ? await browserController.snapshot() : lastBrowserContext;
+          rememberBrowserContext(statusSnap, { source: "status_followup" });
+          printSuccess(statusSnap.title || "Browserseite aktiv.");
+          console.log("  " + C.gray + "URL: " + C.reset + statusSnap.url);
+        } catch (statusErr) {
+          printError("Browserstatus konnte nicht gelesen werden: " + statusErr.message);
+        }
+      }
+      else if (!urlMatch && (browserOpen || (lastBrowserContext && lastBrowserContext.url)) && /(analysier|analyse|schau|check|pruef|was siehst du|was ist auf der seite)/i.test(normalizedInput)) {
+        try {
+          var ctxSnap = browserOpen ? await browserController.snapshot() : lastBrowserContext;
+          rememberBrowserContext(ctxSnap, { source: "analysis_followup" });
+          await sendChat(browserContextPrompt(input));
+        } catch (ctxErr) {
+          await sendChat(input);
+        }
+      }
+      else if (browserFollowupRequest) {
+        await sendChat(browserContextPrompt(input));
+      }
+      else if (looksLikeSearch) {
+        try {
+          if (browserOpen || (lastBrowserContext && lastBrowserContext.url)) {
+            printInfo("Suche im lokalen Browser: " + trimmedInput);
+            var searchSnap = await browserController.search(trimmedInput);
+            rememberBrowserContext(searchSnap, { query: trimmedInput, source: "search" });
+            rememberBrowserAction("search", { query: trimmedInput });
+            printSuccess(searchSnap.title || "Google-Suche geoeffnet.");
+            console.log("  " + C.gray + "URL: " + C.reset + searchSnap.url);
+            if (searchSnap.text) {
+              console.log(C.dim + "  " + BOX.h.repeat(40) + C.reset);
+              console.log("  " + searchSnap.text.slice(0, 500).replace(/\n{3,}/g, "\n\n"));
+            }
+            console.log("");
+          } else {
+            await sendChat(input);
+          }
+        } catch (searchErr) {
+          await sendChat(input);
+        }
+      }
+      else if (urlMatch && (localBrowserRequest || browserWords.test(normalizedInput) || screenshotish.test(normalizedInput) || /\blokal|mein pc|pc\b/i.test(normalizedInput) || normalizedInput.trim() === String(urlMatch[0]).toLowerCase() || normalizedInput.trim() === String(urlMatch[1]).toLowerCase())) {
         var browserUrl = urlMatch[1];
         try {
           var bc = require(path.join(__dirname, "browser-controller"));
-          if (/screenshot|bildschirmfoto/i.test(input)) {
+          if (screenshotish.test(normalizedInput)) {
             printInfo("Screenshot: " + browserUrl);
             var snap = await bc.open(browserUrl);
+            rememberBrowserContext(snap, { source: "open", requestedUrl: browserUrl });
             var shotFile = path.join(config.workdir, "screenshot-" + Date.now() + ".png");
             await bc.screenshot(shotFile);
+            lastCreatedFiles = [{ name: path.basename(shotFile), path: shotFile, size: fs.statSync(shotFile).size }];
+            rememberBrowserAction("screenshot", { url: snap.url, path: shotFile });
             printSuccess("Screenshot gespeichert: " + shotFile);
             console.log("  " + C.gray + "Title: " + C.reset + snap.title);
           } else {
-            printInfo("Öffne " + browserUrl + "...");
+            printInfo("Oeffne " + browserUrl + "...");
             var snap = await bc.open(browserUrl);
+            rememberBrowserContext(snap, { source: "open", requestedUrl: browserUrl });
+            rememberBrowserAction("open", { url: snap.url });
             printSuccess(snap.title);
             console.log("  " + C.gray + "URL: " + C.reset + snap.url);
             if (snap.text) {
@@ -3182,37 +3523,38 @@ async function main() {
               console.log("  " + preview);
             }
             console.log("");
-            // Send page context to chat so BLUN King can discuss it
-            await sendChat(input + "\n\n[Browser-Kontext: " + snap.title + " — " + snap.text.slice(0, 1000) + "]");
+            if (!localBrowserRequest) {
+              await sendChat(browserContextPrompt(input));
+            }
           }
-        } catch(bcErr) {
-          // Playwright not available, send to chat normally
+        } catch (bcErr) {
           await sendChat(input);
         }
       }
-      // Intent detection — natural language → command
       else {
-      var detected = detectIntent(input);
-      if (detected) {
-        printInfo("→ " + detected);
-        runHook("pre", detected.split(/\s+/)[0].slice(1));
-        await handleCommand(detected);
-        runHook("post", detected.split(/\s+/)[0].slice(1));
-      } else if (sessionMode === "agent") {
-        // Agent mode: detect if question or task
-        var trimmed = input.trim();
-        var isChat = trimmed.length < 15 || // short messages = chat
-          /^(hi|hallo|hey|moin|servus|yo|sup|ok|ja|nein|danke|thanks|bye|tschüss|ciao)/i.test(trimmed) ||
-          /^(wo |was |wie |wer |wann |warum |kannst|hast|ist |sind |where|what|how|who|when|why|can you|do you|is |are )/i.test(trimmed) ||
-          /\?$/.test(trimmed);
-        if (isChat) {
-          await sendChat(input);
+        var detected = detectIntent(input);
+        if (detected) {
+          printInfo("-> " + detected);
+          runHook("pre", detected.split(/\s+/)[0].slice(1));
+          await handleCommand(detected);
+          runHook("post", detected.split(/\s+/)[0].slice(1));
+        } else if (lastBrowserContext && lastBrowserContext.url && !/^(hi|hallo|hey|moin|servus|yo|sup|ok|ja|nein|danke|thanks|bye|tschuess|ciao)$/i.test(normalizedInput)) {
+          await sendChat(browserContextPrompt(input));
+        } else if (sessionMode === "agent") {
+          // Agent mode: detect if question or task
+          var trimmed = input.trim();
+          var isChat = trimmed.length < 15 || // short messages = chat
+            /^(hi|hallo|hey|moin|servus|yo|sup|ok|ja|nein|danke|thanks|bye|tschuess|ciao)/i.test(trimmed) ||
+            /^(wo |was |wie |wer |wann |warum |kannst|hast|ist |sind |where|what|how|who|when|why|can you|do you|is |are )/i.test(trimmed) ||
+            /\?$/.test(trimmed);
+          if (isChat) {
+            await sendChat(input);
+          } else {
+            await cmdAgent(input);
+          }
         } else {
-          await cmdAgent(input);
+          await sendChat(input);
         }
-      } else {
-        await sendChat(input);
-      }
       }
     }