@atom8n/n8n-nodes-langchain 2.5.7 → 2.5.8

package/dist/nodes/agents/OpenClawAgent/V2/OpenClawAgentV2.node.js

@@ -0,0 +1,2059 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var OpenClawAgentV2_node_exports = {};
+__export(OpenClawAgentV2_node_exports, {
+  OpenClawAgentV2: () => OpenClawAgentV2
+});
+module.exports = __toCommonJS(OpenClawAgentV2_node_exports);
+var import_child_process = require("child_process");
+var import_crypto = require("crypto");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_n8n_workflow = require("n8n-workflow");
+const selectorTypeToParameterName = {
+  agent: "agentId",
+  sessionId: "sessionId",
+  recipient: "to"
+};
+const selectorTypeToCliFlag = {
+  agent: "--agent",
+  sessionId: "--session-id",
+  recipient: "--to"
+};
+const DEFAULT_TIMEOUT_SECONDS = 300;
+const CLI_SHUTDOWN_GRACE_SECONDS = 90;
+const OPENCLAW_CONFIG_PATH_ENV = "OPENCLAW_CONFIG_PATH";
+const OPENCLAW_STATE_DIR_ENV = "OPENCLAW_STATE_DIR";
+const OPENCLAW_OAUTH_DIR_ENV = "OPENCLAW_OAUTH_DIR";
+const OPENCLAW_DEFAULT_ACCOUNT_ID = "default";
+const OPEN_CODE_FREE_MODEL_SOURCE = "opencode-free";
+const OPEN_CODE_FREE_PROVIDER = "opencode";
+const OPEN_CODE_FREE_ENV_VAR = "OPENCODE_API_KEY";
+const OPEN_CODE_FREE_ENV_ALIAS = "OPENCODE_ZEN_API_KEY";
+const OPEN_CODE_FREE_PUBLIC_KEY = "public";
+const NINE_ROUTER_MODEL_SOURCE = "9router";
+const NINE_ROUTER_PROVIDER = "9router";
+const NINE_ROUTER_DEFAULT_BASE_URL = "http://localhost:20128/api/v1";
+const NINE_ROUTER_API = "openai-completions";
+const NINE_ROUTER_CONTEXT_WINDOW = 128e3;
+const NINE_ROUTER_MAX_TOKENS = 32e3;
+const OPENCLAW_TELEGRAM_CHANNEL_NODE_TYPE = "@n8n/n8n-nodes-langchain.openClawTelegramChannel";
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function normalizeLowercaseStringOrEmpty(value) {
+  return (value ?? "").trim().toLowerCase();
+}
+function normalizeStringOrNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  return normalizeOptionalString(value);
+}
+function normalizeTelegramAllowFromEntry(value) {
+  const raw = normalizeStringOrNumber(value);
+  if (!raw) {
+    return void 0;
+  }
+  const normalized = raw.replace(/^(telegram|tg):/i, "").trim();
+  return normalized || void 0;
+}
+function normalizeAllowFromEntries(value) {
+  const rawEntries = Array.isArray(value) ? value : typeof value === "string" ? value.split(/[\n,]/) : [];
+  const seen = /* @__PURE__ */ new Set();
+  const entries = [];
+  for (const rawEntry of rawEntries) {
+    const entry = normalizeTelegramAllowFromEntry(rawEntry);
+    if (!entry || seen.has(entry)) {
+      continue;
+    }
+    seen.add(entry);
+    entries.push(entry);
+  }
+  return entries;
+}
+function getPublishLiteralExpressionValue(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("=")) {
+    return void 0;
+  }
+  const expression = trimmed.slice(1).trim();
+  if (!expression || expression.startsWith("{{") || expression.includes("$")) {
+    return void 0;
+  }
+  const quotedMatch = expression.match(/^(['"])(.*)\1$/);
+  if (quotedMatch) {
+    return quotedMatch[2];
+  }
+  return expression;
+}
+function getObjectKeys(value) {
+  if (!isObject(value)) {
+    return void 0;
+  }
+  return Object.keys(value);
+}
+function getModelDataPreview(value) {
+  if (value === void 0 || value === null) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value.length <= 300 ? value : `${value.slice(0, 300)}...`;
+  }
+  if (typeof value !== "object") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[array length=${value.length}]`;
+  }
+  if (isObject(value)) {
+    const modelId = normalizeOptionalString(value.modelId);
+    const modelSource = normalizeOptionalString(value.modelSource);
+    const extra = isObject(value.extra) ? value.extra : void 0;
+    if (modelId || modelSource || extra) {
+      return JSON.stringify({
+        modelId,
+        modelSource,
+        extraKeys: getObjectKeys(extra)
+      });
+    }
+    return `[object keys=${Object.keys(value).slice(0, 20).join(",")}]`;
+  }
+  return void 0;
+}
+function getModelProvider(modelId) {
+  const provider = modelId?.split("/")[0];
+  return normalizeOptionalString(provider);
+}
+function parseModelRef(modelId) {
+  const [providerPart, ...modelParts] = modelId.split("/");
+  const provider = normalizeOptionalString(providerPart)?.toLowerCase();
+  const model = normalizeOptionalString(modelParts.join("/"));
+  if (!provider || !model) {
+    return void 0;
+  }
+  return { provider, model };
+}
+function isOpenCodeFreeModel(modelConfig, modelId) {
+  return modelConfig?.modelSource === OPEN_CODE_FREE_MODEL_SOURCE && normalizeLowercaseStringOrEmpty(getModelProvider(modelId)) === OPEN_CODE_FREE_PROVIDER;
+}
+function hasOpenCodeAuthEnv(env) {
+  return normalizeOptionalString(env[OPEN_CODE_FREE_ENV_VAR]) !== void 0 || normalizeOptionalString(env[OPEN_CODE_FREE_ENV_ALIAS]) !== void 0;
+}
+function applyOpenCodeFreeAuthEnv(params) {
+  if (!isOpenCodeFreeModel(params.modelConfig, params.modelId)) {
+    return {
+      applied: false,
+      envVar: OPEN_CODE_FREE_ENV_VAR,
+      reason: "not-open-code-free"
+    };
+  }
+  if (hasOpenCodeAuthEnv(params.env) || hasOpenCodeAuthEnv(process.env)) {
+    return {
+      applied: false,
+      envVar: OPEN_CODE_FREE_ENV_VAR,
+      reason: "existing-auth-env"
+    };
+  }
+  params.env[OPEN_CODE_FREE_ENV_VAR] = OPEN_CODE_FREE_PUBLIC_KEY;
+  return {
+    applied: true,
+    envVar: OPEN_CODE_FREE_ENV_VAR,
+    reason: "configured-public-env"
+  };
+}
+function getOpenClawConfigPath() {
+  const configuredPath = normalizeOptionalString(process.env[OPENCLAW_CONFIG_PATH_ENV]);
+  if (configuredPath) {
+    return configuredPath;
+  }
+  const home = getHomeDirectory();
+  return home ? (0, import_path.join)(home, ".openclaw", "openclaw.json") : void 0;
+}
+function resolveOpenClawStateDir() {
+  const stateDir = normalizeOptionalString(process.env[OPENCLAW_STATE_DIR_ENV]);
+  if (stateDir) {
+    return stateDir;
+  }
+  const home = getHomeDirectory();
+  return home ? (0, import_path.join)(home, ".openclaw") : void 0;
+}
+function resolveOpenClawCredentialsDir() {
+  const oauthDir = normalizeOptionalString(process.env[OPENCLAW_OAUTH_DIR_ENV]);
+  if (oauthDir) {
+    return oauthDir;
+  }
+  const stateDir = resolveOpenClawStateDir();
+  return stateDir ? (0, import_path.join)(stateDir, "credentials") : void 0;
+}
+function safeFilenameKey(value) {
+  return value.trim().toLowerCase().replace(/[\\/:*?"<>|]/g, "_").replace(/\.\./g, "_");
+}
+function getTelegramPairingPath(credentialsDir) {
+  return (0, import_path.join)(credentialsDir, "telegram-pairing.json");
+}
+function getTelegramAllowFromPaths(credentialsDir, accountId) {
+  const accountPath = (0, import_path.join)(credentialsDir, `telegram-${safeFilenameKey(accountId)}-allowFrom.json`);
+  if (accountId === OPENCLAW_DEFAULT_ACCOUNT_ID) {
+    return [accountPath, (0, import_path.join)(credentialsDir, "telegram-allowFrom.json")];
+  }
+  return [accountPath];
+}
+function getTelegramAllowFromWritePath(credentialsDir, accountId) {
+  return (0, import_path.join)(credentialsDir, `telegram-${safeFilenameKey(accountId)}-allowFrom.json`);
+}
+function readOpenClawStateJsonFile(filePath) {
+  try {
+    if (!(0, import_fs.existsSync)(filePath) || !(0, import_fs.statSync)(filePath).isFile()) {
+      return void 0;
+    }
+    return (0, import_n8n_workflow.jsonParse)((0, import_fs.readFileSync)(filePath, "utf8"), {
+      acceptJSObject: true,
+      repairJSON: true
+    });
+  } catch (error) {
+    console.log("[OpenClawAgentV2] Failed to read Telegram allowFrom source file", {
+      filePath,
+      error: getErrorMessage(error)
+    });
+    return void 0;
+  }
+}
+function getMetaString(meta, key) {
+  return isObject(meta) ? normalizeOptionalString(meta[key]) : void 0;
+}
+function addTelegramAllowFromEntry(entries, seen, value) {
+  const entry = normalizeTelegramAllowFromEntry(value);
+  if (!entry || seen.has(entry)) {
+    return;
+  }
+  seen.add(entry);
+  entries.push(entry);
+}
+function getFallbackTelegramAllowFrom(accountId) {
+  const credentialsDir = resolveOpenClawCredentialsDir();
+  if (!credentialsDir) {
+    return { allowFrom: [], pairingCount: 0, allowFromFileCount: 0 };
+  }
+  const pairingPath = getTelegramPairingPath(credentialsDir);
+  const allowFromPaths = getTelegramAllowFromPaths(credentialsDir, accountId);
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  let pairingCount = 0;
+  let allowFromFileCount = 0;
+  const pairingStore = readOpenClawStateJsonFile(pairingPath);
+  const requests = isObject(pairingStore) && Array.isArray(pairingStore.requests) ? pairingStore.requests : [];
+  for (const request of requests) {
+    if (!isObject(request)) {
+      continue;
+    }
+    const requestAccountId = normalizeOpenClawAccountId(getMetaString(request.meta, "accountId")) ?? OPENCLAW_DEFAULT_ACCOUNT_ID;
+    if (requestAccountId !== accountId) {
+      continue;
+    }
+    const beforeCount = entries.length;
+    addTelegramAllowFromEntry(entries, seen, request.id);
+    if (entries.length > beforeCount) {
+      pairingCount++;
+    }
+  }
+  for (const allowFromPath of allowFromPaths) {
+    const allowFromStore = readOpenClawStateJsonFile(allowFromPath);
+    const allowFromEntries = isObject(allowFromStore) && Array.isArray(allowFromStore.allowFrom) ? allowFromStore.allowFrom : [];
+    for (const entry of allowFromEntries) {
+      const beforeCount = entries.length;
+      addTelegramAllowFromEntry(entries, seen, entry);
+      if (entries.length > beforeCount) {
+        allowFromFileCount++;
+      }
+    }
+  }
+  return {
+    allowFrom: entries,
+    credentialsDir,
+    pairingPath,
+    allowFromPaths,
+    pairingCount,
+    allowFromFileCount
+  };
+}
+function writeTelegramAllowFromStore(accountId, allowFrom) {
+  const credentialsDir = resolveOpenClawCredentialsDir();
+  if (!credentialsDir) {
+    console.log(
+      "[OpenClawAgentV2] Telegram allowFrom store sync skipped: credentials dir unknown",
+      {
+        accountId,
+        allowFromCount: allowFrom.length
+      }
+    );
+    return { changed: false };
+  }
+  const filePath = getTelegramAllowFromWritePath(credentialsDir, accountId);
+  const existingStore = readOpenClawStateJsonFile(filePath);
+  const nextStore = isObject(existingStore) ? { ...existingStore, version: 1, allowFrom } : { version: 1, allowFrom };
+  const existingJson = isObject(existingStore) ? JSON.stringify(existingStore, null, 2) : void 0;
+  const nextJson = JSON.stringify(nextStore, null, 2);
+  if (existingJson === nextJson) {
+    console.log("[OpenClawAgentV2] Telegram allowFrom store already current", {
+      accountId,
+      filePath,
+      allowFromCount: allowFrom.length
+    });
+    return { changed: false, filePath };
+  }
+  (0, import_fs.mkdirSync)((0, import_path.dirname)(filePath), { recursive: true });
+  (0, import_fs.writeFileSync)(filePath, `${nextJson}
+`, "utf8");
+  console.log("[OpenClawAgentV2] Telegram allowFrom store written", {
+    accountId,
+    filePath,
+    allowFromCount: allowFrom.length
+  });
+  return { changed: true, filePath };
+}
+function ensureDataObject(parent, key) {
+  const existing = parent[key];
+  if (isObject(existing)) {
+    return existing;
+  }
+  const next = {};
+  parent[key] = next;
+  return next;
+}
+function setConfigValue(target, key, value) {
+  if (target[key] === value) {
+    return false;
+  }
+  target[key] = value;
+  return true;
+}
+function deleteConfigValue(target, key) {
+  if (target[key] === void 0) {
+    return false;
+  }
+  delete target[key];
+  return true;
+}
+function setOptionalConfigValue(target, key, value) {
+  if (value === void 0) {
+    return deleteConfigValue(target, key);
+  }
+  return setConfigValue(target, key, value);
+}
+function setOptionalStringArrayConfigValue(target, key, value) {
+  if (value === void 0) {
+    return deleteConfigValue(target, key);
+  }
+  if (value.length === 0) {
+    return deleteConfigValue(target, key);
+  }
+  const existing = target[key];
+  if (Array.isArray(existing) && existing.length === value.length && existing.every((entry, index) => entry === value[index])) {
+    return false;
+  }
+  target[key] = value;
+  return true;
+}
+function setDefaultConfigValue(target, key, value) {
+  if (target[key] !== void 0) {
+    return false;
+  }
+  target[key] = value;
+  return true;
+}
+function normalizeOpenClawAccountId(value) {
+  const trimmed = normalizeOptionalString(value)?.toLowerCase();
+  if (!trimmed) {
+    return void 0;
+  }
+  const normalized = trimmed.replace(/[^a-z0-9_-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 64);
+  if (!normalized || ["__proto__", "constructor", "prototype"].includes(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function normalizeOpenClawMcpServerName(value) {
+  const trimmed = normalizeOptionalString(value);
+  if (!trimmed) {
+    return void 0;
+  }
+  const normalized = trimmed.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 80);
+  if (!normalized || ["__proto__", "constructor", "prototype"].includes(normalized)) {
+    return void 0;
+  }
+  return normalized;
+}
+function isHttpUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function normalizeMcpTransport(value) {
+  if (value === "sse" || value === "streamable-http") {
+    return value;
+  }
+  if (value === "http") {
+    return "streamable-http";
+  }
+  return void 0;
+}
+function normalizeMcpHeaders(value) {
+  let rawHeaders = value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "{}") {
+      return void 0;
+    }
+    rawHeaders = (0, import_n8n_workflow.jsonParse)(trimmed, { acceptJSObject: true, repairJSON: true });
+  }
+  if (!isObject(rawHeaders)) {
+    return void 0;
+  }
+  const headers = Object.fromEntries(
+    Object.entries(rawHeaders).filter(
+      (entry) => typeof entry[1] === "string" || typeof entry[1] === "number" || typeof entry[1] === "boolean"
+    )
+  );
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function normalizePositiveInteger(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function getActivationVariables(context) {
+  const additionalData = context.additionalData;
+  return isObject(additionalData?.variables) ? additionalData.variables : {};
+}
+function resolveVariableExpression(value, variables) {
+  const trimmed = value.trim();
+  const expression = trimmed.startsWith("=") ? trimmed.slice(1).trim() : trimmed;
+  const match = expression.match(
+    /^\{\{\s*\$vars(?:\.([A-Za-z_][A-Za-z0-9_]*)|\[['"]([^'"]+)['"]\])\s*\}\}$/
+  );
+  if (!match) {
+    return void 0;
+  }
+  const key = match[1] ?? match[2];
+  return key ? variables[key] : void 0;
+}
+function resolvePublishParameterValue(value, variables) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("=") && !trimmed.startsWith("{{")) {
+    return value;
+  }
+  return resolveVariableExpression(trimmed, variables);
+}
+function getPublishAllowFrom(params) {
+  const resolvedValue = resolvePublishParameterValue(params.rawValue, params.variables);
+  if (resolvedValue === void 0 && typeof params.rawValue === "string") {
+    const literalValue = getPublishLiteralExpressionValue(params.rawValue);
+    if (literalValue !== void 0) {
+      const literalAllowFrom = normalizeAllowFromEntries(literalValue);
+      console.log("OpenClaw publish sync: resolved Telegram allowFrom literal expression", {
+        nodeName: params.nodeName,
+        rawValue: params.rawValue,
+        allowFromCount: literalAllowFrom.length
+      });
+      return literalAllowFrom;
+    }
+    const accountId = params.accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID;
+    const fallback = getFallbackTelegramAllowFrom(accountId);
+    if (fallback.allowFrom.length > 0) {
+      console.log("OpenClaw publish sync: using Telegram allowFrom fallback from OpenClaw state", {
+        nodeName: params.nodeName,
+        accountId,
+        credentialsDir: fallback.credentialsDir,
+        pairingPath: fallback.pairingPath,
+        allowFromPaths: fallback.allowFromPaths,
+        pairingCount: fallback.pairingCount,
+        allowFromFileCount: fallback.allowFromFileCount,
+        allowFromCount: fallback.allowFrom.length
+      });
+      return fallback.allowFrom;
+    }
+    console.log("OpenClaw publish sync: Telegram allowFrom expression unresolved, skipping field", {
+      nodeName: params.nodeName,
+      rawValue: params.rawValue,
+      accountId,
+      credentialsDir: fallback.credentialsDir,
+      pairingPath: fallback.pairingPath,
+      allowFromPaths: fallback.allowFromPaths
+    });
+    return void 0;
+  }
+  if (resolvedValue === void 0) {
+    const accountId = params.accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID;
+    const fallback = getFallbackTelegramAllowFrom(accountId);
+    if (fallback.allowFrom.length > 0) {
+      console.log("OpenClaw publish sync: using Telegram allowFrom fallback from OpenClaw state", {
+        nodeName: params.nodeName,
+        accountId,
+        credentialsDir: fallback.credentialsDir,
+        pairingPath: fallback.pairingPath,
+        allowFromPaths: fallback.allowFromPaths,
+        pairingCount: fallback.pairingCount,
+        allowFromFileCount: fallback.allowFromFileCount,
+        allowFromCount: fallback.allowFrom.length
+      });
+      return fallback.allowFrom;
+    }
+    return void 0;
+  }
+  const allowFrom = normalizeAllowFromEntries(resolvedValue);
+  console.log("OpenClaw publish sync: resolved Telegram allowFrom parameter", {
+    nodeName: params.nodeName,
+    rawType: typeof params.rawValue,
+    resolvedType: Array.isArray(resolvedValue) ? "array" : typeof resolvedValue,
+    allowFromCount: allowFrom.length
+  });
+  return allowFrom;
+}
+function getMcpServerConfigFromParameters(parameters) {
+  const serverName = normalizeOptionalString(parameters.serverName);
+  const url = normalizeOptionalString(parameters.endpointUrl);
+  if (!serverName && !url) {
+    return { reason: "not-mcp-server-node" };
+  }
+  if (!serverName) {
+    return { reason: "missing-server-name" };
+  }
+  if (!url) {
+    return { reason: "missing-endpoint-url" };
+  }
+  const options = isObject(parameters.options) ? parameters.options : {};
+  let headers;
+  try {
+    headers = normalizeMcpHeaders(options.headers);
+  } catch (error) {
+    return { reason: `invalid-headers:${getErrorMessage(error)}` };
+  }
+  return {
+    config: {
+      mcpServerSource: "openclaw",
+      serverName,
+      url,
+      transport: normalizeMcpTransport(parameters.transport),
+      headers,
+      connectionTimeoutMs: normalizePositiveInteger(options.connectionTimeoutMs)
+    }
+  };
+}
+function readOpenClawConfig(configPath) {
+  if (!(0, import_fs.existsSync)(configPath)) {
+    return {};
+  }
+  const rawConfig = (0, import_fs.readFileSync)(configPath, "utf8").trim();
+  if (!rawConfig) {
+    return {};
+  }
+  const parsed = (0, import_n8n_workflow.jsonParse)(rawConfig, { acceptJSObject: true, repairJSON: true });
+  if (!isObject(parsed)) {
+    throw new import_n8n_workflow.ApplicationError(`OpenClaw config is not an object: ${configPath}`);
+  }
+  return parsed;
+}
+function syncChannelConfig(params) {
+  const configPath = getOpenClawConfigPath();
+  if (!configPath) {
+    throw new import_n8n_workflow.ApplicationError(
+      `Could not determine OpenClaw config path. Set ${OPENCLAW_CONFIG_PATH_ENV} or HOME for the n8n process.`
+    );
+  }
+  const config = readOpenClawConfig(configPath);
+  const originalConfigJson = JSON.stringify(config);
+  const channels = ensureDataObject(config, "channels");
+  const channel = ensureDataObject(channels, params.channelType);
+  const accountId = normalizeOpenClawAccountId(params.replyAccount);
+  const useAccountTarget = !!accountId && accountId !== OPENCLAW_DEFAULT_ACCOUNT_ID;
+  const target = useAccountTarget ? ensureDataObject(ensureDataObject(channel, "accounts"), accountId) : channel;
+  const targetPath = useAccountTarget ? `channels.${params.channelType}.accounts.${accountId}` : `channels.${params.channelType}`;
+  const dmPolicy = normalizeOptionalString(params.dmPolicy);
+  const groupPolicy = normalizeOptionalString(params.groupPolicy);
+  const isTelegramChannel = params.channelType === "telegram";
+  console.log("[OpenClawAgentV2] syncChannelConfig: start", {
+    channelType: params.channelType,
+    accountId: accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+    targetPath,
+    configPath,
+    hasBotToken: !!params.botToken,
+    dmPolicy: dmPolicy ?? "(openclaw-default)",
+    groupPolicy: groupPolicy ?? "(openclaw-default)",
+    allowFromCount: params.allowFrom?.length
+  });
+  let changed = false;
+  changed = setConfigValue(channel, "enabled", true) || changed;
+  if (useAccountTarget) {
+    changed = setConfigValue(target, "enabled", true) || changed;
+  }
+  changed = (dmPolicy ? setConfigValue(target, "dmPolicy", dmPolicy) : setDefaultConfigValue(target, "dmPolicy", "pairing")) || changed;
+  changed = (groupPolicy ? setConfigValue(target, "groupPolicy", groupPolicy) : setDefaultConfigValue(target, "groupPolicy", "allowlist")) || changed;
+  let allowFromStorePath;
+  if (params.allowFrom !== void 0) {
+    if (isTelegramChannel) {
+      const allowFromStoreSync = writeTelegramAllowFromStore(
+        accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+        params.allowFrom
+      );
+      allowFromStorePath = allowFromStoreSync.filePath;
+      changed = allowFromStoreSync.changed || changed;
+    } else {
+      changed = setOptionalStringArrayConfigValue(target, "allowFrom", params.allowFrom) || changed;
+    }
+  }
+  if (isTelegramChannel) {
+    changed = deleteConfigValue(target, "allowFrom") || changed;
+  }
+  if (params.botToken) {
+    changed = setConfigValue(target, "botToken", params.botToken) || changed;
+  }
+  const configChanged = JSON.stringify(config) !== originalConfigJson;
+  if (configChanged) {
+    (0, import_fs.mkdirSync)((0, import_path.dirname)(configPath), { recursive: true });
+    (0, import_fs.writeFileSync)(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    console.log("[OpenClawAgentV2] syncChannelConfig: openclaw.json written", {
+      channelType: params.channelType,
+      accountId: accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+      targetPath,
+      configPath,
+      allowFromCount: params.allowFrom?.length,
+      allowFromStorePath
+    });
+  } else if (changed) {
+    console.log("[OpenClawAgentV2] syncChannelConfig: external channel store updated", {
+      channelType: params.channelType,
+      accountId: accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+      targetPath,
+      configPath,
+      allowFromCount: params.allowFrom?.length,
+      allowFromStorePath
+    });
+  } else {
+    console.log("[OpenClawAgentV2] syncChannelConfig: no changes needed", {
+      channelType: params.channelType,
+      accountId: accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+      targetPath,
+      configPath,
+      allowFromCount: params.allowFrom?.length,
+      allowFromStorePath
+    });
+  }
+  return { accountId, changed, configPath, targetPath, allowFromStorePath };
+}
+function getNineRouterModelDefinition(model) {
+  return {
+    id: model,
+    name: model === "auto" ? "9Router Auto" : model,
+    api: NINE_ROUTER_API,
+    reasoning: false,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: NINE_ROUTER_CONTEXT_WINDOW,
+    maxTokens: NINE_ROUTER_MAX_TOKENS
+  };
+}
+function syncNineRouterModelConfig(params) {
+  if (params.modelConfig?.modelSource !== NINE_ROUTER_MODEL_SOURCE || normalizeLowercaseStringOrEmpty(getModelProvider(params.modelId)) !== NINE_ROUTER_PROVIDER || !params.modelId) {
+    return { changed: false, reason: "not-nine-router" };
+  }
+  const modelRef = parseModelRef(params.modelId);
+  if (!modelRef || modelRef.provider !== NINE_ROUTER_PROVIDER) {
+    return { changed: false, reason: "invalid-model-id" };
+  }
+  const configPath = getOpenClawConfigPath();
+  if (!configPath) {
+    throw new import_n8n_workflow.ApplicationError(
+      `Could not determine OpenClaw config path. Set ${OPENCLAW_CONFIG_PATH_ENV} or HOME for the n8n process.`
+    );
+  }
+  const config = readOpenClawConfig(configPath);
+  const models = ensureDataObject(config, "models");
+  const providers = ensureDataObject(models, "providers");
+  const provider = ensureDataObject(providers, NINE_ROUTER_PROVIDER);
+  const existingBaseUrl = normalizeOptionalString(provider.baseUrl);
+  let changed = false;
+  changed = setDefaultConfigValue(
+    provider,
+    "baseUrl",
+    normalizeOptionalString(params.modelConfig.extra?.baseUrl) ?? NINE_ROUTER_DEFAULT_BASE_URL
+  ) || changed;
+  changed = setConfigValue(provider, "api", NINE_ROUTER_API) || changed;
+  let providerModels;
+  if (Array.isArray(provider.models)) {
+    providerModels = provider.models.filter(isObject);
+    if (providerModels.length !== provider.models.length) {
+      provider.models = providerModels;
+      changed = true;
+    }
+  } else {
+    providerModels = [];
+    provider.models = providerModels;
+    changed = true;
+  }
+  const existingModel = providerModels.find(
+    (model) => normalizeOptionalString(model.id) === modelRef.model
+  );
+  if (existingModel) {
+    changed = setConfigValue(existingModel, "api", NINE_ROUTER_API) || changed;
+    changed = setDefaultConfigValue(existingModel, "name", modelRef.model) || changed;
+    changed = setDefaultConfigValue(existingModel, "reasoning", false) || changed;
+    changed = setDefaultConfigValue(existingModel, "input", ["text", "image"]) || changed;
+    changed = setDefaultConfigValue(existingModel, "cost", {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    }) || changed;
+    changed = setDefaultConfigValue(existingModel, "contextWindow", NINE_ROUTER_CONTEXT_WINDOW) || changed;
+    changed = setDefaultConfigValue(existingModel, "maxTokens", NINE_ROUTER_MAX_TOKENS) || changed;
+  } else {
+    providerModels.push(getNineRouterModelDefinition(modelRef.model));
+    changed = true;
+  }
+  const agents = ensureDataObject(config, "agents");
+  const defaults = ensureDataObject(agents, "defaults");
+  const defaultModels = ensureDataObject(defaults, "models");
+  const fullModelRef = `${modelRef.provider}/${modelRef.model}`;
+  const existingDefaultModel = defaultModels[fullModelRef];
+  if (!isObject(existingDefaultModel)) {
+    defaultModels[fullModelRef] = {};
+    changed = true;
+  }
+  if (changed) {
+    (0, import_fs.mkdirSync)((0, import_path.dirname)(configPath), { recursive: true });
+    (0, import_fs.writeFileSync)(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  }
+  return {
+    changed,
+    configPath,
+    reason: changed ? "updated-provider" : "already-current",
+    targetPath: `models.providers.${NINE_ROUTER_PROVIDER}`,
+    modelRef: fullModelRef,
+    existingBaseUrl
+  };
+}
+function syncMcpServerConfig(params) {
+  const synced = [];
+  const skipped = [];
+  if (params.mcpServerConfigs.length === 0) {
+    return { changed: false, synced, skipped };
+  }
+  const configPath = getOpenClawConfigPath();
+  if (!configPath) {
+    const reason = `Could not determine OpenClaw config path. Set ${OPENCLAW_CONFIG_PATH_ENV} or HOME for the n8n process.`;
+    console.log("[OpenClawAgentV2] syncMcpServerConfig: skipped all servers", {
+      reason,
+      serverCount: params.mcpServerConfigs.length
+    });
+    return { changed: false, synced, skipped: [reason] };
+  }
+  console.log("[OpenClawAgentV2] syncMcpServerConfig: start", {
+    configPath,
+    serverCount: params.mcpServerConfigs.length,
+    serverNames: params.mcpServerConfigs.map((server) => server.serverName)
+  });
+  const config = readOpenClawConfig(configPath);
+  const mcp = ensureDataObject(config, "mcp");
+  const servers = ensureDataObject(mcp, "servers");
+  let changed = false;
+  for (const serverConfig of params.mcpServerConfigs) {
+    const serverName = normalizeOpenClawMcpServerName(serverConfig.serverName);
+    const url = normalizeOptionalString(serverConfig.url);
+    if (!serverName) {
+      const reason = `invalid-name:${serverConfig.serverName}`;
+      console.log("[OpenClawAgentV2] syncMcpServerConfig: skipping server", {
+        rawServerName: serverConfig.serverName,
+        reason
+      });
+      skipped.push(reason);
+      continue;
+    }
+    if (!url || !isHttpUrl(url)) {
+      const reason = `invalid-url:${serverName}`;
+      console.log("[OpenClawAgentV2] syncMcpServerConfig: skipping server", {
+        serverName,
+        hasUrl: !!url,
+        reason
+      });
+      skipped.push(reason);
+      continue;
+    }
+    const server = ensureDataObject(servers, serverName);
+    const transport = normalizeMcpTransport(serverConfig.transport);
+    const headers = serverConfig.headers && Object.keys(serverConfig.headers).length > 0 ? serverConfig.headers : void 0;
+    const connectionTimeoutMs = normalizePositiveInteger(serverConfig.connectionTimeoutMs);
+    changed = setConfigValue(server, "url", url) || changed;
+    changed = setOptionalConfigValue(server, "transport", transport) || changed;
+    changed = setOptionalConfigValue(server, "headers", headers) || changed;
+    changed = setOptionalConfigValue(server, "connectionTimeoutMs", connectionTimeoutMs) || changed;
+    changed = deleteConfigValue(server, "command") || changed;
+    changed = deleteConfigValue(server, "args") || changed;
+    changed = deleteConfigValue(server, "env") || changed;
+    changed = deleteConfigValue(server, "cwd") || changed;
+    changed = deleteConfigValue(server, "workingDirectory") || changed;
+    console.log("[OpenClawAgentV2] syncMcpServerConfig: prepared server", {
+      serverName,
+      rawServerName: serverConfig.serverName,
+      url,
+      transport: transport ?? "(openclaw-default)",
+      headerKeys: headers ? Object.keys(headers) : [],
+      connectionTimeoutMs
+    });
+    synced.push(serverName);
+  }
+  if (changed) {
+    (0, import_fs.mkdirSync)((0, import_path.dirname)(configPath), { recursive: true });
+    (0, import_fs.writeFileSync)(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+    console.log("[OpenClawAgentV2] syncMcpServerConfig: openclaw.json written", {
+      configPath,
+      synced,
+      skipped
+    });
+  } else {
+    console.log("[OpenClawAgentV2] syncMcpServerConfig: no changes needed", {
+      configPath,
+      synced,
+      skipped
+    });
+  }
+  return { changed, configPath, synced, skipped };
+}
+function syncPluginConfig(params) {
+  const installed = [];
+  const skipped = [];
+  const errors = [];
+  const configPath = getOpenClawConfigPath();
+  let existingInstalls = {};
+  let existingLoadPaths = [];
+  let existingEntries = {};
+  if (configPath) {
+    try {
+      const config = readOpenClawConfig(configPath);
+      const plugins = config.plugins;
+      existingInstalls = plugins?.installs ?? {};
+      existingLoadPaths = plugins?.load?.paths ?? [];
+      existingEntries = plugins?.entries ?? {};
+    } catch {
+    }
+  }
+  const resolvedBinary = resolveOpenClawBinary("openclaw");
+  const env = createOpenClawProcessEnv(resolvedBinary.pathDirectories, { NODE_NO_WARNINGS: "1" });
+  for (const pluginCfg of params.pluginConfigs) {
+    if (pluginCfg.pluginSource === "local" && pluginCfg.pluginPath) {
+      const pluginPath = pluginCfg.pluginPath;
+      const manifestId = pluginCfg.pluginManifest?.id;
+      if (manifestId) {
+        const isPathLoaded = existingLoadPaths.includes(pluginPath);
+        const isEntryEnabled = existingEntries[manifestId]?.enabled === true;
+        if (isPathLoaded && isEntryEnabled) {
+          console.log("[OpenClawAgentV2] syncPluginConfig: already installed, skipping", {
+            manifestId,
+            pluginPath
+          });
+          skipped.push(manifestId);
+          continue;
+        }
+      }
+      try {
+        const cmd = `${resolvedBinary.binaryPath} plugins install -l ${JSON.stringify(pluginPath)}`;
+        console.log("[OpenClawAgentV2] syncPluginConfig: running CLI", { cmd });
+        const output = (0, import_child_process.execSync)(cmd, {
+          timeout: 3e4,
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"],
+          env
+        });
+        console.log("[OpenClawAgentV2] syncPluginConfig: CLI success", {
+          pluginPath,
+          manifestId,
+          output: output.trim().slice(0, 500)
+        });
+        installed.push(manifestId ?? pluginPath);
+      } catch (cliErr) {
+        const errMsg = cliErr instanceof Error ? cliErr.message : String(cliErr);
+        const stderr = cliErr && typeof cliErr === "object" && "stderr" in cliErr ? String(cliErr.stderr).trim().slice(0, 500) : void 0;
+        console.log("[OpenClawAgentV2] syncPluginConfig: CLI failed", {
+          pluginPath,
+          error: errMsg.slice(0, 300),
+          stderr
+        });
+        errors.push(`local:${pluginPath}: ${errMsg.slice(0, 200)}`);
+      }
+    } else if (pluginCfg.pluginSource === "cloud" && pluginCfg.pluginId) {
+      const pluginId = pluginCfg.pluginId;
+      const existingRecord = existingInstalls[pluginId];
+      if (existingRecord?.source === "npm" || existingRecord?.source === "clawhub") {
+        console.log("[OpenClawAgentV2] syncPluginConfig: already installed, skipping", {
+          pluginId,
+          source: existingRecord.source
+        });
+        skipped.push(pluginId);
+        continue;
+      }
+      const spec = pluginCfg.pluginVersion ? `${pluginId}@${pluginCfg.pluginVersion}` : pluginId;
+      try {
+        const cmd = `${resolvedBinary.binaryPath} plugins install ${JSON.stringify(spec)}`;
+        console.log("[OpenClawAgentV2] syncPluginConfig: running CLI", { cmd });
+        const output = (0, import_child_process.execSync)(cmd, {
+          timeout: 6e4,
+          encoding: "utf8",
+          stdio: ["pipe", "pipe", "pipe"],
+          env
+        });
+        console.log("[OpenClawAgentV2] syncPluginConfig: CLI success", {
+          pluginId,
+          output: output.trim().slice(0, 500)
+        });
+        installed.push(pluginId);
+      } catch (cliErr) {
+        const errMsg = cliErr instanceof Error ? cliErr.message : String(cliErr);
+        console.log("[OpenClawAgentV2] syncPluginConfig: CLI failed", {
+          pluginId,
+          error: errMsg.slice(0, 300)
+        });
+        errors.push(`cloud:${pluginId}: ${errMsg.slice(0, 200)}`);
+      }
+    }
+  }
+  console.log("[OpenClawAgentV2] syncPluginConfig: result", {
+    pluginCount: params.pluginConfigs.length,
+    installedCount: installed.length,
+    skippedCount: skipped.length,
+    errorCount: errors.length,
+    installed: installed.length > 0 ? installed : void 0,
+    skipped: skipped.length > 0 ? skipped : void 0,
+    errors: errors.length > 0 ? errors : void 0
+  });
+  return { installed, skipped, errors };
+}
+function parseOpenClawOutput(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return {};
+  }
+  const parsed = (0, import_n8n_workflow.jsonParse)(trimmed);
+  if (isObject(parsed)) {
+    return parsed;
+  }
+  return { result: parsed };
+}
+function isUsableFile(filePath) {
+  try {
+    return (0, import_fs.existsSync)(filePath) && (0, import_fs.statSync)(filePath).isFile();
+  } catch {
+    return false;
+  }
+}
+function getHomeDirectory() {
+  return normalizeOptionalString(process.env.HOME) ?? normalizeOptionalString(process.env.USERPROFILE);
+}
+function getDefaultBinarySearchPaths(binaryName) {
+  const home = getHomeDirectory();
+  const homeCandidates = home ? [
+    (0, import_path.join)(home, ".volta", "bin", binaryName),
+    (0, import_path.join)(home, ".local", "bin", binaryName),
+    (0, import_path.join)(home, ".npm-global", "bin", binaryName),
+    (0, import_path.join)(home, ".bun", "bin", binaryName),
+    (0, import_path.join)(home, "Library", "pnpm", binaryName)
+  ] : [];
+  return [
+    normalizeOptionalString(process.env.OPENCLAW_BINARY_PATH),
+    normalizeOptionalString(process.env.OPENCLAW_BIN),
+    ...(process.env.PATH ?? "").split(import_path.delimiter).filter(Boolean).map((pathDirectory) => (0, import_path.join)(pathDirectory, binaryName)),
+    ...homeCandidates,
+    (0, import_path.join)("/opt/homebrew/bin", binaryName),
+    (0, import_path.join)("/usr/local/bin", binaryName)
+  ].filter((candidate) => typeof candidate === "string");
+}
+function resolveOpenClawBinary(binaryPath) {
+  if (binaryPath.includes("/") || binaryPath.includes("\\")) {
+    return { binaryPath, pathDirectories: [(0, import_path.dirname)(binaryPath)] };
+  }
+  for (const candidate of getDefaultBinarySearchPaths(binaryPath)) {
+    if (isUsableFile(candidate)) {
+      return { binaryPath: candidate, pathDirectories: [(0, import_path.dirname)(candidate)] };
+    }
+  }
+  return { binaryPath, pathDirectories: [] };
+}
+function createOpenClawProcessEnv(pathDirectories, additionalEnv = {}) {
+  const existingPath = process.env.PATH ?? "";
+  const prependedPath = pathDirectories.filter(Boolean).join(import_path.delimiter);
+  const nextPath = prependedPath ? `${prependedPath}${import_path.delimiter}${existingPath}` : existingPath;
+  return { ...process.env, ...additionalEnv, PATH: nextPath };
+}
+function killOpenClawProcess(child, signal) {
+  try {
+    if (child.pid && process.platform !== "win32") {
+      process.kill(-child.pid, signal);
+      return;
+    }
+  } catch {
+  }
+  try {
+    child.kill(signal);
+  } catch {
+  }
+}
+function summarizeProcessOutput(output) {
+  const trimmed = output.trim();
+  if (!trimmed) return "";
+  const maxLength = 2e3;
+  return trimmed.length <= maxLength ? trimmed : `${trimmed.slice(0, maxLength)}...`;
+}
+function getWatchdogTimeoutMs(timeoutSeconds) {
+  return (timeoutSeconds + CLI_SHUTDOWN_GRACE_SECONDS) * 1e3;
+}
+function getGatewayCallArgs(params, rpcTimeoutMs) {
+  return [
+    "gateway",
+    "call",
+    "agent",
+    "--expect-final",
+    "--json",
+    "--timeout",
+    String(rpcTimeoutMs),
+    "--params",
+    JSON.stringify(params)
+  ];
+}
+function quoteCommandArgument(value) {
+  if (/^[A-Za-z0-9_/:=-]+$/.test(value)) return value;
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+function getOpenClawCommand(binaryPath, args) {
+  return [binaryPath, ...args].map(quoteCommandArgument).join(" ");
+}
+async function runOpenClawCli(params) {
+  return await new Promise((resolve, reject) => {
+    const resolvedBinary = resolveOpenClawBinary(params.binaryPath);
+    const command = getOpenClawCommand(resolvedBinary.binaryPath, params.args);
+    const child = (0, import_child_process.spawn)(resolvedBinary.binaryPath, params.args, {
+      cwd: params.cwd,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"],
+      env: createOpenClawProcessEnv(resolvedBinary.pathDirectories, params.env)
+    });
+    let stdout = "";
+    let stderr = "";
+    let aborted = false;
+    let timedOut = false;
+    let forceKillTimer;
+    const abortHandler = () => {
+      aborted = true;
+      killOpenClawProcess(child, "SIGTERM");
+    };
+    const timeoutTimer = setTimeout(() => {
+      timedOut = true;
+      killOpenClawProcess(child, "SIGTERM");
+      forceKillTimer = setTimeout(() => {
+        killOpenClawProcess(child, "SIGKILL");
+      }, 5e3);
+    }, params.timeoutMs);
+    params.abortSignal?.addEventListener("abort", abortHandler, { once: true });
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("error", (error) => {
+      clearTimeout(timeoutTimer);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      params.abortSignal?.removeEventListener("abort", abortHandler);
+      reject(
+        new Error(
+          `Failed to spawn OpenClaw CLI at "${resolvedBinary.binaryPath}": ${error.message}. Set Options > Binary Path to the full path of the openclaw executable, or set OPENCLAW_BINARY_PATH in the n8n process environment.`
+        )
+      );
+    });
+    child.on("close", (exitCode, signal) => {
+      clearTimeout(timeoutTimer);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      params.abortSignal?.removeEventListener("abort", abortHandler);
+      if (aborted) {
+        reject(new Error("OpenClaw CLI execution was cancelled"));
+        return;
+      }
+      if (timedOut) {
+        const stderrSummary = summarizeProcessOutput(stderr);
+        const stdoutSummary = summarizeProcessOutput(stdout);
+        const details = stderrSummary || stdoutSummary ? ` Last output: ${stderrSummary || stdoutSummary}` : "";
+        reject(
+          new Error(
+            `OpenClaw CLI did not finish within ${Math.ceil(params.timeoutMs / 1e3)} seconds and was stopped.${details}`
+          )
+        );
+        return;
+      }
+      resolve({ stdout, stderr, exitCode, signal, command });
+    });
+  });
+}
+class OpenClawAgentV2 {
+  constructor(baseDescription) {
+    this.description = {
+      ...baseDescription,
+      version: 2,
+      subtitle: '={{$parameter.selectorType === "agent" ? "Agent: " + $parameter.agentId : $parameter.selectorType === "sessionId" ? "Session: " + $parameter.sessionId : $parameter.selectorType === "recipient" ? "To: " + $parameter.to : "Default route"}}',
+      defaults: {
+        name: "OpenClaw AI Agent"
+      },
+      codex: {
+        alias: ["OpenClaw", "Agent", "Gateway", "Assistant", "Channel"],
+        categories: ["AI"],
+        subcategories: {
+          AI: ["Agents", "Root Nodes"]
+        },
+        resources: {
+          primaryDocumentation: [
+            {
+              url: "https://docs.openclaw.ai/cli/agent"
+            }
+          ]
+        }
+      },
+      inputs: [
+        import_n8n_workflow.NodeConnectionTypes.Main,
+        {
+          type: import_n8n_workflow.NodeConnectionTypes.AiChannel,
+          displayName: "Channel"
+        },
+        {
+          type: import_n8n_workflow.NodeConnectionTypes.AiLanguageModel,
+          displayName: "Model",
+          required: false,
+          maxConnections: 1
+        },
+        {
+          type: import_n8n_workflow.NodeConnectionTypes.AiTool,
+          displayName: "Plugin",
+          required: false
+        },
+        {
+          type: import_n8n_workflow.NodeConnectionTypes.AiTool,
+          displayName: "MCP",
+          required: false
+        }
+      ],
+      outputs: [import_n8n_workflow.NodeConnectionTypes.Main],
+      // No hardcoded credentials — channels provide their own
+      properties: [
+        {
+          displayName: "Requires the OpenClaw CLI to be installed and configured on the n8n host. Connect Channel sub-nodes to configure messaging channels (Telegram, WhatsApp, etc.).",
+          name: "openClawNotice",
+          type: "notice",
+          default: ""
+        },
+        {
+          displayName: "Message",
+          name: "message",
+          type: "string",
+          required: true,
+          default: '={{ $json.chatInput || $json.chat_input || $json.message || $json.text || "" }}',
+          description: "Message body to send to the OpenClaw agent",
+          typeOptions: { rows: 5 }
+        },
+        {
+          displayName: "Route By",
+          name: "selectorType",
+          type: "options",
+          default: "agent",
+          noDataExpression: true,
+          description: "How to target the OpenClaw agent turn",
+          options: [
+            {
+              name: "Agent ID",
+              value: "agent",
+              description: "Run against a configured OpenClaw agent"
+            },
+            {
+              name: "Existing Session ID",
+              value: "sessionId",
+              description: "Continue an existing OpenClaw session"
+            },
+            {
+              name: "Recipient",
+              value: "recipient",
+              description: "Use a recipient/channel target to derive the session"
+            },
+            {
+              name: "OpenClaw Default",
+              value: "default",
+              description: "Let OpenClaw choose its default route"
+            }
+          ]
+        },
+        {
+          displayName: "Agent ID",
+          name: "agentId",
+          type: "string",
+          default: "main",
+          description: "Configured OpenClaw agent ID",
+          displayOptions: { show: { selectorType: ["agent"] } }
+        },
+        {
+          displayName: "Session ID",
+          name: "sessionId",
+          type: "string",
+          default: "",
+          description: "OpenClaw session ID to continue",
+          displayOptions: { show: { selectorType: ["sessionId"] } }
+        },
+        {
+          displayName: "Recipient",
+          name: "to",
+          type: "string",
+          default: "",
+          description: "Recipient or channel target passed to OpenClaw as --to",
+          displayOptions: { show: { selectorType: ["recipient"] } }
+        },
+        {
+          displayName: "Thinking Level",
+          name: "thinking",
+          type: "options",
+          default: "",
+          description: "Optional OpenClaw thinking level override for this run",
+          options: [
+            { name: "Adaptive", value: "adaptive" },
+            { name: "Extra High", value: "xhigh" },
+            { name: "High", value: "high" },
+            { name: "Low", value: "low" },
+            { name: "Max", value: "max" },
+            { name: "Medium", value: "medium" },
+            { name: "Minimal", value: "minimal" },
+            { name: "Off", value: "off" },
+            { name: "Use OpenClaw Default", value: "" }
+          ]
+        },
+        {
+          displayName: "Run Locally",
+          name: "local",
+          type: "boolean",
+          default: false,
+          description: "Whether to force OpenClaw embedded local runtime instead of Gateway mode"
+        },
+        {
+          displayName: "Deliver Reply",
+          name: "deliver",
+          type: "boolean",
+          default: false,
+          description: "Whether OpenClaw should deliver the reply back to the selected channel/target"
+        },
+        {
+          displayName: "Options",
+          name: "options",
+          type: "collection",
+          placeholder: "Add Option",
+          default: {},
+          options: [
+            {
+              displayName: "System Message",
+              name: "systemMessage",
+              type: "string",
+              default: "",
+              description: "Additional system instructions for this OpenClaw run",
+              typeOptions: { rows: 5 }
+            },
+            {
+              displayName: "Binary Path",
+              name: "binaryPath",
+              type: "string",
+              default: "openclaw",
+              description: "Path to the openclaw binary"
+            },
+            {
+              displayName: "Working Directory",
+              name: "workingDirectory",
+              type: "string",
+              default: "",
+              description: "Working directory for the OpenClaw process"
+            },
+            {
+              displayName: "Timeout",
+              name: "timeout",
+              type: "number",
+              default: DEFAULT_TIMEOUT_SECONDS,
+              description: "OpenClaw agent timeout in seconds",
+              typeOptions: { minValue: 1 }
+            },
+            {
+              displayName: "Verbose",
+              name: "verbose",
+              type: "options",
+              default: "",
+              description: "Optional OpenClaw verbose setting",
+              options: [
+                { name: "Full", value: "full" },
+                { name: "Leave Unchanged", value: "" },
+                { name: "Off", value: "off" },
+                { name: "On", value: "on" }
+              ]
+            },
+            {
+              displayName: "Include Raw Output",
+              name: "includeRawOutput",
+              type: "boolean",
+              default: false,
+              description: "Whether to include raw stdout and stderr from the OpenClaw CLI in the output"
+            }
+          ]
+        }
+      ]
+    };
+  }
+  async trigger() {
+    const node = this.getNode();
+    const workflowId = this.getWorkflow().id;
+    const activationMode = this.getActivationMode();
+    console.log("[OpenClawAgentV2] trigger activation registered", {
+      nodeName: node.name,
+      workflowId,
+      activationMode
+    });
+    console.log("OpenClaw publish sync: trigger activated", {
+      workflowId,
+      activationMode,
+      nodeName: node.name
+    });
+    if (activationMode !== "init") {
+      try {
+        const nodeName = node.name;
+        const aiToolParents = this.getParentNodes(nodeName, {
+          includeNodeParameters: true,
+          connectionType: import_n8n_workflow.NodeConnectionTypes.AiTool,
+          depth: 1
+        });
+        const aiChannelParents = this.getParentNodes(nodeName, {
+          includeNodeParameters: true,
+          connectionType: import_n8n_workflow.NodeConnectionTypes.AiChannel,
+          depth: 1
+        });
+        console.log("OpenClaw publish sync: discovered AI tool config sub-nodes", {
+          count: aiToolParents.length,
+          nodes: aiToolParents.map((p) => ({
+            name: p.name,
+            type: p.type,
+            params: p.parameters ? Object.keys(p.parameters) : []
+          }))
+        });
+        console.log("OpenClaw publish sync: discovered AI channel config sub-nodes", {
+          count: aiChannelParents.length,
+          nodes: aiChannelParents.map((p) => ({
+            name: p.name,
+            type: p.type,
+            params: p.parameters ? Object.keys(p.parameters) : [],
+            hasCredentials: !!p.credentials
+          }))
+        });
+        const activationVariables = getActivationVariables(this);
+        const publishChannelConfigs = [];
+        for (const channelNode of aiChannelParents) {
+          const params = channelNode.parameters ?? {};
+          const channelNodeName = channelNode.name;
+          if (channelNode.type !== OPENCLAW_TELEGRAM_CHANNEL_NODE_TYPE) {
+            console.log("OpenClaw publish sync: skipping unsupported channel sub-node", {
+              nodeName: channelNodeName,
+              type: channelNode.type
+            });
+            continue;
+          }
+          const accountId = normalizeOptionalString(
+            resolvePublishParameterValue(params.accountId, activationVariables)
+          ) ?? void 0;
+          const dmPolicy = normalizeOptionalString(
+            resolvePublishParameterValue(params.dmPolicy, activationVariables)
+          ) ?? "pairing";
+          const groupPolicy = normalizeOptionalString(
+            resolvePublishParameterValue(params.groupPolicy, activationVariables)
+          ) ?? "allowlist";
+          const allowFrom = getPublishAllowFrom({
+            rawValue: params.allowFrom,
+            variables: activationVariables,
+            nodeName: channelNodeName,
+            accountId: accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID
+          });
+          publishChannelConfigs.push({
+            channelType: "telegram",
+            accountId,
+            dmPolicy,
+            groupPolicy,
+            allowFrom
+          });
+          console.log("OpenClaw publish sync: prepared Telegram channel config", {
+            nodeName: channelNodeName,
+            accountId: accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+            dmPolicy,
+            groupPolicy,
+            allowFromCount: allowFrom?.length
+          });
+        }
+        const publishPluginConfigs = [];
+        const publishMcpServerConfigs = [];
+        for (const pluginNode of aiToolParents) {
+          const params = pluginNode.parameters ?? {};
+          const mcpServerConfig = getMcpServerConfigFromParameters(
+            params
+          );
+          if (mcpServerConfig.config) {
+            console.log("OpenClaw publish sync: processing MCP Server sub-node", {
+              type: pluginNode.type,
+              serverName: mcpServerConfig.config.serverName,
+              url: mcpServerConfig.config.url,
+              transport: mcpServerConfig.config.transport ?? "(openclaw-default)",
+              headerKeys: mcpServerConfig.config.headers ? Object.keys(mcpServerConfig.config.headers) : []
+            });
+            publishMcpServerConfigs.push(mcpServerConfig.config);
+            continue;
+          } else if (mcpServerConfig.reason !== "not-mcp-server-node") {
+            console.log("OpenClaw publish sync: skipping MCP Server sub-node", {
+              type: pluginNode.type,
+              reason: mcpServerConfig.reason,
+              params: JSON.stringify(params).slice(0, 300)
+            });
+            continue;
+          }
+          const pluginSource = params.pluginSource || "local";
+          console.log("OpenClaw publish sync: processing plugin sub-node", {
+            type: pluginNode.type,
+            pluginSource,
+            params: JSON.stringify(params).slice(0, 300)
+          });
+          if (pluginSource === "local") {
+            let pluginDirectory = params.pluginDirectory || "";
+            if (pluginDirectory.includes("$workspace.__dirPath") || pluginDirectory.includes("$workspace[")) {
+              const workflowObj = this.workflow;
+              const dirPath = normalizeOptionalString(workflowObj?.workspace?.__dirPath);
+              console.log("OpenClaw publish sync: resolving $workspace.__dirPath expression", {
+                rawValue: pluginDirectory,
+                workspaceAvailable: !!workflowObj?.workspace,
+                dirPath: dirPath ?? "(not set)"
+              });
+              if (dirPath) {
+                pluginDirectory = dirPath;
+              } else {
+                console.log(
+                  "OpenClaw publish sync: $workspace.__dirPath is not available, skipping"
+                );
+                continue;
+              }
+            } else if (pluginDirectory.includes("{{") || pluginDirectory.startsWith("=")) {
+              console.log(
+                "OpenClaw publish sync: pluginDirectory is an unresolvable expression, skipping",
+                {
+                  rawValue: pluginDirectory
+                }
+              );
+              continue;
+            }
+            pluginDirectory = pluginDirectory.trim();
+            if (!pluginDirectory) {
+              console.log("OpenClaw publish sync: pluginDirectory is empty, skipping");
+              continue;
+            }
+            const manifestPath = (0, import_path.join)(pluginDirectory, "openclaw.plugin.json");
+            let pluginManifest;
+            if ((0, import_fs.existsSync)(manifestPath)) {
+              try {
+                const raw = (0, import_fs.readFileSync)(manifestPath, "utf8").trim();
+                const parsed = JSON.parse(raw);
+                pluginManifest = {
+                  id: typeof parsed.id === "string" ? parsed.id : void 0,
+                  name: typeof parsed.name === "string" ? parsed.name : void 0,
+                  description: typeof parsed.description === "string" ? parsed.description : void 0,
+                  version: typeof parsed.version === "string" ? parsed.version : void 0,
+                  providers: Array.isArray(parsed.providers) ? parsed.providers.filter(
+                    (p) => typeof p === "string"
+                  ) : void 0,
+                  channels: Array.isArray(parsed.channels) ? parsed.channels.filter(
+                    (c) => typeof c === "string"
+                  ) : void 0
+                };
+                console.log("OpenClaw publish sync: loaded local manifest", {
+                  manifestPath,
+                  id: pluginManifest.id,
+                  name: pluginManifest.name
+                });
+              } catch (parseErr) {
+                console.log("OpenClaw publish sync: failed to parse manifest", {
+                  manifestPath,
+                  error: getErrorMessage(parseErr)
+                });
+              }
+            }
+            publishPluginConfigs.push({
+              pluginSource: "local",
+              pluginPath: pluginDirectory,
+              pluginManifest
+            });
+          } else if (pluginSource === "cloud") {
+            const pluginId = (params.pluginId || "").trim();
+            const pluginVersion = (params.pluginVersion || "").trim() || void 0;
+            if (pluginId) {
+              publishPluginConfigs.push({
+                pluginSource: "cloud",
+                pluginId,
+                pluginVersion
+              });
+            }
+          }
+        }
+        if (publishPluginConfigs.length > 0) {
+          try {
+            const syncResult = syncPluginConfig({ pluginConfigs: publishPluginConfigs });
+            console.log("OpenClaw publish sync: plugin config synced on activation", {
+              installedCount: syncResult.installed.length,
+              installed: syncResult.installed,
+              errors: syncResult.errors.length > 0 ? syncResult.errors : void 0,
+              pluginCount: publishPluginConfigs.length
+            });
+          } catch (syncErr) {
+            console.log("OpenClaw publish sync: plugin config sync failed on activation", {
+              error: getErrorMessage(syncErr)
+            });
+          }
+        } else {
+          console.log("OpenClaw publish sync: no plugin configs to sync on activation");
+        }
+        if (publishChannelConfigs.length > 0) {
+          for (const channelConfig of publishChannelConfigs) {
+            try {
+              const syncResult = syncChannelConfig({
+                channelType: channelConfig.channelType,
+                replyAccount: channelConfig.accountId,
+                dmPolicy: channelConfig.dmPolicy,
+                groupPolicy: channelConfig.groupPolicy,
+                allowFrom: channelConfig.allowFrom
+              });
+              console.log("OpenClaw publish sync: channel config synced on activation", {
+                channelType: channelConfig.channelType,
+                changed: syncResult.changed,
+                configPath: syncResult.configPath,
+                targetPath: syncResult.targetPath,
+                accountId: syncResult.accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+                allowFromCount: channelConfig.allowFrom?.length,
+                allowFromStorePath: syncResult.allowFromStorePath
+              });
+            } catch (syncErr) {
+              console.log("OpenClaw publish sync: channel config sync failed on activation", {
+                channelType: channelConfig.channelType,
+                error: getErrorMessage(syncErr)
+              });
+            }
+          }
+        } else {
+          console.log("OpenClaw publish sync: no channel configs to sync on activation");
+        }
+        if (publishMcpServerConfigs.length > 0) {
+          try {
+            const syncResult = syncMcpServerConfig({
+              mcpServerConfigs: publishMcpServerConfigs
+            });
+            console.log("OpenClaw publish sync: MCP Server config synced on activation", {
+              changed: syncResult.changed,
+              configPath: syncResult.configPath,
+              synced: syncResult.synced,
+              skipped: syncResult.skipped.length > 0 ? syncResult.skipped : void 0,
+              serverCount: publishMcpServerConfigs.length
+            });
+          } catch (syncErr) {
+            console.log("OpenClaw publish sync: MCP Server config sync failed on activation", {
+              error: getErrorMessage(syncErr)
+            });
+          }
+        } else {
+          console.log("OpenClaw publish sync: no MCP Server configs to sync on activation");
+        }
+      } catch (publishErr) {
+        console.log("OpenClaw publish sync: activation-time config sync failed (non-fatal)", {
+          error: getErrorMessage(publishErr)
+        });
+      }
+    }
+    return {
+      closeFunction: async () => {
+        console.log("[OpenClawAgentV2] trigger activation closed", {
+          nodeName: node.name,
+          workflowId
+        });
+        console.log("OpenClaw publish sync: trigger deactivated", {
+          workflowId,
+          nodeName: node.name
+        });
+      }
+    };
+  }
+  async execute() {
+    const items = this.getInputData();
+    const returnData = [];
+    console.log("OpenClaw publish sync: execute started", {
+      itemCount: items.length,
+      nodeName: this.getNode().name,
+      workflowId: this.getWorkflow().id
+    });
+    let channelConfigs = [];
+    try {
+      const channelData = await this.getInputConnectionData(import_n8n_workflow.NodeConnectionTypes.AiChannel, 0);
+      if (Array.isArray(channelData)) {
+        channelConfigs = channelData;
+      } else if (channelData && isObject(channelData)) {
+        channelConfigs = [channelData];
+      }
+      console.log("OpenClaw publish sync: resolved channel candidates", {
+        channelCount: channelConfigs.length,
+        channelTypes: channelConfigs.map((c) => c.channelType),
+        channels: channelConfigs.map((channelConfig) => ({
+          channelType: channelConfig.channelType,
+          accountId: channelConfig.accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+          dmPolicy: channelConfig.dmPolicy,
+          groupPolicy: channelConfig.groupPolicy,
+          allowFromCount: channelConfig.allowFrom?.length
+        }))
+      });
+    } catch {
+      console.log("OpenClaw publish sync: no channels connected");
+    }
+    let modelConfig;
+    try {
+      const modelData = await this.getInputConnectionData(import_n8n_workflow.NodeConnectionTypes.AiLanguageModel, 0);
+      console.log("[OpenClawAgentV2] Raw model data from getInputConnectionData", {
+        type: typeof modelData,
+        isArray: Array.isArray(modelData),
+        isObject: isObject(modelData),
+        constructorName: modelData && typeof modelData === "object" ? modelData.constructor?.name : void 0,
+        keys: modelData && typeof modelData === "object" && !Array.isArray(modelData) ? Object.keys(modelData) : void 0,
+        preview: getModelDataPreview(modelData)
+      });
+      let candidate = modelData;
+      if (Array.isArray(modelData) && modelData.length > 0) {
+        candidate = modelData[0];
+        console.log("[OpenClawAgentV2] Model data was array, using first element", {
+          arrayLength: modelData.length,
+          elementType: typeof candidate
+        });
+      }
+      if (candidate && isObject(candidate) && typeof candidate.modelId === "string") {
+        modelConfig = candidate;
+        console.log("[OpenClawAgentV2] Model sub-node connected", {
+          modelId: modelConfig.modelId,
+          modelSource: modelConfig.modelSource,
+          extraKeys: getObjectKeys(modelConfig.extra),
+          baseUrl: normalizeOptionalString(modelConfig.extra?.baseUrl),
+          api: normalizeOptionalString(modelConfig.extra?.api)
+        });
+      } else if (candidate) {
+        console.log("[OpenClawAgentV2] Model data received but does not match ModelConfig shape", {
+          candidateType: typeof candidate,
+          isObj: isObject(candidate),
+          hasModelId: isObject(candidate) ? typeof candidate.modelId : "n/a",
+          candidateKeys: isObject(candidate) ? Object.keys(candidate) : [],
+          candidatePreview: getModelDataPreview(candidate)
+        });
+      }
+    } catch (err) {
+      console.log("[OpenClawAgentV2] No Model sub-node connected, using text parameter fallback", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+    console.log("OpenClaw publish sync: resolved model sync candidates", {
+      hasModelSubNode: !!modelConfig,
+      modelId: modelConfig?.modelId,
+      modelSource: modelConfig?.modelSource ?? "none"
+    });
+    let pluginConfigs = [];
+    let mcpServerConfigs = [];
+    console.log("[OpenClawAgentV2] About to retrieve OpenClaw AiTool sub-node data");
+    try {
+      const pluginData = await this.getInputConnectionData(import_n8n_workflow.NodeConnectionTypes.AiTool, 0);
+      console.log("[OpenClawAgentV2] Raw AiTool data from getInputConnectionData", {
+        type: typeof pluginData,
+        isNull: pluginData === null,
+        isUndefined: pluginData === void 0,
+        isArray: Array.isArray(pluginData),
+        isObject: isObject(pluginData),
+        preview: pluginData ? JSON.stringify(pluginData).slice(0, 500) : "(empty)"
+      });
+      const isPluginConfig = (item) => isObject(item) && typeof item.pluginSource === "string";
+      const isMcpServerConfig = (item) => isObject(item) && item.mcpServerSource === "openclaw" && typeof item.serverName === "string" && typeof item.url === "string";
+      if (Array.isArray(pluginData)) {
+        pluginConfigs = pluginData.filter(isPluginConfig);
+        mcpServerConfigs = pluginData.filter(isMcpServerConfig);
+      } else if (pluginData && isPluginConfig(pluginData)) {
+        pluginConfigs = [pluginData];
+      } else if (pluginData && isMcpServerConfig(pluginData)) {
+        mcpServerConfigs = [pluginData];
+      }
+      if (pluginConfigs.length > 0) {
+        console.log("[OpenClawAgentV2] Plugin sub-nodes connected", {
+          count: pluginConfigs.length,
+          plugins: pluginConfigs.map((p) => ({
+            source: p.pluginSource,
+            path: p.pluginPath,
+            manifestId: p.pluginManifest?.id,
+            manifestName: p.pluginManifest?.name,
+            cloudId: p.pluginId,
+            cloudVersion: p.pluginVersion
+          }))
+        });
+      } else {
+        console.log("[OpenClawAgentV2] No valid Plugin sub-nodes connected");
+      }
+      if (mcpServerConfigs.length > 0) {
+        console.log("[OpenClawAgentV2] MCP Server sub-nodes connected", {
+          count: mcpServerConfigs.length,
+          servers: mcpServerConfigs.map((server) => ({
+            serverName: server.serverName,
+            url: server.url,
+            transport: server.transport ?? "(openclaw-default)",
+            headerKeys: server.headers ? Object.keys(server.headers) : [],
+            connectionTimeoutMs: server.connectionTimeoutMs
+          }))
+        });
+      } else {
+        console.log("[OpenClawAgentV2] No valid MCP Server sub-nodes connected");
+      }
+    } catch (pluginErr) {
+      console.log("[OpenClawAgentV2] OpenClaw AiTool sub-node connection FAILED", {
+        errorType: pluginErr instanceof Error ? pluginErr.constructor.name : typeof pluginErr,
+        errorMessage: pluginErr instanceof Error ? pluginErr.message : String(pluginErr),
+        errorStack: pluginErr instanceof Error ? pluginErr.stack?.split("\n").slice(0, 5).join("\n") : void 0
+      });
+      console.log(
+        "[OpenClawAgentV2] No Plugin or MCP Server sub-nodes connected (AiTool input error)"
+      );
+    }
+    console.log("OpenClaw publish sync: resolved plugin sync candidates", {
+      pluginCount: pluginConfigs.length,
+      localCount: pluginConfigs.filter((p) => p.pluginSource === "local").length,
+      cloudCount: pluginConfigs.filter((p) => p.pluginSource === "cloud").length,
+      manifestIds: pluginConfigs.filter((p) => p.pluginManifest?.id).map((p) => p.pluginManifest?.id),
+      cloudIds: pluginConfigs.filter((p) => p.pluginId).map((p) => p.pluginId)
+    });
+    console.log("OpenClaw publish sync: resolved MCP Server sync candidates", {
+      serverCount: mcpServerConfigs.length,
+      serverNames: mcpServerConfigs.map((server) => server.serverName),
+      transports: mcpServerConfigs.map((server) => server.transport ?? "(openclaw-default)")
+    });
+    if (mcpServerConfigs.length > 0) {
+      try {
+        const syncResult = syncMcpServerConfig({ mcpServerConfigs });
+        console.log("OpenClaw publish sync: MCP Server config sync completed before execute", {
+          changed: syncResult.changed,
+          configPath: syncResult.configPath,
+          synced: syncResult.synced,
+          skipped: syncResult.skipped.length > 0 ? syncResult.skipped : void 0
+        });
+      } catch (mcpSyncErr) {
+        console.log("OpenClaw publish sync: MCP Server config sync failed before execute", {
+          error: getErrorMessage(mcpSyncErr)
+        });
+      }
+    }
+    for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+      try {
+        const message = normalizeOptionalString(this.getNodeParameter("message", itemIndex));
+        if (!message) {
+          throw new import_n8n_workflow.NodeOperationError(this.getNode(), "Message must not be empty", { itemIndex });
+        }
+        const openClawEnv = {};
+        if (pluginConfigs.length > 0) {
+          const localPlugins = pluginConfigs.filter((p) => p.pluginSource === "local");
+          const cloudPlugins = pluginConfigs.filter((p) => p.pluginSource === "cloud");
+          const pluginPaths = localPlugins.map((p) => p.pluginPath).filter((p) => typeof p === "string" && p.length > 0);
+          const cloudSpecs = cloudPlugins.map((p) => {
+            if (!p.pluginId) return void 0;
+            return p.pluginVersion ? `clawhub:${p.pluginId}@${p.pluginVersion}` : `clawhub:${p.pluginId}`;
+          }).filter((s) => typeof s === "string");
+          if (pluginPaths.length > 0) {
+            openClawEnv.OPENCLAW_PLUGIN_PATHS = pluginPaths.join(";");
+            console.log("[OpenClawAgentV2] Set OPENCLAW_PLUGIN_PATHS env var", {
+              itemIndex,
+              value: openClawEnv.OPENCLAW_PLUGIN_PATHS
+            });
+          }
+          if (cloudSpecs.length > 0) {
+            openClawEnv.OPENCLAW_CLAWHUB_PLUGINS = cloudSpecs.join(";");
+            console.log("[OpenClawAgentV2] Set OPENCLAW_CLAWHUB_PLUGINS env var", {
+              itemIndex,
+              value: openClawEnv.OPENCLAW_CLAWHUB_PLUGINS
+            });
+          }
+        }
+        const telegramChannel = channelConfigs.find((c) => c.channelType === "telegram");
+        const primaryChannel = channelConfigs[0];
+        if (telegramChannel?.botToken) {
+          openClawEnv.TELEGRAM_BOT_TOKEN = telegramChannel.botToken;
+          const telegramSync = syncChannelConfig({
+            channelType: "telegram",
+            botToken: telegramChannel.botToken,
+            replyAccount: telegramChannel.accountId,
+            dmPolicy: telegramChannel.dmPolicy,
+            groupPolicy: telegramChannel.groupPolicy,
+            allowFrom: telegramChannel.allowFrom ?? []
+          });
+          console.log("OpenClaw publish sync: Telegram channel config synced", {
+            itemIndex,
+            changed: telegramSync.changed,
+            configPath: telegramSync.configPath,
+            targetPath: telegramSync.targetPath,
+            accountId: telegramSync.accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID,
+            allowFromCount: telegramChannel.allowFrom?.length ?? 0,
+            allowFromStorePath: telegramSync.allowFromStorePath
+          });
+        }
+        const whatsappChannel = channelConfigs.find((c) => c.channelType === "whatsapp");
+        if (whatsappChannel?.accessToken) {
+          openClawEnv.WHATSAPP_ACCESS_TOKEN = whatsappChannel.accessToken;
+          if (whatsappChannel.phoneNumberId) {
+            openClawEnv.WHATSAPP_PHONE_NUMBER_ID = whatsappChannel.phoneNumberId;
+          }
+          const whatsappSync = syncChannelConfig({
+            channelType: "whatsapp",
+            botToken: whatsappChannel.accessToken,
+            replyAccount: whatsappChannel.accountId
+          });
+          console.log("OpenClaw publish sync: WhatsApp channel config synced", {
+            itemIndex,
+            changed: whatsappSync.changed,
+            configPath: whatsappSync.configPath,
+            targetPath: whatsappSync.targetPath,
+            accountId: whatsappSync.accountId ?? OPENCLAW_DEFAULT_ACCOUNT_ID
+          });
+        }
+        console.log("OpenClaw publish sync: channel config sync completed", {
+          itemIndex,
+          hasTelegram: !!telegramChannel,
+          hasWhatsApp: !!whatsappChannel,
+          channelCount: channelConfigs.length
+        });
+        let args = ["agent", "--message", message, "--json"];
+        let processTimeoutMs;
+        const gatewayParams = {
+          message,
+          idempotencyKey: (0, import_crypto.randomUUID)()
+        };
+        const selectorType = this.getNodeParameter("selectorType", itemIndex);
+        if (selectorType !== "default") {
+          const parameterName = selectorTypeToParameterName[selectorType];
+          const value = normalizeOptionalString(this.getNodeParameter(parameterName, itemIndex));
+          if (!value) {
+            throw new import_n8n_workflow.NodeOperationError(
+              this.getNode(),
+              `${parameterName} must not be empty when Route By is ${selectorType}`,
+              { itemIndex }
+            );
+          }
+          args.push(selectorTypeToCliFlag[selectorType], value);
+          if (selectorType === "agent") {
+            gatewayParams.agentId = value;
+          } else if (selectorType === "sessionId") {
+            gatewayParams.sessionId = value;
+          } else {
+            gatewayParams.to = value;
+          }
+        }
+        const resolvedModel = modelConfig?.modelId;
+        console.log("[OpenClawAgentV2] Model resolution", {
+          itemIndex,
+          connectedModel: modelConfig?.modelId,
+          resolvedModel,
+          modelSource: modelConfig?.modelSource ?? "none"
+        });
+        if (resolvedModel) {
+          args.push("--model", resolvedModel);
+          gatewayParams.model = resolvedModel;
+        }
+        const openCodeFreeAuth = applyOpenCodeFreeAuthEnv({
+          env: openClawEnv,
+          modelConfig,
+          modelId: resolvedModel
+        });
+        console.log("[OpenClawAgentV2] OpenCode free auth env resolution", {
+          itemIndex,
+          resolvedModel,
+          modelSource: modelConfig?.modelSource ?? "text-parameter",
+          applied: openCodeFreeAuth.applied,
+          envVar: openCodeFreeAuth.envVar,
+          reason: openCodeFreeAuth.reason
+        });
+        const nineRouterConfigSync = syncNineRouterModelConfig({
+          modelConfig,
+          modelId: resolvedModel
+        });
+        console.log("[OpenClawAgentV2] 9Router model config sync", {
+          itemIndex,
+          hasModelSubNode: !!modelConfig,
+          resolvedModel,
+          modelSource: modelConfig?.modelSource ?? "text-parameter",
+          selectorType,
+          changed: nineRouterConfigSync.changed,
+          reason: nineRouterConfigSync.reason,
+          targetPath: nineRouterConfigSync.targetPath,
+          modelRef: nineRouterConfigSync.modelRef,
+          configPath: nineRouterConfigSync.configPath,
+          existingBaseUrl: nineRouterConfigSync.existingBaseUrl,
+          restart: "publish-only"
+        });
+        console.log("OpenClaw publish sync: model config sync completed", {
+          itemIndex,
+          resolvedModel,
+          modelSource: modelConfig?.modelSource ?? "text-parameter",
+          syncChanged: nineRouterConfigSync.changed,
+          syncReason: nineRouterConfigSync.reason
+        });
+        const thinking = normalizeOptionalString(this.getNodeParameter("thinking", itemIndex));
+        if (thinking) {
+          args.push("--thinking", thinking);
+          gatewayParams.thinking = thinking;
+        }
+        const runLocally = this.getNodeParameter("local", itemIndex, false) === true;
+        if (runLocally) args.push("--local");
+        const deliverReply = this.getNodeParameter("deliver", itemIndex, false) === true;
+        if (deliverReply) {
+          args.push("--deliver");
+          gatewayParams.deliver = true;
+        }
+        const timeout = Number(
+          this.getNodeParameter("options.timeout", itemIndex, DEFAULT_TIMEOUT_SECONDS)
+        );
+        const timeoutSeconds = Number.isFinite(timeout) && timeout > 0 ? Math.floor(timeout) : DEFAULT_TIMEOUT_SECONDS;
+        args.push("--timeout", String(timeoutSeconds));
+        gatewayParams.timeout = timeoutSeconds;
+        if (deliverReply && primaryChannel) {
+          const replyChannel = primaryChannel.channelType;
+          args.push("--reply-channel", replyChannel);
+          gatewayParams.replyChannel = replyChannel;
+          if (primaryChannel.accountId) {
+            args.push("--reply-account", primaryChannel.accountId);
+            gatewayParams.replyAccountId = primaryChannel.accountId;
+          }
+        }
+        const verbose = normalizeOptionalString(
+          this.getNodeParameter("options.verbose", itemIndex, "")
+        );
+        if (verbose) args.push("--verbose", verbose);
+        const binaryPath = normalizeOptionalString(this.getNodeParameter("options.binaryPath", itemIndex, "")) ?? "openclaw";
+        const workingDirectory = normalizeOptionalString(
+          this.getNodeParameter("options.workingDirectory", itemIndex, "")
+        );
+        if (workingDirectory && (!(0, import_fs.existsSync)(workingDirectory) || !(0, import_fs.statSync)(workingDirectory).isDirectory())) {
+          throw new import_n8n_workflow.NodeOperationError(
+            this.getNode(),
+            `Working directory does not exist or is not a directory: ${workingDirectory}`,
+            { itemIndex }
+          );
+        }
+        const systemMessage = normalizeOptionalString(
+          this.getNodeParameter("options.systemMessage", itemIndex, "")
+        );
+        if (systemMessage) {
+          if (runLocally) {
+            throw new import_n8n_workflow.NodeOperationError(
+              this.getNode(),
+              "System Message is only supported in OpenClaw Gateway mode. Disable Run Locally to use it.",
+              { itemIndex }
+            );
+          }
+          gatewayParams.extraSystemPrompt = systemMessage;
+          const rpcTimeoutMs = getWatchdogTimeoutMs(timeoutSeconds);
+          args = getGatewayCallArgs(gatewayParams, rpcTimeoutMs);
+          processTimeoutMs = rpcTimeoutMs + 1e4;
+        }
+        console.log("OpenClaw publish sync: launching CLI", {
+          itemIndex,
+          binaryPath,
+          argCount: args.length,
+          cwd: workingDirectory ?? "(default)",
+          envKeys: Object.keys(openClawEnv),
+          resolvedModel,
+          pluginCount: pluginConfigs.length,
+          mcpServerCount: mcpServerConfigs.length,
+          channelCount: channelConfigs.length
+        });
+        const result = await runOpenClawCli({
+          binaryPath,
+          args,
+          cwd: workingDirectory,
+          timeoutMs: processTimeoutMs ?? getWatchdogTimeoutMs(timeoutSeconds),
+          env: openClawEnv,
+          abortSignal: this.getExecutionCancelSignal()
+        });
+        console.log("OpenClaw publish sync: CLI execution completed", {
+          itemIndex,
+          exitCode: result.exitCode,
+          signal: result.signal,
+          stdoutLength: result.stdout.length,
+          stderrLength: result.stderr.length
+        });
+        if (result.exitCode !== 0) {
+          throw new import_n8n_workflow.NodeOperationError(
+            this.getNode(),
+            result.stderr.trim() || result.stdout.trim() || `OpenClaw CLI exited with code ${result.exitCode ?? `signal ${result.signal}`}`,
+            { itemIndex }
+          );
+        }
+        const json = parseOpenClawOutput(result.stdout);
+        json.command = result.command;
+        if (this.getNodeParameter("options.includeRawOutput", itemIndex, false) === true) {
+          json.rawOutput = { stdout: result.stdout, stderr: result.stderr };
+        }
+        returnData.push({ json, pairedItem: { item: itemIndex } });
+      } catch (error) {
+        if (this.continueOnFail()) {
+          returnData.push({
+            json: { error: getErrorMessage(error) },
+            pairedItem: { item: itemIndex }
+          });
+          continue;
+        }
+        throw error;
+      }
+    }
+    return [returnData];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OpenClawAgentV2
+});
+//# sourceMappingURL=OpenClawAgentV2.node.js.map