@xbzbing/dsh-git-panel 1.4.0 → 1.5.1

package/lib/host/actions.d.ts

@@ -11,6 +11,9 @@ type PlanResult = CommandPlan | {
 };
 /** Build the git command sequence for an action. */
 export declare function planAction(action: GitAction, unborn: boolean): PlanResult;
+/** Strip an embedded credential (`scheme://user:token@host`) from a git
+ * message so a token in a remote URL never reaches the RPC reply or logs. */
+export declare function scrubCredentials(text: string): string;
 /**
  * Classify a non-zero git exit into a wire error code + message. Order is
  * semantic and must not be reshuffled:

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, GitSnapshotResult } from './types.ts';
+import type { DiffViewMode, GraphStyle, GitChange, GitErrorCode, GitRemote, GitSnapshotResult } from './types.ts';
 export interface GitPanelConfig {
     readonly timeoutMs: number;
     /** Per-command stdout cap; also the per-side image-diff payload cap. */
@@ -85,6 +85,12 @@ export interface SnapshotDeps {
     readonly getLlm?: () => LlmFace | undefined;
     readonly getAgentDefaultModel?: () => AgentDefaultModelFace | undefined;
 }
+/**
+ * Pick the primary remote from `git remote -v` output and parse its fetch URL.
+ * Prefers `origin`; otherwise the first remote listed. Lines look like
+ * `origin\thttps://…\t(fetch)` — only `(fetch)` rows are considered.
+ */
+export declare function parsePrimaryRemote(stdout: string): GitRemote | null;
 export type WorkspaceResolution = {
     readonly ok: true;
     readonly root: string;

package/lib/host/git.d.ts

@@ -18,6 +18,8 @@ interface SpawnSpec {
     };
     readonly graceMs: number;
     readonly signal?: AbortSignal;
+    /** Explicit child env entries merged onto the service's scrubbed base. */
+    readonly env?: Readonly<Record<string, string | undefined>>;
 }
 interface OutputRead {
     readonly text: string;

package/lib/host/index.d.ts

@@ -10,10 +10,11 @@ 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, } from './types.ts';
-export { normalizeConfig, DEFAULT_CONFIG, snapshotForSession, resolveWorkspace } from './core.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';

package/lib/host/index.js

@@ -65,6 +65,11 @@ function createGitRunner(subprocess, timeoutMs, maxBytes) {
         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 } } },
