@sleep2agi/commhub-server 0.9.0-preview.13 → 0.9.0-preview.130

package/src/send_dedup.ts

@@ -33,6 +33,26 @@
 //   - The structured response shape is identical between MCP and REST
 //     callers so the LLM gets the same parseable hint regardless of
 //     transport.
+//
+// Key selection (#2043, follow-up to #212): the content-hash key above is
+// only right for callers that have no other notion of "one message".
+// Human chat clients (the desktop/mobile app, the web Dashboard) mint a
+// fresh `meta.client_request_id` per message bubble and reuse it only
+// when retrying that same bubble. For those sends the content hash is the
+// WRONG identity: a user who types 「好」 twice within five minutes sent
+// two messages, and dropping the second one (while the app maps the 429
+// to "delivered") silently loses it. So:
+//   - a send WITH a valid client_request_id is keyed on
+//     (network, from, to, client_request_id) — a new id always proceeds,
+//     identical text or not; a same-id retry is answered from the durable
+//     tasks row by the handler (task-idempotency.ts) before this index is
+//     even consulted, so this key is defence in depth, not the primary
+//     replay mechanism;
+//   - a send WITHOUT one (agent / MCP / scripted traffic) keeps the #212
+//     content-hash window unchanged.
+// One id is one message: re-using an id with different content is a
+// client bug and the handlers fail it closed (`idempotency_conflict`)
+// rather than storing a second row or silently replaying the first.
 
 import { createHash } from "crypto";
 
@@ -61,9 +81,23 @@ export function readDedupConfig(env: NodeJS.ProcessEnv = process.env): DedupConf
   };
 }
 
+/** Which identity a dedup key was built from. Logged on every drop. */
+export type DedupKeyKind = "request_id" | "content";
+
+/**
+ * Optional per-send scope. When `requestId` is a non-empty string the key
+ * is the request id (scoped by network/from/to) instead of the content hash.
+ * Callers must pass the already-validated id (clientRequestIdFromMeta), not
+ * raw client input.
+ */
+export type DedupScope = {
+  requestId?: string | null;
+  networkId?: string | null;
+};
+
 export type DedupCheck =
   | { duplicate: false }
