cc-viewer 1.6.293 → 1.6.295

package/server/lib/adapters/feishu-adapter.js

@@ -99,6 +99,25 @@ const feishuAdapter = {
   // Feishu long-connection has no app-level inbound ACK (the SDK handles transport acking).
   ack() { /* no-op */ },
 
+  // 解析发送者姓名 + 头像（供「对话记录」展示）。事件只带 open_id，姓名/头像需查通讯录：
+  // 复用已建好的 sendClient（自带 tenant_access_token 缓存）调 contact.v3.user.get。
+  // 需应用具备「读取通讯录」相关 scope；无权限/外部用户/失败 → null，由 bridge 静默降级。
+  async resolveSender(cfg, senderId, ctx) {
+    if (!senderId) return null;
+    const client = ctx.store.sendClient;
+    if (!client?.contact?.v3?.user?.get) return null;
+    try {
+      const r = await client.contact.v3.user.get({
+        path: { user_id: senderId },
+        params: { user_id_type: 'open_id' },
+      });
+      if (r && typeof r.code === 'number' && r.code !== 0) return null;
+      const u = r?.data?.user || {};
+      const avatar = u.avatar?.avatar_240 || u.avatar?.avatar_72 || u.avatar?.avatar_origin || null;
+      return { name: u.name || null, avatar };
+    } catch { return null; }
+  },
+
   async sendOne(cfg, target, content, ctx) {
     const client = ctx.store.sendClient;
     if (!client) throw new Error('feishu send client not initialized');
@@ -111,6 +130,43 @@ const feishuAdapter = {
     }
   },
 
+  async sendAckCard(cfg, target, statusText, ctx) {
+    const client = ctx.store.sendClient;
+    if (!client) throw new Error('feishu send client not initialized');
+    const card = {
+      config: { wide_screen_mode: true },
+      header: { title: { tag: 'plain_text', content: 'Claude' }, template: 'blue' },
+      elements: [{ tag: 'div', text: { tag: 'lark_md', content: statusText } }],
+    };
+    const r = await client.im.v1.message.create({
+      params: { receive_id_type: target.receiveIdType },
+      data: { receive_id: target.receiveId, msg_type: 'interactive', content: JSON.stringify(card) },
+    });
+    if (r && typeof r.code === 'number' && r.code !== 0) {
+      throw new Error(`sendAckCard ${r.code}: ${r.msg || 'failed'}`);
+    }
+    return { messageId: r?.data?.message_id };
+  },
+
+  async updateAckCard(cfg, target, handle, content, status, ctx) {
+    try {
+      const client = ctx.store.sendClient;
+      if (!client) return false;
+      const templateMap = { done: 'green', interrupted: 'orange', error: 'red' };
+      const card = {
+        config: { wide_screen_mode: true },
+        header: { title: { tag: 'plain_text', content: 'Claude' }, template: templateMap[status] || 'blue' },
+        elements: [{ tag: 'div', text: { tag: 'lark_md', content } }],
+      };
+      const r = await client.im.v1.message.patch({
+        path: { message_id: handle.messageId },
+        data: { content: JSON.stringify(card) },
+      });
+      if (r && typeof r.code === 'number' && r.code !== 0) return false;
+      return true;
+    } catch { return false; }
+  },
+
   async testConnection(cfg, ctx) {
     try {
       const r = await ctx.fetch(tokenHost(cfg.region) + TOKEN_PATH, {

package/server/lib/adapters/wecom-adapter.js

@@ -61,6 +61,10 @@ const wecomAdapter = {
   hasCreds(cfg) { return !!(cfg.botId && cfg.secret); },
   statusFields(cfg) { return { botIdTail: cfg?.botId?.slice(-4) || '' }; },
 
+  // 发送者姓名/头像：v1 不实现 resolveSender —— 智能机器人长连接凭证（botId+secret）拿不到
+  // 企业通讯录的 corp_access_token，`/cgi-bin/user/get` 不可达。故 WeCom 发送者在「对话记录」里
+  // 降级为默认头像 + senderId（不报错、不阻断）。后续如引入管理员级凭证再补 resolveSender。
+
   async connect(cfg, hooks, ctx) {
     const mod = await loadSdk();
     const WSClient = resolveWSClient(mod);

package/server/lib/ask-store.js

@@ -9,10 +9,11 @@
 // - 启动时 hydrate 出的 entry 的 res 字段为 null（旧连接已死），
 //   等待新的 ask-bridge 重新 POST 同 toolUseId 时复用（已在 server.js:2727 实现）
 //   或浏览器通过 /api/pending-asks 拉取展示。
-import { readFileSync, writeFileSync, writeSync, existsSync, mkdirSync, statSync, openSync, closeSync, unlinkSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomBytes } from 'node:crypto';
 import { renameSyncWithRetry } from './file-api.js';
+import { withFileLockAsync } from './async-file-lock.js';
 import { LOG_DIR } from '../../findcc.js';
 
 const SCHEMA_VERSION = 1;
@@ -24,80 +25,8 @@ let _loggedPersistError = false;
 function getStoreFile() { return join(LOG_DIR, 'ask-store.json'); }
 function getLockFile() { return join(LOG_DIR, 'ask-store.lock'); }
 
-function sleep(ms) {
-  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-}
-
-// Lock body 含 owner pid，让其它进程精确判断 owner 是否仍活着 —— 避免 mtime-only stale
-// 判定在 Electron 多 Tab + 慢盘场景下误删活跃锁（持锁方 fn 跑 >5s 时旧实现会被偷锁）。
-// Body 不可读（老格式 / openSync 与 writeSync 之间的瞬间 race）时退回 mtime 阈值兜底。
-function readLockOwnerPid(path) {
-  try {
-    const raw = readFileSync(path, 'utf-8');
-    if (!raw) return null;
-    const obj = JSON.parse(raw);
-    if (obj && Number.isInteger(obj.pid)) return obj.pid;
-  } catch {}
-  return null;
-}
-
-function isPidAlive(pid) {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    // ESRCH = 进程不存在；EPERM = 存在但不同 user（仍算活）
-    return err && err.code === 'EPERM';
-  }
-}
-
-function isLockStale(path, mtimeFallbackMs) {
-  const pid = readLockOwnerPid(path);
-  if (pid !== null) {
-    // 自己 pid 见到 = 必然 stale（理论不可能：try/finally 保证 unlink；
-    // 若发生 → 视作可回收，避免 2 秒死锁）
-    if (pid === process.pid) return true;
-    return !isPidAlive(pid);
-  }
-  try {
-    const stats = statSync(path);
-    return Date.now() - stats.mtimeMs > mtimeFallbackMs;
-  } catch {
-    return false;
-  }
-}
-
 function withLock(fn) {
-  mkdirSync(LOG_DIR, { recursive: true });
-  const deadline = Date.now() + 2000;
-  const STALE_THRESHOLD = 5000;
-  while (true) {
-    try {
-      const fd = openSync(getLockFile(), 'wx');
-      try {
-        writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
-      } finally {
-        closeSync(fd);
-      }
-      break;
-    } catch (err) {
-      if (err?.code === 'EEXIST') {
-        if (Date.now() < deadline) {
-          if (isLockStale(getLockFile(), STALE_THRESHOLD)) {
-            try { unlinkSync(getLockFile()); } catch {}
-            continue;
-          }
-          sleep(25);
-          continue;
-        }
-      }
-      throw err;
-    }
-  }
-  try { return fn(); } finally {
-    try { unlinkSync(getLockFile()); } catch {}
-  }
+  return withFileLockAsync(getLockFile(), fn, { ensureDir: LOG_DIR });
 }
 
 /**
@@ -187,11 +116,11 @@ export function saveAskStore(entries) {
  * last-write-wins 覆盖错乱（A 选 X 落盘 → B 选 Y 又落 → ask-bridge 最终拿 Y 而 A UI 显 X）。
  * Returns true if this call wrote, false if noop'd by existing terminal state.
  */
-export function markAnswered(id, answers) {
+export async function markAnswered(id, answers) {
   if (!id || typeof id !== 'string') return false;
   if (!answers || typeof answers !== 'object') return false;
   try {
-    return withLock(() => {
+    return await withLock(() => {
       const all = loadAskStore();
       const existing = all[id];
       if (existing && (existing.status === 'answered' || existing.status === 'cancelled')) {
@@ -211,10 +140,10 @@ export function markAnswered(id, answers) {
   } catch { return false; }
 }
 
-export function markCancelled(id, reason) {
+export async function markCancelled(id, reason) {
   if (!id || typeof id !== 'string') return false;
   try {
-    return withLock(() => {
+    return await withLock(() => {
       const all = loadAskStore();
       const existing = all[id];
       if (existing && (existing.status === 'answered' || existing.status === 'cancelled')) {
@@ -242,10 +171,10 @@ export function markCancelled(id, reason) {
  * 替代旧的 "无条件 consume + setEntry 写回" 双 withLock 模式 —— 那种模式的两次锁
  * 中间窗口会被 markAnswered 命中 → setEntry 把答案覆盖回 pending。
  */
-export function consumeIfFinal(id) {
+export async function consumeIfFinal(id) {
   if (!id || typeof id !== 'string') return null;
   try {
-    return withLock(() => {
+    return await withLock(() => {
       const all = loadAskStore();
       const entry = all[id];
       if (!entry) return null;
@@ -265,10 +194,10 @@ export function consumeIfFinal(id) {
  * truly want "read + delete regardless of status"). New short-poll GET handler
  * uses consumeIfFinal instead — see server.js GET /api/ask-hook/:id/result.
  */
-export function consume(id) {
+export async function consume(id) {
   if (!id || typeof id !== 'string') return null;
   try {
-    return withLock(() => {
+    return await withLock(() => {
       const all = loadAskStore();
       const entry = all[id];
       if (!entry) return null;
@@ -289,11 +218,11 @@ export function consume(id) {
  * setEntry 不能把 status 倒回 pending —— 否则 setImmediate 排队的延迟 _persistAskEntry
  * 或重 POST 的 placeholder 会覆盖真实终态，导致 ask-bridge 短轮询永远拿不到答案。
  */
-export function setEntry(id, fields) {
+export async function setEntry(id, fields) {
   if (!id || typeof id !== 'string') return;
   if (!fields || !Array.isArray(fields.questions)) return;
   try {
-    withLock(() => {
+    await withLock(() => {
       const all = loadAskStore();
       const existing = all[id];
       if (existing && (existing.status === 'answered' || existing.status === 'cancelled')) {
@@ -312,10 +241,10 @@ export function setEntry(id, fields) {
   }
 }
 
-export function deleteEntry(id) {
+export async function deleteEntry(id) {
   if (!id || typeof id !== 'string') return;
   try {
-    withLock(() => {
+    await withLock(() => {
       const all = loadAskStore();
       if (!(id in all)) return;
       delete all[id];
@@ -328,9 +257,9 @@ export function deleteEntry(id) {
  * Replace the entire store atomically. Used on server startup to drop entries
  * older than maxAgeMs (24h-class staleness sweep) without N round-trips.
  */
-export function replaceAll(entries) {
+export async function replaceAll(entries) {
   try {
-    withLock(() => saveAskStore(entries));
+    await withLock(() => saveAskStore(entries));
   } catch {}
 }
 
@@ -341,9 +270,9 @@ export function replaceAll(entries) {
  * Stale 判定用 max(createdAt, answeredAt)：刚 answered 的老 entry（createdAt 旧但
  * answeredAt 新）必须保留，否则 ask-bridge 短轮询拿不到答案。
  */
-export function pruneStale(maxAgeMs = 24 * 60 * 60 * 1000) {
+export async function pruneStale(maxAgeMs = 24 * 60 * 60 * 1000) {
   try {
-    return withLock(() => {
+    return await withLock(() => {
       const all = loadAskStore();
       const cutoff = Date.now() - maxAgeMs;
       const survivors = {};

package/server/lib/async-file-lock.js

@@ -0,0 +1,123 @@
+// Async file lock — 替代 Atomics.wait 阻塞锁
+// 使用 fs.promises.open('wx') 原子创建 + setTimeout 异步重试
+// 同进程内通过 Promise 链串行化，跨进程通过文件锁互斥
+
+import { open, stat, unlink, readFile } from 'node:fs/promises';
+import { mkdirSync } from 'node:fs';
+
+// 同进程内的 Promise 互斥锁（按 lockPath 分组）
+const _inProcessLocks = new Map();
+
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err && err.code === 'EPERM';
+  }
+}
+
+async function readLockOwnerPid(path) {
+  try {
+    const raw = await readFile(path, 'utf-8');
+    if (!raw) return null;
+    const obj = JSON.parse(raw);
+    if (obj && Number.isInteger(obj.pid)) return obj.pid;
+  } catch {}
+  return null;
+}
+
+async function isLockStale(path, mtimeFallbackMs) {
+  const pid = await readLockOwnerPid(path);
+  if (pid !== null) {
+    // 同进程的锁由 _inProcessLocks 管理，这里看到 own pid 说明是上次崩溃残留
+    if (pid === process.pid) return true;
+    return !isPidAlive(pid);
+  }
+  try {
+    const stats = await stat(path);
+    return Date.now() - stats.mtimeMs > mtimeFallbackMs;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function _acquireFileLock(lockPath, opts) {
+  const deadline = Date.now() + (opts.deadline ?? 2000);
+  const retryMs = opts.retryMs ?? 25;
+  const staleThresholdMs = opts.staleThresholdMs ?? 5000;
+  const writePid = opts.writePid !== false;
+
+  while (true) {
+    try {
+      const fh = await open(lockPath, 'wx');
+      if (writePid) {
+        await fh.writeFile(JSON.stringify({ pid: process.pid, ts: Date.now() }));
+      }
+      await fh.close();
+      return;
+    } catch (err) {
+      if (err?.code === 'EEXIST') {
+        if (Date.now() < deadline) {
+          if (await isLockStale(lockPath, staleThresholdMs)) {
+            try { await unlink(lockPath); } catch {}
+            continue;
+          }
+          await sleep(retryMs);
+          continue;
+        }
+        // deadline exceeded — only break if lock is stale (dead PID or old mtime)
+        if (await isLockStale(lockPath, staleThresholdMs)) {
+          try { await unlink(lockPath); } catch {}
+          continue;
+        }
+        throw new Error(`Lock acquisition timeout: ${lockPath} (held by live process)`);
+
+      }
+      throw err;
+    }
+  }
+}
+
+/**
+ * @param {string} lockPath - 锁文件路径
+ * @param {() => any | Promise<any>} fn - 持锁期间执行的函数
+ * @param {object} [opts]
+ * @param {number} [opts.deadline] - 最长等待时间 (ms)，默认 2000
+ * @param {number} [opts.retryMs] - 重试间隔 (ms)，默认 25
+ * @param {number} [opts.staleThresholdMs] - mtime 过期阈值 (ms)，默认 5000
+ * @param {boolean} [opts.writePid] - 锁文件中写入 PID 信息，默认 true
+ * @param {string} [opts.ensureDir] - 若提供，在获取锁前确保此目录存在
+ */
+export async function withFileLockAsync(lockPath, fn, opts = {}) {
+  if (opts.ensureDir) {
+    try { mkdirSync(opts.ensureDir, { recursive: true }); } catch {}
+  }
+
+  // 同进程串行化：排队等待前一个持锁操作完成
+  const prev = _inProcessLocks.get(lockPath) || Promise.resolve();
+  let resolve;
+  const next = new Promise(r => { resolve = r; });
+  _inProcessLocks.set(lockPath, next);
+
+  await prev;
+
+  try {
+    await _acquireFileLock(lockPath, opts);
+    try {
+      return await fn();
+    } finally {
+      try { await unlink(lockPath); } catch {}
+    }
+  } finally {
+    resolve();
+    if (_inProcessLocks.get(lockPath) === next) {
+      _inProcessLocks.delete(lockPath);
+    }
+  }
+}

package/server/lib/async-write-queue.js

@@ -0,0 +1,131 @@
+// Async Write Queue — 非阻塞追加写入，替代 appendFileSync
+// 单写者模式保证写入顺序，进程退出时回退同步写入保证不丢数据
+
+import { appendFile } from 'node:fs/promises';
+import { appendFileSync } from 'node:fs';
+
+const HIGH_WATER_MARK = 50 * 1024 * 1024; // 50MB — 超过此值降级为同步写入
+
+export class AsyncWriteQueue {
+  /**
+   * @param {string|(() => string)} pathOrGetter - 文件路径或返回路径的函数（支持动态路径）
+   * @param {object} [opts]
+   * @param {boolean} [opts.syncMode] - 强制同步模式
+   */
+  constructor(pathOrGetter, opts = {}) {
+    this._pathOrGetter = pathOrGetter;
+    this._queue = [];          // { path: string, data: string, onDone?: Function }[]
+    this._pendingBytes = 0;
+    this._draining = false;
+    this._drainPromise = null;
+    this._closed = false;
+    this._flushResolvers = []; // resolve() callbacks waiting for flush()
+    this._syncMode = opts.syncMode || !!process.env.CCV_SYNC_WRITES;
+  }
+
+  _getPath() {
+    return typeof this._pathOrGetter === 'function' ? this._pathOrGetter() : this._pathOrGetter;
+  }
+
+  get filePath() { return this._getPath(); }
+  get pendingBytes() { return this._pendingBytes; }
+
+  append(data, onDone) {
+    if (this._closed) return;
+    const path = this._getPath();
+    if (!path) {
+      if (onDone) try { onDone(); } catch {}
+      return;
+    }
+
+    if (this._syncMode || this._pendingBytes >= HIGH_WATER_MARK) {
+      try { appendFileSync(path, data); } catch {}
+      if (onDone) try { onDone(); } catch {}
+      return;
+    }
+
+    const byteLen = Buffer.byteLength(data);
+    this._queue.push({ path, data, onDone });
+    this._pendingBytes += byteLen;
+    this._scheduleDrain();
+  }
+
+  async flush() {
+    if (this._queue.length === 0 && !this._draining) return;
+    return new Promise(resolve => {
+      this._flushResolvers.push(resolve);
+      this._scheduleDrain();
+    });
+  }
+
+  async close() {
+    this._closed = true;
+    // 等待 in-flight 异步 drain 完成，防止退出时丢失正在写入的数据
+    if (this._drainPromise) {
+      try { await this._drainPromise; } catch {}
+    }
+    // 同步兜底：排空 drain 完成后可能新入队的剩余项
+    this._drainSync();
+  }
+
+  // Synchronous drain for process exit — guarantees no data loss
+  _drainSync() {
+    while (this._queue.length > 0) {
+      const item = this._queue.shift();
+      try {
+        appendFileSync(item.path, item.data);
+        if (item.onDone) item.onDone();
+      } catch {}
+    }
+    this._pendingBytes = 0;
+    for (const resolve of this._flushResolvers) resolve();
+    this._flushResolvers.length = 0;
+  }
+
+  _scheduleDrain() {
+    if (this._draining) return;
+    this._draining = true;
+    // queueMicrotask 批量收集同 tick 的 append 调用
+    queueMicrotask(() => { this._drainPromise = this._drain(); });
+  }
+
+  async _drain() {
+    while (this._queue.length > 0) {
+      // Group by path — entries for the same file are batched together
+      const batch = this._queue.splice(0);
+      const byPath = new Map();
+      for (const item of batch) {
+        if (!byPath.has(item.path)) byPath.set(item.path, []);
+        byPath.get(item.path).push(item);
+      }
+
+      for (const [path, items] of byPath) {
+        const callbacks = [];
+        let combined = '';
+        for (const item of items) {
+          combined += item.data;
+          if (item.onDone) callbacks.push(item.onDone);
+        }
+
+        try {
+          await appendFile(path, combined);
+        } catch {}
+        for (const cb of callbacks) {
+          try { cb(); } catch {}
+        }
+      }
+
+      let totalBytes = 0;
+      for (const [, items] of byPath) {
+        for (const item of items) totalBytes += Buffer.byteLength(item.data);
+      }
+      this._pendingBytes -= totalBytes;
+      if (this._pendingBytes < 0) this._pendingBytes = 0;
+    }
+
+    this._draining = false;
+
+    for (const resolve of this._flushResolvers) resolve();
+    this._flushResolvers.length = 0;
+  }
+}

package/server/lib/git-diff.js

@@ -3,7 +3,10 @@ import { join, sep } from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 
-const execFileAsync = promisify(execFile);
+// Windows：从无控制台的 worker node.exe 启动 git.exe 会弹可见控制台窗口，
+// 包装层统一默认 windowsHide（POSIX no-op），覆盖本文件全部 git 调用。
+const _execFileAsyncRaw = promisify(execFile);
+const execFileAsync = (cmd, args, opts) => _execFileAsyncRaw(cmd, args, { windowsHide: true, ...opts });
 
 const UNTRACKED_MAX_BYTES = 5 * 1024 * 1024;
 const BINARY_PROBE_BYTES = 8192;