adp-openclaw 0.0.2 → 0.0.4

package/src/monitor.ts

@@ -1,8 +1,8 @@
 // Monitor: WebSocket connection to Go server for real-time message handling
 // Supports: API Token auth, conversation tracking for multi-turn dialogues
 
-import type { PluginLogger } from "openclaw/plugin-sdk";
-import { getSimpleGoRuntime } from "./runtime.js";
+import type { PluginLogger, ClawdbotConfig } from "openclaw/plugin-sdk";
+import { getAdpOpenclawRuntime } from "./runtime.js";
 import crypto from "crypto";
 
 export type MonitorParams = {
@@ -11,6 +11,7 @@ export type MonitorParams = {
   pollIntervalMs: number; // Used as reconnect delay
   abortSignal?: AbortSignal;
   log?: PluginLogger;
+  cfg?: ClawdbotConfig; // OpenClaw config for model settings
 };
 
 // WebSocket message types
@@ -77,14 +78,14 @@ function generateRequestId(): string {
   return `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
 
-export async function monitorSimpleGo(params: MonitorParams): Promise<void> {
-  const { serverUrl, apiToken, pollIntervalMs, abortSignal, log } = params;
-  const runtime = getSimpleGoRuntime();
+export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
+  const { serverUrl, apiToken, pollIntervalMs, abortSignal, log, cfg } = params;
+  const runtime = getAdpOpenclawRuntime();
 
   // Convert HTTP URL to WebSocket URL
   const wsUrl = serverUrl.replace(/^http/, "ws") + "/ws";
 
-  log?.info(`[simplego] WebSocket monitor started, connecting to ${wsUrl}`);
+  log?.info(`[adp-openclaw] WebSocket monitor started, connecting to ${wsUrl}`);
 
   while (!abortSignal?.aborted) {
     try {
@@ -95,20 +96,21 @@ export async function monitorSimpleGo(params: MonitorParams): Promise<void> {
         abortSignal,
         log,
         runtime,
+        cfg,
       });
     } catch (err) {
       if (abortSignal?.aborted) break;
-      log?.error(`[simplego] WebSocket error: ${err}`);
+      log?.error(`[adp-openclaw] WebSocket error: ${err}`);
     }
 
     // Wait before reconnecting
     if (!abortSignal?.aborted) {
-      log?.info(`[simplego] Reconnecting in ${pollIntervalMs}ms...`);
+      log?.info(`[adp-openclaw] Reconnecting in ${pollIntervalMs}ms...`);
       await sleep(pollIntervalMs, abortSignal);
     }
   }
 
-  log?.info(`[simplego] WebSocket monitor stopped`);
+  log?.info(`[adp-openclaw] WebSocket monitor stopped`);
 }
 
 type ConnectParams = {
@@ -117,11 +119,12 @@ type ConnectParams = {
   serverUrl: string;
   abortSignal?: AbortSignal;
   log?: PluginLogger;
-  runtime: ReturnType<typeof getSimpleGoRuntime>;
+  runtime: ReturnType<typeof getAdpOpenclawRuntime>;
+  cfg?: ClawdbotConfig;
 };
 
 async function connectAndHandle(params: ConnectParams): Promise<void> {
-  const { wsUrl, apiToken, serverUrl, abortSignal, log, runtime } = params;
+  const { wsUrl, apiToken, serverUrl, abortSignal, log, runtime, cfg } = params;
 
   // Dynamic import for WebSocket (works in both Node.js and browser)
   const WebSocket = (await import("ws")).default;
@@ -139,7 +142,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
     abortSignal?.addEventListener("abort", abortHandler);
 
     ws.on("open", () => {
-      log?.info(`[simplego] WebSocket connected, authenticating...`);
+      log?.info(`[adp-openclaw] WebSocket connected, authenticating...`);
 
       // Send authentication message with signature
       const nonce = generateNonce();
@@ -168,7 +171,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             const result = msg.payload as AuthResultPayload;
             if (result.success) {
               authenticated = true;
-              log?.info(`[simplego] Authenticated as client ${result.clientId}`);
+              log?.info(`[adp-openclaw] Authenticated as client ${result.clientId}`);
 
               // Start ping interval
               pingInterval = setInterval(() => {
@@ -181,7 +184,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 }
               }, 25000);
             } else {
-              log?.error(`[simplego] Authentication failed: ${result.message}`);
+              log?.error(`[adp-openclaw] Authentication failed: ${result.message}`);
               ws.close();
             }
             break;
@@ -195,7 +198,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
             if (!authenticated) break;
 
             const inMsg = msg.payload as InboundMessage;
-            log?.info(`[simplego] Received: ${inMsg.from}: ${inMsg.text} (conv=${inMsg.conversationId}, user=${JSON.stringify(inMsg.user || {})})`);
+            log?.info(`[adp-openclaw] Received: ${inMsg.from}: ${inMsg.text} (conv=${inMsg.conversationId}, user=${JSON.stringify(inMsg.user || {})})`);
 
             // Process the message with full user identity
             try {
@@ -218,36 +221,49 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 }
               }
 
+              // Use resolveAgentRoute to get proper sessionKey (like QQBot does)
+              // This ensures session history is correctly associated
+              const peerId = inMsg.conversationId;
+              const route = runtime.channel.routing.resolveAgentRoute({
+                cfg: cfg ?? {},
+                channel: "adp-openclaw",
+                accountId: "default",
+                peer: {
+                  kind: "dm",  // direct message
+                  id: peerId,
+                },
+              });
+
               const ctx = runtime.channel.reply.finalizeInboundContext({
                 Body: inMsg.text,
                 RawBody: inMsg.text,
                 CommandBody: inMsg.text,
-                // User identity: format as "simplego:{tenantId}:{userId}" for multi-tenant support
-                From: `simplego:${tenantPrefix}${userIdentifier}`,
-                To: `simplego:bot`,
-                // SessionKey uses conversationId for multi-turn dialogue tracking per user
-                SessionKey: inMsg.conversationId,
-                AccountId: "default",
+                // User identity: format as "adp-openclaw:{tenantId}:{userId}" for multi-tenant support
+                From: `adp-openclaw:${tenantPrefix}${userIdentifier}`,
+                To: `adp-openclaw:bot`,
+                // SessionKey from resolveAgentRoute for proper session history tracking
+                SessionKey: route.sessionKey,
+                AccountId: route.accountId,
                 ChatType: "direct",
                 // SenderId carries the raw user ID for identification
                 SenderId: userIdentifier,
-                Provider: "simplego",
-                Surface: inMsg.user?.source || "simplego",
+                Provider: "adp-openclaw",
+                Surface: inMsg.user?.source || "adp-openclaw",
                 MessageSid: inMsg.id,
                 MessageSidFull: inMsg.id,
-                OriginatingChannel: "simplego",
-                OriginatingTo: "simplego:bot",
+                OriginatingChannel: "adp-openclaw",
+                OriginatingTo: "adp-openclaw:bot",
                 // Pass user metadata through context (like Feishu does)
                 ...userMetadata,
               });
 
               await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                 ctx,
-                cfg: {},
+                cfg: cfg ?? {},
                 dispatcherOptions: {
                   deliver: async (payload: { text: string }) => {
                     const displayName = inMsg.user?.username || inMsg.from;
-                    log?.info(`[simplego] Sending reply to ${displayName}: ${payload.text.slice(0, 50)}...`);
+                    log?.info(`[adp-openclaw] Sending reply to ${displayName}: ${payload.text.slice(0, 50)}...`);
 
                     // Send via WebSocket
                     const outMsg: WSMessage = {
@@ -266,39 +282,39 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                     ws.send(JSON.stringify(outMsg));
                   },
                   onError: (err: Error) => {
-                    log?.error(`[simplego] Reply error: ${err.message}`);
+                    log?.error(`[adp-openclaw] Reply error: ${err.message}`);
                   },
                 },
               });
             } catch (err) {
-              log?.error(`[simplego] Failed to process message: ${err}`);
+              log?.error(`[adp-openclaw] Failed to process message: ${err}`);
             }
             break;
           }
 
           case MsgType.Ack:
             // Message acknowledgment
-            log?.debug?.(`[simplego] Message acknowledged: ${msg.requestId}`);
+            log?.debug?.(`[adp-openclaw] Message acknowledged: ${msg.requestId}`);
             break;
 
           case MsgType.Error: {
             const error = msg.payload as { error: string; message: string };
-            log?.error(`[simplego] Server error: ${error.error} - ${error.message}`);
+            log?.error(`[adp-openclaw] Server error: ${error.error} - ${error.message}`);
             break;
           }
 
           default:
-            log?.warn(`[simplego] Unknown message type: ${msg.type}`);
+            log?.warn(`[adp-openclaw] Unknown message type: ${msg.type}`);
         }
       } catch (err) {
-        log?.error(`[simplego] Failed to parse message: ${err}`);
+        log?.error(`[adp-openclaw] Failed to parse message: ${err}`);
       }
     });
 
     ws.on("close", (code, reason) => {
       if (pingInterval) clearInterval(pingInterval);
       abortSignal?.removeEventListener("abort", abortHandler);
-      log?.info(`[simplego] WebSocket closed: ${code} ${reason.toString()}`);
+      log?.info(`[adp-openclaw] WebSocket closed: ${code} ${reason.toString()}`);
       resolve();
     });
 

package/src/runtime.ts

@@ -1,15 +1,34 @@
-// Runtime singleton for simplego plugin
+// Runtime singleton for adp-openclaw plugin
 import type { PluginRuntime } from "openclaw/plugin-sdk";
 
-let simpleGoRuntime: PluginRuntime | null = null;
+let adpOpenclawRuntime: PluginRuntime | null = null;
 
-export function setSimpleGoRuntime(runtime: PluginRuntime): void {
-  simpleGoRuntime = runtime;
+// Plugin-level config storage (from plugins.entries.adp-openclaw.config)
+export type PluginConfig = {
+  wsUrl?: string;
+  clientToken?: string;
+  serverUrl?: string;
+  apiToken?: string;
+  pollIntervalMs?: number;
+};
+
+let pluginConfig: PluginConfig = {};
+
+export function setAdpOpenclawRuntime(runtime: PluginRuntime): void {
+  adpOpenclawRuntime = runtime;
 }
 
-export function getSimpleGoRuntime(): PluginRuntime {
-  if (!simpleGoRuntime) {
-    throw new Error("SimpleGo runtime not initialized");
+export function getAdpOpenclawRuntime(): PluginRuntime {
+  if (!adpOpenclawRuntime) {
+    throw new Error("ADP OpenClaw runtime not initialized");
   }
-  return simpleGoRuntime;
+  return adpOpenclawRuntime;
+}
+
+export function setPluginConfig(config: PluginConfig): void {
+  pluginConfig = config;
+}
+
+export function getPluginConfig(): PluginConfig {
+  return pluginConfig;
 }