@xbzbing/dsh-git-panel 1.5.2 → 1.5.4

package/lib/host/actions.d.ts

@@ -1,6 +1,6 @@
-import type { SnapshotDeps, GitPanelConfig } from './core.ts';
-import { isSafePath } from './validate.ts';
-import type { GitAction, GitActionRequest, GitActionResult, GitErrorCode } from './types.ts';
+import type { SnapshotDeps, GitPanelConfig } from './core.js';
+import { isSafePath } from './validate.js';
+import type { GitAction, GitActionRequest, GitActionResult, GitErrorCode } from './types.js';
 export { isSafePath };
 interface CommandPlan {
     readonly argv: readonly (readonly string[])[];

package/lib/host/actions.js

@@ -0,0 +1,230 @@
+import { join, sep } from "node:path";
+import { mapWorkspaceFailure, resolveWorkspace, runCommand, snapshotForSession } from "./core.js";
+import { isSafeBranchName, isSafePath, isSafeRemoteName, isSafeRev } from "./validate.js";
+function withPaths(prefixes, paths) {
+  if (paths.length === 0) return { error: "invalid-path", message: "no paths given" };
+  for (const path of paths) {
+    if (!isSafePath(path)) return { error: "invalid-path", message: `unsafe path: ${path}` };
+  }
+  return { argv: prefixes.map((prefix) => [...prefix, ...paths]) };
+}
+function planAction(action, unborn) {
+  switch (action.kind) {
+    case "stage":
+      return withPaths([["git", "add", "--"]], action.paths);
+    case "stage-all":
+      return { argv: [["git", "add", "-A"]] };
+    case "unstage":
+      return unborn ? withPaths([["git", "rm", "--cached", "-r", "--"]], action.paths) : withPaths([["git", "restore", "--staged", "--"]], action.paths);
+    case "unstage-all":
+      return unborn ? { argv: [["git", "rm", "--cached", "-r", "--", "."]] } : { argv: [["git", "restore", "--staged", "--", "."]] };
+    case "discard":
+      return withPaths([["git", "restore", "--"]], action.paths);
+    case "commit": {
+      const message = action.message.trim();
+      const amend = action.amend === true;
+      if (message === "" && !amend) return { error: "empty-message" };
+      const amendFlag = amend ? ["--amend"] : [];
+      const msgArgs = message === "" ? ["--no-edit"] : ["-m", message];
+      if (action.paths === void 0 || action.paths.length === 0) {
+        return { argv: [["git", "commit", ...amendFlag, ...msgArgs]] };
+      }
+      const staged = withPaths([["git", "add", "--"]], action.paths);
+      if ("error" in staged) return staged;
+      const commitCmd = ["git", "commit", ...amendFlag, ...msgArgs, "--", ...action.paths];
+      return { argv: [...staged.argv, commitCmd] };
+    }
+    case "branch-checkout":
+      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe branch name: ${action.name}` };
+      return { argv: [["git", "checkout", "--end-of-options", action.name]] };
+    case "fetch":
+      return { argv: [["git", "fetch", "--all", "--prune"]] };
+    case "pull-ff":
+      return { argv: [["git", "pull", "--ff-only"]] };
+    case "push":
+      return { argv: [["git", "push"]] };
+    case "publish":
+      if (!isSafeRemoteName(action.remote)) return { error: "invalid-name", message: `unsafe remote name: ${action.remote}` };
+      return { argv: [["git", "push", "-u", action.remote, "HEAD"]] };
+    case "tag-create": {
+      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe tag name: ${action.name}` };
+      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
+      const msg = action.message?.trim() ?? "";
+      const flags = msg === "" ? [] : ["-a", "-m", msg];
+      return { argv: [["git", "tag", ...flags, "--end-of-options", action.name, action.commit]] };
+    }
+    case "tag-delete":
+      if (!isSafeBranchName(action.name)) return { error: "invalid-name", message: `unsafe tag name: ${action.name}` };
+      return { argv: [["git", "tag", "-d", "--end-of-options", action.name]] };
+    case "stash-push": {
+      const msg = action.message?.trim() ?? "";
+      return { argv: [msg === "" ? ["git", "stash", "push"] : ["git", "stash", "push", "-m", msg]] };
+    }
+    case "stash-apply":
+    case "stash-pop":
+    case "stash-drop": {
+      if (!Number.isInteger(action.index) || action.index < 0) {
+        return { error: "invalid-index", message: `invalid stash index: ${action.index}` };
+      }
+      const verb = action.kind === "stash-apply" ? "apply" : action.kind === "stash-pop" ? "pop" : "drop";
+      return { argv: [["git", "stash", verb, "--end-of-options", `stash@{${action.index}}`]] };
+    }
+    case "revert": {
+      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
+      return { argv: [["git", "revert", "--no-edit", "--end-of-options", action.commit]] };
+    }
+    case "reset": {
+      if (!isSafeRev(action.commit)) return { error: "invalid-name", message: `unsafe commit: ${action.commit}` };
+      if (action.mode !== "soft" && action.mode !== "mixed" && action.mode !== "hard") {
+        return { error: "invalid-name", message: `invalid reset mode: ${String(action.mode)}` };
+      }
+      return { argv: [["git", "reset", `--${action.mode}`, "--end-of-options", action.commit]] };
+    }
+  }
+}
+function isIndexBusy(outcome) {
+  if (!("run" in outcome) || outcome.run.exitCode === 0) return false;
+  return /index\.lock|Unable to create.*index|another git process/i.test(outcome.run.stderr + outcome.run.stdout);
+}
+function scrubCredentials(text) {
+  return text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]*@/gi, "$1");
+}
+function classifyActionFailure(stdout, stderr, exitCode) {
+  const combined = stderr + stdout;
+  const err = scrubCredentials(stderr.trim());
+  if (/CONFLICT|Merge conflict|needs merge|could not restore untracked/i.test(combined)) {
+    return { code: "conflict", message: err || "merge conflict" };
+  }
+  if (/index\.lock|Unable to create.*index|another git process/i.test(combined)) {
+    return { code: "index-busy", message: err };
+  }
+  if (/nothing to commit|no changes added/i.test(combined)) {
+    return { code: "git-error", message: err || "nothing to commit" };
+  }
+  if (/No such ref|not a valid reference|is not a stash|no tag|tag .* not found|unknown revision|bad revision|Could not parse object|ambiguous argument/i.test(combined)) {
+    return { code: "not-found", message: err || "not found" };
+  }
+  if (/Authentication failed|could not read (Username|Password)|terminal prompts disabled|Permission denied \(publickey\)|Could not read from remote repository/i.test(combined)) {
+    return { code: "auth-failed", message: err || "authentication failed" };
+  }
+  if (/\[rejected\]|Updates were rejected|failed to push some refs|fetch first|tip of your current branch is behind/i.test(combined)) {
+    return { code: "push-rejected", message: err || "push rejected (remote has new commits; fetch first)" };
+  }
+  if (/Not possible to fast-forward|cannot fast-forward|not a fast-forward|Need to specify how to reconcile divergent branches/i.test(combined)) {
+    return { code: "not-ff", message: err || "cannot fast-forward (branches diverged)" };
+  }
+  if (/would be overwritten by (checkout|merge)|local changes|overwritten by merge|Your local changes/i.test(stderr)) {
+    return { code: "local-changes-block", message: err };
+  }
+  if (/is a merge but no -m|mainline parent/i.test(combined)) {
+    return { code: "revert-merge", message: err || "cannot revert a merge commit from the panel" };
+  }
+  return { code: "git-error", message: err || `git exited ${exitCode}` };
+}
+async function runAction(deps, config, request) {
+  const workspace = await resolveWorkspace(deps, request.sessionId);
+  if (!workspace.ok) return { ok: false, error: mapWorkspaceFailure(workspace.failure) };
+  const root = workspace.root;
+  const headProbe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "HEAD"], root, "head-probe", deps.signal);
+  const unborn = !("run" in headProbe) || headProbe.run.exitCode !== 0;
+  const act = request.action;
+  if (act.kind === "stash-apply" || act.kind === "stash-pop" || act.kind === "stash-drop") {
+    if (!Number.isInteger(act.index) || act.index < 0) {
+      return { ok: false, error: { code: "invalid-index", message: `invalid stash index: ${act.index}` } };
+    }
+    const probe = await runCommand(deps.run, ["git", "rev-parse", "--verify", "--quiet", "--end-of-options", `stash@{${act.index}}`], root, "stash-verify", deps.signal);
+    const sha = "run" in probe && probe.run.exitCode === 0 ? probe.run.stdout.trim() : "";
+    if (sha === "" || sha !== act.sha) {
+      return { ok: false, error: { code: "not-found", message: "stash entry changed; refresh and retry" } };
+    }
+  }
+  if (request.action.kind === "discard") {
+    const removed = await discardUntracked(deps, config, root, request.sessionId, request.action.paths);
+    if (removed !== null) {
+      if (!removed.ok) return removed.result;
+      if (removed.remainingTracked.length === 0) {
+        const snapshot2 = await snapshotForSession(deps, config, request.sessionId);
+        if (!snapshot2.ok) return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
+        return { ok: true, snapshot: snapshot2.value, output: "" };
+      }
+      request = { ...request, action: { kind: "discard", paths: removed.remainingTracked } };
+    }
+  }
+  const plan = planAction(request.action, unborn);
+  if ("error" in plan) return { ok: false, error: { code: plan.error, ...plan.message ? { message: plan.message } : {} } };
+  let lastOutput = "";
+  for (let step = 0; step < plan.argv.length; step += 1) {
+    const argv = plan.argv[step];
+    let outcome = await runCommand(deps.run, argv, root, "action", deps.signal);
+    if (isIndexBusy(outcome)) {
+      await new Promise((resolve) => setTimeout(resolve, 150));
+      outcome = await runCommand(deps.run, argv, root, "action-retry", deps.signal);
+    }
+    const where = plan.argv.length > 1 ? ` (step ${step + 1}/${plan.argv.length}: ${argv.join(" ")})` : "";
+    if ("failure" in outcome) {
+      const message = outcome.failure instanceof Error ? outcome.failure.message : String(outcome.failure);
+      return { ok: false, error: { code: "git-unavailable", message: message + where } };
+    }
+    if (outcome.run.cancelled) return { ok: false, error: { code: "cancelled" } };
+    if (outcome.run.timedOut) return { ok: false, error: { code: "timeout" } };
+    lastOutput = outcome.run.stdout || outcome.run.stderr;
+    if (outcome.run.exitCode !== 0) {
+      const failure = classifyActionFailure(outcome.run.stdout, outcome.run.stderr, outcome.run.exitCode ?? -1);
+      if (request.action.kind === "revert" && failure.code === "conflict") {
+        let abort = await runCommand(deps.run, ["git", "revert", "--abort"], root, "revert-abort", deps.signal);
+        if (isIndexBusy(abort)) {
+          await new Promise((resolve) => setTimeout(resolve, 150));
+          abort = await runCommand(deps.run, ["git", "revert", "--abort"], root, "revert-abort-retry", deps.signal);
+        }
+        const aborted = "run" in abort && abort.run.exitCode === 0;
+        return aborted ? { ok: false, error: { code: "revert-conflict", message: failure.message + where } } : { ok: false, error: { code: "revert-stuck", message: failure.message + where } };
+      }
+      return { ok: false, error: { code: failure.code, message: failure.message + where } };
+    }
+    if (request.action.kind === "stash-push" && /No local changes to save/i.test(outcome.run.stdout + outcome.run.stderr)) {
+      return { ok: false, error: { code: "git-error", message: (outcome.run.stdout.trim() || "No local changes to save") + where } };
+    }
+  }
+  const snapshot = await snapshotForSession(deps, config, request.sessionId);
+  if (!snapshot.ok) {
+    return { ok: false, error: { code: "git-error", message: "snapshot after action failed" } };
+  }
+  return { ok: true, snapshot: snapshot.value, output: lastOutput.trim() };
+}
+async function discardUntracked(deps, config, root, sessionId, paths) {
+  const snap = await snapshotForSession(deps, config, sessionId);
+  if (!snap.ok) return null;
+  const untrackedSet = new Set(snap.value.changes.filter((c) => c.status === "untracked").map((c) => c.path));
+  const untracked = paths.filter((p) => untrackedSet.has(p));
+  if (untracked.length === 0) return null;
+  const tracked = paths.filter((p) => !untrackedSet.has(p));
+  let rootReal;
+  try {
+    rootReal = await deps.fs.realpath(root);
+  } catch {
+    return { ok: false, result: { ok: false, error: { code: "git-error", message: "repository root unavailable" } } };
+  }
+  for (const path of untracked) {
+    if (!isSafePath(path)) return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `unsafe path: ${path}` } } };
+    const target = join(root, path);
+    let targetReal;
+    try {
+      targetReal = await deps.fs.realpath(target);
+    } catch {
+      continue;
+    }
+    if (targetReal !== rootReal && !targetReal.startsWith(rootReal + sep)) {
+      return { ok: false, result: { ok: false, error: { code: "invalid-path", message: `path escapes repository: ${path}` } } };
+    }
+    await deps.fs.remove(target).catch(() => {
+    });
+  }
+  return { ok: true, remainingTracked: tracked };
+}
+export {
+  classifyActionFailure,
+  isSafePath,
+  planAction,
+  runAction,
+  scrubCredentials
+};

