@workclaw/openclaw-workclaw 1.0.17 → 1.0.18

package/src/tools/openclaw-workclaw-cron/src/update/sync.ts

@@ -3,7 +3,7 @@
  */
 
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveOpenclawWorkclawAccount } from '../../../../accounts.js'
+import { resolveWorkclawAccountWithCache } from '../../../../accounts.js'
 import { callCronJobUpdate } from '../../api/index.js'
 
 /**
@@ -25,7 +25,7 @@ const UpdateSyncSchema = {
   properties: {
     jobId: {
       type: 'string',
-      description: 'OpenClaw 任务 ID',
+      description: `OpenClaw 任务 ID（必须是数字或字符串，不是 cron 表达式）`,
     },
     name: {
       type: 'string',
@@ -33,7 +33,7 @@ const UpdateSyncSchema = {
     },
     kind: {
       type: 'string',
-      description: '任务类型：at 或 cron',
+      description: '任务类型（仅支持 cron）',
       enum: ['cron'],
     },
     expr: {
@@ -97,7 +97,7 @@ function getOpenclawWorkclawCronUpdateSyncTool(api: OpenClawPluginApi) {
           return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' })
         }
 
-        const accountConfig = resolveOpenclawWorkclawAccount({
+        const accountConfig = resolveWorkclawAccountWithCache({
           cfg: ctx.config,
           accountId,
         })

package/src/tools/openclaw-workclaw-system/src/get/index.ts

@@ -3,7 +3,7 @@
  */
 
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveOpenclawWorkclawAccount } from '../../../../accounts.js'
+import { resolveWorkclawAccountWithCache } from '../../../../accounts.js'
 
 /**
  * 构造工具返回结果
@@ -35,7 +35,7 @@ function getOpenclawWorkclawSystemConfigTool(api: OpenClawPluginApi) {
 
         api.logger.info(`[智小途-系统信息] accountId=${accountId}`)
 
-        const accountConfig = resolveOpenclawWorkclawAccount({
+        const accountConfig = resolveWorkclawAccountWithCache({
           cfg: ctx.config,
           accountId,
         })

package/src/tools/openclaw-workclaw-system/src/token/index.ts

@@ -3,8 +3,8 @@
  */
 
 import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveOpenclawWorkclawAccount } from '../../../../accounts.js'
-import { getOpenclawWorkclawAccessToken } from '../../../../connection/workclaw-client.js'
+import { resolveWorkclawAccountWithCache } from '../../../../accounts.js'
+import { getWorkclawAccessToken } from '../../../../connection/workclaw-client.js'
 
 /**
  * 构造工具返回结果
@@ -36,7 +36,7 @@ function getOpenclawWorkclawSystemTokenTool(api: OpenClawPluginApi) {
 
         api.logger.info(`[智小途-系统信息] accountId=${accountId}`)
 
-        const accountConfig = resolveOpenclawWorkclawAccount({
+        const accountConfig = resolveWorkclawAccountWithCache({
           cfg: ctx.config,
           accountId,
         })
@@ -53,7 +53,7 @@ function getOpenclawWorkclawSystemTokenTool(api: OpenClawPluginApi) {
 
           api.logger.info(`[智小途-系统信息] 正在获取 AccessToken，accountId=${accountId}`)
 
-          const accessToken = await getOpenclawWorkclawAccessToken(tokenCacheKey, {
+          const accessToken = await getWorkclawAccessToken(tokenCacheKey, {
             baseUrl: accConfig.baseUrl,
             appKey: accConfig.appKey,
             appSecret: accConfig.appSecret,

package/src/types.ts

@@ -1,60 +1,58 @@
 import type {
-  openclawWorkclawAccountConfigSchema,
-  openclawWorkclawConfigSchema,
+  workclawConfigSchema,
+  workclawAccountConfigSchema,
   z,
-} from './config-schema.js'
+} from "./config-schema.js";
 
-export type OpenclawWorkclawConfig = z.infer<typeof openclawWorkclawConfigSchema>
-export type OpenclawWorkclawAccountConfig = z.infer<typeof openclawWorkclawAccountConfigSchema>
+export type WorkclawConfig = z.infer<typeof workclawConfigSchema>;
+export type WorkclawAccountConfig = z.infer<typeof workclawAccountConfigSchema>;
 
-export type OpenclawWorkclawConnectionMode = 'websocket' | 'webhook'
-export type WsConnectionStrategy = 'per-account' | 'per-appKey'
+export type WorkclawConnectionMode = "websocket" | "webhook";
+export type WsConnectionStrategy = "per-account" | "per-appKey";
 
-export interface ResolvedOpenclawWorkclawAccount {
-  accountId: string
-  enabled: boolean
-  configured: boolean
-  name?: string
+export type ResolvedWorkclawAccount = {
+  accountId: string;
+  enabled: boolean;
+  configured: boolean;
+  name?: string;
   /** Merged config (top-level defaults + account-specific overrides) */
