@workclaw/openclaw-workclaw 1.0.202 → 1.0.332

package/dist/packages/plugin/src/gateway/skills-list-handler.js

@@ -0,0 +1,173 @@
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync, statSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import logger from "../logging.js";
+async function handleSkillsListEvent(event, baseUrl, token, log) {
+  const agentId = Number(event.agentId);
+  const userId = Number(event.userId);
+  logger.info(`技能列表: 处理 SKILLS_LIST 事件 agentId: ${agentId}, userId: ${userId}`);
+  try {
+    const skills = await fetchSkillsFromOpenClaw(agentId, userId, log);
+    const callbackPayload = {
+      userId,
+      agentId,
+      dataList: skills
+    };
+    const callbackUrl = `${baseUrl.replace(/\/$/, "")}/open-apis/v1/claw/push/skills`;
+    await sendSkillsListCallback(callbackUrl, callbackPayload, token, log);
+    logger.info(`技能列表: 成功处理 SKILLS_LIST 事件，发送了 ${skills.length} 个技能`);
+  } catch (error) {
+    logger.error(`技能列表: 处理 SKILLS_LIST 事件失败: ${String(error)}`);
+    throw error;
+  }
+}
+async function fetchSkillsFromOpenClaw(agentId, _userId, log) {
+  logger.info(`技能列表: 从 OpenClaw 获取技能列表 agentId: ${agentId}`);
+  try {
+    const result = execSync("openclaw skills list", {
+      encoding: "utf-8",
+      timeout: 3e4
+      // 30秒超时
+    });
+    const globalSkills = parseSkillsListOutput(result);
+    const agentWorkspaceSkills = await fetchAgentWorkspaceSkills(agentId, log);
+    const allSkills = mergeSkills(globalSkills, agentWorkspaceSkills);
+    logger.info(`技能列表: 找到 ${allSkills.length} 个技能 (${globalSkills.length} 个全局，${agentWorkspaceSkills.length} 个智能体专有)`);
+    return allSkills;
+  } catch (error) {
+    logger.error(`技能列表: 获取技能时出错: ${String(error)}`);
+    return [];
+  }
+}
+async function fetchAgentWorkspaceSkills(agentId, log) {
+  const skills = [];
+  try {
+    const agentWorkspace = join(homedir(), ".openclaw", "agents", `openclaw-workclaw-${agentId}`);
+    const skillsDir = join(agentWorkspace, "skills");
+    if (!existsSync(skillsDir)) {
+      logger.info(`技能列表: 智能体工作区中没有找到技能目录: ${skillsDir}`);
+      return skills;
+    }
+    const items = readdirSync(skillsDir);
+    for (const item of items) {
+      const itemPath = join(skillsDir, item);
+      const stat = statSync(itemPath);
+      if (stat.isDirectory()) {
+        const skillFiles = readdirSync(itemPath);
+        for (const skillFile of skillFiles) {
+          if (skillFile.endsWith(".md") || skillFile.endsWith(".prose")) {
+            const skillFilePath = join(itemPath, skillFile);
+            const skill = parseSkillFile(skillFilePath, item, log);
+            if (skill) {
+              skills.push(skill);
+            }
+          }
+        }
+      }
+    }
+    logger.info(`技能列表: 在 ${skillsDir} 中找到 ${skills.length} 个智能体专有技能`);
+  } catch (error) {
+    logger.error(`技能列表: 读取智能体工作区技能时出错: ${String(error)}`);
+  }
+  return skills;
+}
+function parseSkillFile(filePath, skillName, log) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    let description = "Agent-specific skill";
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if (line.startsWith("# ")) {
+        description = line.substring(2).trim();
+        break;
+      } else if (line.startsWith("summary:") || line.startsWith("Summary:")) {
+        description = line.substring(line.indexOf(":") + 1).trim();
+        break;
+      }
+    }
+    return {
+      typeStr: "skill",
+      name: skillName,
+      description
+    };
+  } catch (error) {
+    logger.error(`技能列表: 解析技能文件 ${filePath} 时出错: ${String(error)}`);
+    return null;
+  }
+}
+function mergeSkills(globalSkills, agentSkills) {
+  const skillMap = /* @__PURE__ */ new Map();
+  for (const skill of globalSkills) {
+    skillMap.set(skill.name, skill);
+  }
+  for (const skill of agentSkills) {
+    skillMap.set(skill.name, skill);
+  }
+  return Array.from(skillMap.values());
+}
+function parseSkillsListOutput(output) {
+  const skills = [];
+  const lines = output.split("\n");
+  let inTable = false;
+  let headerLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes("Status") && line.includes("Skill") && line.includes("Description")) {
+      headerLine = i;
+      inTable = true;
+      continue;
+    }
+    if (inTable && (line.startsWith("├") || line.startsWith("┌") || line.startsWith("└"))) {
+      continue;
+    }
+    if (inTable && line.startsWith("│") && i > headerLine + 1) {
+      const parsed = parseSkillsTableRow(line);
+      if (parsed) {
+        skills.push(parsed);
+      }
+    }
+    if (inTable && line.startsWith("└")) {
+      break;
+    }
+  }
+  return skills;
+}
+function parseSkillsTableRow(line) {
+  const content = line.replace(/^│\s*/, "").replace(/\s*│$/, "");
+  const columns = content.split("│").map((col) => col.trim());
+  if (columns.length < 4) {
+    return null;
+  }
+  const status = columns[0];
+  const skillName = columns[1];
+  const description = columns[2];
+  if (!status.includes("✓") && !status.includes("ready")) {
+    return null;
+  }
+  const cleanName = skillName.replace(/[\u{1F300}-\u{1F9FF}]/gu, "").trim();
+  return {
+    typeStr: "skill",
+    name: cleanName,
+    description
+  };
+}
+async function sendSkillsListCallback(callbackUrl, payload, token, log) {
+  logger.info(`技能列表: 发送回调到 ${callbackUrl}`);
+  const response = await fetch(callbackUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    throw new Error(`Callback failed: ${response.status} ${errorText}`);
+  }
+  logger.info(`技能列表: 回调发送成功`);
+}
+export {
+  handleSkillsListEvent
+};

