auvezy-terminal-remote 0.7.6 → 0.9.0

package/dist/cli.js

@@ -75,30 +75,43 @@ function ensureDefaultUserConfig(input) {
   const workdirAllow = normalizeStringArray(src.workdirAllow);
   const workdirDeny = src.workdirDeny === void 0 || !Array.isArray(src.workdirDeny) ? [...DEFAULT_WORKDIR_DENY] : normalizeStringArray(src.workdirDeny) ?? [];
   const rawDisplay = src.display;
-  const fsMinRaw = rawDisplay?.fontSizeMin;
-  const fsMaxRaw = rawDisplay?.fontSizeMax;
-  let fontSizeMin = typeof fsMinRaw === "number" && Number.isFinite(fsMinRaw) && fsMinRaw >= FONT_SIZE_FLOOR && fsMinRaw <= FONT_SIZE_CEIL ? Math.trunc(fsMinRaw) : DEFAULT_DISPLAY.fontSizeMin;
-  let fontSizeMax = typeof fsMaxRaw === "number" && Number.isFinite(fsMaxRaw) && fsMaxRaw >= FONT_SIZE_FLOOR && fsMaxRaw <= FONT_SIZE_CEIL ? Math.trunc(fsMaxRaw) : DEFAULT_DISPLAY.fontSizeMax;
+  let fontSizeMin = normalizeBoundedNumber(rawDisplay?.fontSizeMin, FONT_SIZE_FLOOR, FONT_SIZE_CEIL, DEFAULT_DISPLAY.fontSizeMin, { truncate: true });
+  let fontSizeMax = normalizeBoundedNumber(rawDisplay?.fontSizeMax, FONT_SIZE_FLOOR, FONT_SIZE_CEIL, DEFAULT_DISPLAY.fontSizeMax, { truncate: true });
   if (fontSizeMin > fontSizeMax) {
     [fontSizeMin, fontSizeMax] = [fontSizeMax, fontSizeMin];
   }
   const legacyTargetCols = rawDisplay?.targetCols;
-  const colsRaw = rawDisplay?.maxCols ?? legacyTargetCols;
-  const maxCols = typeof colsRaw === "number" && Number.isFinite(colsRaw) && colsRaw >= 0 && colsRaw <= 500 ? Math.trunc(colsRaw) : DEFAULT_DISPLAY.maxCols;
-  const lsRaw = rawDisplay?.letterSpacing;
-  const letterSpacing = typeof lsRaw === "number" && Number.isFinite(lsRaw) && lsRaw >= -4 && lsRaw <= 8 ? lsRaw : DEFAULT_DISPLAY.letterSpacing;
+  const maxCols = normalizeBoundedNumber(rawDisplay?.maxCols ?? legacyTargetCols, 0, 500, DEFAULT_DISPLAY.maxCols, { truncate: true });
+  const letterSpacing = normalizeBoundedNumber(rawDisplay?.letterSpacing, -4, 8, DEFAULT_DISPLAY.letterSpacing);
   const themeRaw = rawDisplay?.theme;
   const theme = themeRaw === "dark" || themeRaw === "light" || themeRaw === "dark-ansi" || themeRaw === "light-ansi" || themeRaw === "dark-daltonized" || themeRaw === "light-daltonized" || themeRaw === "auto" ? themeRaw : DEFAULT_DISPLAY.theme;
+  const markdownPreview = typeof rawDisplay?.markdownPreview === "boolean" ? rawDisplay.markdownPreview : DEFAULT_DISPLAY.markdownPreview;
   const display = {
     fontSizeMin,
     fontSizeMax,
     maxCols,
     letterSpacing,
-    theme
+    theme,
+    markdownPreview
   };
   const rawIntegrations = src.integrations;
   const ccUserEvents = rawIntegrations?.perModule?.["claude-code"]?.events ?? {};
   const ccDefaults = DEFAULT_INTEGRATIONS.perModule["claude-code"].events;
+  const userRenderingMd = rawIntegrations?.rendering?.markdown?.enabled;
+  const renderingMdEnabled = typeof userRenderingMd === "boolean" ? userRenderingMd : typeof rawDisplay?.markdownPreview === "boolean" ? rawDisplay.markdownPreview : DEFAULT_INTEGRATIONS.rendering.markdown.enabled;
+  const userObsidian = rawIntegrations?.rendering?.obsidian;
+  const obsDefaults = DEFAULT_INTEGRATIONS.rendering.obsidian;
+  const rendering = {
+    markdown: { enabled: renderingMdEnabled },
+    obsidian: {
+      enabled: typeof userObsidian?.enabled === "boolean" ? userObsidian.enabled : obsDefaults.enabled,
+      frontmatter: typeof userObsidian?.frontmatter === "boolean" ? userObsidian.frontmatter : obsDefaults.frontmatter,
+      wikilink: typeof userObsidian?.wikilink === "boolean" ? userObsidian.wikilink : obsDefaults.wikilink,
+      embed: typeof userObsidian?.embed === "boolean" ? userObsidian.embed : obsDefaults.embed,
+      callout: typeof userObsidian?.callout === "boolean" ? userObsidian.callout : obsDefaults.callout,
+      inlineSyntax: typeof userObsidian?.inlineSyntax === "boolean" ? userObsidian.inlineSyntax : obsDefaults.inlineSyntax
+    }
+  };
   const integrations = {
     enabled: typeof rawIntegrations?.enabled === "boolean" ? rawIntegrations.enabled : DEFAULT_INTEGRATIONS.enabled,
     forceModule: rawIntegrations?.forceModule === "auto" || rawIntegrations?.forceModule === "claude-code" || rawIntegrations?.forceModule === "none" ? rawIntegrations.forceModule : DEFAULT_INTEGRATIONS.forceModule,
@@ -112,7 +125,8 @@ function ensureDefaultUserConfig(input) {
           userPrompts: typeof ccUserEvents.userPrompts === "boolean" ? ccUserEvents.userPrompts : ccDefaults.userPrompts
         }
       }
-    }
+    },
+    rendering
   };
   return {
     ...src,
@@ -139,6 +153,13 @@ function normalizeStringArray(input) {
   }
   return out;
 }
