lightclawbot 1.1.2 → 1.2.0-beta.0

package/dist/src/channel.js

@@ -1,272 +1,316 @@
 /**
- * LightClaw — ChannelPlugin 主定义
+ * LightClaw — ChannelPlugin 主定义文件
  *
- * 这是 OpenClaw 框架的「注册契约」：
- * 声明插件 ID、能力、配置管理、出站适配、Gateway 生命周期等。
- * 框架通过这个对象了解你的插件能做什么、怎么启动、怎么发消息。
+ * 使用 OpenClaw SDK 标准的 createChatChannelPlugin 构建器创建聊天频道插件，
+ *
+ * 主要结构组成：
+ *   base:     基础配置 - 来自 shared.ts 的 createLightclawPluginBase + 扩展字段
+ *   messaging: 消息目标解析 - 处理消息发送目标的标准化和验证
+ *   status:   状态管理 - 插件运行状态监控和状态面板构建
+ *   gateway:  Gateway 生命周期 - WebSocket 连接管理和账户生命周期
+ *   outbound: 出站消息适配器 - 消息发送和媒体文件处理
+ *
+ * 该插件实现了与 AI 助手服务的 WebSocket 通信、消息收发、状态管理等核心功能。
  */
-import { applyAccountNameToChannelSection, deleteAccountFromConfigSection, setAccountEnabledInConfigSection, } from "openclaw/plugin-sdk/core";
-import { CHANNEL_KEY, DEFAULT_ACCOUNT_ID, TEXT_CHUNK_LIMIT, listAccountIds, resolveAccount, defaultAccountId, applyAccountConfig, } from "./config.js";
-import { sendText, sendMedia } from "./outbound.js";
-import { startGateway } from "./gateway.js";
-/** 文本分块：按 limit 长度拆分，优先在换行 / 空格处切割 */
-function chunkText(text, limit) {
-    if (text.length <= limit)
-        return [text];
-    const chunks = [];
-    let remaining = text;
-    while (remaining.length > 0) {
-        if (remaining.length <= limit) {
-            chunks.push(remaining);
-            break;
-        }
-        let splitAt = remaining.lastIndexOf("\n", limit);
-        if (splitAt <= 0 || splitAt < limit * 0.5) {
-            splitAt = remaining.lastIndexOf(" ", limit);
-        }
-        if (splitAt <= 0 || splitAt < limit * 0.5) {
-            splitAt = limit;
-        }
-        chunks.push(remaining.slice(0, splitAt));
-        remaining = remaining.slice(splitAt).trimStart();
-    }
-    return chunks;
-}
-// ============================================================
-// ChannelPlugin 定义
-// ============================================================
-export const myAssistantPlugin = {
-    id: CHANNEL_KEY,
-    // ---- 元信息 ----
-    meta: {
-        id: CHANNEL_KEY,
-        label: "LightClawBot",
-        selectionLabel: "LightClawBot",
-        docsPath: "/docs/channels/lightclawbot",
-        blurb: "Connect OpenClaw to your LightClawBot via WebSocket long-connection",
-        order: 60,
-    },
-    // ---- 能力声明 ----
-    capabilities: {
-        chatTypes: ["direct"],
-        media: true,
-        reactions: false,
-        threads: false,
-        // true = deliver 回调会收到 kind="block" 的中间块，实现流式推送
-        blockStreaming: true,
-    },
-    // ---- 配置管理（多账户） ----
-    config: {
-        listAccountIds: (cfg) => listAccountIds(cfg),
-        resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
-        defaultAccountId: (cfg) => defaultAccountId(cfg),
-        setAccountEnabled: ({ cfg, accountId, enabled }) => setAccountEnabledInConfigSection({
-            cfg,
-            sectionKey: CHANNEL_KEY,
-            accountId,
-            enabled,
-            allowTopLevel: true,
-        }),
-        deleteAccount: ({ cfg, accountId }) => deleteAccountFromConfigSection({
-            cfg,
-            sectionKey: CHANNEL_KEY,
-            accountId,
-            clearBaseFields: ["apiKeys", "apiBaseUrl", "name"],
-        }),
-        isConfigured: (account) => Boolean(account?.allApiKeys?.length),
-        describeAccount: (account) => ({
-            accountId: account?.accountId ?? DEFAULT_ACCOUNT_ID,
-            name: account?.name,
-            enabled: account?.enabled ?? false,
-            configured: Boolean(account?.allApiKeys?.length),
-            tokenSource: account?.secretSource,
+import { createChatChannelPlugin } from 'openclaw/plugin-sdk/core';
+// 导入工具函数和常量
+import { chunkText, defaultAccountId } from './utils/index.js';
+import { CHANNEL_KEY, DEFAULT_ACCOUNT_ID, TEXT_CHUNK_LIMIT } from './config.js';
+// 导入功能模块
+import { sendText, sendMedia } from './outbound.js'; // 出站消息发送
+import { startGateway } from './gateway.js'; // WebSocket Gateway 启动
+import { createLightclawPluginBase } from './shared.js'; // 基础插件配置
+import { lightclawSetupAdapter } from './setup-core.js'; // Setup 适配器
+import { normalizeTarget, looksLikeId } from './messaging.js'; // 消息目标处理
+/**
+ * LightClaw 主插件实例
+ *
+ * 使用 createChatChannelPlugin 工厂函数创建类型安全的 ChannelPlugin 实例，
+ * 泛型参数 ResolvedAssistantAccount 指定了账户数据的类型结构。
+ *
+ * @type {ChannelPlugin<ResolvedAssistantAccount>}
+ */
+export const lightclawPlugin = createChatChannelPlugin({
+    // ==================== 基础配置 ====================
+    base: {
+        // ---- 来自 shared.ts 的基础定义 ----
+        // 使用扩展运算符合并基础配置和 setup 适配器
+        ...createLightclawPluginBase({
+            setup: lightclawSetupAdapter, // Setup 阶段使用的适配器
         }),
-        resolveAllowFrom: ({ cfg, accountId }) => {
-            const account = resolveAccount(cfg, accountId);
-            return account.allowFrom.map(String);
-        },
-    },
-    // ---- Setup（命令行配置） ----
-    setup: {
-        resolveAccountId: ({ accountId }) => accountId?.trim().toLowerCase() || DEFAULT_ACCOUNT_ID,
-        applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({ cfg, channelKey: CHANNEL_KEY, accountId, name }),
-        validateInput: ({ input }) => {
-            if (!input.token && !input.useEnv) {
-                return "Requires --token <apiKey> or --use-env (set LIGHTCLAW_API_KEY, LIGHTCLAW_API_BASE_URL)";
-            }
-            return null;
-        },
-        applyAccountConfig: ({ cfg, accountId, input }) => {
-            return applyAccountConfig(cfg, accountId, {
-                apiKey: input.token,
-                apiBaseUrl: input.apiBaseUrl,
-                name: input.name,
-            });
-        },
-    },
-    // ---- 消息目标解析 ----
-    // 使用标准 user:/channel: 前缀，确保框架的 detectTargetKind 能正确识别 peer kind
-    messaging: {
-        normalizeTarget: (target) => {
-            // 剥离通道名前缀 (lightclawbot:)
-            const cleaned = target.replace(new RegExp(`^${CHANNEL_KEY}:`, "i"), "");
-            if (!cleaned)
-                return undefined;
-            // dm:xxx → user:xxx (私聊)
-            if (cleaned.startsWith("dm:")) {
-                return `user:${cleaned.slice(3)}`;
-            }
-            // group:xxx → channel:xxx (群聊)
-            if (cleaned.startsWith("group:")) {
-                return `channel:${cleaned.slice(6)}`;
-            }
-            // 已经是标准格式 user:/channel:，原样返回
-            if (/^(user|channel):/i.test(cleaned)) {
-                return cleaned;
-            }
-            // 纯 ID，默认当作私聊
-            return `user:${cleaned}`;
+        // ---- 消息目标解析配置 ----
+        messaging: {
+            /**
+             * 目标标准化函数
+             * 对原始目标字符串进行标准化处理：去除空格、统一格式、转换编码等
+             *
+             * @param {string} target - 原始目标字符串
+             * @returns {string} 标准化后的目标字符串
+             */
+            normalizeTarget: (target) => {
+                return normalizeTarget(target);
+            },
+            /** 目标解析器配置 */
+            targetResolver: {
+                /**
+                 * ID 格式检测函数
+                 * 判断一个原始字符串是否看起来像一个有效的 ID 格式
+                 * 用于在完整解析前快速分流处理逻辑，提高性能
+                 *
+                 * @param {string} id - 待检测的字符串
+                 * @param {string} [normalized] - 可选的标准化的字符串
+                 * @returns {boolean} 是否看起来像 ID 格式
+                 */
+                looksLikeId: (id, normalized) => {
+                    return looksLikeId(id, normalized);
+                },
+                /**
+                 * 目标格式提示文本
+                 * 显示在 CLI 帮助信息中，指导用户正确的目标格式
+                 */
+                hint: `user:<userId> or channel:<groupId>`,
+            },
         },
-        targetResolver: {
-            looksLikeId: (id, normalized) => {
-                const value = (normalized ?? id).trim();
-                if (!value)
-                    return false;
-                // 标准前缀格式
-                if (/^(user|channel):/i.test(value))
-                    return true;
-                // lightclawbot 自有格式
-                const cleaned = value.replace(new RegExp(`^${CHANNEL_KEY}:`, "i"), "");
-                return /^(dm|group):\d+/.test(cleaned) || /^\d+$/.test(cleaned);
+        // ---- 状态面板配置 ----
+        status: {
+            /** 默认运行时状态配置 */
+            defaultRuntime: {
+                accountId: DEFAULT_ACCOUNT_ID, // 默认账户ID
+                running: false, // 运行状态：未运行
+                connected: false, // 连接状态：未连接
+                lastConnectedAt: null, // 最后连接时间：null
+                lastError: null, // 最后错误信息：null
             },
-            hint: `user:<userId> or channel:<groupId>`,
+            /**
+             * 构建频道摘要信息
+             * 根据快照数据生成频道级别的状态摘要
+             *
+             * @param {Object} param0 - 参数对象
+             * @param {Object} param0.snapshot - 状态快照数据
+             * @returns {Object} 频道摘要信息
+             */
+            buildChannelSummary: ({ snapshot }) => ({
+                configured: snapshot.configured ?? false, // 是否已配置
+                running: snapshot.running ?? false, // 是否正在运行
+                connected: snapshot.connected ?? false, // 是否已连接
+                lastConnectedAt: snapshot.lastConnectedAt ?? null, // 最后连接时间
+                lastError: snapshot.lastError ?? null, // 最后错误信息
+            }),
+            /**
+             * 构建账户快照信息
+             * 根据账户、运行时和配置数据生成账户级别的状态快照
+             *
+             * @param {Object} param0 - 参数对象
+             * @param {ResolvedAssistantAccount} param0.account - 账户信息
+             * @param {Object} param0.runtime - 运行时状态
+             * @param {OpenClawConfig} param0.cfg - 配置信息
+             * @returns {Object} 账户快照信息
+             */
+            buildAccountSnapshot: ({ account, runtime, cfg }) => ({
+                accountId: account?.accountId ?? defaultAccountId(cfg), // 账户ID，优先使用账户的ID
+                name: account?.name, // 账户名称
+                enabled: account?.enabled ?? false, // 是否启用
+                configured: Boolean(account?.apiKey), // 是否已配置（有API密钥）
+                running: runtime?.running ?? false, // 是否正在运行
+                connected: runtime?.connected ?? false, // 是否已连接
+                lastConnectedAt: runtime?.lastConnectedAt ?? null, // 最后连接时间
+                lastError: runtime?.lastError ?? null, // 最后错误信息
+            }),
         },
-    },
-    // ---- 出站消息适配器 ----
-    outbound: {
-        deliveryMode: "direct",
-        chunker: chunkText,
-        chunkerMode: "markdown",
-        textChunkLimit: TEXT_CHUNK_LIMIT,
-        resolveTarget: ({ to, allowFrom, mode }) => {
-            // 优先使用显式 to；implicit 模式下回退到 allowFrom 第一个非通配符条目
-            const effectiveTo = to?.trim();
-            if (effectiveTo) {
-                return { ok: true, to: effectiveTo };
-            }
-            if (mode === "implicit" && allowFrom && allowFrom.length > 0) {
-                const candidate = allowFrom.find((entry) => entry && entry !== "*");
-                if (candidate) {
-                    return { ok: true, to: candidate };
+        // ---- Gateway 生命周期管理（核心功能） ----
+        gateway: {
+            /**
+             * 启动账户
+             * 建立 WebSocket 长连接到 AI 助手服务器
+             * OpenClaw 框架会在加载配置后为每个启用的账户调用此方法
+             *
+             * @async
+             * @param {Object} ctx - 上下文对象
+             * @param {ResolvedAssistantAccount} ctx.account - 账户信息
+             * @param {AbortSignal} ctx.abortSignal - 中止信号，用于取消操作
+             * @param {Object} ctx.log - 日志记录器
+             * @param {OpenClawConfig} ctx.cfg - 配置信息
+             * @param {Function} ctx.setStatus - 状态设置函数
+             * @param {Function} ctx.getStatus - 状态获取函数
+             */
+            startAccount: async (ctx) => {
+                const { account, abortSignal, log, cfg, accountId } = ctx;
+                // 记录启动日志
+                log?.info(`[${CHANNEL_KEY}:${accountId}] Starting gateway...`);
+                // 启动并维持一个 Socket.IO Gateway 实例
+                await startGateway({
+                    account, // 账户信息
+                    abortSignal, // 中止信号
+                    cfg, // 配置信息
+                    log, // 日志记录器
+                    /**
+                     * WebSocket 连接就绪回调
+                     * 当 WebSocket 连接成功建立时调用
+                     */
+                    onReady: () => {
+                        log?.info(`[${CHANNEL_KEY}:${accountId}] Gateway ready: WS connected`);
+                        const now = Date.now();
+                        // 更新运行时状态
+                        ctx.setStatus({
+                            ...ctx.getStatus(), // 保留现有状态
+                            running: true, // 设置为运行中
+                            connected: true, // 设置为已连接
+                            lastConnectedAt: now, // 记录最后连接时间
+                            // 连接建立时即设置 lastEventAt，作为 health-monitor stale-socket 检测的初始基准
+                            lastEventAt: now, // 最后事件时间
+                        });
+                    },
+                    /**
+                     * WebSocket 连接断开回调
+                     * 当 WebSocket 连接断开时调用
+                     */
+                    onDisconnect: () => {
+                        log?.info(`[${CHANNEL_KEY}:${accountId}] Gateway ready: WS disconnect`);
+                        // 更新连接状态为断开
+                        ctx.setStatus({
+                            ...ctx.getStatus(), // 保留现有状态
+                            connected: false, // 设置为未连接
+                        });
+                    },
+                    /**
+                     * 错误回调
+                     * 当发生错误时调用，记录错误信息但不中断重连逻辑
+                     * 重连逻辑由 gateway 内部处理
+                     *
+                     * @param {Error} error - 错误对象
+                     */
+                    onError: (error) => {
+                        log?.error(`[${CHANNEL_KEY}:${accountId}] Gateway error: ${error.message}`);
+                        // 记录错误信息
+                        ctx.setStatus({
+                            ...ctx.getStatus(), // 保留现有状态
+                            lastError: error.message, // 记录错误消息
+                        });
+                    },
+                    /**
+                     * 入站事件回调
+                     * 每次收到消息时调用，用于：
+                     * - 刷新 lastEventAt 和 lastInboundAt 时间戳
+                     * - 通知框架 health-monitor 该连接仍处于活跃状态
+                     * - 防止因长时间无活动而被判定为僵死连接
+                     */
+                    onEvent: () => {
+                        log?.info(`[${CHANNEL_KEY}:${accountId}] Gateway Ready: WS message enter`);
+                        // 更新事件时间戳
+                        ctx.setStatus({
+                            ...ctx.getStatus(), // 保留现有状态
+                            lastEventAt: Date.now(), // 最后事件时间
+                            lastInboundAt: Date.now(), // 最后入站消息时间
+                        });
+                    },
+                });
+            },
+            /**
+             * 登出账户
+             * 清除账户的凭证信息（如 API 密钥）
+             *
+             * @async
+             * @param {Object} param0 - 参数对象
+             * @param {string} param0.accountId - 账户ID
+             * @param {OpenClawConfig} param0.cfg - 配置信息
+             * @returns {Promise<{ok: boolean, cleared: boolean}>} 操作结果
+             */
+            logoutAccount: async ({ accountId, cfg }) => {
+                // 创建配置副本以避免修改原始配置
+                const nextCfg = { ...cfg };
+                // 获取当前 channel 的配置节
+                const section = nextCfg.channels?.[CHANNEL_KEY];
+                let cleared = false; // 清理标志
+                if (section) {
+                    // 处理默认账户的 API 密钥
+                    if (accountId === DEFAULT_ACCOUNT_ID && section.apiKeys) {
+                        delete section.apiKeys; // 删除默认账户的 API 密钥
+                        cleared = true; // 标记为已清理
+                    }
+                    // 处理特定账户的 API 密钥
+                    const accounts = section.accounts;
+                    if (accounts?.[accountId]?.apiKeys) {
+                        delete accounts[accountId].apiKeys; // 删除指定账户的 API 密钥
+                        cleared = true; // 标记为已清理
+                    }
                 }
-            }
-            return {
-                ok: false,
-                error: new Error(`No delivery target for ${CHANNEL_KEY}. Specify a target with --to or configure allowFrom.`),
-            };
-        },
-        sendText: async ({ to, text, accountId, replyToId, cfg }) => {
-            return sendText({ to, text, accountId, replyToId, cfg });
-        },
-        sendMedia: async ({ to, text, mediaUrl, accountId, replyToId, cfg }) => {
-            return sendMedia({ to, text, mediaUrl, accountId, replyToId, cfg });
+                // 返回操作结果
+                return { ok: true, cleared };
+            },
         },
     },
-    // ---- Gateway 生命周期（核心！） ----
-    gateway: {
-        /**
-         * 启动账户：建立 WS 长连接到你的 AI 助手 Server
-         * OpenClaw 会在加载配置后为每个 enabled 的账户调用此方法
-         */
-        startAccount: async (ctx) => {
-            const { account, abortSignal, log, cfg } = ctx;
-            log?.info(`[${CHANNEL_KEY}:${account.accountId}] Starting gateway...`);
-            await startGateway({
-                account,
-                abortSignal,
-                cfg,
-                log,
-                onReady: () => {
-                    log?.info(`[${CHANNEL_KEY}:${account.accountId}] Gateway ready, WS connected`);
-                    const now = Date.now();
-                    ctx.setStatus({
-                        ...ctx.getStatus(),
-                        running: true,
-                        connected: true,
-                        lastConnectedAt: now,
-                        // 连接建立时即设置 lastEventAt，作为 health-monitor stale-socket 检测的初始基准
-                        lastEventAt: now,
-                    });
-                },
-                onDisconnect: () => {
-                    ctx.setStatus({
-                        ...ctx.getStatus(),
-                        connected: false,
-                    });
-                },
-                onError: (error) => {
-                    log?.error(`[${CHANNEL_KEY}:${account.accountId}] Gateway error: ${error.message}`);
-                    ctx.setStatus({
-                        ...ctx.getStatus(),
-                        lastError: error.message,
-                    });
-                },
-                onEvent: () => {
-                    // 通知框架收到了入站事件，防止 health-monitor 因 lastEventAt 过期而误判 stale-socket
-                    ctx.setStatus({
-                        ...ctx.getStatus(),
-                        lastEventAt: Date.now(),
-                        lastInboundAt: Date.now(),
-                    });
-                },
-            });
-        },
-        /** 登出账户：清除凭证 */
-        logoutAccount: async ({ accountId, cfg }) => {
-            const nextCfg = { ...cfg };
-            const section = nextCfg.channels?.[CHANNEL_KEY];
-            let cleared = false;
-            if (section) {
-                if (accountId === DEFAULT_ACCOUNT_ID && section.apiKeys) {
-                    delete section.apiKeys;
-                    cleared = true;
+    // ==================== 出站消息适配器 ====================
+    outbound: {
+        // 基础出站配置
+        base: {
+            deliveryMode: 'direct', // 交付模式：直接交付
+            chunker: chunkText, // 文本分块处理器
+            chunkerMode: 'markdown', // 分块模式：Markdown
+            textChunkLimit: TEXT_CHUNK_LIMIT, // 文本分块限制大小
+            /**
+             * 目标解析函数
+             * 解析消息发送的目标地址
+             *
+             * @param {Object} param0 - 参数对象
+             * @param {string} param0.to - 显式指定的目标
+             * @param {string[]} param0.allowFrom - 允许的来源列表
+             * @param {string} param0.mode - 模式（'direct' 或 'implicit'）
+             * @returns {Object} 解析结果
+             */
+            resolveTarget: ({ to, allowFrom, mode }) => {
+                // 优先使用显式指定的目标地址
+                const effectiveTo = to?.trim();
+                if (effectiveTo) {
+                    return { ok: true, to: effectiveTo };
                 }
-                const accounts = section.accounts;
-                if (accounts?.[accountId]?.apiKeys) {
-                    delete accounts[accountId].apiKeys;
-                    cleared = true;
+                // implicit 模式下回退到 allowFrom 第一个非通配符条目
+                if (mode === 'implicit' && allowFrom && allowFrom.length > 0) {
+                    const candidate = allowFrom.find((entry) => entry && entry !== '*');
+                    if (candidate) {
+                        return { ok: true, to: candidate };
+                    }
                 }
-            }
-            return { ok: true, cleared };
+                // 没有找到有效目标，返回错误
+                return {
+                    ok: false,
+                    error: new Error(`No delivery target for ${CHANNEL_KEY}. Specify a target with --to or configure allowFrom.`),
+                };
+            },
         },
-    },
-    // ---- 状态面板 ----
-    status: {
-        defaultRuntime: {
-            accountId: DEFAULT_ACCOUNT_ID,
-            running: false,
-            connected: false,
-            lastConnectedAt: null,
-            lastError: null,
+        // 附加结果处理
+        attachedResults: {
+            channel: CHANNEL_KEY, // 频道标识
+            /**
+             * 发送文本消息
+             *
+             * @async
+             * @param {Object} param0 - 参数对象
+             * @param {string} param0.to - 目标地址
+             * @param {string} param0.text - 文本内容
+             * @param {string} param0.accountId - 账户ID
+             * @param {string} param0.replyToId - 回复消息ID
+             * @param {OpenClawConfig} param0.cfg - 配置信息
+             * @returns {Promise<any>} 发送结果
+             */
+            sendText: async ({ to, text, accountId, replyToId, cfg }) => {
+                return sendText({ to, text, accountId, replyToId, cfg });
+            },
+            /**
+             * 发送媒体消息
+             *
+             * @async
+             * @param {Object} param0 - 参数对象
+             * @param {string} param0.to - 目标地址
+             * @param {string} param0.text - 文本内容
+             * @param {string} param0.mediaUrl - 媒体文件URL
+             * @param {string} param0.accountId - 账户ID
+             * @param {string} param0.replyToId - 回复消息ID
+             * @param {OpenClawConfig} param0.cfg - 配置信息
+             * @returns {Promise<any>} 发送结果
+             */
+            sendMedia: async ({ to, text, mediaUrl, accountId, replyToId, cfg }) => {
+                return sendMedia({ to, text, mediaUrl, accountId, replyToId, cfg });
+            },
         },
-        buildChannelSummary: ({ snapshot }) => ({
-            configured: snapshot.configured ?? false,
-            running: snapshot.running ?? false,
-            connected: snapshot.connected ?? false,
-            lastConnectedAt: snapshot.lastConnectedAt ?? null,
-            lastError: snapshot.lastError ?? null,
-        }),
-        buildAccountSnapshot: ({ account, runtime, }) => ({
-            accountId: account?.accountId ?? DEFAULT_ACCOUNT_ID,
-            name: account?.name,
-            enabled: account?.enabled ?? false,
-            configured: Boolean(account?.allApiKeys?.length),
-            tokenSource: account?.secretSource,
-            running: runtime?.running ?? false,
-            connected: runtime?.connected ?? false,
-            lastConnectedAt: runtime?.lastConnectedAt ?? null,
-            lastError: runtime?.lastError ?? null,
-        }),
     },
-};
-//# sourceMappingURL=channel.js.map
+});

package/dist/src/channel.setup.js

@@ -0,0 +1,16 @@
+/**
+ * LightClaw — Setup-only 轻量插件
+ *
+ * 参照 Discord 的 channel.setup.ts 模式：
+ * 仅包含 shared base 骨架（id, meta, config, setup），
+ * 不加载 gateway / inbound / outbound 等运行时重依赖。
+ *
+ * 用于插件未配置/未启用时的 setup 流程，避免拉起不必要的运行时。
+ */
+import { createLightclawPluginBase } from "./shared.js";
+import { lightclawSetupAdapter } from "./setup-core.js";
+export const lightclawSetupPlugin = {
+    ...createLightclawPluginBase({
+        setup: lightclawSetupAdapter,
+    }),
+};