@dotobokuri/fleet-console 1.67.0 → 1.68.0

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

@@ -7,16 +7,16 @@ import path3 from 'node:path';
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path9, handler, catalog) {
+function registerRouter(ctx, path12, handler, catalog) {
   if (catalog) {
-    ctx.registerRouter(normalizePath(path9), handler, catalog);
+    ctx.registerRouter(normalizePath(path12), handler, catalog);
     return;
   }
-  ctx.registerRouter(normalizePath(path9), handler);
+  ctx.registerRouter(normalizePath(path12), handler);
 }
-function normalizePath(path9) {
-  if (path9.length === 0 || path9 === "/") return "/";
-  return path9;
+function normalizePath(path12) {
+  if (path12.length === 0 || path12 === "/") return "/";
+  return path12;
 }
 
 // ../../packages/core-process/src/bin-resolver.ts
@@ -418,7 +418,7 @@ async function handleRepositoryFile(req, res, ctx) {
     return;
   }
   const mode = body.mode;
-  if (mode !== "unified" && mode !== "untracked") {
+  if (mode !== "unified" && mode !== "untracked" && mode !== "staged" && mode !== "worktree") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_mode" });
     return;
   }
@@ -490,11 +490,17 @@ async function handleRepositoryFile(req, res, ctx) {
     } catch {
     }
     let result;
-    try {
-      result = await runGit(["diff", "--no-ext-diff", "--no-textconv", "HEAD", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
-    } catch (err) {
-      if (!isNoHeadError(err)) throw err;
+    if (mode === "worktree") {
+      result = await runGit(["diff", "--no-ext-diff", "--no-textconv", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
+    } else if (mode === "staged") {
       result = await runGit(["diff", "--no-ext-diff", "--no-textconv", "--cached", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
+    } else {
+      try {
+        result = await runGit(["diff", "--no-ext-diff", "--no-textconv", "HEAD", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
+      } catch (err) {
+        if (!isNoHeadError(err)) throw err;
+        result = await runGit(["diff", "--no-ext-diff", "--no-textconv", "--cached", "--relative", "--unified=3", "--", literalPathspec(relativePath)], { cwd: gitCwd });
+      }
     }
     ctx.host.http.writeJson(res, 200, { content: result.stdout, truncated: result.truncated });
   } catch (error) {
@@ -602,6 +608,254 @@ async function handleRepositoryCommit(req, res, ctx) {
 function isPlainObject3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+var MAX_PATHS_PER_REQUEST = 1e3;
+function readStagePaths(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.length > MAX_PATHS_PER_REQUEST) return null;
+  const paths = [];
+  for (const raw of value) {
+    if (typeof raw !== "string" || raw === "" || raw.includes("\0")) return null;
+    if (path3.isAbsolute(raw) || path3.posix.isAbsolute(raw)) return null;
+    const normalized = path3.posix.normalize(raw);
+    if (normalized === ".." || normalized.startsWith("../")) return null;
+    paths.push(raw);
+  }
+  return paths;
+}
+function literalPathspecs(paths) {
+  return paths.map((entry) => `:(literal)${entry}`);
+}
+function classifyWriteError(stderr) {
+  return /index\.lock|Unable to create .* File exists/i.test(stderr) ? "index_locked" : null;
+}
+async function resolveWriteContext(req, res, ctx) {
+  if (req.method !== "POST") {
+    ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
+    return null;
+  }
+  if (!ctx.host.security.isTerminalAuthorized(req)) {
+    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
+    return null;
+  }
+  const body = await ctx.host.http.readJsonBody(req);
+  if (!isPlainObject3(body) || "subPath" in body || typeof body.theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return null;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return null;
+  }
+  try {
+    const { gitCwd } = await resolveGitCwd(theaterPath, body.repoRel);
+    return { gitCwd, body };
+  } catch (error) {
+    if (error instanceof InvalidRepoError) {
+      ctx.host.http.writeJson(res, 400, { error: error.code });
+      return null;
+    }
+    throw error;
+  }
+}
+function writeGitFailure(res, ctx, 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 (error.code === "timeout") {
+      ctx.host.http.writeJson(res, 422, { error: "timeout" });
+      return;
+    }
+    const locked = classifyWriteError(error.stderr);
+    if (locked) {
+      ctx.host.http.writeJson(res, 409, { error: locked });
+      return;
+    }
+    ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+    return;
+  }
+  throw error;
+}
+async function handleRepositoryStage(req, res, ctx) {
+  const resolved = await resolveWriteContext(req, res, ctx);
+  if (!resolved) return;
+  if (resolved.body.all === true) {
+    try {
+      await runGit(["add", "-A", "--", "."], { cwd: resolved.gitCwd });
+      ctx.host.http.writeJson(res, 200, { ok: true });
+    } catch (error) {
+      writeGitFailure(res, ctx, error);
+    }
+    return;
+  }
+  const paths = readStagePaths(resolved.body.paths);
+  if (!paths) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_paths" });
+    return;
+  }
+  try {
+    await runGit(["add", "--", ...literalPathspecs(paths)], { cwd: resolved.gitCwd });
+    ctx.host.http.writeJson(res, 200, { ok: true });
+  } catch (error) {
+    writeGitFailure(res, ctx, error);
+  }
+}
+async function handleRepositoryUnstage(req, res, ctx) {
+  const resolved = await resolveWriteContext(req, res, ctx);
+  if (!resolved) return;
+  const all = resolved.body.all === true;
+  const paths = all ? [] : readStagePaths(resolved.body.paths);
+  if (!paths) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_paths" });
+    return;
+  }
+  const pathspecs = all ? ["."] : literalPathspecs(paths);
+  try {
+    try {
+      await runGit(["restore", "--staged", "--", ...pathspecs], { cwd: resolved.gitCwd });
+    } catch (error) {
+      if (!(error instanceof GitExecutorError) || !/could not resolve HEAD|unknown revision|bad revision/i.test(error.stderr)) throw error;
+      await runGit(["rm", "-r", "--cached", "-q", "--", ...pathspecs], { cwd: resolved.gitCwd });
+    }
+    ctx.host.http.writeJson(res, 200, { ok: true });
+  } catch (error) {
+    writeGitFailure(res, ctx, error);
+  }
+}
+async function handleRepositoryDiscard(req, res, ctx) {
+  const resolved = await resolveWriteContext(req, res, ctx);
+  if (!resolved) return;
+  const hasTracked = resolved.body.paths !== void 0;
+  const hasUntracked = resolved.body.untrackedPaths !== void 0;
+  if (!hasTracked && !hasUntracked) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_paths" });
+    return;
+  }
+  const tracked = hasTracked ? readStagePaths(resolved.body.paths) : [];
+  const untracked = hasUntracked ? readStagePaths(resolved.body.untrackedPaths) : [];
+  if (tracked === null || untracked === null) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_paths" });
+    return;
+  }
+  try {
+    if (tracked.length > 0) {
+      await runGit(["restore", "--worktree", "--", ...literalPathspecs(tracked)], { cwd: resolved.gitCwd });
+    }
+    if (untracked.length > 0) {
+      await runGit(["clean", "-f", "-d", "--", ...literalPathspecs(untracked)], { cwd: resolved.gitCwd });
+    }
+    ctx.host.http.writeJson(res, 200, { ok: true });
+  } catch (error) {
+    writeGitFailure(res, ctx, error);
+  }
+}
+
+// ../fleet-plugins/repository/server/commit-create.ts
+function isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var MAX_SUBJECT_LENGTH = 500;
+var MAX_BODY_LENGTH = 1e5;
+var COMMIT_HARDENING_ARGS = [
+  "-c",
+  `core.hooksPath=${process.platform === "win32" ? "NUL" : "/dev/null"}`,
+  "-c",
+  "commit.gpgSign=false"
+];
+async function hasStagedChanges(gitCwd) {
+  try {
+    return (await runGit(["diff", "--cached", "--name-only", "--", "."], { cwd: gitCwd })).stdout.trim() !== "";
+  } catch (error) {
+    if (error instanceof GitExecutorError && /unknown revision|bad revision|ambiguous argument/i.test(error.stderr)) {
+      return (await runGit(["ls-files", "--cached"], { cwd: gitCwd })).stdout.trim() !== "";
+    }
+    throw error;
+  }
+}
+function classifyCommitError(stderr) {
+  if (/Please tell me who you are|unable to auto-detect email address|empty ident name/i.test(stderr)) return "identity_missing";
+  if (/nothing to commit|no changes added to commit|nothing added to commit/i.test(stderr)) return "nothing_to_commit";
+  return null;
+}
+async function handleRepositoryCommitCreate(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 || typeof body.theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const subject = typeof body.subject === "string" ? body.subject.trim() : "";
+  const message = body.message === void 0 ? "" : body.message;
+  const amend = body.amend === true;
+  if (subject === "" || subject.length > MAX_SUBJECT_LENGTH || typeof message !== "string" || message.length > MAX_BODY_LENGTH || subject.includes("\0") || message.includes("\0")) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_message" });
+    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;
+  }
+  try {
+    if (!amend && !await hasStagedChanges(gitCwd)) {
+      ctx.host.http.writeJson(res, 422, { error: "nothing_to_commit" });
+      return;
+    }
+    const trimmedMessage = message.trim();
+    const result = await runGit([
+      ...COMMIT_HARDENING_ARGS,
+      "commit",
+      "--no-verify",
+      ...amend ? ["--amend"] : [],
+      "-m",
+      subject,
+      ...trimmedMessage ? ["-m", trimmedMessage] : []
+    ], { cwd: gitCwd });
+    const sha = (await runGit(["rev-parse", "HEAD"], { cwd: gitCwd })).stdout.trim();
+    ctx.host.http.writeJson(res, 200, { ok: true, sha, summary: result.stdout.split("\n")[0] ?? "" });
+  } catch (error) {
+    if (error instanceof GitExecutorError) {
+      const classified = classifyCommitError(error.stderr) ?? classifyCommitError(error.message);
+      if (classified) {
+        ctx.host.http.writeJson(res, 422, { error: classified });
+        return;
+      }
+      const locked = classifyWriteError(error.stderr);
+      if (locked) {
+        ctx.host.http.writeJson(res, 409, { error: locked });
+        return;
+      }
+      if (error.code === "no_git_repo" || error.code === "git_unavailable" || error.code === "timeout") {
+        ctx.host.http.writeJson(res, 422, { error: error.code });
+        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 resolveLiteralFilePath(gitCwd, rawPath) {
   const relativePath = path3.normalize(rawPath);
   const resolved = path3.resolve(gitCwd, relativePath);
@@ -621,7 +875,7 @@ async function handleRepositoryCommitFile(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject3(body) || "subPath" in body || typeof body.theaterId !== "string" || typeof body.ref !== "string" || typeof body.filePath !== "string") {
+  if (!isPlainObject5(body) || "subPath" in body || typeof body.theaterId !== "string" || typeof body.ref !== "string" || typeof body.filePath !== "string") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -675,7 +929,7 @@ async function handleRepositoryCommitFile(req, res, ctx) {
 }
 
 // ../fleet-plugins/repository/server/compare.ts
-function isPlainObject4(value) {
+function isPlainObject6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var FULL_REF_PREFIXES = ["refs/heads/", "refs/remotes/", "refs/tags/"];
@@ -719,7 +973,7 @@ async function handleRepositoryCompare(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;
   }
@@ -787,7 +1041,7 @@ async function handleRepositoryCompare(req, res, ctx) {
     throw error;
   }
 }
-function isPlainObject5(value) {
+function isPlainObject7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveLiteralFilePath2(gitCwd, rawPath) {
@@ -809,7 +1063,7 @@ async function handleRepositoryCompareFile(req, res, ctx) {
     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") {
+  if (!isPlainObject7(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;
   }
@@ -873,7 +1127,7 @@ async function handleRepositoryCompareFile(req, res, ctx) {
 var AUTO_FETCH_THROTTLE_MS = 3e5;
 var autoFetchInFlight = /* @__PURE__ */ new Map();
 var lastSuccessfulFetchAt = /* @__PURE__ */ new Map();
-function isPlainObject6(value) {
+function isPlainObject8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function classifyFetchError(stderr) {
@@ -922,6 +1176,16 @@ function countFetchUpdatedRefs(stderr) {
 }
 var NoRemoteError = class extends Error {
 };
+var NETWORK_HARDENING_ARGS = [
+  "-c",
+  "core.sshCommand=ssh",
+  "-c",
+  "core.gitProxy=none",
+  "-c",
+  "protocol.ext.allow=never",
+  "-c",
+  `core.hooksPath=${process.platform === "win32" ? "NUL" : "/dev/null"}`
+];
 var SAFE_CREDENTIAL_HELPERS = /* @__PURE__ */ new Set([
   "cache",
   "store",
@@ -1043,7 +1307,7 @@ async function handleRepositoryFetch(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject6(body) || "subPath" in body || typeof body.theaterId !== "string" || body.mode !== void 0 && body.mode !== "auto") {
+  if (!isPlainObject8(body) || "subPath" in body || typeof body.theaterId !== "string" || body.mode !== void 0 && body.mode !== "auto") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -1103,7 +1367,7 @@ function resolveLogOrder(requested) {
   if (requested === void 0) return "topo";
   return requested === "topo" || requested === "date" ? requested : null;
 }
-function isPlainObject7(value) {
+function isPlainObject9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isCanonicalRepositoryRef(ref) {
@@ -1230,7 +1494,7 @@ async function handleRepositoryLog(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject7(body) || "subPath" in body) {
+  if (!isPlainObject9(body) || "subPath" in body) {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -1319,6 +1583,145 @@ async function handleRepositoryLog(req, res, ctx) {
   }
 }
 
+// ../fleet-plugins/repository/server/remote.ts
+function isPlainObject10(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var REMOTE_TIMEOUT_MS = 12e4;
+function classifyPushError(stderr) {
+  return /non-fast-forward|fetch first|updates were rejected/i.test(stderr) ? "non_fast_forward" : null;
+}
+function classifyPullError(stderr) {
+  if (/not possible to fast-forward|need to specify how to reconcile|diverg/i.test(stderr)) return "non_fast_forward";
+  if (/overwritten by merge|Please commit your changes or stash/i.test(stderr)) return "dirty_worktree";
+  return null;
+}
+async function resolveRemoteContext(req, res, ctx) {
+  if (req.method !== "POST") {
+    ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
+    return null;
+  }
+  if (!ctx.host.security.isTerminalAuthorized(req)) {
+    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
+    return null;
+  }
+  const body = await ctx.host.http.readJsonBody(req);
+  if (!isPlainObject10(body) || "subPath" in body || typeof body.theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return null;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return null;
+  }
+  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 null;
+    }
+    throw error;
+  }
+  try {
+    const branch = (await runGit(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd: gitCwd, allowExitCodes: [1] })).stdout.trim();
+    if (!branch) {
+      ctx.host.http.writeJson(res, 422, { error: "detached_head" });
+      return null;
+    }
+    return { gitCwd, branch };
+  } catch (error) {
+    writeRemoteFailure(res, ctx, error, () => null);
+    return null;
+  }
+}
+function writeRemoteFailure(res, ctx, error, classify) {
+  if (error instanceof NoRemoteError) {
+    ctx.host.http.writeJson(res, 422, { error: "no_remote" });
+    return;
+  }
+  if (error instanceof GitExecutorError) {
+    if (error.code === "timeout") {
+      ctx.host.http.writeJson(res, 422, { error: "timeout" });
+      return;
+    }
+    const specific = classify(error.stderr);
+    if (specific) {
+      ctx.host.http.writeJson(res, 409, { error: specific });
+      return;
+    }
+    const network = classifyFetchError(error.stderr);
+    if (network) {
+      ctx.host.http.writeJson(res, 422, { error: network });
+      return;
+    }
+    const locked = classifyWriteError(error.stderr);
+    if (locked) {
+      ctx.host.http.writeJson(res, 409, { error: locked });
+      return;
+    }
+    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;
+}
+async function handleRepositoryPush(req, res, ctx) {
+  const remoteCtx = await resolveRemoteContext(req, res, ctx);
+  if (!remoteCtx) return;
+  const { gitCwd, branch } = remoteCtx;
+  try {
+    const upstreamRemote = (await runGit(["config", "--get", `branch.${branch}.remote`], { cwd: gitCwd, allowExitCodes: [1] })).stdout.trim();
+    const remote = upstreamRemote && upstreamRemote !== "." ? upstreamRemote : await resolveDefaultRemote(gitCwd);
+    if (!remote) throw new NoRemoteError();
+    const credentialArgs = await resolveCredentialHelperArgs(gitCwd);
+    await runGit([
+      ...NETWORK_HARDENING_ARGS,
+      ...credentialArgs,
+      "push",
+      // repo config의 remote.<name>.receivepack이 로컬 transport에서 명령 실행되므로 표준 명령을 강제한다.
+      "--receive-pack=git-receive-pack",
+      "--no-recurse-submodules",
+      ...upstreamRemote ? [] : ["--set-upstream"],
+      remote,
+      `refs/heads/${branch}:refs/heads/${branch}`
+    ], { cwd: gitCwd, timeoutMs: REMOTE_TIMEOUT_MS });
+    ctx.host.http.writeJson(res, 200, { ok: true, remote, branch });
+  } catch (error) {
+    writeRemoteFailure(res, ctx, error, classifyPushError);
+  }
+}
+async function handleRepositoryPull(req, res, ctx) {
+  const remoteCtx = await resolveRemoteContext(req, res, ctx);
+  if (!remoteCtx) return;
+  const { gitCwd, branch } = remoteCtx;
+  try {
+    const upstreamRemote = (await runGit(["config", "--get", `branch.${branch}.remote`], { cwd: gitCwd, allowExitCodes: [1] })).stdout.trim();
+    if (!upstreamRemote || upstreamRemote === ".") {
+      ctx.host.http.writeJson(res, 422, { error: "no_upstream" });
+      return;
+    }
+    const credentialArgs = await resolveCredentialHelperArgs(gitCwd);
+    await runGit([
+      ...NETWORK_HARDENING_ARGS,
+      ...credentialArgs,
+      "pull",
+      "--ff-only",
+      "--no-rebase",
+      "--upload-pack=git-upload-pack",
+      "--no-recurse-submodules"
+    ], { cwd: gitCwd, timeoutMs: REMOTE_TIMEOUT_MS });
+    ctx.host.http.writeJson(res, 200, { ok: true, remote: upstreamRemote, branch });
+  } catch (error) {
+    writeRemoteFailure(res, ctx, error, classifyPullError);
+  }
+}
+
 // ../fleet-plugins/repository/server/refs.ts
 function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -1421,7 +1824,7 @@ var HARD_CAP_DEPTH = 8;
 var NESTED_BRANCH_CAP = 64;
 var SCAN_VISIT_BUDGET = 1e4;
 var DEFAULT_DEPTH = 3;
-function isPlainObject8(value) {
+function isPlainObject11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function resolveRepoBranch(repoDir) {
@@ -1510,7 +1913,7 @@ async function handleRepositoryRepos(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject8(body) || typeof body.theaterId !== "string") {
+  if (!isPlainObject11(body) || typeof body.theaterId !== "string") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -1589,7 +1992,7 @@ async function handleRepositorySearch(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject9(body) || typeof body.theaterId !== "string" || typeof body.query !== "string" || body.query.trim() === "" || !Number.isInteger(body.limit) || body.limit < 1 || body.limit > 8 || "subPath" in body || "ref" in body) {
+  if (!isPlainObject12(body) || typeof body.theaterId !== "string" || typeof body.query !== "string" || body.query.trim() === "" || !Number.isInteger(body.limit) || body.limit < 1 || body.limit > 8 || "subPath" in body || "ref" in body) {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -1643,10 +2046,451 @@ async function handleRepositorySearch(req, res, ctx) {
     throw error;
   }
 }
-function isPlainObject9(value) {
+function isPlainObject12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isPlainObject10(value) {
+
+// ../fleet-plugins/repository/server/stash.ts
+function isPlainObject13(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var STASH_NAME_RE = /^stash@\{\d{1,4}\}$/;
+var MAX_STASH_MESSAGE_LENGTH = 500;
+var STASH_HARDENING_ARGS = [
+  "-c",
+  `core.hooksPath=${process.platform === "win32" ? "NUL" : "/dev/null"}`
+];
+function readStashAction(value) {
+  return value === "save" || value === "apply" || value === "pop" || value === "drop" ? value : null;
+}
+function classifyStashError(stderr) {
+  if (/conflict|could not restore untracked files|overwritten by merge/i.test(stderr)) return "stash_conflict";
+  if (/No local changes to save/i.test(stderr)) return "nothing_to_stash";
+  return null;
+}
+async function handleRepositoryStash(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 (!isPlainObject13(body) || "subPath" in body || typeof body.theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const action = readStashAction(body.action);
+  if (!action) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const name = body.name;
+  if (action !== "save" && (typeof name !== "string" || !STASH_NAME_RE.test(name))) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_stash" });
+    return;
+  }
+  const sha = body.sha;
+  if (action !== "save" && (typeof sha !== "string" || !/^[0-9a-f]{7,40}$/i.test(sha))) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_stash" });
+    return;
+  }
+  const message = body.message === void 0 ? "" : body.message;
+  if (typeof message !== "string" || message.length > MAX_STASH_MESSAGE_LENGTH || message.includes("\0") || message.trimStart().startsWith("-")) {
+    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;
+  }
+  try {
+    if (action === "save") {
+      const trimmed = message.trim();
+      const result = await runGit([
+        ...STASH_HARDENING_ARGS,
+        "stash",
+        "push",
+        "-u",
+        ...trimmed ? ["-m", trimmed] : []
+      ], { cwd: gitCwd });
+      if (/No local changes to save/i.test(result.stdout)) {
+        ctx.host.http.writeJson(res, 422, { error: "nothing_to_stash" });
+        return;
+      }
+      ctx.host.http.writeJson(res, 200, { ok: true });
+      return;
+    }
+    let resolved;
+    try {
+      resolved = (await runGit(["rev-parse", "--verify", `${name}`], { cwd: gitCwd })).stdout.trim();
+    } catch (error) {
+      if (error instanceof GitExecutorError && error.code === "non_zero_exit") {
+        ctx.host.http.writeJson(res, 409, { error: "stash_moved" });
+        return;
+      }
+      throw error;
+    }
+    if (!resolved.toLowerCase().startsWith(sha.toLowerCase())) {
+      ctx.host.http.writeJson(res, 409, { error: "stash_moved" });
+      return;
+    }
+    await runGit([...STASH_HARDENING_ARGS, "stash", action, name], { cwd: gitCwd });
+    ctx.host.http.writeJson(res, 200, { ok: true });
+  } catch (error) {
+    if (error instanceof GitExecutorError) {
+      const classified = classifyStashError(error.stderr);
+      if (classified) {
+        ctx.host.http.writeJson(res, 409, { error: classified });
+        return;
+      }
+      const locked = classifyWriteError(error.stderr);
+      if (locked) {
+        ctx.host.http.writeJson(res, 409, { error: locked });
+        return;
+      }
+      if (error.code === "no_git_repo" || error.code === "git_unavailable" || error.code === "timeout") {
+        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/server/status.ts
+function isPlainObject14(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseNumstat(stdout) {
+  const map = /* @__PURE__ */ new Map();
+  const records = stdout.split("\0");
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    const parts = record.split("	");
+    if (parts.length < 3) continue;
+    let filePath = parts[2];
+    if (filePath === "" && index + 2 < records.length) {
+      filePath = records[index + 2];
+      index += 2;
+    }
+    if (!filePath) continue;
+    map.set(filePath, {
+      additions: Number.parseInt(parts[0] ?? "0", 10) || 0,
+      deletions: Number.parseInt(parts[1] ?? "0", 10) || 0
+    });
+  }
+  return map;
+}
+var STATUS_CHARS = /* @__PURE__ */ new Set(["M", "A", "D", "R", "T"]);
+function toEntry(statusChar, filePath, oldPath, nums) {
+  if (!STATUS_CHARS.has(statusChar)) return null;
+  const stat = nums.get(filePath) ?? { additions: 0, deletions: 0 };
+  return {
+    path: filePath,
+    ...oldPath ? { oldPath } : {},
+    status: statusChar,
+    ...stat
+  };
+}
+function parseStatusV2(stdout, stagedNums, unstagedNums) {
+  const staged = [];
+  const unstaged = [];
+  const records = stdout.split("\0");
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index];
+    if (!record) continue;
+    const kind = record.charAt(0);
+    if (kind === "1" || kind === "2") {
+      const fields = record.split(" ");
+      const xy = fields[1] ?? "..";
+      const filePath = fields.slice(kind === "1" ? 8 : 9).join(" ");
+      if (!filePath) continue;
+      let oldPath;
+      if (kind === "2" && index + 1 < records.length) {
+        oldPath = records[index + 1] || void 0;
+        index += 1;
+      }
+      const stagedChar = xy.charAt(0);
+      const unstagedChar = xy.charAt(1);
+      if (stagedChar !== ".") {
+        const entry = toEntry(stagedChar, filePath, oldPath, stagedNums);
+        if (entry) staged.push(entry);
+      }
+      if (unstagedChar !== ".") {
+        const entry = toEntry(unstagedChar === "R" ? "R" : unstagedChar, filePath, void 0, unstagedNums);
+        if (entry) unstaged.push(entry);
+      }
+    } else if (kind === "?") {
+      const filePath = record.slice(2);
+      if (filePath) unstaged.push({ path: filePath, status: "U", additions: 0, deletions: 0 });
+    } else if (kind === "u") {
+      const filePath = record.split(" ").slice(10).join(" ");
+      if (filePath) unstaged.push({ path: filePath, status: "U", conflicted: true, additions: 0, deletions: 0 });
+    }
+  }
+  return { staged, unstaged };
+}
+async function handleRepositoryStatus(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 (!isPlainObject14(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;
+  }
+  try {
+    const [statusResult, stagedNumsResult, unstagedNumsResult] = await Promise.all([
+      runGit(["status", "--porcelain=v2", "--untracked-files=all", "-z"], { cwd: gitCwd }),
+      // 스테이지 열의 +/− — unborn HEAD에서는 비교 대상이 없어 실패하므로 빈 목록으로 강등한다.
+      runGit(["diff", "--cached", "--numstat", "-z", "--", "."], { cwd: gitCwd }).catch(() => ({ stdout: "", truncated: false })),
+      runGit(["diff", "--numstat", "-z", "--", "."], { cwd: gitCwd }).catch(() => ({ stdout: "", truncated: false }))
+    ]);
+    const parsed = parseStatusV2(statusResult.stdout, parseNumstat(stagedNumsResult.stdout), parseNumstat(unstagedNumsResult.stdout));
+    const payload = { staged: parsed.staged, unstaged: parsed.unstaged, truncated: statusResult.truncated };
+    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;
+  }
+}
+function isPlainObject15(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseTreeEntries(stdout) {
+  const entries = [];
+  for (const record of stdout.split("\0")) {
+    if (!record) continue;
+    const tab = record.indexOf("	");
+    if (tab < 0) continue;
+    const meta = record.slice(0, tab).split(" ");
+    const entryPath = record.slice(tab + 1);
+    const kind = meta[1];
+    if (!entryPath || kind !== "tree" && kind !== "blob") continue;
+    const trimmed = entryPath.endsWith("/") ? entryPath.slice(0, -1) : entryPath;
+    entries.push({ path: entryPath, name: trimmed.slice(trimmed.lastIndexOf("/") + 1), kind });
+  }
+  return entries.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "tree" ? -1 : 1);
+}
+function isSafeTreeDirPath(dirPath) {
+  if (dirPath === "") return true;
+  if (path3.posix.isAbsolute(dirPath) || path3.isAbsolute(dirPath)) return false;
+  if (dirPath.includes("\0") || dirPath.startsWith("-") || dirPath.startsWith(":")) return false;
+  const normalized = path3.posix.normalize(dirPath);
+  return normalized !== ".." && !normalized.startsWith("../");
+}
+async function handleRepositoryTree(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 (!isPlainObject15(body) || "subPath" in body || typeof body.theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const ref = body.ref;
+  if (typeof ref !== "string" || !REF_RE.test(ref)) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
+    return;
+  }
+  const dirPath = body.dirPath === void 0 ? "" : body.dirPath;
+  if (typeof dirPath !== "string" || !isSafeTreeDirPath(dirPath)) {
+    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;
+  }
+  try {
+    const args = ["ls-tree", "-z", "--full-tree", ref, "--", dirPath === "" ? "." : `${dirPath}/`];
+    const result = await runGit(args, { cwd: gitCwd });
+    const payload = { entries: parseTreeEntries(result.stdout), truncated: result.truncated };
+    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;
+      }
+      if (error.code === "non_zero_exit" && /not a tree object|Not a valid object name|bad object/i.test(error.stderr)) {
+        ctx.host.http.writeJson(res, 404, { error: "ref_not_found" });
+        return;
+      }
+      ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+      return;
+    }
+    throw error;
+  }
+}
+function isPlainObject16(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function fileExists(candidate) {
+  try {
+    await fs2.stat(candidate);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseAheadBehind(stdout) {
+  const match = /^(\d+)\s+(\d+)$/.exec(stdout.trim());
+  if (!match) return null;
+  return { behind: Number.parseInt(match[1], 10), ahead: Number.parseInt(match[2], 10) };
+}
+async function handleRepositoryWorkstate(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 (!isPlainObject16(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;
+  }
+  try {
+    const [gitDirResult, headResult, headShaResult] = await Promise.all([
+      runGit(["rev-parse", "--absolute-git-dir"], { cwd: gitCwd }),
+      runGit(["symbolic-ref", "--quiet", "--short", "HEAD"], { cwd: gitCwd, allowExitCodes: [1] }),
+      runGit(["rev-parse", "--quiet", "--verify", "HEAD"], { cwd: gitCwd, allowExitCodes: [1] })
+    ]);
+    const gitDir = path3.resolve(gitCwd, gitDirResult.stdout.trim());
+    const headBranch = headResult.stdout.trim() || null;
+    const headSha = headShaResult.stdout.trim() || null;
+    const [indexLock, merge, rebaseMerge, rebaseApply, cherryPick] = await Promise.all([
+      fileExists(path3.join(gitDir, "index.lock")),
+      fileExists(path3.join(gitDir, "MERGE_HEAD")),
+      fileExists(path3.join(gitDir, "rebase-merge")),
+      fileExists(path3.join(gitDir, "rebase-apply")),
+      fileExists(path3.join(gitDir, "CHERRY_PICK_HEAD"))
+    ]);
+    const inProgress = merge ? "merge" : rebaseMerge || rebaseApply ? "rebase" : cherryPick ? "cherry-pick" : null;
+    let upstream = null;
+    let ahead = null;
+    let behind = null;
+    if (headBranch) {
+      const upstreamResult = await runGit(
+        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"],
+        { cwd: gitCwd, allowExitCodes: [128] }
+      );
+      upstream = upstreamResult.stdout.trim() || null;
+      if (upstream) {
+        const counts = parseAheadBehind((await runGit(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], { cwd: gitCwd })).stdout);
+        ahead = counts?.ahead ?? null;
+        behind = counts?.behind ?? null;
+      }
+    }
+    let realGitCwd = gitCwd;
+    try {
+      realGitCwd = await fs2.realpath(gitCwd);
+    } catch {
+    }
+    const stationedOperations = [];
+    for (const operation of ctx.host.operations.list()) {
+      const rawCwd = operation.payload?.cwd;
+      const cwd = typeof rawCwd === "string" ? rawCwd : theaterPath;
+      let realCwd;
+      try {
+        realCwd = await fs2.realpath(cwd);
+      } catch {
+        continue;
+      }
+      if (isPathContained(realGitCwd, realCwd)) stationedOperations.push({ id: operation.id, title: operation.title });
+    }
+    const payload = { indexLock, inProgress, headBranch, headSha, upstream, ahead, behind, stationedOperations };
+    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;
+  }
+}
+function isPlainObject17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function handleRepositoryWorktrees(req, res, ctx) {
@@ -1659,7 +2503,7 @@ async function handleRepositoryWorktrees(req, res, ctx) {
     return;
   }
   const body = await ctx.host.http.readJsonBody(req);
-  if (!isPlainObject10(body) || "subPath" in body || typeof body.theaterId !== "string") {
+  if (!isPlainObject17(body) || "subPath" in body || typeof body.theaterId !== "string") {
     ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
     return;
   }
@@ -1776,6 +2620,46 @@ var routes_default = definePlugin({
       await handleRepositoryCompareFile(req, res, ctx);
       return true;
     }, { method: "POST", path: "", summary: "Compare repository files.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "tree", async ({ req, res }) => {
+      await handleRepositoryTree(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "List one folder of a commit tree.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "workstate", async ({ req, res }) => {
+      await handleRepositoryWorkstate(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Report write-safety state for a checkout.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "status", async ({ req, res }) => {
+      await handleRepositoryStatus(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "List staged and unstaged repository files.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "stage", async ({ req, res }) => {
+      await handleRepositoryStage(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Stage repository files.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "unstage", async ({ req, res }) => {
+      await handleRepositoryUnstage(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Unstage repository files.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "discard", async ({ req, res }) => {
+      await handleRepositoryDiscard(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Discard working-tree changes for chosen files.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "commit-create", async ({ req, res }) => {
+      await handleRepositoryCommitCreate(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Create or amend a commit from the staged files.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "stash", async ({ req, res }) => {
+      await handleRepositoryStash(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Save, apply, pop, or drop a stash.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "push", async ({ req, res }) => {
+      await handleRepositoryPush(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Push the current branch to its upstream.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
+    registerRouter(ctx, "pull", async ({ req, res }) => {
+      await handleRepositoryPull(req, res, ctx);
+      return true;
+    }, { method: "POST", path: "", summary: "Fast-forward the current branch from its upstream.", category: "Repository Plugin", gate: "origin-write", transport: "http" });
   }
 });