dsh-fish-memory 0.0.0-stage → 1.4.3

package/lib/selfupdate.mjs

@@ -0,0 +1,151 @@
+// 插件自查更新 —— 查的是**这个插件自己的仓库**
+//
+// 每个插件在自己设置页放一个「检查更新」，点一下就去自己的仓库看 package.json 里的版本。
+//
+// 原则：
+//   · 仓库地址从包里自己的 package.json 读（`repository`），不在代码里写死
+//   · 只查，不装不删 —— 更新命令交给用户自己复制去跑
+//   · **查不到要如实说"查不到"，绝不能显示成"已是最新"**
+//   · 结果缓存 6 小时；点按钮（refresh）就绕过缓存
+//
+// ⚠ 内容会进客户端的一份说明：这个文件是**复制多份**到各个插件里的同一份实现，
+//   只在这一个地方改了，记得同步给其它插件（别各改各的）。
+
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const TTL = 6 * 3600 * 1000
+const TIMEOUT = 8000
+
+function parseVer(v) {
+  const s = String(v || '').trim().replace(/^v/i, '')
+  const cut = s.indexOf('-')
+  const core = cut >= 0 ? s.slice(0, cut) : s
+  const pre = cut >= 0 ? s.slice(cut + 1) : ''
+  const nums = core.split('.').map((x) => Number(x) || 0)
+  return { nums: [nums[0] || 0, nums[1] || 0, nums[2] || 0], pre }
+}
+
+// 1.2.3 / v1.2.3 / 1.2.3-beta.1 都认
+export function cmpVer(a, b) {
+  const x = parseVer(a)
+  const y = parseVer(b)
+  for (let i = 0; i < 3; i++) {
+    if (x.nums[i] !== y.nums[i]) return x.nums[i] > y.nums[i] ? 1 : -1
+  }
+  if (x.pre === y.pre) return 0
+  if (!x.pre) return 1   // 正式版比预发布新
+  if (!y.pre) return -1
+  return x.pre > y.pre ? 1 : -1
+}
+
+function rawUrls(repo) {
+  const s = String(repo || '').trim()
+  const m = /github\.com[/:]([^/]+)\/([^/#?]+)/i.exec(s)
+  if (!m) return []
+  const owner = m[1]
+  const name = m[2].replace(/\.git$/i, '')
+  return [
+    `https://raw.githubusercontent.com/${owner}/${name}/HEAD/package.json`,
+    // 备用：jsDelivr 也能读 GitHub，但**有缓存**，可能滞后 —— 消息里会标出来
+    `https://cdn.jsdelivr.net/gh/${owner}/${name}@main/package.json`,
+  ]
+}
+
+export function createSelfUpdate({ packageRoot, diag }) {
+  const noop = () => {}
+  const log = typeof diag === 'function' ? diag : noop
+
+  let meta = {}
+  try {
+    meta = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8'))
+  } catch (e) {
+    log('读自己的 package.json 失败：' + (e && e.message))
+  }
+
+  const current = String(meta.version || '')
+  const repo = String(
+    (meta.repository && (meta.repository.url || meta.repository)) || meta.homepage || ''
+  )
+  const repoUrl = repo
+    .replace(/^git\+/, '')
+    .replace(/^git:/, 'https:')
+    .replace(/\.git$/, '')
+    .replace(/#readme$/i, '')
+
+  let cache = null
+
+  async function fetchLatest() {
+    const urls = rawUrls(repo)
+    if (!urls.length) return { latest: null, error: '包里没写 GitHub 仓库地址，没法查' }
+    let lastErr = ''
+    for (const url of urls) {
+      try {
+        const res = await fetch(url, {
+          signal: AbortSignal.timeout(TIMEOUT),
+          headers: { accept: 'application/json', 'user-agent': 'dsh-plugin-selfupdate' },
+        })
+        if (!res.ok) { lastErr = 'HTTP ' + res.status; continue }
+        const j = await res.json()
+        if (!j || !j.version) { lastErr = '仓库里的 package.json 没有 version'; continue }
+        return {
+          latest: String(j.version),
+          from: url.includes('jsdelivr') ? 'jsDelivr（有缓存，可能滞后）' : 'GitHub',
+        }
+      } catch (e) {
+        lastErr = String((e && e.message) || e)
+      }
+    }
+    return { latest: null, error: lastErr || '查询失败' }
+  }
+
+  async function check(force) {
+    if (!force && cache && Date.now() - cache.checkedAt < TTL) return { ...cache, cached: true }
+    const r = await fetchLatest()
+    const hasUpdate = Boolean(r.latest && current && cmpVer(r.latest, current) > 0)
+    cache = {
+      ok: Boolean(r.latest),
+      current,
+      latest: r.latest || null,
+      hasUpdate,
+      // 本机比仓库还新 —— 自己改过还没推，正常
+      ahead: Boolean(r.latest && current && cmpVer(r.latest, current) < 0),
+      error: r.error || null,
+      from: r.from || null,
+      repoUrl: repoUrl || null,
+      checkedAt: Date.now(),
+    }
+    log('查更新：当前 ' + current + ' / 最新 ' + (r.latest || '查不到') + (r.error ? '（' + r.error + '）' : ''))
+    return cache
+  }
+
+  function register(ctx, route) {
+    try {
+      ctx.effect(() => ctx.webServer.register({
+        kind: 'exact',
+        path: route + '/update',
+        handler: async (req, res) => {
+          const send = (code, obj) => {
+            res.writeHead(code, {
+              'content-type': 'application/json; charset=utf-8',
+              'cache-control': 'no-store',
+            })
+            res.end(JSON.stringify(obj))
+          }
+          try {
+            const url = new URL(req.url, 'http://127.0.0.1')
+            const force = url.searchParams.get('refresh') === '1'
+            send(200, { ok: true, ...(await check(force)) })
+          } catch (e) {
+            log('查更新路由失败：' + (e && e.message))
+            send(200, { ok: false, current, latest: null, error: String((e && e.message) || e) })
+          }
+        },
+      }))
+    } catch (e) {
+      log('查更新路由注册失败：' + (e && e.message))
+    }
+  }
+
+  return { current, repo, repoUrl, check, register }
+}

package/lib/store-merge.mjs

@@ -0,0 +1,31 @@
+// 纯合并逻辑：不访问磁盘、宿主或模型，便于复现后台旧快照与删除交错。
+export function 合并库(盘, 写, 选项 = {}) {
+  const 更新时间 = (m) => Math.max(
+    Date.parse(m.editedAt || 0) || 0,
+    Date.parse(m.relatedAt || 0) || 0,
+    Date.parse(m.reinforcedAt || 0) || 0,
+    Date.parse(m.deletedAt || 0) || 0,
+    Date.parse(m.createdAt || 0) || 0,
+  )
+  const 写记 = new Map((写.memories || []).map((m) => [String(m.id), m]))
+  const 合记 = new Map((盘.memories || []).map((m) => [String(m.id), m]))
+  for (const [id, m] of 写记) {
+    const 旧 = 合记.get(id)
+    合记.set(id, !旧 || 更新时间(m) >= 更新时间(旧) ? m : 旧)
+  }
+  const 删们 = new Map((盘.deleted || []).map((m) => [String(m.id), m]))
+  for (const m of 写.deleted || []) 删们.set(String(m.id), m)
+  // 内存里仍有一条，不等于用户要求找回。只有同步找回入口显式列出的 id 能撤销删除。
+  const 找回 = Array.isArray(选项?.restoreIds) ? 选项.restoreIds : []
+  for (const value of 找回) {
+    const id = String(value)
+    if (写记.has(id)) 删们.delete(id)
+  }
+  const memories = [...合记.values()].filter((m) => !删们.has(String(m.id)))
+  const 记录表 = new Map()
+  const 键 = (t) => String(t && t.at) + '|' + String((t && t.query) || '').slice(0, 80)
+  for (const t of 写.traces || []) 记录表.set(键(t), t)
+  for (const t of 盘.traces || []) if (!记录表.has(键(t))) 记录表.set(键(t), t)
+  const traces = [...记录表.values()].sort((a, b) => (a.at || 0) - (b.at || 0)).slice(-100)
+  return { version: 2, policy: 写.policy || 盘.policy, memories, traces, deleted: [...删们.values()] }
+}