@newpeak/barista-cli 0.1.0

package/src/commands/liberica/orgs/index.ts

@@ -0,0 +1,35 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createOrgsCommand(): Command {
+  const orgsCommand = new Command('orgs');
+  orgsCommand.description('List organizations');
+
+  orgsCommand
+    .command('list')
+    .description('List all organizations')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const response = await apiClient.getOrgListName(environment, tenant);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      const orgs = response.data || [];
+
+      // Always show full IDs
+      console.log(JSON.stringify({ success: true, data: orgs }, null, 2));
+    });
+
+  return orgsCommand;
+}

package/src/commands/liberica/positions/index.ts

@@ -0,0 +1,30 @@
+import { Command } from 'commander';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createPositionsCommand(): Command {
+  const positionsCommand = new Command('positions');
+  positionsCommand.description('List positions');
+
+  positionsCommand
+    .command('list')
+    .description('List all positions')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const response = await apiClient.listPositions(environment, tenant);
+
+      if (!response.success) {
+        console.error(`\n✗ Failed: ${response.error?.message}\n`);
+        process.exit(1);
+      }
+
+      const positions = response.data || [];
+      console.log(JSON.stringify({ success: true, data: positions }, null, 2));
+    });
+
+  return positionsCommand;
+}

package/src/commands/liberica/roles/index.ts

@@ -0,0 +1,59 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+import { configManager } from '../../../core/config/manager.js';
+
+export function createRolesCommand(): Command {
+  const rolesCommand = new Command('roles');
+  rolesCommand.description('List roles');
+
+  rolesCommand
+    .command('list')
+    .description('List all available roles')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      try {
+        const response = await apiClient.listRoles(environment, tenant);
+        
+        if (!response.success) {
+          console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+          process.exit(1);
+        }
+
+        const roles = response.data || [];
+
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, data: roles }, null, 2));
+          return;
+        }
+
+        const table = new Table({
+          head: [chalk.bold('ID'), chalk.bold('Role Code'), chalk.bold('Role Name'), chalk.bold('Status')],
+          colWidths: [20, 20, 20, 10],
+        });
+
+        for (const role of roles) {
+          table.push([
+            role.roleId,
+            role.roleCode || '-',
+            role.roleName || '-',
+            role.statusFlag === 1 ? chalk.green('Enabled') : chalk.red('Disabled'),
+          ]);
+        }
+
+        console.log(table.toString());
+        console.log(chalk.gray(`\nTotal: ${roles.length} roles`));
+      } catch (error: any) {
+        console.error(chalk.red(`\n✗ Error: ${error.message}\n`));
+        process.exit(1);
+      }
+    });
+
+  return rolesCommand;
+}

package/src/commands/liberica/users/create.ts

