@workclaw/openclaw-workclaw 1.0.18 → 1.0.19

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

@@ -1,77 +0,0 @@
-/**
- * 智小途系统信息工具 - 获取系统配置信息
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js'
-
-/**
- * 构造工具返回结果
- */
-function json(data: unknown): any {
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  }
-}
-
-/**
- * 获取系统配置信息工具
- */
-function getOpenclawWorkclawSystemConfigTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-system-config',
-      label: '智小途获取系统信息',
-      description: '获取当前渠道的系统配置信息，包括 appKey、appSecret、agentId、userId 等',
-      execute: async () => {
-        api.logger.info('[智小途-系统信息] 开始获取系统配置信息')
-
-        const accountId = ctx?.agentAccountId
-        if (!accountId) {
-          api.logger.warn('[智小途-系统信息] 无法获取账户 ID')
-          return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' })
-        }
-
-        api.logger.info(`[智小途-系统信息] accountId=${accountId}`)
-
-        const accountConfig = resolveWorkclawAccountWithCache({
-          cfg: ctx.config,
-          accountId,
-        })
-
-        if (!accountConfig.configured) {
-          api.logger.error('[智小途-系统信息] 账户未配置')
-          return json({ error: '账户未配置，请检查账户配置' })
-        }
-
-        const accConfig = accountConfig.config
-
-        const result = {
-          accountId,
-          appKey: accConfig.appKey,
-          appSecret: accConfig.appSecret,
-          agentId: accConfig.agentId,
-          userId: accConfig.userId,
-        }
-
-        api.logger.info(`[智小途-系统信息] 获取成功${JSON.stringify(result)}`)
-
-        return json({
-          code: 0,
-          message: '系统信息获取成功',
-          data: result,
-        })
-      },
-    }
-  }
-}
-
-/**
- * 注册获取系统配置信息工具
- */
-export function registerOpenclawWorkclawSystemConfigTool(api: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawSystemConfigTool(api), {
-    name: 'openclaw-workclaw-system-config',
-  })
-}

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

@@ -1,93 +0,0 @@
-/**
- * 智小途系统信息工具 - 获取用户 AccessToken
- */
-
-import type { OpenClawPluginApi } from 'openclaw/plugin-sdk'
-import { resolveWorkclawAccountWithCache } from '../../../../accounts.js'
-import { getWorkclawAccessToken } from '../../../../connection/workclaw-client.js'
-
-/**
- * 构造工具返回结果
- */
-function json(data: unknown): any {
-  return {
-    content: [{ type: 'text' as const, text: JSON.stringify(data, null, 2) }],
-    details: data,
-  }
-}
-
-/**
- * 获取用户 AccessToken 工具
- */
-function getOpenclawWorkclawSystemTokenTool(api: OpenClawPluginApi) {
-  return (ctx: any) => {
-    return {
-      name: 'openclaw-workclaw-system-token',
-      label: '智小途获取 AccessToken',
-      description: '获取用户的 AccessToken',
-      execute: async () => {
-        api.logger.info('[智小途-系统信息] 开始获取 AccessToken')
-
-        const accountId = ctx?.agentAccountId
-        if (!accountId) {
-          api.logger.warn('[智小途-系统信息] 无法获取账户 ID')
-          return json({ error: '无法获取账户 ID（accountId），请确保已配置账户' })
-        }
-
-        api.logger.info(`[智小途-系统信息] accountId=${accountId}`)
-
-        const accountConfig = resolveWorkclawAccountWithCache({
-          cfg: ctx.config,
-          accountId,
-        })
-
-        if (!accountConfig.configured) {
-          api.logger.error('[智小途-系统信息] 账户未配置')
-          return json({ error: '账户未配置，请检查账户配置' })
-        }
-
-        const accConfig = accountConfig.config
-
-        try {
-          const tokenCacheKey = accConfig.appKey || accountId
-
-          api.logger.info(`[智小途-系统信息] 正在获取 AccessToken，accountId=${accountId}`)
-
-          const accessToken = await getWorkclawAccessToken(tokenCacheKey, {
-            baseUrl: accConfig.baseUrl,
-            appKey: accConfig.appKey,
-            appSecret: accConfig.appSecret,
-            allowInsecureTls: accConfig.allowInsecureTls,
-            requestTimeout: accConfig.requestTimeout,
-          })
-
-          api.logger.info('[智小途-系统信息] AccessToken 获取成功')
-
-          return json({
-            code: 0,
-            message: 'AccessToken 获取成功',
-            data: {
-              accessToken,
-            },
-          })
-        }
-        catch (error: any) {
-          api.logger.error(`[智小途-系统信息] AccessToken 获取失败 ${error.message}`)
-          return json({
-            code: -1,
-            error: error.message || 'AccessToken 获取失败',
-          })
-        }
-      },
-    }
-  }
-}
-
-/**
- * 注册获取用户 AccessToken 工具
- */
-export function registerOpenclawWorkclawSystemTokenTool(api: OpenClawPluginApi): void {
-  (api.registerTool as any)(getOpenclawWorkclawSystemTokenTool(api), {
-    name: 'openclaw-workclaw-system-token',
-  })
-}

package/tests/accounts.test.ts

@@ -1,285 +0,0 @@
-/**
- * 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');
-  });
-});