palz-connector 1.0.0

package/openclaw.plugin.json

@@ -0,0 +1,14 @@
+{
+  "id": "palz-connector",
+  "name": "Palz Connector Channel",
+  "version": "1.0.0",
+  "description": "Palz IM 接入 OpenClaw",
+  "channels": ["palz-connector"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "enabled": { "type": "boolean", "default": true }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "palz-connector",
+  "version": "1.0.0",
+  "description": "Palz IM 接入 OpenClaw",
+  "main": "plugin.ts",
+  "type": "module",
+  "scripts": {
+    "build": "echo 'No build needed - jiti loads TS at runtime'"
+  },
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "openclaw": {
+    "extensions": ["./plugin.ts"],
+    "channels": ["palz-connector"],
+    "installDependencies": true
+  }
+}

package/palz-connector.config.json

@@ -0,0 +1,6 @@
+{
+  "enabled": true,
+  "streamUrl": "ws://14.103.148.99:9090/ws/bot",
+  "apiBaseUrl": "http://14.103.148.99:9090/api",
+  "sessionTimeout": 1800000
+}

package/plugin.ts

@@ -0,0 +1,512 @@
+/**
+ * Palz Connector Channel Plugin for OpenClaw
+ *
+ * Palz IM 接入 OpenClaw。
+ * 通过 WebSocket 接收 IM 消息，调用 Gateway SSE 获取 AI 回复，再通过 REST API 发送回 IM。
+ */
+
+import WebSocket from 'ws';
+import { readFileSync } from 'fs';
+import { resolve, dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+
+// ============ 类型定义 ============
+
+type TextContentPart = { type: 'text'; text: string };
+type ImageUrlContentPart = { type: 'image_url'; image_url: { url: string; detail?: string } };
+type ContentPart = TextContentPart | ImageUrlContentPart;
+type OpenAIContent = string | ContentPart[];
+
+function extractPlainText(content: OpenAIContent): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((p): p is TextContentPart => p.type === 'text')
+      .map(p => p.text)
+      .join('');
+  }
+  return '';
+}
+
+// ============ 常量 & 配置 ============
+
+export const id = 'palz-connector';
+
+const FALLBACK_ACCOUNT_ID = '__default__';
+
+const NEW_SESSION_COMMANDS = ['/new', '/reset', '/clear', '新会话', '重新开始', '清空对话'];
+
+let runtime: any = null;
+let _imConfig: any = null;
+
+function getPluginDir(): string {
+  try {
+    return dirname(fileURLToPath(import.meta.url));
+  } catch {
+    return __dirname;
+  }
+}
+
+function readGatewayToken(log?: any): string {
+  try {
+    const openclawPath = join(homedir(), '.openclaw', 'openclaw.json');
+    const openclawConfig = JSON.parse(readFileSync(openclawPath, 'utf-8'));
+    const token = openclawConfig?.gateway?.auth?.token;
+    if (token) {
+      log?.info?.('[Palz] gatewayToken 从 ~/.openclaw/openclaw.json 读取');
+      return token;
+    }
+  } catch {
+    // 文件不存在或解析失败，继续尝试环境变量
+  }
+
+  if (process.env.GATEWAY_TOKEN) {
+    return process.env.GATEWAY_TOKEN;
+  }
+
+  log?.warn?.('[Palz] gatewayToken 未配置（~/.openclaw/openclaw.json 和环境变量 GATEWAY_TOKEN 均未设置）');
+  return '';
+}
+
+function loadIMConfig(log?: any): any {
+  const configPath = resolve(getPluginDir(), 'palz-connector.config.json');
+  try {
+    _imConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+  } catch (err: any) {
+    if (!_imConfig) {
+      log?.warn?.(`[Palz] 配置加载失败(${configPath}): ${err.message}，使用默认配置`);
+      _imConfig = { enabled: false };
+    }
+  }
+  if (!process.env.BOT_ID) {
+    log?.warn?.('[Palz] 环境变量 BOT_ID 未设置，botId 将为空');
+  }
+  _imConfig.botId = process.env.BOT_ID || '';
+  _imConfig.gatewayToken = readGatewayToken(log);
+  return _imConfig;
+}
+
+function getRuntime(): any {
+  if (!runtime) throw new Error('Palz runtime not initialized');
+  return runtime;
+}
+
+// ============ Session 管理 ============
+
+interface UserSession {
+  lastActivity: number;
+  sessionId: string;
+}
+
+const userSessions = new Map<string, UserSession>();
+
+const processedMessages = new Map<string, number>();
+const MESSAGE_DEDUP_TTL = 5 * 60 * 1000;
+
+function cleanupProcessedMessages(): void {
+  const now = Date.now();
+  for (const [msgId, ts] of processedMessages) {
+    if (now - ts > MESSAGE_DEDUP_TTL) processedMessages.delete(msgId);
+  }
+}
+
+function dedup(msgId: string): boolean {
+  if (!msgId) return false;
+  if (processedMessages.has(msgId)) return true;
+  processedMessages.set(msgId, Date.now());
+  if (processedMessages.size >= 100) cleanupProcessedMessages();
+  return false;
+}
+
+const userLocks = new Map<string, Promise<void>>();
+
+function withUserLock(senderId: string, fn: () => Promise<void>): void {
+  const prev = userLocks.get(senderId) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  userLocks.set(senderId, next);
+  next.finally(() => {
+    if (userLocks.get(senderId) === next) userLocks.delete(senderId);
+  });
+}
+
+function isNewSessionCommand(text: string): boolean {
+  const trimmed = text.trim().toLowerCase();
+  return NEW_SESSION_COMMANDS.some(cmd => trimmed === cmd.toLowerCase());
+}
+
+function getSessionKey(
+  senderId: string,
+  forceNew: boolean,
+  sessionTimeout: number,
+  log?: any,
+): { sessionKey: string; isNew: boolean } {
+  const now = Date.now();
+
+  if (forceNew) {
+    const sessionId = `palz:${senderId}:${now}`;
+    userSessions.set(senderId, { lastActivity: now, sessionId });
+    log?.info?.(`[Palz][Session] 用户主动开启新会话: ${senderId}`);
+    return { sessionKey: sessionId, isNew: true };
+  }
+
+  const existing = userSessions.get(senderId);
+  if (existing) {
+    const elapsed = now - existing.lastActivity;
+    if (elapsed > sessionTimeout) {
+      const sessionId = `palz:${senderId}:${now}`;
+      userSessions.set(senderId, { lastActivity: now, sessionId });
+      log?.info?.(`[Palz][Session] 会话超时(${Math.round(elapsed / 60000)}分钟)，自动开启新会话: ${senderId}`);
+      return { sessionKey: sessionId, isNew: true };
+    }
+    existing.lastActivity = now;
+    return { sessionKey: existing.sessionId, isNew: false };
+  }
+
+  const sessionId = `palz:${senderId}:${now}`;
+  userSessions.set(senderId, { lastActivity: now, sessionId });
+  log?.info?.(`[Palz][Session] 新用户首次会话: ${senderId}`);
+  return { sessionKey: sessionId, isNew: false };
+}
+
+// ============ Gateway SSE 客户端 ============
+
+const GATEWAY_TIMEOUT = 120_000;
+
+async function* streamFromGateway(
+  userContent: OpenAIContent,
+  sessionKey: string,
+  gatewayAuth: string,
+  log?: any,
+): AsyncGenerator<string> {
+  const rt = getRuntime();
+  const gatewayUrl = `http://127.0.0.1:${rt.gateway?.port || 18789}/v1/chat/completions`;
+
+  log?.info?.(`[Palz][Gateway] POST ${gatewayUrl}, session=${sessionKey}`);
+
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), GATEWAY_TIMEOUT);
+
+  let response: Response;
+  try {
+    response = await fetch(gatewayUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(gatewayAuth ? { Authorization: `Bearer ${gatewayAuth}` } : {}),
+      },
+      body: JSON.stringify({
+        model: 'main',
+        messages: [{ role: 'user', content: userContent }],
+        stream: true,
+        user: sessionKey,
+      }),
+      signal: controller.signal,
+    });
+  } catch (err: any) {
+    clearTimeout(timer);
+    throw err;
+  }
+
+  if (!response.ok || !response.body) {
+    clearTimeout(timer);
+    throw new Error(`Gateway error: ${response.status}`);
+  }
+
+  const reader = (response.body as any).getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue;
+        const data = line.slice(6).trim();
+        if (data === '[DONE]') return;
+        try {
+          const chunk = JSON.parse(data);
+          const content = chunk.choices?.[0]?.delta?.content;
+          if (content) yield content;
+        } catch {
+          // skip malformed JSON chunks
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ============ IM 消息发送 ============
+
+async function sendToIM(config: any, conversationId: string, content: OpenAIContent, log?: any) {
+  const botId = config.botId;
+  const url = `${config.apiBaseUrl}/bot/send`;
+  const contentLength = typeof content === 'string' ? content.length : JSON.stringify(content).length;
+  log?.info?.(`[Palz][Send] POST ${url}, bot_id=${botId}, conversation=${conversationId}, length=${contentLength}`);
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      bot_id: botId,
+      conversation_id: conversationId,
+      content,
+    }),
+  });
+
+  const body = await response.json().catch(() => null);
+
+  if (!response.ok) {
+    log?.error?.(`[Palz][Send] 发送消息失败: ${response.status} ${body?.error || ''}`);
+  }
+
+  return body;
+}
+
+// ============ 核心消息处理 ============
+
+function handleIMMessage(params: {
+  config: any;
+  msg: any;
+  log?: any;
+}) {
+  const { config, msg, log } = params;
+  const content: OpenAIContent = msg.content;
+  if (!content) return;
+
+  const plainText = extractPlainText(content).trim();
+  if (!plainText) return;
+
+  if (dedup(msg.msg_id)) {
+    log?.info?.(`[Palz] 跳过重复消息: ${msg.msg_id}`);
+    return;
+  }
+
+  const senderId = msg.sender_id;
+  const conversationId = msg.conversation_id;
+  log?.info?.(`[Palz] 收到消息: sender=${senderId}, bot_id=${config.botId}, conv=${conversationId}`);
+
+  withUserLock(senderId, async () => {
+    const sessionTimeout = config.sessionTimeout ?? 1800000;
+
+    if (isNewSessionCommand(plainText)) {
+      getSessionKey(senderId, true, sessionTimeout, log);
+      await sendToIM(config, conversationId, '✨ 已开启新会话', log);
+      return;
+    }
+
+    const { sessionKey } = getSessionKey(senderId, false, sessionTimeout, log);
+    const gatewayAuth = config.gatewayToken || '';
+
+    let fullResponse = '';
+    try {
+      for await (const chunk of streamFromGateway(content, sessionKey, gatewayAuth, log)) {
+        fullResponse += chunk;
+      }
+      await sendToIM(config, conversationId, fullResponse || '（无响应）', log);
+    } catch (err: any) {
+      log?.error?.(`[Palz][Gateway] 调用失败: ${err.message}`);
+      await sendToIM(config, conversationId, `抱歉，处理请求时出错: ${err.message}`, log);
+    }
+  });
+}
+
+// ============ IM WebSocket 客户端 ============
+
+interface IMConnection {
+  close(): void;
+}
+
+function connectToIM(config: any, onMessage: (msg: any) => void, log?: any): IMConnection {
+  const botId = config.botId;
+  if (!botId) throw new Error('Palz botId is required');
+
+  const baseUrl = config.streamUrl.replace(/\/$/, '');
+  const separator = baseUrl.includes('?') ? '&' : '?';
+  const wsUrl = `${baseUrl}${separator}bot_id=${encodeURIComponent(botId)}`;
+  let reconnectDelay = 1000;
+  let closed = false;
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  let currentWs: WebSocket | null = null;
+
+  function connect() {
+    if (closed) return;
+    const ws = new WebSocket(wsUrl);
+    currentWs = ws;
+
+    let connectedAt = 0;
+
+    ws.on('open', () => {
+      log?.info?.(`[Palz] WebSocket 已连接, bot_id=${botId}`);
+      connectedAt = Date.now();
+    });
+
+    ws.on('message', (data: Buffer) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.event !== 'message') return;
+        onMessage(msg);
+      } catch (err: any) {
+        log?.error?.(`[Palz] 消息解析失败: ${err.message}`);
+      }
+    });
+
+    ws.on('close', (code: number, reason: Buffer) => {
+      if (closed) return;
+      const stableMs = Date.now() - connectedAt;
+      const reasonStr = reason?.toString() || '';
+
+      if (code === 4002) {
+        log?.warn?.(`[Palz] WebSocket 被新连接替代 (code=${code}, reason=${reasonStr})，不再重连`);
+        closed = true;
+        return;
+      }
+
+      if (stableMs > 10_000) {
+        reconnectDelay = 1000;
+      }
+      log?.warn?.(`[Palz] WebSocket 断开 (code=${code}, reason=${reasonStr}, 连接维持${Math.round(stableMs / 1000)}s)，${reconnectDelay}ms 后重连`);
+      reconnectTimer = setTimeout(connect, reconnectDelay);
+      reconnectDelay = Math.min(reconnectDelay * 2, 30000);
+    });
+
+    ws.on('error', (err) => {
+      log?.error?.(`[Palz] WebSocket 错误: ${err.message}`);
+    });
+  }
+
+  connect();
+
+  return {
+    close() {
+      if (closed) return;
+      closed = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (currentWs) {
+        currentWs.removeAllListeners();
+        currentWs.close();
+        currentWs = null;
+      }
+    },
+  };
+}
+
+// ============ 活跃连接追踪 ============
+
+const activeConnections = new Map<string, IMConnection>();
+
+// ============ 插件定义 ============
+
+const palzPlugin = {
+  id: 'palz-connector',
+  meta: {
+    id: 'palz-connector',
+    label: 'Palz Connector',
+    selectionLabel: 'Palz Connector (IM)',
+    blurb: 'Palz IM 接入 OpenClaw',
+  },
+  capabilities: { chatTypes: ['direct'] },
+  config: {
+    listAccountIds: () => {
+      const imCfg = loadIMConfig();
+      if (!imCfg?.enabled) return [];
+      return [imCfg.botId || FALLBACK_ACCOUNT_ID];
+    },
+    resolveAccount: (_cfg: any, accountId?: string) => {
+      const imCfg = loadIMConfig();
+      return {
+        accountId: accountId || imCfg?.botId || FALLBACK_ACCOUNT_ID,
+        config: imCfg,
+        enabled: imCfg.enabled !== false,
+      };
+    },
+    defaultAccountId: () => {
+      const imCfg = loadIMConfig();
+      return imCfg?.botId || FALLBACK_ACCOUNT_ID;
+    },
+    isConfigured: (account: any) =>
+      Boolean(account.config?.botId && account.config?.streamUrl && account.config?.apiBaseUrl),
+    describeAccount: (account: any) => ({
+      accountId: account.accountId,
+      name: `Palz Connector (${account.config?.botId || 'unconfigured'})`,
+      enabled: account.enabled,
+      configured: Boolean(account.config?.botId && account.config?.streamUrl),
+    }),
+  },
+  outbound: {
+    deliveryMode: 'direct' as const,
+    sendText: async (ctx: any) => {
+      const config = loadIMConfig(ctx.log);
+      await sendToIM(config, ctx.to, ctx.text, ctx.log);
+      return { channel: 'palz-connector', messageId: Date.now().toString() };
+    },
+  },
+  gateway: {
+    startAccount: (ctx: any) => {
+      const { account, abortSignal } = ctx;
+      const config = account.config;
+
+      if (!config.botId || !config.streamUrl || !config.apiBaseUrl) {
+        throw new Error('Palz botId, streamUrl and apiBaseUrl are required');
+      }
+
+      ctx.log?.info?.(`[${account.accountId}] 启动 Palz WebSocket 客户端...`);
+
+      const connKey = config.botId;
+      const oldConn = activeConnections.get(connKey);
+      if (oldConn) {
+        ctx.log?.info?.(`[${account.accountId}] 关闭旧的 WebSocket 连接...`);
+        oldConn.close();
+        activeConnections.delete(connKey);
+      }
+
+      const conn = connectToIM(config, (msg) => {
+        handleIMMessage({ config, msg, log: ctx.log });
+      }, ctx.log);
+
+      activeConnections.set(connKey, conn);
+      ctx.log?.info?.(`[${account.accountId}] Palz WebSocket 客户端已启动`);
+
+      return new Promise<void>((resolve) => {
+        let stopped = false;
+        function shutdown() {
+          if (stopped) return;
+          stopped = true;
+          conn.close();
+          activeConnections.delete(connKey);
+          ctx.log?.info?.(`[${account.accountId}] Palz Channel 已停止`);
+          resolve();
+        }
+
+        if (abortSignal) {
+          if (abortSignal.aborted) {
+            shutdown();
+            return;
+          }
+          abortSignal.addEventListener('abort', shutdown);
+        }
+      });
+    },
+  },
+};
+
+// ============ 插件注册 ============
+
+const plugin = {
+  id: 'palz-connector',
+  name: 'Palz Connector Channel',
+  description: 'Palz IM 接入 OpenClaw',
+  register(api: any) {
+    runtime = api.runtime;
+    api.registerChannel({ plugin: palzPlugin });
+    api.logger?.info('[Palz] 插件已注册');
+  },
+};
+
+export default plugin;