@workclaw/openclaw-workclaw 1.0.18 → 1.0.20

package/dist/src/accounts.js

@@ -0,0 +1,279 @@
+import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id';
+import { getWorkclawLogger, getWorkclawConnectionConfig } from './runtime.js';
+// =============================================================================
+// In-memory lookup cache for (userId, agentId) → workspace-N accountId
+// Problem: OpenClaw doesn't support dashes in account IDs, agentId can be negative
+// Solution: workspace-N naming + in-memory Map for O(1) lookups
+// =============================================================================
+/**
+ * Normalize account ID by trimming whitespace
+ */
+export function normalizeAccountId(accountId) {
+    return String(accountId ?? '').trim();
+}
+/**
+ * Key format for the lookup map: "userId|agentId"
+ */
+function makeLookupKey(userId, agentId) {
+    return `${userId}|${agentId}`;
+}
+/**
+ * In-memory map: lookupKey -> accountId
+ */
+const lookupCache = new Map();
+/**
+ * In-memory map: accountId -> { userId, agentId }
+ */
+const accountIndex = new Map();
+/**
+ * Next workspace number to allocate
+ */
+let nextWorkspaceNum = 1;
+/**
+ * Build the lookup cache from existing accounts in cfg.
+ * Called once at gateway startup.
+ */
+export 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 userId = accountCfg.userId || _WorkclawConfig.userId;
+        const agentId = accountCfg.agentId;
+        if (!agentId)
+            continue;
+        // userId may not be present for config-defined accounts; only build
+        // lookup if userId is available (dynamically created accounts have it)
+        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;
+            }
+        }
+    }
+    // 默认账户允许直接使用顶层 userId/agentId，不要求必须存在 accounts.default
+    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}`);
+}
+/**
+ * Resolve accountId by userId + agentId.
+ * First checks cache, then falls back to iteration.
+ */
+export 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 accountUserId = accountCfg.userId || _WorkclawConfig.userId;
+            if (String(accountUserId) === userId && String(accountCfg.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;
+}
+/**
+ * Allocate a new workspace-N accountId and register it in the map.
+ */
+export 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;
+}
+/**
+ * Refresh the cache when an account's userId or agentId changes.
+ */
+export function refreshAccountCache(cfg) {
+    buildAccountMap(cfg);
+}
+// =============================================================================
+// Account config resolution (pure functions, no in-memory state)
+// =============================================================================
+/**
+ * List all configured account IDs from the accounts field.
+ */
+function listConfiguredAccountIds(cfg) {
+    const accounts = cfg.channels?.['openclaw-workclaw']?.accounts;
+    if (!accounts || typeof accounts !== 'object') {
+        return [];
+    }
+    return Object.keys(accounts).filter(Boolean);
+}
+/**
+ * Check if plugin-level workclaw config exists (appKey + appSecret)
+ */
+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);
+}
+/**
+ * List all account IDs.
+ * If no accounts are configured but plugin has workclaw config, returns [DEFAULT_ACCOUNT_ID].
+ */
+export function listWorkclawAccountIds(cfg) {
+    const ids = listConfiguredAccountIds(cfg);
+    if (ids.length === 0) {
+        // 如果没有配置账户，但插件级别有 workclaw 配置，返回默认账户
+        if (hasPluginLevelWorkClawConfig(cfg)) {
+            return [DEFAULT_ACCOUNT_ID];
+        }
+        // Backward compatibility: no accounts configured, use default
+        return [DEFAULT_ACCOUNT_ID];
+    }
+    return [...ids].toSorted((a, b) => a.localeCompare(b));
+}
+/**
+ * Resolve the default account ID.
+ */
+export function resolveDefaultWorkclawAccountId(cfg) {
+    const ids = listWorkclawAccountIds(cfg);
+    if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+        return DEFAULT_ACCOUNT_ID;
+    }
+    return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+/**
+ * Get the raw account-specific config.
+ */
+function resolveAccountConfig(cfg, accountId) {
+    const accounts = cfg.channels?.['openclaw-workclaw']?.accounts;
+    if (!accounts || typeof accounts !== 'object') {
+        return undefined;
+    }
+    return accounts[accountId];
+}
+function hasWorkClawConfig(config) {
+    const key = typeof config.appKey === 'string' ? config.appKey.trim() : '';
+    const secret = typeof config.appSecret === 'string' ? config.appSecret.trim() : '';
+    // 只要有 appKey 和 appSecret 就认为配置了 workclaw（agentId 可以动态添加）
+    return Boolean(key && secret);
+}
+export function isWorkclawAccountConfigured(config) {
+    return hasWorkClawConfig(config);
+}
+/**
+ * Merge top-level config with account-specific config.
+ * Account-specific fields override top-level fields.
+ */
+function mergeWorkclawAccountConfig(cfg, accountId) {
+    const workclawCfg = cfg.channels?.['openclaw-workclaw'];
+    // Extract base config (exclude accounts field to avoid recursion)
+    const { accounts: _ignored, ...base } = workclawCfg ?? {};
+    // Get account-specific overrides
+    const account = resolveAccountConfig(cfg, accountId) ?? {};
+    // Merge: account config overrides base config
+    return { ...base, ...account };
+}
+/**
+ * Resolve a complete account with merged config.
+ */
+export function resolveWorkclawAccount(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const workclawCfg = params.cfg.channels?.['openclaw-workclaw'];
+    // Base enabled state (top-level)
+    const baseEnabled = workclawCfg?.enabled !== false;
+    // Merge configs
+    const merged = mergeWorkclawAccountConfig(params.cfg, accountId);
+    // Account-level enabled state
+    const accountEnabled = merged.enabled !== false;
+    const enabled = baseEnabled && accountEnabled;
+    return {
+        accountId,
+        enabled,
+        configured: isWorkclawAccountConfigured(merged),
+        name: merged.name?.trim() || undefined,
+        config: merged,
+    };
+}
+/**
+ * List all enabled and configured accounts.
+ */
+export function listEnabledWorkclawAccounts(cfg) {
+    return listConfiguredAccountIds(cfg)
+        .map(accountId => resolveWorkclawAccount({ cfg, accountId }))
+        .filter(account => account.enabled && account.configured);
+}
+/**
+ * Resolve account and apply cached connection config if available.
+ * This ensures that appKey/appSecret etc. use the stable values captured at connection time,
+ * not potentially mutated values from cfg at resolution time.
+ */
+export function resolveWorkclawAccountWithCache(params) {
+    const account = resolveWorkclawAccount(params);
+    const cachedConfig = getWorkclawConnectionConfig(account.accountId);
+    if (cachedConfig) {
+        // Apply cached values to ensure stability
+        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 !== undefined)
+            account.config.websocketUrl = cachedConfig.websocketUrl;
+        if (cachedConfig.localIp !== undefined)
+            account.config.localIp = cachedConfig.localIp;
+        if (cachedConfig.allowInsecureTls !== undefined)
+            account.config.allowInsecureTls = cachedConfig.allowInsecureTls;
+        if (cachedConfig.requestTimeout !== undefined)
+            account.config.requestTimeout = cachedConfig.requestTimeout;
+    }
+    return account;
+}
+/**
+ * Inspect and probe workclaw credentials.
+ * Returns a function that can be called to test the connection.
+ */
+export 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 };
+        }
+    };
+}

package/dist/src/api/accounts-api.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export declare function createAccountsApiHandler(api: OpenClawPluginApi): (req: any, res: any) => Promise<void>;

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

@@ -0,0 +1,130 @@
+import { normalizeAccountId } from "../accounts.js";
+function sendJson(res, statusCode, payload) {
+    res.statusCode = statusCode;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(payload));
+}
+async function readRequestBody(req) {
+    const chunks = [];
+    await new Promise((resolve, reject) => {
+        req.on("data", (chunk) => {
+            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        });
+        req.on("end", () => resolve());
+        req.on("error", (err) => reject(err));
+    });
+    return Buffer.concat(chunks).toString("utf-8");
+}
+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,
+            },
+        },
+    };
+}
+export 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" });
+    };
+}

package/dist/src/api/prompts-api.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export declare function createPromptsApiHandler(api: OpenClawPluginApi): (req: any, res: any) => Promise<void>;

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

@@ -0,0 +1,103 @@
+import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+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;
+}
+import path from "node:path";
+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));
+}
+export 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 (error) {
+                    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");
+}

package/dist/src/api/session-api.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+export declare function createSessionApiHandler(api: OpenClawPluginApi): (req: any, res: any) => Promise<void>;