jbc-dssi 1.1.7 → 1.1.9

package/cordis.patch.yml

@@ -67,3 +67,22 @@
 
         # 审批链路自测开关。默认关；验证审批时临时打开。
         allowSelfTest: false
+
+        # ---- 重启接续检查（2026-11-02，见 docs/架构/重启接续检查.md）----
+        # 自动重启 dsh web 后 2 分钟核验四项判据，并发一条群消息接续流程；
+        # 无本次重启记录（marker 不存在 / 是旧文件）时**静默不触发**。
+        # 默认开；`enabled: false` 一键关闭（插件配置在加载期读，下次重启生效）。
+        restart:
+          autocheck:
+            enabled: true
+            delayMs: 120000
+            marker: /tmp/dsh-restart-result.txt
+            cooldownMs: 21600000
+            notifyGroup: true
+            resumeSession: true
+            # 留空 = 自动选“最近活跃且设了主管的群”
+            groupId: ''
+            # 留空 = 用插件自身版本与仓库 version.json 比对；读不到 version.json 时退回“自身版本非空”
+            expectVersion: ''
+            # 工作区目录数下限（结构性判据，不用 mtime）：默认 0 = 只要求目录存在；可上调
+            minWorkspaces: 0

package/index.js

@@ -16,7 +16,9 @@ import net from 'node:net';
 import tls from 'node:tls';
 import fs from 'node:fs';
 import { randomUUID } from 'node:crypto';
+import { fileURLToPath } from 'node:url';
 import { watchUiConfig } from './lib/ui-config-push.js';