@@ -214,7 +219,15 @@ function parseRefs(decoration) {
       continue;
     }
     if (token.startsWith("tag: ")) {
-      refs.push({ kind: "tag", name: token.slice("tag: ".length).trim(), head: false });
+      refs.push({ kind: "tag", name: token.slice("tag: ".length).trim().replace(/^refs\/tags\//, ""), head: false });
+    } else if (token.startsWith("refs/tags/")) {
+      refs.push({ kind: "tag", name: token.slice("refs/tags/".length), head: false });
+    } else if (token.startsWith("refs/remotes/")) {
+      refs.push({ kind: "remote", name: token.slice("refs/remotes/".length), head });
+    } else if (token.startsWith("refs/heads/")) {
+      refs.push({ kind: "branch", name: token.slice("refs/heads/".length), head });
+    } else if (head) {
+      refs.push({ kind: "branch", name: token, head });
     } else if (token.startsWith("origin/") || token.includes("/")) {
       refs.push({ kind: "remote", name: token, head });
     } else {
@@ -310,6 +323,52 @@ function sumNumstat(stdout) {
   return { insertions, deletions };
 }
 
+// src/host/remote.ts
+function classifyHost(host) {
+  const h = host.toLowerCase();
+  if (h === "github.com" || h.endsWith(".github.com")) return "github";
+  if (h === "gitlab.com" || h.endsWith(".gitlab.com")) return "gitlab";
+  if (h === "gitee.com" || h.endsWith(".gitee.com")) return "gitee";
+  if (h === "bitbucket.org" || h.endsWith(".bitbucket.org")) return "bitbucket";
+  return "other";
+}
+function normalizePath(path) {
+  return path.replace(/^\/+/, "").replace(/\/+$/, "").replace(/\.git$/i, "");
+}
+function splitHostPath(raw) {
+  const url = raw.trim();
+  if (url === "") return null;
+  const scp = url.match(/^(?:[^@/]+@)?([^/:]+):(.+)$/);
+  if (scp !== null && !/^[a-z][a-z0-9+.-]*:\/\//i.test(url)) {
+    const host = scp[1];
+    const path = normalizePath(scp[2]);
+    return host !== "" && path !== "" ? { host, path } : null;
+  }
+  const scheme = url.match(/^[a-z][a-z0-9+.-]*:\/\/([^/]+)\/(.+)$/i);
+  if (scheme !== null) {
+    let authority = scheme[1];
+    const at = authority.lastIndexOf("@");
+    if (at >= 0) authority = authority.slice(at + 1);
+    const host = authority.replace(/:\d+$/, "");
+    const path = normalizePath(scheme[2]);
+    return host !== "" && path !== "" ? { host, path } : null;
+  }
+  return null;
+}
+function parseRemote(name, url) {
+  const parsed = splitHostPath(url);
+  if (parsed === null) {
+    return { name, url, webUrl: null, host: null, hostKind: "other" };
+  }
+  return {
+    name,
+    url,
+    webUrl: `https://${parsed.host}/${parsed.path}`,
+    host: parsed.host,
+    hostKind: classifyHost(parsed.host)
+  };
+}
+
 // src/host/validate.ts
 import { isAbsolute, normalize } from "node:path";
 function isSafePath(path) {
@@ -328,6 +387,9 @@ function isSafeRev(input) {
 function isSafeBranchName(name) {
   return isSafeRev(name) && !name.startsWith("/");
 }
+function isSafeRemoteName(name) {
+  return /^[A-Za-z0-9._][A-Za-z0-9._/-]*$/.test(name) && name.length <= 128;
+}
 
 // src/host/core.ts
 var DEFAULT_CONFIG = {
@@ -380,6 +442,22 @@ function readBool(value, fallback) {
   return typeof raw === "boolean" ? raw : fallback;
 }
 var 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));
+}
 var STATS_FANOUT_LIMIT = 200;
 async function resolveBrowseRoot(deps, sessionId) {
   const ws = await resolveWorkspace(deps, sessionId);
@@ -484,14 +562,17 @@ async function snapshotForSession(deps, config, sessionId) {
     return failure;
   }
   const root = workspace.root;
-  const [branchRes, headRes, statusRes, aheadBehindRes, lastCommitRes, worktreeNumRes, stagedNumRes] = await Promise.all([
+  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)
+    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;
@@ -514,11 +595,13 @@ async function snapshotForSession(deps, config, sessionId) {
   }
   let ahead = 0;
   let behind = 0;
-  if ("run" in aheadBehindRes && aheadBehindRes.run.exitCode === 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(""));
@@ -561,6 +644,8 @@ async function snapshotForSession(deps, config, sessionId) {
     untracked,
     ahead,
     behind,
+    hasUpstream,
+    remote,
     lastCommit,
     changes,
     stats,
@@ -630,6 +715,13 @@ function planAction(action, unborn) {
       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}` };
@@ -670,9 +762,12 @@ 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 = stderr.trim();
+  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" };
   }
@@ -685,6 +780,15 @@ function classifyActionFailure(stdout, stderr, exitCode) {
   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 };
   }
@@ -861,6 +965,10 @@ async function runQuery(deps, config, request) {
         return await queryLastCommitMessage(deps, root);
       case "worktree-stats":
         return await queryWorktreeStats(deps, config, request.sessionId);
+      case "pull-preview":
+        return await queryPullPreview(deps, root);
+      case "push-preview":
+        return await queryPushPreview(deps, root);
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -870,7 +978,7 @@ async function runQuery(deps, config, request) {
 async function queryHistory(deps, root, q) {
   const limit = Number.isFinite(q.limit) ? Math.min(500, Math.max(1, Math.trunc(q.limit))) : 100;
   const skip = Number.isFinite(q.skip) ? Math.max(0, Math.trunc(q.skip)) : 0;
-  const args = ["git", "log", "--topo-order", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
+  const args = ["git", "log", "--topo-order", "--decorate=full", GRAPH_FORMAT, `--max-count=${limit}`, `--skip=${skip}`];
   const search = q.search?.trim() ?? "";
   const hexJump = search !== "" && isHexLike(search);
   const countArgs = ["git", "rev-list", "--count"];
@@ -1226,6 +1334,40 @@ async function queryLastCommitMessage(deps, root) {
   const message = "run" in res && res.run.exitCode === 0 ? res.run.stdout.replace(/\n+$/, "") : "";
   return { ok: true, value: { kind: "last-commit-message", message } };
 }
+async function queryPullPreview(deps, root) {
+  const empty = { kind: "pull-preview", hasUpstream: false, commits: 0, files: 0, insertions: 0, deletions: 0 };
+  const commitsRes = await runCommand(deps.run, ["git", "rev-list", "--count", "--end-of-options", "HEAD..@{upstream}"], root, "pull-preview-count", deps.signal);
+  if (!("run" in commitsRes) || commitsRes.run.exitCode !== 0) return { ok: true, value: empty };
+  const commits = Number(commitsRes.run.stdout.trim()) || 0;
+  const diffRes = await runCommand(deps.run, ["git", "diff", "--numstat", "--end-of-options", "HEAD", "@{upstream}"], root, "pull-preview-diff", deps.signal);
+  let files = 0;
+  let insertions = 0;
+  let deletions = 0;
+  if ("run" in diffRes && diffRes.run.exitCode === 0) {
+    files = diffRes.run.stdout.split("\n").filter((l) => l.trim() !== "").length;
+    const sum = sumNumstat(diffRes.run.stdout);
+    insertions = sum.insertions;
+    deletions = sum.deletions;
+  }
+  return { ok: true, value: { kind: "pull-preview", hasUpstream: true, commits, files, insertions, deletions } };
+}
+async function queryPushPreview(deps, root) {
+  const empty = { kind: "push-preview", hasUpstream: false, commits: 0, files: 0, insertions: 0, deletions: 0 };
+  const commitsRes = await runCommand(deps.run, ["git", "rev-list", "--count", "--end-of-options", "@{upstream}..HEAD"], root, "push-preview-count", deps.signal);
+  if (!("run" in commitsRes) || commitsRes.run.exitCode !== 0) return { ok: true, value: empty };
+  const commits = Number(commitsRes.run.stdout.trim()) || 0;
+  const diffRes = await runCommand(deps.run, ["git", "diff", "--numstat", "--end-of-options", "@{upstream}", "HEAD"], root, "push-preview-diff", deps.signal);
+  let files = 0;
+  let insertions = 0;
+  let deletions = 0;
+  if ("run" in diffRes && diffRes.run.exitCode === 0) {
+    files = diffRes.run.stdout.split("\n").filter((l) => l.trim() !== "").length;
+    const sum = sumNumstat(diffRes.run.stdout);
+    insertions = sum.insertions;
+    deletions = sum.deletions;
+  }
+  return { ok: true, value: { kind: "push-preview", hasUpstream: true, commits, files, insertions, deletions } };
+}
 async function queryWorktreeStats(deps, config, sessionId) {
   const snapshot = await snapshotForSession(deps, config, sessionId);
   if (!snapshot.ok) return { ok: false, error: { code: "git-error", message: "snapshot failed" } };
@@ -1689,6 +1831,7 @@ export {
   GitPanelService,
   checkLatestVersion,
   classifyActionFailure,
+  classifyHost,
   compareVersions,
   createGitRunner,
   index_default as default,
@@ -1697,6 +1840,8 @@ export {
   parseBranches,
   parseGraphLog,
   parseNameStatus,
+  parsePrimaryRemote,
+  parseRemote,
   parseRepository,
   parseStashList,
   parseStatus,

package/lib/host/remote.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parse a git remote URL into a browsable https page URL + host classification.
+ *
+ * Git remotes come in several shapes — scp-like ssh (`git@host:owner/repo.git`),
+ * ssh:// , https:// , git:// — all of which must collapse to a single
+ * `https://<host>/<path>` page link and a known-host kind for the status-bar
+ * icon. Credentials in the URL (`https://user:token@host/…`) are stripped so a
+ * token can never leak into an href the browser renders.
+ */
+import type { GitRemote, RemoteHostKind } from './types.ts';
+/** Map a hostname to a known-host kind (self-hosted / unknown → 'other'). */
+export declare function classifyHost(host: string): RemoteHostKind;
+/** Build a {@link GitRemote} from a remote name + its configured URL. */
+export declare function parseRemote(name: string, url: string): GitRemote;

package/lib/host/types.d.ts

@@ -37,6 +37,21 @@ export type GitFailure = {
 } | {
     readonly code: 'cancelled';
 };
+/** Host classification for a remote URL (drives the status-bar icon). */
+export type RemoteHostKind = 'github' | 'gitlab' | 'gitee' | 'bitbucket' | 'other';
+/** The repository's primary remote (origin, else the first remote). */
+export interface GitRemote {
+    /** Remote name (`origin`, or the first configured remote). */
+    readonly name: string;
+    /** The configured fetch URL, verbatim (ssh/scp/https/git form). */
+    readonly url: string;
+    /** A browsable https URL for the repo page; null when unparseable. */
+    readonly webUrl: string | null;
+    /** The remote hostname (e.g. `github.com`); null when unparseable. */
+    readonly host: string | null;
+    /** Known-host classification, for the status-bar icon. */
+    readonly hostKind: RemoteHostKind;
+}
 /** Immutable snapshot of one repository's status at `checkedAt`. */
 export interface GitSnapshot {
     /** Realpath of the repository root (work tree top). */
@@ -54,6 +69,10 @@ export interface GitSnapshot {
     readonly untracked: number;
     readonly ahead: number;
     readonly behind: number;
+    /** True when the current branch tracks an upstream (@{upstream} resolves). */
+    readonly hasUpstream: boolean;
+    /** The repository's primary remote; null when none is configured. */
+    readonly remote: GitRemote | null;
     readonly lastCommit: GitCommit | null;
     readonly changes: readonly GitChange[];
     /** Working-tree statistics for the changes-page header (single source). */
@@ -128,6 +147,13 @@ export type GitAction = {
     readonly name: string;
 } | {
     readonly kind: 'fetch';
+} | {
+    readonly kind: 'pull-ff';
+} | {
+    readonly kind: 'push';
+} | {
+    readonly kind: 'publish';
+    readonly remote: string;
 } | {
     readonly kind: 'tag-create';
     readonly name: string;
@@ -162,7 +188,7 @@ export type GitAction = {
 /** `git reset` modes, from least to most destructive. Single source so the
  * client dialog and the command builder cannot drift. */
 export type ResetMode = 'soft' | 'mixed' | 'hard';
-export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
+export type GitErrorCode = 'cwd-unavailable' | 'not-a-git-repo' | 'git-unavailable' | 'invalid-path' | 'invalid-name' | 'invalid-index' | 'git-error' | 'timeout' | 'cancelled' | 'empty-message' | 'local-changes-block' | 'not-ff' | 'push-rejected' | 'auth-failed' | 'conflict' | 'revert-conflict' | 'revert-stuck' | 'revert-merge' | 'not-found' | 'index-busy' | 'empty-diff' | 'llm-unavailable' | 'llm-error' | 'llm-output' | 'suggest-disabled';
 export type GitActionResult = {
     readonly ok: true;
     readonly snapshot: GitSnapshot;
@@ -244,6 +270,10 @@ export type GitQuery = {
     readonly kind: 'last-commit-message';
 } | {
     readonly kind: 'worktree-stats';
+} | {
+    readonly kind: 'pull-preview';
+} | {
+    readonly kind: 'push-preview';
 };
 /** One entry in a `dir-list` result. */
 export interface DirEntry {
@@ -359,6 +389,20 @@ export type GitQueryResult = {
 } | {
     readonly kind: 'worktree-stats';
     readonly stats: WorktreeStats;
+} | {
+    readonly kind: 'pull-preview';
+    readonly hasUpstream: boolean;
+    readonly commits: number;
+    readonly files: number;
+    readonly insertions: number;
+    readonly deletions: number;
+} | {
+    readonly kind: 'push-preview';
+    readonly hasUpstream: boolean;
+    readonly commits: number;
+    readonly files: number;
+    readonly insertions: number;
+    readonly deletions: number;
 } | {
     readonly kind: 'dir-list';
     readonly path: string;

package/lib/host/validate.d.ts

@@ -8,3 +8,7 @@ export declare function isSafePath(path: string): boolean;
 export declare function isSafeRev(input: string): boolean;
 /** A branch name for `git checkout`: the ref rules plus no leading slash. */
 export declare function isSafeBranchName(name: string): boolean;
+/** A git remote name for `git push -u <remote> HEAD`. Allows the characters git
+ * permits in a remote name (alphanumerics, `._/-`) but never a leading dash, so
+ * a configured remote can never slip into the option position. */
+export declare function isSafeRemoteName(name: string): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbzbing/dsh-git-panel",
-  "version": "1.4.0",
+  "version": "1.5.1",
   "description": "DeepSeek Harness (dsh) plugin: an IDE-style Git panel in the Web GUI — branch/history overview, uncommitted changes with commit & amend, diff stats, and a zsh-style branch marker in the input bar.",
   "type": "module",
   "license": "MIT",