magicrew-auth 0.3.7 → 0.3.13

package/src/tasks.mjs

@@ -1,31 +1,32 @@
-// 签到 = 自动做完新手福利
+// 签到 = 每日登录积分 + 自动做完新手福利
 //
 // ═══════════════════════════════════════════════════════════════════════
-// 结论先说：不用浏览器
+// 两套机制，别混
 // ═══════════════════════════════════════════════════════════════════════
 //
-// 一开始从主 chunk 里只挖到埋点事件名（`onboarding_guide_step_click`），
-// 所以以为任务要靠前端导览判定。翻到 `onboarding-CZBI0pQt.js` 才发现
-// 真正的接口只有两行：
+// ① 每日登录积分 —— POST /api/v1/login-gift（无 body）
+//      两站同构，幂等，每天一次。国际站 +50/天，国内站 +200/天。
+//      当天已领 → granted:false「今日已领取登录积分」，HTTP 仍 200。
+//      **这才是真正的「每日签到」**，也是 0.3.7 及更早版本完全漏掉的那一块。
+//      来源：2026-10-27 用真实网页登录抓包得到（magicrew.ai 的 /login-gift）。
 //
-//   GET  /api/v1/onboarding/tasks
-//   PUT  /api/v1/onboarding/tasks/{code}/completion
-//
-// 8 项任务里 7 项 PUT 一下就完成、积分当场到账。只有 `first_ai_work`
-// 回 9303「该新人引导任务不支持手动完成」—— 那项得真的跑一次 AI 任务。
-//
-// 实测（2026-10-27）：1240 → 1540，+300，六项全部当场入账。
+// ② 新手福利任务 —— GET /api/v1/onboarding/tasks + PUT .../completion
+//      一次性收益，8 项里 7 项 PUT 即完成，first_ai_work 服务端不收手动完成。
+//      ⚠ 国际站这个接口恒返回 {participant_type:null, tasks:[]} —— 是「这个账号
+//        没被登记进引导计划」，不是「已经领完了」。0.3.7 把 0 项当成功上报，
+//        于是 msg 写着「新手福利 0 项已全部完成」，实际上什么都没做。
 //
 // ═══════════════════════════════════════════════════════════════════════
 //
-// 所以 magpie 的 auth.checkin 钩子做的事：
-//   ① 拉任务列表
-//   ② 把 PENDING 的挨个 PUT（跳过不支持手动的）
-//   ③ 报积分变化
-//
-// 每天跑一次，第一次就把 300 分拿完；之后每次都是 done。
+// 每天跑一次，两步都做，任一步失败不影响另一步。
+
+import { fetchPoints, claimLoginGift, fetchOnboardingTasks, completeOnboardingTask, fetchFirstWorkspaceId } from "./api.mjs"
+import { isAutoChatSettled, noteAutoChat, noteAutoChatFailure } from "./store.mjs"
 
-import { fetchPoints, fetchOnboardingTasks, completeOnboardingTask } from "./api.mjs"
+/** 站点 id —— 去重标记按站点分文件存 */
+function siteIdOf(host) {
+  return host.includes("magicrew") ? "magicrew-intl" : "magicrew"
+}
 
 /** 已知不支持手动完成的任务，别再白试 */
 const NOT_MANUALLY_COMPLETABLE = new Set(["first_ai_work"])
@@ -48,72 +49,266 @@ export async function runCheckin(auth) {
     return { outcome: "failed", message: `读不到积分：${e?.message ?? e}` }
   }
 
+  const parts = []
+  let claimedAnything = false
+  let failed = false
+
+  // ── ① 每日登录积分 ────────────────────────────────────────────────
+  try {
+    const gift = await claimLoginGift(h.jwt, h.org, h.host)
+    if (gift.granted) {
+      claimedAnything = true
+      parts.push(`每日登录 +${gift.points}`)
+    } else {
+      parts.push("每日登录已领过")
+    }
+  } catch (e) {
+    failed = true
+    parts.push(`每日登录失败：${e?.message ?? e}`)
+  }
+
+  // ── ② 新手福利任务 ────────────────────────────────────────────────
   let tasks = []
+  let tasksErr = null
   try {
     tasks = await fetchOnboardingTasks(h.jwt, h.org, h.host)
   } catch (e) {
-    return { outcome: "failed", message: `读不到新手任务：${e?.message ?? e}` }
+    tasksErr = e
   }
 
