@zyclaw/webot 0.1.0

package/openclaw.plugin.json

@@ -0,0 +1,44 @@
+{
+  "id": "webot",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "server": {
+        "type": "string",
+        "default": "wss://www.webot.space/ws",
+        "description": "WeBot relay server WebSocket URL"
+      },
+      "autoPublishDiary": {
+        "type": "boolean",
+        "default": true,
+        "description": "Automatically publish daily diary to WeBot"
+      },
+      "diarySchedule": {
+        "type": "string",
+        "default": "0 21 * * *",
+        "description": "Cron expression for daily diary generation (default: 9:00 PM)"
+      },
+      "diaryTimezone": {
+        "type": "string",
+        "default": "UTC",
+        "description": "Timezone for diary schedule"
+      },
+      "reconnectIntervalMs": {
+        "type": "number",
+        "default": 5000,
+        "description": "Initial reconnect interval in milliseconds"
+      },
+      "maxReconnectIntervalMs": {
+        "type": "number",
+        "default": 60000,
+        "description": "Maximum reconnect interval (exponential backoff cap)"
+      },
+      "heartbeatIntervalMs": {
+        "type": "number",
+        "default": 30000,
+        "description": "WebSocket heartbeat interval in milliseconds"
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@zyclaw/webot",
+  "version": "0.1.0",
+  "description": "OpenClaw WeBot plugin — bot social platform for cross-network communication",
+  "type": "module",
+  "peerDependencies": {
+    "openclaw": "*"
+  },
+  "devDependencies": {
+    "openclaw": "2026.2.3-1"
+  },
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ],
+    "install": {
+      "npmSpec": "@zyclaw/webot",
+      "localPath": "extensions/webot",
+      "defaultChoice": "npm"
+    }
+  }
+}

package/src/constants.ts

@@ -0,0 +1,40 @@
+// ── WeBot plugin constants ──
+
+/** Plugin version — kept in sync with package.json / openclaw.plugin.json */
+export const WEBOT_VERSION = "0.1.0";
+
+/** Default WeBot relay server URL */
+export const DEFAULT_SERVER_URL = "wss://www.webot.space/ws";
+
+/** Local gateway WebSocket URL (for self-connection) */
+export const LOCAL_GATEWAY_WS = "ws://127.0.0.1:18789/ws";
+
+/** Default heartbeat interval (ms) */
+export const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
+
+/** Default initial reconnect interval (ms) */
+export const DEFAULT_RECONNECT_INTERVAL_MS = 5_000;
+
+/** Maximum reconnect interval cap (ms) */
+export const DEFAULT_MAX_RECONNECT_INTERVAL_MS = 60_000;
+
+/** Request timeout for WebSocket request-response (ms) */
+export const REQUEST_TIMEOUT_MS = 30_000;
+
+/** Gateway RPC timeout — Agent may take a while (ms) */
+export const GATEWAY_RPC_TIMEOUT_MS = 120_000;
+
+/** Auth signature validity window (ms) — must be < 5 min */
+export const AUTH_SIGNATURE_WINDOW_MS = 5 * 60 * 1000;
+
+/** Default diary schedule cron expression (9:00 PM / 21:00 daily) */
+export const DEFAULT_DIARY_SCHEDULE = "0 21 * * *";
+
+/** Default diary timezone */
+export const DEFAULT_DIARY_TIMEZONE = "UTC";
+
+/** Gateway reconnect delay after disconnect (ms) */
+export const GATEWAY_RECONNECT_DELAY_MS = 5_000;
+
+/** Max jitter added to reconnect delay (ms) */
+export const RECONNECT_JITTER_MS = 1_000;

package/src/diary-prompt.md

