@workclaw/openclaw-workclaw 1.0.32 → 1.0.33

package/dist/packages/plugin/src/api/session-api.js

@@ -0,0 +1,174 @@
+import { getWorkclawRuntime } from "../../../../src/runtime.js";
+function sendJson(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+async function readRequestBody(req) {
+  const chunks = [];
+  await new Promise((resolve, reject) => {
+    req.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on("end", () => resolve());
+    req.on("error", (err) => reject(err));
+  });
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function buildSessionKey(accountId, userId) {
+  return `openclaw-workclaw:${accountId}:${userId}`;
+}
+function parseSessionKey(sessionKey) {
+  const parts = sessionKey.split(":");
+  if (parts.length !== 3 || parts[0] !== "openclaw-workclaw") {
+    return null;
+  }
+  return {
+    channel: parts[0],
+    accountId: parts[1],
+    userId: parts[2]
+  };
+}
+async function resetSession(sessionKey, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    runtime.system.enqueueSystemEvent("/new", {
+      sessionKey,
+      contextKey: null
+    });
+    log?.info?.(`[SessionAPI] Sent /new command to session: ${sessionKey}`);
+    return {
+      success: true,
+      message: `Session reset command sent to ${sessionKey}`
+    };
+  } catch (err) {
+    const errorMsg = `Failed to reset session: ${String(err)}`;
+    log?.error?.(`[SessionAPI] ${errorMsg}`);
+    return { success: false, message: errorMsg };
+  }
+}
+function getSessionStorePath(agentId, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    const storePath = runtime.channel.session.resolveStorePath(void 0, {
+      agentId
+    });
+    return storePath;
+  } catch (err) {
+    log?.error?.(`[SessionAPI] Failed to resolve store path: ${String(err)}`);
+    return null;
+  }
+}
+async function getSessionLastUpdated(sessionKey, log) {
+  try {
+    const runtime = getWorkclawRuntime();
+    const storePath = runtime.channel.session.resolveStorePath();
+    const updatedAt = runtime.channel.session.readSessionUpdatedAt({
+      storePath,
+      sessionKey
+    });
+    return updatedAt ?? null;
+  } catch (err) {
+    log?.error?.(`[SessionAPI] Failed to read session updated at: ${String(err)}`);
+    return null;
+  }
+}
+function createSessionApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "", "http://localhost");
+    const fullPath = url.pathname.replace(/\/+$/, "");
+    const subPath = fullPath.replace(/^\/openclaw-workclaw\/sessions/, "").replace(/^\//, "") || "/";
+    const log = {
+      info: (msg) => api.logger?.info?.(`[SessionAPI] ${msg}`),
+      error: (msg) => api.logger?.error?.(`[SessionAPI] ${msg}`)
+    };
+    log?.info?.(`[SessionAPI] ${method} ${fullPath} (subPath: ${subPath})`);
+    if (method === "GET" && (subPath === "/" || subPath === "")) {
+      const sessionKey = url.searchParams.get("sessionKey");
+      if (sessionKey) {
+        const parsed = parseSessionKey(sessionKey);
+        const updatedAt = await getSessionLastUpdated(sessionKey, log);
+        sendJson(res, 200, {
+          ok: true,
+          session: {
+            sessionKey,
+            parsed,
+            lastUpdatedAt: updatedAt,
+            lastUpdatedAtFormatted: updatedAt ? new Date(updatedAt).toISOString() : null
+          }
+        });
+        return;
+      }
+      sendJson(res, 200, {
+        ok: true,
+        message: "Session Management API",
+        endpoints: {
+          "GET /sessions": "获取会话信息 (可选参数: sessionKey)",
+          "POST /sessions/reset": "重置/开启新会话 (参数: accountId + userId 或直接提供 sessionKey)",
+          "GET /sessions/store-path": "获取会话存储路径 (可选参数: agentId)"
+        }
+      });
+      return;
+    }
+    if (method === "POST" && subPath === "reset") {
+      const raw = await readRequestBody(req);
+      let input = {};
+      try {
+        input = raw ? JSON.parse(raw) : {};
+      } catch {
+        sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      const { accountId, userId, sessionKey: directSessionKey } = input;
+      let sessionKey;
+      if (directSessionKey) {
+        sessionKey = directSessionKey;
+      } else if (accountId && userId) {
+        sessionKey = buildSessionKey(accountId, userId);
+      } else {
+        sendJson(res, 400, {
+          ok: false,
+          error: "Missing required fields: either provide 'sessionKey' or both 'accountId' and 'userId'"
+        });
+        return;
+      }
+      const result = await resetSession(sessionKey, log);
+      if (result.success) {
+        sendJson(res, 200, {
+          ok: true,
+          message: result.message,
+          sessionKey
+        });
+      } else {
+        sendJson(res, 500, {
+          ok: false,
+          error: result.message,
+          sessionKey
+        });
+      }
+      return;
+    }
+    if (method === "GET" && subPath === "store-path") {
+      const agentId = url.searchParams.get("agentId") ?? void 0;
+      const storePath = getSessionStorePath(agentId, log);
+      if (storePath) {
+        sendJson(res, 200, {
+          ok: true,
+          storePath,
+          agentId: agentId ?? "default"
+        });
+      } else {
+        sendJson(res, 500, {
+          ok: false,
+          error: "Failed to resolve session store path"
+        });
+      }
+      return;
+    }
+    sendJson(res, 404, { ok: false, error: "Not Found" });
+  };
+}
+export {
+  createSessionApiHandler
+};

