@newpeak/barista-cli 0.1.0

package/src/core/api/client.ts

@@ -0,0 +1,825 @@
+import axios, { AxiosInstance, AxiosError } from 'axios';
+import { configManager } from '../config/manager.js';
+import { tokenManager } from '../auth/token-manager.js';
+import { Service, Environment, APIResponse } from '../../types/index.js';
+import {
+  CreateEmployeeRequest,
+  UpdateEmployeeRequest,
+  EmployeeQueryParams,
+  EmployeeApiResponse,
+} from '../../types/employee.js';
+import {
+  CreateUserRequest,
+  UpdateUserRequest,
+  UserQueryParams,
+  UserApiResponse,
+} from '../../types/user.js';
+import { OrgListItem } from '../../types/org.js';
+import { PositionListItem } from '../../types/position.js';
+
+export interface LoginResponse {
+  token: string;
+  expiresAt?: string;
+}
+
+export class APIClient {
+  private client: AxiosInstance;
+
+  constructor(baseURL: string, timeout: number = 30000) {
+    this.client = axios.create({
+      baseURL,
+      timeout,
+      headers: {
+        'Content-Type': 'application/json',
+        'tranLanguageCode': 'zh',
+      },
+    });
+  }
+
+  async login(
+    service: Service,
+    environment: Environment,
+    tenant: string,
+    username: string,
+    password: string
+  ): Promise<APIResponse<LoginResponse>> {
+    try {
+      const response = await this.client.post<APIResponse<LoginResponse>>('/api/enterprise/loginApi', {
+        account: username,
+        password,
+      });
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError<APIResponse<LoginResponse>>;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+          // Backend returns error in different format: {success, code, message} instead of {success, error: {code, message}}
+          if (!responseData.success && responseData.message) {
+            return {
+              success: false,
+              error: {
+                code: responseData.code || 'UNKNOWN_ERROR',
+                message: responseData.message,
+              },
+            };
+          }
+          return responseData;
+        }
+        return {
+          success: false,
+          error: {
+            code: 'NETWORK_ERROR',
+            message: axiosError.message || 'Network error occurred',
+          },
+        };
+      }
+      return {
+        success: false,
+        error: {
+          code: 'UNKNOWN_ERROR',
+          message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+      };
+    }
+  }
+
+  async loginArabica(
+    environment: Environment,
+    account: string,
+    password: string,
+    rememberMe: boolean = false
+  ): Promise<APIResponse<LoginResponse>> {
+    try {
+      const response = await this.client.post<APIResponse<LoginResponse>>('/api/login', {
+        account,
+        password,
+        rememberMe,
+      });
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError<APIResponse<LoginResponse>>;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+          if (!responseData.success && responseData.message) {
+            return {
+              success: false,
+              error: {
+                code: responseData.code || 'UNKNOWN_ERROR',
+                message: responseData.message,
+              },
+            };
+          }
+          return responseData;
+        }
+        return {
+          success: false,
+          error: {
+            code: 'NETWORK_ERROR',
+            message: axiosError.message || 'Network error occurred',
+          },
+        };
+      }
+      return {
+        success: false,
+        error: {
+          code: 'UNKNOWN_ERROR',
+          message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+      };
+    }
+  }
+
+  async registerArabica(
+    environment: Environment,
+    email: string,
+    account: string,
+    password: string,
+    phone?: string,
+    username?: string,
+    policyContent?: string,
+    privacyContent?: string
+  ): Promise<APIResponse<{ userId?: string }>> {
+    try {
+      const response = await this.client.post<APIResponse<{ userId?: string }>>('/member/user/register', {
+        email,
+        account,
+        password,
+        phone,
+        userName: username,
+        policyContent,
+        privacyContent,
+      });
+      return response.data;
+    } catch (error) {
+      if (axios.isAxiosError(error)) {
+        const axiosError = error as AxiosError<APIResponse<{ userId?: string }>>;
+        const responseData = axiosError.response?.data;
+        if (responseData) {
+          if (!responseData.success && responseData.message) {
+            return {
+              success: false,
+              error: {
+                code: responseData.code || 'UNKNOWN_ERROR',
+                message: responseData.message,
+              },
+            };
+          }
+          return responseData;
+        }
+        return {
+          success: false,
+          error: {
+            code: 'NETWORK_ERROR',
+            message: axiosError.message || 'Network error occurred',
+          },
+        };
+      }
+      return {
+        success: false,
+        error: {
+          code: 'UNKNOWN_ERROR',
+          message: error instanceof Error ? error.message : 'Unknown error occurred',
+        },
+      };
+    }
+  }
+
+  setAuthToken(token: string): void {
+    this.client.defaults.headers.common['Authorization'] = token;
+  }
+
+  clearAuthToken(): void {
+    delete this.client.defaults.headers.common['Authorization'];
+  }
+
+  getClient(): AxiosInstance {
+    return this.client;
+  }
+}
+
+export function createAPIClient(service: Service, environment: Environment, tenant?: string): APIClient {
+  const baseURL = configManager.getEnvironmentUrl(service, environment, tenant);
+  const timeout = configManager.getConfig().environments[environment][service].timeout;
+  return new APIClient(baseURL, timeout);
+}
+
+const orgCache = new Map<string, { items: OrgListItem[]; timestamp: number }>();
+const positionCache = new Map<string, { items: PositionListItem[]; timestamp: number }>();
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+export const apiClient = {
+  async login(
+    service: Service,
+    environment: Environment,
+    tenant: string,
+    username: string,
+    password: string
+  ): Promise<APIResponse<LoginResponse>> {
+    const client = createAPIClient(service, environment, tenant);
+    return client.login(service, environment, tenant, username, password);
+  },
+
+  async loginArabica(
+    environment: Environment,
+    account: string,
+    password: string,
+    rememberMe: boolean = false
+  ): Promise<APIResponse<LoginResponse>> {
+    const client = createAPIClient('arabica' as Service, environment);
+    return client.loginArabica(environment, account, password, rememberMe);
+  },
+
+  async registerArabica(
+    environment: Environment,
+    email: string,
+    account: string,
+    password: string,
+    phone?: string,
+    username?: string,
+    policyContent?: string,
+    privacyContent?: string
+  ): Promise<APIResponse<{ userId?: string }>> {
+    const client = createAPIClient('arabica' as Service, environment);
+    return client.registerArabica(environment, email, account, password, phone, username, policyContent, privacyContent);
+  },
+
+  async getCodeByType(
+    environment: Environment,
+    tenant: string,
+    type: string
+  ): Promise<{ success: boolean; data?: string; error?: { code: string; message: string } }> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<{ success: boolean; data?: string; message?: string }>(
+        `/api/enterprise/master/id/getCodeByType?type=${type}`
+      );
+      return response.data;
+    } catch (error) {
+      const errorResult = handleApiError(error) as { success: boolean; data?: string; error?: { code: string; message: string } };
+      return errorResult;
+    }
+  },
+
+  async createEmployee(
+    environment: Environment,
+    tenant: string,
+    data: CreateEmployeeRequest
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<EmployeeApiResponse>('/api/enterprise/employee/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async searchEmployees(
+    environment: Environment,
+    tenant: string,
+    searchText: string
+  ): Promise<{ success: boolean; data?: any[]; error?: { code: string; message: string } }> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const url = `/api/enterprise/master/employee/list?searchText=${encodeURIComponent(searchText)}`;
+      const response = await client.getClient().get(url);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: any[]; error?: { code: string; message: string } };
+    }
+  },
+
+  async listEmployees(
+    environment: Environment,
+    tenant: string,
+    params: EmployeeQueryParams
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.status) queryString.append('status', params.status.toString());
+      if (params.organizationId) queryString.append('organizationId', params.organizationId.toString());
+      if (params.employeeCode) queryString.append('employeeCode', params.employeeCode);
+      if (params.employeeName) queryString.append('employeeName', params.employeeName);
+      const url = `/api/enterprise/employee/page${queryString.toString() ? '?' + queryString.toString() : ''}`;
+      const response = await client.getClient().get<EmployeeApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async getEmployee(
+    environment: Environment,
+    tenant: string,
+    employeeId: string
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<EmployeeApiResponse>(
+        `/api/enterprise/employee/detail?employeeId=${employeeId}`
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async updateEmployee(
+    environment: Environment,
+    tenant: string,
+    data: UpdateEmployeeRequest
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<EmployeeApiResponse>('/api/enterprise/employee/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async disableEmployee(
+    environment: Environment,
+    tenant: string,
+    employeeId: string
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<EmployeeApiResponse>(
+        '/api/enterprise/employee/deActive',
+        { employeeId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async enableEmployee(
+    environment: Environment,
+    tenant: string,
+    employeeId: string
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<EmployeeApiResponse>(
+        '/api/enterprise/employee/active',
+        { employeeId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async deleteEmployee(
+    environment: Environment,
+    tenant: string,
+    employeeId: string
+  ): Promise<EmployeeApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<EmployeeApiResponse>(
+        '/api/enterprise/employee/delete',
+        { employeeId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error);
+    }
+  },
+
+  async getOrgListName(
+    environment: Environment,
+    tenant: string
+  ): Promise<{ success: boolean; data?: OrgListItem[]; error?: { code: string; message: string } }> {
+    const cacheKey = `${environment}:${tenant}`;
+    const cached = orgCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+      return { success: true, data: cached.items };
+    }
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      // Use /tree endpoint which returns all orgs with their IDs and names
+      const response = await client.getClient().post<{ success?: boolean; data?: { orgTreeList?: { orgId: number; orgName?: string }[] }; message?: string }>(
+        '/api/enterprise/master/org/tree',
+        { orgParentId: -1 }  // -1 means get all root orgs
+      );
+      if (response.data?.success === false) {
+        return {
+          success: false,
+          error: { code: response.data?.message || 'FETCH_ORG_ERROR', message: response.data?.message || 'Failed to fetch organization list' },
+        };
+      }
+      const orgList = (response.data as any)?.data?.orgTreeList || [];
+      const items: OrgListItem[] = orgList.map((o: { orgId: number; orgName?: string }) => ({
+        id: o.orgId,
+        name: o.orgName || '',
+      }));
+      orgCache.set(cacheKey, { items, timestamp: Date.now() });
+      return { success: true, data: items };
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: OrgListItem[]; error?: { code: string; message: string } };
+    }
+  },
+
+  async listPositions(
+    environment: Environment,
+    tenant: string
+  ): Promise<{ success: boolean; data?: PositionListItem[]; error?: { code: string; message: string } }> {
+    const cacheKey = `${environment}:${tenant}`;
+    const cached = positionCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+      return { success: true, data: cached.items };
+    }
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<{ success?: boolean; data?: { id?: string; name?: string }[]; message?: string }>(
+        '/api/enterprise/master/position/list'
+      );
+      if (response.data?.success === false) {
+        return {
+          success: false,
+          error: { code: response.data?.message || 'FETCH_POSITION_ERROR', message: response.data?.message || 'Failed to fetch position list' },
+        };
+      }
+      const items: PositionListItem[] = ((response.data as any)?.data || []).map((p: { id?: string; name?: string }) => ({
+        id: p.id || '',
+        name: p.name || '',
+      }));
+      positionCache.set(cacheKey, { items, timestamp: Date.now() });
+      return { success: true, data: items };
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: PositionListItem[]; error?: { code: string; message: string } };
+    }
+ },
+
+  async createUser(
+    environment: Environment,
+    tenant: string,
+    data: CreateUserRequest
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UserApiResponse>('/api/enterprise/user/add', data);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async listUsers(
+    environment: Environment,
+    tenant: string,
+    params: UserQueryParams
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const queryString = new URLSearchParams();
+      if (params.pageNo !== undefined) queryString.append('pageNo', params.pageNo.toString());
+      if (params.pageSize) queryString.append('pageSize', params.pageSize.toString());
+      if (params.status) queryString.append('status', params.status.toString());
+      if (params.account) queryString.append('account', params.account);
+      if (params.realName) queryString.append('realName', params.realName);
+      if (params.employeeId) queryString.append('employeeId', params.employeeId.toString());
+      const url = '/api/enterprise/user/page' + (queryString.toString() ? '?' + queryString.toString() : '');
+      const response = await client.getClient().get<UserApiResponse>(url);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async getUser(
+    environment: Environment,
+    tenant: string,
+    userId: string
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<UserApiResponse>(
+        '/api/enterprise/user/detail?userId=' + userId
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async updateUser(
+    environment: Environment,
+    tenant: string,
+    data: UpdateUserRequest
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UserApiResponse>('/api/enterprise/user/edit', data);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async deleteUser(
+    environment: Environment,
+    tenant: string,
+    userId: string
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UserApiResponse>(
+        '/api/enterprise/user/batchDelete',
+        { userIdList: [userId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async enableUser(
+    environment: Environment,
+    tenant: string,
+    userId: string
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UserApiResponse>(
+        '/api/enterprise/user/batchActive',
+        { userIdList: [userId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async disableUser(
+    environment: Environment,
+    tenant: string,
+    userId: string
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UserApiResponse>(
+        '/api/enterprise/user/batchDeActive',
+        { userIdList: [userId] }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async getCurrentUser(
+    environment: Environment,
+    tenant: string
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get<UserApiResponse>('/api/enterprise/user/getUserInfo');
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async getUserIndexInfo(
+    environment: Environment,
+    tenant: string
+  ): Promise<{ success: boolean; data?: any; error?: { code: string; message: string } }> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get('/api/userIndexInfo');
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: any; error?: { code: string; message: string } };
+    }
+  },
+
+  async updateUserOrgOrApp(
+    environment: Environment,
+    tenant: string,
+    params: { newOrgId?: string; newAppId?: string }
+  ): Promise<{ success: boolean; data?: any; error?: { code: string; message: string } }> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post('/api/updateUserOrgOrApp', params);
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: any; error?: { code: string; message: string } };
+    }
+  },
+
+  async resetPassword(
+    environment: Environment,
+    tenant: string,
+    userId: string
+  ): Promise<UserApiResponse> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().post<UserApiResponse>(
+        '/api/enterprise/user/resetPassword',
+        { userId }
+      );
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as UserApiResponse;
+    }
+  },
+
+  async listRoles(
+    environment: Environment,
+    tenant: string
+  ): Promise<{ success: boolean; data?: any[]; error?: { code: string; message: string } }> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in' } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get('/api/enterprise/sysRole/list');
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: any[]; error?: { code: string; message: string } };
+    }
+  },
+
+  async existCheck(
+    environment: Environment,
+    tenant: string,
+    account: string
+  ): Promise<{ success: boolean; data?: boolean; error?: { code: string; message: string } }> {
+    try {
+      const token = await tokenManager.getToken({ service: 'liberica', environment, tenant });
+      if (!token) {
+        return { success: false, error: { code: 'NO_TOKEN', message: 'Not logged in. Run: barista auth login --service liberica --env ' + environment } };
+      }
+      const client = createAPIClient('liberica' as Service, environment, tenant);
+      client.setAuthToken(token);
+      const response = await client.getClient().get('/api/enterprise/user/existCheck', {
+        params: { account },
+        timeout: 60000 // 增加超时时间到60秒
+      });
+      return response.data;
+    } catch (error) {
+      return handleApiError(error) as { success: boolean; data?: boolean; error?: { code: string; message: string } };
+    }
+  },
+
+};
+
+function handleApiError(error: unknown): EmployeeApiResponse {
+  if (axios.isAxiosError(error)) {
+    const axiosError = error as AxiosError<Record<string, unknown>>;
+    const responseData = axiosError.response?.data;
+    if (responseData) {
+      const success = responseData.success as boolean | undefined;
+      if (success === false) {
+        const code = responseData.code as string | undefined;
+        const message = responseData.message as string | undefined;
+        const errorObj = responseData.error as { code?: string; message?: string } | undefined;
+        if (!errorObj && (code || message)) {
+          return {
+            success: false,
+            error: {
+              code: code || 'API_ERROR',
+              message: message || 'API error occurred',
+            },
+          };
+        }
+      }
+      return responseData as unknown as EmployeeApiResponse;
+    }
+    return {
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: axiosError.message || 'Network error occurred',
+      },
+    };
+  }
+  return {
+    success: false,
+    error: {
+      code: 'UNKNOWN_ERROR',
+      message: error instanceof Error ? error.message : 'Unknown error occurred',
+    },
+  };
+}