memory-eternal 0.10.6 → 0.10.7

package/lib/host-heartbeat.js

@@ -1,72 +1,72 @@
-// 宿主心跳：让「独立 Web 端」知道本机此刻有没有活着的 DSH 宿主（issue #21 的宿主无关写路径）。
-//
-// 为什么需要它：配置只有一个权威写入者 —— DSH 宿主（插件用 settings.update 应用，再由
-// index.js 的 syncConfigFile 写共享配置文件）。独立 Web 进程里没有 settings 服务，只能把改动
-// 写进「待应用」文件、等宿主来 drain。但**非 DSH 宿主**（Codex / Claude Code / Cursor，
-// 或只跑 `dsh-memory serve` 的用户）根本没有宿主来 drain：改动会永远停在 pending 文件里，
-// 保存等于没保存 —— 而界面上那句「下次启动生效」在那类环境下是错的（不会有"下次启动 DSH"）。
-//
-// 判据：宿主活着时周期性刷新 `<共享配置>.host.json`（pid + 版本 + 时间戳）。
-// 独立端保存后若「没人消费 pending」且「心跳不新鲜」，即判定本机没有宿主 → 直接原子写共享配置。
-// 反之（宿主活着）**绝不**绕过宿主写文件：那会与宿主的 volatile 配置分叉，下一次
-// syncConfigFile() 就会把改动盖回去。
-import fs from 'node:fs'
-import { configFilePath } from './capture-run.js'
-import { writeFileAtomicSync } from './config-sync.js'
-
-/** 心跳文件路径（与共享配置同目录：`xxx.json` → `xxx.host.json`）。 */
-export function hostMarkerPath(env = process.env) {
-  return String(configFilePath(env)).replace(/\.json$/i, '.host.json')
-}
-
-/** 进程存活判定（EPERM = 存在但无权发信号，仍算活着）。 */
-export function isProcessAlive(pid) {
-  const n = Number(pid)
-  if (!Number.isFinite(n) || n <= 0) return false
-  try {
-    process.kill(n, 0)
-    return true
-  } catch (error) {
-    return Boolean(error && error.code === 'EPERM')
-  }
-}
-
-/** 写/刷新心跳（原子写：这是跨进程判据，读方可能正好在写）。 */
-export function writeHostMarker(env = process.env, info = {}, now = Date.now()) {
-  const data = { pid: process.pid, at: now, ...info }
-  writeFileAtomicSync(hostMarkerPath(env), JSON.stringify(data, null, 2))
-  return data
-}
-
-/** 读心跳；文件不存在 / 内容损坏都返回 null。 */
-export function readHostMarker(env = process.env) {
-  try {
-    const data = JSON.parse(fs.readFileSync(hostMarkerPath(env), 'utf8'))
-    if (!data || typeof data !== 'object') return null
-    return {
-      pid: Number(data.pid) || 0,
-      at: Number(data.at) || 0,
-      version: String(data.version || ''),
-    }
-  } catch { return null }
-}
-
-/** 删除心跳（插件 dispose 时尽力而为；宿主被硬杀时靠新鲜度判定兜底）。 */
-export function clearHostMarker(env = process.env) {
-  try { fs.unlinkSync(hostMarkerPath(env)); return true } catch { return false }
-}
-
-/**
- * 本机此刻有没有活着的 DSH 宿主：心跳新鲜（默认 45s，宿主每 15s 刷一次）**且**那个 pid 还在。
- * 两个条件都要，避免「宿主崩了但心跳文件还在」被误判成有宿主。
- *
- * @param {Record<string,string>} [env]
- * @param {{maxAgeMs?:number, now?:number, isAlive?:(pid:number)=>boolean}} [opts]
- * @returns {boolean}
- */
-export function hostAlive(env = process.env, { maxAgeMs = 45000, now = Date.now(), isAlive = isProcessAlive } = {}) {
-  const marker = readHostMarker(env)
-  if (!marker || !marker.pid || !marker.at) return false
-  if (now - marker.at > Math.max(0, Number(maxAgeMs) || 0)) return false
-  return isAlive(marker.pid)
-}
+// 宿主心跳：让「独立 Web 端」知道本机此刻有没有活着的 DSH 宿主（issue #21 的宿主无关写路径）。
+//
+// 为什么需要它：配置只有一个权威写入者 —— DSH 宿主（插件用 settings.update 应用，再由
+// index.js 的 syncConfigFile 写共享配置文件）。独立 Web 进程里没有 settings 服务，只能把改动
+// 写进「待应用」文件、等宿主来 drain。但**非 DSH 宿主**（Codex / Claude Code / Cursor，
+// 或只跑 `dsh-memory serve` 的用户）根本没有宿主来 drain：改动会永远停在 pending 文件里，
+// 保存等于没保存 —— 而界面上那句「下次启动生效」在那类环境下是错的（不会有"下次启动 DSH"）。
+//
+// 判据：宿主活着时周期性刷新 `<共享配置>.host.json`（pid + 版本 + 时间戳）。
+// 独立端保存后若「没人消费 pending」且「心跳不新鲜」，即判定本机没有宿主 → 直接原子写共享配置。
+// 反之（宿主活着）**绝不**绕过宿主写文件：那会与宿主的 volatile 配置分叉，下一次
+// syncConfigFile() 就会把改动盖回去。
+import fs from 'node:fs'
+import { configFilePath } from './capture-run.js'
+import { writeFileAtomicSync } from './config-sync.js'
+
+/** 心跳文件路径（与共享配置同目录：`xxx.json` → `xxx.host.json`）。 */
+export function hostMarkerPath(env = process.env) {
+  return String(configFilePath(env)).replace(/\.json$/i, '.host.json')
+}
+
+/** 进程存活判定（EPERM = 存在但无权发信号，仍算活着）。 */
+export function isProcessAlive(pid) {
+  const n = Number(pid)
+  if (!Number.isFinite(n) || n <= 0) return false
+  try {
+    process.kill(n, 0)
+    return true
+  } catch (error) {
+    return Boolean(error && error.code === 'EPERM')
+  }
+}
+
+/** 写/刷新心跳（原子写：这是跨进程判据，读方可能正好在写）。 */
+export function writeHostMarker(env = process.env, info = {}, now = Date.now()) {
+  const data = { pid: process.pid, at: now, ...info }
+  writeFileAtomicSync(hostMarkerPath(env), JSON.stringify(data, null, 2))
+  return data
+}
+
+/** 读心跳；文件不存在 / 内容损坏都返回 null。 */
+export function readHostMarker(env = process.env) {
+  try {
+    const data = JSON.parse(fs.readFileSync(hostMarkerPath(env), 'utf8'))
+    if (!data || typeof data !== 'object') return null
+    return {
+      pid: Number(data.pid) || 0,
+      at: Number(data.at) || 0,
+      version: String(data.version || ''),
+    }
+  } catch { return null }
+}
+
+/** 删除心跳（插件 dispose 时尽力而为；宿主被硬杀时靠新鲜度判定兜底）。 */
+export function clearHostMarker(env = process.env) {
+  try { fs.unlinkSync(hostMarkerPath(env)); return true } catch { return false }
+}
+
+/**
+ * 本机此刻有没有活着的 DSH 宿主：心跳新鲜（默认 45s，宿主每 15s 刷一次）**且**那个 pid 还在。
+ * 两个条件都要，避免「宿主崩了但心跳文件还在」被误判成有宿主。
+ *
+ * @param {Record<string,string>} [env]
+ * @param {{maxAgeMs?:number, now?:number, isAlive?:(pid:number)=>boolean}} [opts]
+ * @returns {boolean}
+ */
+export function hostAlive(env = process.env, { maxAgeMs = 45000, now = Date.now(), isAlive = isProcessAlive } = {}) {
+  const marker = readHostMarker(env)
+  if (!marker || !marker.pid || !marker.at) return false
+  if (now - marker.at > Math.max(0, Number(maxAgeMs) || 0)) return false
+  return isAlive(marker.pid)
+}

