@zintrust/core 0.4.17 → 0.4.18

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/FixCommand.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fix Command - Automated Code Cleanup
+ * Runs ESLint fix and other automated tools
+ */
+import type { IBaseCommand } from '../BaseCommand';
+/**
+ * Fix Command Factory
+ */
+export declare const FixCommand: Readonly<{
+    /**
+     * Create a new fix command instance
+     */
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=FixCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FixCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/FixCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAoDrE;;GAEG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;cACO,YAAY;EAkBtB,CAAC"}

package/src/cli/commands/FixCommand.js

@@ -0,0 +1,68 @@
+/**
+ * Fix Command - Automated Code Cleanup
+ * Runs ESLint fix and other automated tools
+ */
+import { appConfig } from '../../config/index.js';
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveNpmPath } from '../../common/index.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { execFileSync } from '../../node-singletons/child-process.js';
+const runNpmScript = (cmd, args) => {
+    const npmPath = resolveNpmPath();
+    cmd.debug(`Executing: npm run ${args.join(' ')}`);
+    execFileSync(npmPath, ['run', ...args], {
+        stdio: 'inherit',
+        encoding: 'utf8',
+        env: appConfig.getSafeEnv(),
+    });
+};
+const executeFix = (cmd, options) => {
+    cmd.info('Starting automated code fixes...');
+    try {
+        const isDryRun = options['dryRun'] === true;
+        cmd.info('Running ESLint fix...');
+        try {
+            runNpmScript(cmd, ['lint', '--', isDryRun ? '--fix-dry-run' : '--fix']);
+        }
+        catch (error) {
+            ErrorFactory.createCliError('ESLint fix failed', error);
+            cmd.warn('ESLint fix encountered some issues, continuing...');
+        }
+        cmd.info('Running Prettier format...');
+        try {
+            runNpmScript(cmd, ['format']);
+        }
+        catch (error) {
+            ErrorFactory.createCliError('Prettier format failed', error);
+            cmd.warn('Prettier format encountered some issues.');
+        }
+        cmd.success('Code fixes completed successfully!');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Fix command failed', error);
+        cmd.warn('Some fixes could not be applied automatically.');
+    }
+};
+/**
+ * Fix Command Factory
+ */
+export const FixCommand = Object.freeze({
+    /**
+     * Create a new fix command instance
+     */
+    create() {
+        const addOptions = (command) => {
+            command.option('--dry-run', 'Show what would be fixed without applying changes');
+        };
+        const cmd = BaseCommand.create({
+            name: 'fix',
+            description: 'Run automated code fixes',
+            addOptions,
+            execute: (options) => executeFix(cmd, options),
+        });
+        cmd.resolveNpmPath = () => resolveNpmPath();
+        cmd.getSafeEnv = () => appConfig.getSafeEnv();
+        cmd.runNpmExec = (args) => runNpmScript(cmd, args);
+        return cmd;
+    },
+});

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;AAyKlE,eAAO,MAAM,oBAAoB;cACrB,YAAY;EAkBtB,CAAC"}

package/src/cli/commands/InitContainerCommand.js

