dsh-mesh-node 0.0.0-stage → 0.0.2

package/src/tools/cluster.js

@@ -0,0 +1,235 @@
+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 { fail, ok } from '../core/result.js'
+
+const TERMINAL = new Set(['done', 'failed', 'cancelled'])
+
+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()
+  try {
+    const head = run(['rev-parse', '--short', 'HEAD'])
+    const branch = run(['rev-parse', '--abbrev-ref', 'HEAD'])
+    const dirty = run(['status', '--porcelain']) !== ''
+    let ahead = null
+    let behind = null
+    try {
+      const counts = run(['rev-list', '--left-right', '--count', 'HEAD...@{upstream}']).split(/\s+/).map(Number)
+      ahead = counts[0] || 0
+      behind = counts[1] || 0
+    } catch {
+      /* no upstream */
+    }
+    return { path: repo, head, branch, dirty, ahead, behind }
+  } catch (error) {
+    return { path: repo, error: String(error?.message || error) }
+  }
+}
+
+function taskStats(root) {
+  const dir = join(root, '.mesh', 'tasks')
+  if (!existsSync(dir)) return { active: 0, stale: 0, activeStale: 0 }
+  let active = 0
+  let stale = 0
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue
+    let status = null
+    try {
+      status = JSON.parse(readFileSync(join(dir, entry.name, 'status.json'), 'utf8'))
+    } catch {
+      status = null
+    }
+    const state = status?.state || 'submitted'
+    if (TERMINAL.has(state)) continue
+    active += 1
+    const match = /^T-(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})-/.exec(entry.name)
+    const idTime = match ? new Date(Number(match[1]), Number(match[2]) - 1, Number(match[3]), Number(match[4]), Number(match[5])).getTime() : 0
+    const age = Number(status?.staleSeconds || 0)
+    const statusAge = status?.updatedAt ? (Date.now() - Date.parse(status.updatedAt)) / 1000 : null
+    if (age > 3600 || (statusAge !== null && statusAge > 3600) || (idTime && Date.now() - idTime > 3600_000)) stale += 1
+  }
+  return { active, stale, activeStale: stale }
+}
+/**
+ * Cluster view (M7 step 4). One read-only call answers "is the whole cluster
+ * healthy, and if not which hop is broken": every local DSH instance behind a
+ * host bridge, plus every paired remote node's `/health` (version / tools /
+ * uptime / TLS pin). Used as the first step of the A-crashed-B-repairs-A drill.
+ */
+export function buildCluster(ctx) {
+  return [
+    {
+      name: 'cluster_status',
+      title: 'Cluster health snapshot',
+      description:
+        'Read-only snapshot of everything this node can reach: local DSH instances behind host bridges (pid, tool count, live agents, latency) and paired remote nodes probed over /health (version, tools, uptime, TLS fingerprint match). Also aggregates each peer\'s own host_instances into summary{local,remote,total} / cluster[] / remoteInstances[] so one call lists every machine\'s DSH instances (four-instance view); a peer that denies host_instances shows instancesError without failing the verdict. Returns a verdict (ok / degraded / down) plus an issues list. Start here before repairing anything: it tells you which hop is broken. Never mutates state.',
+      inputSchema: z.object({
+        includePeers: z.boolean().optional().describe('Probe paired remote nodes too (default true).'),
+        timeoutMs: z.number().int().min(1000).max(60000).optional().describe('Per-probe timeout in ms (default 4000).')
+      }),
+      handler: async ({ includePeers, timeoutMs }) => {
+        try {
+          const config = ctx.getConfig()
+          const peers = includePeers === false ? [] : loadPeers(ctx.home).items || []
+          const report = await clusterReport({
+            config,
+            home: ctx.home,
+            log: ctx.log,
+            peers: peers.map((peer) => ({
+              id: peer.id,
+              name: peer.name,
+              url: peer.url,
+              certFingerprint: peer.certFingerprint,
+              token: peer.token
+            })),
+            timeoutMs: timeoutMs ?? 4000
+          })
+          return ok(report)
+        } catch (error) {
+          return fail('E_CLUSTER_ERROR', error?.message || String(error))
+        }
+      }
+    },
+    {
+      name: 'mesh_overview',
+      title: 'One-screen mesh overview',
+      description:
+        'Read-only overview for AI: node/mesh version, local DSH instances (up/plugin/pid/tools/live agents), peers (health/version), local active/stale delegation tasks, each peer active/stale task counts, and local/peer git head/dirty/ahead/behind. Use this first instead of chaining cluster_status + delegate_list.',
+      inputSchema: z.object({
+        includePeers: z.boolean().optional().describe('Probe and query paired peers too (default true).'),
+        timeoutMs: z.number().int().min(1000).max(60000).optional()
+      }),
+      handler: async ({ includePeers = true, timeoutMs = 4000 }) => {
+        try {
+          const config = ctx.getConfig()
+          const peers = includePeers === false ? [] : loadPeers(ctx.home).items || []
+          const report = await clusterReport({
+            config,
+            home: ctx.home,
+            log: ctx.log,
+            peers: peers.map((peer) => ({
+              id: peer.id,
+              name: peer.name,
+              url: peer.url,
+              certFingerprint: peer.certFingerprint,
+              token: peer.token
+            })),
+            timeoutMs
+          })
+          const localRoot = config.acl?.fsRoots?.[0]?.path || ''
+          const localTasks = localRoot ? taskStats(localRoot) : { active: 0, stale: 0, activeStale: 0 }
+          const peerTasks = []
+          for (const peer of peers) {
+            try {
+              const out = await callPeerTool(peer, { tool: 'delegate_list', args: { limit: 100 }, timeoutMs: Math.min(timeoutMs, 8000) })
+              const text = out.result?.content?.[0]?.text || '{}'
+              const listed = JSON.parse(text)
+              peerTasks.push({ peer: peer.name, activeCount: listed.activeCount || 0, staleActiveCount: listed.staleActiveCount || 0 })
+            } catch (error) {
+              peerTasks.push({ peer: peer.name, error: String(error?.message || error) })
+            }
+          }
+          const peerRepos = []
+          for (const peer of peers) {
+            try {
+              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')
+              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)
+              peerRepos.push({
+                peer: peer.name,
+                path: repoPath,
+                head: status.head ? String(status.head).slice(0, 7) : '',
+                branch: status.branch || '',
+                dirty: (status.dirty?.modified || 0) + (status.dirty?.untracked || 0),
+                ahead: status.ahead ?? null,
+                behind: status.behind ?? null
+              })
+            } catch (error) {
+              peerRepos.push({ peer: peer.name, error: String(error?.message || error) })
+            }
+          }
+          return ok({
+            node: report.node,
+            summary: report.summary,
+            verdict: report.verdict,
+            issues: report.issues,
+            repos: { local: gitInfo(process.cwd()), peers: peerRepos },
+            instances: (report.instances || []).map((instance) => ({
+              id: instance.id,
+              label: instance.label,
+              up: instance.up,
+              plugin: instance.plugin,
+              pid: instance.pid,
+              toolCount: instance.toolCount,
+              liveAgents: (instance.agents || []).length
+            })),
+            peers: report.peers,
+            tasks: { local: localTasks, peers: peerTasks }
+          })
+        } catch (error) {
+          return fail('E_OVERVIEW_ERROR', error?.message || String(error))
+        }
+      }
+    },
+    {
+      name: 'cluster_exec',
+      title: 'Run one MCP tool on a paired peer',
+      description:
+        'Calls exactly one tool on a paired remote node (the reverse direction: this node acts on the other machine). Looks the peer up by name/id in peers.json (token imported via `peer import` or obtained by `peer add`), re-checks its /health and TLS pin first, then makes one MCP tool call. Denied by default — add "cluster_exec" to acl.allow. Read-only tools are the intended use; write/repair tools on the peer are still governed by THAT node\'s own ACL.',
+      inputSchema: z.object({
+        peer: z.string().describe('Paired peer name or id, as listed by `node src/cli.js peer list`.'),
+        tool: z.string().describe('Tool name on the peer (e.g. mesh_self, cluster_status).'),
+        arguments: z.any().optional().describe('Arguments object for the peer tool (default {}).'),
+        timeoutMs: z.number().int().min(1000).max(600000).optional().describe('Per-call timeout in ms (default 30000).')
+      }),
+      handler: async ({ peer, tool, arguments: args, timeoutMs }) => {
+        const config = ctx.getConfig()
+        const target = String(peer || '').trim()
+        const entry = loadPeers(ctx.home).items.find((item) => item.name === target || item.id === target)
+        if (!entry) {
+          return fail('E_NOT_FOUND', `unknown peer "${target}" — run \`node src/cli.js peer list\` / \`peer import\``)
+        }
+        const limit = timeoutMs ?? 30000
+        const probe = await probePeer(
+          { id: entry.id, name: entry.name, url: entry.url, certFingerprint: entry.certFingerprint },
+          { timeoutMs: Math.min(limit, 8000) }
+        )
+        if (probe.up !== true) {
+          return fail(probe.error?.code || 'E_PEER_OFFLINE', `peer "${target}" is unreachable: ${probe.error?.message || 'no response'}`, {
+            retryable: true,
+            peer: target
+          })
+        }
+        if (probe.fingerprintMatch !== true) {
+          return fail('E_PEER_PIN_MISMATCH', `peer "${target}" certificate no longer matches the stored fingerprint`, {
+            retryable: false,
+            peer: target
+          })
+        }
+        try {
+          const out = await callPeerTool(entry, { tool, args: args ?? {}, timeoutMs: limit })
+          return ok({
+            peer: target,
+            node: probe.node,
+            version: probe.version,
+            tool,
+            ok: out.ok,
+            ms: out.ms,
+            result: out.result
+          })
+        } catch (error) {
+          return fail(error.code || 'E_PEER_CALL_FAILED', error.message, { retryable: false, peer: target })
+        }
+      }
+    }
+  ]
+}

