@cored-im/openclaw-plugin 0.1.4 → 0.1.5

package/src/channel.ts

@@ -1,28 +1,113 @@
 // Copyright (c) 2026 Cored Limited
 // SPDX-License-Identifier: Apache-2.0
 
+import {
+  createChatChannelPlugin,
+  createChannelPluginBase,
+} from "openclaw/plugin-sdk/core";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { listAccountIds, resolveAccountConfig } from "./config.js";
 import { sendText } from "./messaging/outbound.js";
 import { parseTarget } from "./targets.js";
 
-export const coredPlugin = {
-  id: "cored",
+type ResolvedAccount = {
+  accountId: string | null;
+  appId: string;
+  appSecret: string;
+  backendUrl: string;
+  enableEncryption: boolean;
+  requestTimeout: number;
+  requireMention: boolean;
+};
+
+function resolveAccount(
+  cfg: OpenClawConfig,
+  accountId?: string | null,
+): ResolvedAccount {
+  const section = (cfg.channels as Record<string, any>)?.["cored"];
+  const accounts = section?.accounts;
+  const defaultAccount = section?.defaultAccount;
+
+  // If multi-account mode, resolve the specific account
+  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 ?? 30000,
+      requireMention: account.requireMention ?? section.requireMention ?? true,
+    };
+  }
+
+  // Single-account mode
+  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 ?? 30000,
+    requireMention: section?.requireMention ?? true,
+  };
+}
+
+export const coredPlugin = createChatChannelPlugin<ResolvedAccount>({
+  base: createChannelPluginBase({
+    id: "cored",
+    setup: {
+      resolveAccount,
+      inspectAccount(cfg, accountId) {
+        const section = (cfg.channels as Record<string, any>)?.["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"] as const,
   },
+
+  // Config
   config: {
     listAccountIds: (cfg: unknown) => listAccountIds(cfg),
     resolveAccount: (cfg: unknown, accountId?: string) =>
       resolveAccountConfig(cfg, accountId),
   },
+
+  // Outbound messaging
   outbound: {
     deliveryMode: "direct" as const,
     resolveTarget: ({ to }: { to?: string }) => {
@@ -58,4 +143,67 @@ export const coredPlugin = {
       return sendText(target.id, text, accountId);
     },
   },
-};
+
+  // Setup wizard for openclaw onboard
+  setupWizard: {
+    channel: "cored",
+    status: {
+      configuredLabel: "Connected",
+      unconfiguredLabel: "Not configured",
+      resolveConfigured: ({ cfg }: { cfg: OpenClawConfig }) => {
+        const section = (cfg.channels as Record<string, any>)?.["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 }: { cfg: OpenClawConfig }) => {
+          const section = (cfg.channels as Record<string, any>)?.["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 }: { cfg: OpenClawConfig }) => {
+          const section = (cfg.channels as Record<string, any>)?.["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 }: { cfg: OpenClawConfig }) => {
+          const section = (cfg.channels as Record<string, any>)?.["cored"];
+          return {
+            accountConfigured: Boolean(section?.backendUrl),
+            hasConfiguredValue: Boolean(section?.backendUrl),
+          };
+        },
+      },
+    ],
+  },
+});

package/src/index.test.ts

@@ -2,8 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import register from "./index.js";
-import type { PluginApi } from "./types.js";
+
+// Mock the SDK module before any imports
+vi.mock("openclaw/plugin-sdk/core", () => ({
+  defineChannelPluginEntry: (config: unknown) => config,
+  createChatChannelPlugin: (config: unknown) => config,
+  createChannelPluginBase: (config: unknown) => config,
+}));
 
 vi.mock("./core/cored-client.js", () => ({
   createClient: vi.fn(),
@@ -18,20 +23,29 @@ vi.mock("./messaging/outbound.js", () => ({
   readMessage: vi.fn().mockResolvedValue(undefined),
 }));
 
+// Import after mocks are set up
 import { createClient, clientCount } from "./core/cored-client.js";
 
-function createMockApi(config: unknown = {}): PluginApi {
+// Import the entry module - need to use dynamic import for esm
+const entry = await import("./index.js");
+
+interface MockPluginApi {
+  registerChannel: ReturnType<typeof vi.fn>;
+  registerService: ReturnType<typeof vi.fn>;
+  config: { channels?: Record<string, unknown> };
+  logger?: {
+    info: ReturnType<typeof vi.fn>;
+    warn: ReturnType<typeof vi.fn>;
+    error: ReturnType<typeof vi.fn>;
+    debug: ReturnType<typeof vi.fn>;
+  };
+}
+
+function createMockApi(config: unknown = {}): MockPluginApi {
   return {
     registerChannel: vi.fn(),
     registerService: vi.fn(),
-    config: config as PluginApi["config"],
-    runtime: {
-      channel: {
-        reply: { dispatchReplyWithBufferedBlockDispatcher: vi.fn() },
-        session: { recordInboundSession: vi.fn() },
-        routing: { resolveAgentRoute: vi.fn() },
-      },
-    },
+    config: config as MockPluginApi["config"],
     logger: {
       info: vi.fn(),
       warn: vi.fn(),
@@ -41,25 +55,37 @@ function createMockApi(config: unknown = {}): PluginApi {
   };
 }
 
-function extractStartFn(api: PluginApi): () => Promise<void> {
+function extractStartFn(api: MockPluginApi): () => Promise<void> {
   const call = (api.registerService as ReturnType<typeof vi.fn>).mock.calls[0];
   return call[0].start;
 }
 
-describe("register", () => {
+describe("entry module", () => {
   beforeEach(() => {
     vi.mocked(clientCount).mockReturnValue(0);
     vi.mocked(createClient).mockResolvedValue({ client: {}, config: {} } as any);
   });
 
-  it("registers channel and service", () => {
-    const api = createMockApi();
-    register(api);
+  it("exports entry with correct id", () => {
+    expect(entry.default.id).toBe("cored");
+  });
 
-    expect(api.registerChannel).toHaveBeenCalledOnce();
-    expect(api.registerChannel).toHaveBeenCalledWith(
-      expect.objectContaining({ plugin: expect.objectContaining({ id: "cored" }) }),
-    );
+  it("exports entry with correct name", () => {
+    expect(entry.default.name).toBe("Cored");
+  });
+
+  it("exports entry with plugin", () => {
+    expect(entry.default.plugin).toBeDefined();
+    expect(entry.default.plugin.base.id).toBe("cored");
+  });
+
+  it("exports registerFull function", () => {
+    expect(entry.default.registerFull).toBeInstanceOf(Function);
+  });
+
+  it("registerFull registers service", () => {
+    const api = createMockApi();
+    entry.default.registerFull(api);
 
     expect(api.registerService).toHaveBeenCalledOnce();
     expect(api.registerService).toHaveBeenCalledWith(
@@ -67,9 +93,9 @@ describe("register", () => {
     );
   });
 
-  it("logs plugin registration", () => {
+  it("registerFull logs plugin registration", () => {
     const api = createMockApi();
-    register(api);
+    entry.default.registerFull(api);
     expect(api.logger!.info).toHaveBeenCalledWith("[cored] plugin registered");
   });
 });
@@ -91,7 +117,7 @@ describe("service start — config validation", () => {
         },
       },
     });
-    register(api);
+    entry.default.registerFull(api);
     await extractStartFn(api)();
 
     expect(api.logger!.warn).toHaveBeenCalledWith(
@@ -113,7 +139,7 @@ describe("service start — config validation", () => {
         },
       },
     });
-    register(api);
+    entry.default.registerFull(api);
     await extractStartFn(api)();
 
     expect(api.logger!.warn).toHaveBeenCalledWith(
@@ -128,7 +154,7 @@ describe("service start — config validation", () => {
         cored: { appId: "a", appSecret: "s", backendUrl: "https://ok.io" },
       },
     });
-    register(api);
+    entry.default.registerFull(api);
     await extractStartFn(api)();
 
     expect(createClient).toHaveBeenCalledOnce();
@@ -148,7 +174,7 @@ describe("service start — config validation", () => {
         },
       },
     });
-    register(api);
+    entry.default.registerFull(api);
     await extractStartFn(api)();
 
     // bad account skipped with warning

package/src/index.ts

@@ -1,6 +1,7 @@
 // Copyright (c) 2026 Cored Limited
 // SPDX-License-Identifier: Apache-2.0
 
+import { defineChannelPluginEntry, type PluginApi } from "openclaw/plugin-sdk/core";
 import { coredPlugin } from "./channel.js";
 import { listEnabledAccountConfigs, validateAccountConfig } from "./config.js";
 import {
@@ -8,72 +9,83 @@ import {
   destroyAllClients,
   clientCount,
 } from "./core/cored-client.js";
-import { processInboundMessage } from "./messaging/inbound.js";
+import { processInboundMessage, type ExtendedPluginApi } from "./messaging/inbound.js";
 import { makeDeliver, setTyping, clearTyping, readMessage } from "./messaging/outbound.js";
-import type { PluginApi, CoredAccountConfig, CoredMessageEvent } from "./types.js";
+import type { CoredAccountConfig, CoredMessageEvent } from "./types.js";
 
-export default function register(api: PluginApi): void {
-  api.registerChannel({ plugin: coredPlugin });
+// Extended PluginApi with config type for service registration
+interface ServicePluginApi extends ExtendedPluginApi {
+  config: { channels?: Record<string, unknown> };
+}
 
-  api.registerService({
-    id: "cored-sdk",
-    start: async () => {
-      if (clientCount() > 0) return;
+export default defineChannelPluginEntry({
+  id: "cored",
+  name: "Cored",
+  description: "Connect OpenClaw with Cored",
+  plugin: coredPlugin,
+  registerFull(api) {
+    const typedApi = api as ServicePluginApi;
 
-      const accounts = listEnabledAccountConfigs(api.config);
-      if (accounts.length === 0) {
-        api.logger?.warn("[cored] no enabled account config found — service idle");
-        return;
-      }
+    typedApi.registerService({
+      id: "cored-sdk",
+      start: async () => {
+        if (clientCount() > 0) 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;
+        const accounts = listEnabledAccountConfigs(typedApi.config);
+        if (accounts.length === 0) {
+          typedApi.logger?.warn?.("[cored] no enabled account config found — 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)}`,
+            );
+          }
         }
-      }
 
-      api.logger?.info(`[cored] service started with ${clientCount()} account(s)`);
-    },
-    stop: async () => {
-      await destroyAllClients();
-      api.logger?.info("[cored] service stopped — all clients disconnected");
-    },
-  });
+        typedApi.logger?.info?.(`[cored] service started with ${clientCount()} account(s)`);
+      },
+      stop: async () => {
+        await destroyAllClients();
+        typedApi.logger?.info?.("[cored] service stopped — all clients disconnected");
+      },
+    });
 
-  api.logger?.info("[cored] plugin registered");
-}
+    typedApi.logger?.info?.("[cored] plugin registered");
+  },
+});
 
 /**
  * Start a single account — create client, subscribe to inbound events.
  */
 async function startAccount(
-  api: PluginApi,
+  api: ServicePluginApi,
   account: CoredAccountConfig,
 ): Promise<void> {
-  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: string) => api.logger?.debug(msg),
+    log: (msg: string) => api.logger?.debug?.(msg),
     onMessage: (event: CoredMessageEvent, accountConfig: CoredAccountConfig) => {
       // Fire-and-forget: process inbound with typing indicator
       handleInbound(api, accountConfig, event, deliver).catch((err) => {
-        api.logger?.error(
+        api.logger?.error?.(
           `[cored] unhandled inbound error for account=${accountConfig.accountId}: ${err}`,
         );
       });
@@ -85,7 +97,7 @@ async function startAccount(
  * Handle a single inbound message with typing indicator lifecycle.
  */
 async function handleInbound(
-  api: PluginApi,
+  api: ServicePluginApi,
   account: CoredAccountConfig,
   event: CoredMessageEvent,
   deliver: (chatId: string, text: string) => Promise<void>,

package/src/messaging/inbound.ts

@@ -17,6 +17,30 @@ import type {
   PluginApi,
 } from "../types.js";
 
+// Extended PluginApi with runtime surfaces used by this module
+export interface ExtendedPluginApi extends PluginApi {
+  runtime?: {
+    channel?: {
+      reply?: {
+        dispatchReplyWithBufferedBlockDispatcher?: (opts: unknown) => Promise<void>;
+      };
+      session?: {
+        recordInboundSession?: (opts: unknown) => Promise<void>;
+        resolveStorePath?: (store: unknown, opts: unknown) => string;
+      };
+      routing?: {
+        resolveAgentRoute?: (opts: unknown) => unknown;
+      };
+    };
+  };
+  logger?: {
+    debug?: (msg: string) => void;
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Parse — extract usable text body from incoming message
 // ---------------------------------------------------------------------------
@@ -290,17 +314,25 @@ export interface InboundDispatchOptions {
  * Returns `true` if the message was dispatched, `false` if filtered.
  */
 export async function processInboundMessage(
-  api: PluginApi,
+  api: ExtendedPluginApi,
   account: CoredAccountConfig,
   event: CoredMessageEvent,
   opts: InboundDispatchOptions,
 ): Promise<boolean> {
   const logger = api.logger;
 
+  // Helper for safe logging
+  const log = {
+    debug: (msg: string) => { logger?.debug?.(msg); },
+    info: (msg: string) => { logger?.info?.(msg); },
+    warn: (msg: string) => { logger?.warn?.(msg); },
+    error: (msg: string) => { logger?.error?.(msg); },
+  };
+
   // 1. Parse
   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;
@@ -309,7 +341,7 @@ export async function processInboundMessage(
   // 2. Gate
   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;
@@ -317,7 +349,7 @@ export async function processInboundMessage(
 
   // 3. Dedup
   if (isDuplicate(parsed.messageId)) {
-    logger?.debug(
+    log.debug(
       `[cored] duplicate message=${parsed.messageId} chat=${parsed.chatId}`,
     );
     return false;
@@ -326,14 +358,14 @@ export async function processInboundMessage(
   // 4. Build context
   const ctx = buildContext(parsed, account);
 
-  logger?.info(
+  log.info(
     `[cored] dispatching message=${parsed.messageId} chat=${parsed.chatId} sender=${parsed.senderId} type=${parsed.chatType}`,
   );
 
   // 5. Dispatch
   const runtime = api.runtime;
   if (!runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
-    logger?.warn("[cored] runtime.channel.reply not available — cannot dispatch");
+    log.warn("[cored] runtime.channel.reply not available — cannot dispatch");
     return false;
   }
 
@@ -361,7 +393,7 @@ export async function processInboundMessage(
   });
 
   // Dispatch reply with buffered block dispatcher
-  logger?.debug(
+  log.debug(
     `[cored] dispatch starting for message=${parsed.messageId} session=${ctx.SessionKey}`,
   );
 
@@ -370,25 +402,25 @@ export async function processInboundMessage(
     cfg: api.config,
     dispatcherOptions: {
       deliver: async (payload: { text?: string }) => {
-        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: unknown, info?: { kind?: string }) => {
-        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}`,
   );
 

package/src/setup-entry.ts

@@ -2,50 +2,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
+import { coredPlugin } from "./channel.js";
 
-export default defineSetupPluginEntry({
-  async onSetup(context) {
-    const appId = await context.prompt({
-      type: "text",
-      message: "Enter your Cored App ID:",
-      validate: (val: string) => val.length > 0 || "This field is required",
-    });
-
-    const appSecret = await context.prompt({
-      type: "password",
-      message: "Enter your Cored App Secret:",
-      validate: (val: string) => val.length > 0 || "This field is required",
-    });
-
-    const backendUrl = await context.prompt({
-      type: "text",
-      message: "Enter Cored backend server URL:",
-      validate: (val: string) => {
-        if (val.length === 0) return "This field is required";
-        try {
-          new URL(val);
-          return true;
-        } catch {
-          return "Please enter a valid URL";
-        }
-      },
-    });
-
-    const enableEncryption = await context.prompt({
-      type: "confirm",
-      message: "Enable message encryption?",
-      default: true,
-    });
-
-    // Write config to ~/.openclaw/openclaw.json
-    await context.updateConfig("channels.cored.appId", appId);
-    await context.updateConfig("channels.cored.appSecret", appSecret);
-    await context.updateConfig("channels.cored.backendUrl", backendUrl);
-    await context.updateConfig("channels.cored.enableEncryption", enableEncryption);
-    await context.updateConfig("channels.cored.enabled", true);
-
-    console.log("✅ Cored channel configuration saved successfully!");
-    console.log("📄 Config file: ~/.openclaw/openclaw.json");
-    console.log("📖 Deploy docs: https://coredim.com/docs/admin/bots/openclaw");
-  },
-});
+export default defineSetupPluginEntry(coredPlugin);