@zintrust/core 0.1.40 → 0.1.41

package/src/boot/registry/runtime.js

@@ -0,0 +1,353 @@
+import * as RuntimeConfig from '../../config/index.js';
+import { StartupHealthChecks } from '../../health/StartupHealthChecks.js';
+import { loadQueueMonitorModule, loadWorkersModule } from '../../runtime/WorkersModule.js';
+import { registerCachesFromRuntimeConfig } from '../../cache/CacheRuntimeRegistration.js';
+import broadcastConfig from '../../config/broadcast.js';
+import { Cloudflare } from '../../config/cloudflare.js';
+import { FeatureFlags } from '../../config/features.js';
+import { Logger } from '../../config/logger.js';
+import notificationConfig from '../../config/notification.js';
+import { StartupConfigValidator } from '../../config/StartupConfigValidator.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+import { pathToFileURL } from '../../node-singletons/url.js';
+import { registerDatabasesFromRuntimeConfig } from '../../orm/DatabaseRuntimeRegistration.js';
+import { registerMasterRoutes, tryImportOptional } from './registerRoute.js';
+import { registerWorkerShutdownHook } from './worker.js';
+import { StartupConfigFile, StartupConfigFileRegistry } from '../../runtime/StartupConfigFileRegistry.js';
+import { registerBroadcastersFromRuntimeConfig } from '../../tools/broadcast/BroadcastRuntimeRegistration.js';
+import { registerNotificationChannelsFromRuntimeConfig } from '../../tools/notification/NotificationRuntimeRegistration.js';
+import { registerQueuesFromRuntimeConfig } from '../../tools/queue/QueueRuntimeRegistration.js';
+import { registerDisksFromRuntimeConfig } from '../../tools/storage/StorageRuntimeRegistration.js';
+const loadRuntimeQueueConfig = async () => {
+    try {
+        const modulePath = '@runtime-config/queue';
+        const loaded = (await import(modulePath));
+        return loaded.default ?? queueConfig ?? undefined;
+    }
+    catch {
+        return queueConfig ?? undefined;
+    }
+};
+const readRuntimeConfig = (key, fallback) => {
+    try {
+        const value = RuntimeConfig[key];
+        return (value ?? fallback);
+    }
+    catch {
+        return fallback;
+    }
+};
+const appConfig = readRuntimeConfig('appConfig', { port: 7777, dockerWorker: false });
+const cacheConfig = readRuntimeConfig('cacheConfig', RuntimeConfig.cacheConfig);
+const databaseConfig = readRuntimeConfig('databaseConfig', {
+    default: 'sqlite',
+    connections: {},
+});
+const queueConfig = readRuntimeConfig('queueConfig', RuntimeConfig.queueConfig);
+const storageConfig = readRuntimeConfig('storageConfig', RuntimeConfig.storageConfig);
+// eslint-disable-next-line @typescript-eslint/require-await
+const dbLoader = async () => {
+    registerDatabasesFromRuntimeConfig(databaseConfig);
+};
+const queuesLoader = async () => {
+    await registerQueuesFromRuntimeConfig(queueConfig);
+};
+// eslint-disable-next-line @typescript-eslint/require-await
+const cachesLoader = async () => {
+    registerCachesFromRuntimeConfig(cacheConfig);
+};
+const registerFromRuntimeConfig = async () => {
+    await dbLoader();
+    await queuesLoader();
+    await cachesLoader();
+    registerBroadcastersFromRuntimeConfig({
+        default: broadcastConfig.default,
+        drivers: broadcastConfig.drivers,
+    });
+    registerDisksFromRuntimeConfig(storageConfig);
+    registerNotificationChannelsFromRuntimeConfig({
+        default: notificationConfig.default,
+        drivers: notificationConfig.drivers,
+    });
+};
+/**
+ * Helper: Register ConnectionManager shutdown hook
+ */
+const registerConnectionManagerHook = (shutdownManager) => {
+    shutdownManager.add(async () => {
+        try {
+            const mod = await import('../../orm/ConnectionManager.js');
+            await mod.ConnectionManager.shutdownIfInitialized();
+        }
+        catch {
+            /* ignore import failures in restrictive runtimes */
+        }
+    });
+};
+/**
+ * Helper: Register Database reset hook
+ */
+const registerDatabaseResetHook = (shutdownManager) => {
+    shutdownManager.add(async () => {
+        try {
+            const mod = await import('../../orm/Database.js');
+            mod.resetDatabase();
+        }
+        catch {
+            /* ignore import failures in restrictive runtimes */
+        }
+    });
+};
+/**
+ * Helper: Register generic reset hook for modules with reset() method
+ */
+const registerResetHook = (shutdownManager, modulePath, exportName) => {
+    shutdownManager.add(async () => {
+        try {
+            const mod = (await import(modulePath));
+            const resetModule = mod[exportName];
+            if (resetModule?.reset) {
+                resetModule.reset();
+            }
+        }
+        catch {
+            /* ignore import failures in restrictive runtimes */
+        }
+    });
+};
+/**
+ * Helper: Register FileLogWriter flush hook
+ */
+const registerFileLogFlushHook = (shutdownManager) => {
+    shutdownManager.add(async () => {
+        try {
+            const mod = await import('../../config/FileLogWriter.js');
+            mod.FileLogWriter.flush();
+        }
+        catch {
+            /* ignore import failures in restrictive runtimes */
+        }
+    });
+};
+export const registerFrameworkShutdownHooks = (shutdownManager) => {
+    // Register framework-level shutdown hooks for long-lived resources
+    registerConnectionManagerHook(shutdownManager);
+    // Ensure worker management system is asked to shutdown BEFORE databases are reset
+    registerWorkerShutdownHook(shutdownManager);
+    // Database and cache reset
+    registerDatabaseResetHook(shutdownManager);
+    registerResetHook(shutdownManager, '@cache/Cache', 'Cache');
+    // File logging
+    registerFileLogFlushHook(shutdownManager);
+    // Registry resets
+    registerResetHook(shutdownManager, '@broadcast/BroadcastRegistry', 'BroadcastRegistry');
+    registerResetHook(shutdownManager, '@storage/StorageDiskRegistry', 'StorageDiskRegistry');
+    registerResetHook(shutdownManager, '@notification/NotificationChannelRegistry', 'NotificationChannelRegistry');
+    registerResetHook(shutdownManager, '@mail/MailDriverRegistry', 'MailDriverRegistry');
+    registerResetHook(shutdownManager, '@tools/queue/Queue', 'Queue');
+};
+const initializeArtifactDirectories = async (resolvedBasePath) => {
+    if (resolvedBasePath === '')
+        return;
+    if (typeof process === 'undefined')
+        return;
+    const globalAny = globalThis;
+    if (globalAny.CF !== undefined)
+        return;
+    if (typeof globalAny.WebSocketPair === 'function')
+        return;
+    if (globalAny.caches !== undefined)
+        return;
+    let nodeFs;
+    try {
+        nodeFs = await import('../../node-singletons/fs.js');
+    }
+    catch {
+        return;
+    }
+    const dirs = ['logs', 'storage', 'tmp'];
+    for (const dir of dirs) {
+        const fullPath = path.join(resolvedBasePath, dir);
+        try {
+            if (!nodeFs.existsSync(fullPath)) {
+                nodeFs.mkdirSync(fullPath, { recursive: true });
+                Logger.info(`✓ Created directory: ${dir}`);
+            }
+        }
+        catch (error) {
+            Logger.warn(`Failed to create ${dir} directory`, error);
+        }
+    }
+};
+const extractRedisConfigFromQueueConfig = () => {
+    const redisConfig = queueConfig.drivers?.redis ?? {};
+    const redisHost = typeof redisConfig['host'] === 'string' ? redisConfig['host'] : '127.0.0.1';
+    const redisPort = typeof redisConfig['port'] === 'number' && Number.isFinite(redisConfig['port'])
+        ? redisConfig['port']
+        : 6379;
+    const redisPassword = typeof redisConfig['password'] === 'string' ? redisConfig['password'] : '';
+    const redisDb = typeof redisConfig['database'] === 'number' && Number.isFinite(redisConfig['database'])
+        ? redisConfig['database']
+        : 0;
+    return {
+        host: redisHost,
+        port: redisPort,
+        password: redisPassword,
+        db: redisDb,
+    };
+};
+const loadAndValidateQueueMonitorModule = async () => {
+    let workersModule;
+    try {
+        workersModule = (await loadQueueMonitorModule());
+    }
+    catch (error) {
+        Logger.warn('Failed to load Queue Monitor module', error);
+        return null;
+    }
+    if (!workersModule || !('QueueMonitor' in workersModule)) {
+        Logger.warn('Queue Monitor module not available');
+        return null;
+    }
+    const queueMonitorModule = workersModule;
+    const { QueueMonitor } = queueMonitorModule;
+    if (QueueMonitor === undefined || typeof QueueMonitor.create !== 'function') {
+        Logger.warn('Queue Monitor module does not expose QueueMonitor.create');
+        return null;
+    }
+    return queueMonitorModule;
+};
+const initializeQueueMonitor = async (router) => {
+    const runQueueConfig = await loadRuntimeQueueConfig();
+    const monitorConfig = runQueueConfig?.monitor;
+    if (monitorConfig === undefined) {
+        return;
+    }
+    if (monitorConfig.enabled === false) {
+        return;
+    }
+    const queueMonitorModule = await loadAndValidateQueueMonitorModule();
+    if (queueMonitorModule === null) {
+        Logger.debug('Queue Monitor is enabled in configuration but module failed to load or is invalid. Skipping Queue Monitor initialization.');
+        return;
+    }
+    const redisConfig = extractRedisConfigFromQueueConfig();
+    const { QueueMonitor } = queueMonitorModule;
+    const monitor = QueueMonitor.create({
+        ...monitorConfig,
+        redis: redisConfig,
+    });
+    try {
+        monitor.registerRoutes(router);
+    }
+    catch (error) {
+        Logger.error('Failed to register Queue Monitor routes', error);
+    }
+    Logger.info(`Queue Monitor routes registered at http://127.0.0.1:${appConfig.port}${monitorConfig.basePath ?? ''}`);
+    Logger.info(`Queue Monitor enqueue endpoint at http://127.0.0.1:${appConfig.port}/test/enqueue`);
+};
+const initializeWorkers = async (router) => {
+    const workers = await loadWorkersModule();
+    if (workers?.WorkerInit !== undefined && typeof workers.registerWorkerRoutes === 'function') {
+        workers.registerWorkerRoutes(router, undefined, { middleware: undefined });
+    }
+};
+const resolveLocalQueueRedisEntry = () => {
+    if (typeof process === 'undefined' || typeof process.cwd !== 'function')
+        return null;
+    const cwd = process.cwd();
+    if (cwd.trim() === '')
+        return null;
+    const localEntry = path.join(cwd, 'dist', 'packages', 'queue-redis', 'src', 'index.js');
+    return existsSync(localEntry) ? localEntry : null;
+};
+const loadQueueHttpGatewayModule = async () => {
+    try {
+        return (await import('@zintrust/queue-redis'));
+    }
+    catch {
+        const localEntry = resolveLocalQueueRedisEntry();
+        if (localEntry === null)
+            return undefined;
+        const url = pathToFileURL(localEntry).href;
+        return (await import(url));
+    }
+};
+const initializeQueueHttpGateway = async (router) => {
+    try {
+        const module = await loadQueueHttpGatewayModule();
+        if (module === undefined) {
+            Logger.warn('Queue HTTP gateway module is unavailable (@zintrust/queue-redis not found)');
+            return;
+        }
+        if (module.QueueHttpGateway === undefined ||
+            typeof module.QueueHttpGateway.create !== 'function') {
+            Logger.warn('Queue HTTP gateway module does not expose QueueHttpGateway.create');
+            return;
+        }
+        module.QueueHttpGateway.create().registerRoutes(router);
+        Logger.info('Queue HTTP gateway route registered at /api/_sys/queue/rpc');
+    }
+    catch (error) {
+        Logger.warn('Failed to register Queue HTTP gateway routes', error);
+    }
+};
+export const createLifecycle = (params) => {
+    const boot = async () => {
+        if (params.getBooted())
+            return;
+        Logger.info(`🚀 Booting ZinTrust Application in ${params.environment} mode...`);
+        if (params.environment === 'development') {
+            // Clear config registry cache to ensure fresh config loading in watch mode
+            // This fixes the issue where config/middleware.ts changes are ignored in watch mode
+            StartupConfigFileRegistry.clear();
+        }
+        StartupConfigValidator.assertValid();
+        // Preload project-owned config overrides that must be available synchronously.
+        await StartupConfigFileRegistry.preload([
+            StartupConfigFile.Middleware,
+            StartupConfigFile.Cache,
+            StartupConfigFile.Database,
+            StartupConfigFile.Queue,
+            StartupConfigFile.Storage,
+            StartupConfigFile.Mail,
+            StartupConfigFile.Broadcast,
+            StartupConfigFile.Notification,
+        ]);
+        FeatureFlags.initialize();
+        await StartupHealthChecks.assertHealthy();
+        await registerFromRuntimeConfig();
+        await initializeArtifactDirectories(params.resolvedBasePath);
+        await registerMasterRoutes(params.resolvedBasePath, params.router);
+        if (Cloudflare.getWorkersEnv() === null && appConfig.dockerWorker === false) {
+            await initializeWorkers(params.router);
+            await initializeQueueMonitor(params.router);
+            await initializeQueueHttpGateway(params.router);
+        }
+        // Register service providers
+        // Bootstrap services
+        Logger.info('✅ Application booted successfully');
+        params.setBooted(true);
+    };
+    const shutdown = async () => {
+        Logger.info('🛑 Shutting down application...');
+        try {
+            await params.shutdownManager.run();
+        }
+        catch (error) {
+            Logger.error('Shutdown hook failed:', error);
+        }
+        // Ensure FileLogWriter.flush is attempted even if dynamic registration failed.
+        try {
+            const fileLogWriter = await tryImportOptional('@config/FileLogWriter');
+            fileLogWriter?.FileLogWriter?.flush?.();
+        }
+        catch {
+            /* best-effort */
+        }
+        params.setBooted(false);
+        Logger.info('✅ Application shut down successfully');
+    };
+    return { boot, shutdown };
+};

