@zintrust/core 2.4.1 → 2.4.2

package/src/cli/commands/D1ProxyCommand.ts

@@ -1,152 +0,0 @@
-import type { IBaseCommand } from '@cli/BaseCommand';
-import { findQuotedValue, trimNonEmptyOption } from '@cli/commands/ProxyScaffoldUtils';
-import {
-  addWranglerProxyBaseOptions,
-  createWranglerProxyCommand,
-  type WranglerProxyCommandOptions,
-} from '@cli/commands/WranglerProxyCommandUtils';
-import { Env } from '@config/env';
-import { Logger } from '@config/logger';
-import type { Command } from 'commander';
-
-type D1ProxyCommandOptions = WranglerProxyCommandOptions & {
-  binding?: string;
-  databaseName?: string;
-  databaseId?: string;
-  migrationsDir?: string;
-};
-
-type D1ProxyConfigValues = {
-  binding: string;
-  databaseName: string;
-  databaseId: string;
-  migrationsDir: string;
-};
-
-const DEFAULT_CONFIG = 'wrangler.jsonc';
-const DEFAULT_COMPATIBILITY_DATE = '2026-03-12';
-const DEFAULT_BINDING = 'ZIN_DB';
-const DEFAULT_DATABASE_NAME = 'd1-proxy-db';
-const DEFAULT_DATABASE_ID = '<your-d1-database-id>';
-const DEFAULT_MIGRATIONS_DIR = 'database/migrations/d1';
-const DEFAULT_ENTRY_FILE = 'src/proxy/d1/ZintrustD1Proxy.ts';
-const DEFAULT_ROUTE_PATTERN = 'd1-proxy.example.com';
-const CORE_PROXY_MODULE = ['@zintrust', 'core', 'proxy'].join('/');
-
-const resolveConfigValues = (
-  content: string | undefined,
-  options: D1ProxyCommandOptions
-): D1ProxyConfigValues => {
-  const fileContent = content ?? '';
-
-  return {
-    binding:
-      trimNonEmptyOption(options.binding) ??
-      trimNonEmptyOption(Env.get('D1_BINDING', '')) ??
-      findQuotedValue(fileContent, 'D1_BINDING') ??
-      findQuotedValue(fileContent, 'binding') ??
-      DEFAULT_BINDING,
-    databaseName:
-      trimNonEmptyOption(options.databaseName) ??
-      trimNonEmptyOption(Env.get('D1_DATABASE_NAME', '')) ??
-      findQuotedValue(fileContent, 'database_name') ??
-      DEFAULT_DATABASE_NAME,
-    databaseId:
-      trimNonEmptyOption(options.databaseId) ??
-      trimNonEmptyOption(Env.get('D1_DATABASE_ID', '')) ??
-      findQuotedValue(fileContent, 'database_id') ??
-      DEFAULT_DATABASE_ID,
-    migrationsDir:
-      trimNonEmptyOption(options.migrationsDir) ??
-      findQuotedValue(fileContent, 'migrations_dir') ??
-      DEFAULT_MIGRATIONS_DIR,
-  };
-};
-
-const renderD1ProxyEnvBlock = (values: D1ProxyConfigValues): string => {
-  return [
-    '    "d1-proxy": {',
-    '      "name": "zintrust-d1-proxy",',
-    '      "main": "./src/proxy/d1/ZintrustD1Proxy.ts",',
-    '      "compatibility_flags": ["nodejs_compat"],',
-    `      "compatibility_date": "${DEFAULT_COMPATIBILITY_DATE}",`,
-    '      "vars": {',
-    `        "D1_BINDING": "${values.binding}",`,
-    '        "ZT_PROXY_SIGNING_WINDOW_MS": "60000",',
-    '        "ZT_MAX_BODY_BYTES": "131072",',
-    '        "ZT_MAX_SQL_BYTES": "32768",',
-    '        "ZT_MAX_PARAMS": "256",',
-    '        "NODE_ENV": "development",',
-    String.raw`        "ZT_D1_STATEMENTS_JSON": "{\"health\":\"select 1 as ok\"}"`,
-    '      },',
-    '      "d1_databases": [',
-    '        {',
-    `          "binding": "${values.binding}",`,
-    `          "database_name": "${values.databaseName}",`,
-    `          "database_id": "${values.databaseId}",`,
-    `          "migrations_dir": "${values.migrationsDir}"`,
-    '        }',
-    '      ],',
-    '      // Add routes here when ready:',
-    `      // "routes": [{ "pattern": "${DEFAULT_ROUTE_PATTERN}", "custom_domain": true }]`,
-    '    }',
-  ].join('\n');
-};
-
-const warnOnPlaceholderDatabaseId = (values: D1ProxyConfigValues): void => {
-  if (values.databaseId !== DEFAULT_DATABASE_ID) return;
-
-  Logger.warn(
-    'Could not resolve a D1 database id automatically. Update wrangler.jsonc or pass --database-id before relying on the generated d1-proxy environment.'
-  );
-};
-
-const warnOnMissingSigningSecret = (): void => {
-  const directSecret = trimNonEmptyOption(Env.get('D1_REMOTE_SECRET', ''));
-  const fallbackSecret = trimNonEmptyOption(Env.get('APP_KEY', ''));
-  if (directSecret !== undefined || fallbackSecret !== undefined) return;
-
-  Logger.warn(
-    'D1 proxy signing will fail: the resolved project env does not expose D1_REMOTE_SECRET or APP_KEY to the Worker runtime. Signed requests will be rejected with 401 CONFIG_ERROR until one of those keys is set.'
-  );
-};
-
-const runD1ProxyDiagnostics = (values: D1ProxyConfigValues): void => {
-  warnOnPlaceholderDatabaseId(values);
-  warnOnMissingSigningSecret();
-};
-
-const addOptions = (command: Command): void => {
-  addWranglerProxyBaseOptions(command, DEFAULT_CONFIG);
-  command.option('--binding <name>', 'D1 binding name', DEFAULT_BINDING);
-  command.option('--database-name <name>', 'Cloudflare D1 database name');
-  command.option('--database-id <id>', 'Cloudflare D1 database id');
-  command.option(
-    '--migrations-dir <path>',
-    'Cloudflare D1 migrations directory',
-    DEFAULT_MIGRATIONS_DIR
-  );
-};
-
-export const D1ProxyCommand = Object.freeze({
-  create(): IBaseCommand {
-    return createWranglerProxyCommand<D1ProxyConfigValues, D1ProxyCommandOptions>({
-      name: 'proxy:d1',
-      aliases: ['d1:proxy'],
-      description:
-        'Start the local Cloudflare D1 proxy Worker via Wrangler and scaffold env.d1-proxy in wrangler.jsonc when missing',
-      envName: 'd1-proxy',
-      defaultConfig: DEFAULT_CONFIG,
-      compatibilityDate: DEFAULT_COMPATIBILITY_DATE,
-      entryFile: DEFAULT_ENTRY_FILE,
-      exportName: 'ZintrustD1Proxy',
-      moduleSpecifier: CORE_PROXY_MODULE,
-      addOptions,
-      resolveValues: resolveConfigValues,
-      renderEnvBlock: renderD1ProxyEnvBlock,
-      afterConfigResolved: runD1ProxyDiagnostics,
-    });
-  },
-});
-
-export default D1ProxyCommand;

