@dotobokuri/fleet-console 1.29.0 → 1.31.0

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

@@ -1,19 +1,19 @@
 #!/usr/bin/env node
 import { spawn } from 'child_process';
 import 'fs';
-import path2 from 'path';
-import fs from 'fs/promises';
+import path4 from 'path';
+import fs2 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, path9, handler) {
+  ctx.registerRouter(normalizePath(path9), handler);
 }
-function normalizePath(path4) {
-  if (path4.length === 0 || path4 === "/") return "/";
-  return path4;
+function normalizePath(path9) {
+  if (path9.length === 0 || path9 === "/") return "/";
+  return path9;
 }
 
 // ../../packages/core-process/src/hidden.ts
@@ -97,6 +97,72 @@ function runGit(args, opts) {
     });
   });
 }
+function isPathContained(root, candidate) {
+  const relative = path4.relative(root, candidate);
+  return relative === "" || !path4.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path4.sep}`);
+}
+function isSelectableRepoRel(repoRel) {
+  if (repoRel === "") return true;
+  if (path4.isAbsolute(repoRel)) return false;
+  const normalized = path4.normalize(repoRel);
+  return !normalized.startsWith("-") && normalized !== ".." && !normalized.startsWith(`..${path4.sep}`);
+}
+
+// ../fleet-plugins/repository/server/git-marker.ts
+var GITDIR_PREFIX = "gitdir:";
+async function resolveContainedGitDir(repoDir, realTheaterPath) {
+  const markerPath = path4.join(repoDir, ".git");
+  let marker;
+  try {
+    marker = await fs2.stat(markerPath);
+  } catch {
+    return null;
+  }
+  let gitDir;
+  if (marker.isFile()) {
+    let content;
+    try {
+      content = await fs2.readFile(markerPath, "utf8");
+    } catch {
+      return null;
+    }
+    const line = content.split("\n").find((entry) => entry.trim().startsWith(GITDIR_PREFIX));
+    if (!line) return null;
+    const target = line.trim().slice(GITDIR_PREFIX.length).trim();
+    if (!target) return null;
+    gitDir = path4.resolve(repoDir, target);
+  } else if (marker.isDirectory()) {
+    gitDir = markerPath;
+  } else {
+    return null;
+  }
+  let realGitDir;
+  try {
+    realGitDir = await fs2.realpath(gitDir);
+  } catch {
+    return null;
+  }
+  if (!isPathContained(realTheaterPath, realGitDir)) return null;
+  let commonRaw = null;
+  try {
+    commonRaw = await fs2.readFile(path4.join(realGitDir, "commondir"), "utf8");
+  } catch {
+  }
+  if (commonRaw !== null) {
+    const commonTarget = commonRaw.trim();
+    if (!commonTarget) return null;
+    let realCommonDir;
+    try {
+      realCommonDir = await fs2.realpath(path4.resolve(realGitDir, commonTarget));
+    } catch {
+      return null;
+    }
+    if (!isPathContained(realTheaterPath, realCommonDir)) return null;
+  }
+  return realGitDir;
+}
+
+// ../fleet-plugins/repository/server/diff.ts
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -154,8 +220,29 @@ function isNoHeadError(error) {
   if (error.code !== "non_zero_exit") return false;
   return error.stderr.includes("unknown revision") || error.stderr.includes("bad revision");
 }
-function resolveGitCwd(theaterPath) {
-  return { gitCwd: theaterPath };
+var InvalidRepoError = class extends Error {
+  code = "invalid_repo";
+};
+async function resolveGitCwd(theaterPath, repoRel = "") {
+  if (repoRel === void 0 || repoRel === "") return { gitCwd: theaterPath };
+  if (typeof repoRel !== "string" || path4.isAbsolute(repoRel)) throw new InvalidRepoError("Repository path must be relative");
+  if (!isSelectableRepoRel(repoRel)) throw new InvalidRepoError("Repository path is invalid");
+  const resolved = path4.resolve(theaterPath, path4.normalize(repoRel));
+  if (!isPathContained(theaterPath, resolved)) throw new InvalidRepoError("Repository path escapes Theater");
+  let realTheater;
+  let realRepo;
+  try {
+    [realTheater, realRepo] = await Promise.all([fs2.realpath(theaterPath), fs2.realpath(resolved)]);
+  } catch {
+    throw new InvalidRepoError("Repository path does not exist");
+  }
+  if (!isPathContained(realTheater, realRepo)) {
+    throw new InvalidRepoError("Repository path escapes Theater");
+  }
+  if (await resolveContainedGitDir(realRepo, realTheater) === null) {
+    throw new InvalidRepoError("Repository marker does not exist");
+  }
+  return { gitCwd: realRepo };
 }
 async function handleRepositoryChanged(req, res, ctx) {
   if (req.method !== "POST") {
@@ -181,7 +268,16 @@ async function handleRepositoryChanged(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const cwdResult = resolveGitCwd(theaterPath);
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
   const { gitCwd } = cwdResult;
   try {
     await ensureGitRepository(gitCwd);
@@ -250,15 +346,24 @@ async function handleRepositoryFile(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const cwdResult = resolveGitCwd(theaterPath);
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
   const { gitCwd } = cwdResult;
   const rawFilePath = body.filePath;
-  const resolvedFilePath = path2.resolve(gitCwd, rawFilePath);
-  if (!resolvedFilePath.startsWith(gitCwd + path2.sep) && resolvedFilePath !== gitCwd) {
+  const resolvedFilePath = path4.resolve(gitCwd, rawFilePath);
+  if (!resolvedFilePath.startsWith(gitCwd + path4.sep) && resolvedFilePath !== gitCwd) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
   }
-  const relativePath = path2.normalize(rawFilePath);
+  const relativePath = path4.normalize(rawFilePath);
   if (relativePath.startsWith("..")) {
     ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
     return;
@@ -269,14 +374,14 @@ async function handleRepositoryFile(req, res, ctx) {
       let realFile;
       try {
         [realGitCwd, realFile] = await Promise.all([
-          fs.realpath(gitCwd),
-          fs.realpath(resolvedFilePath)
+          fs2.realpath(gitCwd),
+          fs2.realpath(resolvedFilePath)
         ]);
       } catch {
         ctx.host.http.writeJson(res, 404, { error: "file_not_found" });
         return;
       }
-      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path2.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path4.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
@@ -289,10 +394,10 @@ async function handleRepositoryFile(req, res, ctx) {
     }
     try {
       const [realGitCwd, realFile] = await Promise.all([
-        fs.realpath(gitCwd),
-        fs.realpath(resolvedFilePath)
+        fs2.realpath(gitCwd),
+        fs2.realpath(resolvedFilePath)
       ]);
-      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path2.sep)) {
+      if (realFile !== realGitCwd && !realFile.startsWith(realGitCwd + path4.sep)) {
         ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
         return;
       }
@@ -369,7 +474,16 @@ async function handleRepositoryCommit(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const cwdResult = resolveGitCwd(theaterPath);
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
   const { gitCwd } = cwdResult;
   try {
     const [metaResult, nameStatusResult, numstatResult] = await Promise.all([
@@ -403,9 +517,9 @@ function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveLiteralFilePath(gitCwd, rawPath) {
-  const relativePath = path2.normalize(rawPath);
-  const resolved = path2.resolve(gitCwd, relativePath);
-  if (relativePath === ".." || relativePath.startsWith(".." + path2.sep) || !resolved.startsWith(gitCwd + path2.sep)) return null;
+  const relativePath = path4.normalize(rawPath);
+  const resolved = path4.resolve(gitCwd, relativePath);
+  if (relativePath === ".." || relativePath.startsWith(".." + path4.sep) || !resolved.startsWith(gitCwd + path4.sep)) return null;
   return relativePath;
 }
 function literalPathspec2(relativePath) {
@@ -442,7 +556,16 @@ async function handleRepositoryCommitFile(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const cwdResult = resolveGitCwd(theaterPath);
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
   const relativePath = resolveLiteralFilePath(cwdResult.gitCwd, body.filePath);
   const oldPath = typeof body.oldPath === "string" ? resolveLiteralFilePath(cwdResult.gitCwd, body.oldPath) : void 0;
   if (!relativePath || body.oldPath !== void 0 && !oldPath) {
@@ -464,10 +587,207 @@ async function handleRepositoryCommitFile(req, res, ctx) {
     throw error;
   }
 }
+
+// ../fleet-plugins/repository/server/compare.ts
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var FULL_REF_PREFIXES = ["refs/heads/", "refs/remotes/", "refs/tags/"];
+var FORBIDDEN_REF_CHARS = /[\\~^:?*\[]/;
+function hasWhitespaceOrControlChar(value) {
+  for (const ch of value) {
+    const code = ch.codePointAt(0);
+    if (code === void 0 || code <= 32 || code === 127) return true;
+  }
+  return /\s/.test(value);
+}
+function isSafeCompareRef(value) {
+  if (value === "HEAD") return true;
+  if (REF_RE.test(value)) return true;
+  if (!FULL_REF_PREFIXES.some((prefix) => value.startsWith(prefix))) return false;
+  if (hasWhitespaceOrControlChar(value) || FORBIDDEN_REF_CHARS.test(value)) return false;
+  if (value.includes("..") || value.includes("@{") || value.includes("//")) return false;
+  if (value.endsWith("/") || value.endsWith(".")) return false;
+  for (const component of value.split("/")) {
+    if (component.startsWith(".") || component.endsWith(".lock")) return false;
+  }
+  return true;
+}
+function isUnknownRevisionError(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");
+}
+function isNoMergeBaseError(error) {
+  if (!(error instanceof GitExecutorError)) return false;
+  if (error.code !== "non_zero_exit") return false;
+  return error.stderr.includes("no merge base");
+}
+async function handleRepositoryCompare(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) || "subPath" in 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 { base, head } = body;
+  if (typeof base !== "string" || typeof head !== "string" || !isSafeCompareRef(base) || !isSafeCompareRef(head)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
+    return;
+  }
+  if (base === head) {
+    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;
+  }
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
+  const { gitCwd } = cwdResult;
+  const range = `${base}...${head}`;
+  try {
+    const [mergeBaseResult, nameStatusResult, numstatResult] = await Promise.all([
+      // 비교 컨텍스트 표기용 — 실패하면 응답에서 생략한다
+      runGit(["merge-base", "--end-of-options", base, head], { cwd: gitCwd }).catch(() => null),
+      runGit(["diff", "--relative", "--name-status", "--diff-filter=MADRT", "-M", "--end-of-options", range, "--", "."], { cwd: gitCwd }),
+      runGit(["diff", "--relative", "--numstat", "--diff-filter=MADRT", "-M", "--end-of-options", range, "--", "."], { cwd: gitCwd })
+    ]);
+    const mergeBase = mergeBaseResult?.stdout.trim().slice(0, 9);
+    ctx.host.http.writeJson(res, 200, {
+      files: parseDiffFileList(nameStatusResult.stdout, numstatResult.stdout),
+      ...mergeBase ? { mergeBase } : {},
+      ...nameStatusResult.truncated || numstatResult.truncated ? { truncated: true } : {}
+    });
+  } catch (error) {
+    if (error instanceof GitExecutorError) {
+      if (error.code === "no_git_repo" || error.code === "git_unavailable") {
+        ctx.host.http.writeJson(res, 422, { error: error.code });
+        return;
+      }
+      if (isNoMergeBaseError(error)) {
+        ctx.host.http.writeJson(res, 400, { error: "no_merge_base" });
+        return;
+      }
+      if (isUnknownRevisionError(error)) {
+        ctx.host.http.writeJson(res, 400, { error: "unknown_ref" });
+        return;
+      }
+      ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+      return;
+    }
+    throw error;
+  }
+}
+function isPlainObject5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveLiteralFilePath2(gitCwd, rawPath) {
+  const relativePath = path4.normalize(rawPath);
+  const resolved = path4.resolve(gitCwd, relativePath);
+  if (relativePath === ".." || relativePath.startsWith(".." + path4.sep) || !resolved.startsWith(gitCwd + path4.sep)) return null;
+  return relativePath;
+}
+function literalPathspec3(relativePath) {
+  return `:(literal)${relativePath}`;
+}
+async function handleRepositoryCompareFile(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 (!isPlainObject5(body) || "subPath" in body || typeof body.theaterId !== "string" || typeof body.base !== "string" || typeof body.head !== "string" || typeof body.filePath !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  if (!isSafeCompareRef(body.base) || !isSafeCompareRef(body.head)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
+    return;
+  }
+  if (!body.filePath) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_file_path" });
+    return;
+  }
+  if (body.oldPath !== void 0 && (typeof body.oldPath !== "string" || !body.oldPath)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_file_path" });
+    return;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
+  const relativePath = resolveLiteralFilePath2(cwdResult.gitCwd, body.filePath);
+  const oldPath = typeof body.oldPath === "string" ? resolveLiteralFilePath2(cwdResult.gitCwd, body.oldPath) : void 0;
+  if (!relativePath || body.oldPath !== void 0 && !oldPath) {
+    ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
+    return;
+  }
+  const range = `${body.base}...${body.head}`;
+  try {
+    const result = await runGit(oldPath ? ["diff", "--unified=3", "-M", "--end-of-options", range, "--", literalPathspec3(oldPath), literalPathspec3(relativePath)] : ["diff", "--unified=3", "-M", "--end-of-options", range, "--", literalPathspec3(relativePath)], { cwd: cwdResult.gitCwd });
+    ctx.host.http.writeJson(res, 200, { content: result.stdout, ...result.truncated ? { truncated: true } : {} });
+  } catch (error) {
+    if (error instanceof GitExecutorError) {
+      if (error.code === "no_git_repo" || error.code === "git_unavailable") {
+        ctx.host.http.writeJson(res, 422, { error: error.code });
+        return;
+      }
+      if (isNoMergeBaseError(error)) {
+        ctx.host.http.writeJson(res, 400, { error: "no_merge_base" });
+        return;
+      }
+      if (isUnknownRevisionError(error)) {
+        ctx.host.http.writeJson(res, 400, { error: "unknown_ref" });
+        return;
+      }
+      ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+      return;
+    }
+    throw error;
+  }
+}
 var WORKTREE_SHA_RE = /^[0-9a-f]{40}$/;
 var CANONICAL_REF_RE = /^refs\/(?:heads|remotes|tags)\//;
 var REF_METACHAR_RE = /[~^:?*\[\\\s\x00-\x1f\x7f]/;
-function isPlainObject4(value) {
+function isPlainObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isCanonicalRepositoryRef(ref) {
@@ -507,7 +827,7 @@ function parseLogOutput(stdout) {
   }
   return commits;
 }
-async function parseWorktreePorcelain(stdout, currentWorktreePath) {
+function parseWorktreePorcelainEntries(stdout) {
   const worktrees = [];
   let worktreePath = null;
   let sha = "";
@@ -538,10 +858,14 @@ async function parseWorktreePorcelain(stdout, currentWorktreePath) {
     }
   }
   pushCurrent();
+  return worktrees;
+}
+async function parseWorktreePorcelain(stdout, currentWorktreePath) {
+  const worktrees = parseWorktreePorcelainEntries(stdout);
   const normalizedCurrentWorktreePath = await normalizeWorktreePath(currentWorktreePath);
-  return Promise.all(worktrees.map(async ({ worktreePath: worktreePath2, ...checkout }) => ({
+  return Promise.all(worktrees.map(async ({ worktreePath, ...checkout }) => ({
     ...checkout,
-    isCurrent: normalizedCurrentWorktreePath !== "" && await normalizeWorktreePath(worktreePath2) === normalizedCurrentWorktreePath
+    isCurrent: normalizedCurrentWorktreePath !== "" && await normalizeWorktreePath(worktreePath) === normalizedCurrentWorktreePath
   })));
 }
 function annotateHeadReachability(commits, revListStdout) {
@@ -557,7 +881,7 @@ function isNoHeadError2(error) {
 async function normalizeWorktreePath(worktreePath) {
   if (!worktreePath) return "";
   try {
-    return await fs.realpath(worktreePath);
+    return await fs2.realpath(worktreePath);
   } catch {
     return worktreePath;
   }
@@ -588,7 +912,7 @@ async function handleRepositoryLog(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject4(body) || "subPath" in body) {
+  if (!isPlainObject6(body) || "subPath" in body) {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -602,7 +926,16 @@ async function handleRepositoryLog(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const cwdResult = resolveGitCwd(theaterPath);
+  let cwdResult;
+  try {
+    cwdResult = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
   const { gitCwd } = cwdResult;
   const requestedRef = body.ref;
   if (requestedRef !== void 0 && (typeof requestedRef !== "string" || !isCanonicalRepositoryRef(requestedRef))) {
@@ -691,7 +1024,16 @@ async function handleRepositoryRefs(req, res, ctx) {
     ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
     return;
   }
-  const resolved = resolveGitCwd(theaterPath);
+  let resolved;
+  try {
+    resolved = await resolveGitCwd(theaterPath, body.repoRel);
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
   try {
     const [head, local, remote, tags, stashes] = await Promise.all([
       runGit(["symbolic-ref", "--quiet", "HEAD"], { cwd: resolved.gitCwd, allowExitCodes: [1] }),
@@ -722,11 +1064,240 @@ async function handleRepositoryRefs(req, res, ctx) {
     ctx.host.http.writeJson(res, 500, { error: "git_failed" });
   }
 }
+var REPOS_CAP = 200;
+var HARD_CAP_DEPTH = 8;
+var NESTED_BRANCH_CAP = 64;
+var SCAN_VISIT_BUDGET = 1e4;
+var DEFAULT_DEPTH = 3;
+function isPlainObject7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function resolveRepoBranch(repoDir) {
+  try {
+    const result = await runGit(["status", "--porcelain=v2", "--branch", "--untracked-files=no"], { cwd: repoDir });
+    const branch = result.stdout.split("\n").find((line) => line.startsWith("# branch.head "))?.slice(14).trim() ?? "";
+    const oid = result.stdout.split("\n").find((line) => line.startsWith("# branch.oid "))?.slice(13).trim() ?? "";
+    return branch === "(detached)" ? oid.slice(0, 7) : branch;
+  } catch {
+    return "";
+  }
+}
+async function scanRepos(theaterPath, realTheaterPath, dir, currentDepth, maxDepth, repos, cap = REPOS_CAP, visits = { remaining: SCAN_VISIT_BUDGET }) {
+  if (repos.length >= cap) return true;
+  if (visits.remaining <= 0) return true;
+  visits.remaining -= 1;
+  const relPath = path4.relative(realTheaterPath, dir);
+  const gitDir = isSelectableRepoRel(relPath) ? await resolveContainedGitDir(dir, realTheaterPath) : null;
+  let linkedWorktree = false;
+  if (gitDir !== null) {
+    try {
+      await fs2.access(path4.join(gitDir, "commondir"));
+      linkedWorktree = true;
+    } catch {
+    }
+  }
+  if (gitDir !== null && !linkedWorktree) {
+    repos.push({ relPath, name: relPath === "" ? path4.basename(realTheaterPath) : path4.basename(dir), repoDir: dir });
+    if (repos.length >= cap) return true;
+  }
+  if (currentDepth >= maxDepth) return false;
+  let dirHandle = null;
+  try {
+    dirHandle = await fs2.opendir(dir);
+    let dirent = await dirHandle.read();
+    while (dirent !== null) {
+      if (repos.length >= cap || visits.remaining <= 0) return true;
+      if (dirent.isDirectory() && dirent.name !== "node_modules" && dirent.name !== ".git") {
+        const childPath = path4.join(dir, dirent.name);
+        let realChildPath;
+        try {
+          realChildPath = await fs2.realpath(childPath);
+        } catch {
+          dirent = await dirHandle.read();
+          continue;
+        }
+        if (isPathContained(realTheaterPath, realChildPath)) {
+          const truncated = await scanRepos(realTheaterPath, realTheaterPath, realChildPath, currentDepth + 1, maxDepth, repos, cap, visits);
+          if (truncated) return true;
+        }
+      }
+      dirent = await dirHandle.read();
+    }
+    return false;
+  } catch {
+    return false;
+  } finally {
+    if (dirHandle) {
+      try {
+        await dirHandle.close();
+      } catch {
+      }
+    }
+  }
+}
+async function resolveNestedRepoCandidates(candidates, availableSlots, resolver = resolveRepoBranch) {
+  const resolved = [];
+  const selected = candidates.slice(0, Math.max(0, availableSlots));
+  for (const [index, candidate] of selected.entries()) {
+    resolved.push({
+      relPath: candidate.relPath,
+      name: candidate.name,
+      branch: index < NESTED_BRANCH_CAP ? await resolver(candidate.repoDir) : "",
+      kind: "nested"
+    });
+  }
+  return resolved;
+}
+async function handleRepositoryRepos(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 (!isPlainObject7(body) || typeof body.theaterId !== "string") {
+    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;
+  }
+  let realTheaterPath;
+  try {
+    realTheaterPath = await fs2.realpath(theaterPath);
+  } catch {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
+  const maxDepth = typeof body.maxDepth === "number" && Number.isFinite(body.maxDepth) ? Math.max(1, Math.min(HARD_CAP_DEPTH, Math.floor(body.maxDepth))) : DEFAULT_DEPTH;
+  const repos = [];
+  const seen = /* @__PURE__ */ new Set();
+  let truncated = false;
+  let rootIsRepo = await resolveContainedGitDir(realTheaterPath, realTheaterPath) !== null;
+  if (!rootIsRepo) {
+    try {
+      const inside = await runGit(["rev-parse", "--is-inside-work-tree"], { cwd: theaterPath });
+      rootIsRepo = inside.stdout.trim() === "true";
+    } catch {
+    }
+  }
+  if (rootIsRepo) {
+    repos.push({ relPath: "", name: path4.basename(theaterPath), branch: await resolveRepoBranch(theaterPath), kind: "root" });
+    seen.add("");
+  }
+  const scanned = [];
+  const scanCap = Math.max(0, REPOS_CAP - repos.length);
+  truncated = await scanRepos(realTheaterPath, realTheaterPath, realTheaterPath, 0, maxDepth, scanned, scanCap) || truncated;
+  const unseenNested = scanned.filter((candidate) => !seen.has(candidate.relPath));
+  const remainingSlots = Math.max(0, REPOS_CAP - repos.length);
+  if (unseenNested.length > remainingSlots) truncated = true;
+  const nestedCandidates = await resolveNestedRepoCandidates(unseenNested, remainingSlots);
+  for (const candidate of nestedCandidates) {
+    if (repos.length >= REPOS_CAP) {
+      truncated = true;
+      break;
+    }
+    repos.push(candidate);
+    seen.add(candidate.relPath);
+  }
+  const result = { repos, ...truncated ? { truncated: true } : {} };
+  ctx.host.http.writeJson(res, 200, result);
+}
+function isPlainObject8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function handleRepositoryWorktrees(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 (!isPlainObject8(body) || "subPath" in body || typeof body.theaterId !== "string") {
+    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;
+  }
+  let gitCwd;
+  try {
+    ({ gitCwd } = await resolveGitCwd(theaterPath, body.repoRel));
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return;
+    }
+    throw error;
+  }
+  let realTheaterPath;
+  let realGitCwd;
+  try {
+    [realTheaterPath, realGitCwd] = await Promise.all([fs2.realpath(theaterPath), fs2.realpath(gitCwd)]);
+  } catch {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_repo" });
+    return;
+  }
+  try {
+    const result = await runGit(["worktree", "list", "--porcelain"], { cwd: gitCwd });
+    const worktrees = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const worktree of parseWorktreePorcelainEntries(result.stdout)) {
+      let realWorktree;
+      try {
+        realWorktree = await fs2.realpath(worktree.worktreePath);
+      } catch {
+        continue;
+      }
+      if (!isPathContained(realTheaterPath, realWorktree)) continue;
+      const relPath = path4.relative(realTheaterPath, realWorktree);
+      if (!isSelectableRepoRel(relPath) || seen.has(relPath)) continue;
+      if (await resolveContainedGitDir(realWorktree, realTheaterPath) === null) continue;
+      worktrees.push({
+        relPath,
+        name: path4.basename(realWorktree),
+        branch: worktree.branch ?? worktree.sha.slice(0, 7),
+        current: realWorktree === realGitCwd
+      });
+      seen.add(relPath);
+    }
+    const payload = { worktrees };
+    ctx.host.http.writeJson(res, 200, payload);
+  } catch (error) {
+    if (error instanceof GitExecutorError) {
+      if (error.code === "no_git_repo" || error.code === "git_unavailable") {
+        ctx.host.http.writeJson(res, 422, { error: error.code });
+        return;
+      }
+      ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+      return;
+    }
+    throw error;
+  }
+}
 
 // ../fleet-plugins/repository/routes.ts
 var routes_default = definePlugin({
   id: "repository",
   register(ctx) {
+    registerRouter(ctx, "repos", async ({ req, res }) => {
+      await handleRepositoryRepos(req, res, ctx);
+      return true;
+    });
+    registerRouter(ctx, "worktrees", async ({ req, res }) => {
+      await handleRepositoryWorktrees(req, res, ctx);
+      return true;
+    });
     registerRouter(ctx, "changed", async ({ req, res }) => {
       await handleRepositoryChanged(req, res, ctx);
       return true;
@@ -751,6 +1322,14 @@ var routes_default = definePlugin({
       await handleRepositoryCommitFile(req, res, ctx);
       return true;
     });
+    registerRouter(ctx, "compare", async ({ req, res }) => {
+      await handleRepositoryCompare(req, res, ctx);
+      return true;
+    });
+    registerRouter(ctx, "compare-file", async ({ req, res }) => {
+      await handleRepositoryCompareFile(req, res, ctx);
+      return true;
+    });
   }
 });