@zintrust/core 0.4.17 → 0.4.19

package/src/cli/commands/PluginCommand.ts

@@ -1,112 +0,0 @@
-/**
- * Plugin Command
- * Manage framework plugins (install, uninstall, list)
- */
-
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { Logger } from '@config/logger';
-import { PluginManager } from '@runtime/PluginManager';
-import type { Command } from 'commander';
-
-export const PluginCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'plugin',
-      description: 'Manage framework plugins',
-      addOptions: (command: Command) => {
-        command.alias('p');
-
-        // Options for short syntax (zin p -i a:sqlite)
-        command.option('-i, --install <pluginId>', 'Install a plugin');
-        command.option('-u, --uninstall <pluginId>', 'Uninstall a plugin');
-        command.option('-l, --list', 'List available plugins');
-
-        command
-          .command('list')
-          .alias('ls')
-          .description('List available plugins')
-          .action(async () => {
-            await listPlugins();
-          });
-
-        command
-          .command('install <pluginId>')
-          .alias('i')
-          .description('Install a plugin')
-          .option('--package-manager <pm>', 'Specify package manager to use (npm|yarn|pnpm)')
-          .action(async (pluginId: string, options: Record<string, unknown>) => {
-            await installPlugin(pluginId, options);
-          });
-
-        command
-          .command('uninstall <pluginId>')
-          .alias('un')
-          .description('Uninstall a plugin')
-          .action(async (pluginId: string) => {
-            await uninstallPlugin(pluginId);
-          });
-      },
-      execute: async (options: CommandOptions) => {
-        const installId = options['install'];
-        const uninstallId = options['uninstall'];
-        const shouldList = options['list'];
-
-        if (typeof installId === 'string' && installId.length > 0) {
-          await installPlugin(installId);
-        } else if (typeof uninstallId === 'string' && uninstallId.length > 0) {
-          await uninstallPlugin(uninstallId);
-        } else if (shouldList === true) {
-          await listPlugins();
-        } else {
-          Logger.info('Use "plugin list", "plugin install <id>", or "plugin uninstall <id>"');
-          Logger.info('Shortcuts: "zin p -l", "zin p -i <id>", "zin p -u <id>"');
-        }
-      },
-    });
-  },
-});
-
-async function listPlugins(): Promise<void> {
-  const plugins = PluginManager.list();
-  Logger.info('Available Plugins:');
-
-  const pluginEntries = Object.entries(plugins);
-
-  const installedStatuses = await Promise.all(
-    pluginEntries.map(async ([id]) => PluginManager.isInstalled(id))
-  );
-
-  for (let i = 0; i < pluginEntries.length; i++) {
-    const [id, plugin] = pluginEntries[i];
-    const isInstalled = installedStatuses[i] ?? false;
-    const status = isInstalled ? '✓ Installed' : '- Available';
-    const aliases =
-      plugin.aliases !== undefined && plugin.aliases.length > 0
-        ? `(aliases: ${plugin.aliases.join(', ')})`
-        : '';
-    Logger.info(`  ${id.padEnd(20)} ${status.padEnd(15)} ${plugin.description} ${aliases}`);
-  }
-}
-
-async function installPlugin(pluginId: string, options?: Record<string, unknown>): Promise<void> {
-  try {
-    const pm =
-      typeof options?.['packageManager'] === 'string'
-        ? String(options?.['packageManager'])
-        : undefined;
-    await PluginManager.install(pluginId, { packageManager: pm });
-  } catch (error) {
-    Logger.error(`Failed to install plugin ${pluginId}`, error);
-    process.exit(1);
-  }
-}
-
-async function uninstallPlugin(pluginId: string): Promise<void> {
-  try {
-    await PluginManager.uninstall(pluginId);
-  } catch (error) {
-    Logger.error(`Failed to uninstall plugin ${pluginId}`, error);
-    process.exit(1);
-  }
-}

package/src/cli/commands/PostgresProxyCommand.ts

