memory-eternal 0.1.0

package/lib/watchdog.js

@@ -0,0 +1,201 @@
+// 记忆核心 · 看门狗（独立进程保活 lib/web.js）。
+//
+// 用法（经 CLI）：dsh-memory watchdog [--port 7999] [--interval 5] [--max-restart 10]
+//
+// 行为：
+// - 启动时探测端口：活则只监督不接管；死则 spawn 新 web server
+// - 周期性探活：HTTP GET /memory-eternal/api/overview（不是我们服务视为死）
+// - 探到死：清理残留进程 → spawn 新 web server → restart 计数 +1
+// - restart 超过 max-restart（默认 10）→ fatal 退出，不再保活
+// - SIGINT/SIGTERM：优雅退出（停掉 watchdog 自己拉起的 web，但不动用户手动起的）
+// - 所有状态输出到 stderr（看门狗 daemon 的标准约定）
+//
+// 独立性：watchdog 完全独立于 DSH 宿主——即便旧版插件（无 autoWeb）跑的
+// DSH 环境，watchdog 也能拉起并保活 web server，让浏览器始终可达。
+
+import http from 'node:http'
+import net from 'node:net'
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import process from 'node:process'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const WEB_JS = path.join(__dirname, 'web.js')
+const API_PREFIX = '/memory-eternal/api'
+
+const ts = () => new Date().toISOString().slice(11, 19) // HH:MM:SS
+const log = (...args) => process.stderr.write(`[${ts()}] [watchdog] ${args.join(' ')}\n`)
+
+/** 探测某端口是否在响应 + 是我们的服务（响应含 vaultDir 标记）。 */
+export async function probe(port, timeoutMs = 1000) {
+  return new Promise((resolve) => {
+    const req = http.request({ host: '127.0.0.1', port, path: `${API_PREFIX}/overview`, method: 'GET', timeout: timeoutMs }, (res) => {
+      if (res.statusCode !== 200) return resolve(null)
+      const chunks = []
+      res.on('data', (c) => chunks.push(c))
+      res.on('end', () => {
+        try {
+          const data = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+          if (data && data.ok === true && typeof data.vaultDir === 'string') return resolve(data)
+          resolve(null)
+        } catch { resolve(null) }
+      })
+      res.on('error', () => resolve(null))
+    })
+    req.on('error', () => resolve(null))
+    req.on('timeout', () => { req.destroy(); resolve(null) })
+    req.end()
+  })
+}
+
+/** 探测端口是否有任何 TCP 监听（即便不是我们的服务也占用）。 */
+export async function probeTcp(port, timeoutMs = 600) {
+  return new Promise((resolve) => {
+    const s = new net.Socket()
+    s.setTimeout(timeoutMs)
+    s.once('connect', () => { s.destroy(); resolve(true) })
+    s.once('timeout', () => { s.destroy(); resolve(false) })
+    s.once('error', () => resolve(false))
+    s.connect(port, '127.0.0.1')
+  })
+}
+
+/**
+ * 启动看门狗。返回对象含 .stop() 优雅退出。
+ * @param {object} opts
+ * @param {number} [opts.port=7999]
+ * @param {string} [opts.vaultRoot]    // 默认 ~/.dsh/memory-vault
+ * @param {number} [opts.interval=5000]
+ * @param {number} [opts.maxRestart=10]
+ * @param {boolean} [opts.autoStart=true]  // 首次探测到死时是否自动拉起
+ */
+export function startWatchdog({ port = 7999, vaultRoot, interval = 5000, maxRestart = 10, autoStart = true } = {}) {
+  let child = null   // 我们 spawn 的 web 进程
+  let ownedByUs = false
+  let restartCount = 0
+  let stopped = false
+  let timer = null
+
+  // 找空闲端口：port, port+1, ... 最多 +10
+  const findFreePort = async (start) => {
+    for (let p = start; p < start + 10; p++) {
+      if (await probeTcp(p) === false) return p
+    }
+    return start
+  }
+
+  const spawnWeb = async () => {
+    if (child && !child.killed) {
+      try { child.kill('SIGTERM') } catch {}
+    }
+    const targetPort = await findFreePort(port)
+    const args = [WEB_JS, '--port', String(targetPort)]
+    if (vaultRoot) args.push('--vault', vaultRoot)
+    log(`spawn web: node ${args.join(' ')}`)
+    const c = spawn(process.execPath, args, {
+      detached: true,
+      stdio: 'ignore',
+      env: { ...process.env, MEMORY_VAULT_DIR: vaultRoot || process.env.MEMORY_VAULT_DIR || '' },
+      windowsHide: true,
+    })
+    c.on('exit', (code, sig) => {
+      if (!stopped && code !== 0) log(`web exited code=${code} sig=${sig}`)
+    })
+    c.unref()
+    child = c
+    ownedByUs = true
+    return targetPort
+  }
+
+  const tick = async () => {
+    if (stopped) return
+    const alive = await probe(port)
+    if (alive) {
+      // 是我们的服务
+      if (!ownedByUs) {
+        log(`port ${port} 已存活（外部实例）→ 切换为保活模式（不接管）`)
+        ownedByUs = true // 至少逻辑上"知道"它活了
+      }
+      return
+    }
+    // 端口死
+    if (restartCount >= maxRestart) {
+      log(`restart 次数达上限 ${maxRestart} → 退出看门狗（请人工排查）`)
+      stop()
+      return
+    }
+    if (!autoStart) {
+      log(`port ${port} 已死，但 --no-restart 设置，跳过`)
+      return
+    }
+    restartCount += 1
+    log(`port ${port} 离线 → 第 ${restartCount} 次拉起 web server`)
+    try {
+      const newPort = await spawnWeb()
+      // 等待 ready
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 500))
+        const a = await probe(newPort)
+        if (a) {
+          log(`web 在 ${newPort} 就绪（vault: ${a.vaultDir}）`)
+          if (newPort !== port) log(`提示：目标端口 ${port} 被占，watchdog 在 ${newPort} 上保活`)
+          return
+        }
+      }
+      log(`web 未能在 15s 内就绪`)
+    } catch (error) {
+      log(`spawn 失败：${error?.message || error}`)
+    }
+  }
+
+  const stop = () => {
+    if (stopped) return
+    stopped = true
+    if (timer) { clearInterval(timer); timer = null }
+    if (child && !child.killed) {
+      try { child.kill('SIGTERM') } catch {}
+      setTimeout(() => { try { child && child.kill('SIGKILL') } catch {} }, 1000).unref()
+    }
+    log('看门狗退出')
+    process.exit(0)
+  }
+
+  // 首次探测
+  ;(async () => {
+    const alive = await probe(port)
+    if (alive) {
+      log(`port ${port} 已活（外部实例），启动保活监督（间隔 ${interval}ms）`)
+    } else if (autoStart) {
+      log(`port ${port} 离线 → 首次拉起 web`)
+      restartCount += 1
+      try {
+        const np = await spawnWeb()
+        for (let i = 0; i < 30; i++) {
+          await new Promise((r) => setTimeout(r, 500))
+          if (await probe(np)) { log(`web 在 ${np} 就绪`); break }
+        }
+      } catch (e) { log(`首次拉起失败：${e?.message || e}`) }
+    }
+    timer = setInterval(tick, interval)
+  })()
+
+  process.on('SIGINT', stop)
+  process.on('SIGTERM', stop)
+  return { stop, get port() { return port }, get restartCount() { return restartCount } }
+}
+
+// 脚本入口：node lib/watchdog.js [--port N] [--interval MS] [--max-restart N] [--vault DIR]
+if (process.argv[1] && /[\\/]watchdog\.js$/.test(process.argv[1])) {
+  const argv = process.argv.slice(2)
+  const argOf = (name) => {
+    const i = argv.indexOf(name)
+    return i >= 0 && i + 1 < argv.length ? argv[i + 1] : null
+  }
+  const port = Number(argOf('--port')) || 7999
+  const interval = Number(argOf('--interval')) || 5000
+  const maxRestart = Number(argOf('--max-restart')) || 10
+  const vaultRoot = argOf('--vault') || undefined
+  const autoStart = !argv.includes('--no-restart')
+  startWatchdog({ port, interval, maxRestart, vaultRoot, autoStart })
+}

