@zlr_236/popo 0.0.1

package/src/monitor.ts

@@ -0,0 +1,236 @@
+import http from "http";
+import { registerPluginHttpRoute, normalizePluginHttpPath } from "openclaw/plugin-sdk";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "openclaw/plugin-sdk";
+import type { PopoConfig } from "./types.js";
+import { resolvePopoCredentials } from "./accounts.js";
+import { verifySignature, decryptMessage, encryptMessage } from "./crypto.js";
+import { handlePopoMessage, type PopoMessageEvent } from "./bot.js";
+import { probePopo } from "./probe.js";
+
+export type MonitorPopoOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+};
+
+// Helper function to read request body
+function readRequestBody(req: http.IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+    req.on("error", reject);
+  });
+}
+
+export async function monitorPopoProvider(opts: MonitorPopoOpts = {}): Promise<void> {
+  const cfg = opts.config;
+  if (!cfg) {
+    throw new Error("Config is required for POPO monitor");
+  }
+
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  const creds = resolvePopoCredentials(popoCfg);
+  if (!creds) {
+    throw new Error("POPO credentials not configured (appKey, appSecret required)");
+  }
+
+  const log = opts.runtime?.log ?? console.log;
+  const error = opts.runtime?.error ?? console.error;
+
+  // Verify credentials by getting a token
+  const probeResult = await probePopo(popoCfg);
+  if (!probeResult.ok) {
+    throw new Error(`POPO probe failed: ${probeResult.error}`);
+  }
+  log(`popo: credentials verified for appKey ${probeResult.appKey}`);
+
+  const webhookPath = popoCfg?.webhookPath?.trim() || "/popo/events";
+  const chatHistories = new Map<string, HistoryEntry[]>();
+
+  // Normalize path
+  const normalizedPath = normalizePluginHttpPath(webhookPath, "/popo/events") ?? "/popo/events";
+
+  // Register HTTP route to gateway
+  const unregisterHttp = registerPluginHttpRoute({
+    path: normalizedPath,
+    pluginId: "popo",
+    accountId: opts.accountId,
+    log: (msg: string) => log(msg),
+    handler: async (req, res) => {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+      log(`popo: received ${req.method} request to ${url.pathname}`);
+
+      // Handle CORS preflight
+      if (req.method === "OPTIONS") {
+        res.writeHead(200, {
+          "Access-Control-Allow-Origin": "*",
+          "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+          "Access-Control-Allow-Headers": "Content-Type, Authorization",
+        });
+        res.end();
+        return;
+      }
+
+      // Handle URL validation (GET request)
+      if (req.method === "GET") {
+        const nonce = url.searchParams.get("nonce");
+        const timestamp = url.searchParams.get("timestamp");
+        const signature = url.searchParams.get("signature");
+
+        log(`popo: URL validation attempt - nonce=${nonce}, timestamp=${timestamp}, signature=${signature}`);
+
+        if (nonce && timestamp && signature && creds.token) {
+          const valid = verifySignature({
+            token: creds.token,
+            nonce,
+            timestamp,
+            signature,
+          });
+
+          if (valid) {
+            log(`popo: URL validation successful`);
+            res.writeHead(200, { "Content-Type": "text/plain" });
+            res.end(nonce);
+            return;
+          } else {
+            log(`popo: signature verification failed`);
+          }
+        } else {
+          log(`popo: missing required parameters for validation`);
+        }
+
+        res.writeHead(400);
+        res.end("Invalid validation request");
+        return;
+      }
+
+      // Handle webhook event (POST request)
+      if (req.method === "POST") {
+        try {
+          const body = await readRequestBody(req);
+          const payload = JSON.parse(body);
+
+          // Check for encrypted payload
+          let eventData: unknown;
+          if (payload.encrypt && creds.aesKey) {
+            // Verify signature first
+            const { nonce, timestamp, signature } = payload;
+            if (nonce && timestamp && signature && creds.token) {
+              const valid = verifySignature({
+                token: creds.token,
+                nonce,
+                timestamp,
+                signature,
+              });
+
+              if (!valid) {
+                log(`popo: invalid signature in webhook event`);
+                res.writeHead(403);
+                res.end("Invalid signature");
+                return;
+              }
+            }
+
+            // Decrypt the message
+            const decrypted = decryptMessage(payload.encrypt, creds.aesKey);
+            eventData = JSON.parse(decrypted);
+          } else {
+            eventData = payload;
+          }
+
+          const event = eventData as { eventType?: string };
+
+          // Handle valid_url event
+          if (event.eventType === "valid_url") {
+            log(`popo: received valid_url event`);
+            const response = { eventType: "valid_url" };
+
+            if (creds.aesKey) {
+              const encrypted = encryptMessage(JSON.stringify(response), creds.aesKey);
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify({ encrypt: encrypted }));
+            } else {
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(JSON.stringify(response));
+            }
+            return;
+          }
+
+          // Handle message events
+          if (
+            event.eventType === "IM_P2P_TO_ROBOT_MSG" ||
+            event.eventType === "IM_CHAT_TO_ROBOT_AT_MSG"
+          ) {
+            const messageEvent = eventData as PopoMessageEvent;
+            log(`popo: received ${event.eventType} event`);
+
+            // Process message asynchronously
+            handlePopoMessage({
+              cfg,
+              event: messageEvent,
+              runtime: opts.runtime,
+              chatHistories,
+            }).catch((err) => {
+              error(`popo: error handling message: ${String(err)}`);
+            });
+          }
+
+          // Handle ACTION events (card interactions)
+          if (event.eventType === "ACTION") {
+            log(`popo: received ACTION event`);
+            // TODO: Implement card action handling if needed
+          }
+
+          // Return success response
+          const successResponse = { success: true };
+          if (creds.aesKey) {
+            const encrypted = encryptMessage(JSON.stringify(successResponse), creds.aesKey);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ encrypt: encrypted }));
+          } else {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(successResponse));
+          }
+        } catch (err) {
+          error(`popo: error processing webhook: ${String(err)}`);
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        }
+        return;
+      }
+
+      res.writeHead(405);
+      res.end("Method Not Allowed");
+    },
+  });
+
+  log(`popo: registered webhook handler at ${normalizedPath}`);
+
+  // Handle abort signal
+  const stopHandler = () => {
+    log("popo: stopping provider");
+    unregisterHttp();
+  };
+
+  if (opts.abortSignal?.aborted) {
+    stopHandler();
+    return;
+  }
+
+  opts.abortSignal?.addEventListener("abort", stopHandler, { once: true });
+
+  // Keep promise pending until abort
+  return new Promise((resolve) => {
+    const handler = () => {
+      stopHandler();
+      resolve();
+    };
+
+    if (opts.abortSignal) {
+      opts.abortSignal.removeEventListener("abort", stopHandler);
+      opts.abortSignal.addEventListener("abort", handler, { once: true });
+    }
+  });
+}

