@zlr_236/popo 0.0.1

package/src/send.ts

@@ -0,0 +1,430 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { PopoConfig, PopoSendResult } from "./types.js";
+import { popoRequest } from "./client.js";
+import { normalizePopoTarget } from "./targets.js";
+
+export type SendPopoMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  atUids?: string[];
+  isAtAll?: boolean;
+};
+
+/**
+ * Send a text message to POPO.
+ */
+export async function sendMessagePopo(params: SendPopoMessageParams): Promise<PopoSendResult> {
+  const { cfg, to, text, atUids, isAtAll } = params;
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  if (!popoCfg) {
+    throw new Error("POPO channel not configured");
+  }
+
+  const receiver = normalizePopoTarget(to);
+  if (!receiver) {
+    throw new Error(`Invalid POPO target: ${to}`);
+  }
+
+  const message: Record<string, unknown> = {
+    content: text,
+  };
+
+  if (atUids && atUids.length > 0) {
+    message.atUids = atUids;
+  }
+  if (isAtAll) {
+    message.isAtAll = true;
+  }
+
+  const response = await popoRequest<{ msgInfo?: Record<string, string> }>({
+    cfg: popoCfg,
+    method: "POST",
+    path: "/open-apis/robots/v1/im/send-msg",
+    body: {
+      receiver,
+      msgType: "text",
+      message,
+    },
+  });
+
+  if (response.errcode !== 0) {
+    throw new Error(`POPO send failed: ${response.errmsg || `errcode ${response.errcode}`}`);
+  }
+
+  const msgInfo = response.data?.msgInfo ?? {};
+  const messageId = msgInfo[receiver];
+
+  return {
+    messageId,
+    sessionId: receiver,
+  };
+}
+
+export type SendPopoRichTextParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  content: Array<{ tag: string; text?: string; href?: string; userId?: string }>;
+};
+
+/**
+ * Send a rich text message to POPO.
+ */
+export async function sendRichTextPopo(params: SendPopoRichTextParams): Promise<PopoSendResult> {
+  const { cfg, to, content } = params;
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  if (!popoCfg) {
+    throw new Error("POPO channel not configured");
+  }
+
+  const receiver = normalizePopoTarget(to);
+  if (!receiver) {
+    throw new Error(`Invalid POPO target: ${to}`);
+  }
+
+  const response = await popoRequest<{ msgInfo?: Record<string, string> }>({
+    cfg: popoCfg,
+    method: "POST",
+    path: "/open-apis/robots/v1/im/send-msg",
+    body: {
+      receiver,
+      msgType: "rich_text",
+      message: { content },
+    },
+  });
+
+  if (response.errcode !== 0) {
+    throw new Error(`POPO rich text send failed: ${response.errmsg || `errcode ${response.errcode}`}`);
+  }
+
+  const msgInfo = response.data?.msgInfo ?? {};
+  const messageId = msgInfo[receiver];
+
+  return {
+    messageId,
+    sessionId: receiver,
+  };
+}
+
+export type PopoCardOptions = {
+  enableForward?: boolean;
+  lastMessage?: string;
+  lastMessageI18n?: Record<string, string>;
+  compatibleMessage?: string;
+  compatibleMessageI18n?: Record<string, string>;
+  withReadFlag?: boolean;
+  removeLastMessagePrefix?: boolean;
+  msgMenuConfigProtocol?: string;
+};
+
+export type SendPopoCardParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  templateUuid: string;
+  instanceUuid: string;
+  callBackConfigKey?: string;
+  publicVariableMap?: Record<string, unknown>;
+  batchPrivateVariableMap?: Record<string, Record<string, unknown>>;
+  options?: PopoCardOptions;
+};
+
+/**
+ * Send a card message to POPO.
+ */
+export async function sendCardPopo(params: SendPopoCardParams): Promise<PopoSendResult> {
+  const { cfg, to, templateUuid, instanceUuid, callBackConfigKey, publicVariableMap, batchPrivateVariableMap, options } = params;
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  if (!popoCfg) {
+    throw new Error("POPO channel not configured");
+  }
+
+  const receiver = normalizePopoTarget(to);
+  if (!receiver) {
+    throw new Error(`Invalid POPO target: ${to}`);
+  }
+
+  const message: Record<string, unknown> = {
+    templateUuid,
+    instanceUuid,
+  };
+
+  if (callBackConfigKey) {
+    message.callBackConfigKey = callBackConfigKey;
+  }
+  if (publicVariableMap) {
+    message.publicVariableMap = publicVariableMap;
+  }
+  if (batchPrivateVariableMap) {
+    message.batchPrivateVariableMap = batchPrivateVariableMap;
+  }
+  if (options) {
+    message.options = options;
+  }
+
+  const response = await popoRequest<{ msgInfo?: Record<string, string> }>({
+    cfg: popoCfg,
+    method: "POST",
+    path: "/open-apis/robots/v1/im/send-msg",
+    body: {
+      receiver,
+      msgType: "card",
+      message,
+    },
+  });
+
+  if (response.errcode !== 0) {
+    throw new Error(`POPO card send failed: ${response.errmsg || `errcode ${response.errcode}`}`);
+  }
+
+  const msgInfo = response.data?.msgInfo ?? {};
+  const messageId = msgInfo[receiver];
+
+  return {
+    messageId,
+    sessionId: receiver,
+  };
+}
+
+/**
+ * Convert markdown-like text to POPO rich text content array.
+ */
+export function textToRichTextContent(
+  text: string
+): Array<{ tag: string; text?: string }> {
+  // For now, just wrap the entire text in a single text element
+  // More sophisticated parsing could handle bold, links, etc.
+  return [{ tag: "text", text }];
+}
+
+export type CreatePopoStreamCardParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  templateUuid: string;
+  instanceUuid: string;
+  robotAccount: string;
+  fromUser?: string;
+  sessionType?: number;
+  callbackKey?: string;
+  initialContent?: string;
+};
+
+export type PopoStreamCardResult = {
+  success: boolean;
+  instanceUuid: string;
+  messageId?: string;
+  error?: string;
+};
+
+/**
+ * Create a streaming card message in POPO.
+ * Streaming cards allow real-time content updates via updateStreamCardPopo().
+ */
+export async function createStreamCardPopo(
+  params: CreatePopoStreamCardParams
+): Promise<PopoStreamCardResult> {
+  const {
+    cfg,
+    to,
+    templateUuid,
+    instanceUuid,
+    robotAccount,
+    fromUser = "",
+    sessionType = 1,
+    callbackKey,
+    initialContent = "AI正在思考中...",
+  } = params;
+
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  if (!popoCfg) {
+    throw new Error("POPO channel not configured");
+  }
+
+  const receiver = normalizePopoTarget(to);
+  if (!receiver) {
+    throw new Error(`Invalid POPO target: ${to}`);
+  }
+
+  const message: Record<string, unknown> = {
+    templateUuid,
+    instanceUuid,
+    options: {
+      enableForward: false,
+      lastMessage: initialContent,
+    },
+    publicVariableMap: {
+      references: [],
+      resultStream: {
+        seq: 0,
+        content: "",
+        status: 0, // 0 = pending
+      },
+      thinkStream: {
+        seq: 0,
+        content: "",
+        status: 0,
+      },
+      thinkTitleText: {
+        "zh-CN": "思考中...",
+        "en-US": "Thinking...",
+        "ja-JP": "考え中...",
+      },
+      isGoodChecked: false,
+      isBadChecked: false,
+      extraParams: {
+        aiMessageId: "",
+        customerMessageId: "",
+        robotKey: robotAccount,
+        openid: fromUser,
+        type: String(sessionType),
+        content: "",
+      },
+    },
+  };
+
+  if (callbackKey) {
+    message.callBackConfigKey = callbackKey;
+  }
+
+  const response = await popoRequest<{ msgInfo?: Record<string, string> }>({
+    cfg: popoCfg,
+    method: "POST",
+    path: "/open-apis/robots/v1/im/send-msg",
+    body: {
+      receiver,
+      msgType: "card",
+      message,
+    },
+  });
+
+  if (response.errcode !== 0) {
+    return {
+      success: false,
+      instanceUuid,
+      error: response.errmsg || `errcode ${response.errcode}`,
+    };
+  }
+
+  const msgInfo = response.data?.msgInfo ?? {};
+  const messageId = msgInfo[receiver];
+
+  return {
+    success: true,
+    instanceUuid,
+    messageId,
+  };
+}
+
+export type UpdatePopoStreamCardParams = {
+  cfg: ClawdbotConfig;
+  templateUuid: string;
+  instanceUuid: string;
+  content: string;
+  sequence: number;
+  isFinalize?: boolean;
+  isError?: boolean;
+  streamKey?: string;
+};
+
+/**
+ * Update a streaming card's content in real-time.
+ * Use this to stream AI-generated content or progress updates.
+ */
+export async function updateStreamCardPopo(
+  params: UpdatePopoStreamCardParams
+): Promise<{ success: boolean; error?: string }> {
+  const {
+    cfg,
+    templateUuid,
+    instanceUuid,
+    content,
+    sequence,
+    isFinalize = false,
+    isError = false,
+    streamKey = "resultStream",
+  } = params;
+
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  if (!popoCfg) {
+    throw new Error("POPO channel not configured");
+  }
+
+  const response = await popoRequest<unknown>({
+    cfg: popoCfg,
+    method: "PUT",
+    path: "/open-apis/robots/v1/im/msg-card/stream",
+    body: {
+      instanceUuid,
+      templateUuid,
+      key: streamKey,
+      content,
+      sequence,
+      isFinalize,
+      isError,
+    },
+  });
+
+  if (response.errcode !== 0) {
+    return {
+      success: false,
+      error: response.errmsg || `errcode ${response.errcode}`,
+    };
+  }
+
+  return { success: true };
+}
+
+export type InstructionVariableOption = {
+  optionId: string;
+  optionValue: string;
+};
+
+export type UpdateInstructionVariableOptionsParams = {
+  cfg: ClawdbotConfig;
+  instructionId: string;
+  variableKey: string;
+  variableOptions: InstructionVariableOption[];
+};
+
+export type UpdateInstructionVariableOptionsResult = {
+  success: boolean;
+  error?: string;
+  traceId?: string;
+};
+
+/**
+ * Update dynamic options for an instruction variable.
+ * This allows robots to dynamically update the options shown in slash commands.
+ */
+export async function updateInstructionVariableOptions(
+  params: UpdateInstructionVariableOptionsParams
+): Promise<UpdateInstructionVariableOptionsResult> {
+  const { cfg, instructionId, variableKey, variableOptions } = params;
+  const popoCfg = cfg.channels?.popo as PopoConfig | undefined;
+  if (!popoCfg) {
+    throw new Error("POPO channel not configured");
+  }
+
+  const response = await popoRequest<{ traceId?: string }>({
+    cfg: popoCfg,
+    method: "POST",
+    path: "/open-apis/robots/v1/instruction/variable/options",
+    body: {
+      instructionId,
+      variableKey,
+      variableOptions,
+    },
+  });
+
+  if (response.errcode !== 0) {
+    return {
+      success: false,
+      error: response.errmsg || `errcode ${response.errcode}`,
+      traceId: response.data?.traceId,
+    };
+  }
+
+  return {
+    success: true,
+    traceId: response.data?.traceId,
+  };
+}

