@ondevplann/remotetype 0.2.0 → 0.3.0

package/bin/index.js

@@ -230,6 +230,59 @@ async function cmdServe(cfg) {
   // 本批按键计划中注入失败过的 seq：commit 到来时走 commitFailed
   // （mirror 不推进、重试），而不是 commitApplied（误以为已注入 → 永久错位）
   const failedAlignSeqs = new Set();
+  // 焦点绑定：首个成功注入的窗口标识记为对齐目标，之后每条 op 携带
+  // expect_focus 校验；rust 拒注时挂起 align 会话+通知手机，避免
+  // 电脑切焦点后误删误打。新会话（对齐模式）建立时重置。
+  let focusTarget = null;
+  let focusPaused = false;
+  let focusPollTimer = null;
+
+  /** 焦点匹配成功：首次绑定，后续直接用。每次顺手更新到目标（target 句柄可能跨进程稳定）。 */
+  function bindFocus(current) {
+    if (current && !focusTarget) {
+      focusTarget = current;
+      logger.info('焦点已绑定（首个注入目标）', { target: focusTarget });
+    }
+  }
+
+  /** 焦点漂移：挂起 align 会话 + 通知手机 + 启动轮询。同一 seq 走 commitFailed 不推进 mirror。 */
+  function handleFocusDrift(seq, currentFocus) {
+    if (focusPaused) return; // 已经在挂起，重复漂移不重复发 ctrl
+    focusPaused = true;
+    logger.warn('焦点漂移，注入已暂停', { target: focusTarget, current: currentFocus, seq });
+    if (seq !== undefined) failedAlignSeqs.add(seq);
+    if (align) align.pause();
+    // 通知手机：把 ctrl 信封通过 sendAck 同一个 transport 推上去（共用 c2p 方向）
+    if (align?.sendCtrl) {
+      align.sendCtrl('focus-paused').catch((e) => logger.warn('ctrl 通知失败', { error: e.message }));
+    }
+    // 启动轮询：每 2s 询问 rust 当前焦点，回到目标则恢复
+    focusPollTimer = setInterval(() => {
+      agent.send({ action: 'focus' }, cfg.requestTimeoutMs)
+        .then((res) => {
+          if (res?.focus && res.focus === focusTarget) {
+            resumeFromFocus();
+          }
+        })
+        .catch((e) => logger.debug('焦点轮询失败', { error: e.message }));
+    }, 2000);
+    focusPollTimer.unref?.();
+  }
+
+  /** 焦点回归：取消轮询、通知手机、恢复 align 会话（会重新 dispatch 当前 desired）。 */
+  function resumeFromFocus() {
+    if (!focusPaused) return;
+    focusPaused = false;
+    if (focusPollTimer) {
+      clearInterval(focusPollTimer);
+      focusPollTimer = null;
+    }
+    logger.info('焦点已恢复，注入恢复', { target: focusTarget });
+    if (align?.sendCtrl) {
+      align.sendCtrl('focus-resumed').catch((e) => logger.warn('ctrl 通知失败', { error: e.message }));
+    }
+    if (align) align.resume();
+  }
 
   // ---- 消息队列：串行消费，逐条注入 ----
   // serve 明文模式 item = {text, clientId}；对齐模式 item =
@@ -255,11 +308,16 @@ async function cmdServe(cfg) {
 
       // backspace：删除原语（relay 对齐模式）
       if (item.op === 'backspace') {
+        const expectFocus = meta.source === 'align' ? focusTarget : null;
         try {
-          const res = await agent.backspace(item.count);
+          const res = await agent.backspace(item.count, cfg.requestTimeoutMs, expectFocus);
           if (res?.ok) {
             logger.debug('退格完成', { count: item.count, queueWaitMs });
             store.append({ status: 'backspaced', count: item.count, source: meta.source, seq: item.seq });
+            if (meta.source === 'align') bindFocus(res.focus);
+          } else if (res?.msg === 'focus_drift') {
+            handleFocusDrift(item.seq, res.focus);
+            store.append({ status: 'backspace_focus_drift', count: item.count, source: meta.source, seq: item.seq, currentFocus: res.focus });
           } else {
             logger.error('退格失败', { count: item.count, msg: res?.msg });
             if (item.seq !== undefined) failedAlignSeqs.add(item.seq);
@@ -274,8 +332,14 @@ async function cmdServe(cfg) {
       }
 
       // type：常规文本注入（serve 与 relay 共用，relay 的 text 是 diff 出的增量）
-      // 二次预处理：即便上游已过滤，这里仍是最后一道防线
-      const cleaned = sanitize(item.text, { maxLength: cfg.maxTextLength });
+      // 二次预处理：即便上游已过滤，这里仍是最后一道防线。
+      // 对齐模式保留纯空白：换行/空格是手机输入框的真实内容（IME 自动插入的
+      // 换行不该被判失败挂起整批计划），见 sanitize 的 keepWhitespace。
+      const isAlignSource = meta.source === 'align';
+      const cleaned = sanitize(item.text, {
+        maxLength: cfg.maxTextLength,
+        keepWhitespace: isAlignSource,
+      });
       if (!cleaned.ok) {
         logger.warn('文本预处理后丢弃', { reason: cleaned.reason, clientId: item.clientId });
         if (meta.source === 'align' && item.seq !== undefined) failedAlignSeqs.add(item.seq);
@@ -289,6 +353,11 @@ async function cmdServe(cfg) {
         });
         return;
       }
+      if (isAlignSource && cleaned.text.length === 0) {
+        // 整条只含不可见字符：无可注入内容，也不算失败——commit 仍会推进 mirror
+        logger.debug('对齐空操作（仅不可见字符），跳过注入', { seq: item.seq });
+        return;
+      }
       if (cleaned.truncated) {
         logger.warn('文本超长已截断', {
           originalLength: cleaned.originalLength,
@@ -305,10 +374,12 @@ async function cmdServe(cfg) {
       });
 
       try {
-        const res = await agent.typeText(cleaned.text);
+        const expectFocus = isAlignSource ? focusTarget : null;
+        const res = await agent.typeText(cleaned.text, cfg.requestTimeoutMs, expectFocus);
         const durationMs = Date.now() - startedAt;
         if (res?.ok) {
           logger.info('注入完成', { durationMs, textLen: cleaned.text.length });
+          if (isAlignSource) bindFocus(res.focus);
           store.append({
             text: cleaned.text,
             status: 'injected',
@@ -318,6 +389,17 @@ async function cmdServe(cfg) {
             durationMs,
             truncated: Boolean(cleaned.truncated),
           });
+        } else if (res?.msg === 'focus_drift' && isAlignSource) {
+          handleFocusDrift(item.seq, res.focus);
+          store.append({
+            text: cleaned.text,
+            status: 'inject_focus_drift',
+            clientId: item.clientId,
+            source: meta.source,
+            queueWaitMs,
+            durationMs,
+            currentFocus: res.focus,
+          });
         } else {
           logger.error('注入失败', { msg: res?.msg, durationMs });
           if (meta.source === 'align' && item.seq !== undefined) failedAlignSeqs.add(item.seq);

package/lib/agent.js

@@ -326,16 +326,18 @@ class AgentManager {
     });
   }
 
-  /** 便捷方法：注入文本。 */
-  async typeText(text, timeoutMs) {
-    const res = await this.send({ action: 'type_text', text }, timeoutMs);
-    return res;
+  /** 便捷方法：注入文本。`expectFocus` 对齐模式校验：与当前焦点不符则 rust 拒注并回 focus_drift。 */
+  async typeText(text, timeoutMs, expectFocus = null) {
+    const payload = { action: 'type_text', text };
+    if (expectFocus) payload.expect_focus = expectFocus;
+    return this.send(payload, timeoutMs);
   }
 
-  /** 便捷方法：向焦点输入框发送 N 次退格（relay 对齐模式的删除原语）。 */
-  async backspace(count, timeoutMs) {
-    const res = await this.send({ action: 'backspace', count }, timeoutMs);
-    return res;
+  /** 便捷方法：向焦点输入框发送 N 次退格。`expectFocus` 同上：漂移时拒退格。 */
+  async backspace(count, timeoutMs, expectFocus = null) {
+    const payload = { action: 'backspace', count };
+    if (expectFocus) payload.expect_focus = expectFocus;
+    return this.send(payload, timeoutMs);
   }
 
   /** 优雅关闭：结束 stdin -> 等待退出 -> 超时强杀。 */

package/lib/rt-align.js

@@ -78,6 +78,7 @@ class RtAlignSession extends EventEmitter {
     this.pendingFails = 0;     // 当前 desired 连续注入失败次数（成功 commit 或新快照归零）
     this.ackSeq = 0;
     this.sid = crypto.randomBytes(4).toString('hex');
+    this.paused = false;       // 焦点漂移期间挂起（focus-paused），挂起期间 _dispatch 直接丢弃
 
     this.stats = {
       envelopesOk: 0, envelopesBad: 0, syncsApplied: 0, acksSent: 0, plaintextRejected: 0,
@@ -157,7 +158,7 @@ class RtAlignSession extends EventEmitter {
    * busy 期间只更新 desiredText，commit 后自动续跑（全文快照语义下永远收敛）。
    */
   _dispatch() {
-    if (this.busy || this.desiredText === null) return;
+    if (this.busy || this.paused || this.desiredText === null) return;
     const plan = planTransition(this.mirror, this.desiredText);
     if (plan.backspaces === 0 && plan.insert === '') {
       // 目标已达成（重复快照），仍需补 ACK 推进手机端确认
@@ -248,6 +249,52 @@ class RtAlignSession extends EventEmitter {
     this.busySince = 0;
     this._dispatch();
   }
+
+  // ================= 挂起/恢复（焦点漂移） =================
+
+  /** 挂起对齐会话：焦点漂移期间停止派发按键计划，避免误删误打。 */
+  pause() {
+    if (this.paused) return;
+    this.paused = true;
+    this.logger?.info('align session paused (focus drift)');
+  }
+
+  /**
+   * 恢复对齐会话：重新派发当前 desired，焦点已回归到目标输入框。
+   * 关键：desiredText / desiredSeq 都保留着（之前的快照），所以新一次
+   * dispatch 从当前 mirror 重新 diff，自然处理「挂起期间手机又改了几个字」。
+   */
+  resume() {
+    if (!this.paused) return;
+    this.paused = false;
+    this.logger?.info('align session resumed (focus restored)');
+    if (this.desiredText !== null) this._dispatch();
+  }
+
+  /**
+   * 发送 ctrl 信封到手机（共用 sendAck 同一传输层 + keyPcToPhone 方向，
+   * 走 c2p 单调 seq 域：手机端会判 ackSeq 顺序与去重）。
+   * @param {string} event 事件名，如 'focus-paused' / 'focus-resumed'
+   */
+  sendCtrl(event) {
+    if (typeof this._sendAckTransport !== 'function') return Promise.resolve();
+    this.ackSeq += 1;
+    const envelope = seal(
+      this.keyPcToPhone,
+      buildAad(this.room, DIR_C2P, this.ackSeq),
+      { event, ts: Date.now() },
+      { sid: this.sid, seq: this.ackSeq },
+    );
+    return new Promise((resolve) => {
+      try {
+        this._sendAckTransport(envelope);
+        this.logger?.info('ctrl sent', { event, seq: this.ackSeq });
+      } catch (e) {
+        this.logger?.warn('ctrl send failed', { event, error: e.message });
+      }
+      resolve();
+    });
+  }
 }
 
 module.exports = { RtAlignSession, looksLikeEnvelope };

package/lib/sanitize.js

@@ -32,10 +32,14 @@ function isInvisible(c) {
  * @param {string} raw
  * @param {object} [opts]
  * @param {number} [opts.maxLength]
+ * @param {boolean} [opts.keepWhitespace] 保留纯空白文本（对齐模式用：
+ *   换行/空格是手机输入框的真实内容，整条空白不算「空文本」；
+ *   返回 ok:true 且 text 可能为空串，由调用方决定是否为无操作）
  * @returns {{ok:boolean, text:string, reason?:string, truncated?:boolean, originalLength?:number}}
  */
 function sanitize(raw, opts = {}) {
   const maxLength = opts.maxLength ?? DEFAULT_MAX_LENGTH;
+  const keepWhitespace = opts.keepWhitespace === true;
 
   if (typeof raw !== 'string') {
     return { ok: false, text: '', reason: 'not_a_string' };
@@ -52,8 +56,8 @@ function sanitize(raw, opts = {}) {
   // 2) 统一换行，避免 \r\n 造成目标程序出现多余字符
   text = text.replace(/\r\n?/g, '\n');
 
-  // 3) 空文本丢弃
-  if (text.trim().length === 0) {
+  // 3) 空文本丢弃（keepWhitespace 时跳过：空白是对齐语义下的有效内容）
+  if (!keepWhitespace && text.trim().length === 0) {
     return { ok: false, text: '', reason: 'empty_after_clean', originalLength };
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ondevplann/remotetype",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "RemoteType PC 客户端：npx 一键启动，接收手机端语音识别文本并注入到当前焦点输入框",
   "bin": {
     "remotetype": "./bin/index.js"
@@ -22,8 +22,10 @@
     "ws": "^8.18.0"
   },
   "optionalDependencies": {
-    "@ondevplann/input-agent-win32-x64": "0.1.0",
-    "@ondevplann/input-agent-linux-x64": "0.1.0"
+    "@ondevplann/input-agent-win32-x64": "0.2.0",
+    "@ondevplann/input-agent-darwin-x64": "0.2.0",
+    "@ondevplann/input-agent-darwin-arm64": "0.2.0",
+    "@ondevplann/input-agent-linux-x64": "0.2.0"
   },
   "engines": {
     "node": ">=18.0.0"