dsh-gitbar-lite 0.3.0 → 0.4.0

package/README.en.md

@@ -23,7 +23,9 @@ The column is narrow (300px minimum, and a narrow viewport makes it full-screen)
 | Commit | Commits exactly what is ticked — because ticking wrote the index |
 | Commit and Push | Commits, then pushes. **A failed push never claims the commit failed**: the commit happened, and the panel says "committed `abc1234`, but the push failed" |
 | Context button | **Push** when local commits are unpushed, **Publish** when the branch has no upstream, **Fetch** otherwise |
-| Automatic fetch | Every five minutes while the panel is visible and the repository has a remote (`autoFetchMs`, `0` to disable). Failures are silent — no error banner |
+| Fetch before push | A push runs `git fetch --prune` first, then pushes. **Being behind refuses the push** and says by how many — git never merges on a push, so it would be rejected either way, and knowing before the attempt beats being told after. A failed fetch does not block the push |
+| Automatic fetch | GitHub Desktop's rhythm while the panel is visible and the repository has a remote: an hour by default, each tick re-asking whether to run, the next scheduled from the *completion* of the last, with a random skew so panels do not sync up. The pace is `autoFetchMs` (`0` to disable), and "was it fetched recently" is answered by `FETCH_HEAD`'s mtime — so a fetch in a terminal counts too |
+| Panel regains focus | The file list refreshes when the panel becomes visible again; if a script is configured, it runs and fills the Summary |
 | Discard | One file or all of them; the diff is archived *before* anything is restored, and the confirmation offers "delete for good" |
 | Trash | Its own tab. Every discard keeps a diff, recorded **against the commit it was taken from** (`abc1234 initial commit`) |
 | Diff preview | Double-click a file, or a trash entry, to open a diff tab in the column — **one tab, ever**, re-navigated in place |
@@ -222,7 +224,7 @@ are in [`docs/CONTRACT.md`](./docs/CONTRACT.md).
 
 ```sh
 npm test          # unit + real-git e2e + artifact self-check
-npm run test:e2e  # the real-git suite alone (21 sections building their own fixtures, 263 assertions)
+npm run test:e2e  # the real-git suite alone (22 sections building their own fixtures, 277 assertions)
 npm run check     # artifact self-check alone (catches boot-breaking mistakes without restarting DSH)
 npm run test:live # probe a running DSH (not part of npm test; needs the app running)
 ```

package/README.md

@@ -23,7 +23,9 @@ DSH 的右栏本来就是一个常驻的标签区。Git 面板放这里，意味
 | Commit | 只提交勾上的（因为勾选写进了索引） |
 | Commit and Push | 提交后立刻推送；**推送失败不会说「提交失败」**——提交已经发生了，面板会明说「已提交 xxx，但推送失败」 |
 | 上下文按钮 | 有本地未推送提交时是 **Push**，没有上游时是 **Publish**，否则是 **Fetch** |
-| 自动 Fetch | 面板可见且仓库有远端时，每 5 分钟自己 fetch 一次（`autoFetchMs` 可调，`0` 关掉）。失败是静默的，不弹错误 |
+| Push 前先 Fetch | 推送前会先 `git fetch --prune`，然后才推。**已经落后就拒绝推**并说明落后几个——git 的 push 从不合并，早晚都是被拒，先知道比推完再被拒有用。fetch 本身失败不阻断推送 |
+| 自动 Fetch | 面板可见且仓库有远端时按 GitHub Desktop 的口径自己抓：默认 1 小时，每次到点重新判断，下一次从**上一次完成后**开始排，并加随机抖动防止多个面板同步。节奏是 `autoFetchMs`（`0` 关掉），并且用 `FETCH_HEAD` 的 mtime 判断"是不是刚抓过"——你在终端里抓也算 |
+| 面板获得焦点 | 面板重新可见时刷新文件列表；配了脚本就顺带跑一次填 Summary |
 | 舍弃更改 | 单个文件或「全部舍弃」；动手前先把这次改动的 diff 归档，确认框里可以勾「彻底删除」 |
 | 回收站 | 独立 tab。每次舍弃存一份 diff，并记下**是对哪个提交（`abc1234 初始提交`）取的 diff** |
 | diff 预览 | 双击文件，或点回收站里的一条，在右栏开一个 diff 标签页——**永远只占一个**，再点就复用 |
@@ -202,7 +204,7 @@ lib/client.js          浏览器半边：三个 tab 类型 + 面板/回收站/di
 
 ```sh
 npm test          # 单测 + 真 git 的 e2e + 产物自检
-npm run test:e2e  # 只跑真 git 的 e2e（21 个小节，各自造自己的夹具，263 项断言）
+npm run test:e2e  # 只跑真 git 的 e2e（22 个小节，各自造自己的夹具，277 项断言）
 npm run check     # 只用产物自检（不启 DSH 也能发现会让 DSH 起不来的问题）
 npm run test:live # 探测一个正在运行的 DSH（不在 npm test 里，需要跑着应用）
 ```

package/docs/CONTRACT.md

@@ -326,7 +326,7 @@ this package on the next upgrade.
 | state files, the binding key, corruption tolerance, write serialization | `test/store.test.mjs` |
 | the route carrier, single registration under a hostile service order, error classification | `test/index.test.mjs` |
 | every registration identity, the wire literals, the dictionaries, and the hook-free components' rendered trees | `test/client.test.mjs` |
