@openbrt/weclawbotctl 0.1.14 → 0.1.15

package/README.md

@@ -57,6 +57,12 @@ rejects stale or unrelated `idle` messages and keeps the visible thinking state.
 The bundled OpenClaw bridge publishes `thinking` before every curator job and
 `idle` after it finishes, so WeChat-origin official-mode work also gets a visible
 processing state without relying on the model to remember it.
+In OpenClaw itself, the plugin also registers hooks for direct Telegram/UI agent
+turns that mention WeClawBot or the physical screen. Those hooks show the
+thinking pet while the turn runs and clear it before the final answer. The
+installer enables `plugins.entries.weclawbot.hooks.allowConversationAccess`
+because OpenClaw blocks conversation hooks for third-party plugins unless the
+user explicitly grants that permission.
 
 To put text, status, diagrams, or images on the screen, render them into a
 pre-rendered `weclawbot.screen_document.v1` first. The firmware receives pixels;
@@ -70,6 +76,9 @@ weclawbotctl screen /path/to/screen-document.json
 only after the firmware reports `applied`; a firmware `rejected` status or a
 timeout is a failed delivery. Use `--no-wait` only for diagnostics where MQTT
 publish acknowledgement is enough.
+When the OpenClaw tool `weclawbot_publish_screen_document` is used from a
+Telegram/UI session, the plugin renders the exact mono1 pages back into PNG
+previews and attaches them to the same session when the channel supports files.
 
 To clear the current note, use the firmware clear command:
 
@@ -125,7 +134,7 @@ openclaw plugins enable weclawbot
 
 Restart the OpenClaw gateway or app after installation so it reloads plugin
 tools. The doctor checks the OpenClaw version, plugin installation, plugin
-diagnostics, and local gateway reachability. If a local WSS gateway uses a
+diagnostics, hook permission, and local gateway reachability. If a local WSS gateway uses a
 self-signed certificate, the doctor will suggest `NODE_EXTRA_CA_CERTS`. If the
 certificate lacks `localhost` or `127.0.0.1` SANs, fix the gateway certificate
 or use a certificate trusted by Node. The package does not rewrite other

package/bin/weclawbotctl.mjs