@@ -0,0 +1,173 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { PromptHelper } from '../PromptHelper.js';
+import { Logger } from '../../config/logger.js';
+import { copyFileSync, existsSync, writeFileSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const DOCKER_COMPOSE_WORKERS_TEMPLATE = `name: zintrust-workers
+
+services:
+  # Workers/Jobs API Service (Port 7772)
+  # Exposes the Workers API to create/manage jobs
+  workers-api:
+    image: \${WORKERS_IMAGE:-zintrust/zintrust-workers:latest}
+    build:
+      context: .
+      dockerfile: Dockerfile
+    command: ["node", "--experimental-specifier-resolution=node", "dist/src/boot/bootstrap.js"]
+    environment:
+      # Runtime
+      - NODE_ENV=\${NODE_ENV:-development}
+      - PORT=7772
+      - HOST=0.0.0.0
+      - RUNTIME_MODE=node-server
+
+      # Application
+      - APP_NAME=\${APP_NAME:-ZinTrust}
+      - APP_KEY=\${APP_KEY}
+      - ENCRYPTION_CIPHER=\${ENCRYPTION_CIPHER:-aes-256-cbc}
+      - LOG_LEVEL=\${LOG_LEVEL:-info}
+      - ZINTRUST_PROJECT_ROOT=/app/dist
+
+      # Workers & Queue
+      - WORKER_ENABLED=\${WORKER_ENABLED:-false}
+      - WORKER_AUTO_START=\${WORKER_AUTO_START:-false}
+      - QUEUE_ENABLED=true
+      - QUEUE_MONITOR_ENABLED=\${QUEUE_MONITOR_ENABLED:-false}
+      - QUEUE_MONITOR_MIDDLEWARE=\${QUEUE_MONITOR_MIDDLEWARE:-}
+      - WORKER_PERSISTENCE_DRIVER=\${WORKER_PERSISTENCE_DRIVER:-redis}
+      - WORKER_PERSISTENCE_DB_CONNECTION=\${WORKER_PERSISTENCE_DB_CONNECTION:-mysql}
+      - WORKER_PERSISTENCE_REDIS_KEY_PREFIX=\${WORKER_PERSISTENCE_REDIS_KEY_PREFIX}
+      - QUEUE_DRIVER=\${QUEUE_DRIVER:-redis}
+      - QUEUE_CONNECTION=\${QUEUE_CONNECTION:-redis}
+      - CACHE_DRIVER=\${CACHE_DRIVER:-redis}
+
+      # Redis
+      - REDIS_HOST=\${DOCKER_REDIS_HOST:-host.docker.internal}
+      - REDIS_PORT=\${REDIS_PORT:-6379}
+      - REDIS_PASSWORD=\${REDIS_PASSWORD}
+      - REDIS_QUEUE_DB=\${REDIS_QUEUE_DB:-1}
+
+      # Database
+      - DB_CONNECTION=\${DB_CONNECTION:-postgres}
+      - DB_HOST=\${DOCKER_DB_HOST:-host.docker.internal}
+      - DB_PORT=\${DB_PORT:-3306}
+      - DB_DATABASE=\${DB_DATABASE:-zintrust}
+      - DB_USERNAME=\${DB_USERNAME:-zintrust}
+      - DB_PASSWORD=\${DB_PASSWORD:-secret}
+
+      # SMTP Mail
+      - MAIL_DRIVER=\${MAIL_DRIVER:-smtp}
+      - MAIL_CONNECTION=\${MAIL_CONNECTION:-smtp}
+      - MAIL_HOST=\${MAIL_HOST}
+      - MAIL_PORT=\${MAIL_PORT:-587}
+      - MAIL_SECURE=\${MAIL_SECURE:-false}
+      - MAIL_USERNAME=\${MAIL_USERNAME}
+      - MAIL_PASSWORD=\${MAIL_PASSWORD}
+      - MAIL_FROM_ADDRESS=\${MAIL_FROM_ADDRESS}
+      - MAIL_FROM_NAME=\${MAIL_FROM_NAME:-ZinTrust}
+
+      # PostgreSQL
+      - DB_PORT_POSTGRESQL=\${DB_PORT_POSTGRESQL:-5432}
+      - DB_DATABASE_POSTGRESQL=\${DB_DATABASE_POSTGRESQL:-zintrust}
+      - DB_USERNAME_POSTGRESQL=\${DB_USERNAME_POSTGRESQL:-zintrust}
+      - DB_PASSWORD_POSTGRESQL=\${DB_PASSWORD_POSTGRESQL:-secret}
+
+      # MySQL
+      - DB_PORT_MYSQL=\${DB_PORT_MYSQL:-3306}
+      - DB_DATABASE_MYSQL=\${DB_DATABASE_MYSQL:-zintrust}
+      - DB_USERNAME_MYSQL=\${DB_USERNAME_MYSQL:-zintrust}
+      - DB_PASSWORD_MYSQL=\${DB_PASSWORD_MYSQL:-secret}
+
+      # Cloudflare D1
+      - D1_DATABASE_ID=\${D1_DATABASE_ID}
+      - D1_ACCOUNT_ID=\${D1_ACCOUNT_ID}
+      - D1_API_TOKEN=\${D1_API_TOKEN}
+      - D1_REMOTE_URL=\${D1_REMOTE_URL}
+      - D1_REMOTE_KEY_ID=\${D1_REMOTE_KEY_ID}
+      - D1_REMOTE_SECRET=\${D1_REMOTE_SECRET}
+
+      # Cloudflare KV
+      - KV_NAMESPACE_ID=\${KV_NAMESPACE_ID}
+      - KV_ACCOUNT_ID=\${KV_ACCOUNT_ID}
+      - KV_API_TOKEN=\${KV_API_TOKEN}
+      - KV_REMOTE_URL=\${KV_REMOTE_URL}
+      - KV_REMOTE_KEY_ID=\${KV_REMOTE_KEY_ID}
+      - KV_REMOTE_SECRET=\${KV_REMOTE_SECRET}
+    ports:
+      - '7772:7772'
+
+`;
+const DOCKERFILE_TEMPLATE = String.raw `FROM zintrust/zintrust:latest AS runtime
+
+WORKDIR /app
+
+ENV NODE_ENV=production
+ENV PORT=7772
+ENV HOST=0.0.0.0
+
+USER nodejs
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+  CMD node -e "require('node:http').get('http://localhost:7772/health', (r) => {if (r.statusCode !== 200) throw new Error(r.statusCode)})"
+
+EXPOSE 7772
+
+CMD ["node", "dist/src/boot/bootstrap.js"]
+`;
+const backupSuffix = () => new Date().toISOString().replaceAll(/[:.]/g, '-');
+const backupFileIfExists = (filePath) => {
+    if (!existsSync(filePath))
+        return;
+    const backupPath = `${filePath}.bak.${backupSuffix()}`;
+    copyFileSync(filePath, backupPath);
+    Logger.info(`🗂️ Backup created: ${backupPath}`);
+};
+async function writeDockerComposeFile(cwd) {
+    const composePath = join(cwd, 'docker-compose.workers.yml');
+    let shouldWrite = true;
+    if (existsSync(composePath)) {
+        shouldWrite = await PromptHelper.confirm('docker-compose.workers.yml already exists. Overwrite?', false);
+    }
+    if (shouldWrite) {
+        backupFileIfExists(composePath);
+        writeFileSync(composePath, DOCKER_COMPOSE_WORKERS_TEMPLATE);
+        Logger.info('✅ Created docker-compose.workers.yml');
+    }
+    else {
+        Logger.info('Skipped docker-compose.workers.yml');
+    }
+}
+async function writeDockerfile(cwd) {
+    const dockerfilePath = join(cwd, 'Dockerfile');
+    let shouldWrite = true;
+    if (existsSync(dockerfilePath)) {
+        // Only ask if it's different or just generic confirm? Let's just ask.
+        shouldWrite = await PromptHelper.confirm('Dockerfile already exists. Overwrite with standard worker configuration?', false);
+    }
+    if (shouldWrite) {
+        backupFileIfExists(dockerfilePath);
+        writeFileSync(dockerfilePath, DOCKERFILE_TEMPLATE);
+        Logger.info('✅ Created Dockerfile');
+    }
+    else {
+        Logger.info('Skipped Dockerfile');
+    }
+}
+export const InitContainerCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'init:container-workers',
+            aliases: ['init:cw', 'init:cwr', 'init:container-workers-routes'],
+            description: 'Initialize container-based worker infrastructure',
+            async execute() {
+                Logger.info('Initializing container-based worker infrastructure...');
+                const cwd = process.cwd();
+                await writeDockerComposeFile(cwd);
+                await writeDockerfile(cwd);
+                Logger.info('✅ Container worker scaffolding complete.');
+                Logger.info('Run with: docker-compose -f docker-compose.workers.yml up');
+                await Promise.resolve();
+            },
+        });
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InitContainersProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/InitContainersProxyCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA6JlE,eAAO,MAAM,0BAA0B;cAC3B,YAAY;EAuBtB,CAAC"}

