@43world/43chat-openclaw-plugin 0.1.6

package/src/monitor.ts

@@ -0,0 +1,277 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import { listEnabled43ChatAccounts, resolve43ChatAccount } from "./accounts.js";
+import { create43ChatClient, Chat43ApiError } from "./client.js";
+import { handle43ChatEvent } from "./bot.js";
+import { waitUntilAbortCompat } from "./plugin-sdk-compat.js";
+import type { Chat43AnySSEEvent, Chat43RuntimeStatusPatch, Resolved43ChatAccount } from "./types.js";
+
+export type Monitor43ChatOpts = {
+  config?: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  accountId?: string;
+  statusSink?: (patch: Chat43RuntimeStatusPatch) => void;
+};
+
+const monitorControllers = new Map<string, AbortController>();
+
+function waitForDelay(delayMs: number, signal?: AbortSignal): Promise<boolean> {
+  if (!signal) {
+    return new Promise((resolve) => setTimeout(() => resolve(false), delayMs));
+  }
+  if (signal.aborted) {
+    return Promise.resolve(true);
+  }
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve(false);
+    }, delayMs);
+    const onAbort = () => {
+      clearTimeout(timeout);
+      resolve(true);
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function combineSignals(signals: Array<AbortSignal | undefined>): AbortSignal | undefined {
+  const filtered = signals.filter((signal): signal is AbortSignal => Boolean(signal));
+  if (filtered.length === 0) {
+    return undefined;
+  }
+  if (filtered.length === 1) {
+    return filtered[0];
+  }
+
+  const controller = new AbortController();
+  const onAbort = (event: Event) => {
+    const source = event.target as AbortSignal | null;
+    controller.abort(source?.reason);
+    for (const signal of filtered) {
+      signal.removeEventListener("abort", onAbort);
+    }
+  };
+
+  for (const signal of filtered) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      return controller.signal;
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  }
+
+  return controller.signal;
+}
+
+async function monitorSingleAccount(params: {
+  cfg: ClawdbotConfig;
+  account: Resolved43ChatAccount;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  statusSink?: (patch: Chat43RuntimeStatusPatch) => void;
+}): Promise<void> {
+  const { cfg, account, runtime, abortSignal, statusSink } = params;
+  const { accountId } = account;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+  const emitStatus = (patch: Chat43RuntimeStatusPatch) => statusSink?.(patch);
+
+  const localController = new AbortController();
+  monitorControllers.set(accountId, localController);
+  const combinedSignal = combineSignals([abortSignal, localController.signal]);
+
+  let reconnectAttempts = 0;
+  const reconnectBaseDelay = account.config.sseReconnectDelayMs ?? 1_000;
+  const reconnectMaxDelay = account.config.sseMaxReconnectDelayMs ?? 60_000;
+
+  const stopStatus = () => {
+    emitStatus({
+      running: false,
+      connected: false,
+      connectionState: "stopped",
+      nextRetryAt: null,
+      lastStopAt: Date.now(),
+    });
+  };
+
+  if (combinedSignal?.aborted) {
+    stopStatus();
+    return;
+  }
+
+  combinedSignal?.addEventListener("abort", stopStatus, { once: true });
+
+  try {
+    while (!combinedSignal?.aborted) {
+      emitStatus({
+        running: true,
+        connected: false,
+        connectionState: "connecting",
+        lastStartAt: Date.now(),
+        nextRetryAt: null,
+        lastError: null,
+      });
+
+      log(`43chat[${accountId}]: connecting SSE stream...`);
+
+      try {
+        const client = create43ChatClient(account);
+        await client.connectSSE<Chat43AnySSEEvent>({
+          signal: combinedSignal,
+          onOpen: () => {
+            reconnectAttempts = 0;
+            emitStatus({
+              running: true,
+              connected: true,
+              connectionState: "connected",
+              reconnectAttempts: 0,
+              nextRetryAt: null,
+              lastConnectedAt: Date.now(),
+              lastError: null,
+            });
+            log(`43chat[${accountId}]: SSE connected`);
+          },
+          onHeartbeat: () => {
+            emitStatus({
+              running: true,
+              connected: true,
+              connectionState: "connected",
+            });
+          },
+          onInvalidFrame: (frame, reason) => {
+            error(`43chat[${accountId}]: invalid SSE frame (${reason}): ${JSON.stringify(frame)}`);
+          },
+          onEvent: async (event) => {
+            emitStatus({ lastInboundAt: Date.now() });
+            await handle43ChatEvent({
+              cfg,
+              event,
+              accountId,
+              runtime,
+            });
+          },
+        });
+
+        if (combinedSignal?.aborted) {
+          break;
+        }
+
+        throw new Chat43ApiError({
+          message: "43Chat SSE stream closed unexpectedly",
+          retryable: true,
+        });
+      } catch (err) {
+        if (combinedSignal?.aborted) {
+          break;
+        }
+
+        reconnectAttempts += 1;
+        const message = err instanceof Error ? err.message : String(err);
+        const retryable = err instanceof Chat43ApiError ? err.retryable : true;
+
+        if (!retryable) {
+          emitStatus({
+            running: true,
+            connected: false,
+            connectionState: "error",
+            reconnectAttempts,
+            lastError: message,
+            nextRetryAt: null,
+            lastDisconnect: {
+              code: err instanceof Chat43ApiError ? err.status ?? 0 : 0,
+              reason: message,
+              at: Date.now(),
+            },
+          });
+          error(`43chat[${accountId}]: fatal SSE error: ${message}`);
+          await waitUntilAbortCompat(combinedSignal);
+          break;
+        }
+
+        const delay = Math.min(
+          reconnectBaseDelay * Math.max(1, 2 ** (reconnectAttempts - 1)),
+          reconnectMaxDelay,
+        );
+        const nextRetryAt = Date.now() + delay;
+
+        emitStatus({
+          running: true,
+          connected: false,
+          connectionState: "backoff",
+          reconnectAttempts,
+          nextRetryAt,
+          lastError: message,
+          lastDisconnect: {
+            code: err instanceof Chat43ApiError ? err.status ?? 0 : 0,
+            reason: message,
+            at: Date.now(),
+          },
+        });
+
+        error(`43chat[${accountId}]: SSE error, retrying in ${delay}ms: ${message}`);
+
+        const aborted = await waitForDelay(delay, combinedSignal);
+        if (aborted) {
+          break;
+        }
+      }
+    }
+  } finally {
+    if (monitorControllers.get(accountId) === localController) {
+      monitorControllers.delete(accountId);
+    }
+    stopStatus();
+  }
+}
+
+export async function monitor43ChatProvider(opts: Monitor43ChatOpts = {}): Promise<void> {
+  const cfg = opts.config;
+  if (!cfg) {
+    throw new Error("Config is required for 43Chat monitor");
+  }
+
+  if (opts.accountId) {
+    const account = resolve43ChatAccount({ cfg, accountId: opts.accountId });
+    if (!account.enabled || !account.configured) {
+      throw new Error(`43Chat account "${opts.accountId}" not configured or disabled`);
+    }
+    return monitorSingleAccount({
+      cfg,
+      account,
+      runtime: opts.runtime,
+      abortSignal: opts.abortSignal,
+      statusSink: opts.statusSink,
+    });
+  }
+
+  const accounts = listEnabled43ChatAccounts(cfg);
+  if (accounts.length === 0) {
+    throw new Error("No enabled 43Chat accounts configured");
+  }
+
+  await Promise.all(
+    accounts.map((account) =>
+      monitorSingleAccount({
+        cfg,
+        account,
+        runtime: opts.runtime,
+        abortSignal: opts.abortSignal,
+        statusSink: opts.statusSink,
+      }),
+    ),
+  );
+}
+
+export function stop43ChatMonitor(accountId?: string): void {
+  if (accountId) {
+    monitorControllers.get(accountId)?.abort();
+    monitorControllers.delete(accountId);
+    return;
+  }
+
+  for (const controller of monitorControllers.values()) {
+    controller.abort();
+  }
+  monitorControllers.clear();
+}