+function normalizeBoundedNumber(input, min, max, fallback, opts = {}) {
+  if (typeof input !== "number" || !Number.isFinite(input))
+    return fallback;
+  if (input < min || input > max)
+    return fallback;
+  return opts.truncate ? Math.trunc(input) : input;
+}
 var SHORTCUT_GROUPS, DEFAULT_SHORTCUTS, COMMAND_GROUPS, DEFAULT_COMMANDS, DEFAULT_INTEGRATIONS, DEFAULT_INPUT, DEFAULT_DISPLAY, FONT_SIZE_FLOOR, FONT_SIZE_CEIL, DEFAULT_WORKDIR_DENY;
 var init_defaults = __esm({
   "shared/dist/defaults.js"() {
@@ -342,6 +363,17 @@ var init_defaults = __esm({
             userPrompts: false
           }
         }
+      },
+      rendering: {
+        markdown: { enabled: true },
+        obsidian: {
+          enabled: true,
+          frontmatter: true,
+          wikilink: true,
+          embed: true,
+          callout: true,
+          inlineSyntax: true
+        }
       }
     };
     DEFAULT_INPUT = {
@@ -357,8 +389,9 @@ var init_defaults = __esm({
       maxCols: 0,
       // 0 = 关闭自适应
       letterSpacing: 0,
-      theme: "auto"
+      theme: "auto",
       // 跟随系统亮暗模式:dark → Campbell, light → Solarized Light
+      markdownPreview: true
     };
     FONT_SIZE_FLOOR = 6;
     FONT_SIZE_CEIL = 32;
@@ -419,6 +452,14 @@ var init_errors = __esm({
       ErrorCode2["PUSH_SEND_FAILED"] = "PUSH_SEND_FAILED";
       ErrorCode2["HOOK_INVALID_PAYLOAD"] = "HOOK_INVALID_PAYLOAD";
       ErrorCode2["HOOK_NON_LOCALHOST"] = "HOOK_NON_LOCALHOST";
+      ErrorCode2["BAD_REQUEST"] = "BAD_REQUEST";
+      ErrorCode2["PATH_NOT_FOUND"] = "PATH_NOT_FOUND";
+      ErrorCode2["PATH_FORBIDDEN"] = "PATH_FORBIDDEN";
+      ErrorCode2["FILE_TOO_LARGE"] = "FILE_TOO_LARGE";
+      ErrorCode2["FILE_BINARY"] = "FILE_BINARY";
+      ErrorCode2["FILE_TYPE_FORBID"] = "FILE_TYPE_FORBID";
+      ErrorCode2["SEARCH_INVALID_Q"] = "SEARCH_INVALID_Q";
+      ErrorCode2["SEARCH_TIMEOUT"] = "SEARCH_TIMEOUT";
       ErrorCode2["INTERNAL_ERROR"] = "INTERNAL_ERROR";
       ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
     })(ErrorCode || (ErrorCode = {}));
@@ -439,8 +480,8 @@ function injectManifestToken(html, token) {
   if (!hm)
     return html;
   const oldHref = hm[2] ?? hm[3] ?? "";
-  const sep2 = oldHref.includes("?") ? "&" : "?";
-  const newHref = `${oldHref}${sep2}token=${encodeURIComponent(token)}`;
+  const sep3 = oldHref.includes("?") ? "&" : "?";
+  const newHref = `${oldHref}${sep3}token=${encodeURIComponent(token)}`;
   const newTag = tag.replace(hrefRe, `href="${newHref}"`);
   return html.replace(tag, newTag);
 }
@@ -450,6 +491,26 @@ var init_html_injection = __esm({
   }
 });
 
+// shared/dist/files.js
+function isSearchMode(v) {
+  return typeof v === "string" && SEARCH_MODES.includes(v);
+}
+var SEARCH_MODES, FILE_READ_MAX_BYTES, FILE_RAW_MAX_BYTES, SEARCH_MAX_Q_LENGTH, SEARCH_MAX_NAME_RESULTS, SEARCH_MAX_CONTENT_RESULTS, SEARCH_FILE_TIMEOUT_MS, SEARCH_TOTAL_TIMEOUT_MS, SEARCH_CONCURRENCY;
+var init_files = __esm({
+  "shared/dist/files.js"() {
+    "use strict";
+    SEARCH_MODES = ["name", "content", "both"];
+    FILE_READ_MAX_BYTES = 2 * 1024 * 1024;
+    FILE_RAW_MAX_BYTES = 8 * 1024 * 1024;
+    SEARCH_MAX_Q_LENGTH = 200;
+    SEARCH_MAX_NAME_RESULTS = 100;
+    SEARCH_MAX_CONTENT_RESULTS = 200;
+    SEARCH_FILE_TIMEOUT_MS = 100;
+    SEARCH_TOTAL_TIMEOUT_MS = 5e3;
+    SEARCH_CONCURRENCY = 8;
+  }
+});
+
 // shared/dist/index.js
 var init_dist = __esm({
   "shared/dist/index.js"() {
@@ -462,11 +523,12 @@ var init_dist = __esm({
     init_action_tree_defaults();
     init_errors();
     init_html_injection();
+    init_files();
   }
 });
 
 // backend/dist/errors.js
-var AppError, AuthError, PtyError, ConfigError, InstanceError, LockError, HookError, PushError;
+var AppError, AuthError, PtyError, ConfigError, InstanceError, LockError, HookError, PushError, FileError;
 var init_errors2 = __esm({
   "backend/dist/errors.js"() {
     "use strict";
@@ -531,6 +593,11 @@ Caused by: ${cause.stack}`;
         super(code, message, httpStatus, cause);
       }
     };
+    FileError = class extends AppError {
+      constructor(code, message, httpStatus = 400, cause) {
+        super(code, message, httpStatus, cause);
+      }
+    };
   }
 });
 
@@ -1352,7 +1419,7 @@ function getEntryUrl(req, subPath = "") {
 function isFromBroker(req) {
   return getInstanceFromHeaders(req.headers) !== null;
 }
-var HEADER_FORWARDED_INSTANCE, HEADER_FORWARDED_PATH, HEADER_FORWARDED_HOST, HEADER_FORWARDED_PROTO, HEADER_FORWARDED_FOR;
+var HEADER_FORWARDED_INSTANCE, HEADER_FORWARDED_PATH, HEADER_FORWARDED_HOST, HEADER_FORWARDED_PROTO, HEADER_FORWARDED_FOR, HEADER_ATR_ERROR;
 var init_forwarded_headers = __esm({
   "backend/dist/broker/forwarded-headers.js"() {
     "use strict";
@@ -1361,6 +1428,7 @@ var init_forwarded_headers = __esm({
     HEADER_FORWARDED_HOST = "x-forwarded-host";
     HEADER_FORWARDED_PROTO = "x-forwarded-proto";
     HEADER_FORWARDED_FOR = "x-forwarded-for";
+    HEADER_ATR_ERROR = "X-ATR-Error";
   }
 });
 
@@ -1556,79 +1624,1807 @@ function collectEndpoints(port, displayIp) {
           continue;
         ipv6KeptForIface = true;
       }
-      const kind = classify(ip, info.family);
-      out.push({ host: ip, port, kind, interface: ifname });
+      const kind = classify(ip, info.family);
+      out.push({ host: ip, port, kind, interface: ifname });
+    }
+  }
+  if (!out.some((e) => e.kind === "loopback")) {
+    out.push({ host: "127.0.0.1", port, kind: "loopback" });
+  }
+  const order = {
+    lan: 0,
+    tailscale: 1,
+    other: 2,
+    ipv6: 3,
+    loopback: 4
+  };
+  out.sort((a, b) => {
+    if (a.kind !== b.kind)
+      return order[a.kind] - order[b.kind];
+    if (a.host === displayIp)
+      return -1;
+    if (b.host === displayIp)
+      return 1;
+    return 0;
+  });
+  let defaultIdx = out.findIndex((e) => e.host === displayIp);
+  if (defaultIdx === -1) {
+    defaultIdx = out.findIndex((e) => e.kind !== "loopback");
+  }
+  if (defaultIdx === -1 && out.length > 0)
+    defaultIdx = 0;
+  if (defaultIdx >= 0)
+    out[defaultIdx].isDefault = true;
+  return out;
+}
+function classify(ip, family) {
+  if (isLoopbackIp(ip))
+    return "loopback";
+  if (family === "IPv6")
+    return "ipv6";
+  if (isTailscaleIp(ip))
+    return "tailscale";
+  if (isPrivateIp(ip))
+    return "lan";
+  if (isLinkLocal(ip))
+    return "other";
+  return "other";
+}
+var init_share_routes = __esm({
+  "backend/dist/api/share-routes.js"() {
+    "use strict";
+    init_network();
+  }
+});
+
+// backend/dist/api/workdir-policy-routes.js
+import { Router as Router8 } from "express";
+function createWorkdirPolicyRoutes(authModule, snapshot) {
+  const router = Router8();
+  router.get("/workdir-policy", authModule.requireAuth, (_req, res) => {
+    const s = snapshot();
+    res.json({ ok: true, allow: s.allow });
+  });
+  return router;
+}
+var init_workdir_policy_routes = __esm({
+  "backend/dist/api/workdir-policy-routes.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/auth/rate-limiter.js
+var RateLimiter;
+var init_rate_limiter = __esm({
+  "backend/dist/auth/rate-limiter.js"() {
+    "use strict";
+    init_logger();
+    RateLimiter = class {
+      entries = /* @__PURE__ */ new Map();
+      maxAttempts;
+      windowMs;
+      cleanupTimer = null;
+      /**
+       * @param maxAttempts 窗口内最大允许次数
+       * @param windowMs   窗口长度（毫秒），默认 60s
+       */
+      constructor(maxAttempts, windowMs = 6e4) {
+        if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) {
+          throw new Error("RateLimiter: maxAttempts \u5FC5\u987B\u662F\u6B63\u6574\u6570");
+        }
+        this.maxAttempts = maxAttempts;
+        this.windowMs = windowMs;
+        this.cleanupTimer = setInterval(() => this.cleanup(), windowMs * 2);
+        if (typeof this.cleanupTimer.unref === "function") {
+          this.cleanupTimer.unref();
+        }
+      }
+      /**
+       * 尝试一次请求，自动累加计数
+       *
+       * @returns true 通过 / false 已超限被拒
+       */
+      attempt(ip) {
+        const now = Date.now();
+        const entry = this.entries.get(ip);
+        if (!entry || now >= entry.resetAt) {
+          this.entries.set(ip, { count: 1, resetAt: now + this.windowMs });
+          return true;
+        }
+        entry.count++;
+        if (entry.count > this.maxAttempts) {
+          logger.warn({ ip, count: entry.count, max: this.maxAttempts }, "\u8BA4\u8BC1\u901F\u7387\u8D85\u9650");
+          return false;
+        }
+        return true;
+      }
+      /** 当前窗口内剩余次数 */
+      remaining(ip) {
+        const now = Date.now();
+        const entry = this.entries.get(ip);
+        if (!entry || now >= entry.resetAt)
+          return this.maxAttempts;
+        return Math.max(0, this.maxAttempts - entry.count);
+      }
+      /**
+       * 重置某 IP 的计数（认证成功后清零）
+       *
+       * 让合法用户不会因为之前误输导致后续尝试被限流
+       */
+      reset(ip) {
+        this.entries.delete(ip);
+      }
+      /** 清理过期 entry（避免内存膨胀） */
+      cleanup() {
+        const now = Date.now();
+        for (const [ip, entry] of this.entries) {
+          if (now >= entry.resetAt) {
+            this.entries.delete(ip);
+          }
+        }
+      }
+      /** 销毁定时器 */
+      destroy() {
+        if (this.cleanupTimer) {
+          clearInterval(this.cleanupTimer);
+          this.cleanupTimer = null;
+        }
+      }
+    };
+  }
+});
+
+// backend/dist/constants.js
+var WS_FLUSH_INTERVAL_MS, WS_MAX_CHUNK_BYTES, WS_HIGH_WATERMARK_BYTES, FILE_LOCK_RETRIES, FILE_LOCK_RETRY_INTERVAL_MS, FILE_LOCK_STALE_MS, FILE_RATE_LIMIT_PER_MIN, SEARCH_RATE_LIMIT_PER_MIN, PTY_DEFAULT_COLS, PTY_DEFAULT_ROWS, PTY_TERM_NAME, DOUBLE_PULSE_DELAY_MS, SHUTDOWN_WS_FLUSH_DELAY_MS, SHUTDOWN_FORCE_EXIT_MS, DOUBLE_CTRL_C_WINDOW_MS, PORT_FINDER_MAX_ATTEMPTS, STOP_INSTANCE_GRACE_MS, STOP_INSTANCE_POLL_INTERVAL_MS, ATTACH_RECONNECT_DELAYS_MS;
+var init_constants2 = __esm({
+  "backend/dist/constants.js"() {
+    "use strict";
+    WS_FLUSH_INTERVAL_MS = 16;
+    WS_MAX_CHUNK_BYTES = 32 * 1024;
+    WS_HIGH_WATERMARK_BYTES = 256 * 1024;
+    FILE_LOCK_RETRIES = 50;
+    FILE_LOCK_RETRY_INTERVAL_MS = 50;
+    FILE_LOCK_STALE_MS = 1e4;
+    FILE_RATE_LIMIT_PER_MIN = 600;
+    SEARCH_RATE_LIMIT_PER_MIN = 60;
+    PTY_DEFAULT_COLS = 80;
+    PTY_DEFAULT_ROWS = 24;
+    PTY_TERM_NAME = "xterm-256color";
+    DOUBLE_PULSE_DELAY_MS = 50;
+    SHUTDOWN_WS_FLUSH_DELAY_MS = 500;
+    SHUTDOWN_FORCE_EXIT_MS = 2e3;
+    DOUBLE_CTRL_C_WINDOW_MS = 500;
+    PORT_FINDER_MAX_ATTEMPTS = 100;
+    STOP_INSTANCE_GRACE_MS = 3e3;
+    STOP_INSTANCE_POLL_INTERVAL_MS = 100;
+    ATTACH_RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+  }
+});
+
+// backend/dist/utils/workdir-policy.js
+import picomatch from "picomatch";
+function checkWorkdir(cwd, allow, deny) {
+  const norm = normalizePath(cwd);
+  const opts = { dot: true };
+  if (deny && deny.length > 0) {
+    for (const pattern of deny) {
+      if (picomatch(pattern, opts)(norm)) {
+        return {
+          reason: `cwd "${cwd}" \u547D\u4E2D\u9ED1\u540D\u5355 pattern\uFF1A${pattern}`,
+          matchedPattern: pattern
+        };
+      }
+    }
+  }
+  if (allow && allow.length > 0) {
+    let hit = false;
+    for (const pattern of allow) {
+      if (picomatch(pattern, opts)(norm)) {
+        hit = true;
+        break;
+      }
+    }
+    if (!hit) {
+      return {
+        reason: `cwd "${cwd}" \u672A\u547D\u4E2D\u4EFB\u4F55\u767D\u540D\u5355 pattern\uFF1A[${allow.join(", ")}]`,
+        matchedPattern: ""
+      };
+    }
+  }
+  return null;
+}
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+var init_workdir_policy = __esm({
+  "backend/dist/utils/workdir-policy.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/files/path-resolver.js
+import { realpathSync } from "node:fs";
+import { isAbsolute, relative as relativePath, resolve as resolvePath } from "node:path";
+function resolveSafePath(cwd, input, policy) {
+  const raw = input && input.length > 0 ? input : ".";
+  const abs = isAbsolute(raw) ? raw : resolvePath(cwd, raw);
+  let real;
+  try {
+    real = realpathSync(abs);
+  } catch (err) {
+    throw new FileError(ErrorCode.PATH_NOT_FOUND, `path not found: ${abs}`, 404, err);
+  }
+  const cwdReal = realpathSync(cwd);
+  if (!isWithin(cwdReal, real)) {
+    throw new FileError(ErrorCode.PATH_FORBIDDEN, `path outside instance cwd: ${real}`, 403);
+  }
+  const verdict = checkWorkdir(real, policy.allow, policy.deny);
+  if (verdict !== null) {
+    throw new FileError(ErrorCode.PATH_FORBIDDEN, `path forbidden: ${verdict.reason}`, 403);
+  }
+  return real;
+}
+function isWithin(parent, child) {
+  if (parent === child)
+    return true;
+  const rel = relativePath(parent, child);
+  if (rel === "" || rel === ".")
+    return true;
+  if (isAbsolute(rel))
+    return false;
+  if (rel.startsWith(".."))
+    return false;
+  return true;
+}
+var init_path_resolver = __esm({
+  "backend/dist/files/path-resolver.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_workdir_policy();
+  }
+});
+
+// backend/dist/files/mime-detect.js
+import { basename as basename2, extname } from "node:path";
+function detectMime(filename) {
+  const base = basename2(filename);
+  const special = lookupSpecial(base);
+  if (special) {
+    return { mime: special.mime, previewable: special.previewable, lang: special.lang };
+  }
+  const ext = extname(base).toLowerCase();
+  const lang = LANG_MAP[ext] ?? "txt";
+  if (ext in IMAGE_EXT_TO_MIME) {
+    return { mime: IMAGE_EXT_TO_MIME[ext], previewable: "image", lang };
+  }
+  if (ext in TEXT_EXT_TO_MIME) {
+    return { mime: TEXT_EXT_TO_MIME[ext], previewable: "text", lang };
+  }
+  return { mime: "application/octet-stream", previewable: "none", lang };
+}
+function lookupSpecial(base) {
+  if (base in SPECIAL_NAMES)
+    return SPECIAL_NAMES[base];
+  const ext = extname(base).toLowerCase();
+  if (ext === "" || ext === ".md" || ext === ".markdown" || ext === ".txt") {
+    const stem = base.slice(0, base.length - ext.length);
+    const upper = stem.toUpperCase();
+    if (upper === "README" || upper === "CHANGELOG" || upper === "LICENSE" || upper === "COPYING" || upper === "AUTHORS" || upper === "CONTRIBUTORS" || upper === "NOTICE" || upper === "TODO") {
+      const isMd = ext === ".md" || ext === ".markdown";
+      const baseEntry = SPECIAL_NAMES[upper];
+      if (baseEntry) {
+        return isMd ? { ...baseEntry, lang: "markdown", mime: "text/markdown" } : baseEntry;
+      }
+    }
+  }
+  return null;
+}
+var SPECIAL_NAMES, IMAGE_EXT_TO_MIME, TEXT_EXT_TO_MIME, LANG_MAP;
+var init_mime_detect = __esm({
+  "backend/dist/files/mime-detect.js"() {
+    "use strict";
+    SPECIAL_NAMES = {
+      // ─── 构建/容器 ───
+      "Makefile": { mime: "text/x-makefile", lang: "makefile", previewable: "text" },
+      "GNUmakefile": { mime: "text/x-makefile", lang: "makefile", previewable: "text" },
+      "Dockerfile": { mime: "text/x-dockerfile", lang: "docker", previewable: "text" },
+      "Containerfile": { mime: "text/x-dockerfile", lang: "docker", previewable: "text" },
+      "CMakeLists.txt": { mime: "text/plain", lang: "cmake", previewable: "text" },
+      // ─── 包管理 / 工程 ───
+      "package.json": { mime: "application/json", lang: "json", previewable: "text" },
+      "package-lock.json": { mime: "application/json", lang: "json", previewable: "text" },
+      "tsconfig.json": { mime: "application/json", lang: "jsonc", previewable: "text" },
+      "tsconfig.base.json": { mime: "application/json", lang: "jsonc", previewable: "text" },
+      "jsconfig.json": { mime: "application/json", lang: "jsonc", previewable: "text" },
+      "turbo.json": { mime: "application/json", lang: "jsonc", previewable: "text" },
+      "nx.json": { mime: "application/json", lang: "json", previewable: "text" },
+      "lerna.json": { mime: "application/json", lang: "json", previewable: "text" },
+      "biome.json": { mime: "application/json", lang: "jsonc", previewable: "text" },
+      "composer.json": { mime: "application/json", lang: "json", previewable: "text" },
+      "composer.lock": { mime: "application/json", lang: "json", previewable: "text" },
+      "pnpm-workspace.yaml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      "pnpm-lock.yaml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      "yarn.lock": { mime: "text/plain", lang: "yaml", previewable: "text" },
+      "bun.lockb": { mime: "application/octet-stream", lang: "txt", previewable: "none" },
+      "bun.lock": { mime: "text/plain", lang: "toml", previewable: "text" },
+      // shiki 没有 go-mod grammar,降级 txt(纯文本仍可读,只是无着色)
+      "go.mod": { mime: "text/x-go-mod", lang: "txt", previewable: "text" },
+      "go.sum": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "Cargo.toml": { mime: "application/toml", lang: "toml", previewable: "text" },
+      "Cargo.lock": { mime: "application/toml", lang: "toml", previewable: "text" },
+      "pyproject.toml": { mime: "application/toml", lang: "toml", previewable: "text" },
+      "poetry.lock": { mime: "application/toml", lang: "toml", previewable: "text" },
+      "Pipfile": { mime: "application/toml", lang: "toml", previewable: "text" },
+      "Pipfile.lock": { mime: "application/json", lang: "json", previewable: "text" },
+      "requirements.txt": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "requirements-dev.txt": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "Rakefile": { mime: "text/x-ruby", lang: "ruby", previewable: "text" },
+      "Gemfile": { mime: "text/x-ruby", lang: "ruby", previewable: "text" },
+      "Gemfile.lock": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "Procfile": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "Brewfile": { mime: "text/x-ruby", lang: "ruby", previewable: "text" },
+      "Vagrantfile": { mime: "text/x-ruby", lang: "ruby", previewable: "text" },
+      "Justfile": { mime: "text/x-just", lang: "just", previewable: "text" },
+      "justfile": { mime: "text/x-just", lang: "just", previewable: "text" },
+      "Taskfile.yml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      "Taskfile.yaml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      // ─── 配置 dotfile ───
+      ".gitignore": { mime: "text/x-gitignore", lang: "txt", previewable: "text" },
+      ".gitattributes": { mime: "text/plain", lang: "txt", previewable: "text" },
+      ".gitmodules": { mime: "text/x-properties", lang: "ini", previewable: "text" },
+      ".gitconfig": { mime: "text/x-properties", lang: "ini", previewable: "text" },
+      ".dockerignore": { mime: "text/x-gitignore", lang: "txt", previewable: "text" },
+      ".npmignore": { mime: "text/x-gitignore", lang: "txt", previewable: "text" },
+      ".eslintignore": { mime: "text/x-gitignore", lang: "txt", previewable: "text" },
+      ".prettierignore": { mime: "text/x-gitignore", lang: "txt", previewable: "text" },
+      ".editorconfig": { mime: "text/x-properties", lang: "ini", previewable: "text" },
+      ".env": { mime: "text/plain", lang: "dotenv", previewable: "text" },
+      ".env.local": { mime: "text/plain", lang: "dotenv", previewable: "text" },
+      ".env.development": { mime: "text/plain", lang: "dotenv", previewable: "text" },
+      ".env.production": { mime: "text/plain", lang: "dotenv", previewable: "text" },
+      ".env.test": { mime: "text/plain", lang: "dotenv", previewable: "text" },
+      ".env.example": { mime: "text/plain", lang: "dotenv", previewable: "text" },
+      ".npmrc": { mime: "text/x-properties", lang: "ini", previewable: "text" },
+      ".yarnrc": { mime: "text/plain", lang: "yaml", previewable: "text" },
+      ".yarnrc.yml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      ".nvmrc": { mime: "text/plain", lang: "txt", previewable: "text" },
+      ".node-version": { mime: "text/plain", lang: "txt", previewable: "text" },
+      ".python-version": { mime: "text/plain", lang: "txt", previewable: "text" },
+      ".ruby-version": { mime: "text/plain", lang: "txt", previewable: "text" },
+      ".tool-versions": { mime: "text/plain", lang: "txt", previewable: "text" },
+      ".eslintrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".eslintrc.json": { mime: "application/json", lang: "json", previewable: "text" },
+      ".eslintrc.js": { mime: "text/javascript", lang: "js", previewable: "text" },
+      ".eslintrc.cjs": { mime: "text/javascript", lang: "js", previewable: "text" },
+      ".eslintrc.yml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      ".eslintrc.yaml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      ".prettierrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".prettierrc.json": { mime: "application/json", lang: "json", previewable: "text" },
+      ".prettierrc.js": { mime: "text/javascript", lang: "js", previewable: "text" },
+      ".prettierrc.cjs": { mime: "text/javascript", lang: "js", previewable: "text" },
+      ".prettierrc.yml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      ".prettierrc.yaml": { mime: "application/yaml", lang: "yaml", previewable: "text" },
+      ".stylelintrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".stylelintrc.json": { mime: "application/json", lang: "json", previewable: "text" },
+      ".babelrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".babelrc.json": { mime: "application/json", lang: "json", previewable: "text" },
+      ".swcrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".huskyrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".atrrc": { mime: "application/json", lang: "json", previewable: "text" },
+      ".bashrc": { mime: "text/x-shellscript", lang: "bash", previewable: "text" },
+      ".zshrc": { mime: "text/x-shellscript", lang: "bash", previewable: "text" },
+      ".profile": { mime: "text/x-shellscript", lang: "bash", previewable: "text" },
+      ".bash_profile": { mime: "text/x-shellscript", lang: "bash", previewable: "text" },
+      ".zprofile": { mime: "text/x-shellscript", lang: "bash", previewable: "text" },
+      ".zshenv": { mime: "text/x-shellscript", lang: "bash", previewable: "text" },
+      // ─── 文档约定(无扩展或带各种扩展,通常 markdown) ───
+      "README": { mime: "text/plain", lang: "markdown", previewable: "text" },
+      "CHANGELOG": { mime: "text/markdown", lang: "markdown", previewable: "text" },
+      "LICENSE": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "COPYING": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "AUTHORS": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "CONTRIBUTORS": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "NOTICE": { mime: "text/plain", lang: "txt", previewable: "text" },
+      "TODO": { mime: "text/plain", lang: "txt", previewable: "text" }
+    };
+    IMAGE_EXT_TO_MIME = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".jpe": "image/jpeg",
+      ".jfif": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".bmp": "image/bmp",
+      ".ico": "image/x-icon",
+      ".avif": "image/avif",
+      ".apng": "image/apng",
+      ".tiff": "image/tiff",
+      ".tif": "image/tiff"
+    };
+    TEXT_EXT_TO_MIME = {
+      // 纯文本 / 文档
+      ".txt": "text/plain",
+      ".text": "text/plain",
+      ".log": "text/plain",
+      ".md": "text/markdown",
+      ".markdown": "text/markdown",
+      ".mkd": "text/markdown",
+      ".mdx": "text/markdown",
+      ".mdc": "text/markdown",
+      ".rst": "text/x-rst",
+      ".adoc": "text/asciidoc",
+      ".asciidoc": "text/asciidoc",
+      ".tex": "text/x-tex",
+      ".bib": "text/x-bibtex",
+      // 数据 / 配置
+      ".json": "application/json",
+      ".jsonc": "application/json",
+      ".json5": "application/json",
+      ".jsonl": "application/x-jsonlines",
+      ".ndjson": "application/x-ndjson",
+      ".yml": "application/yaml",
+      ".yaml": "application/yaml",
+      ".toml": "application/toml",
+      ".ini": "text/x-properties",
+      ".cfg": "text/x-properties",
+      ".conf": "text/plain",
+      ".properties": "text/x-properties",
+      ".env": "text/plain",
+      ".example": "text/plain",
+      ".gitignore": "text/x-gitignore",
+      ".dockerignore": "text/x-gitignore",
+      ".csv": "text/csv",
+      ".tsv": "text/tab-separated-values",
+      ".lock": "text/plain",
+      ".xml": "application/xml",
+      ".xsl": "application/xml",
+      ".xsd": "application/xml",
+      ".plist": "application/xml",
+      ".po": "text/x-gettext",
+      ".pot": "text/x-gettext",
+      ".proto": "text/x-protobuf",
+      ".graphql": "application/graphql",
+      ".gql": "application/graphql",
+      // Web
+      ".html": "text/html",
+      ".htm": "text/html",
+      ".xhtml": "application/xhtml+xml",
+      ".css": "text/css",
+      ".scss": "text/x-scss",
+      ".sass": "text/x-sass",
+      ".less": "text/x-less",
+      ".styl": "text/x-stylus",
+      ".vue": "text/x-vue",
+      ".svelte": "text/x-svelte",
+      ".astro": "text/x-astro",
+      ".hbs": "text/x-handlebars",
+      ".handlebars": "text/x-handlebars",
+      ".pug": "text/x-pug",
+      ".jade": "text/x-pug",
+      ".ejs": "text/x-ejs",
+      ".erb": "text/x-erb",
+      ".liquid": "text/x-liquid",
+      ".twig": "text/x-twig",
+      ".njk": "text/x-jinja",
+      ".jinja": "text/x-jinja",
+      ".jinja2": "text/x-jinja",
+      ".j2": "text/x-jinja",
+      // JS/TS 系
+      ".ts": "text/typescript",
+      ".tsx": "text/tsx",
+      ".mts": "text/typescript",
+      ".cts": "text/typescript",
+      ".js": "text/javascript",
+      ".jsx": "text/jsx",
+      ".mjs": "text/javascript",
+      ".cjs": "text/javascript",
+      ".d.ts": "text/typescript",
+      // 系统/脚本
+      ".sh": "text/x-shellscript",
+      ".bash": "text/x-shellscript",
+      ".zsh": "text/x-shellscript",
+      ".fish": "text/x-shellscript",
+      ".ksh": "text/x-shellscript",
+      ".ps1": "text/x-powershell",
+      ".psm1": "text/x-powershell",
+      ".bat": "text/x-batchfile",
+      ".cmd": "text/x-batchfile",
+      ".awk": "text/x-awk",
+      ".sed": "text/x-sed",
+      ".nginx": "text/x-nginx-conf",
+      ".nginxconf": "text/x-nginx-conf",
+      ".service": "text/x-systemd",
+      ".timer": "text/x-systemd",
+      // Python / Ruby / Go / Rust / 其它语言
+      ".py": "text/x-python",
+      ".pyi": "text/x-python",
+      ".pyw": "text/x-python",
+      ".rb": "text/x-ruby",
+      ".rake": "text/x-ruby",
+      ".go": "text/x-go",
+      ".rs": "text/x-rust",
+      ".php": "text/x-php",
+      ".php3": "text/x-php",
+      ".phtml": "text/x-php",
+      ".java": "text/x-java",
+      ".kt": "text/x-kotlin",
+      ".kts": "text/x-kotlin",
+      ".swift": "text/x-swift",
+      ".c": "text/x-c",
+      ".h": "text/x-c",
+      ".cc": "text/x-c++",
+      ".cpp": "text/x-c++",
+      ".cxx": "text/x-c++",
+      ".hh": "text/x-c++",
+      ".hpp": "text/x-c++",
+      ".hxx": "text/x-c++",
+      ".cs": "text/x-csharp",
+      ".fs": "text/x-fsharp",
+      ".fsx": "text/x-fsharp",
+      ".m": "text/x-objective-c",
+      ".mm": "text/x-objective-c++",
+      ".scala": "text/x-scala",
+      ".sc": "text/x-scala",
+      ".ex": "text/x-elixir",
+      ".exs": "text/x-elixir",
+      ".erl": "text/x-erlang",
+      ".hrl": "text/x-erlang",
+      ".hs": "text/x-haskell",
+      ".lhs": "text/x-haskell",
+      ".lua": "text/x-lua",
+      ".r": "text/x-r",
+      ".R": "text/x-r",
+      ".dart": "text/x-dart",
+      ".pl": "text/x-perl",
+      ".pm": "text/x-perl",
+      ".groovy": "text/x-groovy",
+      ".gradle": "text/x-groovy",
+      ".clj": "text/x-clojure",
+      ".cljs": "text/x-clojure",
+      ".cljc": "text/x-clojure",
+      ".lisp": "text/x-common-lisp",
+      ".lsp": "text/x-common-lisp",
+      ".el": "text/x-emacs-lisp",
+      ".scheme": "text/x-scheme",
+      ".scm": "text/x-scheme",
+      ".ml": "text/x-ocaml",
+      ".mli": "text/x-ocaml",
+      ".jl": "text/x-julia",
+      ".zig": "text/x-zig",
+      ".nim": "text/x-nim",
+      ".cr": "text/x-crystal",
+      ".v": "text/x-v",
+      ".vala": "text/x-vala",
+      ".vb": "text/x-vb",
+      // 数据库 / 数据
+      ".sql": "application/sql",
+      ".psql": "application/sql",
+      ".mysql": "application/sql",
+      ".prisma": "text/x-prisma",
+      // 配置 / IaC
+      ".nix": "text/x-nix",
+      ".tf": "text/x-terraform",
+      ".tfvars": "text/x-terraform",
+      ".hcl": "text/x-hcl",
+      ".dockerfile": "text/x-dockerfile",
+      ".cmake": "text/x-cmake",
+      ".make": "text/x-makefile",
+      ".mk": "text/x-makefile",
+      ".makefile": "text/x-makefile",
+      ".gn": "text/x-gn",
+      ".bzl": "text/x-bzl",
+      ".bazel": "text/x-bzl",
+      // 其它
+      ".diff": "text/x-diff",
+      ".patch": "text/x-diff",
+      ".regex": "text/x-regex",
+      ".http": "message/http",
+      ".cmake.in": "text/x-cmake",
+      ".gitcommit": "text/x-git-commit"
+    };
+    LANG_MAP = {
+      // 纯文本 / 文档
+      ".md": "markdown",
+      ".markdown": "markdown",
+      ".mkd": "markdown",
+      ".mdx": "mdx",
+      ".mdc": "mdc",
+      ".rst": "rst",
+      ".adoc": "asciidoc",
+      ".asciidoc": "asciidoc",
+      ".tex": "latex",
+      ".bib": "bibtex",
+      ".log": "log",
+      // 数据 / 配置
+      ".json": "json",
+      ".jsonc": "jsonc",
+      ".json5": "json5",
+      ".jsonl": "jsonl",
+      ".ndjson": "jsonl",
+      ".yml": "yaml",
+      ".yaml": "yaml",
+      ".toml": "toml",
+      ".ini": "ini",
+      ".cfg": "ini",
+      ".properties": "ini",
+      ".conf": "ini",
+      ".env": "dotenv",
+      ".example": "dotenv",
+      ".xml": "xml",
+      ".xsl": "xml",
+      ".xsd": "xml",
+      ".plist": "xml",
+      ".proto": "proto",
+      ".graphql": "graphql",
+      ".gql": "graphql",
+      ".po": "po",
+      ".pot": "po",
+      // Web
+      ".html": "html",
+      ".htm": "html",
+      ".xhtml": "html",
+      ".css": "css",
+      ".scss": "scss",
+      ".sass": "sass",
+      ".less": "less",
+      ".styl": "stylus",
+      ".vue": "vue",
+      ".svelte": "svelte",
+      ".astro": "astro",
+      ".hbs": "handlebars",
+      ".handlebars": "handlebars",
+      ".pug": "pug",
+      ".jade": "pug",
+      ".erb": "erb",
+      ".liquid": "liquid",
+      ".twig": "twig",
+      ".jinja": "jinja",
+      ".jinja2": "jinja",
+      ".j2": "jinja",
+      ".njk": "jinja",
+      // JS / TS 系
+      ".ts": "ts",
+      ".tsx": "tsx",
+      ".mts": "ts",
+      ".cts": "ts",
+      ".js": "js",
+      ".jsx": "jsx",
+      ".mjs": "js",
+      ".cjs": "js",
+      ".d.ts": "ts",
+      // 系统 / 脚本
+      ".sh": "shell",
+      ".bash": "bash",
+      ".zsh": "bash",
+      ".fish": "fish",
+      ".ksh": "shell",
+      ".ps1": "powershell",
+      ".psm1": "powershell",
+      ".bat": "bat",
+      ".cmd": "bat",
+      ".awk": "awk",
+      ".nginx": "nginx",
+      ".nginxconf": "nginx",
+      ".service": "systemd",
+      ".timer": "systemd",
+      ".dockerfile": "docker",
+      // 语言
+      ".py": "python",
+      ".pyi": "python",
+      ".pyw": "python",
+      ".rb": "ruby",
+      ".rake": "ruby",
+      ".go": "go",
+      ".rs": "rust",
+      ".php": "php",
+      ".java": "java",
+      ".kt": "kotlin",
+      ".kts": "kotlin",
+      ".swift": "swift",
+      ".c": "c",
+      ".h": "c",
+      ".cc": "cpp",
+      ".cpp": "cpp",
+      ".cxx": "cpp",
+      ".hh": "cpp",
+      ".hpp": "cpp",
+      ".hxx": "cpp",
+      ".cs": "csharp",
+      ".fs": "fsharp",
+      ".fsx": "fsharp",
+      ".m": "objective-c",
+      ".mm": "objective-cpp",
+      ".scala": "scala",
+      ".sc": "scala",
+      ".ex": "elixir",
+      ".exs": "elixir",
+      ".erl": "erlang",
+      ".hrl": "erlang",
+      ".hs": "haskell",
+      ".lhs": "haskell",
+      ".lua": "lua",
+      ".r": "r",
+      ".R": "r",
+      ".dart": "dart",
+      ".pl": "perl",
+      ".pm": "perl",
+      ".groovy": "groovy",
+      ".gradle": "groovy",
+      ".clj": "clojure",
+      ".cljs": "clojure",
+      ".cljc": "clojure",
+      ".lisp": "common-lisp",
+      ".lsp": "common-lisp",
+      ".el": "emacs-lisp",
+      ".scm": "scheme",
+      ".ml": "ocaml",
+      ".mli": "ocaml",
+      ".jl": "julia",
+      ".zig": "zig",
+      ".nim": "nim",
+      ".cr": "crystal",
+      ".v": "v",
+      ".vb": "vb",
+      // 数据库
+      ".sql": "sql",
+      ".psql": "sql",
+      ".mysql": "sql",
+      ".prisma": "prisma",
+      // IaC
+      ".nix": "nix",
+      ".tf": "terraform",
+      ".tfvars": "terraform",
+      ".hcl": "hcl",
+      ".cmake": "cmake",
+      ".make": "makefile",
+      ".mk": "makefile",
+      ".makefile": "makefile",
+      // 其它
+      ".diff": "diff",
+      ".patch": "diff",
+      ".svg": "xml",
+      ".http": "http"
+    };
+  }
+});
+
+// backend/dist/files/file-kind.js
+function getFileKind(stat3) {
+  if (stat3.isSymbolicLink())
+    return "symlink";
+  if (stat3.isDirectory())
+    return "dir";
+  if (stat3.isFile())
+    return "file";
+  return "other";
+}
+var init_file_kind = __esm({
+  "backend/dist/files/file-kind.js"() {
+    "use strict";
+  }
+});
+
+// backend/dist/files/list-dir.js
+import { readdir, lstat } from "node:fs/promises";
+import { join } from "node:path";
+async function listDir(dirPath) {
+  const dirents = await readdir(dirPath, { withFileTypes: true });
+  const results = await Promise.all(dirents.map((dirent) => lstat(join(dirPath, dirent.name)).then((stat3) => {
+    const kind = getFileKind(stat3);
+    const entry = {
+      name: dirent.name,
+      kind,
+      size: kind === "dir" ? 0 : stat3.size,
+      mtimeMs: stat3.mtimeMs,
+      hidden: dirent.name.startsWith(".")
+    };
+    if (kind === "file") {
+      const { mime, previewable } = detectMime(dirent.name);
+      entry.mime = mime;
+      entry.previewable = previewable;
+    }
+    return entry;
+  }, () => void 0)));
+  return results.filter((e) => e !== void 0);
+}
+var init_list_dir = __esm({
+  "backend/dist/files/list-dir.js"() {
+    "use strict";
+    init_mime_detect();
+    init_file_kind();
+  }
+});
+
+// backend/dist/files/read-file.js
+import { open, stat } from "node:fs/promises";
+function probeHasAnsi(buf) {
+  for (let i = 0; i < buf.length - 1; i++) {
+    if (buf[i] === 27 && buf[i + 1] === 91)
+      return true;
+  }
+  return false;
+}
+async function readTextFile(absPath) {
+  const st = await stat(absPath);
+  const size = st.size;
+  const fh = await open(absPath, "r");
+  try {
+    const probeLen = Math.min(NUL_PROBE_BYTES, size);
+    let hasAnsi = false;
+    if (probeLen > 0) {
+      const probe = Buffer.alloc(probeLen);
+      await fh.read(probe, 0, probeLen, 0);
+      if (probe.includes(0)) {
+        throw new FileError(ErrorCode.FILE_BINARY, "file contains NUL bytes (binary)", 409);
+      }
+      hasAnsi = probeHasAnsi(probe);
+    }
+    const readLen = Math.min(size, FILE_READ_MAX_BYTES);
+    const buf = Buffer.alloc(readLen);
+    if (readLen > 0) {
+      await fh.read(buf, 0, readLen, 0);
+    }
+    const content = buf.toString("utf-8");
+    const truncated = size > FILE_READ_MAX_BYTES;
+    if (content.length > 0) {
+      let replacements = 0;
+      for (const ch of content) {
+        if (ch === REPLACEMENT_CHAR)
+          replacements++;
+      }
+      const density = replacements / content.length;
+      if (density > REPLACEMENT_DENSITY_LIMIT) {
+        throw new FileError(ErrorCode.FILE_BINARY, `non-UTF8 content (replacement density ${(density * 100).toFixed(1)}%)`, 409);
+      }
+    }
+    return { content, truncated, size, hasAnsi };
+  } finally {
+    await fh.close();
+  }
+}
+var NUL_PROBE_BYTES, REPLACEMENT_CHAR, REPLACEMENT_DENSITY_LIMIT;
+var init_read_file = __esm({
+  "backend/dist/files/read-file.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    NUL_PROBE_BYTES = 4 * 1024;
+    REPLACEMENT_CHAR = "\uFFFD";
+    REPLACEMENT_DENSITY_LIMIT = 0.05;
+  }
+});
+
+// backend/dist/files/search-engine.js
+import { opendir, open as open2, stat as stat2 } from "node:fs/promises";
+import { createInterface } from "node:readline";
+import { join as join2 } from "node:path";
+async function runSearch(opts) {
+  const start = Date.now();
+  let scanned = 0;
+  let nameHits = 0;
+  let contentHits = 0;
+  let truncated = false;
+  const matchers = compileMatchers(opts);
+  const { nameMatch, contentMatch } = matchers;
+  const queue = [];
+  let walkDone = false;
+  let waitResolve = null;
+  let waitPromise = new Promise((r) => {
+    waitResolve = r;
+  });
+  const wakeWorkers = () => {
+    if (waitResolve) {
+      const r = waitResolve;
+      waitResolve = null;
+      r();
+      waitPromise = new Promise((rr) => {
+        waitResolve = rr;
+      });
+    }
+  };
+  const openDirs = /* @__PURE__ */ new Set();
+  const abortAllDirs = () => {
+    for (const d of openDirs) {
+      d.close().catch(() => {
+      });
+    }
+    openDirs.clear();
+  };
+  const onCancel = () => {
+    wakeWorkers();
+    abortAllDirs();
+  };
+  opts.cancelSignal?.addEventListener("abort", onCancel, { once: true });
+  const totalTimeoutHandle = setTimeout(onCancel, SEARCH_TOTAL_TIMEOUT_MS);
+  totalTimeoutHandle.unref();
+  async function walk2(dir, depth) {
+    if (depth > MAX_DEPTH)
+      return;
+    if (scanned >= MAX_ENTRIES_SCANNED) {
+      truncated = true;
+      return;
+    }
+    if (Date.now() - start > SEARCH_TOTAL_TIMEOUT_MS) {
+      truncated = true;
+      return;
+    }
+    if (opts.cancelSignal?.aborted)
+      return;
+    let dirh;
+    try {
+      dirh = await opendir(dir);
+    } catch {
+      return;
+    }
+    openDirs.add(dirh);
+    if (opts.cancelSignal?.aborted) {
+      openDirs.delete(dirh);
+      await dirh.close().catch(() => {
+      });
+      return;
+    }
+    try {
+      for await (const ent of dirh) {
+        scanned++;
+        if (scanned >= MAX_ENTRIES_SCANNED) {
+          truncated = true;
+          break;
+        }
+        if (Date.now() - start > SEARCH_TOTAL_TIMEOUT_MS) {
+          truncated = true;
+          break;
+        }
+        if (opts.cancelSignal?.aborted)
+          break;
+        const full = join2(dir, ent.name);
+        if (ent.isDirectory()) {
+          if (IGNORE_DIRS.has(ent.name))
+            continue;
+          if (checkWorkdir(full, opts.policy.allow, opts.policy.deny) !== null)
+            continue;
+          await walk2(full, depth + 1);
+          continue;
+        }
+        if (!ent.isFile())
+          continue;
+        if (opts.mode !== "content" && nameMatch(ent.name) && nameHits < SEARCH_MAX_NAME_RESULTS) {
+          try {
+            const st = await stat2(full);
+            opts.emit({ kind: "name", path: full, size: st.size, mtimeMs: st.mtimeMs });
+            nameHits++;
+          } catch {
+          }
+        }
+        if (opts.mode !== "name") {
+          queue.push(full);
+          wakeWorkers();
+        }
+      }
+    } catch {
+    } finally {
+      openDirs.delete(dirh);
+      await dirh.close().catch(() => {
+      });
+    }
+  }
+  const workers = [];
+  if (opts.mode !== "name") {
+    for (let i = 0; i < SEARCH_CONCURRENCY; i++) {
+      workers.push((async () => {
+        while (true) {
+          if (contentHits >= SEARCH_MAX_CONTENT_RESULTS) {
+            truncated = true;
+            return;
+          }
+          if (Date.now() - start > SEARCH_TOTAL_TIMEOUT_MS) {
+            truncated = true;
+            return;
+          }
+          if (opts.cancelSignal?.aborted)
+            return;
+          const f = queue.shift();
+          if (!f) {
+            if (walkDone)
+              return;
+            await waitPromise;
+            continue;
+          }
+          await scanFile(f);
+        }
+      })());
+    }
+  }
+  try {
+    await walk2(opts.scope, 0);
+  } finally {
+    walkDone = true;
+    wakeWorkers();
+  }
+  await Promise.all(workers);
+  async function scanFile(path) {
+    const fileStart = Date.now();
+    let st;
+    try {
+      st = await stat2(path);
+    } catch {
+      return;
+    }
+    if (st.size > FILE_MAX_SCAN_BYTES)
+      return;
+    let fh;
+    try {
+      fh = await open2(path, "r");
+    } catch {
+      return;
+    }
+    let isBinary = false;
+    try {
+      const probeLen = Math.min(NUL_PROBE_BYTES2, st.size);
+      if (probeLen > 0) {
+        const buf = Buffer.alloc(probeLen);
+        await fh.read(buf, 0, probeLen, 0);
+        if (buf.includes(0))
+          isBinary = true;
+      }
+    } catch {
+      isBinary = true;
+    }
+    if (isBinary) {
+      await fh.close();
+      return;
+    }
+    await new Promise((resolveP) => {
+      const stream = fh.createReadStream({ encoding: "utf-8", autoClose: true, start: 0 });
+      const rl = createInterface({ input: stream, crlfDelay: Infinity });
+      let lineNo = 0;
+      let stopped = false;
+      const stop = () => {
+        if (stopped)
+          return;
+        stopped = true;
+        rl.close();
+        stream.destroy();
+        resolveP();
+      };
+      rl.on("line", (line) => {
+        lineNo++;
+        if (Date.now() - fileStart > SEARCH_FILE_TIMEOUT_MS) {
+          stop();
+          return;
+        }
+        if (contentHits >= SEARCH_MAX_CONTENT_RESULTS) {
+          truncated = true;
+          stop();
+          return;
+        }
+        if (opts.cancelSignal?.aborted) {
+          stop();
+          return;
+        }
+        const m = contentMatch(line);
+        if (m) {
+          const preview = line.length > PREVIEW_MAX_CHARS ? line.slice(0, PREVIEW_MAX_CHARS) : line;
+          opts.emit({
+            kind: "content",
+            path,
+            line: lineNo,
+            preview,
+            matchStart: Math.min(m.start, preview.length),
+            matchEnd: Math.min(m.end, preview.length)
+          });
+          contentHits++;
+        }
+      });
+      rl.on("close", () => resolveP());
+      rl.on("error", () => stop());
+      stream.on("error", () => stop());
+    });
+  }
+  clearTimeout(totalTimeoutHandle);
+  return {
+    truncated,
+    scanned,
+    elapsedMs: Date.now() - start
+  };
+}
+function compileMatchers(opts) {
+  if (opts.regex) {
+    if (opts.q.includes("\n")) {
+      throw new FileError(ErrorCode.SEARCH_INVALID_Q, "cross-line regex disallowed", 400);
+    }
+    let re;
+    try {
+      re = new RegExp(opts.q, opts.caseSensitive ? "" : "i");
+    } catch (err) {
+      throw new FileError(ErrorCode.SEARCH_INVALID_Q, `invalid regex: ${String(err)}`, 400);
+    }
+    return {
+      nameMatch: (n) => re.test(n),
+      contentMatch: (line) => {
+        const m = re.exec(line);
+        re.lastIndex = 0;
+        return m ? { start: m.index, end: m.index + m[0].length } : null;
+      }
+    };
+  }
+  const needle = opts.caseSensitive ? opts.q : opts.q.toLowerCase();
+  return {
+    nameMatch: (n) => (opts.caseSensitive ? n : n.toLowerCase()).includes(needle),
+    contentMatch: (line) => {
+      const hay = opts.caseSensitive ? line : line.toLowerCase();
+      const idx = hay.indexOf(needle);
+      return idx === -1 ? null : { start: idx, end: idx + needle.length };
+    }
+  };
+}
+var IGNORE_DIRS, MAX_DEPTH, MAX_ENTRIES_SCANNED, NUL_PROBE_BYTES2, PREVIEW_MAX_CHARS, FILE_MAX_SCAN_BYTES;
+var init_search_engine = __esm({
+  "backend/dist/files/search-engine.js"() {
+    "use strict";
+    init_dist();
+    init_errors2();
+    init_workdir_policy();
+    IGNORE_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".svn",
+      ".hg",
+      "dist",
+      "build",
+      ".next",
+      ".turbo",
+      ".cache",
+      "target",
+      ".venv",
+      "__pycache__",
+      ".DS_Store"
+    ]);
+    MAX_DEPTH = 6;
+    MAX_ENTRIES_SCANNED = 5e3;
+    NUL_PROBE_BYTES2 = 4 * 1024;
+    PREVIEW_MAX_CHARS = 200;
+    FILE_MAX_SCAN_BYTES = 2 * 1024 * 1024;
+  }
+});
+
+// backend/dist/files/wikilink-resolver.js
+import { promises as fsp } from "node:fs";
+import { watch as watch2 } from "node:fs";
+import { join as join3, relative, dirname as dirname3, basename as basename3, extname as extname2, sep } from "node:path";
+function makeResult(resolved, fragment) {
+  return fragment ? { resolved, fragment } : { resolved };
+}
+function makeBroken(fragment) {
+  return fragment ? { broken: true, fragment } : { broken: true };
+}
+function splitFragment(target) {
+  const piped = target.split("|")[0];
+  const hashIdx = piped.indexOf("#");
+  if (hashIdx < 0)
+    return { pathPart: piped.trim() };
+  const pathPart = piped.slice(0, hashIdx).trim();
+  const frag = piped.slice(hashIdx + 1).trim();
+  if (frag.startsWith("^")) {
+    return { pathPart, fragment: { kind: "block", id: frag.slice(1) } };
+  }
+  return { pathPart, fragment: { kind: "heading", id: frag } };
+}
+function stripExt(name) {
+  const ext = extname2(name).toLowerCase();
+  if (MD_EXTS.has(ext))
+    return name.slice(0, -ext.length);
+  return name;
+}
+function pickShortestPath(from, candidates) {
+  return candidates.map((c2) => ({ c: c2, common: countCommonDirSegments(from, c2) })).sort((a, b) => {
+    if (b.common !== a.common)
+      return b.common - a.common;
+    return a.c < b.c ? -1 : a.c > b.c ? 1 : 0;
+  })[0].c;
+}
+function countCommonDirSegments(a, b) {
+  const da = a.split("/").slice(0, -1);
+  const db = b.split("/").slice(0, -1);
+  let i = 0;
+  while (i < da.length && i < db.length && da[i] === db[i])
+    i++;
+  return i;
+}
+async function walk(root, cur, onFile) {
+  let ents;
+  try {
+    ents = await fsp.readdir(cur, { withFileTypes: true });
+  } catch (err) {
+    logger.debug({ err, dir: cur }, "WorkspaceIndex.walk: readdir failed (skipped)");
+    return;
+  }
+  const subWalks = [];
+  for (const e of ents) {
+    if (EXCLUDED_DIRS.has(e.name))
+      continue;
+    const full = join3(cur, e.name);
+    if (e.isSymbolicLink()) {
+      try {
+        const real = await fsp.realpath(full);
+        const r = relative(root, real);
+        if (r.startsWith("..") || r === "" || r.startsWith(sep + ".."))
+          continue;
+      } catch {
+        continue;
+      }
+    }
+    if (e.isDirectory() || e.isSymbolicLink() && await isDir(full)) {
+      subWalks.push(walk(root, full, onFile));
+    } else if (e.isFile() || e.isSymbolicLink()) {
+      const rel = relative(root, full).split(sep).join("/");
+      onFile(rel);
+    }
+  }
+  if (subWalks.length > 0)
+    await Promise.all(subWalks);
+}
+async function isDir(p) {
+  try {
+    return (await fsp.stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var MD_EXTS, REBUILD_INTERVAL_MS, STALE_REBUILD_MS, WorkspaceIndex, EXCLUDED_DIRS;
+var init_wikilink_resolver = __esm({
+  "backend/dist/files/wikilink-resolver.js"() {
+    "use strict";
+    init_logger();
+    MD_EXTS = /* @__PURE__ */ new Set([".md", ".markdown"]);
+    REBUILD_INTERVAL_MS = 5 * 60 * 1e3;
+    STALE_REBUILD_MS = 30 * 1e3;
+    WorkspaceIndex = class {
+      cwd;
+      /** lowercased basename(去扩展名) → 相对 cwd 路径数组(已 sorted) */
+      byBasename = /* @__PURE__ */ new Map();
+      built = false;
+      buildPromise = null;
+      watcher = null;
+      rebuildTimer = null;
+      rebuildScheduled = false;
+      /** 上次 buildOnce() 完成时间;用于 staleness 检查决定是否要重 build */
+      lastBuiltAt = 0;
+      constructor(cwd) {
+        this.cwd = cwd;
+      }
+      /**
+       * 触发索引就绪。
+       *
+       * 关键设计:**不阻塞用户请求等 rebuild**。
+       *  - 首次:必须 await(没数据可用)
+       *  - 已 built 但 stale:**fire-and-forget 后台 rebuild**,立即用旧索引响应。
+       *    用户拿到老数据 + 几百毫秒内 background 完成 → 下次请求自动新数据。
+       *
+       * Why:WSL DrvFs walk 5+ 秒,prod WSL 加用户大 vault 可能 10+ 秒,
+       * 不能让用户每 30s 卡一次 wikilink 解析。Obsidian 自身也是后台维护索引,
+       * 用户从不感知 vault rescan。
+       */
+      async ensureBuilt() {
+        if (this.built) {
+          const stale = Date.now() - this.lastBuiltAt > STALE_REBUILD_MS;
+          if (stale && !this.buildPromise) {
+            this.buildPromise = this.buildOnce().then(() => {
+              this.lastBuiltAt = Date.now();
+            }).catch((err) => {
+              logger.warn({ err }, "WorkspaceIndex background rebuild failed");
+            }).finally(() => {
+              this.buildPromise = null;
+            });
+          }
+          return;
+        }
+        if (this.buildPromise) {
+          await this.buildPromise;
+          return;
+        }
+        this.buildPromise = this.buildOnce();
+        try {
+          await this.buildPromise;
+          this.built = true;
+          this.lastBuiltAt = Date.now();
+          this.startWatch();
+        } finally {
+          this.buildPromise = null;
+        }
+      }
+      /**
+       * 后台预热:在用户主动 resolve 之前异步触发首次 build。
+       * 调用方 fire-and-forget。已 built 或正在 build 时 no-op。
+       *
+       * 推荐挂在 /files/list 第一次被调时(用户刚打开文件浏览器,索引提前热好)。
+       */
+      prefetch() {
+        if (this.built || this.buildPromise)
+          return;
+        void this.ensureBuilt().catch((err) => logger.debug({ err }, "WorkspaceIndex prefetch failed (silent)"));
+      }
+      resolve(from, target) {
+        const { pathPart, fragment } = splitFragment(target);
+        if (pathPart.length === 0) {
+          return fragment ? { broken: true, fragment } : { broken: true };
+        }
+        const fromRel = this.normalizeFrom(from);
+        if (pathPart.includes("/")) {
+          const fromVault = this.findByRelPath(pathPart);
+          if (fromVault)
+            return makeResult(fromVault, fragment);
+          const fromCurrent = this.findByRelPath(join3(dirname3(fromRel), pathPart));
+          if (fromCurrent)
+            return makeResult(fromCurrent, fragment);
+          return makeBroken(fragment);
+        }
+        const key = stripExt(pathPart).toLowerCase();
+        const candidates = this.byBasename.get(key);
+        if (!candidates || candidates.length === 0)
+          return makeBroken(fragment);
+        if (candidates.length === 1)
+          return makeResult(candidates[0], fragment);
+        const best = pickShortestPath(fromRel, candidates);
+        return {
+          resolved: best,
+          candidates: [...candidates],
+          ...fragment ? { fragment } : {}
+        };
+      }
+      /**
+       * 把 from 归一为相对 cwd 路径(POSIX `/` 分隔)。
+       *
+       * - 绝对路径(以 cwd 为前缀)→ 剥前缀
+       * - 已是相对路径 → 原样(再做一次 split/join 防 Windows 反斜杠)
+       * - 越过 cwd 的(`..`)→ 不在 vault 内,返回原 from(让 findByRelPath 自然 miss)
+       */
+      normalizeFrom(from) {
+        const normalized = from.split(sep).join("/");
+        const rootPosix = this.cwd.split(sep).join("/");
+        if (normalized.startsWith(rootPosix + "/")) {
+          return normalized.slice(rootPosix.length + 1);
+        }
+        if (normalized === rootPosix)
+          return "";
+        return normalized;
+      }
+      shutdown() {
+        this.watcher?.close();
+        this.watcher = null;
+        if (this.rebuildTimer)
+          clearInterval(this.rebuildTimer);
+        this.rebuildTimer = null;
+      }
+      /** 同步触发一次 rebuild(单测 + scheduleRebuild 复用) */
+      async rebuild() {
+        await this.buildOnce();
+        this.lastBuiltAt = Date.now();
+      }
+      // ─── internals ──────────────────────────────────────────────
+      async buildOnce() {
+        const fresh = /* @__PURE__ */ new Map();
+        await walk(this.cwd, this.cwd, (rel) => {
+          const ext = extname2(rel).toLowerCase();
+          if (!MD_EXTS.has(ext))
+            return;
+          const key = stripExt(basename3(rel)).toLowerCase();
+          const arr = fresh.get(key) ?? [];
+          arr.push(rel);
+          fresh.set(key, arr);
+        });
+        for (const arr of fresh.values())
+          arr.sort();
+        this.byBasename = fresh;
+      }
+      startWatch() {
+        try {
+          this.watcher = watch2(this.cwd, { recursive: true }, () => {
+            this.scheduleRebuild();
+          });
+        } catch (e) {
+          logger.warn({ err: e, cwd: this.cwd }, "WorkspaceIndex: fs.watch failed, falling back to 5min poll");
+        }
+        this.rebuildTimer = setInterval(() => {
+          this.scheduleRebuild();
+        }, REBUILD_INTERVAL_MS);
+        this.rebuildTimer.unref?.();
+      }
+      scheduleRebuild() {
+        if (this.rebuildScheduled)
+          return;
+        this.rebuildScheduled = true;
+        setTimeout(() => {
+          this.rebuildScheduled = false;
+          void this.buildOnce().catch((err) => logger.warn({ err }, "WorkspaceIndex rebuild failed"));
+        }, 500);
+      }
+      findByRelPath(rel) {
+        const norm = rel.split(sep).join("/");
+        for (const ext of ["", ".md", ".markdown"]) {
+          const candidate = norm + ext;
+          const key = stripExt(basename3(candidate)).toLowerCase();
+          const arr = this.byBasename.get(key);
+          if (arr?.includes(candidate))
+            return candidate;
+        }
+        return null;
+      }
+    };
+    EXCLUDED_DIRS = /* @__PURE__ */ new Set([".git", ".obsidian", ".trash", "node_modules"]);
+  }
+});
+
+// backend/dist/api/file-routes.js
+import { Router as Router9 } from "express";
+import { createReadStream } from "node:fs";
+import { lstat as lstat2 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+function createFileRoutes(opts) {
+  const router = Router9();
+  const { authModule, registry, workdirPolicy } = opts;
+  const fileLimiter = new RateLimiter(FILE_RATE_LIMIT_PER_MIN);
+  const searchLimiter = new RateLimiter(SEARCH_RATE_LIMIT_PER_MIN);
+  const wikilinkIndexes = /* @__PURE__ */ new Map();
+  function getWikilinkIndex(instanceId, cwd) {
+    let idx = wikilinkIndexes.get(instanceId);
+    if (!idx) {
+      idx = new WorkspaceIndex(cwd);
+      wikilinkIndexes.set(instanceId, idx);
+    }
+    return idx;
+  }
+  router.get("/files/list", authModule.requireAuth, requireRate(fileLimiter), wrap(async (req, res) => {
+    const tStart = Date.now();
+    const ctx = await resolveContext(req, registry, workdirPolicy);
+    const target = resolveSafePath(ctx.cwd, asString(req.query.path), ctx.policy);
+    const entries = await listDir(target);
+    const parent = computeParent(ctx.cwd, target, ctx.policy);
+    const payload = {
+      ok: true,
+      cwd: ctx.cwd,
+      path: target,
+      parent,
+      entries
+    };
+    logger.info({
+      action: "list",
+      instanceId: ctx.instanceId,
+      path: target,
+      ip: req.ip,
+      elapsedMs: Date.now() - tStart
+    }, "/api/files audit");
+    res.json(payload);
+    getWikilinkIndex(ctx.instanceId, ctx.cwd).prefetch();
+  }));
+  router.get("/files/stat", authModule.requireAuth, requireRate(fileLimiter), wrap(async (req, res) => {
+    const tStart = Date.now();
+    const ctx = await resolveContext(req, registry, workdirPolicy);
+    const target = resolveSafePath(ctx.cwd, asString(req.query.path), ctx.policy);
+    const st = await lstat2(target);
+    const kind = getFileKind(st);
+    const payload = {
+      ok: true,
+      path: target,
+      kind,
+      size: kind === "dir" ? 0 : st.size,
+      mtimeMs: st.mtimeMs
+    };
+    if (kind === "file") {
+      const m = detectMime(target);
+      payload.mime = m.mime;
+      payload.previewable = m.previewable;
+    }
+    logger.info({
+      action: "stat",
+      instanceId: ctx.instanceId,
+      path: target,
+      ip: req.ip,
+      elapsedMs: Date.now() - tStart
+    }, "/api/files audit");
+    res.json(payload);
+  }));
+  router.get("/files/read", authModule.requireAuth, requireRate(fileLimiter), wrap(async (req, res) => {
+    const tStart = Date.now();
+    const ctx = await resolveContext(req, registry, workdirPolicy);
+    const target = resolveSafePath(ctx.cwd, asString(req.query.path), ctx.policy);
+    const st = await lstat2(target);
+    if (!st.isFile()) {
+      throw new FileError(ErrorCode.FILE_TYPE_FORBID, "not a regular file", 409);
+    }
+    const r = await readTextFile(target);
+    const m = detectMime(target);
+    const payload = {
+      ok: true,
+      path: target,
+      mime: m.mime,
+      content: r.content,
+      truncated: r.truncated,
+      size: r.size,
+      lang: pickLang(m.lang, r.hasAnsi)
+    };
+    logger.info({
+      action: "read",
+      instanceId: ctx.instanceId,
+      path: target,
+      ip: req.ip,
+      elapsedMs: Date.now() - tStart,
+      size: r.size,
+      truncated: r.truncated
+    }, "/api/files audit");
+    res.json(payload);
+  }));
+  router.get("/files/raw", authModule.requireAuth, requireRate(fileLimiter), async (req, res) => {
+    const tStart = Date.now();
+    let auditCtx;
+    let auditPath;
+    try {
+      auditCtx = await resolveContext(req, registry, workdirPolicy);
+      auditPath = resolveSafePath(auditCtx.cwd, asString(req.query.path), auditCtx.policy);
+      const st = await lstat2(auditPath);
+      if (!st.isFile())
+        throw new FileError(ErrorCode.FILE_TYPE_FORBID, "", 409);
+      if (st.size > FILE_RAW_MAX_BYTES) {
+        throw new FileError(ErrorCode.FILE_TOO_LARGE, "", 413);
+      }
+      const { mime } = detectMime(auditPath);
+      res.setHeader("Content-Type", mime);
+      res.setHeader("Cache-Control", "private, max-age=0");
+      res.setHeader("Content-Length", String(st.size));
+      logger.info({
+        action: "raw",
+        instanceId: auditCtx.instanceId,
+        path: auditPath,
+        ip: req.ip,
+        elapsedMs: Date.now() - tStart,
+        size: st.size
+      }, "/api/files audit");
+      createReadStream(auditPath).pipe(res);
+    } catch (err) {
+      const code = err instanceof AppError ? err.code : ErrorCode.INTERNAL_ERROR;
+      const status = err instanceof AppError ? err.httpStatus : 500;
+      res.setHeader(HEADER_ATR_ERROR, String(code));
+      logger.info({
+        action: "raw",
+        instanceId: auditCtx?.instanceId,
+        path: auditPath,
+        ip: req.ip,
+        elapsedMs: Date.now() - tStart,
+        code,
+        status
+      }, "/api/files audit (error)");
+      res.status(status).end();
+    }
+  });
+  router.get("/files/search", authModule.requireAuth, requireRate(searchLimiter), async (req, res) => {
+    const tStart = Date.now();
+    const q = asString(req.query.q);
+    if (!q || q.length === 0 || q.length > SEARCH_MAX_Q_LENGTH) {
+      res.status(400).json({
+        error: { code: ErrorCode.BAD_REQUEST, message: "q is required (1..200)" }
+      });
+      return;
+    }
+    const modeRaw = asString(req.query.mode) ?? "name";
+    if (!isSearchMode(modeRaw)) {
+      res.status(400).json({
+        error: { code: ErrorCode.BAD_REQUEST, message: "invalid mode" }
+      });
+      return;
+    }
+    let ctx;
+    try {
+      ctx = await resolveContext(req, registry, workdirPolicy);
+    } catch (err) {
+      if (err instanceof AppError) {
+        res.status(err.httpStatus).json({ error: { code: err.code, message: err.message } });
+      } else {
+        res.status(500).end();
+      }
+      return;
+    }
+    let scopePath;
+    try {
+      scopePath = resolveSafePath(ctx.cwd, asString(req.query.scope), ctx.policy);
+      const st = await lstat2(scopePath);
+      if (!st.isDirectory()) {
+        throw new FileError(ErrorCode.BAD_REQUEST, "scope must be a directory", 400);
+      }
+    } catch (err) {
+      if (err instanceof AppError) {
+        res.status(err.httpStatus).json({ error: { code: err.code, message: err.message } });
+      } else {
+        res.status(500).end();
+      }
+      return;
+    }
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const ac = new AbortController();
+    req.on("close", () => ac.abort());
+    try {
+      const summary = await runSearch({
+        scope: scopePath,
+        q,
+        mode: modeRaw,
+        caseSensitive: asString(req.query.caseSensitive) === "1",
+        regex: asString(req.query.regex) === "1",
+        policy: ctx.policy,
+        cancelSignal: ac.signal,
+        emit: (hit) => {
+          res.write(`event: match
+data: ${JSON.stringify(hit)}
+
+`);
+        }
+      });
+      res.write(`event: done
+data: ${JSON.stringify(summary)}
+
+`);
+      logger.info({
+        action: "search",
+        instanceId: ctx.instanceId,
+        path: scopePath,
+        ip: req.ip,
+        elapsedMs: Date.now() - tStart,
+        scanned: summary.scanned,
+        truncated: summary.truncated
+      }, "/api/files audit");
+    } catch (err) {
+      const code = err instanceof AppError ? err.code : ErrorCode.INTERNAL_ERROR;
+      const message = err instanceof Error ? err.message : String(err);
+      res.write(`event: error
+data: ${JSON.stringify({ code, message })}
+
+`);
+      logger.warn({
+        action: "search",
+        instanceId: ctx.instanceId,
+        path: scopePath,
+        ip: req.ip,
+        elapsedMs: Date.now() - tStart,
+        code
+      }, "/api/files audit (error)");
+    } finally {
+      res.end();
+    }
+  });
+  router.post("/files/resolve-links", authModule.requireAuth, requireRate(fileLimiter), wrap(async (req, res) => {
+    const tStart = Date.now();
+    const body = req.body;
+    if (typeof body.instanceId !== "string" || body.instanceId.length === 0 || typeof body.from !== "string" || !Array.isArray(body.targets)) {
+      throw new AppError(ErrorCode.BAD_REQUEST, "body must be { instanceId: string, from: string, targets: string[] }");
+    }
+    if (body.targets.length > 200) {
+      throw new AppError(ErrorCode.BAD_REQUEST, "too many targets (max 200)");
+    }
+    for (const t of body.targets) {
+      if (typeof t !== "string") {
+        throw new AppError(ErrorCode.BAD_REQUEST, "target must be string");
+      }
+    }
+    const targets = body.targets;
+    const reqWithQuery = Object.assign(Object.create(Object.getPrototypeOf(req)), req, {
+      query: { ...req.query, instanceId: body.instanceId }
+    });
+    const ctx = await resolveContext(reqWithQuery, registry, workdirPolicy);
+    resolveSafePath(ctx.cwd, body.from, ctx.policy);
+    const idx = getWikilinkIndex(ctx.instanceId, ctx.cwd);
+    await idx.ensureBuilt();
+    const results = targets.map((target) => ({
+      target,
+      ...idx.resolve(body.from, target)
+    }));
+    res.json({ ok: true, results });
+    logger.info({
+      action: "resolve-links",
+      instanceId: ctx.instanceId,
+      from: body.from,
+      targetsCount: targets.length,
+      ip: req.ip,
+      elapsedMs: Date.now() - tStart
+    }, "/api/files audit");
+  }));
+  return router;
+}
+function wrap(h) {
+  return async (req, res, _next) => {
+    try {
+      await h(req, res);
+    } catch (err) {
+      if (err instanceof AppError) {
+        res.status(err.httpStatus).json({
+          error: { code: err.code, message: err.message }
+        });
+        return;
+      }
+      logger.error({ err }, "/api/files unexpected error");
+      res.status(500).json({
+        error: { code: ErrorCode.INTERNAL_ERROR, message: "internal error" }
+      });
+    }
+  };
+}
+function asString(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function requireRate(limiter) {
+  return (req, res, next) => {
+    const ip = req.ip ?? "unknown";
+    if (!limiter.attempt(ip)) {
+      res.status(429).json({
+        error: { code: ErrorCode.AUTH_RATE_LIMITED, message: "rate limited" }
+      });
+      return;
     }
+    next();
+  };
+}
+async function resolveContext(req, registry, workdirPolicy) {
+  const instanceId = req.query.instanceId;
+  if (typeof instanceId !== "string" || instanceId.length === 0) {
+    throw new FileError(ErrorCode.BAD_REQUEST, "instanceId is required", 400);
   }
-  if (!out.some((e) => e.kind === "loopback")) {
-    out.push({ host: "127.0.0.1", port, kind: "loopback" });
+  const all = await registry.list();
+  const inst = all.find((i) => i.instanceId === instanceId);
+  if (!inst) {
+    throw new FileError(ErrorCode.INSTANCE_NOT_FOUND, `instance not found: ${instanceId}`, 404);
   }
-  const order = {
-    lan: 0,
-    tailscale: 1,
-    other: 2,
-    ipv6: 3,
-    loopback: 4
+  const snap = workdirPolicy();
+  return {
+    cwd: inst.cwd,
+    policy: { allow: snap.allow, deny: snap.deny },
+    instanceId
   };
-  out.sort((a, b) => {
-    if (a.kind !== b.kind)
-      return order[a.kind] - order[b.kind];
-    if (a.host === displayIp)
-      return -1;
-    if (b.host === displayIp)
-      return 1;
-    return 0;
-  });
-  let defaultIdx = out.findIndex((e) => e.host === displayIp);
-  if (defaultIdx === -1) {
-    defaultIdx = out.findIndex((e) => e.kind !== "loopback");
-  }
-  if (defaultIdx === -1 && out.length > 0)
-    defaultIdx = 0;
-  if (defaultIdx >= 0)
-    out[defaultIdx].isDefault = true;
-  return out;
 }
-function classify(ip, family) {
-  if (isLoopbackIp(ip))
-    return "loopback";
-  if (family === "IPv6")
-    return "ipv6";
-  if (isTailscaleIp(ip))
-    return "tailscale";
-  if (isPrivateIp(ip))
-    return "lan";
-  if (isLinkLocal(ip))
-    return "other";
-  return "other";
+function pickLang(baseLang, hasAnsi) {
+  if (hasAnsi && (baseLang === "txt" || baseLang === "log")) {
+    return "ansi";
+  }
+  return baseLang;
 }
-var init_share_routes = __esm({
-  "backend/dist/api/share-routes.js"() {
-    "use strict";
-    init_network();
+function computeParent(cwd, current, policy) {
+  if (current === cwd)
+    return null;
+  const parentPath = dirname4(current);
+  if (parentPath === current)
+    return null;
+  try {
+    resolveSafePath(cwd, parentPath, policy);
+    return parentPath;
+  } catch {
+    return null;
   }
-});
-
-// backend/dist/api/workdir-policy-routes.js
-import { Router as Router8 } from "express";
-function createWorkdirPolicyRoutes(authModule, snapshot) {
-  const router = Router8();
-  router.get("/workdir-policy", authModule.requireAuth, (_req, res) => {
-    const s = snapshot();
-    res.json({ ok: true, allow: s.allow });
-  });
-  return router;
 }
-var init_workdir_policy_routes = __esm({
-  "backend/dist/api/workdir-policy-routes.js"() {
+var init_file_routes = __esm({
+  "backend/dist/api/file-routes.js"() {
     "use strict";
+    init_dist();
+    init_errors2();
+    init_logger();
+    init_rate_limiter();
+    init_forwarded_headers();
+    init_constants2();
+    init_path_resolver();
+    init_list_dir();
+    init_mime_detect();
+    init_read_file();
+    init_search_engine();
+    init_file_kind();
+    init_wikilink_resolver();
   }
 });
 
 // backend/dist/api/router.js
-import { Router as Router9 } from "express";
+import { Router as Router10 } from "express";
 function createBrokerApiRouter(opts) {
-  const router = Router9();
+  const router = Router10();
   router.use(createHealthRoutes());
   router.use(createAuthRoutes(opts.authModule));
   router.use(createConfigRoutes(opts.authModule, opts.configStore));
@@ -1644,10 +3440,15 @@ function createBrokerApiRouter(opts) {
     displayIp: opts.displayIp
   }));
   router.use(createWorkdirPolicyRoutes(opts.authModule, opts.workdirPolicy));
+  router.use(createFileRoutes({
+    authModule: opts.authModule,
+    registry: opts.registry,
+    workdirPolicy: opts.workdirPolicy
+  }));
   return router;
 }
 function createWorkerApiRouter(opts) {
-  const router = Router9();
+  const router = Router10();
   router.use(createHealthRoutes());
   router.use(createHookRoutes(opts.integrations));
   return router;
@@ -1663,31 +3464,7 @@ var init_router = __esm({
     init_push_routes();
     init_share_routes();
     init_workdir_policy_routes();
-  }
-});
-
-// backend/dist/constants.js
-var WS_FLUSH_INTERVAL_MS, WS_MAX_CHUNK_BYTES, WS_HIGH_WATERMARK_BYTES, FILE_LOCK_RETRIES, FILE_LOCK_RETRY_INTERVAL_MS, FILE_LOCK_STALE_MS, PTY_DEFAULT_COLS, PTY_DEFAULT_ROWS, PTY_TERM_NAME, DOUBLE_PULSE_DELAY_MS, SHUTDOWN_WS_FLUSH_DELAY_MS, SHUTDOWN_FORCE_EXIT_MS, DOUBLE_CTRL_C_WINDOW_MS, PORT_FINDER_MAX_ATTEMPTS, STOP_INSTANCE_GRACE_MS, STOP_INSTANCE_POLL_INTERVAL_MS, ATTACH_RECONNECT_DELAYS_MS;
-var init_constants2 = __esm({
-  "backend/dist/constants.js"() {
-    "use strict";
-    WS_FLUSH_INTERVAL_MS = 16;
-    WS_MAX_CHUNK_BYTES = 32 * 1024;
-    WS_HIGH_WATERMARK_BYTES = 256 * 1024;
-    FILE_LOCK_RETRIES = 50;
-    FILE_LOCK_RETRY_INTERVAL_MS = 50;
-    FILE_LOCK_STALE_MS = 1e4;
-    PTY_DEFAULT_COLS = 80;
-    PTY_DEFAULT_ROWS = 24;
-    PTY_TERM_NAME = "xterm-256color";
-    DOUBLE_PULSE_DELAY_MS = 50;
-    SHUTDOWN_WS_FLUSH_DELAY_MS = 500;
-    SHUTDOWN_FORCE_EXIT_MS = 2e3;
-    DOUBLE_CTRL_C_WINDOW_MS = 500;
-    PORT_FINDER_MAX_ATTEMPTS = 100;
-    STOP_INSTANCE_GRACE_MS = 3e3;
-    STOP_INSTANCE_POLL_INTERVAL_MS = 100;
-    ATTACH_RECONNECT_DELAYS_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+    init_file_routes();
   }
 });
 
@@ -2931,87 +4708,6 @@ var init_terminal_relay = __esm({
   }
 });
 
-// backend/dist/auth/rate-limiter.js
-var RateLimiter;
-var init_rate_limiter = __esm({
-  "backend/dist/auth/rate-limiter.js"() {
-    "use strict";
-    init_logger();
-    RateLimiter = class {
-      entries = /* @__PURE__ */ new Map();
-      maxAttempts;
-      windowMs;
-      cleanupTimer = null;
-      /**
-       * @param maxAttempts 窗口内最大允许次数
-       * @param windowMs   窗口长度（毫秒），默认 60s
-       */
-      constructor(maxAttempts, windowMs = 6e4) {
-        if (!Number.isInteger(maxAttempts) || maxAttempts <= 0) {
-          throw new Error("RateLimiter: maxAttempts \u5FC5\u987B\u662F\u6B63\u6574\u6570");
-        }
-        this.maxAttempts = maxAttempts;
-        this.windowMs = windowMs;
-        this.cleanupTimer = setInterval(() => this.cleanup(), windowMs * 2);
-        if (typeof this.cleanupTimer.unref === "function") {
-          this.cleanupTimer.unref();
-        }
-      }
-      /**
-       * 尝试一次请求，自动累加计数
-       *
-       * @returns true 通过 / false 已超限被拒
-       */
-      attempt(ip) {
-        const now = Date.now();
-        const entry = this.entries.get(ip);
-        if (!entry || now >= entry.resetAt) {
-          this.entries.set(ip, { count: 1, resetAt: now + this.windowMs });
-          return true;
-        }
-        entry.count++;
-        if (entry.count > this.maxAttempts) {
-          logger.warn({ ip, count: entry.count, max: this.maxAttempts }, "\u8BA4\u8BC1\u901F\u7387\u8D85\u9650");
-          return false;
-        }
-        return true;
-      }
-      /** 当前窗口内剩余次数 */
-      remaining(ip) {
-        const now = Date.now();
-        const entry = this.entries.get(ip);
-        if (!entry || now >= entry.resetAt)
-          return this.maxAttempts;
-        return Math.max(0, this.maxAttempts - entry.count);
-      }
-      /**
-       * 重置某 IP 的计数（认证成功后清零）
-       *
-       * 让合法用户不会因为之前误输导致后续尝试被限流
-       */
-      reset(ip) {
-        this.entries.delete(ip);
-      }
-      /** 清理过期 entry（避免内存膨胀） */
-      cleanup() {
-        const now = Date.now();
-        for (const [ip, entry] of this.entries) {
-          if (now >= entry.resetAt) {
-            this.entries.delete(ip);
-          }
-        }
-      }
-      /** 销毁定时器 */
-      destroy() {
-        if (this.cleanupTimer) {
-          clearInterval(this.cleanupTimer);
-          this.cleanupTimer = null;
-        }
-      }
-    };
-  }
-});
-
 // backend/dist/auth/auth-middleware.js
 import { timingSafeEqual } from "node:crypto";
 import * as cookie from "cookie";
@@ -3282,7 +4978,7 @@ var init_token_generator = __esm({
 
 // backend/dist/sessions/sessions-store.js
 import { existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
-import { dirname as dirname3, resolve as resolve3 } from "node:path";
+import { dirname as dirname5, resolve as resolve3 } from "node:path";
 import { homedir } from "node:os";
 function defaultSessionsPath() {
   return resolve3(homedir(), ATR_DATA_DIR, SESSIONS_FILENAME);
@@ -3340,7 +5036,7 @@ var init_sessions_store = __esm({
       sessionTtlMs;
       constructor(opts) {
         this.path = opts.path ?? defaultSessionsPath();
-        this.lockDir = opts.lockDir ?? resolve3(dirname3(this.path), SESSIONS_LOCK_DIRNAME);
+        this.lockDir = opts.lockDir ?? resolve3(dirname5(this.path), SESSIONS_LOCK_DIRNAME);
         this.sessionTtlMs = opts.sessionTtlMs;
       }
       // ──────────────── 公共 API ────────────────
@@ -3464,7 +5160,7 @@ var init_sessions_store = __esm({
       }
       /** 原子写 + 确保父目录存在 */
       persist(data) {
-        const dir = dirname3(this.path);
+        const dir = dirname5(this.path);
         if (!existsSync2(dir)) {
           try {
             mkdirSync3(dir, { recursive: true, mode: 448 });
@@ -3523,7 +5219,7 @@ var init_ws_authenticate = __esm({
 
 // backend/dist/config.js
 import { existsSync as existsSync3, readFileSync as readFileSync3, mkdirSync as mkdirSync4, copyFileSync } from "node:fs";
-import { resolve as resolve4, basename as basename2 } from "node:path";
+import { resolve as resolve4, basename as basename4 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { statSync as statSync2 } from "node:fs";
 function extractSettingsFromArgs(args) {
@@ -3656,7 +5352,7 @@ function loadConfig(deps) {
   const claudeCwd = cli.workdir ?? env["OCR_CWD"] ?? process.cwd();
   const explicitArgs = mergeClaudeArgs(cli.claudeArgs, env["OCR_ARGS"]);
   const claudeArgs = explicitArgs.length > 0 || explicitCommand !== void 0 ? explicitArgs : defaultShellArgs(claudeCommand);
-  const instanceName = cli.instanceName ?? env["INSTANCE_NAME"] ?? (basename2(claudeCwd) || "instance");
+  const instanceName = cli.instanceName ?? env["INSTANCE_NAME"] ?? (basename4(claudeCwd) || "instance");
   const maxBufferLines = cli.maxBufferLines ?? toInt(env["MAX_BUFFER_LINES"]) ?? DEFAULT_MAX_BUFFER_LINES;
   const sessionTtlMs = cli.sessionTtlMs ?? toInt(env["SESSION_TTL_MS"]) ?? DEFAULT_SESSION_TTL_MS;
   const authRateLimit = cli.authRateLimit ?? toInt(env["AUTH_RATE_LIMIT"]) ?? DEFAULT_AUTH_RATE_LIMIT;
@@ -3889,9 +5585,9 @@ var init_manager = __esm({
 });
 
 // backend/dist/integrations/claude-code/detect.js
-import { basename as basename3 } from "node:path";
+import { basename as basename5 } from "node:path";
 function isClaudeCommand(command) {
-  let name = basename3(command).toLowerCase();
+  let name = basename5(command).toLowerCase();
   for (const suffix of WIN_SUFFIXES) {
     if (name.endsWith(suffix)) {
       name = name.slice(0, -suffix.length);
@@ -4050,7 +5746,7 @@ function extractToolFromMessage(message) {
   const m = TOOL_NAME_RE.exec(message);
   return m?.[1] ?? null;
 }
-function asString(v) {
+function asString2(v) {
   return typeof v === "string" && v.length > 0 ? v : void 0;
 }
 function asBool(v) {
@@ -4060,35 +5756,35 @@ function asNumber(v) {
   return typeof v === "number" && Number.isFinite(v) ? v : void 0;
 }
 function deriveApprovalId(payload) {
-  const toolUseId = asString(payload["tool_use_id"]);
+  const toolUseId = asString2(payload["tool_use_id"]);
   if (toolUseId)
     return toolUseId;
-  const tool = asString(payload["tool_name"]) ?? extractToolFromMessage(payload["message"]) ?? "unknown";
+  const tool = asString2(payload["tool_name"]) ?? extractToolFromMessage(payload["message"]) ?? "unknown";
   return `pending:${tool}`;
 }
 function mapHookPayload(payload) {
   if (!payload || typeof payload !== "object")
     return [];
   const p = payload;
-  const event = asString(p["hook_event_name"]);
+  const event = asString2(p["hook_event_name"]);
   if (!event)
     return [];
   switch (event) {
     case "Notification": {
       if (p["notification_type"] !== "permission_prompt")
         return [];
-      const tool = asString(p["tool_name"]) ?? extractToolFromMessage(p["message"]) ?? "unknown_tool";
+      const tool = asString2(p["tool_name"]) ?? extractToolFromMessage(p["message"]) ?? "unknown_tool";
       return [
         {
           kind: "approval_pending",
           id: deriveApprovalId(p),
           tool,
-          ...asString(p["message"]) ? { detail: asString(p["message"]) } : {}
+          ...asString2(p["message"]) ? { detail: asString2(p["message"]) } : {}
         }
       ];
     }
     case "PermissionRequest": {
-      const tool = asString(p["tool_name"]) ?? "unknown_tool";
+      const tool = asString2(p["tool_name"]) ?? "unknown_tool";
       const summary = summarizeToolCall(tool, p["tool_input"]);
       return [
         {
@@ -4100,18 +5796,18 @@ function mapHookPayload(payload) {
       ];
     }
     case "PreToolUse": {
-      const tool = asString(p["tool_name"]) ?? "unknown_tool";
+      const tool = asString2(p["tool_name"]) ?? "unknown_tool";
       return [
         {
           kind: "tool_started",
-          toolUseId: asString(p["tool_use_id"]) ?? deriveApprovalId(p),
+          toolUseId: asString2(p["tool_use_id"]) ?? deriveApprovalId(p),
           tool,
           summary: summarizeToolCall(tool, p["tool_input"])
         }
       ];
     }
     case "PostToolUse": {
-      const id = asString(p["tool_use_id"]) ?? deriveApprovalId(p);
+      const id = asString2(p["tool_use_id"]) ?? deriveApprovalId(p);
       const events = [
         { kind: "tool_finished", toolUseId: id, ok: true, ...asNumber(p["duration_ms"]) !== void 0 ? { durationMs: asNumber(p["duration_ms"]) } : {} },
         { kind: "approval_resolved", id, outcome: "allow" }
@@ -4119,7 +5815,7 @@ function mapHookPayload(payload) {
       return events;
     }
     case "PostToolUseFailure": {
-      const id = asString(p["tool_use_id"]) ?? deriveApprovalId(p);
+      const id = asString2(p["tool_use_id"]) ?? deriveApprovalId(p);
       const interrupted = asBool(p["is_interrupt"]) === true;
       const events = [
         {
@@ -4127,14 +5823,14 @@ function mapHookPayload(payload) {
           toolUseId: id,
           ok: false,
           ...asNumber(p["duration_ms"]) !== void 0 ? { durationMs: asNumber(p["duration_ms"]) } : {},
-          ...asString(p["error"]) ? { error: asString(p["error"]) } : {}
+          ...asString2(p["error"]) ? { error: asString2(p["error"]) } : {}
         },
         { kind: "approval_resolved", id, outcome: interrupted ? "deny" : "unknown" }
       ];
       return events;
     }
     case "UserPromptSubmit": {
-      const text = asString(p["prompt"]);
+      const text = asString2(p["prompt"]);
       if (!text)
         return [];
       return [{ kind: "user_prompt", text }];
@@ -4143,7 +5839,7 @@ function mapHookPayload(payload) {
       return [
         {
           kind: "turn_ended",
-          ...asString(p["last_assistant_message"]) ? { lastMessage: asString(p["last_assistant_message"]) } : {}
+          ...asString2(p["last_assistant_message"]) ? { lastMessage: asString2(p["last_assistant_message"]) } : {}
         }
       ];
     }
@@ -4151,8 +5847,8 @@ function mapHookPayload(payload) {
       return [
         {
           kind: "turn_failed",
-          errorKind: asString(p["error"]) ?? "unknown",
-          ...asString(p["error_details"]) ? { detail: asString(p["error_details"]) } : {}
+          errorKind: asString2(p["error"]) ?? "unknown",
+          ...asString2(p["error_details"]) ? { detail: asString2(p["error_details"]) } : {}
         }
       ];
     }
@@ -4161,7 +5857,7 @@ function mapHookPayload(payload) {
         {
           kind: "session_event",
           phase: "start",
-          ...asString(p["source"]) ? { detail: asString(p["source"]) } : {}
+          ...asString2(p["source"]) ? { detail: asString2(p["source"]) } : {}
         }
       ];
     }
@@ -4170,7 +5866,7 @@ function mapHookPayload(payload) {
         {
           kind: "session_event",
           phase: "end",
-          ...asString(p["reason"]) ? { detail: asString(p["reason"]) } : {}
+          ...asString2(p["reason"]) ? { detail: asString2(p["reason"]) } : {}
         }
       ];
     }
@@ -4179,7 +5875,7 @@ function mapHookPayload(payload) {
         {
           kind: "session_event",
           phase: "compact_start",
-          ...asString(p["trigger"]) ? { detail: asString(p["trigger"]) } : {}
+          ...asString2(p["trigger"]) ? { detail: asString2(p["trigger"]) } : {}
         }
       ];
     }
@@ -4188,13 +5884,13 @@ function mapHookPayload(payload) {
         {
           kind: "session_event",
           phase: "compact_end",
-          ...asString(p["trigger"]) ? { detail: asString(p["trigger"]) } : {}
+          ...asString2(p["trigger"]) ? { detail: asString2(p["trigger"]) } : {}
         }
       ];
     }
     case "CwdChanged": {
-      const from = asString(p["old_cwd"]);
-      const to = asString(p["new_cwd"]);
+      const from = asString2(p["old_cwd"]);
+      const to = asString2(p["new_cwd"]);
       if (!from || !to)
         return [];
       return [{ kind: "cwd_changed", from, to }];
@@ -4968,13 +6664,13 @@ __export(resolve_executable_exports, {
   resolveExecutable: () => resolveExecutable
 });
 import { accessSync, existsSync as existsSync9, readdirSync, statSync as statSync3, constants } from "node:fs";
-import { resolve as pathResolve, isAbsolute, sep } from "node:path";
+import { resolve as pathResolve, isAbsolute as isAbsolute2, sep as sep2 } from "node:path";
 import { delimiter } from "node:path";
 function resolveExecutable(program, env = process.env) {
   if (!program || program.length === 0)
     return null;
-  if (program.includes("/") || program.includes(sep)) {
-    const abs = isAbsolute(program) ? program : pathResolve(program);
+  if (program.includes("/") || program.includes(sep2)) {
+    const abs = isAbsolute2(program) ? program : pathResolve(program);
     return isExecutable(abs) ? abs : null;
   }
   const pathEnv = env["PATH"] ?? env["Path"] ?? "";
@@ -5073,7 +6769,7 @@ function colorsEnabled() {
   }
   return Boolean(process.stdout.isTTY);
 }
-function wrap(fn) {
+function wrap2(fn) {
   return (s) => colorsEnabled() ? fn(s) : s;
 }
 var pcForced, forceDisabled, c;
@@ -5083,14 +6779,14 @@ var init_colors = __esm({
     pcForced = pc.createColors(true);
     forceDisabled = false;
     c = {
-      bold: wrap(pcForced.bold),
-      dim: wrap(pcForced.dim),
-      red: wrap(pcForced.red),
-      green: wrap(pcForced.green),
-      yellow: wrap(pcForced.yellow),
-      blue: wrap(pcForced.blue),
-      cyan: wrap(pcForced.cyan),
-      gray: wrap(pcForced.gray)
+      bold: wrap2(pcForced.bold),
+      dim: wrap2(pcForced.dim),
+      red: wrap2(pcForced.red),
+      green: wrap2(pcForced.green),
+      yellow: wrap2(pcForced.yellow),
+      blue: wrap2(pcForced.blue),
+      cyan: wrap2(pcForced.cyan),
+      gray: wrap2(pcForced.gray)
     };
   }
 });
@@ -5121,7 +6817,7 @@ var init_did_you_mean = __esm({
 
 // backend/dist/broker/broker-state.js
 import { existsSync as existsSync10, mkdirSync as mkdirSync9, readFileSync as readFileSync7, rmSync as rmSync2 } from "node:fs";
-import { dirname as dirname4, resolve as resolve9 } from "node:path";
+import { dirname as dirname6, resolve as resolve9 } from "node:path";
 import { homedir as homedir7 } from "node:os";
 function defaultBrokerStatePath() {
   return resolve9(homedir7(), ATR_DATA_DIR, BROKER_STATE_FILENAME);
@@ -5162,7 +6858,7 @@ function readBrokerState(path = defaultBrokerStatePath()) {
   return { version: SCHEMA_VERSION2, pid, port, host, startedAt, brokerVersion };
 }
 function writeBrokerState(state, path = defaultBrokerStatePath()) {
-  const dir = dirname4(path);
+  const dir = dirname6(path);
   if (!existsSync10(dir)) {
     try {
       mkdirSync9(dir, { recursive: true, mode: 448 });
@@ -5548,6 +7244,10 @@ function createBrokerApp(opts) {
       if (req.path.startsWith("/api") || req.path.startsWith("/ws")) {
         return next();
       }
+      if (isStaticAssetPath(req.path)) {
+        res.status(404).type("text/plain").send("not found");
+        return;
+      }
       const instanceId = req.__atrInstanceId;
       const urlToken = typeof req.query.token === "string" ? req.query.token : null;
       if (!instanceId && !urlToken) {
@@ -5635,6 +7335,11 @@ async function startBrokerServer(opts) {
     }
   };
 }
+function isStaticAssetPath(p) {
+  if (p.startsWith("/assets/"))
+    return true;
+  return STATIC_EXT_RE.test(p);
+}
 function collectLocalHostnames() {
   const set = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
   const ifaces = networkInterfaces3();
@@ -5655,7 +7360,7 @@ function collectLocalHostnames() {
   }
   return set;
 }
-var DEFAULT_BROKER_PORT, DEFAULT_BROKER_HOST;
+var DEFAULT_BROKER_PORT, DEFAULT_BROKER_HOST, STATIC_EXT_RE;
 var init_broker_server = __esm({
   "backend/dist/broker/broker-server.js"() {
     "use strict";
@@ -5667,13 +7372,14 @@ var init_broker_server = __esm({
     init_port_finder();
     DEFAULT_BROKER_PORT = 3737;
     DEFAULT_BROKER_HOST = "0.0.0.0";
+    STATIC_EXT_RE = /\.(js|mjs|cjs|css|map|json|webmanifest|png|jpg|jpeg|gif|svg|webp|ico|avif|woff|woff2|ttf|otf|wasm)$/i;
   }
 });
 
 // backend/dist/broker/ensure-broker.js
 import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync12, mkdirSync as mkdirSync10, openSync } from "node:fs";
-import { dirname as dirname5, resolve as resolve11 } from "node:path";
+import { dirname as dirname7, resolve as resolve11 } from "node:path";
 import { homedir as homedir8 } from "node:os";
 function defaultBrokerLockDir() {
   return resolve11(homedir8(), ATR_DATA_DIR, ".broker.lock");
@@ -5756,7 +7462,7 @@ function resolveBrokerEntry(cliJsPath) {
   return { execPath: process.execPath, args: [cliJsPath] };
 }
 function ensureParentDir(lockDir) {
-  const parent = dirname5(lockDir);
+  const parent = dirname7(lockDir);
   if (existsSync12(parent))
     return;
   try {
@@ -5996,7 +7702,7 @@ var entry_prompt_exports = {};
 __export(entry_prompt_exports, {
   promptEntrySelection: () => promptEntrySelection
 });
-import { createInterface } from "node:readline";
+import { createInterface as createInterface2 } from "node:readline";
 async function promptEntrySelection(opts) {
   const { candidates } = opts;
   if (candidates.length === 0) {
@@ -6026,7 +7732,7 @@ async function promptEntrySelection(opts) {
   const timeoutMs = opts.timeoutMs ?? 0;
   const useTimeout = timeoutMs > 0;
   const promptLine = useTimeout ? `   \u9009\u62E9 [1-${candidates.length}\uFF0C\u56DE\u8F66=${defaultIdx + 1}\uFF0C${Math.round(timeoutMs / 1e3)}s \u8D85\u65F6\u9ED8\u8BA4]: ` : `   \u9009\u62E9 [1-${candidates.length}\uFF0C\u56DE\u8F66=${defaultIdx + 1}]: `;
-  const rl = createInterface({
+  const rl = createInterface2({
     input,
     output,
     terminal: false
@@ -6091,7 +7797,7 @@ __export(index_exports, {
 import { createServer as createServer3 } from "node:http";
 import { execSync } from "node:child_process";
 import { networkInterfaces as networkInterfaces5 } from "node:os";
-import { resolve as resolve12, dirname as dirname6 } from "node:path";
+import { resolve as resolve12, dirname as dirname8 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import express2 from "express";
 import cors2 from "cors";
@@ -6157,7 +7863,7 @@ async function startServer(overrides = {}) {
     }
     logger.info({ requested: cfg.claudeCommand, resolved }, "PTY program resolved");
   }
-  const __dirnameForBroker = dirname6(fileURLToPath2(import.meta.url));
+  const __dirnameForBroker = dirname8(fileURLToPath2(import.meta.url));
   const cliJsPathForBroker = resolve12(__dirnameForBroker, "cli.js");
   const { ensureBroker: ensureBroker2 } = await Promise.resolve().then(() => (init_broker(), broker_exports));
   let brokerState;
@@ -6249,7 +7955,7 @@ hint: check whether ~/.atr/broker.json is held by a stale process; set ATR_DEBUG
     legacyCookieNames: [createSessionCookieName(cfg.port)],
     sessions: sessionsStore
   });
-  const __dirname2 = dirname6(fileURLToPath2(import.meta.url));
+  const __dirname2 = dirname8(fileURLToPath2(import.meta.url));
   const registry = new InstanceRegistryManager();
   const localHostnames = collectLocalHostnames2();
   logger.info({ hostnames: Array.from(localHostnames) }, "CORS \u767D\u540D\u5355");
@@ -6357,7 +8063,7 @@ hint: check whether ~/.atr/broker.json is held by a stale process; set ATR_DEBUG
     const tokenPreview = cfg.token.length >= 16 ? `${cfg.token.slice(0, 8)}...${cfg.token.slice(-8)}` : cfg.token;
     const BOX_INNER = 50;
     const top = `\u2554${"\u2550".repeat(BOX_INNER)}\u2557`;
-    const sep2 = `\u2560${"\u2550".repeat(BOX_INNER)}\u2563`;
+    const sep3 = `\u2560${"\u2550".repeat(BOX_INNER)}\u2563`;
     const bot = `\u255A${"\u2550".repeat(BOX_INNER)}\u255D`;
     const row = (text) => {
       const trimmed = text.length <= BOX_INNER ? text.padEnd(BOX_INNER) : text.slice(0, BOX_INNER);
@@ -6373,13 +8079,13 @@ hint: check whether ~/.atr/broker.json is held by a stale process; set ATR_DEBUG
     process.stderr.write("\n");
     process.stderr.write(top + "\n");
     process.stderr.write(center("Auvezy Terminal Remote \xB7 started") + "\n");
-    process.stderr.write(sep2 + "\n");
+    process.stderr.write(sep3 + "\n");
     process.stderr.write(row(`  instance: ${cfg.instanceName}`) + "\n");
     process.stderr.write(row(`  service:  http://${brokerState.host}:${brokerState.port}`) + "\n");
     process.stderr.write(row(`  token:    ${tokenPreview}`) + "\n");
     process.stderr.write(row(`  source:   ${cfg.tokenSource}`) + "\n");
     if (cfg.tokenSource === "generated") {
-      process.stderr.write(sep2 + "\n");
+      process.stderr.write(sep3 + "\n");
       process.stderr.write(row("  Full token (shown once \u2014 save it now):") + "\n");
       process.stderr.write(row(`  ${cfg.token.slice(0, 48)}`) + "\n");
       process.stderr.write(row(`  ${cfg.token.slice(48)}`) + "\n");
@@ -7305,7 +9011,7 @@ var init_attach = __esm({
 
 // backend/dist/broker/broker-log-rotator.js
 import { appendFileSync, existsSync as existsSync13, mkdirSync as mkdirSync11, readdirSync as readdirSync2, statSync as statSync4, unlinkSync as unlinkSync2 } from "node:fs";
-import { resolve as resolve13, basename as basename4 } from "node:path";
+import { resolve as resolve13, basename as basename6 } from "node:path";
 function createBrokerLogRotator(opts) {
   const now = opts.now ?? (() => /* @__PURE__ */ new Date());
   if (!existsSync13(opts.dir)) {
@@ -7390,51 +9096,10 @@ var init_broker_log_rotator = __esm({
   }
 });
 
-// backend/dist/utils/workdir-policy.js
-import picomatch from "picomatch";
-function checkWorkdir(cwd, allow, deny) {
-  const norm = normalizePath(cwd);
-  const opts = { dot: true };
-  if (deny && deny.length > 0) {
-    for (const pattern of deny) {
-      if (picomatch(pattern, opts)(norm)) {
-        return {
-          reason: `cwd "${cwd}" \u547D\u4E2D\u9ED1\u540D\u5355 pattern\uFF1A${pattern}`,
-          matchedPattern: pattern
-        };
-      }
-    }
-  }
-  if (allow && allow.length > 0) {
-    let hit = false;
-    for (const pattern of allow) {
-      if (picomatch(pattern, opts)(norm)) {
-        hit = true;
-        break;
-      }
-    }
-    if (!hit) {
-      return {
-        reason: `cwd "${cwd}" \u672A\u547D\u4E2D\u4EFB\u4F55\u767D\u540D\u5355 pattern\uFF1A[${allow.join(", ")}]`,
-        matchedPattern: ""
-      };
-    }
-  }
-  return null;
-}
-function normalizePath(p) {
-  return p.replace(/\\/g, "/");
-}
-var init_workdir_policy = __esm({
-  "backend/dist/utils/workdir-policy.js"() {
-    "use strict";
-  }
-});
-
 // backend/dist/registry/instance-spawner.js
 import { spawn as spawn3 } from "node:child_process";
 import { existsSync as existsSync14, statSync as statSync5, openSync as openSync2 } from "node:fs";
-import { resolve as resolve14, isAbsolute as isAbsolute2, dirname as dirname7 } from "node:path";
+import { resolve as resolve14, isAbsolute as isAbsolute3, dirname as dirname9 } from "node:path";
 function waitForEarlyExit(child, timeoutMs) {
   return new Promise((res) => {
     let settled = false;
@@ -7460,7 +9125,7 @@ function resolveEntry(cliJsPath) {
   }
   const tsPath = cliJsPath.replace(/\.js$/, ".ts");
   if (existsSync14(tsPath)) {
-    const tsxBin = findTsxBin(dirname7(tsPath));
+    const tsxBin = findTsxBin(dirname9(tsPath));
     if (tsxBin) {
       return { execPath: tsxBin, args: [tsPath] };
     }
@@ -7477,14 +9142,14 @@ function findTsxBin(startDir) {
     const candidate = resolve14(dir, "node_modules", ".bin", "tsx");
     if (existsSync14(candidate))
       return candidate;
-    const parent = dirname7(dir);
+    const parent = dirname9(dir);
     if (parent === dir)
       break;
     dir = parent;
   }
   return null;
 }
-function basename5(p) {
+function basename7(p) {
   const parts = p.split(/[\\/]/).filter(Boolean);
   return parts[parts.length - 1] ?? "instance";
 }
@@ -7502,7 +9167,7 @@ var init_instance_spawner = __esm({
         this.opts = opts;
       }
       async spawn(input) {
-        const cwd = isAbsolute2(input.cwd) ? input.cwd : resolve14(input.cwd);
+        const cwd = isAbsolute3(input.cwd) ? input.cwd : resolve14(input.cwd);
         if (!existsSync14(cwd)) {
           throw new InstanceError(ErrorCode.CWD_NOT_EXIST, `cwd does not exist: ${cwd}`, 400);
         }
@@ -7514,7 +9179,7 @@ var init_instance_spawner = __esm({
           logger.warn({ cwd, verdict }, "workdir policy rejected spawn");
           throw new InstanceError(ErrorCode.CWD_NOT_EXIST, `cwd not allowed by workdir policy: ${verdict.reason}`, 403);
         }
-        const name = input.name && input.name.trim() ? input.name.trim() : basename5(cwd);
+        const name = input.name && input.name.trim() ? input.name.trim() : basename7(cwd);
         const { execPath, args: entryArgs } = resolveEntry(this.opts.cliJsPath);
         const logFd = process.env.ATR_DEBUG_SPAWN ? openSync2(`/tmp/atr-spawn-${Date.now()}.log`, "a") : "ignore";
         const child = spawn3(execPath, [...entryArgs, "--no-terminal"], {
@@ -7571,7 +9236,7 @@ __export(service_installer_exports, {
   uninstall: () => uninstall
 });
 import { existsSync as existsSync15, mkdirSync as mkdirSync12, readFileSync as readFileSync10, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import { resolve as resolve15, dirname as dirname8 } from "node:path";
+import { resolve as resolve15, dirname as dirname10 } from "node:path";
 import { homedir as homedir9, platform } from "node:os";
 function detectPlatform(env = process.env, plat = platform()) {
   if (plat === "darwin")
@@ -7646,8 +9311,8 @@ function install(opts) {
   if (platformDetected === "macos") {
     const path2 = launchdPlistPath(home);
     const logPath = brokerLogPath(home);
-    ensureDir(fs, dirname8(path2));
-    ensureDir(fs, dirname8(logPath));
+    ensureDir(fs, dirname10(path2));
+    ensureDir(fs, dirname10(logPath));
     fs.writeFileSync(path2, renderLaunchdPlist({
       nodeBin: opts.nodeBin,
       cliPath: opts.cliPath,
@@ -7665,7 +9330,7 @@ function install(opts) {
     };
   }
   const path = systemdUnitPath(home);
-  ensureDir(fs, dirname8(path));
+  ensureDir(fs, dirname10(path));
   fs.writeFileSync(path, renderSystemdUnit({
     nodeBin: opts.nodeBin,
     cliPath: opts.cliPath,
@@ -7792,11 +9457,11 @@ __export(cli_exports, {
 });
 import { execSync as execSync2, spawn as spawn4 } from "node:child_process";
 import { existsSync as existsSync16, openSync as openSync3, readFileSync as readFileSync11 } from "node:fs";
-import { resolve as resolve16, dirname as dirname9 } from "node:path";
+import { resolve as resolve16, dirname as dirname11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { homedir as homedir10 } from "node:os";
 function getBrokerVersion() {
-  const __dirname2 = dirname9(fileURLToPath3(import.meta.url));
+  const __dirname2 = dirname11(fileURLToPath3(import.meta.url));
   const candidates = [
     resolve16(__dirname2, "package.json"),
     resolve16(__dirname2, "..", "package.json"),
@@ -7815,7 +9480,7 @@ function getBrokerVersion() {
   return "0.0.0";
 }
 function getCliPath() {
-  const __dirname2 = dirname9(fileURLToPath3(import.meta.url));
+  const __dirname2 = dirname11(fileURLToPath3(import.meta.url));
   const parentDir = resolve16(__dirname2, "..", "cli.js");
   const sameDir = resolve16(__dirname2, "cli.js");
   try {
@@ -7860,7 +9525,7 @@ async function runBrokerStart(cli) {
   process.stderr.write(`[atr] log file: ${logRotator.currentFilePath()}
 `);
   const registry = new InstanceRegistryManager();
-  const __dirname2 = dirname9(fileURLToPath3(import.meta.url));
+  const __dirname2 = dirname11(fileURLToPath3(import.meta.url));
   const frontendDist = resolve16(__dirname2, "..", "frontend-dist");
   let sharedToken;
   try {
@@ -7912,7 +9577,8 @@ async function runBrokerStart(cli) {
     brokerPort: port,
     displayIp,
     workdirPolicy: () => ({
-      allow: currentUserConfig.workdirAllow ?? []
+      allow: currentUserConfig.workdirAllow ?? [],
+      deny: currentUserConfig.workdirDeny ?? []
     })
   };
   let handle;
@@ -8208,12 +9874,12 @@ async function writeTokenSection() {
     const { resolve: pathResolve2 } = await import("node:path");
     const { homedir: homedir11 } = await import("node:os");
     const path = pathResolve2(homedir11(), ".atrrc");
-    const stat = statSync6(path);
+    const stat3 = statSync6(path);
     const cfg = JSON.parse(readFileSync12(path, "utf-8"));
     if (typeof cfg.token === "string" && cfg.token.length > 0) {
       process.stdout.write(`  token:   ${cfg.token}
 `);
-      process.stdout.write(`  file:    ${path} (mode ${(stat.mode & 511).toString(8)})
+      process.stdout.write(`  file:    ${path} (mode ${(stat3.mode & 511).toString(8)})
 `);
     } else {
       process.stdout.write(`  token:   (none; ${path} has no .token field)
@@ -8492,9 +10158,9 @@ void (async () => {
   }
   if (cli.version) {
     const { readFileSync: readFileSync12 } = await import("node:fs");
-    const { resolve: resolve17, dirname: dirname10 } = await import("node:path");
+    const { resolve: resolve17, dirname: dirname12 } = await import("node:path");
     const { fileURLToPath: fileURLToPath4 } = await import("node:url");
-    const __dirname2 = dirname10(fileURLToPath4(import.meta.url));
+    const __dirname2 = dirname12(fileURLToPath4(import.meta.url));
     const pkg = JSON.parse(readFileSync12(resolve17(__dirname2, "..", "package.json"), "utf-8"));
     process.stdout.write(`${pkg.version}
 `);