dsh-gitbash-shell 0.27.0 → 0.28.0

package/src/index.js

@@ -245,8 +245,15 @@ export function effectivePresetIds(configured, { suppress, peerGitBash } = {}) {
   return list.filter((id) => id !== PEER_COVERED_PRESET_ID)
 }
 
-/** Git Bash binary default — must match src/shell.js. */
-const DEFAULT_GIT_BASH = 'C:/Program Files/Git/bin/bash.exe'
+/**
+ * The ONE bash resolver (v0.28.0, issue #11): the executor (src/shell.js) and
+ * this translation layer read the same memoized result, so "dialect translated
+ * to Q:/Git but the executor still spawns C:/Program Files/Git" cannot happen.
+ */
+import {
+  DEFAULT_GIT_BASH, GIT_BASH_DOWNLOAD_URL, bashResolutionReport,
+  effectiveConfiguredBashPath, executorConfiguredBashPath, resolveGitBashCached, settingsBashPath,
+} from './bash-path.js'
 
 /** The shipped preset whose skills/ dir seeds cordis-gitbash. */
 const SKILLS_SOURCE_PRESET = 'cordis'
@@ -1448,23 +1455,12 @@ export function buildTranslateEnv(configuredBashPath) {
     if (h && existsSync(h)) env.home = h.replace(/\\/g, '/')
   } catch { /* keep undefined */ }
   try {
-    const candidates = []
-    if (cacheKey !== '') candidates.push(cacheKey.replace(/\\/g, '/'))
-    candidates.push(DEFAULT_GIT_BASH)
-    for (const dir of String(process.env.PATH ?? '').split(';')) {
-      const clean = dir && dir.trim()
-      if (clean) candidates.push(clean.replace(/\\/g, '/') + '/bash.exe')
-    }
-    for (const candidate of candidates) {
-      try {
-        if (!existsSync(candidate)) continue
-        const root = dirname(dirname(candidate))
-        if (existsSync(join(root, 'usr', 'bin'))) {
-          env.gitRoot = root.replace(/\\/g, '/')
-          break
-        }
-      } catch { /* try the next candidate */ }
-    }
+    // v0.28.0 (issue #11): ONE resolver for the executor and this layer. Its
+    // chain is setting > default install paths > PATH > registry PATH and it
+    // refuses WSL/MSYS2/Cygwin outright; `cacheKey` is the settings bashPath,
+    // i.e. the same explicit tier the executor reads.
+    const resolution = resolveGitBashCached({ configured: cacheKey })
+    if (resolution.ok) env.gitRoot = resolution.root.replace(/\\/g, '/')
   } catch { /* keep undefined */ }
   translateEnvCache.set(cacheKey, env)
   return env
