@workclaw/openclaw-workclaw 1.0.30 → 1.0.33

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/update/params.js

@@ -0,0 +1,140 @@
+import { validateTimeFormat, isCronExpression, relativeToCron } from "../../utils/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const UpdateParamsSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    time: {
+      type: "string",
+      description: "⏰ 时间（核心！），支持相对时间和 cron 表达式，工具自动转换"
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    message: {
+      type: "string",
+      description: "提醒内容"
+    }
+  },
+  required: ["jobId", "time", "name", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronUpdateParamsTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-update-params",
+    label: "智小途生成修改提醒参数",
+    description: `【核心工具】生成修改提醒的 cronParams 参数。
+
+📋 工作流程（必须按顺序执行）：
+1. 调用此工具获取 cronParams 参数
+2. 使用返回的 cronParams 调用 OpenClaw 的 cron 工具
+3. 必须调用 openclaw-workclaw-cron-update-sync 同步到后端
+
+⏰ 时间格式（核心！）：
+- time 参数支持相对时间（如 "10m"、"1h"、"2d"）和 cron 表达式
+- 工具会自动将所有时间统一转换为 cron 表达式
+- 严禁使用 --at 参数或其他绝对时间格式
+- 最终 CLI 命令必须使用 --cron 参数
+
+🔒 强制规则：
+- schedule.kind 必须是 "cron"
+- 必须使用 --cron 参数传递 cron 表达式
+
+⚠️ 必须从 cron 工具返回值中确认更新成功`,
+    parameters: UpdateParamsSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-生成修改参数] 开始处理 jobId=${p.jobId} name=${p.name} time=${p.time}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-生成修改参数] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      if (!p.time) {
+        api.logger.warn("[智小途-生成修改参数] 缺少时间参数");
+        return json({ error: "time（时间）为必填参数" });
+      }
+      if (!p.name) {
+        api.logger.warn("[智小途-生成修改参数] 缺少任务名称参数");
+        return json({ error: "name（任务名称）为必填参数" });
+      }
+      if (!p.message) {
+        api.logger.warn("[智小途-生成修改参数] 缺少提醒内容参数");
+        return json({ error: "message（提醒内容）为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const name = p.name;
+      const message = p.message;
+      const time = p.time;
+      if (!accountId) {
+        api.logger.warn("[智小途-生成修改参数] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      api.logger.info(`[智小途-生成修改参数] accountId=${accountId} jobId=${p.jobId}`);
+      const timeValidation = validateTimeFormat(time);
+      if (!timeValidation.valid) {
+        api.logger.warn(`[智小途-生成修改参数] 时间格式校验失败: ${timeValidation.error}`);
+        return json({ error: timeValidation.error });
+      }
+      const isCron = isCronExpression(time);
+      let isOneTime = false;
+      let cronExpr;
+      if (!isCron) {
+        isOneTime = true;
+        cronExpr = relativeToCron(time.trim());
+        api.logger.info(`[智小途-生成修改参数] 相对时间转换为绝对时间 cron 表达式 cronExpr=${cronExpr}`);
+      } else {
+        cronExpr = time.trim();
+      }
+      const cronParams = {
+        action: "update",
+        account: accountId,
+        jobId: p.jobId,
+        job: {
+          name,
+          schedule: {
+            kind: "cron",
+            expr: cronExpr,
+            tz: "Asia/Shanghai"
+          },
+          sessionTarget: "isolated",
+          wakeMode: "now",
+          deleteAfterRun: isOneTime ? true : void 0,
+          payload: {
+            kind: "agentTurn",
+            message
+          },
+          delivery: {
+            mode: "announce",
+            channel: "openclaw-workclaw"
+          }
+        }
+      };
+      api.logger.info(`[智小途-生成修改参数] 构建 cron 参数 cronParams=${JSON.stringify(cronParams)}`);
+      return json({
+        cronParams,
+        meta: {
+          accountId,
+          jobId: p.jobId,
+          name,
+          kind: "cron",
+          expr: cronExpr,
+          message
+        },
+        summary: `✅ 提醒已修改: "${name}" (${time})`
+      });
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronUpdateParamsTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/src/update/sync.js

@@ -0,0 +1,113 @@
+import { resolveWorkclawAccountWithCache } from "../../../../accounts.js";
+import { callCronJobUpdate } from "../../api/index.js";
+import { resolveCronToolExecutionContext } from "../../utils/tool-context.js";
+const UpdateSyncSchema = {
+  type: "object",
+  properties: {
+    jobId: {
+      type: "string",
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`
+    },
+    name: {
+      type: "string",
+      description: "任务名称"
+    },
+    kind: {
+      type: "string",
+      description: "任务类型（仅支持 cron）",
+      enum: ["cron"]
+    },
+    expr: {
+      type: "string",
+      description: "Cron 表达式（kind=cron 时必填）"
+    },
+    message: {
+      type: "string",
+      description: "提醒消息"
+    }
+  },
+  required: ["jobId", "name", "kind", "message"]
+};
+function json(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    details: data
+  };
+}
+function registerOpenclawWorkclawCronUpdateSyncTool(api) {
+  api.registerTool({
+    name: "openclaw-workclaw-cron-update-sync",
+    label: "智小途同步修改提醒",
+    description: "将修改定时任务同步到后端。在 cron 工具修改任务后调用此工具同步后端。",
+    parameters: UpdateSyncSchema,
+    execute: async (toolCallId, params) => {
+      const p = params;
+      const ctx = resolveCronToolExecutionContext(toolCallId);
+      api.logger.info(`[智小途-同步修改] 开始同步 jobId=${p.jobId} name=${p.name}`);
+      if (!p.jobId) {
+        api.logger.warn("[智小途-同步修改] 缺少 jobId 参数");
+        return json({ error: "jobId 为必填参数" });
+      }
+      if (!p.name) {
+        api.logger.warn("[智小途-同步修改] 缺少 name 参数");
+        return json({ error: "name 为必填参数" });
+      }
+      if (!p.message) {
+        api.logger.warn("[智小途-同步修改] 缺少 message 参数");
+        return json({ error: "message 为必填参数" });
+      }
+      const accountId = ctx?.agentAccountId;
+      const channelUserId = ctx?.From;
+      if (!accountId) {
+        api.logger.warn("[智小途-同步修改] 无法获取账户 ID");
+        return json({ error: "无法获取账户 ID（accountId），请确保已配置账户" });
+      }
+      const accountConfig = resolveWorkclawAccountWithCache({
+        cfg: ctx.config,
+        accountId
+      });
+      const channelAgentId = accountConfig.configured ? String(accountConfig.config.agentId) : "0";
+      api.logger.info(`[智小途-同步修改] accountId=${accountId} channelUserId=${channelUserId} channelAgentId=${channelAgentId}`);
+      try {
+        const result = await callCronJobUpdate(api, accountId, {
+          jobId: p.jobId,
+          name: p.name,
+          kind: p.kind,
+          expr: p.expr,
+          message: p.message,
+          agentId: channelAgentId
+        });
+        if (result.success) {
+          api.logger.info(`[智小途-同步修改] 后端同步成功 jobId=${p.jobId}`);
+          return json({
+            code: 0,
+            message: "定时任务已修改并同步到后端",
+            data: {
+              jobId: p.jobId,
+              name: p.name,
+              message: p.message,
+              backendSynced: true
+            }
+          });
+        } else {
+          api.logger.error(`[智小途-同步修改] 后端同步失败 ${result.error}`);
+          return json({
+            code: -1,
+            error: result.error || "后端同步失败",
+            data: { jobId: p.jobId, name: p.name }
+          });
+        }
+      } catch (error) {
+        api.logger.error(`[智小途-同步修改] 后端同步异常 ${error.message}`);
+        return json({
+          code: -1,
+          error: error.message,
+          data: { jobId: p.jobId, name: p.name }
+        });
+      }
+    }
+  });
+}
+export {
+  registerOpenclawWorkclawCronUpdateSyncTool
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/utils/index.js

@@ -0,0 +1,99 @@
+function parseRelativeTime(timeStr) {
+  const s = timeStr.trim().toLowerCase();
+  if (/^\d+$/.test(s)) {
+    return Number.parseInt(s, 10) * 6e4;
+  }
+  let totalMs = 0;
+  let matched = false;
+  const regex = /(\d+(?:\.\d+)?)\s*([dhms])/g;
+  let match;
+  while ((match = regex.exec(s)) !== null) {
+    matched = true;
+    const value = Number.parseFloat(match[1]);
+    const unit = match[2];
+    switch (unit) {
+      case "d":
+        totalMs += value * 864e5;
+        break;
+      case "h":
+        totalMs += value * 36e5;
+        break;
+      case "m":
+        totalMs += value * 6e4;
+        break;
+      case "s":
+        totalMs += value * 1e3;
+        break;
+    }
+  }
+  return matched ? Math.round(totalMs) : null;
+}
+function isCronExpression(timeStr) {
+  const parts = timeStr.trim().split(/\s+/);
+  return parts.length >= 3 && parts.length <= 6;
+}
+function validateCronExpression(timeStr) {
+  const parts = timeStr.trim().split(/\s+/);
+  if (parts.length < 3 || parts.length > 6) {
+    return { valid: false, error: `无效的 cron 表达式：字段数量不正确（期望 3-6 个字段，实际 ${parts.length} 个）` };
+  }
+  const patterns = [
+    /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
+    /^(\*|[0-5]?\d(-[0-5]?\d)?(\/[0-5]?\d)?|L(-[0-5]?\d)?|W?)$/,
+    /^(\*|[01]?\d|2[0-3](-[01]?\d|2[0-3])?(\/\d|[01]?\d|2[0-3])?|L(-[01]?\d|2[0-3])?|W)?$/,
+    /^(\*|1[0-2]|0?[1-9](-[1-9]|0?[1-9])?(\/[1-9]|0?[1-9])?|L(-1[0-2]|0?[1-9])?|W)?$/,
+    /^([*LW]|[0-6](-[0-6])?(\/[0-6])?|L-[0-6])?$/,
+    /^(\*|L|(\*\/)?\d{1,2})?$/
+  ];
+  const fieldNames = ["秒", "分钟", "小时", "日期", "月份", "星期"];
+  for (let i = 0; i < parts.length && i < patterns.length; i++) {
+    const part = parts[i].trim();
+    const offset = parts.length - patterns.length;
+    if (i < offset)
+      continue;
+    if (!patterns[i].test(part)) {
+      return { valid: false, error: `无效的 cron 表达式：${fieldNames[i]}字段 "${part}" 格式不正确` };
+    }
+  }
+  return { valid: true };
+}
+function validateTimeFormat(timeStr) {
+  if (!timeStr || typeof timeStr !== "string" || timeStr.trim() === "") {
+    return { valid: false, error: "时间参数不能为空" };
+  }
+  const trimmed = timeStr.trim();
+  if (trimmed.startsWith("+") || /^\d+$/.test(trimmed) || /^\d+[dhms]/.test(trimmed)) {
+    const relativeMs = parseRelativeTime(trimmed);
+    if (relativeMs === null) {
+      return { valid: false, error: `无法解析相对时间 "${trimmed}"，支持的格式：5m、1h、1h30m、2d、30s 等` };
+    }
+    if (relativeMs < 3e4) {
+      return { valid: false, error: "提醒时间不能少于 30 秒" };
+    }
+    return { valid: true };
+  }
+  if (isCronExpression(trimmed)) {
+    return validateCronExpression(trimmed);
+  }
+  return { valid: false, error: `无法解析时间 "${trimmed}"，请使用相对时间（如 5m、1h）或 cron 表达式（如 0 8 * * *）` };
+}
+function relativeToCron(timeStr) {
+  const delayMs = parseRelativeTime(timeStr);
+  if (delayMs === null) {
+    return timeStr;
+  }
+  const futureTime = new Date(Date.now() + delayMs);
+  const seconds = futureTime.getSeconds();
+  const minutes = futureTime.getMinutes();
+  const hours = futureTime.getHours();
+  const dayOfMonth = futureTime.getDate();
+  const month = futureTime.getMonth() + 1;
+  return `${seconds} ${minutes} ${hours} ${dayOfMonth} ${month} *`;
+}
+export {
+  isCronExpression,
+  parseRelativeTime,
+  relativeToCron,
+  validateCronExpression,
+  validateTimeFormat
+};

package/dist/packages/plugin/src/tools/openclaw-workclaw-cron/utils/tool-context.js

@@ -0,0 +1,28 @@
+import { getRunIdByToolCallId, getToolContext, getWorkclawRuntime } from "../../../../../../src/runtime.js";
+function resolveCronToolExecutionContext(toolCallId) {
+  let toolCtx;
+  try {
+    const runId = getRunIdByToolCallId(toolCallId);
+    toolCtx = runId ? getToolContext(runId) : void 0;
+  } catch (e) {
+  }
+  const config = getWorkclawRuntime().config.loadConfig();
+  let agentAccountId = "default";
+  if (config?.bindings && Array.isArray(config.bindings) && config.bindings.length > 0) {
+    const matchedBinding = config.bindings.find((b) => b.agentId === toolCtx?.agentId);
+    if (matchedBinding?.match?.accountId) {
+      agentAccountId = matchedBinding.match.accountId;
+    } else if (config.bindings[0]?.match?.accountId) {
+      agentAccountId = config.bindings[0].match.accountId;
+    }
+  }
+  return {
+    agentAccountId,
+    agentId: toolCtx?.agentId,
+    From: toolCtx?.target,
+    config
+  };
+}
+export {
+  resolveCronToolExecutionContext
+};

package/dist/setup-entry.js

@@ -1,171 +1,4 @@
-import { n as normalizeLowercaseStringOrEmpty, o as openBoundaryFileSync, r as resolvePluginLoaderJitiConfig, c as createJiti, b as buildPluginLoaderJitiOptions, a as resolveLoaderPackageRoot } from "./jiti-4i2h0FGP.js";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-import fs from "node:fs";
-import path from "node:path";
-const nodeRequire = createRequire(import.meta.url);
-const jitiLoaders = /* @__PURE__ */ new Map();
-const loadedModuleExports = /* @__PURE__ */ new Map();
-const disableBundledEntrySourceFallbackEnv = "OPENCLAW_DISABLE_BUNDLED_ENTRY_SOURCE_FALLBACK";
-function isTruthyEnvFlag(value) {
-  return value !== void 0 && !/^(?:0|false)$/iu.test(value.trim());
-}
-function resolveSpecifierCandidates(modulePath) {
-  const ext = normalizeLowercaseStringOrEmpty(path.extname(modulePath));
-  if (ext === ".js") return [modulePath, modulePath.slice(0, -3) + ".ts"];
-  if (ext === ".mjs") return [modulePath, modulePath.slice(0, -4) + ".mts"];
-  if (ext === ".cjs") return [modulePath, modulePath.slice(0, -4) + ".cts"];
-  return [modulePath];
-}
-function resolveEntryBoundaryRoot(importMetaUrl) {
-  return path.dirname(fileURLToPath(importMetaUrl));
-}
-function addBundledEntryCandidates(candidates, basePath, boundaryRoot) {
-  for (const candidate of resolveSpecifierCandidates(basePath)) {
-    if (candidates.some((entry) => entry.path === candidate && entry.boundaryRoot === boundaryRoot)) continue;
-    candidates.push({
-      path: candidate,
-      boundaryRoot
-    });
-  }
-}
-function resolveBundledEntryModuleCandidates(importMetaUrl, specifier) {
-  const importerPath = fileURLToPath(importMetaUrl);
-  const importerDir = path.dirname(importerPath);
-  const boundaryRoot = resolveEntryBoundaryRoot(importMetaUrl);
-  const candidates = [];
-  addBundledEntryCandidates(candidates, path.resolve(importerDir, specifier), boundaryRoot);
-  const sourceRelativeSpecifier = specifier.replace(/^\.\/src\//u, "./");
-  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path.resolve(importerDir, sourceRelativeSpecifier), boundaryRoot);
-  const packageRoot = resolveLoaderPackageRoot({
-    modulePath: importerPath,
-    moduleUrl: importMetaUrl,
-    cwd: importerDir,
-    argv1: process.argv[1]
-  });
-  if (!packageRoot) return candidates;
-  const distExtensionsRoot = path.join(packageRoot, "dist", "extensions") + path.sep;
-  if (!importerPath.startsWith(distExtensionsRoot)) return candidates;
-  if (isTruthyEnvFlag(process.env[disableBundledEntrySourceFallbackEnv])) return candidates;
-  const pluginDirName = path.basename(importerDir);
-  const sourcePluginRoot = path.join(packageRoot, "extensions", pluginDirName);
-  if (sourcePluginRoot === boundaryRoot) return candidates;
-  addBundledEntryCandidates(candidates, path.resolve(sourcePluginRoot, specifier), sourcePluginRoot);
-  if (sourceRelativeSpecifier !== specifier) addBundledEntryCandidates(candidates, path.resolve(sourcePluginRoot, sourceRelativeSpecifier), sourcePluginRoot);
-  return candidates;
-}
-function formatBundledEntryUnknownError(error) {
-  if (typeof error === "string") return error;
-  if (error === void 0) return "boundary validation failed";
-  try {
-    return JSON.stringify(error);
-  } catch {
-    return "non-serializable error";
-  }
-}
-function formatBundledEntryModuleOpenFailure(params) {
-  const importerPath = fileURLToPath(params.importMetaUrl);
-  const errorDetail = params.failure.error instanceof Error ? params.failure.error.message : formatBundledEntryUnknownError(params.failure.error);
-  return [
-    `bundled plugin entry "${params.specifier}" failed to open`,
-    `from "${importerPath}"`,
-    `(resolved "${params.resolvedPath}", plugin root "${params.boundaryRoot}",`,
-    `reason "${params.failure.reason}"): ${errorDetail}`
-  ].join(" ");
-}
-function resolveBundledEntryModulePath(importMetaUrl, specifier) {
-  const candidates = resolveBundledEntryModuleCandidates(importMetaUrl, specifier);
-  const fallbackCandidate = candidates[0] ?? {
-    path: path.resolve(path.dirname(fileURLToPath(importMetaUrl)), specifier),
-    boundaryRoot: resolveEntryBoundaryRoot(importMetaUrl)
-  };
-  let firstFailure = null;
-  for (const candidate of candidates) {
-    const opened = openBoundaryFileSync({
-      absolutePath: candidate.path,
-      rootPath: candidate.boundaryRoot,
-      boundaryLabel: "plugin root",
-      rejectHardlinks: false,
-      skipLexicalRootCheck: true
-    });
-    if (opened.ok) {
-      fs.closeSync(opened.fd);
-      return opened.path;
-    }
-    firstFailure ??= {
-      candidate,
-      failure: opened
-    };
-  }
-  const failure = firstFailure;
-  if (!failure) throw new Error(formatBundledEntryModuleOpenFailure({
-    importMetaUrl,
-    specifier,
-    resolvedPath: fallbackCandidate.path,
-    boundaryRoot: fallbackCandidate.boundaryRoot,
-    failure: {
-      ok: false,
-      reason: "path",
-      error: /* @__PURE__ */ new Error(`ENOENT: no such file or directory, lstat '${fallbackCandidate.path}'`)
-    }
-  }));
-  throw new Error(formatBundledEntryModuleOpenFailure({
-    importMetaUrl,
-    specifier,
-    resolvedPath: failure.candidate.path,
-    boundaryRoot: failure.candidate.boundaryRoot,
-    failure: failure.failure
-  }));
-}
-function getJiti(modulePath) {
-  const { tryNative, aliasMap, cacheKey } = resolvePluginLoaderJitiConfig({
-    modulePath,
-    argv1: process.argv[1],
-    moduleUrl: import.meta.url,
-    preferBuiltDist: true
-  });
-  const cached = jitiLoaders.get(cacheKey);
-  if (cached) return cached;
-  const loader = createJiti(import.meta.url, {
-    ...buildPluginLoaderJitiOptions(aliasMap),
-    tryNative
-  });
-  jitiLoaders.set(cacheKey, loader);
-  return loader;
-}
-function loadBundledEntryModuleSync(importMetaUrl, specifier) {
-  const modulePath = resolveBundledEntryModulePath(importMetaUrl, specifier);
-  const cached = loadedModuleExports.get(modulePath);
-  if (cached !== void 0) return cached;
-  let loaded;
-  if (process.platform === "win32" && modulePath.includes(`${path.sep}dist${path.sep}`) && [
-    ".js",
-    ".mjs",
-    ".cjs"
-  ].includes(normalizeLowercaseStringOrEmpty(path.extname(modulePath)))) try {
-    loaded = nodeRequire(modulePath);
-  } catch {
-    loaded = getJiti(modulePath)(modulePath);
-  }
-  else loaded = getJiti(modulePath)(modulePath);
-  loadedModuleExports.set(modulePath, loaded);
-  return loaded;
-}
-function loadBundledEntryExportSync(importMetaUrl, reference) {
-  const loaded = loadBundledEntryModuleSync(importMetaUrl, reference.specifier);
-  const resolved = loaded && typeof loaded === "object" && "default" in loaded ? loaded.default : loaded;
-  if (!reference.exportName) return resolved;
-  const record = resolved ?? loaded;
-  if (!record || !(reference.exportName in record)) throw new Error(`missing export "${reference.exportName}" from bundled entry module ${reference.specifier}`);
-  return record[reference.exportName];
-}
-function defineBundledChannelSetupEntry({ importMetaUrl, plugin, secrets }) {
-  return {
-    kind: "bundled-channel-setup-entry",
-    loadSetupPlugin: () => loadBundledEntryExportSync(importMetaUrl, plugin),
-    ...secrets ? { loadSetupSecrets: () => loadBundledEntryExportSync(importMetaUrl, secrets) } : {}
-  };
-}
+import { n as defineBundledChannelSetupEntry } from "./node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/channel-entry-contract-BoTfqLnn.js";
 const setupEntry = defineBundledChannelSetupEntry({
   importMetaUrl: import.meta.url,
   plugin: {

package/dist/src/api/accounts-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"accounts-api.d.ts","sourceRoot":"","sources":["../../../src/api/accounts-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AA+D5D,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,iBAAiB,IAC/C,KAAK,GAAG,EAAE,KAAK,GAAG,mBA2FjC"}
+{"version":3,"file":"accounts-api.d.ts","sourceRoot":"","sources":["../../../src/api/accounts-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAgE5D,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,iBAAiB,IAC/C,KAAK,GAAG,EAAE,KAAK,GAAG,mBA2FjC"}

package/dist/src/api/prompts-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prompts-api.d.ts","sourceRoot":"","sources":["../../../src/api/prompts-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AA2B5D,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,iBAAiB,IAC9C,KAAK,GAAG,EAAE,KAAK,GAAG,mBAiFjC"}
+{"version":3,"file":"prompts-api.d.ts","sourceRoot":"","sources":["../../../src/api/prompts-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AA4B5D,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,iBAAiB,IAC9C,KAAK,GAAG,EAAE,KAAK,GAAG,mBAiFjC"}

package/dist/src/api/workspace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../src/api/workspace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAK5D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAsBlE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAgBlE"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../../src/api/workspace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAA;AAK5D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,iBAAiB,GAAG,MAAM,CAuBlE;AAED,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,iBAAiB,GAAG,OAAO,CAgBlE"}

package/dist/src/config-schema.d.ts

@@ -1,88 +1,6 @@
 import { z } from 'zod';
 export { z };
-export declare const workclawAccountConfigSchema: z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    name: z.ZodOptional<z.ZodString>;
-    agentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    userId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    openConversationId: z.ZodOptional<z.ZodString>;
-    dmPolicy: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-    }>>;
-    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-    allowInsecureTls: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-export declare const WorkclawConfigSchema: z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    baseUrl: z.ZodOptional<z.ZodString>;
-    websocketUrl: z.ZodOptional<z.ZodString>;
-    appKey: z.ZodOptional<z.ZodString>;
-    appSecret: z.ZodOptional<z.ZodString>;
-    agentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    localIp: z.ZodOptional<z.ZodString>;
-    userId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    requestTimeout: z.ZodOptional<z.ZodNumber>;
-    allowInsecureTls: z.ZodOptional<z.ZodBoolean>;
-    allowRawJsonPayload: z.ZodOptional<z.ZodBoolean>;
-    uploadUrl: z.ZodOptional<z.ZodString>;
-    uploadFieldName: z.ZodOptional<z.ZodString>;
-    uploadHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    uploadFormFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-    uploadResponseUrlPath: z.ZodOptional<z.ZodString>;
-    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        open: "open";
-    }>>>;
-    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        name: z.ZodOptional<z.ZodString>;
-        agentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        userId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        openConversationId: z.ZodOptional<z.ZodString>;
-        dmPolicy: z.ZodOptional<z.ZodEnum<{
-            open: "open";
-        }>>;
-        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-        mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-        allowInsecureTls: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>>>;
-}, z.core.$strict>;
-export declare const workclawConfigSchema: z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    baseUrl: z.ZodOptional<z.ZodString>;
-    websocketUrl: z.ZodOptional<z.ZodString>;
-    appKey: z.ZodOptional<z.ZodString>;
-    appSecret: z.ZodOptional<z.ZodString>;
-    agentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    localIp: z.ZodOptional<z.ZodString>;
-    userId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-    requestTimeout: z.ZodOptional<z.ZodNumber>;
-    allowInsecureTls: z.ZodOptional<z.ZodBoolean>;
-    allowRawJsonPayload: z.ZodOptional<z.ZodBoolean>;
-    uploadUrl: z.ZodOptional<z.ZodString>;
-    uploadFieldName: z.ZodOptional<z.ZodString>;
-    uploadHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    uploadFormFields: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-    uploadResponseUrlPath: z.ZodOptional<z.ZodString>;
-    dmPolicy: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
-        open: "open";
-    }>>>;
-    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        name: z.ZodOptional<z.ZodString>;
-        agentId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        userId: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
-        openConversationId: z.ZodOptional<z.ZodString>;
-        dmPolicy: z.ZodOptional<z.ZodEnum<{
-            open: "open";
-        }>>;
-        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
-        mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-        allowInsecureTls: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strict>>>>;
-}, z.core.$strict>;
+export declare const workclawAccountConfigSchema: any;
+export declare const WorkclawConfigSchema: any;
+export declare const workclawConfigSchema: any;
 //# sourceMappingURL=config-schema.d.ts.map

package/dist/src/config-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../../src/config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,CAAC,EAAE,CAAA;AAIZ,eAAO,MAAM,2BAA2B;;;;;;;;;;;;kBAY7B,CAAA;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAqC7B,CAAA;AAEJ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAuB,CAAA"}
+{"version":3,"file":"config-schema.d.ts","sourceRoot":"","sources":["../../src/config-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,CAAC,EAAE,CAAA;AAIZ,eAAO,MAAM,2BAA2B,KAY7B,CAAA;AAEX,eAAO,MAAM,oBAAoB,KAqC7B,CAAA;AAEJ,eAAO,MAAM,oBAAoB,KAAuB,CAAA"}

package/dist/src/gateway/cron-tasks-handler.d.ts

@@ -1,11 +1,12 @@
 export interface ParsedTaskData {
     clawJobId?: string | null;
     agentIds: string[];
-    dotype: 'add' | 'remove' | 'edit' | 'search';
+    dotype: 'add' | 'remove' | 'edit' | 'search' | 'trigger';
     name: string;
     expr: string;
     mainId: string;
     userId: string;
+    taskId: string;
 }
 interface Logger {
     info?: (msg: string) => void;