dsh-gitbash-shell 0.42.2 → 0.43.0

package/src/fastctx-bridge.js

@@ -117,6 +117,8 @@ export class McpStdio {
   /** Spawn the server and run the MCP initialize handshake. */
   async start() {
     const { spawn } = await import('node:child_process')
+    // close() can run while the dynamic import is pending; never resurrect it.
+    if (this.dead) throw new Error('the FastCtx bridge was stopped')
     this.child = spawn(this.file, this.args, { stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true })
     this.child.stdout.setEncoding('utf8')
     this.child.stderr.setEncoding('utf8')
@@ -323,43 +325,102 @@ const FASTCTX_SANDBOX_NOTE = 'FastCtx reads the real filesystem with no workspac
  *   - echo(text)      -> result dialect echo, or undefined (off)
  *   - log(message)    -> the plugin's tagged logger
  *
- * The surface publishes at the FIRST agent creation and re-decides on every
- * later one: dsh-ops appearing (ops_* tools in the face) withdraws gb_* for
- * the rest of the process — duplicates would only teach the model two names
- * for one job.
+ * The surface publishes at the first agent creation or live switch update.
+ * User OFF/ON is reversible; dsh-ops appearing (ops_* tools in the face)
+ * independently withdraws gb_* for the rest of the process. Every call also
+ * checks the live switch and its publication generation, including old SDKs.
  */
 export function mountFastctx(ctx, deps) {
   const { platform, enabled, createRequireFrom, tools, msysToWin, echo, log } = deps
   if (platform !== 'win32') return
   let disposer = undefined
   let client = undefined
-  let decided = false
+  let unavailable = false
   let withdrawnByOps = false
+  let switchOn
+  let generation = 0
   let closed = false
   let publishing
   let connecting
   const starting = new Set()
+  const pending = new Set()
+  const agents = new Set()
+
+  const track = (promise) => {
+    pending.add(promise)
+    promise.then(() => pending.delete(promise), () => pending.delete(promise))
+    return promise
+  }
 
   const unpublish = (reason) => {
     if (disposer) {
-      try { disposer() } catch { /* already gone */ }
+      const dispose = disposer
       disposer = undefined
+      try { dispose() } catch { /* already gone */ }
     }
     if (reason) log(reason)
   }
 
-  const callWithReconnect = async (rawName, args) => {
-    if (closed || withdrawnByOps) throw new Error('the FastCtx bridge was stopped')
+  const stopConnections = () => {
+    const owned = new Set([...starting, client].filter(Boolean))
+    client = undefined
+    // Calling close immediately rejects pending requests and kills the child;
+    // track completion as well so disposal owns even superseded generations.
+    track(Promise.allSettled([...owned].map((connection) => connection.close())))
+  }
+
+  const live = (agent) => {
+    if (closed) return false
+    const next = !!enabled()
+    if (switchOn !== next) {
+      switchOn = next
+      generation++
+      unavailable = false
+      if (!next) {
+        unpublish('FastCtx bridge disabled by the fastctxTools switch')
+        stopConnections()
+      }
+    }
+    if (!withdrawnByOps) {
+      const registry = tools(ctx)
+      const faces = new Set(agent ? [agent, ...agents] : agents.size ? agents : [undefined])
+      for (const face of faces) {
+        const names = (registry?.schemas?.(face) ?? []).map((schema) => schema?.name)
+        // Any ops_* name means dsh-ops owns the file surface. Matching the
+        // prefix (rather than only the listed markers) covers the 0.4.0
+        // progressive residents AND the names the marker list does not carry
+        // yet (ops_batch / ops_glob / ops_replace / ops_run): a later caller
+        // can hand the face a name that was never resident in face 1.
+        if (names.some((name) => typeof name === 'string'
+          && (name.startsWith('ops_') || OPS_PRESENCE_MARKERS.includes(name)))) {
+          withdrawnByOps = true
+          generation++
+          unpublish('dsh-ops detected (ops_* tools present): the gb_* surface stands down')
+          stopConnections()
+          break
+        }
+      }
+    }
+    return switchOn && !withdrawnByOps
+  }
+
+  const assertLive = (owner, agent) => {
+    if (!live(agent) || owner !== generation || !disposer) throw new Error('the FastCtx bridge was stopped')
+  }
+
+  const callWithReconnect = async (rawName, args, owner, agent) => {
+    assertLive(owner, agent)
     if (client === undefined || client.isDead) {
-      if (!connecting) {
-        connecting = (async () => {
+      if (!connecting || connecting.owner !== owner) {
+        const task = { owner }
+        task.promise = track((async () => {
           const { file } = resolveFastctx(ctx, createRequireFrom)
           if (file === '') throw new Error('the FastCtx payload is not installed; repair the profile dependencies (frozen install) and retry')
           const fresh = new McpStdio({ file, log })
           starting.add(fresh)
           try {
             await fresh.start()
-            if (closed || withdrawnByOps) throw new Error('the FastCtx bridge was stopped')
+            assertLive(owner, agent)
             client = fresh
           } catch (error) {
             await fresh.close()
@@ -367,23 +428,25 @@ export function mountFastctx(ctx, deps) {
           } finally {
             starting.delete(fresh)
           }
-        })().finally(() => { connecting = undefined })
+        })().finally(() => { if (connecting === task) connecting = undefined }))
+        connecting = task
       }
-      await connecting
+      await connecting.promise
     }
-    if (closed || withdrawnByOps) throw new Error('the FastCtx bridge was stopped')
+    assertLive(owner, agent)
+    // Reconnect only BEFORE dispatch. Never replay a failed tools/call: it may
+    // already have written files even when its response is an ordinary error.
     return client.callTool(rawName, args)
   }
 
-  const publishOnce = async () => {
-    if (closed || disposer || decided && withdrawnByOps) return
+  const publishOnce = async (owner) => {
+    if (!live() || owner !== generation || disposer || unavailable) return
     const registry = tools(ctx)
     if (!registry || typeof registry.register !== 'function') return
     const { file, source } = resolveFastctx(ctx, createRequireFrom)
     if (file === '') {
       log('FastCtx payload not found (probed ' + PAYLOAD_PACKAGES.map((p) => p.pkg).join(', ') + '); gb_* tools stay unpublished')
-      decided = true
-      withdrawnByOps = true // nothing to publish either way; stop re-deciding
+      unavailable = true
       return
     }
     const fresh = new McpStdio({ file, log })
@@ -391,23 +454,30 @@ export function mountFastctx(ctx, deps) {
     let toolList
     try {
       await fresh.start()
+      if (!live() || owner !== generation) return
       toolList = await fresh.listTools()
     } catch (error) {
-      try { await fresh.close() } catch { /* best effort */ }
-      log(`FastCtx server start failed (${source}): ${error?.message ?? error}; gb_* tools stay unpublished`)
-      decided = true
-      withdrawnByOps = true
+      if (live() && owner === generation) {
+        log(`FastCtx server start failed (${source}): ${error?.message ?? error}; gb_* tools stay unpublished`)
+        unavailable = true
+      }
       return
     } finally {
+      try { await fresh.close() } catch { /* best effort */ }
       starting.delete(fresh)
     }
-    await fresh.close()
-    if (closed || withdrawnByOps) return
+    if (!live() || owner !== generation) return
     // Discovery never overwrites the independently owned lazy call client.
     const wanted = toolList.filter((tool) => FASTCTX_FILE_TOOLS.includes(String(tool?.name)))
     const registered = []
     const registeredNames = []
+    const release = () => {
+      for (const dispose of registered) {
+        try { dispose() } catch (error) { log(`FastCtx unregister failed: ${error?.message ?? error}`) }
+      }
+    }
     for (const tool of wanted) {
+      if (!live() || owner !== generation) break
       const rawName = String(tool.name)
       const schema = tool.inputSchema && typeof tool.inputSchema === 'object' ? tool.inputSchema : { type: 'object', properties: {} }
       // Ignore-rule transparency (v0.38.5, the field smoke report): the three
@@ -438,6 +508,7 @@ export function mountFastctx(ctx, deps) {
             render: (_args, value) => renderTextContent(value),
           },
           async execute(args, execution) {
+            assertLive(owner, execution?.agent)
             // Preserve v0.39.1 / #21: glob accepts real string arrays,
             // while stringified arrays and malformed patterns fail loudly.
             if (args !== null && typeof args === 'object' && 'pattern' in args) {
@@ -445,7 +516,7 @@ export function mountFastctx(ctx, deps) {
               if (invalid) throw new Error(invalid)
             }
             const translated = translateFastctxArgs(args, msysToWin ? (path) => msysToWin(path, execution) : undefined)
-            const result = await callWithReconnect(rawName, translated)
+            const result = await callWithReconnect(rawName, translated, owner, execution?.agent)
             const text = renderFastctxResult(rawName, result, echo ? (value) => echo(value, execution) : undefined)
             // The host treats a returned value as success; MCP failures must
             // throw, just as its official MCP client does.
@@ -461,52 +532,51 @@ export function mountFastctx(ctx, deps) {
         log(`${gbName(rawName)} registration failed: ${error?.message ?? error}`)
       }
     }
+    if (!live() || owner !== generation) {
+      release()
+      return
+    }
     if (registered.length === 0) {
       log('FastCtx published none of the known file tools; nothing registered')
-      decided = true
-      withdrawnByOps = true
+      unavailable = true
       return
     }
-    disposer = () => { for (const dispose of registered) dispose() }
+    disposer = release
     log(`FastCtx bridge active (${source}): ${registeredNames.join(', ')}`)
   }
 
   const publish = () => {
-    if (!publishing) publishing = publishOnce().finally(() => { publishing = undefined })
-    return publishing
+    if (!publishing || publishing.owner !== generation) {
+      const task = { owner: generation }
+      task.promise = track(publishOnce(task.owner).finally(() => { if (publishing === task) publishing = undefined }))
+      publishing = task
+    }
+    return publishing.promise
   }
 
   const reconcile = (agent) => {
-    if (closed) return
-    if (!enabled()) { unpublish('FastCtx bridge disabled by the fastctxTools switch'); decided = true; withdrawnByOps = true; return }
-    if (decided && withdrawnByOps) return
-    let names = []
     try {
-      names = (tools(ctx)?.schemas?.(agent) ?? []).map((schema) => schema.name).filter((name) => typeof name === 'string')
-    } catch { /* a broken face reads as empty */ }
-    if (names.some((name) => OPS_PRESENCE_MARKERS.includes(name))) {
-      if (!withdrawnByOps) {
-        withdrawnByOps = true
-        decided = true
-        unpublish('dsh-ops detected (ops_* tools present): the gb_* surface stands down')
-      }
-      return
+      if (!live(agent)) return
+      void publish().catch((error) => log(`FastCtx bridge mount failed: ${error?.message ?? error}`))
+    } catch (error) {
+      log(`FastCtx bridge reconcile failed: ${error?.message ?? error}`)
     }
-    void publish().catch((error) => log(`FastCtx bridge mount failed: ${error?.message ?? error}`))
   }
 
-  try {
-    ctx.on('agent/created', ({ agent } = {}) => { try { reconcile(agent) } catch { /* never break agent creation */ } })
-  } catch (error) {
-    log(`FastCtx bridge wiring failed: ${error?.message ?? error}`)
-    return
-  }
+  // Install disposal before listeners: partial wiring still owns every child.
   ctx.effect(() => async () => {
     closed = true
+    generation++
+    agents.clear()
     unpublish()
-    const owned = new Set([...starting, client].filter(Boolean))
-    await Promise.allSettled([...owned].map((connection) => connection.close()))
-    await Promise.allSettled([publishing, connecting].filter(Boolean))
-    client = undefined
+    stopConnections()
+    await Promise.allSettled([...pending])
   }, 'dsh-gitbash-shell: FastCtx bridge')
+  try {
+    ctx.on('agent/created', ({ agent } = {}) => { if (!closed && agent) agents.add(agent); reconcile(agent) })
+    ctx.on('agent/disposed', ({ agent } = {}) => { agents.delete(agent) })
+    ctx.on('loader/volatile-update', () => { reconcile() })
+  } catch (error) {
+    log(`FastCtx bridge wiring failed: ${error?.message ?? error}`)
+  }
 }

package/src/index.js

@@ -308,7 +308,7 @@ import {
   restoreOpsBash,
 } from './ops-adopt.js'
 import {
-  clearToolJob, currentToolJob, defaultRunnerIo, fenceToolRequest,
+  cancelToolJob, clearToolJob, currentToolJob, defaultRunnerIo, fenceToolRequest,
   probeToolchain, readJsonBody, startToolJob,
 } from './tool-runner.js'
 
@@ -766,7 +766,12 @@ function pathEcho(value, env) {
   const out = driveToMsys(value)
   if (typeof out !== 'string' || out.length === 0) return out
   const tempRoot = env && env.tmpDir ? driveToMsys(env.tmpDir) : ''
-  return tempRoot ? mountTempRoot(out, tempRoot) : out
+  // A whole path has exactly one root; an embedded copy in a backup tree is data.
+  if (tempRoot && out.slice(0, tempRoot.length).toLowerCase() === tempRoot.toLowerCase()
+    && (out.length === tempRoot.length || out[tempRoot.length] === '/')) {
+    return '/tmp' + out.slice(tempRoot.length)
+  }
+  return out
 }
 
 /**
@@ -1251,6 +1256,12 @@ function regexCanStart(previous) {
   return previous.length === 1 && '(,=:[!&|?{;+-*%<>~^'.includes(previous)
 }
 
+/** A newline may end a declaration before a statement regexp; do not guess ASI. */
+function ambiguousSlash(code, index, previous, previousEnd) {
+  return previous === ')' || previous === '}'
+    || (!regexCanStart(previous) && /[\r\n\u2028\u2029]/.test(code.slice(previousEnd, index)))
+}
+
 /** Read an identifier as ONE token: keyword-led regexes are not division. */
 function codeWordAt(code, index) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(code.slice(index))?.[0]
@@ -1263,7 +1274,7 @@ function skipQuotedLiteral(code, index) {
   while (i < code.length) {
     const c = code[i]
     if (c === '\\') { i += 2; continue }
-    if (c === '\n') return -1
+    if (/[\r\n\u2028\u2029]/.test(c)) return -1
     if (c === quote) return i + 1
     i += 1
   }
@@ -1277,7 +1288,7 @@ function skipRegexLiteral(code, index) {
   while (i < code.length) {
     const c = code[i]
     if (c === '\\') { i += 2; continue }
-    if (c === '\n') return -1
+    if (/[\r\n\u2028\u2029]/.test(c)) return -1
     if (c === '[') inClass = true
     else if (c === ']') inClass = false
     else if (c === '/' && inClass === false) {
@@ -1295,11 +1306,13 @@ function skipBracedExpression(code, index) {
   let depth = 1
   let i = index
   let last = ''
+  let previousEnd = 0
   while (i < code.length) {
     const c = code[i]
     const next = code[i + 1]
     if (c === '/' && next === '/') {
-      const nl = code.indexOf('\n', i)
+      const lineEnd = /[\r\n\u2028\u2029]/.exec(code.slice(i))
+      const nl = lineEnd ? i + lineEnd.index : -1
       if (nl === -1) return -1
       i = nl
       continue
@@ -1315,6 +1328,7 @@ function skipBracedExpression(code, index) {
       if (end === -1) return -1
       i = end
       last = 'x'
+      previousEnd = i
       continue
     }
     if (c === '`') {
@@ -1322,15 +1336,17 @@ function skipBracedExpression(code, index) {
       if (inner === null) return -1
       i = inner.end
       last = 'x'
+      previousEnd = i
       continue
     }
     // A slash after a closing group may start a statement regex OR division.
     // Without a parser that distinction is uncertain: abort the WHOLE scan.
-    if (c === '/' && (last === ')' || last === '}')) return -1
+    if (c === '/' && ambiguousSlash(code, i, last, previousEnd)) return -1
     const word = codeWordAt(code, i)
     if (word) {
       last = last === '.' ? 'x' : word
       i += word.length
+      previousEnd = i
       continue
     }
     if (c === '/' && regexCanStart(last)) {
@@ -1338,6 +1354,7 @@ function skipBracedExpression(code, index) {
       if (end === -1) return -1
       i = end
       last = 'x'
+      previousEnd = i
       continue
     }
     if (c === '{') depth += 1
@@ -1345,7 +1362,7 @@ function skipBracedExpression(code, index) {
       depth -= 1
       if (depth === 0) return i + 1
     }
-    if (c.trim() !== '') last = c
+    if (c.trim() !== '') { last = c; previousEnd = i + 1 }
     i += 1
   }
   return -1
@@ -1383,11 +1400,13 @@ export function scanCodeLiterals(code) {
   const spans = []
   let i = 0
   let last = ''
+  let previousEnd = 0
   while (i < code.length) {
     const c = code[i]
     const next = code[i + 1]
     if (c === '/' && next === '/') {
-      const nl = code.indexOf('\n', i)
+      const lineEnd = /[\r\n\u2028\u2029]/.exec(code.slice(i))
+      const nl = lineEnd ? i + lineEnd.index : -1
       // A line comment may legally terminate at EOF (outside interpolation).
       if (nl === -1) break
       i = nl
@@ -1405,6 +1424,7 @@ export function scanCodeLiterals(code) {
       spans.push({ start: i + 1, end: end - 1 })
       i = end
       last = 'x'
+      previousEnd = i
       continue
     }
     if (c === '`') {
@@ -1418,15 +1438,17 @@ export function scanCodeLiterals(code) {
       }
       i = template.end
       last = 'x'
+      previousEnd = i
       continue
     }
     // A slash after a closing group may start a statement regex OR division.
     // Without a parser that distinction is uncertain: abort the WHOLE scan.
-    if (c === '/' && (last === ')' || last === '}')) return null
+    if (c === '/' && ambiguousSlash(code, i, last, previousEnd)) return null
     const word = codeWordAt(code, i)
     if (word) {
       last = last === '.' ? 'x' : word
       i += word.length
+      previousEnd = i
       continue
     }
     if (c === '/' && regexCanStart(last)) {
@@ -1434,9 +1456,10 @@ export function scanCodeLiterals(code) {
       if (end === -1) return null
       i = end
       last = 'x'
+      previousEnd = i
       continue
     }
-    if (c.trim() !== '') last = c
+    if (c.trim() !== '') { last = c; previousEnd = i + 1 }
     i += 1
   }
   return spans
@@ -1512,7 +1535,7 @@ export function rewriteCodePaths(code, env) {
 // path WITHOUT wildcards splits into directory + basename. Runs only for
 // the glob tool and only for patterns that start absolute.
 
-const GLOB_META = /[*?\[\]]/
+const GLOB_META = /[*?\[\]{}]/
 
 /** Split an absolute glob pattern into { prefix, rest }; null when relative. */
 function splitGlobPrefix(pattern) {
@@ -2637,6 +2660,10 @@ export async function apply(ctx, config = {}) {
             return {
               id: job.id, action: job.action, total: job.total, done: job.done,
               current: job.current, finished: job.finished, results: job.results.slice(),
+              // v0.43.0 (issue #35): elapsed time, the freshest winget line,
+              // and the cancelled state, so the card can show them.
+              startedAt: job.startedAt, currentSince: job.currentSince,
+              lastOutput: job.lastOutput, cancelled: job.cancelled === true,
             }
           }
           const handler = async (req, res) => {
@@ -2652,6 +2679,14 @@ export async function apply(ctx, config = {}) {
             try {
               if (method === 'POST') {
                 const action = query.get('action') || ''
+                if (action === 'cancel') {
+                  // v0.43.0 (issue #35): kill the in-flight tree, mark the rest
+                  // skipped. The cancelled job stays current until finished so
+                  // the card can show what happened; `clear` then forgets it.
+                  cancelToolJob('')
+                  send(res, 200, { ok: true, job: snapshot() })
+                  return
+                }
                 if (action === 'clear') {
                   clearToolJob('')
                   send(res, 200, { ok: true, job: null })

package/src/native-executor.js

@@ -25,7 +25,8 @@ export function nativePath(input, translateMsysPath, platform = process.platform
   object(input, label, new Set(['kind', 'value']))
   if (input.kind !== 'path') throw new TypeError(`${label}: kind must be path`)
   const value = string(input.value, label)
-  if (/^[~$]|%[^%]+%/.test(value)) throw new TypeError(`${label}: variable and home expansion are not supported; use an absolute path`)
+  // Reject expansion prefixes, not literal characters inside absolute paths.
+  if (/^(?:[~$]|%[^%]+%)/.test(value)) throw new TypeError(`${label}: variable and home expansion are not supported; use an absolute path`)
   if (platform !== 'win32') throw new Error('gitbash_native currently supports only the Windows local execution world')
   // A rooted Windows path without a drive is not absolute in this contract.
   const absolute = v => /^[a-z]:[\\/]/i.test(v) || /^\\\\[^\\]+\\[^\\]+/.test(v) || /^\/\/[^/]+\/[^/]+/.test(v)

package/src/native-tool.js

@@ -1,6 +1,6 @@
 import { registerExperimentalTool } from './experimental-tools.js'
 import { createNativeExecutor } from './native-executor.js'
-import { processJob, processSources, ringDelta } from './bash-render.js'
+import { processJob, processSources, ringDelta, renderJobRead } from './bash-render.js'
 
 const typedPath = () => ({ type: 'object', additionalProperties: false, properties: {
   kind: { type: 'string', const: 'path', required: true }, value: { type: 'string', required: true },
@@ -165,8 +165,11 @@ export function createNativeToolModule(deps) {
                 throw new Error(`native preparation timed out; job ${attached.id} was cancelled, inspect job_output before retrying`)
               }
               const read = jobs.read(attached.id, owner)
+              // A ring eviction can report gapBefore even when its pull source
+              // was lossless. This consuming read must preserve both loss facts.
+              const lostOutput = read.lossy || read.chunks.some(chunk => chunk.gapBefore)
               return { kind: 'promoted', jobId: attached.id, cwd: request.cwd, timeoutMs: request.timeoutMs,
-                output: ringDelta(read.chunks), encoding: request.output }
+                output: renderJobRead(ringDelta(read.chunks), lostOutput, read.job?.output?.spillPaths), encoding: request.output }
             }
             jobs.remove(attached.id, owner)
             if (!attached.process()) throw new Error(view.detail ?? 'native preparation failed before a process handle was available')