package/src/outbound.ts

@@ -0,0 +1,133 @@
+import type { ChannelOutboundAdapter } from "openclaw/plugin-sdk";
+import { getPopoRuntime } from "./runtime.js";
+import { sendMessagePopo, sendCardPopo, createStreamCardPopo, updateStreamCardPopo } from "./send.js";
+import { sendMediaPopo } from "./media.js";
+
+export const popoOutbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: (text, limit) => getPopoRuntime().channel.text.chunkMarkdownText(text, limit),
+  chunkerMode: "markdown",
+  textChunkLimit: 4000,
+  sendText: async ({ cfg, to, text }) => {
+    const result = await sendMessagePopo({ cfg, to, text });
+    return { channel: "popo", ...result };
+  },
+  sendMedia: async ({ cfg, to, text, mediaUrl }) => {
+    // Send text first if provided
+    if (text?.trim()) {
+      await sendMessagePopo({ cfg, to, text });
+    }
+
+    // Upload and send media if URL provided
+    if (mediaUrl) {
+      try {
+        const result = await sendMediaPopo({ cfg, to, mediaUrl });
+        return { channel: "popo", ...result };
+      } catch (err) {
+        // Log the error for debugging
+        console.error(`[popo] sendMediaPopo failed:`, err);
+        // Fallback to URL link if upload fails
+        const fallbackText = `📎 ${mediaUrl}`;
+        const result = await sendMessagePopo({ cfg, to, text: fallbackText });
+        return { channel: "popo", ...result };
+      }
+    }
+
+    // No media URL, just return text result
+    const result = await sendMessagePopo({ cfg, to, text: text ?? "" });
+    return { channel: "popo", ...result };
+  },
+
+  sendCard: async ({ cfg, to, card }) => {
+    const {
+      templateUuid,
+      instanceUuid,
+      callBackConfigKey,
+      publicVariableMap,
+      batchPrivateVariableMap,
+      options,
+    } = card as {
+      templateUuid: string;
+      instanceUuid: string;
+      callBackConfigKey?: string;
+      publicVariableMap?: Record<string, unknown>;
+      batchPrivateVariableMap?: Record<string, Record<string, unknown>>;
+      options?: import("./send.js").PopoCardOptions;
+    };
+    const result = await sendCardPopo({
+      cfg,
+      to,
+      templateUuid,
+      instanceUuid,
+      callBackConfigKey,
+      publicVariableMap,
+      batchPrivateVariableMap,
+      options,
+    });
+    return { channel: "popo", ...result };
+  },
+
+  // Streaming card support
+  createStreamCard: async ({ cfg, to, card }) => {
+    const {
+      templateUuid,
+      instanceUuid,
+      robotAccount,
+      fromUser,
+      sessionType,
+      callbackKey,
+      initialContent,
+    } = card as {
+      templateUuid: string;
+      instanceUuid: string;
+      robotAccount: string;
+      fromUser?: string;
+      sessionType?: number;
+      callbackKey?: string;
+      initialContent?: string;
+    };
+    const result = await createStreamCardPopo({
+      cfg,
+      to,
+      templateUuid,
+      instanceUuid,
+      robotAccount,
+      fromUser,
+      sessionType,
+      callbackKey,
+      initialContent,
+    });
+    return { channel: "popo", success: result.success, instanceUuid: result.instanceUuid };
+  },
+
+  updateStreamCard: async ({ cfg, card }) => {
+    const {
+      templateUuid,
+      instanceUuid,
+      content,
+      sequence,
+      isFinalize,
+      isError,
+      streamKey,
+    } = card as {
+      templateUuid: string;
+      instanceUuid: string;
+      content: string;
+      sequence: number;
+      isFinalize?: boolean;
+      isError?: boolean;
+      streamKey?: string;
+    };
+    const result = await updateStreamCardPopo({
+      cfg,
+      templateUuid,
+      instanceUuid,
+      content,
+      sequence,
+      isFinalize,
+      isError,
+      streamKey,
+    });
+    return { channel: "popo", success: result.success };
+  },
+};