package/src/cli/commands/DbSeedCommand.ts

@@ -1,181 +0,0 @@
-/**
- * Db Seed Command
- * Run database seeders from database/seeders
- */
-
-import { SeederDiscovery } from '@/seeders/SeederDiscovery';
-import { SeederLoader } from '@/seeders/SeederLoader';
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { confirmProductionRun, mapConnectionToOrmConfig } from '@cli/utils/DatabaseCliUtils';
-import { databaseConfig } from '@config/database';
-import { Env } from '@config/env';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { resetDatabase, useDatabase } from '@orm/Database';
-import type { Command } from 'commander';
-
-type ServiceArgs = { service: string | undefined; includeGlobal: boolean };
-
-const addSeedOptions = (command: Command): void => {
-  command
-    .option(
-      '--dir <path>',
-      'Seeders directory (relative to project root)',
-      databaseConfig.seeders.directory
-    )
-    .option('--service <domain/name>', 'Run global + service-local seeders')
-    .option('--only-service <domain/name>', 'Run only service-local seeders')
-    .option('--no-interactive', 'Skip interactive prompts');
-};
-
-const getInteractive = (options: CommandOptions): boolean =>
-  options['interactive'] !== false && Env.CI !== 'true';
-
-const ensureNonD1Driver = (driver: string): void => {
-  if (driver === 'd1' || driver === 'd1-remote') {
-    throw ErrorFactory.createCliError(
-      'This project is configured for D1. Seeding via `zin db:seed` is not supported yet.'
-    );
-  }
-};
-
-const getServiceArgs = (options: CommandOptions): ServiceArgs => {
-  let serviceArg: string | undefined;
-
-  if (typeof options['onlyService'] === 'string') {
-    serviceArg = String(options['onlyService']);
-  } else if (typeof options['service'] === 'string') {
-    serviceArg = String(options['service']);
-  }
-
-  const includeGlobal = typeof options['onlyService'] !== 'string';
-  return { service: serviceArg, includeGlobal };
-};
-
-const parseServiceRef = (raw: string): { domain: string; name: string } => {
-  const trimmed = raw.trim();
-  const parts = trimmed.split('/').filter((p) => p.trim().length > 0);
-  if (parts.length !== 2) {
-    throw ErrorFactory.createCliError(
-      `Invalid service reference: '${raw}'. Expected format: <domain>/<name>`
-    );
-  }
-  return { domain: parts[0], name: parts[1] };
-};
-
-const normalizeSeederNameArg = (raw: string): string => {
-  const trimmed = raw.trim();
-  if (trimmed.endsWith('.ts')) return trimmed.slice(0, -3);
-  if (trimmed.endsWith('.js')) return trimmed.slice(0, -3);
-  return trimmed;
-};
-
-const selectSeederFiles = (files: string[], seederName: string | undefined): string[] => {
-  if (seederName !== undefined) {
-    return files.filter((filePath) => {
-      const base = filePath.split('/').pop() ?? '';
-      const withoutExt = base.replace(/\.(ts|js)$/u, '');
-      return withoutExt === seederName;
-    });
-  }
-
-  const databaseSeeder = files.find((filePath) => {
-    const base = filePath.split('/').pop() ?? '';
-    const withoutExt = base.replace(/\.(ts|js)$/u, '');
-    return withoutExt === 'DatabaseSeeder';
-  });
-
-  if (databaseSeeder !== undefined) return [databaseSeeder];
-  return files;
-};
-
-const executeSeed = async (options: CommandOptions, cmd: IBaseCommand): Promise<void> => {
-  const interactive = getInteractive(options);
-  const okToProceed = await confirmProductionRun({
-    cmd,
-    interactive,
-    message: 'NODE_ENV=production. Continue running seeders?',
-  });
-  if (!okToProceed) return;
-
-  const conn = databaseConfig.getConnection();
-  ensureNonD1Driver(conn.driver);
-
-  const ormConfig = mapConnectionToOrmConfig(conn);
-  const db = useDatabase(ormConfig, 'default');
-
-  const dirOpt =
-    typeof options['dir'] === 'string' ? options['dir'] : databaseConfig.seeders.directory;
-
-  const { service, includeGlobal } = getServiceArgs(options);
-  const projectRoot = process.cwd();
-
-  const globalDir = SeederDiscovery.resolveDir(projectRoot, dirOpt);
-  const globalFiles = includeGlobal ? SeederDiscovery.listSeederFiles(globalDir) : [];
-
-  let serviceFiles: string[] = [];
-  if (service !== undefined) {
-    const { domain, name } = parseServiceRef(service);
-    const serviceRoot = `${projectRoot}/services/${domain}/${name}`;
-    const serviceDir = SeederDiscovery.resolveDir(serviceRoot, dirOpt);
-    serviceFiles = SeederDiscovery.listSeederFiles(serviceDir);
-  }
-
-  const seederArgRaw = Array.isArray(options.args) ? options.args[0] : undefined;
-  const seederName =
-    typeof seederArgRaw === 'string' && seederArgRaw.trim() !== ''
-      ? normalizeSeederNameArg(seederArgRaw)
-      : undefined;
-
-  const selectedGlobal = selectSeederFiles(globalFiles, seederName);
-  const selectedService = selectSeederFiles(serviceFiles, seederName);
-  const selected = [...selectedGlobal, ...selectedService];
-
-  if (seederName !== undefined) {
-    if (selected.length === 0) {
-      throw ErrorFactory.createCliError(
-        `Seeder not found: ${seederName} (dir=${dirOpt}, global=${globalFiles.length}, service=${serviceFiles.length})`
-      );
-    }
-
-    if (selected.length > 1) {
-      throw ErrorFactory.createCliError(
-        `Seeder name is ambiguous: ${seederName} (matches=${selected.length}). Use --only-service or adjust name.`
-      );
-    }
-  }
-
-  if (selected.length === 0) {
-    cmd.info('No seeders found.');
-    return;
-  }
-
-  cmd.info(`Running ${selected.length} seeder(s)...`);
-  await db.connect();
-
-  try {
-    await selected.reduce(async (previous, filePath) => {
-      await previous;
-
-      const loaded = await SeederLoader.load(filePath);
-      cmd.info(`→ ${loaded.name}`);
-      await loaded.run(db);
-      cmd.success(`✓ Seeded: ${loaded.name}`);
-    }, Promise.resolve());
-  } finally {
-    await resetDatabase();
-  }
-};
-
-export const DbSeedCommand = Object.freeze({
-  create(): IBaseCommand {
-    const cmd: IBaseCommand = BaseCommand.create({
-      name: 'db:seed',
-      description: 'Run database seeders',
-      addOptions: addSeedOptions,
-      execute: async (options: CommandOptions): Promise<void> => executeSeed(options, cmd),
-    });
-
-    return cmd;
-  },
-});

