@geoly-ai/skills-hub 0.3.7 → 0.3.8

package/src/cli.mjs

@@ -37,7 +37,10 @@ const HELP = `skills-hub —— geoly skill 分发（M1 + M2 的命令面）
                                      \`--yes\` 只表示**确认了那个风险**，不跳过任何校验。
 
   stats [--json] [--export <file>]   本地埋点报表
-  telemetry <status|flush>           埋点/上报开关与队列
+  telemetry <status|flush|on|off|delete>
+                                     埋点开关、队列、身份三项的退出；delete 先向服务端申请删除
+                                     已发出的身份记录（--offline / GEOLY_TELEMETRY=0 /
+                                     GEOLY_TELEMETRY_UPLOAD=0 下不出网），再清本机
 
 全局 flag（09-cli.md §2）：
   --clients <list>            默认 = 本机已存在的全部；含未安装 client 是硬错误
@@ -65,7 +68,7 @@ const HELP = `skills-hub —— geoly skill 分发（M1 + M2 的命令面）
 
 埋点（docs/telemetry/00-spec.md）：
   🔴 上报**默认开**（有内置默认端点）。**install 成功收尾后**会静默发一次
-     （24 小时最多一次，超时 1 秒，失败不影响安装）；别的命令只写本地，
+     （24 小时最多一次，超时 3 秒，失败后 1 小时可再试，不影响安装）；别的命令只写本地，
      也可以随时 \`telemetry flush\` 手动发。
      采集面是穷举白名单 —— 不含路径、目录清单、文件内容、用户名。
   GEOLY_TELEMETRY=0           完全关闭：本地一个字节都不写
@@ -156,9 +159,19 @@ export async function main(argv, deps = {}) {
     return EXIT.OK;
   }
 
-  // 埋点两个子命令是纯本地的，不需要快照/锁/target
+  // 埋点两个子命令是纯本地的，不需要快照/锁/target。
+  // 🔴 **但它们照样要守输出契约**：早先 telemetry 那条在顶层 try/catch 之外，
+  //    于是 `telemetry delete --json` 在状态目录不存在时抛 ERR_SQLITE_ERROR，
+  //    stdout / stderr 双双为空 —— 调用方拿到一个非零退出码和零个字节
+  //    （Codex 2026-09-09 实测复现）。这里补一层：异常按 §7 的错误形状出。
   if (cmd === 'stats') return cmdStats(rest.slice(1), globals, stdout, stderr);
-  if (cmd === 'telemetry') return cmdTelemetry(rest.slice(1), stdout, stderr);
+  if (cmd === 'telemetry') {
+    try {
+      return await cmdTelemetry(rest.slice(1), globals, out, stdout, stderr);
+    } catch (err) {
+      return out.emitError('telemetry', classify(err), err);
+    }
+  }
 
   const load = COMMANDS[cmd];
   if (!load) {
@@ -187,9 +200,9 @@ export async function main(argv, deps = {}) {
     //        不是靠记得写 if，而是靠控制流。
     //
     // 🔴 这里 `await`，不是发了就不管：进程一退，在途的 POST 就没了。
-    //    ⚠️ 代价是**这一次 install 会等它**。网络那一段有 1 秒上界
+    //    ⚠️ 代价是**这一次 install 会等它**。网络那一段有 3 秒上界
     //    （AUTO_UPLOAD_TIMEOUT_MS），但**整段没有**：认领戳的 fsync、上报锁、
-    //    stage/reap 都是超时之外的同步 I/O。别把「最多多 1 秒」说成整体保证
+    //    stage/reap 都是超时之外的同步 I/O。别把「最多多 3 秒」说成整体保证
     //    （规格 §5.1.1 已按实话改写）。
     //
     // 🔴 返回值**故意丢弃**：不打印、不改退出码。一次成功的 install 绝不能
@@ -235,6 +248,9 @@ async function noticeOnce(stderr) {
     let url = null;
     try { url = endpoint(); } catch { return; }         // 端点配坏了 = 不会出网
     tm.maybeNoticeUpload((s) => stderr.write(s), url);
+    // 🔴 身份告知是**另一段**：只有在有人显式打开身份采集时才打。
+    //    它同时是 identityEnabled() 的硬前置 —— 没打过就一项都不采。
+    tm.maybeNoticeIdentity((s) => stderr.write(s), url);
   } catch { /* 告知不是主命令的一部分（T-5） */ }
 }
 
@@ -278,13 +294,35 @@ async function cmdStats(args, globals, stdout, stderr) {
   return EXIT.OK;
 }
 
-async function cmdTelemetry(args, stdout, stderr) {
+// `--json` 是**全局** flag，解析后放在 globals 里、已经从 args 里摘走了 ——
+// 所以这里读 globals.json，不是 args.includes('--json')。
+// ⚠️ 我第一版就是写成后者，跑出来一点反应都没有：flag 根本不在 args 里。
+async function cmdTelemetry(args, globals, out, stdout, stderr) {
   const tm = await import('./telemetry.mjs');
   const up = await import('./upload.mjs');
   switch (args[0]) {
     case 'status': {
       let ep;
       try { ep = up.endpoint(); } catch (e) { ep = `无效（${e.message}）`; }
+      // 🔴 身份与匿名计数分两行显示。合成一行「上报：开」的话，
+      //    关掉身份的用户看不出「我关的那个到底关了没有」。
+      const identity = tm.identityEnabled() ? '开'
+        : tm.enabled() ? '关（身份三项不发，匿名计数照发）' : '关（埋点整体已关）';
+      if (globals.json) {
+        stdout.write(`${JSON.stringify({
+          schema: 'geoly.skills.telemetry-status/1',
+          telemetry: tm.enabled(),
+          upload: tm.uploadEnabled(),
+          identity: tm.identityEnabled(),
+          endpoint: ep ?? null,
+          endpointIsDefault: ep ? up.isDefaultEndpoint() : null,
+          permWarning: tm.permWarning(),
+          queued: tm.readAll().length,
+          history: tm.readHistory().length,
+          stateDir: tm.stateDir(),
+        })}\n`);
+        return EXIT.OK;
+      }
       const uploadOff = !tm.enabled() ? '关（埋点整体已关）'
         : tm.offline() ? '关（--offline）'
           : '关（GEOLY_TELEMETRY_UPLOAD=0）';
@@ -293,13 +331,23 @@ async function cmdTelemetry(args, stdout, stderr) {
       // 🔴 端点默认开（2026-09-01 拍板），所以「这是内置默认值」必须写在脸上：
       //    用户有权知道数据默认发去哪，而不是去翻源码才发现有个默认端点。
       stdout.write(`端点      ${ep ?? '无'}${ep && up.isDefaultEndpoint() ? '（内置默认值 —— 未配 GEOLY_TELEMETRY_ENDPOINT）' : ''}\n`);
+      stdout.write(`身份三项  ${identity}\n`);
       stdout.write(`待上报    ${tm.readAll().length} 条\n`);
       stdout.write(`报表历史  ${tm.readHistory().length} 条（上报不消费它）\n`);
       stdout.write(`状态目录  ${tm.stateDir()}\n`);
+      // 🔴 权限收不紧要**说出来**：悄悄地继续写，意味着没人知道这台机器上的
+      //    埋点目录是所有人可读的 —— 而里面可能有登录名与主机名。
+      const pw = tm.permWarning();
+      if (pw) stdout.write(`⚠️ 权限    ${pw}\n`);
       return EXIT.OK;
     }
     case 'flush': {
       const r = await up.flush();
+      if (globals.json) {
+        const bad = r.skipped && (r.reason === 'bad-endpoint' || r.reason?.startsWith('error:'));
+        return out.emit('telemetry', { action: 'flush', sent: r.sent ?? 0, skipped: !!r.skipped, reason: r.reason ?? null },
+          bad ? EXIT.USAGE : EXIT.OK);
+      }
       stdout.write(r.skipped
         ? `未上报：${r.reason}${r.detail ? `（${r.detail}）` : ''}\n`
         : `已上报 ${r.sent} 条\n`);
@@ -309,8 +357,135 @@ async function cmdTelemetry(args, stdout, stderr) {
       const bad = r.skipped && (r.reason === 'bad-endpoint' || r.reason?.startsWith('error:'));
       return bad ? EXIT.USAGE : EXIT.OK;
     }
+    case 'off': {
+      const all = args.includes('--all');
+      // 🔴 **`--all` 做不到它字面的意思，所以它不许假装做到了。**
+      //    「什么都不发」等价于 GEOLY_TELEMETRY=0，而那个开关承诺的是
+      //    「本地一个字节都不写」—— 一个要先写标记文件才能生效的持久开关，
+      //    与那句承诺自相矛盾。所以这里只关身份，并**如实说**全关要走环境变量。
+      //    早先这条的文案写着「什么都不发」而实现只关了身份（Codex 指出）。
+      // 🔴 埋点整体已关时**什么都不写**：那种状态下建目录、落标记，
+      //    本身就违反了那句承诺。
+      if (!tm.enabled()) {
+        const msg = '埋点整体已经是关的（GEOLY_TELEMETRY=0），没有可关的东西，也不写任何文件。';
+        if (globals.json) return out.emit('telemetry', { action: 'off', changed: false, identity: false }, EXIT.OK);
+        stdout.write(`${msg}\n`);
+        return EXIT.OK;
+      }
+      tm.identityOff();
+      if (globals.json) {
+        return out.emit('telemetry', {
+          action: 'off', all, changed: true, identity: tm.identityEnabled(),
+          note: all ? '全关需要环境变量 GEOLY_TELEMETRY=0' : undefined,
+        }, EXIT.OK);
+      }
+      stdout.write('已关闭身份三项（登录名 / 主机名 / 来源 IP）。\n');
+      stdout.write('匿名计数照发 —— 装了什么、成不成功、耗时。\n');
+      if (all) {
+        stdout.write('\n⚠️ `--all` 只关掉了身份三项。要连匿名计数一起停，请设\n');
+        stdout.write('   GEOLY_TELEMETRY=0 —— 它必须是环境变量：那个开关承诺的是\n');
+        stdout.write('   「本地一个字节都不写」，而一个要先写标记文件才生效的持久开关\n');
+        stdout.write('   与这句承诺自相矛盾。\n');
+      }
+      stdout.write('已经发出去的身份记录不会自动删除：skills-hub telemetry delete\n');
+      return EXIT.OK;
+    }
+    case 'on': {
+      if (!tm.enabled()) {
+        if (globals.json) return out.emit('telemetry', { action: 'on', changed: false }, EXIT.OK);
+        stdout.write('埋点整体已关（GEOLY_TELEMETRY=0），不写任何文件。\n');
+        return EXIT.OK;
+      }
+      tm.identityOn();
+      if (globals.json) {
+        return out.emit('telemetry', { action: 'on', changed: true, identity: tm.identityEnabled() }, EXIT.OK);
+      }
+      stdout.write('已撤销「关闭身份」的标记。\n');
+      // 🔴 说清楚它**没有**打开身份采集：还要过环境变量与告知两道门。
+      //    不写这句的话，用户会以为 `telemetry on` 就是开了。
+      stdout.write(`当前身份三项：${tm.identityEnabled() ? '开' : '仍然是关的'}\n`);
+      if (!tm.identityEnabled()) {
+        stdout.write('要真正打开还需要 GEOLY_TELEMETRY_IDENTITY=on，并看过一次身份告知。\n');
+      }
+      return EXIT.OK;
+    }
+    case 'delete': {
+      // 🔴 **先远程、后本机。** 本机那一步会删掉私钥，而私钥是远程删除唯一的所有权证明
+      //    （规格 §4.4）。倒过来做，服务端那批数据就再也证明不了是谁的。
+      const key = tm.deleteKey();
+      // 私钥只在身份开启时生成，身份开启又要求告知过。所以「没私钥、也没告知过」=
+      // 这台机器从没发过带身份的数据，服务端没有可按所有权删的东西。
+      // 反过来「告知过却没私钥」= 私钥丢了或坏了，**不能**说服务端没有数据（Codex 2026-09-13 P1）。
+      const identityEver = key !== null || tm.identityNoticeShown();
+      const remote = key ? await up.remoteDelete({ key }) : null;
+      const r = tm.purgeLocal({ keepDeleteKey: key !== null && !remote.ok });
+      const vetoed = remote !== null && (remote.reason === 'offline' || remote.reason === 'upload-disabled');
+
+      /** @type {'deleted'|'deleted-key-left'|'vetoed'|'remote-failed'|'unprovable'|'nothing-remote'} */
+      let status;
+      let code;
+      if (remote?.ok) {
+        status = r.deleteKeyRemoved ? 'deleted' : 'deleted-key-left';
+        code = r.deleteKeyRemoved ? EXIT.OK : EXIT.PARTIAL;
+      } else if (vetoed) {
+        status = 'vetoed'; code = EXIT.PARTIAL;
+      } else if (remote) {
+        status = 'remote-failed'; code = EXIT.NETWORK;
+      } else if (identityEver) {
+        status = 'unprovable'; code = EXIT.PARTIAL;
+      } else {
+        status = 'nothing-remote'; code = EXIT.OK;
+      }
+      // 🔴 本机删不干净也要反映到退出码上：「已清空」和「清了一部分」是两件事
+      const leftovers = r.remaining.filter((n) => !n.startsWith('upload.lock'));
+      if (leftovers.length > 0 && code === EXIT.OK) code = EXIT.PARTIAL;
+
+      if (globals.json) {
+        return out.emit('telemetry', {
+          action: 'delete', remote: status, reason: remote?.ok ? null : (remote?.reason ?? null),
+          removed: r.removed, remaining: leftovers, kept: r.kept, deleteKeyRemoved: r.deleteKeyRemoved,
+        }, code);
+      }
+      switch (status) {
+        case 'deleted':
+          stdout.write('服务端已删除这台机器发出的身份记录（登录名 / 主机名 / 来源 IP），\n');
+          stdout.write('并剥掉了那些事件上的 install_id。匿名计数保留到到期。\n');
+          break;
+        case 'deleted-key-left':
+          stdout.write('服务端已删除身份记录，但本机的删除私钥没删掉。\n');
+          stdout.write('⚠️ 在删掉它之前，这台机器之后发出的身份记录会被服务端当作「已申请删除」而丢弃。\n');
+          break;
+        case 'vetoed':
+          stdout.write('⚠️ 没有向服务端申请删除：--offline / GEOLY_TELEMETRY=0 / GEOLY_TELEMETRY_UPLOAD=0\n');
+          stdout.write('   都承诺过不发网络请求，删除请求也是网络请求。\n');
+          stdout.write('   删除私钥已保留 —— 临时解除这些开关后再跑一次 `skills-hub telemetry delete`。\n');
+          break;
+        case 'remote-failed':
+          stdout.write(`⚠️ 服务端删除没有成功（${remote.reason}${remote.detail ? `：${remote.detail}` : ''}）。\n`);
+          stdout.write('   删除私钥已保留 —— 稍后再跑一次 `skills-hub telemetry delete`。\n');
+          break;
+        case 'unprovable':
+          stdout.write('⚠️ 这台机器看过身份告知，但找不到可用的删除私钥（丢失或损坏），\n');
+          stdout.write('   无法向服务端证明那些身份记录是你的。它们会在 90 天后到期删除。\n');
+          break;
+        default:
+          stdout.write('这台机器从没发出过带身份的记录，服务端没有需要按所有权删除的东西。\n');
+      }
+      stdout.write(`本机埋点数据已清空（删了 ${r.removed} 个文件，含 install-id 与上报墓碑）。\n`);
+      if (r.kept.includes('identity-off')) stdout.write('「关闭身份」的设置保留着。\n');
+      if (leftovers.length > 0) stdout.write(`⚠️ 这些没删掉：${leftovers.join('、')}\n`);
+      // 删除的是「过去的」；身份采集如果仍开着，之后的新事件照样会带身份
+      if (tm.identityEnabled()) {
+        stdout.write('ℹ️ 身份采集仍然开着，之后的事件会带一把新的删除密钥重新采集 —— 要停请 `skills-hub telemetry off`。\n');
+      }
+      return code;
+    }
     default:
-      stderr.write('用法：skills-hub telemetry <status|flush>\n');
+      if (globals.json) {
+        return out.emitError('telemetry', classify(new UsageError('x')),
+          new Error('用法：skills-hub telemetry <status|flush|on|off [--all]|delete>'));
+      }
+      stderr.write('用法：skills-hub telemetry <status|flush|on|off [--all]|delete>\n');
       return EXIT.USAGE;
   }
 }

package/src/commands/context.mjs

@@ -17,6 +17,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { isAbsolute, resolve as resolvePath } from 'node:path';
 import { UsageError, UnsupportedError } from '../exit-codes.mjs';
 import { SCAN_CEILINGS } from '../target.mjs';
+import { ownVersion } from '../version.mjs';
 
 /** §2 那张表。`arg: true` = 后面跟一个值。 */
 const GLOBAL_FLAGS = Object.freeze({
@@ -226,18 +227,9 @@ export function uintArg(name, val) {
  * 🔴 读不到就**抛**，不要退回一个假版本号：一个编出来的版本号会让
  *    版本门做出错误判定，而那正是这道门要防的事。
  */
-let cachedVersion;
-export function ownVersion() {
-  if (cachedVersion === undefined) {
-    const p = new URL('../../package.json', import.meta.url);
-    const v = JSON.parse(readFileSync(p, 'utf8')).version;
-    if (typeof v !== 'string' || v === '') {
-      throw new Error('读不出本 CLI 的版本号（package.json 的 version 不是非空字符串）');
-    }
-    cachedVersion = v;
-  }
-  return cachedVersion;
-}
+// 实现搬到 src/version.mjs：埋点的 `cli` 字段要取同一个值（见那个文件的注释）。
+// 这里保留导出，调用方与测试不用改。
+export { ownVersion };
 
 export function makeContext(globals, deps = {}) {
   const env = deps.env ?? process.env;

package/src/delete-proof.mjs

@@ -0,0 +1,86 @@
+// 删除通道的签名协议 —— **客户端与服务端共用的唯一定义**。
+//
+// 🔴 放在 src/ 而不是 server/：客户端要照着它签，服务端要照着它验。
+//    两边各写一份，迟早一边改了另一边没改 —— 结果不是报错，是「所有删除请求
+//    都验不过」或者更糟的「验得过一个不该验过的形状」。与 assertValidEvent 只有一份
+//    是同一条纪律。server/delete.mjs 从这里 re-export。
+//
+// 🔴 **零依赖**：只用 node:buffer。服务端的路由模块会 import 它，而仓库根的测试
+//    只装根依赖（server/delete.mjs 文件头那段教训）。
+
+/**
+ * 协议版本。**改了它就是换了一套签名语义**，旧签名一律失效 —— 这正是要的。
+ * v1 → v2（2026-09-13）：把服务端的 audience 纳入签名（Codex 指出的中继重放，见 signedMessage）。
+ */
+export const DELETE_PROTOCOL = 'geoly.skills.telemetry-delete/2';
+
+// 三个定长量。**定长不是「不超过」**：可变长度会让塞了别的东西的值混进来。
+export const RE_PUBKEY = /^[A-Za-z0-9_-]{43}$/;      // 32 字节 Ed25519 公钥
+export const RE_NONCE = /^[A-Za-z0-9_-]{43}$/;       // 32 字节
+export const RE_SIGNATURE = /^[A-Za-z0-9_-]{86}$/;   // 64 字节签名
+
+/** audience 的长度上界 —— 它进签名消息，长度前缀是两个字节。 */
+export const MAX_AUDIENCE_BYTES = 2048;
+
+/**
+ * 是不是**规范**的 base64url，且恰好解出 `bytes` 个字节。
+ *
+ * 🔴 光过正则不够：43 个字符解出 32 字节时，最后一个字符的低 4 位是填充位，
+ *    `…A` 与 `…B` 可能解出同一串字节。同一把公钥有多个文本表示，
+ *    tag（按文本算 HMAC）就会不同 —— 同一个人被算成两个，删一个漏一个。
+ *    判据：解码再编码，必须逐字相等（Codex 2026-09-13）。
+ */
+export function isCanonicalB64u(s, bytes) {
+  if (typeof s !== 'string') return false;
+  const buf = Buffer.from(s, 'base64url');
+  return buf.length === bytes && buf.toString('base64url') === s;
+}
+
+/**
+ * 规范化 audience：它是**删除端点的完整 URL**，客户端与服务端各自独立算出，逐字比对。
+ *
+ * 只收 http/https、不许带凭据、query 与 fragment —— 这三样都能让「同一个端点」
+ * 有多种写法，而 audience 比的是字符串。
+ * @returns {string|null} 不合法返回 null
+ */
+export function normalizeAudience(raw) {
+  if (typeof raw !== 'string' || raw === '') return null;
+  let u;
+  try { u = new URL(raw); } catch { return null; }
+  if (u.protocol !== 'https:' && u.protocol !== 'http:') return null;
+  if (u.username || u.password || u.search || u.hash) return null;
+  const s = u.toString();
+  return Buffer.byteLength(s, 'utf8') <= MAX_AUDIENCE_BYTES ? s : null;
+}
+
+/**
+ * 被签名的消息：`协议名 || u16be(len(audience)) || audience || 公钥32 || nonce32`。
+ *
+ * 🔴 **不是「签 nonce 原文」。** 裸签一个随机串意味着这个签名在**任何**
+ *    也用 Ed25519 的协议里都可能被复用（跨协议重放）。所以：
+ *      · 协议名做**域分离** —— 换了协议就是另一段消息
+ *      · 把公钥包进消息 —— 签名与「谁在签」绑死，不能挪给别的公钥用
+ * 🔴 **audience 必须进签名**（v2，Codex 2026-09-13 的 P0）：客户端允许自定义端点，
+ *    一个恶意端点可以拿受害者的公钥去正式服务取 nonce、原样转给 CLI 签、
+ *    再把签名转发回正式服务 —— 禁止重定向挡不住这种代理式中继。
+ *    签名里写死「我签给的是哪个端点」，转发出去就对不上。
+ * 🔴 audience 是唯一的变长段，所以带**长度前缀**：没有前缀的拼接存在歧义
+ *    （audience 末尾挪几个字节给公钥，拼出来一样）。
+ */
+export function signedMessage({ audience, pubkey, nonce }) {
+  const aud = normalizeAudience(audience);
+  if (aud === null || aud !== audience) throw new Error('delete: audience 不是规范形式');
+  if (!RE_PUBKEY.test(pubkey) || !isCanonicalB64u(pubkey, 32)) throw new Error('delete: pubkey 形状不合法');
+  if (!RE_NONCE.test(nonce) || !isCanonicalB64u(nonce, 32)) throw new Error('delete: nonce 形状不合法');
+  const audBytes = Buffer.from(aud, 'utf8');
+  const len = Buffer.alloc(2);
+  len.writeUInt16BE(audBytes.length);
+  return Buffer.concat([
+    Buffer.from(DELETE_PROTOCOL, 'utf8'), len, audBytes,
+    Buffer.from(pubkey, 'base64url'), Buffer.from(nonce, 'base64url'),
+  ]);
+}
+
+/** 请求与响应信封的 schema。两边共用，理由同上。 */
+export const CHALLENGE_SCHEMA = 'geoly.skills.telemetry-delete-challenge/1';
+export const DELETE_SCHEMA = 'geoly.skills.telemetry-delete/1';