dsh-mobile-plugin 0.5.28 → 0.5.29

package/lib/mobile/phone/routes.js

@@ -23,6 +23,7 @@ const binding = require('./binding.js');
 const pacing = require('./pacing.js');
 const routeHint = require('./route-hint.js');
 const knowledge = require('../phone-knowledge.js');
+const access = require('./access.js');
 
 /** 设备标题：机型优先，没有机型才用 deviceId 的短尾巴。与凭据面板同一口径。 */
 function deviceLabel(row) {
@@ -177,7 +178,7 @@ async function handlePhoneKnowledge(deps, _ctx, req, res) {
     name: site.name,
     display: site.display,
     description: site.description,
-    sites: site.sites,
+    sites: site.domains,
     aliases: site.aliases,
   }));
   sendJson(res, 200, { ok: true, apps, sites, matched: matched ? matched.name : '' });
@@ -219,6 +220,30 @@ async function handlePhonePacing(_deps, _ctx, req, res) {
   }
 }
 
+/**
+ * 逐 App 访问控制：GET 读全部开关行，POST 改一个 App 的一行。
+ *
+ * 只是本地开关，不往手机上发动作；名单落 `$DSH_HOME/storages/mobile-plugin/phone-app-access.json`，
+ * 原生 `AppAccess.kt` 执行前按同一份名单判。包名形状在这里先校验，挡住把路径/命令塞进来。
+ */
+async function handlePhoneAppAccess(_deps, _ctx, req, res) {
+  if (req.method === 'GET' || !req.method) {
+    return sendJson(res, 200, { ok: true, apps: access.rows() });
+  }
+  const body = await readJsonBody(req);
+  const packageName = body && typeof body.packageName === 'string' ? body.packageName : '';
+  const patch = {
+    blocked: typeof body.blocked === 'boolean' ? body.blocked : undefined,
+    shareAllowed: typeof body.shareAllowed === 'boolean' ? body.shareAllowed : undefined,
+  };
+  if (patch.blocked === undefined && patch.shareAllowed === undefined) {
+    return sendJson(res, 400, { ok: false, error: 'missing-flags' });
+  }
+  const result = access.update(packageName, patch);
+  if (!result.ok) return sendJson(res, 400, { ok: false, error: result.error });
+  sendJson(res, 200, { ok: true, apps: access.rows() });
+}
+
 /**
  * 造出路由表要的那组 handler。
  *
@@ -235,6 +260,7 @@ function createPhoneRoutes(deps) {
     knowledge: (ctx, req, res) => handlePhoneKnowledge(deps, ctx, req, res),
     routes: (ctx, req, res) => handlePhoneRoutes(deps, ctx, req, res),
     pacing: (ctx, req, res) => handlePhonePacing(deps, ctx, req, res),
+    appAccess: (ctx, req, res) => handlePhoneAppAccess(deps, ctx, req, res),
   };
 }
 
@@ -246,6 +272,7 @@ module.exports = {
   handlePhoneKnowledge,
   handlePhoneRoutes,
   handlePhonePacing,
+  handlePhoneAppAccess,
   listDevices,
   describeDevice,
   deviceLabel,

package/lib/mobile/phone/service.js

@@ -75,6 +75,22 @@ const ACTIONS = new Map([
   ['screen.wait', 30_000],
   ['gesture', 20_000],
   ['app.link', 20_000],
+  // 结构化：提取 / 查询 / 滚动查找 / 多屏采集。
+  ['extract', 20_000],
+  ['query', 20_000],
+  ['find', 60_000],
+  ['collect', 60_000],
+  // 滚轮选择器一次转到位。
+  ['wheel.set', 25_000],
+  // 分享一段文字到指定 App。
+  ['share.text', 20_000],
+  // 系统动作：闹钟 / 计时器 / 看闹钟 / 日历插入（标准 Intent）。
+  ['system.alarm', 20_000],
+  ['system.timer', 20_000],
+  ['system.show_alarms', 20_000],
+  ['system.calendar_insert', 20_000],
+  // 任务结束时某个 App 的去留标记（只记下，不当场关）。
+  ['app.after_task', 20_000],
 ]);
 
 /**
@@ -173,6 +189,13 @@ function createPhoneService({ authorized, onLog } = {}) {
       }
     }
     total += rtt * 2 * steps.length;
+    // 手机侧还要按 pacing 在步与步之间停一下（standard 约每步 0.5–1.2s、新屏更久；careful/human 更久），
+    // 这段等待是在手机侧真睡掉的、要占同一笔预算，不给它留就会「批跑到一半被自己的停顿撞上超时」。
+    const pace = args && args.pacing;
+    if (pace && typeof pace === 'object') {
+      const careful = pace.place === 'careful' || pace.mode === 'human';
+      total += (careful ? 5_000 : 1_500) * steps.length;
+    }
     return Math.round(Math.min(Math.max(total, 5_000), 180_000));
   }
 

package/lib/mobile/phone/site-commands.js

@@ -0,0 +1,271 @@
+'use strict';
+
+/**
+ * 站点知识里的只读脚本：声明格式、清单与调用参数校验。
+ *
+ * 一条命令就是站点目录下的 `scripts/<name>.js`，文件以一段块注释开头（MARK 见下），后面是
+ * async 函数体，参数从 `args` 取。name 必须与文件名一致。头部一行一项：
+ *
+ *   - `name: list_jobs`
+ *   - `description: 列出当前搜索结果里的职位`
+ *   - `arg: limit integer - 最多几条`
+ *   - `arg: query string required - 只保留标题含这段字的`
+ *   - `returns: [{title, company, salary, url}]`
+ *   - `readOnly: true`（可选；站点命令只能是 true）
+ *
+ * 真正的页面内执行由原生侧做（真实页面、读取世界、同源只读），这个模块**不碰网络、不执行
+ * 任何代码**，只做两件事：把站点目录里的命令声明列出来，以及在调用前按声明校验参数。
+ *
+ * ## 执行契约（原生侧遵守，这里只定义，不在 JS 里强制执行）
+ *
+ * - 只读：脚本只能读 DOM 与页面已加载的数据，不得点击、输入、导航或改动页面状态。
+ * - 同源：只允许当前页面同源的 GET，禁止跨域请求。
+ * - 禁网：除同源只读外不得主动发起网络请求，不发 POST、不调站点的写接口。
+ * - 密码打码：返回值若来自密码 / 验证码等敏感输入，一律以 `***` 代替。
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+/** 命令头的起始标记。与 Mika 的 `/* mika-command` 同构，换成我们自己的名字。 */
+const COMMAND_MARK = '/* dsh-command';
+/** 命令名的字符集：小写字母开头，字母数字下划线，至多 40 个。 */
+const NAME_RE = /^[a-z][a-z0-9_]{0,39}$/;
+/** 参数类型白名单。 */
+const TYPES = ['string', 'integer', 'number', 'boolean'];
+/** 说明文字上限。 */
+const DESCRIPTION_LIMIT = 120;
+/** 脚本正文上限（字符）。太长说明该拆，不放进一块。 */
+const BODY_LIMIT = 12_000;
+
+/**
+ * 站点知识里 `commands` 的字段规格（给写知识的人看，也给校验用）。
+ * 每条命令恒定只读。
+ */
+const COMMAND_SCHEMA = {
+  name: '小写字母开头，字母 / 数字 / 下划线，至多 40，必须与文件名 scripts/<name>.js 一致',
+  description: `一句话说清这条命令取什么，至多 ${DESCRIPTION_LIMIT} 字`,
+  readOnly: '恒为 true：站点命令只能读，不得写页面或改状态',
+  returns: '返回的字段说明，例如 [{title, url}]',
+  args: '[{ name, type: string|integer|number|boolean, required?, description? }]',
+};
+
+/** 执行契约的文字版（给知识注入与原生实现对齐用）。 */
+const EXECUTION_CONTRACT = {
+  readOnly: true,
+  sameOrigin: true,
+  network: false,
+  redactPasswords: true,
+  summary:
+    '只读、同源、禁网、密码打码：脚本只读当前页面同源数据，不点击不输入不改页面，'
+    + '不主动发网络请求（含写接口），敏感输入一律打码后返回。',
+};
+
+const ARG_RE = /^([a-z][A-Za-z0-9_]{0,39})\s+(string|integer|number|boolean)(\s+required)?(?:\s+-\s+(.+))?$/;
+
+/** 去掉 BOM、统一换行、去掉开头空白，便于认头部。 */
+function clean(text) {
+  return String(text || '').replace(/^\uFEFF/, '').replace(/\r\n/g, '\n').replace(/^\s+/, '');
+}
+
+/** 这段文本是不是一条站点命令（以命令头开头）。 */
+function isCommand(text) {
+  return clean(text).startsWith(COMMAND_MARK);
+}
+
+/**
+ * 解析一条站点命令文件。
+ *
+ * 返回 `{ decl, body, errors }`：`decl` 只在 `errors` 为空时给出，形状为
+ * `{ name, description, readOnly: true, returns, args, file }`；`body` 是头部之后的脚本正文。
+ *
+ * @param {string} file 站点目录下的相对路径，如 `scripts/list_jobs.js`
+ * @param {string} text 文件全文
+ */
+function parseCommand(file, text) {
+  const t = clean(text);
+  if (!t.startsWith(COMMAND_MARK)) {
+    return { decl: null, body: '', errors: [`文件要以 \`${COMMAND_MARK}\` 开头`] };
+  }
+  const end = t.indexOf('*/');
+  if (end < 0) return { decl: null, body: '', errors: ['命令头没有用 `*/` 结束'] };
+
+  const body = t.slice(end + 2).trim();
+  const errors = [];
+  let name = null;
+  let description = null;
+  let returns = null;
+  let readOnly = null;
+  const args = [];
+
+  for (const raw of t.slice(COMMAND_MARK.length, end).split('\n')) {
+    // 头部每行可能带一个多余的 `*` 前缀，去掉它再按 key: value 解析。
+    const line = raw.trim().replace(/^\*\s?/, '');
+    if (!line) continue;
+    const idx = line.indexOf(':');
+    if (idx <= 0) {
+      errors.push(`头部这一行看不懂：${line}`);
+      continue;
+    }
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    switch (key) {
+      case 'name':
+        name = value;
+        break;
+      case 'description':
+        description = value;
+        break;
+      case 'returns':
+        returns = value;
+        break;
+      case 'readOnly':
+      case 'readonly':
+        readOnly = value.toLowerCase() === 'true';
+        break;
+      case 'arg':
+        {
+          const m = ARG_RE.exec(value);
+          if (m) {
+            args.push({
+              name: m[1],
+              type: m[2],
+              required: Boolean(m[3]),
+              description: (m[4] || '').trim(),
+            });
+          } else {
+            errors.push(`arg 要写作「名字 类型 [required] [- 说明]」，类型是 ${TYPES.join('/')}：${value}`);
+          }
+        }
+        break;
+      default:
+        errors.push(`头部有不认得的键 ${key}`);
+    }
+  }
+
+  const base = path.basename(file).replace(/\.js$/i, '');
+  if (name == null) errors.push('缺少 name');
+  else if (!NAME_RE.test(name)) errors.push('name 只能用小写字母、数字与下划线，以字母开头，至多 40 个字符');
+  else if (name !== base) errors.push(`name（${name}）必须与文件名（${base}.js）一致`);
+  if (description == null || description === '') errors.push('缺少 description');
+  else if ([...description].length > DESCRIPTION_LIMIT) errors.push(`description 超过 ${DESCRIPTION_LIMIT} 字`);
+  if (returns == null || returns === '') errors.push('缺少 returns');
+  if (readOnly === false) errors.push('站点命令只能只读，readOnly 不能是 false');
+  const dupNames = args.map((a) => a.name).filter((n, i, arr) => arr.indexOf(n) !== i);
+  for (const dup of new Set(dupNames)) errors.push(`arg ${dup} 重复`);
+  if (body === '') errors.push('脚本正文为空');
+  if (body.length > BODY_LIMIT) errors.push(`脚本正文 ${body.length} 字，超过 ${BODY_LIMIT}`);
+
+  const decl = errors.length === 0
+    ? { name, description, readOnly: true, returns, args, file }
+    : null;
+  return { decl, body, errors };
+}
+
+/** 值是否符合声明的类型。 */
+function fitsType(value, type) {
+  switch (type) {
+    case 'string':
+      return typeof value === 'string';
+    case 'boolean':
+      return typeof value === 'boolean';
+    case 'integer':
+      return typeof value === 'number' && Number.isInteger(value);
+    case 'number':
+      return typeof value === 'number' && Number.isFinite(value);
+    default:
+      return false;
+  }
+}
+
+/**
+ * 按声明校验一次调用的参数。没问题返回 null，有问题返回一句中文说明。
+ *
+ * @param {object} decl parseCommand 给出的命令声明
+ * @param {object} args 模型 / 调用方给的参数（名字 → 值）
+ */
+function validateCommand(decl, args) {
+  if (!decl || typeof decl !== 'object') return '命令声明无效';
+  const given = args && typeof args === 'object' && !Array.isArray(args) ? args : {};
+  const declared = new Map((decl.args || []).map((a) => [a.name, a]));
+  for (const key of Object.keys(given)) {
+    if (!declared.has(key)) {
+      const takes = (decl.args || []).map((a) => a.name).join('、') || '无参数';
+      return `'${key}' 不是 ${decl.name} 的参数；它接受 ${takes}`;
+    }
+  }
+  for (const arg of decl.args || []) {
+    const value = given[arg.name];
+    const missing = value === undefined || value === null;
+    if (missing) {
+      if (arg.required) return `${decl.name} 需要参数 '${arg.name}'（${arg.type}）`;
+      continue;
+    }
+    if (!fitsType(value, arg.type)) return `参数 '${arg.name}' 必须是 ${arg.type}`;
+  }
+  return null;
+}
+
+/**
+ * 读一个站点目录下的 `scripts/*.js`，把带命令头的解析成声明清单。
+ *
+ * 返回 `{ commands, errors }`：`commands` 是合法声明（按名字排序），`errors` 收下坏掉的命令
+ * 及其具体问题。目录不存在或某文件读坏了都只跳过，不抛。
+ *
+ * @param {string} siteDir 站点知识目录，如 `knowledge/sites/github.com`
+ */
+function listCommands(siteDir) {
+  const dir = path.join(String(siteDir || ''), 'scripts');
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return { commands: [], errors: [] };
+  }
+  const commands = [];
+  const errors = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith('.js')) continue;
+    let text;
+    try {
+      text = fs.readFileSync(path.join(dir, entry.name), 'utf8');
+    } catch {
+      continue;
+    }
+    if (!isCommand(text)) continue;
+    const rel = `scripts/${entry.name}`;
+    const parsed = parseCommand(rel, text);
+    if (parsed.decl) commands.push(parsed.decl);
+    else errors.push({ file: rel, errors: parsed.errors });
+  }
+  commands.sort((a, b) => a.name.localeCompare(b.name));
+  return { commands, errors };
+}
+
+/** 把一条命令声明写成知识块里的一行（供站点正文注入）。 */
+function formatCommandLine(decl) {
+  const sig = (decl.args || [])
+    .map((a) => `${a.name}${a.required ? '' : '?'}: ${a.type}`)
+    .join(', ');
+  const notes = (decl.args || [])
+    .filter((a) => a.description)
+    .map((a) => `${a.name} ${a.description}`)
+    .join('; ');
+  return `- ${decl.name}(${sig}): ${decl.description}。返回 ${decl.returns}`
+    + (notes ? `。参数：${notes}` : '');
+}
+
+module.exports = {
+  COMMAND_MARK,
+  NAME_RE,
+  TYPES,
+  DESCRIPTION_LIMIT,
+  BODY_LIMIT,
+  COMMAND_SCHEMA,
+  EXECUTION_CONTRACT,
+  isCommand,
+  parseCommand,
+  validateCommand,
+  listCommands,
+  formatCommandLine,
+};

