ygc-dsh-plugin-autoupdate 0.9.5 → 1.0.0

package/README.md

@@ -278,17 +278,19 @@ Electron 的 main / gpu-process / renderer / utility，以及以 `ELECTRON_RUN_A
 ```
 D:\Ai工作空间\插件库\          ← 共享文件夹，两台机器都能读写
 ├─ <本机标识>\                  ← 我的格子，例 DSH-7e6b1bb7e052
-│  ├─ PLUGINS.json             我的插件清单（含副本指纹表）
+│  ├─ PLUGINS.json             我的插件清单（**只有清单，没有任何插件文件**）
 │  ├─ FEATURE.json             我的身份说明
 │  ├─ OTHERS-PLUGINS.json      我的汇总（本机自用）
-│  ├─ OTHERS-PLUGINS.md        同一份的人读版
-│  └─ local\                  本地 / Git 来源插件的 .tgz 副本
+│  └─ OTHERS-PLUGINS.md        同一份的人读版
 └─ <别人的标识>\               ← 别人写，我只读
    ├─ PLUGINS.json
-   ├─ FEATURE.json
-   └─ local\
+   └─ FEATURE.json
 ```
 
+> **0.9.6 起：特征文件夹只存清单，不存插件副本。** 以前这里还有 `local/` 放 .tgz，
+> 现在没有了，而且会自动清掉老版本留下的 `local/` 与散落 tgz。
+> 安装一律按清单里的「安装坐标」去 registry 联网拉取，不存在本地副本安装这条路。
+
 **没有公共分区。** 早先版本在插件库下分出「特征 / 汇集」两级子目录，那是错的：
 插件库是多人共享的盘，公共目录等于公共广场，所有人的东西往一处堆，谁的产出分不清，
 而且「汇集」会成为多方争写的热点。现在改成：
@@ -323,31 +325,45 @@ D:\Ai工作空间\插件库\          ← 共享文件夹，两台机器都能
 `POST /settings { shareResetHash: true }`——这是唯一的重算入口，其它情况一律沿用旧值。
 
 
-### 清单里写什么
+### 清单里写什么（只有清单，没有文件）
+
+每一项只有五个字段：`name` / `version` / `kind` / `installSpec` / `installable`。
 
-| 插件来源 | 清单里写什么 | 要不要打副本 |
+| 插件来源 | 安装坐标 `installSpec` | 能装吗 |
 |---|---|---|
-| `registry`（能联网更新） | 名称 + 版本 | **不打**，对方自己从 registry 拉 |
-| `local`（`file:` 本地路径） | 名称 + 版本 + 来源说明 | **打**，`local/<name>-<version>.tgz` |
-| `git`（GitHub 等） | 名称 + 版本 | **打**，同上 |
-| `installation`（随 DSH 安装提供） | **不写** | 别人本来就有，也没版本号可装 |
+| `registry`（能联网更新） | `<name>@<version>` | 能，registry 拉 |
+| `git`（GitHub 等） | 原 git 写法（`github:o/r#ref`） | 能，联网拉 |
+| `local`（`file:` 本地路径） | 空 | **不能**：未发布的东西没地方拉 |
+| `installation`（随 DSH 安装提供） | — | **不写进清单**：别人本来就有 |
+
+`PLUGINS.json` 里的 `policy` 段把这条规矩写死，别人一看就知道这份清单不含文件：
+
+```json
+{
+  "schemaVersion": 2,
+  "policy": {
+    "manifestOnly": true,
+    "storesBundles": false,
+    "installVia": "registry",
+    "note": "特征文件夹只存清单；安装一律按 installSpec 联网拉取，不使用本地副本。"
+  },
+  "plugins": [
+    { "name": "dsh-tavern", "version": "2.8.1", "kind": "registry",
+      "installSpec": "dsh-tavern@2.8.1", "installable": true }
+  ]
+}
+```
+
+历史遗留的 `local/` 与根上散落的 `*.tgz` 会在每轮同步时被删掉（删除记录写进
+`PLUGINS.json` 的 `legacyPurged`，便于排查「我的 local/ 怎么没了」）。
 
-副本是 npm 标准 tgz（`package/` 前缀），排除 `node_modules`、`.git`、`__pycache__`、`*.bak-*`。
-单包上限 96 MB，单个特征的副本总量上限 512 MB，同名插件只留最近 2 个版本。
-`link:` 装的包在 `node_modules` 下是符号链接，打包时按 `realpath` 追到真实目录。
 
