ai-worklens-agent 0.1.4 → 0.1.6

package/README.md

@@ -35,8 +35,16 @@ npm run mcp
 
 如果管理员已经把员工端发布到 npm 或企业私有 npm 源，可以使用 `npx` 首次安装：
 
+Windows 命令提示符或 PowerShell 使用一行命令，不要混用 macOS/Linux 的反斜杠换行：
+
+```bat
+npx -y --loglevel=error --registry https://registry.npmjs.org -p ai-worklens-agent@0.1.6 worklens-agent-install --server-url http://192.168.1.241:8797 --tool codex --employee-pinyin zhangpeng
+```
+
+macOS / Linux：
+
 ```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.6 worklens-agent-install \
   --server-url http://192.168.1.241:8797 \
   --tool codex \
   --employee-pinyin zhangsan
@@ -60,7 +68,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.6.sh \
   -o ai-worklens-install.sh
 chmod +x ai-worklens-install.sh
 ./ai-worklens-install.sh zhangsan
@@ -83,6 +91,12 @@ npm run agent -- event \
 echo '{"event":"plugin_use","pluginName":"Spreadsheets","message":"整理报价清单"}' | npm run hook:codex
 ```
 
+Windows 命令提示符验证 Codex hook 是否真实可执行：
+
+```bat
+echo {"hook_event_name":"UserPromptSubmit","prompt":"worklens windows smoke","session_id":"manual-smoke"} | "%USERPROFILE%\.ai-worklens\codex-hook.cmd"
+```
+
 模拟 Claude Code 工具 hook 输入：
 
 ```bash
@@ -154,11 +168,11 @@ WORKLENS_QUEUE_FILE=/path/to/queue.json
 
 - `client.json`：中心端地址、员工身份、上传配置。
 - `install-manifest.json`：MCP server、Hook adapter、CLI event entrypoint。
-- `codex-mcp-snippet.toml` / `codex-hook.sh`：Codex 配置片段。
-- `claude-code-mcp.json` / `claude-code-hook.sh` / `claude-code-hooks-settings.json`：Claude Code 配置片段和官方 hooks events 覆盖。
-- `opencode-mcp.jsonc` / `opencode-hook.sh` / `opencode-ai-worklens-plugin.js`：OpenCode MCP 配置和本地插件事件覆盖。
-- `worklens-checkin.sh`：同步远程规则、补传离线队列并上报健康状态。
-- `worklens-auto-update.sh`：补传离线队列，拉取中心端静默更新策略，自动重写本地采集组件。
+- `codex-mcp-snippet.toml` / `codex-hook.sh` / `codex-hook.cmd`：Codex 配置片段。
+- `claude-code-mcp.json` / `claude-code-hook.sh` / `claude-code-hook.cmd` / `claude-code-hooks-settings.json`：Claude Code 配置片段和官方 hooks events 覆盖。
+- `opencode-mcp.jsonc` / `opencode-hook.sh` / `opencode-hook.cmd` / `opencode-ai-worklens-plugin.js`：OpenCode MCP 配置和本地插件事件覆盖。
+- `worklens-checkin.sh` / `worklens-checkin.cmd`：同步远程规则、补传离线队列并上报健康状态。
+- `worklens-auto-update.sh` / `worklens-auto-update.cmd`：补传离线队列，拉取中心端静默更新策略，自动重写本地采集组件。
 - `worklens-register-autoupdate.sh`：在 macOS 用户级 LaunchAgent 注册后台巡检任务。
 - `worklens-unregister-autoupdate.sh`：移除后台巡检任务。
 - `worklens-install-or-update.sh`：同步配置、静默更新、注册后台任务并自检。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-worklens-agent",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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

@@ -38,6 +38,7 @@ function readPackageVersion() {
 
 export function buildInstallManifest(targetDir, options = {}) {
   const node = process.execPath;
+  const platform = normalizePlatform(options.platform);
   const selectedTool = normalizeToolId(options.tool || "codex");
   const profile = getToolProfile(selectedTool);
   const serverUrl = options.serverUrl || "http://127.0.0.1:8797";
@@ -50,6 +51,7 @@ export function buildInstallManifest(targetDir, options = {}) {
   const artifacts = buildToolArtifacts({
     targetDir,
     displayTargetDir,
+    platform,
     selectedTool,
     configFile,
     serverUrl,
@@ -61,6 +63,7 @@ export function buildInstallManifest(targetDir, options = {}) {
   const selectedArtifact = artifacts[selectedTool];
   return {
     version: 1,
+    platform,
     targetDir: displayTargetDir,
     selectedTool,
     supportedTools: listToolProfiles(),
@@ -93,6 +96,9 @@ export function buildInstallManifest(targetDir, options = {}) {
       autoUpdateScript: path.join(targetDir, "worklens-auto-update.sh"),
       registerAutoUpdateScript: path.join(targetDir, "worklens-register-autoupdate.sh"),
       unregisterAutoUpdateScript: path.join(targetDir, "worklens-unregister-autoupdate.sh"),
+      windowsCheckinScript: path.join(targetDir, "worklens-checkin.cmd"),
+      windowsSelfCheckScript: path.join(targetDir, "worklens-self-check.cmd"),
+      windowsAutoUpdateScript: path.join(targetDir, "worklens-auto-update.cmd"),
       windowsRegisterAutoUpdateScript: path.join(targetDir, "worklens-register-autoupdate.ps1"),
       installOrUpdateScript: path.join(targetDir, "worklens-install-or-update.sh"),
       readme: path.join(targetDir, "README.md")
@@ -112,6 +118,7 @@ export function buildInstallManifest(targetDir, options = {}) {
 }
 
 export function installClient(options = {}) {
+  const platform = normalizePlatform(options.platform);
   const targetDir = options.targetDir || path.join(os.homedir(), ".ai-worklens");
   const homeDir = options.homeDir || os.homedir();
   fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
@@ -123,6 +130,9 @@ export function installClient(options = {}) {
   const autoUpdateScriptFile = path.join(targetDir, "worklens-auto-update.sh");
   const registerAutoUpdateScriptFile = path.join(targetDir, "worklens-register-autoupdate.sh");
   const unregisterAutoUpdateScriptFile = path.join(targetDir, "worklens-unregister-autoupdate.sh");
+  const windowsCheckinScriptFile = path.join(targetDir, "worklens-checkin.cmd");
+  const windowsSelfCheckScriptFile = path.join(targetDir, "worklens-self-check.cmd");
+  const windowsAutoUpdateScriptFile = path.join(targetDir, "worklens-auto-update.cmd");
   const windowsRegisterAutoUpdateScriptFile = path.join(targetDir, "worklens-register-autoupdate.ps1");
   const installOrUpdateScriptFile = path.join(targetDir, "worklens-install-or-update.sh");
   const readmeFile = path.join(targetDir, "README.md");
@@ -152,7 +162,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 || "",
@@ -162,13 +172,13 @@ export function installClient(options = {}) {
     collection: options.collection || {},
     update: updatePolicy
   });
-  const manifest = buildInstallManifest(targetDir, options);
+  const manifest = buildInstallManifest(targetDir, { ...options, platform });
   fs.writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
   fs.chmodSync(manifestFile, 0o600);
   for (const artifact of Object.values(manifest.toolArtifacts)) {
     fs.writeFileSync(artifact.configFile, `${artifact.config}\n`, { mode: 0o600 });
     fs.chmodSync(artifact.configFile, 0o600);
-    fs.writeFileSync(artifact.hookFile, buildHookScript(artifact.hook.command, artifact.hook.args), { mode: 0o700 });
+    fs.writeFileSync(artifact.hookFile, buildHookScript(artifact.hook.command, artifact.hook.args, platform), { mode: 0o700 });
     fs.chmodSync(artifact.hookFile, 0o700);
     for (const file of Object.values(artifact.extraFiles || {})) {
       fs.writeFileSync(file.file, `${file.content}\n`, { mode: file.mode || 0o600 });
@@ -182,6 +192,12 @@ export function installClient(options = {}) {
   fs.chmodSync(selfCheckScriptFile, 0o700);
   fs.writeFileSync(autoUpdateScriptFile, buildAutoUpdateScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o700 });
   fs.chmodSync(autoUpdateScriptFile, 0o700);
+  fs.writeFileSync(windowsCheckinScriptFile, buildWindowsCheckinScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o600 });
+  fs.chmodSync(windowsCheckinScriptFile, 0o600);
+  fs.writeFileSync(windowsSelfCheckScriptFile, buildWindowsSelfCheckScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o600 });
+  fs.chmodSync(windowsSelfCheckScriptFile, 0o600);
+  fs.writeFileSync(windowsAutoUpdateScriptFile, buildWindowsAutoUpdateScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o600 });
+  fs.chmodSync(windowsAutoUpdateScriptFile, 0o600);
   fs.writeFileSync(registerAutoUpdateScriptFile, buildRegisterAutoUpdateScript(targetDir), { mode: 0o700 });
   fs.chmodSync(registerAutoUpdateScriptFile, 0o700);
   fs.writeFileSync(unregisterAutoUpdateScriptFile, buildUnregisterAutoUpdateScript(), { mode: 0o700 });
@@ -234,13 +250,26 @@ function upperFirst(value) {
   return input ? `${input[0].toUpperCase()}${input.slice(1)}` : input;
 }
 
-function buildToolArtifacts({ targetDir, displayTargetDir, configFile, serverUrl, mcpCommand, mcpArgs }) {
+function normalizePlatform(value = process.platform) {
+  return String(value || process.platform).toLowerCase() === "win32" ? "win32" : "posix";
+}
+
+function isWindowsPlatform(platform = process.platform) {
+  return normalizePlatform(platform) === "win32";
+}
+
+function hookFileNameFor(profile, platform = process.platform) {
+  if (!isWindowsPlatform(platform)) return profile.hookFileName;
+  return profile.hookFileName.replace(/\.sh$/i, ".cmd");
+}
+
+function buildToolArtifacts({ targetDir, displayTargetDir, platform, configFile, serverUrl, mcpCommand, mcpArgs }) {
   return Object.fromEntries(listToolProfiles().map((profile) => {
     const hookArgs = [path.join(agentSrcDir, "hook-adapter.mjs"), "--config", configFile, "--tool", profile.id];
     const artifact = {
       profile,
       configFile: path.join(targetDir, profile.configFileName),
-      hookFile: path.join(targetDir, profile.hookFileName),
+      hookFile: path.join(targetDir, hookFileNameFor(profile, platform)),
       hook: {
         name: profile.hookName,
         command: mcpCommand,
@@ -263,6 +292,7 @@ function buildToolArtifacts({ targetDir, displayTargetDir, configFile, serverUrl
       }),
       extraFiles: extraFilesFor(profile, {
         targetDir,
+        platform,
         configFile,
         mcpCommand,
         mcpArgs,
@@ -315,12 +345,12 @@ function toolConfigFor(profile, { configFile, serverUrl, mcpCommand, mcpArgs, ho
   return JSON.stringify({ command: mcpCommand, args: mcpArgs, env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id, WORKLENS_SERVER_URL: serverUrl } }, null, 2);
 }
 
-function extraFilesFor(profile, { targetDir, hookCommand, hookArgs }) {
+function extraFilesFor(profile, { targetDir, platform, hookCommand, hookArgs }) {
   if (profile.id === "claude-code") {
     return {
       hooksSettings: {
         file: path.join(targetDir, "claude-code-hooks-settings.json"),
-        content: buildClaudeHooksSettings(hookCommand, hookArgs)
+        content: buildClaudeHooksSettings(hookCommand, hookArgs, platform)
       }
     };
   }
@@ -336,7 +366,7 @@ function extraFilesFor(profile, { targetDir, hookCommand, hookArgs }) {
   return {};
 }
 
-function buildClaudeHooksSettings(command, baseArgs) {
+function buildClaudeHooksSettings(command, baseArgs, platform = process.platform) {
   const events = [
     "SessionStart",
     "ModeChange",
@@ -368,7 +398,7 @@ function buildClaudeHooksSettings(command, baseArgs) {
       hooks: [
         {
           type: "command",
-          command: commandLine(command, [...baseArgs, "--event", eventName]),
+          command: commandLine(command, [...baseArgs, "--event", eventName], platform),
           timeout: 10
         }
       ]
@@ -412,6 +442,7 @@ function selectedIntegrationTools(value, manifest) {
 
 function installCodexIntegration(manifest, homeDir) {
   const artifact = manifest.toolArtifacts.codex;
+  const platform = normalizePlatform(manifest.platform);
   const configPath = path.join(homeDir, ".codex", "config.toml");
   const hooksPath = path.join(homeDir, ".codex", "hooks.json");
   const config = readTextConfig(configPath);
@@ -423,7 +454,7 @@ function installCodexIntegration(manifest, homeDir) {
 
   const hooks = readJsonConfig(hooksPath, { hooks: {} });
   hooks.hooks = hooks.hooks && typeof hooks.hooks === "object" ? hooks.hooks : {};
-  const command = shellQuote(artifact.hookFile);
+  const command = isWindowsPlatform(platform) ? windowsCommandFileInvocation(artifact.hookFile) : shellQuote(artifact.hookFile);
   for (const eventName of ["SessionStart", "PreToolUse", "PostToolUse", "UserPromptSubmit", "Stop"]) {
     const entry = {
       hooks: [{ type: "command", command, ...(eventName === "Stop" ? { timeout: 30 } : {}) }]
@@ -492,7 +523,7 @@ function hookEntryContainsWorkLens(entry = {}) {
 }
 
 function workLensHookCommandPattern() {
-  return /(?:ai[-_]?worklens|worklens|silent-ai-observatory|hook-adapter\.mjs|codex-hook\.sh|claude-code-hook\.sh|opencode-hook\.sh)/i;
+  return /(?:ai[-_]?worklens|worklens|silent-ai-observatory|hook-adapter\.mjs|codex-hook\.(?:sh|cmd)|claude-code-hook\.(?:sh|cmd)|opencode-hook\.(?:sh|cmd))/i;
 }
 
 function ensureHookEntry(current, entry) {
@@ -502,8 +533,8 @@ function ensureHookEntry(current, entry) {
   return [...list, entry];
 }
 
-function commandLine(command, args) {
-  return [command, ...args].map(shellQuote).join(" ");
+function commandLine(command, args, platform = process.platform) {
+  return [command, ...args].map((item) => quoteForShell(item, platform)).join(" ");
 }
 
 function readTextConfig(filePath) {
@@ -695,7 +726,20 @@ function shellQuote(value) {
   return `'${String(value).replaceAll("'", "'\\''")}'`;
 }
 
-function buildHookScript(command, args) {
+function windowsQuote(value) {
+  return `"${String(value).replaceAll('"', '""')}"`;
+}
+
+function quoteForShell(value, platform = process.platform) {
+  return isWindowsPlatform(platform) ? windowsQuote(value) : shellQuote(value);
+}
+
+function windowsCommandFileInvocation(filePath) {
+  return `cmd.exe /d /s /c ${windowsQuote(filePath)}`;
+}
+
+function buildHookScript(command, args, platform = process.platform) {
+  if (isWindowsPlatform(platform)) return buildWindowsHookScript(command, args);
   return [
     "#!/usr/bin/env sh",
     "set -eu",
@@ -703,6 +747,14 @@ function buildHookScript(command, args) {
   ].join("\n") + "\n";
 }
 
+function buildWindowsHookScript(command, args) {
+  return [
+    "@echo off",
+    "setlocal",
+    commandLine(command, args, "win32")
+  ].join("\r\n") + "\r\n";
+}
+
 function buildCheckinScript(command, args) {
   return [
     "#!/usr/bin/env sh",
@@ -713,6 +765,17 @@ function buildCheckinScript(command, args) {
   ].join("\n") + "\n";
 }
 
+function buildWindowsCheckinScript(command, args) {
+  const base = commandLine(command, args, "win32");
+  return [
+    "@echo off",
+    "setlocal",
+    `${base} sync-config`,
+    `${base} recover --sync false --checkin false`,
+    `${base} checkin`
+  ].join("\r\n") + "\r\n";
+}
+
 function buildSelfCheckScript(command, args) {
   return [
     "#!/usr/bin/env sh",
@@ -721,6 +784,14 @@ function buildSelfCheckScript(command, args) {
   ].join("\n") + "\n";
 }
 
+function buildWindowsSelfCheckScript(command, args) {
+  return [
+    "@echo off",
+    "setlocal",
+    `${commandLine(command, args, "win32")} doctor`
+  ].join("\r\n") + "\r\n";
+}
+
 function buildAutoUpdateScript(command, args) {
   return [
     "#!/usr/bin/env sh",
@@ -730,6 +801,16 @@ function buildAutoUpdateScript(command, args) {
   ].join("\n") + "\n";
 }
 
+function buildWindowsAutoUpdateScript(command, args) {
+  const base = commandLine(command, args, "win32");
+  return [
+    "@echo off",
+    "setlocal",
+    `${base} recover --checkin false`,
+    `${base} auto-update`
+  ].join("\r\n") + "\r\n";
+}
+
 function buildRegisterAutoUpdateScript(targetDir) {
   const plist = "com.ai-worklens.autoupdate.plist";
   const interval = 1800;
@@ -793,11 +874,11 @@ function buildUnregisterAutoUpdateScript() {
 }
 
 function buildWindowsRegisterAutoUpdateScript(targetDir) {
-  const autoUpdate = path.win32.join("%USERPROFILE%", ".ai-worklens", "worklens-auto-update.sh");
+  const autoUpdate = path.win32.join("%USERPROFILE%", ".ai-worklens", "worklens-auto-update.cmd");
   return [
     "$TaskName = \"AIWorkLensAutoUpdate\"",
     `$AutoUpdate = \"${autoUpdate}\"`,
-    "$Action = New-ScheduledTaskAction -Execute \"wsl.exe\" -Argument \"sh $AutoUpdate\"",
+    "$Action = New-ScheduledTaskAction -Execute \"cmd.exe\" -Argument \"/d /s /c `\"$AutoUpdate`\"\"",
     "$Trigger = New-ScheduledTaskTrigger -Once -At (Get-Date).AddMinutes(5) -RepetitionInterval (New-TimeSpan -Hours 6)",
     "$Settings = New-ScheduledTaskSettingsSet -AllowStartIfOnBatteries -DontStopIfGoingOnBatteries",
     "Register-ScheduledTask -TaskName $TaskName -Action $Action -Trigger $Trigger -Settings $Settings -Force",
@@ -841,12 +922,12 @@ function buildReadme(manifest) {
     `- client.json: 员工端配置和中心端下发规则。`,
     `- install-manifest.json: 安装清单。`,
     `- *-mcp.*: 各 AI 工具的 MCP 配置片段。`,
-    `- *-hook.sh: 各 AI 工具的 hook adapter 启动脚本。`,
+    `- *-hook.sh / *-hook.cmd: 各 AI 工具的 hook adapter 启动脚本。`,
     `- claude-code-hooks-settings.json: Claude Code hooks 配置片段。`,
     `- opencode-ai-worklens-plugin.js: OpenCode 本地插件。`,
-    `- worklens-checkin.sh: 同步规则、补传离线队列并上报健康状态。`,
-    `- worklens-self-check.sh: 检查中心端连通性、本地配置和离线队列。`,
-    `- worklens-auto-update.sh: 拉取中心端版本策略，并在中心端恢复后自动补传离线队列。`,
+    `- worklens-checkin.sh / worklens-checkin.cmd: 同步规则、补传离线队列并上报健康状态。`,
+    `- worklens-self-check.sh / worklens-self-check.cmd: 检查中心端连通性、本地配置和离线队列。`,
+    `- worklens-auto-update.sh / worklens-auto-update.cmd: 拉取中心端版本策略，并在中心端恢复后自动补传离线队列。`,
     `- worklens-register-autoupdate.sh: 在 macOS 用户级 LaunchAgent 注册后台静默更新和恢复上报任务。`,
     `- worklens-unregister-autoupdate.sh: 移除后台静默更新任务。`,
     `- worklens-install-or-update.sh: 同步中心端规则、上报健康并执行自检。`,
@@ -860,13 +941,26 @@ function buildReadme(manifest) {
 
 function runPostInstall(result, args = {}) {
   if (args["post-install"] === "false") return { ok: true, skipped: true };
-  const checkin = spawnSync(result.generatedFiles.checkinScript, [], {
+  const platform = normalizePlatform(result.manifest?.platform || process.platform);
+  const timeout = Number(args["post-install-timeout-ms"] || 15000);
+  const checkinScript = isWindowsPlatform(platform)
+    ? result.generatedFiles.windowsCheckinScript
+    : result.generatedFiles.checkinScript;
+  const checkinCommand = isWindowsPlatform(platform) ? "cmd.exe" : checkinScript;
+  const checkinArgs = isWindowsPlatform(platform) ? ["/d", "/s", "/c", checkinScript] : [];
+  const registerCommand = isWindowsPlatform(platform)
+    ? "powershell.exe"
+    : result.generatedFiles.registerAutoUpdateScript;
+  const registerArgs = isWindowsPlatform(platform)
+    ? ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", result.generatedFiles.windowsRegisterAutoUpdateScript]
+    : [];
+  const checkin = spawnSync(checkinCommand, checkinArgs, {
     encoding: "utf8",
-    timeout: Number(args["post-install-timeout-ms"] || 15000)
+    timeout
   });
-  const register = spawnSync(result.generatedFiles.registerAutoUpdateScript, [], {
+  const register = spawnSync(registerCommand, registerArgs, {
     encoding: "utf8",
-    timeout: Number(args["post-install-timeout-ms"] || 15000)
+    timeout
   });
   return {
     ok: checkin.status === 0,

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.6";
 
 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([]);
+    });
   }
 }

package/src/uploader.mjs

@@ -410,6 +410,11 @@ export class ClientAgent {
         codexHooks.enabled,
         codexHooks.message
       ));
+      checks.push(check(
+        "codex_hooks_executable",
+        codexHooks.executable,
+        codexHooks.executableMessage || "Codex hook 指向的脚本不存在，或不是当前系统可执行的脚本格式"
+      ));
       status.codexHooks = codexHooks;
     }
 
@@ -435,13 +440,18 @@ function codexHookDiagnostics(config) {
   const configPath = path.join(homeDir, ".codex", "config.toml");
   const hookEvents = new Set(["session_start", "pre_tool_use", "post_tool_use", "user_prompt_submit", "stop"]);
   const configuredEvents = codexConfiguredHookEvents(hooksPath);
+  const hookCommands = codexConfiguredHookCommands(hooksPath);
   const disabledStates = codexDisabledHookStates(configPath, hooksPath, hookEvents);
+  const executableState = codexHookExecutableState(hookCommands);
   return {
     hooksPath,
     configPath,
     configured: configuredEvents.length > 0,
     configuredEvents,
+    hookCommands,
     enabled: disabledStates.length === 0,
+    executable: executableState.ok,
+    executableMessage: executableState.message,
     disabledStates,
     message: disabledStates.length
       ? `Codex hook 已配置但未启用：${disabledStates.join("、")}，请重新运行安装命令或执行 worklens-agent-install 修复。`
@@ -461,6 +471,20 @@ function codexConfiguredHookEvents(hooksPath) {
   }
 }
 
+function codexConfiguredHookCommands(hooksPath) {
+  try {
+    if (!fs.existsSync(hooksPath)) return [];
+    const hooks = JSON.parse(fs.readFileSync(hooksPath, "utf8"));
+    return Object.values(hooks.hooks || {})
+      .flatMap((entries) => Array.isArray(entries) ? entries : [])
+      .flatMap((entry) => Array.isArray(entry.hooks) ? entry.hooks : [])
+      .map((hook) => String(hook.command || ""))
+      .filter((command) => workLensHookPattern().test(command));
+  } catch {
+    return [];
+  }
+}
+
 function entriesContainWorkLensHook(entries) {
   return (Array.isArray(entries) ? entries : []).some((entry) => {
     return (entry.hooks || []).some((hook) => workLensHookPattern().test(String(hook.command || "")));
@@ -468,7 +492,30 @@ function entriesContainWorkLensHook(entries) {
 }
 
 function workLensHookPattern() {
-  return /(?:ai[-_]?worklens|worklens|silent-ai-observatory|hook-adapter\.mjs|codex-hook\.sh)/i;
+  return /(?:ai[-_]?worklens|worklens|silent-ai-observatory|hook-adapter\.mjs|codex-hook\.(?:sh|cmd))/i;
+}
+
+function codexHookExecutableState(commands) {
+  if (!commands.length) return { ok: false, message: "未找到 AI WorkLens Codex hook 命令" };
+  const scriptPaths = commands.map(extractCodexHookScriptPath).filter(Boolean);
+  if (!scriptPaths.length) return { ok: false, message: "Codex hook 命令中未找到 codex-hook 脚本路径" };
+  for (const scriptPath of scriptPaths) {
+    if (!fs.existsSync(scriptPath)) return { ok: false, message: `Codex hook 脚本不存在：${scriptPath}` };
+    if (process.platform === "win32" && !/\.cmd$/i.test(scriptPath)) {
+      return { ok: false, message: `Windows 需要 codex-hook.cmd，当前是：${scriptPath}` };
+    }
+    if (process.platform !== "win32" && !/\.sh$/i.test(scriptPath)) {
+      return { ok: false, message: `macOS/Linux 需要 codex-hook.sh，当前是：${scriptPath}` };
+    }
+  }
+  return { ok: true, message: "" };
+}
+
+function extractCodexHookScriptPath(command) {
+  const quoted = String(command || "").match(/["']([^"']*codex-hook\.(?:sh|cmd))["']/i);
+  if (quoted) return quoted[1];
+  const unquoted = String(command || "").match(/([^\s]+codex-hook\.(?:sh|cmd))/i);
+  return unquoted ? unquoted[1] : "";
 }
 
 function codexDisabledHookStates(configPath, hooksPath, hookEvents) {