@workclaw/openclaw-workclaw 1.0.30 → 1.0.33

package/dist/node_modules/.pnpm/openclaw@2026.4.14_@emnapi__48b26e3018d2f6ac73290fb8288ef325/node_modules/openclaw/node_modules/yaml/browser/dist/visit.js

@@ -0,0 +1,104 @@
+import { isDocument, isNode, isPair, isCollection, isMap, isSeq, isScalar, isAlias } from "./nodes/identity.js";
+const BREAK = Symbol("break visit");
+const SKIP = Symbol("skip children");
+const REMOVE = Symbol("remove node");
+function visit(node, visitor) {
+  const visitor_ = initVisitor(visitor);
+  if (isDocument(node)) {
+    const cd = visit_(null, node.contents, visitor_, Object.freeze([node]));
+    if (cd === REMOVE)
+      node.contents = null;
+  } else
+    visit_(null, node, visitor_, Object.freeze([]));
+}
+visit.BREAK = BREAK;
+visit.SKIP = SKIP;
+visit.REMOVE = REMOVE;
+function visit_(key, node, visitor, path) {
+  const ctrl = callVisitor(key, node, visitor, path);
+  if (isNode(ctrl) || isPair(ctrl)) {
+    replaceNode(key, path, ctrl);
+    return visit_(key, ctrl, visitor, path);
+  }
+  if (typeof ctrl !== "symbol") {
+    if (isCollection(node)) {
+      path = Object.freeze(path.concat(node));
+      for (let i = 0; i < node.items.length; ++i) {
+        const ci = visit_(i, node.items[i], visitor, path);
+        if (typeof ci === "number")
+          i = ci - 1;
+        else if (ci === BREAK)
+          return BREAK;
+        else if (ci === REMOVE) {
+          node.items.splice(i, 1);
+          i -= 1;
+        }
+      }
+    } else if (isPair(node)) {
+      path = Object.freeze(path.concat(node));
+      const ck = visit_("key", node.key, visitor, path);
+      if (ck === BREAK)
+        return BREAK;
+      else if (ck === REMOVE)
+        node.key = null;
+      const cv = visit_("value", node.value, visitor, path);
+      if (cv === BREAK)
+        return BREAK;
+      else if (cv === REMOVE)
+        node.value = null;
+    }
+  }
+  return ctrl;
+}
+function initVisitor(visitor) {
+  if (typeof visitor === "object" && (visitor.Collection || visitor.Node || visitor.Value)) {
+    return Object.assign({
+      Alias: visitor.Node,
+      Map: visitor.Node,
+      Scalar: visitor.Node,
+      Seq: visitor.Node
+    }, visitor.Value && {
+      Map: visitor.Value,
+      Scalar: visitor.Value,
+      Seq: visitor.Value
+    }, visitor.Collection && {
+      Map: visitor.Collection,
+      Seq: visitor.Collection
+    }, visitor);
+  }
+  return visitor;
+}
+function callVisitor(key, node, visitor, path) {
+  if (typeof visitor === "function")
+    return visitor(key, node, path);
+  if (isMap(node))
+    return visitor.Map?.(key, node, path);
+  if (isSeq(node))
+    return visitor.Seq?.(key, node, path);
+  if (isPair(node))
+    return visitor.Pair?.(key, node, path);
+  if (isScalar(node))
+    return visitor.Scalar?.(key, node, path);
+  if (isAlias(node))
+    return visitor.Alias?.(key, node, path);
+  return void 0;
+}
+function replaceNode(key, path, node) {
+  const parent = path[path.length - 1];
+  if (isCollection(parent)) {
+    parent.items[key] = node;
+  } else if (isPair(parent)) {
+    if (key === "key")
+      parent.key = node;
+    else
+      parent.value = node;
+  } else if (isDocument(parent)) {
+    parent.contents = node;
+  } else {
+    const pt = isAlias(parent) ? "alias" : "scalar";
+    throw new Error(`Cannot replace node with ${pt} parent`);
+  }
+}
+export {
+  visit
+};

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

