@zzedbot/yunzhijia 1.0.2

package/src/utils.ts

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import type { YunzhiJiaAccountConfig } from "./types.js";
+
+/**
+ * Verify YunzhiJia webhook signature using HmacSHA1 + Base64 (as per YunzhiJia documentation)
+ * Note: YunzhiJia documentation shows HmacSHA1 + Base64, but some implementations may use SHA256 + hex
+ * We'll implement both and allow configuration to choose
+ */
+export function verifySignature(
+  body: string,
+  signature: string,
+  appSecret: string,
+  skipSignatureVerification?: boolean,
+): boolean {
+  // Explicitly skip signature verification if configured
+  if (skipSignatureVerification) {
+    return true;
+  }
+  
+  // If no app secret configured, skip verification (for testing)
+  if (!appSecret) {
+    return true;
+  }
+  
+  // Parse the JSON body to extract fields for signature calculation
+  try {
+    const payload = JSON.parse(body);
+    const summaryInfo = [
+      payload.robotId,
+      payload.robotName,
+      payload.operatorOpenid,
+      payload.operatorName,
+      payload.time?.toString(),
+      payload.msgId,
+      payload.content
+    ].join(",");
+    
+    // Try HmacSHA1 + Base64 first (as per YunzhiJia documentation)
+    const hmacSha1 = createHmac('sha1', appSecret);
+    hmacSha1.update(summaryInfo);
+    const expectedSignatureBase64 = hmacSha1.digest('base64');
+    
+    if (signature === expectedSignatureBase64) {
+      return true;
+    }
+    
+    // Fallback to SHA256 + hex (current implementation)
+    const expectedSignatureSha256 = createHash("sha256")
+      .update(body + appSecret)
+      .digest("hex");
+      
+    return signature === expectedSignatureSha256;
+  } catch (error) {
+    console.error("Error parsing payload for signature verification:", error);
+    return false;
+  }
+}
+
+/**
+ * Create HMAC hash (Node.js compatible)
+ */
+function createHmac(algorithm: string, key: string) {
+  const crypto = require('node:crypto');
+  return crypto.createHmac(algorithm, key);
+}
+
+/**
+ * Format message for YunzhiJia webhook
+ */
+export function formatYunzhiJiaMessage(content: string): Record<string, unknown> {
+  return {
+    content: content,
+  };
+}
+
+/**
+ * Extract user info from YunzhiJia webhook payload
+ */
+export function extractUserInfo(payload: Record<string, unknown>) {
+  return {
+    userId: String(payload.operatorOpenid ?? "unknown"),
+    userName: String(payload.operatorName ?? "Unknown User"),
+    messageId: String(payload.msgId ?? Date.now().toString()),
+    content: String(payload.content ?? ""),
+    robotId: String(payload.robotId ?? "unknown"),
+    robotName: String(payload.robotName ?? "YunzhiJia Bot"),
+    time: Number(payload.time ?? Date.now()),
+  };
+}
+
+/**
+ * Check if bot is mentioned in the message content
+ */
+export function isBotMentioned(content: string, robotName: string): boolean {
+  // YunzhiJia mentions are typically in the format "@BotName"
+  const mentionPattern = new RegExp(`@${robotName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'i');
+  return mentionPattern.test(content) || content.includes('@ALL') || content.includes('@all');
+}
+
+/**
+ * Extract clean content by removing bot mention
+ */
+export function extractCleanContent(content: string, robotName: string): string {
+  // Remove bot mention patterns
+  const cleaned = content
+    .replace(new RegExp(`@${robotName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'gi'), '')
+    .replace(/@ALL/gi, '')
+    .replace(/@all/gi, '')
+    .trim();
+  
+  return cleaned || content; // Return original if nothing was cleaned
+}
+
+/**
+ * Create session key from sessionId and robotId
+ */
+export function createSessionKey(sessionId: string, robotId: string): string {
+  return `yunzhijia:${robotId}:${sessionId}`;
+}

package/src/webhook.ts

@@ -0,0 +1,50 @@
+import type { YunzhiJiaAccountConfig } from "./types.js";
+
+/**
+ * Send message to YunzhiJia webhook
+ */
+export async function sendToYunzhiJiaWebhook(
+  content: string,
+  accountConfig: YunzhiJiaAccountConfig,
+): Promise<void> {
+  if (!accountConfig.webhookToken) {
+    throw new Error("webhookToken is required");
+  }
+
+  const webhookUrl = `https://www.yunzhijia.com/gateway/robot/webhook/send?yzjtype=12&yzjtoken=${accountConfig.webhookToken}`;
+  const message = {
+    content: content,
+  };
+
+  try {
+    // Use the runtime's fetch implementation for proper error handling and proxy support
+    const response = await fetch(webhookUrl, {
+      method: 'POST',
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(message),
+      timeout: 10000,
+    });
+    
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+  } catch (error) {
+    console.error("Failed to send message to YunzhiJia:", error);
+    throw error;
+  }
+}
+
+/**
+ * Send media to YunzhiJia (placeholder - YunzhiJia may not support media directly)
+ */
+export async function sendMediaToYunzhiJia(
+  content: string,
+  mediaUrl: string,
+  accountConfig: YunzhiJiaAccountConfig,
+): Promise<void> {
+  // For now, just send the content with media URL as text
+  const messageWithMedia = `${content}\n${mediaUrl}`;
+  await sendToYunzhiJiaWebhook(messageWithMedia, accountConfig);
+}

package/test-import.mjs

@@ -0,0 +1,3 @@
+import { yunzhijiaPlugin } from './src/plugin.js';
+
+console.log('Plugin loaded successfully:', yunzhijiaPlugin.id);

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}