dsh-mesh-node 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mesh-node",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Mesh server for dsh-mesh: expose a machine to peer DSH nodes over MCP/HTTPS, with delegation and optional desktop-control tools.",
   "type": "module",
   "private": false,

package/src/core/git-exec.js

@@ -0,0 +1,77 @@
+// @generated 共享的「git 可执行文件解析 + 执行」，供 src/tools/git.js 与 src/tools/cluster.js 共用
+// [why] 2026-11-10：mesh server 由计划任务/启动脚本拉起，PATH 里可能没有 git（peer-node 实测：git 在
+//   C:\Users\<user>\tools\git\cmd，只有 DSH 的 start-dsh0.cmd 把它写进 PATH）。git.js 已有
+//   「DSH_MESH_GIT → PATH → 常见安装目录」回退；cluster.js 的 gitInfo() 却仍直接 execFileSync('git')，
+//   于是 mesh_overview 的本机 repo 摘要在干净 PATH 下失效且只报空。抽成共用模块，两处行为一致。
+import { join } from 'node:path'
+import { run } from './util.js'
+
+/** 找不到 git 时给用户的可诊断提示。 */
+const SPAWN_HINT =
+  'the mesh server process cannot find git on its PATH. Add the git directory to PATH in the mesh server start script, or set DSH_MESH_GIT to the git executable, then restart mesh (no DSH restart needed).'
+
+/**
+ * git 可执行文件候选，按优先级：DSH_MESH_GIT 覆盖 → PATH 里的 git → 平台常见安装位置。
+ * @returns {string[]} 去重后的候选列表
+ */
+export function gitCandidates() {
+  const env = process.env
+  const list = []
+  if (env.DSH_MESH_GIT) list.push(env.DSH_MESH_GIT)
+  list.push('git')
+  if (process.platform === 'win32') {
+    for (const root of [env.ProgramFiles, env.ProgramW6432, env['ProgramFiles(x86)']].filter(Boolean)) {
+      list.push(join(root, 'Git', 'cmd', 'git.exe'))
+    }
+    if (env.LOCALAPPDATA) list.push(join(env.LOCALAPPDATA, 'Programs', 'Git', 'cmd', 'git.exe'))
+    if (env.USERPROFILE) list.push(join(env.USERPROFILE, 'tools', 'git', 'cmd', 'git.exe'))
+  } else {
+    list.push('/usr/bin/git', '/usr/local/bin/git', '/opt/homebrew/bin/git')
+  }
+  return [...new Set(list)]
+}
+
+/** 解析一次并缓存（`git --version` 成功才算命中）。 */
+let gitProbe = null
+/**
+ * @returns {Promise<{bin: string, tried: string[]} | {error: {code: string, message: string}, tried: string[]}>}
+ */
+export function gitBinary() {
+  if (!gitProbe) {
+    gitProbe = (async () => {
+      const tried = []
+      for (const candidate of gitCandidates()) {
+        tried.push(candidate)
+        const out = await run(candidate, ['--version'], { timeout: 5000 })
+        if (!out.error && /\bgit version\b/i.test(out.stdout)) return { bin: candidate, tried }
+      }
+      return { error: { code: 'ENOENT', message: `git not found; probed: ${tried.join(', ')}` }, tried }
+    })()
+  }
+  return gitProbe
+}
+
+/**
+ * 用解析到的 git 跑命令；解析失败时返回与 run() 同形的 error 结果，调用方不必各自处理。
+ * @param {string[]} args git 参数
+ * @param {{timeout?: number, cwd?: string, signal?: AbortSignal, maxBuffer?: number}} [options] 透传给 run()
+ * @returns {Promise<{error: unknown, stdout: string, stderr: string, code: number, killed: boolean, timedOut: boolean}>}
+ */
+export async function runGit(args, options) {
+  const found = await gitBinary()
+  if (found.error) return { error: found.error, stdout: '', stderr: '', code: 0, killed: false, timedOut: false }
+  return run(found.bin, args, options)
+}
+
+/**
+ * 诊断信息：spawn 失败时附加到工具错误里，避免把「找不到 git」误报成「不是仓库」。
+ * @returns {{hint: string, gitCandidates: string[], pathEnv: string, nodePid: number}}
+ */
+export function gitSpawnDiagnostics() {
+  return {
+    hint: SPAWN_HINT,
+    gitCandidates: gitCandidates(),
+    pathEnv: String(process.env.PATH || process.env.Path || ''),
+    nodePid: process.pid
+  }
+}