@@ -2351,7 +2347,28 @@ export async function apply(ctx, config = {}) {
   // plugins (e.g. dsh-ptc-cordis-preset) can adopt it in the presets they
   // materialize: service present, 'active: true' on Windows, 'active: false'
   // where the bundle is installed but the platform stack stayed native.
-  const gitBashCapability = { active: process.platform === 'win32', bashPath: DEFAULT_GIT_BASH }
+  /* The explicit tier of the resolution chain, in its documented priority:
+     the `gitbash-executor` row's own config > the `gitbash-shell` row/settings
+     field > empty (= run the automatic chain). Both this layer and the
+     executor resolve from this same value, so an explicit answer is never
+     substituted and never silently ignored.
+     (issue #11: the row config is where the reporter's workaround landed.) */
+  const configuredBashPath = effectiveConfiguredBashPath(executorConfiguredBashPath(ctx), settingsBashPath(ctx))
+  const bashResolution = resolveGitBashCached({ configured: configuredBashPath })
+  const gitBashCapability = {
+    active: process.platform === 'win32',
+    // Kept for existing consumers (peer plugins read `bashPath`): the resolved
+    // interpreter. When resolution failed we report the explicit value (or the
+    // historical default) so the ENOENT a consumer may hit names a real path —
+    // never a substitute shell.
+    bashPath: bashResolution.ok ? bashResolution.path : (configuredBashPath || DEFAULT_GIT_BASH),
+    // Additive (v0.28.0): the full verdict, for the guided popup and peers.
+    ok: bashResolution.ok,
+    source: bashResolution.source,
+    configured: configuredBashPath,
+    tried: bashResolution.tried,
+    downloadUrl: GIT_BASH_DOWNLOAD_URL,
+  }
   const disposeGitBash = ctx.provide('gitBash', gitBashCapability)
   ctx.effect(() => disposeGitBash, 'dsh-gitbash-shell: gitBash capability')
 
@@ -2571,7 +2588,7 @@ export async function apply(ctx, config = {}) {
           // untouched and the result metadata is not echoed back in MSYS form.
           if (dialect.posixPaths && dialectApplies(dialect, exec && exec.agent)) {
             echo = true
-            const env = dialect.virtualMounts ? buildTranslateEnv(dialect.bashPath) : null
+            const env = dialect.virtualMounts ? buildTranslateEnv(configuredBashPath) : null
             echoEnv = env
             if (exec && exec.arguments && typeof exec.arguments === 'object') {
               const translated = translateDispatch(exec, dialect, env)
@@ -2626,7 +2643,7 @@ export async function apply(ctx, config = {}) {
           if (!dialectApplies(dialect, exec && exec.agent)) return next()
           if (dialect.posixPaths && dialect.errorDialect && exec && result && typeof result === 'object'
             && result.isError === true && Array.isArray(result.content)) {
-            const env = dialect.virtualMounts ? buildTranslateEnv(dialect.bashPath) : null
+            const env = dialect.virtualMounts ? buildTranslateEnv(configuredBashPath) : null
             if (exec.name === 'run_code') {
               // paths only — the /dev/null hint is for file tools
               const content = rewriteErrorContent(result.content, { nulHint: false, env })
@@ -2694,12 +2711,56 @@ export async function apply(ctx, config = {}) {
     }
   }
 
+  // ── fail-loud bash report + the client-visible status route (v0.28.0) ──
+  // issue #11: the old failure mode was "every command dies with
+  // `spawn C:/Program Files/Git/bin/bash.exe ENOENT` and nothing explains it".
+  // Now the boot log names the value, the whole probe chain and where to fix
+  // it, and the client half reads the same verdict over HTTP to raise the
+  // guided popup. Nothing here substitutes another shell — by design.
+  console.log(TAG + ' bash resolution: ' + bashResolutionReport(bashResolution).split('\n').join('\n' + TAG + ' '))
+  if (process.platform === 'win32') {
+    try {
+      ctx.inject(['webServer'], (wctx) => {
+        try {
+          const route = '/dsh-gitbash-shell/api/status'
+          const read = () => {
+            const resolution = resolveGitBashCached({ configured: configuredBashPath, fresh: true })
+            return {
+              ok: resolution.ok,
+              platform: process.platform,
+              resolved: resolution.path,
+              root: resolution.root,
+              source: resolution.source,
+              configured: resolution.configured,
+              tried: resolution.tried,
+              downloadUrl: GIT_BASH_DOWNLOAD_URL,
+              settingsHint: 'Settings -> Plugins -> dsh-gitbash-shell -> "Git Bash path"',
+            }
+          }
+          const handler = (req, res) => {
+            const text = JSON.stringify(read())
+            res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store', 'content-length': Buffer.byteLength(text) })
+            res.end(text)
+          }
+          const dispose = wctx.webServer.register({ kind: 'prefix', path: route, handler })
+          wctx.effect(() => dispose, 'dsh-gitbash-shell: bash status route')
+          console.log(TAG + ' bash status route active at ' + route + ' (read by the guided popup)')
+        } catch (error) {
+          console.log(TAG + ' bash status route failed: ' + (error?.message ?? error))
+        }
+      })
+    } catch (error) {
+      console.log(TAG + ' bash status route wiring failed: ' + (error?.message ?? error))
+    }
+  }
+
   // ── dsh-better-sidebar terminal adoption (Windows only) ────────────────
   // The sidebar resolves its terminal shell through the settings seam per
   // open; adopt it through that seam (see adoptSidebarShell for rationale).
   // Disable with `betterSidebarShell: false` in the plugin row config.
   if (config.betterSidebarShell !== false && process.platform === 'win32') {
-    adoptSidebarShell(ctx, gitBashCapability.bashPath, () => liveSettings.adoptSidebar())
+    if (bashResolution.ok) adoptSidebarShell(ctx, bashResolution.path, () => liveSettings.adoptSidebar())
+    else console.log(TAG + ' sidebar terminal adoption skipped: no Git Bash resolved (nothing is substituted)')
   }
 
   // ── era split: declarative registration on dsh >= 0.1.7 ──────────────────

package/src/shell.js

@@ -38,10 +38,13 @@
  */
 
 import { SandboxBashExecutor } from '@deepseek-ai/dsh-bash-sandbox'
+
+import { DEFAULT_GIT_BASH, bashResolutionReport, effectiveConfiguredBashPath, resolveGitBashCached, settingsBashPath } from './bash-path.js'
+
+/** Re-exported for callers that historically read it here (the value now lives in bash-path.js). */
+export { DEFAULT_GIT_BASH }
 import z from '@deepseek-ai/schemastery'
 
-/** Default Git for Windows bash (forward slashes work on Windows too). */
-export const DEFAULT_GIT_BASH = 'C:/Program Files/Git/bin/bash.exe'
 
 /** Log prefix, matching src/index.js. */
 const TAG = '[gitbash-shell]'
@@ -95,7 +98,12 @@ export function gitBashShellConfig(z) {
     graceMs: live(z.number().default(3000)),
     // Our own knob: the base class neither declares nor `.get()`s it, and
     // `get bashPath()` below reads it as a plain value, so it stays plain.
-    bashPath: z.string().default(DEFAULT_GIT_BASH),
+    //
+    // EMPTY means AUTO (v0.28.0, issue #11): the shared resolver walks
+    // setting > default install paths > PATH > registry PATH and refuses WSL /
+    // MSYS2 / Cygwin. A hard-coded default here is what made a Git installed
+    // outside C:/Program Files look like "dsh is broken".
+    bashPath: z.string().default(''),
   })
 }
 
@@ -107,9 +115,49 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
   static inject = ['subprocess', 'sandbox', 'sandboxPolicy']
   static Config = Config
 
-  /** Effective Git Bash path: composition/config value with the default fallback. */
+  /**
+   * Effective Git Bash path. The configured value wins when it is non-empty
+   * (the user's explicit answer is never substituted); otherwise the SHARED
+   * resolver decides — the very same result the path-dialect translation layer
+   * uses, so "dialect works, executor cannot find bash" (issue #11) is
+   * structurally impossible.
+   *
+   * A failed resolution returns '' — deliberately NOT a substitute shell. Every
+   * argv built from it then fails loudly on spawn; `apply()` has already
+   * printed the full report, and the client half shows the guided popup.
+   */
   get bashPath() {
-    return this.config.bashPath ?? DEFAULT_GIT_BASH
+    return this.bashResolution().path
+  }
+
+  /**
+   * Resolve the interpreter with the SAME merged explicit tier the main plugin
+   * uses (executor row config > `gitbash-shell` settings row > empty = auto),
+   * so both halves of the plugin always agree on which bash this process runs.
+   * @returns {object} the memoized resolution verdict.
+   */
+  bashResolution() {
+    const configured = effectiveConfiguredBashPath(this.config.bashPath, settingsBashPath(this.ctx))
+    return resolveGitBashCached({ configured })
+  }
+
+  /**
+   * The resolved Git Bash path, or a THROW that says exactly what is wrong.
+   *
+   * The throw is the design (AGENTS.md §4h): with no Git Bash there is no
+   * command execution at all — we do not substitute pwsh, cmd, WSL or MSYS2,
+   * and we do not let a bare `spawn ENOENT` be the only thing the user sees.
+   * The boot log carries the same report (src/index.js) and the client half
+   * shows the guided popup with the probed list.
+   * @returns {string} the resolved interpreter path.
+   */
+  requireBashPath() {
+    const resolution = this.bashResolution()
+    if (!resolution.ok) {
+      throw new Error('dsh-gitbash-shell: no Git for Windows bash found, so this command cannot run. '
+        + bashResolutionReport(resolution).split('\n').slice(1).join(' | '))
+    }
+    return resolution.path
   }
 
   /**
@@ -129,7 +177,7 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
    * @returns the provider's exact argv and settlement-classification facts (a promise on dsh >= 0.1.6).
    */
   confine(command, policy, signal) {
-    return this.ctx.sandbox.confine([this.bashPath, '-c', command], policy, signal)
+    return this.ctx.sandbox.confine([this.requireBashPath(), '-c', command], policy, signal)
   }
 
   /**
@@ -219,7 +267,7 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     const routed = this.withParityEnv(spec)
     const route = this.gitBashRoute(routed)
     if (route === undefined) return super.execute(routed)
-    const argv = [this.bashPath, '-c', routed.command]
+    const argv = [this.requireBashPath(), '-c', routed.command]
     if (route.unconfined) this.warnConfinedUnconfined(route.mode)
     const sandbox = route.unconfined
       ? { mode: route.mode, denied: false, enforcement: 'unconfined' }
@@ -304,13 +352,13 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     const { mode } = policy
     if (mode === 'danger-full-access') {
       const { result } = GitBashSandboxExecutor.unwrapRunArgv(
-        await this.runArgv(spec, [this.bashPath, '-c', spec.command]))
+        await this.runArgv(spec, [this.requireBashPath(), '-c', spec.command]))
       return { ...result, sandbox: { mode, denied: false } }
     }
     if (process.platform === 'win32') {
       this.warnConfinedUnconfined(mode)
       const { result, spawnRequested } = GitBashSandboxExecutor.unwrapRunArgv(
-        await this.runArgv(spec, [this.bashPath, '-c', spec.command]))
+        await this.runArgv(spec, [this.requireBashPath(), '-c', spec.command]))
       // No spawn means no argv ran, so there is nothing to label as
       // unconfined; the parent reports the same bare sandbox facts there.
       return { ...result, sandbox: spawnRequested ? { mode, denied: false, enforcement: 'unconfined' } : { mode, denied: false } }
@@ -326,7 +374,7 @@ export class GitBashSandboxExecutor extends SandboxBashExecutor {
     const fullAccess = mode === 'danger-full-access'
     if (fullAccess || process.platform === 'win32') {
       if (!fullAccess) this.warnConfinedUnconfined(mode)
-      const proc = this.startArgv(spec, [this.bashPath, '-c', spec.command])
+      const proc = this.startArgv(spec, [this.requireBashPath(), '-c', spec.command])
       proc.sandbox = fullAccess ? { mode, denied: false } : { mode, denied: false, enforcement: 'unconfined' }
       // Match the loaded base contract: the async one (dsh >= 0.1.6) is
       // awaited by its callers, the synchronous one is consumed directly.