@workclaw/openclaw-workclaw 1.0.202 → 1.0.331

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
+};

package/dist/packages/plugin/src/outbound/index.js

@@ -0,0 +1,89 @@
+import { stat } from "node:fs/promises";
+import { resolveWorkclawAccountWithCache, resolveAccountByUserIdAndAgentId } from "../accounts.js";
+import { loadOpenConversationId } from "../gateway/config-writer.js";
+import { isLocalMediaSource, resolveLocalPath, uploadLocalMedia } from "../media/upload.js";
+import { setLastOutboundAt } from "../../../../src/runtime.js";
+import logger from "../logging.js";
+import { sendWorkclawOutboundMessage } from "./workclaw-sender.js";
+function findAccountIdByTarget(cfg, target, agentId) {
+  if (agentId !== void 0 && agentId !== null) {
+    return resolveAccountByUserIdAndAgentId(cfg, target, String(agentId)) ?? void 0;
+  }
+  return void 0;
+}
+async function resolveMediaUrl(mediaUrl, config) {
+  if (!mediaUrl)
+    return void 0;
+  if (!isLocalMediaSource(mediaUrl))
+    return mediaUrl;
+  const uploadUrl = config.uploadUrl;
+  if (!uploadUrl) {
+    throw new Error("uploadUrl not configured for local mediaUrl");
+  }
+  const filePath = resolveLocalPath(mediaUrl);
+  if (typeof config.mediaMaxMb === "number" && config.mediaMaxMb > 0) {
+    const stats = await stat(filePath);
+    const maxBytes = config.mediaMaxMb * 1024 * 1024;
+    if (stats.size > maxBytes) {
+      throw new Error(`mediaUrl exceeds limit (${config.mediaMaxMb} MB)`);
+    }
+  }
+  return uploadLocalMedia({
+    uploadUrl,
+    filePath,
+    uploadFieldName: config.uploadFieldName,
+    uploadHeaders: config.uploadHeaders,
+    uploadFormFields: config.uploadFormFields,
+    uploadResponseUrlPath: config.uploadResponseUrlPath,
+    requestTimeout: config.requestTimeout ?? 3e4,
+    allowInsecureTls: config.allowInsecureTls
+  });
+}
+async function sendMessageWorkclaw(params) {
+  const { cfg, to, text, mediaUrl, replyToMessageId, accountId, openConversationId, agentId, messageType, msgType, last } = params;
+  const resolvedMessageType = messageType ?? (replyToMessageId ? "reply" : "push");
+  let resolvedAccountId = accountId;
+  if (!resolvedAccountId) {
+    const foundAccountId = findAccountIdByTarget(cfg, to, agentId);
+    if (foundAccountId) {
+      resolvedAccountId = foundAccountId;
+    }
+  }
+  const account = resolveWorkclawAccountWithCache({ cfg, accountId: resolvedAccountId });
+  if (!account.configured) {
+    throw new Error(`Workclaw account "${account.accountId}" not configured`);
+  }
+  const resolvedMediaUrl = await resolveMediaUrl(mediaUrl, account.config);
+  const cfgChannel = cfg.channels?.["openclaw-workclaw"] ?? {};
+  const cfgAccounts = cfgChannel.accounts ?? {};
+  const cfgAccount = resolvedAccountId ? cfgAccounts[resolvedAccountId] ?? {} : {};
+  const cfgOpenConversationId = cfgAccount?.openConversationId ?? cfgChannel?.openConversationId;
+  const stateOpenConversationId = resolvedAccountId ? loadOpenConversationId(resolvedAccountId, to) : void 0;
+  const effectiveOpenConversationId = openConversationId ?? cfgOpenConversationId ?? stateOpenConversationId;
+  logger.info(`[发送] 来源=${params.source || "?"} 类型=${resolvedMessageType} 会话=${effectiveOpenConversationId || "(无)"} 回复消息ID=${replyToMessageId}`);
+  const tokenCacheKey = account.config.appKey || account.accountId;
+  const result = await sendWorkclawOutboundMessage({
+    cacheKey: tokenCacheKey,
+    to,
+    text,
+    msgType,
+    mediaUrl: resolvedMediaUrl,
+    replyToMessageId,
+    openConversationId: effectiveOpenConversationId,
+    agentId,
+    config: account.config,
+    messageType: resolvedMessageType,
+    last,
+    source: params.source
+  });
+  if (resolvedAccountId) {
+    setLastOutboundAt(resolvedAccountId, Date.now());
+  }
+  return {
+    messageId: result.messageId,
+    chatId: to
+  };
+}
+export {
+  sendMessageWorkclaw
+};

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

