ai-worklens-agent 0.1.4 → 0.1.5

package/README.md

@@ -36,7 +36,7 @@ npm run mcp
 如果管理员已经把员工端发布到 npm 或企业私有 npm 源，可以使用 `npx` 首次安装：
 
 ```bash
-NPM_CONFIG_UPDATE_NOTIFIER=false npx -y --loglevel=error -p ai-worklens-agent@0.1.4 worklens-agent-install \
+NPM_CONFIG_UPDATE_NOTIFIER=false npx -y --loglevel=error -p ai-worklens-agent@0.1.5 worklens-agent-install \
   --server-url http://192.168.1.241:8797 \
   --tool codex \
   --employee-pinyin zhangsan
@@ -60,7 +60,7 @@ NPM_TOKEN=<npm_token> npm run client:npm:publish -- \
 如果管理员在官网发布了直链安装包，可以下载安装包后执行包内安装脚本：
 
 ```bash
-curl -fL http://192.168.1.241:8797/site/downloads/ai-worklens-codex-0.1.4.sh \
+curl -fL http://192.168.1.241:8797/site/downloads/ai-worklens-codex-0.1.5.sh \
   -o ai-worklens-install.sh
 chmod +x ai-worklens-install.sh
 ./ai-worklens-install.sh zhangsan

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-worklens-agent",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Employee-side collector agent for AI WorkLens.",
   "type": "module",
   "bin": {
@@ -18,10 +18,5 @@
     "claude-code",
     "opencode"
   ],
-  "license": "UNLICENSED",
-  "private": false,
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  }
+  "license": "UNLICENSED"
 }

package/src/config.mjs

@@ -137,10 +137,12 @@ export function loadClientConfig(options = {}) {
     family: options.modelFamily || envValue(env, "WORKLENS_MODEL_FAMILY") || fileConfig.model?.family
   });
   const inferredModel = inferToolModel({ tool, homeDir, env });
+  const employeePinyin = options.employeePinyin || options.pinyinName || envValue(env, "WORKLENS_EMPLOYEE_PINYIN") || fileConfig.employee?.pinyinName || "";
+  const employeeId = options.employeeId || envValue(env, "WORKLENS_EMPLOYEE_ID") || fileConfig.employee?.id || employeePinyin || os.userInfo().username;
   const employee = {
-    id: options.employeeId || envValue(env, "WORKLENS_EMPLOYEE_ID") || fileConfig.employee?.id || os.userInfo().username,
-    name: options.employeeName || envValue(env, "WORKLENS_EMPLOYEE_NAME") || fileConfig.employee?.name || os.userInfo().username,
-    pinyinName: options.employeePinyin || options.pinyinName || envValue(env, "WORKLENS_EMPLOYEE_PINYIN") || fileConfig.employee?.pinyinName || "",
+    id: employeeId,
+    name: options.employeeName || envValue(env, "WORKLENS_EMPLOYEE_NAME") || fileConfig.employee?.name || employeeId || os.userInfo().username,
+    pinyinName: employeePinyin,
     department: options.department || envValue(env, "WORKLENS_DEPARTMENT") || fileConfig.employee?.department || "",
     role: options.role || envValue(env, "WORKLENS_ROLE") || fileConfig.employee?.role || ""
   };

package/src/install.mjs

