@dotobokuri/fleet-console 1.44.0 → 1.45.0

package/dist/fleet-plugins/file-explorer/routes.mjs

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import { execFile, spawn } from 'child_process';
-import fs3, { constants } from 'fs';
-import fs8 from 'fs/promises';
-import path4 from 'path';
+import fs2, { constants } from 'fs';
+import fsp from 'fs/promises';
+import path5 from 'path';
 
 // sdk/plugin/node.ts
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path10, handler) {
-  ctx.registerRouter(normalizePath(path10), handler);
+function registerRouter(ctx, path6, handler) {
+  ctx.registerRouter(normalizePath(path6), handler);
 }
-function normalizePath(path10) {
-  if (path10.length === 0 || path10 === "/") return "/";
-  return path10;
+function normalizePath(path6) {
+  if (path6.length === 0 || path6 === "/") return "/";
+  return path6;
 }
 var PathActionError = class extends Error {
   code;
@@ -24,16 +24,16 @@ var PathActionError = class extends Error {
   }
 };
 async function resolveContainedActionPath(theaterPath, relativePath) {
-  if (path4.isAbsolute(relativePath)) throw new PathActionError("path_outside_theater");
-  const rootPath = path4.resolve(theaterPath);
-  const candidatePath = path4.resolve(rootPath, relativePath);
+  if (path5.isAbsolute(relativePath)) throw new PathActionError("path_outside_theater");
+  const rootPath = path5.resolve(theaterPath);
+  const candidatePath = path5.resolve(rootPath, relativePath);
   if (!isPathContained(rootPath, candidatePath)) throw new PathActionError("path_outside_theater");
   let realRootPath;
   let realCandidatePath;
   try {
     [realRootPath, realCandidatePath] = await Promise.all([
-      fs8.realpath(rootPath),
-      fs8.realpath(candidatePath)
+      fsp.realpath(rootPath),
+      fsp.realpath(candidatePath)
     ]);
   } catch (error) {
     const code = error.code;
@@ -51,11 +51,61 @@ async function resolveContainedActionPath(theaterPath, relativePath) {
   };
 }
 function isPathContained(rootPath, candidatePath) {
-  const relative = path4.relative(rootPath, candidatePath);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
+  const relative = path5.relative(rootPath, candidatePath);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relative);
+}
+var FileActionUnavailableError = class extends Error {
+  constructor() {
+    super("action_unavailable");
+    this.name = "FileActionUnavailableError";
+  }
+};
+var DEFAULT_REVEAL_DEPENDENCIES = {
+  platform: process.platform,
+  launch: spawnDetached
+};
+async function revealPath(theaterPath, relativePath, mode, dependencies = {}) {
+  const deps = { ...DEFAULT_REVEAL_DEPENDENCIES, ...dependencies };
+  const { realPath } = await resolveContainedActionPath(theaterPath, relativePath);
+  const command = resolveRevealCommand(deps.platform, mode, realPath);
+  if (!command) throw new FileActionUnavailableError();
+  try {
+    await deps.launch(command.file, command.args);
+  } catch (error) {
+    if (error.code === "ENOENT") throw new FileActionUnavailableError();
+    throw error;
+  }
+}
+function resolveRevealCommand(platform, mode, absolutePath) {
+  if (platform === "darwin") {
+    return mode === "reveal" ? { file: "open", args: ["-R", absolutePath] } : { file: "open", args: [absolutePath] };
+  }
+  if (platform === "linux") {
+    return {
+      file: "xdg-open",
+      args: [mode === "reveal" ? path5.dirname(absolutePath) : absolutePath]
+    };
+  }
+  if (platform === "win32") {
+    return mode === "reveal" ? { file: "explorer", args: [`/select,${absolutePath}`] } : { file: "explorer", args: [absolutePath] };
+  }
+  return null;
+}
+function spawnDetached(file, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(file, [...args], {
+      detached: true,
+      shell: false,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.once("error", reject);
+    child.once("spawn", () => {
+      child.unref();
+      resolve();
+    });
+  });
 }
-
-// ../fleet-plugins/file-explorer/server/clipboard.ts
 var ClipboardUnavailableError = class extends Error {
   constructor() {
     super("clipboard_unavailable");
@@ -67,13 +117,13 @@ var LINUX_CLIPBOARD_TOOLS = [
   { name: "xclip", args: ["-selection", "clipboard"] },
   { name: "xsel", args: ["--clipboard", "--input"] }
 ];
-var DEFAULT_DEPENDENCIES = {
+var DEFAULT_CLIPBOARD_ACTION_DEPENDENCIES = {
   platform: process.platform,
   findExecutable: findExecutableOnPath,
   runWithInput: execFileWithInput
 };
 async function copyPathToClipboard(theaterPath, relativePath, dependencies = {}) {
-  const deps = { ...DEFAULT_DEPENDENCIES, ...dependencies };
+  const deps = { ...DEFAULT_CLIPBOARD_ACTION_DEPENDENCIES, ...dependencies };
   const { logicalPath } = await resolveContainedActionPath(theaterPath, relativePath);
   const command = await resolveClipboardCommand(deps.platform, deps.findExecutable);
   if (!command) throw new ClipboardUnavailableError();
@@ -96,11 +146,11 @@ async function resolveClipboardCommand(platform, findExecutable = findExecutable
 }
 async function findExecutableOnPath(name) {
   const rawPath = process.env.PATH ?? "";
-  for (const directory of rawPath.split(path4.delimiter)) {
+  for (const directory of rawPath.split(path5.delimiter)) {
     if (!directory) continue;
-    const candidate = path4.join(directory, name);
+    const candidate = path5.join(directory, name);
     try {
-      await fs8.access(candidate, constants.X_OK);
+      await fsp.access(candidate, constants.X_OK);
       return candidate;
     } catch {
     }
@@ -186,14 +236,14 @@ var EXT_LANG_MAP = {
   ".txt": "plaintext"
 };
 async function readFileForTheater(theaterPath, relativePath) {
-  const resolved = path4.resolve(theaterPath, relativePath);
+  const resolved = path5.resolve(theaterPath, relativePath);
   if (!isWithinRoot(resolved, theaterPath)) throw new FileReadError("path_outside_theater");
   let realResolved;
   let realRoot;
   try {
     [realResolved, realRoot] = await Promise.all([
-      fs3.promises.realpath(resolved),
-      fs3.promises.realpath(theaterPath)
+      fs2.promises.realpath(resolved),
+      fs2.promises.realpath(theaterPath)
     ]);
   } catch (error) {
     const code = error.code;
@@ -203,7 +253,7 @@ async function readFileForTheater(theaterPath, relativePath) {
   if (!isWithinRoot(realResolved, realRoot)) throw new FileReadError("path_outside_theater");
   let stat;
   try {
-    stat = await fs3.promises.stat(realResolved);
+    stat = await fs2.promises.stat(realResolved);
   } catch (error) {
     const code = error.code;
     if (code === "EACCES" || code === "EPERM") throw new FileReadError("forbidden");
@@ -211,29 +261,29 @@ async function readFileForTheater(theaterPath, relativePath) {
   }
   if (!stat.isFile()) throw new FileReadError("not_a_file");
   if (stat.size > FILE_SIZE_CAP) {
-    const fd = await fs3.promises.open(realResolved, "r");
+    const fd = await fs2.promises.open(realResolved, "r");
     const buffer2 = Buffer.alloc(FILE_SIZE_CAP);
     const { bytesRead } = await fd.read(buffer2, 0, FILE_SIZE_CAP, 0);
     await fd.close();
     const chunk = buffer2.subarray(0, bytesRead);
     if (isBinaryBuffer(chunk)) throw new FileReadError("binary_file");
     return {
-      relativePath: path4.relative(realRoot, realResolved),
+      relativePath: path5.relative(realRoot, realResolved),
       content: chunk.toString("utf8"),
       lang: detectLang(realResolved),
       truncated: true
     };
   }
-  const buffer = await fs3.promises.readFile(realResolved);
+  const buffer = await fs2.promises.readFile(realResolved);
   if (isBinaryBuffer(buffer)) throw new FileReadError("binary_file");
   return {
-    relativePath: path4.relative(realRoot, realResolved),
+    relativePath: path5.relative(realRoot, realResolved),
     content: buffer.toString("utf8"),
     lang: detectLang(realResolved)
   };
 }
 function isWithinRoot(resolved, root) {
-  const normalizedRoot = root.endsWith(path4.sep) ? root : root + path4.sep;
+  const normalizedRoot = root.endsWith(path5.sep) ? root : root + path5.sep;
   return resolved === root || resolved.startsWith(normalizedRoot);
 }
 function isBinaryBuffer(buffer) {
@@ -246,605 +296,646 @@ function isBinaryBuffer(buffer) {
   return nulCount / checkLen > BINARY_NUL_THRESHOLD;
 }
 function detectLang(filePath) {
-  const ext = path4.extname(filePath).toLowerCase();
+  const ext = path5.extname(filePath).toLowerCase();
   return EXT_LANG_MAP[ext] ?? "plaintext";
 }
-var FolderBrowserError = class extends Error {
+var ImageServeError = class extends Error {
   code;
   constructor(code) {
     super(code);
-    this.name = "FolderBrowserError";
+    this.name = "ImageServeError";
     this.code = code;
   }
 };
-var DIRECTORY_ENTRY_CAP = 500;
-async function listTheaterContents(theaterPath, relativePath, deps = {}) {
-  const opendir = deps.opendir ?? fs3.promises.opendir;
-  const stat = deps.stat ?? fs3.promises.stat;
-  const targetAbs = path4.resolve(theaterPath, relativePath);
-  const normalizedRoot = theaterPath.endsWith(path4.sep) ? theaterPath : theaterPath + path4.sep;
-  if (targetAbs !== theaterPath && !targetAbs.startsWith(normalizedRoot)) {
-    throw new FolderBrowserError("forbidden");
-  }
+var IMAGE_SIZE_CAP = 16 * 1024 * 1024;
+var MIME_ALLOWLIST = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif"
+};
+var IMAGE_SECURITY_HEADERS = {
+  "X-Content-Type-Options": "nosniff",
+  "Referrer-Policy": "no-referrer",
+  "Cache-Control": "private, no-store"
+};
+async function readImageForTheater(theaterPath, relativePath) {
+  const resolved = path5.resolve(theaterPath, relativePath);
+  if (!isWithinRoot2(resolved, theaterPath)) throw new ImageServeError("path_outside_theater");
+  const ext = path5.extname(resolved).toLowerCase();
+  const mimeType = MIME_ALLOWLIST[ext];
+  if (!mimeType) throw new ImageServeError("mime_not_allowed");
+  let realResolved;
   let realRoot;
-  let realTargetAbs;
   try {
-    [realRoot, realTargetAbs] = await Promise.all([
-      fs3.promises.realpath(theaterPath),
-      fs3.promises.realpath(targetAbs)
+    [realResolved, realRoot] = await Promise.all([
+      fs2.promises.realpath(resolved),
+      fs2.promises.realpath(theaterPath)
     ]);
   } catch (error) {
-    throw mapFsError(error);
-  }
-  const realNormalizedRoot = realRoot.endsWith(path4.sep) ? realRoot : realRoot + path4.sep;
-  if (realTargetAbs !== realRoot && !realTargetAbs.startsWith(realNormalizedRoot)) {
-    throw new FolderBrowserError("forbidden");
+    const code = error.code;
+    if (code === "EACCES" || code === "EPERM") throw new ImageServeError("forbidden");
+    throw new ImageServeError("not_found");
   }
-  const targetStat = await statDirectory(realTargetAbs, stat);
-  if (!targetStat.isDirectory()) throw new FolderBrowserError("invalid_path");
-  const entries = [];
-  const truncated = await collectContentsEntries(realTargetAbs, realRoot, opendir, stat, entries);
-  entries.sort((a, b) => {
-    if (a.kind !== b.kind) return a.kind === "dir" ? -1 : 1;
-    return a.name.localeCompare(b.name);
-  });
-  const rel = path4.relative(realRoot, realTargetAbs);
-  const parentRel = rel === "" ? null : path4.relative(realRoot, path4.dirname(realTargetAbs));
-  return {
-    relativePath: rel,
-    parentRelativePath: parentRel === "" ? null : parentRel ?? null,
-    entries,
-    ...truncated ? { truncated: true } : {}
-  };
-}
-async function statDirectory(targetPath, stat) {
+  if (!isWithinRoot2(realResolved, realRoot)) throw new ImageServeError("path_outside_theater");
+  let stat;
   try {
-    return await stat(targetPath);
+    stat = await fs2.promises.stat(realResolved);
   } catch (error) {
-    throw mapFsError(error);
+    const code = error.code;
+    if (code === "EACCES" || code === "EPERM") throw new ImageServeError("forbidden");
+    throw new ImageServeError("not_found");
   }
+  if (!stat.isFile()) throw new ImageServeError("not_a_file");
+  if (stat.size > IMAGE_SIZE_CAP) throw new ImageServeError("size_exceeded");
+  const buffer = await fs2.promises.readFile(realResolved);
+  return { mimeType, buffer };
 }
-async function collectContentsEntries(targetPath, theaterPath, opendir, stat, entries) {
-  const directory = await openDirectory(targetPath, opendir);
-  try {
-    let dirent = await directory.read();
-    while (dirent !== null) {
-      if (entries.length >= DIRECTORY_ENTRY_CAP) return true;
-      const entry = await toContentsEntry(targetPath, theaterPath, dirent, stat);
-      if (entry !== null) entries.push(entry);
-      dirent = await directory.read();
-    }
-    return false;
-  } catch (error) {
-    throw mapFsError(error);
-  } finally {
-    await directory.close();
-  }
+function writeImageResponse(res, result) {
+  res.writeHead(200, {
+    ...IMAGE_SECURITY_HEADERS,
+    "Content-Type": result.mimeType,
+    "Content-Length": result.buffer.length
+  });
+  res.end(result.buffer);
 }
-async function openDirectory(targetPath, opendir) {
-  try {
-    return await opendir(targetPath, { bufferSize: DIRECTORY_ENTRY_CAP + 1 });
-  } catch (error) {
-    throw mapFsError(error);
-  }
+function isWithinRoot2(resolved, root) {
+  const normalizedRoot = root.endsWith(path5.sep) ? root : root + path5.sep;
+  return resolved === root || resolved.startsWith(normalizedRoot);
 }
-async function toContentsEntry(targetPath, theaterPath, dirent, stat) {
-  const entryPath = path4.join(targetPath, dirent.name);
-  const rel = path4.relative(theaterPath, entryPath);
-  if (dirent.isDirectory()) return { name: dirent.name, relativePath: rel, kind: "dir" };
-  if (dirent.isFile()) return { name: dirent.name, relativePath: rel, kind: "file" };
-  if (dirent.isSymbolicLink()) {
-    try {
-      const realEntryPath = await fs3.promises.realpath(entryPath);
-      const realNormalizedRoot = theaterPath.endsWith(path4.sep) ? theaterPath : theaterPath + path4.sep;
-      if (realEntryPath !== theaterPath && !realEntryPath.startsWith(realNormalizedRoot)) return null;
-      const s = await stat(realEntryPath);
-      if (s.isDirectory()) return { name: dirent.name, relativePath: rel, kind: "dir" };
-      if (s.isFile()) return { name: dirent.name, relativePath: rel, kind: "file" };
-    } catch {
-      return null;
+var DEBOUNCE_MS = 200;
+var LINUX_DIRECTORY_WATCH_CAP = 1024;
+var watcherRegistry = createWatcherRegistry();
+function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs2.watch(p, opts, (ev, fn) => cb(ev, typeof fn === "string" ? fn : null)), debounceMs = DEBOUNCE_MS, platform = process.platform) {
+  const entries = /* @__PURE__ */ new Map();
+  function scheduleChange(entry, relDir) {
+    const pending = entry.debounceTimers.get(relDir);
+    if (pending) clearTimeout(pending);
+    entry.debounceTimers.set(
+      relDir,
+      setTimeout(() => {
+        entry.debounceTimers.delete(relDir);
+        for (const sub of entry.subscribers) sub(relDir);
+      }, debounceMs)
+    );
+  }
+  function closeEntry(entry) {
+    for (const timer of entry.debounceTimers.values()) clearTimeout(timer);
+    entry.debounceTimers.clear();
+    for (const watcher of entry.watchers.values()) {
+      try {
+        watcher.close();
+      } catch {
+      }
     }
+    entry.watchers.clear();
+    entry.identityChecks.clear();
+    entry.pendingDirectories.clear();
   }
-  return null;
-}
-function mapFsError(error) {
-  const code = error.code;
-  if (code === "EACCES" || code === "EPERM") return new FolderBrowserError("forbidden");
-  if (code === "ENOENT" || code === "ENOTDIR") return new FolderBrowserError("not_found");
-  return new FolderBrowserError("invalid_path");
-}
-var GitStatusPathError = class extends Error {
-  code;
-  constructor(code) {
-    super(code);
-    this.name = "GitStatusPathError";
-    this.code = code;
+  async function rearmPendingDirectories(theaterId, entry) {
+    entry.rearmRequested = true;
+    if (entry.rearmRunning) return;
+    entry.rearmRunning = true;
+    try {
+      while (entry.rearmRequested) {
+        entry.rearmRequested = false;
+        for (const relativePath of entry.pendingDirectories) {
+          const target = await resolveTrackedDirectory(entry.theaterPath, relativePath);
+          if (!target) continue;
+          if (entries.get(theaterId) !== entry || !entry.pendingDirectories.has(relativePath) || entry.watchers.has(relativePath) || entry.watchers.size >= LINUX_DIRECTORY_WATCH_CAP) continue;
+          try {
+            startWatcher(theaterId, entry, relativePath, target.path, target.identity);
+            entry.pendingDirectories.delete(relativePath);
+            scheduleChange(entry, relativePath);
+          } catch {
+            for (const notify of entry.stateSubscribers) notify("degraded");
+          }
+        }
+      }
+    } finally {
+      entry.rearmRunning = false;
+    }
   }
-};
-var GIT_TIMEOUT_MS = 5e3;
-var GIT_MAX_BUFFER = 8 * 1024 * 1024;
-var GIT_STATUS_CAP = 1e4;
-var UNMERGED_STATUS_PAIRS = /* @__PURE__ */ new Set(["UU", "UD", "DU", "AA", "AU", "UA", "DD"]);
-async function readTheaterGitStatus(theaterPath, deps = {}) {
-  const realpath = deps.realpath ?? ((target) => fs8.realpath(target));
-  const execGit = deps.execGit ?? executeGit;
-  let theaterRootAbs;
-  try {
-    theaterRootAbs = await realpath(path4.resolve(theaterPath));
-  } catch (error) {
-    throw mapFsError2(error);
+  function invalidateWatcherTree(entry, watchKey) {
+    const descendantPrefix = watchKey + path5.sep;
+    for (const [candidateKey, candidateWatcher] of entry.watchers) {
+      if (candidateKey !== watchKey && !candidateKey.startsWith(descendantPrefix)) continue;
+      entry.watchers.delete(candidateKey);
+      entry.identityChecks.delete(candidateKey);
+      entry.pendingDirectories.add(candidateKey);
+      try {
+        candidateWatcher.close();
+      } catch {
+      }
+    }
   }
-  try {
-    const options = {
-      env: sanitizeGitEnvironment(deps.environment ?? process.env),
-      killSignal: "SIGKILL",
-      maxBuffer: GIT_MAX_BUFFER,
-      timeout: GIT_TIMEOUT_MS
-    };
-    const gitArgs = (args) => [
-      "-c",
-      "core.fsmonitor=false",
-      "--no-optional-locks",
-      "-C",
-      theaterRootAbs,
-      ...args
-    ];
-    const [prefixOutput, statusOutput] = await Promise.all([
-      execGit(gitArgs(["rev-parse", "--show-prefix"]), options),
-      execGit(gitArgs(["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."]), options)
-    ]);
-    const prefix = stripTrailingLineBreak(prefixOutput);
-    const statuses = scopeGitStatusesToTheater(parseGitStatusPorcelainV1Z(statusOutput), prefix);
-    const truncated = statuses.length > GIT_STATUS_CAP;
-    return {
-      ok: true,
-      gitAvailable: true,
-      statuses: statuses.slice(0, GIT_STATUS_CAP),
-      ...truncated ? { truncated: true } : {}
+  function startWatcher(theaterId, entry, watchKey, watchPath, watchIdentity) {
+    let identityCheckRunning = false;
+    let identityCheckRequested = false;
+    let activeWatcher = null;
+    const lexicalWatchPath = path5.resolve(entry.theaterPath, watchKey);
+    const checkDirectoryIdentity = async (expectedWatcher) => {
+      identityCheckRequested = true;
+      if (identityCheckRunning || !watchIdentity) return;
+      identityCheckRunning = true;
+      try {
+        while (identityCheckRequested) {
+          identityCheckRequested = false;
+          let replaced = false;
+          try {
+            const stats = await fs2.promises.stat(lexicalWatchPath);
+            replaced = stats.dev !== watchIdentity.device || stats.ino !== watchIdentity.inode;
+          } catch (error) {
+            replaced = error.code === "ENOENT";
+          }
+          if (entry.watchers.get(watchKey) !== expectedWatcher) return;
+          if (!replaced) continue;
+          invalidateWatcherTree(entry, watchKey);
+          await rearmPendingDirectories(theaterId, entry);
+          return;
+        }
+      } finally {
+        identityCheckRunning = false;
+      }
     };
-  } catch {
-    return { ok: true, gitAvailable: false, statuses: [] };
+    const watcher = watcherFactory(watchPath, { recursive: entry.recursive }, (event, filename) => {
+      const currentWatcher = activeWatcher;
+      if (!currentWatcher || entry.watchers.get(watchKey) !== currentWatcher) return;
+      scheduleChange(entry, entry.recursive ? computeRelDir(filename) : watchKey);
+      if (!entry.recursive && event === "rename") {
+        if (watchKey !== "" && watchIdentity) void checkDirectoryIdentity(currentWatcher);
+        if (filename) {
+          const changedChildKey = path5.join(watchKey, filename);
+          entry.identityChecks.get(changedChildKey)?.();
+        }
+      }
+      if (!entry.recursive && entry.pendingDirectories.size > 0) {
+        void rearmPendingDirectories(theaterId, entry);
+      }
+    });
+    activeWatcher = watcher;
+    entry.watchers.set(watchKey, watcher);
+    if (watchIdentity) {
+      entry.identityChecks.set(watchKey, () => {
+        const currentWatcher = activeWatcher;
+        if (currentWatcher) void checkDirectoryIdentity(currentWatcher);
+      });
+    }
+    watcher.on("error", () => {
+      if (entry.watchers.get(watchKey) !== watcher) return;
+      try {
+        watcher.close();
+      } catch {
+      }
+      entry.watchers.delete(watchKey);
+      entry.identityChecks.delete(watchKey);
+      if (watchKey === "") {
+        closeEntry(entry);
+        if (entries.get(theaterId) === entry) entries.delete(theaterId);
+      } else {
+        const pending = entry.debounceTimers.get(watchKey);
+        if (pending) clearTimeout(pending);
+        entry.debounceTimers.delete(watchKey);
+      }
+      for (const notify of entry.stateSubscribers) notify("degraded");
+    });
   }
-}
-function parseGitStatusPorcelainV1Z(output) {
-  const records = output.split("\0");
-  const statuses = [];
-  for (let index = 0; index < records.length; index += 1) {
-    const record = records[index];
-    if (!record || record.length < 4 || record[2] !== " ") continue;
-    const indexStatus = record[0] ?? " ";
-    const worktreeStatus = record[1] ?? " ";
-    const statusPair = `${indexStatus}${worktreeStatus}`;
-    const gitPath = record.slice(3);
-    const isRenameOrCopy = statusPair.includes("R") || statusPair.includes("C");
-    const status = classifyGitStatus(statusPair);
-    if (status && gitPath) statuses.push({ gitPath, status });
-    if (isRenameOrCopy && index + 1 < records.length) index += 1;
+  function makeUnsubscribe(theaterId, onChange, onState, entry) {
+    let called = false;
+    return () => {
+      if (called) return;
+      called = true;
+      entry.subscribers.delete(onChange);
+      entry.stateSubscribers.delete(onState);
+      entry.subscriberCount--;
+      if (entry.subscriberCount <= 0) {
+        closeEntry(entry);
+        if (entries.get(theaterId) === entry) entries.delete(theaterId);
+      }
+    };
   }
-  return statuses;
-}
-function scopeGitStatusesToTheater(entries, prefix, separator = path4.sep) {
-  const statuses = [];
-  for (const entry of entries) {
-    if (prefix && !entry.gitPath.startsWith(prefix)) continue;
-    const relativeGitPath = prefix ? entry.gitPath.slice(prefix.length) : entry.gitPath;
-    const segments = relativeGitPath.split("/");
-    if (relativeGitPath === "" || relativeGitPath.startsWith("/") || segments.some((segment) => segment === "" || segment === "." || segment === "..")) continue;
-    const relativePath = segments.join(separator);
-    if (path4.isAbsolute(relativePath)) continue;
-    statuses.push({ path: relativePath, status: entry.status });
+  function subscribe(theaterId, theaterPath, onChange, onState) {
+    const existing = entries.get(theaterId);
+    if (existing) {
+      existing.subscribers.add(onChange);
+      existing.stateSubscribers.add(onState);
+      existing.subscriberCount++;
+      onState("watching");
+      return makeUnsubscribe(theaterId, onChange, onState, existing);
+    }
+    const entry = {
+      // Linux의 recursive fs.watch fallback은 구독 시 전체 트리를 동기 순회한다.
+      // 대신 root와 실제로 조회된 디렉터리만 개별 비재귀 watcher로 추적한다.
+      theaterPath,
+      recursive: platform !== "linux",
+      watchers: /* @__PURE__ */ new Map(),
+      identityChecks: /* @__PURE__ */ new Map(),
+      pendingDirectories: /* @__PURE__ */ new Set(),
+      subscribers: /* @__PURE__ */ new Set([onChange]),
+      stateSubscribers: /* @__PURE__ */ new Set([onState]),
+      subscriberCount: 1,
+      debounceTimers: /* @__PURE__ */ new Map(),
+      rearmRunning: false,
+      rearmRequested: false
+    };
+    try {
+      startWatcher(theaterId, entry, "", theaterPath);
+    } catch {
+      onState("degraded");
+      return () => {
+      };
+    }
+    entries.set(theaterId, entry);
+    onState("watching");
+    return makeUnsubscribe(theaterId, onChange, onState, entry);
   }
-  return statuses;
-}
-function classifyGitStatus(statusPair) {
-  if (statusPair === "??") return "untracked";
-  if (UNMERGED_STATUS_PAIRS.has(statusPair)) return "modified";
-  if (statusPair.includes("D")) return "deleted";
-  if ([...statusPair].some((status) => status === "A" || status === "M" || status === "R" || status === "C" || status === "T")) {
-    return "modified";
+  async function trackDirectory(theaterId, theaterPath, relativePath) {
+    const entry = entries.get(theaterId);
+    if (!entry || entry.recursive || relativePath === "" || entry.watchers.has(relativePath)) return;
+    if (entry.watchers.size >= LINUX_DIRECTORY_WATCH_CAP) {
+      for (const notify of entry.stateSubscribers) notify("degraded");
+      return;
+    }
+    const target = await resolveTrackedDirectory(theaterPath, relativePath);
+    if (!target) return;
+    if (entries.get(theaterId) !== entry || entry.watchers.has(relativePath) || entry.watchers.size >= LINUX_DIRECTORY_WATCH_CAP) return;
+    try {
+      startWatcher(theaterId, entry, relativePath, target.path, target.identity);
+      entry.pendingDirectories.delete(relativePath);
+    } catch {
+      for (const notify of entry.stateSubscribers) notify("degraded");
+    }
   }
-  return null;
-}
-function executeGit(args, options) {
-  return new Promise((resolve, reject) => {
-    execFile(
-      "git",
-      [...args],
-      {
-        encoding: "utf8",
-        env: options.env,
-        killSignal: options.killSignal,
-        maxBuffer: options.maxBuffer,
-        shell: false,
-        timeout: options.timeout,
-        windowsHide: true
-      },
-      (error, stdout) => {
-        if (error) {
-          reject(error);
-          return;
-        }
-        resolve(stdout);
-      }
-    );
-  });
+  return { subscribe, trackDirectory };
 }
-function sanitizeGitEnvironment(environment) {
-  const sanitized = {};
-  for (const [key, value] of Object.entries(environment)) {
-    if (key.toUpperCase().startsWith("GIT_")) continue;
-    if (value !== void 0) sanitized[key] = value;
+async function resolveTrackedDirectory(theaterPath, relativePath) {
+  const resolvedRoot = path5.resolve(theaterPath);
+  const targetPath = path5.resolve(resolvedRoot, relativePath);
+  if (!isWithinRoot3(targetPath, resolvedRoot)) return null;
+  try {
+    const [realRoot, realTarget] = await Promise.all([
+      fs2.promises.realpath(theaterPath),
+      fs2.promises.realpath(targetPath)
+    ]);
+    if (!isWithinRoot3(realTarget, realRoot)) return null;
+    const stats = await fs2.promises.stat(realTarget);
+    if (!stats.isDirectory()) return null;
+    return {
+      path: realTarget,
+      identity: { device: stats.dev, inode: stats.ino }
+    };
+  } catch {
+    return null;
   }
-  sanitized.GIT_OPTIONAL_LOCKS = "0";
-  return sanitized;
 }
-function stripTrailingLineBreak(output) {
-  if (!output.endsWith("\n")) return output;
-  const withoutLineFeed = output.slice(0, -1);
-  return withoutLineFeed.endsWith("\r") ? withoutLineFeed.slice(0, -1) : withoutLineFeed;
+function isWithinRoot3(candidate, root) {
+  const normalizedRoot = root.endsWith(path5.sep) ? root : root + path5.sep;
+  return candidate === root || candidate.startsWith(normalizedRoot);
 }
-function mapFsError2(error) {
-  const code = error.code;
-  if (code === "EACCES" || code === "EPERM") return new GitStatusPathError("forbidden");
-  if (code === "ENOENT" || code === "ENOTDIR") return new GitStatusPathError("not_found");
-  return new GitStatusPathError("invalid_path");
+function computeRelDir(filename) {
+  if (!filename) return "";
+  const lastSep = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+  if (lastSep <= 0) return "";
+  return filename.slice(0, lastSep);
 }
-var ImageServeError = class extends Error {
+
+// ../fleet-plugins/file-explorer/server/tree-services.ts
+var FolderBrowserError = class extends Error {
   code;
   constructor(code) {
     super(code);
-    this.name = "ImageServeError";
+    this.name = "FolderBrowserError";
     this.code = code;
   }
 };
-var IMAGE_SIZE_CAP = 16 * 1024 * 1024;
-var MIME_ALLOWLIST = {
-  ".png": "image/png",
-  ".jpg": "image/jpeg",
-  ".jpeg": "image/jpeg",
-  ".webp": "image/webp",
-  ".gif": "image/gif"
-};
-var IMAGE_SECURITY_HEADERS = {
-  "X-Content-Type-Options": "nosniff",
-  "Referrer-Policy": "no-referrer",
-  "Cache-Control": "private, no-store"
-};
-async function readImageForTheater(theaterPath, relativePath) {
-  const resolved = path4.resolve(theaterPath, relativePath);
-  if (!isWithinRoot2(resolved, theaterPath)) throw new ImageServeError("path_outside_theater");
-  const ext = path4.extname(resolved).toLowerCase();
-  const mimeType = MIME_ALLOWLIST[ext];
-  if (!mimeType) throw new ImageServeError("mime_not_allowed");
-  let realResolved;
-  let realRoot;
-  try {
-    [realResolved, realRoot] = await Promise.all([
-      fs3.promises.realpath(resolved),
-      fs3.promises.realpath(theaterPath)
-    ]);
-  } catch (error) {
-    const code = error.code;
-    if (code === "EACCES" || code === "EPERM") throw new ImageServeError("forbidden");
-    throw new ImageServeError("not_found");
+var DIRECTORY_ENTRY_CAP = 500;
+async function listTheaterContents(theaterPath, relativePath, deps = {}) {
+  const opendir = deps.opendir ?? fs2.promises.opendir;
+  const stat = deps.stat ?? fs2.promises.stat;
+  const targetAbs = path5.resolve(theaterPath, relativePath);
+  const normalizedRoot = theaterPath.endsWith(path5.sep) ? theaterPath : theaterPath + path5.sep;
+  if (targetAbs !== theaterPath && !targetAbs.startsWith(normalizedRoot)) {
+    throw new FolderBrowserError("forbidden");
   }
-  if (!isWithinRoot2(realResolved, realRoot)) throw new ImageServeError("path_outside_theater");
-  let stat;
+  let realRoot;
+  let realTargetAbs;
   try {
-    stat = await fs3.promises.stat(realResolved);
+    [realRoot, realTargetAbs] = await Promise.all([
+      fs2.promises.realpath(theaterPath),
+      fs2.promises.realpath(targetAbs)
+    ]);
   } catch (error) {
-    const code = error.code;
-    if (code === "EACCES" || code === "EPERM") throw new ImageServeError("forbidden");
-    throw new ImageServeError("not_found");
+    throw mapFolderBrowserFsError(error);
   }
-  if (!stat.isFile()) throw new ImageServeError("not_a_file");
-  if (stat.size > IMAGE_SIZE_CAP) throw new ImageServeError("size_exceeded");
-  const buffer = await fs3.promises.readFile(realResolved);
-  return { mimeType, buffer };
-}
-function writeImageResponse(res, result) {
-  res.writeHead(200, {
-    ...IMAGE_SECURITY_HEADERS,
-    "Content-Type": result.mimeType,
-    "Content-Length": result.buffer.length
+  const realNormalizedRoot = realRoot.endsWith(path5.sep) ? realRoot : realRoot + path5.sep;
+  if (realTargetAbs !== realRoot && !realTargetAbs.startsWith(realNormalizedRoot)) {
+    throw new FolderBrowserError("forbidden");
+  }
+  const targetStat = await statDirectory(realTargetAbs, stat);
+  if (!targetStat.isDirectory()) throw new FolderBrowserError("invalid_path");
+  const entries = [];
+  const truncated = await collectContentsEntries(realTargetAbs, realRoot, opendir, stat, entries);
+  entries.sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === "dir" ? -1 : 1;
+    return a.name.localeCompare(b.name);
   });
-  res.end(result.buffer);
-}
-function isWithinRoot2(resolved, root) {
-  const normalizedRoot = root.endsWith(path4.sep) ? root : root + path4.sep;
-  return resolved === root || resolved.startsWith(normalizedRoot);
+  const rel = path5.relative(realRoot, realTargetAbs);
+  const parentRel = rel === "" ? null : path5.relative(realRoot, path5.dirname(realTargetAbs));
+  return {
+    relativePath: rel,
+    parentRelativePath: parentRel === "" ? null : parentRel ?? null,
+    entries,
+    ...truncated ? { truncated: true } : {}
+  };
 }
-var FileActionUnavailableError = class extends Error {
-  constructor() {
-    super("action_unavailable");
-    this.name = "FileActionUnavailableError";
-  }
-};
-var DEFAULT_DEPENDENCIES2 = {
-  platform: process.platform,
-  launch: spawnDetached
-};
-async function revealPath(theaterPath, relativePath, mode, dependencies = {}) {
-  const deps = { ...DEFAULT_DEPENDENCIES2, ...dependencies };
-  const { realPath } = await resolveContainedActionPath(theaterPath, relativePath);
-  const command = resolveRevealCommand(deps.platform, mode, realPath);
-  if (!command) throw new FileActionUnavailableError();
+async function statDirectory(targetPath, stat) {
   try {
-    await deps.launch(command.file, command.args);
+    return await stat(targetPath);
   } catch (error) {
-    if (error.code === "ENOENT") throw new FileActionUnavailableError();
-    throw error;
+    throw mapFolderBrowserFsError(error);
   }
 }
-function resolveRevealCommand(platform, mode, absolutePath) {
-  if (platform === "darwin") {
-    return mode === "reveal" ? { file: "open", args: ["-R", absolutePath] } : { file: "open", args: [absolutePath] };
+async function collectContentsEntries(targetPath, theaterPath, opendir, stat, entries) {
+  const directory = await openDirectory(targetPath, opendir);
+  try {
+    let dirent = await directory.read();
+    while (dirent !== null) {
+      if (entries.length >= DIRECTORY_ENTRY_CAP) return true;
+      const entry = await toContentsEntry(targetPath, theaterPath, dirent, stat);
+      if (entry !== null) entries.push(entry);
+      dirent = await directory.read();
+    }
+    return false;
+  } catch (error) {
+    throw mapFolderBrowserFsError(error);
+  } finally {
+    await directory.close();
   }
-  if (platform === "linux") {
-    return {
-      file: "xdg-open",
-      args: [mode === "reveal" ? path4.dirname(absolutePath) : absolutePath]
-    };
+}
+async function openDirectory(targetPath, opendir) {
+  try {
+    return await opendir(targetPath, { bufferSize: DIRECTORY_ENTRY_CAP + 1 });
+  } catch (error) {
+    throw mapFolderBrowserFsError(error);
   }
-  if (platform === "win32") {
-    return mode === "reveal" ? { file: "explorer", args: [`/select,${absolutePath}`] } : { file: "explorer", args: [absolutePath] };
+}
+async function toContentsEntry(targetPath, theaterPath, dirent, stat) {
+  const entryPath = path5.join(targetPath, dirent.name);
+  const rel = path5.relative(theaterPath, entryPath);
+  if (dirent.isDirectory()) return { name: dirent.name, relativePath: rel, kind: "dir" };
+  if (dirent.isFile()) return { name: dirent.name, relativePath: rel, kind: "file" };
+  if (dirent.isSymbolicLink()) {
+    try {
+      const realEntryPath = await fs2.promises.realpath(entryPath);
+      const realNormalizedRoot = theaterPath.endsWith(path5.sep) ? theaterPath : theaterPath + path5.sep;
+      if (realEntryPath !== theaterPath && !realEntryPath.startsWith(realNormalizedRoot)) return null;
+      const s = await stat(realEntryPath);
+      if (s.isDirectory()) return { name: dirent.name, relativePath: rel, kind: "dir" };
+      if (s.isFile()) return { name: dirent.name, relativePath: rel, kind: "file" };
+    } catch {
+      return null;
+    }
   }
   return null;
 }
-function spawnDetached(file, args) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(file, [...args], {
-      detached: true,
-      shell: false,
-      stdio: "ignore",
-      windowsHide: true
-    });
-    child.once("error", reject);
-    child.once("spawn", () => {
-      child.unref();
-      resolve();
-    });
-  });
+function mapFolderBrowserFsError(error) {
+  const code = error.code;
+  if (code === "EACCES" || code === "EPERM") return new FolderBrowserError("forbidden");
+  if (code === "ENOENT" || code === "ENOTDIR") return new FolderBrowserError("not_found");
+  return new FolderBrowserError("invalid_path");
 }
-var DEBOUNCE_MS = 200;
-var LINUX_DIRECTORY_WATCH_CAP = 1024;
-var watcherRegistry = createWatcherRegistry();
-function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs3.watch(p, opts, (ev, fn) => cb(ev, typeof fn === "string" ? fn : null)), debounceMs = DEBOUNCE_MS, platform = process.platform) {
-  const entries = /* @__PURE__ */ new Map();
-  function scheduleChange(entry, relDir) {
-    const pending = entry.debounceTimers.get(relDir);
-    if (pending) clearTimeout(pending);
-    entry.debounceTimers.set(
-      relDir,
-      setTimeout(() => {
-        entry.debounceTimers.delete(relDir);
-        for (const sub of entry.subscribers) sub(relDir);
-      }, debounceMs)
-    );
+var GitStatusPathError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.name = "GitStatusPathError";
+    this.code = code;
   }
-  function closeEntry(entry) {
-    for (const timer of entry.debounceTimers.values()) clearTimeout(timer);
-    entry.debounceTimers.clear();
-    for (const watcher of entry.watchers.values()) {
-      try {
-        watcher.close();
-      } catch {
-      }
-    }
-    entry.watchers.clear();
-    entry.identityChecks.clear();
-    entry.pendingDirectories.clear();
+};
+var GIT_TIMEOUT_MS = 5e3;
+var GIT_MAX_BUFFER = 8 * 1024 * 1024;
+var GIT_STATUS_CAP = 1e4;
+var UNMERGED_STATUS_PAIRS = /* @__PURE__ */ new Set(["UU", "UD", "DU", "AA", "AU", "UA", "DD"]);
+async function readTheaterGitStatus(theaterPath, deps = {}) {
+  const realpath = deps.realpath ?? ((target) => fsp.realpath(target));
+  const execGit = deps.execGit ?? executeGit;
+  let theaterRootAbs;
+  try {
+    theaterRootAbs = await realpath(path5.resolve(theaterPath));
+  } catch (error) {
+    throw mapGitStatusFsError(error);
   }
-  async function rearmPendingDirectories(theaterId, entry) {
-    entry.rearmRequested = true;
-    if (entry.rearmRunning) return;
-    entry.rearmRunning = true;
-    try {
-      while (entry.rearmRequested) {
-        entry.rearmRequested = false;
-        for (const relativePath of entry.pendingDirectories) {
-          const target = await resolveTrackedDirectory(entry.theaterPath, relativePath);
-          if (!target) continue;
-          if (entries.get(theaterId) !== entry || !entry.pendingDirectories.has(relativePath) || entry.watchers.has(relativePath) || entry.watchers.size >= LINUX_DIRECTORY_WATCH_CAP) continue;
-          try {
-            startWatcher(theaterId, entry, relativePath, target.path, target.identity);
-            entry.pendingDirectories.delete(relativePath);
-            scheduleChange(entry, relativePath);
-          } catch {
-            for (const notify of entry.stateSubscribers) notify("degraded");
-          }
-        }
-      }
-    } finally {
-      entry.rearmRunning = false;
-    }
+  try {
+    const options = {
+      env: sanitizeGitEnvironment(deps.environment ?? process.env),
+      killSignal: "SIGKILL",
+      maxBuffer: GIT_MAX_BUFFER,
+      timeout: GIT_TIMEOUT_MS
+    };
+    const gitArgs = (args) => [
+      "-c",
+      "core.fsmonitor=false",
+      "--no-optional-locks",
+      "-C",
+      theaterRootAbs,
+      ...args
+    ];
+    const [prefixOutput, statusOutput] = await Promise.all([
+      execGit(gitArgs(["rev-parse", "--show-prefix"]), options),
+      execGit(gitArgs(["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."]), options)
+    ]);
+    const prefix = stripTrailingLineBreak(prefixOutput);
+    const statuses = scopeGitStatusesToTheater(parseGitStatusPorcelainV1Z(statusOutput), prefix);
+    const truncated = statuses.length > GIT_STATUS_CAP;
+    return {
+      ok: true,
+      gitAvailable: true,
+      statuses: statuses.slice(0, GIT_STATUS_CAP),
+      ...truncated ? { truncated: true } : {}
+    };
+  } catch {
+    return { ok: true, gitAvailable: false, statuses: [] };
   }
-  function invalidateWatcherTree(entry, watchKey) {
-    const descendantPrefix = watchKey + path4.sep;
-    for (const [candidateKey, candidateWatcher] of entry.watchers) {
-      if (candidateKey !== watchKey && !candidateKey.startsWith(descendantPrefix)) continue;
-      entry.watchers.delete(candidateKey);
-      entry.identityChecks.delete(candidateKey);
-      entry.pendingDirectories.add(candidateKey);
-      try {
-        candidateWatcher.close();
-      } catch {
-      }
-    }
+}
+function parseGitStatusPorcelainV1Z(output) {
+  const records = output.split("\0");
+  const statuses = [];
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record || record.length < 4 || record[2] !== " ") continue;
+    const indexStatus = record[0] ?? " ";
+    const worktreeStatus = record[1] ?? " ";
+    const statusPair = `${indexStatus}${worktreeStatus}`;
+    const gitPath = record.slice(3);
+    const isRenameOrCopy = statusPair.includes("R") || statusPair.includes("C");
+    const status = classifyGitStatus(statusPair);
+    if (status && gitPath) statuses.push({ gitPath, status });
+    if (isRenameOrCopy && index + 1 < records.length) index += 1;
   }
-  function startWatcher(theaterId, entry, watchKey, watchPath, watchIdentity) {
-    let identityCheckRunning = false;
-    let identityCheckRequested = false;
-    let activeWatcher = null;
-    const lexicalWatchPath = path4.resolve(entry.theaterPath, watchKey);
-    const checkDirectoryIdentity = async (expectedWatcher) => {
-      identityCheckRequested = true;
-      if (identityCheckRunning || !watchIdentity) return;
-      identityCheckRunning = true;
-      try {
-        while (identityCheckRequested) {
-          identityCheckRequested = false;
-          let replaced = false;
-          try {
-            const stats = await fs3.promises.stat(lexicalWatchPath);
-            replaced = stats.dev !== watchIdentity.device || stats.ino !== watchIdentity.inode;
-          } catch (error) {
-            replaced = error.code === "ENOENT";
-          }
-          if (entry.watchers.get(watchKey) !== expectedWatcher) return;
-          if (!replaced) continue;
-          invalidateWatcherTree(entry, watchKey);
-          await rearmPendingDirectories(theaterId, entry);
-          return;
-        }
-      } finally {
-        identityCheckRunning = false;
-      }
-    };
-    const watcher = watcherFactory(watchPath, { recursive: entry.recursive }, (event, filename) => {
-      const currentWatcher = activeWatcher;
-      if (!currentWatcher || entry.watchers.get(watchKey) !== currentWatcher) return;
-      scheduleChange(entry, entry.recursive ? computeRelDir(filename) : watchKey);
-      if (!entry.recursive && event === "rename") {
-        if (watchKey !== "" && watchIdentity) void checkDirectoryIdentity(currentWatcher);
-        if (filename) {
-          const changedChildKey = path4.join(watchKey, filename);
-          entry.identityChecks.get(changedChildKey)?.();
-        }
-      }
-      if (!entry.recursive && entry.pendingDirectories.size > 0) {
-        void rearmPendingDirectories(theaterId, entry);
-      }
-    });
-    activeWatcher = watcher;
-    entry.watchers.set(watchKey, watcher);
-    if (watchIdentity) {
-      entry.identityChecks.set(watchKey, () => {
-        const currentWatcher = activeWatcher;
-        if (currentWatcher) void checkDirectoryIdentity(currentWatcher);
-      });
-    }
-    watcher.on("error", () => {
-      if (entry.watchers.get(watchKey) !== watcher) return;
-      try {
-        watcher.close();
-      } catch {
-      }
-      entry.watchers.delete(watchKey);
-      entry.identityChecks.delete(watchKey);
-      if (watchKey === "") {
-        closeEntry(entry);
-        if (entries.get(theaterId) === entry) entries.delete(theaterId);
-      } else {
-        const pending = entry.debounceTimers.get(watchKey);
-        if (pending) clearTimeout(pending);
-        entry.debounceTimers.delete(watchKey);
-      }
-      for (const notify of entry.stateSubscribers) notify("degraded");
-    });
+  return statuses;
+}
+function scopeGitStatusesToTheater(entries, prefix, separator = path5.sep) {
+  const statuses = [];
+  for (const entry of entries) {
+    if (prefix && !entry.gitPath.startsWith(prefix)) continue;
+    const relativeGitPath = prefix ? entry.gitPath.slice(prefix.length) : entry.gitPath;
+    const segments = relativeGitPath.split("/");
+    if (relativeGitPath === "" || relativeGitPath.startsWith("/") || segments.some((segment) => segment === "" || segment === "." || segment === "..")) continue;
+    const relativePath = segments.join(separator);
+    if (path5.isAbsolute(relativePath)) continue;
+    statuses.push({ path: relativePath, status: entry.status });
   }
-  function makeUnsubscribe(theaterId, onChange, onState, entry) {
-    let called = false;
-    return () => {
-      if (called) return;
-      called = true;
-      entry.subscribers.delete(onChange);
-      entry.stateSubscribers.delete(onState);
-      entry.subscriberCount--;
-      if (entry.subscriberCount <= 0) {
-        closeEntry(entry);
-        if (entries.get(theaterId) === entry) entries.delete(theaterId);
+  return statuses;
+}
+function classifyGitStatus(statusPair) {
+  if (statusPair === "??") return "untracked";
+  if (UNMERGED_STATUS_PAIRS.has(statusPair)) return "modified";
+  if (statusPair.includes("D")) return "deleted";
+  if ([...statusPair].some((status) => status === "A" || status === "M" || status === "R" || status === "C" || status === "T")) {
+    return "modified";
+  }
+  return null;
+}
+function executeGit(args, options) {
+  return new Promise((resolve, reject) => {
+    execFile(
+      "git",
+      [...args],
+      {
+        encoding: "utf8",
+        env: options.env,
+        killSignal: options.killSignal,
+        maxBuffer: options.maxBuffer,
+        shell: false,
+        timeout: options.timeout,
+        windowsHide: true
+      },
+      (error, stdout) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve(stdout);
       }
-    };
+    );
+  });
+}
+function sanitizeGitEnvironment(environment) {
+  const sanitized = {};
+  for (const [key, value] of Object.entries(environment)) {
+    const normalizedKey = key.toUpperCase();
+    if (normalizedKey.startsWith("GIT_") || normalizedKey === "LC_ALL" || normalizedKey === "SSH_ASKPASS" || normalizedKey === "SSH_ASKPASS_REQUIRE") continue;
+    if (value !== void 0) sanitized[key] = value;
   }
-  function subscribe(theaterId, theaterPath, onChange, onState) {
-    const existing = entries.get(theaterId);
-    if (existing) {
-      existing.subscribers.add(onChange);
-      existing.stateSubscribers.add(onState);
-      existing.subscriberCount++;
-      onState("watching");
-      return makeUnsubscribe(theaterId, onChange, onState, existing);
-    }
-    const entry = {
-      // Linux의 recursive fs.watch fallback은 구독 시 전체 트리를 동기 순회한다.
-      // 대신 root와 실제로 조회된 디렉터리만 개별 비재귀 watcher로 추적한다.
-      theaterPath,
-      recursive: platform !== "linux",
-      watchers: /* @__PURE__ */ new Map(),
-      identityChecks: /* @__PURE__ */ new Map(),
-      pendingDirectories: /* @__PURE__ */ new Set(),
-      subscribers: /* @__PURE__ */ new Set([onChange]),
-      stateSubscribers: /* @__PURE__ */ new Set([onState]),
-      subscriberCount: 1,
-      debounceTimers: /* @__PURE__ */ new Map(),
-      rearmRunning: false,
-      rearmRequested: false
-    };
+  sanitized.GIT_OPTIONAL_LOCKS = "0";
+  sanitized.GIT_TERMINAL_PROMPT = "0";
+  sanitized.GIT_ALLOW_PROTOCOL = "ssh:git:http:https:file";
+  sanitized.LC_ALL = "C";
+  return sanitized;
+}
+function stripTrailingLineBreak(output) {
+  if (!output.endsWith("\n")) return output;
+  const withoutLineFeed = output.slice(0, -1);
+  return withoutLineFeed.endsWith("\r") ? withoutLineFeed.slice(0, -1) : withoutLineFeed;
+}
+function mapGitStatusFsError(error) {
+  const code = error.code;
+  if (code === "EACCES" || code === "EPERM") return new GitStatusPathError("forbidden");
+  if (code === "ENOENT" || code === "ENOTDIR") return new GitStatusPathError("not_found");
+  return new GitStatusPathError("invalid_path");
+}
+var SEARCH_DIRECTORY_CAP = 500;
+var SEARCH_ENTRY_CAP = 25e3;
+async function searchTheaterFiles(theaterPath, query, limit) {
+  const realRoot = await fsp.realpath(theaterPath);
+  const tokens = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  const pending = [{ absolutePath: realRoot, relativePath: "" }];
+  const visited = /* @__PURE__ */ new Set();
+  const matches = [];
+  let directoryCount = 0;
+  let entryCount = 0;
+  while (pending.length > 0 && directoryCount < SEARCH_DIRECTORY_CAP && entryCount < SEARCH_ENTRY_CAP) {
+    const directory = pending.shift();
+    if (!directory || visited.has(directory.absolutePath)) continue;
+    visited.add(directory.absolutePath);
+    directoryCount += 1;
+    let entries;
     try {
-      startWatcher(theaterId, entry, "", theaterPath);
+      entries = await fsp.readdir(directory.absolutePath, { withFileTypes: true });
     } catch {
-      onState("degraded");
-      return () => {
-      };
-    }
-    entries.set(theaterId, entry);
-    onState("watching");
-    return makeUnsubscribe(theaterId, onChange, onState, entry);
-  }
-  async function trackDirectory(theaterId, theaterPath, relativePath) {
-    const entry = entries.get(theaterId);
-    if (!entry || entry.recursive || relativePath === "" || entry.watchers.has(relativePath)) return;
-    if (entry.watchers.size >= LINUX_DIRECTORY_WATCH_CAP) {
-      for (const notify of entry.stateSubscribers) notify("degraded");
-      return;
+      continue;
     }
-    const target = await resolveTrackedDirectory(theaterPath, relativePath);
-    if (!target) return;
-    if (entries.get(theaterId) !== entry || entry.watchers.has(relativePath) || entry.watchers.size >= LINUX_DIRECTORY_WATCH_CAP) return;
-    try {
-      startWatcher(theaterId, entry, relativePath, target.path, target.identity);
-      entry.pendingDirectories.delete(relativePath);
-    } catch {
-      for (const notify of entry.stateSubscribers) notify("degraded");
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (entryCount >= SEARCH_ENTRY_CAP) break;
+      entryCount += 1;
+      const relativePath = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
+      const absolutePath = path5.join(directory.absolutePath, entry.name);
+      let kind = entry.isDirectory() ? "dir" : entry.isFile() ? "file" : null;
+      let realPath = absolutePath;
+      if (entry.isSymbolicLink()) {
+        try {
+          realPath = await fsp.realpath(absolutePath);
+          if (!isContained(realRoot, realPath)) continue;
+          const stat = await fsp.stat(realPath);
+          kind = stat.isDirectory() ? "dir" : stat.isFile() ? "file" : null;
+        } catch {
+          continue;
+        }
+      }
+      if (kind === "dir") {
+        if (!visited.has(realPath)) pending.push({ absolutePath: realPath, relativePath });
+        continue;
+      }
+      if (kind !== "file") continue;
+      const low = relativePath.toLocaleLowerCase();
+      if (tokens.every((token) => low.includes(token))) matches.push({ relativePath });
     }
   }
-  return { subscribe, trackDirectory };
+  return matches.sort((left, right) => compareFileSearchItem(left, right, query)).slice(0, limit);
 }
-async function resolveTrackedDirectory(theaterPath, relativePath) {
-  const resolvedRoot = path4.resolve(theaterPath);
-  const targetPath = path4.resolve(resolvedRoot, relativePath);
-  if (!isWithinRoot3(targetPath, resolvedRoot)) return null;
+async function handleFilesSearch(req, res, ctx) {
+  if (req.method !== "POST") {
+    ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+  if (!ctx.host.security.isTerminalAuthorized(req)) {
+    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  const body = await ctx.host.http.readJsonBody(req);
+  if (!isPlainObject(body) || typeof body.theaterId !== "string" || typeof body.query !== "string" || body.query.trim() === "" || !Number.isInteger(body.limit) || body.limit < 1 || body.limit > 8) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
   try {
-    const [realRoot, realTarget] = await Promise.all([
-      fs3.promises.realpath(theaterPath),
-      fs3.promises.realpath(targetPath)
-    ]);
-    if (!isWithinRoot3(realTarget, realRoot)) return null;
-    const stats = await fs3.promises.stat(realTarget);
-    if (!stats.isDirectory()) return null;
-    return {
-      path: realTarget,
-      identity: { device: stats.dev, inode: stats.ino }
-    };
+    ctx.host.http.writeJson(res, 200, {
+      files: await searchTheaterFiles(theaterPath, body.query, body.limit)
+    });
   } catch {
-    return null;
+    ctx.host.http.writeJson(res, 500, { error: "search_failed" });
   }
 }
-function isWithinRoot3(candidate, root) {
-  const normalizedRoot = root.endsWith(path4.sep) ? root : root + path4.sep;
-  return candidate === root || candidate.startsWith(normalizedRoot);
+function compareFileSearchItem(left, right, query) {
+  const lowQuery = query.trim().toLocaleLowerCase();
+  const leftName = left.relativePath.split("/").at(-1)?.toLocaleLowerCase() ?? "";
+  const rightName = right.relativePath.split("/").at(-1)?.toLocaleLowerCase() ?? "";
+  const leftRank = leftName === lowQuery ? 0 : leftName.startsWith(lowQuery) ? 1 : 2;
+  const rightRank = rightName === lowQuery ? 0 : rightName.startsWith(lowQuery) ? 1 : 2;
+  return leftRank - rightRank || left.relativePath.localeCompare(right.relativePath);
 }
-function computeRelDir(filename) {
-  if (!filename) return "";
-  const lastSep = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
-  if (lastSep <= 0) return "";
-  return filename.slice(0, lastSep);
+function isContained(root, candidate) {
+  const relative = path5.relative(root, candidate);
+  return relative === "" || relative !== ".." && !relative.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relative);
 }
-
-// ../fleet-plugins/file-explorer/server/handlers.ts
 var DEFAULT_CLIPBOARD_DEPENDENCIES = { copyPath: copyPathToClipboard };
-var DEFAULT_REVEAL_DEPENDENCIES = { revealPath };
+var DEFAULT_REVEAL_DEPENDENCIES2 = { revealPath };
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1031,7 +1122,7 @@ async function handleFilesClipboard(req, res, ctx, dependencies = DEFAULT_CLIPBO
     ctx.host.http.writeJson(res, 500, { error: "clipboard_failed" });
   }
 }
-async function handleFilesReveal(req, res, ctx, dependencies = DEFAULT_REVEAL_DEPENDENCIES) {
+async function handleFilesReveal(req, res, ctx, dependencies = DEFAULT_REVEAL_DEPENDENCIES2) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -1127,98 +1218,6 @@ function writePathActionError(res, ctx, error) {
   const status = error.code === "not_found" ? 404 : 403;
   ctx.host.http.writeJson(res, status, { error: error.code });
 }
-var SEARCH_DIRECTORY_CAP = 500;
-var SEARCH_ENTRY_CAP = 25e3;
-async function searchTheaterFiles(theaterPath, query, limit) {
-  const realRoot = await fs8.realpath(theaterPath);
-  const tokens = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
-  const pending = [{ absolutePath: realRoot, relativePath: "" }];
-  const visited = /* @__PURE__ */ new Set();
-  const matches = [];
-  let directoryCount = 0;
-  let entryCount = 0;
-  while (pending.length > 0 && directoryCount < SEARCH_DIRECTORY_CAP && entryCount < SEARCH_ENTRY_CAP) {
-    const directory = pending.shift();
-    if (!directory || visited.has(directory.absolutePath)) continue;
-    visited.add(directory.absolutePath);
-    directoryCount += 1;
-    let entries;
-    try {
-      entries = await fs8.readdir(directory.absolutePath, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-    for (const entry of entries) {
-      if (entryCount >= SEARCH_ENTRY_CAP) break;
-      entryCount += 1;
-      const relativePath = directory.relativePath ? `${directory.relativePath}/${entry.name}` : entry.name;
-      const absolutePath = path4.join(directory.absolutePath, entry.name);
-      let kind = entry.isDirectory() ? "dir" : entry.isFile() ? "file" : null;
-      let realPath = absolutePath;
-      if (entry.isSymbolicLink()) {
-        try {
-          realPath = await fs8.realpath(absolutePath);
-          if (!isContained(realRoot, realPath)) continue;
-          const stat = await fs8.stat(realPath);
-          kind = stat.isDirectory() ? "dir" : stat.isFile() ? "file" : null;
-        } catch {
-          continue;
-        }
-      }
-      if (kind === "dir") {
-        if (!visited.has(realPath)) pending.push({ absolutePath: realPath, relativePath });
-        continue;
-      }
-      if (kind !== "file") continue;
-      const low = relativePath.toLocaleLowerCase();
-      if (tokens.every((token) => low.includes(token))) matches.push({ relativePath });
-    }
-  }
-  return matches.sort((left, right) => compareFileSearchItem(left, right, query)).slice(0, limit);
-}
-async function handleFilesSearch(req, res, ctx) {
-  if (req.method !== "POST") {
-    ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
-    return;
-  }
-  if (!ctx.host.security.isTerminalAuthorized(req)) {
-    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
-    return;
-  }
-  const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject2(body) || typeof body.theaterId !== "string" || typeof body.query !== "string" || body.query.trim() === "" || !Number.isInteger(body.limit) || body.limit < 1 || body.limit > 8) {
-    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
-    return;
-  }
-  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
-  if (!theaterPath) {
-    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
-    return;
-  }
-  try {
-    ctx.host.http.writeJson(res, 200, {
-      files: await searchTheaterFiles(theaterPath, body.query, body.limit)
-    });
-  } catch {
-    ctx.host.http.writeJson(res, 500, { error: "search_failed" });
-  }
-}
-function compareFileSearchItem(left, right, query) {
-  const lowQuery = query.trim().toLocaleLowerCase();
-  const leftName = left.relativePath.split("/").at(-1)?.toLocaleLowerCase() ?? "";
-  const rightName = right.relativePath.split("/").at(-1)?.toLocaleLowerCase() ?? "";
-  const leftRank = leftName === lowQuery ? 0 : leftName.startsWith(lowQuery) ? 1 : 2;
-  const rightRank = rightName === lowQuery ? 0 : rightName.startsWith(lowQuery) ? 1 : 2;
-  return leftRank - rightRank || left.relativePath.localeCompare(right.relativePath);
-}
-function isContained(root, candidate) {
-  const relative = path4.relative(root, candidate);
-  return relative === "" || relative !== ".." && !relative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(relative);
-}
-function isPlainObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 
 // ../fleet-plugins/file-explorer/routes.ts
 var routes_default = definePlugin({