package/lib/llm-openai.js

@@ -1,84 +1,84 @@
-// 记忆核心 · OpenAI 兼容 LLM 适配器（独立进程用）。
-//
-// 在没有 DSH llm 服务的环境（MCP server / CLI / web / hooks）里，为
-// lib/capture.js 的 summarizeTurn 提供同形状的 llm 对象：
-//   - listProviders() / listModels() → 供 resolveRoute 解析路由
-//   - stream(options) → async iterable，yield 纯文本 chunk（由 capture.js
-//     fallback BlockAssembler 拼装）
-//
-// 配置（环境变量，或显式传参覆盖）：
-//   MEMORY_LLM_BASE_URL  OpenAI 兼容端点，如 https://api.deepseek.com、
-//                        http://127.0.0.1:11434/v1（Ollama）等
-//   MEMORY_LLM_KEY       API key（本地端点可留空）
-//   MEMORY_LLM_MODEL     模型名，如 deepseek-chat
-// 未配置时 createLlmFromEnv() 返回 null：调用方应降级（recall 不受影响，
-// capture 退化为存原文卡）。
-
-function flatContent(content) {
-  if (typeof content === 'string') return content
-  if (Array.isArray(content)) {
-    return content
-      .map((c) => (typeof c === 'string' ? c : c?.text ?? ''))
-      .filter(Boolean)
-      .join('\n')
-  }
-  return String(content ?? '')
-}
-
-export function createOpenAiLlm({ baseUrl, apiKey = '', model, purpose = 'memory-capture' } = {}) {
-  if (!baseUrl || !model) return null
-  const endpoint = baseUrl.replace(/\/+$/, '') + '/chat/completions'
-
-  return {
-    purpose,
-
-    listProviders() {
-      return [{ id: 'openai-compat' }]
-    },
-
-    async listModels() {
-      return [{ id: model }]
-    },
-
-    /**
-     * 非流式调用，整体作为单个 chunk yield（capture 的蒸馏一次性输出 JSON，
-     * 无需逐 token 流式）。signal 超时/中断会向上抛出。
-     */
-    async *stream(options = {}) {
-      const messages = []
-      if (options.system) messages.push({ role: 'system', content: options.system })
-      for (const m of options.messages ?? []) {
-        messages.push({ role: m?.role ?? 'user', content: flatContent(m?.content) })
-      }
-      const body = {
-        model: options.model || model,
-        messages,
-        max_tokens: options.maxTokens ?? 900,
-        stream: false,
-      }
-      const headers = { 'Content-Type': 'application/json' }
-      if (apiKey) headers.Authorization = `Bearer ${apiKey}`
-      const res = await fetch(endpoint, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify(body),
-        signal: options.signal ?? undefined,
-      })
-      if (!res.ok) {
-        const detail = await res.text().catch(() => '')
-        throw new Error(`[memory-eternal] LLM ${res.status}: ${detail.slice(0, 300)}`)
-      }
-      const data = await res.json()
-      const text = data?.choices?.[0]?.message?.content ?? ''
-      if (text) yield text
-    },
-  }
-}
-
-export function createLlmFromEnv(env = process.env) {
-  const baseUrl = env.MEMORY_LLM_BASE_URL || env.OPENAI_BASE_URL || ''
-  const apiKey = env.MEMORY_LLM_KEY || env.OPENAI_API_KEY || ''
-  const model = env.MEMORY_LLM_MODEL || ''
-  if (!baseUrl || !model) return null
-  return createOpenAiLlm({ baseUrl, apiKey, model })
-}
+// 记忆核心 · OpenAI 兼容 LLM 适配器（独立进程用）。
+//
+// 在没有 DSH llm 服务的环境（MCP server / CLI / web / hooks）里，为
+// lib/capture.js 的 summarizeTurn 提供同形状的 llm 对象：
+//   - listProviders() / listModels() → 供 resolveRoute 解析路由
+//   - stream(options) → async iterable，yield 纯文本 chunk（由 capture.js
+//     fallback BlockAssembler 拼装）
+//
+// 配置（环境变量，或显式传参覆盖）：
+//   MEMORY_LLM_BASE_URL  OpenAI 兼容端点，如 https://api.deepseek.com、
+//                        http://127.0.0.1:11434/v1（Ollama）等
+//   MEMORY_LLM_KEY       API key（本地端点可留空）
+//   MEMORY_LLM_MODEL     模型名，如 deepseek-chat
+// 未配置时 createLlmFromEnv() 返回 null：调用方应降级（recall 不受影响，
+// capture 退化为存原文卡）。
+
+function flatContent(content) {
+  if (typeof content === 'string') return content
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => (typeof c === 'string' ? c : c?.text ?? ''))
+      .filter(Boolean)
+      .join('\n')
+  }
+  return String(content ?? '')
+}
+
+export function createOpenAiLlm({ baseUrl, apiKey = '', model, purpose = 'memory-capture' } = {}) {
+  if (!baseUrl || !model) return null
+  const endpoint = baseUrl.replace(/\/+$/, '') + '/chat/completions'
+
+  return {
+    purpose,
+
+    listProviders() {
+      return [{ id: 'openai-compat' }]
+    },
+
+    async listModels() {
+      return [{ id: model }]
+    },
+
+    /**
+     * 非流式调用，整体作为单个 chunk yield（capture 的蒸馏一次性输出 JSON，
+     * 无需逐 token 流式）。signal 超时/中断会向上抛出。
+     */
+    async *stream(options = {}) {
+      const messages = []
+      if (options.system) messages.push({ role: 'system', content: options.system })
+      for (const m of options.messages ?? []) {
+        messages.push({ role: m?.role ?? 'user', content: flatContent(m?.content) })
+      }
+      const body = {
+        model: options.model || model,
+        messages,
+        max_tokens: options.maxTokens ?? 900,
+        stream: false,
+      }
+      const headers = { 'Content-Type': 'application/json' }
+      if (apiKey) headers.Authorization = `Bearer ${apiKey}`
+      const res = await fetch(endpoint, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: options.signal ?? undefined,
+      })
+      if (!res.ok) {
+        const detail = await res.text().catch(() => '')
+        throw new Error(`[memory-eternal] LLM ${res.status}: ${detail.slice(0, 300)}`)
+      }
+      const data = await res.json()
+      const text = data?.choices?.[0]?.message?.content ?? ''
+      if (text) yield text
+    },
+  }
+}
+
+export function createLlmFromEnv(env = process.env) {
+  const baseUrl = env.MEMORY_LLM_BASE_URL || env.OPENAI_BASE_URL || ''
+  const apiKey = env.MEMORY_LLM_KEY || env.OPENAI_API_KEY || ''
+  const model = env.MEMORY_LLM_MODEL || ''
+  if (!baseUrl || !model) return null
+  return createOpenAiLlm({ baseUrl, apiKey, model })
+}