package/dist/packages/plugin/src/api/skills-api.js

@@ -0,0 +1,60 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+const execAsync = promisify(exec);
+function sendJson(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function createSkillsApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    if (method === "GET") {
+      try {
+        const { stdout, stderr } = await execAsync("openclaw skills list --json", {
+          timeout: 1e4
+          // 10秒超时
+        });
+        if (stderr && !stdout) {
+          api.logger.error(`Skills list error: ${stderr}`);
+          sendJson(res, 500, { ok: false, error: "Failed to list skills" });
+          return;
+        }
+        let skillsData;
+        try {
+          skillsData = JSON.parse(stdout);
+        } catch {
+          const lines = stdout.split("\n");
+          const skills = lines.filter((line) => line.trim() && !line.includes("Skills")).map((line) => {
+            const parts = line.split(/\s{2,}/).map((p) => p.trim());
+            if (parts.length >= 3) {
+              return {
+                status: parts[0]?.includes("✓") ? "ready" : "missing",
+                name: parts[1],
+                description: parts[2],
+                source: parts[3] || "openclaw-bundled"
+              };
+            }
+            return null;
+          }).filter((s) => s !== null);
+          skillsData = {
+            total: skills.length,
+            ready: skills.filter((s) => s.status === "ready").length,
+            missing: skills.filter((s) => s.status === "missing").length,
+            skills
+          };
+        }
+        sendJson(res, 200, { ok: true, ...skillsData });
+        return;
+      } catch (error) {
+        api.logger.error(`Skills API error: ${error.message}`);
+        sendJson(res, 500, { ok: false, error: error.message });
+        return;
+      }
+    }
+    sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+  };
+}
+export {
+  createSkillsApiHandler
+};

package/dist/packages/plugin/src/api/workspace.js

@@ -0,0 +1,30 @@
+import os from "node:os";
+import path from "node:path";
+import { getWorkclawLogger } from "../../../../src/runtime.js";
+function resolveWorkspaceDir(api) {
+  const agents = api.config.agents?.list ?? [];
+  const defaultAgent = agents.find((agent) => agent?.default === true) ?? agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
+  const workspaceRaw = typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim() || typeof api.config.agents?.defaults?.workspace === "string" && api.config.agents.defaults.workspace.trim();
+  getWorkclawLogger().info(`workspaceRaw: ${workspaceRaw}`);
+  if (workspaceRaw) {
+    const resolved = api.resolvePath(workspaceRaw);
+    if (resolved)
+      return resolved;
+  }
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  const suffix = profile && profile.toLowerCase() !== "default" ? `workspace-${profile}` : "workspace";
+  return path.join(os.homedir(), ".openclaw", suffix);
+}
+function isDefaultWorkspace(api) {
+  const agents = api.config.agents?.list ?? [];
+  const defaultAgent = agents.find((agent) => agent?.default === true) ?? agents.find((agent) => String(agent?.id ?? "").toLowerCase() === "main");
+  const workspaceRaw = typeof defaultAgent?.workspace === "string" && defaultAgent.workspace.trim() || typeof api.config.agents?.defaults?.workspace === "string" && api.config.agents.defaults.workspace.trim();
+  if (workspaceRaw)
+    return false;
+  const profile = process.env.OPENCLAW_PROFILE?.trim();
+  return !profile || profile.toLowerCase() === "default";
+}
+export {
+  isDefaultWorkspace,
+  resolveWorkspaceDir
+};

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

