ai-worklens-agent 0.1.0

package/src/install.mjs

@@ -0,0 +1,602 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { writeClientConfig } from "./config.mjs";
+import { getToolProfile, listToolProfiles, normalizeToolId } from "../../collector-protocol/src/tool-profiles.mjs";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, "../../..");
+
+function parseArgs(argv) {
+  const result = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (!arg.startsWith("--")) continue;
+    const key = arg.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) result[key] = true;
+    else {
+      result[key] = next;
+      index += 1;
+    }
+  }
+  return result;
+}
+
+export function buildInstallManifest(targetDir, options = {}) {
+  const node = process.execPath;
+  const selectedTool = normalizeToolId(options.tool || "codex");
+  const profile = getToolProfile(selectedTool);
+  const displayTargetDir = displayPath(targetDir);
+  const configFile = path.join(displayTargetDir, "client.json");
+  const mcpCommand = node;
+  const mcpArgs = [path.join(projectRoot, "packages/client-agent/src/mcp-server.mjs")];
+  const hookCommand = node;
+  const hookArgs = [path.join(projectRoot, "packages/client-agent/src/hook-adapter.mjs"), "--config", configFile, "--tool", selectedTool];
+  const artifacts = buildToolArtifacts({
+    targetDir,
+    displayTargetDir,
+    selectedTool,
+    configFile,
+    mcpCommand,
+    mcpArgs,
+    hookCommand,
+    hookArgs
+  });
+  const selectedArtifact = artifacts[selectedTool];
+  return {
+    version: 1,
+    targetDir: displayTargetDir,
+    selectedTool,
+    supportedTools: listToolProfiles(),
+    mcp: {
+      name: profile.mcpServerName,
+      command: mcpCommand,
+      args: mcpArgs,
+      env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: selectedTool }
+    },
+    hook: {
+      name: profile.hookName,
+      command: hookCommand,
+      args: hookArgs
+    },
+    eventCli: {
+      command: node,
+      args: [path.join(projectRoot, "packages/client-agent/src/cli.mjs"), "--config", configFile]
+    },
+    generatedFiles: {
+      clientConfig: configFile,
+      installManifest: path.join(targetDir, "install-manifest.json"),
+      ...Object.fromEntries(Object.entries(artifacts).flatMap(([toolId, artifact]) => [
+        [`${camelKey(toolId)}McpConfig`, artifact.configFile],
+        [`${camelKey(toolId)}HookScript`, artifact.hookFile],
+        ...Object.entries(artifact.extraFiles || {}).map(([key, value]) => [`${camelKey(toolId)}${upperFirst(key)}`, value.file])
+      ])),
+      codexMcpSnippet: artifacts.codex.configFile,
+      checkinScript: path.join(targetDir, "worklens-checkin.sh"),
+      selfCheckScript: path.join(targetDir, "worklens-self-check.sh"),
+      autoUpdateScript: path.join(targetDir, "worklens-auto-update.sh"),
+      registerAutoUpdateScript: path.join(targetDir, "worklens-register-autoupdate.sh"),
+      unregisterAutoUpdateScript: path.join(targetDir, "worklens-unregister-autoupdate.sh"),
+      windowsRegisterAutoUpdateScript: path.join(targetDir, "worklens-register-autoupdate.ps1"),
+      installOrUpdateScript: path.join(targetDir, "worklens-install-or-update.sh"),
+      readme: path.join(targetDir, "README.md")
+    },
+    toolArtifacts: artifacts,
+    selectedConfig: selectedArtifact.config,
+    codexConfigToml: artifacts.codex.config,
+    claudeCodeMcpJson: artifacts["claude-code"].config,
+    opencodeConfigJson: artifacts.opencode.config,
+    privacy: {
+      rawPromptUploaded: false,
+      fullReplyUploaded: false,
+      localRedaction: true
+    },
+    serverUrl: options.serverUrl || "http://127.0.0.1:8797"
+  };
+}
+
+export function installClient(options = {}) {
+  const targetDir = options.targetDir || path.join(os.homedir(), ".ai-worklens");
+  fs.mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+  const configFile = path.join(targetDir, "client.json");
+  const manifestFile = path.join(targetDir, "install-manifest.json");
+  const mcpSnippetFile = path.join(targetDir, "codex-mcp-snippet.toml");
+  const checkinScriptFile = path.join(targetDir, "worklens-checkin.sh");
+  const selfCheckScriptFile = path.join(targetDir, "worklens-self-check.sh");
+  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 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");
+  const selectedTool = normalizeToolId(options.tool || "codex");
+  writeClientConfig(configFile, {
+    serverUrl: options.serverUrl || "http://127.0.0.1:8797",
+    collectorToken: options.collectorToken || "",
+    clientId: options.clientId || "",
+    clientVersion: options.clientVersion || "0.1.0",
+    tool: selectedTool,
+    model: {
+      provider: options.modelProvider || "",
+      name: options.modelName || "",
+      version: options.modelVersion || "",
+      family: options.modelFamily || ""
+    },
+    employee: {
+      id: options.employeeId || "",
+      name: options.employeeName || "",
+      pinyinName: options.employeePinyin || options.pinyinName || "",
+      department: options.department || "",
+      role: options.role || ""
+    },
+    upload: options.upload || { timeoutMs: 5000, batchSize: 50 },
+    collection: options.collection || {},
+    update: options.updatePolicy || {}
+  });
+  const manifest = buildInstallManifest(targetDir, options);
+  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.chmodSync(artifact.hookFile, 0o700);
+    for (const file of Object.values(artifact.extraFiles || {})) {
+      fs.writeFileSync(file.file, `${file.content}\n`, { mode: file.mode || 0o600 });
+      fs.chmodSync(file.file, file.mode || 0o600);
+    }
+  }
+  if (!fs.existsSync(mcpSnippetFile)) fs.writeFileSync(mcpSnippetFile, `${manifest.codexConfigToml}\n`, { mode: 0o600 });
+  fs.writeFileSync(checkinScriptFile, buildCheckinScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o700 });
+  fs.chmodSync(checkinScriptFile, 0o700);
+  fs.writeFileSync(selfCheckScriptFile, buildSelfCheckScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o700 });
+  fs.chmodSync(selfCheckScriptFile, 0o700);
+  fs.writeFileSync(autoUpdateScriptFile, buildAutoUpdateScript(manifest.eventCli.command, manifest.eventCli.args), { mode: 0o700 });
+  fs.chmodSync(autoUpdateScriptFile, 0o700);
+  fs.writeFileSync(registerAutoUpdateScriptFile, buildRegisterAutoUpdateScript(targetDir), { mode: 0o700 });
+  fs.chmodSync(registerAutoUpdateScriptFile, 0o700);
+  fs.writeFileSync(unregisterAutoUpdateScriptFile, buildUnregisterAutoUpdateScript(), { mode: 0o700 });
+  fs.chmodSync(unregisterAutoUpdateScriptFile, 0o700);
+  fs.writeFileSync(windowsRegisterAutoUpdateScriptFile, buildWindowsRegisterAutoUpdateScript(targetDir), { mode: 0o600 });
+  fs.chmodSync(windowsRegisterAutoUpdateScriptFile, 0o600);
+  fs.writeFileSync(installOrUpdateScriptFile, buildInstallOrUpdateScript(manifest.eventCli.command, manifest.eventCli.args, targetDir), { mode: 0o700 });
+  fs.chmodSync(installOrUpdateScriptFile, 0o700);
+  fs.writeFileSync(readmeFile, buildReadme(manifest), { mode: 0o600 });
+  fs.chmodSync(readmeFile, 0o600);
+  return {
+    ok: true,
+    targetDir,
+    configFile,
+    manifestFile,
+    generatedFiles: manifest.generatedFiles,
+    manifest
+  };
+}
+
+function tomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function displayPath(value) {
+  const input = String(value || "");
+  if (input === "~") return "$HOME";
+  if (input.startsWith("~/")) return `$HOME/${input.slice(2)}`;
+  return input;
+}
+
+function tomlArray(values) {
+  return `[${values.map((value) => tomlString(value)).join(", ")}]`;
+}
+
+function camelKey(value) {
+  return String(value).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function upperFirst(value) {
+  const input = String(value);
+  return input ? `${input[0].toUpperCase()}${input.slice(1)}` : input;
+}
+
+function buildToolArtifacts({ targetDir, displayTargetDir, configFile, mcpCommand, mcpArgs }) {
+  return Object.fromEntries(listToolProfiles().map((profile) => {
+    const hookArgs = [path.join(projectRoot, "packages/client-agent/src/hook-adapter.mjs"), "--config", configFile, "--tool", profile.id];
+    const artifact = {
+      profile,
+      configFile: path.join(targetDir, profile.configFileName),
+      hookFile: path.join(targetDir, profile.hookFileName),
+      hook: {
+        name: profile.hookName,
+        command: mcpCommand,
+        args: hookArgs
+      },
+      mcp: {
+        name: profile.mcpServerName,
+        command: mcpCommand,
+        args: mcpArgs,
+        env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id }
+      },
+      config: toolConfigFor(profile, {
+        configFile,
+        mcpCommand,
+        mcpArgs,
+        hookCommand: mcpCommand,
+        hookArgs,
+        displayTargetDir
+      }),
+      extraFiles: extraFilesFor(profile, {
+        targetDir,
+        configFile,
+        mcpCommand,
+        mcpArgs,
+        hookCommand: mcpCommand,
+        hookArgs
+      }),
+      note: profile.installNote
+    };
+    return [profile.id, artifact];
+  }));
+}
+
+function toolConfigFor(profile, { configFile, mcpCommand, mcpArgs, hookCommand, hookArgs }) {
+  if (profile.id === "codex") {
+    return [
+      `[mcp_servers.${profile.mcpServerName}]`,
+      `command = ${tomlString(mcpCommand)}`,
+      `args = ${tomlArray(mcpArgs)}`,
+      "",
+      `[mcp_servers.${profile.mcpServerName}.env]`,
+      `WORKLENS_CONFIG_FILE = ${tomlString(configFile)}`,
+      `WORKLENS_TOOL = ${tomlString(profile.id)}`
+    ].join("\n");
+  }
+  if (profile.id === "claude-code") {
+    return JSON.stringify({
+      mcpServers: {
+        [profile.mcpServerName]: {
+          command: mcpCommand,
+          args: mcpArgs,
+          env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id }
+        }
+      }
+    }, null, 2);
+  }
+  if (profile.id === "opencode") {
+    return JSON.stringify({
+      $schema: "https://opencode.ai/config.json",
+      mcp: {
+        [profile.mcpServerName]: {
+          type: "local",
+          command: [mcpCommand, ...mcpArgs],
+          enabled: true,
+          environment: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id }
+        }
+      }
+    }, null, 2);
+  }
+  return JSON.stringify({ command: mcpCommand, args: mcpArgs, env: { WORKLENS_CONFIG_FILE: configFile, WORKLENS_TOOL: profile.id } }, null, 2);
+}
+
+function extraFilesFor(profile, { targetDir, hookCommand, hookArgs }) {
+  if (profile.id === "claude-code") {
+    return {
+      hooksSettings: {
+        file: path.join(targetDir, "claude-code-hooks-settings.json"),
+        content: buildClaudeHooksSettings(hookCommand, hookArgs)
+      }
+    };
+  }
+  if (profile.id === "opencode") {
+    return {
+      plugin: {
+        file: path.join(targetDir, "opencode-ai-worklens-plugin.js"),
+        content: buildOpenCodePlugin(hookCommand, hookArgs),
+        mode: 0o600
+      }
+    };
+  }
+  return {};
+}
+
+function buildClaudeHooksSettings(command, baseArgs) {
+  const events = [
+    "SessionStart",
+    "ModeChange",
+    "UserPromptSubmit",
+    "UserPromptExpansion",
+    "PreToolUse",
+    "PermissionRequest",
+    "PermissionDenied",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PostToolBatch",
+    "TaskCreated",
+    "TaskCompleted",
+    "SubagentStart",
+    "SubagentStop",
+    "FileChanged",
+    "ConfigChange",
+    "CwdChanged",
+    "Notification",
+    "PreCompact",
+    "PostCompact",
+    "Stop",
+    "StopFailure",
+    "SessionEnd"
+  ];
+  const matcherEvents = new Set(["PreToolUse", "PermissionRequest", "PermissionDenied", "PostToolUse", "PostToolUseFailure", "PostToolBatch"]);
+  const hooks = Object.fromEntries(events.map((eventName) => {
+    const entry = {
+      hooks: [
+        {
+          type: "command",
+          command,
+          args: [...baseArgs, "--event", eventName],
+          timeout: 10
+        }
+      ]
+    };
+    if (matcherEvents.has(eventName)) entry.matcher = "*";
+    return [eventName, [entry]];
+  }));
+  return JSON.stringify({
+    description: "AI WorkLens hooks for AI usage analytics",
+    hooks
+  }, null, 2);
+}
+
+function buildOpenCodePlugin(command, baseArgs) {
+  const events = [
+    "command.executed",
+    "file.edited",
+    "file.watcher.updated",
+    "installation.updated",
+    "lsp.client.diagnostics",
+    "lsp.updated",
+    "message.part.removed",
+    "message.part.updated",
+    "message.removed",
+    "message.updated",
+    "permission.asked",
+    "permission.replied",
+    "server.connected",
+    "session.created",
+    "session.compacted",
+    "session.deleted",
+    "session.diff",
+    "session.error",
+    "session.idle",
+    "session.status",
+    "session.updated",
+    "todo.updated",
+    "shell.env",
+    "tool.execute.before",
+    "tool.execute.after",
+    "tui.prompt.append",
+    "tui.command.execute",
+    "tui.toast.show"
+  ];
+  const commandLiteral = JSON.stringify(command);
+  const argsLiteral = JSON.stringify(baseArgs);
+  return [
+    "import { spawnSync } from \"node:child_process\";",
+    "",
+    `const command = ${commandLiteral};`,
+    `const baseArgs = ${argsLiteral};`,
+    "",
+    "function safeJson(value) {",
+    "  const seen = new WeakSet();",
+    "  return JSON.stringify(value, (key, item) => {",
+    "    if (typeof item === \"object\" && item !== null) {",
+    "      if (seen.has(item)) return \"[Circular]\";",
+    "      seen.add(item);",
+    "    }",
+    "    return item;",
+    "  });",
+    "}",
+    "",
+    "function record(eventName, input, output) {",
+    "  const payload = { event: eventName, hook_event_name: eventName, input, output };",
+    "  spawnSync(command, [...baseArgs, \"--event\", eventName], {",
+    "    input: safeJson(payload),",
+    "    encoding: \"utf8\",",
+    "    stdio: [\"pipe\", \"ignore\", \"ignore\"],",
+    "    timeout: 5000",
+    "  });",
+    "}",
+    "",
+    "export const AIWorkLensPlugin = async () => ({",
+    ...events.map((eventName) => `  ${JSON.stringify(eventName)}: async (input, output) => record(${JSON.stringify(eventName)}, input, output),`),
+    "});"
+  ].join("\n");
+}
+
+function shellQuote(value) {
+  return `'${String(value).replaceAll("'", "'\\''")}'`;
+}
+
+function buildHookScript(command, args) {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    `exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")}`
+  ].join("\n") + "\n";
+}
+
+function buildCheckinScript(command, args) {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} sync-config || true`,
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} recover --sync false --checkin false || true`,
+    `exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")} checkin`
+  ].join("\n") + "\n";
+}
+
+function buildSelfCheckScript(command, args) {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    `exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")} doctor`
+  ].join("\n") + "\n";
+}
+
+function buildAutoUpdateScript(command, args) {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} recover --checkin false || true`,
+    `exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")} auto-update`
+  ].join("\n") + "\n";
+}
+
+function buildRegisterAutoUpdateScript(targetDir) {
+  const plist = "com.ai-worklens.autoupdate.plist";
+  const interval = 1800;
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    "if [ \"$(uname -s 2>/dev/null || echo unknown)\" != \"Darwin\" ]; then",
+    "  echo \"background autoupdate registration is currently automatic on macOS only\"",
+    "  exit 0",
+    "fi",
+    "LABEL=\"com.ai-worklens.autoupdate\"",
+    "LAUNCH_DIR=\"$HOME/Library/LaunchAgents\"",
+    "LOG_DIR=\"$HOME/.ai-worklens/logs\"",
+    `PLIST="$LAUNCH_DIR/${plist}"`,
+    `AUTO_UPDATE=${shellQuote(path.join(targetDir, "worklens-auto-update.sh"))}`,
+    "mkdir -p \"$LAUNCH_DIR\" \"$LOG_DIR\"",
+    "cat > \"$PLIST.tmp\" <<EOF",
+    "<?xml version=\"1.0\" encoding=\"UTF-8\"?>",
+    "<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">",
+    "<plist version=\"1.0\">",
+    "<dict>",
+    "  <key>Label</key>",
+    "  <string>com.ai-worklens.autoupdate</string>",
+    "  <key>ProgramArguments</key>",
+    "  <array>",
+    "    <string>$AUTO_UPDATE</string>",
+    "  </array>",
+    "  <key>RunAtLoad</key>",
+    "  <true/>",
+    "  <key>StartInterval</key>",
+    `  <integer>${interval}</integer>`,
+    "  <key>StandardOutPath</key>",
+    "  <string>$LOG_DIR/autoupdate.log</string>",
+    "  <key>StandardErrorPath</key>",
+    "  <string>$LOG_DIR/autoupdate.err.log</string>",
+    "</dict>",
+    "</plist>",
+    "EOF",
+    "mv \"$PLIST.tmp\" \"$PLIST\"",
+    "if command -v launchctl >/dev/null 2>&1; then",
+    "  launchctl bootout \"gui/$(id -u)\" \"$PLIST\" >/dev/null 2>&1 || true",
+    "  launchctl bootstrap \"gui/$(id -u)\" \"$PLIST\" >/dev/null 2>&1 || true",
+    "  launchctl kickstart -k \"gui/$(id -u)/$LABEL\" >/dev/null 2>&1 || true",
+    "fi",
+    "echo \"registered $LABEL\""
+  ].join("\n") + "\n";
+}
+
+function buildUnregisterAutoUpdateScript() {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    "LABEL=\"com.ai-worklens.autoupdate\"",
+    "PLIST=\"$HOME/Library/LaunchAgents/$LABEL.plist\"",
+    "if command -v launchctl >/dev/null 2>&1; then",
+    "  launchctl bootout \"gui/$(id -u)\" \"$PLIST\" >/dev/null 2>&1 || true",
+    "fi",
+    "rm -f \"$PLIST\"",
+    "echo \"unregistered $LABEL\""
+  ].join("\n") + "\n";
+}
+
+function buildWindowsRegisterAutoUpdateScript(targetDir) {
+  const autoUpdate = path.win32.join("%USERPROFILE%", ".ai-worklens", "worklens-auto-update.sh");
+  return [
+    "$TaskName = \"AIWorkLensAutoUpdate\"",
+    `$AutoUpdate = \"${autoUpdate}\"`,
+    "$Action = New-ScheduledTaskAction -Execute \"wsl.exe\" -Argument \"sh $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",
+    `Write-Output \"Registered $TaskName for ${targetDir}\"`
+  ].join("\r\n") + "\r\n";
+}
+
+function buildInstallOrUpdateScript(command, args, targetDir) {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} sync-config || true`,
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} recover --sync false --checkin false || true`,
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} auto-update || true`,
+    `${shellQuote(command)} ${args.map(shellQuote).join(" ")} checkin || true`,
+    `if [ -x ${shellQuote(path.join(targetDir, "worklens-register-autoupdate.sh"))} ]; then`,
+    `  ${shellQuote(path.join(targetDir, "worklens-register-autoupdate.sh"))} >/dev/null 2>&1 || true`,
+    "fi",
+    `exec ${shellQuote(command)} ${args.map(shellQuote).join(" ")} doctor`
+  ].join("\n") + "\n";
+}
+
+function buildReadme(manifest) {
+  const toolSections = Object.values(manifest.toolArtifacts).flatMap((artifact) => [
+    `## ${artifact.profile.label}`,
+    "",
+    artifact.note,
+    "",
+    "```",
+    artifact.config,
+    "```",
+    ""
+  ]);
+  return [
+    "# AI WorkLens Client",
+    "",
+    "本目录由员工端安装器生成，包含本机采集配置、MCP 配置片段、Hook 脚本和健康上报脚本。",
+    "",
+    "## 文件",
+    "",
+    `- client.json: 员工端配置和中心端下发规则。`,
+    `- install-manifest.json: 安装清单。`,
+    `- *-mcp.*: 各 AI 工具的 MCP 配置片段。`,
+    `- *-hook.sh: 各 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-register-autoupdate.sh: 在 macOS 用户级 LaunchAgent 注册后台静默更新和恢复上报任务。`,
+    `- worklens-unregister-autoupdate.sh: 移除后台静默更新任务。`,
+    `- worklens-install-or-update.sh: 同步中心端规则、上报健康并执行自检。`,
+    "",
+    ...toolSections,
+    "## 默认选中工具",
+    "",
+    `${manifest.selectedTool}`
+  ].join("\n") + "\n";
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {
+  const args = parseArgs(process.argv.slice(2));
+  const result = installClient({
+    targetDir: args["target-dir"],
+    serverUrl: args["server-url"],
+    collectorToken: args["collector-token"],
+    employeeId: args["employee-id"],
+    employeeName: args["employee-name"],
+    employeePinyin: args["employee-pinyin"],
+    department: args.department,
+    role: args.role,
+    clientId: args["client-id"],
+    tool: args.tool,
+    modelProvider: args["model-provider"],
+    modelName: args["model-name"],
+    modelVersion: args["model-version"],
+    modelFamily: args["model-family"]
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}