dsh-gitbar-lite 0.1.0 → 0.1.2

package/README.en.md

@@ -189,7 +189,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 (18 independent repositories, 224 assertions)
+npm run test:e2e  # the real-git suite alone (20 sections building their own fixtures, 241 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

@@ -176,7 +176,7 @@ lib/client.js          浏览器半边：三个 tab 类型 + 面板/回收站/di
 
 ```sh
 npm test          # 单测 + 真 git 的 e2e + 产物自检
-npm run test:e2e  # 只跑真 git 的 e2e（18 个独立仓库，224 项断言）
+npm run test:e2e  # 只跑真 git 的 e2e（20 个小节，各自造自己的夹具，241 项断言）
 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`, 224 assertions over 18 independent repositories |
+| the whole host stack against **real git**, mutation by mutation | `test/e2e.mjs`, 241 assertions over 20 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` |
 
@@ -338,11 +338,22 @@ show the index claim rather than assume it.
 
 - **`ctx.subprocess` is doubled in the tests.** The shipped service lives inside
   DSH's own bundle and is not importable from a plugin repository, so
-  `test/helpers/subprocess.mjs` reproduces its documented shapes (the spawn spec,
-  `collected.stdout.readFrom`, `done`) on top of `node:child_process`. It does
-  **not** reproduce the Windows Job containment or the environment scrubbing —
-  those belong to the real service. The first live run in a real DSH is what
-  closes that gap; see `test/live.mjs`.
+  `test/helpers/subprocess.mjs` reproduces its shapes on top of
+  `node:child_process`. Those shapes are not guessed: the live contract was read
+  off a running DSH (Cordis Inspect, host provider `Service`, key `subprocess`)
+  and the double is pinned to it — including the part that is easy to get wrong,
+  that `spawn` **throws synchronously** for an already-aborted signal, or for an
+  argv/cwd/env/grace it rejects, instead of returning a handle. `S20` exists
+  because a caller that only `await`s the handle never sees that throw, and it
+  used to reach the route layer unclassified. What the double still does **not**
+  reproduce: Windows Job containment, the environment scrubbing, spill files
+  (`readFrom`'s `spillPath`), and the `control` duplex.
+- **What the live run established.** The plugin loads into a running DSH and all
+  three right-sidebar seats register and are active — `dsh-gitbar-lite/git` and
+  `dsh-gitbar-lite/trash` (pages) and `dsh-gitbar-lite/diff` (resource) — read
+  off the live client slot tree at `sidebar.right.pane.tab`, next to the shipped
+  occupants. That is evidence about *mounting*; the behaviour claims are the e2e
+  suite's job, and the seam between them is the doubled `ctx.subprocess` above.
 - **No headless-DOM render test.** The panel, the trash and the diff are driven
   by hooks, and the three components with no hooks in them (the row, the
   confirmation, the picker) *are* asserted on their element trees. What is not

package/lib/host/git.js

@@ -66,6 +66,23 @@ export class GitFailure extends Error {
   }
 }
 
+/**
+ * Why a command ended without a verdict, when the reason was cancellation.
+ *
+ * Used for both ways a command can be cancelled — before the child exists (the
+ * provider refuses the spec synchronously) and after it starts — so that the two
+ * report the same sentence instead of one of them reading as an internal error.
+ *
+ * @param {AbortSignal | undefined} signal the combined signal handed to `spawn`
+ * @param {AbortSignal | undefined} timeout our own deadline, when one was set
+ * @param {number} timeoutMs that deadline in milliseconds, for the message
+ * @returns {string | undefined} the reason, or `undefined` when nothing aborted
+ */
+function abortReason(signal, timeout, timeoutMs) {
+  if (signal === undefined || !signal.aborted) return undefined
+  return timeout !== undefined && timeout.aborted ? `timed out after ${timeoutMs}ms` : 'was aborted'
+}
+
 /**
  * Build the git runner for one plugin instance.
  *
@@ -131,24 +148,37 @@ export function createGit(ctx, config) {
           ? timeout
           : AbortSignal.any([options.signal, timeout])
 
-    const handle = ctx.subprocess.spawn({
-      argv: [executablePath, ...args],
-      cwd: options.cwd,
-      stdio: {
-        stdin: options.stdin === undefined ? 'ignore' : { data: options.stdin },
-        stdout: { maxBytes: options.maxBytes ?? DEFAULT_MAX_OUTPUT_BYTES },
-        stderr: { maxBytes: STDERR_TAIL_BYTES },
-      },
-      graceMs: TERMINATE_GRACE_MS,
-      ...(signal === undefined ? {} : { signal }),
-      env: { ...GIT_ENV, ...(options.env ?? {}) },
-    })
+    let handle
+    try {
+      handle = ctx.subprocess.spawn({
+        argv: [executablePath, ...args],
+        cwd: options.cwd,
+        stdio: {
+          stdin: options.stdin === undefined ? 'ignore' : { data: options.stdin },
+          stdout: { maxBytes: options.maxBytes ?? DEFAULT_MAX_OUTPUT_BYTES },
+          stderr: { maxBytes: STDERR_TAIL_BYTES },
+        },
+        graceMs: TERMINATE_GRACE_MS,
+        ...(signal === undefined ? {} : { signal }),
+        env: { ...GIT_ENV, ...(options.env ?? {}) },
+      })
+    } catch (error) {
+      // `spawn` refuses a spec it cannot honour *synchronously*: a signal that is
+      // already aborted, or a cwd/env/grace it considers invalid. Neither is a
+      // git verdict, and letting the throw escape would reach the route layer
+      // unclassified -- a generic internal error for a request that was simply
+      // abandoned. Report it the way the asynchronous abort below does.
+      throw new GitFailure(`git ${args[0] ?? ''}`.trim(), {
+        exitCode: null,
+        stdout: '',
+        stderr: abortReason(signal, timeout, timeoutMs) ?? String(error?.message ?? error),
+      })
+    }
 
     const outcome = await handle.done
 
     if (signal !== undefined && signal.aborted) {
-      const why = timeout !== undefined && timeout.aborted ? `timed out after ${timeoutMs}ms` : 'was aborted'
-      throw new GitFailure(`git ${args[0] ?? ''}`.trim(), { exitCode: null, stdout: '', stderr: why })
+      throw new GitFailure(`git ${args[0] ?? ''}`.trim(), { exitCode: null, stdout: '', stderr: abortReason(signal, timeout, timeoutMs) })
     }
 
     const out = handle.collected.stdout?.readFrom(0) ?? { text: '', lossy: false }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-gitbar-lite",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",