@workclaw/openclaw-workclaw 1.0.23 → 1.0.26

package/dist/src/outbound/index.js

@@ -1,123 +0,0 @@
-import { resolveWorkclawAccountWithCache } from "../accounts.js";
-import { resolveAccountByUserIdAndAgentId } from "../accounts.js";
-import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from "../media/upload.js";
-import { sendWorkclawOutboundMessage, } from "./workclaw-sender.js";
-import { getWorkclawLogger, setLastOutboundAt } from "../runtime.js";
-import { loadOpenConversationId } from "../gateway/config-writer.js";
-import { stat } from "node:fs/promises";
-/**
- * 根据 target (userId) 和可选的 agentId 查找匹配的账户
- * 如果同时提供 userId 和 agentId，走 O(1) 查找
- * 否则遍历所有账户，查找 userId 等于 target 的账户
- */
-function findAccountIdByTarget(cfg, target, agentId) {
-    // O(1) 查找：userId + agentId 唯一确定一个账户
-    if (agentId !== undefined && agentId !== null) {
-        return resolveAccountByUserIdAndAgentId(cfg, target, String(agentId)) ?? undefined;
-    }
-    // 遍历：只有 userId 时，无法唯一确定账户（一个 userId 对应多个 agentId）
-    // 需要通过 bindings 或其他方式 resolve，这里暂不支持
-    return undefined;
-}
-async function resolveMediaUrl(mediaUrl, config) {
-    if (!mediaUrl)
-        return undefined;
-    if (!isLocalMediaSource(mediaUrl))
-        return mediaUrl;
-    const uploadUrl = config.uploadUrl;
-    if (!uploadUrl) {
-        throw new Error('uploadUrl not configured for local mediaUrl');
-    }
-    const filePath = resolveLocalPath(mediaUrl);
-    if (typeof config.mediaMaxMb === "number" && config.mediaMaxMb > 0) {
-        const stats = await stat(filePath);
-        const maxBytes = config.mediaMaxMb * 1024 * 1024;
-        if (stats.size > maxBytes) {
-            throw new Error(`mediaUrl exceeds limit (${config.mediaMaxMb} MB)`);
-        }
-    }
-    return uploadLocalMedia({
-        uploadUrl,
-        filePath,
-        uploadFieldName: config.uploadFieldName,
-        uploadHeaders: config.uploadHeaders,
-        uploadFormFields: config.uploadFormFields,
-        uploadResponseUrlPath: config.uploadResponseUrlPath,
-        requestTimeout: config.requestTimeout ?? 30000,
-        allowInsecureTls: config.allowInsecureTls,
-    });
-}
-export async function sendMessageWorkclaw(params) {
-    const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last } = params;
-    // 如果没有指定 messageType，根据是否有 replyToMessageId 来判断
-    // - 有 replyToMessageId: 回复消息
-    // - 没有 replyToMessageId: 主动推送
-    const resolvedMessageType = messageType ?? (replyToMessageId ? 'reply' : 'push');
-    // 如果没有指定 accountId，尝试根据 target (to) 和 agentId 查找匹配的账户
-    let resolvedAccountId = accountId;
-    if (!resolvedAccountId) {
-        const foundAccountId = findAccountIdByTarget(cfg, to, agentId);
-        if (foundAccountId) {
-            resolvedAccountId = foundAccountId;
-        }
-    }
-    const account = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
-    if (!account.configured) {
-        throw new Error(`Workclaw account "${account.accountId}" not configured`);
-    }
-    const resolvedMediaUrl = await resolveMediaUrl(mediaUrl, account.config);
-    const cfgChannel = cfg.channels?.['openclaw-workclaw'] ?? {};
-    const cfgAccounts = cfgChannel.accounts ?? {};
-    const cfgAccount = cfgAccounts[resolvedAccountId] ?? {};
-    const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId;
-    // 最后尝试从 state 文件恢复（进程重启后 cfg 没有持久化的 openConversationId）
-    const stateOpenConversationId = loadOpenConversationId(resolvedAccountId, to);
-    const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId ?? stateOpenConversationId;
-    getWorkclawLogger().info(`sendMessageWorkclaw - resolvedAccountId: ${resolvedAccountId}, openConversationId param: ${openConversationId}, cfgOpenConversationId: ${cfgOpenConversationId}, effectiveOpenConversationId: ${effectiveOpenConversationId}, messageType: ${resolvedMessageType}, replyToMessageId: ${replyToMessageId}`);
-    // 使用 appKey 作为缓存键，让所有账户共享同一个 token
-    const tokenCacheKey = account.config.appKey || account.accountId;
-    const result = await sendWorkclawOutboundMessage({
-        cacheKey: tokenCacheKey,
-        to,
-        text,
-        msgType,
-        mediaUrl: resolvedMediaUrl,
-        replyToMessageId,
-        openConversationId: effectiveOpenConversationId,
-        agentId,
-        config: account.config,
-        messageType: resolvedMessageType,
-        last,
-    });
-    // 更新上次出站时间
-    if (resolvedAccountId) {
-        setLastOutboundAt(resolvedAccountId, Date.now());
-    }
-    return {
-        messageId: result.messageId,
-        chatId: to,
-    };
-}
-export async function getMessageWorkclaw(_params) {
-    return null;
-}
-/**
- * 发送主动推送消息（定时任务使用）
- * 使用 pushEndpoint 配置的端口
- */
-export async function sendPushMessageWorkclaw(params) {
-    return sendMessageWorkclaw({
-        ...params,
-        messageType: 'push',
-    });
-}
-/**
- * 发送回复消息（用户触发）
- * 使用 replyEndpoint 配置的端口
- */
-export async function sendReplyMessageWorkclaw(params) {
-    return sendMessageWorkclaw({
-        ...params,
-        messageType: 'reply',
-    });
-}

