@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/gateway/config-writer.js

@@ -0,0 +1,149 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { readFile, mkdir, writeFile, rename } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getWorkclawRuntime } from "../../../../src/runtime.js";
+function fixOwner(dir) {
+  if (process.platform === "win32")
+    return;
+  try {
+    execSync(`chown -R node:node "${dir}"`, { stdio: "ignore" });
+  } catch {
+  }
+}
+const STATE_DIR = join("workclaw", "data");
+const SAVE_THROTTLE_MS = 1e3;
+const lastSaveTimeMap = /* @__PURE__ */ new Map();
+function findStateDir() {
+  const stateDir = join(homedir(), ".openclaw");
+  return join(stateDir, STATE_DIR);
+}
+function getStateFilePath() {
+  return join(findStateDir(), "conversations.json");
+}
+async function writeConfigFile(newConfig, cfg, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    const configApi = runtime.config;
+    await configApi.writeConfigFile(newConfig);
+    log?.info?.(`[WriteConfig] Config written via runtime.config.writeConfigFile`);
+    Object.assign(cfg, newConfig);
+  } catch (err) {
+    log?.error?.(`[WriteConfig] Failed to write config: ${String(err)}`);
+    throw err;
+  }
+}
+function loadOpenConversationId(accountId, userId) {
+  const statePath = getStateFilePath();
+  const key = `${accountId}:${userId}`;
+  try {
+    if (!existsSync(statePath))
+      return null;
+    const content = readFileSync(statePath, "utf-8");
+    const state = JSON.parse(content);
+    return state[key]?.openConversationId ?? null;
+  } catch {
+    return null;
+  }
+}
+async function saveOpenConversationId(accountId, userId, openConversationId, cfg, log) {
+  const key = `${accountId}:${userId}`;
+  const workclawCfg = cfg?.channels?.["openclaw-workclaw"];
+  if (workclawCfg?.accounts?.[accountId]) {
+    workclawCfg.accounts[accountId].openConversationId = openConversationId;
+  }
+  const lastSaveTime = lastSaveTimeMap.get(key) ?? 0;
+  const now = Date.now();
+  if (now - lastSaveTime < SAVE_THROTTLE_MS) {
+    return;
+  }
+  await doSaveOpenConversationId(key, openConversationId, log);
+  lastSaveTimeMap.set(key, now);
+}
+async function doSaveOpenConversationId(key, openConversationId, log) {
+  try {
+    const statePath = getStateFilePath();
+    let state = {};
+    if (existsSync(statePath)) {
+      try {
+        const content = await readFile(statePath, "utf-8");
+        state = JSON.parse(content);
+      } catch (parseErr) {
+        log?.error?.(`SaveConversation: Failed to parse state file: ${String(parseErr)}`);
+      }
+    }
+    if (!state[key])
+      state[key] = {};
+    const existing = state[key].openConversationId;
+    if (existing === openConversationId && existing != null && existing !== "") {
+      return;
+    }
+    state[key].openConversationId = openConversationId;
+    const stateDir = findStateDir();
+    if (!existsSync(stateDir)) {
+      try {
+        await mkdir(stateDir, { recursive: true, mode: 493 });
+      } catch (mkdirErr) {
+        if (mkdirErr.code === "EACCES" || mkdirErr.code === "EPERM") {
+          await mkdir(stateDir, { recursive: true, mode: 511 });
+        } else {
+          throw mkdirErr;
+        }
+      }
+      fixOwner(stateDir);
+    }
+    const tmpPath = `${statePath}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(state, null, 2), "utf-8");
+    await rename(tmpPath, statePath);
+    log?.info?.(`SaveConversation: Saved openConversationId for key ${key}`);
+  } catch (err) {
+    log?.error?.(`SaveConversation: Failed to write state file: ${String(err)}`);
+  }
+}
+async function initWorkclawAgent(params, cfg, log) {
+  try {
+    const workclawCfg = cfg?.channels?.["openclaw-workclaw"];
+    if (!workclawCfg)
+      return;
+    if (params.apiKey) {
+      const existingApiKey = cfg.models?.providers?.["sophnet-minimax"]?.apiKey;
+      if (existingApiKey && typeof existingApiKey === "object" && existingApiKey.type) {
+        log?.info?.(`initWorkclawAgent: apiKey is SecretRef (type=${existingApiKey.type}), skipping overwrite`);
+      } else {
+        if (!cfg.models)
+          cfg.models = {};
+        if (!cfg.models.providers)
+          cfg.models.providers = {};
+        if (!cfg.models.providers["sophnet-minimax"])
+          cfg.models.providers["sophnet-minimax"] = {};
+        cfg.models.providers["sophnet-minimax"].apiKey = params.apiKey;
+        log?.info?.(`initWorkclawAgent: apiKey set (plain value)`);
+      }
+    }
+    if (params.agentId) {
+      const accountId = params.accountId || "default";
+      const accounts = workclawCfg.accounts ?? {};
+      workclawCfg.accounts = accounts;
+      if (!accounts[accountId])
+        accounts[accountId] = {};
+      accounts[accountId].agentId = params.agentId;
+      log?.info?.(`initWorkclawAgent: agentId=${params.agentId} set for ${accountId}`);
+    }
+    if (params.userId) {
+      workclawCfg.userId = params.userId;
+      log?.info?.(`initWorkclawAgent: userId=${params.userId} set`);
+    }
+    await writeConfigFile(cfg, cfg, log);
+    log?.info?.(`initWorkclawAgent: all config persisted`);
+  } catch (err) {
+    log?.error?.(`initWorkclawAgent: failed: ${String(err)}`);
+    throw err;
+  }
+}
+export {
+  initWorkclawAgent,
+  loadOpenConversationId,
+  saveOpenConversationId,
+  writeConfigFile
+};

package/dist/{cron-tasks-handler-C-mP3VmV.js → packages/plugin/src/gateway/cron-tasks-handler.js}

@@ -1,12 +1,36 @@
 import { exec } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import { promisify } from "node:util";
 const execAsync = promisify(exec);
+function resolvePreferredCliPathEnv() {
+  const defaultAliasPath = join(homedir(), ".nvm", "alias", "default");
+  if (!existsSync(defaultAliasPath))
+    return process.env;
+  try {
+    const defaultVersion = readFileSync(defaultAliasPath, "utf8").trim();
+    if (!defaultVersion)
+      return process.env;
+    const preferredBin = join(homedir(), ".nvm", "versions", "node", defaultVersion, "bin");
+    if (!existsSync(preferredBin))
+      return process.env;
+    const currentPath = process.env.PATH || "";
+    return {
+      ...process.env,
+      PATH: currentPath ? `${preferredBin}:${currentPath}` : preferredBin
+    };
+  } catch {
+    return process.env;
+  }
+}
 async function runCli(command, log, ignoreError = false) {
   log?.info?.(`[CLI] Executing: ${command}`);
   try {
     const { stdout, stderr } = await execAsync(command, {
       timeout: 6e4,
-      maxBuffer: 10 * 1024 * 1024
+      maxBuffer: 10 * 1024 * 1024,
+      env: resolvePreferredCliPathEnv()
     });
     if (stderr)
       log?.info?.(`[CLI] stderr: ${stderr}`);
@@ -53,12 +77,42 @@ async function sendTaskResult(url, token, taskData, status, log) {
     log?.error?.(`[Callback] Network error: ${String(err)}`);
   }
 }
-const buildCmd = (args) => args.map((a) => a && a.includes(" ") ? `"${a}"` : a).join(" ");
+function buildCmd(args) {
+  return args.map((a) => {
+    const cleaned = a?.replace(/\s+/g, " ").trim() || "";
+    return cleaned && cleaned.includes(" ") ? `"${cleaned}"` : cleaned;
+  }).join(" ");
+}
+function assertRequiredTaskFields(taskData) {
+  if (!String(taskData.name || "").trim())
+    throw new Error("taskData.name 不能为空");
+  if (!String(taskData.expr || "").trim())
+    throw new Error("taskData.expr 不能为空");
+}
 async function handleTaskCreate(taskData, token, url, log) {
   try {
-    const cmd = buildCmd(["openclaw", "cron", "add", "--name", taskData.name, "--cron", taskData.expr, "--command", 'echo "Task executed"']);
+    assertRequiredTaskFields(taskData);
+    const cmd = buildCmd(["openclaw", "cron", "add", "--name", taskData.name?.trim(), "--cron", taskData.expr?.trim(), "--message", taskData.name?.trim()]);
     const { stdout } = await runCli(cmd, log);
-    await sendTaskResult(url, token, taskData, { success: true, message: "创建成功" }, log);
+    const createdJob = JSON.parse(stdout);
+    const createdJobId = String(createdJob?.id || "").trim();
+    if (!createdJobId)
+      throw new Error("创建成功但未返回 jobId");
+    await sendTaskResult(url, token, taskData, {
+      success: true,
+      message: "创建成功",
+      dataListOverride: [{
+        messageId: 0,
+        clawJobId: createdJobId,
+        taskId: taskData.taskId,
+        name: taskData.name,
+        kind: "",
+        expr: taskData.expr,
+        message: "创建成功",
+        agentId: taskData.mainId,
+        nextRunAtMs: 0
+      }]
+    }, log);
   } catch (e) {
     await sendTaskResult(url, token, taskData, { success: false, message: `创建失败: ${e.message}` }, log);
     throw e;
@@ -73,9 +127,9 @@ async function handleTaskUpdate(taskData, token, url, log) {
     await new Promise((r) => setTimeout(r, 500));
     const args = ["openclaw", "cron", "edit", taskId];
     if (taskData.name)
-      args.push("--name", taskData.name);
+      args.push("--name", taskData.name.trim());
     if (taskData.expr)
-      args.push("--cron", taskData.expr);
+      args.push("--cron", taskData.expr.trim());
     await runCli(buildCmd(args), log);
     await runCli(`openclaw cron enable ${taskId}`, log, true);
     await sendTaskResult(url, token, taskData, { success: true, message: "更新成功" }, log);
@@ -126,6 +180,18 @@ async function handleTaskSearch(taskData, token, url, log) {
     throw e;
   }
 }
+async function handleTaskTrigger(taskData, token, url, log) {
+  const taskId = taskData.clawJobId;
+  if (!taskId)
+    throw new Error("clawJobId为空无法执行");
+  try {
+    await runCli(`openclaw cron run ${taskId}`, log);
+    await sendTaskResult(url, token, taskData, { success: true, message: "执行成功" }, log);
+  } catch (e) {
+    await sendTaskResult(url, token, taskData, { success: false, message: `执行失败: ${e.message}` }, log);
+    throw e;
+  }
+}
 async function handleCronTaskEvent(backendEvent, token, baseUrl, appKey, log) {
   const taskData = backendEvent.data;
   const callbackUrl = `${baseUrl}/open-apis/v1/claw/do/cron/result`;
@@ -143,6 +209,9 @@ async function handleCronTaskEvent(backendEvent, token, baseUrl, appKey, log) {
     case "search":
       await handleTaskSearch(taskData, token, callbackUrl, log);
       break;
+    case "trigger":
+      await handleTaskTrigger(taskData, token, callbackUrl, log);
+      break;
     default:
       log?.warn?.(`Unknown dotype: ${taskData.dotype}`);
   }

package/dist/packages/plugin/src/gateway/message-context.js

@@ -0,0 +1,408 @@
+import fs from "node:fs/promises";
+import http from "node:http";
+import https from "node:https";
+import os from "node:os";
+import path from "node:path";
+const OPENCLAW_WORKCLAW_CHANNEL = "openclaw-workclaw";
+function parseWorkClawMessage(data, log) {
+  let input = {};
+  try {
+    input = data ? JSON.parse(data) : {};
+  } catch {
+    log?.info?.(`Failed to parse message data=${data}`);
+    return null;
+  }
+  if (typeof input === "string" && input.toLowerCase() === "ping") {
+    return {
+      type: "ping",
+      pongData: input
+    };
+  }
+  const envelope = input && typeof input === "object" ? input : { data: input };
+  const topic = envelope?.metadata?.topic;
+  const type = String(envelope?.type || "").trim().toUpperCase();
+  const topicLower = String(topic || "").trim().toLowerCase();
+  if (type === "INIT_AGENT") {
+    let parsedData = envelope?.data;
+    if (typeof parsedData === "string") {
+      try {
+        parsedData = JSON.parse(parsedData);
+      } catch (e) {
+      }
+    }
+    return {
+      type: "init_agent",
+      eventData: parsedData
+    };
+  }
+  if (type === "SYSTEM") {
+    if (topicLower === "ping") {
+      return {
+        type: "ping",
+        pongData: envelope?.data
+      };
+    }
+    if (topicLower === "disconnect") {
+      return {
+        type: "disconnect"
+      };
+    }
+    return {
+      type: "ignored"
+    };
+  }
+  if (type === "EVENT") {
+    const eventType = String(envelope?.metadata?.event || "").trim().toUpperCase();
+    let parsedData = envelope?.data;
+    if (typeof parsedData === "string") {
+      try {
+        parsedData = JSON.parse(parsedData);
+      } catch (e) {
+      }
+    }
+    if (eventType === "AGENT_CREATED") {
+      return {
+        type: "agent_created",
+        eventData: parsedData
+      };
+    }
+    if (eventType === "AGENT_UPDATED") {
+      return {
+        type: "agent_updated",
+        eventData: parsedData
+      };
+    }
+    if (eventType === "AGENT_DELETED") {
+      return {
+        type: "agent_deleted",
+        eventData: parsedData
+      };
+    }
+    if (eventType === "TOOLS_LIST") {
+      return {
+        type: "tools_list",
+        eventData: parsedData
+      };
+    }
+    if (eventType === "SKILLS_LIST") {
+      return {
+        type: "skills_list",
+        eventData: parsedData
+      };
+    }
+    if (eventType === "INIT_AGENT") {
+      return {
+        type: "init_agent",
+        eventData: parsedData
+      };
+    }
+    if (eventType === "SKILL_DO_REMIND") {
+      const eventTopic = String(parsedData?.dotype || "").toLowerCase();
+      return {
+        type: "skills_event",
+        eventData: {
+          topic: `skills/${eventTopic}`,
+          requestId: "",
+          callbackUrl: "",
+          authToken: "",
+          data: parsedData
+        }
+      };
+    }
+    if (eventType === "CRON_REMIND") {
+      const eventTopic = String(parsedData?.dotype || "").toLowerCase();
+      return {
+        type: "cron_task_event",
+        cronTaskEvent: {
+          dotype: `${eventTopic}`,
+          data: parsedData
+        }
+      };
+    }
+    return {
+      type: "ignored"
+    };
+  }
+  if (type !== "CALLBACK" || String(topic || "").trim().toUpperCase() !== "AGENT_MESSAGE") {
+    return {
+      type: "ignored"
+    };
+  }
+  let payload = envelope?.data || {};
+  if (typeof payload === "string") {
+    try {
+      payload = JSON.parse(payload);
+    } catch (e) {
+    }
+  }
+  const text = typeof payload?.message?.content === "string" ? payload.message.content : typeof payload?.message === "string" ? payload.message : "";
+  function isImageFile(url) {
+    const imageExtensions = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp", ".svg", ".ico"];
+    const lowerUrl = url.toLowerCase();
+    return imageExtensions.some((ext) => lowerUrl.endsWith(ext));
+  }
+  const fileUrlList = Array.isArray(payload?.fileUrl) ? payload.fileUrl : [];
+  const attachments = fileUrlList.map((url) => ({
+    url,
+    fileId: payload?.fileId ? String(payload.fileId) : "",
+    type: isImageFile(url) ? "image" : "file"
+  }));
+  return {
+    type: "agent_message",
+    message: {
+      text,
+      userId: String(payload?.userId ?? ""),
+      openConversationId: String(payload?.conversationId ?? ""),
+      messageId: String(payload?.msgId ?? ""),
+      agentId: payload?.agentId,
+      attachments: attachments.length > 0 ? attachments : void 0
+    }
+  };
+}
+function detectMediaType(url) {
+  const lower = url.toLowerCase();
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg") || lower.endsWith(".png") || lower.endsWith(".gif") || lower.endsWith(".webp") || lower.endsWith(".bmp") || lower.endsWith(".svg") || lower.endsWith(".ico")) {
+    return "image";
+  }
+  if (lower.endsWith(".mp3") || lower.endsWith(".wav") || lower.endsWith(".amr") || lower.endsWith(".m4a") || lower.endsWith(".ogg")) {
+    return "audio";
+  }
+  if (lower.endsWith(".mp4") || lower.endsWith(".avi") || lower.endsWith(".mov") || lower.endsWith(".mkv") || lower.endsWith(".webm")) {
+    return "video";
+  }
+  if (lower.endsWith(".pdf"))
+    return "application/pdf";
+  if (lower.endsWith(".docx"))
+    return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+  if (lower.endsWith(".xlsx"))
+    return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+  if (lower.endsWith(".pptx"))
+    return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+  if (lower.endsWith(".doc"))
+    return "application/msword";
+  if (lower.endsWith(".xls"))
+    return "application/vnd.ms-excel";
+  if (lower.endsWith(".ppt"))
+    return "application/vnd.ms-powerpoint";
+  if (lower.endsWith(".txt"))
+    return "text/plain";
+  if (lower.endsWith(".zip"))
+    return "application/zip";
+  if (lower.endsWith(".rar"))
+    return "application/x-rar-compressed";
+  return "application/octet-stream";
+}
+function getMediaTypeLabel(url) {
+  const lower = url.toLowerCase();
+  if (lower.endsWith(".pdf"))
+    return "PDF";
+  if (lower.endsWith(".docx"))
+    return "Word";
+  if (lower.endsWith(".doc"))
+    return "Word";
+  if (lower.endsWith(".xlsx"))
+    return "Excel";
+  if (lower.endsWith(".xls"))
+    return "Excel";
+  if (lower.endsWith(".pptx"))
+    return "PowerPoint";
+  if (lower.endsWith(".ppt"))
+    return "PowerPoint";
+  if (lower.endsWith(".txt"))
+    return "文本";
+  if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+    return "JPG图片";
+  if (lower.endsWith(".png"))
+    return "PNG图片";
+  if (lower.endsWith(".gif"))
+    return "GIF图片";
+  if (lower.endsWith(".webp"))
+    return "WebP图片";
+  if (lower.endsWith(".mp3"))
+    return "音频";
+  if (lower.endsWith(".wav"))
+    return "音频";
+  if (lower.endsWith(".mp4"))
+    return "视频";
+  if (lower.endsWith(".zip") || lower.endsWith(".rar"))
+    return "压缩包";
+  return "文件";
+}
+async function downloadFileToLocal(url, accountId, peerId, log) {
+  const downloadsDir = path.join(os.homedir(), ".openclaw", "media", "workclaw", "downloads", accountId, peerId);
+  try {
+    await fs.mkdir(downloadsDir, { recursive: true });
+  } catch {
+  }
+  const urlObj = new URL(url);
+  const fileName = decodeURIComponent(path.basename(urlObj.pathname)) || "file";
+  const ext = path.extname(fileName);
+  const stem = path.basename(fileName, ext);
+  const localFileName = `${stem}_${Date.now()}${ext}`;
+  const localFilePath = path.join(downloadsDir, localFileName);
+  return new Promise((resolve) => {
+    const client = url.startsWith("https:") ? https : http;
+    const req = client.get(url, (res) => {
+      if (res.statusCode !== 200) {
+        log?.warn?.(`downloadFile: HTTP ${res.statusCode} for ${url}`);
+        resolve(null);
+        return;
+      }
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", async () => {
+        try {
+          const buffer = Buffer.concat(chunks);
+          await fs.writeFile(localFilePath, buffer);
+          log?.info?.(`downloadFile: saved ${buffer.length} bytes -> ${localFilePath}`);
+          resolve(localFilePath);
+        } catch (err) {
+          log?.error?.(`downloadFile: write failed: ${String(err)}`);
+          resolve(null);
+        }
+      });
+      res.on("error", (err) => {
+        log?.error?.(`downloadFile: read error: ${String(err)}`);
+        resolve(null);
+      });
+    });
+    req.on("error", (err) => {
+      log?.error?.(`downloadFile: request error: ${String(err)}`);
+      resolve(null);
+    });
+    req.setTimeout(3e4, () => {
+      req.destroy();
+      log?.warn?.(`downloadFile: timeout for ${url}`);
+      resolve(null);
+    });
+  });
+}
+async function buildInboundContext(message, accountId, config, agentId, pluginRuntime, recordSession = true, log) {
+  let existingSessionKey;
+  try {
+    const rawPayload = JSON.parse(message.rawPayload);
+    existingSessionKey = rawPayload.sessionKey;
+  } catch {
+  }
+  const peerId = message.from;
+  const computedSessionKey = existingSessionKey || (agentId && agentId !== "main" ? `agent:${agentId}:openclaw-workclaw:${accountId}:direct:${peerId}` : void 0);
+  const sessionKey = computedSessionKey || (agentId && agentId !== "main" ? `agent:${agentId}:openclaw-workclaw:${accountId}:direct:${peerId}` : void 0);
+  const result = {
+    Body: message.text,
+    BodyForAgent: message.text,
+    RawBody: JSON.stringify(message),
+    From: message.from,
+    To: message.to,
+    ChatType: message.chatType,
+    Provider: OPENCLAW_WORKCLAW_CHANNEL,
+    Surface: OPENCLAW_WORKCLAW_CHANNEL,
+    Timestamp: message.timestamp,
+    AccountId: accountId,
+    AgentId: agentId,
+    MessageSid: message.messageId,
+    OriginatingChannel: OPENCLAW_WORKCLAW_CHANNEL,
+    OriginatingTo: message.to
+  };
+  if (sessionKey) {
+    result.SessionKey = sessionKey;
+  }
+  if (!pluginRuntime) {
+    return result;
+  }
+  const storePath = pluginRuntime.channel.session.resolveStorePath(config.session?.store, { agentId });
+  log?.info?.(`[Session] storePath=${storePath}, agentId=${agentId}, sessionKey=${sessionKey}`);
+  const envelopeOptions = pluginRuntime.channel.reply.resolveEnvelopeFormatOptions(config);
+  const previousTimestamp = pluginRuntime.channel.session.readSessionUpdatedAt({
+    storePath,
+    sessionKey
+  });
+  log?.info?.(`[Session] previousTimestamp=${previousTimestamp}`);
+  const mediaUrls = [];
+  const mediaTypes = [];
+  const bodyText = message.text;
+  if (message.attachments && message.attachments.length > 0) {
+    log?.info?.(`[Attachments] Downloading ${message.attachments.length} files...`);
+    const downloadResults = await Promise.all(
+      message.attachments.map(async (att) => {
+        const localPath = await downloadFileToLocal(att.url, accountId, message.from, log);
+        const mediaType = detectMediaType(att.url);
+        const typeLabel = getMediaTypeLabel(att.url);
+        return { att, localPath, mediaType, typeLabel };
+      })
+    );
+    for (const { att, localPath, mediaType } of downloadResults) {
+      if (localPath) {
+        const homeDir = os.homedir().replace(/\\/g, "/").trim();
+        const normalizedLocalPath = localPath.replace(/\\/g, "/");
+        const relativePath = normalizedLocalPath.startsWith(`${homeDir}/.openclaw/`) ? `/${normalizedLocalPath.slice(homeDir.length + 1)}` : normalizedLocalPath;
+        mediaUrls.push(relativePath);
+        mediaTypes.push(mediaType);
+        log?.info?.(`[Attachments] Downloaded: ${relativePath}`);
+      } else {
+        log?.warn?.(`[Attachments] Failed to download: ${att.url}`);
+      }
+    }
+    log?.info?.(`[Attachments] Downloaded ${mediaUrls.length}/${message.attachments.length} files`);
+  }
+  const fromLabel = message.to;
+  const body = pluginRuntime.channel.reply.formatInboundEnvelope({
+    channel: OPENCLAW_WORKCLAW_CHANNEL,
+    from: fromLabel,
+    timestamp: message.timestamp,
+    body: bodyText,
+    chatType: message.chatType,
+    sender: { name: message.to, id: message.to },
+    previousTimestamp,
+    envelope: envelopeOptions
+  });
+  const finalized = pluginRuntime.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: bodyText,
+    RawBody: JSON.stringify(message),
+    CommandBody: message.text,
+    From: message.from,
+    To: message.to,
+    SessionKey: sessionKey,
+    AccountId: accountId,
+    ChatType: message.chatType,
+    ConversationLabel: fromLabel,
+    Provider: OPENCLAW_WORKCLAW_CHANNEL,
+    Surface: "openclaw-workclaw_dm",
+    MessageSid: message.messageId,
+    Timestamp: message.timestamp,
+    OriginatingChannel: OPENCLAW_WORKCLAW_CHANNEL,
+    OriginatingTo: message.to,
+    // 附件媒体信息（供 skill 读取本地文件）
+    MediaPath: mediaUrls[0] || void 0,
+    MediaUrl: mediaUrls[0] || void 0,
+    MediaUrls: mediaUrls.length > 0 ? mediaUrls : void 0,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : void 0
+  });
+  if (sessionKey && recordSession) {
+    try {
+      await pluginRuntime.channel.session.recordInboundSession({
+        storePath,
+        sessionKey: finalized.SessionKey || sessionKey,
+        ctx: finalized,
+        updateLastRoute: {
+          sessionKey,
+          channel: OPENCLAW_WORKCLAW_CHANNEL,
+          to: message.to,
+          accountId
+        },
+        onRecordError: (err) => {
+          log?.error?.(`[Session] recordInboundSession failed: ${String(err)}`);
+        }
+      });
+      log?.info?.(`[Session] Recorded session for key=${sessionKey}`);
+    } catch (err) {
+      log?.warn?.(`[Session] recordInboundSession error: ${String(err)}`);
+    }
+  }
+  return finalized;
+}
+export {
+  OPENCLAW_WORKCLAW_CHANNEL,
+  buildInboundContext,
+  parseWorkClawMessage
+};