@dotobokuri/fleet-console 1.23.0 → 1.24.0

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

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import { spawn } from 'child_process';
 import 'fs';
-import path3 from 'path';
+import path2 from 'path';
 import fs from 'fs/promises';
 
 // sdk/plugin/node.ts
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path4, handler) {
-  ctx.registerRouter(normalizePath(path4), handler);
+function registerRouter(ctx, path3, handler) {
+  ctx.registerRouter(normalizePath(path3), handler);
 }
-function normalizePath(path4) {
-  if (path4.length === 0 || path4 === "/") return "/";
-  return path4;
+function normalizePath(path3) {
+  if (path3.length === 0 || path3 === "/") return "/";
+  return path3;
 }
 
 // ../../packages/core-process/src/hidden.ts
@@ -132,7 +132,7 @@ function parseDiffFileList(nameStatusOutput, numstatOutput) {
   return files;
 }
 async function fetchUntrackedFiles(cwd) {
-  const result = await runGit(["ls-files", "--others", "--exclude-standard"], { cwd });
+  const result = await runGit(["ls-files", "--others", "--exclude-standard", "--", "."], { cwd });
   return result.stdout.split("\n").filter((p) => p.trim()).map((p) => ({
     path: p,
     status: "U",
@@ -140,6 +140,9 @@ async function fetchUntrackedFiles(cwd) {
     deletions: 0
   }));
 }
+async function ensureGitRepository(cwd) {
+  await runGit(["rev-parse", "--is-inside-work-tree"], { cwd });
+}
 function isNoHeadError(error) {
   if (!(error instanceof GitExecutorError)) return false;
   if (error.code !== "non_zero_exit") return false;
@@ -147,9 +150,9 @@ function isNoHeadError(error) {
 }
 async function resolveGitCwd(theaterPath, rawSubPath) {
   if (rawSubPath === "") return { gitCwd: theaterPath };
-  const resolvedSub = path3.resolve(theaterPath, rawSubPath);
-  if (!resolvedSub.startsWith(theaterPath + path3.sep) && resolvedSub !== theaterPath) return null;
-  if (path3.normalize(rawSubPath).startsWith("..")) return null;
+  const resolvedSub = path2.resolve(theaterPath, rawSubPath);
+  if (!resolvedSub.startsWith(theaterPath + path2.sep) && resolvedSub !== theaterPath) return null;
+  if (path2.normalize(rawSubPath).startsWith("..")) return null;
   let realTheater;
   let realSub;
   try {
@@ -160,7 +163,7 @@ async function resolveGitCwd(theaterPath, rawSubPath) {
   } catch {
     return null;
   }
-  const norm = realTheater.endsWith(path3.sep) ? realTheater : realTheater + path3.sep;
+  const norm = realTheater.endsWith(path2.sep) ? realTheater : realTheater + path2.sep;
   if (realSub !== realTheater && !realSub.startsWith(norm)) return null;
   return { gitCwd: resolvedSub };
 }
@@ -196,20 +199,21 @@ async function handleDiffChanged(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   try {
+    await ensureGitRepository(gitCwd);
     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 })
+        runGit(["diff", "HEAD", "--relative", "--name-status", "--diff-filter=MADR", "--", "."], { cwd: gitCwd }),
+        runGit(["diff", "HEAD", "--relative", "--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 })
+        runGit(["diff", "--cached", "--relative", "--name-status", "--diff-filter=MADR", "--", "."], { cwd: gitCwd }),
+        runGit(["diff", "--cached", "--relative", "--numstat", "--diff-filter=MADR", "--", "."], { cwd: gitCwd })
       ]);
       files = parseDiffFileList(nsResult.stdout, nsNumstat.stdout);
       truncated = nsResult.truncated || nsNumstat.truncated;
@@ -269,12 +273,12 @@ async function handleDiffFile(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   const rawFilePath = body.filePath;
-  const resolvedFilePath = path3.resolve(gitCwd, rawFilePath);
-  if (!resolvedFilePath.startsWith(gitCwd + path3.sep) && resolvedFilePath !== gitCwd) {
+  const resolvedFilePath = path2.resolve(gitCwd, rawFilePath);
+  if (!resolvedFilePath.startsWith(gitCwd + path2.sep) && resolvedFilePath !== gitCwd) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const relativePath = path3.normalize(rawFilePath);
+  const relativePath = path2.normalize(rawFilePath);
   if (relativePath.startsWith("..")) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
@@ -292,12 +296,12 @@ async function handleDiffFile(req, res, ctx) {
         ctx.host.http.writeJson(res, 404, { error: "file_not_found" });
         return;
       }
-      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path3.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path2.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
       const result2 = await runGit(
-        ["diff", "--no-index", "--unified=3", "--", "/dev/null", relativePath],
+        ["diff", "--no-index", "--relative", "--unified=3", "--", "/dev/null", relativePath],
         { cwd: gitCwd, allowExitCodes: [1] }
       );
       ctx.host.http.writeJson(res, 200, { content: result2.stdout, truncated: result2.truncated });
@@ -308,7 +312,7 @@ async function handleDiffFile(req, res, ctx) {
         fs.realpath(gitCwd),
         fs.realpath(resolvedFilePath)
       ]);
-      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path3.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path2.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
@@ -316,10 +320,10 @@ async function handleDiffFile(req, res, ctx) {
     }
     let result;
     try {
-      result = await runGit(["diff", "HEAD", "--unified=3", "--", relativePath], { cwd: gitCwd });
+      result = await runGit(["diff", "HEAD", "--relative", "--unified=3", "--", relativePath], { cwd: gitCwd });
     } catch (err) {
       if (!isNoHeadError(err)) throw err;
-      result = await runGit(["diff", "--cached", "--unified=3", "--", relativePath], { cwd: gitCwd });
+      result = await runGit(["diff", "--cached", "--relative", "--unified=3", "--", relativePath], { cwd: gitCwd });
     }
     ctx.host.http.writeJson(res, 200, { content: result.stdout, truncated: result.truncated });
   } catch (error) {
@@ -377,7 +381,7 @@ async function handleDiffCommit(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   try {
-    const result = await runGit(["show", ref, "--unified=3", "--format="], { cwd: gitCwd });
+    const result = await runGit(["show", ref, "--relative", "--unified=3", "--format=", "--", "."], { cwd: gitCwd });
     ctx.host.http.writeJson(res, 200, { content: result.stdout, ...result.truncated ? { truncated: true } : {} });
   } catch (error) {
     if (error instanceof GitExecutorError) {
@@ -391,8 +395,7 @@ async function handleDiffCommit(req, res, ctx) {
     throw error;
   }
 }
-
-// ../fleet-plugins/diff/server/log.ts
+var WORKTREE_SHA_RE = /^[0-9a-f]{40}$/;
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -410,30 +413,96 @@ function parseLogOutput(stdout) {
     const subject = fields[2] ?? "";
     const authorName = fields[3] ?? "";
     const relTime = fields[4] ?? "";
-    const refsRaw = fields[5] ?? "";
-    const parentsRaw = fields[6] ?? "";
+    const authorAt = Number.parseInt(fields[5] ?? "0", 10);
+    const refsRaw = fields[6] ?? "";
+    const parentsRaw = fields[7] ?? "";
     if (!fullHash) continue;
     const refs = refsRaw.split(",").map((r) => r.trim()).filter(Boolean);
     const parents = parentsRaw.split(" ").map((p) => p.trim()).filter(Boolean);
-    let additions = 0;
-    let deletions = 0;
-    for (const line of lines.slice(1)) {
-      if (!line.trim()) continue;
-      const parts = line.split("	");
-      if (parts.length < 2) continue;
-      const a = parseInt(parts[0] ?? "0", 10);
-      const d = parseInt(parts[1] ?? "0", 10);
-      if (!isNaN(a)) additions += a;
-      if (!isNaN(d)) deletions += d;
-    }
-    commits.push({ shortHash, fullHash, subject, authorName, relTime, refs, parents, additions, deletions });
+    commits.push({
+      shortHash,
+      fullHash,
+      subject,
+      authorName,
+      relTime,
+      authorAt: Number.isFinite(authorAt) ? authorAt : 0,
+      refs,
+      parents,
+      onHead: true
+    });
   }
   return commits;
 }
+async function parseWorktreePorcelain(stdout, currentWorktreePath) {
+  const worktrees = [];
+  let worktreePath = null;
+  let sha = "";
+  let branch = null;
+  let prunable = false;
+  const pushCurrent = () => {
+    if (!worktreePath || !sha || prunable || /^0+$/.test(sha)) return;
+    worktrees.push({
+      sha,
+      branch,
+      worktreePath
+    });
+  };
+  for (const line of stdout.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      pushCurrent();
+      worktreePath = line.slice(9);
+      sha = "";
+      branch = null;
+      prunable = false;
+    } else if (line.startsWith("HEAD ")) {
+      sha = line.slice(5);
+    } else if (line.startsWith("branch ")) {
+      const ref = line.slice(7);
+      branch = ref.startsWith("refs/heads/") ? ref.slice(11) : ref;
+    } else if (line === "prunable" || line.startsWith("prunable ")) {
+      prunable = true;
+    }
+  }
+  pushCurrent();
+  const normalizedCurrentWorktreePath = await normalizeWorktreePath(currentWorktreePath);
+  return Promise.all(worktrees.map(async ({ worktreePath: worktreePath2, ...checkout }) => ({
+    ...checkout,
+    isCurrent: normalizedCurrentWorktreePath !== "" && await normalizeWorktreePath(worktreePath2) === normalizedCurrentWorktreePath
+  })));
+}
+function annotateHeadReachability(commits, revListStdout) {
+  const reachable = new Set(revListStdout.split("\n").map((line) => line.trim()).filter(Boolean));
+  if (reachable.size === 0) return commits;
+  return commits.map((commit) => ({ ...commit, onHead: reachable.has(commit.fullHash) }));
+}
 function isNoHeadError2(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");
+  return error.stderr.includes("unknown revision") || error.stderr.includes("bad revision") || error.stderr.includes("does not have any commits");
+}
+async function normalizeWorktreePath(worktreePath) {
+  if (!worktreePath) return "";
+  try {
+    return await fs.realpath(worktreePath);
+  } catch {
+    return worktreePath;
+  }
+}
+async function readHeadRevList(gitCwd) {
+  try {
+    return (await runGit(["rev-list", "-n", "1000", "HEAD"], { cwd: gitCwd })).stdout;
+  } catch (error) {
+    if (error instanceof GitExecutorError) return "";
+    throw error;
+  }
+}
+async function readCurrentWorktreePath(gitCwd) {
+  try {
+    return (await runGit(["rev-parse", "--show-toplevel"], { cwd: gitCwd })).stdout.trim();
+  } catch (error) {
+    if (error instanceof GitExecutorError) return "";
+    throw error;
+  }
 }
 async function handleDiffLog(req, res, ctx) {
   if (req.method !== "POST") {
@@ -467,16 +536,25 @@ async function handleDiffLog(req, res, ctx) {
   }
   const { gitCwd } = cwdResult;
   try {
+    const [worktrees, currentWorktreePath, headRevList] = await Promise.all([
+      runGit(["worktree", "list", "--porcelain"], { cwd: gitCwd }),
+      readCurrentWorktreePath(gitCwd),
+      readHeadRevList(gitCwd)
+    ]);
+    const checkouts = await parseWorktreePorcelain(worktrees.stdout, currentWorktreePath);
+    const worktreeRevs = [...new Set(checkouts.map((checkout) => checkout.sha))].filter((sha) => WORKTREE_SHA_RE.test(sha) && !/^0+$/.test(sha));
+    const headRevs = headRevList ? ["HEAD"] : [];
     const result = await runGit(
-      ["log", "-n", "50", "--numstat", "--pretty=format:%x1e%H%x00%h%x00%s%x00%an%x00%ar%x00%D%x00%P"],
+      // --all은 refs/stash·refs/notes까지 그래프에 유입시키므로 브랜치/태그/원격 + 현재 HEAD + 워크트리 HEAD로 한정한다
+      ["log", "--branches", "--tags", "--remotes", "--date-order", "-n", "200", "--relative", "--decorate=full", "--pretty=format:%x1e%H%x00%h%x00%s%x00%an%x00%ar%x00%at%x00%D%x00%P", ...headRevs, ...worktreeRevs, "--", "."],
       { cwd: gitCwd }
     );
-    const commits = parseLogOutput(result.stdout);
-    ctx.host.http.writeJson(res, 200, { commits, ...result.truncated ? { truncated: true } : {} });
+    const commits = annotateHeadReachability(parseLogOutput(result.stdout), headRevList);
+    ctx.host.http.writeJson(res, 200, { commits, checkouts, ...result.truncated ? { truncated: true } : {} });
   } catch (error) {
     if (error instanceof GitExecutorError) {
       if (error.code === "no_git_repo") {
-        ctx.host.http.writeJson(res, 200, { commits: [] });
+        ctx.host.http.writeJson(res, 200, { commits: [], checkouts: [] });
         return;
       }
       if (error.code === "git_unavailable") {
@@ -484,7 +562,7 @@ async function handleDiffLog(req, res, ctx) {
         return;
       }
       if (isNoHeadError2(error)) {
-        ctx.host.http.writeJson(res, 200, { commits: [] });
+        ctx.host.http.writeJson(res, 200, { commits: [], checkouts: [] });
         return;
       }
       ctx.host.http.writeJson(res, 500, { error: "git_failed" });
@@ -493,190 +571,11 @@ async function handleDiffLog(req, res, ctx) {
     throw error;
   }
 }
-var REPOS_CAP = 200;
-var HARD_CAP_DEPTH = 8;
-var DEFAULT_DEPTH = 3;
-function isPlainObject4(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 detectWorktreeParent(dir, gitFileContent) {
-  const match = gitFileContent.trim().match(/^gitdir:\s*(.+)$/m);
-  if (!match) return null;
-  const rawPointer = match[1].trim();
-  const resolvedGitdir = path3.normalize(
-    path3.isAbsolute(rawPointer) ? rawPointer : path3.resolve(dir, rawPointer)
-  );
-  if (resolvedGitdir.includes(`${path3.sep}modules${path3.sep}`)) {
-    return null;
-  }
-  const worktreesSegment = `${path3.sep}.git${path3.sep}worktrees${path3.sep}`;
-  const wtIdx = resolvedGitdir.indexOf(worktreesSegment);
-  if (wtIdx === -1) {
-    return null;
-  }
-  const parentAbsRaw = resolvedGitdir.slice(0, wtIdx);
-  let parentAbs;
-  try {
-    parentAbs = await fs.realpath(parentAbsRaw);
-  } catch {
-    parentAbs = path3.normalize(parentAbsRaw);
-  }
-  return { isWorktree: true, parentAbs };
-}
-async function scanRepos(theaterPath, realTheaterPath, dir, currentDepth, maxDepth, repos, cap = REPOS_CAP) {
-  if (repos.length >= cap) return true;
-  const gitPath = path3.join(dir, ".git");
-  try {
-    const gitStat = await fs.stat(gitPath);
-    const relPath = path3.relative(theaterPath, dir);
-    const name = relPath === "" ? path3.basename(theaterPath) : path3.basename(dir);
-    const branch = await resolveRepoBranch(dir);
-    if (gitStat.isFile()) {
-      const content = await fs.readFile(gitPath, "utf8");
-      const worktreeResult = await detectWorktreeParent(dir, content);
-      if (worktreeResult) {
-        repos.push({ relPath, name, branch, isWorktree: true, _wtParentAbs: worktreeResult.parentAbs });
-      } else {
-        repos.push({ relPath, name, branch });
-      }
-    } else {
-      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 = path3.join(dir, childName);
-          let realChildPath;
-          try {
-            realChildPath = await fs.realpath(childPath);
-          } catch {
-            dirent = await dirHandle.read();
-            continue;
-          }
-          const normalizedReal = realTheaterPath.endsWith(path3.sep) ? realTheaterPath : realTheaterPath + path3.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;
-  }
-}
-function resolveWorktreeParents(raw, realTheaterPath) {
-  const absToRelPath = /* @__PURE__ */ new Map();
-  for (const entry of raw) {
-    const absDir = path3.normalize(
-      entry.relPath === "" ? realTheaterPath : path3.join(realTheaterPath, entry.relPath)
-    );
-    absToRelPath.set(absDir, entry.relPath);
-  }
-  return raw.map((entry) => {
-    const { _wtParentAbs, ...rest } = entry;
-    if (_wtParentAbs && entry.isWorktree) {
-      const normalizedParent = path3.normalize(_wtParentAbs);
-      const parentRelPath = absToRelPath.get(normalizedParent);
-      if (parentRelPath !== void 0) {
-        return { ...rest, worktreeOf: parentRelPath };
-      }
-    }
-    return rest;
-  });
-}
-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 (!isPlainObject4(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 raw = [];
-  const truncated = await scanRepos(theaterPath, realTheaterPath, theaterPath, 0, maxDepth, raw);
-  const resolved = resolveWorktreeParents(raw, realTheaterPath);
-  resolved.sort((a, b) => {
-    if (a.relPath === "") return -1;
-    if (b.relPath === "") return 1;
-    return a.relPath.localeCompare(b.relPath);
-  });
-  const result = { repos: resolved, ...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;