-### 什么时候跑
 
 **每次巡检跑一次**——巡检 = 自动更新的那一轮定时检查（间隔见「检查频率」）。
 顺序是先查更新、再同步共享；更新失败不影响共享同步。面板上也有「立即同步一次」。
 
 每次同步都幂等：
 
-- 清单内容（除 `generatedAt` / `lastSyncAt` 这类时间字段）没变 → 不重写文件
-- 源目录指纹（文件数 + 最大 mtime + 总字节）没变 → 不重压 `.tgz`，直接复用
-- 本机标识第一次同步时固定进 state，之后每轮原样传回，不做任何重算
-
-所以几百 MB 的本地插件不会把每轮巡检拖慢。
 
 ### 拉别人的清单
 
@@ -361,28 +377,31 @@ D:\Ai工作空间\插件库\          ← 共享文件夹，两台机器都能
 
 合并去重规则：
 
-- 去重键是包名；多本特征都有同一插件时，版本取**更高**的那份（按语义版本比，不看文件时间）
-- 副本跟着最高版本走；`features` 里记下它出现在哪几本
-- 「本机有没有」按 profile 的 `dsh.profile.bundles` 判断，不看 `node_modules`（那里塞满传递依赖）
+- 去重键是包名；多本特征都有同一插件时，版本与安装坐标都取**更高**的那份（按语义版本比，不看文件时间）
+- `features` 里记下它出现在哪几本；老清单里的 `bundles` 数组一律忽略
 - 没 `PLUGINS.json` 的目录只记一条提示，不报错
 
-### 装的时候走哪条路
+### 装的时候走哪条路（只有一条：联网）
+
+| 清单里的 `installSpec` | 用的 spec | 结果 |
+|---|---|---|
+| `<name>@<version>` | 原样 | 从 registry 拉 |
+| `github:o/r#ref` 这类 git 写法 | 原样 | 联网拉 |
+| 空（`local` 来源） | — | **拒绝**，说明「对方未发布到 registry」 |
+| `file:` / `link:` 开头 | — | **拒绝**：只走 registry 联网拉取 |
+
+就算对方是老版本写的清单、里面还带着 `bundles` 数组，也一律忽略：
+拿别人打包过的旧代码装上，版本号写着新的、行为是老的那份，比装不上更难查。
 
-| 对方特征里有 | 用的 spec |
-|---|---|
-| `.tgz` 副本 | `file:<对方副本的绝对路径>`（正斜杠） |
-| 只有名称（registry 来源） | `<name>@<version>` |
-| 既没副本又不是 registry | 拒绝，说明原因 |
 
-装完自动把包名补进 profile 的 `dsh.profile.bundles`——不补的话插件装下来但不会加载。
 装之前同样会快照 profile 三个清单文件，出问题用 `/restore` 回滚。**装完必须完全退出 DSH 再重开。**
 
 ### 共享相关接口
 
 | 方法 | 路径 | 作用 |
 |---|---|---|
-| GET | `/share` | 我的特征现状 + 他人清单（含每项是否已装、有没有副本） |
-| POST | `/share/sync` | 立即同步一次（我的清单 + 副本 + 他人汇集） |
+| GET | `/share` | 我的特征现状 + 他人清单（含每项是否已装、能不能装、安装坐标） |
+| POST | `/share/sync` | 立即同步一次（我的清单 + 他人汇集；不打包任何文件） |
 | POST | `/share/install` | 安装他人清单里的一个插件（body: `{ name }`） |
 
 设置项（走 `/settings`）：`shareEnabled`、`shareLibraryRoot`、`shareFeatureName`、`shareResetHash`。
@@ -408,7 +427,7 @@ $node = "C:\DeepSeekHarness\resources\runtime\primary-runtime\dependencies\node\
 | `update-guard.test.mjs` | 只向上更新、来源判定、发布年龄门槛 |
 | `git-source.test.mjs` | Git 来源的 commit 比较与安装 spec |
 | `machine.test.mjs` | 本机标识：继承会话同步的 machineId、固定后不漂移、改名不换特征值、卸载会话同步后旧值仍有效、写边界（别人的格 / `../` 逃逸 / 前缀相近） |
