@newpeak/barista-cli 0.1.5 → 0.1.7

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

@@ -0,0 +1,129 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../../../core/config/manager.js';
+import { apiClient } from '../../../core/api/client.js';
+import { Currency, UpdateCurrencyRequest } from '../../../types/currency.js';
+import { Environment } from '../../../types/index.js';
+
+export function createCurrencyUpdateCommand(): Command {
+  const updateCommand = new Command('update');
+  updateCommand.description('Update currency information').argument('<currencyId>', 'Currency ID');
+
+  updateCommand
+    .option('-n, --name <name>', 'Currency name')
+    .option('-s, --sign <sign>', 'Currency sign/symbol')
+    .option('-r, --rate <rate>', 'Currency exchange rate')
+    .option('--unit-fraction <number>', 'Unit price fraction places')
+    .option('--amount-fraction <number>', 'Amount fraction places')
+    .option('--remark <text>', 'Remark')
+    .option('--dry-run', 'Preview changes without making API call')
+    .option('--json', 'Output result as JSON')
+    .action(async (currencyId: string, options: Record<string, unknown>) => {
+      const context = configManager.getCurrentContext();
+      const environment = context.environment as Environment;
+      const tenant = context.tenant;
+
+      const fields: Partial<UpdateCurrencyRequest> = {};
+      if (options.name) fields.currencyName = options.name as string;
+      if (options.sign) fields.currencySign = options.sign as string;
+      if (options.rate) fields.currencyRate = options.rate as string;
+      if (options.unitFraction) fields.unitPriceFractionPlaces = parseInt(options.unitFraction as string, 10);
+      if (options.amountFraction) fields.amountFractionPlaces = parseInt(options.amountFraction as string, 10);
+      if (options.remark) fields.remark = options.remark as string;
+
+      const providedFields = Object.keys(fields).filter(
+        (k) => fields[k as keyof UpdateCurrencyRequest] !== undefined
+      );
+      if (providedFields.length === 0) {
+        console.error(
+          chalk.red('\n✗ No fields to update. Provide at least one of: --name, --sign, --rate, --unit-fraction, --amount-fraction, --remark\n')
+        );
+        process.exit(1);
+      }
+
+      if (options.dryRun) {
+        console.log(chalk.bold(`\n💱 Update Currency — Dry Run (${environment})\n`));
+        console.log(chalk.gray(`  Currency ID: ${currencyId}`));
+        console.log(chalk.gray('\n  Changes to be applied:'));
+        for (const field of providedFields) {
+          const label = field.replace(/([A-Z])/g, (m) => ` ${m.toLowerCase()}`).trim();
+          console.log(chalk.cyan(`    ${label}: "${fields[field as keyof UpdateCurrencyRequest]}"`));
+        }
+        console.log();
+        return;
+      }
+
+      let currentCurrency: Currency | undefined;
+      try {
+        const currencyResponse = await apiClient.getCurrency(environment, tenant, currencyId);
+        if (!currencyResponse.success || !currencyResponse.data) {
+          console.error(chalk.red(`\n✗ Currency not found: ${currencyId}`));
+          if (currencyResponse.error?.message) {
+            console.error(chalk.gray(`  ${currencyResponse.error.message}`));
+          }
+          if (currencyResponse.error?.code) {
+            console.error(chalk.gray(`  Error code: ${currencyResponse.error.code}`));
+          }
+          console.error();
+          process.exit(1);
+        }
+        currentCurrency = currencyResponse.data as Currency;
+      } catch (error) {
+        console.error(chalk.red(`\n✗ Failed to fetch currency: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        process.exit(1);
+      }
+
+      (options as Record<string, unknown>).json = process.argv.includes('--json');
+      const outputJson = (options as Record<string, unknown>).json === true;
+
+      console.log(chalk.bold(`\n💱 Update Currency (${environment})\n`));
+      console.log(chalk.gray(`  Currency ID: ${currencyId}`));
+      console.log(chalk.gray(`  Current Code: ${currentCurrency.currencyCode}`));
+      console.log(chalk.gray(`  Current Name: ${currentCurrency.currencyName}`));
+      console.log(chalk.gray('\n  Changes:'));
+      for (const field of providedFields) {
+        const label = field.replace(/([A-Z])/g, (m) => ` ${m.toLowerCase()}`).trim();
+        const currentVal = (currentCurrency as unknown as Record<string, unknown>)[field] ?? '(not set)';
+        const newVal = fields[field as keyof UpdateCurrencyRequest];
+        console.log(chalk.cyan(`    ${label}: "${currentVal}" → "${newVal}"`));
+      }
+
+      const updateData = { currencyId, ...fields } as UpdateCurrencyRequest;
+      try {
+        const response = await apiClient.updateCurrency(environment, tenant, updateData);
+
+        if (response.success) {
+          if (outputJson) {
+            console.log(JSON.stringify({ success: true, data: response.data }, null, 2));
+          } else {
+            console.log(chalk.green(`\n✓ Currency updated successfully\n`));
+          }
+        } else {
+          if (outputJson) {
+            console.log(JSON.stringify({ success: false, error: response.error }, null, 2));
+          } else {
+            console.error(chalk.red(`\n✗ Update failed: ${response.error?.message || 'Unknown error'}`));
+            if (response.error?.code) {
+              console.error(chalk.gray(`  Error code: ${response.error.code}`));
+            }
+            console.error();
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        if (outputJson) {
+          console.log(
+            JSON.stringify({
+              success: false,
+              error: { message: error instanceof Error ? error.message : 'Unknown error' },
+            })
+          );
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${error instanceof Error ? error.message : 'Unknown error'}\n`));
+        }
+        process.exit(1);
+      }
+    });
+
+  return updateCommand;
+}