@@ -0,0 +1,214 @@
+import { appendFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+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/zod-schema.core-BrzjtZhM.js";
+import { r as buildChannelConfigSchema } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/config-schema-DB8FqQH8.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/zod-schema.agent-runtime-D48J52r_.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/zod-schema.providers-core-CX8AFeyJ.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/zod-schema.providers-whatsapp-7E9bf9oA.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/subsystem-BHv2zSx6.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/paths-LCYGfrV7.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/utils-DGFSjtQF.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/ip-CdfoCORt.js";
+import "node:net";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/mime-BjR-Aw-Q.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/tmp-openclaw-dir-DrKSsX71.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/exec-jRxy02_4.js";
+import "node:fs/promises";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-dir-Cq5y_NKM.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/bundled-Cuj8sKt6.js";
+import "node:crypto";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/logger-BMuqDP66.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/theme-CVJvORNs.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/workspace-oVBetctb.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/ids-By7Nkc8R.js";
+import { n as formatPairingApproveHint } from "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/helpers-CI2CkXhU.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/tailscale-status-Ch1LdrMM.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/redact-D4nea1HF.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/manager-szyCqvou.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/io-DDkf_FUu.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/registry-DE4nHTjg.js";
+import "../../../node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/dist/runtime-Clo2XF6T.js";
+import { isWorkclawAccountConfigured, resolveWorkclawAccount, listWorkclawAccountIds } from "./accounts.js";
+import { WorkclawConfigSchema } from "./config-schema.js";
+import { stopWorkclawGateway, startWorkclawGateway } from "./gateway/workclaw-gateway.js";
+import { sendMessageWorkclaw } from "./outbound/index.js";
+import { getWorkclawWsConnection, getLastInboundAt, getLastOutboundAt, getWorkclawRuntime } from "../../../src/runtime.js";
+const meta = {
+  id: "openclaw-workclaw",
+  label: "智小途",
+  selectionLabel: "智小途",
+  docsPath: "/channels/openclaw-workclaw",
+  docsLabel: "智小途",
+  blurb: "智小途 OpenClaw通道",
+  aliases: [],
+  order: 90
+};
+function writeFileLog(message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const logLine = `[${timestamp}] ${message}
+`;
+  const logDir = join(homedir(), ".openclaw", "logs");
+  const logFile = join(logDir, "sendtext-outbound.log");
+  try {
+    appendFileSync(logFile, logLine);
+  } catch (err) {
+    console.error(`[writeFileLog] Failed to write log: ${err}`);
+  }
+}
+const workclawPlugin = {
+  id: "openclaw-workclaw",
+  meta,
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    media: true,
+    reactions: false,
+    threads: false,
+    polls: false,
+    nativeCommands: false,
+    blockStreaming: true
+  },
+  reload: { configPrefixes: ["channels.openclaw-workclaw"] },
+  configSchema: buildChannelConfigSchema(WorkclawConfigSchema),
+  config: {
+    listAccountIds: (cfg) => listWorkclawAccountIds(cfg),
+    resolveAccount: (cfg, accountId) => resolveWorkclawAccount({ cfg, accountId }),
+    isConfigured: (account) => isWorkclawAccountConfigured(account.config),
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: isWorkclawAccountConfigured(account.config)
+    })
+  },
+  outbound: {
+    deliveryMode: "direct",
+    chunker: (text, _limit) => [text],
+    textChunkLimit: 4096,
+    sendText: async ({ to, text, accountId, cfg, replyToId }) => {
+      writeFileLog(`outbound sendText called: replyToId=${replyToId}, accountId=${accountId}, to=${to}, text=${text.substring(0, 100)}`);
+      const result = await sendMessageWorkclaw({
+        accountId: accountId ?? void 0,
+        cfg,
+        to,
+        text,
+        ...replyToId ? { replyToMessageId: replyToId } : {},
+        last: false,
+        source: "sendText"
+      });
+      return {
+        channel: "openclaw-workclaw",
+        ok: true,
+        messageId: result.messageId
+      };
+    },
+    sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => {
+      if (!mediaUrl && !text.trim()) {
+        throw new Error("mediaUrl is required for outbound media");
+      }
+      const log = getWorkclawRuntime().log ?? console.log;
+      if (typeof log === "function") {
+        log(`outbound sendMedia called for ${to} with text ${text} and mediaUrl ${mediaUrl}`);
+      } else if (log?.info) {
+        log.info(`outbound sendMedia called for ${to} with text ${text} and mediaUrl ${mediaUrl}`);
+      }
+      const messageText = text.trim() ? text : mediaUrl ?? "";
+      const result = await sendMessageWorkclaw({
+        accountId: accountId ?? void 0,
+        cfg,
+        to,
+        text: messageText,
+        mediaUrl: mediaUrl ?? void 0,
+        last: false,
+        source: "sendText"
+      });
+      return {
+        channel: "openclaw-workclaw",
+        ok: true,
+        messageId: result.messageId
+      };
+    }
+  },
+  security: {
+    resolveDmPolicy: ({ cfg, accountId, account }) => {
+      const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+      const channelConfig = cfg.channels?.["openclaw-workclaw"];
+      const useAccountPath = Boolean(channelConfig?.accounts?.[resolvedAccountId]);
+      const basePath = useAccountPath ? `channels.openclaw-workclaw.accounts.${resolvedAccountId}.` : "channels.openclaw-workclaw.";
+      return {
+        policy: account.config.dmPolicy ?? "open",
+        allowFrom: account.config.allowFrom ?? ["*"],
+        policyPath: `${basePath}dmPolicy`,
+        allowFromPath: `${basePath}allowFrom`,
+        approveHint: formatPairingApproveHint("openclaw-workclaw"),
+        normalizeEntry: (raw) => raw.replace(/^openclaw-workclaw:/i, "")
+      };
+    }
+  },
+  status: {
+    buildAccountSnapshot: async ({ account }) => {
+      const wsKey = account.config.appKey;
+      const ws = wsKey ? getWorkclawWsConnection(wsKey) : void 0;
+      const isConnected = ws && ws.readyState === 1;
+      const lastInboundAt = account.accountId ? getLastInboundAt(account.accountId) : void 0;
+      const lastOutboundAt = account.accountId ? getLastOutboundAt(account.accountId) : void 0;
+      return {
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.configured,
+        connected: isConnected,
+        running: account.enabled && account.configured,
+        lastInboundAt: lastInboundAt ?? null,
+        lastOutboundAt: lastOutboundAt ?? null
+      };
+    }
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { setStatus, getStatus, account, accountId, cfg, log } = ctx;
+      log?.info?.(`startAccount called for ${accountId}`);
+      await startWorkclawGateway({
+        accountId,
+        account,
+        cfg,
+        log
+      });
+      setStatus({
+        ...getStatus(),
+        running: true,
+        lastStartAt: Date.now(),
+        lastError: null
+      });
+      log?.info?.(`startAccount completed for ${accountId}, keeping pending until abort`);
+      await new Promise((resolve) => {
+        if (ctx.abortSignal.aborted) {
+          resolve();
+          return;
+        }
+        ctx.abortSignal.addEventListener("abort", () => resolve(), { once: true });
+      });
+      log?.info?.(`startAccount abort signal received for ${accountId}`);
+      stopWorkclawGateway(accountId);
+      setStatus({
+        ...getStatus(),
+        running: false,
+        lastStopAt: Date.now()
+      });
+    },
+    stopAccount: async (ctx) => {
+      const { setStatus, getStatus, accountId } = ctx;
+      stopWorkclawGateway(accountId);
+      setStatus({
+        ...getStatus(),
+        running: false,
+        lastStopAt: Date.now()
+      });
+    }
+  }
+};
+export {
+  workclawPlugin
+};

