@zintrust/core 0.4.17 → 0.4.19

package/src/cli/commands/BroadcastWorkCommand.ts

@@ -1,20 +0,0 @@
-/**
- * Broadcast Work Command
- * Alias to work a broadcast queue.
- */
-
-import { type IBaseCommand } from '@cli/BaseCommand';
-import { createKindWorkCommand } from '@cli/commands/createKindWorkCommand';
-
-export const BroadcastWorkCommand = Object.freeze({
-  create(): IBaseCommand {
-    return createKindWorkCommand({
-      name: 'broadcast:work',
-      description: 'Work queued broadcasts',
-      kind: 'broadcast',
-      helpHint: 'zin broadcast:work --help',
-    });
-  },
-});
-
-export default BroadcastWorkCommand;

package/src/cli/commands/BulletproofKeyGenerateCommand.ts

@@ -1,173 +0,0 @@
-/**
- * Bulletproof Signing Secret Generate Command
- * Generates and sets BULLETPROOF_SIGNING_SECRET (with rotation backups)
- */
-
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { Logger } from '@config/logger';
-import * as crypto from '@node-singletons/crypto';
-import { fsPromises as fs } from '@node-singletons/fs';
-import * as path from '@node-singletons/path';
-import type { Command } from 'commander';
-
-type BulletproofKeyOptions = CommandOptions & {
-  show?: boolean;
-  maxBackups?: string;
-};
-
-const ENV_KEY = 'BULLETPROOF_SIGNING_SECRET';
-const ENV_BK_KEY = 'BULLETPROOF_SIGNING_SECRET_BK';
-
-export const BulletproofKeyGenerateCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'key:bulletproof',
-      description: 'Generate/rotate BULLETPROOF_SIGNING_SECRET (signed-request proof key)',
-      aliases: ['bulletproof:key', 'key:signer'],
-      addOptions: (command: Command) => {
-        command.option('--show', 'Display the key (and suggested env) instead of modifying files');
-        command.option(
-          '--max-backups <n>',
-          'Max secrets to keep in BULLETPROOF_SIGNING_SECRET_BK (default: 5)',
-          '5'
-        );
-      },
-      execute: async (options: BulletproofKeyOptions) => {
-        const key = generateRandomKey();
-        const maxBackups = parseMaxBackups(options.maxBackups);
-
-        if (options.show === true) {
-          Logger.info(`${ENV_KEY}=${key}`);
-          Logger.info(`${ENV_BK_KEY}=[]`);
-          return;
-        }
-
-        const envPath = path.resolve(process.cwd(), '.env');
-
-        try {
-          let envContent = '';
-
-          try {
-            envContent = await fs.readFile(envPath, 'utf-8');
-          } catch (error) {
-            Logger.warn('Could not read .env file, attempting to create from example', { error });
-            const examplePath = path.resolve(process.cwd(), '.env.example');
-            try {
-              envContent = await fs.readFile(examplePath, 'utf-8');
-              await fs.writeFile(envPath, envContent);
-              Logger.info('.env file created from .env.example');
-            } catch (copyError) {
-              Logger.error('Failed to create .env from example', { error: copyError });
-              Logger.warn(
-                '.env file not found and .env.example not found. Creating new .env file.'
-              );
-              envContent = '';
-            }
-          }
-
-          const currentSecret = readEnvLineValue(envContent, ENV_KEY);
-          const currentBackups = parseBackups(readEnvLineValue(envContent, ENV_BK_KEY));
-
-          const nextBackups = rotateBackups({
-            currentSecret,
-            currentBackups,
-            maxBackups,
-          });
-
-          envContent = upsertEnvLine(envContent, ENV_BK_KEY, JSON.stringify(nextBackups));
-          envContent = upsertEnvLine(envContent, ENV_KEY, key);
-
-          await fs.writeFile(envPath, envContent);
-          Logger.info(`Bulletproof signing secret set successfully. [${key}]`);
-        } catch (error) {
-          Logger.error('Failed to update .env file', error);
-        }
-      },
-    });
-  },
-});
-
-const parseMaxBackups = (raw: unknown): number => {
-  const n = typeof raw === 'string' ? Number.parseInt(raw, 10) : Number.NaN;
-  if (!Number.isFinite(n) || n < 0) return 5;
-  return Math.min(50, n);
-};
-
-const generateRandomKey = (): string => {
-  // 32 bytes = 256-bit (same as APP_KEY default strength).
-  return 'base64:' + crypto.randomBytes(32).toString('base64');
-};
-
-const readEnvLineValue = (envContent: string, key: string): string => {
-  const re = new RegExp(`^${escapeRegExp(key)}=(.*)$`, 'm');
-  const match = re.exec(envContent);
-  return typeof match?.[1] === 'string' ? match[1].trim() : '';
-};
-
-const upsertEnvLine = (envContent: string, key: string, value: string): string => {
-  const line = `${key}=${value}`;
-  const re = new RegExp(`^${escapeRegExp(key)}=.*$`, 'm');
-  if (re.test(envContent)) {
-    return envContent.replace(re, line);
-  }
-
-  const trimmed = envContent.trimEnd();
-  if (trimmed === '') return `${line}\n`;
-  return `${trimmed}\n${line}\n`;
-};
-
-const escapeRegExp = (value: string): string =>
-  value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-
-const parseBackups = (raw: string): string[] => {
-  const value = raw.trim();
-  if (value === '') return [];
-
-  if (value.startsWith('[')) {
-    try {
-      const parsed = JSON.parse(value) as unknown;
-      if (!Array.isArray(parsed)) return [];
-      return parsed
-        .filter((v): v is string => typeof v === 'string')
-        .map((s) => s.trim())
-        .filter((s) => s !== '');
-    } catch {
-      return [];
-    }
-  }
-
-  return value
-    .split(',')
-    .map((s) => s.trim())
-    .filter((s) => s !== '');
-};
-
-const rotateBackups = (params: {
-  currentSecret: string;
-  currentBackups: string[];
-  maxBackups: number;
-}): string[] => {
-  const seen = new Set<string>();
-  const out: string[] = [];
-
-  const pushUnique = (secret: string): void => {
-    const s = secret.trim();
-    if (s === '') return;
-    if (seen.has(s)) return;
-    seen.add(s);
-    out.push(s);
-  };
-
-  if (params.currentSecret !== '') {
-    pushUnique(params.currentSecret);
-  }
-
-  for (const s of params.currentBackups) {
-    pushUnique(s);
-  }
-
-  return out.slice(0, Math.max(0, params.maxBackups));
-};
-
-export default BulletproofKeyGenerateCommand;

