@ondevplann/remotetype 0.1.2 → 0.2.0

package/lib/queue.js

@@ -1,141 +1,141 @@
-'use strict';
-
-/**
- * FIFO 消息队列：串行消费，保证「一条输入完成再处理下一条」（需求文档 4.2.2 第 2 条）。
- *
- * 要点：
- *   * 严格 FIFO，绝不并发下发，避免字符交叉乱序；
- *   * 有界队列，超出容量时丢弃新消息并告警（丢弃新消息而非旧消息，
- *     因为旧消息已经在途、语义上更接近用户已完成的操作）；
- *   * 对外暴露 pause / resume，便于断线或重启子进程时挂起消费。
- */
-
-class MessageQueue {
-  /**
-   * @param {object} opts
-   * @param {number} [opts.maxSize]          最大排队条数
-   * @param {Function} opts.handler          消费函数 async (item, meta) => void
-   * @param {object} opts.logger
-   */
-  constructor(opts) {
-    this.maxSize = opts.maxSize ?? 100;
-    this.handler = opts.handler;
-    this.logger = opts.logger;
-
-    this._queue = [];
-    this._running = false;
-    this._paused = false;
-    this._idleWaiters = [];
-
-    this.stats = { enqueued: 0, processed: 0, failed: 0, dropped: 0, maxDepthSeen: 0 };
-  }
-
-  /** 当前排队深度（不含正在处理的那条）。 */
-  get depth() {
-    return this._queue.length;
-  }
-
-  get busy() {
-    return this._running;
-  }
-
-  /**
-   * 入队一条消息。
-   * @returns {boolean} true=已入队，false=因队列满被丢弃
-   */
-  push(item, meta = {}) {
-    if (this._queue.length >= this.maxSize) {
-      this.stats.dropped += 1;
-      this.logger?.warn('message queue overflow, dropping new message', {
-        maxSize: this.maxSize,
-        textLen: typeof item?.text === 'string' ? item.text.length : 0,
-      });
-      return false;
-    }
-    this._queue.push({ item, meta });
-    this.stats.enqueued += 1;
-    if (this._queue.length > this.stats.maxDepthSeen) {
-      this.stats.maxDepthSeen = this._queue.length;
-    }
-    this.logger?.debug('message enqueued', { depth: this._queue.length });
-    // 触发消费（不 await，避免调用方被阻塞）
-    this._drain();
-    return true;
-  }
-
-  /** 暂停消费：已在途的那条会跑完，后续不再取新消息。 */
-  pause() {
-    this._paused = true;
-    this.logger?.debug('queue paused');
-  }
-
-  /** 恢复消费。 */
-  resume() {
-    if (!this._paused) return;
-    this._paused = false;
-    this.logger?.debug('queue resumed', { depth: this._queue.length });
-    this._drain();
-  }
-
-  /** 清空队列，返回被清掉的条数。 */
-  clear(reason = 'cleared') {
-    const n = this._queue.length;
-    this._queue = [];
-    if (n > 0) this.logger?.warn('queue cleared', { count: n, reason });
-    return n;
-  }
-
-  /** 等待队列彻底空闲（含正在处理的那条）。 */
-  async waitIdle(timeoutMs = 30000) {
-    if (!this._running && this._queue.length === 0) return true;
-    return new Promise((resolve) => {
-      const timer = setTimeout(() => resolve(false), timeoutMs);
-      timer.unref?.();
-      this._idleWaiters.push(() => {
-        clearTimeout(timer);
-        resolve(true);
-      });
-    });
-  }
-
-  _notifyIdle() {
-    if (this._running || this._queue.length > 0) return;
-    const waiters = this._idleWaiters;
-    this._idleWaiters = [];
-    for (const w of waiters) w();
-  }
-
-  /** 串行消费主循环。 */
-  async _drain() {
-    if (this._running) return;      // 已有消费者在跑，保证只有一条在途
-    if (this._paused) return;
-    if (this._queue.length === 0) {
-      this._notifyIdle();
-      return;
-    }
-
-    this._running = true;
-    try {
-      while (!this._paused && this._queue.length > 0) {
-        const { item, meta } = this._queue.shift();
-        try {
-          // 顺序 await：这是「串行」的关键
-          await this.handler(item, meta);
-          this.stats.processed += 1;
-        } catch (e) {
-          this.stats.failed += 1;
-          this.logger?.error('queue handler failed', {
-            error: e.message,
-            textLen: typeof item?.text === 'string' ? item.text.length : 0,
-          });
-          // 单条失败不影响后续消息
-        }
-      }
-    } finally {
-      this._running = false;
-    }
-    this._notifyIdle();
-  }
-}
-
-module.exports = { MessageQueue };
+'use strict';
+
+/**
+ * FIFO 消息队列：串行消费，保证「一条输入完成再处理下一条」（需求文档 4.2.2 第 2 条）。
+ *
+ * 要点：
+ *   * 严格 FIFO，绝不并发下发，避免字符交叉乱序；
+ *   * 有界队列，超出容量时丢弃新消息并告警（丢弃新消息而非旧消息，
+ *     因为旧消息已经在途、语义上更接近用户已完成的操作）；
+ *   * 对外暴露 pause / resume，便于断线或重启子进程时挂起消费。
+ */
+
+class MessageQueue {
+  /**
+   * @param {object} opts
+   * @param {number} [opts.maxSize]          最大排队条数
+   * @param {Function} opts.handler          消费函数 async (item, meta) => void
+   * @param {object} opts.logger
+   */
+  constructor(opts) {
+    this.maxSize = opts.maxSize ?? 100;
+    this.handler = opts.handler;
+    this.logger = opts.logger;
+
+    this._queue = [];
+    this._running = false;
+    this._paused = false;
+    this._idleWaiters = [];
+
+    this.stats = { enqueued: 0, processed: 0, failed: 0, dropped: 0, maxDepthSeen: 0 };
+  }
+
+  /** 当前排队深度（不含正在处理的那条）。 */
+  get depth() {
+    return this._queue.length;
+  }
+
+  get busy() {
+    return this._running;
+  }
+
+  /**
+   * 入队一条消息。
+   * @returns {boolean} true=已入队，false=因队列满被丢弃
+   */
+  push(item, meta = {}) {
+    if (this._queue.length >= this.maxSize) {
+      this.stats.dropped += 1;
+      this.logger?.warn('message queue overflow, dropping new message', {
+        maxSize: this.maxSize,
+        textLen: typeof item?.text === 'string' ? item.text.length : 0,
+      });
+      return false;
+    }
+    this._queue.push({ item, meta });
+    this.stats.enqueued += 1;
+    if (this._queue.length > this.stats.maxDepthSeen) {
+      this.stats.maxDepthSeen = this._queue.length;
+    }
+    this.logger?.debug('message enqueued', { depth: this._queue.length });
+    // 触发消费（不 await，避免调用方被阻塞）
+    this._drain();
+    return true;
+  }
+
+  /** 暂停消费：已在途的那条会跑完，后续不再取新消息。 */
+  pause() {
+    this._paused = true;
+    this.logger?.debug('queue paused');
+  }
+
+  /** 恢复消费。 */
+  resume() {
+    if (!this._paused) return;
+    this._paused = false;
+    this.logger?.debug('queue resumed', { depth: this._queue.length });
+    this._drain();
+  }
+
+  /** 清空队列，返回被清掉的条数。 */
+  clear(reason = 'cleared') {
+    const n = this._queue.length;
+    this._queue = [];
+    if (n > 0) this.logger?.warn('queue cleared', { count: n, reason });
+    return n;
+  }
+
+  /** 等待队列彻底空闲（含正在处理的那条）。 */
+  async waitIdle(timeoutMs = 30000) {
+    if (!this._running && this._queue.length === 0) return true;
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => resolve(false), timeoutMs);
+      timer.unref?.();
+      this._idleWaiters.push(() => {
+        clearTimeout(timer);
+        resolve(true);
+      });
+    });
+  }
+
+  _notifyIdle() {
+    if (this._running || this._queue.length > 0) return;
+    const waiters = this._idleWaiters;
+    this._idleWaiters = [];
+    for (const w of waiters) w();
+  }
+
+  /** 串行消费主循环。 */
+  async _drain() {
+    if (this._running) return;      // 已有消费者在跑，保证只有一条在途
+    if (this._paused) return;
+    if (this._queue.length === 0) {
+      this._notifyIdle();
+      return;
+    }
+
+    this._running = true;
+    try {
+      while (!this._paused && this._queue.length > 0) {
+        const { item, meta } = this._queue.shift();
+        try {
+          // 顺序 await：这是「串行」的关键
+          await this.handler(item, meta);
+          this.stats.processed += 1;
+        } catch (e) {
+          this.stats.failed += 1;
+          this.logger?.error('queue handler failed', {
+            error: e.message,
+            textLen: typeof item?.text === 'string' ? item.text.length : 0,
+          });
+          // 单条失败不影响后续消息
+        }
+      }
+    } finally {
+      this._running = false;
+    }
+    this._notifyIdle();
+  }
+}
+
+module.exports = { MessageQueue };