-  config: OpenclawWorkclawFullAccountConfig
-}
-export type ResolvedOpenClawWorkclawAccount = ResolvedOpenclawWorkclawAccount
+  config: WorkclawFullAccountConfig;
+};
+export type ResolvedOpenClawWorkclawAccount = ResolvedWorkclawAccount;
 
-export type OpenclawWorkclawIdType = 'open_id' | 'user_id' | 'union_id' | 'chat_id'
+export type WorkclawIdType = "open_id" | "user_id" | "union_id" | "chat_id";
 
-export interface OpenclawWorkclawSendResult {
-  messageId: string
-  chatId: string
-}
+export type WorkclawSendResult = {
+  messageId: string;
+  chatId: string;
+};
 
 /** WorkClaw plugin base config (shared across all accounts) */
 export interface WorkClawBaseConfig {
-  baseUrl?: string
-  websocketUrl?: string
-  appKey?: string
-  appSecret?: string
-  localIp?: string
-  allowInsecureTls?: boolean
-  requestTimeout?: number
-  userId?: string | number
-  replyEndpoint?: string
-  pushEndpoint?: string
+    baseUrl?: string;
+    websocketUrl?: string;
+    appKey?: string;
+    appSecret?: string;
+    localIp?: string;
+    allowInsecureTls?: boolean;
+    requestTimeout?: number;
+    userId?: string | number;
+    replyEndpoint?: string;
+    pushEndpoint?: string;
 }
 
 /** Per-account WorkClaw fields */
 export interface WorkClawAccountConfig {
-  agentId?: string | number
-  userId?: string | number
-  openConversationId?: string
+    agentId?: string | number;
+    userId?: string | number;
+    openConversationId?: string;
 }
 
-export type WorkClawConfig = WorkClawBaseConfig & WorkClawAccountConfig
+export type WorkClawConfig = WorkClawBaseConfig & WorkClawAccountConfig;
 
-/**
- * account.config is typed as OpenclawWorkclawConfig (top-level) but at runtime
- *  also contains all OpenclawWorkclawAccountConfig fields (merged).
- */
-export type OpenclawWorkclawFullAccountConfig = OpenclawWorkclawConfig & Partial<OpenclawWorkclawAccountConfig>
+/** account.config is typed as OpenclawWorkclawConfig (top-level) but at runtime
+ *  also contains all OpenclawWorkclawAccountConfig fields (merged). */
+export type WorkclawFullAccountConfig = WorkclawConfig & Partial<WorkclawAccountConfig>;
 
 /** Resolved account's config - merge of top-level defaults + account overrides */
-export type ResolvedOpenclawWorkclawAccountConfig = OpenclawWorkclawFullAccountConfig
+export type ResolvedWorkclawAccountConfig = WorkclawFullAccountConfig;

package/src/utils/content.ts

