@dotobokuri/fleet-console 1.16.1 → 1.17.0

package/dist/fleet-plugins/diff/routes.mjs

@@ -7,12 +7,12 @@ import { spawn } from 'child_process';
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path2, handler) {
-  ctx.registerRouter(normalizePath(path2), handler);
+function registerRouter(ctx, path3, handler) {
+  ctx.registerRouter(normalizePath(path3), handler);
 }
-function normalizePath(path2) {
-  if (path2.length === 0 || path2 === "/") return "/";
-  return path2;
+function normalizePath(path3) {
+  if (path3.length === 0 || path3 === "/") return "/";
+  return path3;
 }
 var GitExecutorError = class extends Error {
   code;
@@ -91,14 +91,13 @@ function runGit(args, opts) {
 }
 
 // ../fleet-plugins/diff/server/diff.ts
-var REF_SAFE_RE = /^(?:[a-f0-9]{7,40}|[A-Za-z0-9][A-Za-z0-9/_.~^-]{0,250})$/;
-function isSafeGitRef(ref) {
-  return REF_SAFE_RE.test(ref);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function buildDiffArgs(mode, ref) {
-  if (mode === "staged") return ["diff", "--cached"];
-  if (mode === "commit" && ref) return ["diff", `${ref}^`, ref];
-  return ["diff"];
+function normalizeNumstatPath(p) {
+  const match = /^(.*?)\{[^}]* => ([^}]*)\}(.*)$/.exec(p);
+  if (!match) return p;
+  return (match[1] ?? "") + (match[2] ?? "") + (match[3] ?? "");
 }
 function parseDiffFileList(nameStatusOutput, numstatOutput) {
   const numstatMap = /* @__PURE__ */ new Map();
@@ -107,7 +106,7 @@ function parseDiffFileList(nameStatusOutput, numstatOutput) {
     if (parts.length < 3) continue;
     const [adds, dels, filePath] = parts;
     if (!filePath) continue;
-    numstatMap.set(filePath, {
+    numstatMap.set(normalizeNumstatPath(filePath), {
       additions: parseInt(adds ?? "0", 10) || 0,
       deletions: parseInt(dels ?? "0", 10) || 0
     });
@@ -135,8 +134,29 @@ async function fetchUntrackedFiles(cwd) {
     deletions: 0
   }));
 }
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isNoHeadError(error) {
+  if (!(error instanceof GitExecutorError)) return false;
+  if (error.code !== "non_zero_exit") return false;
+  return error.stderr.includes("unknown revision") || error.stderr.includes("bad revision");
+}
+async function resolveGitCwd(theaterPath, rawSubPath) {
+  if (rawSubPath === "") return { gitCwd: theaterPath };
+  const resolvedSub = path.resolve(theaterPath, rawSubPath);
+  if (!resolvedSub.startsWith(theaterPath + path.sep) && resolvedSub !== theaterPath) return null;
+  if (path.normalize(rawSubPath).startsWith("..")) return null;
+  let realTheater;
+  let realSub;
+  try {
+    [realTheater, realSub] = await Promise.all([
+      fs.realpath(theaterPath),
+      fs.realpath(resolvedSub)
+    ]);
+  } catch {
+    return null;
+  }
+  const norm = realTheater.endsWith(path.sep) ? realTheater : realTheater + path.sep;
+  if (realSub !== realTheater && !realSub.startsWith(norm)) return null;
+  return { gitCwd: resolvedSub };
 }
 async function handleDiffChanged(req, res, ctx) {
   if (req.method !== "POST") {
@@ -152,43 +172,48 @@ async function handleDiffChanged(req, res, ctx) {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
-  const mode = body.mode;
-  if (mode !== "workdir" && mode !== "staged" && mode !== "commit") {
-    ctx.host.http.writeJson(res, 400, { error: "invalid_mode" });
-    return;
-  }
   const theaterId = body.theaterId;
   if (typeof theaterId !== "string") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
-  const rawRef = typeof body.ref === "string" ? body.ref : void 0;
-  if (rawRef !== void 0 && !isSafeGitRef(rawRef)) {
-    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
-    return;
-  }
   const theaterPath = ctx.host.paths.resolveTheaterPath(theaterId);
   if (!theaterPath) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
+  const rawSubPath = typeof body.subPath === "string" ? body.subPath : "";
+  const cwdResult = await resolveGitCwd(theaterPath, rawSubPath);
+  if (!cwdResult) {
+    ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
+    return;
+  }
+  const { gitCwd } = cwdResult;
   try {
-    const diffArgs = buildDiffArgs(mode, rawRef);
-    const nameStatusArgs = [...diffArgs, "--name-status", "--diff-filter=MADR"];
-    const numstatArgs = [...diffArgs, "--numstat", "--diff-filter=MADR"];
-    const [nameStatusResult, numstatResult] = await Promise.all([
-      runGit(nameStatusArgs, { cwd: theaterPath }),
-      runGit(numstatArgs, { cwd: theaterPath })
-    ]);
-    const files = parseDiffFileList(nameStatusResult.stdout, numstatResult.stdout);
-    if (mode === "workdir") {
-      try {
-        const untrackedFiles = await fetchUntrackedFiles(theaterPath);
-        files.push(...untrackedFiles);
-      } catch {
-      }
+    let files;
+    let truncated = false;
+    try {
+      const [nameStatusResult, numstatResult] = await Promise.all([
+        runGit(["diff", "HEAD", "--name-status", "--diff-filter=MADR"], { cwd: gitCwd }),
+        runGit(["diff", "HEAD", "--numstat", "--diff-filter=MADR"], { cwd: gitCwd })
+      ]);
+      files = parseDiffFileList(nameStatusResult.stdout, numstatResult.stdout);
+      truncated = nameStatusResult.truncated || numstatResult.truncated;
+    } catch (err) {
+      if (!isNoHeadError(err)) throw err;
+      const [nsResult, nsNumstat] = await Promise.all([
+        runGit(["diff", "--cached", "--name-status", "--diff-filter=MADR"], { cwd: gitCwd }),
+        runGit(["diff", "--cached", "--numstat", "--diff-filter=MADR"], { cwd: gitCwd })
+      ]);
+      files = parseDiffFileList(nsResult.stdout, nsNumstat.stdout);
+      truncated = nsResult.truncated || nsNumstat.truncated;
+    }
+    try {
+      const untrackedFiles = await fetchUntrackedFiles(gitCwd);
+      files.push(...untrackedFiles);
+    } catch {
     }
-    ctx.host.http.writeJson(res, 200, { files, truncated: nameStatusResult.truncated || numstatResult.truncated });
+    ctx.host.http.writeJson(res, 200, { files, truncated });
   } catch (error) {
     if (error instanceof GitExecutorError) {
       if (error.code === "no_git_repo" || error.code === "git_unavailable") {
@@ -216,7 +241,7 @@ async function handleDiffFile(req, res, ctx) {
     return;
   }
   const mode = body.mode;
-  if (mode !== "workdir" && mode !== "staged" && mode !== "commit" && mode !== "untracked") {
+  if (mode !== "unified" && mode !== "untracked") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_mode" });
     return;
   }
@@ -225,53 +250,71 @@ async function handleDiffFile(req, res, ctx) {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
-  const rawFilePath = body.filePath;
   const theaterPath = ctx.host.paths.resolveTheaterPath(theaterId);
   if (!theaterPath) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const resolvedPath = path.resolve(theaterPath, rawFilePath);
-  if (!resolvedPath.startsWith(theaterPath + path.sep) && resolvedPath !== theaterPath) {
+  const rawSubPath = typeof body.subPath === "string" ? body.subPath : "";
+  const cwdResult = await resolveGitCwd(theaterPath, rawSubPath);
+  if (!cwdResult) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const relativePath = path.normalize(rawFilePath);
-  if (relativePath.startsWith("..")) {
+  const { gitCwd } = cwdResult;
+  const rawFilePath = body.filePath;
+  const resolvedFilePath = path.resolve(gitCwd, rawFilePath);
+  if (!resolvedFilePath.startsWith(gitCwd + path.sep) && resolvedFilePath !== gitCwd) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const rawRef = typeof body.ref === "string" ? body.ref : void 0;
-  if (rawRef !== void 0 && !isSafeGitRef(rawRef)) {
-    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
+  const relativePath = path.normalize(rawFilePath);
+  if (relativePath.startsWith("..")) {
+    ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
   try {
     if (mode === "untracked") {
-      let realTheater;
+      let realGitCwd;
       let realFile;
       try {
-        [realTheater, realFile] = await Promise.all([
-          fs.realpath(theaterPath),
-          fs.realpath(resolvedPath)
+        [realGitCwd, realFile] = await Promise.all([
+          fs.realpath(gitCwd),
+          fs.realpath(resolvedFilePath)
         ]);
       } catch {
         ctx.host.http.writeJson(res, 404, { error: "file_not_found" });
         return;
       }
-      if (realFile !== realTheater && !realFile.startsWith(realTheater + path.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
       const result2 = await runGit(
         ["diff", "--no-index", "--unified=3", "--", "/dev/null", relativePath],
-        { cwd: theaterPath, allowExitCodes: [1] }
+        { cwd: gitCwd, allowExitCodes: [1] }
       );
       ctx.host.http.writeJson(res, 200, { content: result2.stdout, truncated: result2.truncated });
       return;
     }
-    const diffArgs = [...buildDiffArgs(mode, rawRef), "--unified=3", "--", relativePath];
-    const result = await runGit(diffArgs, { cwd: theaterPath });
+    try {
+      const [realGitCwd, realFile] = await Promise.all([
+        fs.realpath(gitCwd),
+        fs.realpath(resolvedFilePath)
+      ]);
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path.sep)) {
+        ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
+        return;
+      }
+    } catch {
+    }
+    let result;
+    try {
+      result = await runGit(["diff", "HEAD", "--unified=3", "--", relativePath], { cwd: gitCwd });
+    } catch (err) {
+      if (!isNoHeadError(err)) throw err;
+      result = await runGit(["diff", "--cached", "--unified=3", "--", relativePath], { cwd: gitCwd });
+    }
     ctx.host.http.writeJson(res, 200, { content: result.stdout, truncated: result.truncated });
   } catch (error) {
     if (error instanceof GitExecutorError) {
@@ -285,11 +328,135 @@ async function handleDiffFile(req, res, ctx) {
     throw error;
   }
 }
+var REPOS_CAP = 200;
+var HARD_CAP_DEPTH = 8;
+var DEFAULT_DEPTH = 3;
+function isPlainObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function resolveRepoBranch(repoDir) {
+  try {
+    const result = await runGit(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: repoDir });
+    const branch = result.stdout.trim();
+    if (branch === "HEAD") {
+      const sha = await runGit(["rev-parse", "--short", "HEAD"], { cwd: repoDir });
+      return sha.stdout.trim() || "HEAD";
+    }
+    return branch || "HEAD";
+  } catch {
+    return "unknown";
+  }
+}
+async function scanRepos(theaterPath, realTheaterPath, dir, currentDepth, maxDepth, repos, cap = REPOS_CAP) {
+  if (repos.length >= cap) return true;
+  const gitPath = path.join(dir, ".git");
+  try {
+    await fs.stat(gitPath);
+    const relPath = path.relative(theaterPath, dir);
+    const name = relPath === "" ? path.basename(theaterPath) : path.basename(dir);
+    const branch = await resolveRepoBranch(dir);
+    repos.push({ relPath, name, branch });
+    if (repos.length >= cap) return true;
+  } catch {
+  }
+  if (currentDepth >= maxDepth) return false;
+  let dirHandle = null;
+  try {
+    dirHandle = await fs.opendir(dir);
+    try {
+      let dirent = await dirHandle.read();
+      while (dirent !== null) {
+        if (repos.length >= cap) return true;
+        if (dirent.isDirectory()) {
+          const childName = dirent.name;
+          if (childName === "node_modules" || childName === ".git") {
+            dirent = await dirHandle.read();
+            continue;
+          }
+          const childPath = path.join(dir, childName);
+          let realChildPath;
+          try {
+            realChildPath = await fs.realpath(childPath);
+          } catch {
+            dirent = await dirHandle.read();
+            continue;
+          }
+          const normalizedReal = realTheaterPath.endsWith(path.sep) ? realTheaterPath : realTheaterPath + path.sep;
+          if (realChildPath !== realTheaterPath && !realChildPath.startsWith(normalizedReal)) {
+            dirent = await dirHandle.read();
+            continue;
+          }
+          const truncated = await scanRepos(theaterPath, realTheaterPath, childPath, currentDepth + 1, maxDepth, repos, cap);
+          if (truncated) return true;
+        }
+        dirent = await dirHandle.read();
+      }
+      return false;
+    } finally {
+      await dirHandle.close();
+    }
+  } catch {
+    if (dirHandle) {
+      try {
+        await dirHandle.close();
+      } catch {
+      }
+    }
+    return false;
+  }
+}
+async function handleDiffRepos(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)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const theaterId = body.theaterId;
+  if (typeof theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
+  const rawDepth = body.maxDepth;
+  const maxDepth = typeof rawDepth === "number" && Number.isFinite(rawDepth) && rawDepth >= 1 ? Math.min(HARD_CAP_DEPTH, Math.floor(rawDepth)) : DEFAULT_DEPTH;
+  let realTheaterPath;
+  try {
+    realTheaterPath = await fs.realpath(theaterPath);
+  } catch {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
+  const repos = [];
+  const truncated = await scanRepos(theaterPath, realTheaterPath, theaterPath, 0, maxDepth, repos);
+  repos.sort((a, b) => {
+    if (a.relPath === "") return -1;
+    if (b.relPath === "") return 1;
+    return a.relPath.localeCompare(b.relPath);
+  });
+  const result = { repos, ...truncated ? { truncated: true } : {} };
+  ctx.host.http.writeJson(res, 200, result);
+}
 
 // ../fleet-plugins/diff/routes.ts
 var routes_default = definePlugin({
   id: "diff",
   register(ctx) {
+    registerRouter(ctx, "repos", async ({ req, res }) => {
+      await handleDiffRepos(req, res, ctx);
+      return true;
+    });
     registerRouter(ctx, "changed", async ({ req, res }) => {
       await handleDiffChanged(req, res, ctx);
       return true;

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

@@ -300,6 +300,81 @@ function isWithinRoot2(resolved, root) {
   const normalizedRoot = root.endsWith(path2.sep) ? root : root + path2.sep;
   return resolved === root || resolved.startsWith(normalizedRoot);
 }
+var DEBOUNCE_MS = 200;
+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) {
+  const entries = /* @__PURE__ */ new Map();
+  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) {
+        for (const t of entry.debounceTimers.values()) clearTimeout(t);
+        entry.watcher.close();
+        if (entries.get(theaterId) === entry) entries.delete(theaterId);
+      }
+    };
+  }
+  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 debounceTimers = /* @__PURE__ */ new Map();
+    const subscribers = /* @__PURE__ */ new Set();
+    const stateSubscribers = /* @__PURE__ */ new Set();
+    let watcher;
+    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)
+        );
+      });
+    } 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 };
+}
+function computeRelDir(filename) {
+  if (!filename) return "";
+  const lastSep = Math.max(filename.lastIndexOf("/"), filename.lastIndexOf("\\"));
+  if (lastSep <= 0) return "";
+  return filename.slice(0, lastSep);
+}
 
 // ../fleet-plugins/file-explorer/server/handlers.ts
 function isPlainObject(value) {
@@ -423,6 +498,57 @@ async function handleFilesImage(req, res, ctx) {
     throw error;
   }
 }
+function handleFilesWatch(req, res, ctx) {
+  if (req.method !== "GET") {
+    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 url = readUrl(req);
+  const theaterId = url.searchParams.get("theaterId");
+  if (!theaterId) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "X-Accel-Buffering": "no"
+  });
+  res.flushHeaders();
+  function sendEvent(name, data) {
+    try {
+      res.write(`event: ${name}
+data: ${data}
+
+`);
+    } catch {
+    }
+  }
+  const unsubscribe = watcherRegistry.subscribe(
+    theaterId,
+    theaterPath,
+    // 개행 포함 파일명이 SSE 필드 경계를 깨지 않도록 JSON으로 프레이밍한다
+    (relDir) => sendEvent("change", JSON.stringify(relDir)),
+    (state) => sendEvent("state", state)
+  );
+  req.on("close", () => {
+    unsubscribe();
+    try {
+      res.end();
+    } catch {
+    }
+  });
+}
 
 // ../fleet-plugins/file-explorer/routes.ts
 var routes_default = definePlugin({
@@ -440,6 +566,10 @@ var routes_default = definePlugin({
       await handleFilesImage(req, res, ctx);
       return true;
     });
+    registerRouter(ctx, "files/watch", ({ req, res }) => {
+      handleFilesWatch(req, res, ctx);
+      return true;
+    });
   }
 });