@@ -0,0 +1,79 @@
+import { resolveWorkclawMessage, sendWorkclawReplyMessage, sendWorkclawMessage } from "../connection/workclaw-client.js";
+import logger from "../logging.js";
+async function sendWorkclawOutboundMessage(params) {
+  const {
+    cacheKey,
+    to,
+    mediaUrl,
+    replyToMessageId,
+    openConversationId,
+    agentId,
+    config,
+    messageType = "reply",
+    last,
+    source
+  } = params;
+  let msgType = params.msgType;
+  let content = params.text;
+  const resolvedAgentId = agentId ?? config.agentId;
+  if (resolvedAgentId === void 0 || resolvedAgentId === null || String(resolvedAgentId).trim() === "") {
+    throw new Error(
+      "agentId is required for sending messages. Please create an account via cloud platform command or configure accounts in openclaw.json"
+    );
+  }
+  if (!msgType) {
+    ({ msgType, content } = resolveWorkclawMessage(content, mediaUrl));
+  }
+  const messageTypeCode = msgType === "text" ? "1" : msgType;
+  const workclawConfig = {
+    baseUrl: config.baseUrl ?? "",
+    appKey: config.appKey ?? "",
+    appSecret: config.appSecret ?? "",
+    localIp: config.localIp,
+    allowInsecureTls: config.allowInsecureTls,
+    requestTimeout: config.requestTimeout
+  };
+  const receiveId = config.userId ?? to;
+  const replyEndpoint = "/open-apis/im/v1/messages/{messageId}/reply";
+  const pushEndpoint = "/open-apis/im/v1/messages";
+  if (messageType === "reply") {
+    if (!replyToMessageId) {
+      throw new Error("replyToMessageId is required for reply message");
+    }
+    const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
+    const msgId = await sendWorkclawReplyMessage({
+      cacheKey,
+      config: workclawConfig,
+      agentId: resolvedAgentId,
+      receiveId,
+      msgType: messageTypeCode,
+      content,
+      messageId: replyToMessageId,
+      openConversationId: resolvedOpenConversationId,
+      endpoint: replyEndpoint.replace("{messageId}", String(replyToMessageId)),
+      last,
+      source
+    });
+    return { messageId: msgId };
+  } else {
+    logger.info(` 正在发送主动消息`);
+    const resolvedOpenConversationId = openConversationId ?? config.openConversationId;
+    logger.info(` 已解析的 openConversationId: ${resolvedOpenConversationId}`);
+    logger.info(` 配置中的 openConversationId: ${config.openConversationId}`);
+    const msgId = await sendWorkclawMessage({
+      cacheKey,
+      config: workclawConfig,
+      agentId: resolvedAgentId,
+      receiveId,
+      msgType: messageTypeCode,
+      content,
+      openConversationId: resolvedOpenConversationId,
+      endpoint: pushEndpoint,
+      last
+    });
+    return { messageId: msgId };
+  }
+}
+export {
+  sendWorkclawOutboundMessage
+};

package/dist/packages/plugin/src/setup-core.js