package/src/outbound.ts

@@ -0,0 +1,59 @@
+import type { ChannelOutboundAdapter, ChannelOutboundContext, ReplyPayload } from "openclaw/plugin-sdk";
+import { sendMessage43Chat } from "./send.js";
+import { log } from "node:console";
+
+function chunkText(text: string, limit: number): string[] {
+  if (text.length <= limit) {
+    return [text];
+  }
+
+  const chunks: string[] = [];
+  for (let index = 0; index < text.length; index += limit) {
+    chunks.push(text.slice(index, index + limit));
+  }
+  return chunks;
+}
+
+export const chat43Outbound: ChannelOutboundAdapter = {
+  deliveryMode: "direct",
+  chunker: chunkText,
+  chunkerMode: "text",
+  textChunkLimit: 4000,
+
+  sendText: async (ctx: ChannelOutboundContext) => {
+    log(`43chat[${ctx.accountId}]: send text ${ctx.text}`);
+    const result = await sendMessage43Chat({
+      cfg: ctx.cfg,
+      to: ctx.to ?? "",
+      text: ctx.text ?? "",
+      accountId: ctx.accountId ?? undefined,
+    });
+    log(`43chat[${ctx.accountId}]: send text result ${result.messageId} ${result.chatId}`);
+    return {
+      channel: "43chat" as const,
+      messageId: result.messageId,
+      chatId: result.chatId,
+    };
+  },
+
+  sendPayload: async (ctx: ChannelOutboundContext & { payload: ReplyPayload }) => {
+    const text = ctx.payload.text ?? ctx.text ?? "";
+    log(`43chat[${ctx.accountId}]: send payload ${text}`);
+    const result = await sendMessage43Chat({
+      cfg: ctx.cfg,
+      to: ctx.to ?? "",
+      text,
+      accountId: ctx.accountId ?? undefined,
+    });
+    log(`43chat[${ctx.accountId}]: send payload result ${result.messageId} ${result.chatId}`);
+    return {
+      channel: "43chat" as const,
+      messageId: result.messageId,
+      chatId: result.chatId,
+    };
+  },
+
+  sendMedia: async () => {
+    throw new Error("43Chat channel does not support media messages");
+  },
+};

