@nextclaw/openclaw-compat 0.1.5 → 0.1.6

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '@nextclaw/core';
+import { Config, ExtensionChannel } from '@nextclaw/core';
 
 type PluginConfigUiHint = {
     label?: string;
@@ -105,6 +105,7 @@ type OpenClawChannelPlugin = {
     id: string;
     meta?: Record<string, unknown>;
     capabilities?: Record<string, unknown>;
+    nextclaw?: ExtensionChannel["nextclaw"];
     configSchema?: OpenClawChannelConfigSchema;
     config?: OpenClawChannelConfigAdapter;
     setup?: OpenClawChannelSetup;
@@ -136,6 +137,7 @@ type OpenClawPluginDefinition = {
     description?: string;
     version?: string;
     kind?: PluginKind;
+    configSchema?: Record<string, unknown>;
     register?: (api: OpenClawPluginApi) => void | Promise<void>;
     activate?: (api: OpenClawPluginApi) => void | Promise<void>;
 };

package/dist/index.js

@@ -224,10 +224,10 @@ function resolvePluginChannelMessageToolHints(params) {
   }
 }
 function getPluginUiMetadataFromRegistry(registry) {
-  return registry.plugins.map((plugin) => ({
-    id: plugin.id,
-    configSchema: plugin.configJsonSchema,
-    configUiHints: plugin.configUiHints
+  return registry.plugins.map((plugin10) => ({
+    id: plugin10.id,
+    configSchema: plugin10.configJsonSchema,
+    configUiHints: plugin10.configUiHints
   }));
 }
 async function startPluginChannelGateways(params) {
@@ -1293,6 +1293,132 @@ function validateJsonSchemaValue(params) {
   return { ok: false, errors: formatAjvErrors(cached.validate.errors) };
 }
 
+// src/plugins/bundled/channels/factory.ts
+import { listBuiltinChannelPlugins } from "@nextclaw/core";
+var EMPTY_PLUGIN_CONFIG_SCHEMA = {
+  type: "object",
+  additionalProperties: false,
+  properties: {}
+};
+function resolveBuiltinChannelPlugin(channelId) {
+  const plugin10 = listBuiltinChannelPlugins().find((entry) => entry.id === channelId);
+  if (!plugin10) {
+    throw new Error(`builtin channel plugin not found: ${channelId}`);
+  }
+  return plugin10;
+}
+function createBundledChannelPlugin(params) {
+  const pluginId = `builtin-channel-${params.channelId}`;
+  const sourceDescription = params.description ?? `Builtin NextClaw channel plugin for ${params.channelId}`;
+  return {
+    id: pluginId,
+    name: params.name,
+    description: sourceDescription,
+    configSchema: EMPTY_PLUGIN_CONFIG_SCHEMA,
+    register(api) {
+      const builtin = resolveBuiltinChannelPlugin(params.channelId);
+      api.registerChannel({
+        plugin: {
+          id: params.channelId,
+          nextclaw: {
+            isEnabled: builtin.isEnabled,
+            createChannel: builtin.create
+          }
+        }
+      });
+    }
+  };
+}
+
+// src/plugins/bundled/channels/telegram.ts
+var plugin = createBundledChannelPlugin({
+  channelId: "telegram",
+  name: "Builtin Telegram Channel",
+  description: "Builtin NextClaw channel plugin for telegram"
+});
+var telegram_default = plugin;
+
+// src/plugins/bundled/channels/whatsapp.ts
+var plugin2 = createBundledChannelPlugin({
+  channelId: "whatsapp",
+  name: "Builtin WhatsApp Channel",
+  description: "Builtin NextClaw channel plugin for whatsapp"
+});
+var whatsapp_default = plugin2;
+
+// src/plugins/bundled/channels/discord.ts
+var plugin3 = createBundledChannelPlugin({
+  channelId: "discord",
+  name: "Builtin Discord Channel",
+  description: "Builtin NextClaw channel plugin for discord"
+});
+var discord_default = plugin3;
+
+// src/plugins/bundled/channels/feishu.ts
+var plugin4 = createBundledChannelPlugin({
+  channelId: "feishu",
+  name: "Builtin Feishu Channel",
+  description: "Builtin NextClaw channel plugin for feishu"
+});
+var feishu_default = plugin4;
+
+// src/plugins/bundled/channels/mochat.ts
+var plugin5 = createBundledChannelPlugin({
+  channelId: "mochat",
+  name: "Builtin Mochat Channel",
+  description: "Builtin NextClaw channel plugin for mochat"
+});
+var mochat_default = plugin5;
+
+// src/plugins/bundled/channels/dingtalk.ts
+var plugin6 = createBundledChannelPlugin({
+  channelId: "dingtalk",
+  name: "Builtin DingTalk Channel",
+  description: "Builtin NextClaw channel plugin for dingtalk"
+});
+var dingtalk_default = plugin6;
+
+// src/plugins/bundled/channels/email.ts
+var plugin7 = createBundledChannelPlugin({
+  channelId: "email",
+  name: "Builtin Email Channel",
+  description: "Builtin NextClaw channel plugin for email"
+});
+var email_default = plugin7;
+
+// src/plugins/bundled/channels/slack.ts
+var plugin8 = createBundledChannelPlugin({
+  channelId: "slack",
+  name: "Builtin Slack Channel",
+  description: "Builtin NextClaw channel plugin for slack"
+});
+var slack_default = plugin8;
+
+// src/plugins/bundled/channels/qq.ts
+var plugin9 = createBundledChannelPlugin({
+  channelId: "qq",
+  name: "Builtin QQ Channel",
+  description: "Builtin NextClaw channel plugin for qq"
+});
+var qq_default = plugin9;
+
+// src/plugins/bundled/channels/index.ts
+var BUNDLED_CHANNEL_PLUGINS = [
+  telegram_default,
+  whatsapp_default,
+  discord_default,
+  feishu_default,
+  mochat_default,
+  dingtalk_default,
+  email_default,
+  slack_default,
+  qq_default
+];
+function listBundledChannelPluginDefinitions() {
+  return [...BUNDLED_CHANNEL_PLUGINS];
+}
+var BUNDLED_CHANNEL_PLUGIN_IDS = BUNDLED_CHANNEL_PLUGINS.map((plugin10) => plugin10.id).filter((id) => typeof id === "string" && id.trim().length > 0);
+
 // src/plugins/loader.ts
 var createJiti = createJitiImport;
 var defaultLogger2 = {
@@ -1446,17 +1572,245 @@ function validatePluginConfig(params) {
   }
   return { ok: false, errors: result.errors };
 }
-function loadOpenClawPlugins(options) {
-  if (process.env.NEXTCLAW_ENABLE_OPENCLAW_PLUGINS === "0") {
-    return {
-      plugins: [],
-      tools: [],
-      channels: [],
-      providers: [],
-      diagnostics: [],
-      resolvedTools: []
+function appendBundledChannelPlugins(params) {
+  for (const definition of listBundledChannelPluginDefinitions()) {
+    const pluginId = typeof definition.id === "string" ? definition.id.trim() : "";
+    const source = `builtin:nextclaw-openclaw-compat/channels/${pluginId || "unknown"}`;
+    if (!pluginId) {
+      params.registry.diagnostics.push({
+        level: "error",
+        source,
+        message: "bundled plugin definition missing id"
+      });
+      continue;
+    }
+    const record = createPluginRecord({
+      id: pluginId,
+      name: definition.name ?? pluginId,
+      description: definition.description,
+      version: definition.version,
+      kind: definition.kind,
+      source,
+      origin: "bundled",
+      workspaceDir: params.workspaceDir,
+      enabled: true,
+      configSchema: Boolean(definition.configSchema),
+      configJsonSchema: definition.configSchema
+    });
+    const register = definition.register ?? definition.activate;
+    if (typeof register !== "function") {
+      record.status = "error";
+      record.error = "plugin export missing register/activate";
+      params.registry.plugins.push(record);
+      params.registry.diagnostics.push({
+        level: "error",
+        pluginId,
+        source,
+        message: record.error
+      });
+      continue;
+    }
+    const pluginRuntime = createPluginRuntime({ workspace: params.workspaceDir, config: params.config });
+    const pluginLogger = buildPluginLogger(params.logger, pluginId);
+    const pushUnsupported = (capability) => {
+      params.registry.diagnostics.push({
+        level: "warn",
+        pluginId,
+        source,
+        message: `${capability} is not supported by nextclaw compat layer yet`
+      });
+      pluginLogger.warn(`${capability} is ignored (not supported yet)`);
     };
+    const api = {
+      id: pluginId,
+      name: record.name,
+      version: record.version,
+      description: record.description,
+      source,
+      config: params.config,
+      pluginConfig: void 0,
+      runtime: pluginRuntime,
+      logger: pluginLogger,
+      registerTool: () => pushUnsupported("registerTool"),
+      registerChannel: (registration) => {
+        const normalizedChannel = registration && typeof registration === "object" && "plugin" in registration ? registration.plugin : registration;
+        if (!normalizedChannel || typeof normalizedChannel !== "object") {
+          params.registry.diagnostics.push({
+            level: "error",
+            pluginId,
+            source,
+            message: "channel registration missing plugin object"
+          });
+          return;
+        }
+        const channelObj = normalizedChannel;
+        const rawId = typeof channelObj.id === "string" ? channelObj.id : String(channelObj.id ?? "");
+        const accepted = ensureUniqueNames({
+          names: [rawId],
+          pluginId,
+          diagnostics: params.registry.diagnostics,
+          source,
+          owners: params.channelIdOwners,
+          reserved: params.reservedChannelIds,
+          kind: "channel"
+        });
+        if (accepted.length === 0) {
+          return;
+        }
+        const channelPlugin = normalizedChannel;
+        params.registry.channels.push({
+          pluginId,
+          channel: channelPlugin,
+          source
+        });
+        const channelId = accepted[0];
+        record.channelIds.push(channelId);
+        const configSchema = channelPlugin.configSchema;
+        if (configSchema && typeof configSchema === "object") {
+          const schema = configSchema.schema;
+          if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+            record.configJsonSchema = schema;
+            record.configSchema = true;
+          }
+          const uiHints = configSchema.uiHints;
+          if (uiHints && typeof uiHints === "object" && !Array.isArray(uiHints)) {
+            record.configUiHints = {
+              ...record.configUiHints ?? {},
+              ...uiHints
+            };
+          }
+        }
+        const pushChannelTools = (value, optional, sourceLabel, resolveValue) => {
+          const previewTools = normalizeToolList(value);
+          if (previewTools.length === 0) {
+            return;
+          }
+          const declaredNames = previewTools.map((tool) => tool.name);
+          const acceptedNames = ensureUniqueNames({
+            names: declaredNames,
+            pluginId,
+            diagnostics: params.registry.diagnostics,
+            source,
+            owners: params.toolNameOwners,
+            reserved: params.reservedToolNames,
+            kind: "tool"
+          });
+          if (acceptedNames.length === 0) {
+            return;
+          }
+          const factory = (ctx) => {
+            const tools = normalizeToolList(resolveValue(ctx));
+            if (tools.length === 0) {
+              return [];
+            }
+            const byName = new Map(tools.map((tool) => [tool.name, tool]));
+            return acceptedNames.map((name) => byName.get(name)).filter(Boolean);
+          };
+          params.registry.tools.push({
+            pluginId,
+            factory,
+            names: acceptedNames,
+            optional,
+            source
+          });
+          record.toolNames.push(...acceptedNames);
+          const previewByName = new Map(previewTools.map((tool) => [tool.name, tool]));
+          for (const name of acceptedNames) {
+            const resolvedTool = previewByName.get(name);
+            if (!resolvedTool || params.resolvedToolNames.has(resolvedTool.name)) {
+              continue;
+            }
+            params.resolvedToolNames.add(resolvedTool.name);
+            params.registry.resolvedTools.push(resolvedTool);
+          }
+          params.registry.diagnostics.push({
+            level: "warn",
+            pluginId,
+            source,
+            message: `${sourceLabel} registered channel-owned tools: ${acceptedNames.join(", ")}`
+          });
+        };
+        const agentTools = channelPlugin.agentTools;
+        if (typeof agentTools === "function") {
+          pushChannelTools(
+            normalizeToolList(agentTools()),
+            false,
+            `channel "${channelId}"`,
+            () => agentTools()
+          );
+        } else if (agentTools) {
+          pushChannelTools(
+            normalizeToolList(agentTools),
+            false,
+            `channel "${channelId}"`,
+            () => agentTools
+          );
+        }
+      },
+      registerProvider: (provider) => {
+        const accepted = ensureUniqueNames({
+          names: [provider.id],
+          pluginId,
+          diagnostics: params.registry.diagnostics,
+          source,
+          owners: params.providerIdOwners,
+          reserved: params.reservedProviderIds,
+          kind: "provider"
+        });
+        if (accepted.length === 0) {
+          return;
+        }
+        params.registry.providers.push({
+          pluginId,
+          provider,
+          source
+        });
+        record.providerIds.push(accepted[0]);
+      },
+      registerHook: () => pushUnsupported("registerHook"),
+      registerGatewayMethod: () => pushUnsupported("registerGatewayMethod"),
+      registerCli: () => pushUnsupported("registerCli"),
+      registerService: () => pushUnsupported("registerService"),
+      registerCommand: () => pushUnsupported("registerCommand"),
+      registerHttpHandler: () => pushUnsupported("registerHttpHandler"),
+      registerHttpRoute: () => pushUnsupported("registerHttpRoute"),
+      resolvePath: (input) => {
+        const trimmed = input.trim();
+        if (!trimmed) {
+          return params.workspaceDir;
+        }
+        if (path4.isAbsolute(trimmed)) {
+          return path4.resolve(expandHome2(trimmed));
+        }
+        return path4.resolve(params.workspaceDir, trimmed);
+      }
+    };
+    try {
+      const result = register(api);
+      if (result && typeof result === "object" && "then" in result) {
+        params.registry.diagnostics.push({
+          level: "warn",
+          pluginId,
+          source,
+          message: "plugin register returned a promise; async registration is ignored"
+        });
+      }
+      params.registry.plugins.push(record);
+    } catch (err) {
+      record.status = "error";
+      record.error = `plugin failed during register: ${String(err)}`;
+      params.registry.plugins.push(record);
+      params.registry.diagnostics.push({
+        level: "error",
+        pluginId,
+        source,
+        message: record.error
+      });
+    }
   }
+}
+function loadOpenClawPlugins(options) {
+  const loadExternalPlugins = process.env.NEXTCLAW_ENABLE_OPENCLAW_PLUGINS !== "0";
   const logger = options.logger ?? defaultLogger2;
   const workspaceDir = options.workspaceDir?.trim() || getWorkspacePathFromConfig(options.config);
   const normalized = normalizePluginsConfig(options.config.plugins);
@@ -1476,6 +1830,22 @@ function loadOpenClawPlugins(options) {
   const reservedToolNames = new Set(options.reservedToolNames ?? []);
   const reservedChannelIds = new Set(options.reservedChannelIds ?? []);
   const reservedProviderIds = new Set(options.reservedProviderIds ?? []);
+  appendBundledChannelPlugins({
+    registry,
+    config: options.config,
+    logger,
+    workspaceDir,
+    toolNameOwners,
+    channelIdOwners,
+    providerIdOwners,
+    resolvedToolNames,
+    reservedToolNames,
+    reservedChannelIds,
+    reservedProviderIds
+  });
+  if (!loadExternalPlugins) {
+    return registry;
+  }
   const discovery = discoverOpenClawPlugins({
     config: options.config,
     workspaceDir,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/openclaw-compat",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "private": false,
   "description": "OpenClaw plugin compatibility layer for NextClaw.",
   "type": "module",
@@ -18,7 +18,7 @@
     "jiti": "^1.21.7",
     "jszip": "^3.10.1",
     "tar": "^7.4.3",
-    "@nextclaw/core": "^0.6.2"
+    "@nextclaw/core": "^0.6.16"
   },
   "devDependencies": {
     "@types/node": "^20.17.6",