@@ -0,0 +1,132 @@
+import { Command } from 'commander';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+import chalk from 'chalk';
+
+export function createUserCreateCommand(): Command {
+  const createCommand = new Command('create');
+  createCommand.description('Create a new user');
+  
+  createCommand
+    .option('-n, --name <name>', 'User real name (required)')
+    .option('-a, --account <account>', 'User account (required)')
+    .option('-e, --email <email>', 'User email')
+    .option('-r, --role-ids <roleIds>', 'Role IDs (comma-separated, required)')
+    .option('--employee-code <employeeCode>', 'Employee code (optional, used to find employee)')
+    .option('--employee-name <employeeName>', 'Employee name (optional, used to find employee)')
+    .option('--org-id <orgId>', 'Organization ID (optional, auto-assigned if not provided)')
+    .option('--dry-run', 'Preview without executing')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      // Commander.js boolean flag parsing workaround
+      options.dryRun = process.argv.includes('--dry-run');
+      options.json = process.argv.includes('--json');
+      
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      if (!options.name || !options.account || !options.roleIds) {
+        console.error(chalk.red('\n✗ Missing required options: --name, --account, --role-ids\n'));
+        createCommand.help();
+      }
+
+      const roleIdList = options.roleIds.split(',').map((id: string) => id.trim());
+      
+      const userData: any = {
+        realName: options.name,
+        account: options.account,
+        email: options.email,
+        roleIdList,
+      };
+
+      if (options.employeeCode || options.employeeName) {
+        const searchText = options.employeeCode || options.employeeName;
+        const searchResponse = await apiClient.searchEmployees(environment, tenant, searchText);
+        if (!searchResponse.success) {
+          console.error(chalk.red(`\n✗ 职员搜索失败: ${searchResponse.error?.message}\n`));
+          process.exit(1);
+        }
+        
+        let employees = searchResponse.data || [];
+        
+        if (options.employeeCode && options.employeeName) {
+          employees = employees.filter((emp: any) => 
+            emp.code === options.employeeCode && 
+            emp.name && emp.name.includes(options.employeeName)
+          );
+        } else if (options.employeeCode) {
+          employees = employees.filter((emp: any) => emp.code === options.employeeCode);
+        } else if (options.employeeName) {
+          employees = employees.filter((emp: any) => 
+            emp.name && emp.name.includes(options.employeeName)
+          );
+        }
+        
+        if (employees.length === 0) {
+          console.error(chalk.red('\n✗ 未找到匹配的职员\n'));
+          process.exit(1);
+        }
+        
+        if (employees.length > 1) {
+          console.error(chalk.red(`\n✗ 找到多个职员，请使用更精确的条件\n`));
+          process.exit(1);
+        }
+        
+        const employee = employees[0];
+        userData.employeeCode = employee.code;
+        userData.employeeNumber = employee.no;
+        userData.employeeId = employee.id;
+      }
+
+      // 检查账号是否已存在
+      const existCheckResponse = await apiClient.existCheck(environment, tenant, options.account);
+      if (!existCheckResponse.success) {
+        console.error(chalk.red(`\n✗ 账号校验失败: ${existCheckResponse.error?.message}\n`));
+        process.exit(1);
+      }
+      
+      // 如果账号已存在，根据模式处理
+      if (existCheckResponse.data === false) {
+        if (options.dryRun) {
+          console.log(chalk.yellow(`\n⚠️  警告: 账号 "${options.account}" 已存在 (dry-run模式继续预览)\n`));
+        } else {
+          console.error(chalk.red(`\n✗ 账号 "${options.account}" 已存在，请使用其他账号\n`));
+          process.exit(1);
+        }
+      }
+
+      if (!options.dryRun) {
+        try {
+          const userIndexResponse = await apiClient.getUserIndexInfo(environment, tenant);
+          if (userIndexResponse.success && userIndexResponse.data?.userOrgInfoList?.length > 0) {
+            const firstOrg = userIndexResponse.data.userOrgInfoList[0];
+            await apiClient.updateUserOrgOrApp(environment, tenant, { newOrgId: String(firstOrg.orgId) });
+          }
+        } catch (err) {
+        }
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode: No changes will be made\n'));
+        console.log(chalk.gray('User Data:'));
+        console.log(JSON.stringify(userData, null, 2));
+        return;
+      }
+
+      const response = await apiClient.createUser(environment, tenant, userData);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n✓ User created successfully\n'));
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: response.data }, null, 2));
+      }
+    });
+
+  return createCommand;
+}

package/src/commands/liberica/users/delete.ts

