@cored-im/openclaw-plugin 0.1.7 → 0.1.11

package/dist/index.js

@@ -10,9 +10,7 @@ import {
 // src/config.ts
 var DEFAULTS = {
   enableEncryption: true,
-  requestTimeout: 3e4,
-  requireMention: true,
-  inboundWhitelist: []
+  requestTimeout: 3e4
 };
 var ENV_PREFIX = "CORED_";
 function getChannelConfig(cfg) {
@@ -31,10 +29,6 @@ function readEnvConfig() {
     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) {
@@ -55,15 +49,12 @@ function resolveAccountConfig(cfg, accountId) {
   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 ?? "",
+    enabled: raw?.enabled ?? true,
     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]
+    requestTimeout: raw?.requestTimeout ?? envConfig.requestTimeout ?? DEFAULTS.requestTimeout
   };
 }
 function validateAccountConfig(config) {
@@ -315,171 +306,177 @@ function parseTarget(to) {
 }
 
 // src/channel.ts
-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 = createChatChannelPlugin({
-  base: 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
+var base = createChannelPluginBase({
+  id: "cored",
   meta: {
     id: "cored",
     label: "Cored",
     selectionLabel: "Cored",
     docsPath: "/channels/cored",
     blurb: "Connect OpenClaw to Cored",
-    aliases: ["cored", "co"]
+    aliases: ["co"]
   },
-  // Capabilities
   capabilities: {
     chatTypes: ["direct", "group"]
   },
-  // Config
   config: {
     listAccountIds: (cfg) => listAccountIds(cfg),
-    resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId)
+    resolveAccount: (cfg, accountId) => resolveAccountConfig(cfg, accountId ?? void 0),
+    inspectAccount(cfg, accountId) {
+      const resolved = resolveAccountConfig(cfg, accountId ?? void 0);
+      const hasConfig = Boolean(
+        resolved.appId && resolved.appSecret && resolved.backendUrl
+      );
+      return {
+        enabled: resolved.enabled,
+        configured: hasConfig,
+        tokenStatus: hasConfig ? "available" : "missing"
+      };
+    }
   },
-  // Outbound messaging
-  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}`)
-        };
+  setup: {
+    applyAccountConfig: ({ cfg, accountId, input }) => {
+      const updated = structuredClone(cfg);
+      if (!updated.channels) updated.channels = {};
+      const ch = updated.channels;
+      if (!ch["cored"]) ch["cored"] = {};
+      const section = ch["cored"];
+      const appId = input.appToken;
+      const appSecret = input.token;
+      const backendUrl = input.url;
+      if (accountId && accountId !== "default") {
+        if (!section.accounts) section.accounts = {};
+        const accounts = section.accounts;
+        if (!accounts[accountId]) accounts[accountId] = {};
+        const account = accounts[accountId];
+        if (appId) account.appId = appId;
+        if (appSecret) account.appSecret = appSecret;
+        if (backendUrl) account.backendUrl = backendUrl;
+      } else {
+        if (appId) section.appId = appId;
+        if (appSecret) section.appSecret = appSecret;
+        if (backendUrl) section.backendUrl = backendUrl;
       }
-      return sendText(target.id, text, accountId);
+      return updated;
     }
   },
-  // 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);
+        const ids = listAccountIds(cfg);
+        return ids.some((id) => {
+          const resolved = resolveAccountConfig(cfg, id);
+          return Boolean(resolved.appId && resolved.appSecret && resolved.backendUrl);
+        });
       }
     },
     credentials: [
       {
-        inputKey: "appId",
+        inputKey: "appToken",
         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"];
+        inspect: ({ cfg, accountId }) => {
+          const resolved = resolveAccountConfig(cfg, accountId ?? void 0);
           return {
-            accountConfigured: Boolean(section?.appId),
-            hasConfiguredValue: Boolean(section?.appId)
+            accountConfigured: Boolean(resolved.appId),
+            hasConfiguredValue: Boolean(resolved.appId)
           };
         }
       },
       {
-        inputKey: "appSecret",
+        inputKey: "token",
         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"];
+        inspect: ({ cfg, accountId }) => {
+          const resolved = resolveAccountConfig(cfg, accountId ?? void 0);
           return {
-            accountConfigured: Boolean(section?.appSecret),
-            hasConfiguredValue: Boolean(section?.appSecret)
+            accountConfigured: Boolean(resolved.appSecret),
+            hasConfiguredValue: Boolean(resolved.appSecret)
           };
         }
       },
       {
-        inputKey: "backendUrl",
+        inputKey: "url",
         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"];
+        inspect: ({ cfg, accountId }) => {
+          const resolved = resolveAccountConfig(cfg, accountId ?? void 0);
           return {
-            accountConfigured: Boolean(section?.backendUrl),
-            hasConfiguredValue: Boolean(section?.backendUrl)
+            accountConfigured: Boolean(resolved.backendUrl),
+            hasConfiguredValue: Boolean(resolved.backendUrl)
           };
         }
       }
     ]
   }
 });
+var coredPlugin = createChatChannelPlugin({
+  base,
+  // DM security: who can message the bot
+  security: {
+    dm: {
+      channelKey: "cored",
+      resolvePolicy: () => void 0,
+      resolveAllowFrom: () => [],
+      defaultPolicy: "allowlist"
+    }
+  },
+  // Threading: how replies are delivered
+  threading: { topLevelReplyToMode: "reply" },
+  // Outbound: send messages to the platform
+  outbound: {
+    attachedResults: {
+      channel: "cored",
+      sendText: async (ctx) => {
+        const target = parseTarget(ctx.to);
+        if (!target) {
+          throw new Error(`[cored] invalid send target: ${ctx.to}`);
+        }
+        const result = await sendText(
+          target.id,
+          ctx.text,
+          ctx.accountId ?? void 0,
+          ctx.replyToId ?? void 0
+        );
+        if (!result.ok) {
+          throw result.error ?? new Error("[cored] send failed");
+        }
+        return { messageId: result.messageId ?? "" };
+      }
+    },
+    base: {
+      deliveryMode: "direct",
+      resolveTarget: ({ to }) => {
+        if (!to) return { ok: false, error: new Error("[cored] --to is required") };
+        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}` };
+      }
+    }
+  }
+});
 
 // src/messaging/inbound.ts
 function parseMessageEvent(event) {
@@ -528,23 +525,8 @@ function extractTextBody(msg) {
   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;
@@ -579,7 +561,7 @@ function buildContext(msg, account) {
   return {
     Body: msg.body,
     From: isGroup ? `cored:chat:${msg.chatId}` : `cored:user:${msg.senderId}`,
-    To: `cored:bot:${account.botUserId ?? account.appId}`,
+    To: `cored:bot:${account.appId}`,
     SessionKey: sessionKey,
     AccountId: account.accountId,
     ChatType: isGroup ? "group" : "direct",
@@ -695,43 +677,42 @@ var index_default = defineChannelPluginEntry({
   description: "Connect OpenClaw with Cored",
   plugin: coredPlugin,
   registerFull(api) {
-    const typedApi = api;
-    typedApi.registerService({
+    api.registerService({
       id: "cored-sdk",
       start: async () => {
         if (clientCount() > 0) return;
-        const accounts = listEnabledAccountConfigs(typedApi.config);
+        const accounts = listEnabledAccountConfigs(api.config);
         if (accounts.length === 0) {
-          typedApi.logger?.warn?.("[cored] no enabled account config found \u2014 service idle");
+          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) {
-            typedApi.logger?.warn?.(
+            api.logger?.warn?.(
               `[cored] skipping account=${account.accountId}: ${errors.map((e) => e.message).join("; ")}`
             );
             continue;
           }
           try {
-            await startAccount(typedApi, account);
-            typedApi.logger?.info?.(
+            await startAccount(api, account);
+            api.logger?.info?.(
               `[cored] account=${account.accountId} connected (appId=${account.appId})`
             );
           } catch (err) {
-            typedApi.logger?.error?.(
+            api.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)`);
+        api.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 stopped \u2014 all clients disconnected");
       }
     });
-    typedApi.logger?.info?.("[cored] plugin registered");
+    api.logger?.info?.("[cored] plugin registered");
   }
 });
 async function startAccount(api, account) {