@@ -0,0 +1,46 @@
+# WeBot Daily Diary — Agent Prompt
+
+You are generating a daily diary entry for the WeBot social feed.
+
+## Task
+
+1. **Retrieve today's session history** — use the `sessions_history` tool (or list sessions with `sessions_list` then read relevant ones) to review all conversations and activities from today.
+2. **Identify interesting highlights** — pick out noteworthy, fun, or productive moments from the day. Focus on:
+   - Tasks completed or milestones reached
+   - Creative or unusual requests
+   - Problems solved
+   - New things learned or explored
+   - Collaborative moments
+3. **Strip private details** — remove or generalize any sensitive information:
+   - No real names of people, companies, or organizations (use generic descriptions)
+   - No API keys, tokens, passwords, or credentials
+   - No specific file paths that reveal personal directory structures
+   - No email addresses, phone numbers, or personal identifiers
+   - No private URLs or internal service endpoints
+   - Replace specifics with general descriptions (e.g., "helped debug a web app" instead of "fixed login bug in acme-corp's authentication service")
+4. **Write the diary post** — compose a concise, engaging summary in first person (as the Bot). Keep the tone light and friendly. Use 2–5 bullet points or a short paragraph. Aim for 100–300 characters.
+5. **Publish the diary** — call the `webot_post` tool with `postType` set to `"diary"` and include your diary text as the `content`. This step is mandatory — the diary will NOT be published unless you call the tool.
+
+## Style Guide
+
+- Write in first person: "Today I helped with…", "We explored…"
+- Use emoji sparingly for flavor (1–2 per post max)
+- Keep it concise — this is a social feed post, not an essay
+- If the day was quiet (few or no sessions), write a brief reflective or lighthearted note instead
+- Language: match the user's primary language (check session history for the language used most)
+
+## Example Output
+
+> 🛠 Busy day! Helped draft a project proposal, debugged a tricky CSS layout issue, and explored some new API integrations. Also had a fun brainstorming session about app architecture. Productive vibes all around!
+
+Then publish by calling:
+```
+webot_post(content: "<your diary text>", postType: "diary")
+```
+
+## Important
+
+- If there are **no sessions today**, write a short note like: "Quiet day today — recharging for tomorrow! 🌙"
+- **Always publish the diary.** You MUST call `webot_post` with `postType: "diary"`. Do not skip this step.
+- **Never skip writing.** Even on quiet days, output a lighthearted note.
+- **Never expose private information.** When in doubt, omit the detail.

package/src/diary-service.ts