@@ -1,43 +0,0 @@
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import {
-  addSqlProxyOptions,
-  runSqlProxyCommand,
-  type SqlProxyCommandOptions,
-} from '@cli/commands/SqlProxyCommandUtils';
-import { Env } from '@config/env';
-import { PostgresProxyServer } from '@proxy/postgres/PostgresProxyServer';
-import type { Command } from 'commander';
-
-type PostgresProxyOptions = SqlProxyCommandOptions & CommandOptions;
-
-const addOptions = (command: Command): void => {
-  addSqlProxyOptions(command, {
-    hostDefault: Env.POSTGRES_PROXY_HOST,
-    portDefault: Env.POSTGRES_PROXY_PORT,
-    maxBodyBytesDefault: Env.POSTGRES_PROXY_MAX_BODY_BYTES,
-    dbVendorLabel: 'PostgreSQL',
-    requireSigningDefault: Env.POSTGRES_PROXY_REQUIRE_SIGNING,
-    keyIdDefault: Env.POSTGRES_PROXY_KEY_ID,
-    secretDefault: Env.POSTGRES_PROXY_SECRET,
-    signingWindowMsDefault: Env.POSTGRES_PROXY_SIGNING_WINDOW_MS,
-  });
-};
-
-export const PostgresProxyCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'proxy:postgres',
-      aliases: ['postgres:proxy', 'postgres-proxy', 'proxy:pg', 'pg:proxy', 'pg-proxy'],
-      description: 'Start the PostgreSQL HTTP proxy for Cloudflare Workers',
-      addOptions,
-      execute: async (options: PostgresProxyOptions) => {
-        await runSqlProxyCommand(options, async (input) => {
-          await PostgresProxyServer.start(input);
-        });
-      },
-    });
-  },
-});
-
-export default PostgresProxyCommand;

package/src/cli/commands/PrepareCommand.ts

@@ -1,65 +0,0 @@
-/**
- * Prepare Command
- * Makes the local dist/ folder installable via `file:/.../dist`.
- * Usage: zintrust prepare
- */
-
-import type { IBaseCommand } from '@cli/BaseCommand';
-import { DistPackager } from '@cli/utils/DistPackager';
-import { SpawnUtil } from '@cli/utils/spawn';
-import { resolveNpmPath } from '@common/index';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import * as path from '@node-singletons/path';
-import chalk from 'chalk';
-import { Command } from 'commander';
-
-type PrepareOptions = {
-  dist?: string;
-  link?: boolean;
-};
-
-export const PrepareCommand = {
-  name: 'prepare',
-  description: 'Prepare local dist/ for file: installs (simulate/fresh install workflow)',
-
-  getCommand(): Command {
-    return new Command('prepare')
-      .description('Prepare local dist/ so it can be installed via file:/.../dist')
-      .option('--dist <path>', 'Dist folder path (default: ./dist)')
-      .option('--link', 'Also run `npm link` to expose zintrust/zin/z/zt on PATH (dev-only)')
-      .action(async (options: PrepareOptions) => {
-        try {
-          const distRel =
-            typeof options.dist === 'string' && options.dist.trim() !== '' ? options.dist : 'dist';
-          const distPath = path.resolve(process.cwd(), distRel);
-
-          DistPackager.prepare(distPath, process.cwd());
-
-          Logger.info(chalk.green('✅ Dist prepared.'));
-          Logger.info('Docs roots:');
-          Logger.info(`- Production/new apps: ${chalk.cyan('dist/public')}`);
-          Logger.info(`- Framework dev:      ${chalk.cyan('docs-website/public')}`);
-
-          if (options.link === true) {
-            Logger.info(chalk.bold('\nLinking CLI globally (npm link)...'));
-            const npm = resolveNpmPath();
-            const exitCode = await SpawnUtil.spawnAndWait({
-              command: npm,
-              args: ['link'],
-              cwd: process.cwd(),
-            });
-
-            if (exitCode !== 0) {
-              throw ErrorFactory.createCliError(`npm link exited with code ${exitCode}`);
-            }
-
-            Logger.info(chalk.green('✅ Linked. You can now run `zintrust` from your shell.'));
-          }
-        } catch (error) {
-          Logger.error('Failed to prepare dist', error);
-          throw ErrorFactory.createCliError('Prepare failed', error);
-        }
-      });
-  },
-} as IBaseCommand;

package/src/cli/commands/ProxyCommand.ts