package/src/plugin-sdk-compat.ts

@@ -0,0 +1,27 @@
+import * as pluginSdk from "openclaw/plugin-sdk";
+
+type PluginSdkCompat = {
+  waitUntilAbort?: (abortSignal?: AbortSignal) => Promise<void>;
+};
+
+function waitUntilAbortFallback(abortSignal?: AbortSignal): Promise<void> {
+  if (!abortSignal) {
+    return new Promise<void>(() => undefined);
+  }
+  if (abortSignal.aborted) {
+    return Promise.resolve();
+  }
+  return new Promise<void>((resolve) => {
+    abortSignal.addEventListener("abort", () => resolve(), { once: true });
+  });
+}
+
+export function waitUntilAbortCompat(
+  abortSignal?: AbortSignal,
+  sdk: PluginSdkCompat = pluginSdk as PluginSdkCompat,
+): Promise<void> {
+  if (typeof sdk.waitUntilAbort === "function") {
+    return sdk.waitUntilAbort(abortSignal);
+  }
+  return waitUntilAbortFallback(abortSignal);
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let chat43Runtime: PluginRuntime | undefined;
+
+export function set43ChatRuntime(runtime: PluginRuntime): void {
+  chat43Runtime = runtime;
+}
+
+export function get43ChatRuntime(): PluginRuntime {
+  if (!chat43Runtime) {
+    throw new Error("43Chat runtime not initialized");
+  }
+  return chat43Runtime;
+}

package/src/send.ts

@@ -0,0 +1,35 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { Chat43SendResult } from "./types.js";
+import { resolve43ChatAccount } from "./accounts.js";
+import { create43ChatClient } from "./client.js";
+import { parse43ChatTarget } from "./targets.js";
+
+export type Send43ChatMessageParams = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  accountId?: string;
+};
+
+export async function sendMessage43Chat(
+  params: Send43ChatMessageParams,
+): Promise<Chat43SendResult> {
+  const { cfg, to, text, accountId } = params;
+  const account = resolve43ChatAccount({ cfg, accountId });
+
+  if (!account.configured) {
+    throw new Error(`43Chat account "${account.accountId}" not configured`);
+  }
+
+  const target = parse43ChatTarget(to);
+  if (!target) {
+    throw new Error(`Invalid 43Chat target: ${to}`);
+  }
+
+  const client = create43ChatClient(account);
+  return client.sendText({
+    targetType: target.kind,
+    targetId: target.id,
+    text: text ?? "",
+  });
+}

