@yanhaidao/wecom 2.4.120 → 2.5.110

package/src/domain/policies.ts

@@ -1,36 +0,0 @@
-import type { ResolvedBotAccount, UnifiedInboundEvent } from "../types/index.js";
-
-export function assertBotPrimaryTransport(account: ResolvedBotAccount): void {
-  if (account.primaryTransport === "ws" && !account.wsConfigured) {
-    throw new Error(`WeCom bot account "${account.accountId}" is missing bot.ws credentials.`);
-  }
-  if (account.primaryTransport === "webhook" && !account.webhookConfigured) {
-    throw new Error(`WeCom bot account "${account.accountId}" is missing bot.webhook credentials.`);
-  }
-}
-
-export function buildDedupKey(event: UnifiedInboundEvent): string {
-  return `${event.accountId}:${event.transport}:${event.messageId}`;
-}
-
-export function resolveConversationKey(event: UnifiedInboundEvent): string {
-  const conversation = event.conversation;
-  return [event.accountId, conversation.peerKind, conversation.peerId, conversation.senderId].join(":");
-}
-
-export function normalizeWecomAllowFromEntry(raw: string): string {
-  return raw
-    .trim()
-    .toLowerCase()
-    .replace(/^wecom:/, "")
-    .replace(/^user:/, "")
-    .replace(/^userid:/, "");
-}
-
-export function isWecomSenderAllowed(senderUserId: string, allowFrom: string[]): boolean {
-  const list = allowFrom.map((entry) => normalizeWecomAllowFromEntry(entry)).filter(Boolean);
-  if (list.includes("*")) return true;
-  const normalizedSender = normalizeWecomAllowFromEntry(senderUserId);
-  if (!normalizedSender) return false;
-  return list.includes(normalizedSender);
-}

package/src/dynamic-agent.account-scope.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { generateAgentId } from "./dynamic-agent.js";
-
-describe("generateAgentId account scoping", () => {
-  it("generates different ids for same peer across accounts", () => {
-    const a = generateAgentId("dm", "zhangsan", "acct-a");
-    const b = generateAgentId("dm", "zhangsan", "acct-b");
-    expect(a).toBe("wecom-acct-a-dm-zhangsan");
-    expect(b).toBe("wecom-acct-b-dm-zhangsan");
-    expect(a).not.toBe(b);
-  });
-
-  it("falls back to default account scope when accountId is omitted", () => {
-    expect(generateAgentId("group", "wr123456")).toBe("wecom-default-group-wr123456");
-  });
-});

package/src/gateway-monitor.ts