package/src/cli/commands/DebugCommand.ts

@@ -1,71 +0,0 @@
-/**
- * Debug Command
- * Launch debug mode with profiling and monitoring
- */
-
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import { Dashboard } from '@cli/debug/Dashboard';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import type { Command } from 'commander';
-
-type DashboardHandle = {
-  start(): void;
-  stop(): void;
-};
-
-type IDebugCommand = IBaseCommand & {
-  dashboard: DashboardHandle | undefined;
-};
-
-const addOptions = (command: Command): void => {
-  command
-    .option('--port <number>', 'Debug server port', '3000')
-    .option('--enable-profiling', 'Enable memory profiling')
-    .option('--enable-tracing', 'Enable request tracing');
-};
-
-const executeDebug = (cmd: IDebugCommand, options: CommandOptions): void => {
-  cmd.info(`Debug command executed with options: ${JSON.stringify(options)}`);
-  try {
-    cmd.dashboard = Dashboard.create() as unknown as DashboardHandle;
-    cmd.dashboard.start();
-
-    process.on('SIGINT', () => {
-      cmd.dashboard?.stop();
-      process.exit(0);
-    });
-  } catch (error) {
-    cmd.dashboard?.stop();
-    throw ErrorFactory.createTryCatchError(`Debug failed: ${(error as Error).message}`, error);
-  }
-};
-
-/**
- * Debug Command
- * Launch debug mode with profiling and monitoring
- */
-
-const create = (): IBaseCommand => {
-  const ext = (options: CommandOptions): void => executeDebug(cmd, options);
-  const cmd = BaseCommand.create<IDebugCommand>({
-    name: 'debug',
-    description: 'Launch debug mode with real-time monitoring dashboard',
-    addOptions,
-    execute: ext,
-  });
-
-  cmd.dashboard = undefined;
-
-  return cmd;
-};
-
-/**
- * Debug Command Factory
- */
-export const DebugCommand = Object.freeze({
-  /**
-   * Create a new debug command instance
-   */
-  create,
-});