package/dist/src/outbound/workclaw-sender.js

@@ -1,95 +0,0 @@
-import { sendWorkclawMessage, sendWorkclawReplyMessage as sendWorkclawReplyToMessage, resolveWorkclawMessage, } from "../connection/workclaw-client.js";
-import { getWorkclawLogger } from "../runtime.js";
-export async function sendWorkclawOutboundMessage(params) {
-    const { cacheKey, to, mediaUrl, replyToMessageId, openConversationId, agentId, config, messageType = "reply", last, } = params;
-    let msgType = params.msgType;
-    let content = params.text;
-    // 优先级: 传入参数 > 配置
-    const resolvedAgentId = agentId ?? config.agentId;
-    if (resolvedAgentId === undefined || resolvedAgentId === null || String(resolvedAgentId).trim() === "") {
-        throw new Error("agentId is required for sending messages. " +
-            "Please create an account via cloud platform command or configure accounts in openclaw.json");
-    }
-    if (!msgType) {
-        ({ msgType, content } = resolveWorkclawMessage(content, mediaUrl));
-    }
-    // msgType 转换为 "1"（文本）或其他类型码
-    const messageTypeCode = msgType === "text" ? "1" : msgType;
-    // 构建 WorkclawConnectionConfig（短名格式，用于 connection 模块）
-    const workclawConfig = {
-        baseUrl: config.baseUrl ?? "",
-        appKey: config.appKey ?? "",
-        appSecret: config.appSecret ?? "",
-        localIp: config.localIp,
-        allowInsecureTls: config.allowInsecureTls,
-        requestTimeout: config.requestTimeout,
-    };
-    // 解析 userId 作为 receiveId（优先使用配置中保存的原始 userId）
-    // 配置中的 userId 是原始值（可能为负数），to 是绝对值（OpenClaw 要求）
-    const receiveId = config.userId ?? to;
-    // 使用固定的 endpoint
-    const replyEndpoint = "/open-apis/im/v1/messages/{messageId}/reply";
-    const pushEndpoint = "/open-apis/im/v1/messages";
-    if (messageType === "reply") {
-        // 回复消息需要 replyToMessageId
-        if (!replyToMessageId) {
-            throw new Error("replyToMessageId is required for reply message");
-        }
-        // 优先使用传入的 openConversationId，其次使用配置中持久化的
-        const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
-        getWorkclawLogger().info(`Sending reply message to messageId: ${replyToMessageId}, openConversationId: ${resolvedOpenConversationId}`);
-        const msgId = await sendWorkclawReplyToMessage({
-            cacheKey,
-            config: workclawConfig,
-            agentId: resolvedAgentId,
-            receiveId,
-            msgType: messageTypeCode,
-            content,
-            messageId: replyToMessageId,
-            openConversationId: resolvedOpenConversationId,
-            endpoint: replyEndpoint.replace("{messageId}", String(replyToMessageId)),
-            last,
-        });
-        return { messageId: msgId };
-    }
-    else {
-        // 主动推送消息
-        getWorkclawLogger().info(` Sending proactive message`);
-        // 优先使用传入的 openConversationId，其次使用配置中持久化的
-        const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
-        getWorkclawLogger().info(` Resolved openConversationId: ${resolvedOpenConversationId}`);
-        getWorkclawLogger().info(` Config openConversationId: ${config.openConversationId}`);
-        const msgId = await sendWorkclawMessage({
-            cacheKey,
-            config: workclawConfig,
-            agentId: resolvedAgentId,
-            receiveId,
-            msgType: messageTypeCode,
-            content,
-            openConversationId: resolvedOpenConversationId,
-            endpoint: pushEndpoint,
-            last,
-        });
-        return { messageId: msgId };
-    }
-}
-/**
- * 发送主动推送消息（定时任务使用）
- * POST /im/v1/messages
- */
-export async function sendWorkClawPushMessage(params) {
-    return sendWorkclawOutboundMessage({
-        ...params,
-        messageType: "push",
-    });
-}
-/**
- * 发送回复消息（用户触发）
- * POST /im/v1/messages/{messageId}/reply
- */
-export async function sendWorkclawReplyMessage(params) {
-    return sendWorkclawOutboundMessage({
-        ...params,
-        messageType: "reply",
-    });
-}

