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

test/scripts/telegram-bot-api.test.ts

@@ -0,0 +1,120 @@
+// Telegram Bot Api tests cover telegram bot api script behavior.
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { readTelegramBotApiLimits, telegramBotApi } from "../../scripts/e2e/telegram-bot-api.ts";
+
+describe("Telegram Bot API helper", () => {
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("rejects loose numeric env limits instead of parsing prefixes", () => {
+    expect(() =>
+      readTelegramBotApiLimits({
+        OPENCLAW_TELEGRAM_USER_BOT_API_TIMEOUT_MS: "1e3",
+      }),
+    ).toThrow("invalid OPENCLAW_TELEGRAM_USER_BOT_API_TIMEOUT_MS: 1e3");
+    expect(() =>
+      readTelegramBotApiLimits({
+        OPENCLAW_TELEGRAM_USER_BOT_API_BODY_MAX_BYTES: "1000ms",
+      }),
+    ).toThrow("invalid OPENCLAW_TELEGRAM_USER_BOT_API_BODY_MAX_BYTES: 1000ms");
+    expect(
+      readTelegramBotApiLimits({
+        OPENCLAW_TELEGRAM_USER_BOT_API_BODY_MAX_BYTES: "2048",
+        OPENCLAW_TELEGRAM_USER_BOT_API_TIMEOUT_MS: "15000",
+      }),
+    ).toEqual({
+      bodyMaxBytes: 2048,
+      timeoutMs: 15000,
+    });
+  });
+
+  it("returns successful Bot API results", async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ ok: true, result: { username: "OpenClawBot" } }), {
+        status: 200,
+      }),
+    );
+
+    await expect(
+      telegramBotApi("test-token", "getMe", {}, { baseUrl: "https://telegram.test", fetchImpl }),
+    ).resolves.toEqual({ username: "OpenClawBot" });
+    expect(fetchImpl).toHaveBeenCalledWith(
+      "https://telegram.test/bottest-token/getMe",
+      expect.objectContaining({
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: "{}",
+      }),
+    );
+  });
+
+  it("surfaces Telegram API descriptions", async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ ok: false, description: "chat not found" }), {
+        status: 400,
+      }),
+    );
+
+    await expect(
+      telegramBotApi(
+        "test-token",
+        "sendMessage",
+        {},
+        { baseUrl: "https://telegram.test", fetchImpl },
+      ),
+    ).rejects.toThrow("chat not found");
+  });
+
+  it("bounds stalled Bot API response bodies", async () => {
+    vi.useFakeTimers();
+    const fetchImpl = vi.fn().mockResolvedValue(
+      new Response(new ReadableStream<Uint8Array>({ start() {} }), {
+        status: 200,
+      }),
+    );
+
+    const result = telegramBotApi(
+      "test-token",
+      "getUpdates",
+      {},
+      {
+        baseUrl: "https://telegram.test",
+        fetchImpl,
+        timeoutMs: 100,
+      },
+    );
+    const rejection = expect(result).rejects.toMatchObject({
+      code: "ETIMEDOUT",
+      message: "Telegram Bot API getUpdates timed out after 100ms",
+    });
+
+    await vi.advanceTimersByTimeAsync(100);
+    await rejection;
+    expect(fetchImpl.mock.calls[0]?.[1]?.signal.aborted).toBe(true);
+  });
+
+  it("bounds oversized Bot API response bodies", async () => {
+    const fetchImpl = vi.fn().mockResolvedValue(
+      new Response(JSON.stringify({ ok: true, result: {}, padding: "x".repeat(128) }), {
+        status: 200,
+      }),
+    );
+
+    await expect(
+      telegramBotApi(
+        "test-token",
+        "getMe",
+        {},
+        {
+          baseUrl: "https://telegram.test",
+          fetchImpl,
+          maxBodyBytes: 16,
+        },
+      ),
+    ).rejects.toMatchObject({
+      code: "ETOOBIG",
+      message: "Telegram Bot API getMe response body exceeded 16 bytes",
+    });
+  });
+});