adp-openclaw 0.0.2

package/src/channel.ts

@@ -0,0 +1,245 @@
+// Simple Go channel plugin for OpenClaw
+// Supports: API Token auth, multiple clients, multi-turn conversations
+
+import {
+  type ChannelPlugin,
+  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;
+    };
+  };
+};
+
+export type ResolvedSimpleGoAccount = {
+  accountId: string;
+  name: string;
+  enabled: boolean;
+  configured: boolean;
+  serverUrl: string;
+  apiToken: string;
+  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";
+
+  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,
+  };
+}
+
+export const simpleGoPlugin: ChannelPlugin<ResolvedSimpleGoAccount> = {
+  id: "simplego",
+  meta: {
+    id: "simplego",
+    label: "Simple Go",
+    selectionLabel: "Simple Go (demo)",
+    docsPath: "/channels/simplego",
+    blurb: "Demo channel backed by a Go HTTP server.",
+    order: 999,
+  },
+  capabilities: {
+    chatTypes: ["direct"],
+    polls: false,
+    reactions: false,
+    threads: false,
+    media: false,
+  },
+  reload: { configPrefixes: ["channels.simplego"] },
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+    resolveAccount: (cfg, accountId) => resolveAccount(cfg as SimpleGoConfig, accountId),
+    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,
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      baseUrl: account.serverUrl,
+    }),
+    resolveAllowFrom: () => [],
+    formatAllowFrom: ({ allowFrom }) => allowFrom,
+  },
+  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,
+          },
+        },
+      };
+    },
+  },
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+    },
+    collectStatusIssues: () => [],
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      baseUrl: snapshot.baseUrl ?? null,
+      running: snapshot.running ?? false,
+      lastStartAt: snapshot.lastStartAt ?? null,
+      lastStopAt: snapshot.lastStopAt ?? null,
+      lastError: snapshot.lastError ?? null,
+    }),
+    probeAccount: async ({ cfg, timeoutMs }) => {
+      const account = resolveAccount(cfg as SimpleGoConfig);
+      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,
+        };
+      }
+    },
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      baseUrl: account.serverUrl,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      probe,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const account = ctx.account;
+      ctx.setStatus({ accountId: account.accountId, baseUrl: account.serverUrl });
+      ctx.log?.info(`[simplego] starting poll loop → ${account.serverUrl}`);
+
+      const { monitorSimpleGo } = await import("./monitor.js");
+      return monitorSimpleGo({
+        serverUrl: account.serverUrl,
+        apiToken: account.apiToken,
+        pollIntervalMs: account.pollIntervalMs,
+        abortSignal: ctx.abortSignal,
+        log: ctx.log,
+      });
+    },
+  },
+  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 SimpleGoConfig);
+      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.apiToken}`,
+        },
+        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,
+      };
+    },
+  },
+};

package/src/config-schema.ts

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

package/src/monitor.ts

@@ -0,0 +1,325 @@
+// 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 crypto from "crypto";
+
+export type MonitorParams = {
+  serverUrl: string;
+  apiToken: string;
+  pollIntervalMs: number; // Used as reconnect delay
+  abortSignal?: AbortSignal;
+  log?: PluginLogger;
+};
+
+// WebSocket message types
+const MsgType = {
+  Auth: "auth",
+  AuthResult: "auth_result",
+  Ping: "ping",
+  Pong: "pong",
+  Inbound: "inbound",
+  Outbound: "outbound",
+  Ack: "ack",
+  Error: "error",
+  ConvHistory: "conv_history",
+  ConvResponse: "conv_response",
+} as const;
+
+type WSMessage = {
+  type: string;
+  requestId?: string;
+  payload?: unknown;
+  timestamp: number;
+};
+
+// UserInfo represents full user identity (matching Go server's UserInfo)
+type UserInfo = {
+  userId: string;
+  username?: string;
+  avatar?: string;
+  email?: string;
+  tenantId?: string;
+  source?: string;
+  extra?: Record<string, string>;
+};
+
+type InboundMessage = {
+  id: string;
+  conversationId: string;
+  clientId: string;
+  from: string;
+  to: string;
+  text: string;
+  timestamp: number;
+  user?: UserInfo; // Full user identity information
+};
+
+type AuthResultPayload = {
+  success: boolean;
+  clientId?: string;
+  message?: string;
+};
+
+// Generate HMAC-SHA256 signature for extra security
+function generateSignature(token: string, nonce: string): string {
+  return crypto.createHash("sha256").update(`${token}:${nonce}`).digest("hex");
+}
+
+// Generate random nonce
+function generateNonce(): string {
+  return crypto.randomBytes(16).toString("hex");
+}
+
+// Generate unique request ID
+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();
+
+  // Convert HTTP URL to WebSocket URL
+  const wsUrl = serverUrl.replace(/^http/, "ws") + "/ws";
+
+  log?.info(`[simplego] WebSocket monitor started, connecting to ${wsUrl}`);
+
+  while (!abortSignal?.aborted) {
+    try {
+      await connectAndHandle({
+        wsUrl,
+        apiToken,
+        serverUrl,
+        abortSignal,
+        log,
+        runtime,
+      });
+    } catch (err) {
+      if (abortSignal?.aborted) break;
+      log?.error(`[simplego] WebSocket error: ${err}`);
+    }
+
+    // Wait before reconnecting
+    if (!abortSignal?.aborted) {
+      log?.info(`[simplego] Reconnecting in ${pollIntervalMs}ms...`);
+      await sleep(pollIntervalMs, abortSignal);
+    }
+  }
+
+  log?.info(`[simplego] WebSocket monitor stopped`);
+}
+
+type ConnectParams = {
+  wsUrl: string;
+  apiToken: string;
+  serverUrl: string;
+  abortSignal?: AbortSignal;
+  log?: PluginLogger;
+  runtime: ReturnType<typeof getSimpleGoRuntime>;
+};
+
+async function connectAndHandle(params: ConnectParams): Promise<void> {
+  const { wsUrl, apiToken, serverUrl, abortSignal, log, runtime } = params;
+
+  // Dynamic import for WebSocket (works in both Node.js and browser)
+  const WebSocket = (await import("ws")).default;
+
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    let authenticated = false;
+    let pingInterval: NodeJS.Timeout | null = null;
+
+    // Handle abort signal
+    const abortHandler = () => {
+      ws.close();
+      resolve();
+    };
+    abortSignal?.addEventListener("abort", abortHandler);
+
+    ws.on("open", () => {
+      log?.info(`[simplego] WebSocket connected, authenticating...`);
+
+      // Send authentication message with signature
+      const nonce = generateNonce();
+      const signature = generateSignature(apiToken, nonce);
+
+      const authMsg: WSMessage = {
+        type: MsgType.Auth,
+        requestId: generateRequestId(),
+        payload: {
+          token: apiToken,
+          nonce,
+          signature,
+        },
+        timestamp: Date.now(),
+      };
+
+      ws.send(JSON.stringify(authMsg));
+    });
+
+    ws.on("message", async (data: Buffer) => {
+      try {
+        const msg: WSMessage = JSON.parse(data.toString());
+
+        switch (msg.type) {
+          case MsgType.AuthResult: {
+            const result = msg.payload as AuthResultPayload;
+            if (result.success) {
+              authenticated = true;
+              log?.info(`[simplego] Authenticated as client ${result.clientId}`);
+
+              // Start ping interval
+              pingInterval = setInterval(() => {
+                if (ws.readyState === WebSocket.OPEN) {
+                  ws.send(JSON.stringify({
+                    type: MsgType.Ping,
+                    requestId: generateRequestId(),
+                    timestamp: Date.now(),
+                  }));
+                }
+              }, 25000);
+            } else {
+              log?.error(`[simplego] Authentication failed: ${result.message}`);
+              ws.close();
+            }
+            break;
+          }
+
+          case MsgType.Pong:
+            // Heartbeat response, connection is alive
+            break;
+
+          case MsgType.Inbound: {
+            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 || {})})`);
+
+            // Process the message with full user identity
+            try {
+              // Build user identity string for From field (like Feishu: "feishu:user_id")
+              const userIdentifier = inMsg.user?.userId || inMsg.from;
+              const tenantPrefix = inMsg.user?.tenantId ? `${inMsg.user.tenantId}:` : "";
+              
+              // Build metadata for user context (passed through to openclaw)
+              const userMetadata: Record<string, string> = {};
+              if (inMsg.user) {
+                if (inMsg.user.username) userMetadata.username = inMsg.user.username;
+                if (inMsg.user.email) userMetadata.email = inMsg.user.email;
+                if (inMsg.user.avatar) userMetadata.avatar = inMsg.user.avatar;
+                if (inMsg.user.tenantId) userMetadata.tenantId = inMsg.user.tenantId;
+                if (inMsg.user.source) userMetadata.source = inMsg.user.source;
+                if (inMsg.user.extra) {
+                  Object.entries(inMsg.user.extra).forEach(([k, v]) => {
+                    userMetadata[`extra_${k}`] = v;
+                  });
+                }
+              }
+
+              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",
+                ChatType: "direct",
+                // SenderId carries the raw user ID for identification
+                SenderId: userIdentifier,
+                Provider: "simplego",
+                Surface: inMsg.user?.source || "simplego",
+                MessageSid: inMsg.id,
+                MessageSidFull: inMsg.id,
+                OriginatingChannel: "simplego",
+                OriginatingTo: "simplego:bot",
+                // Pass user metadata through context (like Feishu does)
+                ...userMetadata,
+              });
+
+              await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+                ctx,
+                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)}...`);
+
+                    // Send via WebSocket
+                    const outMsg: WSMessage = {
+                      type: MsgType.Outbound,
+                      requestId: generateRequestId(),
+                      payload: {
+                        to: inMsg.from,
+                        text: payload.text,
+                        conversationId: inMsg.conversationId,
+                        // Include user info in response for tracing
+                        user: inMsg.user,
+                      },
+                      timestamp: Date.now(),
+                    };
+
+                    ws.send(JSON.stringify(outMsg));
+                  },
+                  onError: (err: Error) => {
+                    log?.error(`[simplego] Reply error: ${err.message}`);
+                  },
+                },
+              });
+            } catch (err) {
+              log?.error(`[simplego] Failed to process message: ${err}`);
+            }
+            break;
+          }
+
+          case MsgType.Ack:
+            // Message acknowledgment
+            log?.debug?.(`[simplego] 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}`);
+            break;
+          }
+
+          default:
+            log?.warn(`[simplego] Unknown message type: ${msg.type}`);
+        }
+      } catch (err) {
+        log?.error(`[simplego] 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()}`);
+      resolve();
+    });
+
+    ws.on("error", (err) => {
+      if (pingInterval) clearInterval(pingInterval);
+      abortSignal?.removeEventListener("abort", abortHandler);
+      reject(err);
+    });
+  });
+}
+
+function sleep(ms: number, signal?: AbortSignal): Promise<void> {
+  return new Promise((resolve) => {
+    if (signal?.aborted) {
+      resolve();
+      return;
+    }
+    const timeout = setTimeout(resolve, ms);
+    signal?.addEventListener("abort", () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+  });
+}

package/src/runtime.ts

@@ -0,0 +1,15 @@
+// Runtime singleton for simplego plugin
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let simpleGoRuntime: PluginRuntime | null = null;
+
+export function setSimpleGoRuntime(runtime: PluginRuntime): void {
+  simpleGoRuntime = runtime;
+}
+
+export function getSimpleGoRuntime(): PluginRuntime {
+  if (!simpleGoRuntime) {
+    throw new Error("SimpleGo runtime not initialized");
+  }
+  return simpleGoRuntime;
+}