-| `share.test.mjs` | 特征文件夹：清单分类（registry 只写名 / 本地打副本 / 宿主自带不写）、tgz 结构、同步幂等与副本复用、他人清单合并去重、安装路径选择、特征名防上跳 |
+| `share.test.mjs` | 特征文件夹：清单只写元数据、**目录里不允许出现任何插件文件**、历史 `local/` 被清理、同步幂等、他人清单合并去重（忽略老清单 bundles）、安装只走 registry（有副本也拒绝、`file:` 坐标也拒绝）、特征名防上跳 |
 | `schedule.test.mjs` | 定时排期：更新与共享同步各自独立开关 |
 | `system-plugins.test.mjs` | **本体插件隐藏契约**（源码级）：`isBuiltinPlugin` 判据只有一处定义、listPlugins 出口过滤并缓存隐藏名单、runCheck 不查、snapshot 再兜一层并透出 `builtin.count`、策略/更新接口对本体插件一律 400、共享清单同一判据、面板整组隐藏只留一行说明 |
 | `system-plugins.behavior.test.mjs` | **本体插件隐藏行为**（真执行 + 假宿主 + 假 profile）：`@deepseek-ai/*` 一行都不出现、第三方插件照常可写策略、`builtin.count` 数对、`pluginManager` 缺失 / 抛错 / 脏数据三种降级都不让 `/state` 失败 |
