memory-eternal 0.9.9 → 0.9.10

package/lib/vault-resolve.js

@@ -0,0 +1,84 @@
+// 记忆核心 · vault 目录解析（宿主与所有独立进程共用同一套优先级）
+//
+// 为什么单独成模块：以前宿主 index.js 认 activeVault，而 CLI / MCP / hooks /
+// 独立 web / sweep 只认 MEMORY_VAULT_DIR 与默认库 —— 用户切库后终端与 hooks 仍写
+// 默认库，同一台机器上的记忆被劈成两份（dsh-memory-eternal#5）。解析逻辑必须只有一份。
+//
+// 优先级：
+//   1. MEMORY_VAULT_DIR              （临时切库 / 宿主 spawn 子进程时显式传入）
+//   2. activeVault 命中 vaultProfiles[].name
+//   3. vaultProfiles[].match.workspace 命中当前 workspace（最长前缀优先，opt-in）
+//   4. vaultDir（单库配置）
+//   5. 默认 ~/.dsh/memory-vault
+
+import path from 'node:path'
+import os from 'node:os'
+
+/** 取当前 workspace（用于 match.workspace 的按项目选库）：MEMORY_WORKSPACE 优先，其次进程 cwd。 */
+export function currentWorkspace(env = process.env) {
+  const explicit = String((env && env.MEMORY_WORKSPACE) || '').trim()
+  if (explicit) return explicit
+  try { return process.cwd() } catch { return '' }
+}
+
+/** 默认库目录。 */
+export function defaultVaultRoot(env = process.env) {
+  const home = (env && env.DSH_HOME) || path.join(os.homedir(), '.dsh')
+  return path.join(home, 'memory-vault')
+}
+
+/** 归一化：反斜杠转正斜杠、去尾斜杠、统一小写（Windows 路径大小写不敏感）。 */
+const norm = (p) => String(p || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase()
+
+/**
+ * 找出 match.workspace 命中当前 workspace 的 profile。
+ * 双向前缀匹配（workspace 落在规则目录下，或规则目录落在 workspace 下），最长规则优先。
+ * @returns {object|null}
+ */
+export function matchWorkspaceProfile(profiles, workspace) {
+  const ws = norm(workspace)
+  if (!ws) return null
+  let best = null
+  let bestLen = -1
+  for (const p of Array.isArray(profiles) ? profiles : []) {
+    const rule = p && p.match && p.match.workspace
+    const target = norm(rule)
+    if (!target) continue
+    // 规则没配可用目录 → 不能作为记忆库，直接跳过（与 resolveVaultDir 的判定保持一致）
+    if (!p.path || !String(p.path).trim()) continue
+    if (!(ws === target || ws.startsWith(target + '/') || target.startsWith(ws + '/'))) continue
+    if (target.length > bestLen) { best = p; bestLen = target.length }
+  }
+  return best
+}
+
+/**
+ * 解析当前 vault 目录。
+ * @param {object} input
+ * @param {NodeJS.ProcessEnv} [input.env]
+ * @param {Array<{name?:string,path?:string,match?:{workspace?:string}}>} [input.profiles]
+ * @param {string} [input.activeVault]
+ * @param {string} [input.configured] vaultDir 单库配置
+ * @param {string} [input.workspace] 显式指定 workspace（默认 currentWorkspace）
+ * @returns {{root:string, source:'env'|'profile'|'workspace'|'vaultDir'|'default', name:string, workspace:string}}
+ */
+export function resolveVaultDir({ env = process.env, profiles = [], activeVault = '', configured = '', workspace } = {}) {
+  const ws = workspace === undefined ? currentWorkspace(env) : String(workspace || '')
+  const envDir = String((env && env.MEMORY_VAULT_DIR) || '').trim()
+  if (envDir) return { root: path.resolve(envDir), source: 'env', name: '', workspace: ws }
+
+  const list = Array.isArray(profiles) ? profiles : []
+  const active = String(activeVault || '').trim()
+  if (active) {
+    const hit = list.find((p) => p && String(p.name || '') === active && p.path && String(p.path).trim())
+    if (hit) return { root: path.resolve(String(hit.path).trim()), source: 'profile', name: active, workspace: ws }
+  }
+  const byWs = matchWorkspaceProfile(list, ws)
+  if (byWs && byWs.path && String(byWs.path).trim()) {
+    return { root: path.resolve(String(byWs.path).trim()), source: 'workspace', name: String(byWs.name || ''), workspace: ws }
+  }
+  if (configured && String(configured).trim()) {
+    return { root: path.resolve(String(configured).trim()), source: 'vaultDir', name: '', workspace: ws }
+  }
+  return { root: defaultVaultRoot(env), source: 'default', name: '', workspace: ws }
+}

package/lib/watchdog.js

@@ -45,33 +45,125 @@ export function isPidAlive(pid) {
   try { process.kill(n, 0); return true } catch (error) { return error?.code === 'EPERM' }
 }
 
-/** 读取锁文件；损坏或不存在返回 null。 */
+/**
+ * 读取锁文件，归一化成 { watchdogs: [{pid, port, vault, startedAt}] }。
+ * 兼容早期单槽格式（顶层就是 {pid, port}）：多端口/多 vault 并存时需要多槽。
+ */
 export function readWatchdogLock(env = process.env) {
-  try { return JSON.parse(fs.readFileSync(watchdogLockPath(env), 'utf8')) } catch { return null }
+  let raw = null
+  try { raw = JSON.parse(fs.readFileSync(watchdogLockPath(env), 'utf8')) } catch { return { watchdogs: [] } }
+  if (!raw || typeof raw !== 'object') return { watchdogs: [] }
+  if (Array.isArray(raw.watchdogs)) return { watchdogs: raw.watchdogs.filter((w) => w && w.pid) }
+  if (raw.pid) return { watchdogs: [raw] } // 旧格式
+  return { watchdogs: [] }
 }
 
-/**
- * 尝试取得看门狗锁。
- * @returns {{acquired:boolean, file:string, previous:object|null}} acquired=false 表示「同端口已有活着的看门狗」，调用方应直接退出。
- */
-export function acquireWatchdogLock({ env = process.env, port, vault = '', pid = process.pid } = {}) {
+function writeWatchdogLock(env, list) {
   const file = watchdogLockPath(env)
-  const prev = readWatchdogLock(env)
-  const samePortOwnerAlive = prev && prev.pid !== pid && Number(prev.port) === Number(port) && isPidAlive(prev.pid)
-  if (samePortOwnerAlive) return { acquired: false, file, previous: prev }
-  const stale = prev && !isPidAlive(prev.pid) ? prev : null
   try {
     fs.mkdirSync(path.dirname(file), { recursive: true })
-    fs.writeFileSync(file, JSON.stringify({ pid, port: Number(port), vault, startedAt: new Date().toISOString() }))
+    fs.writeFileSync(file, JSON.stringify({ watchdogs: list }))
   } catch { /* 写不了锁不阻塞保活 */ }
-  return { acquired: true, file, previous: stale }
 }
 
-/** 释放锁（只清自己的，避免误删别人刚写的）。 */
+/**
+ * 尝试取得看门狗锁（按端口分槽）。
+ * @returns {{acquired:boolean, file:string, previous:object|null, reaped:number[]}} acquired=false 表示同端口已有活着的看门狗，调用方应直接退出。
+ */
+export function acquireWatchdogLock({ env = process.env, port, vault = '', pid = process.pid } = {}) {
+  const file = watchdogLockPath(env)
+  const cur = readWatchdogLock(env)
+  const samePort = cur.watchdogs.filter((w) => Number(w.port) === Number(port) && w.pid !== pid)
+  const alive = samePort.find((w) => isPidAlive(w.pid))
+  if (alive) return { acquired: false, file, previous: alive, reaped: [] }
+  // 清掉死掉的槽（含其它端口的陈旧记录），保留仍然存活的其它端口
+  const reaped = []
+  const kept = []
+  for (const w of cur.watchdogs) {
+    if (Number(w.port) === Number(port)) { reaped.push(w.pid); continue }
+    if (isPidAlive(w.pid)) kept.push(w)
+    else reaped.push(w.pid)
+  }
+  const previous = samePort[0] || (reaped.length ? { pid: reaped[0] } : null)
+  kept.push({ pid, port: Number(port), vault, startedAt: new Date().toISOString() })
+  writeWatchdogLock(env, kept)
+  return { acquired: true, file, previous, reaped }
+}
+
+/** 释放锁（只清自己那一槽；没有其它槽就删文件）。 */
 export function releaseWatchdogLock({ env = process.env, pid = process.pid } = {}) {
   const cur = readWatchdogLock(env)
-  if (!cur || cur.pid !== pid) return false
-  try { fs.unlinkSync(watchdogLockPath(env)); return true } catch { return false }
+  const kept = cur.watchdogs.filter((w) => w.pid !== pid)
+  if (kept.length === cur.watchdogs.length) return false
+  if (!kept.length) { try { fs.unlinkSync(watchdogLockPath(env)) } catch { /* 已不存在 */ } return true }
+  writeWatchdogLock(env, kept)
+  return true
+}
+
+/**
+ * 解析进程列表（纯函数，便于单测）。
+ * 支持 `ps -eo pid,args` 与 Windows 的 `ConvertTo-Csv` 两种输入。
+ * @returns {Array<{pid:number, port:number, command:string}>} 只保留命令行里带 watchdog.js 的 node 进程
+ */
+export function parseWatchdogProcesses(text, platform = process.platform) {
+  const out = []
+  for (const raw of String(text || '').split(/\r?\n/)) {
+    const line = raw.trim()
+    if (!line || !line.includes('watchdog.js')) continue
+    let pid = 0
+    let command = line
+    const csv = /^"?(\d+)"?,(.*)$/.exec(line) // Windows: "1234","node ... watchdog.js --port 7999"
+    const ps = /^(\d+)\s+(.*)$/.exec(line)      // POSIX: 1234 node ... watchdog.js --port 7999
+    if (csv) { pid = Number(csv[1]); command = csv[2].replace(/^"|"$/g, '') }
+    else if (ps) { pid = Number(ps[1]); command = ps[2] }
+    if (!pid) continue
+    const m = /--port\s+(\d+)/.exec(command)
+    out.push({ pid, port: m ? Number(m[1]) : 7999, command })
+  }
+  return out
+}
+
+/** 列出机器上所有 watchdog 进程（平台相关，失败返回空数组）。 */
+async function listWatchdogProcesses(exec, platform = process.platform) {
+  if (platform === 'win32') {
+    const ps = "Get-CimInstance Win32_Process -Filter \"Name='node.exe'\" | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"
+    const out = await exec('powershell', ['-NoProfile', '-Command', ps])
+    return parseWatchdogProcesses(out, 'win32')
+  }
+  const out = await exec('ps', ['-eo', 'pid,args'])
+  return parseWatchdogProcesses(out, 'linux')
+}
+
+/**
+ * 回收历史遗留的孤儿看门狗（新锁只能防新增，管不了升级前已经在跑的）。
+ * 只杀「命令行是 watchdog.js + 端口相同 + pid 不是自己 + 不在锁里存活」的进程。
+ * @returns {Promise<{scanned:number, killed:number[], skipped:number[]}>}
+ */
+export async function reapStaleWatchdogs({ port = 7999, keepPid = process.pid, env = process.env, exec, list, kill } = {}) {
+  const runExec = exec || (async (cmd, args) => {
+    const { spawn } = await import('node:child_process')
+    return await new Promise((resolve) => {
+      const c = spawn(cmd, args, { windowsHide: true })
+      let buf = ''
+      c.stdout.on('data', (d) => { buf += d })
+      c.on('error', () => resolve(''))
+      c.on('close', () => resolve(buf))
+    })
+  })
+  const procs = list ? await list() : await listWatchdogProcesses(runExec)
+  const lock = readWatchdogLock(env)
+  const lockedAlive = new Set(lock.watchdogs.filter((w) => isPidAlive(w.pid)).map((w) => Number(w.pid)))
+  const killFn = kill || ((pid) => { try { process.kill(pid, 'SIGTERM'); return true } catch { return false } })
+  const killed = []
+  const skipped = []
+  for (const p of procs) {
+    if (Number(p.port) !== Number(port)) { skipped.push(p.pid); continue }
+    if (Number(p.pid) === Number(keepPid)) { skipped.push(p.pid); continue }
+    if (lockedAlive.has(Number(p.pid))) { skipped.push(p.pid); continue } // 锁里活着的是当前合法实例
+    if (!isPidAlive(p.pid)) { skipped.push(p.pid); continue }
+    if (killFn(p.pid)) killed.push(p.pid); else skipped.push(p.pid)
+  }
+  return { scanned: procs.length, killed, skipped }
 }
 
 const ts = () => new Date().toISOString().slice(11, 19) // HH:MM:SS
@@ -275,6 +367,11 @@ if (process.argv[1] && /[\\/]watchdog\.js$/.test(process.argv[1])) {
   const maxRestart = Number(argOf('--max-restart')) || 10
   const vaultRoot = argOf('--vault') || undefined
   const autoStart = !argv.includes('--no-restart')
+  if (argv.includes('--reap')) {
+    const out = await reapStaleWatchdogs({ port, keepPid: 0 })
+    log(`回收孤儿看门狗：扫描 ${out.scanned} 个，清理 ${out.killed.length} 个${out.killed.length ? '（pid ' + out.killed.join(', ') + '）' : ''}，保留 ${out.skipped.length} 个`)
+    process.exit(0)
+  }
   const lock = acquireWatchdogLock({ port, vault: vaultRoot || '' })
   if (!lock.acquired) {
     log('同端口已有看门狗在跑（pid ' + (lock.previous && lock.previous.pid) + '，启动于 ' + (lock.previous && lock.previous.startedAt) + '）→ 本次启动退出，避免进程堆积')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memory-eternal",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "记忆核心（Memory Eternal）：自研的 DeepSeek Harness 记忆插件，不移植任何既有记忆框架——对话结束后自动沉淀知识卡到本地 Markdown Vault（自研去重、自研 CJK 检索、可 git 管理），设置页提供图形化知识库（统计 / 搜索 / 知识图谱 + 侧边栏一键弹窗），Agent 通过 memory_recall 工具按需召回历史上下文。零人工干预。",
   "license": "MIT",
   "repository": {
@@ -60,7 +60,7 @@
     "build": "node build.mjs",
     "build:client": "node build.mjs",
     "prepublishOnly": "node build.mjs",
-    "test": "node build.mjs && node tests/vault.test.mjs && node tests/capture.test.mjs && node tests/capture-route.test.mjs && node tests/stall.test.mjs && node tests/vault-path.test.mjs && node tests/api.test.mjs && node tests/graph-perf.test.mjs && node tests/settings-compat.test.mjs && node tests/node-bin.test.mjs && node tests/watchdog-lock.test.mjs && node tests/markdown.test.mjs && node tests/ssr.test.mjs"
+    "test": "node build.mjs && node tests/vault.test.mjs && node tests/capture.test.mjs && node tests/capture-route.test.mjs && node tests/stall.test.mjs && node tests/vault-path.test.mjs && node tests/vault-resolve.test.mjs && node tests/api.test.mjs && node tests/graph-perf.test.mjs && node tests/settings-compat.test.mjs && node tests/node-bin.test.mjs && node tests/watchdog-lock.test.mjs && node tests/markdown.test.mjs && node tests/ssr.test.mjs"
   },
   "dependencies": {
     "@deepseek-ai/schemastery": "^3.18.1"