package/src/targets.ts

@@ -0,0 +1,58 @@
+export type Chat43TargetKind = "user" | "group";
+
+export type Parsed43ChatTarget = {
+  kind: Chat43TargetKind;
+  id: string;
+  normalized: string;
+};
+
+function stripChannelPrefix(raw: string): string {
+  return raw.replace(/^43chat:/i, "");
+}
+
+export function parse43ChatTarget(raw: string): Parsed43ChatTarget | null {
+  const trimmed = stripChannelPrefix(raw.trim());
+  if (!trimmed) {
+    return null;
+  }
+
+  const match = /^(user|group):(.+)$/i.exec(trimmed);
+  if (match) {
+    const kind = match[1].toLowerCase() as Chat43TargetKind;
+    const id = match[2]?.trim();
+    if (!id) {
+      return null;
+    }
+    return {
+      kind,
+      id,
+      normalized: `${kind}:${id}`,
+    };
+  }
+
+  if (/^\d+$/.test(trimmed)) {
+    return {
+      kind: "user",
+      id: trimmed,
+      normalized: `user:${trimmed}`,
+    };
+  }
+
+  return null;
+}
+
+export function normalize43ChatTarget(raw: string): string | null {
+  return parse43ChatTarget(raw)?.normalized ?? null;
+}
+
+export function looksLike43ChatId(raw: string): boolean {
+  return parse43ChatTarget(raw) !== null;
+}
+
+export function to43ChatAddress(raw: string): string | null {
+  const normalized = normalize43ChatTarget(raw);
+  if (!normalized) {
+    return null;
+  }
+  return `43chat:${normalized}`;
+}

package/src/types.ts