package/src/cli/commands/InitContainersProxyCommand.js

@@ -0,0 +1,159 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { PromptHelper } from '../PromptHelper.js';
+import { Logger } from '../../config/logger.js';
+import { copyFileSync, existsSync, mkdirSync, writeFileSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const WRANGLER_CONTAINERS_PROXY_TEMPLATE = `/**
+ * ============================================================================
+ * ZinTrust Cloudflare Containers Proxy
+ * ============================================================================
+ * This Worker acts as the "gateway" for the DB/KV/SMTP proxy stack.
+ *
+ * Requests are routed by path prefix:
+ *   /mysql/*     -> ZintrustMySqlProxyContainer (port 8789)
+ *   /postgres/*  -> ZintrustPostgresProxyContainer (port 8790)
+ *   /redis/*     -> ZintrustRedisProxyContainer (port 8791)
+ *   /mongodb/*   -> ZintrustMongoDbProxyContainer (port 8792)
+ *   /sqlserver/* -> ZintrustSqlServerProxyContainer (port 8793)
+ *   /smtp/*      -> ZintrustSmtpProxyContainer (port 8794)
+ *
+ * Notes:
+ * - You must install the runtime package: "@zintrust/cloudflare-containers-proxy".
+ * - Secrets should be uploaded with the same config file.
+ * ============================================================================
+ */
+
+{
+  "name": "zintrust-containers-proxy",
+  "main": "./src/containers-proxy.ts",
+
+  "compatibility_date": "2025-04-21",
+  "compatibility_flags": ["nodejs_compat"],
+
+  "workers_dev": true,
+  "minify": false,
+
+  "containers": [
+    { "class_name": "ZintrustMySqlProxyContainer", "image": "./Dockerfile", "max_instances": 10 },
+    { "class_name": "ZintrustPostgresProxyContainer", "image": "./Dockerfile", "max_instances": 10 },
+    { "class_name": "ZintrustRedisProxyContainer", "image": "./Dockerfile", "max_instances": 10 },
+    { "class_name": "ZintrustMongoDbProxyContainer", "image": "./Dockerfile", "max_instances": 10 },
+    { "class_name": "ZintrustSqlServerProxyContainer", "image": "./Dockerfile", "max_instances": 10 },
+    { "class_name": "ZintrustSmtpProxyContainer", "image": "./Dockerfile", "max_instances": 10 }
+  ],
+
+  "durable_objects": {
+    "bindings": [
+      { "name": "ZT_PROXY_MYSQL", "class_name": "ZintrustMySqlProxyContainer" },
+      { "name": "ZT_PROXY_POSTGRES", "class_name": "ZintrustPostgresProxyContainer" },
+      { "name": "ZT_PROXY_REDIS", "class_name": "ZintrustRedisProxyContainer" },
+      { "name": "ZT_PROXY_MONGODB", "class_name": "ZintrustMongoDbProxyContainer" },
+      { "name": "ZT_PROXY_SQLSERVER", "class_name": "ZintrustSqlServerProxyContainer" },
+      { "name": "ZT_PROXY_SMTP", "class_name": "ZintrustSmtpProxyContainer" }
+    ]
+  },
+
+  "migrations": [
+    {
+      "tag": "containers-proxy-v1",
+      "new_sqlite_classes": [
+        "ZintrustMySqlProxyContainer",
+        "ZintrustPostgresProxyContainer",
+        "ZintrustRedisProxyContainer",
+        "ZintrustMongoDbProxyContainer",
+        "ZintrustSqlServerProxyContainer",
+        "ZintrustSmtpProxyContainer"
+      ]
+    }
+  ],
+
+  "env": {
+    "staging": {
+      "name": "zintrust-containers-proxy-staging",
+      "minify": false,
+      "vars": {
+        "ENVIRONMENT": "staging",
+        "APP_NAME": "ZinTrust",
+        "CSRF_SKIP_PATHS": "/api/*,/queue-monitor/*"
+      },
+      // Add routes here when ready:
+      // "routes": [{ "pattern": "proxy-staging.example.com", "custom_domain": true }]
+    },
+    "production": {
+      "name": "zintrust-containers-proxy-production",
+      "minify": true,
+      "vars": {
+        "ENVIRONMENT": "production",
+        "APP_NAME": "ZinTrust",
+        "CSRF_SKIP_PATHS": "/api/*,/queue-monitor/*"
+      },
+      // Add routes here when ready:
+      // "routes": [{ "pattern": "proxy.example.com", "custom_domain": true }]
+    }
+  }
+}
+`;
+const WORKER_ENTRY_TEMPLATE = `export { default } from '@zintrust/cloudflare-containers-proxy';
+export * from '@zintrust/cloudflare-containers-proxy';
+`;
+const backupSuffix = () => new Date().toISOString().replaceAll(/[:.]/g, '-');
+const backupFileIfExists = (filePath) => {
+    if (!existsSync(filePath))
+        return;
+    const backupPath = `${filePath}.bak.${backupSuffix()}`;
+    copyFileSync(filePath, backupPath);
+    Logger.info(`🗂️ Backup created: ${backupPath}`);
+};
+async function writeWranglerConfig(cwd) {
+    const configPath = join(cwd, 'wrangler.containers-proxy.jsonc');
+    let shouldWrite = true;
+    if (existsSync(configPath)) {
+        shouldWrite = await PromptHelper.confirm('wrangler.containers-proxy.jsonc already exists. Overwrite?', false);
+    }
+    if (!shouldWrite) {
+        Logger.info('Skipped wrangler.containers-proxy.jsonc');
+        return;
+    }
+    backupFileIfExists(configPath);
+    writeFileSync(configPath, WRANGLER_CONTAINERS_PROXY_TEMPLATE);
+    Logger.info('✅ Created wrangler.containers-proxy.jsonc');
+}
+async function writeWorkerEntry(cwd) {
+    const srcDir = join(cwd, 'src');
+    const entryPath = join(srcDir, 'containers-proxy.ts');
+    if (!existsSync(srcDir)) {
+        mkdirSync(srcDir, { recursive: true });
+    }
+    let shouldWrite = true;
+    if (existsSync(entryPath)) {
+        shouldWrite = await PromptHelper.confirm('src/containers-proxy.ts already exists. Overwrite?', false);
+    }
+    if (!shouldWrite) {
+        Logger.info('Skipped src/containers-proxy.ts');
+        return;
+    }
+    backupFileIfExists(entryPath);
+    writeFileSync(entryPath, WORKER_ENTRY_TEMPLATE);
+    Logger.info('✅ Created src/containers-proxy.ts');
+}
+export const InitContainersProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'init:containers-proxy',
+            aliases: ['init:ccp', 'init:cf-containers-proxy'],
+            description: 'Scaffold Cloudflare Containers proxy Worker (wrangler.containers-proxy.jsonc)',
+            async execute() {
+                Logger.info('Initializing Cloudflare Containers proxy scaffolding...');
+                const cwd = process.cwd();
+                await writeWranglerConfig(cwd);
+                await writeWorkerEntry(cwd);
+                Logger.info('✅ Containers proxy scaffolding complete.');
+                Logger.info('Install runtime: npm i @zintrust/cloudflare-containers-proxy');
+                Logger.info('Dev (Wrangler + Docker): zin docker --wrangler-config wrangler.containers-proxy.jsonc --env staging');
+                Logger.info('Dev (short): zin dk -e staging');
+                Logger.info('Deploy (short): zin d:ccp');
+                await Promise.resolve();
+            },
+        });
+    },
+});

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

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

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

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

