ai-worklens-agent 0.1.2 → 0.1.5

package/README.md

@@ -36,8 +36,8 @@ npm run mcp
 如果管理员已经把员工端发布到 npm 或企业私有 npm 源，可以使用 `npx` 首次安装：
 
 ```bash
-NPM_CONFIG_UPDATE_NOTIFIER=false npx -y --loglevel=error -p ai-worklens-agent@0.1.2 worklens-agent-install \
-  --server-url http://127.0.0.1:8797 \
+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://127.0.0.1:8797/site/downloads/ai-worklens-codex-0.1.0.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.2",
+  "version": "0.1.5",
   "description": "Employee-side collector agent for AI WorkLens.",
   "type": "module",
   "bin": {

package/src/config.mjs

@@ -22,6 +22,92 @@ function readJson(filePath) {
   }
 }
 
+function readText(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return "";
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function firstValue(...values) {
+  return values.map((value) => String(value || "").trim()).find(Boolean) || "";
+}
+
+function knownModel(model) {
+  return Boolean(model?.label && model.label !== "unknown");
+}
+
+function rootTomlString(content, key) {
+  const keyPattern = new RegExp(`^${key}\\s*=\\s*["']([^"']+)["']`);
+  for (const line of String(content || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    if (trimmed.startsWith("[")) return "";
+    const match = trimmed.match(keyPattern);
+    if (match) return match[1].trim();
+  }
+  return "";
+}
+
+function jsonishString(content, key) {
+  const match = String(content || "").match(new RegExp(`["']?${key}["']?\\s*[:=]\\s*["']([^"']+)["']`));
+  return match?.[1]?.trim() || "";
+}
+
+function inferCodexModel(homeDir, env) {
+  const codexConfig = readText(path.join(homeDir, ".codex", "config.toml"));
+  return normalizeModelInfo({
+    provider: firstValue(env.OPENAI_PROVIDER, "openai"),
+    name: firstValue(
+      env.CODEX_MODEL,
+      env.OPENAI_MODEL,
+      rootTomlString(codexConfig, "model"),
+      jsonishString(codexConfig, "model")
+    )
+  });
+}
+
+function inferClaudeModel(homeDir, env) {
+  const claudeSettings = readJson(path.join(homeDir, ".claude", "settings.json"));
+  const claudeJson = readJson(path.join(homeDir, ".claude.json"));
+  return normalizeModelInfo({
+    provider: firstValue(env.ANTHROPIC_PROVIDER, "anthropic"),
+    name: firstValue(
+      env.CLAUDE_CODE_MODEL,
+      env.CLAUDE_MODEL,
+      env.ANTHROPIC_MODEL,
+      claudeSettings.model,
+      claudeSettings.modelName,
+      claudeSettings.env?.ANTHROPIC_MODEL,
+      claudeJson.model,
+      claudeJson.modelName
+    )
+  });
+}
+
+function inferOpenCodeModel(homeDir, env) {
+  const candidates = [
+    path.join(homeDir, ".config", "opencode", "opencode.json"),
+    path.join(homeDir, ".config", "opencode", "opencode.jsonc"),
+    path.join(homeDir, ".opencode", "config.json"),
+    path.join(homeDir, ".opencode", "config.jsonc")
+  ];
+  const configText = candidates.map(readText).find(Boolean) || "";
+  return normalizeModelInfo({
+    name: firstValue(env.OPENCODE_MODEL, env.OPENAI_MODEL, jsonishString(configText, "model")),
+    provider: firstValue(env.OPENCODE_PROVIDER, jsonishString(configText, "provider"))
+  });
+}
+
+function inferToolModel({ tool, homeDir, env }) {
+  const normalizedTool = normalizeToolId(tool);
+  if (normalizedTool === "claude-code") return inferClaudeModel(homeDir, env);
+  if (normalizedTool === "opencode") return inferOpenCodeModel(homeDir, env);
+  return inferCodexModel(homeDir, env);
+}
+
 function defaultClientId() {
   const seed = `${os.hostname()}:${os.userInfo().username}`;
   return `device_${crypto.createHash("sha256").update(seed).digest("hex").slice(0, 12)}`;
@@ -38,31 +124,38 @@ export function defaultQueueFile(configFile = defaultConfigFile()) {
 export function loadClientConfig(options = {}) {
   const configFile = options.configFile || defaultConfigFile();
   const fileConfig = readJson(configFile);
-  const env = process.env;
+  const env = options.env || process.env;
+  const homeDir = options.homeDir || envValue(env, "WORKLENS_HOME_DIR") || fileConfig.homeDir || os.homedir();
+  const tool = normalizeToolId(options.tool || envValue(env, "WORKLENS_TOOL") || fileConfig.tool || "codex");
   const serverUrl = options.serverUrl || envValue(env, "WORKLENS_SERVER_URL") || fileConfig.serverUrl || "http://127.0.0.1:8797";
   const collection = normalizeCollectionSettings(options.collection || fileConfig.collection || {});
+  const configuredModel = normalizeModelInfo({
+    ...fileConfig.model,
+    provider: options.modelProvider || envValue(env, "WORKLENS_MODEL_PROVIDER") || fileConfig.model?.provider,
+    name: options.modelName || envValue(env, "WORKLENS_MODEL_NAME") || fileConfig.model?.name,
+    version: options.modelVersion || envValue(env, "WORKLENS_MODEL_VERSION") || fileConfig.model?.version,
+    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 || ""
   };
   return {
     configFile,
+    homeDir,
     queueFile: options.queueFile || defaultQueueFile(configFile),
     serverUrl,
     collectorToken: options.collectorToken || envValue(env, "WORKLENS_COLLECTOR_TOKEN") || fileConfig.collectorToken || "",
     clientId: options.clientId || envValue(env, "WORKLENS_CLIENT_ID") || fileConfig.clientId || defaultClientId(),
     clientVersion: options.clientVersion || fileConfig.clientVersion || "0.1.0",
-    tool: normalizeToolId(options.tool || envValue(env, "WORKLENS_TOOL") || fileConfig.tool || "codex"),
-    model: normalizeModelInfo({
-      ...fileConfig.model,
-      provider: options.modelProvider || envValue(env, "WORKLENS_MODEL_PROVIDER") || fileConfig.model?.provider,
-      name: options.modelName || envValue(env, "WORKLENS_MODEL_NAME") || fileConfig.model?.name,
-      version: options.modelVersion || envValue(env, "WORKLENS_MODEL_VERSION") || fileConfig.model?.version,
-      family: options.modelFamily || envValue(env, "WORKLENS_MODEL_FAMILY") || fileConfig.model?.family
-    }),
+    tool,
+    model: knownModel(configuredModel) ? configuredModel : inferredModel,
     workspaceRoot: options.workspaceRoot || envValue(env, "WORKLENS_WORKSPACE_ROOT") || process.cwd(),
     repoName: options.repoName || envValue(env, "WORKLENS_REPO_NAME") || path.basename(options.workspaceRoot || envValue(env, "WORKLENS_WORKSPACE_ROOT") || process.cwd()),
     branch: options.branch || envValue(env, "WORKLENS_BRANCH") || fileConfig.branch || "",

package/src/hook-adapter.mjs

@@ -70,11 +70,17 @@ function eventTypeFromHook(name, payload) {
   if (["pretooluse", "toolcall", "tooluse", "toolusebefore", "toolexecutebefore"].includes(compact)) {
     const toolName = toolNameFromPayload(payload);
     const command = commandFromPayload(payload);
+    if (skillNameFromPayload(payload)) return "skill_use";
+    if (mcpServerFromPayload(payload)) return "mcp_tool_call";
+    if (pluginNameFromPayload(payload)) return "plugin_use";
     return /bash|shell|terminal|command/i.test(toolName) ? commandEventType(command) : "tool_call";
   }
   if (["posttooluse", "posttoolbatch", "tooluseafter", "toolexecuteafter"].includes(compact)) {
     const toolName = toolNameFromPayload(payload);
     const command = commandFromPayload(payload);
+    if (skillNameFromPayload(payload)) return "skill_use";
+    if (mcpServerFromPayload(payload)) return "mcp_tool_call";
+    if (pluginNameFromPayload(payload)) return "plugin_use";
     return /bash|shell|terminal|command/i.test(toolName) ? commandEventType(command) : "tool_result";
   }
   if (["commandexecuted", "tuicommandexecute"].includes(compact)) return commandEventType(commandFromPayload(payload));
@@ -96,13 +102,32 @@ function commandEventType(command) {
 }
 
 function toolNameFromPayload(payload) {
-  return payload.toolName ||
-    payload.tool_name ||
-    payload.tool ||
-    payload.input?.tool ||
-    payload.output?.tool ||
-    payload.request?.tool ||
-    "";
+  return firstText(
+    payload.toolName,
+    payload.tool_name,
+    payload.tool,
+    payload.name,
+    payload.input?.toolName,
+    payload.input?.tool_name,
+    payload.input?.tool,
+    payload.input?.name,
+    payload.output?.toolName,
+    payload.output?.tool_name,
+    payload.output?.tool,
+    payload.output?.name,
+    payload.request?.toolName,
+    payload.request?.tool_name,
+    payload.request?.tool,
+    payload.tool_input?.toolName,
+    payload.tool_input?.tool_name,
+    payload.tool_input?.tool,
+    payload.toolInput?.toolName,
+    payload.toolInput?.tool_name,
+    payload.toolInput?.tool,
+    payload.tool_args?.toolName,
+    payload.tool_args?.tool_name,
+    payload.tool_args?.tool
+  );
 }
 
 function firstText(...values) {
@@ -127,6 +152,111 @@ function modeFromPayload(payload) {
   );
 }
 
+function skillNameFromPayload(payload) {
+  return firstText(
+    payload.skillName,
+    payload.skill_name,
+    payload.skill,
+    payload.metadata?.skillName,
+    payload.metadata?.skill_name,
+    payload.metadata?.skill,
+    payload.context?.skillName,
+    payload.context?.skill_name,
+    payload.context?.skill,
+    payload.input?.skillName,
+    payload.input?.skill_name,
+    payload.input?.skill,
+    payload.output?.skillName,
+    payload.output?.skill_name,
+    payload.output?.skill
+  );
+}
+
+function pluginNameFromPayload(payload) {
+  const explicit = firstText(
+    payload.pluginName,
+    payload.plugin_name,
+    payload.plugin,
+    payload.metadata?.pluginName,
+    payload.metadata?.plugin_name,
+    payload.metadata?.plugin,
+    payload.context?.pluginName,
+    payload.context?.plugin_name,
+    payload.context?.plugin,
+    payload.input?.pluginName,
+    payload.input?.plugin_name,
+    payload.input?.plugin,
+    payload.output?.pluginName,
+    payload.output?.plugin_name,
+    payload.output?.plugin
+  );
+  if (explicit) return explicit;
+  return pluginNameFromMcpNamespace(mcpNamespaceFromToolName(toolNameFromPayload(payload)));
+}
+
+function mcpServerFromPayload(payload) {
+  const explicit = firstText(
+    payload.mcpServer,
+    payload.mcp_server,
+    payload.server,
+    payload.metadata?.mcpServer,
+    payload.metadata?.mcp_server,
+    payload.metadata?.server,
+    payload.context?.mcpServer,
+    payload.context?.mcp_server,
+    payload.context?.server,
+    payload.input?.mcpServer,
+    payload.input?.mcp_server,
+    payload.input?.server,
+    payload.output?.mcpServer,
+    payload.output?.mcp_server,
+    payload.output?.server
+  );
+  if (explicit) return normalizeMcpServerName(explicit);
+  return normalizeMcpServerName(mcpNamespaceFromToolName(toolNameFromPayload(payload)));
+}
+
+function mcpNamespaceFromToolName(value) {
+  const toolName = String(value || "");
+  const match = toolName.match(/^mcp__(.+?)(?:[.:].*)?$/);
+  return match ? match[1] : "";
+}
+
+function normalizeMcpServerName(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  if (raw.startsWith("codex_apps__")) return raw.slice("codex_apps__".length).replaceAll("_", "-");
+  return raw.replaceAll("_", "-");
+}
+
+function pluginNameFromMcpNamespace(value) {
+  const raw = String(value || "").trim();
+  if (!raw) return "";
+  const normalized = normalizeMcpServerName(raw);
+  const key = normalized.toLowerCase();
+  const rawKey = raw.toLowerCase();
+  const mapping = {
+    playwright: "Browser",
+    browser: "Browser",
+    chrome: "Chrome",
+    "computer-use": "Computer Use",
+    figma: "Figma",
+    "outlook-email": "Outlook Email",
+    presentations: "Presentations",
+    spreadsheets: "Spreadsheets"
+  };
+  if (rawKey.startsWith("codex_apps__")) return mapping[key] || upperPluginName(normalized);
+  return mapping[key] || "";
+}
+
+function upperPluginName(value) {
+  return String(value || "")
+    .split(/[-_\s]+/)
+    .filter(Boolean)
+    .map((part) => `${part[0]?.toUpperCase() || ""}${part.slice(1)}`)
+    .join(" ");
+}
+
 function previousModeFromPayload(payload) {
   return firstText(
     payload.previousMode,
@@ -268,6 +398,10 @@ export function normalizeHookPayload(payload, args, config) {
   const eventType = eventTypeFromHook(name, payload);
   const summary = pickSummary(payload, name, eventType);
   const metadata = payload.metadata && typeof payload.metadata === "object" ? payload.metadata : {};
+  const skillName = skillNameFromPayload(payload);
+  const pluginName = pluginNameFromPayload(payload);
+  const mcpServer = mcpServerFromPayload(payload);
+  const toolName = toolNameFromPayload(payload);
   return buildEvent({
     ...payload,
     eventType,
@@ -277,9 +411,9 @@ export function normalizeHookPayload(payload, args, config) {
     hookName: name,
     localSessionId: payload.sessionId || payload.session_id || payload.localSessionId,
     turnIndex: payload.turnIndex || payload.turn_index,
-    skillName: payload.skillName || payload.skill_name || payload.skill,
-    pluginName: payload.pluginName || payload.plugin_name || payload.plugin,
-    mcpServer: payload.mcpServer || payload.mcp_server || payload.server,
+    skillName,
+    pluginName,
+    mcpServer,
     files: fileRefsFromPayload(payload),
     commands: commandFromPayload(payload),
     durationSeconds: payload.durationSeconds || payload.duration_seconds || payload.duration_ms && Number(payload.duration_ms) / 1000,
@@ -289,7 +423,11 @@ export function normalizeHookPayload(payload, args, config) {
       sourceTool: config.tool,
       rawHookEvent: name,
       hookEventName: payload.hook_event_name || payload.hookEventName || payload.event || payload.type || name,
-      toolName: toolNameFromPayload(payload),
+      toolName,
+      skillName,
+      pluginName,
+      mcpServer,
+      mcpNamespace: mcpNamespaceFromToolName(toolName),
       codexMode: nextModeFromPayload(payload),
       interactionType: eventType,
       cwd: payload.cwd || payload.directory || payload.project?.directory,
@@ -305,7 +443,7 @@ export function normalizeHookPayload(payload, args, config) {
       previousMode: previousModeFromPayload(payload),
       nextMode: nextModeFromPayload(payload),
       phase: payload.phase || payload.input?.phase || payload.output?.phase,
-      toolName: toolNameFromPayload(payload),
+      toolName,
       toolStatus: statusFromPayload(payload),
       exitCode: payload.exitCode ?? payload.exit_code ?? payload.output?.exitCode ?? payload.output?.exit_code,
       permissionDecision: permissionDecisionFromPayload(payload),