-  | { duplicate: true; lastSentMs: number; ageMs: number };
+  | { duplicate: true; lastSentMs: number; ageMs: number; kind: DedupKeyKind };
 
 export class SendDedup {
   private last = new Map<string, number>();
@@ -93,6 +127,18 @@ export class SendDedup {
     return `${from}|${to}|${hash}`;
   }
 
+  /**
+   * Pick the dedup identity for one send. A validated client request id
+   * wins over the content hash; see the header comment for why.
+   */
+  static keyFor(from: string, to: string, content: string, scope: DedupScope = {}): { key: string; kind: DedupKeyKind } {
+    const requestId = typeof scope.requestId === "string" && scope.requestId.length > 0 ? scope.requestId : null;
+    if (requestId) {
+      return { key: `rid|${scope.networkId ?? ""}|${from}|${to}|${requestId}`, kind: "request_id" };
+    }
+    return { key: SendDedup.key(from, to, content), kind: "content" };
+  }
+
   /**
    * Check whether (from, to, content) was sent recently. Returns
    * `{ duplicate: false }` when the call should proceed, or
@@ -103,10 +149,10 @@ export class SendDedup {
    * AFTER the underlying side effect (inbox insert + pushEvent) succeeds,
    * so failed sends don't accidentally block legitimate retries.
    */
-  check(from: string, to: string, content: string, nowMs: number = Date.now()): DedupCheck {
+  check(from: string, to: string, content: string, nowMs: number = Date.now(), scope: DedupScope = {}): DedupCheck {
     if (!this.enabled) return { duplicate: false };
     this.evictExpired(nowMs);
-    const k = SendDedup.key(from, to, content);
+    const { key: k, kind } = SendDedup.keyFor(from, to, content, scope);
     const lastSentMs = this.last.get(k);
     if (lastSentMs === undefined) return { duplicate: false };
     const ageMs = nowMs - lastSentMs;
@@ -114,13 +160,13 @@ export class SendDedup {
       this.last.delete(k);
       return { duplicate: false };
     }
-    return { duplicate: true, lastSentMs, ageMs };
+    return { duplicate: true, lastSentMs, ageMs, kind };
   }
 
   /** Record a successful send for future dedup checks. */
-  record(from: string, to: string, content: string, nowMs: number = Date.now()): void {
+  record(from: string, to: string, content: string, nowMs: number = Date.now(), scope: DedupScope = {}): void {
     if (!this.enabled) return;
-    const k = SendDedup.key(from, to, content);
+    const k = SendDedup.keyFor(from, to, content, scope).key;
     this.last.set(k, nowMs);
     if (this.last.size > this.cfg.maxKeys) this.evictOldest();
   }

package/src/serve-error.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { buildServeErrorResponse, serveErrorBody } from "./serve-error.js";
+
+// 注:「没有 error 回调时 Bun 回默认非 JSON 500」这一半没法在 bun test 里当用例:
+// 运行器会把 fetch 里抛出的异常当成未处理错误直接判这条用例失败(实测),证据在 #695 末评。
+describe("#695 fetch exceptions become JSON with the exception's own message", () => {
+  test("body carries THE message, both JSON-RPC-shaped and REST-shaped", () => {
+    const b = serveErrorBody(new Error("boom-695: sqlite is locked"));
+    expect(b.error.code).toBe(-32603);
+    expect(b.error.message).toBe("boom-695: sqlite is locked");
+    expect(b.message).toBe("boom-695: sqlite is locked");
+    expect(b.ok).toBe(false);
+    // 不是固定 JSON:换一个异常,message 跟着变
+    expect(serveErrorBody(new Error("other")).error.message).toBe("other");
+    expect(serveErrorBody("plain string").error.message).toBe("plain string");
+    expect(serveErrorBody(new Error("")).error.message).toBe("internal error");
+  });
+
+  test("real Bun.serve: a throwing fetch answers 500 + application/json + the message (was a non-JSON default page)", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch() { throw new Error("boom-695-live"); },
+      error: (err) => buildServeErrorResponse(err),
+    });
+    try {
+      const res = await fetch(`http://127.0.0.1:${server.port}/mcp`, { method: "POST", body: "{}" });
+      expect(res.status).toBe(500);
+      expect(res.headers.get("content-type") ?? "").toContain("application/json");
+      const json = await res.json() as { error: { code: number; message: string }; ok: boolean };
+      expect(json.error.code).toBe(-32603);
+      expect(json.error.message).toBe("boom-695-live");
+      expect(json.ok).toBe(false);
+    } finally {
+      server.stop(true);
+    }
+  });
+
+});

package/src/serve-error.ts

@@ -0,0 +1,27 @@
+// #695 —— Bun.serve 没注册 `error` 回调时,fetch 处理器抛出的异常会变成 Bun 的默认 500,
+// body 不是 JSON;MCP 客户端于是只能报一个泛化的 -32603,拿不到任何一句人话。
+// 这里把异常变成一个带 message 的 JSON 响应:/mcp 的客户端按 JSON-RPC 形状读 error.message,
+// REST 客户端按本仓其它路由的 { ok:false, error, message } 形状读。
+// 🔴 判据(#695 末评):同一个异常,响应里要带**那个异常的 message**,不是一个固定 JSON。
+
+export interface ServeErrorBody {
+  jsonrpc: "2.0";
+  id: null;
+  error: { code: -32603; message: string };
+  ok: false;
+  message: string;
+}
+
+export function serveErrorBody(err: unknown): ServeErrorBody {
+  const raw = err instanceof Error ? err.message : String(err);
+  const message = (raw && raw.trim()) ? raw.trim().slice(0, 500) : "internal error";
+  return { jsonrpc: "2.0", id: null, error: { code: -32603, message }, ok: false, message };
+}
+
+export function buildServeErrorResponse(err: unknown): Response {
+  const body = serveErrorBody(err);
+  return new Response(JSON.stringify(body), {
+    status: 500,
+    headers: { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" },
+  });
+}