package/dist/src/runtime.js

@@ -1,374 +0,0 @@
-let runtime = null;
-// WebSocket 连接存储: key 为 appKey
-const wsByKey = new Map();
-// 额外需要的映射
-const accountIdsByAppKey = new Map();
-const appKeyByAccountId = new Map();
-const reconnectSchedulers = new Map();
-const dispatchersByAppKey = new Map();
-// 正在连接中的 appKey → Promise<ws>（成功后 resolve(ws)，失败 resolve(null)）
-const connectingPromises = new Map();
-const lastMessageAtByKey = new Map(); // 上次消息时间，key 为 accountId 或 appKey
-export function setWorkclawRuntime(next) {
-    runtime = next;
-}
-export function getWorkclawRuntime() {
-    if (!runtime) {
-        throw new Error("Workclaw runtime not initialized");
-    }
-    return runtime;
-}
-let _logger = null;
-const _noop = () => { };
-function _fallbackLogger() {
-    return {
-        info: console.log.bind(console),
-        warn: console.warn.bind(console),
-        error: console.error.bind(console),
-        debug: _noop,
-    };
-}
-/** Store the gateway's log into runtime. Called from startAccount. */
-export function setWorkclawLoggerFromContext(log) {
-    _logger = log;
-}
-/** Get the shared logger. Returns ctx.log from gateway if set, otherwise a console fallback. */
-export function getWorkclawLogger() {
-    if (!_logger) {
-        return _fallbackLogger();
-    }
-    // If the stored logger's info is a noop, fall back to console
-    const l = _logger;
-    if (l.info === _noop) {
-        return _fallbackLogger();
-    }
-    return _logger;
-}
-/**
- * Wrap a logger with a prefix automatically prepended to every message.
- * All messages logged via the returned logger will have the prefix attached.
- */
-export function createLogger(prefix, log) {
-    const fallback = _fallbackLogger();
-    return {
-        info: log?.info ? (msg, ...args) => log.info(`${prefix} ${msg}`, ...args) : fallback.info,
-        warn: log?.warn ? (msg, ...args) => log.warn(`${prefix} ${msg}`, ...args) : fallback.warn,
-        error: log?.error ? (msg, ...args) => log.error(`${prefix} ${msg}`, ...args) : fallback.error,
-        debug: log?.debug ? (msg, ...args) => log.debug(`${prefix} ${msg}`, ...args) : fallback.debug,
-    };
-}
-export function setWorkclawWsConnection(key, ws) {
-    wsByKey.set(key, ws);
-}
-export function clearWorkclawWsConnection(key) {
-    wsByKey.delete(key);
-}
-export function getWorkclawWsConnection(key) {
-    return wsByKey.get(key);
-}
-export function setLastInboundAt(key, timestamp) {
-    lastMessageAtByKey.set(key, timestamp);
-}
-export function getLastInboundAt(key) {
-    return lastMessageAtByKey.get(key);
-}
-const lastOutboundAtByKey = new Map();
-// Cached connection config: accountId -> connection config with stable appKey/appSecret
-// This prevents re-resolving from cfg which may have been mutated
-const connectionConfigCache = new Map();
-export function setWorkclawConnectionConfig(accountId, config) {
-    connectionConfigCache.set(accountId, {
-        appKey: config.appKey,
-        appSecret: config.appSecret,
-        baseUrl: config.baseUrl ?? "",
-        websocketUrl: config.websocketUrl,
-        localIp: config.localIp,
-        allowInsecureTls: config.allowInsecureTls,
-        requestTimeout: config.requestTimeout,
-    });
-}
-export function getWorkclawConnectionConfig(accountId) {
-    return connectionConfigCache.get(accountId);
-}
-export function clearWorkclawConnectionConfig(accountId) {
-    connectionConfigCache.delete(accountId);
-}
-export function setLastOutboundAt(key, timestamp) {
-    lastOutboundAtByKey.set(key, timestamp);
-}
-export function getLastOutboundAt(key) {
-    return lastOutboundAtByKey.get(key);
-}
-// 注册账号上下文
-export function registerAccountContext(appKey, accountId, ctx) {
-    if (!accountIdsByAppKey.has(appKey)) {
-        accountIdsByAppKey.set(appKey, new Set());
-    }
-    accountIdsByAppKey.get(appKey).add(accountId);
-    appKeyByAccountId.set(accountId, appKey);
-    if (!dispatchersByAppKey.has(appKey)) {
-        dispatchersByAppKey.set(appKey, new Map());
-    }
-    dispatchersByAppKey.get(appKey).set(accountId, { ctx });
-}
-export function unregisterAccountContext(appKey, accountId) {
-    accountIdsByAppKey.get(appKey)?.delete(accountId);
-    appKeyByAccountId.delete(accountId);
-    dispatchersByAppKey.get(appKey)?.delete(accountId);
-}
-export function getAccountIdsByAppKey(appKey) {
-    return Array.from(accountIdsByAppKey.get(appKey) ?? []);
-}
-export function getAppKeyByAccountId(accountId) {
-    return appKeyByAccountId.get(accountId);
-}
-export function getDispatcherByAppKeyAndAccountId(appKey, accountId) {
-    return dispatchersByAppKey.get(appKey)?.get(accountId);
-}
-export function getAllDispatchersByAppKey(appKey) {
-    return dispatchersByAppKey.get(appKey);
-}
-export function setReconnectScheduler(appKey, scheduler) {
-    reconnectSchedulers.set(appKey, scheduler);
-}
-export function getReconnectScheduler(appKey) {
-    return reconnectSchedulers.get(appKey);
-}
-export function clearReconnectScheduler(appKey) {
-    reconnectSchedulers.delete(appKey);
-}
-// 尝试开始连接
-// 关键：所有并发调用者必须共享同一个 Promise，而不是各自创建新的导致重复建连
-export function tryStartConnecting(appKey) {
-    // 优先查 connectingPromises，确保所有并发调用者共享同一个 Promise
-    const existingPromise = connectingPromises.get(appKey);
-    if (existingPromise !== undefined) {
-        // 已有并发账号在连接，等待同一个 Promise
-        return {
-            isConnector: false,
-            existingWs: wsByKey.get(appKey),
-            connectingPromise: existingPromise,
-        };
-    }
-    // Map 里没有 entry，自己是新 connector
-    let resolvePromise;
-    const promise = new Promise((resolve) => { resolvePromise = resolve; });
-    promise._resolve = resolvePromise;
-    connectingPromises.set(appKey, promise);
-    return { isConnector: true, existingWs: undefined, connectingPromise: promise };
-}
-// 标记连接完成（成功或失败都需要调用）
-// ws 不传或传 undefined 表示失败
-export function finishConnecting(appKey, ws) {
-    const promise = connectingPromises.get(appKey);
-    if (promise) {
-        promise._resolve?.(ws ?? null);
-        connectingPromises.delete(appKey);
-    }
-    // ws 已建立成功时存入 wsByKey，供后续 tryStartConnecting 返回 existingWs
-    if (ws) {
-        wsByKey.set(appKey, ws);
-    }
-}
-// runId -> ToolContext 映射表
-const runIdToToolContext = new Map();
-// toolCallId -> runId 映射表（用于 tool_result_persist 通过 toolCallId 找到 runId，再找到 ctx）
-const toolCallIdToRunId = new Map();
-// 获取工具上下文（通过 runId）
-export function getToolContext(runId) {
-    return runIdToToolContext.get(runId);
-}
-// 设置工具上下文（仅通过 runId）
-export function setToolContext(runId, ctx) {
-    runIdToToolContext.set(runId, ctx);
-}
-// 建立 toolCallId -> runId 的映射（用于 after_tool_call 中）
-export function setToolCallIdToRunIdMapping(toolCallId, runId) {
-    toolCallIdToRunId.set(toolCallId, runId);
-}
-// 通过 toolCallId 获取 runId
-export function getRunIdByToolCallId(toolCallId) {
-    return toolCallIdToRunId.get(toolCallId);
-}
-// 删除工具上下文
-export function deleteToolContext(runId) {
-    runIdToToolContext.delete(runId);
-}
-// 清空所有工具上下文（用于清理）
-export function clearAllToolContexts() {
-    runIdToToolContext.clear();
-    toolCallIdToRunId.clear();
-}
-// 调用sub-agent进行协作
-export async function spawnSubAgent(params) {
-    if (!runtime) {
-        throw new Error("Workclaw runtime not initialized");
-    }
-    try {
-        // 通过runtime调用sessions_spawn
-        const sessionsSpawn = runtime?.sessions_spawn;
-        if (!sessionsSpawn || typeof sessionsSpawn !== "function") {
-            // 如果runtime没有提供sessions_spawn，返回模拟数据
-            getWorkclawLogger().warn(`Runtime does not provide sessions_spawn, returning mock response for agent ${params.agentId}`);
-            return {
-                ok: true,
-                summary: `[模拟] Agent ${params.agentId} 完成任务: ${params.task.substring(0, 50)}...`
-            };
-        }
-        const result = await sessionsSpawn({
-            agentId: params.agentId,
-            task: params.task,
-            label: params.label,
-            model: params.model
-        });
-        return {
-            ok: true,
-            sessionKey: result.sessionKey,
-            summary: result.summary
-        };
-    }
-    catch (error) {
-        getWorkclawLogger().error(`Failed to spawn sub-agent: ${error.message}`);
-        return {
-            ok: false,
-            error: error.message
-        };
-    }
-}
-export const __openclaw_workclaw_runtime_emitted = true;
-/**
- * 获取工具执行开始的提示（用于 onToolStart）
- */
-export function getToolStartHint(toolName) {
-    if (!toolName)
-        return "🔄 正在执行工具...";
-    const normalizedToolName = toolName.toLowerCase().trim();
-    const toolMap = {
-        // 📁 文件操作
-        read: { emoji: "📖", title: "读取文件", hint: "正在读取文件", aliases: ["file_read", "read_file"] },
-        write: { emoji: "✍️", title: "写入文件", hint: "正在写入文件", aliases: ["file_write", "write_file"] },
-        edit: { emoji: "✏️", title: "编辑文件", hint: "正在编辑文件", aliases: ["file_edit", "modify"] },
-        // 💻 系统命令
-        exec: { emoji: "⚡", title: "执行命令", hint: "正在执行命令", aliases: ["bash", "shell", "cmd", "command"] },
-        process: { emoji: "🔄", title: "进程管理", hint: "正在处理进程", aliases: ["process_manager"] },
-        // 🌐 网络/浏览器
-        web_fetch: { emoji: "🕸️", title: "获取网页", hint: "正在获取网页内容", aliases: ["fetch", "http_get", "http_request", "curl"] },
-        web_search: { emoji: "🔍", title: "搜索网页", hint: "正在搜索网页", aliases: ["search", "google_search", "brave_search"] },
-        browser: { emoji: "🌐", title: "浏览器控制", hint: "正在控制浏览器", aliases: ["browser_control", "playwright"] },
-        // 💬 消息/通信
-        message: { emoji: "💌", title: "发送消息", hint: "正在发送消息", aliases: ["send_message", "mcp_deliver", "deliver", "notify"] },
-        tts: { emoji: "🔊", title: "文字转语音", hint: "正在转换语音", aliases: ["text_to_speech", "speak"] },
-        // 🎭 会话管理
-        sessions_spawn: { emoji: "🧬", title: "创建子代理", hint: "正在创建子代理", aliases: ["spawn", "create_agent", "new_session"] },
-        sessions_send: { emoji: "📤", title: "跨会话发消息", hint: "正在发送跨会话消息", aliases: ["send_to_session", "forward"] },
-        sessions_list: { emoji: "📋", title: "列出会话", hint: "正在列出会话", aliases: ["list_sessions"] },
-        sessions_history: { emoji: "📜", title: "获取历史", hint: "正在获取历史消息", aliases: ["get_history", "history"] },
-        sessions_yield: { emoji: "⏸️", title: "暂停让出", hint: "正在暂停等待", aliases: ["yield", "pause"] },
-        subagents: { emoji: "🐛", title: "子代理管理", hint: "正在管理子代理", aliases: ["subagent_manager"] },
-        agents_list: { emoji: "🤖", title: "列出代理", hint: "正在列出可用代理", aliases: ["list_agents"] },
-        // 🧠 记忆/知识
-        memory_search: { emoji: "🔎", title: "搜索记忆", hint: "正在搜索记忆", aliases: ["search_memory", "recall"] },
-        memory_get: { emoji: "📝", title: "读取记忆", hint: "正在读取记忆片段", aliases: ["get_memory", "read_memory"] },
-        // ⏰ 定时任务
-        "openclaw-workclaw-cron-add-params": { emoji: "⏱️", title: "创建定时任务", hint: "正在创建定时任务", aliases: ["cron_add", "add_timer"] },
-        "openclaw-workclaw-cron-update-params": { emoji: "🔧", title: "修改定时任务", hint: "正在修改定时任务", aliases: ["cron_update", "update_timer"] },
-        "openclaw-workclaw-cron-remove-params": { emoji: "🗑️", title: "删除定时任务", hint: "正在删除定时任务", aliases: ["cron_remove", "remove_timer"] },
-        "openclaw-workclaw-cron-notify-sync": { emoji: "🔔", title: "定时触发通知", hint: "定时任务已触发", aliases: ["cron_trigger", "notify"] },
-        "openclaw-workclaw-cron-add-sync": { emoji: "✅", title: "同步定时任务", hint: "正在同步到后端", aliases: [] },
-        "openclaw-workclaw-cron-update-sync": { emoji: "✅", title: "同步定时更新", hint: "正在同步更新", aliases: [] },
-        "openclaw-workclaw-cron-remove-sync": { emoji: "✅", title: "同步定时删除", hint: "正在同步删除", aliases: [] },
-        "openclaw-workclaw-cron-disable-params": { emoji: "⏸️", title: "禁用定时任务", hint: "正在禁用定时任务", aliases: ["cron_disable"] },
-        "openclaw-workclaw-cron-enable-params": { emoji: "▶️", title: "启用定时任务", hint: "正在启用定时任务", aliases: ["cron_enable"] },
-        // 📊 其他
-        session_status: { emoji: "📊", title: "会话状态", hint: "正在获取会话状态", aliases: ["status", "get_status"] },
-        canvas: { emoji: "🎨", title: "画布控制", hint: "正在控制画布", aliases: ["canvas_control", "draw"] },
-    };
-    // 精确匹配
-    if (toolMap[normalizedToolName]) {
-        const tool = toolMap[normalizedToolName];
-        return `${tool.emoji} ${tool.hint}...`;
-    }
-    // 别名匹配
-    for (const [key, tool] of Object.entries(toolMap)) {
-        if (tool.aliases.includes(normalizedToolName)) {
-            return `${tool.emoji} ${tool.hint}...`;
-        }
-    }
-    // 默认
-    return `🔄 正在执行 ${toolName}...`;
-}
-/**
- * 获取工具执行完成的提示（用于 after_tool_call）
- */
-export function getToolResultHint(toolName) {
-    if (!toolName)
-        return "✅ 工具执行完成";
-    const normalizedToolName = toolName.toLowerCase().trim();
-    const toolMap = {
-        // 📁 文件操作
-        read: { emoji: "📖", title: "读取文件", hint: "已读取文件", aliases: ["file_read", "read_file"] },
-        write: { emoji: "✍️", title: "写入文件", hint: "已写入文件", aliases: ["file_write", "write_file"] },
-        edit: { emoji: "✏️", title: "编辑文件", hint: "已编辑文件", aliases: ["file_edit", "modify"] },
-        // 💻 系统命令
-        exec: { emoji: "⚡", title: "执行命令", hint: "已执行命令", aliases: ["bash", "shell", "cmd", "command"] },
-        process: { emoji: "🔄", title: "进程管理", hint: "已处理进程", aliases: ["process_manager"] },
-        // 🌐 网络/浏览器
-        web_fetch: { emoji: "🕸️", title: "获取网页", hint: "已获取网页", aliases: ["fetch", "http_get", "http_request", "curl"] },
-        web_search: { emoji: "🔍", title: "搜索网页", hint: "已搜索网页", aliases: ["search", "google_search", "brave_search"] },
-        browser: { emoji: "🌐", title: "浏览器控制", hint: "已控制浏览器", aliases: ["browser_control", "playwright"] },
-        // 💬 消息/通信
-        message: { emoji: "💌", title: "发送消息", hint: "已发送消息", aliases: ["send_message", "mcp_deliver", "deliver", "notify"] },
-        tts: { emoji: "🔊", title: "文字转语音", hint: "已转换语音", aliases: ["text_to_speech", "speak"] },
-        // 🎭 会话管理
-        sessions_spawn: { emoji: "🧬", title: "创建子代理", hint: "已创建子代理", aliases: ["spawn", "create_agent", "new_session"] },
-        sessions_send: { emoji: "📤", title: "跨会话发消息", hint: "已发送跨会话消息", aliases: ["send_to_session", "forward"] },
-        sessions_list: { emoji: "📋", title: "列出会话", hint: "已列出会话", aliases: ["list_sessions"] },
-        sessions_history: { emoji: "📜", title: "获取历史", hint: "已获取历史消息", aliases: ["get_history", "history"] },
-        sessions_yield: { emoji: "⏸️", title: "暂停让出", hint: "已暂停等待", aliases: ["yield", "pause"] },
-        subagents: { emoji: "🐛", title: "子代理管理", hint: "已管理子代理", aliases: ["subagent_manager"] },
-        agents_list: { emoji: "🤖", title: "列出代理", hint: "已列出代理", aliases: ["list_agents"] },
-        // 🧠 记忆/知识
-        memory_search: { emoji: "🔎", title: "搜索记忆", hint: "已搜索记忆", aliases: ["search_memory", "recall"] },
-        memory_get: { emoji: "📝", title: "读取记忆", hint: "已读取记忆", aliases: ["get_memory", "read_memory"] },
-        // ⏰ 定时任务
-        "openclaw-workclaw-cron-add-params": { emoji: "⏱️", title: "创建定时任务", hint: "已创建定时任务", aliases: ["cron_add", "add_timer"] },
-        "openclaw-workclaw-cron-update-params": { emoji: "🔧", title: "修改定时任务", hint: "已修改定时任务", aliases: ["cron_update", "update_timer"] },
-        "openclaw-workclaw-cron-remove-params": { emoji: "🗑️", title: "删除定时任务", hint: "已删除定时任务", aliases: ["cron_remove", "remove_timer"] },
-        "openclaw-workclaw-cron-notify-sync": { emoji: "🔔", title: "定时触发通知", hint: "定时任务已触发", aliases: ["cron_trigger", "notify"] },
-        "openclaw-workclaw-cron-add-sync": { emoji: "✅", title: "同步定时任务", hint: "已同步定时任务", aliases: [] },
-        "openclaw-workclaw-cron-update-sync": { emoji: "✅", title: "同步定时更新", hint: "已同步更新", aliases: [] },
-        "openclaw-workclaw-cron-remove-sync": { emoji: "✅", title: "同步定时删除", hint: "已同步删除", aliases: [] },
-        "openclaw-workclaw-cron-disable-params": { emoji: "⏸️", title: "禁用定时任务", hint: "已禁用定时任务", aliases: ["cron_disable"] },
-        "openclaw-workclaw-cron-enable-params": { emoji: "▶️", title: "启用定时任务", hint: "已启用定时任务", aliases: ["cron_enable"] },
-        // 📊 其他
-        session_status: { emoji: "📊", title: "会话状态", hint: "已获取会话状态", aliases: ["status", "get_status"] },
-        canvas: { emoji: "🎨", title: "画布控制", hint: "已控制画布", aliases: ["canvas_control", "draw"] },
-    };
-    // 精确匹配
-    if (toolMap[normalizedToolName]) {
-        const tool = toolMap[normalizedToolName];
-        return `${tool.emoji} ${tool.hint}`;
-    }
-    // 别名匹配
-    for (const [key, tool] of Object.entries(toolMap)) {
-        if (tool.aliases.includes(normalizedToolName)) {
-            return `${tool.emoji} ${tool.hint}`;
-        }
-    }
-    // 默认
-    return `✅ 已执行 ${toolName}`;
-}
-/**
- * 获取 Workclaw 渠道密钥
- * 这是 setup 向导必需的接口
- */
-export async function getWorkclawSecrets(params) {
-    const secrets = {};
-    if (params.appKey) {
-        secrets.appKey = params.appKey;
-    }
-    if (params.appSecret) {
-        secrets.appSecret = params.appSecret;
-    }
-    return secrets;
-}