@@ -0,0 +1,49 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserDeleteCommand(): Command {
+  const deleteCommand = new Command('delete');
+  deleteCommand.description('Delete a user');
+  
+  deleteCommand
+    .argument('<userId>', 'User ID')
+    .option('--force', 'Skip confirmation')
+    .option('--dry-run', 'Preview without executing')
+    .option('--json', 'Output as JSON')
+    .action(async (userId, options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      if (options.dryRun) {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode\n'));
+        console.log(chalk.gray(`Would delete user: ${userId}`));
+        return;
+      }
+
+      if (!options.force) {
+        const { confirm } = await inquirer.prompt([
+          { type: 'confirm', name: 'confirm', message: `Delete user ${userId}?`, default: false },
+        ]);
+        if (!confirm) {
+          console.log(chalk.yellow('\n↩ Cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      const response = await apiClient.deleteUser(environment, tenant, userId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n✓ User deleted successfully\n'));
+    });
+
+  return deleteCommand;
+}

package/src/commands/liberica/users/disable.ts

@@ -0,0 +1,41 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserDisableCommand(): Command {
+  const disableCommand = new Command('disable');
+  disableCommand.description('Disable a user');
+  
+  disableCommand
+    .argument('<userId>', 'User ID')
+    .option('--force', 'Skip confirmation')
+    .action(async (userId, options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      if (!options.force) {
+        const { confirm } = await inquirer.prompt([
+          { type: 'confirm', name: 'confirm', message: `Disable user ${userId}?`, default: false },
+        ]);
+        if (!confirm) {
+          console.log(chalk.yellow('\n↩ Cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      const response = await apiClient.disableUser(environment, tenant, userId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n✓ User disabled successfully\n'));
+    });
+
+  return disableCommand;
+}

package/src/commands/liberica/users/enable.ts

@@ -0,0 +1,30 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserEnableCommand(): Command {
+  const enableCommand = new Command('enable');
+  enableCommand.description('Enable a user');
+  
+  enableCommand
+    .argument('<userId>', 'User ID')
+    .option('--force', 'Skip confirmation')
+    .action(async (userId, options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const response = await apiClient.enableUser(environment, tenant, userId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n✓ User enabled successfully\n'));
+    });
+
+  return enableCommand;
+}

package/src/commands/liberica/users/get.ts

@@ -0,0 +1,46 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserGetCommand(): Command {
+  const getCommand = new Command('get');
+  getCommand.description('Get user details');
+  
+  getCommand
+    .argument('<userId>', 'User ID')
+    .option('--json', 'Output as JSON')
+    .action(async (userId, options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const response = await apiClient.getUser(environment, tenant, userId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      const user = response.data as any;
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: user }, null, 2));
+        return;
+      }
+
+      console.log(chalk.bold('\n👤 User Details\n'));
+      console.log(chalk.gray('ID:          ') + user.userId);
+      console.log(chalk.gray('Name:        ') + user.realName);
+      console.log(chalk.gray('Account:     ') + user.account);
+      console.log(chalk.gray('Email:       ') + (user.email || '-'));
+      console.log(chalk.gray('Status:      ') + (user.statusFlag === 1 ? chalk.green('Enabled') : chalk.red('Disabled')));
+      console.log(chalk.gray('Employee:    ') + (user.employeeName || '-'));
+      console.log(chalk.gray('Roles:       ') + (user.roleNameList?.join(', ') || '-'));
+      console.log(chalk.gray('Created:     ') + user.createTime);
+      console.log();
+    });
+
+  return getCommand;
+}

package/src/commands/liberica/users/index.ts

@@ -0,0 +1,27 @@
+import { Command } from 'commander';
+import { createUserCreateCommand } from './create.js';
+import { createUserListCommand } from './list.js';
+import { createUserGetCommand } from './get.js';
+import { createUserUpdateCommand } from './update.js';
+import { createUserDeleteCommand } from './delete.js';
+import { createUserEnableCommand } from './enable.js';
+import { createUserDisableCommand } from './disable.js';
+import { createUserMeCommand } from './me.js';
+import { createUserResetPasswordCommand } from './reset-password.js';
+
+export function createUsersCommand(): Command {
+  const usersCommand = new Command('users');
+  usersCommand.description('Manage users');
+
+  usersCommand.addCommand(createUserCreateCommand());
+  usersCommand.addCommand(createUserListCommand());
+  usersCommand.addCommand(createUserGetCommand());
+  usersCommand.addCommand(createUserUpdateCommand());
+  usersCommand.addCommand(createUserDeleteCommand());
+  usersCommand.addCommand(createUserEnableCommand());
+  usersCommand.addCommand(createUserDisableCommand());
+  usersCommand.addCommand(createUserMeCommand());
+  usersCommand.addCommand(createUserResetPasswordCommand());
+
+  return usersCommand;
+}

package/src/commands/liberica/users/list.ts

@@ -0,0 +1,68 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserListCommand(): Command {
+  const listCommand = new Command('list');
+  listCommand.description('List users with pagination');
+
+  listCommand
+    .option('-p, --page <number>', 'Page number', '1')
+    .option('-s, --size <number>', 'Page size', '20')
+    .option('--status <status>', 'Status (1=enabled, 2=disabled)')
+    .option('--account <account>', 'Filter by account')
+    .option('--real-name <realName>', 'Filter by name')
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const params: any = {
+        pageNo: parseInt(options.page) - 1,
+        pageSize: parseInt(options.size),
+      };
+
+      if (options.status) params.status = parseInt(options.status);
+      if (options.account) params.account = options.account;
+      if (options.realName) params.realName = options.realName;
+
+      const response = await apiClient.listUsers(environment, tenant, params);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      const data = response.data as any;
+      const items = data?.rows || [];
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: { items, pagination: data } }, null, 2));
+        return;
+      }
+
+      const table = new Table({
+        head: [chalk.bold('ID'), chalk.bold('Name'), chalk.bold('Account'), chalk.bold('Email'), chalk.bold('Status')],
+        colWidths: [10, 18, 18, 25, 10],
+      });
+
+      for (const user of items) {
+        table.push([
+          user.userId,
+          user.realName,
+          user.account,
+          user.email || '-',
+          user.statusFlag === 1 ? chalk.green('Enabled') : chalk.red('Disabled'),
+        ]);
+      }
+
+      console.log(table.toString());
+      console.log(chalk.gray(`\nTotal: ${data?.totalRows || 0} users`));
+    });
+
+  return listCommand;
+}