@@ -1,97 +0,0 @@
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { SpawnUtil } from '@cli/utils/spawn';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import * as path from '@node-singletons/path';
-import { ProxyRegistry } from '@proxy/ProxyRegistry';
-import '@proxy/d1/register';
-import '@proxy/kv/register';
-import '@proxy/mysql/register';
-import '@proxy/postgres/register';
-import '@proxy/redis/register';
-import '@proxy/smtp/register';
-import type { Command } from 'commander';
-
-const PROXY_TARGET_MAP: Readonly<Record<string, string>> = Object.freeze({
-  mysql: 'proxy:mysql',
-  my: 'proxy:mysql',
-  postgres: 'proxy:postgres',
-  postgresql: 'proxy:postgres',
-  pg: 'proxy:postgres',
-  redis: 'proxy:redis',
-  smtp: 'proxy:smtp',
-  mail: 'proxy:smtp',
-  mongodb: 'proxy:mongodb',
-  mongo: 'proxy:mongodb',
-  sqlserver: 'proxy:sqlserver',
-  mssql: 'proxy:sqlserver',
-});
-
-const addOptions = (command: Command): void => {
-  command.argument('[target]', 'Proxy target (e.g. postgres, mysql, redis, smtp)');
-};
-
-const parseForwardArgs = (): { target: string | null; extra: string[] } => {
-  const argv = process.argv.slice(2);
-  const proxyIndex = argv.indexOf('proxy');
-  if (proxyIndex < 0) {
-    return { target: null, extra: [] };
-  }
-
-  const target = argv[proxyIndex + 1] ?? null;
-  const extra = argv.slice(proxyIndex + 2);
-  return { target, extra };
-};
-
-const dispatchProxyTarget = async (targetRaw: string): Promise<void> => {
-  const target = targetRaw.trim().toLowerCase();
-  const mapped = PROXY_TARGET_MAP[target];
-
-  if (!mapped) {
-    throw ErrorFactory.createCliError(
-      `Unknown proxy target '${targetRaw}'. Use one of: ${Object.keys(PROXY_TARGET_MAP).join(', ')}`
-    );
-  }
-
-  const { extra } = parseForwardArgs();
-  const exitCode = await SpawnUtil.spawnAndWait({
-    command: 'tsx',
-    args: [path.join('bin', 'zin.ts'), mapped, ...extra],
-    env: {
-      ...process.env,
-    },
-    forwardSignals: false,
-  });
-
-  process.exit(exitCode);
-};
-
-export const ProxyCommand = Object.freeze({
-  create(): IBaseCommand {
-    const cmd: IBaseCommand = BaseCommand.create({
-      name: 'proxy',
-      description: 'List available proxy servers',
-      addOptions,
-      execute: async (options: CommandOptions): Promise<void> => {
-        const firstArg = Array.isArray(options.args) ? options.args[0] : undefined;
-        if (typeof firstArg === 'string' && firstArg.trim() !== '') {
-          await dispatchProxyTarget(firstArg);
-          return;
-        }
-
-        const list = ProxyRegistry.list();
-        if (list.length === 0) {
-          throw ErrorFactory.createCliError('No proxies registered');
-        }
-
-        for (const proxy of list) {
-          cmd.info(`${proxy.name}: ${proxy.description}`);
-        }
-      },
-    });
-
-    return cmd;
-  },
-});
-
-export default ProxyCommand;

package/src/cli/commands/ProxyCommandUtils.ts