package/src/boot/registry/type.d.ts

@@ -0,0 +1,25 @@
+import type { IMiddlewareStack } from '../../middleware';
+import type { IServiceContainer } from '../../container/ServiceContainer';
+import type { IRouter } from '../../routes/Router';
+export interface IApplication {
+    boot(): Promise<void>;
+    shutdown(): Promise<void>;
+    isBooted(): boolean;
+    isDevelopment(): boolean;
+    isProduction(): boolean;
+    isTesting(): boolean;
+    getEnvironment(): string;
+    getRouter(): IRouter;
+    getContainer(): IServiceContainer;
+    getMiddlewareStack(): IMiddlewareStack;
+    getBasePath(): string;
+}
+export type RoutesModule = {
+    registerRoutes?: (r: IRouter) => void;
+};
+export type ShutdownHook = () => void | Promise<void>;
+export interface IShutdownManager {
+    add(hook: ShutdownHook): void;
+    run(): Promise<void>;
+}
+//# sourceMappingURL=type.d.ts.map

package/src/boot/registry/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,WAAW,YAAY;IAC3B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1B,QAAQ,IAAI,OAAO,CAAC;IACpB,aAAa,IAAI,OAAO,CAAC;IACzB,YAAY,IAAI,OAAO,CAAC;IACxB,SAAS,IAAI,OAAO,CAAC;IACrB,cAAc,IAAI,MAAM,CAAC;IACzB,SAAS,IAAI,OAAO,CAAC;IACrB,YAAY,IAAI,iBAAiB,CAAC;IAClC,kBAAkB,IAAI,gBAAgB,CAAC;IACvC,WAAW,IAAI,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,YAAY,GAAG;IAAE,cAAc,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAA;CAAE,CAAC;AAErE,MAAM,MAAM,YAAY,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAAC;IAC9B,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB"}