package/dist/src/secret-contract-api.js

@@ -1,4 +0,0 @@
-export const channelSecrets = {
-    specifier: "./runtime.js",
-    exportName: "getWorkclawSecrets",
-};

package/dist/src/send.js

@@ -1 +0,0 @@
-export { sendMessageWorkclaw, getMessageWorkclaw } from "./outbound/index.js";

package/dist/src/setup-api.js

@@ -1,3 +0,0 @@
-export { workclawPlugin } from "./channel.js";
-export * from "./setup-core.js";
-export * from "./setup-surface.js";

package/dist/src/setup-core.js

@@ -1,13 +0,0 @@
-import { DEFAULT_ACCOUNT_ID, } from "openclaw/plugin-sdk/setup";
-import { resolveDefaultWorkclawAccountId } from "./accounts.js";
-import { patchWorkclawConfig } from "./setup-surface.js";
-export function setWorkclawNamedAccountEnabled(cfg, accountId, enabled) {
-    return patchWorkclawConfig(cfg, accountId, { enabled });
-}
-export const workclawSetupAdapter = {
-    resolveAccountId: ({ cfg, accountId }) => accountId?.trim() || resolveDefaultWorkclawAccountId(cfg),
-    applyAccountConfig: ({ cfg, accountId }) => {
-        const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
-        return patchWorkclawConfig(cfg, isDefault ? DEFAULT_ACCOUNT_ID : accountId, { enabled: true });
-    },
-};