@zintrust/core 0.1.39 → 0.1.41

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerProxiesCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ContainerProxiesCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAwErE,eAAO,MAAM,uBAAuB;cACxB,YAAY;EAuCtB,CAAC"}

package/src/cli/commands/ContainerProxiesCommand.js

@@ -0,0 +1,77 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveComposePath, runComposeWithFallback, } from '../commands/DockerComposeCommandUtils.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const runBuild = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'build'];
+    if (options.noCache === true) {
+        args.push('--no-cache');
+    }
+    if (options.pull === true) {
+        args.push('--pull');
+    }
+    Logger.info('Building proxy stack image...');
+    await runComposeWithFallback(args);
+};
+const runUp = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'up'];
+    if (options.detach === true) {
+        args.push('-d');
+    }
+    if (options.removeOrphans === true) {
+        args.push('--remove-orphans');
+    }
+    Logger.info('Starting proxy stack...');
+    await runComposeWithFallback(args);
+};
+const runDown = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'down'];
+    if (options.removeOrphans === true) {
+        args.push('--remove-orphans');
+    }
+    if (options.volumes === true) {
+        args.push('--volumes');
+    }
+    Logger.info('Stopping proxy stack...');
+    await runComposeWithFallback(args);
+};
+const normalizeAction = (raw) => {
+    const value = (raw ?? '').trim().toLowerCase();
+    if (value === 'build' || value === 'up' || value === 'down')
+        return value;
+    throw ErrorFactory.createCliError('Usage: zin cp <build|up|down> [options]');
+};
+export const ContainerProxiesCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'cp',
+            aliases: ['container-proxies'],
+            description: 'Build, start, or stop container-based proxy stack',
+            addOptions: (command) => {
+                command.argument('<action>', 'Action to run (build, up, down)');
+                command.option('-d, --detach', 'Run containers in background (up only)');
+                command.option('--no-cache', 'Disable Docker build cache (build only)');
+                command.option('--pull', 'Always attempt to pull a newer base image (build only)');
+                command.option('--build', 'Build before running up (up only)');
+                command.option('--remove-orphans', 'Remove containers for services not defined in compose');
+                command.option('--volumes', 'Remove named volumes when running down (down only)');
+            },
+            execute: async (options) => {
+                const action = normalizeAction(options.args?.[0]);
+                const composePath = resolveComposePath('docker-compose.proxy.yml', 'docker-compose.proxy.yml not found.');
+                if (action === 'build') {
+                    await runBuild(composePath, options);
+                    return;
+                }
+                if (action === 'down') {
+                    await runDown(composePath, options);
+                    return;
+                }
+                if (options.build === true) {
+                    await runBuild(composePath, options);
+                }
+                await runUp(composePath, options);
+            },
+        });
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ContainerWorkersCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ContainerWorkersCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmDrE,eAAO,MAAM,uBAAuB;cACxB,YAAY;EAgCtB,CAAC"}

package/src/cli/commands/ContainerWorkersCommand.js

@@ -0,0 +1,57 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveComposePath, runComposeWithFallback, } from '../commands/DockerComposeCommandUtils.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+const runBuild = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'build'];
+    if (options.noCache === true) {
+        args.push('--no-cache');
+    }
+    if (options.pull === true) {
+        args.push('--pull');
+    }
+    Logger.info('Building container workers image...');
+    await runComposeWithFallback(args);
+};
+const runUp = async (composePath, options) => {
+    const args = ['compose', '-f', composePath, 'up'];
+    if (options.detach === true) {
+        args.push('-d');
+    }
+    Logger.info('Starting container workers...');
+    await runComposeWithFallback(args);
+};
+const normalizeAction = (raw) => {
+    const value = (raw ?? '').trim().toLowerCase();
+    if (value === 'build' || value === 'up')
+        return value;
+    throw ErrorFactory.createCliError('Usage: zin cw <build|up> [options]');
+};
+export const ContainerWorkersCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'cw',
+            aliases: ['container-workers'],
+            description: 'Build or start container-based workers',
+            addOptions: (command) => {
+                command.argument('<action>', 'Action to run (build or up)');
+                command.option('-d, --detach', 'Run containers in background (up only)');
+                command.option('--no-cache', 'Disable Docker build cache (build only)');
+                command.option('--pull', 'Always attempt to pull a newer base image (build only)');
+                command.option('--build', 'Build before running up (up only)');
+            },
+            execute: async (options) => {
+                const action = normalizeAction(options.args?.[0]);
+                const composePath = resolveComposePath('docker-compose.workers.yml', 'docker-compose.workers.yml not found. Run `zin init:cw` first.');
+                if (action === 'build') {
+                    await runBuild(composePath, options);
+                    return;
+                }
+                if (options.build === true) {
+                    await runBuild(composePath, options);
+                }
+                await runUp(composePath, options);
+            },
+        });
+    },
+});

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;AA0HrE;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EAGtB,CAAC"}