package/src/commands/liberica/users/me.ts

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserMeCommand(): Command {
+  const meCommand = new Command('me');
+  meCommand.description('Get current user info');
+  
+  meCommand
+    .option('--json', 'Output as JSON')
+    .action(async (options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const response = await apiClient.getCurrentUser(environment, tenant);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      const user = response.data as any;
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, data: user }, null, 2));
+        return;
+      }
+
+      console.log(chalk.bold('\n👤 Current User\n'));
+      console.log(chalk.gray('ID:       ') + user.userId);
+      console.log(chalk.gray('Name:     ') + user.realName);
+      console.log(chalk.gray('Account:  ') + user.account);
+      console.log(chalk.gray('Email:    ') + (user.email || '-'));
+      console.log(chalk.gray('Roles:    ') + (user.roleNameList?.join(', ') || '-'));
+      console.log();
+    });
+
+  return meCommand;
+}

package/src/commands/liberica/users/reset-password.ts

@@ -0,0 +1,42 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserResetPasswordCommand(): Command {
+  const resetCommand = new Command('reset-password');
+  resetCommand.description('Reset user password');
+  
+  resetCommand
+    .argument('<userId>', 'User ID')
+    .option('--force', 'Skip confirmation')
+    .action(async (userId, options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      if (!options.force) {
+        const { confirm } = await inquirer.prompt([
+          { type: 'confirm', name: 'confirm', message: `Reset password for user ${userId}?`, default: false },
+        ]);
+        if (!confirm) {
+          console.log(chalk.yellow('\n↩ Cancelled\n'));
+          process.exit(0);
+        }
+      }
+
+      const response = await apiClient.resetPassword(environment, tenant, userId);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n✓ Password reset successfully\n'));
+      console.log(chalk.yellow('Note: New password will be sent to user email\n'));
+    });
+
+  return resetCommand;
+}

package/src/commands/liberica/users/update.ts

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Environment } from '../../../types/index.js';
+
+export function createUserUpdateCommand(): Command {
+  const updateCommand = new Command('update');
+  updateCommand.description('Update user information');
+  
+  updateCommand
+    .argument('<userId>', 'User ID')
+    .option('-n, --name <name>', 'User real name')
+    .option('-e, --email <email>', 'User email')
+    .option('-r, --role-ids <roleIds>', 'Role IDs (comma-separated)')
+    .option('--dry-run', 'Preview without executing')
+    .option('--json', 'Output as JSON')
+    .action(async (userId, options) => {
+      const context = configManager.getCurrentContext();
+      const environment = (options.env as Environment) || context.environment;
+      const tenant = options.tenant || context.tenant;
+
+      const updateData: any = { userId };
+      if (options.name) updateData.realName = options.name;
+      if (options.email) updateData.email = options.email;
+      if (options.roleIds) {
+        updateData.roleIdList = options.roleIds.split(',').map((id: string) => id.trim());
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode\n'));
+        console.log(chalk.gray('Update Data:'));
+        console.log(JSON.stringify(updateData, null, 2));
+        return;
+      }
+
+      const response = await apiClient.updateUser(environment, tenant, updateData);
+
+      if (!response.success) {
+        console.error(chalk.red(`\n✗ Failed: ${response.error?.message}\n`));
+        process.exit(1);
+      }
+
+      console.log(chalk.green('\n✓ User updated successfully\n'));
+    });
+
+  return updateCommand;
+}