@@ -9,17 +9,14 @@
  * Handles content format: [{ type: "text", text: "..." }]
  */
 export function collectTextContentBlocks(content: unknown): string[] {
-  if (!Array.isArray(content))
-    return []
-  const parts: string[] = []
-  for (const block of content) {
-    if (!block || typeof block !== 'object')
-      continue
-    const rec = block as { type?: string, text?: string }
-    if (rec.type === 'text' && typeof rec.text === 'string')
-      parts.push(rec.text)
-  }
-  return parts
+    if (!Array.isArray(content)) return [];
+    const parts: string[] = [];
+    for (const block of content) {
+        if (!block || typeof block !== "object") continue;
+        const rec = block as { type?: string; text?: string };
+        if (rec.type === "text" && typeof rec.text === "string") parts.push(rec.text);
+    }
+    return parts;
 }
 
 /**
@@ -27,14 +24,12 @@ export function collectTextContentBlocks(content: unknown): string[] {
  * Handles result.content as array of text blocks or direct text fields.
  */
 export function extractToolResultText(result: unknown): string | undefined {
-  if (!result || typeof result !== 'object')
-    return
-  const record = result as { content?: unknown }
-  const texts = collectTextContentBlocks(record.content).map((item) => {
-    const trimmed = item.trim()
-    return trimmed || void 0
-  }).filter(value => Boolean(value))
-  if (texts.length === 0)
-    return
-  return texts.join('\n')
+    if (!result || typeof result !== "object") return;
+    const record = result as { content?: unknown };
+    const texts = collectTextContentBlocks(record.content).map((item) => {
+        const trimmed = item.trim();
+        return trimmed ? trimmed : void 0;
+    }).filter((value) => Boolean(value));
+    if (texts.length === 0) return;
+    return texts.join("\n");
 }

package/tests/accounts.test.ts