@@ -361,6 +361,13 @@ async function commandOpenClawInstall(values) {
   if (options.force) installArgs.push("--force");
   await runRequired(openclaw, installArgs);
   await runRequired(openclaw, ["plugins", "enable", "weclawbot"]);
+  await runRequired(openclaw, [
+    "config",
+    "set",
+    "plugins.entries.weclawbot.hooks.allowConversationAccess",
+    "true",
+    "--strict-json",
+  ]);
   console.log("OpenClaw plugin installed and enabled. Restart the OpenClaw gateway or app so it reloads plugins.");
   if (options.doctor) {
     await commandOpenClawDoctor(["--bin", openclaw, "--gateway=false"]);
@@ -402,6 +409,22 @@ async function commandOpenClawDoctor(values) {
     hint: weclawbotIssue ? "Upgrade and reinstall: weclawbotctl openclaw install" : "",
   });
 
+  const hooksAccess = await runCaptured(openclaw, [
+    "config",
+    "get",
+    "plugins.entries.weclawbot.hooks.allowConversationAccess",
+    "--json",
+  ], { timeoutMs });
+  const hooksEnabled = hooksAccess.code === 0 && /^\s*true\s*$/iu.test(hooksAccess.stdout);
+  checks.push({
+    name: "openclaw_weclawbot_hooks",
+    ok: hooksEnabled,
+    detail: hooksEnabled
+      ? "conversation hooks enabled for automatic thinking state"
+      : compactText(hooksAccess.stderr || hooksAccess.stdout || "hooks.allowConversationAccess is not enabled"),
+    hint: hooksEnabled ? "" : "Run: openclaw config set plugins.entries.weclawbot.hooks.allowConversationAccess true --strict-json",
+  });
+
   if (options.gateway) {
     const gatewayEnv = { ...process.env };
     const defaultCert = path.join(os.homedir(), ".openclaw", "gateway", "tls", "gateway-cert.pem");

package/index.mjs

@@ -9,16 +9,23 @@ import { defineToolPlugin } from "openclaw/plugin-sdk/tool-plugin";
 import { validateActivity } from "./lib/activity.mjs";
 import { validateScreenDocument } from "./lib/direct-control.mjs";
 import { normalizeCredentials, publishControl, publishControlAndWaitStatus, testConnection } from "./lib/mqtt-control.mjs";
+import { previewSummary, renderScreenDocumentPreviewPages } from "./lib/screen-preview.mjs";
 
 const DEFAULT_CREDENTIALS_PATH = path.join(os.homedir(), ".config", "weclawbot", "agent-mqtt.json");
+const SCREEN_PROMPT_PATTERN = /weclawbot|weclaw|微笺|桌宠|墨水屏|电子墨水|屏上|上屏|发到屏|推到屏|放到屏|显示到屏|发送到屏|清屏|清理屏幕|屏幕/iu;
+const activeRunActivities = new Map();
 
 // The long-running curator bridge remains a separate service. These tools keep
 // the local agent path explicit: validate first, then publish only with the
 // user's paired MQTT credential.
-export default defineToolPlugin({
+const pluginEntry = defineToolPlugin({
   id: "weclawbot",
   name: "WeClawBot",
   description: "WeClawBot screen-curation skill pack and direct MQTT control tools.",
+  configSchema: Type.Object({
+    auto_activity: Type.Optional(Type.Boolean()),
+    auto_preview: Type.Optional(Type.Boolean()),
+  }, { additionalProperties: false }),
   tools: (tool) => [
     tool({
       name: "weclawbot_status",
@@ -127,6 +134,8 @@ export default defineToolPlugin({
           document: outbound,
         };
         const credentials = await requireCredentials(credentials_path);
+        const previewPages = renderScreenDocumentPreviewPages(outbound);
+        const preview = previewSummary(previewPages);
         if (wait_status !== false) {
           const delivery = await publishControlAndWaitStatus(credentials, control, {
             expectedDetail: outbound.id,
@@ -142,6 +151,7 @@ export default defineToolPlugin({
             force_replace: outbound.force_replace === true,
             warnings: validation.warnings,
             layout_guidance: validation.layout_guidance,
+            preview,
             status: delivery.status,
           };
         }
@@ -155,6 +165,7 @@ export default defineToolPlugin({
           force_replace: outbound.force_replace === true,
           warnings: validation.warnings,
           layout_guidance: validation.layout_guidance,
+          preview,
         };
       },
     }),
@@ -201,6 +212,218 @@ export default defineToolPlugin({
   ],
 });
 
+const registerTools = pluginEntry.register;
+pluginEntry.register = (api) => {
+  registerTools(api);
+  registerOpenClawHooks(api);
+};
+
+export default pluginEntry;
+
+function registerOpenClawHooks(api) {
+  if (!api || typeof api.on !== "function") return;
+  api.on("before_agent_run", async (event, ctx) => {
+    await startHookActivity(api, event, ctx);
+    return { outcome: "pass" };
+  }, { timeoutMs: 5_000 });
+  api.on("before_agent_finalize", async (event, ctx) => {
+    await finishHookActivity(api, event, ctx);
+    return { action: "continue" };
+  }, { timeoutMs: 5_000 });
+  api.on("agent_end", async (event, ctx) => {
+    await finishHookActivity(api, event, ctx);
+  }, { timeoutMs: 5_000 });
+  api.on("after_tool_call", async (event, ctx) => {
+    await attachScreenPreview(api, event, ctx);
+  }, { timeoutMs: 10_000 });
+}
+
+async function startHookActivity(api, event, ctx) {
+  try {
+    if (api.pluginConfig?.auto_activity === false) return;
+    if (!shouldAutoActivity(event, ctx)) return;
+    const key = hookActivityKey(event, ctx);
+    if (!key || activeRunActivities.has(key)) return;
+    const correlationId = `openclaw-${sanitizeId(ctx?.runId || key).slice(0, 72)}`;
+    await publishControl(await requireCredentials(), {
+      schema: "weclawbot.control.v1",
+      id: `activity_${crypto.randomUUID()}`,
+      kind: "activity",
+      activity: {
+        schema: "weclawbot.activity.v1",
+        state: "thinking",
+        correlation_id: correlationId,
+        ttl_seconds: 120,
+      },
+    });
+    activeRunActivities.set(key, { correlationId, startedAt: Date.now() });
+    api.logger?.info?.(`weclawbot activity thinking sent for ${key}`);
+  } catch (error) {
+    api.logger?.debug?.(`weclawbot activity hook skipped: ${errorMessage(error)}`);
+  }
+}
+
+async function finishHookActivity(api, event, ctx) {
+  try {
+    const key = hookActivityKey(event, ctx);
+    if (!key) return;
+    const active = activeRunActivities.get(key);
+    if (!active) return;
+    activeRunActivities.delete(key);
+    await publishControl(await requireCredentials(), {
+      schema: "weclawbot.control.v1",
+      id: `activity_${crypto.randomUUID()}`,
+      kind: "activity",
+      activity: {
+        schema: "weclawbot.activity.v1",
+        state: "idle",
+        correlation_id: active.correlationId,
+      },
+    });
+    api.logger?.info?.(`weclawbot activity idle sent for ${key}`);
+  } catch (error) {
+    api.logger?.debug?.(`weclawbot activity idle hook skipped: ${errorMessage(error)}`);
+  }
+}
+
+async function attachScreenPreview(api, event, ctx) {
+  try {
+    if (api.pluginConfig?.auto_preview === false) return;
+    if (event?.error) return;
+    if (!ctx?.sessionKey || typeof api.session?.workflow?.sendSessionAttachment !== "function") return;
+    let document = null;
+    let source = "tool";
+    if (event?.toolName === "weclawbot_publish_screen_document") {
+      document = cloneObject(event.params?.document);
+      if (event.params?.force_replace) {
+        document.force_replace = true;
+        document.base_revision = "*";
+      }
+    } else if (isExecTool(event?.toolName)) {
+      const file = extractScreenDocumentPathFromExecParams(event.params);
+      if (!file) return;
+      document = JSON.parse(await fs.readFile(file, "utf8"));
+      source = "cli";
+    } else {
+      return;
+    }
+    await attachPreviewForDocument(api, document, ctx, source);
+  } catch (error) {
+    api.logger?.debug?.(`weclawbot preview attachment skipped: ${errorMessage(error)}`);
+  }
+}
+
+async function attachPreviewForDocument(api, document, ctx, source) {
+    const validation = validateScreenDocument(document, {
+      agent_transport: { available: true, screen_document_available: true },
+    });
+    if (!validation.ok) return;
+    const previewPages = renderScreenDocumentPreviewPages(document);
+    if (previewPages.length === 0) return;
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "weclawbot-preview-"));
+    const files = [];
+    for (const page of previewPages) {
+      const file = path.join(dir, `${safeFilename(document.id || "screen")}-p${page.index + 1}.png`);
+      await fs.writeFile(file, page.png);
+      files.push({ path: file });
+    }
+    const pageLabel = `${previewPages.length} page${previewPages.length === 1 ? "" : "s"}`;
+    await api.session.workflow.sendSessionAttachment({
+      sessionKey: ctx.sessionKey,
+      files,
+      text: `WeClawBot screen preview: ${document.id || "screen"} (${pageLabel}, ${source})`,
+      maxBytes: 2_000_000,
+    });
+    scheduleRemove(dir);
+}
+
+function shouldAutoActivity(event, ctx) {
+  if (String(ctx?.trigger || "").includes("curator")) return false;
+  const prompt = String(event?.prompt || "");
+  if (prompt.includes("WECLAWBOT_CURATOR_EVENT")) return false;
+  return SCREEN_PROMPT_PATTERN.test(prompt);
+}
+
+function hookActivityKey(event, ctx) {
+  if (ctx?.runId || event?.runId) return `run:${ctx?.runId || event?.runId}`;
+  if (ctx?.sessionKey) return `session:${ctx.sessionKey}`;
+  return "";
+}
+
+function isExecTool(name) {
+  return /(^|[_-])(exec|shell|command)($|[_-])/iu.test(String(name || ""));
+}
+
+function extractScreenDocumentPathFromExecParams(params) {
+  const command = collectCommandStrings(params).join("\n");
+  if (!/weclawbotctl\s+screen\b/u.test(command)) return "";
+  for (const line of command.split(/\r?\n/u)) {
+    const match = line.match(/(?:^|\s)(?:[^\s;&|]*\/)?weclawbotctl\s+screen\b([^;&|\n]*)/u);
+    if (!match) continue;
+    const tokens = shellSplit(match[1] || "");
+    const candidates = [];
+    for (let index = 0; index < tokens.length; index += 1) {
+      const token = tokens[index];
+      if (!token) continue;
+      if (token.startsWith("--")) {
+        const key = token.split("=", 1)[0];
+        if (!token.includes("=") && new Set(["--credentials", "--timeout"]).has(key)) index += 1;
+        continue;
+      }
+      candidates.push(token);
+    }
+    const picked = candidates.findLast((token) => token.endsWith(".json")) || candidates.at(-1) || "";
+    if (picked) return expandPathWithBase(picked, params?.cwd || params?.workdir || process.cwd());
+  }
+  return "";
+}
+
+function collectCommandStrings(value, depth = 0) {
+  if (depth > 3 || value == null) return [];
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) return value.flatMap((item) => collectCommandStrings(item, depth + 1));
+  if (typeof value !== "object") return [];
+  const wanted = ["cmd", "command", "script", "input", "args", "argv"];
+  return wanted.flatMap((key) => collectCommandStrings(value[key], depth + 1));
+}
+
+function shellSplit(value) {
+  const tokens = [];
+  let token = "";
+  let quote = "";
+  let escaped = false;
+  for (const ch of String(value || "")) {
+    if (escaped) {
+      token += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (ch === quote) quote = "";
+      else token += ch;
+      continue;
+    }
+    if (ch === "'" || ch === "\"") {
+      quote = ch;
+      continue;
+    }
+    if (/\s/u.test(ch)) {
+      if (token) {
+        tokens.push(token);
+        token = "";
+      }
+      continue;
+    }
+    token += ch;
+  }
+  if (token) tokens.push(token);
+  return tokens;
+}
+
 async function requireCredentials(credentialsPath) {
   const file = expandPath(credentialsPath || DEFAULT_CREDENTIALS_PATH);
   const payload = await readCredentials(file);
@@ -222,6 +445,11 @@ function expandPath(value) {
   return raw.startsWith("~/") ? path.join(os.homedir(), raw.slice(2)) : raw;
 }
 
+function expandPathWithBase(value, base) {
+  const expanded = expandPath(value);
+  return path.isAbsolute(expanded) ? expanded : path.resolve(String(base || process.cwd()), expanded);
+}
+
 function cloneObject(value) {
   if (!value || typeof value !== "object") throw new Error("document must be an object");
   return JSON.parse(JSON.stringify(value));
@@ -239,6 +467,25 @@ function clearStatusDetail(target) {
   return target === "idle_photo" ? "clear_idle_photo" : "clear_note";
 }
 
+function sanitizeId(value) {
+  return String(value || crypto.randomUUID()).replace(/[^a-zA-Z0-9_.-]/gu, "_");
+}
+
+function safeFilename(value) {
+  return sanitizeId(value).slice(0, 80) || "screen";
+}
+
+function scheduleRemove(dir) {
+  const timer = setTimeout(() => {
+    fs.rm(dir, { recursive: true, force: true }).catch(() => {});
+  }, 60_000);
+  timer.unref?.();
+}
+
+function errorMessage(error) {
+  return String(error instanceof Error ? error.message : error).replace(/\s+/gu, " ").trim().slice(0, 240);
+}
+
 function maskedMqtt(config, topics) {
   return {
     url: config.url,

package/lib/screen-preview.mjs

@@ -0,0 +1,125 @@
+import crypto from "node:crypto";
+import { deflateSync } from "node:zlib";
+
+const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+
+export function renderScreenDocumentPreviewPages(document, options = {}) {
+  const pages = Array.isArray(document?.pages) ? document.pages : [];
+  const scale = clampInteger(options.scale ?? 2, 1, 4);
+  return pages.map((page, index) => {
+    const png = renderMonoPagePreview(page, { scale });
+    return {
+      index,
+      width: Number(page.width) * scale,
+      height: Number(page.height) * scale,
+      scale,
+      png,
+      bytes: png.length,
+      sha256: crypto.createHash("sha256").update(png).digest("hex"),
+    };
+  });
+}
+
+export function previewSummary(previewPages) {
+  return {
+    available: previewPages.length > 0,
+    pages: previewPages.map((page) => ({
+      index: page.index,
+      width: page.width,
+      height: page.height,
+      scale: page.scale,
+      bytes: page.bytes,
+      sha256: page.sha256,
+      mime_type: "image/png",
+    })),
+  };
+}
+
+function renderMonoPagePreview(page, options = {}) {
+  const width = Number(page?.width);
+  const height = Number(page?.height);
+  const stride = Number(page?.stride);
+  const scale = clampInteger(options.scale ?? 2, 1, 4);
+  if (!Number.isInteger(width) || width < 1 || !Number.isInteger(height) || height < 1) {
+    throw new Error("preview page width/height must be positive integers");
+  }
+  if (!Number.isInteger(stride) || stride < Math.ceil(width / 8)) {
+    throw new Error("preview page stride is invalid");
+  }
+  const packed = Buffer.from(String(page?.data_b64 || ""), "base64");
+  if (packed.length < stride * height) {
+    throw new Error("preview page data is shorter than stride * height");
+  }
+
+  const outWidth = width * scale;
+  const outHeight = height * scale;
+  const gray = Buffer.alloc(outWidth * outHeight, 0xff);
+  for (let y = 0; y < height; y += 1) {
+    const row = y * stride;
+    for (let x = 0; x < width; x += 1) {
+      const black = (packed[row + (x >> 3)] & (0x80 >> (x & 7))) !== 0;
+      if (!black) continue;
+      for (let dy = 0; dy < scale; dy += 1) {
+        const outRow = (y * scale + dy) * outWidth;
+        for (let dx = 0; dx < scale; dx += 1) {
+          gray[outRow + x * scale + dx] = 0;
+        }
+      }
+    }
+  }
+  return encodeGrayscalePng(gray, outWidth, outHeight);
+}
+
+function encodeGrayscalePng(gray, width, height) {
+  const raw = Buffer.alloc((width + 1) * height);
+  for (let y = 0; y < height; y += 1) {
+    const row = y * (width + 1);
+    raw[row] = 0;
+    gray.copy(raw, row + 1, y * width, (y + 1) * width);
+  }
+  const ihdr = Buffer.alloc(13);
+  ihdr.writeUInt32BE(width, 0);
+  ihdr.writeUInt32BE(height, 4);
+  ihdr[8] = 8;
+  ihdr[9] = 0;
+  ihdr[10] = 0;
+  ihdr[11] = 0;
+  ihdr[12] = 0;
+  return Buffer.concat([
+    PNG_SIGNATURE,
+    pngChunk("IHDR", ihdr),
+    pngChunk("IDAT", deflateSync(raw)),
+    pngChunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+function pngChunk(type, data) {
+  const typeBuf = Buffer.from(type, "ascii");
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length, 0);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0);
+  return Buffer.concat([len, typeBuf, data, crc]);
+}
+
+const crcTable = new Uint32Array(256).map((_, index) => {
+  let c = index;
+  for (let bit = 0; bit < 8; bit += 1) {
+    c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+  }
+  return c >>> 0;
+});
+
+function crc32(buffer) {
+  let crc = 0xffffffff;
+  for (const byte of buffer) {
+    crc = crcTable[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+  }
+  return (crc ^ 0xffffffff) >>> 0;
+}
+
+function clampInteger(value, min, max) {
+  const parsed = Number.parseInt(String(value), 10);
+  if (!Number.isFinite(parsed)) return min;
+  return Math.max(min, Math.min(max, parsed));
+}

package/openclaw.plugin.json

@@ -21,6 +21,15 @@
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
-    "properties": {}
+    "properties": {
+      "auto_activity": {
+        "type": "boolean",
+        "description": "Automatically show the WeClawBot thinking pet during OpenClaw turns that mention the physical screen."
+      },
+      "auto_preview": {
+        "type": "boolean",
+        "description": "Automatically attach PNG previews after publishing a screen document from an OpenClaw session."
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openbrt/weclawbotctl",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "WeClawBot pairing and screen-control CLI for local AI agents.",
   "type": "module",
   "license": "MIT",
@@ -43,10 +43,11 @@
     "./activity": "./lib/activity.mjs",
     "./direct-control": "./lib/direct-control.mjs",
     "./mqtt-control": "./lib/mqtt-control.mjs",
+    "./screen-preview": "./lib/screen-preview.mjs",
     "./package.json": "./package.json"
   },
   "scripts": {
-    "check": "node --check index.mjs && node --check bin/weclawbot-openclaw-bridge.mjs && node --check bin/weclawbot-byoa-bind.mjs && node --check bin/weclawbotctl.mjs && node --test test/direct-control.test.mjs test/activity.test.mjs"
+    "check": "node --check index.mjs && node --check bin/weclawbot-openclaw-bridge.mjs && node --check bin/weclawbot-byoa-bind.mjs && node --check bin/weclawbotctl.mjs && node --test test/direct-control.test.mjs test/activity.test.mjs test/screen-preview.test.mjs"
   },
   "dependencies": {
     "mqtt": "^5.10.4",

package/skills/weclawbot-curator/SKILL.md

@@ -53,11 +53,13 @@ publish it with:
 weclawbotctl screen /path/to/screen-document.json
 ```
 
-or call `weclawbot_publish_screen_document` with the same document. Do not use
-OpenClaw Canvas for requests that mention WeClawBot, the physical screen, or
-“屏上”; Canvas is an OpenClaw UI surface, not the ESP32 e-paper display. Do
-not send raw text to firmware. The agent owns text layout, font choice, image
-rasterization, and page splitting; the device consumes pixels.
+or call `weclawbot_publish_screen_document` with the same document. Inside
+OpenClaw Telegram/UI sessions, prefer `weclawbot_publish_screen_document`: after
+publish it can attach PNG previews of the exact mono1 pages back to the
+conversation. Do not use OpenClaw Canvas for requests that mention WeClawBot, the
+physical screen, or “屏上”; Canvas is an OpenClaw UI surface, not the ESP32
+e-paper display. Do not send raw text to firmware. The agent owns text layout,
+font choice, image rasterization, and page splitting; the device consumes pixels.
 
 For clear requests such as “清屏”, “清理屏幕”, “clear screen”, or removing the
 current note, call `weclawbot_clear_screen` or run `weclawbotctl clear`. Never

package/test/screen-preview.test.mjs

@@ -0,0 +1,35 @@
+import assert from "node:assert/strict";
+
+import { renderScreenDocumentPreviewPages, previewSummary } from "../lib/screen-preview.mjs";
+
+const width = 16;
+const height = 8;
+const stride = 2;
+const bytes = Buffer.alloc(stride * height, 0x00);
+for (let i = 0; i < Math.min(width, height); i += 1) {
+  bytes[i * stride + (i >> 3)] |= 0x80 >> (i & 7);
+}
+
+const preview = renderScreenDocumentPreviewPages({
+  schema: "weclawbot.screen_document.v1",
+  pages: [{
+    format: "mono1",
+    width,
+    height,
+    stride,
+    data_b64: bytes.toString("base64"),
+  }],
+}, { scale: 2 });
+
+assert.equal(preview.length, 1);
+assert.equal(preview[0].width, width * 2);
+assert.equal(preview[0].height, height * 2);
+assert.equal(preview[0].png.subarray(0, 8).toString("hex"), "89504e470d0a1a0a");
+assert.ok(preview[0].bytes > 50);
+assert.match(preview[0].sha256, /^[0-9a-f]{64}$/u);
+
+const summary = previewSummary(preview);
+assert.equal(summary.available, true);
+assert.equal(summary.pages[0].mime_type, "image/png");
+
+console.log("screen-preview renderer: ok");

package/workspace/AGENTS.md

@@ -42,6 +42,11 @@ success only after it exits with success. If the user explicitly asks to
 replace whatever is currently shown, use `--force`; otherwise use the current
 screen revision in `base_revision`.
 
+When running inside OpenClaw with the WeClawBot plugin tools available, prefer
+`weclawbot_publish_screen_document` over shelling out to `weclawbotctl screen`;
+the tool can attach PNG previews of the exact pages back to the chat/UI after a
+successful publish.
+
 The firmware receives pixels. Do not send raw text to firmware, and do not
 answer that direct delivery is unavailable before checking the local
 `weclawbotctl` profile.