package/lib/host/core.d.ts

@@ -1,6 +1,6 @@
-import type { GitRunner } from './git.ts';
-import type { AgentDefaultModelFace, LlmFace } from './llm-face.ts';
-import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.ts';
+import type { GitRunner } from './git.js';
+import type { AgentDefaultModelFace, LlmFace } from './llm-face.js';
+import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.js';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
     /** Per-command stdout cap; also the per-side image-diff payload cap. */

package/lib/host/core.js

@@ -0,0 +1,300 @@
+import { dirname, join } from "node:path";
+import { commitFromFields, parseStatus, sumNumstat } from "./parser.js";
+import { parseRemote } from "./remote.js";
+import { isSafePath } from "./validate.js";
+const DEFAULT_CONFIG = {
+  timeoutMs: 8e3,
+  maxBytes: 4 * 1024 * 1024,
+  maxChanges: 1e3,
+  refreshIntervalMs: 3e4,
+  showInputPill: true,
+  defaultDiffView: "unified",
+  graphStyle: "parallel",
+  suggestEnabled: true,
+  suggestMaxBytes: 64 * 1024,
+  suggestMaxOutputTokens: 200,
+  suggestTimeoutMs: 15e3
+};
+function normalizeConfig(raw) {
+  const c = raw ?? {};
+  const num = (v, d) => typeof v === "number" && Number.isFinite(v) && v >= 1 ? Math.floor(v) : d;
+  const hasProvider = typeof c.suggestProvider === "string" && c.suggestProvider !== "";
+  const hasModel = typeof c.suggestModel === "string" && c.suggestModel !== "";
+  const route = hasProvider && hasModel ? { suggestProvider: c.suggestProvider, suggestModel: c.suggestModel } : {};
+  return {
+    timeoutMs: num(c.timeoutMs, DEFAULT_CONFIG.timeoutMs),
+    maxBytes: num(c.maxBytes, DEFAULT_CONFIG.maxBytes),
+    maxChanges: num(c.maxChanges, DEFAULT_CONFIG.maxChanges),
+    refreshIntervalMs: num(c.refreshIntervalMs, DEFAULT_CONFIG.refreshIntervalMs),
+    showInputPill: readBool(c.showInputPill, DEFAULT_CONFIG.showInputPill),
+    defaultDiffView: readDiffView(c.defaultDiffView, DEFAULT_CONFIG.defaultDiffView),
+    graphStyle: readGraphStyle(c.graphStyle, DEFAULT_CONFIG.graphStyle),
+    suggestEnabled: readBool(c.suggestEnabled, DEFAULT_CONFIG.suggestEnabled),
+    suggestMaxBytes: num(c.suggestMaxBytes, DEFAULT_CONFIG.suggestMaxBytes),
+    suggestMaxOutputTokens: num(c.suggestMaxOutputTokens, DEFAULT_CONFIG.suggestMaxOutputTokens),
+    suggestTimeoutMs: num(c.suggestTimeoutMs, DEFAULT_CONFIG.suggestTimeoutMs),
+    ...route
+  };
+}
+function unwrapVolatile(value) {
+  return value !== null && typeof value === "object" && "get" in value && typeof value.get === "function" ? value.get() : value;
+}
+function readDiffView(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return raw === "unified" || raw === "split" ? raw : fallback;
+}
+function readGraphStyle(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return raw === "parallel" || raw === "compact" ? raw : fallback;
+}
+function readBool(value, fallback) {
+  const raw = unwrapVolatile(value);
+  return typeof raw === "boolean" ? raw : fallback;
+}
+const NEG_CACHE_MS = 15e3;
+function parsePrimaryRemote(stdout) {
+  const fetchUrls = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const line of stdout.split("\n")) {
+    const m = line.match(/^(\S+)\t(\S+)\s+\(fetch\)$/);
+    if (m === null) continue;
+    const name2 = m[1];
+    if (!fetchUrls.has(name2)) {
+      fetchUrls.set(name2, m[2]);
+      order.push(name2);
+    }
+  }
+  if (order.length === 0) return null;
+  const name = fetchUrls.has("origin") ? "origin" : order[0];
+  return parseRemote(name, fetchUrls.get(name));
+}
+const STATS_FANOUT_LIMIT = 200;
+async function resolveBrowseRoot(deps, sessionId) {
+  const ws = await resolveWorkspace(deps, sessionId);
+  if (ws.ok) return { ok: true, root: ws.root, isGitRepo: true };
+  const err = ws.failure.error;
+  if ((err.code === "not-a-git-repo" || err.code === "git-unavailable") && "cwd" in err && err.cwd !== void 0 && err.cwd !== "") {
+    try {
+      return { ok: true, root: await deps.fs.realpath(err.cwd), isGitRepo: false };
+    } catch {
+      return { ok: false, error: { code: "git-error" } };
+    }
+  }
+  return { ok: false, error: mapWorkspaceFailure(ws.failure) };
+}
+async function resolveWorkspace(deps, sessionId) {
+  let cwd = deps.sessions.liveCwd(sessionId);
+  if (cwd === void 0 || cwd === "") {
+    const meta = await deps.sessions.persistedMeta(sessionId);
+    cwd = meta?.cwd;
+  }
+  if (cwd === void 0 || cwd === "") {
+    return { ok: false, failure: { ok: false, error: { code: "cwd-unavailable", sessionId } } };
+  }
+  const cached = deps.rootCache?.get(cwd);
+  if (cached !== void 0) return { ok: true, root: cached };
+  const negAt = deps.rootNegCache?.get(cwd);
+  if (negAt !== void 0) {
+    if (Date.now() < negAt) return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
+    deps.rootNegCache?.delete(cwd);
+  }
+  const top = await runCommand(deps.run, ["git", "rev-parse", "--show-toplevel"], cwd, "toplevel", deps.signal);
+  if ("failure" in top) {
+    return { ok: false, failure: { ok: false, error: { ...mapRunFailure(top.failure), cwd } } };
+  }
+  if (top.run.cancelled) return { ok: false, failure: { ok: false, error: { code: "cancelled" } } };
+  if (top.run.timedOut) return { ok: false, failure: { ok: false, error: { code: "timeout" } } };
+  if (top.run.exitCode !== 0) {
+    deps.rootNegCache?.set(cwd, Date.now() + NEG_CACHE_MS);
+    return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
+  }
+  const raw = top.run.stdout.trim();
+  if (raw === "") {
+    deps.rootNegCache?.set(cwd, Date.now() + NEG_CACHE_MS);
+    return { ok: false, failure: { ok: false, error: { code: "not-a-git-repo", cwd } } };
+  }
+  let root = raw;
+  try {
+    root = await deps.fs.realpath(raw);
+  } catch {
+  }
+  deps.rootCache?.set(cwd, root);
+  return { ok: true, root };
+}
+async function runCommand(runner, argv, cwd, _label, signal, stdinData) {
+  try {
+    const run = await runner.run(argv, { cwd, ...signal ? { signal } : {}, ...stdinData !== void 0 ? { stdinData } : {} });
+    return { run };
+  } catch (error) {
+    return { failure: error };
+  }
+}
+function mapRunFailure(failure) {
+  const message = failure instanceof Error ? failure.message : String(failure);
+  return { code: "git-unavailable", detail: message };
+}
+async function detectGitRepo(deps, cwd) {
+  let dir;
+  try {
+    dir = await deps.fs.realpath(cwd);
+  } catch {
+    dir = cwd;
+  }
+  for (let i = 0; i < 100; i++) {
+    try {
+      await deps.fs.stat(join(dir, ".git"));
+      return true;
+    } catch {
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+function mapWorkspaceFailure(failure) {
+  const error = failure.error;
+  const message = "detail" in error ? error.detail : void 0;
+  return { code: error.code, ...message !== void 0 ? { message } : {} };
+}
+async function snapshotForSession(deps, config, sessionId) {
+  const workspace = await resolveWorkspace(deps, sessionId);
+  if (!workspace.ok) {
+    const failure = workspace.failure;
+    if (failure.error.code === "not-a-git-repo") {
+      return { ok: false, error: { ...failure.error, showInputPill: config.showInputPill } };
+    }
+    if (failure.error.code === "git-unavailable") {
+      const cwd = failure.error.cwd;
+      const isGitRepo = cwd !== void 0 && cwd !== "" ? await detectGitRepo(deps, cwd) : false;
+      return { ok: false, error: { ...failure.error, isGitRepo } };
+    }
+    return failure;
+  }
+  const root = workspace.root;
+  const [branchRes, headRes, statusRes, aheadBehindRes, lastCommitRes, worktreeNumRes, stagedNumRes, remoteRes] = await Promise.all([
+    runCommand(deps.run, ["git", "symbolic-ref", "--quiet", "--short", "HEAD"], root, "branch", deps.signal),
+    runCommand(deps.run, ["git", "rev-parse", "--short", "HEAD"], root, "head", deps.signal),
+    runCommand(deps.run, ["git", "status", "--porcelain=v1", "-z"], root, "status", deps.signal),
+    runCommand(deps.run, ["git", "rev-list", "--count", "--left-right", "@{upstream}...HEAD"], root, "aheadBehind", deps.signal),
+    runCommand(deps.run, ["git", "log", "-1", "--format=%H%x1f%h%x1f%s%x1f%an%x1f%aI"], root, "lastCommit", deps.signal),
+    runCommand(deps.run, ["git", "diff", "--numstat"], root, "numstat-worktree", deps.signal),
+    runCommand(deps.run, ["git", "diff", "--numstat", "--cached"], root, "numstat-staged", deps.signal),
+    // `git remote -v` lists every remote's fetch/push URL; parsed into the
+    // primary remote (origin, else the first) for the left-column status bar.
+    runCommand(deps.run, ["git", "remote", "-v"], root, "remote", deps.signal)
+  ]);
+  const branch = "run" in branchRes && branchRes.run.exitCode === 0 ? branchRes.run.stdout.trim() || null : null;
+  const unborn = "run" in headRes && headRes.run.exitCode !== 0;
+  const head = "run" in headRes && headRes.run.exitCode === 0 ? headRes.run.stdout.trim() || null : null;
+  let allChanges = [];
+  let statusLossy = false;
+  if ("run" in statusRes && !statusRes.run.timedOut && statusRes.run.exitCode === 0) {
+    allChanges = parseStatus(statusRes.run.stdout);
+    statusLossy = statusRes.run.stdoutLossy;
+  }
+  const truncated = allChanges.length > config.maxChanges || statusLossy;
+  const changes = allChanges.length > config.maxChanges ? allChanges.slice(0, config.maxChanges) : allChanges;
+  let staged = 0;
+  let modified = 0;
+  let untracked = 0;
+  for (const c of allChanges) {
+    if (c.status === "untracked") untracked++;
+    else if (c.staged) staged++;
+    else modified++;
+  }
+  let ahead = 0;
+  let behind = 0;
+  const hasUpstream = "run" in aheadBehindRes && aheadBehindRes.run.exitCode === 0;
+  if (hasUpstream && "run" in aheadBehindRes) {
+    const parts = aheadBehindRes.run.stdout.trim().split(/\s+/);
+    behind = Number(parts[0]) || 0;
+    ahead = Number(parts[1]) || 0;
+  }
+  const remote = "run" in remoteRes && remoteRes.run.exitCode === 0 ? parsePrimaryRemote(remoteRes.run.stdout) : null;
+  let lastCommit = null;
+  if ("run" in lastCommitRes && lastCommitRes.run.exitCode === 0) {
+    lastCommit = commitFromFields(lastCommitRes.run.stdout.trim().split(""));
+  }
+  const wt = "run" in worktreeNumRes && worktreeNumRes.run.exitCode === 0 ? sumNumstat(worktreeNumRes.run.stdout) : { insertions: 0, deletions: 0 };
+  const stg = "run" in stagedNumRes && stagedNumRes.run.exitCode === 0 ? sumNumstat(stagedNumRes.run.stdout) : { insertions: 0, deletions: 0 };
+  const statsDetailed = allChanges.length <= STATS_FANOUT_LIMIT;
+  let untrackedInsertions = 0;
+  if (statsDetailed) {
+    const untrackedPaths = allChanges.filter((c) => c.status === "untracked" && !c.isDirectory).map((c) => c.path);
+    const safeUntracked = untrackedPaths.filter(isSafePath);
+    if (safeUntracked.length > 0) {
+      const perFile = await Promise.all(
+        safeUntracked.map((p) => runCommand(deps.run, ["git", "diff", "--numstat", "--no-index", "--", "/dev/null", p], root, "numstat-untracked", deps.signal))
+      );
+      for (const r of perFile) if ("run" in r) untrackedInsertions += sumNumstat(r.run.stdout).insertions;
+    }
+  }
+  const lastChangeAt = statsDetailed ? await maxChangeMtime(deps, root, allChanges) : null;
+  const distinct = new Set(allChanges.map((c) => c.path));
+  const stats = {
+    fileCount: distinct.size,
+    staged,
+    modified,
+    untracked,
+    insertions: wt.insertions + stg.insertions + untrackedInsertions,
+    deletions: wt.deletions + stg.deletions,
+    lastChangeAt,
+    headCommittedAt: lastCommit?.dateIso ?? null,
+    partial: !statsDetailed
+  };
+  const snapshot = {
+    root,
+    branch,
+    head,
+    unborn,
+    dirty: allChanges.length > 0,
+    staged,
+    modified,
+    untracked,
+    ahead,
+    behind,
+    hasUpstream,
+    remote,
+    lastCommit,
+    changes,
+    stats,
+    truncated,
+    refreshIntervalMs: config.refreshIntervalMs,
+    showInputPill: config.showInputPill,
+    defaultDiffView: config.defaultDiffView,
+    graphStyle: config.graphStyle,
+    suggestEnabled: config.suggestEnabled,
+    checkedAt: Date.now()
+  };
+  return { ok: true, value: snapshot };
+}
+async function maxChangeMtime(deps, root, changes, cap = 200) {
+  let max = null;
+  const slice = changes.slice(0, cap);
+  await Promise.all(slice.map(async (c) => {
+    if (c.isDirectory) return;
+    try {
+      const info = await deps.fs.stat(join(root, c.path));
+      if (Number.isFinite(info.mtimeMs)) {
+        max = max === null ? info.mtimeMs : Math.max(max, info.mtimeMs);
+      }
+    } catch {
+    }
+  }));
+  return max;
+}
+export {
+  DEFAULT_CONFIG,
+  mapWorkspaceFailure,
+  maxChangeMtime,
+  normalizeConfig,
+  parsePrimaryRemote,
+  readBool,
+  readDiffView,
+  readGraphStyle,
+  resolveBrowseRoot,
+  resolveWorkspace,
+  runCommand,
+  snapshotForSession
+};

package/lib/host/git.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+function createGitRunner(subprocess, timeoutMs, maxBytes) {
+  const spillMaxBytes = maxBytes * 16;
+  return {
+    async run(argv, opts) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), timeoutMs);
+      try {
+        const signal = opts.signal === void 0 ? controller.signal : AbortSignal.any([controller.signal, opts.signal]);
+        const handle = subprocess.spawn({
+          argv,
+          cwd: opts.cwd,
+          // Never let a network command (fetch/pull) block on an interactive
+          // credential or host-key prompt: with stdin ignored git would hang
+          // until the timeout. GIT_TERMINAL_PROMPT=0 makes it fail fast instead,
+          // and is harmless for the non-network commands that share this runner.
+          env: { GIT_TERMINAL_PROMPT: "0" },
+          stdio: {
+            stdin: opts.stdinData === void 0 ? "ignore" : { data: opts.stdinData },
+            stdout: { collect: { maxBytes, spill: { maxBytes: spillMaxBytes } } },
+            stderr: { collect: { maxBytes, spill: { maxBytes: spillMaxBytes } } }
+          },
+          graceMs: 200,
+          signal
+        });
+        let outcome;
+        try {
+          outcome = await handle.done;
+        } catch (error) {
+          const cancelled2 = opts.signal?.aborted === true && !controller.signal.aborted;
+          if (controller.signal.aborted || opts.signal?.aborted === true) {
+            return { exitCode: null, stdout: "", stderr: "", timedOut: !cancelled2, cancelled: cancelled2, stdoutLossy: false };
+          }
+          throw error;
+        }
+        const stdout = handle.collected.stdout?.readFrom(0);
+        const stderr = handle.collected.stderr?.readFrom(0);
+        const resolved = await resolveStdout(stdout);
+        const cancelled = opts.signal?.aborted === true && !controller.signal.aborted;
+        return {
+          exitCode: outcome.exitCode,
+          stdout: resolved.text,
+          stderr: stderr?.text ?? "",
+          timedOut: controller.signal.aborted,
+          cancelled,
+          stdoutLossy: resolved.lossy
+        };
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  };
+}
+async function resolveStdout(read) {
+  if (read === void 0) return { text: "", lossy: false };
+  if (!read.lossy || read.spillPath === void 0) return { text: read.text, lossy: read.lossy };
+  try {
+    return { text: await readFile(read.spillPath, "utf8"), lossy: false };
+  } catch {
+    return { text: read.text, lossy: true };
+  }
+}
+export {
+  createGitRunner
+};

package/lib/host/index.d.ts

@@ -9,16 +9,16 @@
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
-import type { GitActionRequest, GitActionResult, GitQueryRequest, GitQueryResponse, GitSnapshotRequest, GitSnapshotResult, GitSuggestRequest, GitSuggestResult, GitVersionInfo, GitVersionRequest } from './types.ts';
-export type { GitSnapshot, GitSnapshotResult, GitSnapshotRequest, GitFailure, GitCommit, GraphCommit, GitRef, GitChange, GitChangeStatus, GitAction, GitActionRequest, GitActionResult, GitErrorCode, GitQuery, GitQueryRequest, GitQueryResponse, GitQueryResult, GitBranch, GitFileStat, WorktreeStats, StashEntry, GitVersionRequest, GitVersionInfo, DiffViewMode, GraphStyle, DirEntry, ResetMode, GitSuggestRequest, GitSuggestResult, GitRemote, RemoteHostKind, } from './types.ts';
-export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace, parsePrimaryRemote } from './core.ts';
-export { createGitRunner } from './git.ts';
-export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from './parser.ts';
-export { parseRemote, classifyHost } from './remote.ts';
-export { isSafePath, planAction, runAction, classifyActionFailure } from './actions.ts';
-export { runQuery } from './queries.ts';
-export { runSuggest } from './suggest.ts';
-export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.ts';
+import type { GitActionRequest, GitActionResult, GitQueryRequest, GitQueryResponse, GitSnapshotRequest, GitSnapshotResult, GitSuggestRequest, GitSuggestResult, GitVersionInfo, GitVersionRequest } from './types.js';
+export type { GitSnapshot, GitSnapshotResult, GitSnapshotRequest, GitFailure, GitCommit, GraphCommit, GitRef, GitChange, GitChangeStatus, GitAction, GitActionRequest, GitActionResult, GitErrorCode, GitQuery, GitQueryRequest, GitQueryResponse, GitQueryResult, GitBranch, GitFileStat, WorktreeStats, StashEntry, GitVersionRequest, GitVersionInfo, DiffViewMode, GraphStyle, DirEntry, ResetMode, GitSuggestRequest, GitSuggestResult, GitRemote, RemoteHostKind, } from './types.js';
+export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace, parsePrimaryRemote } from './core.js';
+export { createGitRunner } from './git.js';
+export { parseStatus, parseGraphLog, parseBranches, parseNameStatus, parseStashList, parseTags, sumNumstat } from './parser.js';
+export { parseRemote, classifyHost } from './remote.js';
+export { isSafePath, planAction, runAction, classifyActionFailure } from './actions.js';
+export { runQuery } from './queries.js';
+export { runSuggest } from './suggest.js';
+export { readVersionInfo, checkLatestVersion, compareVersions, parseRepository } from './version.js';
 export declare class GitPanelService extends TypertRemoteService {
     static inject: string[];
     /**