@zintrust/core 0.1.23 → 0.1.25

package/src/cli/commands/QueueCommand.js

@@ -3,8 +3,93 @@
  * Run queued jobs via the framework CLI.
  */
 import { BaseCommand } from '../BaseCommand.js';
+import { setupQueueLockCommands } from '../commands/QueueLockCommand.js';
 import { QueueWorkCommandUtils } from '../commands/QueueWorkCommandUtils.js';
 import { QueueWorkRunner } from '../workers/QueueWorkRunner.js';
+/**
+ * Setup work subcommand with explicit kind
+ */
+const setupWorkCommand = (command) => {
+    command
+        .command('work <kind> <queueName>')
+        .alias('w')
+        .description('Work a queue with explicit kind (broadcast|notification)')
+        .option('--timeout <seconds>', 'Stop after this many seconds (default: 10)')
+        .option('--retry <count>', 'Retries after first attempt (default: 3)')
+        .option('--max-items <count>', 'Max items to process in one run (default: 1000)')
+        .option('--driver <name>', 'Queue driver name (default: from QUEUE_DRIVER)')
+        .action(async (kindRaw, queueName, subOptions) => {
+        const kind = QueueWorkRunner.parseKind(kindRaw);
+        const timeoutSeconds = QueueWorkCommandUtils.parsePositiveInt(subOptions['timeout'], '--timeout');
+        const retry = QueueWorkCommandUtils.parseNonNegativeInt(subOptions['retry'], '--retry');
+        const maxItems = QueueWorkCommandUtils.parsePositiveInt(subOptions['maxItems'], '--max-items');
+        const driverName = QueueWorkCommandUtils.normalizeDriverName(subOptions['driver']);
+        const result = await QueueWorkRunner.run({
+            kind,
+            queueName,
+            timeoutSeconds,
+            retry,
+            maxItems,
+            driverName,
+        });
+        QueueWorkCommandUtils.logSummary(queueName, kind, result);
+    });
+};
+/**
+ * Setup prune subcommand
+ */
+const setupPruneCommand = (command) => {
+    command
+        .command('prune')
+        .description('Prune failed jobs from the database queue')
+        .option('--hours <count>', 'Prune jobs older than this many hours (default: 168)', '168')
+        .action(async (options) => {
+        const { Logger } = await import('../../config/logger.js');
+        const { QueryBuilder } = await import('../../orm/QueryBuilder.js');
+        const { useEnsureDbConnected } = await import('../../orm/Database.js');
+        const { databaseConfig } = await import('../../config/database.js');
+        const hours = Number.parseInt(options.hours ?? '168', 10);
+        const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000);
+        Logger.info(`[Queue] Pruning failed jobs older than ${cutoff.toISOString()}...`);
+        try {
+            // Resolved connection config (Queue prune usually runs on default DB)
+            const config = databaseConfig.getConnection();
+            const db = await useEnsureDbConnected(config);
+            const deleted = await QueryBuilder.create('queue_jobs_failed', db)
+                .where('failed_at', '<', cutoff)
+                .delete();
+            Logger.info(`[Queue] Pruned ${deleted} failed jobs.`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (msg.includes('no such table')) {
+                Logger.warn('[Queue] Table queue_jobs_failed not found. Skipping prune.');
+            }
+            else {
+                Logger.error('[Queue] Prune failed', err);
+                process.exit(1);
+            }
+        }
+    });
+};
+/**
+ * Parse command options and run queue work
+ */
+const executeQueueWork = async (options) => {
+    const queueName = QueueWorkCommandUtils.requireQueueNameFromArgs(options.args, 'zin queue --help');
+    const timeoutSeconds = QueueWorkCommandUtils.parsePositiveInt(options.timeout, '--timeout');
+    const retry = QueueWorkCommandUtils.parseNonNegativeInt(options.retry, '--retry');
+    const maxItems = QueueWorkCommandUtils.parsePositiveInt(options.maxItems, '--max-items');
+    const driverName = QueueWorkCommandUtils.normalizeDriverName(options.driver);
+    const result = await QueueWorkRunner.run({
+        queueName,
+        timeoutSeconds,
+        retry,
+        maxItems,
+        driverName,
+    });
+    QueueWorkCommandUtils.logSummary(queueName, 'auto', result);
+};
 export const QueueCommand = Object.freeze({
     create() {
         return BaseCommand.create({
@@ -17,46 +102,11 @@ export const QueueCommand = Object.freeze({
                     .option('--retry <count>', 'Retries after first attempt (default: 3)')
                     .option('--max-items <count>', 'Max items to process in one run (default: 1000)')
                     .option('--driver <name>', 'Queue driver name (default: from QUEUE_DRIVER)');
-                command
-                    .command('work <kind> <queueName>')
-                    .alias('w')
-                    .description('Work a queue with explicit kind (broadcast|notification)')
-                    .option('--timeout <seconds>', 'Stop after this many seconds (default: 10)')
-                    .option('--retry <count>', 'Retries after first attempt (default: 3)')
-                    .option('--max-items <count>', 'Max items to process in one run (default: 1000)')
-                    .option('--driver <name>', 'Queue driver name (default: from QUEUE_DRIVER)')
-                    .action(async (kindRaw, queueName, subOptions) => {
-                    const kind = QueueWorkRunner.parseKind(kindRaw);
-                    const timeoutSeconds = QueueWorkCommandUtils.parsePositiveInt(subOptions['timeout'], '--timeout');
-                    const retry = QueueWorkCommandUtils.parseNonNegativeInt(subOptions['retry'], '--retry');
-                    const maxItems = QueueWorkCommandUtils.parsePositiveInt(subOptions['maxItems'], '--max-items');
-                    const driverName = QueueWorkCommandUtils.normalizeDriverName(subOptions['driver']);
-                    const result = await QueueWorkRunner.run({
-                        kind,
-                        queueName,
-                        timeoutSeconds,
-                        retry,
-                        maxItems,
-                        driverName,
-                    });
-                    QueueWorkCommandUtils.logSummary(queueName, kind, result);
-                });
-            },
-            execute: async (options) => {
-                const queueName = QueueWorkCommandUtils.requireQueueNameFromArgs(options.args, 'zin queue --help');
-                const timeoutSeconds = QueueWorkCommandUtils.parsePositiveInt(options.timeout, '--timeout');
-                const retry = QueueWorkCommandUtils.parseNonNegativeInt(options.retry, '--retry');
-                const maxItems = QueueWorkCommandUtils.parsePositiveInt(options.maxItems, '--max-items');
-                const driverName = QueueWorkCommandUtils.normalizeDriverName(options.driver);
-                const result = await QueueWorkRunner.run({
-                    queueName,
-                    timeoutSeconds,
-                    retry,
-                    maxItems,
-                    driverName,
-                });
-                QueueWorkCommandUtils.logSummary(queueName, 'auto', result);
+                setupWorkCommand(command);
+                setupPruneCommand(command);
+                setupQueueLockCommands(command);
             },
+            execute: executeQueueWork,
         });
     },
 });

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

@@ -0,0 +1,7 @@
+/**
+ * Queue Lock Command Extensions
+ * Implements CLI commands for managing queue locks and deduplication
+ */
+import type { Command } from 'commander';
+export declare function setupQueueLockCommands(command: Command): void;
+//# sourceMappingURL=QueueLockCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"QueueLockCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/QueueLockCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2IzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAK7D"}

package/src/cli/commands/QueueLockCommand.js

@@ -0,0 +1,138 @@
+/**
+ * Queue Lock Command Extensions
+ * Implements CLI commands for managing queue locks and deduplication
+ */
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ZintrustLang } from '../../lang/lang.js';
+import { Logger } from '../../config/logger.js';
+import { createAdvancedQueue } from '../../tools/queue/AdvancedQueue.js';
+import { getLockProvider } from '../../tools/queue/LockProvider.js';
+// Reusing initialization logic from AdvancedQueue
+// But we need direct access to lock provider for maintenance
+// AdvancedQueue only exposes limited interface
+function getProvider(providerName = 'redis') {
+    // Create proper QueueConfig object that matches the expected interface
+    const advancedQueueConfig = {
+        name: ZintrustLang.CLI_LOCKS,
+        connection: undefined, // No specific connection needed for CLI operations
+        defaultDedupTtl: ZintrustLang.ZINTRUST_LOCKS_TTL,
+        lockProvider: providerName,
+    };
+    // Need to ensure provider is registered. creating AdvancedQueue triggers registration.
+    createAdvancedQueue(advancedQueueConfig);
+    const provider = getLockProvider(providerName);
+    if (!provider) {
+        throw ErrorFactory.createCliError(`Lock provider '${providerName}' not found.`);
+    }
+    return provider;
+}
+const setupLockListCommand = (command) => {
+    command
+        .command('lock:list')
+        .description('List active deduplication locks')
+        .option('--pattern <pattern>', 'Key pattern to match (default: *)', '*')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (options) => {
+        try {
+            const provider = getProvider(options.provider);
+            const locks = await provider.list(options?.pattern ?? '*');
+            if (locks.length === 0) {
+                Logger.info('No locks found.');
+                return;
+            }
+            Logger.info(`Found ${locks.length} locks:`);
+            // Batch all status checks for better performance
+            const statusPromises = locks.map(async (key) => {
+                const status = await provider.status(key);
+                const expires = status.expires ? status.expires.toISOString() : 'never';
+                const ttl = typeof status.ttl === 'number' ? `${Math.round(status.ttl / 1000)}s` : 'unknown';
+                return { key, ttl, expires };
+            });
+            const lockStatuses = await Promise.all(statusPromises);
+            for (const { key, ttl, expires } of lockStatuses) {
+                Logger.info(`- [${key}] (TTL: ${ttl}, Expires: ${expires})`);
+            }
+        }
+        catch (error) {
+            Logger.error('Failed to list locks', error);
+        }
+    });
+};
+const setupLockReleaseCommand = (command) => {
+    command
+        .command('lock:release <key>')
+        .description('Manually release a deduplication lock')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (key, options) => {
+        try {
+            const provider = getProvider(options.provider);
+            const status = await provider.status(key);
+            if (!status.exists) {
+                Logger.info(`Lock '${key}' does not exist.`);
+                return;
+            }
+            await provider.release({ key, ttl: 0, acquired: true, expires: new Date() });
+            Logger.info(`Lock '${key}' released successfully.`);
+        }
+        catch (error) {
+            Logger.error(`Failed to release lock ${key}`, error);
+        }
+    });
+};
+const setupLockExtendCommand = (command) => {
+    command
+        .command('lock:extend <key> <seconds>')
+        .description('Extend TTL of an existing lock')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (key, seconds, options) => {
+        try {
+            const ttl = Number.parseInt(seconds, 10) * 1000;
+            const provider = getProvider(options.provider);
+            // Mock lock object for extension
+            const lock = { key, ttl: 0, acquired: true, expires: new Date() };
+            const extended = await provider.extend(lock, ttl);
+            if (extended) {
+                Logger.info(`Lock '${key}' extended by ${seconds} seconds.`);
+            }
+            else {
+                Logger.info(`Failed to extend lock '${key}' (may not exist).`);
+            }
+        }
+        catch (error) {
+            Logger.error(`Failed to extend lock ${key}`, error);
+        }
+    });
+};
+const setupDedupeStatusCommand = (command) => {
+    command
+        .command('dedupe:status <id>')
+        .description('Check deduplication status of a job ID')
+        .option('--provider <name>', 'Lock provider name (default: redis)', 'redis')
+        .action(async (id, options) => {
+        try {
+            const provider = getProvider(options.provider);
+            const status = await provider.status(id);
+            if (status.exists) {
+                Logger.info(`Job ID '${id}' is currently LOCKED (Deduplicated).`);
+                const ttlMs = status.ttl;
+                const ttlSeconds = ttlMs !== null && ttlMs !== undefined && !Number.isNaN(ttlMs) && ttlMs > 0
+                    ? Math.round(ttlMs / 1000) + 's'
+                    : 'unknown';
+                Logger.info(`TTL Remaining: ${ttlSeconds}`);
+                Logger.info(`Expires At: ${status.expires ? status.expires.toISOString() : 'unknown'}`);
+            }
+            else {
+                Logger.info(`Job ID '${id}' is NOT locked (Ready for processing or expired).`);
+            }
+        }
+        catch (error) {
+            Logger.error(`Failed to check status for ${id}`, error);
+        }
+    });
+};
+export function setupQueueLockCommands(command) {
+    setupLockListCommand(command);
+    setupLockReleaseCommand(command);
+    setupLockExtendCommand(command);
+    setupDedupeStatusCommand(command);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAoavF,eAAO,MAAM,YAAY;cACb,YAAY;EAyBtB,CAAC"}
+{"version":3,"file":"StartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/StartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAqavF,eAAO,MAAM,YAAY;cACb,YAAY;EAyBtB,CAAC"}

package/src/cli/commands/StartCommand.js

@@ -2,8 +2,8 @@ import { BaseCommand } from '../BaseCommand.js';
 import { DENO_RUNNER_SOURCE, LAMBDA_RUNNER_SOURCE } from '../commands/runner/index.js';
 import { EnvFileLoader } from '../utils/EnvFileLoader.js';
 import { SpawnUtil } from '../utils/spawn.js';
+import { readEnvString } from '../../common/ExternalServiceUtils.js';
 import { resolveNpmPath } from '../../common/index.js';
-import { Env } from '../../config/env.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from '../../node-singletons/fs.js';
 import * as path from '../../node-singletons/path.js';
@@ -20,18 +20,6 @@ const normalizeMode = (value) => {
         return 'testing';
     return 'development';
 };
-const readEnvString = (key) => {
-    const anyEnv = Env;
-    const fromEnv = typeof anyEnv.get === 'function' ? anyEnv.get(key, '') : '';
-    if (typeof fromEnv === 'string' && fromEnv.trim() !== '')
-        return fromEnv;
-    if (typeof process !== 'undefined') {
-        const raw = process.env?.[key];
-        if (typeof raw === 'string')
-            return raw;
-    }
-    return fromEnv ?? '';
-};
 const resolveModeFromAppMode = () => {
     const raw = readEnvString('APP_MODE').trim();
     const normalized = raw.toLowerCase();
@@ -258,18 +246,30 @@ const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
             cmd.warn('Watch mode disabled; starting once.');
             const bootstrap = resolveBootstrapEntryTs(cwd);
             const args = bootstrap === undefined ? ['src/index.ts'] : [bootstrap];
-            const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args });
+            const exitCode = await SpawnUtil.spawnAndWait({
+                command: 'tsx',
+                args,
+                forwardSignals: false,
+            });
             process.exit(exitCode);
         }
         const packageJson = readPackageJson(cwd);
         const dev = resolveNodeDevCommand(cwd, packageJson);
         cmd.info('Starting in development mode (watch enabled)...');
