fanluc 2.0.0 → 2.4.0

package/dist/server.cjs

@@ -4,10 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -24,391 +20,1833 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // server.ts
-var server_exports = {};
-__export(server_exports, {
-  WORKSPACE_DIR: () => WORKSPACE_DIR,
-  startServer: () => startServer
-});
-module.exports = __toCommonJS(server_exports);
 var import_express = __toESM(require("express"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_fs = __toESM(require("fs"), 1);
-var import_os = __toESM(require("os"), 1);
-var import_child_process = require("child_process");
+var import_path3 = __toESM(require("path"), 1);
+var import_fs3 = __toESM(require("fs"), 1);
 var import_vite = require("vite");
 var import_google_translate_api_x = require("google-translate-api-x");
 var import_jsdom = require("jsdom");
 var import_readability = require("@mozilla/readability");
 var import_dotenv = __toESM(require("dotenv"), 1);
-var import_promises = __toESM(require("node:dns/promises"), 1);
+var import_promises2 = __toESM(require("node:dns/promises"), 1);
 var import_node_net = __toESM(require("node:net"), 1);
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
 
-// src/utils/decodeText.ts
-function decodeTextBuffer(buf) {
-  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
-    return { text: buf.subarray(3).toString("utf8"), encoding: "utf-8-bom" };
-  }
-  if (buf.length >= 2 && buf[0] === 255 && buf[1] === 254) {
-    return { text: buf.subarray(2).toString("utf16le"), encoding: "utf-16le" };
-  }
-  if (buf.length >= 2 && buf[0] === 254 && buf[1] === 255) {
-    const sw = Buffer.from(buf.subarray(2));
-    for (let i = 0; i + 1 < sw.length; i += 2) {
-      const t = sw[i];
-      sw[i] = sw[i + 1];
-      sw[i + 1] = t;
-    }
-    return { text: sw.toString("utf16le"), encoding: "utf-16be" };
-  }
-  const sample = buf.subarray(0, Math.min(buf.length, 1024));
-  let nulOdd = 0, nulTotal = 0;
-  for (let i = 0; i < sample.length; i++) if (sample[i] === 0) {
-    nulTotal++;
-    if (i % 2 === 1) nulOdd++;
-  }
-  if (sample.length >= 4 && nulTotal > sample.length * 0.2 && nulOdd >= nulTotal * 0.9) {
-    return { text: buf.toString("utf16le"), encoding: "utf-16le" };
-  }
+// localExec.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_os2 = __toESM(require("os"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var import_promises = require("stream/promises");
+
+// permissions.ts
+var import_fs = __toESM(require("fs"), 1);
+var import_os = __toESM(require("os"), 1);
+var import_path = __toESM(require("path"), 1);
+var DEFAULTS = {
+  modes: { create: "ask", move: "allow", delete: "ask", archive: "allow", install: "ask", edit: "allow" },
+  limits: { maxCreateMB: "", maxDeleteMB: "", maxInstallMB: "", maxToolCalls: "" }
+};
+var LABEL = {
+  create: "create file/folder",
+  move: "move/rename",
+  delete: "delete",
+  archive: "zip/unzip",
+  install: "install/uninstall libraries",
+  edit: "edit file"
+};
+var FILE = import_path.default.join(import_os.default.homedir(), ".fanluc", "permissions.json");
+var cache = null;
+function getPerms() {
+  if (cache) return cache;
+  let raw = {};
   try {
-    return { text: new TextDecoder("utf-8", { fatal: true }).decode(buf), encoding: "utf-8" };
+    raw = JSON.parse(import_fs.default.readFileSync(FILE, "utf-8"));
   } catch {
   }
+  cache = sanitize(raw);
+  return cache;
+}
+function sanitize(raw) {
+  const out = JSON.parse(JSON.stringify(DEFAULTS));
+  for (const k of Object.keys(DEFAULTS.modes)) {
+    const v = raw?.modes?.[k];
+    if (v === "allow" || v === "ask" || v === "deny") out.modes[k] = v;
+  }
+  for (const k of Object.keys(DEFAULTS.limits)) {
+    const v = raw?.limits?.[k];
+    if (typeof v === "string" || typeof v === "number") out.limits[k] = String(v).trim().replace(/[^0-9.]/g, "").slice(0, 12);
+  }
+  return out;
+}
+function setPerms(raw) {
+  cache = sanitize(raw);
   try {
-    return { text: new TextDecoder("windows-1258").decode(buf), encoding: "windows-1258" };
-  } catch {
+    import_fs.default.mkdirSync(import_path.default.dirname(FILE), { recursive: true });
+    import_fs.default.writeFileSync(FILE, JSON.stringify(cache, null, 2), { mode: 384 });
+  } catch (e) {
+    console.warn("[permissions] save failed:", e);
   }
-  return { text: buf.toString("latin1"), encoding: "latin1" };
+  return cache;
 }
-
-// src/core/security/blocklist.ts
-var import_node_path = __toESM(require("node:path"), 1);
-var DANGEROUS_PATTERNS = [
-  { pattern: /\bsudo\b|\bsu\s+(-|root)\b/i, reason: "privilege escalation (sudo/su)" },
-  { pattern: /\brm\s+(-[a-z]*r[a-z]*f[a-z]*|-[a-z]*f[a-z]*r[a-z]*)\s+\/(?!home\/|tmp\/|workspace)/i, reason: "recursive delete outside the workspace" },
-  { pattern: /\brm\s+(-[a-z]*r[a-z]*f[a-z]*|-[a-z]*f[a-z]*r[a-z]*)\s+[~*]\s*(\/|$)/i, reason: "recursive delete of home/root" },
-  { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&?\s*\}\s*;/, reason: "fork bomb" },
-  { pattern: /\bmkfs\b|\bdd\s+if=.*of=\/dev\/|\bshred\b/i, reason: "disk-level destructive command" },
-  { pattern: /\b(shutdown|reboot|halt|poweroff)\b/i, reason: "system power control" },
-  { pattern: /\bchmod\s+.*777\s+\//i, reason: "world-writable permission change on root" },
-  { pattern: /\b(curl|wget)\b[^\n|]*\|\s*(sudo\s+)?(bash|sh|zsh)\b/i, reason: "piping a remote script straight into a shell" },
-  { pattern: /\/etc\/(passwd|shadow|sudoers)\b/i, reason: "reading system credential files" },
-  { pattern: /\.env\b/i, reason: "accessing .env (may contain server secrets, not exposed to run_cmd on purpose)" },
-  { pattern: /\bnc\b.*-e\b|\/dev\/tcp\//i, reason: "raw reverse-shell / netcat exec pattern" },
-  { pattern: /\bcrontab\b/i, reason: "persistence via crontab" },
-  // --- Windows / PowerShell ---
-  { pattern: /\b(rd|rmdir)\b[^&|;]*\/s/i, reason: "Windows rd/rmdir /s recursive delete" },
-  { pattern: /\b(del|erase)\b[^&|;]*\/s/i, reason: "Windows del/erase /s recursive delete" },
-  { pattern: /\b(Format-Volume|Format-C|Clear-Disk|Remove-Partition)\b/i, reason: "Windows disk destructive command" },
-  { pattern: /\b(iwr|Invoke-WebRequest|Invoke-RestMethod|curl|wget)\b[^\n|;]*\|\s*(iex|Invoke-Expression)\b/i, reason: "PowerShell piping remote script into Invoke-Expression (iwr | iex)" },
-  { pattern: /\biex\b|\bInvoke-Expression\b/i, reason: "PowerShell Invoke-Expression" },
-  { pattern: /\b(Start-Process|Invoke-Item)\b.*\b(powershell|cmd|wscript|cscript)\b/i, reason: "PowerShell spawning shell via Start-Process" },
-  { pattern: /-EncodedCommand\b/i, reason: "PowerShell EncodedCommand (obfuscated script)" },
-  { pattern: /\bFromBase64String\b/i, reason: "PowerShell FromBase64String (obfuscated)" }
-];
-function tokenizeSegments(cmd) {
-  const segments = [];
+function limitBytes(s) {
+  const n = parseFloat(s);
+  return Number.isFinite(n) && n > 0 ? n * 1024 * 1024 : null;
+}
+var fmt = (b) => b >= 1024 * 1024 ? `${(b / 1024 / 1024).toFixed(1)} MB` : `${Math.max(1, Math.round(b / 1024))} KB`;
+var WIN = process.platform === "win32";
+function splitCommand(cmd) {
+  const segs = [];
   let tokens = [];
+  let redirects = [];
   let cur = "";
-  let hasCur = false;
-  let curFromPipe = false;
-  const pushToken = () => {
-    if (hasCur) tokens.push(cur);
+  let has = false;
+  let heredocEnd = null;
+  const pendingHeredocs = [];
+  const endWord = () => {
+    if (has) tokens.push(cur);
     cur = "";
-    hasCur = false;
+    has = false;
   };
-  const endSegment = (sep) => {
-    pushToken();
-    if (tokens.length) segments.push({ tokens, fromPipe: curFromPipe });
+  const endSeg = () => {
+    endWord();
+    if (tokens.length || redirects.length) segs.push({ tokens, redirects });
     tokens = [];
-    curFromPipe = sep === "|";
+    redirects = [];
+  };
+  const readWord = (i2) => {
+    while (i2 < cmd.length && (cmd[i2] === " " || cmd[i2] === "	")) i2++;
+    let w = "";
+    let q = null;
+    while (i2 < cmd.length) {
+      const c = cmd[i2];
+      if (q) {
+        if (c === q) q = null;
+        else w += c;
+      } else if (c === "'" || c === '"') q = c;
+      else if (/[\s;&|<>()]/.test(c)) break;
+      else w += c;
+      i2++;
+    }
+    return { word: w, next: i2 };
   };
-  for (let i = 0; i < cmd.length; i++) {
-    const ch = cmd[i];
-    if (ch === "'" || ch === '"') {
-      hasCur = true;
-      const q = ch;
+  let i = 0;
+  let quote = null;
+  while (i < cmd.length) {
+    const c = cmd[i];
+    if (quote) {
+      if (c === quote) quote = null;
+      else if (c === "\\" && quote === '"' && !WIN && i + 1 < cmd.length) {
+        cur += cmd[++i];
+      } else cur += c;
       i++;
-      while (i < cmd.length) {
-        if (cmd[i] === q) {
-          if (cmd[i + 1] === q) {
-            cur += q;
-            i += 2;
-            continue;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      quote = c;
+      has = true;
+      i++;
+      continue;
+    }
+    if (c === "\\" && !WIN && i + 1 < cmd.length) {
+      cur += cmd[i + 1];
+      has = true;
+      i += 2;
+      continue;
+    }
+    if (c === "\n") {
+      endSeg();
+      i++;
+      if (pendingHeredocs.length) {
+        for (const h of pendingHeredocs) {
+          while (i < cmd.length) {
+            let e = cmd.indexOf("\n", i);
+            if (e < 0) e = cmd.length;
+            const line = cmd.slice(i, e);
+            i = Math.min(cmd.length, e + 1);
+            if ((h.strip ? line.trim() : line.replace(/\r$/, "")) === h.marker) break;
           }
-          break;
         }
-        if (q === '"' && cmd[i] === "`" && i + 1 < cmd.length) {
-          cur += cmd[i + 1];
-          i += 2;
-          continue;
+        pendingHeredocs.length = 0;
+      }
+      continue;
+    }
+    if (c === ";" || c === "|" || c === "&") {
+      if ((c === "&" || c === "|") && cmd[i + 1] === c) i++;
+      endSeg();
+      i++;
+      continue;
+    }
+    if (c === "(" || c === ")") {
+      endSeg();
+      i++;
+      continue;
+    }
+    if (c === "<") {
+      if (cmd[i + 1] === "<" && cmd[i + 2] !== "<") {
+        let j = i + 2;
+        let strip = false;
+        if (cmd[j] === "-") {
+          strip = true;
+          j++;
         }
-        cur += cmd[i++];
+        const { word, next } = readWord(j);
+        if (word) pendingHeredocs.push({ marker: word, strip });
+        i = next;
+      } else {
+        const { next } = readWord(i + (cmd[i + 1] === "<" ? 3 : 1));
+        i = next;
       }
       continue;
     }
-    if (ch === ";" || ch === "\n" || ch === "\r" || ch === "&" || ch === "{" || ch === "}" || ch === "(" || ch === ")") {
-      endSegment(ch);
+    if (c === ">") {
+      let fd = "";
+      if (has && /^\d+$/.test(cur)) {
+        fd = cur;
+        cur = "";
+        has = false;
+      } else endWord();
+      let j = i + 1;
+      if (cmd[j] === ">") j++;
+      if (cmd[j] === "&") {
+        const r2 = readWord(j + 1);
+        i = r2.next;
+        continue;
+      }
+      const r = readWord(j);
+      i = r.next;
+      if (fd !== "2" && r.word) redirects.push(r.word);
       continue;
     }
-    if (ch === "|") {
-      endSegment("|");
+    if (c === " " || c === "	" || c === "\r") {
+      endWord();
+      i++;
       continue;
     }
-    if (ch === " " || ch === "	" || ch === ",") {
-      pushToken();
+    cur += c;
+    has = true;
+    i++;
+  }
+  endSeg();
+  void heredocEnd;
+  return segs;
+}
+var base = (s) => import_path.default.basename(s.replace(/\\/g, "/")).toLowerCase().replace(/\.(exe|cmd|bat|ps1|com)$/, "");
+var NPM_INST = {
+  npm: { inst: ["install", "i", "in", "ins", "inst", "add", "ci", "update", "up", "upgrade", "link", "ln", "rebuild", "dedupe"], un: ["uninstall", "remove", "rm", "r", "un", "unlink"] },
+  cnpm: { inst: ["install", "i", "add", "update"], un: ["uninstall", "remove", "rm"] },
+  pnpm: { inst: ["add", "install", "i", "update", "up", "upgrade", "link", "ln", "import", "dlx"], un: ["remove", "rm", "uninstall", "un", "unlink"] },
+  yarn: { inst: ["add", "install", "upgrade", "up", "global", "dlx", "link", ""], un: ["remove"] },
+  bun: { inst: ["add", "install", "i", "update", "link", "x"], un: ["remove", "rm", "unlink"] }
+};
+var SYS_PM = /* @__PURE__ */ new Set(["apt", "apt-get", "aptitude", "dnf", "yum", "zypper", "pacman", "apk", "brew", "choco", "winget", "scoop", "snap", "flatpak", "nix-env", "port", "pkg", "emerge", "xbps-install"]);
+var SYS_INST = /* @__PURE__ */ new Set(["install", "add", "upgrade", "dist-upgrade", "full-upgrade", "reinstall", "update-all"]);
+var SYS_UN = /* @__PURE__ */ new Set(["remove", "uninstall", "purge", "autoremove", "del", "erase"]);
+var PIP_VALUE_FLAGS = /* @__PURE__ */ new Set(["-r", "--requirement", "-e", "--editable", "-c", "--constraint", "-i", "--index-url", "--extra-index-url", "-t", "--target", "--prefix", "-f", "--find-links", "--python", "--root", "--src", "--cache-dir", "--proxy"]);
+function pkgArgs(args, valueFlags) {
+  const pkgs = [];
+  let explicit = true;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("-")) {
+      if (a === "-r" || a === "--requirement" || a === "-e" || a === "--editable" || a === "-c" || a === "--constraint") explicit = false;
+      if (valueFlags.has(a)) i++;
       continue;
     }
-    cur += ch;
-    hasCur = true;
-  }
-  endSegment(";");
-  return segments;
-}
-function looksWindows(opts) {
-  const ws = opts.workspaceDir || "";
-  return opts.platform === "win32" || /^[a-zA-Z]:[\\/]/.test(ws) || ws.startsWith("\\\\");
-}
-var UNIVERSAL_WILDCARD = /^(\.?[\\/])?\*+(\.\*)?$/;
-function classifyTarget(rawTarget, recurse, force, opts) {
-  const t = rawTarget.trim();
-  if (!t) return null;
-  if (t === "~" || /^~[\\/]/.test(t) || /\$home\b/i.test(t) || /\$env:/i.test(t) || /%[^%]+%/.test(t)) {
-    return "target is home directory or environment path (~, $HOME, $env:, %VAR%)";
-  }
-  if (recurse && (/\$/.test(t) || /`/.test(t))) {
-    return "recursive delete with a target that cannot be resolved statically (variable / subexpression)";
-  }
-  const hasWildcard = /[*?]/.test(t);
-  if (recurse && UNIVERSAL_WILDCARD.test(t)) {
-    return "recursive delete of everything via wildcard (*)";
-  }
-  if (recurse && force && hasWildcard) {
-    return "recursive + force delete with a wildcard target";
-  }
-  const isWin = looksWindows(opts);
-  const p = isWin ? import_node_path.default.win32 : import_node_path.default.posix;
-  const isAbs = /^[a-zA-Z]:/.test(t) || t.startsWith("\\\\") || t.startsWith("\\") || t.startsWith("/") || p.isAbsolute(t);
-  if (!isWin && (/^[a-zA-Z]:/.test(t) || t.startsWith("\\"))) {
-    return "target is a Windows-style absolute path outside the workspace";
-  }
-  const ws = opts.workspaceDir ? p.resolve(opts.workspaceDir) : null;
-  const norm = (s) => isWin ? s.toLowerCase() : s;
-  const forResolve = hasWildcard ? t.replace(/[\\/]?[^\\/]*[*?][^\\/]*$/, "") || "." : t;
-  if (!ws) {
-    if (isAbs) return "absolute path target (workspace unknown)";
-    if (forResolve.split(/[\\/]+/).includes("..")) return "target escapes the workspace (..)";
+    pkgs.push(a);
+  }
+  return { pkgs, explicit };
+}
+function installInfo(name, args) {
+  const global = args.some((a) => a === "-g" || a === "--global" || a === "global");
+  const subIdx = args.findIndex((a) => !a.startsWith("-"));
+  const sub = subIdx >= 0 ? args[subIdx].toLowerCase() : "";
+  const after = subIdx >= 0 ? args.slice(subIdx + 1) : [];
+  if (NPM_INST[name]) {
+    const t = NPM_INST[name];
+    const un = t.un.includes(sub);
+    if (!un && !t.inst.includes(sub)) return null;
+    if (name === "yarn" && sub === "" && args.length > 0 && !args.every((a) => a.startsWith("-"))) return null;
+    const p = pkgArgs(after.filter((a) => a !== "global"), /* @__PURE__ */ new Set(["--prefix", "--registry", "-w", "--workspace", "--cwd"]));
+    const noPkgsMeansAll = !un && p.pkgs.length === 0;
+    return { mgr: name, uninstall: un, pkgs: p.pkgs, explicit: !noPkgsMeansAll && p.explicit, global };
+  }
+  if (name === "npx" || name === "pnpx" || name === "bunx") {
+    const p = args.filter((a) => !a.startsWith("-"))[0];
+    return { mgr: "npm", uninstall: false, pkgs: p ? [p] : [], explicit: !!p, global: false };
+  }
+  if (name === "pip" || name === "pip3" || name === "pipx" || name === "pip3.11" || name === "pip3.12") {
+    const un = sub === "uninstall";
+    const inst = sub === "install" || sub === "download" || name === "pipx" && (sub === "run" || sub === "inject" || sub === "upgrade");
+    if (!un && !inst) return null;
+    const p = pkgArgs(after, PIP_VALUE_FLAGS);
+    return { mgr: "pip", uninstall: un, pkgs: p.pkgs, explicit: p.explicit && p.pkgs.length > 0, global: false };
+  }
+  if (/^python(\d(\.\d+)?)?$|^py$/.test(name)) {
+    const m = args.indexOf("-m");
+    if (m >= 0 && args[m + 1] === "pip") return installInfo("pip", args.slice(m + 2));
+    return null;
+  }
+  if (name === "uv") {
+    if (sub === "pip") return installInfo("pip", after);
+    if (sub === "add") return { mgr: "pip", uninstall: false, ...(() => {
+      const p = pkgArgs(after, /* @__PURE__ */ new Set());
+      return { pkgs: p.pkgs, explicit: p.explicit && p.pkgs.length > 0 };
+    })(), global: false };
+    if (sub === "remove") return { mgr: "pip", uninstall: true, pkgs: after.filter((a) => !a.startsWith("-")), explicit: false, global: false };
+    if (sub === "sync" || sub === "lock") return { mgr: "pip", uninstall: false, pkgs: [], explicit: false, global: false };
+    if (sub === "tool") {
+      const s2 = after.find((a) => !a.startsWith("-"));
+      if (s2 === "install" || s2 === "upgrade") return { mgr: "pip", uninstall: false, pkgs: [], explicit: false, global: true };
+      if (s2 === "uninstall") return { mgr: "pip", uninstall: true, pkgs: [], explicit: false, global: true };
+    }
     return null;
   }
-  const resolved = p.resolve(ws, forResolve);
-  const rel = p.relative(norm(ws), norm(resolved));
-  const escapes = rel === ".." || rel.startsWith(".." + p.sep) || p.isAbsolute(rel);
-  if (escapes) {
-    return isAbs ? "target is an absolute path outside the workspace" : "target escapes the workspace (..)";
+  if (name === "uvx") return { mgr: "pip", uninstall: false, pkgs: [], explicit: false, global: false };
+  if (name === "poetry" || name === "pdm" || name === "pipenv") {
+    if (["add", "install", "update", "sync"].includes(sub)) return { mgr: "pip", uninstall: false, pkgs: [], explicit: false, global: false };
+    if (sub === "remove") return { mgr: "pip", uninstall: true, pkgs: [], explicit: false, global: false };
+    return null;
   }
-  if (recurse && rel === "" && !hasWildcard) {
-    return "recursive delete of the workspace root itself";
+  if (name === "conda" || name === "mamba" || name === "micromamba") {
+    if (["install", "update", "upgrade"].includes(sub)) return { mgr: name, uninstall: false, pkgs: [], explicit: false, global: false };
+    if (["remove", "uninstall"].includes(sub)) return { mgr: name, uninstall: true, pkgs: [], explicit: false, global: false };
+    return null;
   }
+  if (SYS_PM.has(name)) {
+    const first = args[0] || "";
+    if (name === "pacman") {
+      if (/^-S/.test(first) && !/^-Ss|^-Si|^-Sq/.test(first)) return { mgr: name, uninstall: false, pkgs: [], explicit: false, global: true };
+      if (/^-R/.test(first)) return { mgr: name, uninstall: true, pkgs: [], explicit: false, global: true };
+      return null;
+    }
+    if (SYS_INST.has(sub)) return { mgr: name, uninstall: false, pkgs: after.filter((a) => !a.startsWith("-")), explicit: false, global: true };
+    if (SYS_UN.has(sub)) return { mgr: name, uninstall: true, pkgs: after.filter((a) => !a.startsWith("-")), explicit: false, global: true };
+    return null;
+  }
+  if (name === "cargo") {
+    if (sub === "install" || sub === "add") return { mgr: name, uninstall: false, pkgs: [], explicit: false, global: sub === "install" };
+    if (sub === "uninstall" || sub === "remove") return { mgr: name, uninstall: true, pkgs: [], explicit: false, global: sub === "uninstall" };
+    return null;
+  }
+  if (name === "go" && (sub === "install" || sub === "get")) return { mgr: name, uninstall: false, pkgs: [], explicit: false, global: false };
+  if (name === "gem" || name === "bundle" || name === "composer" || name === "dotnet" || name === "pecl") {
+    if (["install", "add", "require", "update"].includes(sub) || name === "dotnet" && sub === "tool") return { mgr: name, uninstall: false, pkgs: [], explicit: false, global: false };
+    if (["uninstall", "remove"].includes(sub)) return { mgr: name, uninstall: true, pkgs: [], explicit: false, global: false };
+    return null;
+  }
+  if (/^install-(module|package|script|packageprovider)$/.test(name)) return { mgr: "ps", uninstall: false, pkgs: [], explicit: false, global: true };
+  if (/^uninstall-(module|package|script)$/.test(name)) return { mgr: "ps", uninstall: true, pkgs: [], explicit: false, global: true };
   return null;
 }
-var PS_ONLY_DELETE = /* @__PURE__ */ new Set(["remove-item", "ri"]);
-var WIN_ALIAS_DELETE = /* @__PURE__ */ new Set(["rm", "del", "erase", "rd", "rmdir"]);
-var VALUE_FLAGS_TARGET = ["path", "literalpath"];
-var VALUE_FLAGS_SKIP = ["include", "exclude", "filter", "credential", "stream"];
-function flagMatches(name, full, minLen) {
-  const n = name.toLowerCase();
-  return n.length >= minLen && full.startsWith(n);
-}
-function analyzePowerShellDelete(command, opts) {
-  const platform = opts.platform ?? process.platform;
-  const heads = new Set(PS_ONLY_DELETE);
-  if (platform === "win32") for (const a of WIN_ALIAS_DELETE) heads.add(a);
-  const segments = tokenizeSegments(command);
-  let analyzedRemoveItem = 0;
-  for (const seg of segments) {
-    const head = (seg.tokens[0] || "").toLowerCase().replace(/^.*\\/, "");
-    if (!heads.has(head)) continue;
-    if (head === "remove-item") analyzedRemoveItem++;
-    let recurse = false;
-    let force = false;
-    const targets = [];
-    for (let i = 1; i < seg.tokens.length; i++) {
-      const tok = seg.tokens[i];
-      if (tok.startsWith("-") && tok.length > 1 && !/^-\d/.test(tok)) {
-        const body = tok.slice(1);
-        const colon = body.indexOf(":");
-        const name = colon >= 0 ? body.slice(0, colon) : body;
-        const inlineVal = colon >= 0 ? body.slice(colon + 1) : null;
-        if (flagMatches(name, "recurse", 1)) {
-          recurse = !(inlineVal && /^\$?false$/i.test(inlineVal));
-        } else if (flagMatches(name, "force", 2)) {
-          force = !(inlineVal && /^\$?false$/i.test(inlineVal));
-        } else if (VALUE_FLAGS_TARGET.some((f) => flagMatches(name, f, 1))) {
-          const v = inlineVal ?? seg.tokens[++i];
-          if (v) targets.push(v);
-        } else if (VALUE_FLAGS_SKIP.some((f) => flagMatches(name, f, 1))) {
-          if (inlineVal === null) i++;
-        }
+var NULL_TARGETS = /^(\/dev\/(null|stdout|stderr|tty|fd\/\d+)|nul|\$null|&\d+)$/i;
+var WRAPPERS = /* @__PURE__ */ new Set(["sudo", "doas", "time", "nohup", "command", "exec", "nice", "ionice", "stdbuf", "env", "builtin"]);
+var SHELLS = /* @__PURE__ */ new Set(["bash", "sh", "zsh", "dash", "ksh", "fish"]);
+function classify(cmd, cwd, depth = 0) {
+  const out = [];
+  if (depth > 3 || !cmd.trim()) return out;
+  for (const m of cmd.matchAll(/\$\(([^()]*)\)/g)) out.push(...classify(m[1], cwd, depth + 1));
+  for (const m of cmd.matchAll(/`([^`]*)`/g)) out.push(...classify(m[1], cwd, depth + 1));
+  for (const seg of splitCommand(cmd)) {
+    let t = seg.tokens.slice();
+    let viaXargs = false;
+    while (t.length) {
+      if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(t[0])) {
+        t.shift();
+        continue;
+      }
+      const n = base(t[0]);
+      if (WRAPPERS.has(n)) {
+        t.shift();
+        while (t.length && (t[0].startsWith("-") || /^[A-Za-z_][A-Za-z0-9_]*=/.test(t[0]))) t.shift();
         continue;
       }
-      targets.push(tok);
+      if (n === "xargs") {
+        viaXargs = true;
+        t.shift();
+        while (t.length && t[0].startsWith("-")) t.shift();
+        continue;
+      }
+      break;
+    }
+    if (t.length) {
+      const name = base(t[0]);
+      const args = t.slice(1);
+      const nonFlag = args.filter((a) => !a.startsWith("-"));
+      const sub = (nonFlag[0] || "").toLowerCase();
+      const has = (re) => args.some((a) => re.test(a));
+      if (SHELLS.has(name)) {
+        const i = args.findIndex((a) => /^-[a-z]*c$/.test(a));
+        if (i >= 0 && args[i + 1]) out.push(...classify(args[i + 1], cwd, depth + 1));
+      } else if (name === "powershell" || name === "pwsh") {
+        const i = args.findIndex((a) => /^-(c|command)$/i.test(a));
+        if (i >= 0) out.push(...classify(args.slice(i + 1).join(" "), cwd, depth + 1));
+      } else if (name === "cmd") {
+        const i = args.findIndex((a) => /^\/(c|k)$/i.test(a));
+        if (i >= 0) out.push(...classify(args.slice(i + 1).join(" "), cwd, depth + 1));
+      }
+      const flagLikeWin = (a) => WIN && /^\/[a-z?]$/i.test(a);
+      if (["rm", "rmdir", "del", "erase", "rd", "unlink", "shred", "trash", "trash-put", "remove-item", "ri"].includes(name)) {
+        const targets = [];
+        for (let i = 0; i < args.length; i++) {
+          const a = args[i];
+          if (/^-(path|literalpath)$/i.test(a)) {
+            if (args[i + 1]) targets.push(args[++i]);
+            continue;
+          }
+          if (a.startsWith("-") || flagLikeWin(a)) continue;
+          targets.push(a);
+        }
+        out.push({ cat: "delete", targets, dynamic: viaXargs || targets.length === 0 });
+      } else if (name === "git" && sub === "clean") {
+        out.push({ cat: "delete", dynamic: true });
+      } else if (name === "git" && sub === "rm") {
+        out.push({ cat: "delete", targets: nonFlag.slice(1), dynamic: nonFlag.length < 2 });
+      } else if (name === "find" && (args.includes("-delete") || args.includes("-exec") && /(^|\/)(rm|rmdir)$/.test(args[args.indexOf("-exec") + 1] || ""))) {
+        out.push({ cat: "delete", dynamic: true });
+      }
+      if (["mv", "move", "ren", "rename", "move-item", "mi", "rename-item", "rni"].includes(name) || name === "git" && sub === "mv") {
+        out.push({ cat: "move" });
+      }
+      if (["zip", "unzip", "tar", "7z", "7za", "7zr", "7zz", "gzip", "gunzip", "bzip2", "bunzip2", "xz", "unxz", "zstd", "unzstd", "rar", "unrar", "compress-archive", "expand-archive"].includes(name)) {
+        out.push({ cat: "archive" });
+      } else if (/^python(\d(\.\d+)?)?$|^py$/.test(name) && args[0] === "-m" && (args[1] === "zipfile" || args[1] === "tarfile")) {
+        out.push({ cat: "archive" });
+      }
+      const inst = installInfo(name, args);
+      if (inst) out.push({ cat: "install", install: inst });
+      if (["mkdir", "md", "touch", "new-item", "ni", "mkfifo", "cp", "copy", "copy-item", "cpi", "xcopy", "robocopy", "ln", "fallocate", "virtualenv"].includes(name)) {
+        out.push({ cat: "create" });
+      } else if (name === "git" && (sub === "clone" || sub === "init" || sub === "worktree")) {
+        out.push({ cat: "create" });
+      } else if (name === "curl" && has(/^(-[a-zA-Z]*[oOJ][a-zA-Z]*|--output|--remote-name|--create-dirs)$/)) {
+        out.push({ cat: "create" });
+      } else if (name === "wget" && !(args.includes("-O-") || args.some((a, i) => a === "-O" && args[i + 1] === "-") || has(/^-\w*O-$/))) {
+        out.push({ cat: "create" });
+      } else if (name === "dd" && has(/^of=/)) {
+        out.push({ cat: "create" });
+      } else if (name === "cargo" && (sub === "new" || sub === "init")) {
+        out.push({ cat: "create" });
+      } else if (name === "dotnet" && sub === "new") {
+        out.push({ cat: "create" });
+      } else if ((name === "npm" || name === "pnpm" || name === "yarn" || name === "bun") && (sub === "init" || sub === "create")) {
+        out.push({ cat: "create" });
+      } else if (name === "uv" && (sub === "venv" || sub === "init")) {
+        out.push({ cat: "create" });
+      } else if (/^python(\d(\.\d+)?)?$|^py$/.test(name) && args[0] === "-m" && args[1] === "venv") {
+        out.push({ cat: "create" });
+      } else if (name === "tee") {
+        for (const f of nonFlag) pushWriteTarget(out, f, cwd);
+      }
+      if (name === "sed" && has(/^(-[a-zA-Z]*i[a-zA-Z.]*|--in-place(=.*)?)$/)) out.push({ cat: "edit" });
+      else if (name === "perl" && has(/^-[a-zA-Z]*i[a-zA-Z.]*$/)) out.push({ cat: "edit" });
+      else if (name === "awk" && args.some((a, i) => a === "-i" && /inplace/.test(args[i + 1] || ""))) out.push({ cat: "edit" });
+      else if (["set-content", "sc", "add-content", "ac", "out-file", "clear-content", "patch", "sponge", "dos2unix", "unix2dos", "truncate"].includes(name)) out.push({ cat: "edit" });
+      else if (name === "git" && ["apply", "am", "restore"].includes(sub)) out.push({ cat: "edit" });
+      else if (name === "git" && sub === "reset" && args.includes("--hard")) out.push({ cat: "edit" });
+    }
+    for (const r of seg.redirects) pushWriteTarget(out, r, cwd);
+  }
+  return out;
+}
+function pushWriteTarget(out, target, cwd) {
+  if (!target || NULL_TARGETS.test(target)) return;
+  if (/[$`]/.test(target)) {
+    out.push({ cat: "edit" });
+    return;
+  }
+  const abs = resolveToken(target, cwd);
+  out.push({ cat: import_fs.default.existsSync(abs) ? "edit" : "create" });
+}
+function resolveToken(tok, cwd) {
+  let t = tok;
+  if (t === "~" || t.startsWith("~/") || t.startsWith("~\\")) t = import_path.default.join(import_os.default.homedir(), t.slice(1));
+  return import_path.default.resolve(cwd, t);
+}
+async function sizeOf(p, budget = { n: 3e5 }) {
+  let st;
+  try {
+    st = await import_fs.default.promises.lstat(p);
+  } catch {
+    return { bytes: 0, exists: false, complete: true };
+  }
+  if (!st.isDirectory()) return { bytes: st.size, exists: true, complete: true };
+  let bytes = 0;
+  let complete = true;
+  let entries = [];
+  try {
+    entries = await import_fs.default.promises.readdir(p);
+  } catch {
+    return { bytes: 0, exists: true, complete: false };
+  }
+  for (const e of entries) {
+    if (--budget.n < 0) {
+      complete = false;
+      break;
+    }
+    const r = await sizeOf(import_path.default.join(p, e), budget);
+    bytes += r.bytes;
+    if (!r.complete) complete = false;
+  }
+  return { bytes, exists: true, complete };
+}
+async function expandTargets(tokens, cwd) {
+  const paths = [];
+  let unknown = false;
+  for (const tok of tokens) {
+    if (/[$`]/.test(tok)) {
+      unknown = true;
+      continue;
+    }
+    const abs = resolveToken(tok, cwd);
+    const dir = import_path.default.dirname(abs);
+    const leaf = import_path.default.basename(abs);
+    if (/[*?[]/.test(dir)) {
+      unknown = true;
+      continue;
+    }
+    if (/[*?[]/.test(leaf)) {
+      try {
+        const re = new RegExp(
+          "^" + leaf.replace(/[.+^${}()|\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$"
+        );
+        for (const f of await import_fs.default.promises.readdir(dir)) if (re.test(f) && !(f.startsWith(".") && !leaf.startsWith("."))) paths.push(import_path.default.join(dir, f));
+      } catch {
+        unknown = true;
+      }
+    } else paths.push(abs);
+  }
+  return { paths, unknown };
+}
+async function fetchJson(url, ms = 6e3) {
+  const ac = new AbortController();
+  const t = setTimeout(() => ac.abort(), ms);
+  try {
+    const r = await fetch(url, { signal: ac.signal, headers: { accept: "application/json" } });
+    if (!r.ok) return null;
+    return await r.json();
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(t);
+  }
+}
+async function estimateInstallBytes(info) {
+  if (!info.explicit || info.pkgs.length === 0) return null;
+  let total = 0;
+  for (const spec of info.pkgs) {
+    if (/^(\.|\/|file:|git|http|github:|[a-z]:\\)/i.test(spec) || spec.includes("/") && !spec.startsWith("@")) return null;
+    if (info.mgr === "npm" || NPM_INST[info.mgr]) {
+      const m = spec.match(/^(@?[^@]+)(?:@(.+))?$/);
+      if (!m) return null;
+      const name = m[1];
+      const ver = m[2] && /^\d[\w.\-+]*$/.test(m[2]) ? m[2] : "latest";
+      const j = await fetchJson(`https://registry.npmjs.org/${name.replace("/", "%2F")}/${ver}`);
+      const sz = j?.dist?.unpackedSize;
+      if (typeof sz !== "number") return null;
+      total += sz;
+    } else if (info.mgr === "pip") {
+      const m = spec.match(/^([A-Za-z0-9_.\-]+)(?:\[[^\]]*\])?(?:==([\w.\-+]+))?/);
+      if (!m) return null;
+      const j = await fetchJson(m[2] ? `https://pypi.org/pypi/${m[1]}/${m[2]}/json` : `https://pypi.org/pypi/${m[1]}/json`);
+      const files = j?.urls || [];
+      if (!files.length) return null;
+      const wheels = files.filter((f) => f.packagetype === "bdist_wheel");
+      const pool = wheels.length ? wheels : files;
+      total += Math.min(...pool.map((f) => Number(f.size) || Infinity));
+    } else return null;
+  }
+  return Number.isFinite(total) ? total : null;
+}
+var pending = /* @__PURE__ */ new Map();
+var seq = 0;
+var APPROVAL_TIMEOUT_MS = 10 * 60 * 1e3;
+function requestApproval(info) {
+  return new Promise((resolve) => {
+    const id = `ap${(++seq).toString(36)}${Date.now().toString(36).slice(-4)}`;
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      resolve({ allow: false, remember: false, timedOut: true });
+    }, APPROVAL_TIMEOUT_MS);
+    pending.set(id, {
+      info: { ...info, id, createdAt: Date.now() },
+      resolve: (d) => {
+        clearTimeout(timer);
+        pending.delete(id);
+        resolve(d);
+      }
+    });
+  });
+}
+async function evaluatePermission(command, cwd, opts) {
+  const cfg = getPerms();
+  const findings = classify(command, cwd);
+  const cats = new Set(findings.map((f) => f.cat));
+  for (const c of cats) {
+    if (cfg.modes[c] === "deny") {
+      return { ok: false, message: `Blocked by the user's permission settings: "${LABEL[c]}" is set to DENY. Don't retry this; use a different approach or tell the user.` };
     }
-    if (recurse && targets.length === 0 && seg.fromPipe) {
-      return "recursive delete with pipeline input (target unknown)";
+  }
+  const askCats = new Set([...cats].filter((c) => cfg.modes[c] === "ask"));
+  const modeAsk = new Set(askCats);
+  const reasons = [];
+  const delLimit = limitBytes(cfg.limits.maxDeleteMB);
+  if (delLimit) {
+    let total = 0;
+    for (const f of findings) {
+      if (f.cat === "delete") {
+        if (f.dynamic) {
+          askCats.add("delete");
+          reasons.push("can't tell from the command how much will be deleted");
+          continue;
+        }
+        const { paths, unknown } = await expandTargets(f.targets || [], cwd);
+        if (unknown) {
+          askCats.add("delete");
+          reasons.push("some delete targets can't be resolved (variables / complex globs)");
+        }
+        for (const p of paths) {
+          const s = await sizeOf(p);
+          total += s.bytes;
+          if (!s.complete) {
+            askCats.add("delete");
+            reasons.push(`${import_path.default.basename(p)} is too large to measure fully`);
+          }
+        }
+      } else if (f.cat === "install" && f.install?.uninstall) {
+        const i = f.install;
+        if (i.global || !(NPM_INST[i.mgr] || i.mgr === "npm") || i.pkgs.length === 0) {
+          askCats.add("install");
+          reasons.push("can't measure how much the uninstall removes");
+        } else {
+          for (const p of i.pkgs) {
+            const s = await sizeOf(import_path.default.join(cwd, "node_modules", p.replace(/@[^/]+$/, "")));
+            total += s.bytes;
+          }
+        }
+      }
+    }
+    if (total > delLimit) {
+      return { ok: false, message: `Blocked: this would delete about ${fmt(total)}, over the user's limit of ${cfg.limits.maxDeleteMB} MB. Don't retry; tell the user.` };
+    }
+  }
+  const insLimit = limitBytes(cfg.limits.maxInstallMB);
+  if (insLimit) {
+    let total = 0;
+    let unknown = false;
+    let any = false;
+    for (const f of findings) {
+      if (f.cat === "install" && f.install && !f.install.uninstall) {
+        any = true;
+        const b = await estimateInstallBytes(f.install);
+        if (b == null) unknown = true;
+        else total += b;
+      }
     }
-    if (recurse && targets.length === 0) {
-      return "recursive delete without an explicit target";
+    if (any && total > insLimit) {
+      return { ok: false, message: `Blocked: the named packages alone are about ${fmt(total)}, over the user's install limit of ${cfg.limits.maxInstallMB} MB. Don't retry; tell the user.` };
     }
-    for (const t of targets) {
-      const why = classifyTarget(t, recurse, force, opts);
-      if (why) return `PowerShell delete blocked: ${why}`;
+    if (any && unknown) {
+      askCats.add("install");
+      reasons.push("install size can't be verified beforehand");
     }
   }
-  const rawCount = (command.match(/\bRemove-Item\b/gi) || []).length;
-  if (rawCount > analyzedRemoveItem && /-r(e(c(u(r(s(e)?)?)?)?)?)?\b/i.test(command)) {
-    return "PowerShell recursive delete inside a nested/quoted command (cannot verify target)";
+  if (askCats.size > 0) {
+    const d = await requestApproval({ command, cwd, categories: [...askCats].map((c) => LABEL[c]), reasons: [...new Set(reasons)] });
+    if (!d.allow) {
+      return {
+        ok: false,
+        message: d.timedOut ? "The user did not answer the permission prompt in time, so the command was NOT run. Ask them first, then retry." : "The user denied this command. Don't retry it; tell the user what you wanted to do or choose another approach."
+      };
+    }
+    if (d.remember) {
+      const next = getPerms();
+      for (const c of modeAsk) next.modes[c] = "allow";
+      setPerms(next);
+    }
   }
-  return null;
+  const crLimit = limitBytes(cfg.limits.maxCreateMB);
+  if (crLimit && !cats.has("install")) {
+    return opts.canUlimit ? { ok: true, ulimitMb: crLimit / 1024 / 1024 } : { ok: true, scanBytes: crLimit };
+  }
+  return { ok: true };
 }
-function findBlockedPattern(command, opts = {}) {
-  for (const { pattern, reason } of DANGEROUS_PATTERNS) {
-    if (pattern.test(command)) return reason;
+var SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", ".venv", "venv", "__pycache__", "dist", "build", ".next", "target"]);
+async function removeOversizeNewFiles(root, sinceMs, limit) {
+  const removed = [];
+  let visits = 0;
+  async function walk(dir) {
+    let ents = [];
+    try {
+      ents = await import_fs.default.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of ents) {
+      if (++visits > 6e4) return;
+      const full = import_path.default.join(dir, e.name);
+      if (e.isDirectory()) {
+        if (!SKIP_DIRS.has(e.name)) await walk(full);
+      } else if (e.isFile()) {
+        try {
+          const st = await import_fs.default.promises.stat(full);
+          if (st.size > limit && st.birthtimeMs >= sinceMs - 1e3) {
+            await import_fs.default.promises.rm(full, { force: true });
+            removed.push(`${import_path.default.relative(root, full)} (${fmt(st.size)})`);
+          }
+        } catch {
+        }
+      }
+    }
   }
-  return analyzePowerShellDelete(command, opts);
+  await walk(root);
+  return removed;
+}
+function registerPermissionRoutes(app, requireLocal2) {
+  app.get("/api/permissions", requireLocal2, (_req, res) => res.json(getPerms()));
+  app.post("/api/permissions", requireLocal2, (req, res) => res.json(setPerms(req.body)));
+  app.get("/api/permissions/pending", requireLocal2, (_req, res) => res.json({ pending: [...pending.values()].map((p) => p.info) }));
+  app.post("/api/permissions/decide", requireLocal2, (req, res) => {
+    const { id, allow, remember } = req.body || {};
+    const p = pending.get(String(id));
+    if (!p) return res.status(404).json({ error: "No such pending request (maybe it already timed out)" });
+    p.resolve({ allow: !!allow, remember: !!remember && !!allow });
+    return res.json({ ok: true });
+  });
 }
 
-// server.ts
-var import_client = require("@modelcontextprotocol/sdk/client/index.js");
-var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
-var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
-import_dotenv.default.config();
-var IS_WINDOWS = process.platform === "win32";
-function resolveWorkspaceDir() {
-  const override = process.env.FANLUC_WORKSPACE?.trim();
-  if (override) return import_path.default.resolve(override);
-  if (process.env.WORKSPACE_DIR?.trim()) return import_path.default.resolve(process.env.WORKSPACE_DIR.trim());
-  return import_path.default.join(process.cwd(), "workspace");
-}
-var WORKSPACE_DIR = resolveWorkspaceDir();
-function isInsideWorkspace(p) {
-  const rel = import_path.default.relative(WORKSPACE_DIR, import_path.default.resolve(p));
-  return rel === "" || !rel.startsWith("..") && !import_path.default.isAbsolute(rel);
-}
-try {
-  import_fs.default.mkdirSync(WORKSPACE_DIR, { recursive: true });
-} catch (e) {
-  console.error("Failed to create workspace dir:", e);
-}
-var SAFE_ENV = IS_WINDOWS ? {
-  PATH: process.env.PATH,
-  SystemRoot: process.env.SystemRoot,
-  windir: process.env.windir,
-  COMSPEC: process.env.COMSPEC,
-  OS: process.env.OS,
-  SystemDrive: process.env.SystemDrive,
-  TEMP: process.env.TEMP,
-  TMP: process.env.TMP,
-  // On Windows, don't override HOME/USERPROFILE to WORKSPACE_DIR — that causes
-  // PowerShell to create AppData\Local inside the workspace (polluting project).
-  // Keep original USERPROFILE/HOME so profile data stays in real home.
-  HOME: process.env.HOME || process.env.USERPROFILE || WORKSPACE_DIR,
-  USERPROFILE: process.env.USERPROFILE || process.env.HOME || WORKSPACE_DIR,
-  APPDATA: process.env.APPDATA,
-  LOCALAPPDATA: process.env.LOCALAPPDATA,
-  PYTHONDONTWRITEBYTECODE: "1",
-  PATHEXT: process.env.PATHEXT,
-  LANG: process.env.LANG || "en_US.UTF-8"
-} : {
-  PATH: process.env.PATH,
-  HOME: WORKSPACE_DIR,
-  LANG: process.env.LANG || "en_US.UTF-8",
-  PYTHONDONTWRITEBYTECODE: "1"
-};
-var permissionGrants = { file: 0, shell: 0 };
-var GRANT_TTL_MS = Number(process.env.FANLUC_GRANT_TTL_MS) > 0 ? Number(process.env.FANLUC_GRANT_TTL_MS) : 5 * 60 * 1e3;
-function isGranted(type) {
-  return permissionGrants[type] > Date.now();
+// localExec.ts
+var import_child_process = require("child_process");
+var HOME_DIR = process.env.FANLUC_HOME || import_path2.default.join(import_os2.default.homedir(), ".fanluc");
+var CONFIG_FILE = import_path2.default.join(HOME_DIR, "config.json");
+function readConfig() {
+  try {
+    return JSON.parse(import_fs2.default.readFileSync(CONFIG_FILE, "utf-8")) || {};
+  } catch {
+    return {};
+  }
 }
-function grantPermission(type) {
-  const until = Date.now() + GRANT_TTL_MS;
-  if (type === "all" || type === "file") permissionGrants.file = until;
-  if (type === "all" || type === "shell") permissionGrants.shell = until;
+function writeConfig(cfg) {
+  try {
+    import_fs2.default.mkdirSync(HOME_DIR, { recursive: true });
+    import_fs2.default.writeFileSync(CONFIG_FILE, JSON.stringify(cfg, null, 2), "utf-8");
+  } catch (e) {
+    console.warn("[workspace] could not save config:", e?.message || e);
+  }
 }
-function clearGrants() {
-  permissionGrants = { file: 0, shell: 0 };
+function isDir(p) {
+  try {
+    return import_fs2.default.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
 }
-var FIREJAIL_AVAILABLE = false;
-if (!IS_WINDOWS) {
+function pickInitialWorkspace() {
+  const forced = process.env.WORKSPACE_DIR || process.env.WORKSPACE;
+  if (forced && isDir(forced)) return import_path2.default.resolve(forced);
+  const saved = readConfig().workspace;
+  if (saved && isDir(saved)) return import_path2.default.resolve(saved);
+  const fallback = import_path2.default.join(process.cwd(), "workspace");
   try {
-    (0, import_child_process.execFileSync)("which", ["firejail"], { stdio: "ignore" });
-    FIREJAIL_AVAILABLE = true;
-    console.log("[run_cmd] firejail detected \u2014 sandboxing run_cmd with it.");
+    import_fs2.default.mkdirSync(fallback, { recursive: true });
   } catch {
-    console.warn(
-      "[run_cmd] firejail not found \u2014 run_cmd will still be jailed to " + WORKSPACE_DIR + " with a stripped env + blocklist, but for real OS-level isolation install firejail (`sudo apt-get install -y firejail`) or run this whole server inside a Docker container."
-    );
   }
-} else {
-  console.log("[run_cmd] Windows detected \u2014 firejail disabled, using PowerShell/cmd sandbox (blocklist enforced, permission ask blocks by default)");
+  return fallback;
+}
+var currentWorkspace = pickInitialWorkspace();
+function getWorkspace() {
+  return currentWorkspace;
 }
-var ZIP_AVAILABLE = false;
-var UNZIP_AVAILABLE = false;
-if (!IS_WINDOWS) {
+var workspaceListeners = [];
+function onWorkspaceChange(cb) {
+  workspaceListeners.push(cb);
+}
+function setWorkspace(dir) {
+  if (!dir || typeof dir !== "string") return { ok: false, error: "Missing path" };
+  const abs = import_path2.default.resolve(dir.trim().replace(/^~(?=$|[\\/])/, import_os2.default.homedir()));
+  if (!isDir(abs)) return { ok: false, error: `Folder does not exist: ${abs}` };
   try {
-    (0, import_child_process.execFileSync)("which", ["zip"], { stdio: "ignore" });
-    ZIP_AVAILABLE = true;
+    import_fs2.default.accessSync(abs, import_fs2.default.constants.R_OK | import_fs2.default.constants.W_OK);
   } catch {
+    return { ok: false, error: `No read/write permission: ${abs}` };
   }
+  currentWorkspace = abs;
+  const cfg = readConfig();
+  const recent = [abs, ...(cfg.recent || []).filter((r) => r !== abs)].filter(isDir).slice(0, 10);
+  writeConfig({ workspace: abs, recent });
+  console.log(`[workspace] now: ${abs}`);
+  for (const cb of workspaceListeners) {
+    try {
+      cb(abs);
+    } catch {
+    }
+  }
+  return { ok: true, workspace: abs };
+}
+function resolveInWorkspace(rel) {
+  const clean = String(rel || "").trim().replace(/^(\.\/|\/|\\)+/, "");
+  const abs = import_path2.default.resolve(currentWorkspace, clean);
+  if (abs === currentWorkspace) return abs;
+  return abs.startsWith(currentWorkspace + import_path2.default.sep) ? abs : null;
+}
+function agentDir(workspaceId) {
+  if (!workspaceId || typeof workspaceId !== "string") return currentWorkspace;
+  const safeId = workspaceId.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 64);
+  if (!safeId) return currentWorkspace;
+  const dir = import_path2.default.join(currentWorkspace, ".fanluc", "agents", safeId);
   try {
-    (0, import_child_process.execFileSync)("which", ["unzip"], { stdio: "ignore" });
-    UNZIP_AVAILABLE = true;
+    import_fs2.default.mkdirSync(dir, { recursive: true });
   } catch {
   }
-} else {
+  return dir;
+}
+function which(name) {
   try {
-    (0, import_child_process.execFileSync)("where", ["zip"], { stdio: "ignore" });
-    ZIP_AVAILABLE = true;
+    const finder = process.platform === "win32" ? "where" : "which";
+    const out = (0, import_child_process.execFileSync)(finder, [name], { stdio: ["ignore", "pipe", "ignore"] }).toString().split(/\r?\n/)[0].trim();
+    return out || null;
   } catch {
+    return null;
+  }
+}
+function shellFromBinary(bin) {
+  const base2 = import_path2.default.basename(bin).toLowerCase();
+  if (base2.includes("pwsh") || base2.includes("powershell")) {
+    return {
+      bin,
+      kind: "powershell",
+      label: base2.includes("pwsh") ? "PowerShell 7 (pwsh)" : "Windows PowerShell",
+      args: (cmd) => ["-NoLogo", "-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", cmd]
+    };
+  }
+  if (base2 === "cmd.exe" || base2 === "cmd") {
+    return { bin, kind: "cmd", label: "cmd.exe", args: (cmd) => ["/d", "/s", "/c", cmd] };
   }
+  return { bin, kind: "posix", label: base2.includes("bash") ? "bash" : base2, args: (cmd) => ["-c", cmd] };
+}
+function detectShell() {
+  const override = process.env.FANLUC_SHELL;
+  if (override) return shellFromBinary(override);
+  if (process.platform === "win32") {
+    const pf = process.env.ProgramFiles || "C:\\Program Files";
+    const pf86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+    const local = process.env.LOCALAPPDATA || "";
+    const gitBash = [
+      import_path2.default.join(pf, "Git", "bin", "bash.exe"),
+      import_path2.default.join(pf86, "Git", "bin", "bash.exe"),
+      local && import_path2.default.join(local, "Programs", "Git", "bin", "bash.exe")
+    ].filter(Boolean);
+    for (const c of gitBash) if (import_fs2.default.existsSync(c)) return { ...shellFromBinary(c), label: "Git Bash" };
+    const pwsh = which("pwsh");
+    if (pwsh) return shellFromBinary(pwsh);
+    return shellFromBinary(which("powershell") || "powershell.exe");
+  }
+  const bash = which("bash");
+  return shellFromBinary(bash || "/bin/sh");
+}
+var SHELL = detectShell();
+function systemInfo() {
+  return {
+    platform: process.platform,
+    arch: process.arch,
+    os: `${import_os2.default.type()} ${import_os2.default.release()}`,
+    shell: SHELL.label,
+    shellKind: SHELL.kind,
+    home: import_os2.default.homedir(),
+    workspace: currentWorkspace,
+    node: process.version,
+    python: which("python3") ? "python3" : which("python") ? "python" : null,
+    git: !!which("git")
+  };
+}
+var STRIP_ENV = new Set(
+  ["GEMINI_API_KEY", "TOKEN", "ADMIN_TOKEN", "ACCESS_TOKEN", ...(process.env.STRIP_ENV || "").split(",").map((s) => s.trim())].filter(Boolean)
+);
+function buildEnv() {
+  const env = {};
+  for (const [k, v] of Object.entries(process.env)) if (!STRIP_ENV.has(k)) env[k] = v;
+  return {
+    ...env,
+    PYTHONIOENCODING: "utf-8",
+    PYTHONUTF8: "1",
+    NO_COLOR: "1",
+    FORCE_COLOR: "0",
+    GIT_TERMINAL_PROMPT: "0",
+    // fail instead of hanging on a credential prompt
+    GIT_PAGER: "cat",
+    PAGER: "cat",
+    npm_config_yes: "true",
+    DEBIAN_FRONTEND: "noninteractive",
+    MPLBACKEND: env.MPLBACKEND || "Agg"
+  };
+}
+var CATASTROPHIC = [
+  { pattern: /\brm\s+(-[a-z]*\s+)*-[a-z]*[rf][a-z]*\s+(-[a-z]+\s+)*(--no-preserve-root\s+)?(\/|~|\$HOME|\/\*|~\/\*)\s*(;|&|\||$)/i, reason: "recursive delete of / or home" },
+  { pattern: /\bmkfs(\.\w+)?\b/i, reason: "formatting a filesystem" },
+  { pattern: /\bdd\b[^\n]*\bof=\/dev\/(sd|nvme|hd|disk|mmcblk)/i, reason: "writing raw to a disk device" },
+  { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&?\s*\}\s*;/, reason: "fork bomb" },
+  { pattern: /\bformat\s+[a-z]:/i, reason: "formatting a drive" },
+  { pattern: /\b(rd|rmdir)\s+\/s\s+(\/q\s+)?[a-z]:\\?\s*$/i, reason: "deleting a whole drive" },
+  { pattern: /\bRemove-Item\b[^\n]*-Recurse[^\n]*\s[a-z]:\\?\s*$/i, reason: "deleting a whole drive" }
+];
+function findBlocked(command) {
+  if (process.env.FANLUC_UNRESTRICTED === "1") return null;
+  for (const { pattern, reason } of CATASTROPHIC) if (pattern.test(command)) return reason;
+  return null;
+}
+function killTree(child) {
+  const pid = child.pid;
+  if (!pid) return;
   try {
-    (0, import_child_process.execFileSync)("where", ["unzip"], { stdio: "ignore" });
-    UNZIP_AVAILABLE = true;
+    if (process.platform === "win32") {
+      (0, import_child_process.spawn)("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+    } else {
+      try {
+        process.kill(-pid, "SIGTERM");
+      } catch {
+        child.kill("SIGTERM");
+      }
+      setTimeout(() => {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }
+      }, 2e3).unref?.();
+    }
   } catch {
   }
 }
-function preprocessCommand(command) {
-  let trimmed = command.trim();
-  if (!ZIP_AVAILABLE && /^zip\s+/i.test(trimmed)) {
-    const parts = trimmed.split(/\s+/).slice(1);
-    if (parts.length >= 2) {
-      const zipFile = parts[0];
-      const files = parts.slice(1).join(" ");
-      return `python3 -m zipfile -c ${zipFile} ${files}`;
+var CAN_ULIMIT = process.platform !== "win32" && SHELL.kind === "posix";
+function spawnShell(command, cwd) {
+  return (0, import_child_process.spawn)(SHELL.bin, SHELL.args(command), {
+    cwd,
+    env: buildEnv(),
+    stdio: ["ignore", "pipe", "pipe"],
+    // no stdin: interactive prompts fail fast instead of hanging
+    detached: process.platform !== "win32",
+    // own process group so we can kill the whole tree
+    windowsHide: true
+  });
+}
+var MAX_CAPTURE = 2 * 1024 * 1024;
+var MAX_RETURN = Number(process.env.FANLUC_MAX_RETURN) > 0 ? Number(process.env.FANLUC_MAX_RETURN) : 1e5;
+function runCommand(command, cwd, timeoutMs) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawnShell(command, cwd);
+    } catch (e) {
+      return resolve({ stdout: "", stderr: `Failed to start shell (${SHELL.bin}): ${e?.message || e}`, exitCode: 127, timedOut: false, truncated: false });
     }
+    let stdout = "";
+    let stderr = "";
+    let truncated = false;
+    let timedOut = false;
+    const add = (which2, d) => {
+      const s = d.toString("utf-8");
+      if (which2 === "o") stdout += s;
+      else stderr += s;
+      if (stdout.length + stderr.length > MAX_CAPTURE) {
+        truncated = true;
+        stdout = stdout.slice(-MAX_CAPTURE / 2);
+        stderr = stderr.slice(-MAX_CAPTURE / 2);
+      }
+    };
+    child.stdout?.on("data", (d) => add("o", d));
+    child.stderr?.on("data", (d) => add("e", d));
+    const timer = setTimeout(() => {
+      timedOut = true;
+      killTree(child);
+    }, timeoutMs);
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr: stderr + `
+[spawn error: ${err.message}]`, exitCode: 127, timedOut, truncated });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, exitCode: code, timedOut, truncated });
+    });
+  });
+}
+var BG_JOBS = /* @__PURE__ */ new Map();
+var BG_MAX_LOG = 3e5;
+var BG_MAX_CONCURRENT = 20;
+var BG_EVICT_MS = 30 * 60 * 1e3;
+var bgSeq = 0;
+function bgAppend(job, chunk) {
+  if (!chunk) return;
+  job.log += chunk;
+  if (job.log.length > BG_MAX_LOG) {
+    job.log = job.log.slice(job.log.length - BG_MAX_LOG);
+    job.truncated = true;
   }
-  if (!UNZIP_AVAILABLE && /^unzip\s+/i.test(trimmed)) {
-    const parts = trimmed.split(/\s+/).slice(1);
-    let zipFile = "";
-    let outDir = WORKSPACE_DIR;
-    for (let i = 0; i < parts.length; i++) {
-      if (parts[i] === "-d" && parts[i + 1]) {
-        outDir = parts[i + 1];
-        i++;
-      } else if (!zipFile && !parts[i].startsWith("-")) {
-        zipFile = parts[i];
+}
+function bgStatus(job) {
+  if (job.status === "exited") return `exited (code ${job.exitCode})`;
+  return job.status;
+}
+function lastLine(text) {
+  const lines = text.split("\n").map((l) => l.trimEnd());
+  for (let i = lines.length - 1; i >= 0; i--) if (lines[i].trim()) return lines[i];
+  return "(no output yet)";
+}
+function bgEvictLater(job) {
+  setTimeout(() => {
+    if (BG_JOBS.get(job.id) === job) BG_JOBS.delete(job.id);
+  }, BG_EVICT_MS).unref?.();
+}
+function killAllJobs() {
+  for (const j of BG_JOBS.values()) if (j.status === "running") killTree(j.child);
+}
+process.on("exit", killAllJobs);
+for (const sig of ["SIGINT", "SIGTERM"]) {
+  process.on(sig, () => {
+    killAllJobs();
+    process.exit(0);
+  });
+}
+function isLoopbackAddr(ip) {
+  return ip === "127.0.0.1" || ip === "::1" || ip === "::ffff:127.0.0.1";
+}
+function requireLocal(req, res, next) {
+  if (process.env.ALLOW_REMOTE_EXEC === "1") return next();
+  const ip = String(req.socket?.remoteAddress || "");
+  const viaProxy = !!req.headers["x-forwarded-for"] || !!req.headers["x-forwarded-host"];
+  const host = String(req.headers.host || "").replace(/:\d+$/, "").replace(/^\[|\]$/g, "").toLowerCase();
+  const extra = (process.env.ALLOWED_HOSTS || "").split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+  const hostOk = host === "localhost" || host === "127.0.0.1" || host === "::1" || host.endsWith(".localhost") || extra.includes(host);
+  if (isLoopbackAddr(ip) && !viaProxy && hostOk) return next();
+  return res.status(403).json({
+    error: "Local only: running commands / browsing folders is allowed only from the machine running the server (open http://localhost:PORT). Set ALLOW_REMOTE_EXEC=1 to override (dangerous).",
+    formattedText: "Blocked: this request did not come from localhost."
+  });
+}
+var SKIP_DIRS2 = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".cache",
+  ".venv",
+  "venv",
+  "env",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  "target",
+  "vendor",
+  ".gradle",
+  ".idea",
+  ".vscode",
+  "coverage",
+  ".turbo",
+  ".fanluc"
+]);
+var BINARY_EXT = /* @__PURE__ */ new Set([
+  "zip",
+  "gz",
+  "tar",
+  "tgz",
+  "rar",
+  "7z",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "bmp",
+  "ico",
+  "pdf",
+  "exe",
+  "dll",
+  "so",
+  "dylib",
+  "bin",
+  "apk",
+  "iso",
+  "mp3",
+  "mp4",
+  "mkv",
+  "avi",
+  "mov",
+  "wav",
+  "flac",
+  "ogg",
+  "woff",
+  "woff2",
+  "ttf",
+  "otf",
+  "class",
+  "jar",
+  "pyc",
+  "sqlite",
+  "db"
+]);
+var MAX_FILES = 5e3;
+var VIEW_LIMIT = 70 * 1024 * 1024;
+var MAX_INLINE_FILE = 256 * 1024 * 1024;
+async function listWorkspaceFiles(root) {
+  const files = {};
+  let count = 0;
+  let truncated = false;
+  async function walk(dir, rel) {
+    if (truncated) return;
+    let entries = [];
+    try {
+      entries = await import_fs2.default.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (truncated) return;
+      const name = entry.name;
+      if (entry.isDirectory()) {
+        if (SKIP_DIRS2.has(name) || name.startsWith(".")) continue;
+        await walk(import_path2.default.join(dir, name), rel ? `${rel}/${name}` : name);
+      } else if (entry.isFile()) {
+        if (name.startsWith(".")) continue;
+        if (count >= MAX_FILES) {
+          truncated = true;
+          return;
+        }
+        const full = import_path2.default.join(dir, name);
+        const relPath = rel ? `${rel}/${name}` : name;
+        let st;
+        try {
+          st = await import_fs2.default.promises.stat(full);
+        } catch {
+          continue;
+        }
+        const ext = name.split(".").pop()?.toLowerCase() || "";
+        let content;
+        if (BINARY_EXT.has(ext)) content = `[Binary File: ${name} (${(st.size / 1024).toFixed(1)} KB)]`;
+        else if (st.size > MAX_INLINE_FILE || st.size > VIEW_LIMIT && !/\.html?$/i.test(name))
+          content = `[Large File: ${(st.size / 1024).toFixed(1)} KB \u2014 read it with run_cmd (cat / sed -n)]`;
+        else {
+          try {
+            content = await import_fs2.default.promises.readFile(full, "utf-8");
+          } catch {
+            content = `[Unreadable File: ${(st.size / 1024).toFixed(1)} KB]`;
+          }
+        }
+        files[relPath] = { path: relPath, name, content, size: st.size, language: ext, updatedAt: st.mtimeMs };
+        count++;
       }
     }
-    if (zipFile) {
-      return `python3 -m zipfile -e ${zipFile} ${outDir}`;
+  }
+  await walk(root, "");
+  return { files, truncated, count };
+}
+var KV_FILE = import_path2.default.join(import_os2.default.homedir(), ".fanluc", "state.json");
+var kvCache = null;
+function kvLoad() {
+  if (kvCache) return kvCache;
+  try {
+    kvCache = JSON.parse(import_fs2.default.readFileSync(KV_FILE, "utf-8")) || {};
+  } catch {
+    kvCache = {};
+  }
+  return kvCache;
+}
+var kvTimer = null;
+function kvSave(data) {
+  kvCache = data;
+  if (kvTimer) return;
+  kvTimer = setTimeout(() => {
+    kvTimer = null;
+    try {
+      import_fs2.default.mkdirSync(import_path2.default.dirname(KV_FILE), { recursive: true });
+      const tmp = KV_FILE + ".tmp";
+      import_fs2.default.writeFileSync(tmp, JSON.stringify(kvCache), { mode: 384 });
+      import_fs2.default.renameSync(tmp, KV_FILE);
+    } catch (e) {
+      console.warn("[kv] save failed:", e);
+    }
+  }, 300);
+}
+process.on("exit", () => {
+  if (kvTimer) {
+    try {
+      import_fs2.default.mkdirSync(import_path2.default.dirname(KV_FILE), { recursive: true });
+      import_fs2.default.writeFileSync(KV_FILE, JSON.stringify(kvCache), { mode: 384 });
+    } catch {
     }
   }
-  return trimmed;
+});
+function clampTimeout(v) {
+  const n = Number(v);
+  if (!Number.isFinite(n) || n <= 0) return 12e4;
+  return Math.min(6e5, Math.max(1e3, n));
 }
-function findBlockedPattern2(command) {
-  return findBlockedPattern(command, { workspaceDir: WORKSPACE_DIR, platform: process.platform });
+function listRoots() {
+  const roots = [];
+  if (process.platform === "win32") {
+    for (let c = 65; c <= 90; c++) {
+      const d = `${String.fromCharCode(c)}:\\`;
+      try {
+        if (import_fs2.default.existsSync(d)) roots.push({ name: d, path: d });
+      } catch {
+      }
+    }
+  } else {
+    roots.push({ name: "/", path: "/" });
+  }
+  return roots;
+}
+function registerLocalRoutes(app) {
+  registerPermissionRoutes(app, requireLocal);
+  app.get("/api/workspace", requireLocal, (_req, res) => {
+    const cfg = readConfig();
+    res.json({
+      workspace: currentWorkspace,
+      name: import_path2.default.basename(currentWorkspace) || currentWorkspace,
+      recent: (cfg.recent || []).filter(isDir),
+      home: import_os2.default.homedir(),
+      roots: listRoots(),
+      system: systemInfo()
+    });
+  });
+  app.post("/api/workspace/set", requireLocal, (req, res) => {
+    const r = setWorkspace(String(req.body?.path || ""));
+    if (!r.ok) return res.status(400).json(r);
+    return res.json({ ok: true, workspace: r.workspace, name: import_path2.default.basename(r.workspace) || r.workspace });
+  });
+  app.get("/api/fs/browse", requireLocal, async (req, res) => {
+    try {
+      const raw = String(req.query.path || "").trim();
+      const target = import_path2.default.resolve(raw ? raw.replace(/^~(?=$|[\\/])/, import_os2.default.homedir()) : import_os2.default.homedir());
+      if (!isDir(target)) return res.status(404).json({ error: `Not a folder: ${target}` });
+      const showHidden = req.query.hidden === "1";
+      let entries = [];
+      try {
+        entries = await import_fs2.default.promises.readdir(target, { withFileTypes: true });
+      } catch (e) {
+        return res.status(403).json({ error: e?.message || "Cannot read folder" });
+      }
+      const dirs = entries.filter((e) => {
+        if (!e.isDirectory() && !(e.isSymbolicLink() && isDir(import_path2.default.join(target, e.name)))) return false;
+        return showHidden || !e.name.startsWith(".");
+      }).map((e) => e.name).sort((a, b) => a.localeCompare(b));
+      const parent = import_path2.default.dirname(target);
+      res.json({
+        path: target,
+        parent: parent === target ? null : parent,
+        dirs,
+        fileCount: entries.filter((e) => e.isFile()).length,
+        roots: listRoots()
+      });
+    } catch (e) {
+      res.status(500).json({ error: e?.message || "browse failed" });
+    }
+  });
+  app.post("/api/fs/mkdir", requireLocal, async (req, res) => {
+    try {
+      const parent = import_path2.default.resolve(String(req.body?.parent || ""));
+      const name = String(req.body?.name || "").trim();
+      if (!name || /[\\/:*?"<>|]/.test(name) || name === "." || name === "..") return res.status(400).json({ error: "Invalid folder name" });
+      if (!isDir(parent)) return res.status(404).json({ error: "Parent folder not found" });
+      const full = import_path2.default.join(parent, name);
+      await import_fs2.default.promises.mkdir(full, { recursive: false });
+      res.json({ ok: true, path: full });
+    } catch (e) {
+      res.status(500).json({ error: e?.message || "mkdir failed" });
+    }
+  });
+  app.get("/api/system-info", requireLocal, (_req, res) => res.json(systemInfo()));
+  app.post("/api/run-cmd", requireLocal, async (req, res) => {
+    if (process.env.DISABLE_RUN_CMD === "1") {
+      const msg = "run_cmd is disabled on this server (DISABLE_RUN_CMD=1).";
+      return res.json({ stdout: "", stderr: msg, formattedText: msg, blocked: true });
+    }
+    const { command, workspaceId, timeoutMs } = req.body || {};
+    if (!command || typeof command !== "string" || !command.trim()) {
+      return res.status(400).json({ error: "Missing command", formattedText: "Error: missing command" });
+    }
+    const trimmed = command.trim();
+    const blocked = findBlocked(trimmed);
+    if (blocked) {
+      const msg = `Command blocked as catastrophic: ${blocked}. (Set FANLUC_UNRESTRICTED=1 to disable this guard.)`;
+      return res.json({ stdout: "", stderr: msg, formattedText: msg, blocked: true });
+    }
+    const cwd = agentDir(workspaceId);
+    const limit = clampTimeout(timeoutMs);
+    const ev = await evaluatePermission(trimmed, cwd, { canUlimit: CAN_ULIMIT });
+    if (!ev.ok) {
+      return res.json({ stdout: "", stderr: ev.message, formattedText: `$ ${trimmed}
+${ev.message}`, blocked: true });
+    }
+    const startedAt = Date.now();
+    const toRun = ev.ulimitMb ? `ulimit -f ${Math.max(1, Math.floor(ev.ulimitMb * 1024))}; ${trimmed}` : trimmed;
+    const r = await runCommand(toRun, cwd, limit);
+    const out = r.stdout.slice(-MAX_RETURN);
+    const errOut = r.stderr.slice(-MAX_RETURN);
+    const notes = [];
+    if (r.truncated || r.stdout.length > MAX_RETURN || r.stderr.length > MAX_RETURN) notes.push("[output truncated \u2014 showing the end]");
+    if (ev.ulimitMb && r.exitCode === 153) notes.push("[stopped: a file would exceed the user's max file-size limit (permission settings)]");
+    if (ev.scanBytes) {
+      const removed = await removeOversizeNewFiles(cwd, startedAt, ev.scanBytes);
+      if (removed.length) notes.push(`[removed new files over the user's max file-size limit: ${removed.join(", ")}]`);
+    }
+    if (r.timedOut) notes.push(`[timed out after ${Math.round(limit / 1e3)}s and was killed \u2014 use run_cmd_bg for long-running commands]`);
+    const body = `${out}${errOut ? (out ? "\n" : "") + errOut : ""}`.trim() || "(no output)";
+    const formattedText = `$ ${trimmed}
+${body}${notes.length ? "\n" + notes.join("\n") : ""}${!r.timedOut && r.exitCode ? `
+[exit code ${r.exitCode}]` : ""}`;
+    return res.json({ stdout: out, stderr: errOut, exitCode: r.exitCode, timedOut: r.timedOut, formattedText });
+  });
+  app.post("/api/run-cmd-bg", requireLocal, async (req, res) => {
+    if (process.env.DISABLE_RUN_CMD === "1") {
+      return res.json({ id: null, formattedText: "run_cmd_bg is disabled on this server.", blocked: true });
+    }
+    const { command, workspaceId } = req.body || {};
+    if (!command || typeof command !== "string" || !command.trim()) {
+      return res.status(400).json({ error: "Missing command", formattedText: "Error: missing command" });
+    }
+    const trimmed = command.trim();
+    const blocked = findBlocked(trimmed);
+    if (blocked) return res.json({ id: null, formattedText: `Command blocked as catastrophic: ${blocked}.`, blocked: true });
+    const ev = await evaluatePermission(trimmed, agentDir(workspaceId), { canUlimit: CAN_ULIMIT });
+    if (!ev.ok) return res.json({ id: null, formattedText: `$ ${trimmed}
+${ev.message}`, blocked: true });
+    const running = [...BG_JOBS.values()].filter((j) => j.status === "running").length;
+    if (running >= BG_MAX_CONCURRENT) {
+      return res.json({ id: null, formattedText: `Too many background commands running (max ${BG_MAX_CONCURRENT}). Kill one with kill_cmd_bg first.`, blocked: true });
+    }
+    let child;
+    try {
+      child = spawnShell(ev.ulimitMb ? `ulimit -f ${Math.max(1, Math.floor(ev.ulimitMb * 1024))}; ${trimmed}` : trimmed, agentDir(workspaceId));
+    } catch (e) {
+      return res.json({ id: null, formattedText: `Failed to start background command: ${e?.message || e}`, blocked: true });
+    }
+    const id = `bg${(++bgSeq).toString(36)}${Date.now().toString(36).slice(-4)}`;
+    const job = { id, command: trimmed, child, log: "", truncated: false, status: "running", exitCode: null, startedAt: Date.now(), endedAt: null };
+    BG_JOBS.set(id, job);
+    child.stdout?.on("data", (d) => bgAppend(job, d.toString()));
+    child.stderr?.on("data", (d) => bgAppend(job, d.toString()));
+    child.on("error", (err) => {
+      bgAppend(job, `
+[process error: ${err.message}]
+`);
+      job.status = "error";
+      job.endedAt = Date.now();
+      bgEvictLater(job);
+    });
+    child.on("exit", (code, signal) => {
+      job.exitCode = code;
+      job.endedAt = Date.now();
+      if (job.status === "running") job.status = "exited";
+      if (signal) bgAppend(job, `
+[terminated by signal ${signal}]
+`);
+      bgEvictLater(job);
+    });
+    return res.json({ id, formattedText: `Started background command ${id}: ${trimmed}` });
+  });
+  app.post("/api/kill-cmd-bg", requireLocal, (req, res) => {
+    const { id } = req.body || {};
+    const job = id && BG_JOBS.get(id);
+    if (!job) return res.json({ formattedText: `No background command with id "${id}" (it may have finished and been cleaned up).` });
+    if (job.status !== "running") return res.json({ formattedText: `${id} is not running (status: ${bgStatus(job)}).` });
+    job.status = "killed";
+    killTree(job.child);
+    return res.json({ formattedText: `Killed ${id} (${job.command}).` });
+  });
+  app.post("/api/read-cmd-bg-log", requireLocal, (req, res) => {
+    const { id, offset, limit } = req.body || {};
+    const job = id && BG_JOBS.get(id);
+    if (!job) return res.json({ formattedText: `No background command with id "${id}" (it may have finished and been cleaned up).` });
+    const lines = job.log.split("\n");
+    const off = Math.max(1, parseInt(offset, 10) || 1);
+    const lim = Math.max(1, Math.min(2e3, parseInt(limit, 10) || 200));
+    const slice = lines.slice(off - 1, off - 1 + lim);
+    const header = `[${id}] status: ${bgStatus(job)} | command: ${job.command} | log lines: ${lines.length}${job.truncated ? " (older lines were trimmed)" : ""}`;
+    return res.json({ formattedText: `${header}
+${slice.join("\n") || "(nothing at this offset)"}` });
+  });
+  app.post("/api/list-cmd-bg", requireLocal, (_req, res) => {
+    const jobs = [...BG_JOBS.values()].sort((a, b) => a.startedAt - b.startedAt);
+    if (!jobs.length) return res.json({ formattedText: "No background commands.", jobs: [] });
+    const rows = jobs.map((j) => ({ id: j.id, command: j.command, status: bgStatus(j), lastLogLine: lastLine(j.log) }));
+    return res.json({ formattedText: rows.map((r) => `- ${r.id} | ${r.status} | ${r.command}
+  last: ${r.lastLogLine}`).join("\n"), jobs: rows });
+  });
+  app.post("/api/agent-workspace-export", requireLocal, async (req, res) => {
+    const safeId = typeof req.body?.workspaceId === "string" ? req.body.workspaceId.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 64) : "";
+    if (!safeId) return res.status(400).json({ error: "Missing workspaceId" });
+    const dir = import_path2.default.join(currentWorkspace, ".fanluc", "agents", safeId);
+    if (!import_fs2.default.existsSync(dir)) return res.status(404).json({ error: "This agent has no workspace files yet." });
+    try {
+      const { default: JSZip } = await import("jszip");
+      const zip = new JSZip();
+      const walk = async (d, rel) => {
+        for (const e of await import_fs2.default.promises.readdir(d, { withFileTypes: true })) {
+          const p = import_path2.default.join(d, e.name);
+          const r = rel ? `${rel}/${e.name}` : e.name;
+          if (e.isDirectory()) await walk(p, r);
+          else if (e.isFile()) zip.file(r, await import_fs2.default.promises.readFile(p));
+        }
+      };
+      await walk(dir, "");
+      const buf = await zip.generateAsync({ type: "nodebuffer", compression: "DEFLATE" });
+      res.setHeader("Content-Type", "application/zip");
+      res.setHeader("Content-Disposition", `attachment; filename="agent-${safeId}-workspace.zip"`);
+      res.send(buf);
+    } catch (e) {
+      res.status(500).json({ error: e?.message || String(e) });
+    }
+  });
+  app.post("/api/agent-workspace-clear", requireLocal, (req, res) => {
+    const safeId = typeof req.body?.workspaceId === "string" ? req.body.workspaceId.replace(/[^a-zA-Z0-9_-]/g, "").slice(0, 64) : "";
+    if (!safeId) return res.status(400).json({ error: "Missing workspaceId" });
+    const dir = import_path2.default.join(currentWorkspace, ".fanluc", "agents", safeId);
+    try {
+      import_fs2.default.rmSync(dir, { recursive: true, force: true });
+      import_fs2.default.mkdirSync(dir, { recursive: true });
+      res.json({ ok: true, formattedText: `Cleared workspace for agent ${safeId}.` });
+    } catch (e) {
+      res.status(500).json({ error: e?.message || String(e) });
+    }
+  });
+  app.post("/api/install-pack", (_req, res) => {
+    res.json({
+      ok: true,
+      formattedText: "[INSTALL_PACK_V1 STATUS: SUCCESS]\nThis build runs commands directly on the user's machine. There is nothing to install automatically: use run_cmd with the tool's own installer (pip install X, npm i X, winget/brew/apt) when something is missing."
+    });
+  });
+  app.post("/api/upload-workspace-file", requireLocal, async (req, res) => {
+    try {
+      const { name, content, encoding = "utf-8" } = req.body || {};
+      if (!name || typeof name !== "string") return res.status(400).json({ error: "Missing file name" });
+      const filePath = resolveInWorkspace(name);
+      if (!filePath || filePath === currentWorkspace) return res.status(403).json({ error: "Invalid file path outside workspace" });
+      await import_fs2.default.promises.mkdir(import_path2.default.dirname(filePath), { recursive: true });
+      let buffer;
+      if ((encoding === "base64" || name.toLowerCase().endsWith(".zip")) && typeof content === "string") {
+        buffer = Buffer.from(content.includes(",") ? content.split(",")[1] : content, "base64");
+      } else if (typeof content === "string") {
+        buffer = Buffer.from(content, "utf-8");
+      } else {
+        buffer = Buffer.from("");
+      }
+      await import_fs2.default.promises.writeFile(filePath, buffer);
+      const st = await import_fs2.default.promises.stat(filePath);
+      return res.json({ success: true, path: import_path2.default.relative(currentWorkspace, filePath).split(import_path2.default.sep).join("/"), name: import_path2.default.basename(filePath), size: st.size, updatedAt: st.mtimeMs });
+    } catch (err) {
+      return res.status(500).json({ error: err?.message || "Failed to upload workspace file" });
+    }
+  });
+  app.post("/api/delete-workspace-file", requireLocal, async (req, res) => {
+    try {
+      const p = req.body?.path;
+      if (!p || typeof p !== "string") return res.status(400).json({ error: "Missing file path" });
+      const target = resolveInWorkspace(p);
+      if (!target || target === currentWorkspace) return res.status(403).json({ error: "Invalid file path outside workspace" });
+      if (import_fs2.default.existsSync(target)) await import_fs2.default.promises.rm(target, { recursive: true, force: true });
+      return res.json({ success: true, path: p });
+    } catch (err) {
+      return res.status(500).json({ error: err?.message || "Failed to delete workspace file" });
+    }
+  });
+  app.post("/api/workspace/upload-raw", requireLocal, async (req, res) => {
+    try {
+      const rel = String(req.query.path || "");
+      if (!rel) return res.status(400).json({ error: "Missing path" });
+      const target = resolveInWorkspace(rel);
+      if (!target || target === currentWorkspace) return res.status(403).json({ error: "Invalid file path outside workspace" });
+      await import_fs2.default.promises.mkdir(import_path2.default.dirname(target), { recursive: true });
+      await (0, import_promises.pipeline)(req, import_fs2.default.createWriteStream(target));
+      const st = await import_fs2.default.promises.stat(target);
+      return res.json({ success: true, path: import_path2.default.relative(currentWorkspace, target).split(import_path2.default.sep).join("/"), size: st.size, updatedAt: st.mtimeMs });
+    } catch (err) {
+      return res.status(500).json({ error: err?.message || "Upload failed" });
+    }
+  });
+  app.post("/api/workspace/reveal", requireLocal, async (req, res) => {
+    try {
+      const target = resolveInWorkspace(String(req.body?.path || ""));
+      if (!target || !import_fs2.default.existsSync(target)) return res.status(404).json({ error: "Not found" });
+      let bin;
+      let args;
+      if (process.platform === "win32") {
+        bin = "explorer.exe";
+        args = [`/select,${target}`];
+      } else if (process.platform === "darwin") {
+        bin = "open";
+        args = ["-R", target];
+      } else {
+        bin = "xdg-open";
+        args = [import_path2.default.dirname(target)];
+      }
+      const child = (0, import_child_process.spawn)(bin, args, { detached: true, stdio: "ignore", windowsHide: false });
+      child.on("error", () => {
+      });
+      child.unref();
+      return res.json({ ok: true });
+    } catch (err) {
+      return res.status(500).json({ error: err?.message || "Could not open folder" });
+    }
+  });
+  app.get("/api/workspace/file", requireLocal, async (req, res) => {
+    try {
+      const target = resolveInWorkspace(String(req.query.path || ""));
+      if (!target || target === currentWorkspace || !import_fs2.default.existsSync(target)) return res.status(404).json({ error: "Not found" });
+      const st = await import_fs2.default.promises.stat(target);
+      if (!st.isFile()) return res.status(400).json({ error: "Not a file" });
+      res.setHeader("Content-Type", "application/octet-stream");
+      res.setHeader("Content-Length", String(st.size));
+      res.setHeader("Content-Disposition", `attachment; filename*=UTF-8''${encodeURIComponent(import_path2.default.basename(target))}`);
+      import_fs2.default.createReadStream(target).on("error", () => res.destroy()).pipe(res);
+    } catch (err) {
+      return res.status(500).json({ error: err?.message || "Download failed" });
+    }
+  });
+  app.get("/api/kv", requireLocal, (_req, res) => res.json({ data: kvLoad() }));
+  app.post("/api/kv", requireLocal, (req, res) => {
+    const { set, remove } = req.body || {};
+    const data = kvLoad();
+    if (set && typeof set === "object") {
+      for (const [k, v] of Object.entries(set)) if (typeof v === "string") data[k] = v;
+    }
+    if (Array.isArray(remove)) for (const k of remove) delete data[String(k)];
+    kvSave(data);
+    return res.json({ ok: true });
+  });
+  app.get("/api/workspace-files", requireLocal, async (_req, res) => {
+    try {
+      const { files, truncated, count } = await listWorkspaceFiles(currentWorkspace);
+      return res.json({ files, truncated, count, workspace: currentWorkspace });
+    } catch (err) {
+      return res.status(500).json({ error: err?.message || "Failed to list workspace files" });
+    }
+  });
+}
+
+// localSearch.ts
+var UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
+function detectLocale() {
+  const env = process.env.SEARCH_LANG;
+  if (env) return env;
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().locale || "en-US";
+  } catch {
+    return "en-US";
+  }
+}
+var LOCALE = detectLocale();
+var LANG = LOCALE.split("-")[0] || "en";
+var REGION = (LOCALE.split("-")[1] || "US").toUpperCase();
+var ACCEPT_LANGUAGE = `${LOCALE},${LANG};q=0.9,en;q=0.8`;
+function decodeEntities(s) {
+  return s.replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0?39;|&apos;/g, "'").replace(/&nbsp;/g, " ").replace(/&#x([0-9a-f]+);/gi, (_m, h) => String.fromCodePoint(parseInt(h, 16))).replace(/&#(\d+);/g, (_m, d) => String.fromCodePoint(parseInt(d, 10)));
+}
+function stripTags(s) {
+  return decodeEntities(s.replace(/<[^>]*>/g, " ")).replace(/\s+/g, " ").trim();
+}
+async function getText(url, ms, headers = {}) {
+  const resp = await fetch(url, {
+    headers: { "User-Agent": UA, "Accept-Language": ACCEPT_LANGUAGE, ...headers },
+    signal: AbortSignal.timeout(ms)
+  });
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+  return await resp.text();
+}
+async function getJson(url, ms, headers = {}) {
+  const resp = await fetch(url, {
+    headers: { "User-Agent": UA, Accept: "application/json", "Accept-Language": ACCEPT_LANGUAGE, ...headers },
+    signal: AbortSignal.timeout(ms)
+  });
+  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+  return await resp.json();
+}
+var health = /* @__PURE__ */ new Map();
+function engineStatus() {
+  const out = {};
+  const now = Date.now();
+  for (const [k, h] of health) out[k] = { ok: h.until <= now, fails: h.fails, retryInSec: Math.max(0, Math.round((h.until - now) / 1e3)), lastError: h.lastError };
+  return out;
+}
+async function runEngine(name, fn, timeoutMs = 5e3) {
+  const h = health.get(name);
+  if (h && h.until > Date.now()) return [];
+  try {
+    const res = await Promise.race([
+      fn(),
+      new Promise((_r, rej) => setTimeout(() => rej(new Error(`timeout ${timeoutMs}ms`)), timeoutMs).unref?.())
+    ]);
+    if (res.length === 0) {
+      const cur = health.get(name) || { fails: 0, until: 0 };
+      cur.fails += 0.5;
+      if (cur.fails >= 3) cur.until = Date.now() + 2 * 60 * 1e3;
+      health.set(name, cur);
+    } else {
+      health.delete(name);
+    }
+    return res;
+  } catch (e) {
+    const cur = health.get(name) || { fails: 0, until: 0 };
+    cur.fails += 1;
+    cur.lastError = e?.message || String(e);
+    if (cur.fails >= 2) cur.until = Date.now() + Math.min(30, 2 ** (cur.fails - 1)) * 60 * 1e3;
+    health.set(name, cur);
+    return [];
+  }
+}
+var cache2 = /* @__PURE__ */ new Map();
+async function cached(key, ttlMs, fn, shouldCache = () => true) {
+  const hit = cache2.get(key);
+  if (hit && hit.exp > Date.now()) return hit.value;
+  const value = await fn();
+  if (shouldCache(value)) {
+    cache2.set(key, { exp: Date.now() + ttlMs, value });
+    if (cache2.size > 300) cache2.delete(cache2.keys().next().value);
+  }
+  return value;
+}
+function dedupeKey(url) {
+  try {
+    const u = new URL(url);
+    return (u.hostname.replace(/^www\./, "") + u.pathname.replace(/\/$/, "")).toLowerCase();
+  } catch {
+    return url.toLowerCase();
+  }
+}
+function fuseResults(lists) {
+  const K = 60;
+  const map = /* @__PURE__ */ new Map();
+  for (const list of lists) {
+    list.forEach((hit, i) => {
+      const key = dedupeKey(hit.url);
+      const add = 1 / (K + i + 1);
+      const cur = map.get(key);
+      if (cur) {
+        cur.score += add;
+        if ((hit.snippet || "").length > (cur.hit.snippet || "").length) cur.hit = { ...cur.hit, snippet: hit.snippet };
+        cur.hit.engine += `+${hit.engine}`;
+      } else map.set(key, { hit: { ...hit }, score: add });
+    });
+  }
+  return [...map.values()].sort((a, b) => b.score - a.score).map((x) => x.hit);
+}
+async function searchMojeek(query, count) {
+  const html = await getText(`https://www.mojeek.com/search?q=${encodeURIComponent(query.trim())}&lb=${LANG}`, 5e3);
+  const out = [];
+  const re = /<li[^>]*>\s*<h2>\s*<a[^>]+href="(https?:\/\/[^"]+)"[^>]*class="title"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/li>/gi;
+  const re2 = /<a[^>]+class="title"[^>]+href="(https?:\/\/[^"]+)"[^>]*>([\s\S]*?)<\/a>([\s\S]*?)(?=<a[^>]+class="title"|<\/ul>)/gi;
+  let m;
+  while ((m = re2.exec(html)) !== null && out.length < count * 2) {
+    const title = stripTags(m[2]);
+    const sn = m[3].match(/<p[^>]*class="s"[^>]*>([\s\S]*?)<\/p>/i);
+    const snippet = sn ? stripTags(sn[1]) : title;
+    if (title) out.push({ url: decodeEntities(m[1]), title, snippet, engine: "mojeek" });
+  }
+  void re;
+  return out;
+}
+async function searchBingLocal(query, count) {
+  const html = await getText(
+    `https://www.bing.com/search?q=${encodeURIComponent(query.trim())}&count=${Math.min(30, count * 3)}&setlang=${encodeURIComponent(LOCALE)}&cc=${REGION}`,
+    5e3
+  );
+  if (/captcha|unusual traffic|verify you are a human|\/ck\/a\?!&&p=.*challenge/i.test(html) && !/class="b_algo"/.test(html)) throw new Error("bing captcha");
+  const out = [];
+  const re = /<li class="b_algo"[^>]*>[\s\S]*?<h2[^>]*>[\s\S]*?<a href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/h2>([\s\S]*?)<\/li>/gi;
+  let m;
+  while ((m = re.exec(html)) !== null && out.length < count * 2) {
+    const url = decodeEntities(m[1]);
+    if (!url.startsWith("http")) continue;
+    const title = stripTags(m[2]);
+    const p = m[3].match(/<p[^>]*>([\s\S]*?)<\/p>/i) || m[3].match(/<div class="b_caption"[^>]*>([\s\S]*?)<\/div>/i);
+    out.push({ url, title, snippet: p ? stripTags(p[1]) : title, engine: "bing" });
+  }
+  return out;
+}
+async function searchWikipedia(query, count) {
+  const langs = LANG === "en" ? ["en"] : [LANG, "en"];
+  const lists = await Promise.all(
+    langs.map(async (lg) => {
+      try {
+        const j = await getJson(
+          `https://${lg}.wikipedia.org/w/api.php?action=query&list=search&srsearch=${encodeURIComponent(query.trim())}&srlimit=${Math.min(5, count)}&format=json&utf8=1`,
+          4e3
+        );
+        return (j?.query?.search || []).map((r) => ({
+          url: `https://${lg}.wikipedia.org/wiki/${encodeURIComponent(String(r.title).replace(/ /g, "_"))}`,
+          title: String(r.title),
+          snippet: stripTags(String(r.snippet || r.title)),
+          engine: "wikipedia"
+        }));
+      } catch {
+        return [];
+      }
+    })
+  );
+  return lists.flat().slice(0, count);
+}
+async function raceUntilEnough(tasks, enough, deadlineMs = 4500, graceMs = 350) {
+  const collected = tasks.map(() => []);
+  return new Promise((resolve) => {
+    let done = false;
+    let graceTimer = null;
+    let pending2 = tasks.length;
+    const finish = () => {
+      if (done) return;
+      done = true;
+      clearTimeout(deadline);
+      if (graceTimer) clearTimeout(graceTimer);
+      resolve(collected.map((c) => c.slice()));
+    };
+    const deadline = setTimeout(finish, deadlineMs);
+    tasks.forEach((t, i) => {
+      t.then((r) => {
+        collected[i] = r;
+      }).catch(() => {
+      }).finally(() => {
+        pending2--;
+        if (pending2 === 0) return finish();
+        if (!done && !graceTimer && enough(collected)) graceTimer = setTimeout(finish, graceMs);
+      });
+    });
+    if (tasks.length === 0) finish();
+  });
+}
+var STOP = /* @__PURE__ */ new Set(["a", "an", "the", "of", "and", "or", "in", "on", "for", "to", "with", "image", "images", "photo", "photos", "picture", "pictures", "pic", "anh", "hinh"]);
+function norm(s) {
+  return s.normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/\u0111/g, "d").replace(/\u0110/g, "D").toLowerCase();
+}
+function matchesAllKeywords(query, text) {
+  const toks = norm(query).split(/[^a-z0-9\u0080-\uffff]+/).filter((t) => t && !STOP.has(t));
+  if (toks.length === 0) return false;
+  const hay = norm(text);
+  return toks.every((t) => {
+    if (/[^\x00-\x7f]/.test(t)) return hay.includes(t);
+    return new RegExp(`(^|[^a-z0-9])${t.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(s|es)?($|[^a-z0-9])`).test(hay);
+  });
+}
+async function imagesSearxng(baseUrl, query, count) {
+  if (!baseUrl) return [];
+  const params = new URLSearchParams({ q: query.trim(), format: "json", categories: "images", pageno: "1" });
+  const j = await getJson(`${baseUrl.replace(/\/$/, "")}/search?${params}`, 4e3);
+  const out = [];
+  for (const x of Array.isArray(j.results) ? j.results : []) {
+    const src = String(x.img_src || "");
+    if (!/^https?:\/\//i.test(src)) continue;
+    out.push({ title: String(x.title || x.content || query), src, thumb: String(x.thumbnail_src || x.thumbnail || src), page: String(x.url || src), engine: "searxng" });
+    if (out.length >= count * 2) break;
+  }
+  return out;
+}
+async function imagesBing(query, count) {
+  const html = await getText(
+    `https://www.bing.com/images/async?q=${encodeURIComponent(query.trim())}&first=0&count=${Math.min(35, count * 3)}&mmasync=1&setlang=${encodeURIComponent(LOCALE)}`,
+    6e3
+  );
+  const out = [];
+  const tagRe = /<a\b[^>]*\bclass="[^"]*\biusc\b[^"]*"[^>]*>/gi;
+  let t;
+  while ((t = tagRe.exec(html)) !== null && out.length < count * 2) {
+    const mm = t[0].match(/\bm="([^"]*)"/) || t[0].match(/\bm='([^']*)'/);
+    if (!mm) continue;
+    try {
+      const j = JSON.parse(decodeEntities(mm[1]));
+      const src = String(j.murl || "");
+      if (!/^https?:\/\//i.test(src)) continue;
+      out.push({ title: decodeEntities(String(j.t || j.desc || query)).replace(/<[^>]*>/g, ""), src, thumb: String(j.turl || src), page: String(j.purl || src), engine: "bing-img" });
+    } catch {
+    }
+  }
+  return out;
+}
+async function imagesWikimedia(query, count) {
+  const params = new URLSearchParams({
+    action: "query",
+    format: "json",
+    generator: "search",
+    gsrnamespace: "6",
+    gsrlimit: String(Math.min(20, count * 2)),
+    gsrsearch: query.trim(),
+    prop: "imageinfo",
+    iiprop: "url|mime",
+    iiurlwidth: "480",
+    origin: "*"
+  });
+  const j = await getJson(`https://commons.wikimedia.org/w/api.php?${params}`, 5e3);
+  const pages = Object.values(j?.query?.pages || {});
+  pages.sort((a, b) => (a.index || 0) - (b.index || 0));
+  const out = [];
+  for (const p of pages) {
+    const ii = p.imageinfo?.[0];
+    if (!ii || !/^image\/(jpeg|png|webp|gif)$/.test(ii.mime || "")) continue;
+    if (!matchesAllKeywords(query, String(p.title || "").replace(/^File:/, ""))) continue;
+    out.push({ title: String(p.title || query).replace(/^File:/, ""), src: ii.url, thumb: ii.thumburl || ii.url, page: ii.descriptionurl || ii.url, engine: "wikimedia" });
+  }
+  return out;
+}
+async function imagesOpenverse(query, count) {
+  const j = await getJson(`https://api.openverse.org/v1/images/?q=${encodeURIComponent(query.trim())}&page_size=${Math.min(20, count * 2)}`, 6e3);
+  const out = [];
+  for (const x of Array.isArray(j.results) ? j.results : []) {
+    const src = String(x.url || "");
+    if (!/^https?:\/\//i.test(src)) continue;
+    const text = `${x.title || ""} ${(Array.isArray(x.tags) ? x.tags : []).map((t) => t?.name || "").join(" ")}`;
+    if (!matchesAllKeywords(query, text)) continue;
+    out.push({ title: String(x.title || query), src, thumb: String(x.thumbnail || src), page: String(x.foreign_landing_url || src), engine: "openverse" });
+  }
+  return out;
+}
+async function searchImages(query, count, searxUrl = "") {
+  const key = `img:${LOCALE}:${searxUrl}:${query.toLowerCase().trim()}:${count}`;
+  return cached(
+    key,
+    10 * 60 * 1e3,
+    async () => {
+      const seen = /* @__PURE__ */ new Set();
+      const merged = [];
+      const push = (list) => {
+        for (const h of list) {
+          const k = h.src.split("?")[0].toLowerCase();
+          if (seen.has(k)) continue;
+          seen.add(k);
+          merged.push(h);
+        }
+      };
+      const lists = await raceUntilEnough(
+        [
+          searxUrl ? runEngine("img:searxng", () => imagesSearxng(searxUrl, query, count), 4e3) : Promise.resolve([]),
+          runEngine("img:bing", () => imagesBing(query, count), 4e3),
+          runEngine("img:wikimedia", () => imagesWikimedia(query, count), 4e3),
+          runEngine("img:openverse", () => imagesOpenverse(query, count), 4e3)
+        ],
+        (c) => c.reduce((n, a) => n + a.length, 0) >= count,
+        4500
+      );
+      const main = [lists[0], lists[1]];
+      const maxLen = Math.max(...main.map((a) => a.length), 0);
+      for (let i = 0; i < maxLen; i++) for (const a of main) if (a[i]) push([a[i]]);
+      push(lists[2]);
+      push(lists[3]);
+      return merged.slice(0, count);
+    },
+    (v) => v.length > 0
+  );
 }
+
+// server.ts
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_streamableHttp = require("@modelcontextprotocol/sdk/client/streamableHttp.js");
+var import_sse = require("@modelcontextprotocol/sdk/client/sse.js");
+import_dotenv.default.config();
 var DESKTOP_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
 var BLOCKED_HOST_SUFFIXES = [
   "facebook.com",
@@ -544,68 +1982,6 @@ function stripInnerTags(str) {
   if (!str) return "";
   return str.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
 }
-async function searchDuckDuckGo(query, count) {
-  const results = [];
-  try {
-    const q = encodeURIComponent(query.trim());
-    const resp = await fetch(`https://html.duckduckgo.com/html/?q=${q}&kl=wt-wt`, {
-      headers: {
-        "User-Agent": DESKTOP_UA,
-        "Accept-Language": "en-US,en;q=0.9,vi;q=0.8"
-      }
-    });
-    if (!resp.ok) return results;
-    const html = await resp.text();
-    const resultRegex = /<a[^>]+class="result__a"[^>]+href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<a[^>]+class="result__snippet"[^>]*>([\s\S]*?)<\/a>/gi;
-    let m;
-    while ((m = resultRegex.exec(html)) !== null && results.length < count * 2) {
-      let url = m[1];
-      if (url.startsWith("//duckduckgo.com/l/")) {
-        const uddgMatch = url.match(/[?&]uddg=([^&]+)/);
-        if (uddgMatch) url = decodeURIComponent(uddgMatch[1]);
-      } else if (url.startsWith("//")) {
-        url = "https:" + url;
-      }
-      if (!url.startsWith("http")) continue;
-      const title = decodeHtmlEntities(stripInnerTags(m[2]));
-      const snippet = decodeHtmlEntities(stripInnerTags(m[3])) || title;
-      if (!title && !snippet) continue;
-      results.push({ url, title, snippet, engine: "duckduckgo" });
-    }
-  } catch (err) {
-    console.warn("DuckDuckGo search error:", err);
-  }
-  return results;
-}
-async function searchBing(query, count) {
-  const results = [];
-  try {
-    const q = encodeURIComponent(query.trim());
-    const resp = await fetch(`https://www.bing.com/search?q=${q}&count=${Math.min(30, count * 3)}&setlang=en-US`, {
-      headers: {
-        "User-Agent": DESKTOP_UA,
-        "Accept-Language": "en-US,en;q=0.9,vi;q=0.8"
-      }
-    });
-    if (!resp.ok) return results;
-    const html = await resp.text();
-    const resultRegex = /<li class="b_algo"[^>]*>[\s\S]*?<h2>[\s\S]*?<a href="([^"]+)"[^>]*>([\s\S]*?)<\/a>[\s\S]*?<\/h2>([\s\S]*?)<\/li>/gi;
-    let m;
-    while ((m = resultRegex.exec(html)) !== null && results.length < count * 2) {
-      const url = m[1];
-      if (!url.startsWith("http")) continue;
-      const title = decodeHtmlEntities(stripInnerTags(m[2]));
-      const bodyBlock = m[3] || "";
-      const snippetMatch = bodyBlock.match(/<p[^>]*>([\s\S]*?)<\/p>/i) || bodyBlock.match(/<div class="b_caption"[^>]*>([\s\S]*?)<\/div>/i);
-      const snippet = snippetMatch ? decodeHtmlEntities(stripInnerTags(snippetMatch[1])) : title;
-      if (!title && !snippet) continue;
-      results.push({ url, title, snippet, engine: "bing" });
-    }
-  } catch (err) {
-    console.warn("Bing search error:", err);
-  }
-  return results;
-}
 async function searchYahooJP(query, count) {
   const results = [];
   const q = encodeURIComponent(query.trim());
@@ -614,28 +1990,33 @@ async function searchYahooJP(query, count) {
       headers: {
         "User-Agent": DESKTOP_UA,
         "Accept-Language": "en-US,en;q=0.9,vi;q=0.8"
-      }
+      },
+      signal: AbortSignal.timeout(5e3)
     });
     if (response.ok) {
       const html = await response.text();
-      const sectionRegex = /<div class="sw-Card[^"]*"[\s\S]*?<a\s+href="([^"]+)"[^>]*>[\s\S]*?<h3[^>]*>([\s\S]*?)<\/h3>[\s\S]*?(?:<p class="sw-Card__summary">([\s\S]*?)<\/p>)?/gi;
+      const cardRegex = /<a\s+[^>]*href="([^"]+)"[^>]*>[\s\S]*?<h3[^>]*>([\s\S]*?)<\/h3>[\s\S]*?(?:<(?:p|div)[^>]*class="[^"]*(?:summary|Snippet|desc|text)[^"]*"[^>]*>([\s\S]*?)<\/(?:p|div)>)?/gi;
       let match;
-      while ((match = sectionRegex.exec(html)) !== null && results.length < count) {
+      const seen = /* @__PURE__ */ new Set();
+      while ((match = cardRegex.exec(html)) !== null && results.length < count) {
         const url = match[1];
-        if (url.startsWith("http") && !url.includes("search.yahoo.co.jp")) {
-          const title = decodeHtmlEntities(stripInnerTags(match[2]));
-          const snippet = match[3] ? decodeHtmlEntities(stripInnerTags(match[3])) : title;
+        if (!url || !url.startsWith("http") || url.includes("search.yahoo.co.jp") || url === "https://www.yahoo.co.jp" || url === "https://www.yahoo.co.jp/") continue;
+        if (seen.has(url)) continue;
+        seen.add(url);
+        const title = decodeHtmlEntities(stripInnerTags(match[2]));
+        const snippet = match[3] ? decodeHtmlEntities(stripInnerTags(match[3])) : title;
+        if (title) {
           results.push({ url, title, snippet, engine: "yahoo" });
         }
       }
     }
-  } catch (err) {
-    console.warn("Yahoo search primary endpoint error:", err);
+  } catch (_err) {
   }
   if (results.length === 0) {
     try {
       const newsRes = await fetch(`https://news.search.yahoo.com/search?p=${q}`, {
-        headers: { "User-Agent": DESKTOP_UA }
+        headers: { "User-Agent": DESKTOP_UA },
+        signal: AbortSignal.timeout(5e3)
       });
       if (newsRes.ok) {
         const newsHtml = await newsRes.text();
@@ -653,22 +2034,11 @@ async function searchYahooJP(query, count) {
           }
         }
       }
-    } catch (err) {
-      console.warn("Yahoo news fallback error:", err);
+    } catch (_err) {
     }
   }
   return results;
 }
-function interleaveResults(arrays) {
-  const out = [];
-  const maxLen = Math.max(0, ...arrays.map((a) => a.length));
-  for (let i = 0; i < maxLen; i++) {
-    for (const arr of arrays) {
-      if (arr[i]) out.push(arr[i]);
-    }
-  }
-  return out;
-}
 function normalizeForDedupe(url) {
   try {
     const u = new URL(url);
@@ -691,12 +2061,12 @@ function mergeAndFilterResults(all, count) {
     }
     if (isBlockedHost(hostname)) continue;
     if (looksLikeNonHtmlFile(r.url)) continue;
-    const dedupeKey = normalizeForDedupe(r.url);
-    if (seen.has(dedupeKey)) continue;
+    const dedupeKey2 = normalizeForDedupe(r.url);
+    if (seen.has(dedupeKey2)) continue;
     const domainKey = hostname.replace(/^www\./, "");
     const domainCount = perDomainCount.get(domainKey) || 0;
     if (domainCount >= 2) continue;
-    seen.add(dedupeKey);
+    seen.add(dedupeKey2);
     perDomainCount.set(domainKey, domainCount + 1);
     filtered.push({ ...r, url: applyDomainRewrite(r.url), score: reputationScore(hostname) });
   }
@@ -706,7 +2076,106 @@ function mergeAndFilterResults(all, count) {
     snippet: r.snippet && r.snippet.trim() || r.title || r.url
   }));
 }
-var MAX_FETCH_BYTES = 6 * 1024 * 1024;
+var MAX_FETCH_BYTES = Number(process.env.FANLUC_MAX_FETCH_MB) > 0 ? Number(process.env.FANLUC_MAX_FETCH_MB) * 1024 * 1024 : 30 * 1024 * 1024;
+var DOCS_VIRTUAL_HOST = "fanluc.docs";
+var DOCS_VIRTUAL_URL = `https://${DOCS_VIRTUAL_HOST}/`;
+var MONDK_MSH_VIRTUAL_HOST = "mondk-msh.docs";
+var MONDK_MSH_VIRTUAL_URL = `https://${MONDK_MSH_VIRTUAL_HOST}/`;
+var DOCS_MAX_CHARS = 4e4;
+var VIRTUAL_DOCS_SITES = [
+  {
+    host: DOCS_VIRTUAL_HOST,
+    url: DOCS_VIRTUAL_URL,
+    trigger: /fanluc/i,
+    snippet: "Official FANLUC docs (detailed interface/UI description, creator mondk, msh, connection guide) - fetch this URL to read them in full."
+  },
+  {
+    host: MONDK_MSH_VIRTUAL_HOST,
+    url: MONDK_MSH_VIRTUAL_URL,
+    trigger: /\b(?:mondk|msh)\b/i,
+    snippet: "Official docs about the author mondk and the msh project (docs/mondk.md and docs/msh.md) - fetch this URL to read them in full."
+  }
+];
+function injectDocsResult(query, results, maxCount) {
+  const sites = VIRTUAL_DOCS_SITES.filter((site) => site.trigger.test(query || ""));
+  if (sites.length === 0) return results;
+  const rest = results.filter((r) => !sites.some((site) => r.url.toLowerCase().includes(site.host)));
+  const keepCount = Math.max(1, maxCount - sites.length);
+  const kept = rest.length > keepCount && maxCount > sites.length ? rest.slice(0, keepCount) : rest;
+  return [...sites.map((site) => ({ url: site.url, snippet: site.snippet })), ...kept];
+}
+async function readDocsFile(name) {
+  const docsDir = import_path3.default.join(process.cwd(), "docs");
+  let files = [];
+  try {
+    files = (await import_fs3.default.promises.readdir(docsDir)).filter((f) => /\.(md|txt)$/i.test(f));
+  } catch {
+    return null;
+  }
+  const file = files.find((f) => f.toLowerCase() === name || f.toLowerCase() === `${name}.md`) || files.find((f) => f.toLowerCase().includes(name));
+  if (!file) return null;
+  return { file, text: await import_fs3.default.promises.readFile(import_path3.default.join(docsDir, file), "utf-8") };
+}
+async function readMondkMshPage(pathname) {
+  let name = "";
+  try {
+    name = decodeURIComponent(pathname || "");
+  } catch {
+    name = pathname || "";
+  }
+  name = name.replace(/^\/+|\/+$/g, "").toLowerCase().replace(/\.md$/, "");
+  const pages = ["mondk", "msh"];
+  if (name && name !== "index") {
+    if (!pages.includes(name)) {
+      return {
+        title: "Not found",
+        text: `Page '${name}' not found. Available: ${pages.map((n) => MONDK_MSH_VIRTUAL_URL + n).join(", ")}`
+      };
+    }
+    const doc = await readDocsFile(name);
+    if (!doc) return { title: "Not found", text: `docs/${name}.md was not found on this server.` };
+    return { title: doc.file, text: doc.text.slice(0, DOCS_MAX_CHARS) };
+  }
+  const parts = [];
+  for (const n of pages) {
+    const doc = await readDocsFile(n);
+    parts.push(`=== docs/${doc ? doc.file : n + ".md"} ===
+${doc ? doc.text.trim() : "(file not found)"}`);
+  }
+  return { title: "MONDK and MSH docs", text: parts.join("\n\n").slice(0, DOCS_MAX_CHARS) };
+}
+async function readVirtualDocsPage(pathname) {
+  const docsDir = import_path3.default.join(process.cwd(), "docs");
+  let files = [];
+  try {
+    files = (await import_fs3.default.promises.readdir(docsDir)).filter((f) => /\.(md|txt)$/i.test(f));
+  } catch {
+  }
+  let name = "";
+  try {
+    name = decodeURIComponent(pathname || "");
+  } catch {
+    name = pathname || "";
+  }
+  name = name.replace(/^\/+|\/+$/g, "").toLowerCase().replace(/\.md$/, "");
+  const find = (n) => files.find((f) => f.toLowerCase() === n || f.toLowerCase() === `${n}.md`) || files.find((f) => f.toLowerCase().includes(n));
+  const read = (f) => import_fs3.default.promises.readFile(import_path3.default.join(docsDir, f), "utf-8");
+  if (!name || name === "index") {
+    const ui = find("fanluc");
+    const pages = ["fanluc", "guide", "mondk", "msh"].filter((n) => find(n));
+    const index = "FANLUC docs index:\n" + pages.map((n) => `- ${DOCS_VIRTUAL_URL}${n === "fanluc" ? "" : n}`).join("\n") + "\n\n";
+    const body = ui ? await read(ui) : "(fanluc ui doc not found)";
+    return { title: "FANLUC docs", text: (index + body).slice(0, DOCS_MAX_CHARS) };
+  }
+  const file = find(name);
+  if (!file) {
+    return {
+      title: "Not found",
+      text: `Page '${name}' not found. Available: ${["fanluc", "guide", "mondk", "msh"].map((n) => DOCS_VIRTUAL_URL + (n === "fanluc" ? "" : n)).join(", ")}`
+    };
+  }
+  return { title: file, text: (await read(file)).slice(0, DOCS_MAX_CHARS) };
+}
 async function fetchWithByteLimit(url, signal, maxBytes) {
   const response = await fetch(url, {
     signal,
@@ -765,20 +2234,19 @@ function extractReadableContent(html, url) {
 var SEARXNG_URL = (process.env.SEARXNG_URL || process.env.SEARXNG || "").replace(/\/$/, "");
 async function searchSearXNG(query, count, categories = "general", baseUrl = SEARXNG_URL) {
   const results = [];
-  if (!baseUrl) return results;
+  if (!baseUrl || !baseUrl.startsWith("http")) return results;
   try {
     const params = new URLSearchParams({ q: query.trim(), format: "json", categories, pageno: "1" });
     const url = `${baseUrl}/search?${params.toString()}`;
     const resp = await fetch(url, {
-      signal: AbortSignal.timeout(6e3),
       headers: {
         "User-Agent": DESKTOP_UA,
         "Accept": "application/json",
         "Accept-Language": "en-US,en;q=0.9,vi;q=0.8"
-      }
+      },
+      signal: AbortSignal.timeout(3e3)
     });
     if (!resp.ok) {
-      console.warn(`SearXNG search failed ${resp.status} for "${query}"`);
       return results;
     }
     const j = await resp.json();
@@ -807,8 +2275,7 @@ async function searchSearXNG(query, count, categories = "general", baseUrl = SEA
         results.push({ url: url2, title, snippet, engine: "searxng" });
       }
     }
-  } catch (err) {
-    console.warn("SearXNG search error:", err);
+  } catch (_err) {
   }
   return results;
 }
@@ -824,10 +2291,10 @@ function isPrivateIp(ip) {
 async function assertPublicUrl(raw) {
   const u = new URL(raw);
   if (u.protocol !== "http:" && u.protocol !== "https:") throw new Error("Only http/https URLs are allowed");
-  if (process.env.ALLOW_PRIVATE_URLS === "1") return u;
+  if (process.env.ALLOW_PRIVATE_URLS !== "0") return u;
   const host = u.hostname.replace(/^\[|\]$/g, "");
   if (host === "localhost" || host.endsWith(".local") || host.endsWith(".internal")) throw new Error("Private/local hosts are not allowed");
-  const addrs = import_node_net.default.isIP(host) ? [{ address: host }] : await import_promises.default.lookup(host, { all: true });
+  const addrs = import_node_net.default.isIP(host) ? [{ address: host }] : await import_promises2.default.lookup(host, { all: true });
   for (const a of addrs) if (isPrivateIp(a.address)) throw new Error("Private/local hosts are not allowed");
   return u;
 }
@@ -853,7 +2320,11 @@ function mcpAdminGuard(req, res, next) {
 }
 function resolveEnvVars(str) {
   if (typeof str !== "string") return str;
-  return str.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name.trim()] ?? "");
+  return str.replace(/\$\{([^}]+)\}/g, (_, name) => {
+    const n = String(name).trim();
+    if (n === "WORKSPACE") return getWorkspace();
+    return process.env[n] ?? "";
+  });
 }
 function resolveEnvObject(obj) {
   if (!obj || typeof obj !== "object") return obj;
@@ -879,28 +2350,66 @@ async function connectMcp(name, cfg) {
   const entry = { client: null, tools: [], status: "connecting", config: cfg, type };
   mcp.set(name, entry);
   try {
-    let transport;
+    let client;
     if (type === "http") {
       const rawUrl = cfg.url;
       if (!rawUrl) throw new Error("Missing url for http/remote MCP server");
-      const resolvedUrl = resolveEnvVars(String(rawUrl));
+      const resolvedUrl = new URL(resolveEnvVars(String(rawUrl)));
       const headers = resolveEnvObject(cfg.headers) || {};
-      transport = new import_streamableHttp.StreamableHTTPClientTransport(new URL(resolvedUrl), { requestInit: { headers } });
+      const mk = () => new import_client.Client({ name: "fanluc", version: "1.0.0" }, { capabilities: {} });
+      try {
+        client = mk();
+        await client.connect(new import_streamableHttp.StreamableHTTPClientTransport(resolvedUrl, { requestInit: { headers } }), { timeout: 3e4 });
+      } catch (e1) {
+        try {
+          client = mk();
+          await client.connect(new import_sse.SSEClientTransport(resolvedUrl, { requestInit: { headers } }), { timeout: 3e4 });
+        } catch {
+          throw e1;
+        }
+      }
     } else {
       let command = cfg.command;
       let args = Array.isArray(cfg.args) ? cfg.args : [];
-      let env = resolveEnvObject(cfg.env || cfg.environment);
+      const userEnv = resolveEnvObject(cfg.env || cfg.environment) || {};
       if (Array.isArray(command)) {
         args = command.slice(1);
         command = command[0];
       }
       if (!command) throw new Error("Missing command for stdio/local MCP server");
-      const resolvedCommand = resolveEnvVars(String(command));
-      const resolvedArgs = args.map((a) => resolveEnvVars(String(a)));
-      transport = new import_stdio.StdioClientTransport({ command: resolvedCommand, args: resolvedArgs, env });
+      let resolvedCommand = resolveEnvVars(String(command)).trim();
+      let resolvedArgs = args.map((a) => resolveEnvVars(String(a)));
+      if (!resolvedArgs.length && /\s/.test(resolvedCommand)) {
+        const parts = resolvedCommand.split(/\s+/);
+        resolvedCommand = parts[0];
+        resolvedArgs = parts.slice(1);
+      }
+      const baseEnv = {};
+      for (const [k, v] of Object.entries(process.env)) {
+        if (typeof v === "string" && !["GEMINI_API_KEY", "TOKEN", "ADMIN_TOKEN", "ACCESS_TOKEN"].includes(k)) baseEnv[k] = v;
+      }
+      const cwd = cfg.cwd ? resolveEnvVars(String(cfg.cwd)) : getWorkspace();
+      const transport = new import_stdio.StdioClientTransport({
+        command: resolvedCommand,
+        args: resolvedArgs,
+        env: { ...baseEnv, ...userEnv },
+        cwd,
+        stderr: "pipe"
+      });
+      let errTail = "";
+      transport.stderr?.on?.("data", (d) => {
+        errTail = (errTail + d.toString()).slice(-1500);
+      });
+      client = new import_client.Client({ name: "fanluc", version: "1.0.0" }, { capabilities: {} });
+      try {
+        await client.connect(transport, { timeout: 12e4 });
+      } catch (e) {
+        const tail = errTail.trim();
+        throw new Error(`${e?.message || e}${tail ? `
+--- server stderr ---
+${tail}` : ""}`);
+      }
     }
-    const client = new import_client.Client({ name: "fanluc", version: "1.0.0" }, { capabilities: {} });
-    await client.connect(transport);
     const toolsRes = await client.listTools();
     const tools = Array.isArray(toolsRes?.tools) ? toolsRes.tools : [];
     const truncated = tools.map((t) => ({
@@ -915,45 +2424,15 @@ async function connectMcp(name, cfg) {
     mcp.set(name, { client: null, tools: [], status: "failed", error: msg, config: cfg, type });
   }
 }
-function getFanlucConfigDir() {
-  if (process.env.FANLUC_CONFIG_DIR?.trim()) return process.env.FANLUC_CONFIG_DIR.trim();
-  if (IS_WINDOWS) {
-    const appData = process.env.APPDATA;
-    if (appData) return import_path.default.join(appData, "fanluc");
-    return import_path.default.join(import_os.default.homedir(), "AppData", "Roaming", "fanluc");
-  }
-  const xdg = process.env.XDG_CONFIG_HOME;
-  if (xdg) return import_path.default.join(xdg, "fanluc");
-  return import_path.default.join(import_os.default.homedir(), ".config", "fanluc");
-}
-function mcpConfigPath() {
-  const dir = getFanlucConfigDir();
-  try {
-    import_fs.default.mkdirSync(dir, { recursive: true });
-  } catch {
-  }
-  return import_path.default.join(dir, "mcp.json");
-}
-function readMcpServersFile(mcpPath) {
-  if (!import_fs.default.existsSync(mcpPath)) return {};
-  const raw = import_fs.default.readFileSync(mcpPath, "utf-8").replace(/^\uFEFF/, "");
-  if (!raw.trim()) return {};
-  const j = JSON.parse(stripJsonc(raw));
-  if (j.mcpServers) return j.mcpServers;
-  if (j.mcp && j.mcp.servers) return j.mcp.servers;
-  if (j.mcp && typeof j.mcp === "object") return j.mcp;
-  return j;
-}
 function loadMcpConfigSync() {
-  const configDir = getFanlucConfigDir();
   const candidates = [
-    import_path.default.join(configDir, "mcp.json"),
-    import_path.default.join(configDir, "mcp.jsonc")
+    import_path3.default.join(process.cwd(), "mcp.json"),
+    import_path3.default.join(process.cwd(), "mcp.jsonc")
   ];
   for (const p of candidates) {
     try {
-      if (import_fs.default.existsSync(p)) {
-        const raw = import_fs.default.readFileSync(p, "utf-8").replace(/^\uFEFF/, "");
+      if (import_fs3.default.existsSync(p)) {
+        const raw = import_fs3.default.readFileSync(p, "utf-8");
         const cleaned = stripJsonc(raw);
         const j = JSON.parse(cleaned);
         if (j.mcpServers && typeof j.mcpServers === "object") return j.mcpServers;
@@ -981,9 +2460,7 @@ async function initMcpFromFile() {
     return;
   }
   console.log(`[MCP] loading ${entries.length} server(s) from mcp.json`);
-  for (const [name, cfg] of entries) {
-    await connectMcp(name, cfg);
-  }
+  await Promise.all(entries.map(([name, cfg]) => connectMcp(name, cfg)));
 }
 function getMcpToolsForModel() {
   const out = [];
@@ -1003,18 +2480,26 @@ function getMcpToolsForModel() {
 }
 async function startServer() {
   const app = (0, import_express.default)();
-  {
-    const bind = process.env.HOST || "0.0.0.0";
-    if (bind === "127.0.0.1" || bind === "localhost" || bind === "::1") {
-      app.use((req, res, next) => {
-        const h = String(req.headers.host || "").replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
-        if (h === "localhost" || h === "127.0.0.1" || h === "::1") return next();
-        return res.status(403).json({ error: "Forbidden host" });
-      });
+  const portArgIdx = process.argv.indexOf("--port");
+  const cliPort = portArgIdx !== -1 && process.argv[portArgIdx + 1] ? Number(process.argv[portArgIdx + 1]) : null;
+  const PORT = cliPort || (process.env.APP_PORT ? Number(process.env.APP_PORT) : 3e3);
+  app.use(import_express.default.json({ limit: "2gb" }));
+  app.use("/api", (req, res, next) => req.path === "/health" ? next() : requireLocal(req, res, next));
+  onWorkspaceChange(() => {
+    for (const [name, entry] of mcp.entries()) {
+      if (entry.status === "disabled") continue;
+      if (/colab-mcp|StudioMCP|Roblox.mcp\.bat/i.test(JSON.stringify(entry.config || {}))) continue;
+      if (JSON.stringify(entry.config || {}).includes("${WORKSPACE}") || entry.type === "stdio" && !entry.config?.cwd) {
+        const old = entry.client;
+        connectMcp(name, entry.config).finally(() => {
+          try {
+            old?.close();
+          } catch {
+          }
+        });
+      }
     }
-  }
-  const PORT = Number(process.env.PORT) || 3e3;
-  app.use(import_express.default.json({ limit: "50mb" }));
+  });
   initMcpFromFile().catch((e) => console.warn("[MCP] init failed:", e));
   app.post("/api/proxy-chat", async (req, res) => {
     try {
@@ -1025,7 +2510,7 @@ async function startServer() {
       const headers = {
         "Content-Type": "application/json",
         "ngrok-skip-browser-warning": "true",
-        "User-Agent": "AI-Studio-Rest-Client/1.0",
+        "User-Agent": "fanluc/2.4.0",
         "Authorization": `Bearer ${apiKey || ""}`,
         ...customHeaders || {}
       };
@@ -1084,50 +2569,45 @@ async function startServer() {
         return res.status(400).json({ error: "Missing query parameter" });
       }
       const maxCount = Math.min(15, Math.max(1, parseInt(count) || 7));
-      let searxResults = [];
-      try {
-        searxResults = await searchSearXNG(query, maxCount, "general", await resolveSearxUrl(req));
-      } catch (e) {
-        console.warn("SearXNG general search error, falling back:", e);
-      }
-      if (searxResults.length > 0) {
-        let results2 = mergeAndFilterResults(searxResults, maxCount);
-        if (results2.length === 0) {
-          results2 = searxResults.slice(0, maxCount).map((r) => ({ url: r.url, snippet: r.snippet || r.title || r.url }));
-        }
-        const formattedText2 = `${results2.length} results:
-` + results2.map((r) => `${r.url}: ${r.snippet}`).join("\n");
-        return res.json({ count: results2.length, results: results2, formattedText: formattedText2, engine: "searxng" });
-      }
-      const perEngineCount = Math.min(20, maxCount + 6);
-      const withTimeout = (p, ms = 8e3) => Promise.race([p.catch(() => []), new Promise((r) => setTimeout(() => r([]), ms))]);
-      const [ddgResults, bingResults, yahooResults] = await Promise.all([
-        withTimeout(searchDuckDuckGo(query, perEngineCount)),
-        withTimeout(searchBing(query, perEngineCount)),
-        withTimeout(searchYahooJP(query, perEngineCount))
-      ]);
-      let results = mergeAndFilterResults(
-        interleaveResults([ddgResults, bingResults, yahooResults]),
-        maxCount
-      );
-      if (results.length === 0) {
-        const rawAll = [...ddgResults, ...bingResults, ...yahooResults];
-        results = rawAll.slice(0, maxCount).map((r) => ({ url: r.url, snippet: r.snippet || r.title || r.url }));
-      }
-      const formattedText = results.length > 0 ? `${results.length} results:
+      const searxUrl = await resolveSearxUrl(req);
+      const key = `web:${LOCALE}:${searxUrl}:${query.toLowerCase().trim()}:${maxCount}`;
+      const payload = await cached(
+        key,
+        10 * 60 * 1e3,
+        async () => {
+          const per = Math.min(20, maxCount + 6);
+          const lists = await raceUntilEnough(
+            [
+              searxUrl ? runEngine("searxng", () => searchSearXNG(query, per, "general", searxUrl), 4e3) : Promise.resolve([]),
+              runEngine("bing", () => searchBingLocal(query, per), 4e3),
+              runEngine("mojeek", () => searchMojeek(query, per), 4e3),
+              runEngine("wikipedia", () => searchWikipedia(query, 5), 4e3),
+              runEngine("yahoo", () => searchYahooJP(query, per), 4e3)
+            ],
+            (c) => c.reduce((n, a) => n + a.length, 0) >= maxCount,
+            4500
+          );
+          const fused = fuseResults(lists);
+          let results = mergeAndFilterResults(fused, maxCount);
+          if (results.length === 0) results = fused.slice(0, maxCount).map((r) => ({ url: r.url, snippet: r.snippet || r.title || r.url }));
+          results = injectDocsResult(query, results, maxCount);
+          const names = ["searxng", "bing", "mojeek", "wikipedia", "yahoo"].filter((_, i) => lists[i].length > 0);
+          const formattedText = results.length > 0 ? `${results.length} results:
 ` + results.map((r) => `${r.url}: ${r.snippet}`).join("\n") : `0 results:
 (no results found for "${query}")`;
-      return res.json({
-        count: results.length,
-        results,
-        formattedText,
-        engine: results.length ? "fallback" : "none"
-      });
+          return { count: results.length, results, formattedText, engine: names.join("+") || "none" };
+        },
+        (v) => v.count > 0
+      );
+      return res.json(payload);
     } catch (error) {
       console.error("Web search error:", error);
       return res.status(500).json({ error: error?.message || "Web search failed" });
     }
   });
+  app.get("/api/search-status", (_req, res) => {
+    res.json({ locale: LOCALE, searxng: SEARXNG_URL || null, engines: engineStatus() });
+  });
   app.post("/api/searxng-search", async (req, res) => {
     try {
       const { query, count = 7, categories = "general" } = req.body;
@@ -1162,20 +2642,9 @@ async function startServer() {
       const { query, count = 6 } = req.body;
       if (!query || typeof query !== "string") return res.status(400).json({ error: "Missing query" });
       const maxCount = Math.min(12, Math.max(1, parseInt(count) || 6));
-      const raw = await searchSearXNG(query, maxCount, "images", await resolveSearxUrl(req));
-      let images = raw.slice(0, maxCount).map((r) => ({
-        title: r.title || query,
-        src: r._img_src || r.url,
-        thumb: r._thumb || r._img_src || r.url,
-        page: r.url
-      })).filter((x) => x.src && x.src.startsWith("http"));
-      const seen = /* @__PURE__ */ new Set();
-      images = images.filter((x) => {
-        if (seen.has(x.src)) return false;
-        seen.add(x.src);
-        return true;
-      });
-      const formattedText = images.length ? `\u0110\xE3 hi\u1EC3n th\u1ECB ${images.length} \u1EA3nh v\u1EC1 "${query}"` : `Kh\xF4ng t\xECm th\u1EA5y \u1EA3nh cho "${query}"`;
+      const hits = await searchImages(query, maxCount, await resolveSearxUrl(req));
+      const images = hits.map((h) => ({ title: h.title || query, src: h.src, thumb: h.thumb, page: h.page }));
+      const formattedText = images.length ? `Showing ${images.length} images for "${query}"` : `No images found for "${query}"`;
       return res.json({ count: images.length, images, formattedText });
     } catch (e) {
       console.error("Image search error:", e);
@@ -1193,7 +2662,7 @@ async function startServer() {
       for (let hop = 0; hop < 4; hop++) {
         const h = new URL(cur).hostname;
         if (isBlockedHost(h)) return res.status(403).send("Blocked host");
-        resp = await fetch(cur, { redirect: "manual", headers: { "User-Agent": DESKTOP_UA, "Accept": "image/*,*/*" } });
+        resp = await fetch(cur, { redirect: "manual", headers: { "User-Agent": DESKTOP_UA, "Accept": "image/*,*/*", "Referer": new URL(cur).origin + "/" } });
         const loc = resp.headers.get("location");
         if (resp.status >= 300 && resp.status < 400 && loc) {
           cur = new URL(loc, cur).toString();
@@ -1234,7 +2703,11 @@ async function startServer() {
       // connected / failed / disabled / connecting
       tools: v.tools,
       toolCount: v.tools.length,
-      error: v.error || null
+      error: v.error || null,
+      command: v.config?.command || "",
+      args: Array.isArray(v.config?.args) ? v.config.args.join(" ") : v.config?.args || "",
+      url: v.config?.url || "",
+      headers: v.config?.headers || void 0
     }));
     const modelTools = getMcpToolsForModel();
     res.json({ servers: list, modelTools, count: list.length });
@@ -1252,7 +2725,19 @@ async function startServer() {
       if (!entry) return res.status(404).json({ error: `MCP server "${server}" not found` });
       if (entry.status !== "connected" || !entry.client) return res.status(400).json({ error: `MCP server "${server}" not connected (${entry.status})${entry.error ? ": " + entry.error : ""}` });
       const actualTool = toolName.includes("_") && toolName.startsWith(server + "_") ? toolName.slice(server.length + 1) : toolName;
-      const result = await entry.client.callTool({ name: actualTool, arguments: toolArgs });
+      const callOpts = { timeout: 18e4 };
+      let result;
+      try {
+        result = await entry.client.callTool({ name: actualTool, arguments: toolArgs }, void 0, callOpts);
+      } catch (err) {
+        if (/closed|not connected|EPIPE|terminated|ECONNRESET|fetch failed/i.test(String(err?.message || err))) {
+          await connectMcp(server, entry.config);
+          const again = mcp.get(server);
+          if (again?.status === "connected" && again.client) {
+            result = await again.client.callTool({ name: actualTool, arguments: toolArgs }, void 0, callOpts);
+          } else throw err;
+        } else throw err;
+      }
       return res.json(result);
     } catch (e) {
       console.error("MCP call error:", e);
@@ -1355,17 +2840,6 @@ async function startServer() {
         }
         mcp.set(server, { client: null, tools: [], status: "disabled", config: newCfg, type: normalizeMcpType(newCfg.type) });
       }
-      try {
-        const mcpPath = mcpConfigPath();
-        const existing = readMcpServersFile(mcpPath);
-        if (existing[server]) {
-          existing[server] = { ...existing[server], enabled: newEnabled };
-          delete existing[server].disabled;
-          import_fs.default.writeFileSync(mcpPath, JSON.stringify({ mcpServers: existing }, null, 2), "utf-8");
-        }
-      } catch (e) {
-        console.warn("[MCP] could not persist toggle:", e?.message);
-      }
       const entry = mcp.get(server);
       return res.json({ name: server, status: entry.status, enabled: newEnabled });
     } catch (e) {
@@ -1390,16 +2864,23 @@ async function startServer() {
         else if (typeof args === "string" && args.trim()) newCfg.args = String(args).trim().split(/\s+/);
         if (env && typeof env === "object") newCfg.env = env;
       }
-      const mcpPath = mcpConfigPath();
+      const mcpPath = import_path3.default.join(process.cwd(), "mcp.json");
       let existing = {};
       try {
-        existing = readMcpServersFile(mcpPath);
+        if (import_fs3.default.existsSync(mcpPath)) {
+          const raw = import_fs3.default.readFileSync(mcpPath, "utf-8");
+          const j = JSON.parse(stripJsonc(raw));
+          if (j.mcpServers) existing = j.mcpServers;
+          else if (j.mcp && j.mcp.servers) existing = j.mcp.servers;
+          else if (j.mcp && typeof j.mcp === "object") existing = j.mcp;
+          else existing = j;
+        }
       } catch (e) {
         return res.status(500).json({ error: "mcp.json is invalid, refusing to overwrite: " + (e?.message || e) });
       }
       existing[cleanName] = newCfg;
       const toWrite = { mcpServers: existing };
-      import_fs.default.writeFileSync(mcpPath, JSON.stringify(toWrite, null, 2));
+      import_fs3.default.writeFileSync(mcpPath, JSON.stringify(toWrite, null, 2));
       await connectMcp(cleanName, newCfg);
       const entry = mcp.get(cleanName);
       return res.json({ name: cleanName, status: entry.status, toolCount: entry.tools.length, error: entry.error || null });
@@ -1407,6 +2888,93 @@ async function startServer() {
       return res.status(500).json({ error: e?.message });
     }
   });
+  app.post("/api/mcp/edit", mcpAdminGuard, async (req, res) => {
+    try {
+      const { oldName, name, type, command, args, url, headers, env, enabled = true } = req.body || {};
+      if (!oldName || typeof oldName !== "string") return res.status(400).json({ error: "Missing oldName" });
+      if (!name || typeof name !== "string") return res.status(400).json({ error: "Missing name" });
+      const cleanOldName = oldName.trim();
+      const cleanName = name.trim().replace(/[^a-zA-Z0-9_-]/g, "_");
+      if (!cleanName) return res.status(400).json({ error: "Invalid name" });
+      const newCfg = { type: type || (url ? "http" : "stdio"), enabled: !!enabled };
+      if (newCfg.type === "http" || newCfg.type === "remote") {
+        if (!url || !String(url).startsWith("http")) return res.status(400).json({ error: "Invalid url for http server" });
+        newCfg.url = String(url);
+        if (headers && typeof headers === "object") newCfg.headers = headers;
+      } else {
+        if (!command || typeof command !== "string") return res.status(400).json({ error: "Missing command for stdio server" });
+        newCfg.command = String(command);
+        if (Array.isArray(args) && args.length) newCfg.args = args.map(String);
+        else if (typeof args === "string" && args.trim()) newCfg.args = String(args).trim().split(/\s+/);
+        if (env && typeof env === "object") newCfg.env = env;
+      }
+      const mcpPath = import_path3.default.join(process.cwd(), "mcp.json");
+      let existing = {};
+      try {
+        if (import_fs3.default.existsSync(mcpPath)) {
+          const raw = import_fs3.default.readFileSync(mcpPath, "utf-8");
+          const j = JSON.parse(stripJsonc(raw));
+          if (j.mcpServers) existing = j.mcpServers;
+          else if (j.mcp && j.mcp.servers) existing = j.mcp.servers;
+          else if (j.mcp && typeof j.mcp === "object") existing = j.mcp;
+          else existing = j;
+        }
+      } catch (e) {
+        return res.status(500).json({ error: "mcp.json is invalid, refusing to overwrite: " + (e?.message || e) });
+      }
+      if (cleanOldName !== cleanName || mcp.has(cleanOldName)) {
+        delete existing[cleanOldName];
+        const old = mcp.get(cleanOldName);
+        try {
+          await old?.client?.close?.();
+        } catch {
+        }
+        mcp.delete(cleanOldName);
+      }
+      existing[cleanName] = newCfg;
+      import_fs3.default.writeFileSync(mcpPath, JSON.stringify({ mcpServers: existing }, null, 2));
+      if (newCfg.enabled) {
+        await connectMcp(cleanName, newCfg);
+      } else {
+        mcp.set(cleanName, { client: null, tools: [], status: "disabled", config: newCfg, type: normalizeMcpType(newCfg.type) });
+      }
+      const entry = mcp.get(cleanName);
+      return res.json({ name: cleanName, status: entry?.status || "disabled", toolCount: entry?.tools?.length || 0, error: entry?.error || null });
+    } catch (e) {
+      return res.status(500).json({ error: e?.message });
+    }
+  });
+  app.post("/api/mcp/delete", mcpAdminGuard, async (req, res) => {
+    try {
+      const { name } = req.body || {};
+      if (!name || typeof name !== "string") return res.status(400).json({ error: "Missing name" });
+      const cleanName = name.trim();
+      const mcpPath = import_path3.default.join(process.cwd(), "mcp.json");
+      let existing = {};
+      if (import_fs3.default.existsSync(mcpPath)) {
+        try {
+          const raw = import_fs3.default.readFileSync(mcpPath, "utf-8");
+          const j = JSON.parse(stripJsonc(raw));
+          if (j.mcpServers) existing = j.mcpServers;
+          else if (j.mcp && j.mcp.servers) existing = j.mcp.servers;
+          else if (j.mcp && typeof j.mcp === "object") existing = j.mcp;
+          else existing = j;
+        } catch {
+        }
+      }
+      delete existing[cleanName];
+      import_fs3.default.writeFileSync(mcpPath, JSON.stringify({ mcpServers: existing }, null, 2));
+      const old = mcp.get(cleanName);
+      try {
+        await old?.client?.close?.();
+      } catch {
+      }
+      mcp.delete(cleanName);
+      return res.json({ success: true });
+    } catch (e) {
+      return res.status(500).json({ error: e?.message });
+    }
+  });
   app.post("/api/fetch-url", async (req, res) => {
     const errorFallback = "you entered an incorrect URL, are missing characters, or the website no longer exists";
     try {
@@ -1420,6 +2988,7 @@ async function startServer() {
       }
       const urlMatch = url.match(/https?:\/\/[^\s"']+/);
       let targetUrl = urlMatch ? urlMatch[0] : url.trim();
+      if (/^(?:fanluc|mondk-msh)\.docs(?:[\/?#]|$)/i.test(targetUrl)) targetUrl = "https://" + targetUrl;
       try {
         new URL(targetUrl);
       } catch {
@@ -1435,6 +3004,18 @@ async function startServer() {
         hostname = new URL(targetUrl).hostname.toLowerCase();
       } catch {
       }
+      if (hostname === DOCS_VIRTUAL_HOST || hostname === MONDK_MSH_VIRTUAL_HOST) {
+        const pathname = new URL(targetUrl).pathname;
+        const doc = hostname === MONDK_MSH_VIRTUAL_HOST ? await readMondkMshPage(pathname) : await readVirtualDocsPage(pathname);
+        return res.json({
+          url: targetUrl,
+          title: doc.title,
+          text: doc.text,
+          formattedText: `fetched url: ${targetUrl}
+title: ${doc.title}
+text: ${doc.text}`
+        });
+      }
       if (isBlockedHost(hostname)) {
         const blockedMsg = `This site (${hostname}) blocks automated crawling or requires login, so its content cannot be reliably extracted. Try a different, publicly accessible source instead.`;
         return res.json({
@@ -1513,9 +3094,9 @@ ${titlePart}text: ${extracted}`;
         return res.status(400).json({ error: "Missing name parameter" });
       }
       const cleanName = name.trim().toLowerCase().replace(/^['"`]|['"`]$/g, "");
-      const docsDir = import_path.default.join(process.cwd(), "docs");
+      const docsDir = import_path3.default.join(process.cwd(), "docs");
       try {
-        const files = await import_fs.default.promises.readdir(docsDir);
+        const files = await import_fs3.default.promises.readdir(docsDir);
         let targetFile = files.find(
           (f) => f.toLowerCase() === cleanName || f.toLowerCase() === `${cleanName}.md`
         );
@@ -1527,7 +3108,7 @@ ${titlePart}text: ${extracted}`;
           else targetFile = files.find((f) => f.toLowerCase().includes(cleanName));
         }
         if (targetFile) {
-          const content = await import_fs.default.promises.readFile(import_path.default.join(docsDir, targetFile), "utf-8");
+          const content = await import_fs3.default.promises.readFile(import_path3.default.join(docsDir, targetFile), "utf-8");
           return res.json({
             found: true,
             fileName: targetFile,
@@ -1646,329 +3227,51 @@ ${content}`
       res.status(500).json({ error: "Failed to fetch weather" });
     }
   });
-  function getPermissionMode() {
-    const m = (process.env.FANLUC_PERMISSION || "").trim();
-    if (m === "readOnly" || m === "autoEdit" || m === "ask") return m;
-    try {
-      const cfgDir2 = getFanlucConfigDir();
-      const p = import_path.default.join(cfgDir2, "settings.json");
-      if (import_fs.default.existsSync(p)) {
-        const raw = import_fs.default.readFileSync(p, "utf-8").replace(/^\uFEFF/, "");
-        const j = JSON.parse(raw);
-        if (j.permission === "readOnly" || j.permission === "autoEdit" || j.permission === "ask") return j.permission;
-      }
-    } catch {
-    }
-    return "ask";
-  }
-  function loadFanlucMdSync() {
-    const candidates = [
-      import_path.default.join(WORKSPACE_DIR, "FANLUC.md"),
-      import_path.default.join(WORKSPACE_DIR, "fanluc.md"),
-      import_path.default.join(WORKSPACE_DIR, ".fanluc", "FANLUC.md")
-    ];
-    for (const p of candidates) {
-      try {
-        if (import_fs.default.existsSync(p) && import_fs.default.statSync(p).isFile()) {
-          const raw = import_fs.default.readFileSync(p, "utf-8").replace(/^\uFEFF/, "");
-          const MAX = 6e3;
-          const content = raw.length > MAX ? raw.slice(0, MAX) + "\n\n[... truncated ...]" : raw;
-          return { path: p, content };
-        }
-      } catch {
-      }
-    }
-    return null;
-  }
-  app.get("/api/fanluc-md", (_req, res) => {
-    const md = loadFanlucMdSync();
-    if (!md) return res.json({ found: false, path: null, content: "" });
-    return res.json({ found: true, path: md.path, content: md.content });
-  });
-  app.get("/api/config", (_req, res) => {
-    const cfgDir2 = getFanlucConfigDir();
-    const perm = getPermissionMode();
-    const ws = WORKSPACE_DIR;
-    const md = loadFanlucMdSync();
-    res.json({
-      workspace: ws,
-      configDir: cfgDir2,
-      permission: perm,
-      fanlucMd: md ? { path: md.path, length: md.content.length } : null,
-      platform: process.platform
-    });
-  });
-  app.get("/api/permission/status", (_req, res) => {
-    const perm = getPermissionMode();
-    res.json({
-      permission: perm,
-      fileGranted: isGranted("file"),
-      shellGranted: isGranted("shell"),
-      ttlMs: GRANT_TTL_MS
-    });
-  });
-  app.post("/api/permission/approve", (req, res) => {
-    const { type } = req.body || {};
-    const t = type === "file" ? "file" : type === "shell" ? "shell" : "all";
-    const perm = getPermissionMode();
-    if (perm === "readOnly") {
-      return res.status(403).json({ error: "readOnly: cannot grant permission" });
-    }
-    grantPermission(t);
-    res.json({ ok: true, granted: t, until: Date.now() + GRANT_TTL_MS });
-  });
-  app.post("/api/permission/mode", (req, res) => {
-    const m = String(req.body?.mode || "");
-    if (m !== "ask" && m !== "autoEdit" && m !== "readOnly") return res.status(400).json({ error: "mode must be ask | autoEdit | readOnly" });
-    process.env.FANLUC_PERMISSION = m;
-    return res.json({ ok: true, permission: m });
-  });
-  app.post("/api/permission/reset", (_req, res) => {
-    clearGrants();
-    res.json({ ok: true });
-  });
-  app.post("/api/run-cmd", (req, res) => {
-    if (process.env.DISABLE_RUN_CMD === "1") {
-      const msg = "run_cmd is disabled on this server.";
-      return res.json({ stdout: "", stderr: msg, formattedText: msg, blocked: true });
-    }
-    const perm = getPermissionMode();
-    const needShellGrant = perm === "ask" || perm === "autoEdit";
-    if (perm === "readOnly" || needShellGrant && !isGranted("shell")) {
-      const hint = perm === "readOnly" ? "readOnly \u2014 shell disabled" : `permission '${perm}' requires confirmation via web ConfirmModal or POST /api/permission/approve {type:'shell'}`;
-      const msg = `Blocked by permission mode '${perm}': shell execution requires confirmation. ${hint}`;
-      return res.status(403).json({ stdout: "", stderr: msg, formattedText: msg, blocked: true, needConfirm: true, permission: perm });
-    }
-    const { command } = req.body || {};
-    if (!command || typeof command !== "string" || !command.trim()) {
-      return res.status(400).json({ error: "Missing command", formattedText: "Error: missing command" });
-    }
-    const trimmed = preprocessCommand(command.trim());
-    const blockedReason = findBlockedPattern2(trimmed);
-    if (blockedReason) {
-      const msg = `Command blocked for safety: ${blockedReason}.`;
-      return res.json({ stdout: "", stderr: msg, formattedText: msg, blocked: true });
-    }
-    const TIMEOUT_MS = 2e4;
-    const MAX_BUFFER = 2 * 1024 * 1024;
-    let bin;
-    let args;
-    if (IS_WINDOWS) {
-      bin = "powershell.exe";
-      const PS_UTF8 = "[Console]::OutputEncoding=[System.Text.UTF8Encoding]::new($false);$OutputEncoding=[Console]::OutputEncoding;$PSDefaultParameterValues['Get-Content:Encoding']='utf8';$PSDefaultParameterValues['Set-Content:Encoding']='utf8';$PSDefaultParameterValues['Add-Content:Encoding']='utf8';$PSDefaultParameterValues['Out-File:Encoding']='utf8';";
-      args = ["-NoProfile", "-Command", PS_UTF8 + trimmed];
-    } else if (FIREJAIL_AVAILABLE) {
-      bin = "firejail";
-      args = [
-        "--quiet",
-        "--noprofile",
-        `--private=${WORKSPACE_DIR}`,
-        "--net=none",
-        "--rlimit-fsize=50000000",
-        "--rlimit-as=1073741824",
-        "bash",
-        "-c",
-        trimmed
-      ];
-    } else {
-      bin = "bash";
-      args = ["-c", trimmed];
-    }
-    (0, import_child_process.execFile)(
-      bin,
-      args,
-      { cwd: WORKSPACE_DIR, timeout: TIMEOUT_MS, maxBuffer: MAX_BUFFER, env: SAFE_ENV },
-      (err, stdout, stderr) => {
-        const out = (stdout || "").toString().slice(0, 2e4);
-        const errOut = (stderr || "").toString().slice(0, 2e4);
-        if (err && err.killed) {
-          const msg = `Command timed out (${TIMEOUT_MS / 1e3}s limit).`;
-          return res.json({ stdout: out, stderr: msg, formattedText: `$ ${trimmed}
-${out}
-${msg}`.trim(), timedOut: true });
-        }
-        const exitCode = err ? typeof err.code === "number" ? err.code : 1 : 0;
-        const body = `${out}${errOut ? (out ? "\n" : "") + errOut : ""}`.trim() || "(no output)";
-        const formattedText = `$ ${trimmed}
-${body}`;
-        return res.json({ stdout: out, stderr: errOut, exitCode, formattedText });
-      }
-    );
-  });
-  app.post("/api/upload-workspace-file", import_express.default.json({ limit: "10mb" }), async (req, res) => {
-    const perm = getPermissionMode();
-    if (perm === "readOnly" || perm === "ask" && !isGranted("file")) {
-      const hint = perm === "ask" ? "requires confirmation via ConfirmModal or POST /api/permission/approve {type:'file'}" : "readOnly";
-      return res.status(403).json({ error: `Blocked by permission mode '${perm}': file write ${hint}`, needConfirm: perm === "ask", permission: perm });
-    }
-    try {
-      const { name, content, encoding = "utf-8" } = req.body || {};
-      if (!name || typeof name !== "string") {
-        return res.status(400).json({ error: "Missing file name" });
-      }
-      const cleanName = name.trim().replace(/^(\.\/|\/)+/, "");
-      const filePath = import_path.default.join(WORKSPACE_DIR, cleanName);
-      const dir = import_path.default.dirname(filePath);
-      if (!isInsideWorkspace(dir)) {
-        return res.status(403).json({ error: "Invalid file path outside workspace" });
-      }
-      await import_fs.default.promises.mkdir(dir, { recursive: true });
-      let buffer;
-      if ((encoding === "base64" || cleanName.toLowerCase().endsWith(".zip")) && typeof content === "string") {
-        let rawBase64 = content;
-        if (rawBase64.includes(",")) {
-          rawBase64 = rawBase64.split(",")[1];
-        }
-        buffer = Buffer.from(rawBase64, "base64");
-      } else if (typeof content === "string") {
-        buffer = Buffer.from(content, "utf-8");
-      } else {
-        buffer = Buffer.from("");
-      }
-      await import_fs.default.promises.writeFile(filePath, buffer);
-      const stats = await import_fs.default.promises.stat(filePath);
-      return res.json({
-        success: true,
-        path: cleanName,
-        name: import_path.default.basename(cleanName),
-        size: stats.size,
-        updatedAt: stats.mtimeMs
-      });
-    } catch (err) {
-      console.error("Upload workspace file error:", err);
-      return res.status(500).json({ error: err?.message || "Failed to upload workspace file" });
-    }
-  });
-  app.post("/api/delete-workspace-file", import_express.default.json(), async (req, res) => {
-    const perm = getPermissionMode();
-    if (perm === "readOnly" || perm === "ask" && !isGranted("file")) {
-      const hint = perm === "ask" ? "requires confirmation via ConfirmModal or POST /api/permission/approve {type:'file'}" : "readOnly";
-      return res.status(403).json({ error: `Blocked by permission mode '${perm}': file delete ${hint}`, needConfirm: perm === "ask", permission: perm });
-    }
-    try {
-      const { path: filePathParam } = req.body || {};
-      if (!filePathParam || typeof filePathParam !== "string") {
-        return res.status(400).json({ error: "Missing file path" });
-      }
-      const cleanName = filePathParam.trim().replace(/^(\.\/|\/)+/, "");
-      const targetPath = import_path.default.join(WORKSPACE_DIR, cleanName);
-      if (!isInsideWorkspace(targetPath)) {
-        return res.status(403).json({ error: "Invalid file path outside workspace" });
-      }
-      if (import_fs.default.existsSync(targetPath)) {
-        await import_fs.default.promises.rm(targetPath, { recursive: true, force: true });
-      }
-      return res.json({ success: true, path: cleanName });
-    } catch (err) {
-      console.error("Delete workspace file error:", err);
-      return res.status(500).json({ error: err?.message || "Failed to delete workspace file" });
-    }
-  });
-  app.get("/api/workspace-files", async (_req, res) => {
-    try {
-      const filesMap = {};
-      async function walkDir(currentDir, relativeDir = "") {
-        let entries = [];
-        try {
-          entries = await import_fs.default.promises.readdir(currentDir, { withFileTypes: true });
-        } catch {
-          return;
-        }
-        for (const entry of entries) {
-          if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
-          const fullPath = import_path.default.join(currentDir, entry.name);
-          const relPath = relativeDir ? `${relativeDir}/${entry.name}` : entry.name;
-          if (entry.isDirectory()) {
-            await walkDir(fullPath, relPath);
-          } else if (entry.isFile()) {
-            try {
-              const stats = await import_fs.default.promises.stat(fullPath);
-              if (stats.size <= 2 * 1024 * 1024) {
-                const ext = entry.name.split(".").pop()?.toLowerCase() || "";
-                const isBinary = ["zip", "gz", "tar", "tgz", "rar", "7z", "png", "jpg", "jpeg", "gif", "pdf", "exe", "bin", "apk", "iso"].includes(ext);
-                let content = "";
-                let fileEncoding = "utf-8";
-                if (isBinary) {
-                  content = `[Binary File: ${entry.name} (${(stats.size / 1024).toFixed(1)} KB)]`;
-                } else {
-                  try {
-                    const dec = decodeTextBuffer(await import_fs.default.promises.readFile(fullPath));
-                    content = dec.text;
-                    fileEncoding = dec.encoding;
-                  } catch {
-                    content = `[Unreadable File: ${(stats.size / 1024).toFixed(1)} KB]`;
-                  }
-                }
-                filesMap[relPath] = {
-                  path: relPath,
-                  name: entry.name,
-                  content,
-                  size: stats.size,
-                  language: ext,
-                  encoding: fileEncoding,
-                  updatedAt: stats.mtimeMs
-                };
-              } else {
-                filesMap[relPath] = {
-                  path: relPath,
-                  name: entry.name,
-                  content: `[Large File: ${(stats.size / 1024).toFixed(1)} KB]`,
-                  size: stats.size,
-                  language: entry.name.split(".").pop()?.toLowerCase() || "binary",
-                  updatedAt: stats.mtimeMs
-                };
-              }
-            } catch {
-            }
-          }
-        }
-      }
-      await walkDir(WORKSPACE_DIR);
-      return res.json({ files: filesMap });
-    } catch (err) {
-      return res.status(500).json({ error: err?.message || "Failed to list workspace files" });
-    }
-  });
+  registerLocalRoutes(app);
   app.get("/api/health", (_req, res) => {
-    res.json({ status: "ok", workspace: WORKSPACE_DIR, permission: getPermissionMode(), platform: process.platform });
+    res.json({ status: "ok" });
   });
   if (process.env.NODE_ENV !== "production") {
     const vite = await (0, import_vite.createServer)({
-      server: { middlewareMode: true },
+      server: { middlewareMode: true, hmr: false },
       appType: "spa"
     });
     app.use(vite.middlewares);
   } else {
-    const distPath = import_path.default.join(process.cwd(), "dist");
+    const distPath = import_path3.default.join(process.cwd(), "dist");
     app.use(import_express.default.static(distPath));
     app.get("*", (_req, res) => {
-      res.sendFile(import_path.default.join(distPath, "index.html"));
+      res.sendFile(import_path3.default.join(distPath, "index.html"));
     });
   }
-  const HOST = process.env.HOST || "0.0.0.0";
-  const cfgDir = getFanlucConfigDir();
-  const permMode = getPermissionMode();
-  const fanlucMd = loadFanlucMdSync();
-  console.log(`[fanluc] Workspace : ${WORKSPACE_DIR}`);
-  console.log(`[fanluc] Config dir: ${cfgDir}`);
-  console.log(`[fanluc] Permission: ${permMode}`);
-  if (fanlucMd) console.log(`[fanluc] FANLUC.md  : ${fanlucMd.path} (${fanlucMd.content.length} chars)`);
-  else console.log(`[fanluc] FANLUC.md  : (none)`);
+  const HOST = process.env.HOST || "127.0.0.1";
   app.listen(PORT, HOST, () => {
-    const displayHost = HOST === "0.0.0.0" ? "localhost" : HOST;
-    console.log(`Server running on http://${displayHost}:${PORT}`);
-    console.log(`Health: http://${displayHost}:${PORT}/api/health`);
+    console.log(`Server running on http://localhost:${PORT}  (bound to ${HOST})`);
+    console.log(`Workspace: ${getWorkspace()}  |  shell: ${SHELL.label}`);
+    if (!["127.0.0.1", "localhost", "::1"].includes(HOST)) {
+      console.warn("[security] HOST is not loopback. Commands run WITHOUT a sandbox: anyone who can reach this port can run commands on this PC.");
+    }
   });
 }
-if (process.env.FANLUC_NO_AUTO_START !== "1") {
-  startServer().catch((e) => {
-    console.error("Failed to start server:", e);
-    process.exit(1);
-  });
+var shuttingDown = false;
+function closeAllMcp() {
+  if (shuttingDown) return;
+  shuttingDown = true;
+  for (const entry of mcp.values()) {
+    try {
+      entry.client?.close();
+    } catch {
+    }
+  }
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  WORKSPACE_DIR,
-  startServer
+process.on("SIGINT", () => {
+  closeAllMcp();
+  setTimeout(() => process.exit(0), 300);
+});
+process.on("SIGTERM", () => {
+  closeAllMcp();
+  setTimeout(() => process.exit(0), 300);
 });
+process.on("exit", closeAllMcp);
+startServer();
 //# sourceMappingURL=server.cjs.map