adp-openclaw 0.0.13 → 0.0.14

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "adp-openclaw",
-  "version": "0.0.13",
-  "description": "OpenClaw demo channel plugin (Go WebSocket backend)",
+  "version": "0.0.14",
+  "description": "ADP-OpenClaw demo channel plugin (Go WebSocket backend)",
   "type": "module",
   "dependencies": {
     "ws": "^8.16.0",
@@ -16,10 +16,10 @@
     ],
     "channel": {
       "id": "adp-openclaw",
-      "label": "ADP OpenClaw",
-      "selectionLabel": "ADP OpenClaw",
+      "label": "ADP-OpenClaw",
+      "selectionLabel": "ADP-OpenClaw",
       "docsPath": "/channels/adp-openclaw",
-      "blurb": "ADP channel backed by a Go WebSocket server.",
+      "blurb": "ADP-OpenClaw channel backed by a Go WebSocket server.",
       "order": 999
     }
   }

package/src/channel.ts

@@ -7,14 +7,15 @@ import {
   DEFAULT_ACCOUNT_ID,
 } from "openclaw/plugin-sdk";
 
+// Default WebSocket URL for ADP OpenClaw
+const DEFAULT_WS_URL = "wss://wss.lke.cloud.tencent.com/bot/gateway/ws/";
+
 // Channel-level config type (from channels["adp-openclaw"])
 export type AdpOpenclawChannelConfig = {
   enabled?: boolean;
-  serverUrl?: string;
-  wsUrl?: string;
+  wsUrl?: string; // WebSocket URL (optional, has default)
   clientToken?: string;
-  hmacKey?: string; // HMAC key for signature generation
-  pollIntervalMs?: number;
+  signKey?: string; // HMAC key for signature generation
 };
 
 export type ResolvedAdpOpenclawAccount = {
@@ -22,29 +23,20 @@ export type ResolvedAdpOpenclawAccount = {
   name: string;
   enabled: boolean;
   configured: boolean;
-  serverUrl: string;
+  wsUrl: string; // WebSocket URL
   clientToken: string;
-  hmacKey: string; // HMAC key for signature generation
-  pollIntervalMs: number;
+  signKey: string; // HMAC key for signature generation
 };
 
 function resolveAdpOpenclawCredentials(channelCfg?: AdpOpenclawChannelConfig): {
-  serverUrl: string;
+  wsUrl: string;
   clientToken: string;
-  hmacKey: string;
-  pollIntervalMs: number;
+  signKey: string;
 } | 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 wsUrl from config or env (has default value)
+  let wsUrl = channelCfg?.wsUrl?.trim();
+  if (!wsUrl) {
+    wsUrl = process.env.ADP_OPENCLAW_WS_URL || DEFAULT_WS_URL;
   }
 
   // Get clientToken from config or env
@@ -53,20 +45,18 @@ function resolveAdpOpenclawCredentials(channelCfg?: AdpOpenclawChannelConfig): {
     clientToken = process.env.ADP_OPENCLAW_CLIENT_TOKEN || "";
   }
 
-  // Get hmacKey from config or env (default: ADPOpenClaw)
-  let hmacKey = channelCfg?.hmacKey?.trim();
-  if (!hmacKey) {
-    hmacKey = process.env.ADP_OPENCLAW_HMAC_KEY || "ADPOpenClaw";
+  // Get signKey from config or env (default: ADPOpenClaw)
+  let signKey = channelCfg?.signKey?.trim();
+  if (!signKey) {
+    signKey = process.env.ADP_OPENCLAW_SIGN_KEY || "ADPOpenClaw";
   }
 
-  // Both are required for configured status
-  if (!serverUrl || !clientToken) {
+  // clientToken is required for configured status (wsUrl has default)
+  if (!clientToken) {
     return null;
   }
 
-  const pollIntervalMs = channelCfg?.pollIntervalMs ?? 1000;
-
-  return { serverUrl, clientToken, hmacKey, pollIntervalMs };
+  return { wsUrl, clientToken, signKey };
 }
 
 function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpenclawAccount {
@@ -79,10 +69,9 @@ function resolveAccount(cfg: ClawdbotConfig, accountId?: string): ResolvedAdpOpe
     name: "ADP OpenClaw",
     enabled,
     configured: Boolean(creds),
-    serverUrl: creds?.serverUrl || "http://localhost:9876",
+    wsUrl: creds?.wsUrl || DEFAULT_WS_URL,
     clientToken: creds?.clientToken || "",
-    hmacKey: creds?.hmacKey || "ADPOpenClaw",
-    pollIntervalMs: creds?.pollIntervalMs || 1000,
+    signKey: creds?.signKey || "ADPOpenClaw",
   };
 }
 
@@ -115,11 +104,9 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
       additionalProperties: false,
       properties: {
         enabled: { type: "boolean" },
-        serverUrl: { type: "string" },
-        wsUrl: { type: "string" },
+        wsUrl: { type: "string" }, // WebSocket URL (optional, default: wss://wss.lke.cloud.tencent.com/bot/gateway/ws/)
         clientToken: { type: "string" },
-        hmacKey: { type: "string" },
-        pollIntervalMs: { type: "integer", minimum: 100 },
+        signKey: { type: "string" },
       },
     },
   },