package/src/targets.ts

@@ -0,0 +1,68 @@
+export type PopoReceiverType = "email" | "groupId";
+
+/**
+ * Normalize a POPO target string.
+ * Supports formats:
+ * - "user:email@example.com" -> "email@example.com"
+ * - "group:123456" -> "123456"
+ * - "email@example.com" -> "email@example.com"
+ * - "123456" -> "123456"
+ */
+export function normalizePopoTarget(raw: string): string | null {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+
+  const lowered = trimmed.toLowerCase();
+  if (lowered.startsWith("user:")) {
+    return trimmed.slice("user:".length).trim() || null;
+  }
+  if (lowered.startsWith("group:")) {
+    return trimmed.slice("group:".length).trim() || null;
+  }
+
+  return trimmed;
+}
+
+/**
+ * Detect if a target is an email (P2P) or group ID.
+ */
+export function detectReceiverType(target: string): PopoReceiverType {
+  // If it contains @ it's an email
+  if (target.includes("@")) {
+    return "email";
+  }
+  // Otherwise assume it's a group ID
+  return "groupId";
+}
+
+/**
+ * Format a POPO target for display.
+ */
+export function formatPopoTarget(id: string, type?: PopoReceiverType): string {
+  const trimmed = id.trim();
+  const actualType = type ?? detectReceiverType(trimmed);
+
+  if (actualType === "email") {
+    return `user:${trimmed}`;
+  }
+  return `group:${trimmed}`;
+}
+
+/**
+ * Check if a string looks like a POPO ID.
+ */
+export function looksLikePopoId(raw: string): boolean {
+  const trimmed = raw.trim();
+  if (!trimmed) return false;
+
+  // Has prefix
+  if (/^(user|group):/i.test(trimmed)) return true;
+
+  // Looks like an email
+  if (/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(trimmed)) return true;
+
+  // Could be a group ID (numeric string)
+  if (/^\d+$/.test(trimmed)) return true;
+
+  return false;
+}