package/src/cli/commands/DeployCommand.ts

@@ -1,208 +0,0 @@
-/**
- * Deploy Command - Deploy ZinTrust to Cloudflare Workers
- * Handles deployment of workers and proxies
- */
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import {
-  reportCloudflareSecretSync,
-  syncCloudflareSecrets,
-} from '@cli/cloudflare/CloudflareSecretSync';
-import { SpawnUtil } from '@cli/utils/spawn';
-import { Logger } from '@config/logger';
-import { ErrorFactory } from '@exceptions/ZintrustError';
-import { existsSync } from '@node-singletons/fs';
-import { join } from '@node-singletons/path';
-import type { Command } from 'commander';
-
-type DeployCommandOptions = CommandOptions & {
-  env?: string;
-  config?: string;
-  envPath?: string;
-  target?: string;
-  syncSecrets?: boolean;
-  all?: boolean;
-};
-
-const runCompose = async (args: string[]): Promise<void> => {
-  try {
-    const exitCode = await SpawnUtil.spawnAndWait({ command: 'docker', args });
-    if (exitCode !== 0) process.exit(exitCode);
-    return;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (!message.includes("'docker' not found")) throw error;
-  }
-
-  Logger.warn("'docker' not found. Falling back to 'docker-compose'.");
-  const exitCode = await SpawnUtil.spawnAndWait({
-    command: 'docker-compose',
-    args: args.slice(1),
-  });
-  if (exitCode !== 0) process.exit(exitCode);
-};
-
-const deployContainerStack = async (label: string): Promise<void> => {
-  const composeFile = 'docker-compose.workers.yml';
-  const composePath = join(process.cwd(), composeFile);
-  if (!existsSync(composePath)) {
-    throw ErrorFactory.createCliError(`${composeFile} not found. Run \`zin init:cw\` first.`);
-  }
-
-  Logger.info(`Deploying ${label}...`);
-  await runCompose(['compose', '-f', composePath, 'up', '-d', '--build']);
-  Logger.info(`✅ ${label} deployed.`);
-};
-
-const deployProxyStack = async (label: string): Promise<void> => {
-  const composeFile = 'docker-compose.proxy.yml';
-  const composePath = join(process.cwd(), composeFile);
-  if (!existsSync(composePath)) {
-    throw ErrorFactory.createCliError(`${composeFile} not found.`);
-  }
-
-  Logger.info(`Deploying ${label}...`);
-  await runCompose(['compose', '-f', composePath, 'up', '-d', '--build']);
-  Logger.info(`✅ ${label} deployed.`);
-};
-
-const syncWranglerSecrets = async (
-  cmd: IBaseCommand,
-  cwd: string,
-  wranglerEnv: string,
-  options: DeployCommandOptions
-): Promise<void> => {
-  if (options.syncSecrets === false) return;
-
-  const result = await syncCloudflareSecrets({
-    log: cmd,
-    cwd,
-    wranglerEnvs: [wranglerEnv],
-    envPath:
-      typeof options.envPath === 'string' && options.envPath.trim() !== ''
-        ? options.envPath
-        : '.env',
-    configPath: typeof options.config === 'string' ? options.config.trim() : undefined,
-    target: typeof options.target === 'string' ? options.target : undefined,
-    requireSelection: false,
-    all: options.all === true,
-  });
-
-  if (result.selectedKeys.length === 0) return;
-  reportCloudflareSecretSync(cmd, result);
-};
-
-const runDeploy = async (
-  cmd: IBaseCommand,
-  target: string,
-  options: DeployCommandOptions
-): Promise<void> => {
-  const normalizedTarget = target.trim().toLowerCase();
-
-  if (normalizedTarget === 'cw' || normalizedTarget === 'cwr') {
-    const label =
-      normalizedTarget === 'cwr'
-        ? 'container workers stack (cwr compatibility alias)'
-        : 'container workers stack';
-    await deployContainerStack(label);
-    return;
-  }
-
-  if (normalizedTarget === 'cp' || normalizedTarget === 'proxy') {
-    const label =
-      normalizedTarget === 'proxy' ? 'proxy stack (proxy compatibility alias)' : 'proxy stack';
-    await deployProxyStack(label);
-    return;
-  }
-
-  const environment = options.env ?? target ?? 'worker';
-
-  const config = typeof options.config === 'string' ? options.config.trim() : '';
-  if (config.length > 0) {
-    const full = join(process.cwd(), config);
-    if (existsSync(full)) {
-      // ok
-    } else {
-      throw ErrorFactory.createCliError(`Wrangler config not found: ${config}`);
-    }
-  }
-
-  Logger.info(`Deploying to Cloudflare environment: ${environment}`);
-  await syncWranglerSecrets(cmd, process.cwd(), environment, options);
-
-  const exitCode = await SpawnUtil.spawnAndWait({
-    command: 'wrangler',
-    args: ['deploy', ...(config.length > 0 ? ['--config', config] : []), '--env', environment],
-  });
-
-  if (exitCode !== 0) {
-    process.exit(exitCode);
-  }
-};
-
-const createDeployCommand = (): IBaseCommand => {
-  const cmd = BaseCommand.create({
-    name: 'deploy',
-    description: 'Deploy ZinTrust to Cloudflare Workers',
-    addOptions: (command: Command) => {
-      command
-        .argument(
-          '[target]',
-          'Deployment target (worker, d1-proxy, kv-proxy, production, cw, cp)',
-          'worker'
-        )
-        .option('-e, --env <env>', 'Wrangler environment (overrides target)');
-      command.option(
-        '-c, --config <path>',
-        'Wrangler config file (e.g. wrangler.containers-proxy.jsonc)'
-      );
-      command.option(
-        '--env-path <path>',
-        'Path to env file used when syncing Cloudflare secrets',
-        '.env'
-      );
-      command.option(
-        '--target <id>',
-        'Cloudflare worker target key from .zintrust.json cloudflare.targets'
-      );
-      command.option(
-        '--all',
-        'Sync both custom env file and process.env (only applies when custom env file is provided)'
-      );
-      command.option('--no-sync-secrets', 'Skip Cloudflare secret sync before wrangler deploy');
-    },
-    execute: async (options: DeployCommandOptions): Promise<void> => {
-      // Note: BaseCommand.create sets up action handler that calls execute(options).
-      // However, since we define arguments '[target]', commander passes them to the action callback
-      // BEFORE the options object.
-      //
-      // The BaseCommand.create generic action handler:
-      // command.action(async (...args: unknown[]) => {
-      //   const options = args.at(-2) as CommandOptions;
-      //   const commandArgs = args.slice(0, -2) as string[];
-      //   options.args = commandArgs;
-      //   await config.execute(options);
-      // });
-      //
-      // So 'target' will be available in options.args[0]
-
-      const target = options.args?.[0] ?? 'worker';
-      await runDeploy(cmd, target, options);
-    },
-  });
-
-  return cmd;
-};
-
-/**
- * Deploy Command Factory
- * Sealed namespace for immutability
- */
-export const DeployCommand = Object.freeze({
-  /**
-   * Create a deploy command instance
-   */
-  create(): IBaseCommand {
-    return createDeployCommand();
-  },
-});