@@ -0,0 +1,182 @@
+import type { z } from "zod";
+import type { Chat43AccountConfigSchema, Chat43ConfigSchema } from "./config-schema.js";
+
+export type Chat43Config = z.infer<typeof Chat43ConfigSchema>;
+export type Chat43AccountConfig = z.infer<typeof Chat43AccountConfigSchema>;
+
+export type Resolved43ChatAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  name?: string;
+  baseUrl?: string;
+  apiKey?: string;
+  config: Chat43AccountConfig;
+};
+
+export type Chat43ConnectionState =
+  | "idle"
+  | "connecting"
+  | "connected"
+  | "backoff"
+  | "error"
+  | "stopped";
+
+export type Chat43DisconnectInfo = {
+  code: number;
+  reason: string;
+  at: number;
+};
+
+export type Chat43RuntimeStatusPatch = {
+  running?: boolean;
+  connected?: boolean;
+  connectionState?: Chat43ConnectionState;
+  reconnectAttempts?: number;
+  nextRetryAt?: number | null;
+  lastConnectedAt?: number | null;
+  lastDisconnect?: Chat43DisconnectInfo | null;
+  lastError?: string | null;
+  lastStartAt?: number | null;
+  lastStopAt?: number | null;
+  lastInboundAt?: number | null;
+  lastOutboundAt?: number | null;
+};
+
+export type Chat43EventType =
+  | "private_message"
+  | "group_message"
+  | "friend_request"
+  | "friend_accepted"
+  | "group_invitation"
+  | "group_member_joined"
+  | "system_notice"
+  | "heartbeat";
+
+export type Chat43SSEEventEnvelope<T = unknown> = {
+  id: string;
+  event_type: Chat43EventType;
+  data: T;
+  timestamp: number;
+};
+
+export type Chat43PrivateMessageEventData = {
+  message_id: string;
+  from_user_id: number;
+  from_nickname: string;
+  to_user_id: number;
+  content: string;
+  content_type: string;
+  timestamp: number;
+};
+
+export type Chat43GroupMessageEventData = {
+  message_id: string;
+  group_id: number;
+  from_user_id: number;
+  from_nickname: string;
+  content: string;
+  content_type: string;
+  timestamp: number;
+};
+
+export type Chat43FriendRequestEventData = {
+  request_id: number;
+  from_user_id: number;
+  from_nickname: string;
+  from_avatar: string;
+  request_msg: string;
+  timestamp: number;
+};
+
+export type Chat43FriendAcceptedEventData = {
+  request_id: number;
+  from_user_id: number;
+  from_nickname: string;
+  timestamp: number;
+};
+
+export type Chat43GroupInvitationEventData = {
+  invitation_id: number;
+  group_id: number;
+  group_name: string;
+  inviter_id: number;
+  inviter_name: string;
+  invite_msg: string;
+  timestamp: number;
+};
+
+export type Chat43GroupMemberJoinedEventData = {
+  group_id: number;
+  group_name: string;
+  user_id: number;
+  nickname: string;
+  join_method: string;
+  timestamp: number;
+};
+
+export type Chat43SystemNoticeEventData = {
+  notice_id: string;
+  title: string;
+  content: string;
+  level: string;
+  timestamp: number;
+};
+
+export type Chat43AnySSEEvent =
+  | Chat43SSEEventEnvelope<Chat43PrivateMessageEventData>
+  | Chat43SSEEventEnvelope<Chat43GroupMessageEventData>
+  | Chat43SSEEventEnvelope<Chat43FriendRequestEventData>
+  | Chat43SSEEventEnvelope<Chat43FriendAcceptedEventData>
+  | Chat43SSEEventEnvelope<Chat43GroupInvitationEventData>
+  | Chat43SSEEventEnvelope<Chat43GroupMemberJoinedEventData>
+  | Chat43SSEEventEnvelope<Chat43SystemNoticeEventData>;
+
+export type Chat43OpenApiResponse<T> = {
+  code: number;
+  message: string;
+  timestamp: number;
+  data?: T;
+};
+
+export type Chat43AgentProfile = {
+  agent_id: string;
+  name: string;
+  avatar: string;
+  thumbnail_url: string;
+  description: string;
+  user_id: number;
+  im_user_id: string;
+  developer_name: string;
+  developer_email: string;
+  gender: number;
+  birthday: string;
+  city: string;
+  status: number;
+  created_at: number;
+  claim_url?: string;
+};
+
+export type Chat43Probe = {
+  ok: boolean;
+  agentId?: string;
+  userId?: number;
+  name?: string;
+  status?: number;
+  error?: string;
+};
+
+export type Chat43SendResult = {
+  messageId: string;
+  chatId: string;
+  targetType: "user" | "group";
+};
+
+export type Chat43MessageContext = {
+  messageId: string;
+  senderId: string;
+  text: string;
+  timestamp: number;
+  target: string;
+  chatType: "direct" | "group";
+};