@workclaw/openclaw-workclaw 1.0.18 → 1.0.20

package/dist/src/setup-surface.js

@@ -0,0 +1,363 @@
+import { DEFAULT_ACCOUNT_ID, formatDocsLink, patchTopLevelChannelConfigSection, } from "openclaw/plugin-sdk/setup";
+import { inspectWorkclawCredentials, resolveDefaultWorkclawAccountId } from "./accounts.js";
+import { doFetchJson } from "./connection/workclaw-client.js";
+const channel = "openclaw-workclaw";
+/**
+ * 规范化字符串值
+ */
+function normalizeString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function trimTrailingSlash(value) {
+    return value.endsWith("/") ? value.slice(0, -1) : value;
+}
+function resolveSetupApiBases(cfg) {
+    const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+    const configuredBaseUrl = normalizeString(workclawCfg?.baseUrl) ??
+        normalizeString(process.env.WORKCLAW_BASE_URL);
+    const configuredAuthBaseUrl = normalizeString(process.env.WORKCLAW_AUTH_BASE_URL);
+    const configuredOpenApiBaseUrl = normalizeString(process.env.WORKCLAW_OPEN_API_BASE_URL);
+    const defaultAuthBaseUrl = "https://workbrain.cn/backend-api";
+    const defaultOpenApiBaseUrl = `${defaultAuthBaseUrl}/open-apis`;
+    const fromBaseUrl = (() => {
+        if (!configuredBaseUrl) {
+            return null;
+        }
+        const normalized = trimTrailingSlash(configuredBaseUrl);
+        if (normalized.endsWith("/open-apis")) {
+            return {
+                authBaseUrl: normalized.slice(0, -"/open-apis".length),
+                openApiBaseUrl: normalized,
+            };
+        }
+        return {
+            authBaseUrl: normalized,
+            openApiBaseUrl: `${normalized}/open-apis`,
+        };
+    })();
+    return {
+        authBaseUrl: trimTrailingSlash(configuredAuthBaseUrl ?? fromBaseUrl?.authBaseUrl ?? defaultAuthBaseUrl),
+        openApiBaseUrl: trimTrailingSlash(configuredOpenApiBaseUrl ?? fromBaseUrl?.openApiBaseUrl ?? defaultOpenApiBaseUrl),
+        allowInsecureTls: workclawCfg?.allowInsecureTls,
+        requestTimeout: workclawCfg?.requestTimeout,
+    };
+}
+/**
+ * 检查 Workclaw 是否已配置
+ */
+function isWorkclawConfigured(cfg) {
+    const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+    // 检查字符串值是否已配置
+    const isConfigured = (value) => {
+        const asString = normalizeString(value);
+        return !!asString;
+    };
+    const topLevelConfigured = isConfigured(workclawCfg?.appKey) &&
+        isConfigured(workclawCfg?.appSecret);
+    const accountConfigured = Object.values(workclawCfg?.accounts ?? {}).some((account) => {
+        if (!account || typeof account !== "object") {
+            return false;
+        }
+        const hasOwnAppKey = Object.prototype.hasOwnProperty.call(account, "appKey");
+        const hasOwnAppSecret = Object.prototype.hasOwnProperty.call(account, "appSecret");
+        const accountAppKeyConfigured = hasOwnAppKey
+            ? isConfigured(account.appKey)
+            : isConfigured(workclawCfg?.appKey);
+        const accountSecretConfigured = hasOwnAppSecret
+            ? isConfigured(account.appSecret)
+            : isConfigured(workclawCfg?.appSecret);
+        return accountAppKeyConfigured && accountSecretConfigured;
+    });
+    return topLevelConfigured || accountConfigured;
+}
+/**
+ * 修补 Workclaw 配置
+ */
+export function patchWorkclawConfig(cfg, accountId, patch) {
+    const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        return patchTopLevelChannelConfigSection({
+            cfg,
+            channel,
+            enabled: true,
+            patch,
+        });
+    }
+    const nextAccountPatch = {
+        ...workclawCfg?.accounts?.[accountId],
+        enabled: true,
+        ...patch,
+    };
+    return patchTopLevelChannelConfigSection({
+        cfg,
+        channel,
+        enabled: true,
+        patch: {
+            accounts: {
+                ...workclawCfg?.accounts,
+                [accountId]: nextAccountPatch,
+            },
+        },
+    });
+}
+/**
+ * 提示凭证帮助信息
+ */
+async function noteWorkclawCredentialHelp(prompter) {
+    await prompter.note([
+        "智小途插件安装引导",
+        "",
+        "准备事项:",
+        "1. 访问 workbrain.cn 获取 App Key 和 App Secret",
+        "2. 确保您的账号已开通智小途服务",
+        "3. 准备好您的手机号（用于获取配置信息）",
+        "",
+        `文档: ${formatDocsLink("/channels/openclaw-workclaw", "智小途")}`,
+    ].join("\n"), "智小途配置");
+}
+/**
+ * 提示 App Key 输入
+ */
+async function promptWorkclawAppKey(params) {
+    return (await params.prompter.text({
+        message: "智小途 App Key",
+        initialValue: params.initialValue,
+        validate: (value) => (value?.trim() ? undefined : "App Key 不能为空"),
+    })).trim();
+}
+/**
+ * 提示 App Secret 输入
+ */
+async function promptWorkclawAppSecret(params) {
+    return (await params.prompter.text({
+        message: "智小途 App Secret",
+        initialValue: params.initialValue,
+        validate: (value) => (value?.trim() ? undefined : "App Secret 不能为空"),
+    })).trim();
+}
+/**
+ * 提示手机号输入
+ */
+async function promptWorkclawPhone(params) {
+    return (await params.prompter.text({
+        message: "智小途手机号",
+        initialValue: params.initialValue,
+        validate: (value) => {
+            if (!value?.trim())
+                return "手机号不能为空";
+            if (!/^1[3-9]\d{9}$/.test(value.trim()))
+                return "请输入正确的手机号格式";
+            return undefined;
+        },
+    })).trim();
+}
+/**
+ * 通过手机号获取 agentId 和 userId
+ */
+async function fetchAgentInfoByPhone(cfg, appKey, appSecret, phone, prompter) {
+    prompter.note?.("正在通过手机号获取配置信息...", "获取配置");
+    try {
+        const { authBaseUrl, openApiBaseUrl, allowInsecureTls, requestTimeout } = resolveSetupApiBases(cfg);
+        // 1. 获取 access token
+        const tokenData = await doFetchJson(`${authBaseUrl}/authen/v1/access_token/internal`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                app_key: appKey,
+                app_secret: appSecret,
+            }),
+        }, allowInsecureTls, requestTimeout);
+        if (tokenData.code !== 200 || !tokenData.data?.accessToken) {
+            prompter.note?.(`获取 Token 失败: ${tokenData.message || "未知错误"}`, "获取配置");
+            return null;
+        }
+        const accessToken = tokenData.data.accessToken;
+        // 2. 通过手机号获取 agentId 和 userId
+        const agentData = await doFetchJson(`${openApiBaseUrl}/instance/local/agentInf`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({
+                appKey,
+                phone,
+            }),
+        }, allowInsecureTls, requestTimeout);
+        if (agentData.code !== 200 || !agentData.data) {
+            prompter.note?.(`获取配置信息失败: ${agentData.message || "未知错误"}`, "获取配置");
+            return null;
+        }
+        prompter.note?.(`成功获取配置信息`, "获取配置");
+        return {
+            agentId: agentData.data.agentId,
+            userId: agentData.data.userId,
+        };
+    }
+    catch (error) {
+        prompter.note?.(`获取配置失败: ${error.message}`, "获取配置");
+        return null;
+    }
+}
+/**
+ * 运行新应用流程
+ */
+async function runNewAppFlow(params) {
+    const { prompter } = params;
+    let next = params.cfg;
+    // 1. 显示帮助信息
+    await noteWorkclawCredentialHelp(prompter);
+    // 2. 获取 App Key
+    const appKey = await promptWorkclawAppKey({
+        prompter,
+        initialValue: normalizeString(process.env.WORKCLAW_APP_KEY),
+    });
+    // 3. 获取 App Secret
+    const appSecret = await promptWorkclawAppSecret({
+        prompter,
+        initialValue: normalizeString(process.env.WORKCLAW_APP_SECRET),
+    });
+    // 4. 获取手机号（通过手机号获取 agentId 和 userId）
+    const phone = await promptWorkclawPhone({
+        prompter,
+        initialValue: normalizeString(process.env.WORKCLAW_PHONE),
+    });
+    // 5. 配置基础信息
+    next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, {
+        appKey,
+        appSecret,
+        connectionMode: "websocket",
+        enabled: true,
+    });
+    // 6. 通过手机号获取 agentId 和 userId
+    const agentInfo = await fetchAgentInfoByPhone(next, appKey, appSecret, phone, prompter);
+    if (agentInfo) {
+        // 更新配置中的 agentId 和 userId
+        const accountConfig = {
+            enabled: true,
+        };
+        if (agentInfo.agentId) {
+            accountConfig.agentId = agentInfo.agentId;
+        }
+        if (agentInfo.userId) {
+            accountConfig.userId = agentInfo.userId;
+        }
+        next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, accountConfig);
+    }
+    // 6. DM 策略固定为 open
+    next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, {
+        dmPolicy: "open",
+        allowFrom: ["*"],
+    });
+    await prompter.note("智小途配置完成!", "");
+    return { cfg: next };
+}
+/**
+ * 运行编辑配置流程
+ */
+async function runEditFlow(params) {
+    const workclawCfg = params.cfg.channels?.["openclaw-workclaw"];
+    const existingAppKey = workclawCfg?.appKey;
+    await params.prompter.note(`当前配置的 App Key: ${existingAppKey ?? "(未配置)"}`, "智小途配置");
+    const useExisting = await params.prompter.confirm({
+        message: `使用现有的智小途配置 (App Key: ${existingAppKey})?`,
+        initialValue: true,
+    });
+    if (!useExisting) {
+        return runNewAppFlow(params);
+    }
+    await params.prompter.note("保持现有配置不变。", "");
+    return { cfg: params.cfg };
+}
+/**
+ * 运行凭证探测流程
+ */
+async function runProbeFlow(params) {
+    const workclawCfg = params.cfg.channels?.["openclaw-workclaw"];
+    const resolvedCredentials = inspectWorkclawCredentials(workclawCfg);
+    if (resolvedCredentials) {
+        try {
+            const probeResult = await resolvedCredentials();
+            params.prompter.note(`智小途连接测试成功! ${probeResult.botName ? `Bot名称: ${probeResult.botName}` : ""}`, "连接测试");
+        }
+        catch {
+            params.prompter.note("智小途连接测试失败，请检查配置。", "连接测试");
+        }
+    }
+    return params.cfg;
+}
+export { workclawSetupAdapter } from "./setup-core.js";
+export const workclawSetupWizard = {
+    channel,
+    resolveAccountIdForConfigure: ({ accountOverride, defaultAccountId, cfg }) => (typeof accountOverride === "string" && accountOverride.trim()
+        ? accountOverride.trim()
+        : undefined) ??
+        resolveDefaultWorkclawAccountId(cfg) ??
+        defaultAccountId,
+    resolveShouldPromptAccountIds: () => false,
+    status: {
+        configuredLabel: "已配置",
+        unconfiguredLabel: "需要配置",
+        configuredHint: "已配置",
+        unconfiguredHint: "需要凭证",
+        configuredScore: 2,
+        unconfiguredScore: 0,
+        resolveConfigured: ({ cfg }) => isWorkclawConfigured(cfg),
+        resolveStatusLines: async ({ cfg, configured }) => {
+            const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+            const resolvedCredentials = inspectWorkclawCredentials(workclawCfg);
+            let probeResult = null;
+            if (configured && resolvedCredentials) {
+                try {
+                    probeResult = await resolvedCredentials();
+                }
+                catch { }
+            }
+            if (!configured) {
+                return ["智小途: 需要 App Key 和 App Secret"];
+            }
+            if (probeResult?.ok) {
+                return [`智小途: 已连接${probeResult.botName ? ` (${probeResult.botName})` : ""}`];
+            }
+            return ["智小途: 已配置 (连接未验证)"];
+        },
+    },
+    prepare: async ({ cfg, credentialValues }) => {
+        const alreadyConfigured = isWorkclawConfigured(cfg);
+        if (alreadyConfigured) {
+            return {
+                credentialValues: { ...credentialValues, _flow: "edit" },
+            };
+        }
+        return {
+            credentialValues: { ...credentialValues, _flow: "new" },
+        };
+    },
+    credentials: [],
+    finalize: async ({ cfg, prompter, options, credentialValues }) => {
+        const flow = credentialValues._flow ?? "new";
+        if (flow === "edit") {
+            const result = await runEditFlow({ cfg, prompter, options });
+            if (result === null) {
+                return { cfg };
+            }
+            cfg = result.cfg;
+        }
+        else {
+            cfg = (await runNewAppFlow({ cfg, prompter, options })).cfg;
+        }
+        await runProbeFlow({ cfg, prompter });
+        return { cfg };
+    },
+    disable: (cfg) => patchTopLevelChannelConfigSection({
+        cfg,
+        channel,
+        patch: { enabled: false },
+    }),
+};

