dsh-git-ui 0.0.1 → 0.1.0

package/lib/host/index.js

@@ -136,10 +136,8 @@ function parseStatusHeader(line) {
   const branch = core.split("...", 1)[0] ?? core;
   return { branch: branch === "" ? null : branch, unborn: false, ahead, behind };
 }
-function changeStatus(x, y) {
-  if (x === "?" && y === "?") return "untracked";
-  if (x === "U" || y === "U" || x !== " " && y !== " ") return "conflicted";
-  switch (x) {
+function singleStatus(code) {
+  switch (code) {
     case "A":
       return "added";
     case "M":
@@ -156,6 +154,9 @@ function changeStatus(x, y) {
       return "modified";
   }
 }
+function isConflicted(x, y) {
+  return x === "U" || y === "U" || x === "A" && y === "A" || x === "D" && y === "D";
+}
 function parseStatusOutput(output, maxChanges) {
   const raw = output.split(NUL);
   const segments = raw[raw.length - 1] === "" ? raw.slice(0, -1) : raw;
@@ -165,6 +166,13 @@ function parseStatusOutput(output, maxChanges) {
   let untracked = 0;
   const changes = [];
   let truncated = false;
+  const pushChange = (path, status, isStaged) => {
+    if (changes.length < maxChanges) {
+      changes.push({ path, status, staged: isStaged, isDirectory: path.endsWith("/") });
+    } else {
+      truncated = true;
+    }
+  };
   for (let index = 1; index < segments.length; index += 1) {
     const entry = segments[index] ?? "";
     const x = entry[0] ?? " ";
@@ -176,14 +184,19 @@ function parseStatusOutput(output, maxChanges) {
     }
     if (x === "?" && y === "?") {
       untracked += 1;
-    } else {
-      if (x !== " " && x !== "?") staged += 1;
-      if (y !== " " && y !== "?") modified += 1;
+      pushChange(path, "untracked", false);
+      continue;
     }
-    if (changes.length < maxChanges) {
-      changes.push({ path, status: changeStatus(x, y), staged: x !== " " && x !== "?" });
+    if (x !== " " && x !== "?") staged += 1;
+    if (y !== " " && y !== "?") modified += 1;
+    if (isConflicted(x, y)) {
+      pushChange(path, "conflicted", true);
+    } else if (x !== " " && y !== " ") {
+      pushChange(path, singleStatus(x), true);
+      pushChange(path, singleStatus(y), false);
     } else {
-      truncated = true;
+      const isStaged = x !== " ";
+      pushChange(path, singleStatus(isStaged ? x : y), isStaged);
     }
   }
   return {
@@ -214,6 +227,92 @@ function parseLogOutput(output) {
   }
   return commits;
 }
+function parseGraphLogOutput(output, remotes = []) {
+  const commits = [];
+  for (const line of output.split("\n")) {
+    if (line === "") continue;
+    const [hash, shortHash, subject, author, dateIso, parentField, decoField] = line.split(LOG_SEP);
+    if (hash === void 0 || hash === "") continue;
+    const parents = (parentField ?? "").split(" ").filter((p) => p !== "");
+    commits.push({
+      hash,
+      shortHash: shortHash ?? "",
+      subject: subject ?? "",
+      author: author ?? "",
+      dateIso: dateIso ?? "",
+      parents,
+      refs: parseDecorations(decoField ?? "", remotes)
+    });
+  }
+  return commits;
+}
+function parseDecorations(decorations, remotes) {
+  const trimmed = decorations.trim();
+  if (trimmed === "") return [];
+  const refs = [];
+  for (const token of trimmed.split(", ")) {
+    if (token.startsWith("HEAD -> ")) {
+      refs.push({ kind: "branch", name: token.slice(8), head: true });
+    } else if (token.startsWith("tag: ")) {
+      refs.push({ kind: "tag", name: token.slice(5), head: false });
+    } else if (remotes.some((remote) => token === remote || token.startsWith(`${remote}/`))) {
+      refs.push({ kind: "remote", name: token, head: false });
+    } else {
+      refs.push({ kind: "branch", name: token, head: false });
+    }
+  }
+  return refs;
+}
+function parseShowMeta(output) {
+  const trimmed = output.trimEnd();
+  if (trimmed === "") return null;
+  const [hash, shortHash, subject, author, dateIso, ...bodyParts] = trimmed.split(LOG_SEP);
+  if (hash === void 0 || hash === "") return null;
+  return {
+    commit: {
+      hash,
+      shortHash: shortHash ?? "",
+      subject: subject ?? "",
+      author: author ?? "",
+      dateIso: dateIso ?? ""
+    },
+    body: bodyParts.join(LOG_SEP).trimEnd()
+  };
+}
+function nameStatusCode(code) {
+  switch (code) {
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "T":
+      return "typechange";
+    case "U":
+      return "conflicted";
+    default:
+      return "modified";
+  }
+}
+function parseNameStatusOutput(output) {
+  const raw = output.split(NUL);
+  const segments = raw[raw.length - 1] === "" ? raw.slice(0, -1) : raw;
+  const rows = [];
+  for (let i = 0; i < segments.length; i += 1) {
+    const entry = segments[i] ?? "";
+    if (entry === "") continue;
+    const code = entry[0] ?? " ";
+    if (code === "R" || code === "C") {
+      rows.push({ path: segments[i + 2] ?? "", status: nameStatusCode(code) });
+      i += 2;
+    } else {
+      rows.push({ path: segments[i + 1] ?? "", status: nameStatusCode(code) });
+      i += 1;
+    }
+  }
+  return rows;
+}
 function parseBranchOutput(output) {
   const trimmed = output.trim();
   return trimmed === "" ? null : trimmed;
@@ -257,7 +356,7 @@ async function runCommand(runner, argv, cwd, label, signal) {
     return { failure: { code: "git-unavailable", detail: `${label}: ${error instanceof Error ? error.message : String(error)}` } };
   }
 }
-async function snapshotForSession(deps, config, sessionId) {
+async function resolveWorkspace(deps, sessionId) {
   const resolved = await resolveCwd(deps.sessions, sessionId);
   if (!resolved.ok) return { ok: false, error: resolved.error };
   let realCwd;
@@ -282,6 +381,12 @@ async function snapshotForSession(deps, config, sessionId) {
   }
   const root = toplevel.run.stdout.trim();
   if (root === "") return { ok: false, error: { code: "not-a-git-repo" } };
+  return { ok: true, cwd: realCwd, root };
+}
+async function snapshotForSession(deps, config, sessionId) {
+  const workspace = await resolveWorkspace(deps, sessionId);
+  if (!workspace.ok) return { ok: false, error: workspace.error };
+  const root = workspace.root;
   const branchRun = await runCommand(deps.run, ["git", "branch", "--show-current"], root, "branch", deps.signal);
   if ("failure" in branchRun) return { ok: false, error: branchRun.failure };
   if (branchRun.run.timedOut) return { ok: false, error: { code: "timeout" } };
@@ -290,7 +395,7 @@ async function snapshotForSession(deps, config, sessionId) {
   if ("failure" in headRun) return { ok: false, error: headRun.failure };
   if (headRun.run.timedOut) return { ok: false, error: { code: "timeout" } };
   const head = headRun.run.exitCode === 0 ? headRun.run.stdout.trim() || null : null;
-  const status = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--branch"], root, "status", deps.signal);
+  const status = await runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z", "--branch", "--untracked-files=all"], root, "status", deps.signal);
   if ("failure" in status) return { ok: false, error: status.failure };
   if (status.run.timedOut) return { ok: false, error: { code: "timeout" } };
   if (status.run.exitCode !== 0) {
@@ -323,25 +428,337 @@ async function snapshotForSession(deps, config, sessionId) {
   return { ok: true, value: snapshot };
 }
 
+// src/host/actions.ts
+import { resolve, sep } from "node:path";
+function buildArgv(action, root) {
+  switch (action.kind) {
+    case "stage":
+      return withPaths([["git", "add", "--"]], action.paths, root);
+    case "stage-all":
+      return { argv: [["git", "add", "-A"]] };
+    case "unstage":
+      return withPaths([["git", "restore", "--staged", "--"]], action.paths, root);
+    case "unstage-all":
+      return { argv: [["git", "restore", "--staged", "--", "."]] };
+    case "discard":
+      return withPaths([["git", "restore", "--"]], action.paths, root);
+    case "discard-all":
+      return { argv: [["git", "restore", "--staged", "--", "."], ["git", "restore", "--", "."]] };
+    case "commit": {
+      const message = action.message.trim();
+      if (action.paths === void 0 || action.paths.length === 0) {
+        return { argv: [["git", "commit", "-m", message]] };
+      }
+      return withPaths([["git", "add", "--"], ["git", "commit", "-m", message, "--"]], action.paths, root);
+    }
+    case "branch-create": {
+      const from = action.from === void 0 || action.from === "" ? [] : [action.from];
+      return { argv: [["git", "branch", action.name, ...from]] };
+    }
+    case "branch-checkout":
+      return { argv: [["git", "checkout", action.name]] };
+    case "branch-delete":
+      return { argv: [["git", "branch", action.force === true ? "-D" : "-d", action.name]] };
+    case "fetch":
+      return { argv: [["git", "fetch", "--all", "--prune"]] };
+  }
+}
+function isValidBranchName(name) {
+  if (name === "" || name.startsWith("-") || name.includes("..") || name.endsWith("/") || name.includes("//")) return false;
+  return /^[A-Za-z0-9._/-]+$/.test(name);
+}
+function withPaths(prefixes, paths, root) {
+  if (paths.length === 0) return { error: "no paths given" };
+  for (const path of paths) {
+    if (!isSafePath(path, root)) return { error: `unsafe path: ${path}` };
+  }
+  return { argv: prefixes.map((prefix) => [...prefix, ...paths]) };
+}
+function isSafePath(path, root) {
+  if (path === "") return false;
+  if (path.startsWith("/") || path.startsWith("\\") || /^[A-Za-z]:/.test(path)) return false;
+  const resolved = resolve(root, path);
+  const prefix = root.endsWith(sep) ? root : `${root}${sep}`;
+  return resolved === root || resolved.startsWith(prefix);
+}
+function operationError(failure) {
+  if (failure.code === "git-unavailable") {
+    return { ok: false, error: { code: "git-error", message: failure.detail } };
+  }
+  return { ok: false, error: failure };
+}
+function classifyOperationError(kind, message) {
+  if (kind === "branch-checkout" && /would be overwritten by checkout|将被 checkout 覆盖|有未跟踪工作区文件将会被 checkout 覆盖/i.test(message)) {
+    return "local-changes-block";
+  }
+  return "git-error";
+}
+async function runAction(deps, config, request) {
+  const workspace = await resolveWorkspace(deps, request.sessionId);
+  if (!workspace.ok) return operationError(workspace.error);
+  const root = workspace.root;
+  if (request.action.kind === "commit" && request.action.message.trim() === "") {
+    return { ok: false, error: { code: "git-error", message: "commit message is empty" } };
+  }
+  const kind = request.action.kind;
+  if (kind === "branch-create" || kind === "branch-checkout" || kind === "branch-delete") {
+    const name = request.action.name;
+    if (!isValidBranchName(name)) {
+      return { ok: false, error: { code: "invalid-name", message: `invalid branch name: ${name}` } };
+    }
+  }
+  const built = buildArgv(request.action, root);
+  if ("error" in built) return { ok: false, error: { code: "invalid-path", message: built.error } };
+  let lastStdout = "";
+  for (const argv of built.argv) {
+    const outcome = await runCommand(deps.run, argv, root, `action ${request.action.kind}`, deps.signal);
+    if ("failure" in outcome) return operationError(outcome.failure);
+    if (outcome.run.timedOut) return { ok: false, error: { code: "timeout" } };
+    if (outcome.run.exitCode !== 0) {
+      const message = outcome.run.stderr.trim() || outcome.run.stdout.trim();
+      const code = classifyOperationError(request.action.kind, message);
+      return {
+        ok: false,
+        error: {
+          code,
+          message: message !== "" ? message : `git ${request.action.kind} exited ${String(outcome.run.exitCode)}`
+        }
+      };
+    }
+    lastStdout = outcome.run.stdout.trim();
+  }
+  const snapshot = await snapshotForSession(deps, config, request.sessionId);
+  if (!snapshot.ok) return operationError(snapshot.error);
+  return { ok: true, snapshot: snapshot.value, ...lastStdout === "" ? {} : { output: lastStdout } };
+}
+
+// src/host/queries.ts
+var LOG_FORMAT = "%H%x1f%h%x1f%s%x1f%an%x1f%aI";
+var GRAPH_FORMAT = "%H%x1f%h%x1f%s%x1f%an%x1f%aI%x1f%P%x1f%D";
+var MAX_HISTORY_LIMIT = 1e3;
+function isValidRef(ref) {
+  return ref !== "" && !/\s/.test(ref);
+}
+async function runQuery(deps, config, request) {
+  void config;
+  const workspace = await resolveWorkspace(deps, request.sessionId);
+  if (!workspace.ok) return { ok: false, error: operationError(workspace.error).error };
+  const root = workspace.root;
+  const query = request.query;
+  switch (query.kind) {
+    case "history":
+      return historyQuery(deps, root, query);
+    case "diff":
+      return diffQuery(deps, root, query.path, query.base);
+    case "show":
+      return showQuery(deps, root, query.ref);
+    case "branches":
+      return branchesQuery(deps, root);
+    case "tags":
+      return tagsQuery(deps, root);
+    case "authors":
+      return authorsQuery(deps, root);
+  }
+}
+async function historyQuery(deps, root, query) {
+  const safeLimit = Math.min(Math.max(Math.floor(query.limit), 0), MAX_HISTORY_LIMIT);
+  const safeSkip = Math.max(Math.floor(query.skip), 0);
+  if (query.ref !== void 0 && !isValidRef(query.ref)) {
+    return { ok: false, error: { code: "invalid-name", message: `invalid ref: ${query.ref}` } };
+  }
+  const search = query.search?.trim() ?? "";
+  const hexLike = /^[0-9a-f]{7,40}$/i.test(search);
+  const scope = hexLike ? [] : query.ref === void 0 ? ["--all"] : [query.ref];
+  const noWalk = hexLike ? ["--no-walk", search] : [];
+  const filters = [];
+  if (search !== "" && !hexLike) filters.push("--regexp-ignore-case", "--extended-regexp", `--grep=${search}`);
+  const author = query.author?.trim() ?? "";
+  if (author !== "") filters.push(`--author=${author}`);
+  const since = query.since?.trim() ?? "";
+  if (since !== "") filters.push(`--since=${since}`);
+  const log = await runCommand(
+    deps.run,
+    // -n/--skip 前置：git 的 `-n N` 出现在 `--no-walk` 之后会重置 no-walk
+    // （hexLike 会错误列出全部祖先），前置则 `-n 1000 --no-walk x` 恒返回单条。
+    ["git", "log", ...filters, `--skip=${String(safeSkip)}`, "-n", String(safeLimit), ...noWalk, ...scope, `--format=${GRAPH_FORMAT}`],
+    root,
+    "log",
+    deps.signal
+  );
+  if ("failure" in log) return { ok: false, error: operationError(log.failure).error };
+  if (log.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (log.run.exitCode !== 0) {
+    if (log.run.stderr.includes("does not have any commits")) {
+      return { ok: true, value: { kind: "history", commits: [], total: 0 } };
+    }
+    if (hexLike && /unknown revision|bad revision|ambiguous/i.test(log.run.stderr)) {
+      return { ok: true, value: { kind: "history", commits: [], total: 0 } };
+    }
+    return gitError("log", log.run.stderr, log.run.stdout);
+  }
+  let total = 0;
+  const count = await runCommand(deps.run, ["git", "rev-list", "--count", ...noWalk, ...scope, ...filters], root, "rev-list", deps.signal);
+  if ("run" in count && count.run.exitCode === 0) {
+    const parsed = Number(count.run.stdout.trim());
+    if (Number.isFinite(parsed) && parsed >= 0) total = parsed;
+  }
+  let remotes = [];
+  const remoteRun = await runCommand(deps.run, ["git", "remote"], root, "remote", deps.signal);
+  if ("run" in remoteRun && remoteRun.run.exitCode === 0) {
+    remotes = remoteRun.run.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== "");
+  }
+  return { ok: true, value: { kind: "history", commits: parseGraphLogOutput(log.run.stdout, remotes), total } };
+}
+async function diffQuery(deps, root, path, base) {
+  if (!isSafePath(path, root)) return { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } };
+  const argv = base === "staged" ? ["git", "diff", "--cached", "-U999999", "--", path] : ["git", "diff", "-U999999", "--", path];
+  const run = await runCommand(deps.run, argv, root, "diff", deps.signal);
+  if ("failure" in run) return { ok: false, error: operationError(run.failure).error };
+  if (run.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (run.run.exitCode !== 0) return gitError("diff", run.run.stderr, run.run.stdout);
+  if (run.run.stdout !== "" || base === "staged") {
+    return { ok: true, value: { kind: "diff", path, text: run.run.stdout } };
+  }
+  const ni = await runCommand(deps.run, ["git", "diff", "--no-index", "-U999999", "--", "/dev/null", path], root, "diff --no-index", deps.signal);
+  if ("failure" in ni) return { ok: false, error: operationError(ni.failure).error };
+  if (ni.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (ni.run.exitCode !== 0 && ni.run.exitCode !== 1) return gitError("diff", ni.run.stderr, ni.run.stdout);
+  return { ok: true, value: { kind: "diff", path, text: ni.run.stdout } };
+}
+async function showQuery(deps, root, ref) {
+  if (!isValidRef(ref)) return { ok: false, error: { code: "invalid-name", message: `invalid ref: ${ref}` } };
+  const meta = await runCommand(
+    deps.run,
+    ["git", "show", "-s", `--format=${LOG_FORMAT}%x1f%b`, ref],
+    root,
+    "show",
+    deps.signal
+  );
+  if ("failure" in meta) return { ok: false, error: operationError(meta.failure).error };
+  if (meta.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (meta.run.exitCode !== 0) return gitError("show", meta.run.stderr, meta.run.stdout);
+  const stat2 = await runCommand(
+    deps.run,
+    ["git", "-c", "core.quotePath=false", "show", "--format=", "--name-status", "-z", ref],
+    root,
+    "show --name-status",
+    deps.signal
+  );
+  if ("failure" in stat2) return { ok: false, error: operationError(stat2.failure).error };
+  if (stat2.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (stat2.run.exitCode !== 0) return gitError("show", stat2.run.stderr, stat2.run.stdout);
+  const parsed = parseShowMeta(meta.run.stdout);
+  return {
+    ok: true,
+    value: {
+      kind: "show",
+      ref,
+      commit: parsed?.commit ?? null,
+      body: parsed?.body ?? "",
+      stats: parseNameStatusOutput(stat2.run.stdout)
+    }
+  };
+}
+async function authorsQuery(deps, root) {
+  const run = await runCommand(deps.run, ["git", "log", "--all", "-n", "1000", "--format=%an"], root, "log authors", deps.signal);
+  if ("failure" in run) return { ok: false, error: operationError(run.failure).error };
+  if (run.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (run.run.exitCode !== 0) return { ok: true, value: { kind: "authors", authors: [] } };
+  const authors = [...new Set(run.run.stdout.split("\n").map((s) => s.trim()).filter((s) => s !== ""))].sort().slice(0, 100);
+  return { ok: true, value: { kind: "authors", authors } };
+}
+async function tagsQuery(deps, root) {
+  const FORMAT = "--format=%(refname:short)%09%(objectname:short)";
+  const run = await runCommand(deps.run, ["git", "tag", FORMAT], root, "tag", deps.signal);
+  if ("failure" in run) return { ok: false, error: operationError(run.failure).error };
+  if (run.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (run.run.exitCode !== 0) return gitError("tag", run.run.stderr, run.run.stdout);
+  return { ok: true, value: { kind: "tags", tags: parseBranchList(run.run.stdout) } };
+}
+async function branchesQuery(deps, root) {
+  const LOCAL_FORMAT = "--format=%(refname:short)%09%(objectname:short)%09%(upstream:short)%09%(upstream:track)";
+  const REMOTE_FORMAT = "--format=%(refname:short)%09%(objectname:short)";
+  const local = await runCommand(deps.run, ["git", "branch", LOCAL_FORMAT], root, "branch", deps.signal);
+  if ("failure" in local) return { ok: false, error: operationError(local.failure).error };
+  if (local.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (local.run.exitCode !== 0) return gitError("branch", local.run.stderr, local.run.stdout);
+  const remote = await runCommand(deps.run, ["git", "branch", "-r", REMOTE_FORMAT], root, "branch -r", deps.signal);
+  if ("failure" in remote) return { ok: false, error: operationError(remote.failure).error };
+  if (remote.run.timedOut) return { ok: false, error: { code: "timeout" } };
+  if (remote.run.exitCode !== 0) return gitError("branch -r", remote.run.stderr, remote.run.stdout);
+  const current = await runCommand(deps.run, ["git", "branch", "--show-current"], root, "branch", deps.signal);
+  const currentName = "run" in current && current.run.exitCode === 0 ? parseBranchOutput(current.run.stdout) : null;
+  let defaultBranch = null;
+  const def = await runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], root, "symbolic-ref", deps.signal);
+  if ("run" in def && def.run.exitCode === 0) {
+    const value = def.run.stdout.trim();
+    const slash = value.indexOf("/");
+    defaultBranch = value === "" ? null : slash === -1 ? value : value.slice(slash + 1);
+  }
+  return {
+    ok: true,
+    value: {
+      kind: "branches",
+      current: currentName,
+      defaultBranch,
+      local: parseBranchList(local.run.stdout),
+      remote: parseBranchList(remote.run.stdout).filter((branch) => !branch.name.endsWith("/HEAD"))
+    }
+  };
+}
+function parseBranchList(output) {
+  const branches = [];
+  for (const line of output.split("\n")) {
+    if (line === "") continue;
+    const parts = line.split("	");
+    const name = parts[0];
+    const hash = parts[1];
+    if (name === void 0 || name === "") continue;
+    const track = parts[3] ?? "";
+    const aheadMatch = /ahead (\d+)/.exec(track);
+    const behindMatch = /behind (\d+)/.exec(track);
+    const ahead = aheadMatch ? Number(aheadMatch[1]) : 0;
+    const behind = behindMatch ? Number(behindMatch[1]) : 0;
+    branches.push({
+      name,
+      shortHash: hash === void 0 || hash === "" ? null : hash,
+      ...ahead > 0 ? { ahead } : {},
+      ...behind > 0 ? { behind } : {}
+    });
+  }
+  return branches;
+}
+function gitError(label, stderr, stdout) {
+  const message = stderr.trim() || stdout.trim();
+  return {
+    ok: false,
+    error: {
+      code: "git-error",
+      message: message !== "" ? message : `git ${label} failed`
+    }
+  };
+}
+
 // src/host/index.ts
-var _snapshot_dec, _a, _init;
-var GitStatusService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _a) {
+var _query_dec, _run_dec, _snapshot_dec, _a, _init;
+var GitStatusService = class extends (_a = TypertRemoteService, _snapshot_dec = [Remote("snapshot")], _run_dec = [Remote("run")], _query_dec = [Remote("query")], _a) {
   constructor(ctx, config) {
     super(ctx, "gitInfo");
     __runInitializers(_init, 5, this);
     __publicField(this, "config");
     this.config = normalizeConfig(config);
   }
-  async snapshot(request, signal) {
+  /** Adapter face shared by both endpoints (injected services + runner). */
+  deps(signal) {
     const subprocess = this.ctx.get("subprocess");
     if (subprocess === void 0) {
-      return { ok: false, error: { code: "git-unavailable", detail: "subprocess service unavailable" } };
+      return { failure: { code: "git-unavailable", detail: "subprocess service unavailable" } };
     }
     const sessions = this.ctx.get("sessions");
     const persistence = this.ctx.get("sessionPersistence");
     const runner = createGitRunner(subprocess, this.config.timeoutMs, this.config.maxStatusBytes);
-    return snapshotForSession(
-      {
+    return {
+      deps: {
         run: runner,
         fs: { realpath, stat },
         sessions: {
@@ -357,14 +774,33 @@ var GitStatusService = class extends (_a = TypertRemoteService, _snapshot_dec =
           }
         },
         signal
-      },
-      this.config,
-      request.sessionId
-    );
+      }
+    };
+  }
+  async snapshot(request, signal) {
+    const adapted = this.deps(signal);
+    if ("failure" in adapted) return { ok: false, error: adapted.failure };
+    return snapshotForSession(adapted.deps, this.config, request.sessionId);
+  }
+  async run(request, signal) {
+    const adapted = this.deps(signal);
+    if ("failure" in adapted) {
+      return { ok: false, error: { code: "git-error", message: adapted.failure.detail } };
+    }
+    return runAction(adapted.deps, this.config, request);
+  }
+  async query(request, signal) {
+    const adapted = this.deps(signal);
+    if ("failure" in adapted) {
+      return { ok: false, error: { code: "git-error", message: adapted.failure.detail } };
+    }
+    return runQuery(adapted.deps, this.config, request);
   }
 };
 _init = __decoratorStart(_a);
 __decorateElement(_init, 1, "snapshot", _snapshot_dec, GitStatusService);
+__decorateElement(_init, 1, "run", _run_dec, GitStatusService);
+__decorateElement(_init, 1, "query", _query_dec, GitStatusService);
 __decoratorMetadata(_init, GitStatusService);
 __publicField(GitStatusService, "inject", ["subprocess", "sessions", "sessionPersistence"]);
 var index_default = GitStatusService;
@@ -372,9 +808,14 @@ export {
   DEFAULT_CONFIG,
   GitStatusService,
   index_default as default,
+  isSafePath,
+  isValidBranchName,
   normalizeConfig,
   parseBranchOutput,
   parseLogOutput,
-  parseStatusOutput
+  parseNameStatusOutput,
+  parseStatusOutput,
+  runAction,
+  runQuery
 };
 //# sourceMappingURL=index.js.map