package/src/core/remote-path.js

@@ -0,0 +1,53 @@
+// @generated 平台无关的「对端路径」拼接 / 取父目录（src 与 scripts 共用）
+// [why] 2026-11-10：peer-inspect.mjs 用本机 `node:path.dirname` 推导对端用户目录。调用方可能是 Linux
+//   （手机 proot 里的 node），对端路径却是 Windows（`C:\Users\<user>\.dsh-mesh`）——
+//   posix dirname 把整串当成一个文件名，返回 `.`，于是拼出相对路径 `.dsh0/storages/workspace.json`，
+//   被对端按 mesh server 的 cwd 解析成 `...\Code\dsh-mesh\.dsh0\storages\workspace.json` → E_NOT_FOUND。
+//   对端路径的分隔符由**对端平台**决定，不能交给本机 path 模块；这里只用字符串处理，`/` 和 `\` 都支持。
+//   2026-11-10 batch2（B5）：从 scripts/lib/remote-path.mjs 提升到 src/core，供 src/tools/cluster.js 等共用；
+//   scripts/lib/remote-path.mjs 只做 re-export，保持既有 import 不变。
+
+/** 探测一串路径使用的分隔符：出现反斜杠按 Windows 处理，否则按 POSIX。 */
+function sepOf(p) {
+  return String(p ?? '').includes('\\') ? '\\' : '/'
+}
+
+/**
+ * 平台无关的取父目录。
+ * `C:\Users\<user>\.dsh-mesh` → `C:\Users\<user>`
+ * `/root/.dsh-mesh` → `/root`；`C:\` → `C:\`；`/` → `/`
+ * 没有分隔符的单段（相对名）原样返回——调用方只应对绝对路径使用它。
+ * @param {string} p 路径（对端风格，`/` 或 `\` 均可）
+ * @returns {string} 父目录
+ */
+export function parentDir(p) {
+  const s = String(p ?? '')
+  if (!s) return ''
+  const trimmed = s.replace(/[\\/]+$/, '')
+  if (!trimmed) return s[0]
+  const m = /^(.*)[\\/][^\\/]*$/.exec(trimmed)
+  if (!m) {
+    // 单段：盘符（C:）要补回分隔符，相对名原样返回
+    return /^[A-Za-z]:$/.test(trimmed) ? trimmed + sepOf(s) : trimmed
+  }
+  if (/^[A-Za-z]:$/.test(m[1])) return m[1] + sepOf(s)
+  return m[1] || sepOf(s)
+}
+
+/**
+ * 平台无关拼接：分隔符跟随 base（base 含反斜杠就用 `\`），避免在本机用错分隔符拼出相对路径。
+ * `joinRemote('C:\\Users\\Administrator', '.dsh0', 'storages')` → `C:\Users\<user>\.dsh0\storages`
+ * @param {string} base 基准目录
+ * @param {...string} parts 追加的路径段
+ * @returns {string} 拼接结果
+ */
+export function joinRemote(base, ...parts) {
+  const sep = sepOf(base)
+  let out = String(base ?? '').replace(/[\\/]+$/, '')
+  for (const part of parts) {
+    const p = String(part ?? '').replace(/^[\\/]+|[\\/]+$/g, '')
+    if (!p) continue
+    out = out ? `${out}${sep}${p}` : p
+  }
+  return out || sep
+}