package/src/policy.ts

@@ -0,0 +1,93 @@
+import type { ChannelGroupContext, GroupToolPolicyConfig } from "openclaw/plugin-sdk";
+import type { PopoConfig } from "./types.js";
+import type { PopoGroupConfig } from "./config-schema.js";
+
+export type PopoAllowlistMatch = {
+  allowed: boolean;
+  matchKey?: string;
+  matchSource?: "wildcard" | "id" | "name";
+};
+
+export function resolvePopoAllowlistMatch(params: {
+  allowFrom: Array<string | number>;
+  senderId: string;
+  senderName?: string | null;
+}): PopoAllowlistMatch {
+  const allowFrom = params.allowFrom
+    .map((entry) => String(entry).trim().toLowerCase())
+    .filter(Boolean);
+
+  if (allowFrom.length === 0) return { allowed: false };
+  if (allowFrom.includes("*")) {
+    return { allowed: true, matchKey: "*", matchSource: "wildcard" };
+  }
+
+  const senderId = params.senderId.toLowerCase();
+  if (allowFrom.includes(senderId)) {
+    return { allowed: true, matchKey: senderId, matchSource: "id" };
+  }
+
+  const senderName = params.senderName?.toLowerCase();
+  if (senderName && allowFrom.includes(senderName)) {
+    return { allowed: true, matchKey: senderName, matchSource: "name" };
+  }
+
+  return { allowed: false };
+}
+
+export function resolvePopoGroupConfig(params: {
+  cfg?: PopoConfig;
+  groupId?: string | null;
+}): PopoGroupConfig | undefined {
+  const groups = params.cfg?.groups ?? {};
+  const groupId = params.groupId?.trim();
+  if (!groupId) return undefined;
+
+  const direct = groups[groupId] as PopoGroupConfig | undefined;
+  if (direct) return direct;
+
+  const lowered = groupId.toLowerCase();
+  const matchKey = Object.keys(groups).find((key) => key.toLowerCase() === lowered);
+  return matchKey ? (groups[matchKey] as PopoGroupConfig | undefined) : undefined;
+}
+
+export function resolvePopoGroupToolPolicy(
+  params: ChannelGroupContext
+): GroupToolPolicyConfig | undefined {
+  const cfg = params.cfg.channels?.popo as PopoConfig | undefined;
+  if (!cfg) return undefined;
+
+  const groupConfig = resolvePopoGroupConfig({
+    cfg,
+    groupId: params.groupId,
+  });
+
+  return groupConfig?.tools;
+}
+
+export function isPopoGroupAllowed(params: {
+  groupPolicy: "open" | "allowlist" | "disabled";
+  allowFrom: Array<string | number>;
+  senderId: string;
+  senderName?: string | null;
+}): boolean {
+  const { groupPolicy } = params;
+  if (groupPolicy === "disabled") return false;
+  if (groupPolicy === "open") return true;
+  return resolvePopoAllowlistMatch(params).allowed;
+}
+
+export function resolvePopoReplyPolicy(params: {
+  isDirectMessage: boolean;
+  globalConfig?: PopoConfig;
+  groupConfig?: PopoGroupConfig;
+}): { requireMention: boolean } {
+  if (params.isDirectMessage) {
+    return { requireMention: false };
+  }
+
+  const requireMention =
+    params.groupConfig?.requireMention ?? params.globalConfig?.requireMention ?? true;
+
+  return { requireMention };
+}

