@zintrust/core 0.1.24 → 0.1.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zintrust/core",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "description": "Production-grade TypeScript backend framework for JavaScript",
   "homepage": "https://zintrust.com",
   "repository": {
@@ -36,13 +36,14 @@
     "bcrypt": "^6.0.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.2",
-    "inquirer": "^13.2.0",
+    "inquirer": "^13.2.1",
     "jsonwebtoken": "^9.0.3"
   },
   "overrides": {
     "node-forge": "1.3.3",
     "cross-spawn": "^7.0.5",
-    "glob": "^11.1.0"
+    "glob": "^11.1.0",
+    "undici": "^6.23.0"
   },
   "bin": {
     "zintrust": "bin/zintrust.js",

package/src/auth/Auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Auth.d.ts","sourceRoot":"","sources":["../../../src/auth/Auth.ts"],"names":[],"mappings":"AAEA,OAAY,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AAIlE,eAAO,MAAM,IAAI;IACf;;OAEG;mBACkB,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAK7C;;OAEG;sBACqB,MAAM,QAAQ,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI/D;;OAEG;2BAEQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UACxB,MAAM,cACH,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,GAC/C,MAAM;IAKT;;OAEG;gBACS,CAAC,SAAS,MAAM,UAAU,MAAM,GAAG,CAAC;EAGhD,CAAC"}

package/src/boot/Application.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Application.d.ts","sourceRoot":"","sources":["../../../src/boot/Application.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,kBAAkB,CAAC;AAUxD,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;AA2YD;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;sBACe,MAAM,GAAG,YAAY;EA0CvC,CAAC;AAEH,eAAe,WAAW,CAAC"}
+{"version":3,"file":"Application.d.ts","sourceRoot":"","sources":["../../../src/boot/Application.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAGtE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,KAAK,OAAO,EAAU,MAAM,kBAAkB,CAAC;AAUxD,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;AAqZD;;GAEG;AACH,eAAO,MAAM,WAAW;IACtB;;OAEG;sBACe,MAAM,GAAG,YAAY;EA0CvC,CAAC;AAEH,eAAe,WAAW,CAAC"}

package/src/boot/Application.js

@@ -291,6 +291,14 @@ const createLifecycle = (params) => {
         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');
     };

package/src/boot/bootstrap.js

@@ -87,8 +87,11 @@ const gracefulShutdown = async (signal) => {
     if (isShuttingDown)
         return;
     isShuttingDown = true;
-    const timeoutMs = Env.getInt('SHUTDOWN_TIMEOUT', 1500);
-    const forceExitMs = Env.getInt('SHUTDOWN_FORCE_EXIT_MS', 2500);
+    const shutdownBudgetMs = Env.getInt('SHUTDOWN_TIMEOUT', 1500);
+    const minForceExitMs = shutdownBudgetMs + 250;
+    const forceExitMs = Math.max(Env.getInt('SHUTDOWN_FORCE_EXIT_MS', 10000), minForceExitMs);
+    const deadlineMs = Date.now() + shutdownBudgetMs;
+    const remainingMs = () => Math.max(0, deadlineMs - Date.now());
     Logger.info(`${signal} received, shutting down gracefully...`);
     try {
         const forceExitTimer = globalThis.setTimeout(() => {
@@ -97,24 +100,30 @@ const gracefulShutdown = async (signal) => {
         // Best-effort: don't keep the process alive just for this timer
         forceExitTimer.unref?.();
         await withTimeout((async () => {
+            // Shutdown worker management system FIRST (before database closes)
+            if (appConfig.detectRuntime() === 'nodejs' || appConfig.detectRuntime() === 'lambda') {
+                try {
+                    const { WorkerShutdown } = await import('../../packages/workers/src/index.js');
+                    const workerBudgetMs = Math.min(15000, remainingMs());
+                    await withTimeout(WorkerShutdown.shutdown({ signal, timeout: workerBudgetMs, forceExit: false }), workerBudgetMs, 'Worker shutdown timed out');
+                }
+                catch (error) {
+                    Logger.warn('Worker shutdown failed (continuing with app shutdown)', error);
+                }
+            }
             if (serverInstance !== undefined) {
                 await serverInstance.close();
             }
             if (appInstance !== undefined) {
-                await appInstance.shutdown();
-            }
-        })(), timeoutMs, 'Graceful shutdown timed out');
-        // Shutdown worker management system first
-        if (appConfig.detectRuntime() === 'nodejs' || appConfig.detectRuntime() === 'lambda') {
-            try {
-                const { WorkerShutdown } = await import('../../packages/workers/src/index.js');
-                await withTimeout(WorkerShutdown.shutdown({ signal, timeout: 30000, forceExit: false }), timeoutMs, 'Worker shutdown timed out');
-                Logger.info('Worker management system shutdown complete');
-            }
-            catch (error) {
-                Logger.warn('Worker shutdown failed (continuing with app shutdown)', error);
+                try {
+                    const appBudgetMs = Math.min(5000, remainingMs());
+                    await withTimeout(appInstance.shutdown(), appBudgetMs, 'App shutdown timed out');
+                }
+                catch (error) {
+                    Logger.warn('App shutdown failed or timed out, forcing exit', error);
+                }
             }
-        }
+        })(), shutdownBudgetMs, 'Graceful shutdown timed out');
         globalThis.clearTimeout(forceExitTimer);
         process.exit(0);
     }
@@ -155,6 +164,16 @@ const BootstrapFunctions = Object.freeze({
      */
     async start() {
         try {
+            // Ensure project-installed adapters/drivers are registered for web server.
+            // (This is driven by src/zintrust.plugins.ts generated by `zin plugin install`.)
+            try {
+                const { PluginAutoImports } = await import('../runtime/PluginAutoImports.js');
+                await PluginAutoImports.tryImportProjectAutoImports();
+            }
+            catch (error) {
+                // best-effort; run without plugins if loader fails (e.g. non-Node runtime)
+                Logger.debug('Plugin auto-imports loader skipped:', error);
+            }
             // Create application instance
             // if (Env.ZINTRUST_PROJECT_ROOT) {
             // }

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

@@ -1 +1 @@
-{"version":3,"file":"RedisDriver.d.ts","sourceRoot":"","sources":["../../../../src/cache/drivers/RedisDriver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA+EtD;;GAEG;AACH,eAAO,MAAM,WAAW;kBA1EL,WAAW;EA4E5B,CAAC"}
+{"version":3,"file":"RedisDriver.d.ts","sourceRoot":"","sources":["../../../../src/cache/drivers/RedisDriver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAoFtD;;GAEG;AACH,eAAO,MAAM,WAAW;kBA9EL,WAAW;EAgF5B,CAAC"}

package/src/cache/drivers/RedisDriver.js

@@ -5,6 +5,7 @@
 import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
 import * as net from '../../node-singletons/net.js';
+import { createCacheKey } from '../../tools/redis/RedisKeyManager.js';
 /**
  * Create a new Redis driver instance
  */
@@ -38,7 +39,8 @@ const create = () => {
     return {
         async get(key) {
             try {
-                const response = await sendCommand(`GET ${key}\r\n`);
+                const prefixedKey = createCacheKey(key);
+                const response = await sendCommand(`GET ${prefixedKey}\r\n`);
                 if (response.startsWith('$-1'))
                     return null;
                 // Basic RESP parsing
@@ -52,21 +54,24 @@ const create = () => {
             }
         },
         async set(key, value, ttl) {
+            const prefixedKey = createCacheKey(key);
             const jsonValue = JSON.stringify(value);
-            let command = `SET ${key} ${jsonValue}\r\n`;
+            let command = `SET ${prefixedKey} ${jsonValue}\r\n`;
             if (ttl !== undefined) {
-                command = `SETEX ${key} ${ttl} ${jsonValue}\r\n`;
+                command = `SETEX ${prefixedKey} ${ttl} ${jsonValue}\r\n`;
             }
             await sendCommand(command);
         },
         async delete(key) {
-            await sendCommand(`DEL ${key}\r\n`);
+            const prefixedKey = createCacheKey(key);
+            await sendCommand(`DEL ${prefixedKey}\r\n`);
         },
         async clear() {
             await sendCommand(`FLUSHDB\r\n`);
         },
         async has(key) {
-            const response = await sendCommand(`EXISTS ${key}\r\n`);
+            const prefixedKey = createCacheKey(key);
+            const response = await sendCommand(`EXISTS ${prefixedKey}\r\n`);
             return response.includes(':1');
         },
     };

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;AAyCH,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;AAqMD;;;;;;;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;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"}

package/src/cli/CLI.js

@@ -32,6 +32,7 @@ import { TemplatesCommand } from './commands/TemplatesCommand.js';
 import { UpgradeCommand } from './commands/UpgradeCommand.js';
 import { WorkerCommands } from './commands/WorkerCommands.js';
 import { ErrorHandler } from './ErrorHandler.js';
+import { VersionChecker } from './services/VersionChecker.js';
 import { esmDirname } from '../common/index.js';
 import { Logger } from '../config/logger.js';
 import { ErrorFactory } from '../exceptions/ZintrustError.js';
@@ -194,6 +195,11 @@ const runCLI = async (program, version, args) => {
         }
         // Always show banner for normal commands
         ErrorHandler.banner(version);
+        // Run version check in background (non-blocking)
+        VersionChecker.runVersionCheck().catch((error) => {
+            // Version check should never crash the CLI
+            Logger.debug('Version check encountered an error', error);
+        });
         // Show help if no arguments provided
         if (args.length === 0) {
             program.help();

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

@@ -1 +1 @@
-{"version":3,"file":"QueueCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/QueueCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAYvF,eAAO,MAAM,YAAY;cACb,YAAY;EA0EtB,CAAC;AAEH,eAAe,YAAY,CAAC"}
+{"version":3,"file":"QueueCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/QueueCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAqHvF,eAAO,MAAM,YAAY;cACb,YAAY;EAmBtB,CAAC;AAEH,eAAe,YAAY,CAAC"}

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;AAyZvF,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

@@ -246,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"}