package/dist/packages/plugin/src/gateway/tools-list-handler.js

@@ -0,0 +1,89 @@
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { fetch } from "undici";
+import logger from "../logging.js";
+const WORKCLAW_CRON_TOOLS = [
+  { typeStr: "function", name: "openclaw-workclaw-cron-add-params", description: "Generate the first-step cron parameters for creating a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-add-sync", description: "Sync a newly created reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-update-params", description: "Generate the first-step cron parameters for updating a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-update-sync", description: "Sync an updated reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-remove-params", description: "Generate the first-step parameters for removing a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-remove-sync", description: "Sync a removed reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-enable-params", description: "Generate the first-step parameters for enabling a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-enable-sync", description: "Sync an enabled reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-disable-params", description: "Generate the first-step parameters for disabling a Workclaw reminder." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-disable-sync", description: "Sync a disabled reminder job back to the Workclaw backend." },
+  { typeStr: "function", name: "openclaw-workclaw-cron-notify-sync", description: "Sync reminder trigger notifications back to the Workclaw backend." }
+];
+async function handleToolsListEvent(event, baseUrl, token, log) {
+  const agentId = Number(event.agentId);
+  const userId = Number(event.userId);
+  logger.info(`工具列表: 处理 TOOLS_LIST 事件，agentId: ${agentId}, userId: ${userId}`);
+  try {
+    const tools = await fetchToolsFromOpenClaw(agentId, userId, log);
+    const callbackPayload = {
+      userId,
+      agentId,
+      dataList: tools
+    };
+    const callbackUrl = `${baseUrl.replace(/\/$/, "")}/open-apis/v1/claw/push/tools`;
+    await sendToolsListCallback(callbackUrl, callbackPayload, token, log);
+    logger.info(`[智小途-工具列表] 成功处理 TOOLS_LIST 事件，发送了 ${tools.length} 个工具`);
+  } catch (error) {
+    logger.error(`[智小途-工具列表] 处理 TOOLS_LIST 事件失败: ${String(error)}`);
+    throw error;
+  }
+}
+async function fetchToolsFromOpenClaw(agentId, userId, log) {
+  logger.info(`工具列表: 从 OpenClaw 获取工具列表 agentId: ${agentId}`);
+  const allTools = [
+    { typeStr: "function", name: "web_search", description: "Search the web for information using Brave Search API." },
+    { typeStr: "function", name: "web_fetch", description: "Fetch and read content from a URL." },
+    { typeStr: "function", name: "sessions_list", description: "List all active agent sessions." },
+    { typeStr: "function", name: "sessions_history", description: "Get the history of a specific session." },
+    { typeStr: "function", name: "memory_search", description: "Search memory for past conversations and information." },
+    { typeStr: "function", name: "memory_get", description: "Get specific memory by ID." },
+    { typeStr: "function", name: "gateway", description: "Gateway control operations." },
+    { typeStr: "function", name: "exec", description: "Execute shell commands." },
+    ...WORKCLAW_CRON_TOOLS
+  ];
+  try {
+    const configPath = path.join(homedir(), ".openclaw", "openclaw.json");
+    const configContent = await readFile(configPath, "utf-8");
+    const config = JSON.parse(configContent);
+    const agentConfig = config.agents?.list?.find(
+      (agent) => String(agent.id) === String(agentId) || agent.id === `openclaw-workclaw-${agentId}`
+    );
+    const allowTools = agentConfig?.tools?.allow;
+    if (!allowTools || allowTools.length === 0 || allowTools.includes("*")) {
+      logger.info(`工具列表: 智能体没有 allow 限制或 allow=[*]，返回全部 ${allTools.length} 个工具`);
+      return allTools;
+    }
+    const filteredTools = allTools.filter((tool) => allowTools.includes(tool.name));
+    logger.info(`工具列表: 智能体 allow=${JSON.stringify(allowTools)}，返回 ${filteredTools.length} 个工具`);
+    return filteredTools;
+  } catch (error) {
+    logger.error(`工具列表: 读取智能体配置时出错: ${String(error)}，返回全部工具`);
+    return allTools;
+  }
+}
+async function sendToolsListCallback(callbackUrl, payload, token, log) {
+  logger.info(`工具列表: 发送回调到 ${callbackUrl}`);
+  const response = await fetch(callbackUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${token}`
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Callback failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  logger.info(`[智小途-工具列表] 回调发送成功: ${response.status}`);
+}
+export {
+  handleToolsListEvent
+};

package/dist/packages/plugin/src/gateway/workclaw-gateway.js

@@ -0,0 +1,245 @@
+import { buildAccountMap, resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { getAppKeyByAccountId, unregisterAccountContext, getAllDispatchersByAppKey, getWorkclawWsConnection, clearWorkclawWsConnection, getReconnectScheduler, clearReconnectScheduler, clearWorkclawConnectionConfig, registerAccountContext, tryStartConnecting, setReconnectScheduler, finishConnecting, setWorkclawConnectionConfig, getDispatcherByAppKeyAndAccountId } from "../../../../src/runtime.js";
+import logger from "../logging.js";
+import { parseWorkClawMessage } from "./message-context.js";
+import { dispatchWorkclawMessage } from "./message-dispatcher.js";
+import { createReconnectScheduler } from "./reconnect.js";
+async function startWorkclawGateway(options) {
+  await startSharedWebSocket(options);
+}
+function normalizeCronTaskEventToAgentMessageData(data, parsed) {
+  const cronData = parsed.eventData?.data ?? {};
+  const normalizedPayload = {
+    conversationId: null,
+    message: cronData.message ?? cronData.name ?? null,
+    agentId: cronData.mainId ?? cronData.agentIds?.[0] ?? null,
+    chatType: null,
+    sendTime: cronData.startTime ?? null,
+    userId: cronData.userId ?? null,
+    conversationType: null,
+    orgId: null,
+    fileId: null,
+    fileIds: null,
+    fileUrl: [],
+    taskId: cronData.taskId ?? null
+  };
+  let input = {};
+  try {
+    input = data ? JSON.parse(data) : {};
+  } catch {
+    input = {};
+  }
+  return JSON.stringify({
+    specVersion: input?.specVersion ?? "1.0",
+    type: "CALLBACK",
+    metadata: {
+      topic: "AGENT_MESSAGE",
+      time: input?.metadata?.time ?? `${Date.now()}`,
+      contentType: "application/json"
+    },
+    data: JSON.stringify(normalizedPayload)
+  });
+}
+async function startSharedWebSocket(options) {
+  const { accountId, account, cfg } = options;
+  logger.info(`[智小途-网关] 启动 accountId=${accountId}`);
+  const rawConfig = account.config;
+  const baseConfig = {
+    baseUrl: rawConfig.baseUrl,
+    websocketUrl: rawConfig.websocketUrl,
+    appKey: rawConfig.appKey,
+    appSecret: rawConfig.appSecret,
+    localIp: rawConfig.localIp,
+    allowInsecureTls: rawConfig.allowInsecureTls,
+    requestTimeout: rawConfig.requestTimeout,
+    dmPolicy: rawConfig.dmPolicy ?? "open"
+  };
+  const accountConfig = {
+    agentId: rawConfig.agentId,
+    userId: rawConfig.userId,
+    openConversationId: rawConfig.openConversationId
+  };
+  const appKey = baseConfig.appKey || accountId;
+  const appKeyRaw = baseConfig.appKey ?? "";
+  buildAccountMap(cfg);
+  logger.info(
+    `Gateway start accountId=${accountId} appKey=${appKeyRaw ? `${appKeyRaw.slice(0, 8)}...` : "missing"} baseUrl=${baseConfig.baseUrl ?? ""} websocketUrl=${baseConfig.websocketUrl ?? ""}`
+  );
+  const ctx = {
+    accountId,
+    account,
+    cfg,
+    baseConfig,
+    accountConfig,
+    log: logger,
+    scheduleReconnect: () => {
+      const scheduler2 = getReconnectScheduler(appKey);
+      scheduler2?.scheduleReconnect();
+    }
+  };
+  registerAccountContext(appKey, accountId, ctx);
+  const existingWs = getWorkclawWsConnection(appKey);
+  if (existingWs) {
+    logger.info(`Gateway using existing WebSocket for appKey=${appKey}`);
+    return;
+  }
+  const startResult = tryStartConnecting(appKey);
+  if (!startResult.isConnector) {
+    logger.info(`Gateway another account is connecting, waiting... appKey=${appKey}`);
+    const resultWs = await startResult.connectingPromise;
+    if (resultWs) {
+      logger.info(`Gateway connection established by another account, using it appKey=${appKey}`);
+      return;
+    }
+    logger.warn(`Gateway connection attempt failed, will create own connection appKey=${appKey}`);
+  } else {
+    logger.info(`Gateway acquired connector lock, creating connection appKey=${appKey}`);
+  }
+  const scheduler = createReconnectScheduler({
+    key: appKey,
+    config: baseConfig,
+    onMessage: (data) => {
+      handleSharedMessage(appKey, data, cfg, logger);
+    },
+    onClose: () => {
+      scheduler.scheduleReconnect();
+    },
+    // 旧代码在 setWorkclawWsConnection 后、ws.onopen 前就调用 finishConnecting，
+    // 这个回调模拟同样的时机：ws 已存入 runtime，通知所有等待者
+    onConnectingStarted: (ws) => {
+      finishConnecting(appKey, ws);
+    }
+  });
+  setReconnectScheduler(appKey, scheduler);
+  try {
+    await scheduler.connect();
+  } catch (err) {
+    finishConnecting(appKey);
+    throw err;
+  }
+  setWorkclawConnectionConfig(accountId, {
+    appKey: baseConfig.appKey ?? "",
+    appSecret: baseConfig.appSecret ?? "",
+    baseUrl: baseConfig.baseUrl,
+    websocketUrl: baseConfig.websocketUrl,
+    localIp: baseConfig.localIp,
+    allowInsecureTls: baseConfig.allowInsecureTls,
+    requestTimeout: baseConfig.requestTimeout
+  });
+}
+function handleSharedMessage(appKey, data, cfg, logger2) {
+  const parsed = parseWorkClawMessage(data);
+  logger2.info(`网关收到消息: ${JSON.stringify(parsed)}`);
+  if (!parsed) {
+    logger2.warn(`网关解析消息失败`);
+    return;
+  }
+  if (parsed.type === "ping") {
+    const ws = getWorkclawWsConnection(appKey);
+    if (ws && ws.readyState === 1) {
+      const pongResponse = {
+        code: 200,
+        message: "pong",
+        metadata: { contentType: "application/json" },
+        data: JSON.stringify(parsed.pongData)
+      };
+      ws.send(JSON.stringify(pongResponse));
+    }
+    return;
+  }
+  if (parsed.type === "disconnect") {
+    const ws = getWorkclawWsConnection(appKey);
+    ws?.close();
+    return;
+  }
+  let userId = "";
+  let agentId = "";
+  if (parsed.type === "agent_message" && parsed.message) {
+    userId = String(parsed.message.userId || "");
+    agentId = String(parsed.message.agentId || "");
+  } else if (parsed.type === "agent_created") {
+    const allDispatchers = getAllDispatchersByAppKey(appKey);
+    if (allDispatchers && allDispatchers.size > 0) {
+      const firstDispatcher = allDispatchers.values().next().value;
+      if (firstDispatcher) {
+        dispatchWorkclawMessage(data, firstDispatcher.ctx).catch((err) => {
+          logger2.error(`分发消息错误: ${String(err)}`);
+        });
+      }
+    }
+    return;
+  } else if (parsed.type === "agent_updated" || parsed.type === "agent_deleted") {
+    userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || "");
+  } else if (parsed.type === "tools_list") {
+    userId = String(parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.agentId || "");
+  } else if (parsed.type === "skills_list" || parsed.type === "skills_event") {
+    userId = String(parsed.eventData?.data?.userId || parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.data?.agentIds?.[0] || parsed.eventData?.data?.agentId || parsed.eventData?.agentId || "");
+  } else if (parsed.type === "init_agent") {
+    userId = String(parsed.eventData?.futureId || parsed.eventData?.userId || "");
+    agentId = String(parsed.eventData?.id || parsed.eventData?.agentId || "");
+    const accountId2 = "default";
+    const dispatcher2 = getDispatcherByAppKeyAndAccountId(appKey, accountId2);
+    if (dispatcher2) {
+      dispatchWorkclawMessage(data, dispatcher2.ctx).catch((err) => {
+        logger2.error(`分发消息错误: ${String(err)}`);
+      });
+    } else {
+      logger2.warn(`网关未找到账户 ${accountId2} 的调度器`);
+    }
+    return;
+  } else if (parsed.type === "cron_task_event") {
+    const userId2 = String(parsed.eventData.data.userId || "");
+    const agentId2 = String(parsed.eventData.data.mainId || "");
+    const accountId2 = resolveAccountByUserIdAndAgentId(cfg, userId2, agentId2);
+    const dispatcher2 = getDispatcherByAppKeyAndAccountId(appKey, accountId2);
+    let normalizedData = data;
+    if (parsed.eventData.dotype === "add") {
+      normalizedData = normalizeCronTaskEventToAgentMessageData(data, parsed);
+    }
+    if (dispatcher2) {
+      dispatchWorkclawMessage(normalizedData, dispatcher2.ctx).catch((err) => {
+        logger2.error(`分发消息错误: ${String(err)}`);
+      });
+    } else {
+      logger2.warn(`网关（按 appKey）未找到账户 ${accountId2} 的调度器`);
+    }
+    return;
+  } else {
+    return;
+  }
+  const accountId = resolveAccountByUserIdAndAgentId(cfg, userId, agentId);
+  if (!accountId) {
+    logger2.warn(`网关未找到账户: userId=${userId} agentId=${agentId}`);
+    return;
+  }
+  const dispatcher = getDispatcherByAppKeyAndAccountId(appKey, accountId);
+  if (dispatcher) {
+    dispatchWorkclawMessage(data, dispatcher.ctx).catch((err) => {
+      logger2.error(`分发消息错误: ${String(err)}`);
+    });
+  } else {
+    logger2.warn(`网关未找到账户 ${accountId} 的调度器`);
+  }
+}
+function stopWorkclawGateway(accountId) {
+  const appKey = getAppKeyByAccountId(accountId);
+  if (!appKey)
+    return;
+  unregisterAccountContext(appKey, accountId);
+  if (getAllDispatchersByAppKey(appKey)?.size === 0) {
+    const ws = getWorkclawWsConnection(appKey);
+    ws?.close();
+    clearWorkclawWsConnection(appKey);
+    const scheduler = getReconnectScheduler(appKey);
+    scheduler?.stopReconnect();
+    clearReconnectScheduler(appKey);
+  }
+  clearWorkclawConnectionConfig(accountId);
+}
+export {
+  startWorkclawGateway,
+  stopWorkclawGateway
+};

package/dist/packages/plugin/src/logging.js

@@ -0,0 +1,62 @@
+const LOG_LEVEL = {
+  // 测试环境
+  Test: "test",
+  // 生产环境
+  Production: "production"
+};
+function isLogLevel(value) {
+  return value === LOG_LEVEL.Test || value === LOG_LEVEL.Production;
+}
+class Logger {
+  logLevel = LOG_LEVEL.Production;
+  pluginApi = null;
+  /**
+   * 设置插件 API
+   *
+   * @param pluginApi - OpenClaw 插件 API
+   */
+  setApi(pluginApi) {
+    this.pluginApi = pluginApi;
+  }
+  /**
+   * 设置日志级别
+   *
+   * @param logLevel - 日志级别
+   */
+  setLevel(logLevel) {
+    this.logLevel = logLevel;
+  }
+  /**
+   * 记录信息日志（仅在 test 场景输出）
+   *
+   * @param message - 日志消息
+   */
+  info(message) {
+    if (this.logLevel === LOG_LEVEL.Production) {
+      return;
+    }
+    this.pluginApi?.logger?.info(message);
+  }
+  /**
+   * 记录警告日志（任何场景都输出）
+   *
+   * @param message - 日志消息
+   */
+  warn(message) {
+    this.pluginApi?.logger?.warn(message);
+  }
+  /**
+   * 记录错误日志（任何场景都输出）
+   *
+   * @param message - 日志消息
+   */
+  error(message) {
+    this.pluginApi?.logger?.error(message);
+  }
+}
+const logger = new Logger();
+export {
+  LOG_LEVEL,
+  logger as default,
+  isLogLevel
+};

package/dist/packages/plugin/src/media/upload.js

@@ -0,0 +1,126 @@
+import { stat, readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Agent, fetch } from "undici";
+function isLocalMediaSource(value) {
+  const trimmed = value.trim();
+  return trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("~") || trimmed.startsWith("file://");
+}
+function resolveLocalPath(input) {
+  if (input.startsWith("file://")) {
+    return fileURLToPath(input);
+  }
+  if (input.startsWith("~")) {
+    return path.join(os.homedir(), input.slice(1));
+  }
+  return path.resolve(input);
+}
+function readResponseUrlPath(data, pathValue) {
+  if (!pathValue)
+    return void 0;
+  const parts = pathValue.split(".").filter(Boolean);
+  let current = data;
+  for (const part of parts) {
+    if (!current || typeof current !== "object")
+      return void 0;
+    current = current[part];
+  }
+  return typeof current === "string" ? current : void 0;
+}
+function extractUploadedUrl(responseText, responseData, pathValue) {
+  const fromPath = readResponseUrlPath(responseData, pathValue);
+  if (fromPath)
+    return fromPath;
+  const direct = responseData.url ?? responseData.mediaUrl;
+  if (typeof direct === "string" && direct.trim())
+    return direct;
+  const dataObj = responseData.data;
+  if (dataObj && typeof dataObj === "object") {
+    const dataUrl = dataObj.url;
+    const dataMedia = dataObj.mediaUrl;
+    if (typeof dataUrl === "string" && dataUrl.trim())
+      return dataUrl;
+    if (typeof dataMedia === "string" && dataMedia.trim())
+      return dataMedia;
+  }
+  const resultObj = responseData.result;
+  if (resultObj && typeof resultObj === "object") {
+    const resultUrl = resultObj.url;
+    const resultMedia = resultObj.mediaUrl;
+    if (typeof resultUrl === "string" && resultUrl.trim())
+      return resultUrl;
+    if (typeof resultMedia === "string" && resultMedia.trim())
+      return resultMedia;
+  }
+  if (responseText.trim() && /^https?:\/\//i.test(responseText.trim())) {
+    return responseText.trim();
+  }
+  return void 0;
+}
+async function uploadLocalMedia(params) {
+  const stats = await stat(params.filePath);
+  if (!stats.isFile()) {
+    throw new Error(`mediaUrl is not a file: ${params.filePath}`);
+  }
+  const content = await readFile(params.filePath);
+  const form = new FormData();
+  const fieldName = params.uploadFieldName?.trim() || "file";
+  const fileName = path.basename(params.filePath);
+  form.set(fieldName, new Blob([content], { type: "application/octet-stream" }), fileName);
+  if (params.uploadFormFields) {
+    for (const [key, value] of Object.entries(params.uploadFormFields)) {
+      form.set(key, String(value));
+    }
+  }
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), params.requestTimeout);
+  let dispatcher;
+  let doFetch = globalThis.fetch.bind(globalThis);
+  if (params.allowInsecureTls) {
+    try {
+      dispatcher = new Agent({ connect: { rejectUnauthorized: false } });
+      doFetch = fetch;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`allowInsecureTls requires undici. ${message}`);
+    }
+  }
+  try {
+    const response = await doFetch(params.uploadUrl, {
+      method: "POST",
+      headers: params.uploadHeaders ?? {},
+      body: form,
+      signal: controller.signal,
+      ...dispatcher ? { dispatcher } : {}
+    });
+    const responseText = await response.text().catch(() => "");
+    if (!response.ok) {
+      throw new Error(`Upload failed: ${response.status} ${responseText}`);
+    }
+    let data = {};
+    if (responseText) {
+      try {
+        data = JSON.parse(responseText);
+      } catch {
+        data = {};
+      }
+    }
+    const uploadedUrl = extractUploadedUrl(
+      responseText,
+      data,
+      params.uploadResponseUrlPath
+    );
+    if (!uploadedUrl) {
+      throw new Error("Upload response missing file URL");
+    }
+    return uploadedUrl;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+export {
+  isLocalMediaSource,
+  resolveLocalPath,
+  uploadLocalMedia
+};