package/src/cli/commands/DeployContainerProxiesCommand.ts

@@ -1,41 +0,0 @@
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import {
-  resolveComposePath,
-  runComposeWithFallback,
-} from '@cli/commands/DockerComposeCommandUtils';
-import { Logger } from '@config/logger';
-import type { Command } from 'commander';
-
-type DeployCpOptions = CommandOptions & {
-  noBuild?: boolean;
-  removeOrphans?: boolean;
-};
-
-export const DeployContainerProxiesCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'deploy:cp',
-      aliases: ['deploy:container-proxies', 'deploy:proxy-stack'],
-      description: 'Deploy proxy stack (docker-compose.proxy.yml)',
-      addOptions: (command: Command): void => {
-        command.option('--no-build', 'Skip image build before up');
-        command.option('--remove-orphans', 'Remove containers for services not defined in compose');
-      },
-      execute: async (options: DeployCpOptions): Promise<void> => {
-        const composePath = resolveComposePath(
-          'docker-compose.proxy.yml',
-          'docker-compose.proxy.yml not found.'
-        );
-
-        const args = ['compose', '-f', composePath, 'up', '-d'];
-        if (options.noBuild !== true) args.push('--build');
-        if (options.removeOrphans === true) args.push('--remove-orphans');
-
-        Logger.info('Deploying proxy stack...');
-        await runComposeWithFallback(args);
-        Logger.info('✅ Proxy stack deployed.');
-      },
-    });
-  },
-});