package/src/boot/registry/type.js

@@ -0,0 +1 @@
+export {};

package/src/boot/registry/worker.d.ts

@@ -0,0 +1,6 @@
+import type { IShutdownManager } from './type';
+/**
+ * Helper: Register Worker management system shutdown hook
+ */
+export declare const registerWorkerShutdownHook: (shutdownManager: IShutdownManager) => Promise<void>;
+//# sourceMappingURL=worker.d.ts.map

package/src/boot/registry/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../../../../src/boot/registry/worker.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAGvD;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACrC,iBAAiB,gBAAgB,KAChC,OAAO,CAAC,IAAI,CA0Cd,CAAC"}

package/src/boot/registry/worker.js

@@ -0,0 +1,35 @@
+import { appConfig } from '../../config/app.js';
+import { Env } from '../../config/env.js';
+import { loadWorkersModule } from '../../runtime/WorkersModule.js';
+/**
+ * Helper: Register Worker management system shutdown hook
+ */
+export const registerWorkerShutdownHook = async (shutdownManager) => {
+    if (Env.getBool('WORKER_SHUTDOWN_ON_APP_EXIT', true) === false ||
+        appConfig.dockerWorker === true) {
+        return Promise.resolve(); // NOSONAR - Skip worker shutdown hook registration
+    }
+    // Ensure worker management system is asked to shutdown BEFORE databases are reset.
+    // This prevents workers from trying to access DB connections that have already
+    // been closed by subsequent shutdown hooks.
+    shutdownManager.add(async () => {
+        try {
+            const mod = (await loadWorkersModule());
+            const isShuttingDown = typeof mod.WorkerShutdown.isShuttingDown === 'function'
+                ? mod.WorkerShutdown.isShuttingDown()
+                : (mod.WorkerShutdown.getShutdownState?.().isShuttingDown ?? false);
+            const completedAt = mod.WorkerShutdown.getShutdownState?.().completedAt ?? null;
+            if (isShuttingDown || completedAt !== null)
+                return;
+            await mod.WorkerShutdown.shutdown({
+                signal: 'APP_SHUTDOWN',
+                timeout: 5000,
+                forceExit: false,
+            });
+        }
+        catch {
+            /* ignore import failures in restrictive runtimes */
+        }
+    });
+    return Promise.resolve(); // NOSONAR
+};