@@ -0,0 +1,285 @@
+/**
+ * Tests for account config resolution and lookup cache.
+ */
+
+import { describe, expect, it, beforeEach } from 'vitest';
+import type { OpenClawConfig } from 'openclaw/plugin-sdk';
+import {
+  normalizeAccountId,
+  buildAccountMap,
+  resolveAccountByUserIdAndAgentId,
+  allocateWorkerAccountId,
+  resolveWorkclawAccount,
+  listWorkclawAccountIds,
+  isWorkclawAccountConfigured,
+  listEnabledWorkclawAccounts,
+} from '../src/accounts.js';
+
+function makeCfg(workclaw: Record<string, unknown>): OpenClawConfig {
+  return { channels: { 'openclaw-workclaw': workclaw } } as unknown as OpenClawConfig;
+}
+
+// ---------------------------------------------------------------------------
+// normalizeAccountId
+// ---------------------------------------------------------------------------
+
+describe('normalizeAccountId', () => {
+  it('trims whitespace', () => {
+    expect(normalizeAccountId('  default  ')).toBe('default');
+  });
+
+  it('leaves normal IDs unchanged', () => {
+    expect(normalizeAccountId('workspace-1')).toBe('workspace-1');
+  });
+
+  it('coerces non-string to string', () => {
+    expect(normalizeAccountId(123 as any)).toBe('123');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isWorkclawAccountConfigured
+// ---------------------------------------------------------------------------
+
+describe('isWorkclawAccountConfigured', () => {
+  it('returns true when appKey and appSecret are present', () => {
+    expect(isWorkclawAccountConfigured({ appKey: 'key123', appSecret: 'secret123' })).toBe(true);
+  });
+
+  it('returns false when appKey is missing', () => {
+    expect(isWorkclawAccountConfigured({ appSecret: 'secret' })).toBe(false);
+  });
+
+  it('returns false when appSecret is missing', () => {
+    expect(isWorkclawAccountConfigured({ appKey: 'key' })).toBe(false);
+  });
+
+  it('returns false when both are empty strings', () => {
+    expect(isWorkclawAccountConfigured({ appKey: '', appSecret: '' })).toBe(false);
+  });
+
+  it('returns false when values are only whitespace', () => {
+    expect(isWorkclawAccountConfigured({ appKey: '  ', appSecret: '  ' })).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listWorkclawAccountIds
+// ---------------------------------------------------------------------------
+
+describe('listWorkclawAccountIds', () => {
+  it('returns sorted account IDs when accounts are configured', () => {
+    const cfg = makeCfg({
+      appKey: 'key',
+      appSecret: 'secret',
+      accounts: {
+        'workspace-2': { appKey: 'k2', appSecret: 's2' },
+        'default': { appKey: 'kd', appSecret: 'sd' },
+        'workspace-1': { appKey: 'k1', appSecret: 's1' },
+      },
+    });
+    const ids = listWorkclawAccountIds(cfg);
+    expect(ids).toEqual(['default', 'workspace-1', 'workspace-2']);
+  });
+
+  it('returns [default] when no accounts configured but plugin has appKey+appSecret', () => {
+    const cfg = makeCfg({ appKey: 'key', appSecret: 'secret' });
+    const ids = listWorkclawAccountIds(cfg);
+    expect(ids).toContain('default');
+  });
+
+  it('returns [default] when channel config is empty', () => {
+    const cfg = makeCfg({});
+    const ids = listWorkclawAccountIds(cfg);
+    expect(ids).toContain('default');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// resolveWorkclawAccount — config merging
+// ---------------------------------------------------------------------------
+
+describe('resolveWorkclawAccount', () => {
+  it('account-level fields override top-level fields', () => {
+    const cfg = makeCfg({
+      appKey: 'top-key',
+      appSecret: 'top-secret',
+      baseUrl: 'http://top.example.com',
+      accounts: {
+        'bot-a': { appKey: 'a-key', appSecret: 'a-secret', baseUrl: 'http://a.example.com' },
+      },
+    });
+    const account = resolveWorkclawAccount({ cfg, accountId: 'bot-a' });
+    expect(account.config.appKey).toBe('a-key');
+    expect(account.config.baseUrl).toBe('http://a.example.com');
+    expect(account.configured).toBe(true);
+  });
+
+  it('account inherits top-level fields not overridden', () => {
+    const cfg = makeCfg({
+      appKey: 'top-key',
+      appSecret: 'top-secret',
+      baseUrl: 'http://top.example.com',
+      accounts: {
+        'bot-a': { appKey: 'a-key', appSecret: 'a-secret' },
+      },
+    });
+    const account = resolveWorkclawAccount({ cfg, accountId: 'bot-a' });
+    expect(account.config.baseUrl).toBe('http://top.example.com');
+  });
+
+  it('account is not configured when appKey/appSecret missing after merge', () => {
+    const cfg = makeCfg({
+      accounts: {
+        'bot-empty': {},
+      },
+    });
+    const account = resolveWorkclawAccount({ cfg, accountId: 'bot-empty' });
+    expect(account.configured).toBe(false);
+  });
+
+  it('account is disabled when top-level enabled=false', () => {
+    const cfg = makeCfg({
+      enabled: false,
+      appKey: 'key',
+      appSecret: 'secret',
+      accounts: {
+        'bot-a': { appKey: 'ak', appSecret: 'as' },
+      },
+    });
+    const account = resolveWorkclawAccount({ cfg, accountId: 'bot-a' });
+    expect(account.enabled).toBe(false);
+  });
+
+  it('account is disabled when account-level enabled=false', () => {
+    const cfg = makeCfg({
+      appKey: 'key',
+      appSecret: 'secret',
+      accounts: {
+        'bot-off': { appKey: 'ak', appSecret: 'as', enabled: false },
+      },
+    });
+    const account = resolveWorkclawAccount({ cfg, accountId: 'bot-off' });
+    expect(account.enabled).toBe(false);
+  });
+
+  it('accountId is normalized (trimmed)', () => {
+    const cfg = makeCfg({
+      accounts: {
+        'bot-a': { appKey: 'ak', appSecret: 'as' },
+      },
+    });
+    const account = resolveWorkclawAccount({ cfg, accountId: '  bot-a  ' });
+    expect(account.accountId).toBe('bot-a');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listEnabledWorkclawAccounts
+// ---------------------------------------------------------------------------
+
+describe('listEnabledWorkclawAccounts', () => {
+  it('returns only enabled and configured accounts', () => {
+    // No top-level appKey/appSecret so 'unconfigured' stays unconfigured (no inheritance)
+    const cfg = makeCfg({
+      accounts: {
+        'active': { appKey: 'ak', appSecret: 'as' },
+        'disabled': { appKey: 'dk', appSecret: 'ds', enabled: false },
+        'unconfigured': {},
+      },
+    });
+    const accounts = listEnabledWorkclawAccounts(cfg);
+    const ids = accounts.map(a => a.accountId);
+    expect(ids).toContain('active');
+    expect(ids).not.toContain('disabled');
+    expect(ids).not.toContain('unconfigured');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// buildAccountMap + resolveAccountByUserIdAndAgentId
+// ---------------------------------------------------------------------------
+
+describe('buildAccountMap + resolveAccountByUserIdAndAgentId', () => {
+  beforeEach(() => {
+    // Reset state by calling buildAccountMap with empty config
+    buildAccountMap(makeCfg({}));
+  });
+
+  it('resolves accountId from userId+agentId after buildAccountMap', () => {
+    const cfg = makeCfg({
+      accounts: {
+        'workspace-1': { appKey: 'k', appSecret: 's', userId: 'user-123', agentId: '456' },
+      },
+    });
+    buildAccountMap(cfg);
+    const result = resolveAccountByUserIdAndAgentId(cfg, 'user-123', '456');
+    expect(result).toBe('workspace-1');
+  });
+
+  it('returns null when no matching account', () => {
+    const cfg = makeCfg({
+      accounts: {
+        'workspace-1': { appKey: 'k', appSecret: 's', userId: 'user-123', agentId: '456' },
+      },
+    });
+    buildAccountMap(cfg);
+    const result = resolveAccountByUserIdAndAgentId(cfg, 'user-999', '456');
+    expect(result).toBeNull();
+  });
+
+  it('caches lookup on second call', () => {
+    const cfg = makeCfg({
+      accounts: {
+        'workspace-1': { appKey: 'k', appSecret: 's', userId: 'user-abc', agentId: '789' },
+      },
+    });
+    buildAccountMap(cfg);
+    // First call
+    expect(resolveAccountByUserIdAndAgentId(cfg, 'user-abc', '789')).toBe('workspace-1');
+    // Second call (from cache)
+    expect(resolveAccountByUserIdAndAgentId(cfg, 'user-abc', '789')).toBe('workspace-1');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// allocateWorkerAccountId
+// ---------------------------------------------------------------------------
+
+describe('allocateWorkerAccountId', () => {
+  beforeEach(() => {
+    buildAccountMap(makeCfg({}));
+  });
+
+  it('allocates workspace-1 on fresh state', () => {
+    const cfg = makeCfg({});
+    const id = allocateWorkerAccountId(cfg, 'user-1', 'agent-1');
+    expect(id).toBe('workspace-1');
+  });
+
+  it('increments on each allocation', () => {
+    const cfg = makeCfg({});
+    const id1 = allocateWorkerAccountId(cfg, 'user-1', 'agent-1');
+    const id2 = allocateWorkerAccountId(cfg, 'user-2', 'agent-2');
+    expect(id1).toBe('workspace-1');
+    expect(id2).toBe('workspace-2');
+  });
+
+  it('allocated account is immediately resolvable', () => {
+    const cfg = makeCfg({});
+    allocateWorkerAccountId(cfg, 'user-x', 'agent-x');
+    const result = resolveAccountByUserIdAndAgentId(cfg, 'user-x', 'agent-x');
+    expect(result).toBe('workspace-1');
+  });
+
+  it('nextWorkspaceNum continues from existing accounts', () => {
+    const cfg = makeCfg({
+      accounts: {
+        'workspace-5': { appKey: 'k', appSecret: 's', userId: 'u', agentId: '1' },
+      },
+    });
+    buildAccountMap(cfg);
+    const id = allocateWorkerAccountId(cfg, 'user-new', 'agent-new');
+    expect(id).toBe('workspace-6');
+  });
+});