package/src/tools/config-patch.js

@@ -0,0 +1,182 @@
+// @generated 2026-10-27 P1：mesh_config_patch（受限的「远程改本机 mesh 配置」）
+// [why] 2026-10-27 事故暴露的鸡生蛋：实例全死时想远程救，必须先在本机开 repair/加 ACL，而那头没人。
+//       本工具只允许**白名单字段**的**增量**修改（不删、不碰 token/shell/端口），带备份 + 原子写 + JSON 校验 + 默认 dry-run，
+//       把「远程改配置」从「开放 fs_write」降级为「受限补丁」。
+// 门禁：ACL 必须显式 allow `mesh_config_patch`（默认不给）；写操作要 confirm:true。
+//   - op=repair.set 允许在 repair.enabled=false 时执行（用于远程开启修复通道，bootstrap）
+//   - 其它 op 要求 repair.enabled=true
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { basename } from 'node:path'
+import { z } from 'zod'
+import { configPath, isAbsolutePath } from '../core/config.js'
+import { validateRestartCommand } from '../core/restart-policy.js'
+import { fail, ok } from '../core/result.js'
+
+const TOOL_NAME_RE = /^[a-z][a-z0-9_]{2,40}$/
+const SCRIPT_NAME_RE = /^[A-Za-z0-9._-]{1,40}$/
+const NEVER_APPEND = new Set(['shell_run'])
+const MAX_FSROOTS_PER_CALL = 10
+
+const opSchema = z.enum(['acl.allow.append', 'acl.fsRoots.append', 'repair.set', 'restartScript.set'])
+
+function readConfigFile(home) {
+  const file = configPath(home)
+  const text = readFileSync(file, 'utf8')
+  return { file, text, config: JSON.parse(text) }
+}
+
+function diffSummary(before, after) {
+  const flat = (value, prefix = '') => {
+    const out = {}
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+      for (const [k, v] of Object.entries(value)) Object.assign(out, flat(v, prefix ? `${prefix}.${k}` : k))
+    } else {
+      out[prefix] = value
+    }
+    return out
+  }
+  const a = flat(before)
+  const b = flat(after)
+  const added = []
+  const changed = []
+  for (const key of Object.keys(b)) {
+    if (!(key in a)) added.push(key)
+    else if (JSON.stringify(a[key]) !== JSON.stringify(b[key])) changed.push(key)
+  }
+  const removed = Object.keys(a).filter((key) => !(key in b))
+  return { added, changed, removed }
+}
+
+/** Apply one whitelisted op in place on `config`; throws on invalid input. */
+function applyOp(config, op, value) {
+  config.acl = config.acl || {}
+  config.repair = config.repair || {}
+  if (op === 'acl.allow.append') {
+    const list = Array.isArray(value) ? value : [value]
+    if (list.length === 0 || list.length > 40) throw new Error('value must be 1..40 tool names')
+    config.acl.allow = Array.isArray(config.acl.allow) ? config.acl.allow : []
+    let appended = 0
+    for (const raw of list) {
+      const name = String(raw || '').trim()
+      if (!TOOL_NAME_RE.test(name)) throw new Error(`invalid tool name: ${name}`)
+      if (NEVER_APPEND.has(name)) throw new Error(`refusing to auto-widen ${name} (enable it by hand on that machine)`)
+      if (!config.acl.allow.includes(name)) {
+        config.acl.allow.push(name)
+        appended += 1
+      }
+    }
+    return { appended, total: config.acl.allow.length }
+  }
+  if (op === 'acl.fsRoots.append') {
+    const list = Array.isArray(value) ? value : [value]
+    if (list.length === 0 || list.length > MAX_FSROOTS_PER_CALL) throw new Error(`value must be 1..${MAX_FSROOTS_PER_CALL} paths`)
+    config.acl.fsRoots = Array.isArray(config.acl.fsRoots) ? config.acl.fsRoots : []
+    let appended = 0
+    for (const raw of list) {
+      const path = String(raw || '').trim()
+      if (!isAbsolutePath(path)) throw new Error(`fsRoot must be an absolute path: ${path}`)
+      if (path.length > 260) throw new Error('fsRoot too long')
+      if (!config.acl.fsRoots.includes(path)) {
+        config.acl.fsRoots.push(path)
+        appended += 1
+      }
+    }
+    return { appended, total: config.acl.fsRoots.length }
+  }
+  if (op === 'repair.set') {
+    const patch = value && typeof value === 'object' ? value : {}
+    const keys = Object.keys(patch)
+    if (keys.length === 0 || keys.some((k) => !['enabled', 'timeoutMs'].includes(k))) throw new Error('repair.set only accepts {enabled?, timeoutMs?}')
+    if ('enabled' in patch) {
+      if (typeof patch.enabled !== 'boolean') throw new Error('enabled must be boolean')
+      config.repair.enabled = patch.enabled
+    }
+    if ('timeoutMs' in patch) {
+      const ms = Number(patch.timeoutMs)
+      if (!Number.isFinite(ms) || ms < 5000 || ms > 600000) throw new Error('timeoutMs must be 5000..600000')
+      config.repair.timeoutMs = ms
+    }
+    return { enabled: config.repair.enabled, timeoutMs: config.repair.timeoutMs }
+  }
+  if (op === 'restartScript.set') {
+    const patch = value && typeof value === 'object' ? value : {}
+    const name = String(patch.name || '').trim()
+    const command = String(patch.command || '').trim()
+    if (!SCRIPT_NAME_RE.test(name)) throw new Error('name must match [A-Za-z0-9._-]{1,40}')
+    if (!command || command.length > 500) throw new Error('command must be 1..500 chars')
+    const policy = validateRestartCommand(command)
+    if (!policy.ok) throw new Error(policy.reason)
+    config.repair.restartScripts = config.repair.restartScripts || {}
+    config.repair.restartScripts[name] = command
+    return { name, scripts: Object.keys(config.repair.restartScripts) }
+  }
+  throw new Error(`unknown op: ${op}`)
+}
+
+export function buildConfigPatch(ctx) {
+  return [
+    {
+      name: 'mesh_config_patch',
+      title: 'Patch this node mesh config (whitelisted, incremental only)',
+      description:
+        'Remote-editable subset of THIS machine\'s mesh config.json: append ACL entries (acl.allow / acl.fsRoots), toggle repair.enabled/timeoutMs, set one repair.restartScripts entry. Incremental only — never removes entries, never touches tokens/shell/ports. Backup + atomic write + JSON re-parse + diff returned. Default is dry-run: pass confirm:true to write. ACL must explicitly allow mesh_config_patch; every op except repair.set also requires repair.enabled=true.',
+      inputSchema: z.object({
+        op: opSchema.describe(
+          'acl.allow.append (value: string|string[]) | acl.fsRoots.append (value: string|string[]) | repair.set (value: {enabled?,timeoutMs?}) | restartScript.set (value: {name,command})'
+        ),
+        value: z.any().describe('Op-specific value (see op description).'),
+        confirm: z.boolean().optional().describe('true = actually write; otherwise dry-run.'),
+        note: z.string().max(200).optional().describe('Free-text reason recorded in the result/audit.')
+      }),
+      handler: async ({ op, value, confirm, note }) => {
+        const config = ctx.getConfig()
+        const enabled = Boolean(config.repair?.enabled)
+        if (op !== 'repair.set' && !enabled) {
+          return fail('E_REPAIR_DISABLED', 'repair.enabled=false on this node: only repair.set can run remotely', { op })
+        }
+        let before
+        try {
+          const loaded = readConfigFile(ctx.home)
+          before = loaded.config
+        } catch (error) {
+          return fail('E_CONFIG_READ', `cannot read config.json: ${error?.message || error}`)
+        }
+        const after = JSON.parse(JSON.stringify(before))
+        let summary
+        try {
+          summary = applyOp(after, op, value)
+        } catch (error) {
+          return fail('E_INVALID_ARG', error?.message || String(error), { op })
+        }
+        const diff = diffSummary(before, after)
+        const base = { op, note: note || '', dryRun: confirm !== true, summary, diff }
+        if (confirm !== true) return ok({ ...base, applied: false, hint: 'pass confirm:true to write' })
+        if (diff.removed.length > 0) return fail('E_GUARD', 'patch would remove keys (refused)', { diff })
+
+        const file = configPath(ctx.home)
+        const backup = `${file}.bak-${new Date().toISOString().replace(/[-:T]/g, '').slice(0, 14)}`
+        try {
+          copyFileSync(file, backup)
+          const next = JSON.stringify(after, null, 2) + '\n'
+          writeFileSync(file, next, 'utf8')
+          const verify = JSON.parse(readFileSync(file, 'utf8'))
+          if (JSON.stringify(verify) !== JSON.stringify(after)) throw new Error('re-read mismatch')
+        } catch (error) {
+          try {
+            copyFileSync(backup, file)
+          } catch {
+            /* keep the original error */
+          }
+          return fail('E_CONFIG_WRITE', `patch failed and was rolled back: ${error?.message || error}`, { backup })
+        }
+        return ok({
+          ...base,
+          applied: true,
+          backup: basename(backup),
+          configPath: file,
+          hotReload: 'mesh server reads config on every call (mtime) — ACL/repair changes take effect immediately; new TOOLS need `node scripts/mesh-restart.mjs`'
+        })
+      }
+    }
+  ]
+}