@cored-im/openclaw-plugin 0.1.5 → 0.1.10

package/src/index.ts

@@ -1,7 +1,7 @@
 // Copyright (c) 2026 Cored Limited
 // SPDX-License-Identifier: Apache-2.0
 
-import { defineChannelPluginEntry, type PluginApi } from "openclaw/plugin-sdk/core";
+import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
 import { coredPlugin } from "./channel.js";
 import { listEnabledAccountConfigs, validateAccountConfig } from "./config.js";
 import {
@@ -9,64 +9,58 @@ import {
   destroyAllClients,
   clientCount,
 } from "./core/cored-client.js";
-import { processInboundMessage, type ExtendedPluginApi } from "./messaging/inbound.js";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
+import { processInboundMessage } from "./messaging/inbound.js";
 import { makeDeliver, setTyping, clearTyping, readMessage } from "./messaging/outbound.js";
 import type { CoredAccountConfig, CoredMessageEvent } from "./types.js";
 
-// Extended PluginApi with config type for service registration
-interface ServicePluginApi extends ExtendedPluginApi {
-  config: { channels?: Record<string, unknown> };
-}
-
 export default defineChannelPluginEntry({
   id: "cored",
   name: "Cored",
   description: "Connect OpenClaw with Cored",
   plugin: coredPlugin,
   registerFull(api) {
-    const typedApi = api as ServicePluginApi;
-
-    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 — service idle");
+          api.logger?.warn?.("[cored] no enabled account config found — 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 — all clients disconnected");
+        api.logger?.info?.("[cored] service stopped — all clients disconnected");
       },
     });
 
-    typedApi.logger?.info?.("[cored] plugin registered");
+    api.logger?.info?.("[cored] plugin registered");
   },
 });
 
