@zintrust/core 0.1.42 → 0.1.44

package/src/cache/drivers/RedisDriver.js

@@ -2,40 +2,235 @@
  * Redis Cache Driver
  * Zero-dependency implementation using Node.js native net module
  */
+import { Cloudflare } from '../../config/cloudflare.js';
 import { Env } from '../../config/env.js';
 import { Logger } from '../../config/logger.js';
+import { createRedisConnection } from '../../config/workers.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import * as net from '../../node-singletons/net.js';
 import { RedisKeys } from '../../tools/redis/RedisKeyManager.js';
-/**
- * Create a new Redis driver instance
- */
-const create = () => {
+const listenPreferOnce = (socket, event, cb) => {
+    if (typeof socket.once === 'function') {
+        socket.once(event, cb);
+        return;
+    }
+    socket.on?.(event, cb);
+};
+const listenPreferOn = (socket, event, cb) => {
+    if (typeof socket.on === 'function') {
+        socket.on(event, cb);
+        return;
+    }
+    socket.once?.(event, cb);
+};
+const hasToString = (value) => {
+    if (value === null || value === undefined)
+        return false;
+    return typeof value.toString === 'function';
+};
+const createIoredisClient = (params) => {
+    if (String(Env.NODE_ENV ?? '').startsWith('test'))
+        return null;
+    try {
+        const db = Env.getInt('REDIS_CACHE_DB', Env.getInt('REDIS_QUEUE_DB', 0));
+        const client = createRedisConnection({
+            host: Env.REDIS_HOST,
+            port: Env.REDIS_PORT,
+            password: Env.get('REDIS_PASSWORD', ''),
+            db,
+        }, 3);
+        return client !== null && typeof client.get === 'function' ? client : null;
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (params.isWorkersRuntime || params.wantsProxy) {
+            Logger.error('Redis cache driver initialization failed', { error: msg });
+            throw error;
+        }
+        Logger.warn('Redis cache driver falling back to TCP socket implementation', {
+            error: msg,
+        });
+        return null;
+    }
+};
+const createCacheDriverFromIoredisClient = (client) => ({
+    async get(key) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            const value = await client.get(prefixedKey);
+            if (value === null)
+                return null;
+            return JSON.parse(value);
+        }
+        catch (error) {
+            Logger.error('Redis GET failed', error);
+            return null;
+        }
+    },
+    async set(key, value, ttl) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            const jsonValue = JSON.stringify(value);
+            if (ttl === undefined) {
+                await client.set(prefixedKey, jsonValue);
+                return;
+            }
+            await client.set(prefixedKey, jsonValue, 'EX', ttl);
+        }
+        catch (error) {
+            Logger.error('Redis SET failed', error);
+        }
+    },
+    async delete(key) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            await client.del(prefixedKey);
+        }
+        catch (error) {
+            Logger.error('Redis DEL failed', error);
+        }
+    },
+    async clear() {
+        try {
+            await client.flushdb();
+        }
+        catch (error) {
+            Logger.error('Redis FLUSHDB failed', error);
+        }
+    },
+    async has(key) {
+        try {
+            const prefixedKey = RedisKeys.createCacheKey(key);
+            const out = await client.exists(prefixedKey);
+            return out > 0;
+        }
+        catch (error) {
+            Logger.error('Redis EXISTS failed', error);
+            return false;
+        }
+    },
+});
+const createIoredisCacheDriver = (params) => {
+    const client = createIoredisClient(params);
+    return client === null ? null : createCacheDriverFromIoredisClient(client);
+};
+const createTcpConnect = (params) => {
     let client = null;
-    const host = Env.REDIS_HOST;
-    const port = Env.REDIS_PORT;
-    const connect = async () => {
+    return async () => {
         if (client && !client.destroyed)
             return client;
         return new Promise((resolve, reject) => {
-            const socket = net.connect(port, host, () => {
-                client = socket;
-                resolve(socket);
-            });
-            socket.on('error', (err) => {
+            const onTimeout = () => {
+                cleanup();
+                try {
+                    socket.destroy?.();
+                }
+                catch {
+                    /* ignore */
+                }
+                reject(ErrorFactory.createConnectionError('Redis connection timeout', {
+                    host: params.host,
+                    port: params.port,
+                    timeoutMs: params.connectTimeoutMs,
+                }));
+            };
+            const onError = (err) => {
+                cleanup();
                 Logger.error(`Redis Connection Error: ${err.message}`);
                 reject(err);
-            });
+            };
+            const onErrorUnknown = (err) => {
+                if (err instanceof Error) {
+                    onError(err);
+                    return;
+                }
+                cleanup();
+                const msg = String(err);
+                Logger.error(`Redis Connection Error: ${msg}`);
+                reject(ErrorFactory.createConnectionError(`Redis Connection Error: ${msg}`, {
+                    error: msg,
+                }));
+            };
+            const onConnect = () => {
+                cleanup();
+                client = socket;
+                resolve(socket);
+            };
+            const socket = net.connect(params.port, params.host, onConnect);
+            const anySocket = socket;
+            const cleanup = () => {
+                anySocket.setTimeout?.(0);
+                anySocket.removeListener?.('timeout', onTimeout);
+                anySocket.removeListener?.('error', onErrorUnknown);
+            };
+            anySocket.setTimeout?.(Math.max(1, params.connectTimeoutMs));
+            listenPreferOnce(anySocket, 'timeout', onTimeout);
+            listenPreferOn(anySocket, 'error', onErrorUnknown);
         });
     };
-    const sendCommand = async (command) => {
-        const socket = await connect();
-        return new Promise((resolve, _reject) => {
-            socket.once('data', (data) => {
-                resolve(data.toString());
-            });
-            socket.write(command);
+};
+const createTcpSendCommand = (params) => {
+    return async (command) => {
+        const socket = await params.connect();
+        const anySocket = socket;
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const onDataUnknown = (data) => {
+                if (typeof data === 'string') {
+                    settleOk(data);
+                    return;
+                }
+                if (hasToString(data)) {
+                    settleOk(data.toString());
+                    return;
+                }
+                settleOk(String(data));
+            };
+            const onErrorUnknown = (err) => {
+                settleErr(err instanceof Error
+                    ? err
+                    : ErrorFactory.createConnectionError('Redis socket error', {
+                        error: String(err),
+                    }));
+            };
+            const cleanup = () => {
+                anySocket.setTimeout?.(0);
+                anySocket.removeListener?.('data', onDataUnknown);
+                anySocket.removeListener?.('error', onErrorUnknown);
+                anySocket.removeListener?.('timeout', onTimeout);
+            };
+            const settleOk = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve(value);
+            };
+            const settleErr = (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(err);
+            };
+            const onTimeout = () => settleErr(ErrorFactory.createConnectionError('Redis command timeout', {
+                timeoutMs: params.commandTimeoutMs,
+            }));
+            anySocket.setTimeout?.(Math.max(1, params.commandTimeoutMs));
+            listenPreferOnce(anySocket, 'data', onDataUnknown);
+            listenPreferOnce(anySocket, 'timeout', onTimeout);
+            listenPreferOn(anySocket, 'error', onErrorUnknown);
+            anySocket.write?.(command);
         });
     };
+};
+const createTcpCacheDriver = () => {
+    const host = Env.REDIS_HOST;
+    const port = Env.REDIS_PORT;
+    const connectTimeoutMs = Env.getInt('REDIS_CONNECT_TIMEOUT_MS', 5_000);
+    const commandTimeoutMs = Env.getInt('REDIS_COMMAND_TIMEOUT_MS', 5_000);
+    const connect = createTcpConnect({ host, port, connectTimeoutMs });
+    const sendCommand = createTcpSendCommand({ connect, commandTimeoutMs });
     return {
         async get(key) {
             try {
@@ -43,7 +238,6 @@ const create = () => {
                 const response = await sendCommand(`GET ${prefixedKey}\r\n`);
                 if (response.startsWith('$-1'))
                     return null;
-                // Basic RESP parsing
                 const lines = response.split('\r\n');
                 const value = lines[1];
                 return JSON.parse(value);
@@ -54,28 +248,57 @@ const create = () => {
             }
         },
         async set(key, value, ttl) {
-            const prefixedKey = RedisKeys.createCacheKey(key);
-            const jsonValue = JSON.stringify(value);
-            let command = `SET ${prefixedKey} ${jsonValue}\r\n`;
-            if (ttl !== undefined) {
-                command = `SETEX ${prefixedKey} ${ttl} ${jsonValue}\r\n`;
+            try {
+                const prefixedKey = RedisKeys.createCacheKey(key);
+                const jsonValue = JSON.stringify(value);
+                const command = ttl === undefined
+                    ? `SET ${prefixedKey} ${jsonValue}\r\n`
+                    : `SETEX ${prefixedKey} ${ttl} ${jsonValue}\r\n`;
+                await sendCommand(command);
+            }
+            catch (error) {
+                Logger.error('Redis SET failed', error);
             }
-            await sendCommand(command);
         },
         async delete(key) {
-            const prefixedKey = RedisKeys.createCacheKey(key);
-            await sendCommand(`DEL ${prefixedKey}\r\n`);
+            try {
+                const prefixedKey = RedisKeys.createCacheKey(key);
+                await sendCommand(`DEL ${prefixedKey}\r\n`);
+            }
+            catch (error) {
+                Logger.error('Redis DEL failed', error);
+            }
         },
         async clear() {
-            await sendCommand(`FLUSHDB\r\n`);
+            try {
+                await sendCommand(`FLUSHDB\r\n`);
+            }
+            catch (error) {
+                Logger.error('Redis FLUSHDB failed', error);
+            }
         },
         async has(key) {
-            const prefixedKey = RedisKeys.createCacheKey(key);
-            const response = await sendCommand(`EXISTS ${prefixedKey}\r\n`);
-            return response.includes(':1');
+            try {
+                const prefixedKey = RedisKeys.createCacheKey(key);
+                const response = await sendCommand(`EXISTS ${prefixedKey}\r\n`);
+                return response.includes(':1');
+            }
+            catch (error) {
+                Logger.error('Redis EXISTS failed', error);
+                return false;
+            }
         },
     };
 };
+/**
+ * Create a new Redis driver instance
+ */
+const create = () => {
+    const isWorkersRuntime = Cloudflare.getWorkersEnv() !== null;
+    const wantsProxy = Env.USE_REDIS_PROXY === true || (Env.get('REDIS_PROXY_URL', '') || '').trim() !== '';
+    const ioredisDriver = createIoredisCacheDriver({ isWorkersRuntime, wantsProxy });
+    return ioredisDriver ?? createTcpCacheDriver();
+};
 /**
  * RedisDriver namespace - sealed for immutability
  */

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;AAiEH,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;AAuPD;;;;;;;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;AAoEH,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;AA0PD;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG;cACJ,IAAI;EAed,CAAC"}

package/src/cli/CLI.js

@@ -14,10 +14,13 @@ 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 { DeployContainersProxyCommand } from './commands/DeployContainersProxyCommand.js';
 import { DeployContainerWorkersCommand } from './commands/DeployContainerWorkersCommand.js';
+import { DockerCommand } from './commands/DockerCommand.js';
 import { DoctorArchitectureCommand } from './commands/DoctorArchitectureCommand.js';
 import { FixCommand } from './commands/FixCommand.js';
 import { InitContainerCommand } from './commands/InitContainerCommand.js';
+import { InitContainersProxyCommand } from './commands/InitContainersProxyCommand.js';
 import { InitEcosystemCommand } from './commands/InitEcosystemCommand.js';
 import { InitProducerCommand } from './commands/InitProducerCommand.js';
 import { InitProxyCommand } from './commands/InitProxyCommand.js';
@@ -75,6 +78,7 @@ const buildCommandRegistry = () => {
         UpgradeCommand.create(),
         PrepareCommand,
         InitContainerCommand.create(),
+        InitContainersProxyCommand.create(),
         InitProxyCommand.create(),
         InitProducerCommand.create(),
         InitEcosystemCommand.create(),
@@ -84,6 +88,7 @@ const buildCommandRegistry = () => {
         CreateMigrationCommand.create(),
         AddMigrationCommand.create(),
         StartCommand.create(),
+        DockerCommand.create(),
         QueueCommand.create(),
         QueueRecoveryCommand.create(),
         ScheduleListCommand.create(),
@@ -106,6 +111,7 @@ const buildCommandRegistry = () => {
         PublishCommand.create(),
         PutCommand.create(),
         DeployCommand.create(),
+        DeployContainersProxyCommand.create(),
         DeployContainerWorkersCommand.create(),
         DeployContainerProxiesCommand.create(),
         QACommand(),

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

@@ -1 +1 @@
-{"version":3,"file":"DeployCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0HrE;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EAGtB,CAAC"}
+{"version":3,"file":"DeployCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyIrE;;;GAGG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EAGtB,CAAC"}

package/src/cli/commands/DeployCommand.js

@@ -59,10 +59,20 @@ const runDeploy = async (target, options) => {
         return;
     }
     const environment = options.env ?? target ?? 'worker';
+    const config = typeof options.config === 'string' ? options.config.trim() : '';
+    if (config.length > 0) {
+        const full = join(process.cwd(), config);
+        if (existsSync(full)) {
+            // ok
+        }
+        else {
+            throw ErrorFactory.createCliError(`Wrangler config not found: ${config}`);
+        }
+    }
     Logger.info(`Deploying to Cloudflare environment: ${environment}`);
     const exitCode = await SpawnUtil.spawnAndWait({
         command: 'wrangler',
-        args: ['deploy', '--env', environment],
+        args: ['deploy', ...(config.length > 0 ? ['--config', config] : []), '--env', environment],
     });
     if (exitCode !== 0) {
         process.exit(exitCode);
@@ -76,6 +86,7 @@ const createDeployCommand = () => {
             command
                 .argument('[target]', 'Deployment target (worker, d1-proxy, kv-proxy, production, cw, cp)', 'worker')
                 .option('-e, --env <env>', 'Wrangler environment (overrides target)');
+            command.option('-c, --config <path>', 'Wrangler config file (e.g. wrangler.containers-proxy.jsonc)');
         },
         execute: async (options) => {
             // Note: BaseCommand.create sets up action handler that calls execute(options).

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DeployContainersProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DeployContainersProxyCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA2CrE,eAAO,MAAM,4BAA4B;cAC7B,YAAY;EAatB,CAAC"}

package/src/cli/commands/DeployContainersProxyCommand.js

@@ -0,0 +1,45 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const DEFAULT_CONFIG = 'wrangler.containers-proxy.jsonc';
+const resolveConfig = (cwd, raw) => {
+    const normalized = typeof raw === 'string' ? raw.trim() : '';
+    const candidate = normalized.length > 0 ? normalized : DEFAULT_CONFIG;
+    const full = join(cwd, candidate);
+    if (existsSync(full))
+        return candidate;
+    throw ErrorFactory.createCliError(`Wrangler config not found: ${candidate}`);
+};
+const resolveEnv = (raw) => {
+    const normalized = typeof raw === 'string' ? raw.trim() : '';
+    return normalized.length > 0 ? normalized : 'production';
+};
+const execute = async (options) => {
+    const cwd = process.cwd();
+    const config = resolveConfig(cwd, options.config);
+    const env = resolveEnv(options.env);
+    Logger.info(`Deploying Containers proxy via Wrangler (env=${env})...`);
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: 'wrangler',
+        args: ['deploy', '--config', config, '--env', env],
+        env: process.env,
+    });
+    process.exit(exitCode);
+};
+export const DeployContainersProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'deploy:ccp',
+            aliases: ['deploy:containers-proxy', 'deploy:cf-containers-proxy', 'd:ccp', 'ccp:deploy'],
+            description: 'Deploy Cloudflare Containers proxy Worker (wrangler.containers-proxy.jsonc)',
+            addOptions: (command) => {
+                command.option('-e, --env <name>', 'Wrangler environment name', 'production');
+                command.option('-c, --config <path>', 'Wrangler config file', DEFAULT_CONFIG);
+            },
+            execute: async (options) => execute(options),
+        });
+    },
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DockerCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DockerCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0ErE,eAAO,MAAM,aAAa;cACd,YAAY;EAiBtB,CAAC"}

package/src/cli/commands/DockerCommand.js

@@ -0,0 +1,74 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { SpawnUtil } from '../utils/spawn.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { existsSync } from '../../node-singletons/fs.js';
+import { join } from '../../node-singletons/path.js';
+const resolveDefaultWranglerConfig = (cwd) => {
+    const candidates = [
+        'wrangler.containers-proxy.jsonc',
+        'wrangler.containers-proxy.json',
+        'wrangler.containers-proxy.toml',
+        'wrangler.jsonc',
+        'wrangler.json',
+        'wrangler.toml',
+    ];
+    for (const candidate of candidates) {
+        const full = join(cwd, candidate);
+        if (existsSync(full))
+            return candidate;
+    }
+    return undefined;
+};
+const resolvePort = (raw) => {
+    const value = typeof raw === 'string' ? raw.trim() : '';
+    if (value === '')
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed >= 65536) {
+        throw ErrorFactory.createCliError(`Error: Invalid --port '${value}'. Expected 1-65535.`);
+    }
+    return String(parsed);
+};
+const resolveWranglerConfig = (cwd, options) => {
+    const fromCli = typeof options.wranglerConfig === 'string' ? options.wranglerConfig.trim() : '';
+    if (fromCli.length > 0) {
+        const full = join(cwd, fromCli);
+        if (existsSync(full))
+            return fromCli;
+        throw ErrorFactory.createCliError(`Wrangler config not found: ${fromCli}`);
+    }
+    const fallback = resolveDefaultWranglerConfig(cwd);
+    if (typeof fallback === 'string' && fallback.length > 0)
+        return fallback;
+    throw ErrorFactory.createCliError('Wrangler config not found. Expected wrangler.containers-proxy.jsonc (or wrangler.jsonc/toml).');
+};
+const executeDocker = async (options) => {
+    const cwd = process.cwd();
+    const config = resolveWranglerConfig(cwd, options);
+    const env = typeof options.env === 'string' ? options.env.trim() : '';
+    const port = resolvePort(options.port);
+    const args = ['dev', '--config', config];
+    if (typeof port === 'string' && port.length > 0)
+        args.push('--port', port);
+    if (env.length > 0)
+        args.push('--env', env);
+    Logger.info('Starting Wrangler dev (Containers/Docker-backed)...');
+    const exitCode = await SpawnUtil.spawnAndWait({ command: 'wrangler', args, env: process.env });
+    process.exit(exitCode);
+};
+export const DockerCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'docker',
+            aliases: ['dkr', 'dk'],
+            description: 'Run Wrangler dev using a Docker-backed Cloudflare Containers config',
+            addOptions: (command) => {
+                command.option('-c, --wrangler-config <path>', 'Wrangler config file (defaults if present)');
+                command.option('-e, --env <name>', 'Wrangler environment name');
+                command.option('-p, --port <number>', 'Port for wrangler dev');
+            },
+            execute: async (options) => executeDocker(options),
+        });
+    },
+});

