@zintrust/core 0.4.17 → 0.4.19

package/src/cli/commands/DebugCommand.js

@@ -0,0 +1,52 @@
+/**
+ * Debug Command
+ * Launch debug mode with profiling and monitoring
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { Dashboard } from '../debug/Dashboard.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const addOptions = (command) => {
+    command
+        .option('--port <number>', 'Debug server port', '3000')
+        .option('--enable-profiling', 'Enable memory profiling')
+        .option('--enable-tracing', 'Enable request tracing');
+};
+const executeDebug = (cmd, options) => {
+    cmd.info(`Debug command executed with options: ${JSON.stringify(options)}`);
+    try {
+        cmd.dashboard = Dashboard.create();
+        cmd.dashboard.start();
+        process.on('SIGINT', () => {
+            cmd.dashboard?.stop();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        cmd.dashboard?.stop();
+        throw ErrorFactory.createTryCatchError(`Debug failed: ${error.message}`, error);
+    }
+};
+/**
+ * Debug Command
+ * Launch debug mode with profiling and monitoring
+ */
+const create = () => {
+    const ext = (options) => executeDebug(cmd, options);
+    const cmd = BaseCommand.create({
+        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.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deploy Command - Deploy ZinTrust to Cloudflare Workers
+ * Handles deployment of workers and proxies
+ */
+import type { IBaseCommand } from '../BaseCommand';
+/**
+ * Deploy Command Factory
+ * Sealed namespace for immutability
+ */
+export declare const DeployCommand: Readonly<{
+    /**
+     * Create a deploy command instance
+     */
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=DeployCommand.d.ts.map

package/src/cli/commands/DeployCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeployCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyIrE;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EAGtB,CAAC"}

package/src/cli/commands/DeployCommand.js

@@ -0,0 +1,121 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const runCompose = async (args) => {
+    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) => {
+    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) => {
+    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 runDeploy = async (target, options) => {
+    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}`);
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: 'wrangler',
+        args: ['deploy', ...(config.length > 0 ? ['--config', config] : []), '--env', environment],
+    });
+    if (exitCode !== 0) {
+        process.exit(exitCode);
+    }
+};
+const createDeployCommand = () => {
+    return BaseCommand.create({
+        name: 'deploy',
+        description: 'Deploy ZinTrust to Cloudflare Workers',
+        addOptions: (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)');
+        },
+        execute: async (options) => {
+            // 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(target, options);
+        },
+    });
+};
+/**
+ * Deploy Command Factory
+ * Sealed namespace for immutability
+ */
+export const DeployCommand = Object.freeze({
+    /**
+     * Create a deploy command instance
+     */
+    create() {
+        return createDeployCommand();
+    },
+});

package/src/cli/commands/DeployContainerProxiesCommand.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const DeployContainerProxiesCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=DeployContainerProxiesCommand.d.ts.map

package/src/cli/commands/DeployContainerProxiesCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeployContainerProxiesCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployContainerProxiesCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAcrE,eAAO,MAAM,6BAA6B;cAC9B,YAAY;EAyBtB,CAAC"}

package/src/cli/commands/DeployContainerProxiesCommand.js

@@ -0,0 +1,27 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveComposePath, runComposeWithFallback, } from '../commands/DockerComposeCommandUtils.js';
+import { Logger } from '../../config/logger.js';
+export const DeployContainerProxiesCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'deploy:cp',
+            aliases: ['deploy:container-proxies', 'deploy:proxy-stack'],
+            description: 'Deploy proxy stack (docker-compose.proxy.yml)',
+            addOptions: (command) => {
+                command.option('--no-build', 'Skip image build before up');
+                command.option('--remove-orphans', 'Remove containers for services not defined in compose');
+            },
+            execute: async (options) => {
+                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.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const DeployContainerWorkersCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=DeployContainerWorkersCommand.d.ts.map

package/src/cli/commands/DeployContainerWorkersCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeployContainerWorkersCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployContainerWorkersCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAcrE,eAAO,MAAM,6BAA6B;cAC9B,YAAY;EAyBtB,CAAC"}

package/src/cli/commands/DeployContainerWorkersCommand.js

@@ -0,0 +1,27 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveComposePath, runComposeWithFallback, } from '../commands/DockerComposeCommandUtils.js';
+import { Logger } from '../../config/logger.js';
+export const DeployContainerWorkersCommand = Object.freeze({
+    create() {
+        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.option('--no-build', 'Skip image build before up');
+                command.option('--remove-orphans', 'Remove containers for services not defined in compose');
+            },
+            execute: async (options) => {
+                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.');
+            },
+        });
+    },
+});

package/src/cli/commands/DeployContainersProxyCommand.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const DeployContainersProxyCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=DeployContainersProxyCommand.d.ts.map

package/src/cli/commands/DeployContainersProxyCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeployContainersProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployContainersProxyCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA2CrE,eAAO,MAAM,4BAA4B;cAC7B,YAAY;EAatB,CAAC"}

package/src/cli/commands/DeployContainersProxyCommand.js

@@ -0,0 +1,45 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const DEFAULT_CONFIG = 'wrangler.containers-proxy.jsonc';
+const resolveConfig = (cwd, raw) => {
+    const normalized = typeof raw === 'string' ? raw.trim() : '';
+    const candidate = normalized.length > 0 ? normalized : DEFAULT_CONFIG;
+    const full = join(cwd, candidate);
+    if (existsSync(full))
+        return candidate;
+    throw ErrorFactory.createCliError(`Wrangler config not found: ${candidate}`);
+};
+const resolveEnv = (raw) => {
+    const normalized = typeof raw === 'string' ? raw.trim() : '';
+    return normalized.length > 0 ? normalized : 'production';
+};
+const execute = async (options) => {
+    const cwd = process.cwd();
+    const config = resolveConfig(cwd, options.config);
+    const env = resolveEnv(options.env);
+    Logger.info(`Deploying Containers proxy via Wrangler (env=${env})...`);
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: 'wrangler',
+        args: ['deploy', '--config', config, '--env', env],
+        env: process.env,
+    });
+    process.exit(exitCode);
+};
+export const DeployContainersProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'deploy:ccp',
+            aliases: ['deploy:containers-proxy', 'deploy:cf-containers-proxy', 'd:ccp', 'ccp:deploy'],
+            description: 'Deploy Cloudflare Containers proxy Worker (wrangler.containers-proxy.jsonc)',
+            addOptions: (command) => {
+                command.option('-e, --env <name>', 'Wrangler environment name', 'production');
+                command.option('-c, --config <path>', 'Wrangler config file', DEFAULT_CONFIG);
+            },
+            execute: async (options) => execute(options),
+        });
+    },
+});

package/src/cli/commands/DockerCommand.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const DockerCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=DockerCommand.d.ts.map

package/src/cli/commands/DockerCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DockerCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DockerCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAqMrE,eAAO,MAAM,aAAa;cACd,YAAY;EAuBtB,CAAC"}

package/src/cli/commands/DockerCommand.js

@@ -0,0 +1,184 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { DockerPushCommand } from '../commands/DockerPushCommand.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { existsSync, readdirSync, renameSync, unlinkSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const resolveDefaultWranglerConfig = (cwd) => {
+    const candidates = [
+        'wrangler.containers-proxy.jsonc',
+        'wrangler.containers-proxy.json',
+        'wrangler.containers-proxy.toml',
+        'wrangler.jsonc',
+        'wrangler.json',
+        'wrangler.toml',
+    ];
+    for (const candidate of candidates) {
+        const full = join(cwd, candidate);
+        if (existsSync(full))
+            return candidate;
+    }
+    return undefined;
+};
+const resolvePort = (raw) => {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (value === '')
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed >= 65536) {
+        throw ErrorFactory.createCliError(`Error: Invalid --port '${value}'. Expected 1-65535.`);
+    }
+    return String(parsed);
+};
+const resolveWranglerConfig = (cwd, options) => {
+    const fromCli = typeof options.wranglerConfig === 'string' ? options.wranglerConfig.trim() : '';
+    if (fromCli.length > 0) {
+        const full = join(cwd, fromCli);
+        if (existsSync(full))
+            return fromCli;
+        throw ErrorFactory.createCliError(`Wrangler config not found: ${fromCli}`);
+    }
+    const fallback = resolveDefaultWranglerConfig(cwd);
+    if (typeof fallback === 'string' && fallback.length > 0)
+        return fallback;
+    throw ErrorFactory.createCliError('Wrangler config not found. Expected wrangler.containers-proxy.jsonc (or wrangler.jsonc/toml).');
+};
+const isContainersProxyConfig = (config) => {
+    const base = config.split(/[/\\]/).pop() ?? config;
+    return (base === 'wrangler.containers-proxy.jsonc' ||
+        base === 'wrangler.containers-proxy.json' ||
+        base === 'wrangler.containers-proxy.toml' ||
+        base.startsWith('wrangler.containers-proxy.'));
+};
+const getDevVarsBackupPath = (cwd, name) => join(cwd, `${name}.disabled-by-zin`);
+const clearLegacyDevVarsBackups = (cwd, name) => {
+    const legacyPrefix = `${name}.disabled-by-zin-`;
+    const entries = readdirSync(cwd);
+    for (const entry of entries) {
+        if (!entry.startsWith(legacyPrefix))
+            continue;
+        try {
+            unlinkSync(join(cwd, entry));
+        }
+        catch {
+            // noop
+        }
+    }
+};
+const reconcileDevVarsBackup = (cwd, name) => {
+    const targetPath = join(cwd, name);
+    const backupPath = getDevVarsBackupPath(cwd, name);
+    clearLegacyDevVarsBackups(cwd, name);
+    const hasTarget = existsSync(targetPath);
+    const hasBackup = existsSync(backupPath);
+    if (!hasBackup)
+        return backupPath;
+    if (!hasTarget) {
+        renameSync(backupPath, targetPath);
+        return backupPath;
+    }
+    unlinkSync(backupPath);
+    return backupPath;
+};
+const withDevVarsForConfig = async (cwd, config, envName, fn) => {
+    const moved = [];
+    const swappedIn = [];
+    const disable = (name) => {
+        const from = join(cwd, name);
+        if (!existsSync(from))
+            return;
+        const to = reconcileDevVarsBackup(cwd, name);
+        renameSync(from, to);
+        moved.push({ from, to });
+    };
+    const swapIn = (source, target) => {
+        const from = join(cwd, source);
+        if (!existsSync(from))
+            return;
+        const to = join(cwd, target);
+        if (existsSync(to))
+            return;
+        renameSync(from, to);
+        swappedIn.push({ from, to });
+    };
+    try {
+        if (isContainersProxyConfig(config)) {
+            // For containers-proxy configs, we want `.dev.vars*` to exist but only for
+            // this run. Users keep the files renamed as `.dev.vars*.containers-proxy`.
+            swapIn('.dev.vars.containers-proxy', '.dev.vars');
+            if (envName !== '') {
+                swapIn(`.dev.vars.${envName}.containers-proxy`, `.dev.vars.${envName}`);
+            }
+            return await fn();
+        }
+        // For all other configs, disable `.dev.vars*` so Wrangler relies on `.env*`.
+        disable('.dev.vars');
+        disable('.dev.vars.local');
+        disable('.dev.vars.staging');
+        disable('.dev.vars.staging.local');
+        if (envName !== '') {
+            disable(`.dev.vars.${envName}`);
+            disable(`.dev.vars.${envName}.local`);
+        }
+        return await fn();
+    }
+    finally {
+        const restoreSwaps = swappedIn.slice().reverse();
+        for (const item of restoreSwaps) {
+            try {
+                if (existsSync(item.to) && !existsSync(item.from))
+                    renameSync(item.to, item.from);
+            }
+            catch {
+                // noop
+            }
+        }
+        const restoreMoved = moved.slice().reverse();
+        for (const item of restoreMoved) {
+            try {
+                if (existsSync(item.to))
+                    renameSync(item.to, item.from);
+            }
+            catch {
+                // noop
+            }
+        }
+    }
+};
+const executeDocker = async (options) => {
+    const cwd = process.cwd();
+    const config = resolveWranglerConfig(cwd, options);
+    const env = typeof options.env === 'string' ? options.env.trim() : '';
+    const port = resolvePort(options.port);
+    const args = ['dev', '--config', config];
+    if (typeof port === 'string' && port.length > 0)
+        args.push('--port', port);
+    if (env.length > 0)
+        args.push('--env', env);
+    Logger.info('Starting Wrangler dev (Containers/Docker-backed)...');
+    const exitCode = await withDevVarsForConfig(cwd, config, env, async () => {
+        return SpawnUtil.spawnAndWait({ command: 'wrangler', args, env: process.env });
+    });
+    process.exit(exitCode);
+};
+export const DockerCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'docker',
+            aliases: ['dkr', 'dk'],
+            description: 'Run Wrangler dev using a Docker-backed Cloudflare Containers config',
+            addOptions: (command) => {
+                // `zin docker push` (subcommand) for Docker Hub publishing.
+                // Keep `zin docker` itself as the Wrangler dev command.
+                const pushCommand = DockerPushCommand.create().getCommand();
+                pushCommand.name('push');
+                command.addCommand(pushCommand);
+                command.option('-c, --wrangler-config <path>', 'Wrangler config file (defaults if present)');
+                command.option('-e, --env <name>', 'Wrangler environment name');
+                command.option('-p, --port <number>', 'Port for wrangler dev');
+            },
+            execute: async (options) => executeDocker(options),
+        });
+    },
+});

package/src/cli/commands/DockerComposeCommandUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const resolveComposePath: (composeFileName: string, missingMessage: string) => string;
+export declare const runComposeWithFallback: (args: string[]) => Promise<void>;
+//# sourceMappingURL=DockerComposeCommandUtils.d.ts.map

package/src/cli/commands/DockerComposeCommandUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DockerComposeCommandUtils.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DockerComposeCommandUtils.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,kBAAkB,GAAI,iBAAiB,MAAM,EAAE,gBAAgB,MAAM,KAAG,MAMpF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAU,MAAM,MAAM,EAAE,KAAG,OAAO,CAAC,IAAI,CAqBzE,CAAC"}

package/src/cli/commands/DockerComposeCommandUtils.js

@@ -0,0 +1,34 @@
+import { SpawnUtil } from '../utils/spawn.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+export const resolveComposePath = (composeFileName, missingMessage) => {
+    const composePath = join(process.cwd(), composeFileName);
+    if (!existsSync(composePath)) {
+        throw ErrorFactory.createCliError(missingMessage);
+    }
+    return composePath;
+};
+export const runComposeWithFallback = async (args) => {
+    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);
+    }
+};

package/src/cli/commands/DockerPushCommand.d.ts

@@ -0,0 +1,5 @@
+import type { IBaseCommand } from '../BaseCommand';
+export declare const DockerPushCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=DockerPushCommand.d.ts.map

package/src/cli/commands/DockerPushCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DockerPushCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DockerPushCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+GrE,eAAO,MAAM,iBAAiB;cAClB,YAAY;EA8BtB,CAAC"}