@@ -0,0 +1,22 @@
+import "node:path";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/utils-DGFSjtQF.js";
+import { t as DEFAULT_ACCOUNT_ID } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/account-id-C6v13Xic.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-helpers-ChrkNnYE.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-jRxy02_4.js";
+import "node:fs/promises";
+import { resolveDefaultWorkclawAccountId } from "./accounts.js";
+import { patchWorkclawConfig } from "./setup-surface.js";
+function setWorkclawNamedAccountEnabled(cfg, accountId, enabled) {
+  return patchWorkclawConfig(cfg, accountId, { enabled });
+}
+const workclawSetupAdapter = {
+  resolveAccountId: ({ cfg, accountId }) => accountId?.trim() || resolveDefaultWorkclawAccountId(cfg),
+  applyAccountConfig: ({ cfg, accountId }) => {
+    const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+    return patchWorkclawConfig(cfg, isDefault ? DEFAULT_ACCOUNT_ID : accountId, { enabled: true });
+  }
+};
+export {
+  setWorkclawNamedAccountEnabled,
+  workclawSetupAdapter
+};

package/dist/packages/plugin/src/setup-surface.js

@@ -0,0 +1,338 @@
+import { t as formatDocsLink } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/links-BlUEqVE8.js";
+import "node:path";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/utils-DGFSjtQF.js";
+import { t as DEFAULT_ACCOUNT_ID } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/account-id-C6v13Xic.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-helpers-ChrkNnYE.js";
+import { D as patchTopLevelChannelConfigSection } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/setup-wizard-helpers-DnMkYslk.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-jRxy02_4.js";
+import "node:fs/promises";
+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 void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+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
+  };
+}
+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;
+}
+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"),
+    "智小途配置"
+  );
+}
+async function promptWorkclawAppKey(params) {
+  return (await params.prompter.text({
+    message: "智小途 App Key",
+    initialValue: params.initialValue,
+    validate: (value) => value?.trim() ? void 0 : "App Key 不能为空"
+  })).trim();
+}
+async function promptWorkclawAppSecret(params) {
+  return (await params.prompter.text({
+    message: "智小途 App Secret",
+    initialValue: params.initialValue,
+    validate: (value) => value?.trim() ? void 0 : "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 void 0;
+    }
+  })).trim();
+}
+async function fetchAgentInfoByPhone(cfg, appKey, appSecret, phone, prompter) {
+  prompter.note?.("正在通过手机号获取配置信息...", "获取配置");
+  try {
+    const { authBaseUrl, openApiBaseUrl, allowInsecureTls, requestTimeout } = resolveSetupApiBases(cfg);
+    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;
+    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;
+  await noteWorkclawCredentialHelp(prompter);
+  const appKey = await promptWorkclawAppKey({
+    prompter,
+    initialValue: normalizeString(process.env.WORKCLAW_APP_KEY)
+  });
+  const appSecret = await promptWorkclawAppSecret({
+    prompter,
+    initialValue: normalizeString(process.env.WORKCLAW_APP_SECRET)
+  });
+  const phone = await promptWorkclawPhone({
+    prompter,
+    initialValue: normalizeString(process.env.WORKCLAW_PHONE)
+  });
+  next = patchWorkclawConfig(next, DEFAULT_ACCOUNT_ID, {
+    appKey,
+    appSecret,
+    enabled: true
+  });
+  const agentInfo = await fetchAgentInfoByPhone(next, appKey, appSecret, phone, prompter);
+  if (agentInfo) {
+    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);
+  }
+  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;
+}
+const workclawSetupWizard = {
+  channel,
+  resolveAccountIdForConfigure: ({ accountOverride, defaultAccountId, cfg }) => (typeof accountOverride === "string" && accountOverride.trim() ? accountOverride.trim() : void 0) ?? 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 });
+      if (result === null) {
+        return { cfg };
+      }
+      cfg = result.cfg;
+    } else {
+      cfg = (await runNewAppFlow({ cfg, prompter })).cfg;
+    }
+    await runProbeFlow({ cfg, prompter });
+    return { cfg };
+  },
+  disable: (cfg) => patchTopLevelChannelConfigSection({
+    cfg,
+    channel,
+    patch: { enabled: false }
+  })
+};
+export {
+  patchWorkclawConfig,
+  workclawSetupWizard
+};