@cored-im/openclaw-plugin 0.1.0

package/dist/index.cjs

@@ -0,0 +1,650 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => register
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config.ts
+var DEFAULTS = {
+  enableEncryption: true,
+  requestTimeout: 3e4,
+  requireMention: true,
+  inboundWhitelist: []
+};
+var ENV_PREFIX = "CORED_";
+function getChannelConfig(cfg) {
+  const root = cfg;
+  return root?.channels ? root.channels.cored : void 0;
+}
+function readEnvConfig() {
+  const env = process.env;
+  const result = {};
+  if (env[`${ENV_PREFIX}APP_ID`]) result.appId = env[`${ENV_PREFIX}APP_ID`];
+  if (env[`${ENV_PREFIX}APP_SECRET`])
+    result.appSecret = env[`${ENV_PREFIX}APP_SECRET`];
+  if (env[`${ENV_PREFIX}BACKEND_URL`])
+    result.backendUrl = env[`${ENV_PREFIX}BACKEND_URL`];
+  if (env[`${ENV_PREFIX}ENABLE_ENCRYPTION`] !== void 0)
+    result.enableEncryption = env[`${ENV_PREFIX}ENABLE_ENCRYPTION`] !== "false";
+  if (env[`${ENV_PREFIX}REQUEST_TIMEOUT`])
+    result.requestTimeout = Number(env[`${ENV_PREFIX}REQUEST_TIMEOUT`]);
+  if (env[`${ENV_PREFIX}REQUIRE_MENTION`] !== void 0)
+    result.requireMention = env[`${ENV_PREFIX}REQUIRE_MENTION`] !== "false";
+  if (env[`${ENV_PREFIX}BOT_USER_ID`])
+    result.botUserId = env[`${ENV_PREFIX}BOT_USER_ID`];
+  return result;
+}
+function listAccountIds(cfg) {
+  const ch = getChannelConfig(cfg);
+  if (!ch) {
+    if (process.env[`${ENV_PREFIX}APP_ID`]) return ["default"];
+    return [];
+  }
+  if (ch.accounts) return Object.keys(ch.accounts);
+  if (ch.appId) return ["default"];
+  if (process.env[`${ENV_PREFIX}APP_ID`]) return ["default"];
+  return [];
+}
+function resolveAccountConfig(cfg, accountId) {
+  const ch = getChannelConfig(cfg);
+  const id = accountId ?? "default";
+  const envConfig = readEnvConfig();
+  const raw = ch?.accounts?.[id] ?? ch;
+  return {
+    accountId: id,
+    enabled: raw?.enabled ?? true,
+    appId: raw?.appId ?? envConfig.appId ?? "",
+    appSecret: raw?.appSecret ?? envConfig.appSecret ?? "",
+    backendUrl: raw?.backendUrl ?? envConfig.backendUrl ?? "",
+    enableEncryption: raw?.enableEncryption ?? envConfig.enableEncryption ?? DEFAULTS.enableEncryption,
+    requestTimeout: raw?.requestTimeout ?? envConfig.requestTimeout ?? DEFAULTS.requestTimeout,
+    requireMention: raw?.requireMention ?? envConfig.requireMention ?? DEFAULTS.requireMention,
+    botUserId: raw?.botUserId ?? envConfig.botUserId,
+    inboundWhitelist: raw?.inboundWhitelist ?? [...DEFAULTS.inboundWhitelist]
+  };
+}
+function validateAccountConfig(config) {
+  const errors = [];
+  if (!config.appId) {
+    errors.push({
+      field: "appId",
+      message: `Account "${config.accountId}": appId is required. Set it in channels.cored.appId or CORED_APP_ID env var.`
+    });
+  }
+  if (!config.appSecret) {
+    errors.push({
+      field: "appSecret",
+      message: `Account "${config.accountId}": appSecret is required. Set it in channels.cored.appSecret or CORED_APP_SECRET env var.`
+    });
+  }
+  if (!config.backendUrl) {
+    errors.push({
+      field: "backendUrl",
+      message: `Account "${config.accountId}": backendUrl is required. Set it in channels.cored.backendUrl or CORED_BACKEND_URL env var.`
+    });
+  } else if (!config.backendUrl.startsWith("http://") && !config.backendUrl.startsWith("https://")) {
+    errors.push({
+      field: "backendUrl",
+      message: `Account "${config.accountId}": backendUrl must start with http:// or https:// (got "${config.backendUrl}").`
+    });
+  }
+  if (typeof config.requestTimeout !== "number" || !Number.isFinite(config.requestTimeout) || config.requestTimeout <= 0) {
+    errors.push({
+      field: "requestTimeout",
+      message: `Account "${config.accountId}": requestTimeout must be a positive number in milliseconds (got ${config.requestTimeout}).`
+    });
+  }
+  return errors;
+}
+function listEnabledAccountConfigs(cfg) {
+  const ids = listAccountIds(cfg);
+  return ids.map((id) => resolveAccountConfig(cfg, id)).filter((account) => account.enabled);
+}
+
+// src/core/cored-client.ts
+var import_sdk = require("@cored-im/sdk");
+var AUTH_ERROR_CODE = 40000006;
+function isAuthError(err) {
+  return err instanceof import_sdk.ApiError && err.code === AUTH_ERROR_CODE;
+}
+var MessageType_TEXT = "text";
+var clients = /* @__PURE__ */ new Map();
+function makeLoggerAdapter(log) {
+  const emit = (level) => (msg, ...args) => {
+    log?.(`[${level}] ${msg}${args.length ? " " + JSON.stringify(args) : ""}`);
+  };
+  return {
+    debug: emit("debug"),
+    info: emit("info"),
+    warn: emit("warn"),
+    error: emit("error")
+  };
+}
+async function createClient(opts) {
+  const { config, onMessage, log } = opts;
+  const accountId = config.accountId;
+  if (clients.has(accountId)) {
+    await destroyClient(accountId);
+  }
+  const sdkClient = await import_sdk.CoredClient.create(
+    config.backendUrl,
+    config.appId,
+    config.appSecret,
+    {
+      enableEncryption: config.enableEncryption,
+      requestTimeout: config.requestTimeout,
+      logger: log ? makeLoggerAdapter(log) : void 0,
+      logLevel: log ? import_sdk.LoggerLevel.Debug : import_sdk.LoggerLevel.Info
+    }
+  );
+  await sdkClient.preheat();
+  const managed = { client: sdkClient, config, connectionState: "connected" };
+  if (onMessage) {
+    const handler = (sdkEvent) => {
+      const normalized = normalizeSdkEvent(sdkEvent);
+      if (normalized) {
+        onMessage(normalized, config);
+      }
+    };
+    sdkClient.Im.v1.Message.Event.onMessageReceive(
+      handler
+    );
+    managed.eventHandler = handler;
+  }
+  clients.set(accountId, managed);
+  return managed;
+}
+async function destroyClient(accountId) {
+  const managed = clients.get(accountId);
+  if (!managed) return;
+  managed.connectionState = "disconnecting";
+  if (managed.eventHandler) {
+    managed.client.Im.v1.Message.Event.offMessageReceive(
+      managed.eventHandler
+    );
+  }
+  try {
+    await managed.client.close();
+  } catch {
+  }
+  clients.delete(accountId);
+}
+async function destroyAllClients() {
+  const ids = [...clients.keys()];
+  await Promise.allSettled(ids.map((id) => destroyClient(id)));
+}
+function getClient(accountId) {
+  if (accountId && clients.has(accountId)) return clients.get(accountId);
+  if (clients.size > 0) return clients.values().next().value;
+  return void 0;
+}
+function clientCount() {
+  return clients.size;
+}
+function normalizeSdkEvent(sdk) {
+  const msg = sdk.body?.message;
+  if (!msg) return null;
+  const senderId = msg.sender_id;
+  let userId = "";
+  if (typeof senderId === "string") {
+    userId = senderId;
+  } else if (senderId && typeof senderId === "object") {
+    userId = senderId.user_id ?? senderId.open_user_id ?? senderId.union_user_id ?? "";
+  }
+  const mentionUsers = (msg.mention_user_list ?? []).map((u) => ({
+    userId: u.user_id?.user_id ?? u.user_id?.open_user_id ?? u.user_id?.union_user_id ?? ""
+  }));
+  const createdAt = typeof msg.message_created_at === "string" ? parseInt(msg.message_created_at, 10) || Date.now() : msg.message_created_at ?? Date.now();
+  return {
+    message: {
+      messageId: msg.message_id ?? "",
+      messageType: msg.message_type ?? "",
+      messageContent: msg.message_content,
+      chatId: msg.chat_id ?? "",
+      chatType: msg.chat_type ?? "direct",
+      sender: {
+        userId
+      },
+      createdAt,
+      mentionUserList: mentionUsers
+    }
+  };
+}
+
+// src/messaging/outbound.ts
+async function sendText(chatId, text, accountId, replyMessageId, logWarn) {
+  const managed = getClient(accountId);
+  if (!managed) {
+    return {
+      ok: false,
+      error: new Error(
+        `[cored] no connected client for account=${accountId ?? "default"}`
+      )
+    };
+  }
+  const req = {
+    chat_id: chatId,
+    message_type: MessageType_TEXT,
+    message_content: {
+      text: { content: text }
+    },
+    reply_message_id: replyMessageId
+  };
+  try {
+    const resp = await managed.client.Im.v1.Message.sendMessage(req);
+    return { ok: true, messageId: resp.message_id, provider: "cored" };
+  } catch (err) {
+    if (!isAuthError(err)) {
+      return {
+        ok: false,
+        error: new Error(
+          `[cored] send failed for chat=${chatId}: ${err instanceof Error ? err.message : String(err)}`
+        )
+      };
+    }
+    logWarn?.(
+      `[cored] auth error on send (chat=${chatId}, account=${accountId ?? "default"}) \u2014 refreshing token and retrying`
+    );
+    try {
+      await managed.client.preheat();
+      const resp = await managed.client.Im.v1.Message.sendMessage(req);
+      logWarn?.(
+        `[cored] auth retry succeeded (chat=${chatId}, account=${accountId ?? "default"})`
+      );
+      return { ok: true, messageId: resp.message_id, provider: "cored" };
+    } catch (retryErr) {
+      return {
+        ok: false,
+        error: new Error(
+          `[cored] send failed after auth retry for chat=${chatId}: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`
+        )
+      };
+    }
+  }
+}
+async function setTyping(chatId, accountId) {
+  const managed = getClient(accountId);
+  if (!managed) return;
+  try {
+    await managed.client.Im.v1.Chat.createTyping({ chat_id: chatId });
+  } catch {
+  }
+}
+async function clearTyping(chatId, accountId) {
+  const managed = getClient(accountId);
+  if (!managed) return;
+  try {
+    await managed.client.Im.v1.Chat.deleteTyping({ chat_id: chatId });
+  } catch {
+  }
+}
+async function readMessage(messageId, accountId) {
+  const managed = getClient(accountId);
+  if (!managed) return;
+  try {
+    await managed.client.Im.v1.Message.readMessage({ message_id: messageId });
+  } catch {
+  }
+}
+function makeDeliver(accountId, logWarn) {
+  return async (chatId, text) => {
+    const result = await sendText(chatId, text, accountId, void 0, logWarn);
+    if (!result.ok) {
+      throw result.error ?? new Error("[cored] send failed");
+    }
+  };
+}
+
+// src/targets.ts
+function parseTarget(to) {
+  const raw = String(to ?? "").trim();
+  if (!raw) return null;
+  const stripped = raw.replace(/^cored:/i, "");
+  if (stripped.startsWith("user:")) {
+    const id = stripped.slice("user:".length).trim();
+    return id ? { kind: "user", id } : null;
+  }
+  if (stripped.startsWith("chat:")) {
+    const id = stripped.slice("chat:".length).trim();
+    return id ? { kind: "chat", id } : null;
+  }
+  return stripped ? { kind: "chat", id: stripped } : null;
+}
+
+// src/channel.ts
+var coredPlugin = {
+  id: "cored",
+  meta: {
+    id: "cored",
+    label: "Cored",
+    selectionLabel: "Cored",
+    docsPath: "/channels/cored",
+    blurb: "Cored enterprise IM channel",
+    aliases: ["cored", "cd"]
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"]
+  },
+  config: {
+    listAccountIds: (cfg) => listAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId)
+  },
+  outbound: {
+    deliveryMode: "direct",
+    resolveTarget: ({ to }) => {
+      const target = parseTarget(to);
+      if (!target) {
+        return {
+          ok: false,
+          error: new Error(
+            `Cored requires --to <user:ID|chat:ID>, got: ${JSON.stringify(to)}`
+          )
+        };
+      }
+      return { ok: true, to: `${target.kind}:${target.id}` };
+    },
+    sendText: async ({
+      to,
+      text,
+      accountId
+    }) => {
+      const target = parseTarget(to);
+      if (!target) {
+        return {
+          ok: false,
+          error: new Error(`[cored] invalid send target: ${to}`)
+        };
+      }
+      return sendText(target.id, text, accountId);
+    }
+  }
+};
+
+// src/messaging/inbound.ts
+function parseMessageEvent(event) {
+  const msg = event?.message;
+  if (!msg || !msg.messageId || !msg.chatId) return null;
+  const body = extractTextBody(msg);
+  if (body === null) return null;
+  const chatType = msg.chatType === "group" ? "group" : "direct";
+  const senderId = msg.sender?.userId || msg.sender?.openUserId || msg.sender?.unionUserId;
+  if (!senderId) return null;
+  const mentionUserIds = (msg.mentionUserList ?? []).map((u) => u.userId || u.openUserId || u.unionUserId || "").filter(Boolean);
+  return {
+    messageId: msg.messageId,
+    chatId: msg.chatId,
+    chatType,
+    senderId,
+    body,
+    timestamp: msg.createdAt ?? Date.now(),
+    mentionUserIds
+  };
+}
+function extractTextBody(msg) {
+  if (msg.messageType !== "text") return null;
+  const content = msg.messageContent;
+  if (typeof content === "string") {
+    try {
+      const parsed = JSON.parse(content);
+      if (parsed?.text && typeof parsed.text === "object" && typeof parsed.text.content === "string")
+        return parsed.text.content.trim() || null;
+      if (typeof parsed?.text === "string") return parsed.text.trim() || null;
+      if (typeof parsed?.content === "string")
+        return parsed.content.trim() || null;
+    } catch {
+    }
+    return content.trim() || null;
+  }
+  if (content && typeof content === "object") {
+    const obj = content;
+    if (obj.text && typeof obj.text === "object") {
+      const textObj = obj.text;
+      if (typeof textObj.content === "string") return textObj.content.trim() || null;
+    }
+    if (typeof obj.text === "string") return obj.text.trim() || null;
+    if (typeof obj.content === "string") return obj.content.trim() || null;
+  }
+  return null;
+}
+function checkMessageGate(msg, account) {
+  if (account.botUserId && msg.senderId === account.botUserId) {
+    return { pass: false, reason: "self-message" };
+  }
+  if (account.inboundWhitelist.length > 0) {
+    if (!account.inboundWhitelist.includes(msg.senderId)) {
+      return { pass: false, reason: "sender-not-in-whitelist" };
+    }
+  }
+  if (msg.chatType === "group" && account.requireMention && !isBotMentioned(msg, account)) {
+    return { pass: false, reason: "group-no-mention" };
+  }
+  return { pass: true };
+}
+function isBotMentioned(msg, account) {
+  if (!account.botUserId) return false;
+  return msg.mentionUserIds.includes(account.botUserId);
+}
+var DEDUP_TTL_MS = 5 * 60 * 1e3;
+var DEDUP_CLEANUP_INTERVAL_MS = 60 * 1e3;
+var DEDUP_MAX_SIZE = 1e4;
+var processedMessages = /* @__PURE__ */ new Map();
+var lastCleanup = Date.now();
+function isDuplicate(messageId) {
+  cleanupIfNeeded();
+  if (processedMessages.has(messageId)) return true;
+  processedMessages.set(messageId, Date.now());
+  return false;
+}
+function cleanupIfNeeded() {
+  const now = Date.now();
+  if (now - lastCleanup < DEDUP_CLEANUP_INTERVAL_MS) return;
+  lastCleanup = now;
+  const expiry = now - DEDUP_TTL_MS;
+  for (const [id, ts] of processedMessages) {
+    if (ts < expiry) processedMessages.delete(id);
+  }
+  if (processedMessages.size > DEDUP_MAX_SIZE) {
+    const excess = processedMessages.size - DEDUP_MAX_SIZE;
+    const iter = processedMessages.keys();
+    for (let i = 0; i < excess; i++) {
+      const key = iter.next().value;
+      if (key !== void 0) processedMessages.delete(key);
+    }
+  }
+}
+function buildContext(msg, account) {
+  const isGroup = msg.chatType === "group";
+  const sessionKey = isGroup ? `cored:chat:${msg.chatId}` : `cored:user:${msg.senderId}`;
+  return {
+    Body: msg.body,
+    From: isGroup ? `cored:chat:${msg.chatId}` : `cored:user:${msg.senderId}`,
+    To: `cored:bot:${account.botUserId ?? account.appId}`,
+    SessionKey: sessionKey,
+    AccountId: account.accountId,
+    ChatType: isGroup ? "group" : "direct",
+    Provider: "cored",
+    Surface: "cored",
+    MessageSid: msg.messageId,
+    Timestamp: msg.timestamp,
+    CommandAuthorized: true,
+    _cored: {
+      accountId: account.accountId,
+      isGroup,
+      senderId: msg.senderId,
+      chatId: msg.chatId
+    }
+  };
+}
+async function processInboundMessage(api, account, event, opts) {
+  const logger = api.logger;
+  const parsed = parseMessageEvent(event);
+  if (!parsed) {
+    logger?.debug(
+      `[cored] ignoring unparseable event (messageId=${event?.message?.messageId ?? "unknown"} messageType=${event?.message?.messageType ?? "undefined"})`
+    );
+    return false;
+  }
+  const gate = checkMessageGate(parsed, account);
+  if (!gate.pass) {
+    logger?.debug(
+      `[cored] gated message=${parsed.messageId} reason=${gate.reason} chat=${parsed.chatId}`
+    );
+    return false;
+  }
+  if (isDuplicate(parsed.messageId)) {
+    logger?.debug(
+      `[cored] duplicate message=${parsed.messageId} chat=${parsed.chatId}`
+    );
+    return false;
+  }
+  const ctx = buildContext(parsed, account);
+  logger?.info(
+    `[cored] dispatching message=${parsed.messageId} chat=${parsed.chatId} sender=${parsed.senderId} type=${parsed.chatType}`
+  );
+  const runtime = api.runtime;
+  if (!runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+    logger?.warn("[cored] runtime.channel.reply not available \u2014 cannot dispatch");
+    return false;
+  }
+  const cfgSession = api.config?.session;
+  const storePath = runtime.channel.session?.resolveStorePath?.(
+    cfgSession?.store,
+    { agentId: "main" }
+  ) ?? "";
+  await runtime.channel.session?.recordInboundSession?.({
+    storePath,
+    sessionKey: ctx.SessionKey,
+    ctx,
+    updateLastRoute: ctx.ChatType === "direct" ? {
+      sessionKey: ctx.SessionKey,
+      channel: "cored",
+      to: parsed.chatId,
+      accountId: account.accountId
+    } : void 0
+  });
+  logger?.debug(
+    `[cored] dispatch starting for message=${parsed.messageId} session=${ctx.SessionKey}`
+  );
+  await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx,
+    cfg: api.config,
+    dispatcherOptions: {
+      deliver: async (payload) => {
+        logger?.info(
+          `[cored] deliver callback called for message=${parsed.messageId} hasText=${!!payload.text} textLen=${payload.text?.length ?? 0}`
+        );
+        if (payload.text) {
+          await opts.deliver(parsed.chatId, payload.text);
+          logger?.info(
+            `[cored] deliver completed for message=${parsed.messageId} chat=${parsed.chatId}`
+          );
+        }
+      },
+      onError: (err, info) => {
+        logger?.error(
+          `[cored] ${info?.kind ?? "reply"} error for message=${parsed.messageId}: ${err}`
+        );
+      }
+    }
+  });
+  logger?.info(
+    `[cored] dispatch finished for message=${parsed.messageId}`
+  );
+  return true;
+}
+
+// src/index.ts
+function register(api) {
+  api.registerChannel({ plugin: coredPlugin });
+  api.registerService({
+    id: "cored-sdk",
+    start: async () => {
+      if (clientCount() > 0) return;
+      const accounts = listEnabledAccountConfigs(api.config);
+      if (accounts.length === 0) {
+        api.logger?.warn("[cored] no enabled account config found \u2014 service idle");
+        return;
+      }
+      for (const account of accounts) {
+        const errors = validateAccountConfig(account);
+        if (errors.length > 0) {
+          api.logger?.warn(
+            `[cored] skipping account=${account.accountId}: ${errors.map((e) => e.message).join("; ")}`
+          );
+          continue;
+        }
+        try {
+          await startAccount(api, account);
+          api.logger?.info(
+            `[cored] account=${account.accountId} connected (appId=${account.appId})`
+          );
+        } catch (err) {
+          api.logger?.error(
+            `[cored] account=${account.accountId} failed to start: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      api.logger?.info(`[cored] service started with ${clientCount()} account(s)`);
+    },
+    stop: async () => {
+      await destroyAllClients();
+      api.logger?.info("[cored] service stopped \u2014 all clients disconnected");
+    }
+  });
+  api.logger?.info("[cored] plugin registered");
+}
+async function startAccount(api, account) {
+  const deliver = makeDeliver(account.accountId, (msg) => api.logger?.warn(msg));
+  await createClient({
+    config: account,
+    log: (msg) => api.logger?.debug(msg),
+    onMessage: (event, accountConfig) => {
+      handleInbound(api, accountConfig, event, deliver).catch((err) => {
+        api.logger?.error(
+          `[cored] unhandled inbound error for account=${accountConfig.accountId}: ${err}`
+        );
+      });
+    }
+  });
+}
+async function handleInbound(api, account, event, deliver) {
+  const chatId = event.message?.chatId;
+  const messageId = event.message?.messageId;
+  if (chatId) {
+    setTyping(chatId, account.accountId).catch(() => {
+    });
+  }
+  if (messageId) {
+    readMessage(messageId, account.accountId).catch(() => {
+    });
+  }
+  try {
+    await processInboundMessage(api, account, event, { deliver });
+  } finally {
+    if (chatId) {
+      clearTyping(chatId, account.accountId).catch(() => {
+      });
+    }
+  }
+}
+//# sourceMappingURL=index.cjs.map