@dotobokuri/fleet-console 1.28.0 → 1.30.0

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

@@ -6,12 +6,12 @@ import path2 from 'path';
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path4, handler) {
-  ctx.registerRouter(normalizePath(path4), handler);
+function registerRouter(ctx, path5, handler) {
+  ctx.registerRouter(normalizePath(path5), handler);
 }
-function normalizePath(path4) {
-  if (path4.length === 0 || path4 === "/") return "/";
-  return path4;
+function normalizePath(path5) {
+  if (path5.length === 0 || path5 === "/") return "/";
+  return path5;
 }
 var FileReadError = class extends Error {
   code;
@@ -301,9 +301,142 @@ function isWithinRoot2(resolved, root) {
   return resolved === root || resolved.startsWith(normalizedRoot);
 }
 var DEBOUNCE_MS = 200;
+var LINUX_DIRECTORY_WATCH_CAP = 1024;
 var watcherRegistry = createWatcherRegistry();
-function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs.watch(p, opts, (ev, fn) => cb(ev, typeof fn === "string" ? fn : null)), debounceMs = DEBOUNCE_MS) {
+function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs.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();
+  }
+  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;
+    }
+  }
+  function invalidateWatcherTree(entry, watchKey) {
+    const descendantPrefix = watchKey + path2.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 startWatcher(theaterId, entry, watchKey, watchPath, watchIdentity) {
+    let identityCheckRunning = false;
+    let identityCheckRequested = false;
+    let activeWatcher = null;
+    const lexicalWatchPath = path2.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 fs.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 = path2.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 makeUnsubscribe(theaterId, onChange, onState, entry) {
     let called = false;
     return () => {
@@ -313,8 +446,7 @@ function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs.watch(p, opt
       entry.stateSubscribers.delete(onState);
       entry.subscriberCount--;
       if (entry.subscriberCount <= 0) {
-        for (const t of entry.debounceTimers.values()) clearTimeout(t);
-        entry.watcher.close();
+        closeEntry(entry);
         if (entries.get(theaterId) === entry) entries.delete(theaterId);
       }
     };
@@ -328,46 +460,74 @@ function createWatcherRegistry(watcherFactory = (p, opts, cb) => fs.watch(p, opt
       onState("watching");
       return makeUnsubscribe(theaterId, onChange, onState, existing);
     }
-    const debounceTimers = /* @__PURE__ */ new Map();
-    const subscribers = /* @__PURE__ */ new Set();
-    const stateSubscribers = /* @__PURE__ */ new Set();
-    let watcher;
+    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 {
-      watcher = watcherFactory(theaterPath, { recursive: true }, (_, filename) => {
-        const relDir = computeRelDir(filename);
-        const pending = debounceTimers.get(relDir);
-        if (pending) clearTimeout(pending);
-        debounceTimers.set(
-          relDir,
-          setTimeout(() => {
-            debounceTimers.delete(relDir);
-            for (const sub of subscribers) sub(relDir);
-          }, debounceMs)
-        );
-      });
+      startWatcher(theaterId, entry, "", theaterPath);
     } catch {
       onState("degraded");
       return () => {
       };
     }
-    const entry = { watcher, subscribers, stateSubscribers, subscriberCount: 1, debounceTimers };
-    watcher.on("error", () => {
-      for (const t of debounceTimers.values()) clearTimeout(t);
-      debounceTimers.clear();
-      try {
-        watcher.close();
-      } catch {
-      }
-      if (entries.get(theaterId) === entry) entries.delete(theaterId);
-      for (const notify of stateSubscribers) notify("degraded");
-    });
     entries.set(theaterId, entry);
-    subscribers.add(onChange);
-    stateSubscribers.add(onState);
     onState("watching");
     return makeUnsubscribe(theaterId, onChange, onState, entry);
   }
-  return { subscribe };
+  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 { subscribe, trackDirectory };
+}
+async function resolveTrackedDirectory(theaterPath, relativePath) {
+  const resolvedRoot = path2.resolve(theaterPath);
+  const targetPath = path2.resolve(resolvedRoot, relativePath);
+  if (!isWithinRoot3(targetPath, resolvedRoot)) return null;
+  try {
+    const [realRoot, realTarget] = await Promise.all([
+      fs.promises.realpath(theaterPath),
+      fs.promises.realpath(targetPath)
+    ]);
+    if (!isWithinRoot3(realTarget, realRoot)) return null;
+    const stats = await fs.promises.stat(realTarget);
+    if (!stats.isDirectory()) return null;
+    return {
+      path: realTarget,
+      identity: { device: stats.dev, inode: stats.ino }
+    };
+  } catch {
+    return null;
+  }
+}
+function isWithinRoot3(candidate, root) {
+  const normalizedRoot = root.endsWith(path2.sep) ? root : root + path2.sep;
+  return candidate === root || candidate.startsWith(normalizedRoot);
 }
 function computeRelDir(filename) {
   if (!filename) return "";
@@ -415,6 +575,7 @@ async function handleFilesList(req, res, ctx) {
   }
   try {
     const result = await listTheaterContents(theaterPath, relPath);
+    await watcherRegistry.trackDirectory(rawTheaterId, theaterPath, relPath);
     ctx.host.http.writeJson(res, 200, result);
   } catch (error) {
     if (error instanceof FolderBrowserError) {