@@ -549,7 +568,7 @@ POST /api/local/plugin-autoupdate/plugin-policy  {"name":"@deepseek-ai/dsh-base"
   版本跟桌面端走，`registry` 上的同名包与它无关；策略/更新接口对它们一律 400
 - 更新失败只记历史，不自动回滚（避免把用户自己手改的清单吞掉）；要回滚用 `/restore`
 - DSH 关闭期间不检查（进程内定时器的固有限制）；重开后会立刻按上游发布时间重新判定
-- 共享只**同步清单与副本**，不自动安装别人的插件；安装必须人工点选
+- 共享只**同步清单**（不存任何插件文件），不自动安装别人的插件；安装必须人工点选，且只走 registry 联网拉取
 - 只写 `插件库\<本机标识>\` 那一格，别人的格子只读（写入口有守卫）
 - 不在插件库根下留任何公共文件或公共目录
 - **重启只认显式 pid**：任何「按映像名清场」的写法都是回归，`restart-safety.test.mjs` 会红

package/client.js

@@ -46,7 +46,6 @@ const CSS = `
 .pau-switch{display:inline-flex;align-items:center;gap:8px;font-size:13px;cursor:pointer;user-select:none}
 .pau-switch input{width:16px;height:16px;cursor:pointer}
 .pau-actions{display:flex;gap:10px;flex-wrap:wrap;align-items:center}
-.pau-share-path{font-family:ui-monospace,Menlo,Consolas,monospace;font-size:12px;word-break:break-all;color:var(--dsw-alias-label-secondary,#555)}
 .pau-tag-mine{background:var(--dsw-alias-info-tint,#e0f2fe);color:var(--dsw-alias-info,#0369a1)}
 .pau-grid{display:flex;flex-direction:column;gap:8px}
 .pau-other{display:flex;align-items:center;gap:10px;padding:8px 0;border-bottom:1px solid var(--dsw-alias-border-l25,#f0f0f0);flex-wrap:wrap}
@@ -96,7 +95,6 @@ function makePanel(React) {
 
   return function AutoUpdatePanel() {
     const [snap, setSnap] = useState(null);
-    const [shareDetail, setShareDetail] = useState(null);
     const [busy, setBusy] = useState('');
     const [error, setError] = useState('');
     const [note, setNote] = useState('');
@@ -105,18 +103,6 @@ function makePanel(React) {
     const apply = useCallback((next) => {
       if (!next) return;
       setSnap(next);
-      // 共享面板的明细单独取一次：它是扫盘结果，比状态文件重，不跟 15 秒轮询一起刷
-      if (next.share && next.share.detail) setShareDetail(next.share.detail);
-    }, []);
-
-    const loadShareDetail = useCallback(async () => {
-      try {
-        const data = await call('/share');
-        if (data && data.share && data.share.detail) setShareDetail(data.share.detail);
-        if (data) setSnap(data);
-      } catch (err) {
-        setError(String(err.message || err));
-      }
     }, []);
 
     const refresh = useCallback(async () => {
@@ -137,11 +123,6 @@ function makePanel(React) {
       };
     }, [refresh]);
 
-    useEffect(() => {
-      // 共享明细只取一次，之后靠「立即同步」/ 安装后刷新
-      loadShareDetail();
-    }, [loadShareDetail]);
-
     const run = async (name, fn) => {
       setBusy(name);
       setError('');
@@ -676,237 +657,7 @@ function makePanel(React) {
       ),
     );
 
-    const share = snap.share || {};
-    const detail = shareDetail || null;
-    const myFeature = (detail && detail.myFeature) || share.effectiveFeature || '';
-    const libRoot = (detail && detail.libraryRoot) || share.effectiveRoot || '';
-    const others = (detail && Array.isArray(detail.others) ? detail.others : []).filter((p) => !p.installed);
-    const installedFromOthers = (detail && Array.isArray(detail.others) ? detail.others : []).filter(
-      (p) => p.installed,
-    );
-    const sources = (detail && Array.isArray(detail.sources) ? detail.sources : []) || [];
 
-    const shareCard = h(
-      'div',
-      { className: 'pau-card' },
-      h(
-        'div',
-        { className: 'pau-card-h' },
-        h('h3', { className: 'pau-card-t' }, '插件共享（特征文件夹）'),
-        h(
-          'span',
-          { className: share.enabled ? 'pau-tag pau-tag-ok' : 'pau-tag' },
-          share.enabled ? '每次巡检自动同步' : '自动同步已关闭',
-        ),
-      ),
-      h(
-        'p',
-        { className: 'pau-sub' },
-        '插件库是共享文件夹，一个人一格：我的清单、本地插件副本、我自己的汇总全都写在「插件库\\<我的特征>」这一格里面。能联网更新的插件只写名称，本地/Git 来源的打成 .tgz 副本一起放过去。别人的格子只读，汇总也是各机扫一遍自己算，不放在公共位置。',
-      ),
-      h(
-        'label',
-        { className: 'pau-switch' },
-        h('input', {
-          type: 'checkbox',
-          checked: !!share.enabled,
-          onChange: (e) => patchSettings({ shareEnabled: e.target.checked }),
-        }),
-        '每次巡检顺带同步一次特征文件夹',
-      ),
-      h(
-        'div',
-        { className: 'pau-field' },
-        h('span', { className: 'pau-field-l' }, '插件库根目录'),
-        h('input', {
-          className: 'pau-input',
-          style: { minWidth: 320, flex: 1 },
-          placeholder: '留空用默认 D:\\Ai工作空间\\插件库',
-          defaultValue: share.libraryRoot || '',
-          onBlur: (e) => patchSettings({ shareLibraryRoot: e.target.value.trim() }),
-        }),
-      ),
-      h(
-        'div',
-        { className: 'pau-field' },
-        h('span', { className: 'pau-field-l' }, '我的特征文件夹名'),
-        h('input', {
-          className: 'pau-input',
-          style: { minWidth: 220 },
-          placeholder: '名称部分，留空用电脑名',
-          defaultValue: share.featureName || '',
-          onBlur: (e) => patchSettings({ shareFeatureName: e.target.value.trim() }),
-        }),
-        h(
-          'span',
-          { className: 'pau-row-d' },
-          share.machineHash ? `特征值 ${share.machineHash}（已固定，改名字不会变）` : '特征值首次同步时固定',
-        ),
-      ),
-      (detail && detail.identity && detail.identity.sharesWithSyncBackup) !== false
-        ? h(
-            'div',
-            { className: 'pau-row-d' },
-            '与会话同步插件共用同一个本机标识，两台机器之间只有「一个我」。',
-          )
-        : h(
-            'div',
-            { className: 'pau-row-d' },
-            '注意：没读到会话同步插件的标识，本插件用了自己的特征值。',
-          ),
-      h('div', { className: 'pau-row-d' }, `我的特征目录：`),
-      h('div', { className: 'pau-share-path' }, `${libRoot}${myFeature ? `\\${myFeature}` : ''}`),
-      h(
-        'div',
-        { className: 'pau-row-d' },
-        `我的汇总（只给本机看，各机自己汇集）：${myFeature ? `\\${myFeature}\\OTHERS-PLUGINS.json` : ''}`,
-      ),
-      h(
-        'div',
-        { className: 'pau-row-d', style: { marginTop: 6 } },
-        `上次同步：${fmtAgo(share.lastSyncAt)}${
-          share.lastResult
-            ? ` · 本机 ${share.lastResult.total} 个插件（副本 ${share.lastResult.bundled}，${share.lastResult.totalMb} MB） · 他人 ${share.lastResult.others} 个，可装 ${share.lastResult.installable}`
-            : ''
-        }`,
-      ),
-      share.lastError
-        ? h('div', { className: 'pau-banner pau-banner-warn', style: { marginTop: 8 } }, `上次同步失败：${share.lastError}`)
-        : null,
-      h(
-        'div',
-        { className: 'pau-actions', style: { marginTop: 12 } },
-        h(
-          'button',
-          {
-            className: 'pau-btn pau-btn-primary',
-            disabled: !!busy,
-            onClick: () =>
-              run('share-sync', async () => {
-                const next = await call('/share/sync', {});
-                const result = next.result || {};
-                if (result && result.ok === false) {
-                  setNote(`同步失败：${result.error || '未知错误'}`);
-                } else {
-                  const counts = (result.mine && result.mine.counts) || {};
-                  const others2 = (result.aggregate && result.aggregate.counts) || {};
-                  setNote(
-                    `同步完成：本机 ${counts.total || 0} 个插件（副本 ${counts.bundled || 0}），他人 ${others2.othersTotal || 0} 个，可装 ${others2.installable || 0} 个`,
-                  );
-                }
-                if (next.share && next.share.detail) setShareDetail(next.share.detail);
-                return next;
-              }),
-          },
-          busy === 'share-sync' ? '同步中…' : '立即同步一次',
-        ),
-        h(
-          'button',
-          {
-            className: 'pau-btn',
-            disabled: !!busy,
-            onClick: () => run('share-reload', async () => {
-              await loadShareDetail();
-              setNote('已重新读取特征文件夹');
-              return null;
-            }),
-          },
-          '重新读取',
-        ),
-      ),
-      h(
-        'div',
-        { className: 'pau-card-h', style: { marginTop: 18, marginBottom: 6 } },
-        h('h4', { className: 'pau-card-t' }, `他人插件（本机没有的 ${others.length} 个）`),
-        h(
-          'span',
-          { className: 'pau-row-d' },
-          sources.length ? `${sources.filter((s) => !s.mine).length} 本外部特征` : '还没有拉到别人的特征',
-        ),
-      ),
-      others.length
-        ? h(
-            'div',
-            { className: 'pau-scroll' },
-            others.map((plugin) =>
-              h(
-                'div',
-                { className: 'pau-other', key: plugin.name },
-                h(
-                  'div',
-                  { className: 'pau-other-main' },
-                  h(
-                    'div',
-                    { className: 'pau-row-t' },
-                    h('span', { className: 'pau-mono' }, plugin.name),
-                    plugin.version ? h('span', { className: 'pau-tag' }, `v${plugin.version}`) : null,
-                    h(
-                      'span',
-                      {
-                        className:
-                          plugin.bundle || plugin.kind === 'registry'
-                            ? 'pau-tag pau-tag-ok'
-                            : 'pau-tag pau-tag-warn',
-                      },
-                      plugin.bundle
-                        ? '含副本，可离线装'
-                        : plugin.kind === 'registry'
-                          ? '需联网拉取'
-                          : '无副本，装不了',
-                    ),
-                    h('span', { className: 'pau-tag pau-tag-mine' }, plugin.features.join(' / ')),
-                  ),
-                  plugin.description
-                    ? h('div', { className: 'pau-row-d' }, plugin.description.slice(0, 140))
-                    : null,
-                ),
-                h(
-                  'button',
-                  {
-                    className: 'pau-btn pau-btn-sm pau-btn-primary',
-                    disabled: !!busy || (!plugin.bundle && plugin.kind !== 'registry'),
-                    title: plugin.bundle ? `安装对方特征里的副本` : '从 registry 安装该版本',
-                    onClick: () =>
-                      run(`share-install:${plugin.name}`, async () => {
-                        const next = await call('/share/install', { name: plugin.name });
-                        setNote((next.result && next.result.message) || `${plugin.name} 已安装`);
-                        if (next.share && next.share.detail) setShareDetail(next.share.detail);
-                        return next;
-                      }),
-                  },
-                  busy === `share-install:${plugin.name}` ? '安装中…' : '安装',
-                ),
-              ),
-            ),
-          )
-        : h(
-            'div',
-            { className: 'pau-empty' },
-            sources.length ? '他人清单里的插件本机都有了' : '把别人的特征文件夹直接放进 插件库\\ 后点「重新读取」',
-          ),
-      installedFromOthers.length
-        ? h(
-            'div',
-            { className: 'pau-row-d', style: { marginTop: 10 } },
-            `已从共享装上 ${installedFromOthers.length} 个：${installedFromOthers
-              .map((p) => p.name)
-              .slice(0, 8)
-              .join('、')}${installedFromOthers.length > 8 ? ' 等' : ''}`,
-          )
-        : null,
-      (detail && detail.warnings && detail.warnings.length) || (detail && detail.myManifest && detail.myManifest.skipped && detail.myManifest.skipped.length)
-        ? h(
-            'div',
-            { className: 'pau-row-d', style: { marginTop: 10, color: 'var(--dsw-alias-warning,#a16207)' } },
-            [
-              ...((detail && detail.warnings) || []),
-              ...((detail && detail.myManifest && detail.myManifest.skipped) || []).map(
-                (item) => `${item.name}：${item.reason}`,
-              ),
-            ].slice(0, 5),
-          )
-        : null,
-    );
 
     const historyCard = h(
       'div',
@@ -939,7 +690,6 @@ function makePanel(React) {
       masterCard,
       policyCard,
       pluginsCard,
-      shareCard,
       restartCard,
       historyCard,
     );

package/index.js

@@ -38,8 +38,6 @@ import { backupProfile, installSpec, installVersion } from './lib/updater.js';
 import { gracefulHost, scheduleRestart } from './lib/restart.js';
 import { createUninstall } from './lib/uninstall.js';
 import { createApi } from './lib/api.js';
-import { installSharedPlugin, libraryRoot, shareSnapshot, syncMyFeature, writeAggregate } from './lib/share.js';
-import { resolveIdentity } from './lib/machine.js';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -259,133 +257,6 @@ export function apply(ctx, config = {}) {
     return '';
   };
 
-  /* -------------------------------------------------------------- 共享 */
-
-  /** 共享相关的设置（目录、特征名）从状态里读，面板改完立即生效。 */
-  const shareConfig = () => {
-    const state = loadState();
-    return {
-      libraryRoot: state.shareLibraryRoot || '',
-      featureName: state.shareFeatureName || '',
-      // 已固定的特征值必须原样传回：不传就会重新推导，目录会漂移
-      machineHash: state.shareMachineHash || '',
-      publishedNames: state.publishedNames || [],
-    };
-  };
-
-  /**
-   * 把本机标识固定进状态。
-   *
-   * 规则与会话同步插件一致：第一次确定后永久不变。所以只有 state 里没有特征值时
-   * 才解析一次并落盘；已有值绝不重算（哪怕主机名改了、换用户名了）。
-   */
-  const ensureIdentityFixed = () => {
-    const state = loadState();
-    if (state.shareMachineHash) return state.shareMachineHash;
-    const identity = resolveIdentity({ name: state.shareFeatureName });
-    const next = loadState();
-    next.shareMachineHash = identity.machineHash;
-    next.shareHashFixedAt = Date.now();
-    if (!next.shareFeatureName) next.shareFeatureName = identity.machineName;
-    saveState(next);
-    log(`本机标识已固定：${identity.machineId}（特征值来源：${identity.hashSource}）`);
-    return identity.machineHash;
-  };
-
-  let sharing = false;
-
-  /**
-   * 同步我自己的特征文件夹 + 汇集他人清单。
-   * 巡检每轮跑一次；面板上的「立即同步」也走这里。
-   */
-  const runShareSync = async ({ reason } = {}) => {
-    const state = loadState();
-    if (!state.shareEnabled && reason !== '手动') {
-      return { ok: true, skipped: '共享同步已关闭' };
-    }
-    if (sharing) return { ok: false, error: '正在同步中' };
-    sharing = true;
-    try {
-      // 同步前先把本机标识钉死：第一次运行时确定，之后永久不变
-      ensureIdentityFixed();
-      const config = shareConfig();
-      const mine = await syncMyFeature({
-        config,
-        publishedNames: config.publishedNames,
-        log,
-      });
-      const aggregate = writeAggregate({
-        config,
-        publishedNames: config.publishedNames,
-        log,
-      });
-      const next = loadState();
-      next.shareLastSyncAt = Date.now();
-      next.shareLastResult = {
-        feature: mine.feature,
-        root: mine.root,
-        total: mine.counts.total,
-        bundled: mine.counts.bundled,
-        skipped: mine.counts.skipped,
-        totalMb: mine.totalMb,
-        others: aggregate.doc.counts.othersTotal,
-        installable: aggregate.doc.counts.installable,
-        sources: aggregate.doc.counts.sources,
-        reason: reason || '定时',
-      };
-      next.shareLastError = '';
-      pushHistory(next, {
-        kind: 'share',
-        reason: reason || '定时',
-        text: `共享同步：本机 ${mine.counts.total} 个插件 / 副本 ${mine.counts.bundled}；他人 ${aggregate.doc.counts.othersTotal} 个，可装 ${aggregate.doc.counts.installable}`,
-      });
-      saveState(next);
-      return { ok: true, mine, aggregate: { counts: aggregate.doc.counts }, root: libraryRoot(config) };
-    } catch (error) {
-      const message = String(error?.message || error);
-      const next = loadState();
-      next.shareLastError = message;
-      pushHistory(next, { kind: 'share-failed', text: `共享同步失败：${message}` });
-      saveState(next);
-      log(`共享同步失败：${message}`);
-      return { ok: false, error: message };
-    } finally {
-      sharing = false;
-    }
-  };
-
-  const shareState = () => {
-    try {
-      ensureIdentityFixed();
-    } catch {
-      /* 标识固定失败也要能看面板（会用临时值显示） */
-    }
-    const config = shareConfig();
-    return shareSnapshot({ config, publishedNames: config.publishedNames });
-  };
-
-  /** 人工安装他人清单里的一个插件。 */
-  const installFromShare = async (name) => {
-    ensureIdentityFixed();
-    const config = shareConfig();
-    const result = await installSharedPlugin({
-      ctx,
-      config,
-      publishedNames: config.publishedNames,
-      name,
-      installSpec,
-      log,
-    });
-    const next = loadState();
-    pushHistory(next, {
-      kind: result.ok ? 'share-install' : 'share-install-failed',
-      name,
-      text: result.ok ? `从共享安装 ${name}：${result.message}` : `从共享安装 ${name} 失败：${result.message}`,
-    });
-    saveState(next);
-    return result;
-  };
-
   /* -------------------------------------------------------------- 检查 */
 
   /**
@@ -724,7 +595,6 @@ export function apply(ctx, config = {}) {
     // 两件事各自排期：自动更新按「启用 + 间隔」跑；共享同步只受它自己的开关约束。
     // 共用同一个 tick，但状态独立——用户把自动更新关掉、只想要清单同步是完全合理的。
     let updateDueAt = 0;
-    let shareDueAt = 0;
     let booted = false;
     let lastIntervalMs = 0;
 
@@ -739,7 +609,6 @@ export function apply(ctx, config = {}) {
           booted = true;
           // 开机首跑稍晚，避开启动高峰
           updateDueAt = state.enabled ? Date.now() + 20 * 1000 : 0;
-          shareDueAt = state.shareEnabled ? Date.now() + 40 * 1000 : 0;
           lastIntervalMs = intervalMsOf(state);
           return;
         }
@@ -764,18 +633,6 @@ export function apply(ctx, config = {}) {
           }
         }
 
-        // ---- 共享同步：每次巡检跑一次 ----
-        if (!state.shareEnabled) {
-          shareDueAt = 0;
-        } else {
-          if (!shareDueAt) shareDueAt = Date.now() + 1000;
-          if (Date.now() >= shareDueAt) {
-            shareDueAt = Date.now() + intervalMs;
-            runShareSync({ reason: '定时' }).catch((error) =>
-              log(`共享同步失败：${error?.message || error}`),
-            );
-          }
-        }
       } catch (error) {
         log(`调度失败：${error?.message || error}`);
       }
@@ -876,9 +733,6 @@ export function apply(ctx, config = {}) {
     requestRestart,
     isBusy,
     log,
-    runShareSync,
-    shareState,
-    installFromShare,
     // 卸载：走宿主官方 pluginManager.removeBundle，本插件不自己改清单/包目录
     uninstall: createUninstall({
       getManager: () => {