@@ -0,0 +1,199 @@
+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 { getWorkclawConnectionConfig, getWorkclawLogger } from "../../../src/runtime.js";
+function normalizeAccountId(accountId) {
+  return String(accountId ?? "").trim();
+}
+function makeLookupKey(userId, agentId) {
+  return `${userId}|${agentId}`;
+}
+const lookupCache = /* @__PURE__ */ new Map();
+const accountIndex = /* @__PURE__ */ new Map();
+let nextWorkspaceNum = 1;
+function buildAccountMap(cfg) {
+  lookupCache.clear();
+  accountIndex.clear();
+  nextWorkspaceNum = 1;
+  const _WorkclawConfig = cfg.channels?.["openclaw-workclaw"] || {};
+  const accounts = _WorkclawConfig?.accounts;
+  if (!accounts || typeof accounts !== "object")
+    return;
+  for (const [accountId, accountCfg] of Object.entries(accounts)) {
+    if (!accountCfg)
+      continue;
+    const cfg2 = accountCfg;
+    const userId = cfg2.userId || _WorkclawConfig.userId;
+    const agentId = cfg2.agentId;
+    if (!agentId)
+      continue;
+    if (userId) {
+      const key = makeLookupKey(String(userId), String(agentId));
+      lookupCache.set(key, accountId);
+    }
+    accountIndex.set(accountId, { userId: String(userId ?? ""), agentId: String(agentId) });
+    if (accountId.startsWith("workspace-")) {
+      const num = Number.parseInt(accountId.slice(accountId.lastIndexOf("-") + 1), 10);
+      if (!Number.isNaN(num) && num >= nextWorkspaceNum) {
+        nextWorkspaceNum = num + 1;
+      }
+    }
+  }
+  if (!accountIndex.has(DEFAULT_ACCOUNT_ID) && _WorkclawConfig.userId && _WorkclawConfig.agentId) {
+    const userId = String(_WorkclawConfig.userId);
+    const agentId = String(_WorkclawConfig.agentId);
+    const key = makeLookupKey(userId, agentId);
+    lookupCache.set(key, DEFAULT_ACCOUNT_ID);
+    accountIndex.set(DEFAULT_ACCOUNT_ID, { userId, agentId });
+  }
+  getWorkclawLogger().info(`[AccountManager] Built account map with ${lookupCache.size} entries, nextWorkspaceNum=${nextWorkspaceNum}`);
+}
+function resolveAccountByUserIdAndAgentId(cfg, userId, agentId) {
+  const key = makeLookupKey(userId, agentId);
+  if (lookupCache.has(key)) {
+    return lookupCache.get(key);
+  }
+  const _WorkclawConfig = cfg.channels?.["openclaw-workclaw"] || {};
+  const accounts = _WorkclawConfig?.accounts;
+  if (accounts && typeof accounts === "object") {
+    for (const [accountId, accountCfg] of Object.entries(accounts)) {
+      if (!accountCfg)
+        continue;
+      const cfg2 = accountCfg;
+      const accountUserId = cfg2.userId || _WorkclawConfig.userId;
+      if (String(accountUserId) === userId && String(cfg2.agentId) === agentId) {
+        lookupCache.set(key, accountId);
+        accountIndex.set(accountId, { userId, agentId });
+        return accountId;
+      }
+    }
+  }
+  if (String(_WorkclawConfig.userId ?? "") === userId && String(_WorkclawConfig.agentId ?? "") === agentId) {
+    lookupCache.set(key, DEFAULT_ACCOUNT_ID);
+    accountIndex.set(DEFAULT_ACCOUNT_ID, { userId, agentId });
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return null;
+}
+function allocateWorkerAccountId(_cfg, userId, agentId) {
+  const accountId = `workspace-${nextWorkspaceNum}`;
+  nextWorkspaceNum++;
+  const key = makeLookupKey(userId, agentId);
+  lookupCache.set(key, accountId);
+  accountIndex.set(accountId, { userId, agentId });
+  getWorkclawLogger().info(`[AccountManager] Allocated accountId=${accountId} for userId=${userId} agentId=${agentId}`);
+  return accountId;
+}
+function refreshAccountCache(cfg) {
+  buildAccountMap(cfg);
+}
+function listConfiguredAccountIds(cfg) {
+  const accounts = cfg.channels?.["openclaw-workclaw"]?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return [];
+  }
+  return Object.keys(accounts).filter(Boolean);
+}
+function hasPluginLevelWorkClawConfig(cfg) {
+  const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+  const key = typeof workclawCfg?.appKey === "string" ? workclawCfg.appKey.trim() : "";
+  const secret = typeof workclawCfg?.appSecret === "string" ? workclawCfg.appSecret.trim() : "";
+  return Boolean(key && secret);
+}
+function listWorkclawAccountIds(cfg) {
+  const ids = listConfiguredAccountIds(cfg);
+  if (ids.length === 0) {
+    if (hasPluginLevelWorkClawConfig(cfg)) {
+      return [DEFAULT_ACCOUNT_ID];
+    }
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+function resolveDefaultWorkclawAccountId(cfg) {
+  const ids = listWorkclawAccountIds(cfg);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function resolveAccountConfig(cfg, accountId) {
+  const accounts = cfg.channels?.["openclaw-workclaw"]?.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return void 0;
+  }
+  return accounts[accountId];
+}
+function hasWorkClawConfig(config) {
+  const key = typeof config.appKey === "string" ? config.appKey.trim() : "";
+  const secret = typeof config.appSecret === "string" ? config.appSecret.trim() : "";
+  return Boolean(key && secret);
+}
+function isWorkclawAccountConfigured(config) {
+  return hasWorkClawConfig(config);
+}
+function mergeWorkclawAccountConfig(cfg, accountId) {
+  const workclawCfg = cfg.channels?.["openclaw-workclaw"];
+  const { accounts: _ignored, ...base } = workclawCfg ?? {};
+  const account = resolveAccountConfig(cfg, accountId) ?? {};
+  return { ...base, ...account };
+}
+function resolveWorkclawAccount(params) {
+  const accountId = normalizeAccountId(params.accountId);
+  const workclawCfg = params.cfg.channels?.["openclaw-workclaw"];
+  const baseEnabled = workclawCfg?.enabled !== false;
+  const merged = mergeWorkclawAccountConfig(params.cfg, accountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  return {
+    accountId,
+    enabled,
+    configured: isWorkclawAccountConfigured(merged),
+    name: merged.name?.trim() || void 0,
+    config: merged
+  };
+}
+function resolveWorkclawAccountWithCache(params) {
+  const account = resolveWorkclawAccount(params);
+  const cachedConfig = getWorkclawConnectionConfig(account.accountId);
+  if (cachedConfig) {
+    account.config.appKey = cachedConfig.appKey || account.config.appKey;
+    account.config.appSecret = cachedConfig.appSecret || account.config.appSecret;
+    if (cachedConfig.baseUrl)
+      account.config.baseUrl = cachedConfig.baseUrl;
+    if (cachedConfig.websocketUrl !== void 0)
+      account.config.websocketUrl = cachedConfig.websocketUrl;
+    if (cachedConfig.localIp !== void 0)
+      account.config.localIp = cachedConfig.localIp;
+    if (cachedConfig.allowInsecureTls !== void 0)
+      account.config.allowInsecureTls = cachedConfig.allowInsecureTls;
+    if (cachedConfig.requestTimeout !== void 0)
+      account.config.requestTimeout = cachedConfig.requestTimeout;
+  }
+  return account;
+}
+function inspectWorkclawCredentials(workclawCfg) {
+  const appKey = typeof workclawCfg?.appKey === "string" ? workclawCfg.appKey.trim() : "";
+  const appSecret = typeof workclawCfg?.appSecret === "string" ? workclawCfg.appSecret.trim() : "";
+  if (!appKey || !appSecret) {
+    return null;
+  }
+  return async () => {
+    try {
+      return { ok: true };
+    } catch {
+      return { ok: false };
+    }
+  };
+}
+export {
+  allocateWorkerAccountId,
+  buildAccountMap,
+  inspectWorkclawCredentials,
+  isWorkclawAccountConfigured,
+  listWorkclawAccountIds,
+  normalizeAccountId,
+  refreshAccountCache,
+  resolveAccountByUserIdAndAgentId,
+  resolveDefaultWorkclawAccountId,
+  resolveWorkclawAccount,
+  resolveWorkclawAccountWithCache
+};

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

@@ -0,0 +1,133 @@
+import { normalizeAccountId } from "../accounts.js";
+import { Buffer } from "node:buffer";
+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");
+}
+async function loadRuntimeConfig(api) {
+  const runtimeConfig = api.runtime?.config;
+  if (runtimeConfig?.loadConfig) {
+    return runtimeConfig.loadConfig();
+  }
+  return api.config;
+}
+async function writeRuntimeConfig(api, config) {
+  const runtimeConfig = api.runtime?.config;
+  if (runtimeConfig?.writeConfigFile) {
+    await runtimeConfig.writeConfigFile(config);
+    return;
+  }
+  throw new Error("Config write not supported");
+}
+function getAccountMap(config) {
+  const channels = config?.channels && typeof config.channels === "object" ? config.channels : {};
+  const openclawWorkclaw = channels["openclaw-workclaw"] && typeof channels["openclaw-workclaw"] === "object" ? channels["openclaw-workclaw"] : {};
+  const accounts = openclawWorkclaw.accounts && typeof openclawWorkclaw.accounts === "object" ? openclawWorkclaw.accounts : {};
+  return { ...accounts };
+}
+function withAccounts(config, accounts) {
+  const channels = config?.channels && typeof config.channels === "object" ? config.channels : {};
+  const openclawWorkclaw = channels["openclaw-workclaw"] && typeof channels["openclaw-workclaw"] === "object" ? channels["openclaw-workclaw"] : {};
+  return {
+    ...config,
+    channels: {
+      ...channels,
+      "openclaw-workclaw": {
+        ...openclawWorkclaw,
+        accounts
+      }
+    }
+  };
+}
+function createAccountsApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "", "http://localhost");
+    const idRaw = url.searchParams.get("id") ?? url.searchParams.get("accountId");
+    const accountId = idRaw ? normalizeAccountId(idRaw) : null;
+    if (method === "GET") {
+      const cfg = await loadRuntimeConfig(api);
+      const accounts = getAccountMap(cfg);
+      if (accountId) {
+        const account = accounts[accountId];
+        if (!account) {
+          sendJson(res, 404, { ok: false, error: "Not Found" });
+          return;
+        }
+        sendJson(res, 200, { ok: true, accountId, config: account });
+        return;
+      }
+      const entries = Object.entries(accounts).map(([id, config]) => ({
+        accountId: id,
+        config
+      }));
+      sendJson(res, 200, { ok: true, accounts: entries });
+      return;
+    }
+    if (method === "POST" || method === "PUT") {
+      const raw = await readRequestBody(req);
+      let input = {};
+      try {
+        input = raw ? JSON.parse(raw) : {};
+      } catch {
+        sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      const inputId = input?.accountId ?? input?.id;
+      const normalizedId = inputId ? normalizeAccountId(String(inputId)) : "";
+      const patch = input?.config;
+      if (!normalizedId || !patch || typeof patch !== "object") {
+        sendJson(res, 400, { ok: false, error: "Missing accountId or config" });
+        return;
+      }
+      const cfg = await loadRuntimeConfig(api);
+      const accounts = getAccountMap(cfg);
+      if (method === "POST" && accounts[normalizedId]) {
+        sendJson(res, 409, { ok: false, error: "Account already exists" });
+        return;
+      }
+      if (method === "PUT" && !accounts[normalizedId]) {
+        sendJson(res, 404, { ok: false, error: "Not Found" });
+        return;
+      }
+      const next = method === "PUT" ? { ...accounts[normalizedId], ...patch } : patch;
+      const updated = withAccounts(cfg, { ...accounts, [normalizedId]: next });
+      await writeRuntimeConfig(api, updated);
+      sendJson(res, 200, { ok: true, accountId: normalizedId });
+      return;
+    }
+    if (method === "DELETE") {
+      if (!accountId) {
+        sendJson(res, 400, { ok: false, error: "Missing accountId" });
+        return;
+      }
+      const cfg = await loadRuntimeConfig(api);
+      const accounts = getAccountMap(cfg);
+      if (!accounts[accountId]) {
+        sendJson(res, 404, { ok: false, error: "Not Found" });
+        return;
+      }
+      const { [accountId]: _ignored, ...rest } = accounts;
+      const updated = withAccounts(cfg, rest);
+      await writeRuntimeConfig(api, updated);
+      sendJson(res, 200, { ok: true, accountId, deleted: true });
+      return;
+    }
+    sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+  };
+}
+export {
+  createAccountsApiHandler
+};

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