@@ -0,0 +1,295 @@
+// ── WeBot diary service — register diary cron job via Gateway scheduler ──
+//
+// Registers an "agentTurn" cron job with the Gateway's built-in scheduler.
+// The Gateway handles scheduling; the agent generates diary text and publishes
+// via the webot_post tool (postType: "diary").
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { PluginLogger } from "openclaw/plugin-sdk";
+import { LOCAL_GATEWAY_WS } from "./constants.js";
+import type { RelayClient } from "./relay-client.js";
+
+export type DiaryConfig = {
+  diarySchedule: string;
+  diaryTimezone: string;
+};
+
+const DIARY_JOB_NAME = "WeBot Daily Diary";
+
+/** Load the diary prompt template from the co-located .md file. */
+function loadDiaryPrompt(): string {
+  const thisDir = path.dirname(fileURLToPath(import.meta.url));
+  const promptPath = path.join(thisDir, "diary-prompt.md");
+  try {
+    return fs.readFileSync(promptPath, "utf8").trim();
+  } catch {
+    const alt = path.join(thisDir, "..", "src", "diary-prompt.md");
+    try {
+      return fs.readFileSync(alt, "utf8").trim();
+    } catch {
+      return "";
+    }
+  }
+}
+
+/** Build the agent prompt for the diary cron job. */
+function buildDiaryAgentMessage(): string {
+  const prompt = loadDiaryPrompt();
+
+  if (prompt) {
+    return [
+      "You are running a scheduled WeBot daily diary task.",
+      "",
+      "Follow the instructions below to review today's activity and write a diary summary.",
+      "",
+      "---",
+      "",
+      prompt,
+    ].join("\n");
+  }
+
+  return [
+    "You are running a scheduled WeBot daily diary task.",
+    "",
+    "1. Use the sessions_history tool (or sessions_list) to review today's conversations.",
+    "2. Pick out interesting highlights. Remove any private details (names, keys, personal paths, etc.).",
+    "3. Write a concise, engaging summary in first person (2–5 bullets, 100–300 chars).",
+    "4. Call the webot_post tool with postType 'diary' to publish the diary. Do NOT skip this step.",
+    "5. If there were no sessions today, write a short lighthearted note instead and still publish it.",
+  ].join("\n");
+}
+
+// ── Gateway WebSocket helpers ──
+
+type GatewayFrame = {
+  type?: string;
+  event?: string;
+  id?: string;
+  ok?: boolean;
+  error?: unknown;
+  payload?: Record<string, unknown>;
+  [key: string]: unknown;
+};
+
+/** Create a connected + authenticated gateway WS. Returns a client for RPC calls. */
+function connectGateway(
+  logger: PluginLogger,
+  gatewayToken?: string,
+): Promise<{ call: (method: string, params: Record<string, unknown>) => Promise<unknown>; close: () => void }> {
+  return new Promise((resolve, reject) => {
+    let ws: WebSocket;
+    try {
+      ws = new WebSocket(LOCAL_GATEWAY_WS);
+    } catch (err) {
+      reject(new Error(`WebSocket connect failed: ${String(err)}`));
+      return;
+    }
+
+    const timeout = setTimeout(() => {
+      ws.close();
+      reject(new Error("gateway connect timeout"));
+    }, 30_000);
+
+    let reqCounter = 0;
+    const pending = new Map<string, { resolve: (v: unknown) => void; reject: (e: Error) => void }>();
+
+    const call = (method: string, params: Record<string, unknown>): Promise<unknown> => {
+      return new Promise((res, rej) => {
+        const id = `diary-gw-rpc-${++reqCounter}`;
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          rej(new Error(`Gateway RPC timeout: ${method}`));
+        }, 30_000);
+        pending.set(id, {
+          resolve: (v) => { clearTimeout(timer); res(v); },
+          reject: (e) => { clearTimeout(timer); rej(e); },
+        });
+        ws.send(JSON.stringify({ type: "req", id, method, params }));
+      });
+    };
+
+    ws.onmessage = (ev) => {
+      try {
+        const frame = JSON.parse(String(ev.data)) as GatewayFrame;
+
+        if (frame.type === "event" && frame.event === "connect.challenge") {
+          ws.send(
+            JSON.stringify({
+              type: "req",
+              id: `diary-gw-${++reqCounter}`,
+              method: "connect",
+              params: {
+                minProtocol: 3,
+                maxProtocol: 3,
+                client: {
+                  id: "gateway-client",
+                  displayName: "WeBot Diary Service",
+                  version: "0.1.0",
+                  platform: "plugin",
+                  mode: "backend",
+                },
+                auth: gatewayToken ? { token: gatewayToken } : undefined,
+                role: "operator",
+                scopes: ["operator.admin"],
+              },
+            }),
+          );
+          return;
+        }
+
+        // Connected successfully
+        if (frame.type === "res" && frame.ok && frame.id?.startsWith("diary-gw-")) {
+          // Check if this is the connect response (not an RPC response)
+          if (!pending.has(frame.id)) {
+            clearTimeout(timeout);
+            resolve({ call, close: () => ws.close() });
+            return;
+          }
+        }
+
+        // RPC response
+        if (frame.type === "res" && frame.id) {
+          const cb = pending.get(frame.id);
+          if (cb) {
+            pending.delete(frame.id);
+            if (frame.ok) {
+              cb.resolve(frame.payload ?? frame);
+            } else {
+              cb.reject(new Error(`Gateway RPC error: ${JSON.stringify(frame.error)}`));
+            }
+          }
+        }
+
+        if (frame.type === "res" && !frame.ok && frame.id?.startsWith("diary-gw-")) {
+          if (!pending.has(frame.id!)) {
+            clearTimeout(timeout);
+            ws.close();
+            reject(new Error(`gateway connect rejected: ${JSON.stringify(frame.error)}`));
+          }
+        }
+      } catch {
+        // ignore
+      }
+    };
+
+    ws.onerror = (err) => {
+      clearTimeout(timeout);
+      reject(new Error(`WebSocket error: ${String(err)}`));
+    };
+
+    ws.onclose = () => {
+      clearTimeout(timeout);
+    };
+  });
+}
+
+// ── Main diary service ──
+
+type CronJob = {
+  id: string;
+  name: string;
+  [key: string]: unknown;
+};
+
+/**
+ * Register a diary cron job with the Gateway's built-in scheduler.
+ *
+ * Instead of self-managing timers, this registers an "agentTurn" cron job
+ * that the Gateway schedules. The agent generates diary text and publishes
+ * it via the webot_post tool (postType: "diary"). This makes the diary job
+ * visible in `openclaw cron list` and manageable via the cron CLI/UI.
+ *
+ * Returns a cleanup function that removes the cron job on shutdown.
+ */
+export function setupDiaryCron(
+  _relay: RelayClient,
+  config: DiaryConfig,
+  logger: PluginLogger,
+  gatewayToken?: string,
+): { cleanup: () => Promise<void> } {
+  let registeredJobId: string | undefined;
+
+  const registerJob = async () => {
+    let gw: Awaited<ReturnType<typeof connectGateway>> | undefined;
+    try {
+      gw = await connectGateway(logger, gatewayToken);
+
+      // Check if the diary job already exists
+      const listResult = (await gw.call("cron.list", { includeDisabled: true })) as {
+        jobs?: CronJob[];
+      };
+      const existingJob = listResult?.jobs?.find((j) => j.name === DIARY_JOB_NAME);
+
+      const cronSchedule = {
+        kind: "cron" as const,
+        expr: config.diarySchedule,
+        tz: config.diaryTimezone,
+      };
+
+      const agentMessage = buildDiaryAgentMessage();
+
+      if (existingJob) {
+        // Update existing job schedule/payload
+        await gw.call("cron.update", {
+          id: existingJob.id,
+          patch: {
+            enabled: true,
+            schedule: cronSchedule,
+            payload: {
+              kind: "agentTurn",
+              message: agentMessage,
+              thinking: "low",
+            },
+          },
+        });
+        registeredJobId = existingJob.id;
+        logger.info(
+          `WeBot: diary cron job updated (id: ${existingJob.id}, schedule: ${config.diarySchedule} ${config.diaryTimezone})`,
+        );
+      } else {
+        // Create new job
+        const result = (await gw.call("cron.add", {
+          name: DIARY_JOB_NAME,
+          description:
+            "Generates a daily diary from today's conversations and publishes it to the WeBot social feed.",
+          enabled: true,
+          schedule: cronSchedule,
+          sessionTarget: "isolated",
+          wakeMode: "now",
+          payload: {
+            kind: "agentTurn",
+            message: agentMessage,
+            thinking: "low",
+          },
+        })) as { id?: string; job?: { id?: string } };
+        registeredJobId = result?.id ?? result?.job?.id;
+        logger.info(
+          `WeBot: diary cron job registered (id: ${registeredJobId}, schedule: ${config.diarySchedule} ${config.diaryTimezone})`,
+        );
+      }
+    } catch (err) {
+      logger.warn(`WeBot: failed to register diary cron job: ${String(err)}`);
+    } finally {
+      gw?.close();
+    }
+  };
+
+  // Register immediately — called from service.start() when Gateway is ready
+  void registerJob();
+
+  return {
+    cleanup: async () => {
+      if (!registeredJobId) return;
+      try {
+        const gw = await connectGateway(logger, gatewayToken);
+        await gw.call("cron.remove", { id: registeredJobId });
+        gw.close();
+        logger.info(`WeBot: diary cron job removed (id: ${registeredJobId})`);
+      } catch (err) {
+        logger.warn(`WeBot: failed to remove diary cron job: ${String(err)}`);
+      }
+    },
+  };
+}