package/src/cli/commands/DeployContainerWorkersCommand.ts

@@ -1,41 +0,0 @@
-import type { CommandOptions, IBaseCommand } from '@cli/BaseCommand';
-import { BaseCommand } from '@cli/BaseCommand';
-import {
-  resolveComposePath,
-  runComposeWithFallback,
-} from '@cli/commands/DockerComposeCommandUtils';
-import { Logger } from '@config/logger';
-import type { Command } from 'commander';
-
-type DeployCwOptions = CommandOptions & {
-  noBuild?: boolean;
-  removeOrphans?: boolean;
-};
-
-export const DeployContainerWorkersCommand = Object.freeze({
-  create(): IBaseCommand {
-    return BaseCommand.create({
-      name: 'deploy:cw',
-      aliases: ['deploy:container-workers', 'deploy:cwr', 'deploy:container-workers-routes'],
-      description: 'Deploy Container Workers stack (docker-compose.workers.yml)',
-      addOptions: (command: Command): void => {
-        command.option('--no-build', 'Skip image build before up');
-        command.option('--remove-orphans', 'Remove containers for services not defined in compose');
-      },
-      execute: async (options: DeployCwOptions): Promise<void> => {
-        const composePath = resolveComposePath(
-          'docker-compose.workers.yml',
-          'docker-compose.workers.yml not found. Run `zin init:cw` first.'
-        );
-
-        const args = ['compose', '-f', composePath, 'up', '-d'];
-        if (options.noBuild !== true) args.push('--build');
-        if (options.removeOrphans === true) args.push('--remove-orphans');
-
-        Logger.info('Deploying container workers stack...');
-        await runComposeWithFallback(args);
-        Logger.info('✅ Container workers deployed.');
-      },
-    });
-  },
-});