+import { createRestartAutocheck } from './lib/restart-autocheck.js';
 
 /*
  * ★ 协议层与瘦身层**直接引用 core**，本目录不再保有自己的副本。
@@ -95,6 +97,15 @@ try {
   console.log(`[mob-bridge] groups 模块未加载（群聊能力关闭）：${err?.message ?? err}`);
 }
 
+/** 插件自身版本（读 package.json；读不到返回空串，版本判据按"查不到=失败"处理）。 */
+function pluginVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version ?? '';
+  } catch {
+    return '';
+  }
+}
+
 export const name = 'jbc-dssi';
 
 /**
@@ -1389,6 +1400,40 @@ function activate(ctx, config) {
       server.close();
     };
   });
+
+  /*
+   * 重启接续检查（2026-11-02）：自动重启后 2 分钟核验四项判据并发一条消息。
+   * 口径见 docs/架构/重启接续检查.md；只读 marker、不改冻结脚本。
+   * 全程 try/catch：本机制只观测，任何异常都不得影响主流程（配对/中继/帧分发）。
+   */
+  let autocheck = null;
+  if (config.restart?.autocheck?.enabled !== false) {
+    try {
+      autocheck = createRestartAutocheck({
+        ctx,
+        log,
+        groups,
+        packageVersion: pluginVersion(),
+        config: {
+          ...(config.restart?.autocheck ?? {}),
+          dshWebPort: config.relay?.dshWebPort ?? 3080,
+          rootDir: typeof config.dssAgent?.rootDir === 'string' ? config.dssAgent.rootDir : undefined,
+          groupsStateFile: typeof config.groups?.stateFile === 'string' ? config.groups.stateFile : undefined,
+          deviceAuthFile,
+          packageRoot: fileURLToPath(new URL('.', import.meta.url)),
+          groupsDisabled: !groups,
+        },
+      });
+      autocheck.start();
+      log('[autocheck] 重启接续检查已启用（marker=/tmp/dsh-restart-result.txt）');
+    } catch (err) {
+      log(`[autocheck] 初始化失败（不影响主流程）：${err?.message ?? err}`);
+      autocheck = null;
+    }
+  } else {
+    log('[autocheck] 重启接续检查已关闭（restart.autocheck.enabled=false）');
+  }
+  if (typeof ctx.effect === 'function') ctx.effect(() => () => autocheck?.dispose?.());
 }
 
 /**

package/lib/restart-autocheck.js

@@ -0,0 +1,428 @@
+/**
+ * jbc-dssi/lib/restart-autocheck.js —— 重启接续检查（2026-11-02）。
+ *
+ * 背景：自动重启 dsh web 会掐断会话、没有新的触发源。本模块在**重启后 2 分钟**
+ * 自动核验重启是否真的成功，并以主管名义发一条简短群消息接续流程；失败则明确写
+ * "需人工介入"。设计与口径见 `docs/架构/重启接续检查.md`。
+ *
+ * 硬约束（遵守才允许上线）：
+ *   - 只读 `/tmp/dsh-restart-result.txt` 的 mtime，**不改冻结脚本** restart-dsh-web.py；
+ *   - 两道闸：marker 必须存在、且 mtime ≥ 本次进程启动−5s（否则 = 没有本次重启记录，
+ *     **静默跳过，绝不发"失败"消息**）；
+ *   - 幂等：sha256(markerMtime + ':' + pid) 前 16 hex；同 key 只触发一次；
+ *     marker mtime 相同的 6h 冷却（防崩溃重启循环刷屏）；
+ *   - 判据"查不到 = 失败"（假阳性最坏）；只有 groups 整体关闭时才记 N/A；
+ *   - 全程 try/catch，任何异常只记日志；定时器 unref()，不阻止进程退出。
+ *
+ * 本模块不 import `jbc-dssi/index.js`、不写 groups.json、不反向依赖调用方。
+ */
+
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { get } from 'node:http';
+import { connect } from 'node:net';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+/** 默认参数（与文档 §六 一致；配置段可覆盖）。 */
+const DEFAULTS = {
+  enabled: true,
+  delayMs: 120_000,
+  marker: '/tmp/dsh-restart-result.txt',
+  cooldownMs: 6 * 60 * 60_000,
+  notifyGroup: true,
+  resumeSession: true,
+  groupId: '',
+  dshWebPort: 3080,
+  /** 工作区目录数下限（默认 0 = 只要求目录存在；需要更严时由配置上调）。 */
+  minWorkspaces: 0,
+};
+
+/** marker mtime 允许比进程启动早多少毫秒（两者本就有约 12s 差，用 5s 会让旧文件挡掉；见文档 §一）。 */
+const PROCESS_START_TOLERANCE_MS = 5_000;
+
+/** 判据项 → 消息里的标记名。 */
+const MISSING_LABEL = {
+  process: 'process',
+  port: 'port',
+  version: 'version',
+  groups: 'baseline(groups)',
+  workspaces: 'baseline(workspaces)',
+  pairing: 'baseline(pairing)',
+};
+
+/**
+ * 触发判定（纯函数，单测直接钉边界）。
+ *
+ * @returns {{trigger:boolean, delayMs:number, reason:string}}
+ */
+export function planTrigger({ markerMtimeMs, processStartMs, now, delayMs = DEFAULTS.delayMs }) {
+  if (!Number.isFinite(markerMtimeMs) || markerMtimeMs <= 0) {
+    return { trigger: false, delayMs: 0, reason: 'marker-missing' };
+  }
+  if (markerMtimeMs < processStartMs - PROCESS_START_TOLERANCE_MS) {
+    return { trigger: false, delayMs: 0, reason: 'marker-older-than-process' };
+  }
+  const fireAt = markerMtimeMs + delayMs;
+  return { trigger: true, delayMs: Math.max(0, fireAt - now), reason: 'scheduled' };
+}
+
+/** 幂等 key：sha256(markerMtimeMs + ':' + pid) 前 16 hex。 */
+export function idempotencyKey(markerMtimeMs, pid, sha = (s) => createHash('sha256').update(s).digest('hex')) {
+  return sha(`${markerMtimeMs}:${pid}`).slice(0, 16);
+}
+
+/** 进程启动时刻（毫秒）：now − uptime。 */
+export function processStartMs(now = Date.now(), uptimeSec = process.uptime()) {
+  return Math.round(now - uptimeSec * 1000);
+}
+
+/** 成功消息（一行，模板见文档 §四）。 */
+export function formatSuccess({ pid, startedAt, version, checkedAt, versionFallback = false }) {
+  const hhmmss = new Date(checkedAt).toLocaleTimeString('zh-CN', { hour12: false });
+  return (
+    `✅ 重启已接续：PID ${pid}（${new Date(startedAt).toLocaleTimeString('zh-CN', { hour12: false })} 起）` +
+    `｜插件 ${version}${versionFallback ? '（版本对照 N/A）' : ''}｜3080 可连（401 正常）` +
+    `｜群数据/工作区/配对均未重置（自动核验 ${hhmmss}）`
+  );
+}
+
+/** 失败消息（≤2 行，明确"需人工介入" + 缺的判据）。 */
+export function formatFailure({ missing, evidence, checkedAt }) {
+  const hhmmss = new Date(checkedAt).toLocaleTimeString('zh-CN', { hour12: false });
+  const labels = missing.map((m) => MISSING_LABEL[m] ?? m).join('、');
+  return `⚠️ 重启未完成，需人工介入：缺 ${labels} 判据；证据：${evidence}。自动核验 ${hhmmss}`;
+}
+
+/**
+ * 造自动检查器。
+ *
+ * @param {object} opts
+ * @param {object} opts.ctx DSH 上下文（仅用 sessionController 公开方法）
+ * @param {Function} opts.log
+ * @param {object} [opts.config] `restart.autocheck` 配置段
+ * @param {object|null} [opts.groups] groups 引擎（可选；缺失时只跳过群消息/主管接续）
+ * @param {string} [opts.packageVersion] 插件自身版本
+ * @param {object} [opts.deps] 测试注入（clock/fs/net/通道）
+ */
+export function createRestartAutocheck({ ctx, log, config = {}, groups = null, packageVersion = '', deps = {} }) {
+  const cfg = { ...DEFAULTS, ...(config ?? {}) };
+  const now = deps.now ?? (() => Date.now());
+  const pid = deps.pid ?? process.pid;
+  const startMs = deps.processStartMs ?? (() => processStartMs(now()));
+  const statMarker = deps.statMarker ?? ((path) => statSync(path).mtimeMs);
+  const statePath = deps.statePath ?? join(homedir(), '.dsh', 'jbc-dssi', 'restart-autocheck.json');
+  const readState = deps.readState ?? (() => {
+    try { return JSON.parse(readFileSync(statePath, 'utf8')); } catch { return null; }
+  });
+  const writeState = deps.writeState ?? ((value) => {
+    try {
+      mkdirSync(dirname(statePath), { recursive: true });
+      writeFileSync(statePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+    } catch (err) {
+      log?.(`[autocheck] 写状态文件失败：${err?.message ?? err}`);
+    }
+  });
+  const probePort = deps.probePort ?? ((port) => probeHttp(port));
+  const checkBaseline = deps.checkBaseline ?? ((markerMtimeMs) => baselineCheck({ markerMtimeMs, config: cfg, log }));
+  const readExpectedVersion = deps.readExpectedVersion ?? (() => expectedVersionFromRepo(cfg));
+  const postGroupLine = deps.postGroupLine ?? (async (groupId, line) => groups?.postSystemLine?.(groupId, line));
+  const promptManager = deps.promptManager ?? (async (sessionId, text) => {
+    const controller = ctx?.sessionController;
+    if (!controller?.prompt || !sessionId) return false;
+    await controller.prompt(
+      { requestId: `autocheck-${pid}-${Math.round(now())}`, sessionId, mode: 'queue', content: [{ type: 'text', text }] },
+      AbortSignal.timeout(10_000),
+    );
+    return true;
+  });
+
+  let timer = null;
+  let disposed = false;
+  let inProcessFired = false;
+
+  /** 选一个可用的群：配置优先；否则最近活跃且设了主管的群。 */
+  async function pickGroupId() {
+    if (cfg.groupId) return cfg.groupId;
+    try {
+      const snap = await groups?.snapshot?.();
+      const list = Array.isArray(snap?.groups) ? snap.groups : [];
+      return list.find((g) => g?.managerId)?.id ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /** 执行一次核验（触发后调用；异常一律吞掉，只落日志）。 */
+  async function runCheck(markerMtimeMs) {
+    const checkedAt = now();
+    const missing = [];
+    const evidence = [];
+    const version = String(packageVersion ?? '');
+    const expected = String(cfg.expectVersion || readExpectedVersion() || '');
+    /** 判据 1：进程已换新（marker 不早于本次启动）。 */
+    const startedAt = startMs();
+    if (!(markerMtimeMs >= startedAt - PROCESS_START_TOLERANCE_MS)) missing.push('process');
+    evidence.push(`pid=${pid}`, `start=${new Date(startedAt).toISOString()}`);
+
+    /** 判据 2：3080 可访问（TCP + GET /，status<500 即活；401 是鉴权常态）。 */
+    try {
+      const alive = await probePort(Number(cfg.dshWebPort ?? 3080));
+      evidence.push(`port=${cfg.dshWebPort}:${alive ? 'ok' : 'fail'}`);
+      if (!alive) missing.push('port');
+    } catch (err) {
+      evidence.push(`port=${cfg.dshWebPort}:error(${err?.message ?? err})`);
+      missing.push('port');
+    }
+
+    /** 判据 3：插件版本符合（读不到 version.json → 退回"自身版本非空"并注明）。 */
+    let versionFallback = false;
+    if (!version) {
+      missing.push('version');
+      evidence.push('version=empty');
+    } else if (expected) {
+      if (version !== expected) {
+        missing.push('version');
+        evidence.push(`version=${version}!==${expected}`);
+      } else {
+        evidence.push(`version=${version}`);
+      }
+    } else {
+      versionFallback = true;
+      evidence.push(`version=${version}(no version.json)`);
+    }
+
+    /** 判据 4：数据基线未重置（查不到=失败；groups 整体关闭才 N/A）。 */
+    try {
+      const baseline = checkBaseline(markerMtimeMs);
+      evidence.push(...baseline.evidence);
+      if (!baseline.skipped) missing.push(...baseline.missing);
+    } catch (err) {
+      missing.push('groups');
+      evidence.push(`baseline=error(${err?.message ?? err})`);
+    }
+
+    const ok = missing.length === 0;
+    const text = ok
+      ? formatSuccess({ pid, startedAt, version, checkedAt, versionFallback })
+      : formatFailure({ missing: [...new Set(missing)], evidence: evidence.join(' '), checkedAt });
+
+    /** 通道 1：群消息（以主管身份落一行；posts 后返回主管会话信息，供通道 2 复用）。 */
+    let groupInfo = null;
+    if (cfg.notifyGroup) {
+      try {
+        const groupId = await pickGroupId();
+        if (groupId) groupInfo = await postGroupLine(groupId, { text, auto: true });
+        else log?.('[autocheck] 找不到可发消息的群，跳过群消息');
+      } catch (err) {
+        log?.(`[autocheck] 群消息发送失败（不影响主流程）：${err?.message ?? err}`);
+      }
+    }
+
+    /** 通道 2：内部事件（接续流程，不产生群气泡；取不到主管会话就跳过）。 */
+    if (cfg.resumeSession) {
+      try {
+        if (!groupInfo) {
+          const groupId = await pickGroupId();
+          groupInfo = groupId ? await postGroupLine(groupId, { silent: true }) : null;
+        }
+        const sessionId = groupInfo?.managerSessionId ?? null;
+        if (sessionId) {
+          await promptManager(sessionId, `【自动接续】${text}`);
+          log?.(`[autocheck] 已向主管会话 ${sessionId} 投递接续事件`);
+        } else {
+          log?.('[autocheck] 取不到主管会话，跳过内部接续');
+        }
+      } catch (err) {
+        log?.(`[autocheck] 内部接续失败（不影响主流程）：${err?.message ?? err}`);
+      }
+    }
+
+    writeState({ key: idempotencyKey(markerMtimeMs, pid), markerMtime: markerMtimeMs, checkedAt, ok, missing, version });
+    log?.(`[autocheck] 核验完成 ok=${ok} missing=[${missing.join(',')}] markerMtime=${markerMtimeMs}`);
+    return { ok, missing, text, checkedAt };
+  }
+
+  /** 起定时器；不满足两道闸时静默跳过（只打一行日志）。 */
+  function start() {
+    if (!cfg.enabled) {
+      log?.('[autocheck] 已关闭（restart.autocheck.enabled=false），不读 marker、不起定时器');
+      return;
+    }
+    let markerMtimeMs = NaN;
+    try {
+      markerMtimeMs = statMarker(cfg.marker);
+    } catch {
+      log?.(`[autocheck] 无重启记录（marker 不存在）：${cfg.marker}，静默跳过`);
+      return;
+    }
+    const decision = planTrigger({ markerMtimeMs, processStartMs: startMs(), now: now(), delayMs: cfg.delayMs });
+    if (!decision.trigger) {
+      log?.(`[autocheck] 无本次重启记录（${decision.reason}），静默跳过`);
+      return;
+    }
+    const key = idempotencyKey(markerMtimeMs, pid);
+    const state = readState();
+    if (state?.key === key) {
+      log?.(`[autocheck] 同一次重启已核验过（key=${key}），跳过`);
+      return;
+    }
+    if (state?.markerMtime === markerMtimeMs && now() - Number(state.checkedAt ?? 0) < cfg.cooldownMs) {
+      log?.('[autocheck] 同 marker 在冷却期内已核验，跳过（防重启循环刷屏）');
+      return;
+    }
+    log?.(`[autocheck] 排定核验：${Math.round(decision.delayMs / 1000)}s 后（markerMtime=${markerMtimeMs}）`);
+    timer = setTimeout(() => {
+      timer = null;
+      if (disposed) return;
+      void runCheck(markerMtimeMs).catch((err) => {
+        log?.(`[autocheck] 核验异常（不影响主流程）：${err?.message ?? err}`);
+      });
+    }, decision.delayMs);
+    timer.unref?.();
+  }
+
+  function dispose() {
+    disposed = true;
+    if (timer) { clearTimeout(timer); timer = null; }
+  }
+
+  /** 仅供单测：直接触发一次核验（绕过定时器）。 */
+  async function checkNow(markerMtimeMs) {
+    if (inProcessFired) return { ok: false, skipped: true };
+    inProcessFired = true;
+    return runCheck(markerMtimeMs);
+  }
+
+  return { start, dispose, checkNow, config: cfg };
+}
+
+/** TCP 连通 + GET /（status<500 即算活着；401 是鉴权常态）。导出供单测直接覆盖本体。 */
+export function probeHttp(port, timeoutMs = 1_200) {
+  return new Promise((resolve) => {
+    const socket = connect({ host: '127.0.0.1', port, timeout: timeoutMs });
+    let settled = false;
+    const done = (alive) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(alive);
+    };
+    socket.once('connect', () => {
+      try {
+        const req = get({ host: '127.0.0.1', port, path: '/', timeout: timeoutMs }, (res) => {
+          res.resume();
+          done(Number(res.statusCode ?? 0) < 500);
+        });
+        req.on('timeout', () => { req.destroy(); done(false); });
+        req.on('error', () => done(false));
+      } catch {
+        done(false);
+      }
+    });
+    socket.once('timeout', () => done(false));
+    socket.once('error', () => done(false));
+  });
+}
+
+/**
+ * 数据基线（**结构性判据，绝不用 mtime**）—— 2026-11-02 测测姐阻断项修复。
+ *
+ * 旧口径（被拦下）：用 `mtime < markerMtime` 判"未重置"。但重启后 2 分钟窗口里，
+ * 用户/主管正常发一条群消息就会写 `groups.json` → mtime 变新 → 被误判成"数据重置"，
+ * 于是第一次实战会发**假的**"需人工介入"。这与"假成功通知"同等有害。
+ *
+ * 新口径（本函数）：
+ *   ① `groups.json`：存在 + **可 JSON 解析** + 结构完好（`groups` 数组、`rooms`/`groupSessions`
+ *      对象、每个群有 id/name）；**群数为 0 也算正常**（新装用户合法），mtime 不参与判定；
+ *   ② `workspaces/`：目录存在且可读 + 顶层目录数 ≥ `minWorkspaces`（默认 1，可配置；
+ *      删掉"魔法数 6"）；
+ *   ③ `authorized-device.json`：存在 + 非空 + 可解析 + `deviceId`/`deviceName`/`authorizedAt`
+ *      三个关键字段非空。
+ *
+ * 判据纪律不变：**查不到/解析失败 = 失败**（唯一例外：groups 模块整体关闭 → 记 N/A）。
+ */
+export function baselineCheck({ markerMtimeMs, config, log }) {
+  const missing = [];
+  const evidence = [];
+
+  // ① groups.json：结构校验（mtime 一律不参与）
+  const rootDir = String(config.rootDir || join(homedir(), '.dssAgent'));
+  const groupsFile = String(config.groupsStateFile || join(rootDir, 'jbc-groups', 'groups.json'));
+  if (config.groupsDisabled === true) {
+    evidence.push('groups=N/A(模块关闭)');
+  } else {
+    try {
+      const raw = readFileSync(groupsFile, 'utf8');
+      if (!raw.trim()) {
+        missing.push('groups');
+        evidence.push('groups.json=empty');
+      } else {
+        const json = JSON.parse(raw);
+        const shaped = Boolean(json) && typeof json === 'object'
+          && Array.isArray(json.groups)
+          && json.rooms !== null && typeof json.rooms === 'object'
+          && json.groupSessions !== null && typeof json.groupSessions === 'object';
+        const groupsOk = !shaped || json.groups.every((g) => g && typeof g.id === 'string' && typeof g.name === 'string');
+        evidence.push(`groups.json=groups:${Array.isArray(json?.groups) ? json.groups.length : '?'},shape:${shaped && groupsOk}`);
+        if (!shaped || !groupsOk) missing.push('groups');
+      }
+    } catch (err) {
+      missing.push('groups');
+      evidence.push(`groups.json=unreadable(${err?.message ?? err})`);
+    }
+  }
+
+  // ② workspaces：存在 + 目录数 ≥ 可配置下限（默认 1，替代旧的魔法数 6）
+  const workspacesDir = join(rootDir, 'workspaces');
+  const floor = Number.isFinite(Number(config.minWorkspaces)) ? Number(config.minWorkspaces) : 0;
+  try {
+    const count = readdirSync(workspacesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).length;
+    evidence.push(`workspaces=${count}(floor:${floor})`);
+    if (count < floor) missing.push('workspaces');
+  } catch (err) {
+    evidence.push(`workspaces=missing(${err?.code ?? err?.message ?? err})`);
+    missing.push('workspaces');
+  }
+
+  // ③ 配对凭据：存在 + 非空 + 可解析 + 关键字段非空
+  const deviceFile = String(config.deviceAuthFile || join(homedir(), '.dsh', 'jbc-dssi', 'authorized-device.json'));
+  try {
+    const raw = readFileSync(deviceFile, 'utf8');
+    const json = JSON.parse(raw);
+    const fieldsOk = Boolean(json) && typeof json === 'object'
+      && typeof json.deviceId === 'string' && json.deviceId.length > 0
+      && typeof json.deviceName === 'string' && json.deviceName.length > 0
+      && typeof json.authorizedAt === 'string' && json.authorizedAt.length > 0;
+    evidence.push(`authorized-device.json=fields:${fieldsOk}`);
+    if (!fieldsOk) missing.push('pairing');
+  } catch (err) {
+    evidence.push(`authorized-device.json=unreadable(${err?.code ?? err?.message ?? err})`);
+    missing.push('pairing');
+  }
+
+  log?.(`[autocheck] 基线结构校验 missing=[${missing.join(',')}] ${evidence.join(' ')}`);
+  return { missing, evidence, skipped: false };
+}
+
+/** 从插件目录向上找仓库 `version.json`（dev 仓库场景）；找不到返回 null。 */
+function expectedVersionFromRepo(config) {
+  try {
+    let dir = config.packageRoot || null;
+    if (!dir) return null;
+    for (let i = 0; i < 5; i += 1) {
+      const candidate = join(dir, 'version.json');
+      if (existsSync(candidate)) {
+        const json = JSON.parse(readFileSync(candidate, 'utf8'));
+        // 仓库 version.json 的字段名是 versionName（不是 version），两者都认
+        return json.versionName ?? json.version ?? null;
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jbc-dssi",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "type": "module",
   "description": "鲸编程 - 不只是手机遥控操作电脑,而是将电脑级的Agent能力装进手机",
   "keywords": [