package/src/cli/commands/InitContainerCommand.js

@@ -98,7 +98,7 @@ services:
 `;
 const DOCKERFILE_TEMPLATE = String.raw `# syntax=docker/dockerfile:1.6
 # Build Stage - Compile TypeScript
-FROM node:20-alpine AS builder
+FROM node:20-bookworm-slim AS builder
 
 WORKDIR /app
 
@@ -106,12 +106,10 @@ WORKDIR /app
 ENV NPM_CONFIG_CACHE=/root/.npm
 ENV NPM_CONFIG_PREFER_OFFLINE=true
 
-# Reuse npm cache across builds (requires BuildKit)
-ENV NPM_CONFIG_CACHE=/root/.npm
-ENV NPM_CONFIG_PREFER_OFFLINE=true
-
 # Install build dependencies for native modules (better-sqlite3, bcrypt)
-RUN apk add --no-cache python3 make g++
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends python3 make g++ \
+  && rm -rf /var/lib/apt/lists/*
 
 # Copy package files
 COPY package.json package-lock.json ./
@@ -131,7 +129,7 @@ ARG BUILD_VARIANT=full
 RUN --mount=type=cache,target=/root/.npm,id=zintrust-npm-cache,sharing=locked npm run build:dk
 
 # Runtime Stage - Production image
-FROM node:20-alpine AS runtime
+FROM node:20-bookworm-slim AS runtime
 
 WORKDIR /app
 
@@ -141,16 +139,18 @@ ENV PORT=7772
 ENV HOST=0.0.0.0
 
 # Create non-root user for security
-RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
+RUN groupadd -g 1001 nodejs && useradd -u 1001 -g 1001 -m -s /usr/sbin/nologin nodejs
 
 # Copy package files for production dependencies
 COPY package.json package-lock.json ./
 
 # Install only production dependencies (requires build tools for native modules)
 RUN --mount=type=cache,target=/root/.npm,id=zintrust-npm-cache,sharing=locked \
-  apk add --no-cache --virtual .build-deps python3 make g++ \
+  apt-get update \
+  && apt-get install -y --no-install-recommends python3 make g++ \
   && npm ci --omit=dev \
-    && apk del .build-deps
+  && apt-get purge -y --auto-remove python3 make g++ \
+  && rm -rf /var/lib/apt/lists/*
 
 # Copy compiled code from builder stage
 COPY --from=builder /app/dist ./dist

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

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

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

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