package/src/cli/commands/InitEcosystemCommand.js

@@ -0,0 +1,51 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { PromptHelper } from '../PromptHelper.js';
+import { Logger } from '../../config/logger.js';
+import { copyFileSync, existsSync, readFileSync, writeFileSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+import { fileURLToPath } from '../../node-singletons/url.js';
+const backupSuffix = () => new Date().toISOString().replaceAll(/[:.]/g, '-');
+const backupFileIfExists = (filePath) => {
+    if (!existsSync(filePath))
+        return;
+    const backupPath = `${filePath}.bak.${backupSuffix()}`;
+    copyFileSync(filePath, backupPath);
+    Logger.info(`🗂️ Backup created: ${backupPath}`);
+};
+const readTemplate = (relPathFromThisModule) => {
+    const absPath = fileURLToPath(new URL(relPathFromThisModule, import.meta.url));
+    return readFileSync(absPath, 'utf-8');
+};
+const TEMPLATE_ECOSYSTEM = readTemplate('../../templates/docker/docker-compose.ecosystem.yml.tpl');
+const TEMPLATE_SCHEDULES = readTemplate('../../templates/docker/docker-compose.schedules.yml.tpl');
+const writeScaffoldFile = async (cwd, fileName, content) => {
+    const outPath = join(cwd, fileName);
+    let shouldWrite = true;
+    if (existsSync(outPath)) {
+        shouldWrite = await PromptHelper.confirm(`${fileName} already exists. Overwrite?`, false);
+    }
+    if (!shouldWrite) {
+        Logger.info(`Skipped ${fileName}`);
+        return;
+    }
+    backupFileIfExists(outPath);
+    writeFileSync(outPath, content);
+    Logger.info(`✅ Created ${fileName}`);
+};
+const execute = async () => {
+    const cwd = process.cwd();
+    await writeScaffoldFile(cwd, 'docker-compose.ecosystem.yml', TEMPLATE_ECOSYSTEM);
+    await writeScaffoldFile(cwd, 'docker-compose.schedules.yml', TEMPLATE_SCHEDULES);
+    Logger.info('✅ Ecosystem scaffolding complete.');
+    Logger.info('Next: docker compose -f docker-compose.ecosystem.yml up -d');
+};
+export const InitEcosystemCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'init:ecosystem',
+            description: 'Scaffold docker-compose.ecosystem.yml and docker-compose.schedules.yml',
+            execute,
+        });
+    },
+});
+export default InitEcosystemCommand;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InitProducerCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/InitProducerCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAKlE,eAAO,MAAM,mBAAmB;cACpB,YAAY;EAkDtB,CAAC"}