@@ -1,53 +0,0 @@
-import { SpawnUtil } from '@cli/utils/spawn';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import * as path from '@node-singletons/path';
-
-type NumberExpectation = 'positive' | 'non-negative';
-
-export const parseIntOption = (
-  raw: string | undefined,
-  name: string,
-  expectation: NumberExpectation = 'positive'
-): number | undefined => {
-  if (raw === undefined) return undefined;
-
-  const parsed = Number.parseInt(raw, 10);
-  const isValid =
-    expectation === 'non-negative'
-      ? Number.isFinite(parsed) && parsed >= 0
-      : Number.isFinite(parsed) && parsed > 0;
-
-  if (!isValid) {
-    const expected = expectation === 'non-negative' ? 'a non-negative number' : 'a positive number';
-    throw ErrorFactory.createCliError(`Invalid --${name} '${raw}'. Expected ${expected}.`);
-  }
-
-  return parsed;
-};
-
-export const trimOption = (value: string | undefined): string | undefined => value?.trim();
-
-const isWatchChild = (): boolean => process.env['ZINTRUST_PROXY_WATCH_CHILD'] === '1';
-
-const buildWatchArgs = (): string[] => {
-  const rawArgs = process.argv.slice(2);
-  const filtered = rawArgs.filter((arg) => arg !== '--watch');
-  return ['watch', path.join('bin', 'zin.ts'), ...filtered];
-};
-
-export const maybeRunProxyWatchMode = async (watch: boolean | undefined): Promise<void> => {
-  if (watch !== true || isWatchChild()) return;
-
-  const args = buildWatchArgs();
-  const exitCode = await SpawnUtil.spawnAndWait({
-    command: 'tsx',
-    args,
-    env: {
-      ...process.env,
-      ZINTRUST_PROXY_WATCH_CHILD: '1',
-    },
-    forwardSignals: false,
-  });
-
-  process.exit(exitCode);
-};

package/src/cli/commands/PublishCommand.ts

@@ -1,79 +0,0 @@
-import { BaseCommand, type IBaseCommand } from '@cli/BaseCommand';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import fs from '@node-singletons/fs';
-import path from '@node-singletons/path';
-import type { Command } from 'commander';
-
-const publishQueueMonitorConfig = (cwd: string): void => {
-  const targetPath = path.join(cwd, 'config', 'queueMonitor.ts');
-
-  if (fs.existsSync(targetPath)) {
-    Logger.warn('Configuration file already exists: config/queueMonitor.ts');
-    return;
-  }
-
-  // 1. Try resolving through node_modules (production usage)
-  const nodeModulesPath = path.join(
-    cwd,
-    'node_modules',
-    '@zintrust',
-    'queue-monitor',
-    'src',
-    'config',
-    'queueMonitor.ts'
-  );
-
-  // 2. Fallback for monorepo development (local usage)
-  const monorepoPath = path.join(
-    cwd,
-    'packages',
-    'queue-monitor',
-    'src',
-    'config',
-    'queueMonitor.ts'
-  );
-
-  let sourcePath = '';
-
-  if (fs.existsSync(nodeModulesPath)) {
-    sourcePath = nodeModulesPath;
-  } else if (fs.existsSync(monorepoPath)) {
-    sourcePath = monorepoPath;
-  } else {
-    throw ErrorFactory.createCliError(
-      `Could not locate source configuration file. Ensure @zintrust/queue-monitor is installed.`
-    );
-  }
-
-  // Ensure config directory exists
-  const configDir = path.dirname(targetPath);
-  if (!fs.existsSync(configDir)) {
-    fs.mkdirSync(configDir, { recursive: true });
-  }
-
-  fs.copyFileSync(sourcePath, targetPath);
-  Logger.info('Published configuration: config/queueMonitor.ts');
-};
-
-export const PublishCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'publish:config',
-      description: 'Publish configuration files from packages to your project',
-      aliases: ['p:config'],
-      addOptions: (command: Command) => {
-        command.option('--queue-monitor', 'Publish Queue Monitor configuration');
-      },
-      execute: async (options) => {
-        const cwd = process.cwd();
-
-        if (options['queueMonitor'] !== undefined && options['queueMonitor'] !== null) {
-          await publishQueueMonitorConfig(cwd); //NOSONAR
-        } else {
-          Logger.warn('Please specify a configuration to publish (e.g., --queue-monitor)');
-        }
-      },
-    });
-  },
-});

package/src/cli/commands/PutCommand.ts