package/src/cli/commands/DeployCommand.js

@@ -0,0 +1,110 @@
+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';
+    Logger.info(`Deploying to Cloudflare environment: ${environment}`);
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: 'wrangler',
+        args: ['deploy', '--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)');
+        },
+        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/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/DoctorArchitectureCommand.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DoctorArchitectureCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DoctorArchitectureCommand.ts"],"names":[],"mappings":"AAEA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIlE,eAAO,MAAM,yBAAyB;cAC1B,YAAY;EAgEtB,CAAC"}

package/src/cli/commands/DoctorArchitectureCommand.js

@@ -0,0 +1,54 @@
+import { getRuntimeMode } from '../../runtime/detectRuntime.js';
+import { BaseCommand } from '../BaseCommand.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+export const DoctorArchitectureCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'doctor:architecture',
+            aliases: ['d'],
+            description: 'Validate producer/consumer architecture configuration',
+            async execute() {
+                Logger.info('🩺 Diagnosing Architecture Configuration...');
+                const mode = getRuntimeMode();
+                const workerEnabled = Env.getBool('WORKER_ENABLED', true);
+                const dockerWorker = Env.getBool('DOCKER_WORKER', false);
+                Logger.info('----------------------------------------');
+                Logger.info(`Runtime Mode:    ${mode}`);
+                Logger.info(`Docker Worker:   ${dockerWorker}`);
+                Logger.info(`Worker Enabled:  ${workerEnabled}`);
+                Logger.info('----------------------------------------');
+                const issues = [];
+                // Rule 1: Cloudflare Workers cannot run Consumers
+                if (mode === 'cloudflare-workers' && workerEnabled) {
+                    issues.push('❌ CRITICAL: Cloudflare Workers runtime detected but WORKER_ENABLED=true. Consumers will fail due to connection persistence limits. Set WORKER_ENABLED=false.');
+                }
+                // Rule 2: Containers should generally run Workers (unless dedicated to API)
+                if (mode === 'containers' && !workerEnabled) {
+                    issues.push('⚠️ WARNING: Container runtime detected but WORKER_ENABLED=false. Are these containers for API only? If attempting to process jobs, enable workers.');
+                }
+                // Rule 2b: Dedicated Docker worker containers must keep workers enabled
+                if (mode === 'containers' && dockerWorker && !workerEnabled) {
+                    issues.push('❌ CRITICAL: DOCKER_WORKER=true but WORKER_ENABLED=false. Dedicated worker containers must enable workers or unset DOCKER_WORKER.');
+                }
+                // Rule 3: Proxy requirement for Cloudflare
+                if (mode === 'cloudflare-workers') {
+                    const useProxy = Env.getBool('USE_REDIS_PROXY', false) ||
+                        Env.getBool('ENABLE_CLOUDFLARE_SOCKETS', false);
+                    if (!useProxy) {
+                        issues.push('❌ CRITICAL: Cloudflare runtime requires USE_REDIS_PROXY=true or ENABLE_CLOUDFLARE_SOCKETS=true for Queue producers.');
+                    }
+                }
+                if (issues.length > 0) {
+                    Logger.error('Found configuration issues:');
+                    issues.forEach((issue) => Logger.error(issue));
+                    process.exit(1);
+                }
+                else {
+                    Logger.info('✅ Architecture configuration looks valid for this runtime.');
+                }
+                await Promise.resolve();
+            },
+        });
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InitContainerCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/InitContainerCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAoNlE,eAAO,MAAM,oBAAoB;cACrB,YAAY;EAkBtB,CAAC"}