@zlr_236/popo 0.0.1

package/src/channel.ts

@@ -0,0 +1,839 @@
+import type { ChannelPlugin, ClawdbotConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, PAIRING_APPROVED_MESSAGE } from "openclaw/plugin-sdk";
+import type { ResolvedPopoAccount, PopoConfig } from "./types.js";
+import { resolvePopoAccount, resolvePopoCredentials } from "./accounts.js";
+import { popoOutbound } from "./outbound.js";
+import { probePopo } from "./probe.js";
+import { resolvePopoGroupToolPolicy } from "./policy.js";
+import { normalizePopoTarget, looksLikePopoId } from "./targets.js";
+import { sendMessagePopo, updateInstructionVariableOptions } from "./send.js";
+import { recallMessagePopo, getMessageReadAckPopo, downloadMessageFilePopo, configureCardCallbackPopo } from "./media.js";
+import {
+  createTeam,
+  inviteToTeam,
+  dropTeam,
+  getTeamMembers,
+  getTeamInfo,
+  updateTeamInfo,
+  updateTeamManagement,
+  getViewScope,
+  modifyViewScope,
+  publishRobot,
+} from "./team.js";
+
+const meta = {
+  id: "popo",
+  label: "POPO",
+  selectionLabel: "POPO (网易)",
+  docsPath: "/channels/popo",
+  docsLabel: "popo",
+  blurb: "POPO enterprise messaging.",
+  aliases: [],
+  order: 80,
+} as const;
+
+export const popoPlugin: ChannelPlugin<ResolvedPopoAccount> = {
+  id: "popo",
+  meta: {
+    ...meta,
+  },
+  pairing: {
+    idLabel: "popoEmail",
+    normalizeAllowEntry: (entry) => entry.replace(/^(popo|user):/i, ""),
+    notifyApproval: async ({ cfg, id }) => {
+      await sendMessagePopo({
+        cfg,
+        to: id,
+        text: PAIRING_APPROVED_MESSAGE,
+      });
+    },
+  },
+  capabilities: {
+    chatTypes: ["direct", "channel"],
+    polls: false,
+    threads: false,
+    media: true,
+    reactions: false,
+    edit: false,
+    reply: true,
+  },
+  agentPrompt: {
+    messageToolHints: () => [
+      "- POPO targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:email@example.com` or `group:groupId`.",
+      "- POPO actions: send, card, unsend (target=to), addParticipant (target=tid), channel-info/channel-edit/channel-delete (channelId=tid), channel-create (no target), member-info (tid param). Custom actions without target: read-ack (msgId), download-file (fileId), update-team-mgmt, view-scope, modify-view-scope, publish-robot, update-instruction-options, configure-card-callback.",
+    ],
+  },
+  groups: {
+    resolveToolPolicy: resolvePopoGroupToolPolicy,
+  },
+  reload: { configPrefixes: ["channels.popo"] },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        systemPrompt: { type: "string" },
+        appKey: { type: "string" },
+        appSecret: { type: "string" },
+        token: { type: "string" },
+        aesKey: { type: "string" },
+        server: { type: "string" },
+        webhookPath: { type: "string" },
+        webhookPort: { type: "integer", minimum: 1 },
+        dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+        allowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
+        groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
+        groupAllowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
+        requireMention: { type: "boolean" },
+        historyLimit: { type: "integer", minimum: 0 },
+        dmHistoryLimit: { type: "integer", minimum: 0 },
+        textChunkLimit: { type: "integer", minimum: 1 },
+        chunkMode: { type: "string", enum: ["length", "newline"] },
+        mediaMaxMb: { type: "number", minimum: 0 },
+        renderMode: { type: "string", enum: ["raw", "rich_text"] },
+      },
+    },
+  },
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+    resolveAccount: (cfg) => resolvePopoAccount({ cfg }),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    setAccountEnabled: ({ cfg, enabled }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        popo: {
+          ...cfg.channels?.popo,
+          enabled,
+        },
+      },
+    }),
+    deleteAccount: ({ cfg }) => {
+      const next = { ...cfg } as ClawdbotConfig;
+      const nextChannels = { ...cfg.channels };
+      delete (nextChannels as Record<string, unknown>).popo;
+      if (Object.keys(nextChannels).length > 0) {
+        next.channels = nextChannels;
+      } else {
+        delete next.channels;
+      }
+      return next;
+    },
+    isConfigured: (_account, cfg) =>
+      Boolean(resolvePopoCredentials(cfg.channels?.popo as PopoConfig | undefined)),
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+    }),
+    resolveAllowFrom: ({ cfg }) =>
+      (cfg.channels?.popo as PopoConfig | undefined)?.allowFrom ?? [],
+    formatAllowFrom: ({ allowFrom }) =>
+      allowFrom
+        .map((entry) => String(entry).trim())
+        .filter(Boolean)
+        .map((entry) => entry.toLowerCase()),
+  },
+  security: {
+    collectWarnings: ({ cfg }) => {
+      const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+      const defaultGroupPolicy = (cfg.channels as Record<string, { groupPolicy?: string }> | undefined)?.defaults?.groupPolicy;
+      const groupPolicy = popoCfg?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+      if (groupPolicy !== "open") return [];
+      return [
+        `- POPO groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.popo.groupPolicy="allowlist" + channels.popo.groupAllowFrom to restrict senders.`,
+      ];
+    },
+  },
+  setup: {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    applyAccountConfig: ({ cfg }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        popo: {
+          ...cfg.channels?.popo,
+          enabled: true,
+        },
+      },
+    }),
+  },
+  messaging: {
+    normalizeTarget: normalizePopoTarget,
+    targetResolver: {
+      looksLikeId: looksLikePopoId,
+      hint: "<email|user:email|group:groupId>",
+    },
+  },
+  outbound: popoOutbound,
+  actions: {
+    listActions: ({ cfg }) => {
+      const enabled = cfg.channels?.popo?.enabled !== false;
+      if (!enabled) return [];
+      // Return all supported actions
+      // Use built-in action names to work with OpenClaw's target mode system:
+      // - unsend (recall), channel-create (create-team), addParticipant (invite-team)
+      // - channel-delete (drop-team), member-info (team-members), channel-info (team-info)
+      // - channel-edit (update-team-info)
+      return [
+        "send",
+        "card",
+        "unsend",
+        "channel-create",
+        "addParticipant",
+        "channel-delete",
+        "member-info",
+        "channel-info",
+        "channel-edit",
+        "read-ack",
+        "download-file",
+        "update-team-mgmt",
+        "view-scope",
+        "modify-view-scope",
+        "publish-robot",
+        "update-instruction-options",
+        "configure-card-callback",
+      ];
+    },
+    supportsCards: ({ cfg }) => {
+      return cfg.channels?.popo?.enabled !== false;
+    },
+    handleAction: async (ctx) => {
+      const { action, params, cfg } = ctx;
+
+      // Handle send action (with optional card)
+      if (action === "send") {
+        if (params.card) {
+          const card = params.card as Record<string, unknown>;
+          const to =
+            typeof params.to === "string"
+              ? params.to.trim()
+              : typeof params.target === "string"
+                ? params.target.trim()
+                : "";
+          if (!to) {
+            return {
+              isError: true,
+              content: [{ type: "text", text: "Card send requires a target (to)." }],
+            };
+          }
+          const { sendCardPopo } = await import("./send.js");
+          const result = await sendCardPopo({
+            cfg,
+            to,
+            templateUuid: String(card.templateUuid ?? ""),
+            instanceUuid: String(card.instanceUuid ?? ""),
+            callBackConfigKey: card.callBackConfigKey ? String(card.callBackConfigKey) : undefined,
+            publicVariableMap: (card.publicVariableMap as Record<string, unknown>) ?? {},
+            batchPrivateVariableMap: card.batchPrivateVariableMap as Record<string, Record<string, unknown>> | undefined,
+            options: card.options as import("./send.js").PopoCardOptions | undefined,
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  ok: true,
+                  channel: "popo",
+                  messageId: result.messageId,
+                  sessionId: result.sessionId,
+                }),
+              },
+            ],
+          };
+        }
+
+        // Regular text send
+        const to =
+          typeof params.to === "string"
+            ? params.to.trim()
+            : typeof params.target === "string"
+              ? params.target.trim()
+              : "";
+        const text = typeof params.text === "string" ? params.text : typeof params.message === "string" ? params.message : "";
+        if (!to || !text) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Send requires target (to) and text/message." }],
+          };
+        }
+        const result = await sendMessagePopo({ cfg, to, text });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: true,
+                channel: "popo",
+                messageId: result.messageId,
+                sessionId: result.sessionId,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle card action
+      if (action === "card") {
+        const card = params.card as Record<string, unknown>;
+        const to =
+          typeof params.to === "string"
+            ? params.to.trim()
+            : typeof params.target === "string"
+              ? params.target.trim()
+              : "";
+        if (!to) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Card action requires a target (to)." }],
+          };
+        }
+        const { sendCardPopo } = await import("./send.js");
+        const result = await sendCardPopo({
+          cfg,
+          to,
+          templateUuid: String(card?.templateUuid ?? ""),
+          instanceUuid: String(card?.instanceUuid ?? ""),
+          callBackConfigKey: card?.callBackConfigKey ? String(card.callBackConfigKey) : undefined,
+          publicVariableMap: (card?.publicVariableMap as Record<string, unknown>) ?? {},
+          batchPrivateVariableMap: card?.batchPrivateVariableMap as Record<string, Record<string, unknown>> | undefined,
+          options: card?.options as import("./send.js").PopoCardOptions | undefined,
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: true,
+                channel: "popo",
+                messageId: result.messageId,
+                sessionId: result.sessionId,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle unsend action (recall message) - uses built-in "unsend" which has proper target mode
+      // Accepts: target (to), messageId, sessionId, sessionType
+      if (action === "unsend") {
+        const msgId = typeof params.messageId === "string" ? params.messageId : typeof params.msgId === "string" ? params.msgId : "";
+        // For unsend, sessionId can come from "to" (target) or explicit sessionId
+        const sessionId =
+          typeof params.sessionId === "string"
+            ? params.sessionId
+            : typeof params.to === "string"
+              ? params.to.trim()
+              : "";
+        const sessionType = typeof params.sessionType === "number" ? params.sessionType : 1;
+        if (!msgId || !sessionId) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Unsend requires messageId and target (or sessionId)." }],
+          };
+        }
+        const result = await recallMessagePopo({ cfg, msgId, sessionId, sessionType: sessionType as 1 | 3 });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle read-ack action
+      if (action === "read-ack") {
+        const msgId = typeof params.msgId === "string" ? params.msgId : "";
+        const type = typeof params.type === "number" ? params.type : 1;
+        const st = typeof params.st === "number" ? params.st : Date.now();
+        const page = typeof params.page === "number" ? params.page : 1;
+        const size = typeof params.size === "number" ? params.size : 30;
+        if (!msgId) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Read-ack requires msgId." }],
+          };
+        }
+        const result = await getMessageReadAckPopo({
+          cfg,
+          msgId,
+          sessionType: 3,
+          type: type as 1 | 2,
+          st,
+          page,
+          size,
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                rnum: result.rnum,
+                unrnum: result.unrnum,
+                list: result.list,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle download-file action
+      if (action === "download-file") {
+        const fileId = typeof params.fileId === "string" ? params.fileId : "";
+        if (!fileId) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Download-file requires fileId." }],
+          };
+        }
+        const result = await downloadMessageFilePopo({ cfg, fileId });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                downloadUrl: result.downloadUrl,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // ==================== Team Management Actions ====================
+
+      // Handle channel-create action (create team)
+      // Built-in action with targetMode: none
+      if (action === "channel-create") {
+        const uid = typeof params.uid === "string" ? params.uid : "";
+        const name = typeof params.name === "string" ? params.name : undefined;
+        const uidList = Array.isArray(params.uidList) ? params.uidList : [];
+        const photoUrl = typeof params.photoUrl === "string" ? params.photoUrl : undefined;
+        if (!uid || uidList.length === 0) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "channel-create requires uid (owner) and uidList (members)." }],
+          };
+        }
+        const result = await createTeam({ cfg, uid, name, uidList, photoUrl });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                tid: result.tid,
+                passNum: result.passNum,
+                failList: result.failList,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle addParticipant action (invite to team)
+      // Built-in action with targetMode: to (tid comes from target/to)
+      if (action === "addParticipant") {
+        const tid =
+          typeof params.tid === "string"
+            ? params.tid
+            : typeof params.to === "string"
+              ? params.to.trim()
+              : "";
+        const inviteList = Array.isArray(params.inviteList) ? params.inviteList : Array.isArray(params.participant) ? params.participant : [];
+        const type = typeof params.type === "string" ? (params.type as "1" | "2") : "1";
+        const text = typeof params.text === "string" ? params.text : undefined;
+        if (!tid || inviteList.length === 0) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "addParticipant requires target (tid) and inviteList/participant." }],
+          };
+        }
+        const result = await inviteToTeam({ cfg, tid, inviteList, type, text });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                type: result.type,
+                failList: result.failList,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle channel-delete action (drop/disband team)
+      // Built-in action with targetMode: channelId
+      if (action === "channel-delete") {
+        const tid =
+          typeof params.tid === "string"
+            ? params.tid
+            : typeof params.channelId === "string"
+              ? params.channelId.trim()
+              : "";
+        if (!tid) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "channel-delete requires channelId (team ID)." }],
+          };
+        }
+        const result = await dropTeam({ cfg, tid });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle member-info action (get team members)
+      // Built-in action with targetMode: none
+      if (action === "member-info") {
+        const tid = typeof params.tid === "string" ? params.tid : "";
+        const page = typeof params.page === "number" ? params.page : 1;
+        const limit = typeof params.limit === "number" ? params.limit : 20;
+        if (!tid) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "member-info requires tid (team ID)." }],
+          };
+        }
+        const result = await getTeamMembers({ cfg, tid, page, limit });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                records: result.records,
+                total: result.total,
+                page: result.page,
+                limit: result.limit,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle channel-info action (get team info)
+      // Built-in action with targetMode: channelId
+      if (action === "channel-info") {
+        const tid =
+          typeof params.tid === "string"
+            ? params.tid
+            : typeof params.channelId === "string"
+              ? params.channelId.trim()
+              : "";
+        const scopes = Array.isArray(params.scopes) ? params.scopes : undefined;
+        if (!tid) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "channel-info requires channelId (team ID)." }],
+          };
+        }
+        const result = await getTeamInfo({ cfg, tid, scopes });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                info: result.info,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle channel-edit action (update team info)
+      // Built-in action with targetMode: channelId
+      if (action === "channel-edit") {
+        const tid =
+          typeof params.tid === "string"
+            ? params.tid
+            : typeof params.channelId === "string"
+              ? params.channelId.trim()
+              : "";
+        const name = typeof params.name === "string" ? params.name : "";
+        const board = typeof params.board === "string" ? params.board : "";
+        const type = typeof params.type === "number" ? params.type : undefined;
+        if (!tid || !name || !board) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "channel-edit requires channelId (tid), name, and board." }],
+          };
+        }
+        const result = await updateTeamInfo({ cfg, tid, name, board, type });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle update-team-mgmt action
+      if (action === "update-team-mgmt") {
+        const tid = typeof params.tid === "string" ? params.tid : "";
+        const settingType = typeof params.type === "number" ? params.type : typeof params.settingType === "number" ? params.settingType : 0;
+        const value = typeof params.value === "number" ? params.value : 0;
+        if (!tid || !settingType) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Update-team-mgmt requires tid, type (setting type 1-8), and value." }],
+          };
+        }
+        const result = await updateTeamManagement({ cfg, tid, type: settingType, value });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // ==================== View Scope Actions ====================
+
+      // Handle view-scope action
+      if (action === "view-scope") {
+        const scopeType = typeof params.scopeType === "string" ? (params.scopeType as "PERSONAL" | "DEPARTMENT") : "PERSONAL";
+        const current = typeof params.current === "number" ? params.current : 1;
+        const limit = typeof params.limit === "number" ? params.limit : 10;
+        const result = await getViewScope({ cfg, scopeType, current, limit });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                records: result.records,
+                viewScopeType: result.viewScopeType,
+                total: result.total,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle modify-view-scope action
+      if (action === "modify-view-scope") {
+        const operationType = typeof params.operationType === "number" ? (params.operationType as 1 | 2) : 1;
+        const scopeType = typeof params.scopeType === "string" ? (params.scopeType as "PERSONAL" | "DEPARTMENT") : "PERSONAL";
+        const scopeValues = Array.isArray(params.scopeValues) ? params.scopeValues : [];
+        if (scopeValues.length === 0) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Modify-view-scope requires scopeValues array." }],
+          };
+        }
+        const result = await modifyViewScope({ cfg, operationType, scopeType, scopeValues });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                successNum: result.successNum,
+                failNum: result.failNum,
+                failMsg: result.failMsg,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // Handle publish-robot action
+      if (action === "publish-robot") {
+        const uid = typeof params.uid === "string" ? params.uid : "";
+        if (!uid) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Publish-robot requires uid (applicant email)." }],
+          };
+        }
+        const result = await publishRobot({ cfg, uid });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // ==================== Instruction Variable Options ====================
+
+      // Handle update-instruction-options action
+      if (action === "update-instruction-options") {
+        const instructionId = typeof params.instructionId === "string" ? params.instructionId : "";
+        const variableKey = typeof params.variableKey === "string" ? params.variableKey : "";
+        const variableOptions = Array.isArray(params.variableOptions) ? params.variableOptions : [];
+        if (!instructionId || !variableKey || variableOptions.length === 0) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Update-instruction-options requires instructionId, variableKey, and variableOptions." }],
+          };
+        }
+        const result = await updateInstructionVariableOptions({ cfg, instructionId, variableKey, variableOptions });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                traceId: result.traceId,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      // ==================== Card Callback Configuration ====================
+
+      // Handle configure-card-callback action
+      if (action === "configure-card-callback") {
+        const configKey = typeof params.configKey === "string" ? params.configKey : "";
+        const requestUrl = typeof params.requestUrl === "string" ? params.requestUrl : "";
+        const token = typeof params.token === "string" ? params.token : "";
+        if (!configKey || !requestUrl || !token) {
+          return {
+            isError: true,
+            content: [{ type: "text", text: "Configure-card-callback requires configKey, requestUrl, and token." }],
+          };
+        }
+        const aesKey = typeof params.aesKey === "string" ? params.aesKey : undefined;
+        const overwriteUpdate = typeof params.overwriteUpdate === "boolean" ? params.overwriteUpdate : false;
+        const withCallBackTest = typeof params.withCallBackTest === "boolean" ? params.withCallBackTest : true;
+        const pushToOffice = typeof params.pushToOffice === "boolean" ? params.pushToOffice : false;
+        const authType = typeof params.authType === "string" ? (params.authType as "CODE" | "SIGN") : "SIGN";
+        const result = await configureCardCallbackPopo({
+          cfg,
+          configKey,
+          requestUrl,
+          token,
+          aesKey,
+          overwriteUpdate,
+          withCallBackTest,
+          pushToOffice,
+          authType,
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                ok: result.success,
+                channel: "popo",
+                config: result.config,
+                error: result.error,
+              }),
+            },
+          ],
+        };
+      }
+
+      return undefined;
+    },
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+      port: null,
+    },
+    buildChannelSummary: ({ snapshot, cfg }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      lastStartAt: snapshot.lastStartAt ?? null,
+      lastStopAt: snapshot.lastStopAt ?? null,
+      lastError: snapshot.lastError ?? null,
+      port: snapshot.port ?? null,
+      probe: snapshot.probe,
+      lastProbeAt: snapshot.lastProbeAt ?? null,
+      webhookPath: (cfg.channels?.popo as PopoConfig)?.webhookPath ?? '/popo/events',
+    }),
+    probeAccount: async ({ cfg }) =>
+      await probePopo(cfg.channels?.popo as PopoConfig | undefined),
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      port: runtime?.port ?? null,
+      probe,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { monitorPopoProvider } = await import("./monitor.js");
+      const popoCfg = ctx.cfg.channels?.popo as PopoConfig | undefined;
+      const webhookPath = popoCfg?.webhookPath ?? "/popo/events";
+      // Set port to null to indicate gateway mode
+      ctx.setStatus({ accountId: ctx.accountId, port: null });
+      ctx.log?.info(`starting popo provider (gateway mode, path: ${webhookPath})`);
+      return monitorPopoProvider({
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        accountId: ctx.accountId,
+      });
+    },
+  },
+};