@@ -1,181 +0,0 @@
-import type {
-  ChannelGatewayContext,
-  OpenClawConfig,
-} from "openclaw/plugin-sdk";
-
-import {
-  listWecomAccountIds,
-  resolveDerivedPathSummary,
-  resolveWecomAccount,
-  resolveWecomAccountConflict,
-} from "./config/index.js";
-import { createAccountRuntime } from "./app/bootstrap.js";
-import { registerAccountRuntime, unregisterAccountRuntime } from "./app/index.js";
-import type { ResolvedWecomAccount, WecomConfig } from "./types/index.js";
-import { WecomBotCapabilityService } from "./capability/bot/index.js";
-import { WecomAgentIngressService } from "./capability/agent/index.js";
-import type { WecomRuntimeEnv } from "./types/runtime-context.js";
-
-type AccountRouteRegistryItem = {
-  botPaths: string[];
-  agentPaths: string[];
-};
-
-const accountRouteRegistry = new Map<string, AccountRouteRegistryItem>();
-
-function logRegisteredRouteSummary(
-  ctx: ChannelGatewayContext<ResolvedWecomAccount>,
-  preferredOrder: string[],
-): void {
-  const seen = new Set<string>();
-  const orderedAccountIds = [
-    ...preferredOrder.filter((accountId) => accountRouteRegistry.has(accountId)),
-    ...Array.from(accountRouteRegistry.keys())
-      .filter((accountId) => !seen.has(accountId))
-      .sort((a, b) => a.localeCompare(b)),
-  ].filter((accountId) => {
-    if (seen.has(accountId)) return false;
-    seen.add(accountId);
-    return true;
-  });
-
-  const entries = orderedAccountIds
-    .map((accountId) => {
-      const routes = accountRouteRegistry.get(accountId);
-      if (!routes) return undefined;
-      const botText = routes.botPaths.length > 0 ? routes.botPaths.join(", ") : "未启用";
-      const agentText = routes.agentPaths.length > 0 ? routes.agentPaths.join(", ") : "未启用";
-      return `accountId=${accountId}（Bot: ${botText}；Agent: ${agentText}）`;
-    })
-    .filter((entry): entry is string => Boolean(entry));
-  const summary = entries.length > 0 ? entries.join("； ") : "无";
-  ctx.log?.info(`[${ctx.account.accountId}] 已注册账号路由汇总：${summary}`);
-}
-
-function resolveExpectedRouteSummaryAccountIds(cfg: OpenClawConfig): string[] {
-  return listWecomAccountIds(cfg)
-    .filter((accountId) => {
-      const conflict = resolveWecomAccountConflict({ cfg, accountId });
-      if (conflict) return false;
-      const account = resolveWecomAccount({ cfg, accountId });
-      if (!account.enabled || !account.configured) return false;
-      return Boolean(account.bot?.configured || account.agent?.configured);
-    })
-    .sort((a, b) => a.localeCompare(b));
-}
-
-function waitForAbortSignal(abortSignal: AbortSignal): Promise<void> {
-  if (abortSignal.aborted) {
-    return Promise.resolve();
-  }
-  return new Promise<void>((resolve) => {
-    const onAbort = () => {
-      abortSignal.removeEventListener("abort", onAbort);
-      resolve();
-    };
-    abortSignal.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-/**
- * Keeps WeCom webhook targets registered for the account lifecycle.
- * The promise only settles after gateway abort/reload signals shutdown.
- */
-export async function monitorWecomProvider(
-  ctx: ChannelGatewayContext<ResolvedWecomAccount>,
-): Promise<void> {
-  const account = ctx.account;
-  const cfg = ctx.cfg as OpenClawConfig;
-  const expectedRouteSummaryAccountIds = resolveExpectedRouteSummaryAccountIds(cfg);
-  const conflict = resolveWecomAccountConflict({
-    cfg,
-    accountId: account.accountId,
-  });
-  if (conflict) {
-    ctx.setStatus({
-      accountId: account.accountId,
-      running: false,
-      configured: false,
-      lastError: conflict.message,
-    });
-    throw new Error(conflict.message);
-  }
-  const bot = account.bot;
-  const agent = account.agent;
-  const botConfigured = Boolean(bot?.configured);
-  const agentConfigured = Boolean(agent?.configured);
-
-  if (!botConfigured && !agentConfigured) {
-    ctx.log?.warn(`[${account.accountId}] wecom not configured; channel is idle`);
-    ctx.setStatus({ accountId: account.accountId, running: false, configured: false });
-    await waitForAbortSignal(ctx.abortSignal);
-    return;
-  }
-
-  const accountRuntime = createAccountRuntime(ctx);
-  registerAccountRuntime(accountRuntime);
-  const botPaths: string[] = [];
-  const agentPaths: string[] = [];
-  const runtimeEnv: WecomRuntimeEnv = {
-    log: (message) => ctx.log?.info(message),
-    error: (message) => ctx.log?.error(message),
-  };
-  const botService = new WecomBotCapabilityService(
-    accountRuntime,
-    cfg,
-    runtimeEnv,
-  );
-  const agentIngress = new WecomAgentIngressService(accountRuntime, cfg, runtimeEnv);
-  try {
-    ctx.log?.info(
-      `[${account.accountId}] wecom runtime start bot=${bot?.primaryTransport ?? "disabled"} agent=${agentConfigured ? "callback/api" : "disabled"}`,
-    );
-    const botRegistration = botService.start();
-    if (botRegistration) {
-      botPaths.push(...botRegistration.descriptors);
-      ctx.log?.info(
-        `[${account.accountId}] wecom bot ${botRegistration.transport} started: ${botRegistration.descriptors.join(", ")}`,
-      );
-    }
-
-    const agentRegistration = agentIngress.start();
-    if (agentRegistration) {
-      agentPaths.push(...agentRegistration.descriptors);
-      ctx.log?.info(
-        `[${account.accountId}] wecom agent ${agentRegistration.transport} started: ${agentRegistration.descriptors.join(", ")}`,
-      );
-    }
-
-    accountRouteRegistry.set(account.accountId, { botPaths, agentPaths });
-    const shouldLogSummary =
-      expectedRouteSummaryAccountIds.length <= 1 ||
-      expectedRouteSummaryAccountIds.every((accountId) => accountRouteRegistry.has(accountId));
-    if (shouldLogSummary) {
-      logRegisteredRouteSummary(ctx, expectedRouteSummaryAccountIds);
-    }
-
-    ctx.setStatus({
-      running: true,
-      configured: true,
-      webhookPath: botPaths[0] ?? agentPaths[0] ?? null,
-      lastStartAt: Date.now(),
-      ...accountRuntime.buildRuntimeStatus(),
-    });
-    ctx.log?.info(
-      `[${account.accountId}] runtime status health=${accountRuntime.buildRuntimeStatus().health} transports=${(accountRuntime.buildRuntimeStatus().transportSessions ?? []).join(" | ") || "none"}`,
-    );
-
-    await waitForAbortSignal(ctx.abortSignal);
-  } finally {
-    botService.stop();
-    agentIngress.stop();
-    accountRouteRegistry.delete(account.accountId);
-    unregisterAccountRuntime(account.accountId);
-    ctx.setStatus({
-      running: false,
-      lastStopAt: Date.now(),
-      ...accountRuntime.buildRuntimeStatus(),
-    });
-    ctx.log?.info(`[${account.accountId}] wecom runtime stopped`);
-  }
-}

package/src/http.ts

@@ -1,137 +0,0 @@
-import type { Dispatcher } from "undici";
-import { ProxyAgent, fetch as undiciFetch } from "undici";
-
-type ProxyDispatcher = Dispatcher;
-
-const proxyDispatchers = new Map<string, ProxyDispatcher>();
-
-/**
- * **getProxyDispatcher (获取代理 Dispatcher)**
- * 
- * 缓存并复用 ProxyAgent，避免重复创建连接池。
- */
-function getProxyDispatcher(proxyUrl: string): ProxyDispatcher {
-  const existing = proxyDispatchers.get(proxyUrl);
-  if (existing) return existing;
-  const created = new ProxyAgent(proxyUrl);
-  proxyDispatchers.set(proxyUrl, created);
-  return created;
-}
-
-function summarizeHttpTarget(input: string | URL): string {
-  try {
-    const url = typeof input === "string" ? new URL(input) : input;
-    return `${url.origin}${url.pathname}`;
-  } catch {
-    return String(input);
-  }
-}
-
-function mergeAbortSignal(params: {
-  signal?: AbortSignal;
-  timeoutMs?: number;
-}): AbortSignal | undefined {
-  const signals: AbortSignal[] = [];
-  if (params.signal) signals.push(params.signal);
-  if (params.timeoutMs && Number.isFinite(params.timeoutMs) && params.timeoutMs > 0) {
-    signals.push(AbortSignal.timeout(params.timeoutMs));
-  }
-  if (!signals.length) return undefined;
-  if (signals.length === 1) return signals[0];
-  return AbortSignal.any(signals);
-}
-
-/**
- * **WecomHttpOptions (HTTP 选项)**
- * 
- * @property proxyUrl 代理服务器地址
- * @property timeoutMs 请求超时时间 (毫秒)
- * @property signal AbortSignal 信号
- */
-export type WecomHttpOptions = {
-  proxyUrl?: string;
-  timeoutMs?: number;
-  signal?: AbortSignal;
-};
-
-/**
- * **wecomFetch (统一 HTTP 请求)**
- * 
- * 基于 `undici` 的 fetch 封装，自动处理 ProxyAgent 和 Timeout。
- * 所有对企业微信 API 的调用都应经过此函数。
- */
-export async function wecomFetch(input: string | URL, init?: RequestInit, opts?: WecomHttpOptions): Promise<Response> {
-  const proxyUrl = opts?.proxyUrl?.trim() ?? "";
-  const dispatcher = proxyUrl ? getProxyDispatcher(proxyUrl) : undefined;
-  const startedAt = Date.now();
-  const method = (init?.method ?? "GET").toUpperCase();
-  const target = summarizeHttpTarget(input);
-
-  const initSignal = init?.signal ?? undefined;
-  const signal = mergeAbortSignal({ signal: opts?.signal ?? initSignal, timeoutMs: opts?.timeoutMs });
-  
-  const headers = new Headers(init?.headers ?? {});
-  if (!headers.has("User-Agent")) {
-    headers.set("User-Agent", "OpenClaw/2.0 (WeCom-Agent)");
-  }
-
-  const nextInit: RequestInit & { dispatcher?: Dispatcher } = {
-    ...(init ?? {}),
-    ...(signal ? { signal } : {}),
-    ...(dispatcher ? { dispatcher } : {}),
-    headers,
-  };
-
-  try {
-    console.log(
-      `[wecom-http] request method=${method} target=${target} proxy=${proxyUrl || "none"} timeoutMs=${String(opts?.timeoutMs ?? "none")}`,
-    );
-    const response = await undiciFetch(input, nextInit as Parameters<typeof undiciFetch>[1]) as unknown as Response;
-    console.log(
-      `[wecom-http] response method=${method} target=${target} status=${response.status} durationMs=${Date.now() - startedAt}`,
-    );
-    return response;
-  } catch (err: unknown) {
-    if (err instanceof Error && err.name === "TypeError" && err.message === "fetch failed") {
-      const cause = (err as any).cause;
-      console.error(
-        `[wecom-http] fetch failed method=${method} target=${target} durationMs=${Date.now() - startedAt} proxy=${proxyUrl || "none"}${cause ? ` cause=${String(cause)}` : ""}`,
-      );
-    }
-    throw err;
-  }
-}
-
-/**
- * **readResponseBodyAsBuffer (读取响应 Body)**
- * 
- * 将 Response Body 读取为 Buffer，支持最大字节限制以防止内存溢出。
- * 适用于下载媒体文件等场景。
- */
-export async function readResponseBodyAsBuffer(res: Response, maxBytes?: number): Promise<Buffer> {
-  if (!res.body) return Buffer.alloc(0);
-
-  const limit = maxBytes && Number.isFinite(maxBytes) && maxBytes > 0 ? maxBytes : undefined;
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-
-  const reader = res.body.getReader();
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    if (!value) continue;
-
-    total += value.byteLength;
-    if (limit && total > limit) {
-      try {
-        await reader.cancel("body too large");
-      } catch {
-        // ignore
-      }
-      throw new Error(`response body too large (>${limit} bytes)`);
-    }
-    chunks.push(value);
-  }
-
-  return Buffer.concat(chunks.map((c) => Buffer.from(c)));
-}

package/src/media.test.ts

@@ -1,82 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { decryptWecomMedia, decryptWecomMediaWithMeta } from "./media.js";
-import { WECOM_PKCS7_BLOCK_SIZE } from "./crypto.js";
-import crypto from "node:crypto";
-
-const { undiciFetch } = vi.hoisted(() => {
-    const undiciFetch = vi.fn();
-    return { undiciFetch };
-});
-
-vi.mock("undici", () => ({
-    fetch: undiciFetch,
-    ProxyAgent: class ProxyAgent { },
-}));
-
-function pkcs7Pad(buf: Buffer, blockSize: number): Buffer {
-    const mod = buf.length % blockSize;
-    const pad = mod === 0 ? blockSize : blockSize - mod;
-    const padByte = Buffer.from([pad]);
-    return Buffer.concat([buf, Buffer.alloc(pad, padByte[0]!)]);
-}
-
-describe("decryptWecomMedia", () => {
-    it("should download and decrypt media successfully", async () => {
-        // 1. Setup Key and Data
-        const aesKeyBase64 = "jWmYm7qr5nMoCAstdRmNjt3p7vsH8HkK+qiJqQ0aaaa="; // 32 bytes when decoded + padding
-        const aesKey = Buffer.from(aesKeyBase64 + "=", "base64");
-        const iv = aesKey.subarray(0, 16);
-
-        const originalData = Buffer.from("Hello WeCom Image Data", "utf8");
-
-        // 2. Encrypt manually (AES-256-CBC + PKCS7)
-        const padded = pkcs7Pad(originalData, WECOM_PKCS7_BLOCK_SIZE);
-        const cipher = crypto.createCipheriv("aes-256-cbc", aesKey, iv);
-        cipher.setAutoPadding(false);
-        const encrypted = Buffer.concat([cipher.update(padded), cipher.final()]);
-
-        // 3. Mock HTTP fetch
-        undiciFetch.mockResolvedValue(new Response(encrypted));
-
-        // 4. Test
-        const decrypted = await decryptWecomMedia("http://mock.url/image", aesKeyBase64);
-
-        // 5. Assert
-        expect(decrypted.toString("utf8")).toBe("Hello WeCom Image Data");
-        expect(undiciFetch).toHaveBeenCalledWith(
-            "http://mock.url/image",
-            expect.objectContaining({ signal: expect.anything() }),
-        );
-    });
-
-    it("should fail if key is invalid", async () => {
-        await expect(decryptWecomMedia("http://url", "invalid-key")).rejects.toThrow();
-    });
-
-    it("should return source metadata when using decryptWecomMediaWithMeta", async () => {
-        const aesKeyBase64 = "jWmYm7qr5nMoCAstdRmNjt3p7vsH8HkK+qiJqQ0aaaa=";
-        const aesKey = Buffer.from(aesKeyBase64 + "=", "base64");
-        const iv = aesKey.subarray(0, 16);
-        const originalData = Buffer.from("meta test", "utf8");
-        const padded = pkcs7Pad(originalData, WECOM_PKCS7_BLOCK_SIZE);
-        const cipher = crypto.createCipheriv("aes-256-cbc", aesKey, iv);
-        cipher.setAutoPadding(false);
-        const encrypted = Buffer.concat([cipher.update(padded), cipher.final()]);
-
-        undiciFetch.mockResolvedValue(
-            new Response(encrypted, {
-                status: 200,
-                headers: {
-                    "content-type": "application/octet-stream; charset=binary",
-                    "content-disposition": "attachment; filename*=UTF-8''report%20v1.docx",
-                },
-            }),
-        );
-
-        const decrypted = await decryptWecomMediaWithMeta("http://mock.url/media?id=1", aesKeyBase64);
-        expect(decrypted.buffer.toString("utf8")).toBe("meta test");
-        expect(decrypted.sourceContentType).toBe("application/octet-stream");
-        expect(decrypted.sourceFilename).toBe("report v1.docx");
-        expect(decrypted.sourceUrl).toBe("http://mock.url/media?id=1");
-    });
-});

package/src/monitor/limits.ts

@@ -1,7 +0,0 @@
-export const LIMITS = {
-  STREAM_TTL_MS: 10 * 60 * 1000,
-  ACTIVE_REPLY_TTL_MS: 60 * 60 * 1000,
-  DEFAULT_DEBOUNCE_MS: 500,
-  STREAM_MAX_BYTES: 20_480,
-  REQUEST_TIMEOUT_MS: 15_000,
-};

package/src/monitor/state.queue.test.ts

@@ -1,185 +0,0 @@
-import { describe, expect, test, vi } from "vitest";
-
-import type { WecomBotInboundMessage as WecomInboundMessage } from "../types/index.js";
-import type { WecomWebhookTarget } from "./types.js";
-import { StreamStore } from "./state.js";
-
-describe("wecom StreamStore queue", () => {
-  test("does not merge into active batch; flushes queued batch after active finishes", async () => {
-    vi.useFakeTimers();
-    try {
-      const store = new StreamStore();
-      const flushed: string[] = [];
-      store.setFlushHandler((pending) => flushed.push(pending.streamId));
-
-      const target = {
-        account: {} as any,
-        config: {} as any,
-        runtime: {},
-        core: {} as any,
-        path: "/wecom",
-      } satisfies WecomWebhookTarget;
-
-      const conversationKey = "wecom:default:U:C";
-
-      const msg1 = { msgid: "M1" } satisfies WecomInboundMessage;
-      const msg2 = { msgid: "M2" } satisfies WecomInboundMessage;
-
-      const r1 = store.addPendingMessage({
-        conversationKey,
-        target,
-        msg: msg1,
-        msgContent: "1",
-        nonce: "n",
-        timestamp: "t",
-        debounceMs: 10,
-      });
-      const r2 = store.addPendingMessage({
-        conversationKey,
-        target,
-        msg: msg2,
-        msgContent: "2",
-        nonce: "n",
-        timestamp: "t",
-        debounceMs: 10,
-      });
-
-      expect(r1.status).toBe("active_new");
-      // 初始批次不接收合并：第二条进入 queued
-      expect(r2.status).toBe("queued_new");
-      expect(r2.streamId).not.toBe(r1.streamId);
-
-      // Follow-ups within queued should merge into queued (status queued_merged).
-      const r3 = store.addPendingMessage({
-        conversationKey,
-        target,
-        msg: { msgid: "M3" } as any,
-        msgContent: "3",
-        nonce: "n",
-        timestamp: "t",
-        debounceMs: 10,
-      });
-      expect(r3.status).toBe("queued_merged");
-      expect(r3.streamId).toBe(r2.streamId);
-
-      // Active batch flushes at debounce time.
-      await vi.advanceTimersByTimeAsync(11);
-      expect(flushed).toEqual([r1.streamId]);
-
-      // Queued batch timer also fires, but cannot flush until active finishes.
-      await vi.advanceTimersByTimeAsync(11);
-      expect(flushed).toEqual([r1.streamId]);
-
-      // Once the active stream finishes, queued batch is promoted and flushes immediately.
-      store.onStreamFinished(r1.streamId);
-      expect(flushed).toEqual([r1.streamId, r2.streamId]);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  test("merges into active batch when it has not started yet (even after promotion)", async () => {
-    vi.useFakeTimers();
-    try {
-      const store = new StreamStore();
-      const flushed: string[] = [];
-      store.setFlushHandler((pending) => flushed.push(pending.streamId));
-
-      const target = {
-        account: {} as any,
-        config: {} as any,
-        runtime: {},
-        core: {} as any,
-        path: "/wecom",
-      } satisfies WecomWebhookTarget;
-
-      const conversationKey = "wecom:default:U:C2";
-
-      // 1 becomes active and flushes; mark as started to simulate "processing started".
-      const r1 = store.addPendingMessage({
-        conversationKey,
-        target,
-        msg: { msgid: "M1" } as any,
-        msgContent: "1",
-        nonce: "n",
-        timestamp: "t",
-        debounceMs: 10,
-      });
-      store.markStarted(r1.streamId);
-      await vi.advanceTimersByTimeAsync(11);
-      expect(flushed).toEqual([r1.streamId]);
-
-      // 2 enters queued with a longer debounce; it should NOT become readyToFlush yet.
-      const r2 = store.addPendingMessage({
-        conversationKey,
-        target,
-        msg: { msgid: "M2" } as any,
-        msgContent: "2",
-        nonce: "n",
-        timestamp: "t",
-        debounceMs: 100,
-      });
-      expect(flushed).toEqual([r1.streamId]);
-
-      // Finish 1, promote 2 to active (but do NOT flush immediately since it's not readyToFlush).
-      store.onStreamFinished(r1.streamId);
-      expect(flushed).toEqual([r1.streamId]);
-
-      // Now 2 is active, but (in real monitor) it may still be in debounce before markStarted.
-      // We simulate that by NOT calling markStarted. Follow-up should merge into active (same streamId).
-      const r3 = store.addPendingMessage({
-        conversationKey,
-        target,
-        msg: { msgid: "M3" } as any,
-        msgContent: "3",
-        nonce: "n",
-        timestamp: "t",
-        debounceMs: 10,
-      });
-      expect(r3.streamId).toBe(r2.streamId);
-      expect(r3.status).toBe("active_merged");
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  test("clears conversation state when idle so next message becomes active", async () => {
-    const store = new StreamStore();
-    store.setFlushHandler(() => { });
-
-    const target = {
-      account: {} as any,
-      config: {} as any,
-      runtime: {},
-      core: {} as any,
-      path: "/wecom",
-    } satisfies WecomWebhookTarget;
-
-    const conversationKey = "wecom:default:U:idle";
-
-    const r1 = store.addPendingMessage({
-      conversationKey,
-      target,
-      msg: { msgid: "M1" } as any,
-      msgContent: "1",
-      nonce: "n",
-      timestamp: "t",
-      debounceMs: 10,
-    });
-    store.markStarted(r1.streamId);
-    store.markFinished(r1.streamId);
-    store.onStreamFinished(r1.streamId);
-
-    const r2 = store.addPendingMessage({
-      conversationKey,
-      target,
-      msg: { msgid: "M2" } as any,
-      msgContent: "2",
-      nonce: "n",
-      timestamp: "t",
-      debounceMs: 10,
-    });
-    expect(r2.status).toBe("active_new");
-    expect(r2.streamId).not.toBe(r1.streamId);
-  });
-});

package/src/monitor/state.ts

@@ -1,34 +0,0 @@
-import { LegacyOperationalEventStore, type MonitorOperationalEvent } from "../observability/legacy-operational-event-store.js";
-import { ActiveReplyStore } from "../store/active-reply-store.js";
-import { StreamStore } from "../store/stream-batch-store.js";
-import { LIMITS } from "./limits.js";
-
-export { LIMITS, StreamStore, ActiveReplyStore };
-export type { MonitorOperationalEvent };
-
-class MonitorState {
-  public readonly streamStore = new StreamStore();
-  public readonly activeReplyStore = new ActiveReplyStore("multi");
-  public readonly operationalEvents = new LegacyOperationalEventStore();
-
-  private pruneInterval?: NodeJS.Timeout;
-
-  public startPruning(intervalMs: number = 60_000): void {
-    if (this.pruneInterval) return;
-    this.pruneInterval = setInterval(() => {
-      const now = Date.now();
-      this.streamStore.prune(now);
-      this.activeReplyStore.prune(now);
-      this.operationalEvents.prune(now);
-    }, intervalMs);
-  }
-
-  public stopPruning(): void {
-    if (this.pruneInterval) {
-      clearInterval(this.pruneInterval);
-      this.pruneInterval = undefined;
-    }
-  }
-}
-
-export const monitorState = new MonitorState();