package/lib/sanitize.js

@@ -1,71 +1,71 @@
-'use strict';
-
-/**
- * 文本预处理（需求文档 4.2.2 第 3 条）。
- *
- * 规则：
- *   1. 过滤不可见控制字符（换行/Tab 视为可保留的可见分隔，其余控制字符剔除）；
- *   2. 过滤零宽字符（\u200B-\u200D、\uFEFF 等），它们会造成「看似输入了却看不见」的困惑；
- *   3. 空串（含只有空白）直接丢弃；
- *   4. 超长文本截断并告警。
- */
-
-/** 默认最大长度（字符数）。按语音输入场景，5000 字符足够，且能规避注入卡死。 */
-const DEFAULT_MAX_LENGTH = 5000;
-
-/**
- * 判断是否为应剔除的不可见字符。
- * 注意：刻意保留 \n 和 \t —— 语音文本里它们通常是有效分隔。
- */
-function isInvisible(c) {
-  const code = c.codePointAt(0);
-  // 零宽字符与 BOM
-  if (code === 0x200b || code === 0x200c || code === 0x200d || code === 0xfeff) return true;
-  // 其他 C0/C1 控制字符（保留 \n \t \r 交给上层处理）
-  if (c === '\n' || c === '\t' || c === '\r') return false;
-  if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) return true;
-  return false;
-}
-
-/**
- * 预处理文本。
- * @param {string} raw
- * @param {object} [opts]
- * @param {number} [opts.maxLength]
- * @returns {{ok:boolean, text:string, reason?:string, truncated?:boolean, originalLength?:number}}
- */
-function sanitize(raw, opts = {}) {
-  const maxLength = opts.maxLength ?? DEFAULT_MAX_LENGTH;
-
-  if (typeof raw !== 'string') {
-    return { ok: false, text: '', reason: 'not_a_string' };
-  }
-
-  const originalLength = raw.length;
-
-  // 1) 剔除不可见字符
-  let text = '';
-  for (const ch of raw) {
-    if (!isInvisible(ch)) text += ch;
-  }
-
-  // 2) 统一换行，避免 \r\n 造成目标程序出现多余字符
-  text = text.replace(/\r\n?/g, '\n');
-
-  // 3) 空文本丢弃
-  if (text.trim().length === 0) {
-    return { ok: false, text: '', reason: 'empty_after_clean', originalLength };
-  }
-
-  // 4) 超长截断
-  let truncated = false;
-  const chars = Array.from(text);
-  if (chars.length > maxLength) {
-    text = chars.slice(0, maxLength).join('');
-    truncated = true;
-  }
-
-  return { ok: true, text, truncated, originalLength };
-}
-
-module.exports = { sanitize, isInvisible, DEFAULT_MAX_LENGTH };
+'use strict';
+
+/**
+ * 文本预处理（需求文档 4.2.2 第 3 条）。
+ *
+ * 规则：
+ *   1. 过滤不可见控制字符（换行/Tab 视为可保留的可见分隔，其余控制字符剔除）；
+ *   2. 过滤零宽字符（\u200B-\u200D、\uFEFF 等），它们会造成「看似输入了却看不见」的困惑；
+ *   3. 空串（含只有空白）直接丢弃；
+ *   4. 超长文本截断并告警。
+ */
+
+/** 默认最大长度（字符数）。按语音输入场景，5000 字符足够，且能规避注入卡死。 */
+const DEFAULT_MAX_LENGTH = 5000;
+
+/**
+ * 判断是否为应剔除的不可见字符。
+ * 注意：刻意保留 \n 和 \t —— 语音文本里它们通常是有效分隔。
+ */
+function isInvisible(c) {
+  const code = c.codePointAt(0);
+  // 零宽字符与 BOM
+  if (code === 0x200b || code === 0x200c || code === 0x200d || code === 0xfeff) return true;
+  // 其他 C0/C1 控制字符（保留 \n \t \r 交给上层处理）
+  if (c === '\n' || c === '\t' || c === '\r') return false;
+  if (code < 0x20 || (code >= 0x7f && code <= 0x9f)) return true;
+  return false;
+}
+
+/**
+ * 预处理文本。
+ * @param {string} raw
+ * @param {object} [opts]
+ * @param {number} [opts.maxLength]
+ * @returns {{ok:boolean, text:string, reason?:string, truncated?:boolean, originalLength?:number}}
+ */
+function sanitize(raw, opts = {}) {
+  const maxLength = opts.maxLength ?? DEFAULT_MAX_LENGTH;
+
+  if (typeof raw !== 'string') {
+    return { ok: false, text: '', reason: 'not_a_string' };
+  }
+
+  const originalLength = raw.length;
+
+  // 1) 剔除不可见字符
+  let text = '';
+  for (const ch of raw) {
+    if (!isInvisible(ch)) text += ch;
+  }
+
+  // 2) 统一换行，避免 \r\n 造成目标程序出现多余字符
+  text = text.replace(/\r\n?/g, '\n');
+
+  // 3) 空文本丢弃
+  if (text.trim().length === 0) {
+    return { ok: false, text: '', reason: 'empty_after_clean', originalLength };
+  }
+
+  // 4) 超长截断
+  let truncated = false;
+  const chars = Array.from(text);
+  if (chars.length > maxLength) {
+    text = chars.slice(0, maxLength).join('');
+    truncated = true;
+  }
+
+  return { ok: true, text, truncated, originalLength };
+}
+
+module.exports = { sanitize, isInvisible, DEFAULT_MAX_LENGTH };

