Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

packages/memory-host-sdk/src/host/post-json.test.ts

@@ -0,0 +1,242 @@
+// Memory Host SDK tests cover post json behavior.
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { postJson } from "./post-json.js";
+import { withRemoteHttpResponse } from "./remote-http.js";
+
+vi.mock("./remote-http.js", () => ({
+  withRemoteHttpResponse: vi.fn(),
+}));
+
+const remoteHttpMock = vi.mocked(withRemoteHttpResponse);
+
+function jsonResponse(payload: unknown, status = 200): Response {
+  return new Response(JSON.stringify(payload), { status });
+}
+
+function textResponse(body: string, status: number): Response {
+  return new Response(body, { status });
+}
+
+function streamingTextResponse(params: {
+  body: string;
+  status: number;
+  headers?: HeadersInit;
+  onCancel: () => void;
+}): Response {
+  const encoded = new TextEncoder().encode(params.body);
+  const stream = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.enqueue(encoded);
+    },
+    cancel() {
+      params.onCancel();
+    },
+  });
+  return new Response(stream, { status: params.status, headers: params.headers });
+}
+
+function stallingSuccessResponse(onCancel: () => void): Response {
+  const reader = {
+    read: () => new Promise<ReadableStreamReadResult<Uint8Array>>(() => {}),
+    cancel: async () => {
+      onCancel();
+    },
+    releaseLock: () => undefined,
+  } as ReadableStreamDefaultReader<Uint8Array>;
+
+  return {
+    body: { getReader: () => reader },
+    headers: new Headers(),
+    ok: true,
+    status: 200,
+  } as Response;
+}
+
+describe("postJson", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("parses JSON payload on successful response", async () => {
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(jsonResponse({ data: [{ embedding: [1, 2] }] }));
+    });
+
+    const result = await postJson({
+      url: "https://memory.example/v1/post",
+      headers: { Authorization: "Bearer test" },
+      body: { input: ["x"] },
+      errorPrefix: "post failed",
+      parse: (payload) => payload,
+    });
+
+    expect(result).toEqual({ data: [{ embedding: [1, 2] }] });
+  });
+
+  it("forwards abort signals to the remote HTTP request", async () => {
+    const controller = new AbortController();
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      expect(params.signal).toBe(controller.signal);
+      return await params.onResponse(jsonResponse({ ok: true }));
+    });
+
+    await postJson({
+      url: "https://memory.example/v1/post",
+      headers: {},
+      body: {},
+      signal: controller.signal,
+      errorPrefix: "post failed",
+      parse: (payload) => payload,
+    });
+  });
+
+  it("applies abort signals while reading successful response bodies", async () => {
+    let canceled = false;
+    const controller = new AbortController();
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(
+        stallingSuccessResponse(() => {
+          canceled = true;
+        }),
+      );
+    });
+
+    const read = postJson({
+      url: "https://memory.example/v1/post",
+      headers: {},
+      body: {},
+      signal: controller.signal,
+      errorPrefix: "post failed",
+      parse: () => ({}),
+    });
+
+    await new Promise((resolve) => {
+      setTimeout(resolve, 0);
+    });
+    controller.abort(new Error("body aborted"));
+
+    await expect(read).rejects.toThrow("body aborted");
+    expect(canceled).toBe(true);
+  });
+
+  it("attaches status to thrown error when requested", async () => {
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(textResponse("bad gateway", 502));
+    });
+
+    let error: unknown;
+    try {
+      await postJson({
+        url: "https://memory.example/v1/post",
+        headers: {},
+        body: {},
+        errorPrefix: "post failed",
+        attachStatus: true,
+        parse: () => ({}),
+      });
+    } catch (caught) {
+      error = caught;
+    }
+
+    expect(error).toBeInstanceOf(Error);
+    expect((error as Error).message).toBe("post failed: 502 bad gateway");
+    expect((error as { status?: unknown }).status).toBe(502);
+  });
+
+  it("bounds non-ok response bodies before formatting the error", async () => {
+    let canceled = false;
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(
+        streamingTextResponse({
+          body: "x".repeat(12_000),
+          status: 502,
+          onCancel: () => {
+            canceled = true;
+          },
+        }),
+      );
+    });
+
+    await expect(
+      postJson({
+        url: "https://memory.example/v1/post",
+        headers: {},
+        body: {},
+        errorPrefix: "post failed",
+        parse: () => ({}),
+      }),
+    ).rejects.toThrow(`post failed: 502 ${"x".repeat(1_000)}... [truncated]`);
+    expect(canceled).toBe(true);
+  });
+
+  it("wraps malformed success JSON with the request error prefix", async () => {
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(textResponse("{ nope", 200));
+    });
+
+    await expect(
+      postJson({
+        url: "https://memory.example/v1/post",
+        headers: {},
+        body: {},
+        errorPrefix: "post failed",
+        parse: () => ({}),
+      }),
+    ).rejects.toThrow("post failed: malformed JSON response");
+  });
+
+  it("rejects successful JSON responses with oversized content-length", async () => {
+    let canceled = false;
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(
+        streamingTextResponse({
+          body: "{}",
+          status: 200,
+          headers: { "content-length": "32" },
+          onCancel: () => {
+            canceled = true;
+          },
+        }),
+      );
+    });
+
+    await expect(
+      postJson({
+        url: "https://memory.example/v1/post",
+        headers: {},
+        body: {},
+        errorPrefix: "post failed",
+        maxResponseBytes: 8,
+        parse: () => ({}),
+      }),
+    ).rejects.toThrow("post failed: response body too large: 32 bytes (limit: 8 bytes)");
+    expect(canceled).toBe(true);
+  });
+
+  it("cancels successful JSON responses that exceed the streaming byte cap", async () => {
+    let canceled = false;
+    remoteHttpMock.mockImplementationOnce(async (params) => {
+      return await params.onResponse(
+        streamingTextResponse({
+          body: `{"data":"${"x".repeat(32)}"}`,
+          status: 200,
+          onCancel: () => {
+            canceled = true;
+          },
+        }),
+      );
+    });
+
+    await expect(
+      postJson({
+        url: "https://memory.example/v1/post",
+        headers: {},
+        body: {},
+        errorPrefix: "post failed",
+        maxResponseBytes: 16,
+        parse: () => ({}),
+      }),
+    ).rejects.toThrow("post failed: response body too large");
+    expect(canceled).toBe(true);
+  });
+});