dsh-mobile-plugin 0.5.28 → 0.5.29

package/lib/mobile/phone/learn.js

@@ -0,0 +1,329 @@
+'use strict';
+
+/**
+ * 从实际跑过的任务里沉淀 App / 网站知识草稿。
+ *
+ * 一次任务收尾后，把用过的动作序列（打开哪个 App / 网站、依次点了什么、在哪个框输入了什么）
+ * 归纳成一份「知识草稿」，**写进待审目录**，不直接改正式的 `knowledge/apps/*` 或
+ * `knowledge/sites/*`。人工看过、收下之后才并入正式知识——所以草稿与正式知识是两份东西。
+ *
+ * 知识只讲事实（入口在哪、界面怎么组织、走到哪一步会发生什么），不写行为规则；行为规则归
+ * 审批层。草稿里也会把这一次的具体值（输入过的文字、长数字串）换成 `<参数>`，避免把订单号、
+ * 手机号、人名固化进知识。
+ *
+ * 脱敏优先用仓库里已有的 `redact.js`（存在就用），不存在时走这里一个保守的兜底并在代码里
+ * 留了清楚的 TODO。见 `desensitize()`。
+ *
+ * 待审目录：默认插件根下的 `.knowledge-drafts/`，可用 `DSH_PHONE_KNOWLEDGE_DRAFT_DIR` 覆盖。
+ * 它**不在** `knowledge/` 里，也不在发布声明的打包路径里，所以草稿不会被当成正式知识发出去。
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** 待审目录：插件根下的 `.knowledge-drafts/`。 */
+function draftsDir() {
+  const override = process.env.DSH_PHONE_KNOWLEDGE_DRAFT_DIR;
+  if (typeof override === 'string' && override.trim()) return override.trim();
+  // learn.js 在 lib/mobile/phone/ 下，往上三层是插件根。
+  return path.join(__dirname, '..', '..', '..', '.knowledge-drafts');
+}
+
+/* ── 脱敏 ──────────────────────────────────────────────────────────────── */
+
+/**
+ * 找现成的脱敏模块。同目录的 `phone/redact.js` 就是统一的那一份（运行记录、证据账本、
+ * 网络数据共用同一个实现）；路径对不上时再往下试旧位置，最后才退保守兜底。
+ */
+function loadRedactor() {
+  const candidates = ['./redact.js', '../redact.js', '../../redact.js'];
+  for (const candidate of candidates) {
+    try {
+      const mod = require(candidate);
+      if (typeof mod === 'function') return { fn: mod, source: candidate };
+      if (mod && typeof mod.redact === 'function') return { fn: (t) => mod.redact(t), source: candidate };
+    } catch {
+      // 没装 / 路径不对，试下一个。
+    }
+  }
+  return null;
+}
+
+const REDACTOR = loadRedactor();
+
+/** 兜底脱敏：把这次输入过的原文与较长的数字串换成 `<参数>`。 */
+function fallbackRedact(text, sensitive) {
+  let out = String(text || '');
+  for (const value of sensitive) {
+    if (typeof value !== 'string') continue;
+    const needle = value.trim();
+    // 太短的词（如「好」「1」）换掉会把正文弄烂，跳过。
+    if (needle.length < 2) continue;
+    out = out.split(needle).join('<参数>');
+  }
+  // 6 位以上的连续数字（订单号、手机号、卡号一类）打码；版本号、年份一般不到 6 位。
+  out = out.replace(/\d{6,}/g, '<参数>');
+  return out;
+}
+
+/**
+ * 对一段文本做脱敏。
+ *
+ * TODO(脱敏)：仓库里还没有 `lib/mobile/redact.js`。它应有的规则（对齐 Mika 的 SkillRedactor）是：
+ * 把「引号内的内容、2 位以上数字、金额、这次输入的文字」换成 `<参数>`（先 NFKC、中文数字与
+ * 分隔数字归一，长的先换、纯数字只换整段），保留 App 名字里自带的数字。补上后本模块自动改用。
+ * 现在先走 `fallbackRedact`，只换本次输入原文与 6 位以上数字串。
+ *
+ * @param {string} text 待脱敏文本
+ * @param {string[]} sensitive 这次任务里输入过的原文
+ */
+function desensitize(text, sensitive = []) {
+  // 先换掉本次任务里确实输入过的原文（人名、地址这类 redactor 的模式不一定认识），
+  // 再交给统一脱敏模块跑一遍凭据/卡号/验证码那套；没有 redactor 时退回纯数字兜底。
+  let out = String(text || '');
+  for (const value of sensitive) {
+    if (typeof value !== 'string') continue;
+    const needle = value.trim();
+    if (needle.length < 2) continue;
+    out = out.split(needle).join('<参数>');
+  }
+  if (REDACTOR) return REDACTOR.fn(out);
+  return out.replace(/\d{6,}/g, '<参数>');
+}
+
+/* ── 动作序列 → 事实 ────────────────────────────────────────────────────── */
+
+/** 从一段地址里抽主机名（小写）；认不出就按 `/`、`:` 切第一段。 */
+function hostOf(raw) {
+  const text = typeof raw === 'string' ? raw.trim() : '';
+  if (!text) return '';
+  try {
+    return new URL(text.includes('://') ? text : `https://${text}`).hostname.toLowerCase();
+  } catch {
+    return text.toLowerCase().split('/')[0].split(':')[0];
+  }
+}
+
+/** 一步动作里最能说明「动了哪儿」的标签。 */
+function stepLabel(step) {
+  const args = (step && step.args) || {};
+  const raw = args.target || args.text || args.label || step.target || step.label || args.ref || step.ref || '';
+  return String(raw || '').trim();
+}
+
+/** 一步的动作名；兼容 `{action}` 与 `{name}` 两种写法。 */
+function stepAction(step) {
+  return String((step && (step.action || step.name)) || '').trim().toLowerCase();
+}
+
+/**
+ * 把动作序列归成「经过的界面 / 做过的操作 / 需注意的现象」三组事实。
+ * 只做归纳，不评价对错，也不写行为规则。
+ */
+function summarizeSteps(steps) {
+  const opened = [];
+  const taps = [];
+  const typed = [];
+  const scrolled = new Set();
+  const keys = new Set();
+  const waits = [];
+  const sensitive = [];
+
+  for (const step of Array.isArray(steps) ? steps : []) {
+    const action = stepAction(step);
+    const args = (step && step.args) || {};
+    switch (action) {
+      case 'app.open':
+        opened.push(stepLabel(step) || String(args.packageName || args.package || '').trim());
+        break;
+      case 'app.link':
+        opened.push(stepLabel(step) || String(args.uri || args.url || '').trim());
+        break;
+      case 'tap':
+        taps.push(stepLabel(step));
+        break;
+      case 'type': {
+        const where = stepLabel(step);
+        const text = String(args.text || step.text || '').trim();
+        if (text) {
+          typed.push({ where, text });
+          sensitive.push(text);
+        }
+        break;
+      }
+      case 'swipe':
+        scrolled.add(args.direction === 'up' ? '注意：向上滑是看下面的内容' : `向${args.direction || '下'}滑动`);
+        break;
+      case 'key':
+        if (args.key) keys.add(String(args.key));
+        break;
+      case 'wait':
+      case 'screen.wait':
+        if (args.appears) waits.push(String(args.appears));
+        break;
+      default:
+        break;
+    }
+  }
+
+  return { opened, taps, typed, scrolled, keys, waits, sensitive };
+}
+
+/* ── 由任务提炼草稿 ────────────────────────────────────────────────────── */
+
+/** 把一段名字压成可做文件名的 slug。 */
+function slugify(value) {
+  return String(value || '')
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9.-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'unknown';
+}
+
+/** 现在的时间，ISO 到分钟。 */
+function nowIso() {
+  return new Date().toISOString().replace(/\.\d+Z$/, 'Z');
+}
+
+/**
+ * 从一次任务的轨迹提炼一份知识草稿（不落盘）。
+ *
+ * @param {object} trace 任务轨迹
+ * @param {string} [trace.kind] 'app' | 'site'，不给时按有没有 url / 包名推断
+ * @param {string} [trace.packageName] App 包名
+ * @param {string} [trace.appName] App 中文名
+ * @param {string} [trace.url] 网站地址
+ * @param {string} [trace.host] 网站主机名（与 url 二选一）
+ * @param {string} [trace.siteName] 网站名
+ * @param {string} [trace.outcome] done / partial / not_possible / unknown
+ * @param {string} [trace.sessionId] 来源会话
+ * @param {Array}  [trace.steps] 动作序列，每步 `{ action, args }`
+ * @param {string[]} [trace.inputs] 额外需要脱敏的原文
+ * @returns {{kind, name, slug, display, status, markdown, outcome}}
+ */
+function draftFromTask(trace) {
+  const t = trace && typeof trace === 'object' ? trace : {};
+  const url = String(t.url || t.host || '').trim();
+  const host = hostOf(url);
+  const pkg = String(t.packageName || t.package || '').trim();
+  const kind = t.kind === 'app' || t.kind === 'site'
+    ? t.kind
+    : (host && !pkg ? 'site' : 'app');
+
+  const summary = summarizeSteps(t.steps);
+  const extraSensitive = Array.isArray(t.inputs) ? t.inputs.map(String) : [];
+  const sensitive = [...summary.sensitive, ...extraSensitive];
+
+  const name = kind === 'site' ? (host || 'site') : (pkg || slugify(t.appName));
+  const display = kind === 'site'
+    ? String(t.siteName || host || name)
+    : String(t.appName || name);
+
+  const lines = [];
+  const fm = [];
+  fm.push('---');
+  fm.push(`name: ${name}`);
+  fm.push(`display: ${display}`);
+  fm.push(`kind: ${kind}`);
+  fm.push('status: draft');
+  fm.push('review: pending');
+  fm.push(`learned_from: ${String(t.sessionId || 'task').slice(0, 80)}`);
+  fm.push(`outcome: ${String(t.outcome || 'unknown').slice(0, 40)}`);
+  fm.push(`created: ${nowIso()}`);
+  fm.push('---');
+  lines.push(fm.join('\n'));
+  lines.push('');
+  lines.push('# 知识草稿（待审）');
+  lines.push('');
+  lines.push('> 这是从一次实际任务归纳出的草稿，收下并人工核对后才并入正式知识。只记录事实（入口、界面、走到哪一步会发生什么），不含行为规则。');
+  lines.push('');
+  lines.push('## 是什么');
+  if (kind === 'site') {
+    lines.push(`${display}（${host || name}）。以下按一次实际任务的操作顺序记录。`);
+  } else {
+    lines.push(`${display}（${pkg || name}）。以下按一次实际任务的操作顺序记录。`);
+  }
+  lines.push('');
+  lines.push('## 界面');
+  const iface = [];
+  if (summary.opened.length > 0) iface.push(`- 入口：${summary.opened.filter(Boolean).join('、') || display}`);
+  for (const tap of summary.taps) {
+    if (tap) iface.push(`- 点「${tap}」`);
+  }
+  if (iface.length === 0) iface.push('- 这次任务没有记录到具体的界面入口。');
+  lines.push(...iface);
+  lines.push('');
+  lines.push('## 功能');
+  const func = [];
+  for (const item of summary.typed) {
+    func.push(`- 在「${item.where || '输入框'}」里输入：${item.text}`);
+  }
+  for (const note of summary.scrolled) func.push(`- ${note}`);
+  if (func.length === 0) func.push('- 这次任务没有记录到具体操作。');
+  lines.push(...func);
+  lines.push('');
+  lines.push('## 已知现象');
+  const signs = [];
+  if (summary.waits.length > 0) signs.push(`- 某些页面需要等待加载：${summary.waits.join('、')}`);
+  if (summary.keys.has('back')) signs.push('- 过程中用返回键退出过当前页');
+  if (signs.length === 0) signs.push('- 这次任务没有遇到需要特别记下的现象。');
+  lines.push(...signs);
+
+  const body = desensitize(lines.join('\n'), sensitive);
+
+  return {
+    kind,
+    name,
+    slug: slugify(name),
+    display,
+    status: 'draft',
+    outcome: String(t.outcome || 'unknown'),
+    markdown: body,
+  };
+}
+
+/**
+ * 把草稿写进待审目录。文件名带时间戳，避免同一条知识的多份草稿互相覆盖。
+ *
+ * @returns {{path, file, dir, kind, name, status}}
+ */
+function writeDraft(draft, options = {}) {
+  if (!draft || typeof draft.markdown !== 'string') throw new Error('没有可写的草稿。');
+  const slug = String(draft.slug || '');
+  if (!/^[a-z0-9.-]+$/.test(slug)) throw new Error('草稿 slug 不合法，可能会逃出待审目录。');
+  const kind = draft.kind === 'site' ? 'site' : 'app';
+  const dir = options.dir || draftsDir();
+  fs.mkdirSync(dir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[-:]/g, '').replace(/\..*$/, '').replace('T', '-');
+  const file = `${kind}-${slug}-${stamp}.md`;
+  const target = path.resolve(dir, file);
+  const root = path.resolve(dir);
+  if (target !== root && !target.startsWith(root + path.sep)) {
+    throw new Error('草稿文件名逃出了待审目录。');
+  }
+  fs.writeFileSync(target, draft.markdown, 'utf8');
+  return { path: target, file, dir, kind: draft.kind, name: draft.name, status: 'draft' };
+}
+
+/** 便利入口：从轨迹直接提炼并落盘，返回写入位置与草稿概要。 */
+function learnFromTask(trace, options = {}) {
+  const draft = draftFromTask(trace);
+  return writeDraft(draft, options);
+}
+
+module.exports = {
+  draftsDir,
+  draftFromTask,
+  writeDraft,
+  learnFromTask,
+  desensitize,
+  // 供测试
+  _internal: {
+    summarizeSteps,
+    slugify,
+    hostOf,
+    fallbackRedact,
+    redactorSource: REDACTOR ? REDACTOR.source : null,
+  },
+};