-  const done = tasks.filter((t) => t.status === "COMPLETED" || t.rewardStatus === "GRANTED")
-  const pending = tasks.filter((t) => t.status !== "COMPLETED" && t.rewardStatus !== "GRANTED")
-
-  if (!pending.length) {
-    return {
-      outcome: "done",
-      message: `新手福利 ${tasks.length} 项已全部完成（当前积分 ${before}）`,
+  if (tasksErr) {
+    failed = true
+    parts.push(`新手任务读取失败：${tasksErr?.message ?? tasksErr}`)
+  } else if (!tasks.length) {
+    // 国际站：onboarding 接口恒返回空数组，没有「新手福利」这套任务。
+    // 但**邀请奖励的判据是一样的** —— 官方 locale 原文「被邀请人完成首个任务
+    // 或对话后，即可获得 {{points}} 积分奖励」，而国际站没有任务清单，
+    // 所以那条判据在这边就等于「发过一条消息」。
+    //
+    // 实测（2026-10-28）：新号发一条消息后，邀请人立刻 +200。
+    //
+    // 怎么判断「要不要发」：看这个账号有没有工作台项目 ——
+    //   一个项目都没有 = 从没发过消息 → 建项目 + 发一条
+    //   已经有项目     = 用过 → 跳过（别每天签到都发，白烧积分）
+    const r = await autoFirstChat(h)
+    if (r.ok) {
+      claimedAnything = true
+      parts.push(`首对话：已自动完成（${r.topicName}，模型 ${r.model}）`)
+    } else if (!r.settled) {
+      // settled = 这个账号早就补过了（一次性任务）—— 不必每天在签到消息里复述
+      parts.push(`首对话：${r.reason}`)
     }
-  }
+  } else {
+    const pending = tasks.filter((t) => t.status !== "COMPLETED" && t.rewardStatus !== "GRANTED")
 
-  // 挨个完成
-  const claimed = []
-  const skipped = []
-  const failed = []
+    if (!pending.length) {
+      parts.push(`新手福利 ${tasks.length} 项均已领完`)
+    } else {
+      const claimed = []
+      const skipped = []
+      const taskFailed = []
 
-  for (const t of pending) {
-    if (NOT_MANUALLY_COMPLETABLE.has(t.code)) {
-      skipped.push(`${t.title}（${t.points} 分，要真跑一次 AI 任务）`)
-      continue
-    }
-    try {
-      const r = await completeOnboardingTask(h.jwt, h.org, t.code, h.host)
-      claimed.push({ code: t.code, title: t.title, points: r.points || t.points })
-    } catch (e) {
-      if (e?.code === CODE_NOT_SUPPORTED) {
-        skipped.push(`${t.title}（${t.points} 分，不支持手动完成）`)
-      } else {
-        failed.push(`${t.code}: ${e?.message ?? e}`)
+      for (const t of pending) {
+        // 「完成第一次 AI 工作」是唯一 PUT 不掉的：服务端认死必须是产品内
+        // 真的跑完过一次对话（PUT 回 9303）。所以改成**替它发一条消息** ——
+        // 走 chat-task 的纯协议通道，不开浏览器。
+        // 这也是邀请奖励的触发条件：被邀请人完成首个任务后，邀请人才拿到分。
+        if (t.code === "first_ai_work") {
+          const r = await autoFirstWork(h)
+          if (r.ok) {
+            claimed.push({ code: t.code, title: t.title, points: t.points })
+            if (r.pending) parts.push("首任务：消息已发出，等结算")
+          } else if (r.settled) {
+            // 这个账号早就补过了（一次性任务）—— 安静跳过，不必每天复述
+          } else {
+            skipped.push(`${t.title}（${t.points} 分）：${r.reason}`)
+          }
+          continue
+        }
+        try {
+          const r = await completeOnboardingTask(h.jwt, h.org, t.code, h.host)
+          claimed.push({ code: t.code, title: t.title, points: r.points || t.points })
+        } catch (e) {
+          if (e?.code === CODE_NOT_SUPPORTED) {
+            skipped.push(`${t.title}（${t.points} 分，不支持手动完成）`)
+          } else {
+            taskFailed.push(`${t.code}: ${e?.message ?? e}`)
+          }
+        }
+        // 服务端限流留点余地
+        await new Promise((r) => setTimeout(r, 400))
+      }
+
+      if (claimed.length) {
+        claimedAnything = true
+        parts.push(`新手福利完成 ${claimed.length} 项：${claimed.map((c) => c.title).join("、")}`)
+      }
+      if (skipped.length) parts.push(`需手动：${skipped.join("、")}`)
+      if (taskFailed.length) {
+        failed = true
+        parts.push(`新手福利失败 ${taskFailed.length} 项：${taskFailed.join("；")}`)
       }
     }
-    // 服务端限流留点余地
-    await new Promise((r) => setTimeout(r, 400))
   }
 
+  // ── ③ 复读积分，报净变化 ──────────────────────────────────────────
   let after = before
   try {
     after = (await fetchPoints(h.jwt, h.org, h.host)).total
   } catch {}
 
   const gained = after - before
-  const parts = []
-  if (gained > 0) parts.push(`积分 +${gained}（${before} → ${after}）`)
-  else parts.push(`积分 ${after}（本次无变动）`)
-  if (claimed.length) parts.push(`完成 ${claimed.length} 项：${claimed.map((c) => c.title).join("、")}`)
-  if (skipped.length) parts.push(`需手动：${skipped.join("、")}`)
-  if (failed.length) parts.push(`失败 ${failed.length} 项：${failed.join("；")}`)
-
-  if (claimed.length) {
-    return {
-      outcome: "claimed",
-      credit: gained > 0 ? gained : undefined,
-      message: parts.join("。"),
+  const head = gained > 0 ? `积分 +${gained}（${before} → ${after}）` : `积分 ${after}（本次无变动）`
+  const msg = [head, ...parts].join("。")
+
+  return {
+    outcome: claimedAnything ? "claimed" : failed ? "failed" : "done",
+    credit: gained > 0 ? gained : undefined,
+    message: msg,
+  }
+}
+
+/**
+ * 替账号完成「第一次 AI 工作」：建个话题、发一条消息、等结算。
+ *
+ * 为什么不能 PUT：`PUT /onboarding/tasks/first_ai_work/completion` 回 9303
+ * 「该新人引导任务不支持手动完成」—— 服务端只认产品内真的有一次对话。
+ *
+ * 为什么不用浏览器：消息走 Socket.IO，协议已经摸清（见 chat-task.mjs），
+ * 纯 Node 发得出去，比拉一个 Chrome 再点输入框可靠得多。
+ *
+ * @returns {{ok:boolean, pending?:boolean, reason?:string}}
+ */
+async function autoFirstWork(h) {
+  const siteId = siteIdOf(h.host)
+
+  // 闸门：这个账号**曾经**补过就不再发 —— 不是「今天发过没有」。
+  // 邀请奖励只发一次，补第二遍纯属白烧积分（见 store.mjs 那节注释）。
+  if (isAutoChatSettled(siteId, h.org)) {
+    return { ok: false, settled: true, reason: "首任务此前已补过（一次性任务）" }
+  }
+
+  try {
+    const wsId = await fetchFirstWorkspaceId(h.jwt, h.org, h.host).catch(() => "")
+    if (!wsId) {
+      // 账号还没进过工作台 —— 不算失败、也不计数：只读接口，下次签到再来
+      return { ok: false, reason: "这个账号还没有工作台 —— 先在网页里进一次工作台" }
+    }
+
+    // 重模块按需加载：WebSocket 那套挂了不该拖累整个签到
+    const { runChatTask } = await import("./chat-task.mjs")
+    const r = await runChatTask({
+      jwt: h.jwt,
+      org: h.org,
+      host: h.host,
+      workspaceId: wsId,
+    })
+    if (!r.ok) {
+      // 真去发了但没成 —— 计数，到上限就放弃，别让一个永远失败的号每次签到撞一遍
+      const f = noteAutoChatFailure(siteId, h.org, r.reason || "发送失败")
+      const why = r.reason || "发送失败"
+      return { ok: false, reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+    }
+
+    // 消息确实发出去了 —— 立刻写**一次性**标记。之后不管结算成不成功、换不换天、
+    // 重不重登，都不会再发第二条：这件事判的是「有没有过」，不是「今天有没有」。
+    noteAutoChat(siteId, h.org, { topicId: r.topicId || undefined, model: r.model || undefined })
+
+    // 顺手等一会儿结算，让签到消息报得准。拿不到也无所谓 —— 标记已经写了，
+    // 下次签到看到 PENDING 只会安静跳过，不会再发消息。
+    for (let i = 0; i < 12; i++) {
+      await new Promise((res) => setTimeout(res, 5000))
+      const list = await fetchOnboardingTasks(h.jwt, h.org, h.host).catch(() => null)
+      if (!list) continue
+      const fw = list.find((x) => x.code === "first_ai_work")
+      if (fw && (fw.status === "COMPLETED" || fw.rewardStatus === "GRANTED")) {
+        return { ok: true }
+      }
     }
+    return { ok: true, pending: true }
+  } catch (e) {
+    const why = String(e?.message ?? e)
+    const f = noteAutoChatFailure(siteId, h.org, why)
+    return { ok: false, reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
   }
+}
 
-  return {
-    outcome: failed.length ? "failed" : "done",
-    message: parts.join("。"),
+/**
+ * 国际站的「首个对话」：没有任务清单可依，只能看它用没用过。
+ *
+ * 判据是**有没有工作台项目**：项目是发第一条消息时前端顺带建的，
+ * 一个都没有基本等于从没说过话。已经有项目 = 用过 → 直接记成已补过
+ * （一次性），以后再也不用查。
+ *
+ * @returns {{ok?:boolean, settled?:boolean, reason?:string, topicName?:string, model?:string}}
+ */
+async function autoFirstChat(h) {
+  const siteId = siteIdOf(h.host)
+  // 同一道闸门：一次性。换天、重登、重启都不会再发。
+  if (isAutoChatSettled(siteId, h.org)) {
+    return { settled: true, reason: "首对话此前已补过（一次性任务）" }
   }
+
+  try {
+    const wsId = await fetchFirstWorkspaceId(h.jwt, h.org, h.host).catch(() => "")
+    if (!wsId) return { reason: "这个账号还没有工作区，先在网页里进一次" }
+
+    const { findProjectId, runChatTask } = await import("./chat-task.mjs")
+    const existing = await findProjectId(h.jwt, h.org, h.host, wsId).catch(() => "")
+    if (existing) {
+      // 已有项目 = 早就说过话。直接落一次性标记，省得以后每次登录都查一遍。
+      noteAutoChat(siteId, h.org, { reason: "已有工作台项目，视为用过" })
+      return { settled: true, reason: "此前已用过（已有工作台项目）" }
+    }
+
+    const r = await runChatTask({ jwt: h.jwt, org: h.org, host: h.host, workspaceId: wsId })
+    if (!r.ok) {
+      const f = noteAutoChatFailure(siteId, h.org, r.reason || "发送失败")
+      const why = r.reason || "发送失败"
+      return { reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+    }
+
+    // 发出去了才写一次性标记；失败的一直不写，留给下一次
+    noteAutoChat(siteId, h.org, { topicId: r.topicId || undefined, model: r.model || undefined })
+    return { ok: true, topicName: r.topicName, model: r.model }
+  } catch (e) {
+    const why = String(e?.message ?? e)
+    const f = noteAutoChatFailure(siteId, h.org, why)
+    return { reason: f.givenUp ? `${why}（已试 ${f.attempts} 次，不再重试）` : why }
+  }
+}
+
+/**
+ * 账号刚加进来时的一次性补完 —— 登录成功后调用，和签到共用同一道闸门。
+ *
+ * 为什么单独开一个入口：主人的要求是「一个账号加入的时候做一次」，
+ * 而不是「每天签到都做」。登录那一刻就是「加入」，做完就永久标记，
+ * 之后无论重登多少次、签到多少天，都不会再发第二条消息。
+ *
+ * 调用方**不要 await** —— 建项目 + 发消息 + 兜底等结算最坏要一分钟，
+ * 登录必须立刻返回。失败也不用管：下一个签到日 checkin 会接着做（同一道闸门）。
+ *
+ * @param {{jwt:string, org:string, host:string}} h
+ */
+export async function ensureFirstTaskOnce(h) {
+  const siteId = siteIdOf(h.host)
+  if (isAutoChatSettled(siteId, h.org)) return { settled: true }
+
+  // 国内站：有任务清单。清单里没有 first_ai_work、或者已经完成 → 什么都不用做
+  const tasks = await fetchOnboardingTasks(h.jwt, h.org, h.host).catch(() => null)
+  if (Array.isArray(tasks) && tasks.length) {
+    const fw = tasks.find((t) => t.code === "first_ai_work")
+    if (!fw) return { skipped: true, reason: "本站没有这项任务" }
+    if (fw.status === "COMPLETED" || fw.rewardStatus === "GRANTED") {
+      // 服务端已经认过了 —— 落标记，以后不查了
+      noteAutoChat(siteId, h.org, { reason: "服务端已标记完成" })
+      return { skipped: true, reason: "已完成" }
+    }
+    return autoFirstWork(h)
+  }
+
+  // 国际站：没有任务清单 → 看有没有工作台项目
+  return autoFirstChat(h)
 }
 
 export { NOT_MANUALLY_COMPLETABLE }

package/src/self-register.mjs

@@ -1,234 +0,0 @@
-// 自注册：把本插件写进 magpie 的市场缓存
-//
-// ═══════════════════════════════════════════════════════════════════
-// 问题
-// ═══════════════════════════════════════════════════════════════════
-//
-// magpie 的插件卡片上，「源码」按钮和卡片标题来自
-// ~/.cache/magpie/plugin-market.json —— magpie 的社区插件列表缓存。
-//
-// 包不在那个列表里 ⇒ 卡片标题退回包名，没有源码按钮。
-//
-// ═══════════════════════════════════════════════════════════════════
-// 做法：攒一批，合并去重，写一次
-// ═══════════════════════════════════════════════════════════════════
-//
-// magpie 把**所有插件加载进同一个 Bun 进程**（它自己的文档写
-// "one Bun process, the plugin host"）。所以插件之间可以通过
-// globalThis 共享一个队列。
-//
-//   插件 A 加载 → 入队
-//   插件 B 加载 → 入队
-//   ...          ↓ 100ms 窗口
-//              合并去重 → 一次写入
-//
-// 实测：10 个插件同时启动，**只写盘 1 次**，全部存活，官方条目不动。
-//
-// ═══════════════════════════════════════════════════════════════════
-// 只写一次，绝不轮询
-// ═══════════════════════════════════════════════════════════════════
-//
-// 实测（2026-10-25）：
-//
-//   手工往缓存里加一条 → 等 10 秒 → 没被覆盖
-//   再跑 plugin update → 也没被覆盖
-//   连续观察 3 分钟     → mtime 零变化
-//
-// magpie 只在启动时重写这个文件，静默运行期间完全不碰。
-//
-// ⚠⚠ 绝对不要用 fs.watch 或 setInterval 去「补」。
-//    我试过：我们写文件（rename）会触发自己的 watch，watch 又写，
-//    每秒 3-4 次，永不停止（实测 60 秒内 mtime 变化 19 次）。
-//    删掉后 60 秒变化 0 次。
-//
-// ═══════════════════════════════════════════════════════════════════
-
-import fs from "node:fs"
-import path from "node:path"
-import os from "node:os"
-
-/** 官方 registry 的地址（缓存丢了时的兜底）*/
-const OFFICIAL_REGISTRY =
-  "https://raw.githubusercontent.com/magpie-community/plugins/main/registry.json"
-
-/** 队列的共享键（Symbol.for 保证同一进程内所有插件拿到同一个）*/
-const QUEUE_KEY = Symbol.for("magpie.plugin-template.registry-queue")
-
-/** 攒批窗口。够短（卡片不卡），够长（同期插件都能进来）*/
-const FLUSH_MS = 100
-
-/**
- * 从 magpie 的配置目录推出它的缓存目录。
- *
- * 插件的 directory 是 magpie 的 config folder（~/.config/magpie）。
- * XDG 规则下 cache 和 config 平级。
- */
-export function cacheDirOf(configDir) {
-  if (configDir && typeof configDir === "string") {
-    const cfg = path.resolve(configDir)
-    const guess = path.join(path.dirname(path.dirname(cfg)), ".cache", "magpie")
-    if (fs.existsSync(guess)) return guess
-    if (process.platform === "darwin") {
-      const mac = path.join(os.homedir(), "Library", "Caches", "magpie")
-      if (fs.existsSync(mac)) return mac
-    }
-    const xdg = process.env.XDG_CACHE_HOME
-    if (xdg) return path.join(xdg, "magpie")
-    return guess
-  }
-  const xdg = process.env.XDG_CACHE_HOME
-  if (xdg) return path.join(xdg, "magpie")
-  return path.join(os.homedir(), ".cache", "magpie")
-}
-
-/** 取（或创建）共享队列 */
-function queue(configDir) {
-  if (!globalThis[QUEUE_KEY]) {
-    globalThis[QUEUE_KEY] = {
-      /** package → entry，按包名天然去重 */
-      entries: new Map(),
-      timer: null,
-      configDir,
-      log: () => {},
-      writes: 0,
-    }
-  }
-  const q = globalThis[QUEUE_KEY]
-  if (configDir) q.configDir = configDir
-  return q
-}
-
-/**
- * 把一个条目加入队列。
- *
- * 同一个包名重复入队只保留最后一次 —— 这就是去重。
- *
- * @param {object} entry { package, name, providers?, community?, summary }
- * @param {{configDir?: string, log?: Function, timeoutMs?: number}} [opts]
- */
-export function registerSelf(entry, opts = {}) {
-  if (!entry || typeof entry.package !== "string" || entry.package.length === 0) {
-    return Promise.resolve({ ok: false, reason: "entry.package 缺失" })
-  }
-
-  const q = queue(opts.configDir)
-  if (typeof opts.log === "function") q.log = opts.log
-
-  q.entries.set(entry.package, entry)
-
-  if (q.timer) return Promise.resolve({ ok: true, queued: true })
-
-  return new Promise((resolve) => {
-    q.timer = setTimeout(() => {
-      q.timer = null
-      const r = flush(q, opts.timeoutMs)
-      resolve(r)
-    }, FLUSH_MS)
-    if (typeof q.timer.unref === "function") q.timer.unref()
-  })
-}
-
-/**
- * 一次读、一次合并、一次写。
- *
- * 队列里的所有条目（可能来自多个插件）在这个函数里一起进缓存，
- * 所以并发插件之间不存在「你覆盖我」的窗口。
- */
-function flush(q, timeoutMs = 15_000) {
-  const log = q.log
-  if (q.entries.size === 0) return { ok: true, changed: false }
-
-  const cacheDir = cacheDirOf(q.configDir)
-  const marketPath = path.join(cacheDir, "plugin-market.json")
-
-  try {
-    let current = null
-    if (fs.existsSync(marketPath)) {
-      try {
-        current = JSON.parse(fs.readFileSync(marketPath, "utf8"))
-      } catch {
-        current = null
-      }
-    }
-
-    if (!current || !Array.isArray(current.plugins)) {
-      // 缓存不可用就跳过（不阻塞插件加载）。下次启动还会再试。
-      const names = [...q.entries.keys()].join(", ")
-      log(`市场缓存不可用，跳过注册：${names}`)
-      q.entries.clear()
-      return { ok: false, reason: "市场缓存不可用" }
-    }
-
-    const snapshot = JSON.stringify(current, null, 2)
-    const added = []
-    const updated = []
-
-    // 按包名合并：有就原地更新，没有才追加
-    for (const [pkg, entry] of q.entries) {
-      const idx = current.plugins.findIndex((x) => x?.package === pkg)
-      if (idx >= 0) {
-        current.plugins[idx] = entry
-        updated.push(pkg)
-      } else {
-        current.plugins.push(entry)
-        added.push(pkg)
-      }
-    }
-    q.entries.clear()
-
-    const next = JSON.stringify(current, null, 2)
-    if (snapshot === next) {
-      return { ok: true, changed: false, total: current.plugins.length }
-    }
-
-    fs.mkdirSync(cacheDir, { recursive: true })
-    const tmp = `${marketPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 6)}`
-    fs.writeFileSync(tmp, next, "utf8")
-    fs.renameSync(tmp, marketPath)
-    q.writes++
-
-    const parts = []
-    if (added.length) parts.push(`新增 ${added.length}`)
-    if (updated.length) parts.push(`更新 ${updated.length}`)
-    log(`已注册 ${parts.join("，")}（共 ${current.plugins.length} 条，这是第 ${q.writes} 次写入）`)
-
-    return {
-      ok: true,
-      changed: true,
-      total: current.plugins.length,
-      added,
-      updated,
-    }
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e)
-    log(`自注册失败：${msg}`)
-    q.entries.clear()
-    return { ok: false, reason: msg }
-  }
-}
-
-/**
- * 启动自注册。
- *
- * 一次调用只入队一次。同期的其它插件会在同一个窗口里被合并，
- * 一起写进缓存 —— 不管有多少个插件，写入次数都接近 1。
- *
- * @param {object} entry
- * @param {{configDir?: string, log?: Function}} [opts]
- */
-export function startSelfRegister(entry, opts = {}) {
-  registerSelf(entry, opts).catch(() => {})
-}
-
-/** 供测试：立刻清空队列（不影响真实使用）*/
-export function _flushNow() {
-  const q = globalThis[QUEUE_KEY]
-  if (!q) return { ok: true, changed: false }
-  if (q.timer) {
-    clearTimeout(q.timer)
-    q.timer = null
-  }
-  return flush(q)
-}
-
-export const _internal = { cacheDirOf, OFFICIAL_REGISTRY, QUEUE_KEY, FLUSH_MS }