@@ -155,7 +142,7 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
       name: account.name,
       enabled: account.enabled,
       configured: account.configured,
-      baseUrl: account.serverUrl,
+      wsUrl: account.wsUrl,
     }),
     resolveAllowFrom: () => [],
     formatAllowFrom: ({ allowFrom }) => allowFrom,
@@ -184,39 +171,27 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
     collectStatusIssues: () => [],
     buildChannelSummary: ({ snapshot }) => ({
       configured: snapshot.configured ?? false,
-      baseUrl: snapshot.baseUrl ?? null,
+      wsUrl: snapshot.wsUrl ?? null,
       running: snapshot.running ?? false,
       lastStartAt: snapshot.lastStartAt ?? null,
       lastStopAt: snapshot.lastStopAt ?? null,
       lastError: snapshot.lastError ?? null,
     }),
-    probeAccount: async ({ cfg, timeoutMs }) => {
+    probeAccount: async ({ cfg }) => {
+      // For WebSocket-only architecture, we just check if config is valid
       const account = resolveAccount(cfg);
       const start = Date.now();
-      try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), timeoutMs ?? 5000);
-        const res = await fetch(`${account.serverUrl}/health`, { signal: controller.signal });
-        clearTimeout(timeout);
-        const data = (await res.json()) as { ok?: boolean };
-        return {
-          ok: data.ok === true,
-          elapsedMs: Date.now() - start,
-        };
-      } catch (err) {
-        return {
-          ok: false,
-          error: err instanceof Error ? err.message : String(err),
-          elapsedMs: Date.now() - start,
-        };
-      }
+      return {
+        ok: account.configured && Boolean(account.clientToken),
+        elapsedMs: Date.now() - start,
+      };
     },
     buildAccountSnapshot: ({ account, runtime, probe }) => ({
       accountId: account.accountId,
       name: account.name,
       enabled: account.enabled,
       configured: account.configured,
-      baseUrl: account.serverUrl,
+      wsUrl: account.wsUrl,
       running: runtime?.running ?? false,
       lastStartAt: runtime?.lastStartAt ?? null,
       lastStopAt: runtime?.lastStopAt ?? null,
@@ -227,61 +202,20 @@ export const adpOpenclawPlugin: ChannelPlugin<ResolvedAdpOpenclawAccount> = {
   gateway: {
     startAccount: async (ctx) => {
       const account = ctx.account;
-      ctx.setStatus({ accountId: account.accountId, baseUrl: account.serverUrl });
-      ctx.log?.info(`[adp-openclaw] starting poll loop → ${account.serverUrl}`);
+      ctx.setStatus({ accountId: account.accountId, wsUrl: account.wsUrl });
+      ctx.log?.info(`[adp-openclaw] starting WebSocket connection → ${account.wsUrl}`);
 
       const { monitorAdpOpenclaw } = await import("./monitor.js");
       return monitorAdpOpenclaw({
-        serverUrl: account.serverUrl,
+        wsUrl: account.wsUrl,
         clientToken: account.clientToken,
-        hmacKey: account.hmacKey,
-        pollIntervalMs: account.pollIntervalMs,
+        signKey: account.signKey,
         abortSignal: ctx.abortSignal,
         log: ctx.log,
         cfg: ctx.cfg,
       });
     },
   },
-  outbound: {
-    send: async ({ target, message, cfg, context }: {
-      target: string;
-      message: string;
-      cfg: unknown;
-      context?: { 
-        conversationId?: string;
-        userId?: string;
-        username?: string;
-        tenantId?: string;
-      };
-    }) => {
-      const account = resolveAccount(cfg as ClawdbotConfig);
-      const conversationId = context?.conversationId || "";
-      
-      // Extract user info from context for response tracing
-      const userInfo = context?.userId ? {
-        userId: context.userId,
-        username: context.username,
-        tenantId: context.tenantId,
-      } : undefined;
-      
-      const res = await fetch(`${account.serverUrl}/send`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${account.clientToken}`,
-        },
-        body: JSON.stringify({
-          to: target,
-          text: message,
-          conversationId,
-          user: userInfo,
-        }),
-      });
-      const data = (await res.json()) as { ok?: boolean; message?: { id?: string } };
-      return {
-        ok: data.ok === true,
-        messageId: data.message?.id,
-      };
-    },
-  },
+  // Note: outbound.send is not available in WebSocket-only architecture
+  // All message sending is done through the WebSocket connection in monitor.ts
 };

package/src/config-schema.ts

@@ -2,8 +2,7 @@ import { z } from "zod";
 
 export const AdpOpenclawConfigSchema = z.object({
   enabled: z.boolean().optional(),
-  serverUrl: z.string().optional(),
+  wsUrl: z.string().optional(), // WebSocket URL (optional, default: wss://wss.lke.cloud.tencent.com/bot/gateway/ws/)
   clientToken: z.string().optional(),
-  hmacKey: z.string().optional(),
-  pollIntervalMs: z.number().optional(),
+  signKey: z.string().optional(),
 });

package/src/monitor.ts

@@ -5,11 +5,13 @@ import type { PluginLogger, ClawdbotConfig } from "openclaw/plugin-sdk";
 import { getAdpOpenclawRuntime } from "./runtime.js";
 import crypto from "crypto";
 
+// WebSocket reconnect delay (fixed at 1 second)
+const RECONNECT_DELAY_MS = 1000;
+
 export type MonitorParams = {
-  serverUrl: string;
+  wsUrl: string; // WebSocket URL (direct, no conversion needed)
   clientToken: string;
-  hmacKey?: string; // HMAC key for signature generation
-  pollIntervalMs: number; // Used as reconnect delay
+  signKey?: string; // HMAC key for signature generation
   abortSignal?: AbortSignal;
   log?: PluginLogger;
   cfg?: ClawdbotConfig; // OpenClaw config for model settings
@@ -67,10 +69,10 @@ type AuthResultPayload = {
 };
 
 // Generate HMAC-SHA256 signature for authentication (includes timestamp for anti-replay)
-// Uses hmacKey as the HMAC key, and "token:nonce:timestamp" as the message
-function generateSignature(hmacKey: string, token: string, nonce: string, timestamp: number): string {
-  // Use HMAC-SHA256 with hmacKey as the key, and "token:nonce:timestamp" as the message
-  return crypto.createHmac("sha256", hmacKey).update(`${token}:${nonce}:${timestamp}`).digest("hex");
+// Uses signKey as the HMAC key, and "token:nonce:timestamp" as the message
+function generateSignature(signKey: string, token: string, nonce: string, timestamp: number): string {
+  // Use HMAC-SHA256 with signKey as the key, and "token:nonce:timestamp" as the message
+  return crypto.createHmac("sha256", signKey).update(`${token}:${nonce}:${timestamp}`).digest("hex");
 }
 
 // Generate random nonce
@@ -84,12 +86,9 @@ function generateRequestId(): string {
 }
 
 export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
-  const { serverUrl, clientToken, hmacKey, pollIntervalMs, abortSignal, log, cfg } = params;
+  const { wsUrl, clientToken, signKey, abortSignal, log, cfg } = params;
   const runtime = getAdpOpenclawRuntime();
 
-  // Convert HTTP URL to WebSocket URL
-  const wsUrl = serverUrl.replace(/^http/, "ws") + "/ws";
-
   log?.info(`[adp-openclaw] WebSocket monitor started, connecting to ${wsUrl}`);
 
   while (!abortSignal?.aborted) {
@@ -97,8 +96,7 @@ export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
       await connectAndHandle({
         wsUrl,
         clientToken,
-        hmacKey,
-        serverUrl,
+        signKey,
         abortSignal,
         log,
         runtime,
@@ -111,8 +109,8 @@ export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
 
     // Wait before reconnecting
     if (!abortSignal?.aborted) {
-      log?.info(`[adp-openclaw] Reconnecting in ${pollIntervalMs}ms...`);
-      await sleep(pollIntervalMs, abortSignal);
+      log?.info(`[adp-openclaw] Reconnecting in ${RECONNECT_DELAY_MS}ms...`);
+      await sleep(RECONNECT_DELAY_MS, abortSignal);
     }
   }
 
@@ -122,8 +120,7 @@ export async function monitorAdpOpenclaw(params: MonitorParams): Promise<void> {
 type ConnectParams = {
   wsUrl: string;
   clientToken: string;
-  hmacKey?: string;
-  serverUrl: string;
+  signKey?: string;
   abortSignal?: AbortSignal;
   log?: PluginLogger;
   runtime: ReturnType<typeof getAdpOpenclawRuntime>;
@@ -131,7 +128,7 @@ type ConnectParams = {
 };
 
 async function connectAndHandle(params: ConnectParams): Promise<void> {
-  const { wsUrl, clientToken, hmacKey, serverUrl, abortSignal, log, runtime, cfg } = params;
+  const { wsUrl, clientToken, signKey, abortSignal, log, runtime, cfg } = params;
 
   // Dynamic import for WebSocket (works in both Node.js and browser)
   const WebSocket = (await import("ws")).default;
@@ -154,17 +151,17 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
       // Send authentication message with signature (includes timestamp for anti-replay)
       const nonce = generateNonce();
       const timestamp = Date.now();
-      // Generate signature only if hmacKey is provided
-      const signature = hmacKey ? generateSignature(hmacKey, clientToken, nonce, timestamp) : "";
+      // Generate signature only if signKey is provided
+      const signature = signKey ? generateSignature(signKey, clientToken, nonce, timestamp) : "";
 
       const authMsg: WSMessage = {
         type: MsgType.Auth,
         requestId: generateRequestId(),
         payload: {
           token: clientToken,
-          nonce: hmacKey ? nonce : undefined,
-          signature: hmacKey ? signature : undefined,
-          timestamp: hmacKey ? timestamp : undefined, // Include timestamp in payload for server verification
+          nonce: signKey ? nonce : undefined,
+          signature: signKey ? signature : undefined,
+          timestamp: signKey ? timestamp : undefined, // Include timestamp in payload for server verification
         },
         timestamp: Date.now(),
       };
@@ -313,6 +310,7 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 }
               };
 
+              log?.info(`[adp-openclaw] Starting dispatchReplyWithBufferedBlockDispatcher for ${displayName}`);
               await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                 ctx,
                 cfg: cfg ?? {},
@@ -366,10 +364,10 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                   // SDK calls this with info.kind = "block" for streaming chunks, "final" for complete response
                   deliver: async (payload: { text?: string }, info?: { kind?: string }) => {
                     const text = payload.text || "";
-                    const kind = info?.kind || "final";
+                    const kind = info?.kind;
                     
-                    // Debug log for all deliver calls
-                    log?.debug?.(`[adp-openclaw] deliver called with kind=${kind}, text length=${text.length}`);
+                    // Debug log for all deliver calls - log the actual info object
+                    log?.info(`[adp-openclaw] deliver called: kind=${kind}, text.length=${text.length}, info=${JSON.stringify(info)}`);
                     
                     // Handle streaming block - send chunk via WebSocket
                     if (kind === "block" && text) {
@@ -400,9 +398,11 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                       return;
                     }
 
-                    // Handle final reply - send outbound_end
-                    if (kind === "final") {
-                      sendOutboundEnd(text);
+                    // Handle final reply or undefined kind - send outbound_end
+                    // SDK may call deliver without kind when streaming ends
+                    if (kind === "final" || kind === undefined) {
+                      log?.info(`[adp-openclaw] deliver triggering sendOutboundEnd (kind=${kind})`);
+                      sendOutboundEnd(text || lastPartialText);
                     }
                   },
                   onError: (err: Error) => {
@@ -411,6 +411,8 @@ async function connectAndHandle(params: ConnectParams): Promise<void> {
                 },
               });
               
+              log?.info(`[adp-openclaw] dispatchReplyWithBufferedBlockDispatcher returned (finalSent=${finalSent}, chunkIndex=${chunkIndex})`);
+              
               // IMPORTANT: After dispatchReplyWithBufferedBlockDispatcher completes,
               // ensure outbound_end is sent even if "final" deliver was not called.
               // This handles cases where the SDK only sends blocks without a final callback.

package/src/runtime.ts

@@ -7,9 +7,7 @@ let adpOpenclawRuntime: PluginRuntime | null = null;
 export type PluginConfig = {
   wsUrl?: string;
   clientToken?: string;
-  hmacKey?: string;
-  serverUrl?: string;
-  pollIntervalMs?: number;
+  signKey?: string;
 };
 
 let pluginConfig: PluginConfig = {};