package/src/cache/drivers/KVRemoteDriver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"KVRemoteDriver.d.ts","sourceRoot":"","sources":["../../../../src/cache/drivers/KVRemoteDriver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAsBtD,eAAO,MAAM,cAAc;cACf,WAAW;EAiErB,CAAC;AAEH,eAAe,cAAc,CAAC"}
+{"version":3,"file":"KVRemoteDriver.d.ts","sourceRoot":"","sources":["../../../../src/cache/drivers/KVRemoteDriver.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAiCtD,eAAO,MAAM,cAAc;cACf,WAAW;EAkErB,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/src/cache/drivers/KVRemoteDriver.js

@@ -6,13 +6,25 @@
 import { RemoteSignedJson } from '../../common/RemoteSignedJson.js';
 import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
+const resolveSigningPrefix = (baseUrl) => {
+    try {
+        const parsed = new URL(baseUrl);
+        const path = parsed.pathname.endsWith('/') ? parsed.pathname.slice(0, -1) : parsed.pathname;
+        if (path === '' || path === '/')
+            return undefined;
+        return path;
+    }
+    catch {
+        return undefined;
+    }
+};
 const normalizeNamespace = (defaultNamespace) => defaultNamespace.trim() === '' ? undefined : defaultNamespace;
 export const KVRemoteDriver = Object.freeze({
     create() {
         const settings = {
             baseUrl: Env.get('KV_REMOTE_URL'),
             keyId: Env.get('KV_REMOTE_KEY_ID'),
-            secret: Env.get('KV_REMOTE_SECRET'),
+            secret: Env.get('KV_REMOTE_SECRET', Env.APP_KEY),
             defaultNamespace: Env.get('KV_REMOTE_NAMESPACE'),
             timeoutMs: Env.getInt('ZT_PROXY_TIMEOUT_MS', Env.REQUEST_TIMEOUT),
         };
@@ -21,6 +33,7 @@ export const KVRemoteDriver = Object.freeze({
             keyId: settings.keyId,
             secret: settings.secret,
             timeoutMs: settings.timeoutMs,
+            signaturePathPrefixToStrip: resolveSigningPrefix(settings.baseUrl),
             missingUrlMessage: 'KV remote proxy URL is missing (KV_REMOTE_URL)',
             missingCredentialsMessage: 'KV remote signing credentials are missing (KV_REMOTE_KEY_ID / KV_REMOTE_SECRET)',
             messages: {

package/src/cli/CLI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CLI.d.ts","sourceRoot":"","sources":["../../../src/cli/CLI.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA0CH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,MAAM,WAAW,IAAI;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,IAAI,OAAO,CAAC;CACvB;AA2MD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}
+{"version":3,"file":"CLI.d.ts","sourceRoot":"","sources":["../../../src/cli/CLI.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA2DH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,MAAM,WAAW,IAAI;IACnB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnC,UAAU,IAAI,OAAO,CAAC;CACvB;AAiPD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}

package/src/cli/CLI.js

@@ -5,28 +5,45 @@
 import { AddCommand } from './commands/AddCommand.js';
 import { BroadcastWorkCommand } from './commands/BroadcastWorkCommand.js';
 import { ConfigCommand } from './commands/ConfigCommand.js';
+import { ContainerProxiesCommand } from './commands/ContainerProxiesCommand.js';
+import { ContainerWorkersCommand } from './commands/ContainerWorkersCommand.js';
 import { AddMigrationCommand, CreateCommand, CreateMigrationCommand, } from './commands/CreateCommand.js';
 import { D1MigrateCommand } from './commands/D1MigrateCommand.js';
 import { DbSeedCommand } from './commands/DbSeedCommand.js';
 import { DebugCommand } from './commands/DebugCommand.js';
+import { DeployCommand } from './commands/DeployCommand.js';
+import { DeployContainerProxiesCommand } from './commands/DeployContainerProxiesCommand.js';
+import { DeployContainerWorkersCommand } from './commands/DeployContainerWorkersCommand.js';
+import { DoctorArchitectureCommand } from './commands/DoctorArchitectureCommand.js';
 import { FixCommand } from './commands/FixCommand.js';
+import { InitContainerCommand } from './commands/InitContainerCommand.js';
+import { InitProducerCommand } from './commands/InitProducerCommand.js';
+import { InitProxyCommand } from './commands/InitProxyCommand.js';
 import { JwtDevCommand } from './commands/JwtDevCommand.js';
 import { KeyGenerateCommand } from './commands/KeyGenerateCommand.js';
 import { MakeMailTemplateCommand } from './commands/MakeMailTemplateCommand.js';
 import { MakeNotificationTemplateCommand } from './commands/MakeNotificationTemplateCommand.js';
 import { MigrateCommand } from './commands/MigrateCommand.js';
 import { MigrateWorkerCommand } from './commands/MigrateWorkerCommand.js';
+import { MongoDBProxyCommand } from './commands/MongoDBProxyCommand.js';
+import { MySqlProxyCommand } from './commands/MySqlProxyCommand.js';
 import { NewCommand } from './commands/NewCommand.js';
 import { NotificationWorkCommand } from './commands/NotificationWorkCommand.js';
 import { PluginCommand } from './commands/PluginCommand.js';
+import { PostgresProxyCommand } from './commands/PostgresProxyCommand.js';
 import { PrepareCommand } from './commands/PrepareCommand.js';
+import { ProxyCommand } from './commands/ProxyCommand.js';
 import { PublishCommand } from './commands/PublishCommand.js';
 import { QACommand } from './commands/QACommand.js';
 import { QueueCommand } from './commands/QueueCommand.js';
+import { QueueRecoveryCommand } from './commands/QueueRecoveryCommand.js';
+import { RedisProxyCommand } from './commands/RedisProxyCommand.js';
 import { ResourceControlCommand } from './commands/ResourceControlCommand.js';
 import { RoutesCommand } from './commands/RoutesCommand.js';
 import { SecretsCommand } from './commands/SecretsCommand.js';
 import { SimulateCommand } from './commands/SimulateCommand.js';
+import { SmtpProxyCommand } from './commands/SmtpProxyCommand.js';
+import { SqlServerProxyCommand } from './commands/SqlServerProxyCommand.js';
 import { StartCommand } from './commands/StartCommand.js';
 import { TemplatesCommand } from './commands/TemplatesCommand.js';
 import { UpgradeCommand } from './commands/UpgradeCommand.js';
@@ -40,48 +57,28 @@ import { readFileSync } from '../node-singletons/fs.js';
 import { join } from '../node-singletons/path.js';
 import { Command } from 'commander';
 const __dirname = esmDirname(import.meta.url);
-/**
- * Load version from package.json
- */
-const loadVersion = () => {
-    try {
-        const packagePath = join(__dirname, '../../package.json');
-        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
-        return typeof packageJson.version === 'string' ? packageJson.version : '1.0.0';
-    }
-    catch (error) {
-        ErrorFactory.createCliError('Failed to load version from package.json', error);
-        // Use default version if package.json not found
-        return '1.0.0';
-    }
-};
-/**
- * Setup program metadata
- */
-const setupProgram = (program, version) => {
-    program
-        .name('zintrust')
-        .description('ZinTrust Framework CLI - Build production-grade TypeScript APIs')
-        .version(version, '-v, --version', 'Output version number')
-        .helpOption('-h, --help', 'Display help for command')
-        .usage('[command] [options]');
-    // Global error handling
-    program.exitOverride();
+const isCommandProvider = (command) => {
+    return (typeof command === 'object' &&
+        command !== null &&
+        'getCommand' in command &&
+        typeof command.getCommand === 'function');
 };
-/**
- * Register all available commands
- */
-const registerCommands = (program) => {
-    const commands = [
+const buildCommandRegistry = () => {
+    return [
         NewCommand.create(),
         UpgradeCommand.create(),
         PrepareCommand,
+        InitContainerCommand.create(),
+        InitProxyCommand.create(),
+        InitProducerCommand.create(),
+        DoctorArchitectureCommand.create(),
         AddCommand.create(),
         CreateCommand.create(),
         CreateMigrationCommand.create(),
         AddMigrationCommand.create(),
         StartCommand.create(),
         QueueCommand.create(),
+        QueueRecoveryCommand.create(),
         BroadcastWorkCommand.create(),
         NotificationWorkCommand.create(),
         ResourceControlCommand,
@@ -92,8 +89,13 @@ const registerCommands = (program) => {
         DebugCommand.create(),
         SecretsCommand.create(),
         ConfigCommand.create(),
+        ContainerWorkersCommand.create(),
+        ContainerProxiesCommand.create(),
         PluginCommand.create(),
         PublishCommand.create(),
+        DeployCommand.create(),
+        DeployContainerWorkersCommand.create(),
+        DeployContainerProxiesCommand.create(),
         QACommand(),
         FixCommand.create(),
         KeyGenerateCommand.create(),
@@ -103,16 +105,62 @@ const registerCommands = (program) => {
         MakeNotificationTemplateCommand.create(),
         RoutesCommand.create(),
         JwtDevCommand,
-        // Worker management commands
+        ProxyCommand.create(),
+        MySqlProxyCommand.create(),
+        PostgresProxyCommand.create(),
+        MongoDBProxyCommand.create(),
+        SqlServerProxyCommand.create(),
+        RedisProxyCommand.create(),
+        SmtpProxyCommand.create(),
         WorkerCommands.createWorkerListCommand(),
         WorkerCommands.createWorkerStatusCommand(),
         WorkerCommands.createWorkerStartCommand(),
+        WorkerCommands.createWorkerStartAllCommand(),
         WorkerCommands.createWorkerStopCommand(),
         WorkerCommands.createWorkerRestartCommand(),
         WorkerCommands.createWorkerSummaryCommand(),
     ];
+};
+/**
+ * Load version from package.json
+ */
+const loadVersion = () => {
+    try {
+        const packagePath = join(__dirname, '../../package.json');
+        const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+        return typeof packageJson.version === 'string' ? packageJson.version : '1.0.0';
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Failed to load version from package.json', error);
+        // Use default version if package.json not found
+        return '1.0.0';
+    }
+};
+/**
+ * Setup program metadata
+ */
+const setupProgram = (program, version) => {
+    program
+        .name('zintrust')
+        .description('ZinTrust Framework CLI - Build production-grade TypeScript APIs')
+        .version(version, '-v, --version', 'Output version number')
+        .helpOption('-h, --help', 'Display help for command')
+        .usage('[command] [options]');
+    // Global error handling
+    program.exitOverride();
+};
+/**
+ * Register all available commands
+ */
+const registerCommands = (program) => {
+    const commands = buildCommandRegistry();
     for (const command of commands) {
-        program.addCommand(command.getCommand());
+        if (isCommandProvider(command)) {
+            program.addCommand(command.getCommand());
+        }
+        else {
+            program.addCommand(command);
+        }
     }
     // Help command
     program

package/src/cli/ErrorHandler.js

@@ -46,7 +46,7 @@ const displayBanner = (version) => {
     const framework = 'ZinTrust Framework';
     const bannerWidth = 46;
     const env = Env.NODE_ENV ?? 'development';
-    const db = Env.DB_CONNECTION ?? 'sqlite';
+    const db = Env.DB_CONNECTION || 'sqlite';
     const border = chalk.cyanBright;
     const label = chalk.bold.white;
     const frameworkValue = chalk.bold.cyanBright;