package/src/tools/cluster.js

@@ -1,25 +1,42 @@
 import { z } from 'zod'
 import { existsSync, readFileSync, readdirSync } from 'node:fs'
-import { execFileSync } from 'node:child_process'
 import { join } from 'node:path'
 import { loadPeers } from '../core/pairing.js'
 import { clusterReport, probePeer } from '../core/cluster.js'
 import { callPeerTool } from '../core/peer-client.js'
+import { gitSpawnDiagnostics, runGit } from '../core/git-exec.js'
+import { joinRemote } from '../core/remote-path.js'
 import { fail, ok } from '../core/result.js'
 
 const TERMINAL = new Set(['done', 'failed', 'cancelled'])
 
-function gitInfo(repo) {
+/**
+ * 本机仓库摘要。走共享的 git 解析（DSH_MESH_GIT → PATH → 常见安装目录），
+ * 否则计划任务式干净 PATH 下这里会把「找不到 git」报成空摘要。
+ * @param {string} repo 仓库目录
+ * @returns {Promise<object>} { path, head, branch, dirty, ahead, behind } 或 { path, error, ...诊断 }
+ */
+async function gitInfo(repo) {
   if (!repo) return { path: '', error: 'no repo path' }
-  const run = (args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8', timeout: 5000, windowsHide: true }).trim()
+  const run = async (args) => {
+    const out = await runGit(['-C', repo, ...args], { timeout: 5000 })
+    if (out.error) {
+      const code = typeof out.error.code === 'string' ? out.error.code : `exit-${out.code}`
+      const error = new Error(out.error.message || out.stderr.trim() || `git ${args[0]} failed`)
+      error.spawnCode = typeof out.error.code === 'string' ? out.error.code : null
+      error.code = code
+      throw error
+    }
+    return out.stdout.trim()
+  }
   try {
-    const head = run(['rev-parse', '--short', 'HEAD'])
-    const branch = run(['rev-parse', '--abbrev-ref', 'HEAD'])
-    const dirty = run(['status', '--porcelain']) !== ''
+    const head = await run(['rev-parse', '--short', 'HEAD'])
+    const branch = await run(['rev-parse', '--abbrev-ref', 'HEAD'])
+    const dirty = (await run(['status', '--porcelain'])) !== ''
     let ahead = null
     let behind = null
     try {
-      const counts = run(['rev-list', '--left-right', '--count', 'HEAD...@{upstream}']).split(/\s+/).map(Number)
+      const counts = (await run(['rev-list', '--left-right', '--count', 'HEAD...@{upstream}'])).split(/\s+/).map(Number)
       ahead = counts[0] || 0
       behind = counts[1] || 0
     } catch {
@@ -27,6 +44,9 @@ function gitInfo(repo) {
     }
     return { path: repo, head, branch, dirty, ahead, behind }
   } catch (error) {
+    if (error?.spawnCode) {
+      return { path: repo, error: `E_GIT_SPAWN: ${error.message}`, ...gitSpawnDiagnostics() }
+    }
     return { path: repo, error: String(error?.message || error) }
   }
 }
@@ -140,7 +160,8 @@ export function buildCluster(ctx) {
               const selfOut = await callPeerTool(peer, { tool: 'mesh_self', args: {}, timeoutMs: Math.min(timeoutMs, 8000) })
               const selfText = selfOut.result?.content?.[0]?.text || '{}'
               const self = JSON.parse(selfText)
-              const repoPath = self.mesh?.repo || join(self.acl?.fsRoots?.[0]?.path || '', 'dsh-mesh')
+              // 对端仓库路径由**对端**决定：用平台无关拼接（Linux 节点拼 Windows 对端路径不能走本机 path.join）
+              const repoPath = self.mesh?.repo || joinRemote(self.acl?.fsRoots?.[0]?.path || '', 'dsh-mesh')
               const statusOut = await callPeerTool(peer, { tool: 'git_status', args: { path: repoPath }, timeoutMs: Math.min(timeoutMs, 8000) })
               const statusText = statusOut.result?.content?.[0]?.text || '{}'
               const status = JSON.parse(statusText)
@@ -157,12 +178,13 @@ export function buildCluster(ctx) {
               peerRepos.push({ peer: peer.name, error: String(error?.message || error) })
             }
           }
+          const localRepo = await gitInfo(process.cwd())
           return ok({
             node: report.node,
             summary: report.summary,
             verdict: report.verdict,
             issues: report.issues,
-            repos: { local: gitInfo(process.cwd()), peers: peerRepos },
+            repos: { local: localRepo, peers: peerRepos },
             instances: (report.instances || []).map((instance) => ({
               id: instance.id,
               label: instance.label,

package/src/tools/git.js

@@ -2,8 +2,9 @@ import { existsSync, readdirSync, realpathSync } from 'node:fs'
 import { basename, join, resolve } from 'node:path'
 import { z } from 'zod'
 import { isInsideRoots } from '../core/config.js'
-import { clip, run } from '../core/util.js'
-import { denied, invalidArg, notFound, ok } from '../core/result.js'
+import { gitBinary, gitSpawnDiagnostics, runGit } from '../core/git-exec.js'
+import { clip } from '../core/util.js'
+import { denied, fail, invalidArg, notFound, ok } from '../core/result.js'
 
 function guard(path, config) {
   const abs = resolve(path)
@@ -14,10 +15,53 @@ function guard(path, config) {
   return { abs }
 }
 
+// git 可执行文件解析/执行与 spawn 诊断都在 src/core/git-exec.js（cluster.js 共用同一套回退）。
+// [why] 2026-11-10：peer-node 的 mesh server 由没设 PATH 的启动脚本拉起，spawn git 直接 ENOENT，
+//   旧代码把 top.error 一律吞成「不是仓库」，把真因藏了。现在 spawn 失败如实报 E_GIT_SPAWN。
+function gitFailureResult(failure, extra = {}) {
+  return fail(failure.code, failure.message, { ...failure.extra, ...extra })
+}
+
 async function repoRootOf(abs, { timeout, signal } = {}) {
-  const top = await run('git', ['-C', abs, 'rev-parse', '--show-toplevel'], { timeout, signal })
-  if (top.error || !top.stdout.trim()) return { error: top }
+  const top = await runGit(['-C', abs, 'rev-parse', '--show-toplevel'], { timeout, signal })
+  if (top.error) {
+    const spawnCode = top.error.code
+    // spawn 失败时 error.code 是字符串（ENOENT/EACCES…）；进程正常退出（不是仓库）时是数字 exit code
+    if (typeof spawnCode === 'string') {
+      const probed = (await gitBinary()).tried || []
+      return {
+        failure: {
+          code: 'E_GIT_SPAWN',
+          message: `cannot spawn git (${spawnCode}): ${top.error.message || spawnCode}`,
+          extra: { spawnCode, ...gitSpawnDiagnostics(), probed }
+        }
+      }
+    }
+    if (top.killed || top.timedOut) {
+      return {
+        failure: {
+          code: 'E_GIT_TIMEOUT',
+          message: `git rev-parse timed out after ${timeout ?? '?'}ms: git -C ${abs} rev-parse --show-toplevel`,
+          extra: { timeoutMs: timeout ?? null }
+        }
+      }
+    }
+    const stderr = String(top.stderr || '').trim()
+    if (top.code === 128 && /not a git repository/i.test(stderr)) {
+      return { failure: { code: 'E_INVALID_ARG', message: `not a git repository: ${abs}`, extra: { exitCode: top.code, stderr: stderr.slice(0, 500) } } }
+    }
+    return {
+      failure: {
+        code: 'E_GIT_EXIT',
+        message: `git rev-parse failed (exit ${top.code}): ${stderr.slice(0, 400) || 'no stderr'}`,
+        extra: { exitCode: top.code, stderr: stderr.slice(0, 500) }
+      }
+    }
+  }
   const root = top.stdout.trim()
+  if (!root) {
+    return { failure: { code: 'E_GIT_EXIT', message: `git rev-parse returned no path for ${abs} (exit ${top.code})`, extra: { exitCode: top.code } } }
+  }
   try {
     return { root: realpathSync(root) }
   } catch {
@@ -44,18 +88,18 @@ function countDirty(entries) {
 
 async function repoSummary(abs, { timeout, signal, entries = 200 } = {}) {
   const found = await repoRootOf(abs, { timeout, signal })
-  if (found.error) return null
+  if (found.failure) return { failure: found.failure }
   const root = found.root
   const [branch, head, upstream, status] = await Promise.all([
-    run('git', ['-C', root, 'rev-parse', '--abbrev-ref', 'HEAD'], { timeout, signal }),
-    run('git', ['-C', root, 'rev-parse', 'HEAD'], { timeout, signal }),
-    run('git', ['-C', root, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { timeout, signal }),
-    run('git', ['-C', root, 'status', '--porcelain=v1', '-b', '--untracked-files=normal'], { timeout, signal })
+    runGit(['-C', root, 'rev-parse', '--abbrev-ref', 'HEAD'], { timeout, signal }),
+    runGit(['-C', root, 'rev-parse', 'HEAD'], { timeout, signal }),
+    runGit(['-C', root, 'rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}'], { timeout, signal }),
+    runGit(['-C', root, 'status', '--porcelain=v1', '-b', '--untracked-files=normal'], { timeout, signal })
   ])
   let ahead = null
   let behind = null
   if (!upstream.error) {
-    const counts = await run('git', ['-C', root, 'rev-list', '--left-right', '--count', '@{u}...HEAD'], {
+    const counts = await runGit(['-C', root, 'rev-list', '--left-right', '--count', '@{u}...HEAD'], {
       timeout,
       signal
     })
@@ -69,17 +113,19 @@ async function repoSummary(abs, { timeout, signal, entries = 200 } = {}) {
   const branchLine = lines.find((l) => l.startsWith('## ')) || ''
   const statusEntries = lines.filter((l) => !l.startsWith('## '))
   return {
-    root,
-    name: basename(root),
-    branch: branch.error ? null : branch.stdout.trim(),
-    head: head.error ? null : head.stdout.trim(),
-    upstream: upstream.error ? null : upstream.stdout.trim(),
-    ahead,
-    behind,
-    statusBranchLine: branchLine,
-    dirty: countDirty(statusEntries),
-    entries: statusEntries.slice(0, entries),
-    truncatedEntries: Math.max(0, statusEntries.length - entries)
+    summary: {
+      root,
+      name: basename(root),
+      branch: branch.error ? null : branch.stdout.trim(),
+      head: head.error ? null : head.stdout.trim(),
+      upstream: upstream.error ? null : upstream.stdout.trim(),
+      ahead,
+      behind,
+      statusBranchLine: branchLine,
+      dirty: countDirty(statusEntries),
+      entries: statusEntries.slice(0, entries),
+      truncatedEntries: Math.max(0, statusEntries.length - entries)
+    }
   }
 }
 
@@ -124,8 +170,8 @@ export function buildGit(ctx) {
         const g = guard(path, config)
         if (g.error) return g.error
         const timeout = config.limits?.gitTimeoutMs ?? 20000
-        const summary = await repoSummary(g.abs, { timeout, signal })
-        if (!summary) return invalidArg(`not a git repository: ${g.abs}`)
+        const { summary, failure } = await repoSummary(g.abs, { timeout, signal })
+        if (failure) return gitFailureResult(failure, { path: g.abs })
         return ok(summary)
       }
     },
@@ -146,13 +192,13 @@ export function buildGit(ctx) {
         if (g.error) return g.error
         const timeout = config.limits?.gitTimeoutMs ?? 20000
         const found = await repoRootOf(g.abs, { timeout, signal })
-        if (found.error) return invalidArg(`not a git repository: ${g.abs}`)
+        if (found.failure) return gitFailureResult(found.failure, { path: g.abs })
         const n = Math.min(limit ?? 20, 200)
         const args = ['-C', found.root, 'log', `-n${n}`]
         if (format === 'detail') args.push('--date=iso-strict', '--pretty=format:%H%x09%h%x09%an%x09%aI%x09%s')
         else args.push('--date=short', '--pretty=format:%h%x09%ad%x09%s')
         if (ref) args.push(ref, '--')
-        const out = await run('git', args, { timeout, signal })
+        const out = await runGit(args, { timeout, signal })
         if (out.error) return invalidArg(`git log failed: ${out.stderr.trim().slice(0, 500)}`)
         const commits = out.stdout
           .split(/\r?\n/)
@@ -184,13 +230,13 @@ export function buildGit(ctx) {
         if (g.error) return g.error
         const timeout = config.limits?.gitTimeoutMs ?? 20000
         const found = await repoRootOf(g.abs, { timeout, signal })
-        if (found.error) return invalidArg(`not a git repository: ${g.abs}`)
+        if (found.failure) return gitFailureResult(found.failure, { path: g.abs })
         const base = ['-C', found.root, 'diff']
         if (staged) base.push('--staged')
         if (ref) base.push(ref)
         const pathspec = file ? ['--', file] : []
-        const statOut = await run('git', [...base, '--stat', ...pathspec], { timeout, signal })
-        const diffOut = await run('git', [...base, ...pathspec], { timeout, signal })
+        const statOut = await runGit([...base, '--stat', ...pathspec], { timeout, signal })
+        const diffOut = await runGit([...base, ...pathspec], { timeout, signal })
         if (diffOut.error && diffOut.code !== 1) {
           return invalidArg(`git diff failed: ${diffOut.stderr.trim().slice(0, 500)}`)
         }
@@ -233,13 +279,17 @@ export function buildGit(ctx) {
           targets.push(...findRepos(abs, { depth: depth ?? 2, maxRepos: cap - targets.length }))
         }
         const repos = []
+        const errors = []
         let index = 0
         const worker = async () => {
           while (index < targets.length) {
             const dir = targets[index]
             index += 1
-            const summary = await repoSummary(dir, { timeout, signal, entries: 20 })
-            if (!summary) continue
+            const { summary, failure } = await repoSummary(dir, { timeout, signal, entries: 20 })
+            if (failure) {
+              errors.push({ path: dir, code: failure.code, message: failure.message, ...failure.extra })
+              continue
+            }
             const dirtyCount =
               summary.dirty.staged + summary.dirty.modified + summary.dirty.untracked + summary.dirty.unmerged
             if (dirtyOnly && dirtyCount === 0 && !(summary.ahead > 0)) continue
@@ -248,6 +298,10 @@ export function buildGit(ctx) {
         }
         await Promise.all(Array.from({ length: Math.min(4, targets.length) }, worker))
         repos.sort((a, b) => a.root.localeCompare(b.root))
+        // 全部候选都失败时把真因抛出来（2026-11-10 的坑：repo_scan 只回 scanned 1/repos 0，看不出是 git spawn 失败）
+        if (targets.length > 0 && repos.length === 0 && errors.length === targets.length) {
+          return gitFailureResult(errors[0], { scanned: targets.length, errors })
+        }
         const dirty = repos.filter(
           (r) => r.dirty.staged + r.dirty.modified + r.dirty.untracked + r.dirty.unmerged > 0 || r.ahead > 0
         )
@@ -258,6 +312,7 @@ export function buildGit(ctx) {
           repos: repos.length,
           dirtyRepos: dirty.length,
           dirtyOnly: Boolean(dirtyOnly),
+          ...(errors.length ? { errors } : {}),
           items: repos
         })
       }