@buildautomaton/cli 0.1.35 → 0.1.36

package/dist/cli.js

@@ -974,7 +974,7 @@ var require_command = __commonJS({
     var EventEmitter2 = __require("node:events").EventEmitter;
     var childProcess2 = __require("node:child_process");
     var path43 = __require("node:path");
-    var fs38 = __require("node:fs");
+    var fs41 = __require("node:fs");
     var process8 = __require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
@@ -1907,10 +1907,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
           const localBin = path43.resolve(baseDir, baseName);
-          if (fs38.existsSync(localBin)) return localBin;
+          if (fs41.existsSync(localBin)) return localBin;
           if (sourceExt.includes(path43.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
-            (ext) => fs38.existsSync(`${localBin}${ext}`)
+            (ext) => fs41.existsSync(`${localBin}${ext}`)
           );
           if (foundExt) return `${localBin}${foundExt}`;
           return void 0;
@@ -1922,7 +1922,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._scriptPath) {
           let resolvedScriptPath;
           try {
-            resolvedScriptPath = fs38.realpathSync(this._scriptPath);
+            resolvedScriptPath = fs41.realpathSync(this._scriptPath);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
@@ -25064,14 +25064,14 @@ var {
 } = import_index.default;
 
 // src/cli-version.ts
-var CLI_VERSION = "0.1.35".length > 0 ? "0.1.35" : "0.0.0-dev";
+var CLI_VERSION = "0.1.36".length > 0 ? "0.1.36" : "0.0.0-dev";
 
 // src/cli/defaults.ts
 var DEFAULT_API_URL = process.env.BUILDAUTOMATON_API_URL ?? "https://api.buildautomaton.com";
 var DEFAULT_FIREHOSE_URL = "https://buildautomaton-firehose.fly.dev";
 
 // src/cli/run-cli-action.ts
-import * as fs37 from "node:fs";
+import * as fs40 from "node:fs";
 import * as path42 from "node:path";
 
 // src/cli-log-level.ts
@@ -26961,6 +26961,7 @@ function recordMigrationAndPruneCheckpointLegacy(db, migration, applied2) {
 var CHECKPOINT_V1 = "001_cli_sqlite_checkpoint_v1";
 var CHECKPOINT_V1_SQL = readCliSqliteMigrationSql("001_cli_sqlite_checkpoint_v1.sql");
 var AGENT_CAPABILITIES_SQL = readCliSqliteMigrationSql("002_agent_capabilities.sql");
+var FILE_INDEX_PARENT_PATHS_SQL = readCliSqliteMigrationSql("003_file_index_parent_paths.sql");
 function agentCapabilitiesTableState(db) {
   const rows = db.all(
     `SELECT name FROM sqlite_master WHERE type='table' AND name IN ('agent_capabilities', 'agent_capability_cache')`
@@ -26994,6 +26995,18 @@ var CLI_SQLITE_MIGRATIONS = [
       db.exec(AGENT_CAPABILITIES_SQL);
     },
     alreadyApplied: (db) => agentCapabilitiesTableState(db) === "current"
+  },
+  {
+    name: "003_file_index_parent_paths",
+    migrate: (db) => {
+      db.exec(FILE_INDEX_PARENT_PATHS_SQL);
+    },
+    alreadyApplied: (db) => {
+      const row = db.get(
+        `SELECT 1 as ok FROM sqlite_master WHERE type='table' AND name='file_index_parent_path' LIMIT 1`
+      );
+      return row != null;
+    }
   }
 ];
 function migrateCliSqlite(db) {
@@ -27032,6 +27045,10 @@ var CliSqliteInterrupted = class extends Error {
   }
 };
 function applyCliSqliteConcurrencyPragmas(db) {
+  try {
+    db.run("PRAGMA foreign_keys = ON");
+  } catch {
+  }
   try {
     db.exec("PRAGMA journal_mode = WAL");
   } catch {
@@ -36743,8 +36760,18 @@ import path29 from "node:path";
 // src/files/index/walk-workspace-tree.ts
 import fs25 from "node:fs";
 import path28 from "node:path";
+var DEPENDENCY_INSTALL_DIR_NAMES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "bower_components",
+  "vendor",
+  "Pods",
+  "Carthage",
+  "DerivedData",
+  ".yarn",
+  ".pnpm-store"
+]);
 function shouldSkipWorkspaceWalkEntry(name) {
-  return name.startsWith(".");
+  return DEPENDENCY_INSTALL_DIR_NAMES.has(name);
 }
 async function walkWorkspaceTreeAsync(dir, baseDir, onFile, state) {
   let names;
@@ -36815,14 +36842,26 @@ var FILE_INDEX_INTERRUPT_CHECK_EVERY = 256;
 function assertNotShutdown() {
   if (isCliImmediateShutdownRequested()) throw new CliSqliteInterrupted();
 }
+function upsertFileIndexParentPath(db, resolved) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.run(
+    `INSERT INTO file_index_parent_path (path, path_hash, updated_at)
+     VALUES (?, ?, ?)
+     ON CONFLICT(path) DO UPDATE SET path_hash = excluded.path_hash, updated_at = excluded.updated_at`,
+    [resolved, getCwdHashForFileIndex(resolved), now]
+  );
+  const row = db.get("SELECT id FROM file_index_parent_path WHERE path = ?", [resolved]);
+  if (row == null) throw new Error(`Failed to upsert file index parent path: ${resolved}`);
+  return Number(row.id);
+}
 function persistFileIndexPaths(resolved, paths) {
   return withCliSqliteSync((db) => {
-    const h = getCwdHashForFileIndex(resolved);
     let pathCount = 0;
     db.run("BEGIN IMMEDIATE");
     try {
-      db.run("DELETE FROM file_index_path WHERE cwd_hash = ?", [h]);
-      const ins = db.prepare("INSERT INTO file_index_path (cwd_hash, path) VALUES (?, ?)");
+      const parentId = upsertFileIndexParentPath(db, resolved);
+      db.run("DELETE FROM file_index_child_path WHERE parent_id = ?", [parentId]);
+      const ins = db.prepare("INSERT INTO file_index_child_path (parent_id, path) VALUES (?, ?)");
       try {
         let batch = 0;
         for (const rel of paths) {
@@ -36830,7 +36869,7 @@ function persistFileIndexPaths(resolved, paths) {
             batch = 0;
             assertNotShutdown();
           }
-          ins.run([h, rel]);
+          ins.run([parentId, rel]);
           pathCount += 1;
         }
       } finally {
@@ -36872,36 +36911,38 @@ async function buildFileIndexAsync(cwd) {
 // src/files/index/ensure-file-index.ts
 import path30 from "node:path";
 
-// src/files/index/file-index-dependency-path.ts
-function sqliteExprBridgeFileIndexDependencyRank() {
-  return `CASE WHEN lower(path) = 'node_modules' OR lower(path) LIKE 'node_modules/%' OR lower(path) LIKE '%/node_modules/%' OR lower(path) = 'bower_components' OR lower(path) LIKE 'bower_components/%' OR lower(path) LIKE '%/bower_components/%' THEN 1 ELSE 0 END`;
-}
-
 // src/files/index/search-file-index.ts
 function escapeLikePattern(fragment) {
   return fragment.replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
 }
 function bridgeFileIndexIsPopulatedWithDb(resolvedCwd, db) {
-  const h = getCwdHashForFileIndex(resolvedCwd);
-  const row = db.get("SELECT 1 as ok FROM file_index_path WHERE cwd_hash = ? LIMIT 1", [h]);
+  const row = db.get("SELECT 1 as ok FROM file_index_parent_path WHERE path = ? LIMIT 1", [resolvedCwd]);
   return row != null;
 }
 function bridgeFileIndexPathCountWithDb(resolvedCwd, db) {
-  const h = getCwdHashForFileIndex(resolvedCwd);
-  const row = db.get("SELECT COUNT(*) as c FROM file_index_path WHERE cwd_hash = ?", [h]);
+  const row = db.get(
+    `SELECT COUNT(*) as c
+     FROM file_index_child_path child
+     JOIN file_index_parent_path parent ON parent.id = child.parent_id
+     WHERE parent.path = ?`,
+    [resolvedCwd]
+  );
   const c = row?.c ?? 0;
   return Number(c);
 }
 function searchBridgeFilePathsWithDb(resolvedCwd, query, limit, db) {
   const q = query.trim().toLowerCase();
   if (!q) return [];
-  const h = getCwdHashForFileIndex(resolvedCwd);
   const pattern = `%${escapeLikePattern(q)}%`;
   const lim = Math.max(0, Math.min(1e4, Math.floor(limit)));
-  const depRank = sqliteExprBridgeFileIndexDependencyRank();
   const rows = db.all(
-    `SELECT path FROM file_index_path WHERE cwd_hash = ? AND lower(path) LIKE ? ESCAPE '\\' ORDER BY ${depRank}, path LIMIT ?`,
-    [h, pattern, lim]
+    `SELECT child.path
+     FROM file_index_child_path child
+     JOIN file_index_parent_path parent ON parent.id = child.parent_id
+     WHERE parent.path = ? AND lower(child.path) LIKE ? ESCAPE '\\'
+     ORDER BY child.path
+     LIMIT ?`,
+    [resolvedCwd, pattern, lim]
   );
   return rows.map((r) => String(r.path));
 }
@@ -36931,9 +36972,7 @@ async function ensureFileIndexAsync(cwd) {
 var DEBOUNCE_MS = 900;
 function shouldIgnoreRelative(rel) {
   const n = rel.replace(/\\/g, "/");
-  if (n.includes("/.git/") || n === ".git" || n.startsWith(".git/")) return true;
-  if (n.includes("/.buildautomaton/") || n.startsWith(".buildautomaton/")) return true;
-  return false;
+  return n.split("/").some((segment) => shouldSkipWorkspaceWalkEntry(segment));
 }
 function attachWatchErrorLog(w) {
   w.on("error", (err) => {
@@ -39318,9 +39357,8 @@ var handleSkillCallMessage = (msg, { getWs, log: log2 }) => {
   );
 };
 
-// src/files/list-dir.ts
-import fs33 from "node:fs";
-import path36 from "node:path";
+// src/files/list-dir/index.ts
+import fs34 from "node:fs";
 
 // src/files/ensure-under-cwd.ts
 import path35 from "node:path";
@@ -39333,71 +39371,93 @@ function ensureUnderCwd(relativePath, cwd = getBridgeRoot()) {
   return resolved;
 }
 
-// src/files/list-dir.ts
+// src/files/list-dir/types.ts
 var LIST_DIR_YIELD_EVERY = 256;
-async function listDirAsync(relativePath) {
-  const resolved = ensureUnderCwd(relativePath || ".", getBridgeRoot());
+
+// src/files/list-dir/map-dir-entry.ts
+import path36 from "node:path";
+import fs33 from "node:fs";
+async function mapDirEntry(d, relativePath, resolved) {
+  const entryPath = path36.join(relativePath || ".", d.name).replace(/\\/g, "/");
+  const fullPath = path36.join(resolved, d.name);
+  let isDir = d.isDirectory();
+  if (d.isSymbolicLink()) {
+    try {
+      const targetStat = await fs33.promises.stat(fullPath);
+      isDir = targetStat.isDirectory();
+    } catch {
+      isDir = false;
+    }
+  }
+  return {
+    name: d.name,
+    path: entryPath,
+    isDir,
+    isSymlink: d.isSymbolicLink()
+  };
+}
+
+// src/files/list-dir/sort-entries.ts
+function sortListEntries(entries) {
+  return entries.sort((a, b) => {
+    if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
+    return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+  });
+}
+
+// src/files/list-dir/index.ts
+async function listDirAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  await yieldToEventLoop();
+  const resolved = ensureUnderCwd(relativePath || ".", sessionParentPath);
   if (!resolved) {
     return { error: "Path is outside working directory" };
   }
   try {
-    const names = await fs33.promises.readdir(resolved, { withFileTypes: true });
-    const visible = names.filter((d) => !d.name.startsWith("."));
+    const names = await fs34.promises.readdir(resolved, { withFileTypes: true });
     const entries = [];
-    for (let i = 0; i < visible.length; i++) {
+    for (let i = 0; i < names.length; i++) {
       if (i > 0 && i % LIST_DIR_YIELD_EVERY === 0) {
         await yieldToEventLoop();
       }
-      const d = visible[i];
-      const entryPath = path36.join(relativePath || ".", d.name).replace(/\\/g, "/");
-      const fullPath = path36.join(resolved, d.name);
-      let isDir = d.isDirectory();
-      if (d.isSymbolicLink()) {
-        try {
-          const targetStat = await fs33.promises.stat(fullPath);
-          isDir = targetStat.isDirectory();
-        } catch {
-          isDir = false;
-        }
-      }
-      entries.push({
-        name: d.name,
-        path: entryPath,
-        isDir,
-        isSymlink: d.isSymbolicLink()
-      });
+      entries.push(await mapDirEntry(names[i], relativePath, resolved));
     }
-    entries.sort((a, b) => {
-      if (a.isDir !== b.isDir) return a.isDir ? -1 : 1;
-      return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
-    });
-    return { entries };
+    return { entries: sortListEntries(entries) };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { error: message };
   }
 }
 
-// src/files/read-file.ts
-import fs34 from "node:fs";
-import { StringDecoder } from "node:string_decoder";
-function resolveFilePath(relativePath) {
-  const resolved = ensureUnderCwd(relativePath, getBridgeRoot());
+// src/files/read-file/types.ts
+var LINE_CHUNK_SIZE = 64 * 1024;
+var READ_RANGE_YIELD_EVERY_BYTES = 256 * 1024;
+
+// src/files/read-file/resolve-file-path.ts
+import fs35 from "node:fs";
+async function resolveFilePathAsync(relativePath, sessionParentPath = getBridgeRoot()) {
+  const resolved = ensureUnderCwd(relativePath, sessionParentPath);
   if (!resolved) return { error: "Path is outside working directory" };
   let real;
   try {
-    real = fs34.realpathSync(resolved);
+    real = await fs35.promises.realpath(resolved);
   } catch {
     real = resolved;
   }
-  const stat3 = fs34.statSync(real);
-  if (!stat3.isFile()) return { error: "Not a file" };
-  return real;
+  try {
+    const stat3 = await fs35.promises.stat(real);
+    if (!stat3.isFile()) return { error: "Not a file" };
+    return real;
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
 }
-var LINE_CHUNK_SIZE = 64 * 1024;
-function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
-  const fileSize = fs34.statSync(filePath).size;
-  const fd = fs34.openSync(filePath, "r");
+
+// src/files/read-file/read-file-range-async.ts
+import fs36 from "node:fs";
+import { StringDecoder } from "node:string_decoder";
+async function readFileRangeAsync(filePath, startLine, endLine, lineOffsetIn, lineChunkSize = LINE_CHUNK_SIZE) {
+  const fileSize = (await fs36.promises.stat(filePath)).size;
+  const fd = await fs36.promises.open(filePath, "r");
   const bufSize = 64 * 1024;
   const buf = Buffer.alloc(bufSize);
   const decoder = new StringDecoder("utf8");
@@ -39408,9 +39468,18 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
   let skipLine0Chars = typeof lineOffsetIn === "number" ? lineOffsetIn : 0;
   let line0CharsReturned = 0;
   let line0Accum = "";
+  let bytesSinceYield = 0;
   try {
-    let bytesRead;
-    while (!done && (bytesRead = fs34.readSync(fd, buf, 0, bufSize, null)) > 0) {
+    let position = 0;
+    while (!done) {
+      const { bytesRead } = await fd.read(buf, 0, bufSize, position);
+      if (bytesRead === 0) break;
+      position += bytesRead;
+      bytesSinceYield += bytesRead;
+      if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+        await yieldToEventLoop();
+        bytesSinceYield = 0;
+      }
       const text = partial2 + decoder.write(buf.subarray(0, bytesRead));
       partial2 = "";
       let lineStart = 0;
@@ -39545,39 +39614,132 @@ function readFileRange(filePath, startLine, endLine, lineOffsetIn, lineChunkSize
     }
     return { content: resultLines.join("\n"), size: fileSize };
   } finally {
-    fs34.closeSync(fd);
+    await fd.close();
   }
 }
-function readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
+
+// src/files/read-file/read-file-buffer-full-async.ts
+import fs37 from "node:fs";
+var READ_CHUNK_BYTES = 256 * 1024;
+async function readFileBufferFullAsync(filePath) {
+  const stat3 = await fs37.promises.stat(filePath);
+  const fd = await fs37.promises.open(filePath, "r");
+  const chunks = [];
+  let position = 0;
+  let bytesSinceYield = 0;
   try {
-    const result = resolveFilePath(relativePath);
+    while (position < stat3.size) {
+      const buf = Buffer.alloc(Math.min(READ_CHUNK_BYTES, stat3.size - position));
+      const { bytesRead } = await fd.read(buf, 0, buf.length, position);
+      if (bytesRead === 0) break;
+      chunks.push(buf.subarray(0, bytesRead));
+      position += bytesRead;
+      bytesSinceYield += bytesRead;
+      if (bytesSinceYield >= READ_RANGE_YIELD_EVERY_BYTES) {
+        await yieldToEventLoop();
+        bytesSinceYield = 0;
+      }
+    }
+  } finally {
+    await fd.close();
+  }
+  return { buffer: Buffer.concat(chunks), size: stat3.size };
+}
+
+// src/files/read-file/read-file-full-async.ts
+async function readFileFullAsync(filePath) {
+  const { buffer, size } = await readFileBufferFullAsync(filePath);
+  const raw = buffer.toString("utf8");
+  const lines = raw.split(/\r?\n/);
+  return { content: raw, totalLines: lines.length, size };
+}
+
+// src/files/read-file/guess-mime-type.ts
+var MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  bmp: "image/bmp",
+  ico: "image/x-icon",
+  webp: "image/webp",
+  avif: "image/avif",
+  svg: "image/svg+xml",
+  pdf: "application/pdf",
+  json: "application/json",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  js: "text/javascript",
+  mjs: "text/javascript",
+  ts: "text/typescript",
+  txt: "text/plain",
+  md: "text/markdown",
+  xml: "application/xml",
+  zip: "application/zip",
+  gz: "application/gzip",
+  wasm: "application/wasm"
+};
+function guessMimeType(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  return MIME_BY_EXT[ext] ?? "application/octet-stream";
+}
+
+// src/files/read-file/read-file-binary-full-async.ts
+async function readFileBinaryFullAsync(filePath) {
+  const { buffer, size } = await readFileBufferFullAsync(filePath);
+  return {
+    content: buffer.toString("base64"),
+    size,
+    mimeType: guessMimeType(filePath)
+  };
+}
+
+// src/files/read-file/index.ts
+async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE, sessionParentPath = getBridgeRoot(), encoding = "utf8") {
+  await yieldToEventLoop();
+  try {
+    const result = await resolveFilePathAsync(relativePath, sessionParentPath);
     if (typeof result === "object") return result;
+    const resolvedPath = result;
     const hasRange = typeof startLine === "number" && typeof endLine === "number";
+    if (encoding === "base64") {
+      if (hasRange) return { error: "base64 encoding requires a full file read (no line range)" };
+      const read2 = await readFileBinaryFullAsync(resolvedPath);
+      return { ...read2, resolvedPath };
+    }
     if (hasRange) {
-      return readFileRange(result, startLine, endLine, lineOffset, lineChunkSize);
+      return readFileRangeAsync(resolvedPath, startLine, endLine, lineOffset, lineChunkSize);
     }
-    const stat3 = fs34.statSync(result);
-    const raw = fs34.readFileSync(result, "utf8");
-    const lines = raw.split(/\r?\n/);
-    return { content: raw, totalLines: lines.length, size: stat3.size };
+    const read = await readFileFullAsync(resolvedPath);
+    return { ...read, resolvedPath };
   } catch (err) {
     return { error: err instanceof Error ? err.message : String(err) };
   }
 }
-async function readFileAsync(relativePath, startLine, endLine, lineOffset, lineChunkSize = LINE_CHUNK_SIZE) {
-  await yieldToEventLoop();
-  return readFile3(relativePath, startLine, endLine, lineOffset, lineChunkSize);
+
+// src/files/resolve-file-browser-session-parent.ts
+function resolveFileBrowserSessionParent(sessionWorktreeManager, sessionId) {
+  const sid = sessionId?.trim();
+  if (sid) {
+    sessionWorktreeManager.ensureRepoCheckoutPathsForSession(sid);
+    const worktreeRoot = sessionWorktreeManager.getSessionWorktreeRootForSession(sid);
+    if (worktreeRoot) return worktreeRoot;
+  }
+  return getBridgeRoot();
 }
 
 // src/files/handle-file-browser-search.ts
 import path37 from "node:path";
 var SEARCH_LIMIT = 100;
-function handleFileBrowserSearch(msg, socket, e2ee) {
+function handleFileBrowserSearch(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     await yieldToEventLoop();
     const q = typeof msg.q === "string" ? msg.q : "";
-    const cwd = path37.resolve(getBridgeRoot());
-    if (!await bridgeFileIndexIsPopulated(cwd)) {
+    const sessionParentPath = path37.resolve(
+      sessionWorktreeManager != null ? resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : getBridgeRoot()
+    );
+    if (!await bridgeFileIndexIsPopulated(sessionParentPath)) {
       const payload2 = {
         type: "file_browser_search_response",
         id: msg.id,
@@ -39587,7 +39749,7 @@ function handleFileBrowserSearch(msg, socket, e2ee) {
       sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload2, ["paths"]) : payload2);
       return;
     }
-    const results = await searchBridgeFilePathsAsync(cwd, q, SEARCH_LIMIT);
+    const results = await searchBridgeFilePathsAsync(sessionParentPath, q, SEARCH_LIMIT);
     const payload = {
       type: "file_browser_search_response",
       id: msg.id,
@@ -39597,9 +39759,9 @@ function handleFileBrowserSearch(msg, socket, e2ee) {
     sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["paths"]) : payload);
   })();
 }
-function triggerFileIndexBuild() {
+function triggerFileIndexBuild(sessionParentPath = getBridgeRoot()) {
   setImmediate(() => {
-    void ensureFileIndexAsync(getBridgeRoot()).catch((e) => {
+    void ensureFileIndexAsync(sessionParentPath).catch((e) => {
       console.error("[file-index] Background build failed:", e);
     });
   });
@@ -39609,18 +39771,19 @@ function triggerFileIndexBuild() {
 function sendFileBrowserMessage(socket, e2ee, payload) {
   sendWsMessage(socket, e2ee ? e2ee.encryptFields(payload, ["entries", "content", "totalLines", "size", "lineOffset"]) : payload);
 }
-function handleFileBrowserRequest(msg, socket, e2ee) {
+function handleFileBrowserRequest(msg, socket, e2ee, sessionWorktreeManager) {
   void (async () => {
     const reqPath = msg.path.replace(/^\/+/, "") || ".";
     const op = msg.op === "read" ? "read" : "list";
+    const sessionParentPath = sessionWorktreeManager != null ? resolveFileBrowserSessionParent(sessionWorktreeManager, msg.sessionId) : void 0;
     if (op === "list") {
-      const result = await listDirAsync(reqPath);
+      const result = await listDirAsync(reqPath, sessionParentPath);
       if ("error" in result) {
         sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
       } else {
         sendFileBrowserMessage(socket, e2ee, { type: "file_browser_response", id: msg.id, entries: result.entries });
         if (reqPath === "." || reqPath === "") {
-          triggerFileIndexBuild();
+          triggerFileIndexBuild(sessionParentPath);
         }
       }
     } else {
@@ -39628,7 +39791,16 @@ function handleFileBrowserRequest(msg, socket, e2ee) {
       const endLine = typeof msg.endLine === "number" ? msg.endLine : void 0;
       const lineOffset = typeof msg.lineOffset === "number" ? msg.lineOffset : void 0;
       const lineChunkSize = typeof msg.lineChunkSize === "number" ? msg.lineChunkSize : void 0;
-      const result = await readFileAsync(reqPath, startLine, endLine, lineOffset, lineChunkSize);
+      const encoding = msg.encoding === "base64" ? "base64" : "utf8";
+      const result = await readFileAsync(
+        reqPath,
+        startLine,
+        endLine,
+        lineOffset,
+        lineChunkSize,
+        sessionParentPath,
+        encoding
+      );
       if ("error" in result) {
         sendWsMessage(socket, { type: "file_browser_response", id: msg.id, error: result.error });
       } else {
@@ -39640,6 +39812,8 @@ function handleFileBrowserRequest(msg, socket, e2ee) {
           size: result.size
         };
         if (result.lineOffset != null) payload.lineOffset = result.lineOffset;
+        if (result.mimeType != null) payload.mimeType = result.mimeType;
+        if (result.resolvedPath != null) payload.resolvedPath = result.resolvedPath;
         sendFileBrowserMessage(socket, e2ee, payload);
       }
     }
@@ -39647,21 +39821,27 @@ function handleFileBrowserRequest(msg, socket, e2ee) {
 }
 
 // src/routing/handlers/file-browser-messages.ts
-function handleFileBrowserRequestMessage(msg, { getWs, e2ee }) {
+function handleFileBrowserRequestMessage(msg, { getWs, e2ee, sessionWorktreeManager }) {
   if (typeof msg.id !== "string" || typeof msg.path !== "string") return;
   const socket = getWs();
   if (!socket) return;
   handleFileBrowserRequest(
     msg,
     socket,
-    e2ee
+    e2ee,
+    sessionWorktreeManager
   );
 }
-function handleFileBrowserSearchMessage(msg, { getWs, e2ee }) {
+function handleFileBrowserSearchMessage(msg, { getWs, e2ee, sessionWorktreeManager }) {
   if (typeof msg.id !== "string") return;
   const socket = getWs();
   if (!socket) return;
-  handleFileBrowserSearch(msg, socket, e2ee);
+  handleFileBrowserSearch(
+    msg,
+    socket,
+    e2ee,
+    sessionWorktreeManager
+  );
 }
 
 // src/routing/handlers/skill-layout-request.ts
@@ -39675,7 +39855,7 @@ function handleSkillLayoutRequest(msg, deps) {
 }
 
 // src/skills/install-remote-skills.ts
-import fs35 from "node:fs";
+import fs38 from "node:fs";
 import path38 from "node:path";
 function installRemoteSkills(cwd, targetDir, items) {
   const installed2 = [];
@@ -39691,11 +39871,11 @@ function installRemoteSkills(cwd, targetDir, items) {
       for (const f of item.files) {
         if (typeof f.path !== "string" || !f.text && !f.base64) continue;
         const dest = path38.join(skillDir, f.path);
-        fs35.mkdirSync(path38.dirname(dest), { recursive: true });
+        fs38.mkdirSync(path38.dirname(dest), { recursive: true });
         if (f.text !== void 0) {
-          fs35.writeFileSync(dest, f.text, "utf8");
+          fs38.writeFileSync(dest, f.text, "utf8");
         } else if (f.base64) {
-          fs35.writeFileSync(dest, Buffer.from(f.base64, "base64"));
+          fs38.writeFileSync(dest, Buffer.from(f.base64, "base64"));
         }
       }
       installed2.push({
@@ -39853,7 +40033,7 @@ var handleSessionDiscardedMessage = (msg, deps) => {
 };
 
 // src/routing/handlers/revert-turn-snapshot.ts
-import * as fs36 from "node:fs";
+import * as fs39 from "node:fs";
 var handleRevertTurnSnapshotMessage = (msg, deps) => {
   const id = typeof msg.id === "string" ? msg.id : "";
   const sessionId = typeof msg.sessionId === "string" ? msg.sessionId : "";
@@ -39866,7 +40046,7 @@ var handleRevertTurnSnapshotMessage = (msg, deps) => {
     const agentBase = sessionWorktreeManager.getSessionWorktreeRootForSession(sessionId) ?? getBridgeRoot();
     const file2 = snapshotFilePath(agentBase, turnId);
     try {
-      await fs36.promises.access(file2, fs36.constants.F_OK);
+      await fs39.promises.access(file2, fs39.constants.F_OK);
     } catch {
       sendWsMessage(s, {
         type: "revert_turn_snapshot_result",
@@ -40882,7 +41062,7 @@ async function runCliAction(program2, opts) {
   if (bridgeRootOpt) {
     const resolvedBridgeRoot = path42.resolve(process.cwd(), bridgeRootOpt);
     try {
-      const st = fs37.statSync(resolvedBridgeRoot);
+      const st = fs40.statSync(resolvedBridgeRoot);
       if (!st.isDirectory()) {
         console.error(`Bridge root is not a directory: ${resolvedBridgeRoot}`);
         process.exit(1);