@@ -0,0 +1,105 @@
+import { readFile, stat, mkdir, writeFile, unlink } from "node:fs/promises";
+import path from "node:path";
+import { Buffer } from "node:buffer";
+import { resolveWorkspaceDir } from "./workspace.js";
+const promptNames = ["SOUL.md", "USER.md"];
+function normalizePromptName(raw) {
+  const name = String(raw ?? "").trim().toUpperCase();
+  if (name === "SOUL" || name === "SOUL.MD")
+    return "SOUL.md";
+  if (name === "USER" || name === "USER.MD")
+    return "USER.md";
+  return null;
+}
+function resolvePromptPath(api, name) {
+  return path.join(resolveWorkspaceDir(api), name);
+}
+function sendJson(res, statusCode, payload) {
+  res.statusCode = statusCode;
+  res.setHeader("Content-Type", "application/json");
+  res.end(JSON.stringify(payload));
+}
+function createPromptsApiHandler(api) {
+  return async (req, res) => {
+    const method = String(req.method ?? "GET").toUpperCase();
+    const url = new URL(req.url ?? "", "http://localhost");
+    const name = normalizePromptName(url.searchParams.get("name"));
+    if (method === "GET") {
+      if (name) {
+        const filePath = resolvePromptPath(api, name);
+        try {
+          const content = await readFile(filePath, "utf-8");
+          sendJson(res, 200, { ok: true, name, content });
+          return;
+        } catch {
+          sendJson(res, 404, { ok: false, error: "Not Found" });
+          return;
+        }
+      }
+      const entries = await Promise.all(
+        promptNames.map(async (promptName) => {
+          const filePath = resolvePromptPath(api, promptName);
+          try {
+            const info = await stat(filePath);
+            return { name: promptName, exists: true, bytes: info.size };
+          } catch {
+            return { name: promptName, exists: false, bytes: 0 };
+          }
+        })
+      );
+      sendJson(res, 200, { ok: true, entries });
+      return;
+    }
+    if (method === "PUT" || method === "POST") {
+      const raw = await readRequestBody(req);
+      let input = {};
+      try {
+        input = raw ? JSON.parse(raw) : {};
+      } catch {
+        sendJson(res, 400, { ok: false, error: "Invalid JSON" });
+        return;
+      }
+      const targetName = normalizePromptName(input?.name);
+      const content = typeof input?.content === "string" ? input.content : null;
+      if (!targetName || content === null) {
+        sendJson(res, 400, { ok: false, error: "Missing name or content" });
+        return;
+      }
+      const workspaceDir = resolveWorkspaceDir(api);
+      await mkdir(workspaceDir, { recursive: true });
+      await writeFile(resolvePromptPath(api, targetName), content, { encoding: "utf-8" });
+      sendJson(res, 200, { ok: true, name: targetName });
+      return;
+    }
+    if (method === "DELETE") {
+      if (!name) {
+        sendJson(res, 400, { ok: false, error: "Missing name" });
+        return;
+      }
+      const filePath = resolvePromptPath(api, name);
+      try {
+        await unlink(filePath);
+        sendJson(res, 200, { ok: true, name, deleted: true });
+        return;
+      } catch {
+        sendJson(res, 200, { ok: true, name, deleted: false });
+        return;
+      }
+    }
+    sendJson(res, 405, { ok: false, error: "Method Not Allowed" });
+  };
+}
+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");
+}
+export {
+  createPromptsApiHandler
+};