package/dist/src/tools/openclaw-workclaw-cron/api/index.d.ts

@@ -0,0 +1,93 @@
+/**
+ * 智小途定时任务工具 - 后端接口封装
+ */
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk';
+/**
+ * 调用后端 API 的通用方法
+ * @param api - OpenClaw API 实例
+ * @param accountId - 账户 ID
+ * @param path - API 路径
+ * @param payload - 请求体
+ * @param options - 可选配置
+ * @returns 接口调用结果
+ */
+export declare function callBackendApi(api: OpenClawPluginApi, accountId: string, path: string, payload: Record<string, any>, options?: {
+    maxRetries?: number;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+    attempts?: number;
+}>;
+/**
+ * 调用新增定时任务接口
+ */
+export declare function callCronJobAdd(api: OpenClawPluginApi, accountId: string, payload: {
+    jobId: string;
+    name: string;
+    kind: 'cron';
+    expr?: string;
+    message: string;
+    messageId?: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;
+/**
+ * 调用删除定时任务接口
+ */
+export declare function callCronJobRemove(api: OpenClawPluginApi, accountId: string, payload: {
+    jobId: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;
+/**
+ * 调用更新定时任务接口
+ */
+export declare function callCronJobUpdate(api: OpenClawPluginApi, accountId: string, payload: {
+    jobId: string;
+    name: string;
+    kind: 'cron';
+    expr?: string;
+    message: string;
+    agentId?: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;
+/**
+ * 调用启用定时任务接口
+ */
+export declare function callCronJobEnabled(api: OpenClawPluginApi, accountId: string, payload: {
+    jobId: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;
+/**
+ * 调用禁用定时任务接口
+ */
+export declare function callCronJobDisabled(api: OpenClawPluginApi, accountId: string, payload: {
+    jobId: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;
+/**
+ * 调用定时任务触发通知接口
+ */
+export declare function callCronJobMessage(api: OpenClawPluginApi, accountId: string, payload: {
+    jobId: string;
+    message: string;
+    agentId?: string;
+}): Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+}>;

package/dist/src/tools/openclaw-workclaw-cron/api/index.js

@@ -0,0 +1,209 @@
+/**
+ * 智小途定时任务工具 - 后端接口封装
+ */
+import { resolveWorkclawAccountWithCache } from '../../../accounts.js';
+import { doFetchJson, getWorkclawAccessToken, normalizeBaseUrl } from '../../../connection/workclaw-client.js';
+const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_RETRY_DELAY_MS = 1000;
+/**
+ * 睡眠函数
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * 带重试机制的 fetch 调用
+ */
+async function fetchWithRetry(fetchFn, options = {}) {
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const retryDelayMs = options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS;
+    const retryableErrors = options.retryableErrors ?? [
+        'ECONNREFUSED',
+        'ETIMEDOUT',
+        'ENOTFOUND',
+        'ENETUNREACH',
+        'EAI_AGAIN',
+    ];
+    let lastError = '';
+    let attempts = 0;
+    for (let i = 0; i <= maxRetries; i++) {
+        attempts = i + 1;
+        try {
+            const data = await fetchFn();
+            return { data, attempts };
+        }
+        catch (error) {
+            lastError = error.message || String(error);
+            const isRetryable = retryableErrors.some(e => lastError.toLowerCase().includes(e.toLowerCase()));
+            if (i < maxRetries && isRetryable) {
+                const delay = retryDelayMs * 2 ** i;
+                await sleep(delay);
+                continue;
+            }
+            break;
+        }
+    }
+    return { error: lastError, attempts };
+}
+/**
+ * 脱敏日志输出（隐藏敏感字段）
+ */
+function sanitizePayload(payload) {
+    const sensitiveFields = [
+        'password',
+        'secret',
+        'token',
+        'authorization',
+        'appSecret',
+        'appSecret',
+    ];
+    const sanitized = {};
+    for (const [key, value] of Object.entries(payload)) {
+        const lowerKey = key.toLowerCase();
+        if (sensitiveFields.some(f => lowerKey.includes(f))) {
+            sanitized[key] = '***';
+        }
+        else if (typeof value === 'object' && value !== null) {
+            sanitized[key] = sanitizePayload(value);
+        }
+        else {
+            sanitized[key] = value;
+        }
+    }
+    return sanitized;
+}
+/**
+ * 调用后端 API 的通用方法
+ * @param api - OpenClaw API 实例
+ * @param accountId - 账户 ID
+ * @param path - API 路径
+ * @param payload - 请求体
+ * @param options - 可选配置
+ * @returns 接口调用结果
+ */
+export async function callBackendApi(api, accountId, path, payload, options = {}) {
+    try {
+        const account = resolveWorkclawAccountWithCache({
+            cfg: api.config,
+            accountId,
+        });
+        if (!account.configured) {
+            api.logger.error(`[智小途-定时任务] 账户未配置 accountId=${accountId}`);
+            return { success: false, error: 'Account not configured' };
+        }
+        const accConfig = account.config;
+        const tokenCacheKey = accConfig.appKey || accountId;
+        const baseUrl = normalizeBaseUrl(accConfig.baseUrl);
+        api.logger.info(`[智小途-定时任务] 正在获取认证 token，accountId=${accountId}`);
+        const token = await getWorkclawAccessToken(tokenCacheKey, {
+            baseUrl: accConfig.baseUrl,
+            appKey: accConfig.appKey,
+            appSecret: accConfig.appSecret,
+            allowInsecureTls: accConfig.allowInsecureTls,
+            requestTimeout: accConfig.requestTimeout,
+        });
+        const requestUrl = `${baseUrl}/open-apis${path}`;
+        const sanitizedPayload = sanitizePayload(payload);
+        api.logger.info(`[智小途-定时任务] 调用接口 ${requestUrl}`);
+        api.logger.info(`[智小途-定时任务] 请求参数 ${JSON.stringify(sanitizedPayload)}`);
+        const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+        const fetchResult = await fetchWithRetry(() => doFetchJson(requestUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${token}`,
+            },
+            body: JSON.stringify(payload),
+        }, accConfig.allowInsecureTls, accConfig.requestTimeout), { maxRetries });
+        if (fetchResult.error) {
+            api.logger.error(`[智小途-定时任务] 接口调用失败（已重试 ${fetchResult.attempts} 次）: ${fetchResult.error}`);
+            return { success: false, error: fetchResult.error, attempts: fetchResult.attempts };
+        }
+        const data = fetchResult.data;
+        api.logger.info(`[智小途-定时任务] 接口响应（尝试 ${fetchResult.attempts} 次）: ${JSON.stringify(data)}`);
+        if (data?.code === 200 || data?.code === 0) {
+            return { success: true, data, attempts: fetchResult.attempts };
+        }
+        else {
+            const errorMsg = data?.message || data?.msg || 'Unknown error';
+            api.logger.error(`[智小途-定时任务] 接口返回错误 ${errorMsg}`);
+            return { success: false, error: errorMsg };
+        }
+    }
+    catch (error) {
+        api.logger.error(`[智小途-定时任务] 接口调用异常 ${error.message}`);
+        return { success: false, error: error.message };
+    }
+}
+/**
+ * 调用新增定时任务接口
+ */
+export async function callCronJobAdd(api, accountId, payload) {
+    api.logger.info(`[智小途-定时任务] 新增定时任务 jobId=${payload.jobId} name=${payload.name}`);
+    const result = await callBackendApi(api, accountId, '/cron/job/add', {
+        clawJobId: payload.jobId,
+        name: payload.name,
+        kind: payload.kind,
+        expr: payload.expr || '',
+        message: payload.message,
+        agentId: payload.messageId || '0',
+    });
+    return { success: result.success, data: result.data, error: result.error };
+}
+/**
+ * 调用删除定时任务接口
+ */
+export async function callCronJobRemove(api, accountId, payload) {
+    api.logger.info(`[智小途-定时任务] 删除定时任务 jobId=${payload.jobId}`);
+    const result = await callBackendApi(api, accountId, '/cron/job/del', {
+        clawJobId: payload.jobId,
+    });
+    return { success: result.success, data: result.data, error: result.error };
+}
+/**
+ * 调用更新定时任务接口
+ */
+export async function callCronJobUpdate(api, accountId, payload) {
+    api.logger.info(`[智小途-定时任务] 更新定时任务 jobId=${payload.jobId} name=${payload.name} agentId=${payload.agentId}`);
+    const result = await callBackendApi(api, accountId, '/cron/job/update', {
+        clawJobId: payload.jobId,
+        name: payload.name,
+        kind: payload.kind,
+        expr: payload.expr || '',
+        message: payload.message,
+        agentId: payload.agentId || '0',
+    });
+    return { success: result.success, data: result.data, error: result.error };
+}
+/**
+ * 调用启用定时任务接口
+ */
+export async function callCronJobEnabled(api, accountId, payload) {
+    api.logger.info(`[智小途-定时任务] 启用定时任务 jobId=${payload.jobId}`);
+    const result = await callBackendApi(api, accountId, '/cron/job/enabled', {
+        clawJobId: payload.jobId,
+    });
+    return { success: result.success, data: result.data, error: result.error };
+}
+/**
+ * 调用禁用定时任务接口
+ */
+export async function callCronJobDisabled(api, accountId, payload) {
+    api.logger.info(`[智小途-定时任务] 禁用定时任务 jobId=${payload.jobId}`);
+    const result = await callBackendApi(api, accountId, '/cron/job/disabled', {
+        clawJobId: payload.jobId,
+    });
+    return { success: result.success, data: result.data, error: result.error };
+}
+/**
+ * 调用定时任务触发通知接口
+ */
+export async function callCronJobMessage(api, accountId, payload) {
+    api.logger.info(`[智小途-定时任务] 定时任务触发通知 jobId=${payload.jobId} message=${payload.message} agentId=${payload.agentId}`);
+    const result = await callBackendApi(api, accountId, '/cron/job/message', {
+        clawJobId: payload.jobId,
+        message: payload.message,
+        agentId: payload.agentId || '0',
+    });
+    return { success: result.success, data: result.data, error: result.error };
+}

package/dist/src/tools/openclaw-workclaw-cron/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 智小途定时任务工具 - 统一出口
+ *
+ * 提供统一的工具注册入口，一次性注册所有定时任务相关工具
+ */
+/**
+ * 统一注册所有定时任务工具
+ * @param api - OpenClaw API 实例
+ */
+export declare function registerAllOpenclawWorkclawCronTools(api: any): void;