-| the whole host stack against **real git**, mutation by mutation | `test/e2e.mjs`, 263 assertions over 21 sections that build their own fixtures |
+| the whole host stack against **real git**, mutation by mutation | `test/e2e.mjs`, 277 assertions over 22 sections that build their own fixtures |
 | the manifest, the patch layer, the tarball's contents, the two copies of the wire contract, the dictionaries, the workflow | `test/check.mjs` |
 | that the client bundle would not abort the Host boot | `scripts/check-client-bundle.mjs` |
 

package/lib/client.js

@@ -1592,6 +1592,14 @@ window.__ModuleLoader__.load({
             setSummary('')
             setDescription('')
             setDescriptionOpen(false)
+            // Clear the "already auto-selected this set" guard, so the
+            // select-by-default rule applies again to whatever is left. GitHub
+            // Desktop's equivalent is that a rebuilt working-directory list has
+            // every new file included; here the same effect comes from letting
+            // the existing rule run once more. A clean tree makes it a no-op,
+            // and a partly-ticked commit leaves the rest ticked, which is what
+            // Desktop does.
+            autoStaged.current = ''
             const short = data.commit?.short ?? ''
             if (andPush && data.push?.ok === false) {
               flash('warn', `${t('toast.pushFailed', { commit: short })}：${errorText(t, data.push.error?.code, data.push.error?.message)}`)

package/lib/host/repo.js

@@ -436,8 +436,30 @@ export function createRepo(git, config) {
    * @param {string} repoRoot
    * @param {AbortSignal} [signal]
    */
+  /**
+   * Push the current branch, publishing it when it has no upstream yet.
+   *
+   * A fetch runs first. GitHub Desktop goes further — fetch, then pull, then push
+   * — but a pull rewrites the working tree, and this panel's whole model is that
+   * a tick is the real index: a merge commit appearing under the user between
+   * their tick and their push would quietly invalidate what they selected. So the
+   * fetch is followed by a check instead, and the push is refused with a sentence
+   * when the branch has fallen behind.
+   *
+   * That refusal is the honest outcome, not a limitation: git never merges on
+   * push, so a behind branch is rejected either way. What the fetch buys is that
+   * the answer is known *before* the push attempt, and that the upstream tracking
+   * ref the ahead/behind count is read from is current rather than however stale
+   * it was when the panel opened.
+   *
+   * The fetch itself is best-effort: if it fails (offline, no credential) the
+   * push still goes ahead, because the fetch's failure says nothing about whether
+   * the push can work, and silently refusing to push would be worse.
+   *
+   * @param {string} repoRoot
+   * @param {AbortSignal} [signal]
+   */
   async function push(repoRoot, signal) {
-    const { branch } = await statusOf(repoRoot, signal)
     const remotesResult = await git.run(['remote'], { cwd: repoRoot, signal })
     const remotes =
       remotesResult.exitCode === 0
@@ -448,13 +470,36 @@ export function createRepo(git, config) {
         : []
     const remote = pickRemote(remotes)
 
+    let fetched = false
+    const preFetch = await git.run(['fetch', '--prune', remote], { cwd: repoRoot, signal, maxBytes: 1024 * 1024 })
+    if (preFetch.exitCode === 0) fetched = true
+
+    // Re-read after the fetch: the branch's upstream and its ahead/behind counts
+    // are exactly what the fetch may have changed.
+    const { branch } = await statusOf(repoRoot, signal)
+
+    // Only refuse when we *know* we are behind, which requires both an upstream
+    // and a fetch that actually told us something. Without an upstream this is a
+    // publish, and a failed fetch leaves the counts unknown — neither should be
+    // turned into a refusal.
+    if (fetched && branch.upstream !== null && branch.behind > 0) {
+      const refusal = new RepoError(
+        ERROR_CODES.PUSH_REJECTED,
+        `远端有新提交（落后 ${branch.behind} 个），先 Pull 或 Rebase 再推。`,
+      )
+      // Carried on the error so the route can report "we did look" alongside the
+      // refusal, rather than the caller having to guess whether a fetch happened.
+      refusal.fetched = true
+      throw refusal
+    }
+
     const args =
       branch.upstream === null ? ['push', '--set-upstream', remote, 'HEAD'] : ['push', remote]
     const result = await git.run(args, { cwd: repoRoot, signal, maxBytes: 1024 * 1024 })
     if (result.exitCode !== 0) {
       throw classifyGitFailure({ ...result, message: `git push failed: ${result.stderr.trim()}` })
     }
-    return { remote, published: branch.upstream === null, output: `${result.stdout}${result.stderr}`.trim() }
+    return { remote, published: branch.upstream === null, fetched, output: `${result.stdout}${result.stderr}`.trim() }
   }
 
   /**

package/lib/host/routes.js

@@ -261,7 +261,11 @@ export function createHandlers({ ctx, git, repo, store }) {
       try {
         push = { ok: true, ...(await repo.push(repoRoot, request.signal)) }
       } catch (error) {
-        push = { ok: false, error: describeError(error) }
+        // `fetched` is carried out of a refusal because it is the difference
+        // between "the push was rejected, fetch and try again" and "we already
+        // looked, and the branch really is behind" — the same sentence reads very
+        // differently depending on which one it is.
+        push = { ok: false, error: describeError(error), fetched: error?.fetched === true }
       }
 
       const state = await repo.readStatus(repoRoot, request.signal)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gitbar-lite",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "A GitHub Desktop-style Git panel for DSH: changed files, tick-to-stage, Summary + Description, Commit and Commit and Push, discard-to-trash, and diff preview, in the built-in right sidebar.",
   "type": "module",
   "license": "MIT",