package/src/probe.ts

@@ -0,0 +1,29 @@
+import type { PopoConfig, PopoProbeResult } from "./types.js";
+import { resolvePopoCredentials } from "./accounts.js";
+import { getAccessToken } from "./auth.js";
+
+export async function probePopo(cfg?: PopoConfig): Promise<PopoProbeResult> {
+  const creds = resolvePopoCredentials(cfg);
+  if (!creds) {
+    return {
+      ok: false,
+      error: "missing credentials (appKey, appSecret)",
+    };
+  }
+
+  try {
+    // Try to get an access token to verify credentials
+    await getAccessToken(cfg!);
+
+    return {
+      ok: true,
+      appKey: creds.appKey,
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      appKey: creds.appKey,
+      error: err instanceof Error ? err.message : String(err),
+    };
+  }
+}

package/src/reply-dispatcher.ts

@@ -0,0 +1,141 @@
+import {
+  createReplyPrefixContext,
+  createTypingCallbacks,
+  logTypingFailure,
+  type ClawdbotConfig,
+  type RuntimeEnv,
+  type ReplyPayload,
+} from "openclaw/plugin-sdk";
+import { getPopoRuntime } from "./runtime.js";
+import { sendMessagePopo, sendRichTextPopo, textToRichTextContent } from "./send.js";
+import type { PopoConfig } from "./types.js";
+
+export type CreatePopoReplyDispatcherParams = {
+  cfg: ClawdbotConfig;
+  agentId: string;
+  runtime: RuntimeEnv;
+  sessionId: string;
+};
+
+export function createPopoReplyDispatcher(params: CreatePopoReplyDispatcherParams) {
+  const core = getPopoRuntime();
+  const { cfg, agentId, sessionId } = params;
+
+  const prefixContext = createReplyPrefixContext({
+    cfg,
+    agentId,
+  });
+
+  // Track whether any tool results have been sent
+  let hasToolResults = false;
+  let toolResultCount = 0;
+
+  // POPO doesn't have a native typing indicator API
+  // We could potentially use emoji reactions but skip for now
+  const typingCallbacks = createTypingCallbacks({
+    start: async () => {
+      // No-op for POPO
+    },
+    stop: async () => {
+      // No-op for POPO
+    },
+    onStartError: (err) => {
+      logTypingFailure({
+        log: (message) => params.runtime.log?.(message),
+        channel: "popo",
+        action: "start",
+        error: err,
+      });
+    },
+    onStopError: (err) => {
+      logTypingFailure({
+        log: (message) => params.runtime.log?.(message),
+        channel: "popo",
+        action: "stop",
+        error: err,
+      });
+    },
+  });
+
+  const textChunkLimit = core.channel.text.resolveTextChunkLimit({
+    cfg,
+    channel: "popo",
+    defaultLimit: 4000,
+  });
+  const chunkMode = core.channel.text.resolveChunkMode(cfg, "popo");
+
+  const { dispatcher, replyOptions, markDispatchIdle } =
+    core.channel.reply.createReplyDispatcherWithTyping({
+      responsePrefix: prefixContext.responsePrefix,
+      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+      humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+      onReplyStart: typingCallbacks.onReplyStart,
+      deliver: async (payload: ReplyPayload) => {
+        params.runtime.log?.(`popo deliver called: text=${payload.text?.slice(0, 100)}`);
+        const text = payload.text ?? "";
+
+        // Check render mode: raw (default) or rich_text
+        const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+        const renderMode = popoCfg?.renderMode ?? "raw";
+
+        // Build tool execution indicator if tools were used
+        let fullText = text;
+        if (hasToolResults) {
+          const toolIndicator = toolResultCount === 1
+            ? "🛠️ **使用了 1 个工具**\n\n"
+            : `🛠️ **使用了 ${toolResultCount} 个工具**\n\n`;
+          fullText = toolIndicator + text;
+          // Reset after including in message
+          hasToolResults = false;
+          toolResultCount = 0;
+        }
+
+        if (!fullText.trim()) {
+          params.runtime.log?.(`popo deliver: empty text, skipping`);
+          return;
+        }
+
+        const chunks = core.channel.text.chunkTextWithMode(fullText, textChunkLimit, chunkMode);
+        params.runtime.log?.(`popo deliver: sending ${chunks.length} chunks to ${sessionId}`);
+
+        for (const chunk of chunks) {
+          if (renderMode === "rich_text") {
+            // Rich text mode
+            const content = textToRichTextContent(chunk);
+            await sendRichTextPopo({
+              cfg,
+              to: sessionId,
+              content,
+            });
+          } else {
+            // Raw text mode (default)
+            await sendMessagePopo({
+              cfg,
+              to: sessionId,
+              text: chunk,
+            });
+          }
+        }
+      },
+      onError: (err, info) => {
+        params.runtime.error?.(`popo ${info.kind} reply failed: ${String(err)}`);
+        typingCallbacks.onIdle?.();
+      },
+      onIdle: typingCallbacks.onIdle,
+    });
+
+  return {
+    dispatcher,
+    replyOptions: {
+      ...replyOptions,
+      onModelSelected: prefixContext.onModelSelected,
+      // Track tool results as they are executed
+      onToolResult: (_payload: { text?: string; mediaUrls?: string[] }) => {
+        hasToolResults = true;
+        toolResultCount++;
+        params.runtime.log?.(`popo: tracked tool result #${toolResultCount}`);
+      },
+    },
+    markDispatchIdle,
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setPopoRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getPopoRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("POPO runtime not initialized");
+  }
+  return runtime;
+}