@syengup/friday-channel-next 0.1.15 → 0.1.16

package/dist/src/http/handlers/messages.d.ts

@@ -22,6 +22,22 @@ export type FridayReplyPayload = {
     interactive?: unknown;
     channelData?: unknown;
 };
+/** Map local / gateway paths to public `/friday-next/files/...` URLs where possible. */
+/**
+ * Canvas snapshots are captured so the *agent* can "see" the rendered canvas. OpenClaw core surfaces
+ * any image tool result as deliverable media on the assistant reply block, which for Friday Next would
+ * make the snapshot auto-appear as an attachment mid-stream — not what we want. Snapshot temp files are
+ * named `openclaw-canvas-snapshot-<uuid>.<ext>`, so we detect them by basename and drop them from the
+ * delivered payload (the assistant text is preserved). Agent-initiated media sends are unaffected —
+ * those flow through the `outbound` channel action, not the deliver block path.
+ */
+export declare function isCanvasSnapshotMediaPath(url: unknown): boolean;
+export declare function translateDeliverPayload(pl: FridayReplyPayload, kind: string, meta?: {
+    modelName?: string;
+    totalTokens?: number;
+    contextTokensUsed?: number;
+    contextWindowMax?: number;
+}): Record<string, unknown>;
 export interface FridayMessagePayload {
     deviceId: string;
     text: string;

package/dist/src/http/handlers/messages.js

@@ -84,7 +84,28 @@ function inferFridayNextMediaKind(params) {
     return "file";
 }
 /** Map local / gateway paths to public `/friday-next/files/...` URLs where possible. */
-function translateDeliverPayload(pl, kind, meta) {
+/**
+ * Canvas snapshots are captured so the *agent* can "see" the rendered canvas. OpenClaw core surfaces
+ * any image tool result as deliverable media on the assistant reply block, which for Friday Next would
+ * make the snapshot auto-appear as an attachment mid-stream — not what we want. Snapshot temp files are
+ * named `openclaw-canvas-snapshot-<uuid>.<ext>`, so we detect them by basename and drop them from the
+ * delivered payload (the assistant text is preserved). Agent-initiated media sends are unaffected —
+ * those flow through the `outbound` channel action, not the deliver block path.
+ */
+export function isCanvasSnapshotMediaPath(url) {
+    if (typeof url !== "string")
+        return false;
+    const base = url.split(/[/\\]/).pop() ?? url;
+    return /canvas-snapshot-/i.test(base);
+}
+export function translateDeliverPayload(pl, kind, meta) {
+    // Strip canvas-snapshot tool-result images before any media resolution (paths here are still the
+    // original `/tmp/openclaw/openclaw-canvas-snapshot-*.jpg` temp paths, not yet copied to friday files).
+    const filteredSingle = typeof pl.mediaUrl === "string" && !isCanvasSnapshotMediaPath(pl.mediaUrl) ? pl.mediaUrl : null;
+    const filteredArr = Array.isArray(pl.mediaUrls)
+        ? pl.mediaUrls.filter((u) => !isCanvasSnapshotMediaPath(u))
+        : pl.mediaUrls;
+    pl = { ...pl, mediaUrl: filteredSingle, mediaUrls: filteredArr };
     const raw = { ...pl };
     const originalUrls = collectReplyPayloadMediaUrls(pl);
     if (typeof pl.mediaUrl === "string" && pl.mediaUrl.trim()) {

package/install.js

@@ -238,14 +238,22 @@ if (configChanged) {
 
 // --------------- restart gateway ---------------
 
-log("Restarting OpenClaw gateway...");
+log("Restarting OpenClaw gateway... (this can take 20-30s)");
 try {
-  const out = execSync(`${openclawCmd} gateway restart`, { encoding: "utf8", stdio: "pipe", timeout: 15000 });
+  // A full gateway restart commonly takes 20s+ on a fresh boot; give it plenty of room
+  // so we don't kill it mid-restart and report a false failure.
+  const out = execSync(`${openclawCmd} gateway restart`, { encoding: "utf8", stdio: "pipe", timeout: 90000 });
   if (out.trim()) console.log(out.trim());
 } catch (e) {
   if (e.stdout?.trim()) console.log(e.stdout.trim());
   if (e.stderr?.trim()) console.error(e.stderr.trim());
-  warn("Gateway restart failed. Restart manually: openclaw gateway restart");
+  // ETIMEDOUT/SIGTERM here usually means the restart is simply slow, not broken —
+  // the verify step below will confirm whether the gateway actually came up.
+  if (e.code === "ETIMEDOUT" || e.signal === "SIGTERM") {
+    warn("Gateway restart is taking a while — will verify below.");
+  } else {
+    warn("Gateway restart failed. Restart manually: openclaw gateway restart");
+  }
 }
 
 // --------------- verify ---------------
@@ -270,7 +278,11 @@ const gatewayUrl = bindMode === "lan"
   ? `http://${getLanIp()}:${gatewayPort}`
   : `http://127.0.0.1:${gatewayPort}`;
 
-async function verifyGateway(url, token, retries = 6) {
+// Always verify against loopback: the gateway binds 0.0.0.0 so it's reachable here,
+// and this avoids false negatives from LAN/NAT routing of the advertised IP.
+const verifyUrl = `http://127.0.0.1:${gatewayPort}`;
+
+async function verifyGateway(url, token, retries = 30) {
   const http = await import("node:http");
   const { hostname, port } = new URL(url);
   for (let i = 1; i <= retries; i++) {
@@ -312,7 +324,7 @@ async function verifyGateway(url, token, retries = 6) {
 }
 
 log("Verifying gateway...");
-const verified = await verifyGateway(gatewayUrl, gatewayToken);
+const verified = await verifyGateway(verifyUrl, gatewayToken);
 
 // --------------- show connection info ---------------
 
@@ -372,4 +384,39 @@ if (ipType === "tailscale") {
 } else {
   log("This URL appears to be publicly accessible (" + ip + ").");
 }
+
+// On a cloud server the advertised IP is the internal/NAT address, which a phone
+// over the internet can't reach. Best-effort: detect the public IP so the user
+// has the address to actually connect with (and a reminder to open the port).
+if (ipType === "private" || ipType === "loopback") {
+  const publicIp = await detectPublicIp();
+  if (publicIp && publicIp !== ip) {
+    log("");
+    log(BOLD_YELLOW("Looks like a cloud server. For remote access use the PUBLIC address:"));
+    log(BOLD_YELLOW("检测到云服务器，远程连接请改用公网地址："));
+    log("Public URL:   " + BOLD_YELLOW(`http://${publicIp}:${gatewayPort}`));
+    log("(Open inbound TCP port " + gatewayPort + " in your firewall / security group first.)");
+    log("(需先在防火墙/安全组放行入站 TCP 端口 " + gatewayPort + "。)");
+  }
+}
 log("--------------------------------------------------");
+
+async function detectPublicIp() {
+  const endpoints = ["http://api.ipify.org", "http://ifconfig.me/ip", "http://icanhazip.com"];
+  const http = await import("node:http");
+  for (const url of endpoints) {
+    try {
+      const ipStr = await new Promise((resolve, reject) => {
+        const req = http.get(url, { timeout: 3000 }, (res) => {
+          let body = "";
+          res.on("data", (c) => body += c);
+          res.on("end", () => resolve(body.trim()));
+        });
+        req.on("error", reject);
+        req.on("timeout", () => { req.destroy(); reject(new Error("timeout")); });
+      });
+      if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ipStr)) return ipStr;
+    } catch { /* try next */ }
+  }
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/http/handlers/messages.canvas-snapshot.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { isCanvasSnapshotMediaPath, translateDeliverPayload } from "./messages.js";
+
+/**
+ * canvas.snapshot tool results are an agent-facing capture. OpenClaw core surfaces image tool
+ * results as deliverable media on the assistant reply block, which would otherwise auto-attach the
+ * snapshot to the user's stream. translateDeliverPayload must drop snapshot temp files (by basename)
+ * while preserving the assistant text and any non-snapshot media.
+ */
+describe("canvas snapshot media suppression", () => {
+  it("detects canvas snapshot temp paths by basename", () => {
+    expect(
+      isCanvasSnapshotMediaPath("/tmp/openclaw/openclaw-canvas-snapshot-d2e6aef2-0441.jpg"),
+    ).toBe(true);
+    expect(isCanvasSnapshotMediaPath("C:\\tmp\\openclaw-canvas-snapshot-abc.png")).toBe(true);
+    expect(isCanvasSnapshotMediaPath("/Users/me/Pictures/screenshot_latest.jpg")).toBe(false);
+    expect(isCanvasSnapshotMediaPath("/friday-next/files/uuid.jpg")).toBe(false);
+    expect(isCanvasSnapshotMediaPath(undefined)).toBe(false);
+  });
+
+  it("strips a snapshot mediaUrl from a block deliver payload, keeping the text", () => {
+    const out = translateDeliverPayload(
+      {
+        text: "🎉 通了!",
+        mediaUrl: "/tmp/openclaw/openclaw-canvas-snapshot-d2e6aef2-0441.jpg",
+      },
+      "block",
+    );
+    expect(out.text).toBe("🎉 通了!");
+    expect(out.mediaUrl).toBeNull();
+    // No media survived → no image mediaKind tagged onto the payload.
+    const channelData = out.channelData as { fridayNext?: { mediaKind?: string } } | undefined;
+    expect(channelData?.fridayNext?.mediaKind).toBeUndefined();
+  });
+
+  it("strips snapshot entries from mediaUrls but preserves non-snapshot media", () => {
+    const out = translateDeliverPayload(
+      {
+        text: "page rendered",
+        mediaUrls: [
+          "/tmp/openclaw/openclaw-canvas-snapshot-aaa.jpg",
+          "/Users/me/Pictures/real-image.png",
+        ],
+      },
+      "block",
+    );
+    const urls = out.mediaUrls as string[];
+    expect(urls).toHaveLength(1);
+    expect(urls.some((u) => u.includes("canvas-snapshot-"))).toBe(false);
+  });
+});

package/src/http/handlers/messages.ts

@@ -132,11 +132,34 @@ function inferFridayNextMediaKind(params: {
 }
 
 /** Map local / gateway paths to public `/friday-next/files/...` URLs where possible. */
-function translateDeliverPayload(
+/**
+ * Canvas snapshots are captured so the *agent* can "see" the rendered canvas. OpenClaw core surfaces
+ * any image tool result as deliverable media on the assistant reply block, which for Friday Next would
+ * make the snapshot auto-appear as an attachment mid-stream — not what we want. Snapshot temp files are
+ * named `openclaw-canvas-snapshot-<uuid>.<ext>`, so we detect them by basename and drop them from the
+ * delivered payload (the assistant text is preserved). Agent-initiated media sends are unaffected —
+ * those flow through the `outbound` channel action, not the deliver block path.
+ */
+export function isCanvasSnapshotMediaPath(url: unknown): boolean {
+  if (typeof url !== "string") return false;
+  const base = url.split(/[/\\]/).pop() ?? url;
+  return /canvas-snapshot-/i.test(base);
+}
+
+export function translateDeliverPayload(
   pl: FridayReplyPayload,
   kind: string,
   meta?: { modelName?: string; totalTokens?: number; contextTokensUsed?: number; contextWindowMax?: number },
 ): Record<string, unknown> {
+  // Strip canvas-snapshot tool-result images before any media resolution (paths here are still the
+  // original `/tmp/openclaw/openclaw-canvas-snapshot-*.jpg` temp paths, not yet copied to friday files).
+  const filteredSingle =
+    typeof pl.mediaUrl === "string" && !isCanvasSnapshotMediaPath(pl.mediaUrl) ? pl.mediaUrl : null;
+  const filteredArr = Array.isArray(pl.mediaUrls)
+    ? pl.mediaUrls.filter((u) => !isCanvasSnapshotMediaPath(u))
+    : pl.mediaUrls;
+  pl = { ...pl, mediaUrl: filteredSingle, mediaUrls: filteredArr };
+
   const raw = { ...pl } as Record<string, unknown>;
   const originalUrls = collectReplyPayloadMediaUrls(pl);
   if (typeof pl.mediaUrl === "string" && pl.mediaUrl.trim()) {