blun-king-cli 5.3.4 → 5.3.6

package/blun-cli.js

@@ -112,6 +112,105 @@ function apiCall(method, endpoint, body) {
   });
 }
 
+function downloadArtifactToWorkdir(downloadPath, filename) {
+  return new Promise(function(resolve, reject) {
+    if (!downloadPath || !filename) return resolve(null);
+
+    var url = new URL(config.api.base_url + downloadPath);
+    var isHttps = url.protocol === "https:";
+    var options = {
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname + (url.search || ""),
+      method: "GET",
+      headers: {},
+      timeout: config.api.timeout
+    };
+
+    var authToken = config.api.key || config.auth.api_key;
+    if (authToken) {
+      options.headers["Authorization"] = "Bearer " + authToken;
+    } else if (config.auth.type === "oauth" && config.auth.oauth_token) {
+      options.headers["Authorization"] = "Bearer " + config.auth.oauth_token;
+    }
+
+    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);
+      });
+    });
+
+    req.on("error", function(e) { reject(e); });
+    req.on("timeout", function() { req.destroy(); reject(new Error("Artifact download 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));
+    }
+  }
+
+  if (artifact && artifact.download && artifact.filename && !seen.has(path.basename(artifact.filename))) {
+    try {
+      var downloaded = await downloadArtifactToWorkdir(artifact.download, artifact.filename);
+      if (downloaded) saved.push(downloaded);
+    } catch (artifactErr) {
+      printError("Artefakt konnte nicht lokal gespeichert werden: " + artifactErr.message);
+    }
+  }
+
+  return saved;
+}
+
 // ── Chat History ──
 var chatHistory = [];
 var lastCreatedFiles = []; // Track files from last response for follow-up context
@@ -635,6 +734,7 @@ async function sendChat(message) {
 
     var fullAnswer = "";
     var receivedFiles = [];
+    var receivedArtifact = null;
     var meta = "";
 
     try {
@@ -655,6 +755,7 @@ 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" : "") +
@@ -679,19 +780,14 @@ async function sendChat(message) {
     sessionCost.outputTokensEst += outTok;
 
     // ── Save received files to local workdir ──
-    if (receivedFiles.length > 0) {
+    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 < receivedFiles.length; fi++) {
-        var f = receivedFiles[fi];
-        if (f.content && f.name) {
-          var localPath = path.join(config.workdir, f.name);
-          var localDir = path.dirname(localPath);
-          if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
-          fs.writeFileSync(localPath, f.content, "utf8");
-          console.log("    " + C.brightCyan + localPath + C.reset + C.dim + " (" + f.size + " bytes)" + C.reset);
-          lastCreatedFiles.push({ name: f.name, path: localPath, size: f.size });
-        }
+      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("");
     }
@@ -1619,17 +1715,14 @@ async function cmdAgent(args) {
       lastAnswer = d.answer || "";
 
       // Save files locally to workspace — API now returns file contents
-      if (d.files && d.files.length > 0) {
-        for (var fi = 0; fi < d.files.length; fi++) {
-          var f = d.files[fi];
-          if (f.content && f.name) {
-            var localPath = path.join(workdir, f.name);
-            var localDir = path.dirname(localPath);
-            if (!fs.existsSync(localDir)) fs.mkdirSync(localDir, { recursive: true });
-            fs.writeFileSync(localPath, f.content, "utf8");
-            f.localPath = localPath;
-          }
-          totalFiles.push(f);
+      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
+          });
         }
       }
 

package/browser-controller.js

@@ -3,6 +3,31 @@ const { chromium } = require("playwright");
 let browserInstance = null;
 let pageInstance = null;
 
+function normalizeUrl(input) {
+  const raw = String(input || "").trim();
+  if (!raw) {
+    throw new Error("No URL provided.");
+  }
+
+  let cleaned = raw
+    .replace(/^[<\s"'`]+/, "")
+    .replace(/[>\s"'`]+$/, "");
+
+  if (/^www\./i.test(cleaned)) {
+    cleaned = `https://${cleaned}`;
+  }
+
+  if (!/^[a-z][a-z0-9+.-]*:/i.test(cleaned)) {
+    cleaned = `https://${cleaned}`;
+  }
+
+  try {
+    return new URL(cleaned).toString();
+  } catch {
+    throw new Error(`Invalid URL: ${raw}`);
+  }
+}
+
 async function ensurePage() {
   if (!browserInstance) {
     browserInstance = await chromium.launch({ headless: true });
@@ -15,9 +40,7 @@ async function ensurePage() {
 
 async function open(url) {
   const page = await ensurePage();
-  var cleanUrl = String(url).replace(/^<|>$/g, "").trim();
-  if (!/^https?:\/\//i.test(cleanUrl)) cleanUrl = "https://" + cleanUrl;
-  await page.goto(cleanUrl, { waitUntil: "domcontentloaded", timeout: 30000 });
+  await page.goto(normalizeUrl(url), { waitUntil: "domcontentloaded", timeout: 30000 });
   return snapshot();
 }
 
@@ -68,6 +91,7 @@ async function close() {
 }
 
 module.exports = {
+  normalizeUrl,
   open,
   click,
   type,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "5.3.4",
+  "version": "5.3.6",
   "description": "BLUN King CLI — Your local AI assistant powered by Gemma4",
   "type": "commonjs",
   "bin": {

package/reference-inspector.js

@@ -4,8 +4,36 @@ const { storeReference } = require("./local-data");
 
 let chromiumLoader = null;
 
+function normalizeDetectedUrl(input) {
+  const raw = String(input || "").trim();
+  if (!raw) return null;
+
+  let cleaned = raw
+    .replace(/^[<\s"'`(]+/, "")
+    .replace(/[>\s"'`),.;:!?]+$/, "");
+
+  if (!cleaned) return null;
+  if (/^www\./i.test(cleaned)) cleaned = `https://${cleaned}`;
+  if (/^[a-z0-9.-]+\.[a-z]{2,}(\/|$)/i.test(cleaned) && !/^[a-z][a-z0-9+.-]*:/i.test(cleaned)) {
+    cleaned = `https://${cleaned}`;
+  }
+
+  try {
+    const parsed = new URL(cleaned);
+    if (!/^https?:$/i.test(parsed.protocol) && !/^data:$/i.test(parsed.protocol)) return null;
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+
 function extractUrls(text) {
-  return Array.from(String(text || "").matchAll(/https?:\/\/[^\s)>"']+/gi)).map((match) => match[0]);
+  const matches = [
+    ...Array.from(String(text || "").matchAll(/https?:\/\/[^\s)>"']+/gi)).map((match) => match[0]),
+    ...Array.from(String(text || "").matchAll(/(?:^|[\s<(])((?:www\.)?[a-z0-9.-]+\.[a-z]{2,}(?:\/[^\s)>"']*)?)/gi)).map((match) => match[1])
+  ];
+
+  return [...new Set(matches.map(normalizeDetectedUrl).filter(Boolean))];
 }
 
 function summarizeHtml(source) {

package/runtime.js

@@ -56,6 +56,10 @@ function clampConfidence(score) {
   return Math.max(0, Math.min(1, score / 8));
 }
 
+function hasResolvableUrl(raw) {
+  return /(https?:\/\/\S+)|(?:^|[\s<(])(?:www\.)?[a-z0-9.-]+\.[a-z]{2,}(?:\/[^\s)>"']*)?/i.test(String(raw || ""));
+}
+
 function detectIntent(raw, session) {
   const text = normalize(raw);
   const activeTask = session?.activeTask || null;
@@ -226,6 +230,12 @@ function detectIntent(raw, session) {
   const wantsDebug = hasAny(text, debugTerms);
   const wantsOperator = hasAny(text, operatorTerms);
   const wantsCoding = hasAny(text, codingTerms);
+  const hasUrl = hasResolvableUrl(raw);
+  const screenshotStorageComplaint =
+    activeTask?.type === "browser_capture" &&
+    wantsScreenshot &&
+    !hasUrl &&
+    /\b(ordner|datei|gespeichert|download|liegt|finde|fehlt|nicht im ordner|nicht da)\b/i.test(text);
 
   const scores = {
     installation:
@@ -233,7 +243,7 @@ function detectIntent(raw, session) {
       scoreApproxWords(text, ["installier", "installieren", "telegram", "telegramm", "plugin", "skill", "playwright"], 1.5) +
       scoreApproxPhrases(text, ["telegram bot", "playwright"], 2),
     browser_capture:
-      (wantsWebsite ? 2 : scoreApproxWords(text, ["website", "webseite"], 1.5)) +
+      ((wantsWebsite || hasUrl) ? 2 : scoreApproxWords(text, ["website", "webseite"], 1.5)) +
       (wantsScreenshot ? 3 : scoreApproxWords(text, ["screenshot", "screen"], 1.5)),
     website_builder:
       (wantsWebsite ? 2 : scoreApproxWords(text, ["website", "webseite", "landingpage", "homepage"], 1.5)) +
@@ -256,6 +266,10 @@ function detectIntent(raw, session) {
     return { kind: "followup", activeTask, scores, confidence: 1 };
   }
 
+  if (screenshotStorageComplaint) {
+    return { kind: "followup", activeTask, scores, confidence: 1 };
+  }
+
   if (/^(hi|hey|hallo|moin|servus|yo|na|guten morgen|guten abend)\b/.test(text) && text.split(" ").length <= 5) {
     return { kind: "chat", scores, confidence: 1 };
   }

package/tests/browser-controller.test.js

@@ -40,3 +40,8 @@ test("browser controller can save a screenshot file", async () => {
 
   await browser.close();
 });
+
+test("browser controller normalizes bracketed hostnames into valid urls", () => {
+  assert.equal(browser.normalizeUrl("<www.autofiles.de>"), "https://www.autofiles.de/");
+  assert.equal(browser.normalizeUrl("autofiles.de"), "https://autofiles.de/");
+});

package/tests/reference-inspector.test.js

@@ -34,3 +34,9 @@ test("reference helper builds a prompt block from inspected references", () => {
   assert.match(block, /Example/);
   assert.match(block, /example\.png/);
 });
+
+test("reference helper extracts and normalizes bare domains and bracketed urls", () => {
+  const urls = inspector.extractUrls("mach einen screenshot von <www.autofiles.de> und vielleicht auch autofiles.de");
+
+  assert.deepEqual(urls, ["https://www.autofiles.de/", "https://autofiles.de/"]);
+});