@@ -1,249 +0,0 @@
-import { BaseCommand, type CommandOptions, type IBaseCommand } from '@cli/BaseCommand';
-import { resolveNpmPath } from '@common/index';
-import { appConfig } from '@config/app';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { execFileSync } from '@node-singletons/child-process';
-import { existsSync, readFileSync } from '@node-singletons/fs';
-import * as path from '@node-singletons/path';
-import { EnvFile } from '@toolkit/Secrets/EnvFile';
-import type { Command } from 'commander';
-
-type PutCommandOptions = CommandOptions & {
-  wg?: string[] | string;
-  var?: string[] | string;
-  env_path?: string;
-  dryRun?: boolean;
-  config?: string;
-};
-
-type ZintrustConfig = Record<string, unknown>;
-
-type PutFailure = {
-  wranglerEnv: string;
-  key: string;
-  reason: string;
-};
-
-const toStringArray = (value: unknown): string[] => {
-  if (typeof value === 'string') return [value];
-  if (!Array.isArray(value)) return [];
-  return value.filter((v): v is string => typeof v === 'string');
-};
-
-const uniq = (items: string[]): string[] => {
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const item of items) {
-    const normalized = item.trim();
-    if (normalized === '' || seen.has(normalized)) continue;
-    seen.add(normalized);
-    out.push(normalized);
-  }
-  return out;
-};
-
-const readZintrustConfig = (cwd: string): ZintrustConfig => {
-  const filePath = path.join(cwd, '.zintrust.json');
-  if (!existsSync(filePath)) {
-    return {};
-  }
-
-  try {
-    const raw = readFileSync(filePath, 'utf8');
-    const parsed = JSON.parse(raw) as unknown;
-    return typeof parsed === 'object' && parsed !== null ? (parsed as ZintrustConfig) : {};
-  } catch (error) {
-    throw ErrorFactory.createCliError('Failed to parse .zintrust.json', error);
-  }
-};
-
-const getConfigArray = (config: ZintrustConfig, key: string): string[] => {
-  const raw = config[key];
-  if (!Array.isArray(raw)) return [];
-  return uniq(raw.filter((item): item is string => typeof item === 'string'));
-};
-
-const resolveConfigGroups = (options: PutCommandOptions): string[] => {
-  return uniq(toStringArray(options.var));
-};
-
-const resolveWranglerEnvs = (options: PutCommandOptions): string[] => {
-  const requested = uniq(toStringArray(options.wg));
-  if (requested.length === 0) return ['worker'];
-  return requested;
-};
-
-const parseEnvPath = (options: PutCommandOptions): string => {
-  const direct = options['env_path'];
-  if (typeof direct === 'string' && direct.trim() !== '') return direct;
-  return '.env';
-};
-
-const resolveValue = (key: string, envMap: Record<string, string>): string => {
-  const fromFile = envMap[key];
-  const fromProcess = process.env[key];
-  return fromFile ?? fromProcess ?? '';
-};
-
-const getPutTimeoutMs = (): number => {
-  const raw = process.env['ZT_PUT_TIMEOUT_MS'];
-  if (typeof raw !== 'string') return 120000;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0) return 120000;
-  return parsed;
-};
-
-const putSecret = (
-  wranglerEnv: string,
-  key: string,
-  value: string,
-  configPath: string | undefined
-): void => {
-  const npmPath = resolveNpmPath();
-
-  const args = ['exec', '--yes', '--', 'wrangler'];
-  if (typeof configPath === 'string' && configPath.trim().length > 0) {
-    args.push('--config', configPath.trim());
-  }
-  args.push('secret', 'put', key, '--env', wranglerEnv);
-
-  execFileSync(npmPath, args, {
-    stdio: ['pipe', 'inherit', 'inherit'],
-    input: value,
-    encoding: 'utf8',
-    timeout: getPutTimeoutMs(),
-    killSignal: 'SIGTERM',
-    env: appConfig.getSafeEnv(),
-  });
-};
-
-const addOptions = (command: Command): void => {
-  command
-    .argument('[provider]', 'Secret provider (cloudflare)', 'cloudflare')
-    .option('--wg <env...>', 'Wrangler environment target(s), e.g. d1-proxy kv-proxy')
-    .option('--var <configKey...>', 'Config array key(s) from .zintrust.json (e.g. d1_env kv_env)')
-    .option('--env_path <path>', 'Path to env file used as source values', '.env')
-    .option('-c, --config <path>', 'Wrangler config file to target (optional)')
-    .option('--dry-run', 'Show what would be uploaded without calling wrangler');
-};
-
-const ensureCloudflareProvider = (providerRaw: string): void => {
-  if (providerRaw.toLowerCase() === 'cloudflare') return;
-  throw ErrorFactory.createCliError('Only cloudflare provider is supported for `zin put`');
-};
-
-const resolveSelectedKeys = (
-  cmd: IBaseCommand,
-  config: ZintrustConfig,
-  options: PutCommandOptions
-): string[] => {
-  const configGroups = resolveConfigGroups(options);
-  if (configGroups.length === 0) {
-    throw ErrorFactory.createCliError('No config groups selected. Use --var <group>.');
-  }
-
-  const selectedKeys = uniq(
-    configGroups.flatMap((groupKey) => {
-      const keys = getConfigArray(config, groupKey);
-      if (keys.length === 0) {
-        cmd.warn(`Group \`${groupKey}\` is missing or empty in .zintrust.json`);
-      }
-      return keys;
-    })
-  );
-
-  if (selectedKeys.length === 0) {
-    throw ErrorFactory.createCliError('No secret keys resolved from selected groups.');
-  }
-
-  return selectedKeys;
-};
-
-const getFailureReason = (error: unknown): string =>
-  error instanceof Error ? error.message : String(error);
-
-const reportResult = (cmd: IBaseCommand, pushed: number, failures: PutFailure[]): void => {
-  cmd.success(`Cloudflare secrets report: pushed=${pushed}, failed=${failures.length}`);
-  for (const item of failures) {
-    cmd.warn(`${item.key} -> ${item.wranglerEnv}: ${item.reason}`);
-  }
-};
-
-const processPut = (
-  cmd: IBaseCommand,
-  wranglerEnvs: string[],
-  selectedKeys: string[],
-  envMap: Record<string, string>,
-  dryRun: boolean,
-  configPath: string | undefined
-): { pushed: number; failures: PutFailure[] } => {
-  let pushed = 0;
-  const failures: PutFailure[] = [];
-
-  for (const wranglerEnv of wranglerEnvs) {
-    for (const key of selectedKeys) {
-      const value = resolveValue(key, envMap);
-      if (value.trim() === '') {
-        failures.push({ wranglerEnv, key, reason: 'empty value' });
-        continue;
-      }
-
-      try {
-        if (!dryRun) {
-          cmd.info(`putting ${key} -> ${wranglerEnv}...`);
-          putSecret(wranglerEnv, key, value, configPath);
-        }
-        pushed += 1;
-        cmd.info(`${dryRun ? '[dry-run] ' : ''}put ${key} -> ${wranglerEnv}`);
-      } catch (error) {
-        failures.push({ wranglerEnv, key, reason: getFailureReason(error) });
-      }
-    }
-  }
-
-  return { pushed, failures };
-};
-
-const execute = async (cmd: IBaseCommand, options: PutCommandOptions): Promise<void> => {
-  ensureCloudflareProvider(String(options.args?.[0] ?? 'cloudflare'));
-
-  const cwd = process.cwd();
-  const config = readZintrustConfig(cwd);
-  const selectedKeys = resolveSelectedKeys(cmd, config, options);
-
-  const envFilePath = parseEnvPath(options);
-  const envMap = await EnvFile.read({ cwd, path: envFilePath });
-  const wranglerEnvs = resolveWranglerEnvs(options);
-  const dryRun = options.dryRun === true;
-
-  const configPath = typeof options.config === 'string' ? options.config.trim() : '';
-  if (configPath !== '' && !existsSync(path.join(cwd, configPath))) {
-    throw ErrorFactory.createCliError(`Wrangler config not found: ${configPath}`);
-  }
-
-  const result = processPut(
-    cmd,
-    wranglerEnvs,
-    selectedKeys,
-    envMap,
-    dryRun,
-    configPath === '' ? undefined : configPath
-  );
-  reportResult(cmd, result.pushed, result.failures);
-};
-
-export const PutCommand = Object.freeze({
-  create(): IBaseCommand {
-    const cmd: IBaseCommand = BaseCommand.create({
-      name: 'put',
-      description: 'Put secrets to Cloudflare with dynamic groups from .zintrust.json',
-      addOptions,
-      execute: async (options: CommandOptions): Promise<void> =>
-        execute(cmd, options as PutCommandOptions),
-    });
-
-    return cmd;
-  },
-});
-
-export default PutCommand;