package/src/cli/commands/ConfigCommand.ts

@@ -1,420 +0,0 @@
-/**
- * Config Command - Configuration management CLI command
- * Handles configuration operations: get, set, list, reset, edit, export
- */
-
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import type { IConfigManager } from '@cli/config/ConfigManager';
-import { ConfigManager } from '@cli/config/ConfigManager';
-import type { ProjectConfig } from '@cli/config/ConfigSchema';
-import { ConfigValidator } from '@cli/config/ConfigValidator';
-import { ErrorHandler } from '@cli/ErrorHandler';
-import { PromptHelper } from '@cli/PromptHelper';
-import { Logger } from '@config/logger';
-import { isArray, isObject } from '@helper/index';
-import chalk from 'chalk';
-import type { Command } from 'commander';
-
-type ConfigManagerLike = {
-  get?: (key: string) => unknown;
-  set?: (key: string, value: unknown) => void;
-  save?: () => void;
-  reset?: () => void;
-  getConfig?: () => ProjectConfig;
-  getAllKeys?: () => string[];
-  export?: () => string;
-};
-
-type IConfigCommand = IBaseCommand & {
-  getConfigManager: (isGlobal: boolean) => Promise<IConfigManager>;
-  handleAction: (
-    action: string,
-    manager: ConfigManagerLike,
-    key?: string,
-    value?: string,
-    options?: CommandOptions
-  ) => Promise<void>;
-  handleGet: (manager: ConfigManagerLike, key?: string, value?: string) => void;
-  handleSet: (
-    manager: ConfigManagerLike,
-    key?: string,
-    value?: string,
-    options?: CommandOptions
-  ) => void;
-  handleList: (manager: ConfigManagerLike, options: CommandOptions) => void;
-  handleReset: (manager: ConfigManagerLike) => Promise<void>;
-  handleEdit: (manager: ConfigManagerLike) => Promise<void>;
-  handleExport: (manager: ConfigManagerLike) => void;
-  parseConfigValue: (value?: string) => unknown;
-  formatConfigValue: (value: unknown) => string;
-  displayValidationStatus: (config: ProjectConfig) => void;
-  displayConfigurationKeys: (keys: string[]) => void;
-  displayConfigurationValues: (config: ProjectConfig) => void;
-  editSingleConfig: (manager: ConfigManagerLike, selectedKey: string) => Promise<void>;
-};
-
-const addOptions = (command: Command): void => {
-  command.argument('[action]', 'Action: get, set, list, reset, edit, export');
-  command.argument('[key]', 'Configuration key (for get/set)');
-  command.argument('[value]', 'Configuration value (for set)');
-  command.option('--global', 'Use global config instead of project config');
-  command.option('--json', 'Output as JSON');
-  command.option('--show-defaults', 'Show default values in list');
-};
-
-const getGlobalConfigManager = async (): Promise<IConfigManager> => ConfigManager.getGlobalConfig();
-
-const getProjectConfigManager = async (): Promise<IConfigManager> =>
-  ConfigManager.getProjectConfig();
-
-const toDisplayString = (value: unknown): string => {
-  if (value === undefined || value === null) return 'null';
-  if (typeof value === 'string') return value;
-  if (typeof value === 'number' || typeof value === 'bigint') return value.toString();
-  if (typeof value === 'boolean') return value ? 'true' : 'false';
-  if (typeof value === 'symbol') return value.toString();
-  if (typeof value === 'function') return '[Function]';
-
-  try {
-    return JSON.stringify(value, null, 2);
-  } catch {
-    return '[Unserializable]';
-  }
-};
-
-const formatConfigValue = (value: unknown): string => {
-  if (value === undefined || value === null) return chalk.gray('null');
-  if (typeof value === 'object') return JSON.stringify(value, null, 2);
-  if (typeof value === 'boolean') return value ? chalk.green('true') : chalk.red('false');
-  if (typeof value === 'number') return chalk.yellow(value.toString());
-  if (typeof value === 'string') return value;
-  if (typeof value === 'bigint') return chalk.yellow(value.toString());
-  if (typeof value === 'symbol') return chalk.gray(value.toString());
-  if (typeof value === 'function') return chalk.gray('[Function]');
-  return chalk.gray(toDisplayString(value));
-};
-
-const parseConfigValue = (value?: string): unknown => {
-  if (value === undefined) return undefined;
-  if (value === '') return '';
-
-  const lower = value.toLowerCase();
-  if (lower === 'true') return true;
-  if (lower === 'false') return false;
-  if (lower === 'null') return null;
-
-  if (/^-?\d+$/.test(value)) return Number.parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return Number.parseFloat(value);
-
-  if (value.startsWith('{') || value.startsWith('[')) {
-    try {
-      return JSON.parse(value) as unknown;
-    } catch (error) {
-      Logger.error('Failed to parse JSON config value', error);
-      return value;
-    }
-  }
-
-  return value;
-};
-
-const displayValidationStatus = (cmd: IBaseCommand, config: ProjectConfig): void => {
-  const validation = ConfigValidator.validate(config);
-  if (validation?.valid === true) {
-    cmd.info(chalk.green('  ✅ Configuration is valid'));
-    return;
-  }
-
-  const errors = validation?.errors ?? [];
-  cmd.info(chalk.red(`  ❌ Configuration has ${errors.length} errors:`));
-  for (const error of errors) {
-    const message =
-      error !== null && typeof error === 'object' && 'message' in error
-        ? toDisplayString((error as { message: unknown }).message)
-        : toDisplayString(error);
-    cmd.info(chalk.red(`     - ${message}`));
-  }
-};
-
-const displayConfigurationKeys = (cmd: IBaseCommand, keys: string[]): void => {
-  const sorted = keys.slice().sort((a, b) => a.localeCompare(b));
-  cmd.info(chalk.cyan('\n  Available Keys:'));
-  for (const key of sorted) {
-    cmd.info(`  • ${key}`);
-  }
-};
-
-const displayConfigurationValues = (cmd: IBaseCommand, config: ProjectConfig): void => {
-  cmd.info('');
-  const entries = Object.entries(config).sort(([a], [b]) => a.localeCompare(b));
-  for (const [key, value] of entries) {
-    cmd.info(`${chalk.cyan(key)}: ${formatConfigValue(value)}`);
-  }
-};
-
-const handleGet = (cmd: IBaseCommand, manager: ConfigManagerLike, key?: string): void => {
-  if (key === undefined) {
-    ErrorHandler.usageError('Configuration key is required for "get"');
-  }
-
-  if (typeof manager.get !== 'function') {
-    cmd.warn('Configuration manager does not support "get"');
-  }
-
-  if (typeof manager.get === 'function' && key !== undefined) {
-    const value = manager.get(key);
-    if (value === undefined) {
-      cmd.warn(`Configuration key "${key}" not found`);
-    }
-
-    cmd.info(formatConfigValue(value));
-  }
-};
-
-const handleSet = (
-  cmd: IBaseCommand,
-  manager: ConfigManagerLike,
-  key?: string,
-  value?: string
-): void => {
-  if (key === undefined || value === undefined) {
-    ErrorHandler.usageError('Both key and value are required for "set"');
-    return;
-  }
-
-  if (typeof manager.set !== 'function') {
-    cmd.warn('Configuration manager does not support "set"');
-    return;
-  }
-
-  const parsedValue = parseConfigValue(value);
-  const validationError = ConfigValidator.validateValue(key, parsedValue);
-  if (validationError) {
-    cmd.warn(`Validation error for "${key}": ${validationError.message}`);
-    return;
-  }
-
-  manager.set(key, parsedValue);
-  if (typeof manager.save === 'function') {
-    manager.save();
-  }
-  cmd.success(`Configuration updated: ${key} = ${value}`);
-};
-
-const handleList = (
-  cmd: IBaseCommand,
-  manager: ConfigManagerLike,
-  options: CommandOptions
-): void => {
-  if (options['json'] === true && typeof manager.export === 'function') {
-    cmd.info(manager.export());
-  }
-
-  const config =
-    typeof manager.getConfig === 'function' ? manager.getConfig() : ({} as ProjectConfig);
-  cmd.info(chalk.bold('\n🛠️  Current Configuration:\n'));
-  displayValidationStatus(cmd, config);
-  displayConfigurationKeys(cmd, Object.keys(config));
-  displayConfigurationValues(cmd, config);
-
-  if (options['showDefaults'] === true) {
-    cmd.info(chalk.gray('\n(Default values shown above)'));
-  }
-};
-
-const handleReset = async (cmd: IBaseCommand, manager: ConfigManagerLike): Promise<void> => {
-  const confirmed = await PromptHelper.confirm(
-    'Are you sure you want to reset configuration to defaults?',
-    false
-  );
-
-  if (!confirmed) {
-    cmd.info('Reset cancelled');
-    return;
-  }
-
-  if (typeof manager.reset === 'function') {
-    manager.reset();
-  }
-  cmd.success('Configuration reset to defaults');
-};
-
-const editSingleConfig = async (
-  cmd: IBaseCommand,
-  manager: ConfigManagerLike,
-  selectedKey: string
-): Promise<void> => {
-  const currentValue = typeof manager.get === 'function' ? manager.get(selectedKey) : undefined;
-  let defaultValue = '';
-  if (currentValue !== undefined) {
-    defaultValue =
-      typeof currentValue === 'object'
-        ? JSON.stringify(currentValue)
-        : toDisplayString(currentValue);
-  }
-
-  const newValue = await PromptHelper.textInput(
-    `Enter new value for "${selectedKey}":`,
-    defaultValue
-  );
-  if (newValue === undefined) return;
-
-  const parsedValue = parseConfigValue(newValue);
-  const validationError = ConfigValidator.validateValue(selectedKey, parsedValue);
-  if (validationError) {
-    cmd.warn(`Validation error: ${validationError.message}`);
-    return;
-  }
-
-  if (typeof manager.set === 'function') {
-    manager.set(selectedKey, parsedValue);
-  }
-  if (typeof manager.save === 'function') {
-    manager.save();
-  }
-  cmd.success(`Updated ${selectedKey}`);
-};
-
-const handleEdit = async (cmd: IBaseCommand, manager: ConfigManagerLike): Promise<void> => {
-  cmd.info(chalk.bold('\n📝 Interactive Configuration Editor\n'));
-
-  const config =
-    typeof manager.getConfig === 'function' ? manager.getConfig() : ({} as ProjectConfig);
-  const keys = Object.keys(config);
-  const fallbackKeys = typeof manager.getAllKeys === 'function' ? manager.getAllKeys() : [];
-  const availableKeys = keys.length > 0 ? keys : fallbackKeys;
-
-  if (availableKeys.length === 0) {
-    cmd.warn('No configuration keys found');
-    return;
-  }
-
-  const menuKeys = [...availableKeys].sort((a, b) => a.localeCompare(b)).concat(['(Done)']);
-
-  // Interactive prompt loop must be sequential.
-  /* eslint-disable no-await-in-loop */
-  while (true) {
-    const selectedKey = await PromptHelper.chooseFrom(
-      'Select configuration key to edit:',
-      menuKeys
-    );
-    if (selectedKey === '' || selectedKey === '(Done)') break;
-    await editSingleConfig(cmd, manager, selectedKey);
-  }
-  /* eslint-enable no-await-in-loop */
-
-  cmd.success('Configuration editing complete');
-};
-
-const handleExport = (cmd: IBaseCommand, manager: ConfigManagerLike): void => {
-  cmd.info(typeof manager.export === 'function' ? manager.export() : '{}');
-};
-
-const getArg = (args: unknown, index: number): string | undefined => {
-  if (!isArray(args)) return undefined;
-  const value = args[index];
-  return typeof value === 'string' ? value : undefined;
-};
-
-const executeConfig = async (cmd: IBaseCommand, options: CommandOptions): Promise<void> => {
-  const typedCmd = cmd as IConfigCommand;
-  const command = cmd.getCommand();
-  const toRecord = (value: unknown): Record<string, unknown> => {
-    return isObject(value) ? value : {};
-  };
-
-  const commandOpts: Record<string, unknown> =
-    typeof command.opts === 'function' ? toRecord(command.opts() as unknown) : {};
-
-  const mergedOptions: CommandOptions = {
-    ...commandOpts,
-    ...options,
-  };
-
-  const action = getArg(options.args, 0) ?? getArg(command.args, 0) ?? 'list';
-  const key = getArg(options.args, 1) ?? getArg(command.args, 1);
-  const value = getArg(options.args, 2) ?? getArg(command.args, 2);
-
-  const manager = await typedCmd.getConfigManager(mergedOptions['global'] === true);
-  await typedCmd.handleAction(action, manager, key, value, mergedOptions);
-};
-
-/**
- * Config Command Factory
- */
-export const ConfigCommand = Object.freeze({
-  /**
-   * Create a new config command instance
-   */
-  create(): IBaseCommand {
-    const cmd = BaseCommand.create<IConfigCommand>({
-      name: 'config',
-      description: 'Manage application configuration',
-      addOptions,
-      execute: async (options: CommandOptions): Promise<void> => executeConfig(cmd, options),
-    });
-
-    cmd.getConfigManager = async (isGlobal: boolean): Promise<IConfigManager> =>
-      isGlobal ? getGlobalConfigManager() : getProjectConfigManager();
-
-    cmd.handleGet = (manager: ConfigManagerLike, key?: string, value?: string): void =>
-      handleGet(cmd, manager, key ?? value);
-
-    cmd.handleSet = (manager: ConfigManagerLike, key?: string, value?: string): void =>
-      handleSet(cmd, manager, key, value);
-
-    cmd.handleList = (manager: ConfigManagerLike, options: CommandOptions): void =>
-      handleList(cmd, manager, options);
-
-    cmd.handleReset = async (manager: ConfigManagerLike): Promise<void> =>
-      handleReset(cmd, manager);
-
-    cmd.handleEdit = async (manager: ConfigManagerLike): Promise<void> => handleEdit(cmd, manager);
-
-    cmd.handleExport = (manager: ConfigManagerLike): void => handleExport(cmd, manager);
-
-    cmd.handleAction = async (
-      action: string,
-      manager: ConfigManagerLike,
-      key?: string,
-      value?: string,
-      options?: CommandOptions
-    ): Promise<void> => {
-      switch (action.toLowerCase()) {
-        case 'get':
-          cmd.handleGet(manager, key, value);
-          return;
-        case 'set':
-          cmd.handleSet(manager, key, value, options);
-          return;
-        case 'list':
-          cmd.handleList(manager, options ?? {});
-          return;
-        case 'reset':
-          await cmd.handleReset(manager);
-          return;
-        case 'edit':
-          await cmd.handleEdit(manager);
-          return;
-        case 'export':
-          cmd.handleExport(manager);
-          return;
-        default:
-          ErrorHandler.usageError(`Unknown action: ${action}`);
-      }
-    };
-
-    cmd.parseConfigValue = (value?: string): unknown => parseConfigValue(value);
-    cmd.formatConfigValue = (value: unknown): string => formatConfigValue(value);
-    cmd.displayValidationStatus = (config: ProjectConfig): void =>
-      displayValidationStatus(cmd, config);
-    cmd.displayConfigurationKeys = (keys: string[]): void => displayConfigurationKeys(cmd, keys);
-    cmd.displayConfigurationValues = (config: ProjectConfig): void =>
-      displayConfigurationValues(cmd, config);
-    cmd.editSingleConfig = async (manager: ConfigManagerLike, selectedKey: string): Promise<void> =>
-      editSingleConfig(cmd, manager, selectedKey);
-
-    return cmd;
-  },
-});

