@cored-im/openclaw-plugin 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -20,9 +20,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  default: () => register
+  default: () => index_default
 });
 module.exports = __toCommonJS(index_exports);
+var import_core2 = require("openclaw/plugin-sdk/core");
+
+// src/channel.ts
+var import_core = require("openclaw/plugin-sdk/core");
 
 // src/config.ts
 var DEFAULTS = {
@@ -332,23 +336,79 @@ function parseTarget(to) {
 }
 
 // src/channel.ts
-var coredPlugin = {
-  id: "cored",
+function resolveAccount(cfg, accountId) {
+  const section = cfg.channels?.["cored"];
+  const accounts = section?.accounts;
+  const defaultAccount = section?.defaultAccount;
+  if (accounts && Object.keys(accounts).length > 0) {
+    const targetId = accountId ?? defaultAccount ?? Object.keys(accounts)[0];
+    const account = accounts[targetId];
+    if (!account) {
+      throw new Error(`cored: account "${targetId}" not found`);
+    }
+    return {
+      accountId: targetId,
+      appId: account.appId,
+      appSecret: account.appSecret,
+      backendUrl: account.backendUrl,
+      enableEncryption: account.enableEncryption ?? section.enableEncryption ?? true,
+      requestTimeout: account.requestTimeout ?? section.requestTimeout ?? 3e4,
+      requireMention: account.requireMention ?? section.requireMention ?? true
+    };
+  }
+  const appId = section?.appId;
+  const appSecret = section?.appSecret;
+  const backendUrl = section?.backendUrl;
+  if (!appId || !appSecret || !backendUrl) {
+    throw new Error("cored: appId, appSecret, and backendUrl are required");
+  }
+  return {
+    accountId: null,
+    appId,
+    appSecret,
+    backendUrl,
+    enableEncryption: section?.enableEncryption ?? true,
+    requestTimeout: section?.requestTimeout ?? 3e4,
+    requireMention: section?.requireMention ?? true
+  };
+}
+var coredPlugin = (0, import_core.createChatChannelPlugin)({
+  base: (0, import_core.createChannelPluginBase)({
+    id: "cored",
+    setup: {
+      resolveAccount,
+      inspectAccount(cfg, accountId) {
+        const section = cfg.channels?.["cored"];
+        const hasConfig = Boolean(
+          section?.appId && section?.appSecret && section?.backendUrl
+        );
+        return {
+          enabled: Boolean(section?.enabled !== false),
+          configured: hasConfig,
+          tokenStatus: hasConfig ? "available" : "missing"
+        };
+      }
+    }
+  }),
+  // Plugin metadata
   meta: {
     id: "cored",
     label: "Cored",
     selectionLabel: "Cored",
     docsPath: "/channels/cored",
-    blurb: "Cored enterprise IM channel",
+    blurb: "Connect OpenClaw to Cored",
     aliases: ["cored", "co"]
   },
+  // Capabilities
   capabilities: {
     chatTypes: ["direct", "group"]
   },
+  // Config
   config: {
     listAccountIds: (cfg) => listAccountIds(cfg),
     resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId)
   },
+  // Outbound messaging
   outbound: {
     deliveryMode: "direct",
     resolveTarget: ({ to }) => {
@@ -377,8 +437,70 @@ var coredPlugin = {
       }
       return sendText(target.id, text, accountId);
     }
+  },
+  // Setup wizard for openclaw onboard
+  setupWizard: {
+    channel: "cored",
+    status: {
+      configuredLabel: "Connected",
+      unconfiguredLabel: "Not configured",
+      resolveConfigured: ({ cfg }) => {
+        const section = cfg.channels?.["cored"];
+        return Boolean(section?.appId && section?.appSecret && section?.backendUrl);
+      }
+    },
+    credentials: [
+      {
+        inputKey: "appId",
+        providerHint: "cored",
+        credentialLabel: "App ID",
+        preferredEnvVar: "CORED_APP_ID",
+        envPrompt: "Use CORED_APP_ID from environment?",
+        keepPrompt: "Keep current App ID?",
+        inputPrompt: "Enter your Cored App ID:",
+        inspect: ({ cfg }) => {
+          const section = cfg.channels?.["cored"];
+          return {
+            accountConfigured: Boolean(section?.appId),
+            hasConfiguredValue: Boolean(section?.appId)
+          };
+        }
+      },
+      {
+        inputKey: "appSecret",
+        providerHint: "cored",
+        credentialLabel: "App Secret",
+        preferredEnvVar: "CORED_APP_SECRET",
+        envPrompt: "Use CORED_APP_SECRET from environment?",
+        keepPrompt: "Keep current App Secret?",
+        inputPrompt: "Enter your Cored App Secret:",
+        inspect: ({ cfg }) => {
+          const section = cfg.channels?.["cored"];
+          return {
+            accountConfigured: Boolean(section?.appSecret),
+            hasConfiguredValue: Boolean(section?.appSecret)
+          };
+        }
+      },
+      {
+        inputKey: "backendUrl",
+        providerHint: "cored",
+        credentialLabel: "Backend URL",
+        preferredEnvVar: "CORED_BACKEND_URL",
+        envPrompt: "Use CORED_BACKEND_URL from environment?",
+        keepPrompt: "Keep current Backend URL?",
+        inputPrompt: "Enter your Cored backend server URL:",
+        inspect: ({ cfg }) => {
+          const section = cfg.channels?.["cored"];
+          return {
+            accountConfigured: Boolean(section?.backendUrl),
+            hasConfiguredValue: Boolean(section?.backendUrl)
+          };
+        }
+      }
+    ]
   }
-};
+});
 
 // src/messaging/inbound.ts
 function parseMessageEvent(event) {
@@ -497,33 +619,47 @@ function buildContext(msg, account) {
 }
 async function processInboundMessage(api, account, event, opts) {
   const logger = api.logger;
+  const log = {
+    debug: (msg) => {
+      logger?.debug?.(msg);
+    },
+    info: (msg) => {
+      logger?.info?.(msg);
+    },
+    warn: (msg) => {
+      logger?.warn?.(msg);
+    },
+    error: (msg) => {
+      logger?.error?.(msg);
+    }
+  };
   const parsed = parseMessageEvent(event);
   if (!parsed) {
-    logger?.debug(
+    log.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(
+    log.debug(
       `[cored] gated message=${parsed.messageId} reason=${gate.reason} chat=${parsed.chatId}`
     );
     return false;
   }
   if (isDuplicate(parsed.messageId)) {
-    logger?.debug(
+    log.debug(
       `[cored] duplicate message=${parsed.messageId} chat=${parsed.chatId}`
     );
     return false;
   }
   const ctx = buildContext(parsed, account);
-  logger?.info(
+  log.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");
+    log.warn("[cored] runtime.channel.reply not available \u2014 cannot dispatch");
     return false;
   }
   const cfgSession = api.config?.session;
@@ -542,7 +678,7 @@ async function processInboundMessage(api, account, event, opts) {
       accountId: account.accountId
     } : void 0
   });
-  logger?.debug(
+  log.debug(
     `[cored] dispatch starting for message=${parsed.messageId} session=${ctx.SessionKey}`
   );
   await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
@@ -550,77 +686,83 @@ async function processInboundMessage(api, account, event, opts) {
     cfg: api.config,
     dispatcherOptions: {
       deliver: async (payload) => {
-        logger?.info(
+        log.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(
+          log.info(
             `[cored] deliver completed for message=${parsed.messageId} chat=${parsed.chatId}`
           );
         }
       },
       onError: (err, info) => {
-        logger?.error(
+        log.error(
           `[cored] ${info?.kind ?? "reply"} error for message=${parsed.messageId}: ${err}`
         );
       }
     }
   });
-  logger?.info(
+  log.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;
+var index_default = (0, import_core2.defineChannelPluginEntry)({
+  id: "cored",
+  name: "Cored",
+  description: "Connect OpenClaw with Cored",
+  plugin: coredPlugin,
+  registerFull(api) {
+    const typedApi = api;
+    typedApi.registerService({
+      id: "cored-sdk",
+      start: async () => {
+        if (clientCount() > 0) return;
+        const accounts = listEnabledAccountConfigs(typedApi.config);
+        if (accounts.length === 0) {
+          typedApi.logger?.warn?.("[cored] no enabled account config found \u2014 service idle");
+          return;
         }
-        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)}`
-          );
+        for (const account of accounts) {
+          const errors = validateAccountConfig(account);
+          if (errors.length > 0) {
+            typedApi.logger?.warn?.(
+              `[cored] skipping account=${account.accountId}: ${errors.map((e) => e.message).join("; ")}`
+            );
+            continue;
+          }
+          try {
+            await startAccount(typedApi, account);
+            typedApi.logger?.info?.(
+              `[cored] account=${account.accountId} connected (appId=${account.appId})`
+            );
+          } catch (err) {
+            typedApi.logger?.error?.(
+              `[cored] account=${account.accountId} failed to start: ${err instanceof Error ? err.message : String(err)}`
+            );
+          }
         }
+        typedApi.logger?.info?.(`[cored] service started with ${clientCount()} account(s)`);
+      },
+      stop: async () => {
+        await destroyAllClients();
+        typedApi.logger?.info?.("[cored] service stopped \u2014 all clients disconnected");
       }
-      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");
-}
+    });
+    typedApi.logger?.info?.("[cored] plugin registered");
+  }
+});
 async function startAccount(api, account) {
-  const deliver = makeDeliver(account.accountId, (msg) => api.logger?.warn(msg));
+  const deliver = makeDeliver(account.accountId, (msg) => api.logger?.warn?.(msg));
   await createClient({
     config: account,
-    log: (msg) => api.logger?.debug(msg),
+    log: (msg) => api.logger?.debug?.(msg),
     onMessage: (event, accountConfig) => {
       handleInbound(api, accountConfig, event, deliver).catch((err) => {
-        api.logger?.error(
+        api.logger?.error?.(
           `[cored] unhandled inbound error for account=${accountConfig.accountId}: ${err}`
         );
       });