@glin_1/miniabc 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glin_1/miniabc",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "智工坊智能任务平台 OpenClaw 插件 - 发布和接受AI任务，发推文，赚收益",
   "main": "index.ts",
   "types": "index.ts",

package/src/channel.ts

@@ -179,21 +179,120 @@ export const miniabcPlugin: ChannelPlugin<ResolvedMiniABCAccount> = {
     },
   },
 
-  connect: async ({ account, onEvent }) => {
-    console.log(`[miniabc] Connecting to ${account.platformUrl}...`);
-    console.log(`[miniabc] Bot ID: ${account.botId}`);
-    
-    return {
-      connected: true,
-      metadata: {
-        botId: account.botId,
-        platformUrl: account.platformUrl,
-      },
-    };
-  },
-
-  disconnect: async ({ account }) => {
-    console.log(`[miniabc] Disconnected from ${account.accountId}`);
+  gateway: {
+    startAccount: async (ctx) => {
+      const { account, abortSignal, log, cfg } = ctx;
+      
+      log?.info(`[miniabc:${account.accountId}] Starting gateway — botId=${account.botId}, enabled=${account.enabled}`);
+      console.log(`[miniabc:channel] startAccount: accountId=${account.accountId}, botId=${account.botId}`);
+      
+      // 建立 WebSocket 连接接收任务通知
+      const wsUrl = account.wsUrl || `${account.platformUrl.replace('https://', 'wss://').replace('http://', 'ws://')}/ws/openclaw`;
+      
+      const ws = new WebSocket(wsUrl);
+      let heartbeatInterval: NodeJS.Timeout | null = null;
+      
+      // 创建一个 Promise 来保持函数运行,直到 WebSocket 关闭或 abort
+      return new Promise<void>((resolve, reject) => {
+        ws.onopen = () => {
+          log?.info(`[miniabc:${account.accountId}] WebSocket connected to ${wsUrl}`);
+          console.log(`[miniabc] WebSocket connected to ${wsUrl}`);
+          
+          // 发送认证
+          ws.send(JSON.stringify({
+            type: 'auth',
+            payload: { botId: account.botId, token: account.token }
+          }));
+          
+          // 设置心跳
+          heartbeatInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: 'heartbeat' }));
+            }
+          }, 30000);
+        };
+        
+        ws.onmessage = (event) => {
+          try {
+            const data = JSON.parse(event.data as string);
+            log?.debug(`[miniabc:${account.accountId}] WebSocket message: ${data.type}`);
+            
+            switch (data.type) {
+              case 'new_task':
+                // 收到新任务,触发 inbound 事件
+                log?.info(`[miniabc:${account.accountId}] New task received: ${data.payload.task.id}`);
+                ctx.onInbound({
+                  type: 'message',
+                  channel: 'miniabc',
+                  accountId: account.accountId,
+                  from: { id: data.payload.task.publisher_id, name: 'TaskPublisher' },
+                  text: `新任务: ${data.payload.task.content}`,
+                  raw: data.payload.task,
+                });
+                break;
+              case 'new_message':
+                // 收到新消息
+                log?.info(`[miniabc:${account.accountId}] New message received`);
+                ctx.onInbound({
+                  type: 'message',
+                  channel: 'miniabc',
+                  accountId: account.accountId,
+                  from: { id: data.payload.message.bot_id, name: 'System' },
+                  text: data.payload.message.content,
+                  raw: data.payload.message,
+                });
+                break;
+              case 'auth_success':
+                log?.info(`[miniabc:${account.accountId}] WebSocket authenticated: ${data.payload.botId}`);
+                ctx.setStatus({
+                  ...ctx.getStatus(),
+                  running: true,
+                  connected: true,
+                  lastConnectedAt: Date.now(),
+                });
+                break;
+              case 'pong':
+                // Heartbeat response
+                break;
+            }
+          } catch (e) {
+            log?.error(`[miniabc:${account.accountId}] WebSocket message parse error: ${e}`);
+          }
+        };
+        
+        ws.onerror = (error) => {
+          log?.error(`[miniabc:${account.accountId}] WebSocket error: ${error}`);
+          ctx.setStatus({
+            ...ctx.getStatus(),
+            lastError: String(error),
+          });
+        };
+        
+        ws.onclose = () => {
+          log?.info(`[miniabc:${account.accountId}] WebSocket disconnected`);
+          if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+          }
+          ctx.setStatus({
+            ...ctx.getStatus(),
+            running: false,
+            connected: false,
+          });
+          resolve();
+        };
+        
+        // 监听 abort 信号
+        if (abortSignal) {
+          abortSignal.addEventListener('abort', () => {
+            log?.info(`[miniabc:${account.accountId}] Gateway stopped by abort signal`);
+            if (heartbeatInterval) {
+              clearInterval(heartbeatInterval);
+            }
+            ws.close();
+          });
+        }
+      });
+    },
   },
 
   sendText: async ({ account, target, text }) => {
@@ -223,4 +322,31 @@ export const miniabcPlugin: ChannelPlugin<ResolvedMiniABCAccount> = {
 
     throw new Error("Direct messaging not supported.");
   },
+
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      connected: false,
+      lastConnectedAt: null,
+      lastError: null,
+      lastInboundAt: null,
+      lastOutboundAt: null,
+    },
+    buildChannelSummary: ({ snapshot }: { snapshot: Record<string, unknown> }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      connected: snapshot.connected ?? false,
+      lastConnectedAt: snapshot.lastConnectedAt ?? null,
+      lastError: snapshot.lastError ?? null,
+    }),
+    buildAccountSnapshot: ({ account, runtime }: { account?: ResolvedMiniABCAccount; runtime?: Record<string, unknown> }) => ({
+      accountId: account?.accountId ?? DEFAULT_ACCOUNT_ID,
+      name: account?.name,
+      enabled: account?.enabled ?? false,
+      configured: Boolean(account?.botId && account?.token),
+      platformUrl: account?.platformUrl,
+      ...(runtime ?? {}),
+    }),
+  },
 };