-        const exitCode = await SpawnUtil.spawnAndWait({ command: dev.command, args: dev.args });
+        const exitCode = await SpawnUtil.spawnAndWait({
+            command: dev.command,
+            args: dev.args,
+            forwardSignals: false,
+        });
         process.exit(exitCode);
     }
     const prod = resolveNodeProdCommand(cwd);
     cmd.info('Starting in production mode...');
-    const exitCode = await SpawnUtil.spawnAndWait({ command: prod.command, args: prod.args });
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: prod.command,
+        args: prod.args,
+        forwardSignals: false,
+    });
     process.exit(exitCode);
 };
 const executeStart = async (options, cmd) => {

package/src/cli/commands/TemplatesCommand.js

@@ -1,7 +1,7 @@
 import { BaseCommand } from '../BaseCommand.js';
 import { ErrorHandler } from '../ErrorHandler.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
-import { listTemplates as listMail, renderTemplate as renderMail } from '../../tools/mail/templates/markdown/index.js';
+import { listTemplates as listMail, renderTemplate as renderMail } from '../../tools/mail/templates/index.js';
 import { listTemplates as listNotification, renderTemplate as renderNotification, } from '../../tools/notification/templates/markdown/index.js';
 const listForScope = (scope) => {
     let items = [];

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

@@ -1 +1 @@
-{"version":3,"file":"WorkerCommands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/WorkerCommands.ts"],"names":[],"mappings":"AACA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0UrD;;GAEG;AACH,eAAO,MAAM,cAAc;mCAhPS,YAAY;qCA2CV,YAAY;oCAiDb,YAAY;mCA+Bb,YAAY;sCAgCT,YAAY;sCAgCZ,YAAY;CA4DlD,CAAC"}
+{"version":3,"file":"WorkerCommands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/WorkerCommands.ts"],"names":[],"mappings":"AACA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmWrD;;GAEG;AACH,eAAO,MAAM,cAAc;mCAjPS,YAAY;qCA4CV,YAAY;oCAiDb,YAAY;mCA+Bb,YAAY;sCAgCT,YAAY;sCAgCZ,YAAY;CA4DlD,CAAC"}

