ai-worklens-agent 0.1.0

package/src/team-rollout.mjs

@@ -0,0 +1,197 @@
+#!/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 { 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;
+}
+
+function normalizeEmployee(employee) {
+  const employeeId = String(employee.employeeId || employee.id || "").trim();
+  return {
+    employeeId,
+    name: String(employee.name || employee.employeeName || employeeId).trim(),
+    pinyinName: String(employee.pinyinName || employee.employeePinyin || employee.registrationName || "").trim(),
+    department: String(employee.department || "").trim(),
+    role: String(employee.role || "").trim()
+  };
+}
+
+function readEmployees(filePath) {
+  if (!filePath) return [];
+  const raw = fs.readFileSync(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  return (Array.isArray(parsed) ? parsed : parsed.items || []).map(normalizeEmployee).filter((item) => item.employeeId);
+}
+
+export function buildTeamRolloutManifest(options = {}) {
+  const tool = normalizeToolId(options.tool || "codex");
+  const targetDir = options.targetDir || path.join(process.cwd(), "data/team-rollout", tool);
+  const employees = (options.employees || readEmployees(options.employeesFile)).map(normalizeEmployee).filter((item) => item.employeeId);
+  return {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    serverUrl: options.serverUrl || "http://127.0.0.1:8797",
+    collectorToken: options.collectorToken || "",
+    tool,
+    clientTargetDir: options.clientTargetDir || "~/.ai-worklens",
+    packageDir: targetDir,
+    employeeCount: employees.length,
+    employees,
+    files: {
+      manifest: path.join(targetDir, "rollout-manifest.json"),
+      employees: path.join(targetDir, "employees.json"),
+      runner: path.join(targetDir, "team-install-runner.mjs"),
+      install: path.join(targetDir, "team-install.sh"),
+      update: path.join(targetDir, "team-update.sh"),
+      check: path.join(targetDir, "team-check.sh"),
+      readme: path.join(targetDir, "README.md")
+    }
+  };
+}
+
+export function writeTeamRolloutPackage(options = {}) {
+  const manifest = buildTeamRolloutManifest(options);
+  fs.mkdirSync(manifest.packageDir, { recursive: true, mode: 0o700 });
+  fs.writeFileSync(manifest.files.manifest, `${JSON.stringify({ ...manifest, employees: undefined }, null, 2)}\n`, { mode: 0o600 });
+  fs.writeFileSync(manifest.files.employees, `${JSON.stringify(manifest.employees, null, 2)}\n`, { mode: 0o600 });
+  fs.writeFileSync(manifest.files.runner, buildRunnerScript(), { mode: 0o700 });
+  fs.writeFileSync(manifest.files.install, buildTeamShell("install"), { mode: 0o700 });
+  fs.writeFileSync(manifest.files.update, buildTeamShell("update"), { mode: 0o700 });
+  fs.writeFileSync(manifest.files.check, buildCheckShell(), { mode: 0o700 });
+  fs.writeFileSync(manifest.files.readme, buildReadme(manifest), { mode: 0o600 });
+  for (const file of [manifest.files.runner, manifest.files.install, manifest.files.update, manifest.files.check]) {
+    fs.chmodSync(file, 0o700);
+  }
+  return { ok: true, manifest };
+}
+
+function buildRunnerScript() {
+  return [
+    "#!/usr/bin/env node",
+    "import fs from \"node:fs\";",
+    "import os from \"node:os\";",
+    "import path from \"node:path\";",
+    `import { installClient } from ${JSON.stringify(path.join(projectRoot, "packages/client-agent/src/install.mjs"))};`,
+    "",
+    "const packageDir = path.dirname(new URL(import.meta.url).pathname);",
+    "const manifest = JSON.parse(fs.readFileSync(path.join(packageDir, \"rollout-manifest.json\"), \"utf8\"));",
+    "const employees = JSON.parse(fs.readFileSync(path.join(packageDir, \"employees.json\"), \"utf8\"));",
+    "const employeeId = process.argv[2] || process.env.WORKLENS_EMPLOYEE_ID || \"\";",
+    "const mode = process.argv[3] || \"install\";",
+    "const employee = employees.find((item) => item.employeeId === employeeId || item.id === employeeId || item.pinyinName === employeeId);",
+    "if (!employee) {",
+    "  console.error(JSON.stringify({ ok: false, error: \"employee not found\", employeeId, hint: \"传入员工 ID，例如 ./team-install.sh E001\" }));",
+    "  process.exit(2);",
+    "}",
+    "const targetDir = path.join(os.homedir(), \".ai-worklens\");",
+    "const result = installClient({",
+    "  targetDir,",
+    "  serverUrl: manifest.serverUrl,",
+    "  collectorToken: manifest.collectorToken || \"\",",
+    "  employeeId: employee.employeeId,",
+    "  employeeName: employee.name,",
+    "  employeePinyin: employee.pinyinName || \"\",",
+    "  department: employee.department || \"\",",
+    "  role: employee.role || \"\",",
+    "  clientId: `${employee.pinyinName || employee.employeeId}-${employee.employeeId}-${manifest.tool}-client`,",
+    "  tool: manifest.tool",
+    "});",
+    "console.log(JSON.stringify({ ok: true, mode, employeeId: employee.employeeId, targetDir, generatedFiles: result.generatedFiles }, null, 2));"
+  ].join("\n") + "\n";
+}
+
+function buildTeamShell(mode) {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    "EMPLOYEE_ID=\"${1:-${WORKLENS_EMPLOYEE_ID:-}}\"",
+    "if [ -z \"$EMPLOYEE_ID\" ]; then",
+    "  echo \"请传入员工 ID，例如 ./team-install.sh E001\" >&2",
+    "  exit 2",
+    "fi",
+    "SCRIPT_DIR=$(CDPATH= cd -- \"$(dirname -- \"$0\")\" && pwd)",
+    `node "$SCRIPT_DIR/team-install-runner.mjs" "$EMPLOYEE_ID" ${mode}`,
+    "exec \"$HOME/.ai-worklens/worklens-install-or-update.sh\""
+  ].join("\n") + "\n";
+}
+
+function buildCheckShell() {
+  return [
+    "#!/usr/bin/env sh",
+    "set -eu",
+    "if [ ! -x \"$HOME/.ai-worklens/worklens-self-check.sh\" ]; then",
+    "  echo \"尚未安装员工端，请先执行 ./team-install.sh <员工ID>\" >&2",
+    "  exit 2",
+    "fi",
+    "exec \"$HOME/.ai-worklens/worklens-self-check.sh\""
+  ].join("\n") + "\n";
+}
+
+function buildReadme(manifest) {
+  return [
+    "# AI WorkLens 团队推广包",
+    "",
+    "本目录用于把员工端 MCP、hook、客户端配置和自检脚本推广到团队成员机器。",
+    "",
+    "## 员工执行",
+    "",
+    "```bash",
+    "./team-install.sh E001",
+    "./team-check.sh",
+    "```",
+    "",
+    "后续更新同一套配置：",
+    "",
+    "```bash",
+    "./team-update.sh E001",
+    "```",
+    "",
+    "## 管理员信息",
+    "",
+    `- 中心端地址：${manifest.serverUrl}`,
+    `- 默认工具：${manifest.tool}`,
+    `- 员工数量：${manifest.employeeCount}`,
+    `- 令牌策略：${manifest.collectorToken ? "已写入员工端配置" : "未配置采集令牌"}`,
+    "",
+    "## 生成文件",
+    "",
+    "- rollout-manifest.json：推广配置。",
+    "- employees.json：员工清单。",
+    "- team-install.sh：员工首次安装。",
+    "- team-update.sh：员工更新配置。",
+    "- team-check.sh：员工自检。",
+    "- team-install-runner.mjs：安装执行器。"
+  ].join("\n") + "\n";
+}
+
+if (fileURLToPath(import.meta.url) === path.resolve(process.argv[1] || "")) {
+  const args = parseArgs(process.argv.slice(2));
+  const result = writeTeamRolloutPackage({
+    targetDir: args["target-dir"],
+    serverUrl: args["server-url"],
+    collectorToken: args["collector-token"],
+    tool: args.tool,
+    employeesFile: args["employees-file"],
+    clientTargetDir: args["client-target-dir"]
+  });
+  process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+}