package/src/commands/liberica/index.ts

@@ -11,6 +11,8 @@ import { createClientsCommand } from './clients/index.js';
 import { createSuppliersCommand } from './suppliers/index.js';
 import { createMaterialsCommand } from './materials/index.js';
 import { createUomsCommand } from './uoms/index.js';
+import { createCurrencyCommand } from './currency/index.js';
+import { createWarehousesCommand } from './warehouses/index.js';
 
 export function createLibericaCommand(): Command {
   const libericaCommand = new Command('liberica');
@@ -27,6 +29,8 @@ export function createLibericaCommand(): Command {
   libericaCommand.addCommand(createSuppliersCommand());
   libericaCommand.addCommand(createMaterialsCommand());
   libericaCommand.addCommand(createUomsCommand());
+  libericaCommand.addCommand(createCurrencyCommand());
+  libericaCommand.addCommand(createWarehousesCommand());
 
   libericaCommand.action(() => {
     console.log(chalk.bold('\n☕ Liberica Commands\n'));
@@ -40,6 +44,9 @@ export function createLibericaCommand(): Command {
     console.log('  Use "barista liberica clients <command>" for client management');
     console.log('  Use "barista liberica materials <command>" for material management');
     console.log('  Use "barista liberica uoms <command>" for unit of measure management');
+    console.log('  Use "barista liberica currencies <command>" for currency management');
+    console.log('  Use "barista liberica warehouses <command>" for warehouse management');
+    console.log('  Use "barista liberica warehouses locations <command>" for warehouse location management');
     console.log('\n  Run "barista liberica <command> --help" for more details\n');
   });
 

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

@@ -29,19 +29,26 @@ export function createMaterialsCreateCommand(): Command {
     .option('--dry-run', 'Preview without making API call')
     .option('--json', 'Output as JSON');
 
-  cmd.action(async () => {
+  cmd.action(async (options) => {
     const context = configManager.getCurrentContext();
-    const opts = cmd.opts();
 
-    let name = opts.name as string | undefined;
-    let materialNo = (opts.no as string | undefined) || (opts['no'] as string | undefined);
-    let materialClass = opts.class as string | undefined;
-    const materialType = opts.type as string | undefined;
-    const materialUnit = opts.unit as string | undefined;
-    const dryRun = opts.dryRun === true;
-    const outputJson = (opts as any).json === true || process.argv.includes('--json');
+    let name = options.name as string | undefined;
+    let materialNo = (options.no as string | undefined) || (options['no'] as string | undefined);
+    let materialClass = options.class as string | undefined;
+    const materialType = options.type as string | undefined;
+    const materialUnit = options.unit as string | undefined;
+    const dryRun = options.dryRun === true;
+    const outputJson = options.json === true;
 
     if (!name) {
+      if (dryRun) {
+        if (outputJson) {
+          console.log(JSON.stringify({ success: false, error: { code: 'DRY_RUN_MISSING_ARGS', message: 'Missing required --name in dry-run mode' } }));
+        } else {
+          console.error(chalk.red('\n✗ --name is required. Cannot preview without material name.\n'));
+        }
+        process.exit(1);
+      }
       const { inputName } = await inquirer.prompt([
         {
           type: 'input',
@@ -54,6 +61,14 @@ export function createMaterialsCreateCommand(): Command {
     }
 
     if (!materialClass) {
+      if (dryRun) {
+        if (outputJson) {
+          console.log(JSON.stringify({ success: false, error: { code: 'DRY_RUN_MISSING_ARGS', message: 'Missing required --class in dry-run mode' } }));
+        } else {
+          console.error(chalk.red('\n✗ --class is required. Cannot preview without material class.\n'));
+        }
+        process.exit(1);
+      }
       const { inputClass } = await inquirer.prompt([
         {
           type: 'input',
@@ -66,6 +81,14 @@ export function createMaterialsCreateCommand(): Command {
     }
 
     if (!materialNo) {
+      if (dryRun) {
+        if (outputJson) {
+          console.log(JSON.stringify({ success: false, error: { code: 'DRY_RUN_MISSING_ARGS', message: 'Missing required --no in dry-run mode' } }));
+        } else {
+          console.error(chalk.red('\n✗ --no is required. Cannot preview without material number.\n'));
+        }
+        process.exit(1);
+      }
       const { inputNo } = await inquirer.prompt([
         {
           type: 'input',

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

@@ -1,6 +1,5 @@
 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';

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

@@ -105,6 +105,7 @@ export function createUserCreateCommand(): Command {
             await apiClient.updateUserOrgOrApp(environment, tenant, { newOrgId: String(firstOrg.orgId) });
           }
         } catch (err) {
+          // ignore errors during org switch
         }
       }
 

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

@@ -0,0 +1,204 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { apiClient } from '../../../core/api/client.js';
+import { configManager } from '../../../core/config/manager.js';
+import { CreateWarehouseRequest } from '../../../types/warehouse.js';
+
+function formatTable(data: CreateWarehouseRequest): string {
+  const lines: string[] = [];
+  lines.push(`  ${chalk.gray('Code:')}   ${data.warehouseCode}`);
+  lines.push(`  ${chalk.gray('Name:')}   ${data.warehouseName || '(not set)'}`);
+  if (data.warehouseType) lines.push(`  ${chalk.gray('Type:')}   ${data.warehouseType}`);
+  if (data.warehouseClasses) lines.push(`  ${chalk.gray('Classes:')}   ${data.warehouseClasses}`);
+  if (data.address) lines.push(`  ${chalk.gray('Address:')}   ${data.address}`);
+  if (data.contact) lines.push(`  ${chalk.gray('Contact:')}   ${data.contact}`);
+  if (data.phone) lines.push(`  ${chalk.gray('Phone:')}   ${data.phone}`);
+  if (data.manager) lines.push(`  ${chalk.gray('Manager:')}   ${data.manager}`);
+  if (data.enableLocation !== undefined) {
+    lines.push(`  ${chalk.gray('Enable Location:')}   ${data.enableLocation === 'Y' ? 'Yes' : 'No'}`);
+  }
+  if (data.enableNegativeInventory !== undefined) {
+    lines.push(`  ${chalk.gray('Enable Negative Inventory:')}   ${data.enableNegativeInventory === 'Y' ? 'Yes' : 'No'}`);
+  }
+  if (data.remark) lines.push(`  ${chalk.gray('Remark:')}   ${data.remark}`);
+  return lines.join('\n');
+}
+
+export function createWarehouseCreateCommand(): Command {
+  const cmd = new Command('create');
+  cmd.description('Create a new warehouse (auto-generates code if not provided)');
+
+  cmd
+    .option('-n, --name <name>', 'Warehouse name (required)')
+    .option('-c, --code <code>', 'Warehouse code (auto-generated if not provided)')
+    .option('-t, --type <type>', 'Warehouse type')
+    .option('--classes <classes>', 'Warehouse classes')
+    .option('-a, --address <address>', 'Address')
+    .option('--contact <contact>', 'Contact person')
+    .option('-p, --phone <phone>', 'Contact phone')
+    .option('-m, --manager <manager>', 'Warehouse manager')
+    .option('--enable-location', 'Enable location management')
+    .option('--disable-location', 'Disable location management')
+    .option('--enable-negative-inventory', 'Enable negative inventory')
+    .option('--disable-negative-inventory', 'Disable negative inventory')
+    .option('--remark <remark>', 'Remark')
+    .option('--dry-run', 'Preview without making API call')
+    .option('--json', 'Output as JSON');
+
+  cmd.action(async (options) => {
+    const context = configManager.getCurrentContext();
+
+    let name = options.name as string | undefined;
+    let code = options.code as string | undefined;
+    const type = options.type as string | undefined;
+    const classes = options.classes as string | undefined;
+    const address = options.address as string | undefined;
+    const contact = options.contact as string | undefined;
+    const phone = options.phone as string | undefined;
+    const manager = options.manager as string | undefined;
+    const enableLocationRaw = options.enableLocation as boolean | undefined;
+    const disableLocationRaw = options.disableLocation as boolean | undefined;
+    const enableNegativeInventoryRaw = options.enableNegativeInventory as boolean | undefined;
+    const disableNegativeInventoryRaw = options.disableNegativeInventory as boolean | undefined;
+    const remark = options.remark as string | undefined;
+    const dryRun = options.dryRun === true;
+    const jsonOutput = options.json === true;
+
+    if (!name) {
+      const { inputName } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'inputName',
+          message: 'Enter warehouse name:',
+          validate: (input: string) => input.trim().length > 0 || 'Warehouse name is required',
+        },
+      ]);
+      name = inputName;
+    }
+
+    if (!code) {
+      const codeResponse = await apiClient.getCodeByType(context.environment, context.tenant, 'TenantWarehouseCode');
+      if (codeResponse.success && codeResponse.data) {
+        code = codeResponse.data;
+      } else {
+        const errMsg = codeResponse.error?.message || 'Failed to generate warehouse code';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'CODE_GENERATION_ERROR', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ Failed to generate warehouse code: ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+    }
+
+    let enableLocation: string | undefined;
+    if (enableLocationRaw !== undefined) {
+      enableLocation = 'Y';
+    } else if (disableLocationRaw !== undefined) {
+      enableLocation = 'N';
+    }
+
+    let enableNegativeInventory: string | undefined;
+    if (enableNegativeInventoryRaw !== undefined) {
+      enableNegativeInventory = 'Y';
+    } else if (disableNegativeInventoryRaw !== undefined) {
+      enableNegativeInventory = 'N';
+    }
+
+    const data: CreateWarehouseRequest = {
+      warehouseCode: code!,
+      warehouseName: name!,
+      warehouseType: type,
+      warehouseClasses: classes,
+      address: address,
+      contact: contact,
+      phone: phone,
+      manager: manager,
+      enableLocation: enableLocation,
+      enableNegativeInventory: enableNegativeInventory,
+      remark: remark,
+    };
+
+    if (dryRun) {
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, dryRun: true, data }));
+      } else {
+        console.log(chalk.bold('\n🔍 Dry-Run Mode: No changes will be made\n'));
+        console.log('  Warehouse to be created:');
+        console.log(formatTable(data));
+        console.log();
+      }
+      return;
+    }
+
+    if (!jsonOutput) {
+      console.log(chalk.bold('\n📝 Creating Warehouse\n'));
+    }
+
+    const response = await apiClient.createWarehouse(context.environment, context.tenant, data);
+
+    if (!response.success) {
+      const errorMsg = response.error?.message || 'Failed to create warehouse';
+      const errorCode = response.error?.code || 'CREATE_WAREHOUSE_ERROR';
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+      } else {
+        console.error(chalk.red(`\n✗ Failed to create warehouse: ${errorMsg}`));
+        if (response.error?.code) {
+          console.error(chalk.gray(`  Error code: ${response.error.code}`));
+        }
+        console.error();
+      }
+      process.exit(1);
+    }
+
+    if (response.success) {
+      const warehouse = response.data as {
+        warehouseId?: string;
+        warehouseCode?: string;
+        warehouseName?: string;
+        warehouseType?: string;
+        warehouseClasses?: string;
+        address?: string;
+        contact?: string;
+        phone?: string;
+        manager?: string;
+        enableLocation?: boolean;
+        enableNegativeInventory?: boolean;
+        remark?: string;
+        status?: number;
+        createTime?: string;
+      } | undefined;
+
+      if (jsonOutput) {
+        console.log(JSON.stringify({ success: true, data: warehouse }));
+      } else {
+        console.log(chalk.green('✓ Warehouse created successfully\n'));
+        if (warehouse?.warehouseId) console.log(`  ${chalk.gray('Warehouse ID:')} ${chalk.green(String(warehouse.warehouseId))}`);
+        if (warehouse?.warehouseCode) console.log(`  ${chalk.gray('Code:')}   ${warehouse.warehouseCode}`);
+        if (warehouse?.warehouseName) console.log(`  ${chalk.gray('Name:')}   ${warehouse.warehouseName}`);
+        if (warehouse?.warehouseType) console.log(`  ${chalk.gray('Type:')}   ${warehouse.warehouseType}`);
+        if (warehouse?.warehouseClasses) console.log(`  ${chalk.gray('Classes:')}   ${warehouse.warehouseClasses}`);
+        if (warehouse?.address) console.log(`  ${chalk.gray('Address:')}   ${warehouse.address}`);
+        if (warehouse?.contact) console.log(`  ${chalk.gray('Contact:')}   ${warehouse.contact}`);
+        if (warehouse?.phone) console.log(`  ${chalk.gray('Phone:')}   ${warehouse.phone}`);
+        if (warehouse?.manager) console.log(`  ${chalk.gray('Manager:')}   ${warehouse.manager}`);
+        if (warehouse?.enableLocation !== undefined) {
+          console.log(`  ${chalk.gray('Enable Location:')}   ${warehouse.enableLocation ? 'Yes' : 'No'}`);
+        }
+        if (warehouse?.enableNegativeInventory !== undefined) {
+          console.log(`  ${chalk.gray('Enable Negative Inventory:')}   ${warehouse.enableNegativeInventory ? 'Yes' : 'No'}`);
+        }
+        if (warehouse?.remark) console.log(`  ${chalk.gray('Remark:')}   ${warehouse.remark}`);
+        if (warehouse?.status !== undefined) {
+          const statusText = warehouse.status === 1 ? 'Enabled' : 'Disabled';
+          console.log(`  ${chalk.gray('Status:')}   ${chalk.green(statusText)}`);
+        }
+        console.log();
+      }
+    }
+  });
+
+  return cmd;
+}

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

@@ -0,0 +1,112 @@
+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';
+import { Warehouse } from '../../../types/warehouse.js';
+
+export function createWarehouseDeleteCommand(): Command {
+  const deleteCommand = new Command('delete');
+  deleteCommand
+    .description('Delete a warehouse')
+    .argument('<warehouseId>', 'Warehouse ID')
+    .option('--force', 'Skip confirmation and delete directly')
+    .option('--dry-run', 'Preview without making API call')
+    .option('--json', 'Output as JSON')
+    .action(async (warehouseId: string, options: Record<string, unknown>) => {
+      const context = configManager.getCurrentContext();
+      const environment = context.environment as Environment;
+      const tenant = context.tenant;
+      const dryRun = options.dryRun === true;
+      const jsonOutput = options.json === true;
+
+      if (!jsonOutput) {
+        console.log(chalk.bold(`\n🗑️  Delete Warehouse (${environment})\n`));
+        console.log(chalk.gray(`  Warehouse ID: ${warehouseId}`));
+      }
+
+      let warehouse: Warehouse | undefined;
+      try {
+        const warehouseResponse = await apiClient.getWarehouse(environment, tenant, warehouseId);
+        if (!warehouseResponse.success || !warehouseResponse.data || !('warehouseId' in warehouseResponse.data)) {
+          const errMsg = `Warehouse not found: ${warehouseId}`;
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: { code: 'NOT_FOUND', message: errMsg } }));
+          } else {
+            console.error(chalk.red(`\n✗ ${errMsg}\n`));
+          }
+          process.exit(1);
+        }
+        warehouse = warehouseResponse.data as Warehouse;
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'FETCH_ERROR', message: `Failed to fetch warehouse: ${errMsg}` } }));
+        } else {
+          console.error(chalk.red(`\n✗ Failed to fetch warehouse: ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+
+      if (!jsonOutput) {
+        console.log(chalk.gray(`  Name: ${warehouse.warehouseName}`));
+        console.log(chalk.gray(`  Code: ${warehouse.warehouseCode}`));
+        if (warehouse.contact) {
+          console.log(chalk.gray(`  Contact: ${warehouse.contact} (${warehouse.phone || 'N/A'})`));
+        }
+        if (warehouse.address) {
+          console.log(chalk.gray(`  Address: ${warehouse.address}`));
+        }
+      }
+
+      if (dryRun) {
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: true, dryRun: true, warehouse }));
+        } else {
+          console.log(chalk.cyan('\n🔍 Dry-Run Mode: No actual deletion will be made\n'));
+          console.log(chalk.yellow('  To delete, add: --force\n'));
+        }
+        return;
+      }
+
+      if (!options.force) {
+        // TODO: add confirmation prompt here
+        return;
+      }
+
+      try {
+        const response = await apiClient.deleteWarehouse(environment, tenant, warehouseId);
+
+        if (response.success) {
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: true, warehouseId, name: warehouse.warehouseName }));
+          } else {
+            console.log(chalk.green(`\n✓ Warehouse "${warehouse.warehouseName}" (ID: ${warehouseId}) deleted\n`));
+          }
+        } else {
+          const errorMsg = response.error?.message || 'Unknown error';
+          const errorCode = response.error?.code || 'DELETE_ERROR';
+          if (jsonOutput) {
+            console.log(JSON.stringify({ success: false, error: { code: errorCode, message: errorMsg } }));
+          } else {
+            console.error(chalk.red(`\n✗ Failed to delete warehouse: ${errorMsg}`));
+            if (response.error?.code) {
+              console.error(chalk.gray(`  Error code: ${response.error.code}`));
+            }
+            console.error();
+          }
+          process.exit(1);
+        }
+      } catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        if (jsonOutput) {
+          console.log(JSON.stringify({ success: false, error: { code: 'ERROR', message: errMsg } }));
+        } else {
+          console.error(chalk.red(`\n✗ Error: ${errMsg}\n`));
+        }
+        process.exit(1);
+      }
+    });
+
+  return deleteCommand;
+}