package/src/cli/commands/WorkerCommands.js

@@ -3,28 +3,51 @@
  * Worker Management CLI Commands
  * Command-line interface for managing workers
  */
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { BaseCommand } from '../BaseCommand.js';
 import { Logger } from '../../config/logger.js';
-import { HealthMonitor as HealthMonitorAny, ResourceMonitor as ResourceMonitorAny, WorkerFactory as WorkerFactoryAny, WorkerRegistry as WorkerRegistryAny, } from '../../../packages/workers/src/index.js';
 // Lazy initialization to prevent temporal dead zone issues
 let WorkerFactory;
 let WorkerRegistry;
 let HealthMonitor;
 let ResourceMonitor;
-const getWorkerFactory = () => {
-    WorkerFactory ??= WorkerFactoryAny;
+let workersModulePromise;
+const loadWorkersModule = async () => {
+    workersModulePromise ??= import('../../../packages/workers/src/index.js');
+    try {
+        return await workersModulePromise;
+    }
+    catch (error) {
+        Logger.error('Failed to load optional package "@zintrust/workers"; worker commands require this package.', error);
+        throw ErrorFactory.createCliError('Optional package "@zintrust/workers" is required for worker commands. Install it to use worker:* commands.');
+    }
+};
+const getWorkerFactory = async () => {
+    if (!WorkerFactory) {
+        const mod = await loadWorkersModule();
+        WorkerFactory = mod.WorkerFactory;
+    }
     return WorkerFactory;
 };
-const getWorkerRegistry = () => {
-    WorkerRegistry ??= WorkerRegistryAny;
+const getWorkerRegistry = async () => {
+    if (!WorkerRegistry) {
+        const mod = await loadWorkersModule();
+        WorkerRegistry = mod.WorkerRegistry;
+    }
     return WorkerRegistry;
 };
-const getHealthMonitor = () => {
-    HealthMonitor ??= HealthMonitorAny;
+const getHealthMonitor = async () => {
+    if (!HealthMonitor) {
+        const mod = await loadWorkersModule();
+        HealthMonitor = mod.HealthMonitor;
+    }
     return HealthMonitor;
 };
-const getResourceMonitor = () => {
-    ResourceMonitor ??= ResourceMonitorAny;
+const getResourceMonitor = async () => {
+    if (!ResourceMonitor) {
+        const mod = await loadWorkersModule();
+        ResourceMonitor = mod.ResourceMonitor;
+    }
     return ResourceMonitor;
 };
 /**
@@ -46,14 +69,15 @@ const formatTable = (headers, rows) => {
 const createWorkerListCommand = () => {
     const ext = async () => {
         try {
-            const workers = await getWorkerFactory().listPersisted();
+            const workers = await (await getWorkerFactory()).listPersisted();
             console.log(`\nTotal Workers: ${workers.length}\n`);
             if (workers.length === 0) {
                 console.log('No workers found.');
                 return;
             }
+            const registry = await getWorkerRegistry();
             const rows = workers.map((name) => {
-                const status = getWorkerRegistry().status(name);
+                const status = registry.status(name);
                 return [
                     name,
                     status?.status ?? 'unknown',
@@ -87,12 +111,12 @@ const createWorkerStatusCommand = () => {
                 Logger.error('Error: Worker name is required');
                 process.exit(1);
             }
-            const status = getWorkerRegistry().status(name);
-            const health = await getWorkerFactory().getHealth(name);
+            const status = (await getWorkerRegistry()).status(name);
+            const health = await (await getWorkerFactory()).getHealth(name);
             const healthData = typeof health === 'object' && health !== null
                 ? health
                 : {};
-            const metrics = await getWorkerFactory().getMetrics(name);
+            const metrics = await (await getWorkerFactory()).getMetrics(name);
             console.log(`\n=== Worker: ${name} ===\n`);
             console.log(`Status: ${status?.status}`);
             console.log(`Version: ${status?.version}`);
@@ -131,7 +155,7 @@ const createWorkerStartCommand = () => {
                 Logger.error('Error: Worker name is required');
                 process.exit(1);
             }
-            await getWorkerFactory().start(name);
+            await (await getWorkerFactory()).start(name);
             Logger.info(`✓ Worker "${name}" started successfully`);
         }
         catch (error) {
@@ -159,7 +183,7 @@ const createWorkerStopCommand = () => {
                 console.error('Error: Worker name is required');
                 process.exit(1);
             }
-            await getWorkerFactory().stop(name);
+            await (await getWorkerFactory()).stop(name);
             console.log(`✓ Worker "${name}" stopped successfully`);
         }
         catch (error) {
@@ -188,7 +212,7 @@ const createWorkerRestartCommand = () => {
                 console.error('Error: Worker name is required');
                 process.exit(1);
             }
-            await getWorkerFactory().restart(name);
+            await (await getWorkerFactory()).restart(name);
             console.log(`✓ Worker "${name}" restarted successfully`);
         }
         catch (error) {
@@ -211,11 +235,11 @@ const createWorkerRestartCommand = () => {
  * Worker Summary Command
  */
 const createWorkerSummaryCommand = () => {
-    const ext = () => {
+    const ext = async () => {
         try {
-            const workers = getWorkerFactory().list();
-            const monitoringSummary = getHealthMonitor().getSummary();
-            const resourceUsage = getResourceMonitor().getCurrentUsage('system');
+            const workers = (await getWorkerFactory()).list();
+            const monitoringSummary = (await getHealthMonitor()).getSummary();
+            const resourceUsage = (await getResourceMonitor()).getCurrentUsage('system');
             console.log(`\n=== Worker System Summary ===\n`);
             console.log(`Total Workers: ${workers.length}`);
             console.log(`\nHealth Overview:`);
@@ -247,7 +271,7 @@ const createWorkerSummaryCommand = () => {
     const cmd = BaseCommand.create({
         name: 'worker:summary',
         description: 'Get system-wide worker summary',
-        execute: () => ext(),
+        execute: async () => ext(),
     });
     return cmd;
 };

package/src/cli/scaffolding/ProjectScaffolder.js

@@ -199,8 +199,8 @@ const createEnvFile = (projectPath, variables) => {
             '',
             '# Logging',
             'LOG_LEVEL=debug',
-            'LOG_CHANNEL=console',
-            'LOG_FORMAT=json',
+            'LOG_CHANNEL=file',
+            'LOG_FORMAT=text',
             '',
             '# Auth / Security',
             'JWT_SECRET=',

package/src/cli/scaffolding/RouteGenerator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RouteGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/RouteGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAuBD,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAqB3F;AAED;;GAEG;AAEH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA4CnF;AA+LD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,EAAE,CAsCpD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,eAAe,EAAE,CA6BjD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,eAAe,EAAE,CA+BlD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;EAOzB,CAAC"}
+{"version":3,"file":"RouteGenerator.d.ts","sourceRoot":"","sources":["../../../../src/cli/scaffolding/RouteGenerator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEnF,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;CACnB;AAuBD,MAAM,WAAW,YAAY;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAqB3F;AAED;;GAEG;AAEH,wBAAgB,cAAc,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA4CnF;AA4LD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,EAAE,CAsCpD;AAED;;GAEG;AACH,wBAAgB,aAAa,IAAI,eAAe,EAAE,CA6BjD;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,eAAe,EAAE,CA+BlD;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,WAAW,EAAE,CAEhD;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;;;;;;;EAOzB,CAAC"}

package/src/cli/scaffolding/RouteGenerator.js

@@ -8,21 +8,21 @@ import * as path from '../../node-singletons/path.js';
 // Escape characters that can cause issues when embedding JSON.stringify output
 // into generated JavaScript source (e.g., inside <script> tags).
 const unsafeCharMap = {
-    '<': '\\u003C',
-    '>': '\\u003E',
-    '/': '\\u002F',
+    '<': String.raw `\u003C`,
+    '>': String.raw `\u003E`,
+    '/': String.raw `\u002F`,
     '\\': '\\\\',
-    '\b': '\\b',
-    '\f': '\\f',
-    '\n': '\\n',
-    '\r': '\\r',
-    '\t': '\\t',
-    '\0': '\\0',
-    '\u2028': '\\u2028',
-    '\u2029': '\\u2029',
+    '\b': String.raw `\b`,
+    '\f': String.raw `\f`,
+    '\n': String.raw `\n`,
+    '\r': String.raw `\r`,
+    '\t': String.raw `\t`,
+    '\0': String.raw `\0`,
+    '\u2028': String.raw `\u2028`,
+    '\u2029': String.raw `\u2029`,
 };
 function escapeUnsafeChars(str) {
-    return str.replace(/[<>/\\\b\f\n\r\t\0\u2028\u2029]/g, (ch) => unsafeCharMap[ch] ?? ch);
+    return str.replaceAll(/[<>/\\\b\f\n\r\t\0\u2028\u2029]/g, (ch) => unsafeCharMap[ch] ?? ch);
 }
 /**
  * Validate route options
@@ -181,6 +181,19 @@ function buildRouteCode(route, router, groupMiddlewareList) {
         return buildMethodRoute(route, router, groupMiddlewareList);
     }
 }
+/**
+ * Build middleware property string for routes
+ */
+function buildMiddlewareProp(route, groupMiddlewareList) {
+    const localMiddlewareList = (route.middleware ?? []).map((m) => `'${m}'`).join(', ');
+    const hasGroup = groupMiddlewareList.trim() !== '';
+    const hasLocal = localMiddlewareList.trim() !== '';
+    return hasGroup || hasLocal
+        ? `middleware: [${[hasGroup ? groupMiddlewareList : '', hasLocal ? localMiddlewareList : '']
+            .filter((v) => v.trim() !== '')
+            .join(', ')}]`
+        : '';
+}
 /**
  * Build standard method route (GET, POST, etc.)
  */
@@ -192,14 +205,7 @@ function buildMethodRoute(route, router, groupMiddlewareList) {
     const tag = toTag(controller);
     const summary = `${method.toUpperCase()} ${routePath}`;
     const controllerVar = toControllerVar(controller);
-    const localMiddlewareList = (route.middleware ?? []).map((m) => `'${m}'`).join(', ');
-    const hasGroup = groupMiddlewareList.trim() !== '';
-    const hasLocal = localMiddlewareList.trim() !== '';
-    const middlewareProp = hasGroup || hasLocal
-        ? `middleware: [${[hasGroup ? groupMiddlewareList : '', hasLocal ? localMiddlewareList : '']
-            .filter((v) => v.trim() !== '')
-            .join(', ')}]`
-        : '';
+    const middlewareProp = buildMiddlewareProp(route, groupMiddlewareList);
     const metaProp = `meta: { summary: ${escapeUnsafeChars(JSON.stringify(summary))}, tags: [${escapeUnsafeChars(JSON.stringify(tag))}] }`;
     const options = `{ ${[middlewareProp, metaProp].filter((v) => v !== '').join(', ')} }`;
     return `  Router.${method}(${router}, '${routePath}', (req, res) => ${controllerVar}.${action}(req, res), ${options});\n`;
@@ -212,14 +218,7 @@ function buildResourceRoute(route, router, groupMiddlewareList) {
     const controller = route.controller;
     const tag = toTag(controller);
     const controllerVar = toControllerVar(controller);
-    const localMiddlewareList = (route.middleware ?? []).map((m) => `'${m}'`).join(', ');
-    const hasGroup = groupMiddlewareList.trim() !== '';
-    const hasLocal = localMiddlewareList.trim() !== '';
-    const middlewareProp = hasGroup || hasLocal
-        ? `middleware: [${[hasGroup ? groupMiddlewareList : '', hasLocal ? localMiddlewareList : '']
-            .filter((v) => v.trim() !== '')
-            .join(', ')}]`
-        : '';
+    const middlewareProp = buildMiddlewareProp(route, groupMiddlewareList);
     const resourceMeta = (action, routePattern) => `meta: { summary: ${escapeUnsafeChars(JSON.stringify(action.toUpperCase() + ' ' + routePattern))}, tags: [${escapeUnsafeChars(JSON.stringify(tag))}] }`;
     const pathId = routePath + '/:id';
     const optsParts = [