package/src/uploader.mjs

@@ -0,0 +1,428 @@
+import path from "node:path";
+import { EventQueue } from "./queue.mjs";
+import { writeClientConfig } from "./config.mjs";
+import { normalizeCollectionSettings } from "../../collector-protocol/src/collection-settings.mjs";
+import { normalizeClientUpdatePolicy, updateNeeded } from "../../collector-protocol/src/client-update-policy.mjs";
+import { installClient } from "./install.mjs";
+
+async function requestJson(url, config, options = {}) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), config.upload.timeoutMs);
+  try {
+    const headers = { "Content-Type": "application/json" };
+    if (config.collectorToken) headers.Authorization = `Bearer ${config.collectorToken}`;
+    const response = await fetch(new URL(url, config.serverUrl), {
+      method: options.method || "GET",
+      headers,
+      body: options.body === undefined ? undefined : JSON.stringify(options.body),
+      signal: controller.signal
+    });
+    const body = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+    return body;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function postJson(url, payload, config) {
+  return requestJson(url, config, { method: "POST", body: payload });
+}
+
+function clientConfigFileValue(config, remote) {
+  const collection = normalizeCollectionSettings(remote.collection || config.collection || {});
+  const update = normalizeClientUpdatePolicy(remote.update || config.update || {});
+  return {
+    serverUrl: config.serverUrl,
+    collectorToken: config.collectorToken,
+    clientId: config.clientId,
+    clientVersion: config.clientVersion,
+    tool: remote.tool || config.tool,
+    model: config.model,
+    employee: {
+      id: remote.employee?.employeeId || config.employee.id,
+      name: remote.employee?.name || config.employee.name,
+      pinyinName: remote.employee?.pinyinName || config.employee.pinyinName || "",
+      department: remote.employee?.department || config.employee.department || "",
+      role: remote.employee?.role || config.employee.role || ""
+    },
+    upload: {
+      timeoutMs: config.upload.timeoutMs,
+      batchSize: Number(remote.upload?.batchSize || collection.uploadBatchSize || config.upload.batchSize)
+    },
+    collection,
+    update: {
+      ...update,
+      appliedRevision: config.update?.appliedRevision || "",
+      lastUpdatedAt: config.update?.lastUpdatedAt || ""
+    },
+    lastSyncedAt: remote.generatedAt || new Date().toISOString()
+  };
+}
+
+export class ClientAgent {
+  constructor(config) {
+    this.config = config;
+    this.queue = new EventQueue(config.queueFile);
+  }
+
+  async record(event) {
+    const length = await this.queue.enqueue(event);
+    if (this.config.collection?.enabled === false) {
+      return {
+        ok: true,
+        queued: length,
+        flush: { ok: false, skipped: "collection_disabled", remaining: length }
+      };
+    }
+    const flush = await this.flush().catch((error) => ({ ok: false, error: error.message }));
+    return { ok: true, queued: length, flush };
+  }
+
+  async flush(options = {}) {
+    const items = await this.queue.list();
+    if (!items.length) return { ok: true, sent: 0, remaining: 0, postponed: 0 };
+    if (this.config.collection?.enabled === false) {
+      return { ok: false, sent: 0, remaining: items.length, postponed: 0, skipped: "collection_disabled" };
+    }
+    const batch = await this.queue.due({ limit: this.config.upload.batchSize, force: options.force === true });
+    if (!batch.length) {
+      const stats = await this.queue.stats();
+      return {
+        ok: true,
+        sent: 0,
+        remaining: stats.total,
+        postponed: stats.waiting,
+        nextAttemptAt: stats.nextAttemptAt
+      };
+    }
+    try {
+      const response = await postJson("/api/ingest/events", { events: batch.map((item) => item.event) }, this.config);
+      const acceptedItems = acceptedBatchItems(response, batch);
+      const accepted = acceptedItems.length;
+      const acceptedIds = new Set(acceptedItems.map((item) => item.id));
+      const failedItems = batch.filter((item) => !acceptedIds.has(item.id));
+      await this.queue.remove(acceptedItems.map((item) => item.id));
+      if (failedItems.length) {
+        await this.queue.markFailed(failedItems.map((item) => item.id), "partial_upload_not_accepted");
+      }
+      const stats = await this.queue.stats();
+      return {
+        ok: failedItems.length === 0,
+        sent: accepted,
+        remaining: stats.total,
+        postponed: stats.waiting,
+        nextAttemptAt: stats.nextAttemptAt,
+        partial: failedItems.length > 0,
+        response
+      };
+    } catch (error) {
+      await this.queue.markFailed(batch.map((item) => item.id), error);
+      const stats = await this.queue.stats();
+      return {
+        ok: false,
+        sent: 0,
+        remaining: stats.total,
+        postponed: stats.waiting,
+        nextAttemptAt: stats.nextAttemptAt,
+        error: error.message
+      };
+    }
+  }
+
+  async flushPending(options = {}) {
+    const maxBatches = Number(options.maxBatches || 20);
+    const results = [];
+    let totalSent = 0;
+    for (let index = 0; index < maxBatches; index += 1) {
+      const result = await this.flush({ force: options.force === true });
+      results.push(result);
+      totalSent += Number(result.sent || 0);
+      if (!result.ok || result.remaining === 0 || result.sent === 0) break;
+    }
+    const stats = await this.queue.stats();
+    const last = results.at(-1) || { ok: true };
+    return {
+      ok: results.every((item) => item.ok),
+      sent: totalSent,
+      remaining: stats.total,
+      postponed: stats.waiting,
+      nextAttemptAt: stats.nextAttemptAt,
+      batches: results.length,
+      stoppedBy: stats.total === 0 ? "empty" : !last.ok ? "upload_failed" : last.sent === 0 ? "no_due_items" : "batch_limit",
+      results
+    };
+  }
+
+  async recover(options = {}) {
+    const startedAt = new Date().toISOString();
+    const synced = options.sync === false
+      ? { ok: true, skipped: "sync_disabled" }
+      : await this.syncConfig({ write: true }).catch((error) => ({ ok: false, error: error.message }));
+    const flush = await this.flushPending({ maxBatches: options.maxBatches || 20, force: options.force === true }).catch((error) => ({ ok: false, sent: 0, error: error.message }));
+    const issues = [];
+    if (synced.ok === false) issues.push(`sync_failed:${synced.error}`);
+    if (flush.ok === false) issues.push(`flush_failed:${flush.error || flush.stoppedBy || "unknown"}`);
+    const checkin = options.checkin === false
+      ? { ok: true, skipped: "checkin_disabled" }
+      : await this.checkin({ issues }).catch((error) => ({ ok: false, error: error.message }));
+    const stats = await this.queue.stats();
+    return {
+      ok: synced.ok !== false && flush.ok !== false && checkin.ok !== false,
+      startedAt,
+      synced,
+      flush,
+      checkin,
+      queue: stats
+    };
+  }
+
+  async checkin(overrides = {}) {
+    const queueItems = await this.queue.list();
+    return postJson("/api/clients/checkin", {
+      employeeId: this.config.employee.id,
+      employeeName: this.config.employee.name,
+      pinyinName: this.config.employee.pinyinName || "",
+      department: this.config.employee.department,
+      role: this.config.employee.role,
+      clientId: this.config.clientId,
+      tool: this.config.tool,
+      version: this.config.clientVersion,
+      artifactRevision: this.config.update?.appliedRevision || "",
+      mcpReady: overrides.mcpReady ?? true,
+      hookReady: overrides.hookReady ?? true,
+      uploadQueueSize: queueItems.length,
+      issues: overrides.issues || []
+    }, this.config);
+  }
+
+  async syncConfig(options = {}) {
+    const params = new URLSearchParams({
+      employeeId: this.config.employee.id,
+      clientId: this.config.clientId,
+      tool: this.config.tool
+    });
+    const remote = await requestJson(`/api/client/config?${params.toString()}`, this.config);
+    const fileValue = clientConfigFileValue(this.config, remote);
+    if (options.write !== false) {
+      writeClientConfig(this.config.configFile, fileValue);
+    }
+    this.config.employee = fileValue.employee;
+    this.config.tool = fileValue.tool;
+    this.config.upload = fileValue.upload;
+    this.config.collection = fileValue.collection;
+    this.config.update = fileValue.update;
+    return {
+      ok: true,
+      configFile: this.config.configFile,
+      collection: fileValue.collection,
+      update: fileValue.update,
+      upload: fileValue.upload,
+      employee: fileValue.employee,
+      wroteConfig: options.write !== false
+    };
+  }
+
+  async updateManifest() {
+    const params = new URLSearchParams({
+      employeeId: this.config.employee.id,
+      clientId: this.config.clientId,
+      tool: this.config.tool,
+      version: this.config.clientVersion,
+      artifactRevision: this.config.update?.appliedRevision || ""
+    });
+    return requestJson(`/api/client/update-manifest?${params.toString()}`, this.config);
+  }
+
+  async autoUpdate(options = {}) {
+    const startedAt = new Date().toISOString();
+    const beforeVersion = this.config.clientVersion;
+    const synced = await this.syncConfig({ write: true }).catch((error) => ({ ok: false, error: error.message }));
+    const manifest = await this.updateManifest().catch((error) => ({ ok: false, error: error.message }));
+    if (manifest.ok === false) {
+      const recovery = await this.recover({ sync: false, maxBatches: 20 }).catch((error) => ({ ok: false, error: error.message }));
+      return {
+        ok: false,
+        skipped: "center_unavailable",
+        startedAt,
+        beforeVersion,
+        error: manifest.error,
+        synced,
+        recovery
+      };
+    }
+    const policy = normalizeClientUpdatePolicy(manifest.update || {});
+    const shouldUpdate = options.force === true || updateNeeded(this.config.clientVersion, this.config.update, policy);
+    if (!policy.enabled || !policy.autoUpdate) {
+      const recovery = await this.flushPending({ maxBatches: 20 }).catch((error) => ({ ok: false, error: error.message }));
+      const issues = recovery.ok === false ? [`flush_failed:${recovery.error || recovery.stoppedBy || "unknown"}`] : [];
+      const checkin = await this.checkin({ issues }).catch((error) => ({ ok: false, error: error.message }));
+      return {
+        ok: true,
+        skipped: "auto_update_disabled",
+        startedAt,
+        beforeVersion,
+        policy,
+        synced,
+        recovery,
+        checkin
+      };
+    }
+    if (!shouldUpdate) {
+      const recovery = await this.flushPending({ maxBatches: 20 }).catch((error) => ({ ok: false, error: error.message }));
+      const issues = recovery.ok === false ? [`flush_failed:${recovery.error || recovery.stoppedBy || "unknown"}`] : [];
+      const checkin = await this.checkin({ issues }).catch((error) => ({ ok: false, error: error.message }));
+      return {
+        ok: true,
+        updated: false,
+        startedAt,
+        beforeVersion,
+        afterVersion: this.config.clientVersion,
+        policy,
+        synced,
+        recovery,
+        checkin
+      };
+    }
+
+    try {
+      const updatePolicy = {
+        ...policy,
+        appliedRevision: policy.artifactRevision,
+        lastUpdatedAt: new Date().toISOString()
+      };
+      const install = installClient({
+        targetDir: path.dirname(this.config.configFile),
+        serverUrl: this.config.serverUrl,
+        collectorToken: this.config.collectorToken,
+        employeeId: this.config.employee.id,
+        employeeName: this.config.employee.name,
+        employeePinyin: this.config.employee.pinyinName || "",
+        department: this.config.employee.department,
+        role: this.config.employee.role,
+        clientId: this.config.clientId,
+        clientVersion: policy.clientVersion,
+        tool: this.config.tool,
+        modelProvider: this.config.model?.provider || "",
+        modelName: this.config.model?.name || "",
+        modelVersion: this.config.model?.version || "",
+        modelFamily: this.config.model?.family || "",
+        upload: this.config.upload,
+        collection: this.config.collection,
+        updatePolicy
+      });
+      this.config.clientVersion = policy.clientVersion;
+      this.config.update = updatePolicy;
+      const recovery = await this.flushPending({ maxBatches: 20 }).catch((error) => ({ ok: false, error: error.message }));
+      const issues = recovery.ok === false ? [`flush_failed:${recovery.error || recovery.stoppedBy || "unknown"}`] : [];
+      const checkin = await this.checkin({ issues }).catch((error) => ({ ok: false, error: error.message }));
+      return {
+        ok: true,
+        updated: true,
+        startedAt,
+        beforeVersion,
+        afterVersion: this.config.clientVersion,
+        appliedRevision: updatePolicy.appliedRevision,
+        generatedFiles: install.generatedFiles,
+        policy,
+        synced,
+        recovery,
+        checkin
+      };
+    } catch (error) {
+      const issue = `update_failed:${error.message}`;
+      const checkin = await this.checkin({ issues: [issue] }).catch((checkinError) => ({ ok: false, error: checkinError.message }));
+      return {
+        ok: false,
+        updated: false,
+        startedAt,
+        beforeVersion,
+        policy,
+        error: error.message,
+        checkin
+      };
+    }
+  }
+
+  async status() {
+    const queueItems = await this.queue.list();
+    const queueStats = await this.queue.stats();
+    return {
+      serverUrl: this.config.serverUrl,
+      employee: this.config.employee,
+      clientId: this.config.clientId,
+      configFile: this.config.configFile,
+      queueFile: this.config.queueFile,
+      queueSize: queueItems.length,
+      queue: queueStats,
+      collection: this.config.collection,
+      update: this.config.update
+    };
+  }
+
+  async health() {
+    return requestJson("/api/health", this.config);
+  }
+
+  async doctor() {
+    const status = await this.status();
+    const checks = [];
+    checks.push(check("employee_configured", Boolean(this.config.employee.id), "缺少员工编号"));
+    checks.push(check("client_configured", Boolean(this.config.clientId), "缺少客户端编号"));
+    checks.push(check("tool_configured", Boolean(this.config.tool), "缺少 AI 工具类型"));
+    checks.push(check("server_url_configured", Boolean(this.config.serverUrl), "缺少中心端地址"));
+
+    let centerHealth = null;
+    try {
+      centerHealth = await this.health();
+      checks.push(check("center_reachable", true));
+    } catch (error) {
+      checks.push(check("center_reachable", false, `中心端不可达：${error.message}`));
+    }
+
+    const queueWarnThreshold = Number(this.config.collection?.queueWarnThreshold || 1000);
+    checks.push(check(
+      "queue_below_threshold",
+      status.queueSize < queueWarnThreshold,
+      `离线队列 ${status.queueSize} 条，已达到预警阈值 ${queueWarnThreshold}`
+    ));
+    checks.push(check(
+      "collection_enabled",
+      this.config.collection?.enabled !== false,
+      "中心端已关闭采集，事件会保留在本地队列"
+    ));
+    checks.push(check(
+      "auto_update_enabled",
+      this.config.update?.enabled !== false && this.config.update?.autoUpdate !== false,
+      "中心端已关闭客户端静默更新"
+    ));
+
+    const issues = checks.filter((item) => !item.ok).map((item) => item.message);
+    return {
+      ok: issues.length === 0,
+      checkedAt: new Date().toISOString(),
+      checks,
+      issues,
+      centerHealth,
+      status
+    };
+  }
+}
+
+function check(name, ok, message = "") {
+  return { name, ok: Boolean(ok), message: ok ? "" : message };
+}
+
+function clampAccepted(value, batchLength) {
+  const accepted = Number(value);
+  if (!Number.isFinite(accepted)) return batchLength;
+  return Math.min(batchLength, Math.max(0, Math.floor(accepted)));
+}
+
+function acceptedBatchItems(response, batch) {
+  if (Array.isArray(response?.eventIds) && response.eventIds.length) {
+    const eventIds = new Set(response.eventIds.map(String));
+    return batch.filter((item) => eventIds.has(String(item.event?.eventId)));
+  }
+  return batch.slice(0, clampAccepted(response?.accepted, batch.length));
+}