package/dist/packages/plugin/src/config-schema.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { z as z2 } from "zod";
+const DmPolicySchema = z.enum(["open"]);
+const workclawAccountConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  name: z.string().optional(),
+  agentId: z.union([z.string(), z.number()]).optional(),
+  userId: z.union([z.string(), z.number()]).optional(),
+  openConversationId: z.string().optional(),
+  dmPolicy: DmPolicySchema.optional(),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  mediaMaxMb: z.number().positive().optional(),
+  allowInsecureTls: z.boolean().optional()
+}).strict();
+const WorkclawConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  baseUrl: z.string().url().optional(),
+  websocketUrl: z.string().url().optional(),
+  appKey: z.string().optional(),
+  appSecret: z.string().optional(),
+  agentId: z.union([z.string(), z.number()]).optional(),
+  localIp: z.string().optional(),
+  userId: z.union([z.string(), z.number()]).optional(),
+  requestTimeout: z.number().int().positive().optional(),
+  allowInsecureTls: z.boolean().optional(),
+  allowRawJsonPayload: z.boolean().optional(),
+  uploadUrl: z.string().url().optional(),
+  uploadFieldName: z.string().optional(),
+  uploadHeaders: z.record(z.string(), z.string()).optional(),
+  uploadFormFields: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+  uploadResponseUrlPath: z.string().optional(),
+  dmPolicy: DmPolicySchema.optional().default("open"),
+  allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+  mediaMaxMb: z.number().positive().optional(),
+  accounts: z.record(z.string(), workclawAccountConfigSchema.optional()).optional()
+}).strict().superRefine((value, ctx) => {
+  const allowFrom = value.allowFrom ?? [];
+  const hasWildcard = allowFrom.some((entry) => String(entry).trim() === "*");
+  if (!hasWildcard) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["allowFrom"],
+      message: 'channels.openclaw-workclaw.allowFrom must include "*"'
+    });
+  }
+});
+export {
+  WorkclawConfigSchema,
+  workclawAccountConfigSchema,
+  z2 as z
+};