package/src/cli/commands/ContainerComposeLifecycle.ts

@@ -1,85 +0,0 @@
-import { runComposeWithFallback } from '@cli/commands/DockerComposeCommandUtils';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-
-type ComposeBuildOptions = {
-  noCache?: boolean;
-  pull?: boolean;
-};
-
-type ComposeUpOptions = {
-  detach?: boolean;
-  removeOrphans?: boolean;
-};
-
-type ComposeDownOptions = {
-  volumes?: boolean;
-  removeOrphans?: boolean;
-};
-
-export const ContainerComposeLifecycle = Object.freeze({
-  normalizeAction<const Allowed extends readonly string[]>(
-    raw: string | undefined,
-    allowed: Allowed,
-    usageMessage: string
-  ): Allowed[number] {
-    const value = (raw ?? '').trim().toLowerCase();
-    for (const item of allowed) {
-      if (value === item) return item;
-    }
-    throw ErrorFactory.createCliError(usageMessage);
-  },
-
-  async runBuild(
-    composePath: string,
-    options: ComposeBuildOptions,
-    logMessage: string
-  ): Promise<void> {
-    const args = ['compose', '-f', composePath, 'build'];
-
-    if (options.noCache === true) {
-      args.push('--no-cache');
-    }
-
-    if (options.pull === true) {
-      args.push('--pull');
-    }
-
-    Logger.info(logMessage);
-    await runComposeWithFallback(args);
-  },
-
-  async runUp(composePath: string, options: ComposeUpOptions, logMessage: string): Promise<void> {
-    const args = ['compose', '-f', composePath, 'up'];
-
-    if (options.detach === true) {
-      args.push('-d');
-    }
-
-    if (options.removeOrphans === true) {
-      args.push('--remove-orphans');
-    }
-
-    Logger.info(logMessage);
-    await runComposeWithFallback(args);
-  },
-
-  async runDown(
-    composePath: string,
-    options: ComposeDownOptions,
-    logMessage: string
-  ): Promise<void> {
-    const args = ['compose', '-f', composePath, 'down'];
-
-    if (options.volumes === true) {
-      args.push('-v');
-    }
-
-    if (options.removeOrphans === true) {
-      args.push('--remove-orphans');
-    }
-
-    Logger.info(logMessage);
-    await runComposeWithFallback(args);
-  },
-});