package/lib/store.js

@@ -1,75 +1,75 @@
-'use strict';
-
-/**
- * 客户端本地转录记录持久化（需求文档 4.2.2 第 5 条）。
- * jsonlines，字段：timestamp / text / status / errorMsg
- */
-
-const fs = require('fs');
-const path = require('path');
-
-class LocalStore {
-  constructor({ file, logger }) {
-    this.file = file;
-    this.logger = logger;
-    try {
-      fs.mkdirSync(path.dirname(this.file), { recursive: true });
-      if (!fs.existsSync(this.file)) fs.writeFileSync(this.file, '');
-    } catch (e) {
-      this.logger?.warn('cannot init local record file', { file, error: e.message });
-      this.disabled = true;
-    }
-  }
-
-  append(entry) {
-    const record = {
-      timestamp: new Date().toISOString(),
-      text: entry.text ?? '',
-      status: entry.status ?? 'unknown',
-      errorMsg: entry.errorMsg ?? null,
-      clientId: entry.clientId ?? null,
-      queueWaitMs: entry.queueWaitMs ?? null,
-      durationMs: entry.durationMs ?? null,
-      truncated: entry.truncated ?? false,
-      source: entry.source ?? null,
-    };
-    if (this.disabled) return record;
-    try {
-      fs.appendFileSync(this.file, `${JSON.stringify(record)}\n`, 'utf8');
-    } catch (e) {
-      this.logger?.warn('failed to append local record', { error: e.message });
-    }
-    return record;
-  }
-
-  /** 读取最近 N 条，倒序。 */
-  tail(limit = 50) {
-    try {
-      const lines = fs.readFileSync(this.file, 'utf8').split('\n').filter(Boolean);
-      return lines
-        .slice(-Math.max(1, limit))
-        .map((l) => { try { return JSON.parse(l); } catch { return { raw: l }; } })
-        .reverse();
-    } catch {
-      return [];
-    }
-  }
-
-  /** 简单统计：成功 / 失败 条数。 */
-  stats() {
-    try {
-      const lines = fs.readFileSync(this.file, 'utf8').split('\n').filter(Boolean);
-      let ok = 0;
-      let failed = 0;
-      for (const l of lines) {
-        if (l.includes('"status":"injected"')) ok += 1;
-        else if (l.includes('"status":"inject_failed"') || l.includes('"status":"dropped"')) failed += 1;
-      }
-      return { total: lines.length, injected: ok, failed };
-    } catch {
-      return { total: 0, injected: 0, failed: 0 };
-    }
-  }
-}
-
-module.exports = { LocalStore };
+'use strict';
+
+/**
+ * 客户端本地转录记录持久化（需求文档 4.2.2 第 5 条）。
+ * jsonlines，字段：timestamp / text / status / errorMsg
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+class LocalStore {
+  constructor({ file, logger }) {
+    this.file = file;
+    this.logger = logger;
+    try {
+      fs.mkdirSync(path.dirname(this.file), { recursive: true });
+      if (!fs.existsSync(this.file)) fs.writeFileSync(this.file, '');
+    } catch (e) {
+      this.logger?.warn('cannot init local record file', { file, error: e.message });
+      this.disabled = true;
+    }
+  }
+
+  append(entry) {
+    const record = {
+      timestamp: new Date().toISOString(),
+      text: entry.text ?? '',
+      status: entry.status ?? 'unknown',
+      errorMsg: entry.errorMsg ?? null,
+      clientId: entry.clientId ?? null,
+      queueWaitMs: entry.queueWaitMs ?? null,
+      durationMs: entry.durationMs ?? null,
+      truncated: entry.truncated ?? false,
+      source: entry.source ?? null,
+    };
+    if (this.disabled) return record;
+    try {
+      fs.appendFileSync(this.file, `${JSON.stringify(record)}\n`, 'utf8');
+    } catch (e) {
+      this.logger?.warn('failed to append local record', { error: e.message });
+    }
+    return record;
+  }
+
+  /** 读取最近 N 条，倒序。 */
+  tail(limit = 50) {
+    try {
+      const lines = fs.readFileSync(this.file, 'utf8').split('\n').filter(Boolean);
+      return lines
+        .slice(-Math.max(1, limit))
+        .map((l) => { try { return JSON.parse(l); } catch { return { raw: l }; } })
+        .reverse();
+    } catch {
+      return [];
+    }
+  }
+
+  /** 简单统计：成功 / 失败 条数。 */
+  stats() {
+    try {
+      const lines = fs.readFileSync(this.file, 'utf8').split('\n').filter(Boolean);
+      let ok = 0;
+      let failed = 0;
+      for (const l of lines) {
+        if (l.includes('"status":"injected"')) ok += 1;
+        else if (l.includes('"status":"inject_failed"') || l.includes('"status":"dropped"')) failed += 1;
+      }
+      return { total: lines.length, injected: ok, failed };
+    } catch {
+      return { total: 0, injected: 0, failed: 0 };
+    }
+  }
+}
+
+module.exports = { LocalStore };