package/src/cli/commands/InitProducerCommand.js

@@ -0,0 +1,47 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { Logger } from '../../config/logger.js';
+import { existsSync, readFileSync, writeFileSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+export const InitProducerCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'init:producer',
+            aliases: ['init:p'],
+            description: 'Configure Cloudflare Workers as producer-only',
+            async execute() {
+                Logger.info('Configuring Cloudflare Workers project as Producer-only...');
+                const cwd = process.cwd();
+                const wranglerPath = join(cwd, 'wrangler.jsonc');
+                if (!existsSync(wranglerPath)) {
+                    Logger.error('wrangler.jsonc not found. Is this a Cloudflare Workers project?');
+                    return;
+                }
+                let content = readFileSync(wranglerPath, 'utf-8');
+                let modified = false;
+                // Force WORKER_ENABLED = false
+                if (content.includes('"WORKER_ENABLED"')) {
+                    content = content.replace(/"WORKER_ENABLED"\s*:\s*"true"/, '"WORKER_ENABLED": "false"');
+                    content = content.replace(/"WORKER_ENABLED"\s*:\s*true/, '"WORKER_ENABLED": "false"');
+                    modified = true;
+                }
+                else {
+                    // Inject into vars
+                    const varsMatch = content.match(/"vars"\s*:\s*{/);
+                    if (varsMatch) {
+                        content = content.replace(/"vars"\s*:\s*{/, `"vars": {\n    "WORKER_ENABLED": "false",\n    "QUEUE_ENABLED": "true",\n    "RUNTIME_MODE": "cloudflare-workers",`);
+                        modified = true;
+                    }
+                }
+                if (modified) {
+                    writeFileSync(wranglerPath, content);
+                    Logger.info('✅ Updated wrangler.jsonc: Set WORKER_ENABLED=false, QUEUE_ENABLED=true');
+                }
+                else {
+                    Logger.info('wrangler.jsonc configuration appears correct or could not be automatically patched.');
+                }
+                Logger.info('✅ Producer configuration check complete.');
+                await Promise.resolve();
+            },
+        });
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"InitProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/InitProxyCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA6blE,eAAO,MAAM,gBAAgB;cACjB,YAAY;EAmBtB,CAAC"}