package/lib/mobile/phone/redact.js

@@ -0,0 +1,237 @@
+'use strict';
+
+/**
+ * 统一脱敏：运行记录、证据账本、网络数据三处共用同一套规则，一处改了另两处跟着改。
+ * 纯逻辑、无 IO、不改入参（redactObject 返回新对象）。
+ *
+ * 覆盖 Mika Redactor.kt 的全部口径，并补上卡号：
+ *   - 密码框里打进去的字（字段名像凭据的，整段打码）；
+ *   - sk-* / AIza* / AQ.* / ghp_* 等已知格式的 Key、Bearer 令牌；
+ *   - JWT（eyJ… 三段）；
+ *   - 又长又杂的串（≥32 位，且同时有大写、小写、数字）；
+ *   - 16 位 / 19 位卡号类数字串（含分组空格 / 连字符）；
+ *   - 名字像凭据的 query / 表单 / JSON / 头字段的值（token、secret、password、cookie、
+ *     authorization…；author、keyword 这类不算）；
+ *   - OAuth 回跳里的 code、state；
+ *   - 前后 24 字内有「验证码 / 短信 / code / otp」一类词的 4–8 位数字。
+ *
+ * 三个导出的分工：
+ *   redact(text)          对一段自由文本跑全部文本级规则（Key/JWT/长串/卡号/验证码）。
+ *   redactObject(obj)     递归处理对象/数组：凭据名整段打码，其余字符串跑 redact。
+ *   redactNetwork(body)   网络数据（URL / 表单 / JSON 正文 / 头表）：凭据名与 OAuth 一并打码。
+ */
+
+const MASK = '***';
+
+/* ── 已知格式的凭据 ───────────────────────────────────────────────────── */
+
+const SK_KEY = /\bsk-[A-Za-z0-9_-]{16,}/g;
+const GOOGLE_KEY = /\bAIza[0-9A-Za-z_-]{30,}/g;
+/** Google 新格式认证 Key：AQ. 开头一长串 base64url。 */
+const GOOGLE_AUTH_KEY = /\bAQ\.[0-9A-Za-z_-]{20,}/g;
+const GITHUB_TOKEN = /\bgh[pousr]_[A-Za-z0-9]{20,}/g;
+const BEARER = /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}/g;
+
+/* ── JWT 与又长又杂的串 ───────────────────────────────────────────────── */
+
+const JWT = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g;
+const LONG = /[A-Za-z0-9_\-+=]{32,}/g;
+const LONG_SLASH = /[A-Za-z0-9_\-+/=]{32,}/g;
+
+/* ── 16 / 19 位卡号类 ─────────────────────────────────────────────────── */
+
+/** 13–19 位数字，允许单个空格或连字符分组；是否真按卡号遮由位数（16 或 19）决定。 */
+const CARD_LIKE = /(?<![\d.,])(?:\d[ -]?){15,18}\d(?![\d.,])/g;
+
+/* ── 验证码一类的 4–8 位数字 ──────────────────────────────────────────── */
+
+const CODE_WORD = /验证|校验码|动态码|动态密码|确认码|安全码|短信|口令|\b(?:code|otp|passcode|pin|2fa)\b/gi;
+/** 4–8 位数字，中间可隔单个空格或连字符；后面跟单位 / 年份 / 货币的是量，不是码。 */
+const CODE_DIGITS =
+  /(?<![\d.¥$€£])(?<!\d,)\d(?:[ -]?\d){3,7}(?!\d)(?!\.\d)(?!,\d{3}(?!\d))(?!\s*(?:年|元|块|角|分钟|小时|秒|天|月|日|号|次|个|人|件|条|米|公里|千米|克|公斤|千克|斤|吨|度|℃|°|%|‰|[¥$€£]|km|kg|mb|gb|kb|ms|cm|mm|mah|rmb|usd|cny))/gi;
+/** 码和词之间至多隔几个字（哪一边都算）。 */
+const CODE_WINDOW = 24;
+
+/* ── 名字像凭据 ──────────────────────────────────────────────────────── */
+
+const SECRET_WORDS = new Set([
+  'token', 'tokens', 'secret', 'password', 'passwd', 'pwd', 'passcode', 'session', 'sessionid', 'sessid', 'sid',
+  'auth', 'authorization', 'csrf', 'xsrf', 'signature', 'sig', 'otp', 'cookie', 'credential', 'credentials',
+  'apikey', 'jwt', 'bearer', 'pin', 'privatekey',
+]);
+const SECRET_COMPOUNDS = new Set([
+  'apikey', 'accesskey', 'secretkey', 'privatekey', 'clientsecret', 'sessionkey', 'authkey',
+]);
+const CASE_BOUNDARY = /(?<=[a-z0-9])(?=[A-Z])/g;
+const WORD_SPLIT = /[^A-Za-z0-9]+/g;
+
+/** 字段名按驼峰 / 下划线 / 连字符拆成词，有像凭据的词就是凭据字段。 */
+function secretName(name) {
+  const words = String(name == null ? '' : name)
+    .split(WORD_SPLIT)
+    .flatMap((part) => part.split(CASE_BOUNDARY))
+    .map((w) => w.toLowerCase())
+    .filter(Boolean);
+  return words.some((w) => SECRET_WORDS.has(w)) || SECRET_COMPOUNDS.has(words.join(''));
+}
+
+const OAUTH_MARKERS = new Set(['state', 'redirect_uri', 'client_id', 'code_verifier']);
+const OAUTH_RESULTS = new Set(['code', 'state']);
+
+/* ── 文本级规则 ──────────────────────────────────────────────────────── */
+
+function maskLong(s, slash) {
+  const re = slash ? LONG_SLASH : LONG;
+  return s.replace(re, (m) => {
+    if (/[A-Z]/.test(m) && /[a-z]/.test(m) && /\d/.test(m)) return MASK;
+    return m;
+  });
+}
+
+function maskCards(s) {
+  return s.replace(CARD_LIKE, (m) => {
+    const digits = m.replace(/\D/g, '').length;
+    return digits === 16 || digits === 19 ? MASK : m;
+  });
+}
+
+function maskCodes(s) {
+  const words = [];
+  for (const m of s.matchAll(CODE_WORD)) {
+    words.push({ start: m.index, last: m.index + m[0].length - 1 });
+  }
+  if (words.length === 0) return s;
+  return s.replace(CODE_DIGITS, (match, offset) => {
+    const first = offset;
+    const last = offset + match.length - 1;
+    const near = words.some((w) => {
+      const afterWord = first - w.last;
+      const beforeWord = w.start - last;
+      return (afterWord >= 1 && afterWord <= CODE_WINDOW + 1) || (beforeWord >= 1 && beforeWord <= CODE_WINDOW + 1);
+    });
+    return near ? MASK : match;
+  });
+}
+
+/**
+ * 自由文本脱敏：Key / Bearer / JWT / 长杂串 / 卡号 / 验证码。
+ * @param {string} input
+ * @returns {string}
+ */
+function redact(input) {
+  if (input === null || input === undefined) return input;
+  let s = typeof input === 'string' ? input : String(input);
+  s = s.replace(SK_KEY, MASK);
+  s = s.replace(GOOGLE_KEY, MASK);
+  s = s.replace(GOOGLE_AUTH_KEY, MASK);
+  s = s.replace(GITHUB_TOKEN, MASK);
+  s = s.replace(BEARER, 'Bearer ' + MASK);
+  s = s.replace(JWT, MASK);
+  s = maskLong(s, true);
+  s = maskCards(s);
+  s = maskCodes(s);
+  return s;
+}
+
+/* ── 结构化数据：query / 表单 / JSON / 头 ────────────────────────────── */
+
+/**
+ * 查询串或表单里 a=b&c=d：凭据名的值遮住；像 OAuth 回跳的（有 state 等，且带 code 或凭据）把 code、state 也遮住。
+ * [bareKey] 为真时，孤零零一个叫 key 的参数也算凭据。
+ */
+function maskParams(q, bareKey) {
+  const parts = q.split('&');
+  const names = parts.map((p) => p.split('=')[0].toLowerCase());
+  const oauth = names.some((n) => OAUTH_MARKERS.has(n)) && (names.includes('code') || names.some((n) => secretName(n)));
+  return parts
+    .map((p) => {
+      const eq = p.indexOf('=');
+      if (eq <= 0) return p;
+      const name = p.slice(0, eq);
+      const n = name.toLowerCase();
+      const hide = secretName(name) || (bareKey && n === 'key') || (oauth && OAUTH_RESULTS.has(n));
+      return hide ? name + '=' + MASK : p;
+    })
+    .join('&');
+}
+
+function maskUrl(u) {
+  const hash = u.indexOf('#');
+  const beforeHash = hash >= 0 ? u.slice(0, hash) : u;
+  const fragment = hash >= 0 ? u.slice(hash + 1) : null;
+  const q = beforeHash.indexOf('?');
+  const base = q >= 0 ? beforeHash.slice(0, q + 1) + maskParams(beforeHash.slice(q + 1), true) : beforeHash;
+  return fragment === null ? base : base + '#' + (fragment.includes('=') ? maskParams(fragment, true) : fragment);
+}
+
+const JSON_PAIR = /"((?:[^"\\]|\\.){1,100})"(\s*:\s*)("(?:[^"\\]|\\.)*"|-?\d[\d.eE+-]*|true|false|null)/g;
+const FORM = /^[^\s{}[\]"<>]+=[^\s]*$/;
+
+function maskBody(b) {
+  if (FORM.test(b)) return maskParams(b, false);
+  return b.replace(JSON_PAIR, (m, key, sep) => (secretName(key) ? `"${key}"${sep}"${MASK}"` : m));
+}
+
+/**
+ * 网络数据里的一个字符串（URL / 表单 / JSON 正文）脱敏。先按结构遮凭据名与 OAuth，
+ * 再跑一遍文本级规则兜住值里的 Key / JWT / 长串 / 卡号。
+ */
+function maskNetworkString(s) {
+  let out;
+  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(s) || (/^[^\s]*\?/.test(s) && s.includes('='))) {
+    out = maskUrl(s);
+  } else if (FORM.test(s)) {
+    out = maskParams(s, false);
+  } else {
+    out = maskBody(s);
+  }
+  return redact(out);
+}
+
+/**
+ * 递归脱敏对象 / 数组。名字像凭据的键整段打码；其余字符串跑 redact；数字布尔原样。
+ * @param {*} value
+ * @returns {*}
+ */
+function redactObject(value) {
+  if (value === null || value === undefined) return value;
+  if (Array.isArray(value)) return value.map((v) => redactObject(v));
+  if (typeof value === 'string') return redact(value);
+  if (typeof value === 'object') {
+    const out = {};
+    for (const k of Object.keys(value)) {
+      if (secretName(k)) out[k] = MASK;
+      else out[k] = redactObject(value[k]);
+    }
+    return out;
+  }
+  return value;
+}
+
+/**
+ * 网络数据脱敏：body 可以是字符串（URL / 表单 / JSON 正文），也可以是头表这类对象。
+ * @param {*} body
+ * @returns {*}
+ */
+function redactNetwork(body) {
+  if (body === null || body === undefined) return body;
+  if (typeof body === 'string') return maskNetworkString(body);
+  if (Array.isArray(body)) return body.map((b) => redactNetwork(b));
+  if (typeof body === 'object') return redactObject(body);
+  return body;
+}
+
+module.exports = {
+  redact,
+  redactObject,
+  redactNetwork,
+  secretName,
+  maskParams,
+  maskUrl,
+  // 给「证据账本 / 运行记录」这类只要纯文本遮罩的调用方留的别名，语义等价于 redact：
+  // phone/evidence.js 的 loadSharedRedactor 找的就是 evidence / text 这两个名字之一。
+  evidence: redact,
+  text: redact,
+  MASK,
+  CODE_WINDOW,
+};

package/lib/mobile/phone/risk.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * 动作风险五级分级：纯函数，只回答「这一步大概会造成多大影响」，不做任何动作、不读屏。
+ *
+ * 从 Mika（`core/action/Approval.kt` 的 `ActionRisk`）借五级口径：
+ *
+ *   Read          只看，或只在界面间移动（读屏、等、开/关 App、返回）
+ *   Change        在界面上改东西（点、打字、滑、手势、按键），改的是界面不是世界
+ *   External      把东西交给别人（发送、发布、提交），会影响屏外的世界
+ *   Irreversible  做了收不回（付款、下单、删除）
+ *   Unknown       看不清点的是什么，按拿不准处理
+ *
+ * `outward`（影响屏幕之外的世界，或拿不准会不会）对 External / Irreversible / Unknown 为真，
+ * 用来决定「这一步要不要记账、要不要人工确认」。这份分级只给调用方做参考：真正的放行/接管
+ * 判定在 gate.js 里，risk 不碰任何状态。
+ *
+ * 我们对 Mika 的取舍：Mika 分级要读整屏快照，能按资源 ID、组合键、弹框、拖拽等信号判；
+ * 我们的输入只有「动作名 + 目标文字 + 是否对外」这一份结构化信息，所以分级只用到这三样，
+ * 判不准的一律落到 Unknown，不猜。
+ */
+
+const { matchLabel } = require('./irreversible.js');
+
+/** 只看、只在界面间移动，不改屏外的世界。 */
+const READ_ACTIONS = new Set([
+  'screen.read', 'read', 'screenshot', 'list', 'find', 'wait',
+  'scroll', 'app.open', 'app.close', 'back', 'home', 'recents', 'tab',
+]);
+
+/** 在界面上改东西。 */
+const CHANGE_ACTIONS = new Set(['tap', 'type', 'swipe', 'key', 'gesture', 'clear', 'clear_text', 'long_press']);
+
+/** 点按类：读不到目标文字时判不了点的是什么。 */
+const TAP_LIKE = new Set(['tap', 'long_press']);
+
+function result(level, outward, why) {
+  return { level, outward, why };
+}
+
+/**
+ * classify({ action, target, outward }) → { level, outward, why }
+ *
+ * @param {object} input
+ * @param {string} input.action   动作名（tap / type / swipe / key / app.open / screen.read …）
+ * @param {string} [input.target] 这一下作用的文字（按钮名、发送对象、输入框标签…）
+ * @param {boolean} [input.outward] 调用方已经知道这一步对外（如带回车的打字、提交式点击）时置 true
+ * @returns {{level:string, outward:boolean, why:string}}
+ */
+function classify(input) {
+  const src = input && typeof input === 'object' ? input : {};
+  const action = typeof src.action === 'string' ? src.action.trim().toLowerCase() : '';
+  const target = typeof src.target === 'string' ? src.target.trim() : '';
+  const outwardFlag = src.outward === true;
+
+  if (!action) return result('Unknown', true, '没有动作名，判不了这一步做什么');
+
+  if (READ_ACTIONS.has(action)) {
+    return result('Read', false, `${action} 只看或只在界面间移动，不改屏外的东西`);
+  }
+
+  if (!CHANGE_ACTIONS.has(action)) {
+    return result('Unknown', true, `不认识的动作「${action}」，按拿不准处理`);
+  }
+
+  // 目标文字能命中不可逆词表：按命中的类别定级。
+  const hit = target ? matchLabel(target) : null;
+  if (hit) {
+    if (hit.kind === 'payment') {
+      return result('Irreversible', true, `「${target}」是付款/下单一类，做了收不回`);
+    }
+    if (hit.kind === 'delete') {
+      return result('Irreversible', true, `「${target}」是删除一类，做了收不回`);
+    }
+    return result('External', true, `「${target}」会把东西交给别人（${hit.kind}）`);
+  }
+
+  // 调用方已经声明这一步对外（例如带回车的打字）。
+  if (outwardFlag) {
+    return result('External', true, `${action} 被声明为对外动作，会影响屏外的世界`);
+  }
+
+  // 点按类却读不到目标文字：看不清点的是什么。
+  if (TAP_LIKE.has(action) && !target) {
+    return result('Unknown', true, '点按但读不到目标文字，看不清点的是什么');
+  }
+
+  return result('Change', false, `${action} 只在界面上改动，不涉及屏外的世界`);
+}
+
+module.exports = {
+  classify,
+  READ_ACTIONS,
+  CHANGE_ACTIONS,
+};