@cored-im/openclaw-plugin 0.1.7 → 0.1.10

package/dist/index.cjs

@@ -336,171 +336,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 = (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
+var base = (0, import_core.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)}`
-          )
-        };
+  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 { 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);
+      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 = (0, import_core.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) {
@@ -716,43 +722,42 @@ var index_default = (0, import_core2.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) {