package/lib/mobile/phone/step-summary.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/**
+ * 压缩时的**结构化步骤摘要**：目标 / 已确认事实（按种类去重）/ 进展行 / 更早结局计数 / 最后打算。
+ *
+ * 全从原话、工具结果与模型说过的话里**确定性**地取，**不调模型**。理由和 Mika 一样直白：
+ * 压缩每次都要重算摘要，调一次模型既多一次往返，同样的历史还可能得出不同的摘要——请求前缀
+ * 就不稳，缓存命中率跟着掉。摘要稳 = 前缀稳 = 省钱。
+ *
+ * 各段都有上限（事实每类 `MAX_FACT_VALUES` 个、进展 `MAX_PROGRESS` 行、更早结局 `MAX_EARLIER_KINDS`
+ * 种、单项截到 `CLIP` 字），步数再多摘要也不会无限变长。
+ *
+ * 输入沿用直播 / 历史清单的形状（`{ key, step }` 或裸 step 数组，step 里带
+ * `kind` / `name` / `summary` / `state`，可选 `args` / 结构化事实字段）。`render()` 产出的
+ * 是给模型读的确定性文本，可直接当压缩时折叠段的头。
+ */
+
+const MAX_FACT_VALUES = 4;
+const MAX_PROGRESS = 15;
+const MAX_EARLIER_KINDS = 5;
+const CLIP = 100;
+const OTHER = '其他';
+
+/** 结果里能当事实记下的短字段 → 事实种类（对齐 Mika StepSummary 的 FACT_KEYS）。 */
+const FACT_KEYS = [
+  ['currentApp', '去过的应用'],
+  ['app', '去过的应用'],
+  ['packageName', '去过的应用'],
+  ['url', '打开的页面'],
+  ['path', '读写的文件'],
+  ['file_path', '读写的文件'],
+];
+
+function clip(text, max = CLIP) {
+  const one = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+  if (one.length <= max) return one;
+  return `${one.slice(0, max - 1)}…`;
+}
+
+function normalizeEntry(entry) {
+  if (!entry || typeof entry !== 'object') return {};
+  return entry.step && typeof entry.step === 'object'
+    ? { key: entry.key, ...entry.step }
+    : entry;
+}
+
+function toStepList(run) {
+  const list = Array.isArray(run)
+    ? run
+    : (run && typeof run === 'object' && Array.isArray(run.steps) ? run.steps : null);
+  return list ? list.map(normalizeEntry) : [];
+}
+
+function labelOf(step) {
+  if (!step || typeof step !== 'object') return '';
+  if (typeof step.summary === 'string' && step.summary.trim() !== '') return clip(step.summary);
+  const args = step.args && typeof step.args === 'object' ? step.args : {};
+  for (const key of ['target', 'text', 'description', 'query', 'command', 'file_path', 'path', 'ref', 'packageName', 'url']) {
+    if (typeof args[key] === 'string' && args[key].trim() !== '') return clip(args[key]);
+  }
+  return clip(step.name || step.kind || '');
+}
+
+/** 状态 → 进展行末尾的结局词。 */
+function outcomeOf(step) {
+  const state = step && typeof step.state === 'string' ? step.state : '';
+  if (state === 'ok') return '成功';
+  if (state === 'error') return '失败';
+  if (state === 'stopped') return '中断';
+  if (state === 'running') return '未完成';
+  return '完成';
+}
+
+/** 工具名 → 从它这一步能确认的事实（路径 / 网址 / 应用）。 */
+function factsFromStep(step, out) {
+  if (!step || typeof step !== 'object') return;
+  // 优先用步骤/结果里已经结构化好的字段。
+  for (const [key, kind] of FACT_KEYS) {
+    const value = step[key] != null ? step[key]
+      : (step.result && typeof step.result === 'object' ? step.result[key] : undefined);
+    if (typeof value === 'string' && value.trim() !== '') {
+      pushFact(out, kind, value.trim());
+    }
+  }
+  // 退一步：从工具摘要里认（读写/编辑给的是路径，web_fetch 给的是网址）。
+  const args = step.args && typeof step.args === 'object' ? step.args : {};
+  if (step.name === 'web_fetch' && typeof args.url === 'string') pushFact(out, '打开的页面', args.url.trim());
+  if (['read', 'read_image', 'write', 'edit', 'str_replace_editor'].includes(step.name)) {
+    const path = args.file_path || args.path;
+    if (typeof path === 'string' && path.trim() !== '') pushFact(out, '读写的文件', path.trim());
+  }
+  if (step.name === 'phone_open_app' && typeof args.packageName === 'string') pushFact(out, '去过的应用', args.packageName.trim());
+}
+
+function pushFact(out, kind, value) {
+  const clipped = clip(value);
+  if (!clipped) return;
+  const list = out[kind] || [];
+  const next = list.filter((v) => v !== clipped).concat(clipped).slice(-MAX_FACT_VALUES);
+  out[kind] = next;
+}
+
+/**
+ * 生成结构化步骤摘要。
+ *
+ * @param {object|Array} steps 步骤流（见文件头）
+ * @param {{goal?:string, intent?:string}} [opts] 目标；`intent` 不传就从最后一段有内容的思考取
+ * @returns {{
+ *   goal:string, facts:Object<string,string[]>, progress:string[],
+ *   earlier:Object<string,number>, intent:string,
+ *   render:(header?:string)=>string
+ * }}
+ */
+function summarizeSteps(steps, opts) {
+  const list = toStepList(steps);
+  const goal = opts && typeof opts.goal === 'string' ? clip(opts.goal, 200) : '';
+
+  const facts = {};
+  const progress = [];
+  let lastThought = '';
+
+  for (const step of list) {
+    if (!step || typeof step !== 'object') continue;
+    if (step.kind === 'think') {
+      const label = labelOf(step);
+      if (label) lastThought = label;
+      continue;
+    }
+    const label = labelOf(step);
+    if (!label && !step.name) continue;
+    factsFromStep(step, facts);
+    progress.push(`${label || step.name} → ${outcomeOf(step)}`);
+  }
+
+  // 进展行超上限：最早的几行并进「更早结局计数」。
+  const earlier = {};
+  let p = progress;
+  while (p.length > MAX_PROGRESS) {
+    const out = p[0].substring(p[0].lastIndexOf('→ ') + 2).trim() || OTHER;
+    const key = (out in earlier || Object.keys(earlier).length < MAX_EARLIER_KINDS) ? out : OTHER;
+    earlier[key] = (earlier[key] || 0) + 1;
+    p = p.slice(1);
+  }
+
+  const intent = opts && typeof opts.intent === 'string' && opts.intent.trim() !== ''
+    ? clip(opts.intent)
+    : lastThought;
+
+  const summary = {
+    goal,
+    facts,
+    progress: p,
+    earlier,
+    intent,
+  };
+  summary.render = (header) => render(summary, header);
+  return summary;
+}
+
+/** 把摘要渲染成给模型读的确定性文本（无时间戳，保证前缀稳定）。 */
+function render(summary, header) {
+  const lines = [];
+  lines.push(typeof header === 'string' && header.trim() !== '' ? header.trim() : '【本轮进度摘要】');
+  lines.push('只有最新的用户消息是当前任务，工具仍然可用；更早的用户消息只作参考。');
+  lines.push(`目标：${summary.goal || '（未记录）'}`);
+  lines.push('已确认：');
+  const kinds = Object.keys(summary.facts);
+  if (kinds.length === 0) {
+    lines.push('- （暂无）');
+  } else {
+    for (const kind of kinds) lines.push(`- ${kind}：${summary.facts[kind].join('、')}`);
+  }
+  lines.push('进展：');
+  const earlierKeys = Object.keys(summary.earlier);
+  if (earlierKeys.length > 0) {
+    const total = earlierKeys.reduce((sum, k) => sum + summary.earlier[k], 0);
+    lines.push(`- 更早 ${total} 步：${earlierKeys.map((k) => `${k} ${summary.earlier[k]}`).join('，')}`);
+  }
+  if (summary.progress.length === 0) {
+    lines.push('- （暂无）');
+  } else {
+    for (const line of summary.progress) lines.push(`- ${line}`);
+  }
+  lines.push(summary.intent
+    ? `下一步：从下面保留的最近几步接着做（折叠前的最后打算：${summary.intent}）`
+    : '下一步：从下面保留的最近几步接着做');
+  return lines.join('\n');
+}
+
+module.exports = {
+  summarizeSteps,
+  render,
+  // 纯函数与小常量：
+  labelOf,
+  outcomeOf,
+  factsFromStep,
+  MAX_FACT_VALUES,
+  MAX_PROGRESS,
+  MAX_EARLIER_KINDS,
+  CLIP,
+};