adp-openclaw 0.0.2 → 0.0.4

package/e2e_test.cjs

@@ -0,0 +1,98 @@
+const WebSocket = require('ws');
+
+// 测试配置
+const token = '334b209ed0833464202cc4438e7ce801583fc74c13384cbac60d02949f33e09c';
+const host = '101.32.33.231';
+const port = 9876;
+
+console.log('🧪 OpenClaw 发送消息测试');
+console.log(`📍 目标服务器: ${host}:${port}`);
+console.log(`🔑 Token: ${token.slice(0, 16)}...\n`);
+
+// Step 1: 测试 WebSocket 连接
+console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+console.log('1️⃣ 连接 WebSocket...');
+const ws = new WebSocket(`ws://${host}:${port}/ws`);
+
+ws.on('open', () => {
+  console.log('   ✅ WebSocket 连接成功');
+  console.log('   📤 发送认证请求...');
+  ws.send(JSON.stringify({ type: 'auth', payload: { token, name: 'e2e-test-client' } }));
+});
+
+ws.on('message', (data) => {
+  const msg = JSON.parse(data.toString());
+  console.log('   📥 收到消息:', msg.type);
+  
+  if (msg.type === 'auth_result') {
+    console.log('   完整响应:', JSON.stringify(msg.payload, null, 2));
+    if (msg.payload.success) {
+      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+      console.log('2️⃣ 认证成功');
+      console.log('   ClientID:', msg.payload.clientId);
+      
+      // Step 3: 发送 outbound 消息 (Bot 回复)
+      setTimeout(() => {
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('3️⃣ 发送 outbound 消息...');
+        
+        const requestId = 'req-' + Date.now() + '-test';
+        const testMessage = {
+          type: 'outbound',
+          requestId: requestId,
+          payload: {
+            to: 'test-user',
+            text: '🎉 这是来自 E2E 测试的消息！时间: ' + new Date().toLocaleString('zh-CN'),
+            conversationId: 'conv-test-' + Date.now()
+          },
+          timestamp: Date.now()
+        };
+        
+        console.log('   发送内容:', JSON.stringify(testMessage, null, 2));
+        ws.send(JSON.stringify(testMessage));
+        
+        console.log('   📤 消息已发送，等待服务器确认 (ack)...');
+      }, 500);
+    } else {
+      console.log('   ❌ 认证失败:', msg.payload.message || msg.payload.error);
+      ws.close();
+    }
+  }
+  
+  // 处理服务器的响应
+  if (msg.type === 'ack') {
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('4️⃣ 收到服务器确认 (ack)');
+    console.log('   确认内容:', JSON.stringify(msg.payload, null, 2));
+    if (msg.payload?.ok) {
+      console.log('   ✅ 消息发送成功！');
+      console.log('   消息ID:', msg.payload.message?.id);
+    } else {
+      console.log('   ❌ 消息发送失败');
+    }
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('✅ 测试完成！');
+    ws.close();
+  }
+  
+  if (msg.type === 'error') {
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('❌ 服务器错误:', JSON.stringify(msg.payload, null, 2));
+    ws.close();
+  }
+});
+
+ws.on('error', (err) => {
+  console.log('   ❌ WebSocket 错误:', err.message);
+});
+
+ws.on('close', () => {
+  console.log('\n📴 连接已关闭');
+  process.exit(0);
+});
+
+// 超时处理
+setTimeout(() => {
+  console.log('\n⏱️ 测试超时 (10秒)');
+  ws.close();
+}, 10000);

package/index.ts

@@ -1,16 +1,17 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
-import { simpleGoPlugin } from "./src/channel.js";
-import { setSimpleGoRuntime } from "./src/runtime.js";
+import { adpOpenclawPlugin } from "./src/channel.js";
+import { setAdpOpenclawRuntime } from "./src/runtime.js";
 
 const plugin = {
-  id: "simplego",
-  name: "Simple Go",
-  description: "Demo channel plugin backed by a Go HTTP server",
+  id: "adp-openclaw",
+  name: "ADP OpenClaw",
+  description: "ADP channel plugin backed by a Go WebSocket server",
   configSchema: emptyPluginConfigSchema(),
   register(api: OpenClawPluginApi) {
-    setSimpleGoRuntime(api.runtime);
-    api.registerChannel({ plugin: simpleGoPlugin });
+    console.log("[adp-openclaw] register() called");
+    setAdpOpenclawRuntime(api.runtime);
+    api.registerChannel({ plugin: adpOpenclawPlugin });
   },
 };
 

