ai-worklens-agent 0.1.0

package/src/mcp-server.mjs

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+import readline from "node:readline";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadClientConfig } from "./config.mjs";
+import { buildEvent } from "./event-builder.mjs";
+import { ClientAgent } from "./uploader.mjs";
+
+const tools = [
+  {
+    name: "record_ai_event",
+    description: "静默记录一条通用 AI 使用事件，上传到中心端；上传失败会进入本地队列。",
+    inputSchema: {
+      type: "object",
+      required: ["summary"],
+      properties: {
+        eventType: { type: "string" },
+        summary: { type: "string" },
+        title: { type: "string" },
+        durationSeconds: { type: "number" },
+        files: { type: "string" },
+        commands: { type: "string" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_skill_use",
+    description: "记录 Codex Skill 使用事件。",
+    inputSchema: {
+      type: "object",
+      required: ["skillName"],
+      properties: {
+        skillName: { type: "string" },
+        summary: { type: "string" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_assistant_turn",
+    description: "记录 AI 助手回复摘要，用于更准确计算对话轮次和会话完整度。",
+    inputSchema: {
+      type: "object",
+      required: ["summary"],
+      properties: {
+        summary: { type: "string" },
+        title: { type: "string" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" },
+        turnIndex: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "record_mode_change",
+    description: "记录 Plan/Edit/Agent 等模式切换，避免通过文本猜测规划能力。",
+    inputSchema: {
+      type: "object",
+      required: ["mode"],
+      properties: {
+        mode: { type: "string" },
+        previousMode: { type: "string" },
+        summary: { type: "string" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_tool_result",
+    description: "记录工具调用结果、退出码、成功失败和命令，补齐工具调用闭环。",
+    inputSchema: {
+      type: "object",
+      required: ["toolName"],
+      properties: {
+        toolName: { type: "string" },
+        status: { type: "string" },
+        exitCode: { type: "number" },
+        summary: { type: "string" },
+        command: { type: "string" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_retry",
+    description: "记录失败后的重试、返修或再次执行，辅助分析返工风险。",
+    inputSchema: {
+      type: "object",
+      required: ["summary"],
+      properties: {
+        summary: { type: "string" },
+        failureKind: { type: "string" },
+        retryAttempt: { type: "number" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_plugin_use",
+    description: "记录插件使用事件，例如 Spreadsheets、Figma、Playwright 等。",
+    inputSchema: {
+      type: "object",
+      required: ["pluginName"],
+      properties: {
+        pluginName: { type: "string" },
+        summary: { type: "string" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_mcp_tool_call",
+    description: "记录 MCP server 或 MCP tool 调用事件。",
+    inputSchema: {
+      type: "object",
+      required: ["mcpServer"],
+      properties: {
+        mcpServer: { type: "string" },
+        toolName: { type: "string" },
+        summary: { type: "string" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "record_verification",
+    description: "记录测试、构建、浏览器验证或人工检查结果。",
+    inputSchema: {
+      type: "object",
+      required: ["summary"],
+      properties: {
+        summary: { type: "string" },
+        command: { type: "string" },
+        durationSeconds: { type: "number" },
+        sessionId: { type: "string" }
+      }
+    }
+  },
+  {
+    name: "client_checkin",
+    description: "上报员工端 MCP、Hook、队列和版本健康状态。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        mcpReady: { type: "boolean" },
+        hookReady: { type: "boolean" },
+        issues: { type: "array", items: { type: "string" } }
+      }
+    }
+  },
+  {
+    name: "flush_queue",
+    description: "立即上传本地离线队列中已到期的事件。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        force: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "recover_queue",
+    description: "中心端恢复后同步规则、按批补传本地离线队列并上报健康状态。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        force: { type: "boolean" },
+        maxBatches: { type: "number" },
+        sync: { type: "boolean" },
+        checkin: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "sync_remote_config",
+    description: "从中心端拉取最新采集规则，并写入本地 client.json。",
+    inputSchema: {
+      type: "object",
+      properties: {
+        write: { type: "boolean" }
+      }
+    }
+  }
+];
+
+function textResult(value) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value, null, 2)
+      }
+    ]
+  };
+}
+
+function eventForTool(name, args, config) {
+  if (name === "record_assistant_turn") {
+    return buildEvent({
+      eventType: "assistant_response",
+      title: args.title || "AI 回复",
+      content: args.summary,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId,
+      turnIndex: args.turnIndex,
+      interactionType: "assistant_response"
+    }, config);
+  }
+  if (name === "record_mode_change") {
+    return buildEvent({
+      eventType: "mode_change",
+      title: `模式切换：${args.mode}`,
+      content: args.summary || `${args.previousMode || "-"} -> ${args.mode}`,
+      previousMode: args.previousMode,
+      nextMode: args.mode,
+      codexMode: args.mode,
+      localSessionId: args.sessionId,
+      interactionType: "mode_change"
+    }, config);
+  }
+  if (name === "record_tool_result") {
+    return buildEvent({
+      eventType: "tool_result",
+      title: args.toolName,
+      content: args.summary || `工具结果：${args.toolName}`,
+      commands: args.command,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId,
+      toolName: args.toolName,
+      toolStatus: args.status,
+      exitCode: args.exitCode,
+      interactionType: "tool_result"
+    }, config);
+  }
+  if (name === "record_retry") {
+    return buildEvent({
+      eventType: "retry",
+      title: "失败重试",
+      content: args.summary,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId,
+      failureKind: args.failureKind,
+      retryAttempt: args.retryAttempt,
+      interactionType: "retry"
+    }, config);
+  }
+  if (name === "record_skill_use") {
+    return buildEvent({
+      eventType: "skill_use",
+      title: args.skillName,
+      content: args.summary || `使用 Skill：${args.skillName}`,
+      skillName: args.skillName,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId
+    }, config);
+  }
+  if (name === "record_plugin_use") {
+    return buildEvent({
+      eventType: "plugin_use",
+      title: args.pluginName,
+      content: args.summary || `使用插件：${args.pluginName}`,
+      pluginName: args.pluginName,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId
+    }, config);
+  }
+  if (name === "record_mcp_tool_call") {
+    return buildEvent({
+      eventType: "mcp_tool_call",
+      title: args.toolName || args.mcpServer,
+      content: args.summary || `调用 MCP：${args.mcpServer}`,
+      mcpServer: args.mcpServer,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId,
+      metadata: { toolName: args.toolName }
+    }, config);
+  }
+  if (name === "record_verification") {
+    return buildEvent({
+      eventType: "verification",
+      title: "验证",
+      content: args.summary,
+      commands: args.command,
+      durationSeconds: args.durationSeconds,
+      localSessionId: args.sessionId
+    }, config);
+  }
+  return buildEvent({
+    eventType: args.eventType || "tool_call",
+    title: args.title || args.eventType || "AI 使用事件",
+    content: args.summary || args.content,
+    files: args.files,
+    commands: args.commands,
+    durationSeconds: args.durationSeconds,
+    localSessionId: args.sessionId
+  }, config);
+}
+
+export async function handleMcpRequest(request, config = loadClientConfig()) {
+  if (request.method === "initialize") {
+    return {
+      protocolVersion: "2024-11-05",
+      capabilities: { tools: {} },
+      serverInfo: { name: "ai-worklens", version: "0.1.0" }
+    };
+  }
+  if (request.method === "tools/list") {
+    return { tools };
+  }
+  if (request.method === "tools/call") {
+    const { name, arguments: args = {} } = request.params || {};
+    const agent = new ClientAgent(config);
+    if (name === "client_checkin") return textResult(await agent.checkin(args));
+    if (name === "flush_queue") return textResult(await agent.flush({ force: args.force === true }));
+    if (name === "recover_queue") {
+      return textResult(await agent.recover({
+        force: args.force === true,
+        maxBatches: args.maxBatches || 20,
+        sync: args.sync !== false,
+        checkin: args.checkin !== false
+      }));
+    }
+    if (name === "sync_remote_config") return textResult(await agent.syncConfig({ write: args.write !== false }));
+    if (!tools.some((tool) => tool.name === name)) {
+      throw new Error(`unknown tool: ${name}`);
+    }
+    const event = eventForTool(name, args, config);
+    return textResult({ eventId: event.eventId, eventType: event.eventType, result: await agent.record(event) });
+  }
+  return {};
+}
+
+function writeResponse(message) {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+async function main() {
+  const config = loadClientConfig();
+  const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (!line.trim()) continue;
+    const request = JSON.parse(line);
+    if (!request.id) continue;
+    try {
+      const result = await handleMcpRequest(request, config);
+      writeResponse({ jsonrpc: "2.0", id: request.id, result });
+    } catch (error) {
+      writeResponse({ jsonrpc: "2.0", id: request.id, error: { code: -32000, message: error.message } });
+    }
+  }
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {
+  main().catch((error) => {
+    process.stderr.write(`${error.stack || error.message}\n`);
+    process.exitCode = 1;
+  });
+}

package/src/publish-npm.mjs

@@ -0,0 +1,149 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(__dirname, "..");
+const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org";
+
+export function parseArgs(argv = []) {
+  const options = {
+    access: "public",
+    registry: PUBLIC_NPM_REGISTRY,
+    tag: "latest",
+    dryRun: false
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    const next = () => argv[++index];
+    if (arg === "--package-name") options.packageName = next();
+    else if (arg === "--version") options.version = next();
+    else if (arg === "--tag") options.tag = next();
+    else if (arg === "--registry") options.registry = next();
+    else if (arg === "--access") options.access = next();
+    else if (arg === "--token") options.token = next();
+    else if (arg === "--otp") options.otp = next();
+    else if (arg === "--dry-run") options.dryRun = true;
+    else if (arg === "--help" || arg === "-h") options.help = true;
+    else throw new Error(`unknown argument: ${arg}`);
+  }
+  options.packageName = options.packageName || process.env.WORKLENS_NPM_PACKAGE_NAME || "";
+  options.version = options.version || process.env.WORKLENS_NPM_VERSION || "";
+  options.token = options.token || process.env.NPM_TOKEN || "";
+  return options;
+}
+
+export function usage() {
+  return [
+    "Usage:",
+    "  npm run client:npm:publish -- --package-name <npm-package> --version <version> --tag latest --dry-run",
+    "  NPM_TOKEN=<token> npm run client:npm:publish -- --package-name <npm-package> --version <version> --tag latest",
+    "",
+    "Notes:",
+    "  - Public npm scoped packages require --access public.",
+    "  - For @scope/name, the npm account token must have permission for that scope.",
+    "  - Token can be passed through NPM_TOKEN or --token; it is written only to a temporary .npmrc."
+  ].join("\n");
+}
+
+function readPackageJson() {
+  return JSON.parse(fs.readFileSync(path.join(PACKAGE_ROOT, "package.json"), "utf8"));
+}
+
+function safePackageName(name) {
+  const value = String(name || "").trim();
+  if (!value) throw new Error("--package-name is required for public npm publish");
+  if (!/^(@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/.test(value)) {
+    throw new Error(`invalid npm package name: ${value}`);
+  }
+  return value;
+}
+
+function safeVersion(version, fallback) {
+  const value = String(version || fallback || "").trim();
+  if (!value) throw new Error("--version is required for public npm publish");
+  if (!/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/.test(value)) {
+    throw new Error(`invalid semver version: ${value}`);
+  }
+  return value;
+}
+
+function registryAuthHost(registry) {
+  const url = new URL(registry || PUBLIC_NPM_REGISTRY);
+  return `${url.host}${url.pathname.replace(/\/?$/, "/")}`;
+}
+
+export function preparePublishDirectory(options = {}) {
+  const pkg = readPackageJson();
+  const packageName = safePackageName(options.packageName || pkg.name);
+  const version = safeVersion(options.version, pkg.version);
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "worklens-npm-publish-"));
+  const stagedPackage = {
+    ...pkg,
+    name: packageName,
+    version,
+    private: false,
+    publishConfig: {
+      ...(pkg.publishConfig || {}),
+      access: options.access || "public",
+      registry: options.registry || PUBLIC_NPM_REGISTRY
+    }
+  };
+  fs.cpSync(path.join(PACKAGE_ROOT, "src"), path.join(tempDir, "src"), { recursive: true });
+  fs.copyFileSync(path.join(PACKAGE_ROOT, "README.md"), path.join(tempDir, "README.md"));
+  fs.writeFileSync(path.join(tempDir, "package.json"), `${JSON.stringify(stagedPackage, null, 2)}\n`);
+  if (options.token) {
+    fs.writeFileSync(path.join(tempDir, ".npmrc"), `//${registryAuthHost(options.registry)}:_authToken=${options.token}\n`);
+  }
+  return { tempDir, packageName, version };
+}
+
+export function buildNpmPublishArgs(stagedDir, options = {}) {
+  return [
+    "publish",
+    stagedDir,
+    "--registry",
+    options.registry || PUBLIC_NPM_REGISTRY,
+    "--access",
+    options.access || "public",
+    "--tag",
+    options.tag || "latest",
+    "--cache",
+    path.join(stagedDir, ".npm-cache"),
+    ...(options.dryRun ? ["--dry-run"] : []),
+    ...(options.token ? ["--userconfig", path.join(stagedDir, ".npmrc")] : []),
+    ...(options.otp ? ["--otp", options.otp] : [])
+  ];
+}
+
+export function publishToNpm(options = {}) {
+  if (!options.dryRun && !options.token) {
+    throw new Error("NPM_TOKEN is required for real public npm publish; use --dry-run to preview without token");
+  }
+  const prepared = preparePublishDirectory(options);
+  const args = buildNpmPublishArgs(prepared.tempDir, options);
+  const result = spawnSync("npm", args, { stdio: "inherit" });
+  if (result.status !== 0) {
+    throw new Error(`npm publish failed with exit code ${result.status}`);
+  }
+  return prepared;
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.help) {
+      console.log(usage());
+      process.exit(0);
+    }
+    const result = publishToNpm(options);
+    console.log(`Published package payload: ${result.packageName}@${result.version}`);
+  } catch (error) {
+    console.error(error.message);
+    console.error("");
+    console.error(usage());
+    process.exit(1);
+  }
+}

package/src/queue.mjs

@@ -0,0 +1,128 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+
+const DEFAULT_RETRY = {
+  maxDelayMs: 30 * 60 * 1000,
+  baseDelayMs: 30 * 1000
+};
+
+async function readJsonArray(filePath) {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+function normalizeItem(item) {
+  const event = item?.event || item;
+  const queuedAt = item?.queuedAt || new Date().toISOString();
+  return {
+    id: item?.id || event?.eventId || crypto.randomUUID(),
+    queuedAt,
+    attempts: Number(item?.attempts || 0),
+    lastAttemptAt: item?.lastAttemptAt || "",
+    nextAttemptAt: item?.nextAttemptAt || queuedAt,
+    lastError: item?.lastError || "",
+    event
+  };
+}
+
+function dueAt(item) {
+  const value = Date.parse(item.nextAttemptAt || item.queuedAt || 0);
+  return Number.isFinite(value) ? value : 0;
+}
+
+function retryDelay(attempts, options = {}) {
+  const baseDelayMs = Number(options.baseDelayMs || DEFAULT_RETRY.baseDelayMs);
+  const maxDelayMs = Number(options.maxDelayMs || DEFAULT_RETRY.maxDelayMs);
+  const exponent = Math.min(10, Math.max(0, Number(attempts || 1) - 1));
+  return Math.min(maxDelayMs, baseDelayMs * (2 ** exponent));
+}
+
+export class EventQueue {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+
+  async list() {
+    const items = await readJsonArray(this.filePath);
+    return items.map(normalizeItem);
+  }
+
+  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 });
+  }
+
+  async enqueue(event) {
+    const items = await this.list();
+    items.push(normalizeItem({ queuedAt: new Date().toISOString(), event }));
+    await this.save(items);
+    return items.length;
+  }
+
+  async replace(items) {
+    await this.save(items);
+  }
+
+  async due({ now = new Date(), limit = Infinity, force = false } = {}) {
+    const timestamp = now instanceof Date ? now.getTime() : Date.parse(now);
+    const items = await this.list();
+    return items
+      .filter((item) => force || dueAt(item) <= timestamp)
+      .slice(0, limit);
+  }
+
+  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()
+      };
+    });
+    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;
+  }
+
+  async stats({ now = new Date() } = {}) {
+    const timestamp = now instanceof Date ? now.getTime() : Date.parse(now);
+    const items = await this.list();
+    const dueItems = items.filter((item) => dueAt(item) <= timestamp);
+    const nextAttemptAt = items
+      .filter((item) => dueAt(item) > timestamp)
+      .map((item) => item.nextAttemptAt)
+      .sort()[0] || "";
+    return {
+      total: items.length,
+      due: dueItems.length,
+      waiting: items.length - dueItems.length,
+      nextAttemptAt,
+      maxAttempts: items.reduce((max, item) => Math.max(max, Number(item.attempts || 0)), 0)
+    };
+  }
+
+  async clear() {
+    await this.save([]);
+  }
+}