@@ -152,7 +152,7 @@ export function installClient(options = {}) {
       family: options.modelFamily || ""
     },
     employee: {
-      id: options.employeeId || "",
+      id: options.employeeId || options.employeePinyin || options.pinyinName || "",
       name: options.employeeName || "",
       pinyinName: options.employeePinyin || options.pinyinName || "",
       department: options.department || "",

package/src/protocol/client-update-policy.mjs

@@ -1,4 +1,4 @@
-export const CLIENT_AGENT_VERSION = "0.1.4";
+export const CLIENT_AGENT_VERSION = "0.1.5";
 
 export const DEFAULT_CLIENT_UPDATE_POLICY = {
   enabled: true,

package/src/queue.mjs

@@ -7,11 +7,66 @@ const DEFAULT_RETRY = {
   baseDelayMs: 30 * 1000
 };
 
+const LOCK_STALE_MS = 15 * 1000;
+const LOCK_TIMEOUT_MS = 5 * 1000;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseFirstJsonArray(raw) {
+  let started = false;
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+
+  for (let index = 0; index < raw.length; index += 1) {
+    const char = raw[index];
+    if (!started) {
+      if (/\s/.test(char)) continue;
+      if (char !== "[") return null;
+      started = true;
+      depth = 1;
+      continue;
+    }
+
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === "\"") {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (char === "\"") {
+      inString = true;
+    } else if (char === "[") {
+      depth += 1;
+    } else if (char === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        const parsed = JSON.parse(raw.slice(0, index + 1));
+        return Array.isArray(parsed) ? parsed : null;
+      }
+    }
+  }
+  return null;
+}
+
 async function readJsonArray(filePath) {
   try {
     const raw = await fs.readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch (error) {
+      const recovered = parseFirstJsonArray(raw);
+      if (recovered) return recovered;
+      throw error;
+    }
   } catch (error) {
     if (error.code === "ENOENT") return [];
     throw error;
@@ -44,30 +99,96 @@ function retryDelay(attempts, options = {}) {
   return Math.min(maxDelayMs, baseDelayMs * (2 ** exponent));
 }
 
+async function writeJsonArrayAtomic(filePath, items) {
+  const directory = path.dirname(filePath);
+  await fs.mkdir(directory, { recursive: true });
+  const tempPath = path.join(directory, `.${path.basename(filePath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+  try {
+    await fs.writeFile(tempPath, `${JSON.stringify(items.map(normalizeItem), null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(tempPath, filePath);
+    await fs.chmod(filePath, 0o600).catch(() => {});
+  } catch (error) {
+    await fs.unlink(tempPath).catch(() => {});
+    throw error;
+  }
+}
+
+async function acquireQueueLock(filePath, options = {}) {
+  const lockPath = `${filePath}.lock`;
+  const staleMs = Number(options.staleMs || LOCK_STALE_MS);
+  const timeoutMs = Number(options.timeoutMs || LOCK_TIMEOUT_MS);
+  const startedAt = Date.now();
+
+  while (true) {
+    try {
+      await fs.mkdir(path.dirname(filePath), { recursive: true });
+      const handle = await fs.open(lockPath, "wx", 0o600);
+      await handle.writeFile(JSON.stringify({ pid: process.pid, createdAt: new Date().toISOString() }));
+      return async () => {
+        await handle.close().catch(() => {});
+        await fs.unlink(lockPath).catch(() => {});
+      };
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const stats = await fs.stat(lockPath).catch(() => null);
+      if (stats && Date.now() - stats.mtimeMs > staleMs) {
+        await fs.unlink(lockPath).catch(() => {});
+        continue;
+      }
+      if (Date.now() - startedAt > timeoutMs) {
+        throw new Error(`queue lock timeout: ${lockPath}`);
+      }
+      await sleep(25 + Math.floor(Math.random() * 50));
+    }
+  }
+}
+
 export class EventQueue {
   constructor(filePath) {
     this.filePath = filePath;
   }
 
-  async list() {
+  async withLock(fn) {
+    const release = await acquireQueueLock(this.filePath);
+    try {
+      return await fn();
+    } finally {
+      await release();
+    }
+  }
+
+  async listUnlocked() {
     const items = await readJsonArray(this.filePath);
     return items.map(normalizeItem);
   }
 
+  async saveUnlocked(items) {
+    await writeJsonArrayAtomic(this.filePath, items);
+  }
+
+  async list() {
+    return this.listUnlocked();
+  }
+
   async save(items) {
-    await fs.mkdir(path.dirname(this.filePath), { recursive: true });
-    await fs.writeFile(this.filePath, `${JSON.stringify(items.map(normalizeItem), null, 2)}\n`, { mode: 0o600 });
+    await this.withLock(async () => {
+      await this.saveUnlocked(items);
+    });
   }
 
   async enqueue(event) {
-    const items = await this.list();
-    items.push(normalizeItem({ queuedAt: new Date().toISOString(), event }));
-    await this.save(items);
-    return items.length;
+    return this.withLock(async () => {
+      const items = await this.listUnlocked();
+      items.push(normalizeItem({ queuedAt: new Date().toISOString(), event }));
+      await this.saveUnlocked(items);
+      return items.length;
+    });
   }
 
   async replace(items) {
-    await this.save(items);
+    await this.withLock(async () => {
+      await this.saveUnlocked(items);
+    });
   }
 
   async due({ now = new Date(), limit = Infinity, force = false } = {}) {
@@ -79,30 +200,34 @@ export class EventQueue {
   }
 
   async markFailed(failedIds, error, { now = new Date(), retry = DEFAULT_RETRY } = {}) {
-    const idSet = new Set(failedIds);
-    const nowIso = now instanceof Date ? now.toISOString() : new Date(now).toISOString();
-    const items = await this.list();
-    const marked = items.map((item) => {
-      if (!idSet.has(item.id)) return item;
-      const attempts = Number(item.attempts || 0) + 1;
-      return {
-        ...item,
-        attempts,
-        lastAttemptAt: nowIso,
-        lastError: String(error?.message || error || "upload_failed"),
-        nextAttemptAt: new Date(Date.parse(nowIso) + retryDelay(attempts, retry)).toISOString()
-      };
+    return this.withLock(async () => {
+      const idSet = new Set(failedIds);
+      const nowIso = now instanceof Date ? now.toISOString() : new Date(now).toISOString();
+      const items = await this.listUnlocked();
+      const marked = items.map((item) => {
+        if (!idSet.has(item.id)) return item;
+        const attempts = Number(item.attempts || 0) + 1;
+        return {
+          ...item,
+          attempts,
+          lastAttemptAt: nowIso,
+          lastError: String(error?.message || error || "upload_failed"),
+          nextAttemptAt: new Date(Date.parse(nowIso) + retryDelay(attempts, retry)).toISOString()
+        };
+      });
+      await this.saveUnlocked(marked);
+      return marked;
     });
-    await this.save(marked);
-    return marked;
   }
 
   async remove(removeIds) {
-    const idSet = new Set(removeIds);
-    const items = await this.list();
-    const remaining = items.filter((item) => !idSet.has(item.id));
-    await this.save(remaining);
-    return remaining;
+    return this.withLock(async () => {
+      const idSet = new Set(removeIds);
+      const items = await this.listUnlocked();
+      const remaining = items.filter((item) => !idSet.has(item.id));
+      await this.saveUnlocked(remaining);
+      return remaining;
+    });
   }
 
   async stats({ now = new Date() } = {}) {
@@ -123,6 +248,8 @@ export class EventQueue {
   }
 
   async clear() {
-    await this.save([]);
+    await this.withLock(async () => {
+      await this.saveUnlocked([]);
+    });
   }
 }