package/lib/web.js

@@ -0,0 +1,149 @@
+// 记忆核心 · 独立 Web server（UI 唯一真源）。
+//
+// 职责：
+// - 静态服务 web/index.html + web/app.js（自包含 bundle，react 打入）
+// - 同源挂载 /memory-eternal/api/*（复用 lib/api.js，与 DSH 内完全同一实现）
+// - iframe 友好：不设 X-Frame-Options（DSH 宿主内嵌加载本页）
+//
+// 常驻方式：ensureWebServer() 探活 → 未活则 detached spawn 独立进程
+// （DSH 插件激活 / MCP server 启动 / CLI 调用都会走它，实现「默认开启」）。
+//
+// 直接运行：node lib/web.js --port 7999 [--vault <dir>]
+
+import http from 'node:http'
+import { promises as fs, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { createApi, API_PREFIX } from './api.js'
+import { defaultVaultDir, configFilePath } from './capture-run.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const WEB_ROOT = path.join(__dirname, '..', 'web')
+export const DEFAULT_WEB_PORT = Number(process.env.MEMORY_WEB_PORT) || 7999
+const VERSION = (() => { try { return JSON.parse(readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version } catch { return '' } })()
+process.env.MEMORY_ETERNAL_VERSION = VERSION
+
+const MIME = { '.html': 'text/html; charset=utf-8', '.js': 'application/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8' }
+
+export function startWebServer({ port = DEFAULT_WEB_PORT, vaultRoot = defaultVaultDir(), host = '127.0.0.1' } = {}) {
+  const handleApi = createApi({
+    vaultDir: () => vaultRoot,
+    vaultRoots: () => [{ name: '', root: vaultRoot }],
+    // 读 DSH 写入的共享配置文件 → web 端与 DSH 设置同步（不同步修复）
+    getSettings: () => { try { return JSON.parse(readFileSync(configFilePath(process.env), 'utf8')) } catch { return {} } },
+    getDshInfo: () => ({ name: 'deepseek-harness', label: 'DeepSeek Harness（当前宿主）', installed: true, memoryRecallTool: true, autoCapture: true, autoRecall: true, vaultDir: vaultRoot, version: VERSION }),
+  })
+
+  const server = http.createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url, 'http://localhost')
+      const p = url.pathname
+      if (p.startsWith(API_PREFIX)) return await handleApi(req, res)
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.writeHead(405, { 'Content-Type': 'application/json' })
+        return res.end(JSON.stringify({ ok: false, error: 'method not allowed' }))
+      }
+      if (p === '/' || p === '/index.html') {
+        const buf = await fs.readFile(path.join(WEB_ROOT, 'index.html'))
+        res.writeHead(200, { 'Content-Type': MIME['.html'], 'Cache-Control': 'no-store' })
+        return res.end(buf)
+      }
+      if (p === '/app.js') {
+        const buf = await fs.readFile(path.join(WEB_ROOT, 'app.js'))
+        res.writeHead(200, { 'Content-Type': MIME['.js'], 'Cache-Control': 'no-store' })
+        return res.end(buf)
+      }
+      res.writeHead(404, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ ok: false, error: 'not found' }))
+    } catch (error) {
+      if (!res.headersSent) res.writeHead(500, { 'Content-Type': 'application/json' })
+      res.end(JSON.stringify({ ok: false, error: String(error?.message || error) }))
+    }
+  })
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(port, host, () => {
+      process.stderr.write(`[memory-eternal] web server on http://${host}:${port} (vault: ${vaultRoot})\n`)
+      resolve({ server, port, host, url: `http://${host}:${port}` })
+    })
+  })
+}
+
+/** 探测某端口是否已是本项目的 web server（响应 /api/overview 且带 vaultDir 标记）。 */
+export async function probeWebServer(port = DEFAULT_WEB_PORT, timeoutMs = 800) {
+  try {
+    const res = await fetch(`http://127.0.0.1:${port}${API_PREFIX}/overview`, { signal: AbortSignal.timeout(timeoutMs) })
+    if (!res.ok) return null
+    const data = await res.json()
+    if (data && data.ok === true && typeof data.vaultDir === 'string') return data
+    return null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 确保 web server 存活（默认开启的实现核心）。
+ * 已活 → 直接返回 URL；未活 → detached spawn 独立进程并轮询探活。
+ * 端口被非本项目进程占用时向后漂移（+1..+10）。
+ * @returns {Promise<{url:string, port:number, spawned:boolean}>}
+ */
+export async function ensureWebServer({ port = DEFAULT_WEB_PORT, vaultRoot = defaultVaultDir(), spawnEnv = {}, totalTimeoutMs = 15000 } = {}) {
+  // 探测可用端口：先找「已是我们的服务」的端口，再找空闲端口
+  let target = port
+  let found = null
+  for (let p = port; p < port + 10; p++) {
+    const alive = await probeWebServer(p)
+    if (alive) { found = { url: `http://127.0.0.1:${p}`, port: p, spawned: false }; break }
+    // 该端口不是我们的服务：若连不上（空闲）就用它；连得上但不是我们的（被占用）则漂移
+    const isFree = await probeWebServer(p, 300) === null && await isPortConnectable(p) === false
+    if (isFree) { target = p; break }
+    target = p + 1
+  }
+  if (found) return found
+
+  // detached spawn：独立进程，父进程退出不影响（常驻）；stdio ignore 防阻塞
+  const { spawn } = await import('node:child_process')
+  const child = spawn(
+    process.execPath,
+    [path.join(__dirname, 'web.js'), '--port', String(target), '--vault', vaultRoot],
+    { detached: true, stdio: 'ignore', env: { ...process.env, ...spawnEnv, MEMORY_VAULT_DIR: vaultRoot }, windowsHide: true },
+  )
+  child.unref()
+
+  const deadline = Date.now() + totalTimeoutMs
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 400))
+    const alive = await probeWebServer(target)
+    if (alive) return { url: `http://127.0.0.1:${target}`, port: target, spawned: true }
+  }
+  throw new Error(`[memory-eternal] web server 未能在 ${totalTimeoutMs}ms 内就绪 (port ${target})`)
+}
+
+async function isPortConnectable(port) {
+  const net = await import('node:net')
+  return new Promise((resolve) => {
+    const s = new net.Socket()
+    s.setTimeout(300)
+    s.once('connect', () => { s.destroy(); resolve(true) })
+    s.once('timeout', () => { s.destroy(); resolve(false) })
+    s.once('error', () => resolve(false))
+    s.connect(port, '127.0.0.1')
+  })
+}
+
+// -- 脚本入口 -----------------------------------------------------------------
+const argv = process.argv.slice(2)
+const argOf = (name) => {
+  const i = argv.indexOf(name)
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : null
+}
+if (process.argv[1] && /[\\/]web\.js$/.test(process.argv[1])) {
+  const port = Number(argOf('--port')) || DEFAULT_WEB_PORT
+  const vault = argOf('--vault') || defaultVaultDir()
+  startWebServer({ port, vaultRoot: path.resolve(vault) })
+  // 常驻：不主动退出；Ctrl+C / 进程被杀即停
+  process.on('SIGINT', () => process.exit(0))
+  process.on('SIGTERM', () => process.exit(0))
+}

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "memory-eternal",
+  "version": "0.1.0",
+  "description": "记忆核心（Memory Eternal）：自研的 DeepSeek Harness 记忆插件，不移植任何既有记忆框架——对话结束后自动沉淀知识卡到本地 Markdown Vault（自研去重、自研 CJK 检索、可 git 管理），设置页提供图形化知识库（统计 / 搜索 / 知识图谱 + 侧边栏一键弹窗），Agent 通过 memory_recall 工具按需召回历史上下文。零人工干预。",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/EternalNight996/memory-eternal.git"
+  },
+  "homepage": "https://github.com/EternalNight996/memory-eternal",
+  "author": "EternalNight996",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "dsh-memory": "bin/dsh-memory.mjs"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "lib",
+    "bin",
+    "web",
+    "hooks",
+    "skills",
+    ".claude-plugin",
+    ".codex-plugin",
+    ".cursor-plugin",
+    ".mcp.json",
+    "cordis.patch.yml",
+    "README.md",
+    "README.en.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "plugin",
+    "memory",
+    "knowledge-base",
+    "vault",
+    "markdown",
+    "knowledge-graph",
+    "rag",
+    "second-brain"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "build:client": "node build.mjs",
+    "prepublishOnly": "node build.mjs",
+    "test": "node tests/vault.test.mjs && node tests/capture.test.mjs && node tests/api.test.mjs"
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-llm": ">=0.1.0-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-tools": ">=0.1.0-rc.2 <0.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.1",
+    "esbuild": "^0.24.0",
+    "react": "18.3.1",
+    "react-dom": "18.3.1"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-api-remotes"
+      ]
+    },
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "marketplace": {
+      "profiles": [
+        "web"
+      ],
+      "requiresBuildApproval": false,
+      "requiresRestart": true,
+      "manualSteps": false
+    }
+  }
+}

package/skills/memory-recall/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: memory
+description: Recall relevant knowledge cards from the unified memory vault and capture durable findings. Use memory_recall before answering when prior context helps; call memory_capture when a session produces a durable insight.
+---
+
+# Memory Eternal
+
+This agent has access to `memory_recall` (retrieve cards) and `memory_capture` (store a card) via the `memory` MCP server.
+
+## When to recall
+Before answering when the user's question may depend on prior project decisions, past bugs, or preferences. Combine with `memory_stats` to gauge coverage.
+
+## When to capture
+At the end of a session that produced a durable, reusable conclusion (a fix, a decision, an architecture rationale, a constraint). Capture concise findings rather than raw transcripts; the hook also auto-captures at session end into the same vault (pending → audit). Source attribution is automatic.