package/lib/mcp.js

@@ -25,7 +25,9 @@ export const MCP_TOOLS = [
     name: 'memory_recall',
     description:
       '从本地记忆核心（Markdown 知识库）检索相关知识卡。需要项目背景、历史决策、之前讨论过的方案、' +
-      '或领域知识时调用；返回最相关的卡片摘要。用 query 描述要找的内容，支持中文整词与字符片段检索。',
+      '或领域知识时调用；返回最相关的卡片摘要。用 query 描述要找的内容，支持中文整词与字符片段检索。' +
+      '需要 API key / token / 令牌等**凭证**时也先查这里（查「密钥 目录」）：记忆里存的是目录' +
+      '（名字、存放位置、取用命令），**值不在记忆库里**，请按卡片给的本机命令取用，不要直接读凭据文件。',
     inputSchema: {
       type: 'object',
       properties: {

package/lib/node-bin.js

@@ -1,99 +1,99 @@
-// 记忆核心 · 子进程用的 node 可执行文件解析
-//
-// 背景（真实故障）：
-// 在 Electron 宿主里（例如 DSH Desktop），`process.execPath` 指向的是
-// Electron 主程序，而不是 node。此前 `ensureWebServer()` / watchdog / 插件的
-// 保活逻辑都用 `spawn(process.execPath, ['.../web.js', ...])` 拉起子进程，
-// 于是在 Electron 宿主下 spawn 出来的是「第二个 Electron 实例」：
-// 它不会执行 web.js，而是立刻退出（或被单实例锁挡掉），而调用方用的是
-// `stdio: 'ignore'` + `.catch(() => {})`，失败被彻底吞掉——表现就是侧边栏
-// 「记忆」弹窗里那个指向 127.0.0.1:7999 的 iframe 永远白屏。
-//
-// 本模块把「找出一个真正能跑 node 脚本的子进程入口」收敛到一处：
-//   1. MEMORY_ETERNAL_NODE 显式指定（逃生口，便于测试与非常规宿主）；
-//   2. 非 Electron 宿主：process.execPath 本身就是 node，直接用；
-//   3. Electron 宿主：优先从 PATH 找真正的 node；
-//   4. 都找不到时退回 process.execPath，并由 childEnv() 打开
-//      ELECTRON_RUN_AS_NODE，让 Electron 二进制以纯 node 模式运行。
-
-import fs from 'node:fs'
-import path from 'node:path'
-
-let cachedBinary = null
-let cachedSource = null
-
-/** 在 PATH 中查找真正的 node 可执行文件；找不到返回 null。 */
-function findNodeOnPath() {
-  const names = process.platform === 'win32' ? ['node.exe', 'node.cmd', 'node'] : ['node', 'node.exe']
-  const dirs = String(process.env.PATH || '').split(path.delimiter)
-  for (const dir of dirs) {
-    if (!dir) continue
-    for (const name of names) {
-      const candidate = path.join(dir, name)
-      try {
-        if (fs.statSync(candidate).isFile()) return candidate
-      } catch {
-        // 目录不存在或无权访问：继续找下一个
-      }
-    }
-  }
-  return null
-}
-
-/**
- * 返回用于 spawn 子进程（跑 .js 脚本）的可执行文件路径。
- * @returns {string}
- */
-export function nodeBinary() {
-  if (cachedBinary) return cachedBinary
-
-  if (process.env.MEMORY_ETERNAL_NODE) {
-    cachedBinary = process.env.MEMORY_ETERNAL_NODE
-    cachedSource = 'env'
-    return cachedBinary
-  }
-
-  if (!process.versions.electron) {
-    cachedBinary = process.execPath
-    cachedSource = 'execPath'
-    return cachedBinary
-  }
-
-  const found = findNodeOnPath()
-  if (found) {
-    cachedBinary = found
-    cachedSource = 'path'
-    return cachedBinary
-  }
-
-  cachedBinary = process.execPath
-  cachedSource = 'electron-run-as-node'
-  return cachedBinary
-}
-
-/** 说明 nodeBinary() 最终选了哪条路径（诊断用，不参与逻辑）。 */
-export function nodeBinarySource() {
-  nodeBinary()
-  return cachedSource
-}
-
-/**
- * 子进程环境：始终打开 ELECTRON_RUN_AS_NODE。
- * 真正的 node 会忽略这个变量，所以无条件设置是安全的；而当 nodeBinary()
- * 只能退回 Electron 二进制时，它就是让子进程以 node 模式运行的关键。
- * @param {Record<string, string>} [extra]
- */
-export function childEnv(extra) {
-  return { ...process.env, ...(extra || {}), ELECTRON_RUN_AS_NODE: '1' }
-}
-
-/** 是否只能依赖 Electron 二进制的 node 模式（PATH 上没有真 node）。 */
-export function usesElectronBinary() {
-  return nodeBinarySource() === 'electron-run-as-node'
-}
-
-/** 仅测试用：清掉进程内缓存。 */
-export function resetNodeBinaryCache() {
-  cachedBinary = null
-  cachedSource = null
-}
+// 记忆核心 · 子进程用的 node 可执行文件解析
+//
+// 背景（真实故障）：
+// 在 Electron 宿主里（例如 DSH Desktop），`process.execPath` 指向的是
+// Electron 主程序，而不是 node。此前 `ensureWebServer()` / watchdog / 插件的
+// 保活逻辑都用 `spawn(process.execPath, ['.../web.js', ...])` 拉起子进程，
+// 于是在 Electron 宿主下 spawn 出来的是「第二个 Electron 实例」：
+// 它不会执行 web.js，而是立刻退出（或被单实例锁挡掉），而调用方用的是
+// `stdio: 'ignore'` + `.catch(() => {})`，失败被彻底吞掉——表现就是侧边栏
+// 「记忆」弹窗里那个指向 127.0.0.1:7999 的 iframe 永远白屏。
+//
+// 本模块把「找出一个真正能跑 node 脚本的子进程入口」收敛到一处：
+//   1. MEMORY_ETERNAL_NODE 显式指定（逃生口，便于测试与非常规宿主）；
+//   2. 非 Electron 宿主：process.execPath 本身就是 node，直接用；
+//   3. Electron 宿主：优先从 PATH 找真正的 node；
+//   4. 都找不到时退回 process.execPath，并由 childEnv() 打开
+//      ELECTRON_RUN_AS_NODE，让 Electron 二进制以纯 node 模式运行。
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+let cachedBinary = null
+let cachedSource = null
+
+/** 在 PATH 中查找真正的 node 可执行文件；找不到返回 null。 */
+function findNodeOnPath() {
+  const names = process.platform === 'win32' ? ['node.exe', 'node.cmd', 'node'] : ['node', 'node.exe']
+  const dirs = String(process.env.PATH || '').split(path.delimiter)
+  for (const dir of dirs) {
+    if (!dir) continue
+    for (const name of names) {
+      const candidate = path.join(dir, name)
+      try {
+        if (fs.statSync(candidate).isFile()) return candidate
+      } catch {
+        // 目录不存在或无权访问：继续找下一个
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * 返回用于 spawn 子进程（跑 .js 脚本）的可执行文件路径。
+ * @returns {string}
+ */
+export function nodeBinary() {
+  if (cachedBinary) return cachedBinary
+
+  if (process.env.MEMORY_ETERNAL_NODE) {
+    cachedBinary = process.env.MEMORY_ETERNAL_NODE
+    cachedSource = 'env'
+    return cachedBinary
+  }
+
+  if (!process.versions.electron) {
+    cachedBinary = process.execPath
+    cachedSource = 'execPath'
+    return cachedBinary
+  }
+
+  const found = findNodeOnPath()
+  if (found) {
+    cachedBinary = found
+    cachedSource = 'path'
+    return cachedBinary
+  }
+
+  cachedBinary = process.execPath
+  cachedSource = 'electron-run-as-node'
+  return cachedBinary
+}
+
+/** 说明 nodeBinary() 最终选了哪条路径（诊断用，不参与逻辑）。 */
+export function nodeBinarySource() {
+  nodeBinary()
+  return cachedSource
+}
+
+/**
+ * 子进程环境：始终打开 ELECTRON_RUN_AS_NODE。
+ * 真正的 node 会忽略这个变量，所以无条件设置是安全的；而当 nodeBinary()
+ * 只能退回 Electron 二进制时，它就是让子进程以 node 模式运行的关键。
+ * @param {Record<string, string>} [extra]
+ */
+export function childEnv(extra) {
+  return { ...process.env, ...(extra || {}), ELECTRON_RUN_AS_NODE: '1' }
+}
+
+/** 是否只能依赖 Electron 二进制的 node 模式（PATH 上没有真 node）。 */
+export function usesElectronBinary() {
+  return nodeBinarySource() === 'electron-run-as-node'
+}
+
+/** 仅测试用：清掉进程内缓存。 */
+export function resetNodeBinaryCache() {
+  cachedBinary = null
+  cachedSource = null
+}