@@ -74,7 +68,7 @@ export default defineChannelPluginEntry({
  * Start a single account — create client, subscribe to inbound events.
  */
 async function startAccount(
-  api: ServicePluginApi,
+  api: OpenClawPluginApi,
   account: CoredAccountConfig,
 ): Promise<void> {
   const deliver = makeDeliver(account.accountId, (msg) => api.logger?.warn?.(msg));
@@ -97,7 +91,7 @@ async function startAccount(
  * Handle a single inbound message with typing indicator lifecycle.
  */
 async function handleInbound(
-  api: ServicePluginApi,
+  api: OpenClawPluginApi,
   account: CoredAccountConfig,
   event: CoredMessageEvent,
   deliver: (chatId: string, text: string) => Promise<void>,

package/src/messaging/inbound.test.ts

@@ -14,8 +14,8 @@ import {
 import type {
   CoredAccountConfig,
   CoredMessageEvent,
-  PluginApi,
 } from "../types.js";
+import type { InboundPluginApi } from "./inbound.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -56,7 +56,7 @@ function makeEvent(
   };
 }
 
-function makeMockApi(): PluginApi {
+function makeMockApi(): InboundPluginApi {
   return {
     registerChannel: vi.fn(),
     registerService: vi.fn(),

package/src/messaging/inbound.ts

@@ -14,22 +14,25 @@ import type {
   CoredAccountConfig,
   CoredMessage,
   CoredMessageEvent,
-  PluginApi,
 } from "../types.js";
 
-// Extended PluginApi with runtime surfaces used by this module
-export interface ExtendedPluginApi extends PluginApi {
+// Plugin API surface used by this module.
+// At runtime the full OpenClawPluginApi is provided by the gateway;
+// we only declare the subset we access so the module stays decoupled
+// and testable without importing the full SDK.
+export interface InboundPluginApi {
+  config: Record<string, unknown>;
   runtime?: {
     channel?: {
       reply?: {
-        dispatchReplyWithBufferedBlockDispatcher?: (opts: unknown) => Promise<void>;
+        dispatchReplyWithBufferedBlockDispatcher?: (...args: any[]) => any;
       };
       session?: {
-        recordInboundSession?: (opts: unknown) => Promise<void>;
-        resolveStorePath?: (store: unknown, opts: unknown) => string;
+        recordInboundSession?: (...args: any[]) => any;
+        resolveStorePath?: (...args: any[]) => string;
       };
       routing?: {
-        resolveAgentRoute?: (opts: unknown) => unknown;
+        resolveAgentRoute?: (...args: any[]) => unknown;
       };
     };
   };
@@ -314,7 +317,7 @@ export interface InboundDispatchOptions {
  * Returns `true` if the message was dispatched, `false` if filtered.
  */
 export async function processInboundMessage(
-  api: ExtendedPluginApi,
+  api: InboundPluginApi,
   account: CoredAccountConfig,
   event: CoredMessageEvent,
   opts: InboundDispatchOptions,

package/src/types.ts

@@ -79,7 +79,3 @@ export type ConnectionState =
   | "connected"
   | "disconnecting";
 
-// --- OpenClaw Plugin API (re-export from SDK) ---
-
-// Re-export PluginApi from SDK for convenience
-export type { PluginApi } from "openclaw/plugin-sdk/core";

package/src/typings/openclaw-plugin-sdk.d.ts

@@ -1,162 +0,0 @@
-// Copyright (c) 2026 Cored Limited
-// SPDX-License-Identifier: Apache-2.0
-
-/**
- * Type declarations for openclaw/plugin-sdk.
- *
- * These types provide the minimal interface needed for the channel plugin.
- * The actual implementation is provided by the OpenClaw runtime at plugin load time.
- */
-
-declare module "openclaw/plugin-sdk/core" {
- export interface OpenClawConfig {
-  channels?: Record<string, unknown>;
-  plugins?: {
-   entries?: Record<string, { enabled?: boolean; config?: unknown }>;
-  };
- }
-
- export interface ChannelPluginMeta {
-  id: string;
-  label: string;
-  selectionLabel?: string;
-  docsPath?: string;
-  blurb?: string;
-  aliases?: string[];
- }
-
- export interface ChannelPluginCapabilities {
-  chatTypes?: readonly ("direct" | "group")[];
- }
-
- export interface ResolvedAccountResult {
-  ok: true;
-  to: string;
- }
-
- export interface ResolvedAccountError {
-  ok: false;
-  error: Error;
- }
-
- export type ResolvedAccount = ResolvedAccountResult | ResolvedAccountError;
-
- export interface OutboundAdapter {
-  deliveryMode?: "direct" | "queue";
-  resolveTarget?: (params: { to?: string }) => ResolvedAccount;
-  sendText?: (params: {
-   to: string;
-   text: string;
-   accountId?: string;
-  }) => Promise<{ ok: boolean; error?: Error }>;
- }
-
- export interface AccountInspection {
-  enabled: boolean;
-  configured: boolean;
-  tokenStatus: "available" | "missing" | "invalid";
- }
-
- export interface ChannelSetup {
-  resolveAccount: (
-   cfg: OpenClawConfig,
-   accountId?: string | null,
-  ) => unknown;
-  inspectAccount?: (
-   cfg: OpenClawConfig,
-   accountId?: string | null,
-  ) => AccountInspection;
- }
-
- export interface ChannelPluginBase {
-  id: string;
-  setup?: ChannelSetup;
- }
-
- export interface ChatChannelPlugin<TResolved = unknown> {
-  base: ChannelPluginBase;
-  meta?: ChannelPluginMeta;
-  capabilities?: ChannelPluginCapabilities;
-  config?: {
-   listAccountIds?: (cfg: unknown) => string[];
-   resolveAccount?: (cfg: unknown, accountId?: string) => unknown;
-  };
-  outbound?: OutboundAdapter;
-  setupWizard?: unknown;
- }
-
- export interface PluginLogger {
-  debug?: (msg: string) => void;
-  info?: (msg: string) => void;
-  warn?: (msg: string) => void;
-  error?: (msg: string) => void;
- }
-
- export interface PluginApi {
-  config: OpenClawConfig;
-  logger?: PluginLogger;
-  pluginConfig?: unknown;
-  registrationMode: "full" | "setup-only" | "setup-runtime" | "cli-metadata";
-  runtime?: unknown;
-  registerChannel(options: { plugin: unknown }): void;
-  registerService(service: {
-   id: string;
-   start: () => Promise<void>;
-   stop: () => Promise<void>;
-  }): void;
-  registerTool(options: unknown): void;
-  registerHook(events: string[], handler: unknown): void;
-  registerHttpRoute(options: unknown): void;
-  registerGatewayMethod(name: string, handler: unknown): void;
-  registerCli(registrar: unknown, options?: unknown): void;
-  registerCommand(options: unknown): void;
- }
-
- export type { PluginApi };
-
- export interface DefineChannelPluginEntryOptions<TPlugin> {
-  id: string;
-  name: string;
-  description: string;
-  plugin: TPlugin;
-  configSchema?: unknown;
-  setRuntime?: (runtime: unknown) => void;
-  registerCliMetadata?: (api: PluginApi) => void;
-  registerFull?: (api: PluginApi) => void;
- }
-
- export interface DefinedChannelPluginEntry<TPlugin> {
-  plugin: TPlugin;
- }
-
- export interface DefineSetupPluginEntry<TPlugin> {
-  plugin: TPlugin;
- }
-
- export function createChannelPluginBase(options: {
-  id: string;
-  setup: ChannelSetup;
- }): ChannelPluginBase;
-
- export function createChatChannelPlugin<TResolved>(options: {
-  base: ChannelPluginBase;
-  meta?: ChannelPluginMeta;
-  capabilities?: ChannelPluginCapabilities;
-  config?: {
-   listAccountIds?: (cfg: unknown) => string[];
-   resolveAccount?: (cfg: unknown, accountId?: string) => unknown;
-  };
-  outbound?: OutboundAdapter;
-  setupWizard?: unknown;
- }): ChatChannelPlugin<TResolved>;
-
- export function defineChannelPluginEntry<TPlugin>(
-  options: DefineChannelPluginEntryOptions<TPlugin>,
- ): DefinedChannelPluginEntry<TPlugin>;
-
- export function defineSetupPluginEntry<TPlugin>(
-  plugin: TPlugin,
- ): DefineSetupPluginEntry<TPlugin>;
-
- export function buildChannelConfigSchema(schema: unknown): unknown;
-}