package/openclaw.plugin.json

@@ -1,22 +1,9 @@
 {
-  "id": "simplego",
-  "name": "@openclaw/simplego",
-  "version": "0.0.1",
-  "description": "OpenClaw demo channel plugin (Go HTTP backend)",
+  "id": "adp-openclaw",
+  "channels": ["adp-openclaw"],
   "configSchema": {
     "type": "object",
-    "properties": {},
-    "additionalProperties": false
-  },
-  "extensions": [
-    "./index.ts"
-  ],
-  "channel": {
-    "id": "simplego",
-    "label": "Simple Go",
-    "selectionLabel": "Simple Go (demo)",
-    "docsPath": "/channels/simplego",
-    "blurb": "demo channel backed by a Go HTTP server.",
-    "order": 999
+    "additionalProperties": false,
+    "properties": {}
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "OpenClaw demo channel plugin (Go WebSocket backend)",
   "type": "module",
   "dependencies": {
@@ -15,11 +15,11 @@
       "./index.ts"
     ],
     "channel": {
-      "id": "adp",
-      "label": "Simple Go",
-      "selectionLabel": "Simple Go (demo)",
-      "docsPath": "/channels/adp",
-      "blurb": "demo channel backed by a Go HTTP server.",
+      "id": "adp-openclaw",
+      "label": "ADP OpenClaw",
+      "selectionLabel": "ADP OpenClaw",
+      "docsPath": "/channels/adp-openclaw",
+      "blurb": "ADP channel backed by a Go WebSocket server.",
       "order": 999
     }
   }

package/src/channel.ts

@@ -1,25 +1,23 @@
-// Simple Go channel plugin for OpenClaw
+// ADP OpenClaw channel plugin for OpenClaw
 // Supports: API Token auth, multiple clients, multi-turn conversations
 
 import {
   type ChannelPlugin,
+  type ClawdbotConfig,
   DEFAULT_ACCOUNT_ID,
-  setAccountEnabledInConfigSection,
-  deleteAccountFromConfigSection,
 } from "openclaw/plugin-sdk";
 
-export type SimpleGoConfig = {
-  channels?: {
-    simplego?: {
-      enabled?: boolean;
-      serverUrl?: string;
-      apiToken?: string; // Client API token for authentication
-      pollIntervalMs?: number;
-    };
-  };
+// Channel-level config type (from channels["adp-openclaw"])
+export type AdpOpenclawChannelConfig = {
+  enabled?: boolean;
+  serverUrl?: string;
+  wsUrl?: string;
+  apiToken?: string;
+  clientToken?: string;
+  pollIntervalMs?: number;
 };
 
-export type ResolvedSimpleGoAccount = {
+export type ResolvedAdpOpenclawAccount = {
   accountId: string;
   name: string;
   enabled: boolean;
@@ -29,35 +27,67 @@ export type ResolvedSimpleGoAccount = {
   pollIntervalMs: number;
 };
 
-function resolveAccount(cfg: SimpleGoConfig, accountId?: string): ResolvedSimpleGoAccount {
-  const section = cfg.channels?.simplego ?? {};
-  // Use environment variables as fallback
-  const serverUrl = section.serverUrl?.trim() ||
-                    process.env.SIMPLEGO_SERVER_URL ||
-                    "http://localhost:9876";
-  const apiToken = section.apiToken?.trim() ||
-                   process.env.SIMPLEGO_API_TOKEN ||
-                   "92527c1a861bb50bd1acc47180ef317369e97529c7a5491b2bc67839992cfbb8";
+function resolveAdpOpenclawCredentials(channelCfg?: AdpOpenclawChannelConfig): {
+  serverUrl: string;
+  apiToken: string;
+  pollIntervalMs: number;
+} | null {
+  // Get serverUrl: support both serverUrl and wsUrl
+  let serverUrl = channelCfg?.serverUrl?.trim();
+  if (!serverUrl && channelCfg?.wsUrl) {
+    // Convert ws://host:port/ws to http://host:port
+    serverUrl = channelCfg.wsUrl
+      .replace(/^wss:\/\//, "https://")
+      .replace(/^ws:\/\//, "http://")
+      .replace(/\/ws\/?$/, "");
+  }
+  if (!serverUrl) {
+    serverUrl = process.env.ADP_OPENCLAW_SERVER_URL || "";
+  }
+
+  // Get apiToken: support both apiToken and clientToken
+  let apiToken = channelCfg?.apiToken?.trim();
+  if (!apiToken && channelCfg?.clientToken) {
+    apiToken = channelCfg.clientToken.trim();
+  }
+  if (!apiToken) {
+    apiToken = process.env.ADP_OPENCLAW_API_TOKEN || "";
+  }
+
+  // Both are required for configured status
+  if (!serverUrl || !apiToken) {
+    return null;
+  }
+
+  const pollIntervalMs = channelCfg?.pollIntervalMs ?? 1000;
+
+  return { serverUrl, apiToken, pollIntervalMs };
+}
+
+function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpenclawAccount {
+  const channelCfg = cfg.channels?.["adp-openclaw"] as AdpOpenclawChannelConfig | undefined;
+  const enabled = channelCfg?.enabled !== false;
+  const creds = resolveAdpOpenclawCredentials(channelCfg);
 
   return {
-    accountId: accountId || DEFAULT_ACCOUNT_ID,
-    name: "Simple Go",
-    enabled: section.enabled !== false,
-    configured: Boolean(serverUrl && apiToken), // Always configured if we have values
-    serverUrl,
-    apiToken,
-    pollIntervalMs: section.pollIntervalMs ?? 1000,
+    accountId: accountId?.trim() || DEFAULT_ACCOUNT_ID,
+    name: "ADP OpenClaw",
+    enabled,
+    configured: Boolean(creds),
+    serverUrl: creds?.serverUrl || "http://localhost:9876",
+    apiToken: creds?.apiToken || "",
+    pollIntervalMs: creds?.pollIntervalMs || 1000,
   };
 }
 
-export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
-  id: "simplego",
+export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
+  id: "adp-openclaw",
   meta: {
-    id: "simplego",
-    label: "Simple Go",
-    selectionLabel: "Simple Go (demo)",
-    docsPath: "/channels/simplego",
-    blurb: "Demo channel backed by a Go HTTP server.",
+    id: "adp-openclaw",
+    label: "ADP OpenClaw",
+    selectionLabel: "ADP OpenClaw",
+    docsPath: "/channels/adp-openclaw",
+    blurb: "ADP channel backed by a Go WebSocket server.",
     order: 999,
   },
   capabilities: {
@@ -67,27 +97,48 @@ export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
     threads: false,
     media: false,
   },
-  reload: { configPrefixes: ["channels.simplego"] },
+  reload: { configPrefixes: ["channels.adp-openclaw"] },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        serverUrl: { type: "string" },
+        wsUrl: { type: "string" },
+        apiToken: { type: "string" },
+        clientToken: { type: "string" },
+        pollIntervalMs: { type: "integer", minimum: 100 },
+      },
+    },
+  },
   config: {
     listAccountIds: () => [DEFAULT_ACCOUNT_ID],
-    resolveAccount: (cfg, accountId) => resolveAccount(cfg as SimpleGoConfig, accountId),
+    resolveAccount: (cfg) => resolveAccount(cfg),
     defaultAccountId: () => DEFAULT_ACCOUNT_ID,
-    setAccountEnabled: ({ cfg, accountId, enabled }) =>
-      setAccountEnabledInConfigSection({
-        cfg: cfg as SimpleGoConfig,
-        sectionKey: "simplego",
-        accountId,
-        enabled,
-        allowTopLevel: true,
-      }),
-    deleteAccount: ({ cfg, accountId }) =>
-      deleteAccountFromConfigSection({
-        cfg: cfg as SimpleGoConfig,
-        sectionKey: "simplego",
-        accountId,
-        clearBaseFields: ["serverUrl", "apiToken", "pollIntervalMs"],
-      }),
-    isConfigured: (account) => account.configured,
+    setAccountEnabled: ({ cfg, enabled }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        "adp-openclaw": {
+          ...cfg.channels?.["adp-openclaw"],
+          enabled,
+        },
+      },
+    }),
+    deleteAccount: ({ cfg }) => {
+      const next = { ...cfg } as ClawdbotConfig;
+      const nextChannels = { ...cfg.channels };
+      delete (nextChannels as Record<string, unknown>)["adp-openclaw"];
+      if (Object.keys(nextChannels).length > 0) {
+        next.channels = nextChannels;
+      } else {
+        delete next.channels;
+      }
+      return next;
+    },
+    isConfigured: (_account, cfg) =>
+      Boolean(resolveAdpOpenclawCredentials(cfg.channels?.["adp-openclaw"] as AdpOpenclawChannelConfig | undefined)),
     describeAccount: (account) => ({
       accountId: account.accountId,
       name: account.name,
@@ -100,38 +151,16 @@ export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
   },
   setup: {
     resolveAccountId: () => DEFAULT_ACCOUNT_ID,
-    validateInput: ({ input }: { input: Record<string, string | undefined> }) => {
-      // Accept both standard names (url, token) and custom names (serverUrl, apiToken)
-      const serverUrl = input.url || input.serverUrl;
-      const apiToken = input.token || input.apiToken;
-
-      if (!serverUrl?.trim()) {
-        return "Simple Go requires --url (server URL)";
-      }
-      if (!apiToken?.trim()) {
-        return "Simple Go requires --token (API token)";
-      }
-      return null;
-    },
-    applyAccountConfig: ({ cfg, input }) => {
-      const existing = (cfg as SimpleGoConfig).channels?.simplego ?? {};
-      // Accept both standard names and custom names
-      const serverUrl = input.url || input.serverUrl;
-      const apiToken = input.token || input.apiToken;
-
-      return {
-        ...cfg,
-        channels: {
-          ...(cfg as SimpleGoConfig).channels,
-          simplego: {
-            ...existing,
-            enabled: true,
-            serverUrl: serverUrl?.trim() || existing.serverUrl || "http://localhost:9876",
-            apiToken: apiToken?.trim() || existing.apiToken,
-          },
+    applyAccountConfig: ({ cfg }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        "adp-openclaw": {
+          ...cfg.channels?.["adp-openclaw"],
+          enabled: true,
         },
-      };
-    },
+      },
+    }),
   },
   status: {
     defaultRuntime: {
@@ -151,7 +180,7 @@ export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
       lastError: snapshot.lastError ?? null,
     }),
     probeAccount: async ({ cfg, timeoutMs }) => {
-      const account = resolveAccount(cfg as SimpleGoConfig);
+      const account = resolveAccount(cfg);
       const start = Date.now();
       try {
         const controller = new AbortController();
@@ -188,15 +217,16 @@ export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
     startAccount: async (ctx) => {
       const account = ctx.account;
       ctx.setStatus({ accountId: account.accountId, baseUrl: account.serverUrl });
-      ctx.log?.info(`[simplego] starting poll loop → ${account.serverUrl}`);
+      ctx.log?.info(`[adp-openclaw] starting poll loop → ${account.serverUrl}`);
 
-      const { monitorSimpleGo } = await import("./monitor.js");
-      return monitorSimpleGo({
+      const { monitorAdpOpenclaw } = await import("./monitor.js");
+      return monitorAdpOpenclaw({
         serverUrl: account.serverUrl,
         apiToken: account.apiToken,
         pollIntervalMs: account.pollIntervalMs,
         abortSignal: ctx.abortSignal,
         log: ctx.log,
+        cfg: ctx.cfg,
       });
     },
   },
@@ -212,7 +242,7 @@ export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
         tenantId?: string;
       };
     }) => {
-      const account = resolveAccount(cfg as SimpleGoConfig);
+      const account = resolveAccount(cfg as ClawdbotConfig);
       const conversationId = context?.conversationId || "";
       
       // Extract user info from context for response tracing

package/src/config-schema.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const SimpleGoConfigSchema = z.object({
+export const AdpOpenclawConfigSchema = z.object({
   enabled: z.boolean().optional(),
   serverUrl: z.string().optional(),
   apiToken: z.string().optional(),