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/helpers/live-image-probe.ts

@@ -0,0 +1,461 @@
+// Live image probe helpers build tiny image fixtures for live provider tests.
+import { encodePngRgba, fillPixel } from "../../src/media/png-encode.js";
+
+const GLYPH_ROWS_5X7: Record<string, number[]> = {
+  "0": [0b01110, 0b10001, 0b10011, 0b10101, 0b11001, 0b10001, 0b01110],
+  "1": [0b00100, 0b01100, 0b00100, 0b00100, 0b00100, 0b00100, 0b01110],
+  "2": [0b01110, 0b10001, 0b00001, 0b00010, 0b00100, 0b01000, 0b11111],
+  "3": [0b11110, 0b00001, 0b00001, 0b01110, 0b00001, 0b00001, 0b11110],
+  "4": [0b00010, 0b00110, 0b01010, 0b10010, 0b11111, 0b00010, 0b00010],
+  "5": [0b11111, 0b10000, 0b11110, 0b00001, 0b00001, 0b10001, 0b01110],
+  "6": [0b00110, 0b01000, 0b10000, 0b11110, 0b10001, 0b10001, 0b01110],
+  "7": [0b11111, 0b00001, 0b00010, 0b00100, 0b01000, 0b01000, 0b01000],
+  "8": [0b01110, 0b10001, 0b10001, 0b01110, 0b10001, 0b10001, 0b01110],
+  "9": [0b01110, 0b10001, 0b10001, 0b01111, 0b00001, 0b00010, 0b01100],
+
+  A: [0b01110, 0b10001, 0b10001, 0b11111, 0b10001, 0b10001, 0b10001],
+  B: [0b11110, 0b10001, 0b10001, 0b11110, 0b10001, 0b10001, 0b11110],
+  C: [0b01110, 0b10001, 0b10000, 0b10000, 0b10000, 0b10001, 0b01110],
+  D: [0b11110, 0b10001, 0b10001, 0b10001, 0b10001, 0b10001, 0b11110],
+  E: [0b11111, 0b10000, 0b10000, 0b11110, 0b10000, 0b10000, 0b11111],
+  F: [0b11111, 0b10000, 0b10000, 0b11110, 0b10000, 0b10000, 0b10000],
+  T: [0b11111, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100, 0b00100],
+};
+
+function drawGlyph5x7(params: {
+  buf: Buffer;
+  width: number;
+  x: number;
+  y: number;
+  char: string;
+  scale: number;
+  color: { r: number; g: number; b: number; a?: number };
+}) {
+  const rows = GLYPH_ROWS_5X7[params.char];
+  if (!rows) {
+    return;
+  }
+  for (let row = 0; row < 7; row += 1) {
+    const bits = rows[row] ?? 0;
+    for (let col = 0; col < 5; col += 1) {
+      const on = (bits & (1 << (4 - col))) !== 0;
+      if (!on) {
+        continue;
+      }
+      for (let dy = 0; dy < params.scale; dy += 1) {
+        for (let dx = 0; dx < params.scale; dx += 1) {
+          fillPixel(
+            params.buf,
+            params.x + col * params.scale + dx,
+            params.y + row * params.scale + dy,
+            params.width,
+            params.color.r,
+            params.color.g,
+            params.color.b,
+            params.color.a ?? 255,
+          );
+        }
+      }
+    }
+  }
+}
+
+function drawText(params: {
+  buf: Buffer;
+  width: number;
+  x: number;
+  y: number;
+  text: string;
+  scale: number;
+  color: { r: number; g: number; b: number; a?: number };
+}) {
+  const text = params.text.toUpperCase();
+  let cursorX = params.x;
+  for (const raw of text) {
+    const ch = raw in GLYPH_ROWS_5X7 ? raw : raw.toUpperCase();
+    drawGlyph5x7({
+      buf: params.buf,
+      width: params.width,
+      x: cursorX,
+      y: params.y,
+      char: ch,
+      scale: params.scale,
+      color: params.color,
+    });
+    cursorX += 6 * params.scale;
+  }
+}
+
+function measureTextWidthPx(text: string, scale: number) {
+  return text.length * 6 * scale - scale; // 5px glyph + 1px space
+}
+
+export function renderBitmapTextPngBase64(
+  text: string,
+  options: {
+    background?: { r: number; g: number; b: number; a?: number };
+    foreground?: { r: number; g: number; b: number; a?: number };
+    padding?: number;
+    scale?: number;
+  } = {},
+): string {
+  const normalized = text.trim().toUpperCase();
+  if (!normalized) {
+    throw new Error("bitmap text image requires non-empty text");
+  }
+  const unsupported = Array.from(normalized).filter((ch) => !(ch in GLYPH_ROWS_5X7));
+  if (unsupported.length > 0) {
+    throw new Error(`bitmap text image contains unsupported glyphs: ${unsupported.join(",")}`);
+  }
+  const scale = Math.max(1, Math.floor(options.scale ?? 4));
+  const padding = Math.max(0, Math.floor(options.padding ?? 8));
+  const width = measureTextWidthPx(normalized, scale) + padding * 2;
+  const height = 7 * scale + padding * 2;
+  const background = options.background ?? { r: 245, g: 247, b: 250, a: 255 };
+  const foreground = options.foreground ?? { r: 18, g: 24, b: 33, a: 255 };
+  const buf = Buffer.alloc(width * height * 4);
+  fillRect({
+    buf,
+    width,
+    height,
+    x: 0,
+    y: 0,
+    w: width,
+    h: height,
+    color: background,
+  });
+  drawText({
+    buf,
+    width,
+    x: padding,
+    y: padding,
+    text: normalized,
+    scale,
+    color: foreground,
+  });
+  return encodePngRgba(buf, width, height).toString("base64");
+}
+
+function fillRect(params: {
+  buf: Buffer;
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+  color: { r: number; g: number; b: number; a?: number };
+}) {
+  const startX = Math.max(0, params.x);
+  const startY = Math.max(0, params.y);
+  const endX = Math.min(params.width, params.x + params.w);
+  const endY = Math.min(params.height, params.y + params.h);
+  for (let y = startY; y < endY; y += 1) {
+    for (let x = startX; x < endX; x += 1) {
+      fillPixel(
+        params.buf,
+        x,
+        y,
+        params.width,
+        params.color.r,
+        params.color.g,
+        params.color.b,
+        params.color.a ?? 255,
+      );
+    }
+  }
+}
+
+function fillEllipse(params: {
+  buf: Buffer;
+  width: number;
+  height: number;
+  cx: number;
+  cy: number;
+  rx: number;
+  ry: number;
+  color: { r: number; g: number; b: number; a?: number };
+}) {
+  for (
+    let y = Math.max(0, params.cy - params.ry);
+    y <= Math.min(params.height - 1, params.cy + params.ry);
+    y += 1
+  ) {
+    for (
+      let x = Math.max(0, params.cx - params.rx);
+      x <= Math.min(params.width - 1, params.cx + params.rx);
+      x += 1
+    ) {
+      const dx = (x - params.cx) / params.rx;
+      const dy = (y - params.cy) / params.ry;
+      if (dx * dx + dy * dy <= 1) {
+        fillPixel(
+          params.buf,
+          x,
+          y,
+          params.width,
+          params.color.r,
+          params.color.g,
+          params.color.b,
+          params.color.a ?? 255,
+        );
+      }
+    }
+  }
+}
+
+function fillTriangle(params: {
+  buf: Buffer;
+  width: number;
+  height: number;
+  a: { x: number; y: number };
+  b: { x: number; y: number };
+  c: { x: number; y: number };
+  color: { r: number; g: number; b: number; a?: number };
+}) {
+  const minX = Math.max(0, Math.min(params.a.x, params.b.x, params.c.x));
+  const maxX = Math.min(params.width - 1, Math.max(params.a.x, params.b.x, params.c.x));
+  const minY = Math.max(0, Math.min(params.a.y, params.b.y, params.c.y));
+  const maxY = Math.min(params.height - 1, Math.max(params.a.y, params.b.y, params.c.y));
+  const area =
+    (params.b.x - params.a.x) * (params.c.y - params.a.y) -
+    (params.b.y - params.a.y) * (params.c.x - params.a.x);
+  if (area === 0) {
+    return;
+  }
+  for (let y = minY; y <= maxY; y += 1) {
+    for (let x = minX; x <= maxX; x += 1) {
+      const w0 =
+        (params.b.x - params.a.x) * (y - params.a.y) - (params.b.y - params.a.y) * (x - params.a.x);
+      const w1 =
+        (params.c.x - params.b.x) * (y - params.b.y) - (params.c.y - params.b.y) * (x - params.b.x);
+      const w2 =
+        (params.a.x - params.c.x) * (y - params.c.y) - (params.a.y - params.c.y) * (x - params.c.x);
+      if ((w0 <= 0 && w1 <= 0 && w2 <= 0) || (w0 >= 0 && w1 >= 0 && w2 >= 0)) {
+        fillPixel(
+          params.buf,
+          x,
+          y,
+          params.width,
+          params.color.r,
+          params.color.g,
+          params.color.b,
+          params.color.a ?? 255,
+        );
+      }
+    }
+  }
+}
+
+function drawBlockCatLabel(params: {
+  buf: Buffer;
+  width: number;
+  height: number;
+  x: number;
+  y: number;
+  color: { r: number; g: number; b: number; a?: number };
+}) {
+  const t = 12;
+  const h = 78;
+  const w = 58;
+  const gap = 20;
+  const cX = params.x;
+  const aX = cX + w + gap;
+  const tX = aX + w + gap;
+
+  fillRect({ ...params, x: cX, y: params.y, w, h: t, color: params.color });
+  fillRect({ ...params, x: cX, y: params.y, w: t, h, color: params.color });
+  fillRect({ ...params, x: cX, y: params.y + h - t, w, h: t, color: params.color });
+
+  fillRect({ ...params, x: aX, y: params.y, w, h: t, color: params.color });
+  fillRect({ ...params, x: aX, y: params.y, w: t, h, color: params.color });
+  fillRect({ ...params, x: aX + w - t, y: params.y, w: t, h, color: params.color });
+  fillRect({
+    ...params,
+    x: aX,
+    y: params.y + Math.floor((h - t) / 2),
+    w,
+    h: t,
+    color: params.color,
+  });
+
+  fillRect({ ...params, x: tX, y: params.y, w, h: t, color: params.color });
+  fillRect({
+    ...params,
+    x: tX + Math.floor((w - t) / 2),
+    y: params.y,
+    w: t,
+    h,
+    color: params.color,
+  });
+}
+
+export function renderCatNoncePngBase64(nonce: string): string {
+  const top = "CAT";
+  const bottom = nonce.toUpperCase();
+
+  const scale = 12;
+  const pad = 18;
+  const gap = 18;
+
+  const topWidth = measureTextWidthPx(top, scale);
+  const bottomWidth = measureTextWidthPx(bottom, scale);
+  const width = Math.max(topWidth, bottomWidth) + pad * 2;
+  const height = pad * 2 + 7 * scale + gap + 7 * scale;
+
+  const buf = Buffer.alloc(width * height * 4, 255);
+  const black = { r: 0, g: 0, b: 0 };
+
+  drawText({
+    buf,
+    width,
+    x: Math.floor((width - topWidth) / 2),
+    y: pad,
+    text: top,
+    scale,
+    color: black,
+  });
+
+  drawText({
+    buf,
+    width,
+    x: Math.floor((width - bottomWidth) / 2),
+    y: pad + 7 * scale + gap,
+    text: bottom,
+    scale,
+    color: black,
+  });
+
+  const png = encodePngRgba(buf, width, height);
+  return png.toString("base64");
+}
+
+export function renderSolidColorPngBase64(color: { r: number; g: number; b: number }): string {
+  const width = 192;
+  const height = 192;
+  const buf = Buffer.alloc(width * height * 4, 255);
+  fillRect({
+    buf,
+    width,
+    height,
+    x: 0,
+    y: 0,
+    w: width,
+    h: height,
+    color,
+  });
+  const png = encodePngRgba(buf, width, height);
+  return png.toString("base64");
+}
+
+export function renderCatFacePngBase64(): string {
+  const width = 256;
+  const height = 288;
+  const buf = Buffer.alloc(width * height * 4, 255);
+  const outline = { r: 40, g: 40, b: 40 };
+  const innerEar = { r: 245, g: 182, b: 193 };
+  const nose = { r: 222, g: 102, b: 138 };
+  const whisker = { r: 30, g: 30, b: 30 };
+
+  fillTriangle({
+    buf,
+    width,
+    height,
+    a: { x: 62, y: 74 },
+    b: { x: 106, y: 12 },
+    c: { x: 134, y: 88 },
+    color: outline,
+  });
+  fillTriangle({
+    buf,
+    width,
+    height,
+    a: { x: 194, y: 74 },
+    b: { x: 150, y: 12 },
+    c: { x: 122, y: 88 },
+    color: outline,
+  });
+  fillTriangle({
+    buf,
+    width,
+    height,
+    a: { x: 80, y: 70 },
+    b: { x: 106, y: 34 },
+    c: { x: 122, y: 80 },
+    color: innerEar,
+  });
+  fillTriangle({
+    buf,
+    width,
+    height,
+    a: { x: 176, y: 70 },
+    b: { x: 150, y: 34 },
+    c: { x: 134, y: 80 },
+    color: innerEar,
+  });
+  fillEllipse({
+    buf,
+    width,
+    height,
+    cx: 128,
+    cy: 112,
+    rx: 78,
+    ry: 66,
+    color: outline,
+  });
+  fillEllipse({
+    buf,
+    width,
+    height,
+    cx: 98,
+    cy: 100,
+    rx: 9,
+    ry: 12,
+    color: { r: 255, g: 255, b: 255 },
+  });
+  fillEllipse({
+    buf,
+    width,
+    height,
+    cx: 158,
+    cy: 100,
+    rx: 9,
+    ry: 12,
+    color: { r: 255, g: 255, b: 255 },
+  });
+  fillEllipse({
+    buf,
+    width,
+    height,
+    cx: 128,
+    cy: 130,
+    rx: 22,
+    ry: 17,
+    color: { r: 255, g: 255, b: 255 },
+  });
+  fillTriangle({
+    buf,
+    width,
+    height,
+    a: { x: 128, y: 122 },
+    b: { x: 118, y: 136 },
+    c: { x: 138, y: 136 },
+    color: nose,
+  });
+  fillRect({ buf, width, height, x: 127, y: 136, w: 2, h: 15, color: whisker });
+  fillRect({ buf, width, height, x: 74, y: 134, w: 42, h: 2, color: whisker });
+  fillRect({ buf, width, height, x: 140, y: 134, w: 42, h: 2, color: whisker });
+  fillRect({ buf, width, height, x: 80, y: 146, w: 34, h: 2, color: whisker });
+  fillRect({ buf, width, height, x: 142, y: 146, w: 34, h: 2, color: whisker });
+  drawBlockCatLabel({
+    buf,
+    width,
+    height,
+    x: 21,
+    y: 190,
+    color: outline,
+  });
+
+  const png = encodePngRgba(buf, width, height);
+  return png.toString("base64");
+}