@zintrust/core 0.1.40 → 0.1.41

package/src/proxy/mysql/MySqlProxyServer.js

@@ -0,0 +1,169 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { createProxyServer } from '../ProxyServer.js';
+import { resolveBaseConfig, resolveBaseSigningConfig, verifyRequestSignature, } from '../ProxyServerUtils.js';
+import { RequestValidator } from '../RequestValidator.js';
+import { validateSqlPayload } from '../SqlPayloadValidator.js';
+import { createPool } from 'mysql2/promise';
+const resolveDatabaseConfig = (overrides = {}) => {
+    const dbHost = overrides.dbHost ?? Env.get('MYSQL_DB_HOST', Env.get('DB_HOST', '127.0.0.1'));
+    const dbPort = overrides.dbPort ?? Env.getInt('MYSQL_DB_PORT', Env.getInt('DB_PORT', 3306));
+    const dbName = overrides.dbName ?? Env.get('MYSQL_DB_DATABASE', Env.get('DB_DATABASE', 'zintrust'));
+    const dbUser = overrides.dbUser ?? Env.get('MYSQL_DB_USERNAME', Env.get('DB_USERNAME', 'root'));
+    const dbPass = overrides.dbPass ?? Env.get('MYSQL_DB_PASSWORD', Env.get('DB_PASSWORD', 'pass'));
+    const connectionLimit = overrides.connectionLimit ?? Env.MYSQL_PROXY_POOL_LIMIT;
+    return { dbHost, dbPort, dbName, dbUser, dbPass, connectionLimit };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = resolveBaseConfig(overrides, 'MYSQL');
+    const dbConfig = resolveDatabaseConfig(overrides);
+    const signingConfig = resolveBaseSigningConfig(overrides, 'MYSQL');
+    const poolOptions = {
+        host: dbConfig.dbHost,
+        port: dbConfig.dbPort,
+        database: dbConfig.dbName,
+        user: dbConfig.dbUser,
+        password: dbConfig.dbPass,
+        waitForConnections: true,
+        connectionLimit: dbConfig.connectionLimit <= 0 ? 50 : dbConfig.connectionLimit,
+        queueLimit: 0,
+        enableKeepAlive: true,
+        keepAliveInitialDelay: 0,
+        namedPlaceholders: true,
+    };
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        poolOptions,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+    };
+};
+const normalizeResult = (rows) => {
+    if (Array.isArray(rows)) {
+        return { rows: rows, rowCount: rows.length };
+    }
+    if (rows !== null && rows !== undefined && typeof rows === 'object') {
+        const input = rows;
+        const affectedRows = Number.isFinite(input.affectedRows) ? Number(input.affectedRows) : 0;
+        const insertId = input.insertId;
+        const lastInsertId = typeof insertId === 'number' || typeof insertId === 'string' || typeof insertId === 'bigint'
+            ? insertId
+            : undefined;
+        return { rows: [], rowCount: affectedRows, lastInsertId };
+    }
+    return { rows: [], rowCount: 0 };
+};
+const handleEndpoint = (path, rows) => {
+    if (path === '/zin/mysql/query') {
+        return { status: 200, body: normalizeResult(rows) };
+    }
+    if (path === '/zin/mysql/queryOne') {
+        if (Array.isArray(rows)) {
+            return { status: 200, body: { row: rows[0] ?? null } };
+        }
+        return { status: 200, body: { row: null } };
+    }
+    if (path === '/zin/mysql/exec') {
+        const normalized = normalizeResult(rows);
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                meta: { changes: normalized.rowCount, lastRowId: normalized.lastInsertId },
+            },
+        };
+    }
+    return ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
+};
+const createBackend = (pool) => ({
+    name: 'mysql',
+    async handle(request) {
+        const methodError = RequestValidator.requirePost(request.method);
+        if (methodError) {
+            return ErrorHandler.toProxyError(405, methodError.code, methodError.message);
+        }
+        const parsed = RequestValidator.parseJson(request.body);
+        if (!parsed.ok) {
+            return ErrorHandler.toProxyError(400, parsed.error.code, parsed.error.message);
+        }
+        const sqlValidation = validateSqlPayload(parsed.value);
+        if (!sqlValidation.valid) {
+            const error = sqlValidation.error ?? {
+                code: 'VALIDATION_ERROR',
+                message: 'Invalid SQL payload',
+            };
+            return ErrorHandler.toProxyError(400, error.code, error.message);
+        }
+        try {
+            const [rows] = await pool.query(sqlValidation.sql ?? '', sqlValidation.params ?? []);
+            return handleEndpoint(request.path, rows);
+        }
+        catch (error) {
+            Logger.error('[MySQLProxyServer] Query execution failed', {
+                path: request.path,
+                sqlPreview: String(sqlValidation.sql ?? '').slice(0, 160),
+                paramsCount: Array.isArray(sqlValidation.params) ? sqlValidation.params.length : 0,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return ErrorHandler.toProxyError(500, 'MYSQL_ERROR', String(error));
+        }
+    },
+    async health() {
+        try {
+            await pool.query('SELECT 1');
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            Logger.error('[MySQLProxyServer] Health check failed', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            return ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
+        }
+    },
+});
+export const MySqlProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        const signingHasKeyId = config.signing.keyId.trim() !== '';
+        const signingHasSecret = config.signing.secret.trim() !== '';
+        if (config.signing.require && (!signingHasKeyId || !signingHasSecret)) {
+            throw ErrorFactory.createConfigError(`MySQL proxy signing is required but credentials are missing. ` +
+                `Set MYSQL_PROXY_KEY_ID and MYSQL_PROXY_SECRET (fallbacks: APP_NAME and APP_KEY). ` +
+                `Resolved state: keyId=${config.signing.keyId || '<empty>'}, hasSecret=${String(signingHasSecret)}, ` +
+                `cwd=${typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : '<unknown>'}`);
+        }
+        // Debug: surface resolved config so we can compare watch vs non-watch runs
+        try {
+            Logger.info(`MySQL proxy config: proxyHost=${config.host} proxyPort=${config.port} dbHost=${String(config.poolOptions.host)} dbPort=${String(config.poolOptions.port)} dbName=${String(config.poolOptions.database)} dbUser=${String(config.poolOptions.user)} requireSigning=${String(config.signing.require)} keyId=${config.signing.keyId} hasSecret=${String(config.signing.secret.trim() !== '')} signingWindowMs=${String(config.signing.windowMs)}`);
+        }
+        catch {
+            // noop - logging must not block startup
+        }
+        const pool = createPool(config.poolOptions);
+        const backend = createBackend(pool);
+        const proxy = createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: async (req, body) => {
+                const verified = await verifyRequestSignature(req, body, config, 'MySQLProxyServer');
+                if (!verified.ok && verified.error) {
+                    return { ok: false, status: verified.error.status, message: verified.error.message };
+                }
+                return { ok: true };
+            },
+        });
+        await proxy.start();
+        Logger.info(`MySQL proxy listening on http://${config.host}:${config.port}`);
+    },
+});
+export default MySqlProxyServer;

package/src/proxy/mysql/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/src/proxy/mysql/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/proxy/mysql/register.ts"],"names":[],"mappings":""}

package/src/proxy/mysql/register.js

@@ -0,0 +1,5 @@
+import { ProxyRegistry } from '../ProxyRegistry.js';
+ProxyRegistry.register({
+    name: 'mysql',
+    description: 'MySQL HTTP proxy server',
+});

package/src/proxy/postgres/PostgresProxyServer.d.ts

@@ -0,0 +1,14 @@
+import { type BaseProxyOverrides } from '../ProxyServerUtils';
+type ProxyOverrides = BaseProxyOverrides & Partial<{
+    dbHost: string;
+    dbPort: number;
+    dbName: string;
+    dbUser: string;
+    dbPass: string;
+    connectionLimit: number;
+}>;
+export declare const PostgresProxyServer: Readonly<{
+    start(overrides?: ProxyOverrides): Promise<void>;
+}>;
+export default PostgresProxyServer;
+//# sourceMappingURL=PostgresProxyServer.d.ts.map

package/src/proxy/postgres/PostgresProxyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostgresProxyServer.d.ts","sourceRoot":"","sources":["../../../../src/proxy/postgres/PostgresProxyServer.ts"],"names":[],"mappings":"AAMA,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAoBjC,KAAK,cAAc,GAAG,kBAAkB,GACtC,OAAO,CAAC;IACN,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC,CAAC;AAgIL,eAAO,MAAM,mBAAmB;sBACP,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EAoC1D,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/src/proxy/postgres/PostgresProxyServer.js

@@ -0,0 +1,140 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { createProxyServer } from '../ProxyServer.js';
+import { resolveBaseConfig, resolveBaseSigningConfig, verifyRequestSignature, } from '../ProxyServerUtils.js';
+import { RequestValidator } from '../RequestValidator.js';
+import { validateSqlPayload } from '../SqlPayloadValidator.js';
+import { Pool } from 'pg';
+const resolveDatabaseConfig = (overrides = {}) => {
+    const dbHost = overrides.dbHost ?? Env.DB_HOST ?? '127.0.0.1';
+    const dbPort = overrides.dbPort ?? Env.DB_PORT_POSTGRESQL ?? 5432;
+    const dbName = overrides.dbName ?? Env.DB_DATABASE_POSTGRESQL ?? 'postgres';
+    const dbUser = overrides.dbUser ?? Env.DB_USERNAME_POSTGRESQL ?? 'postgres';
+    const dbPass = overrides.dbPass ?? Env.DB_PASSWORD_POSTGRESQL ?? '';
+    const connectionLimit = overrides.connectionLimit ?? Env.POSTGRES_PROXY_POOL_LIMIT;
+    return { dbHost, dbPort, dbName, dbUser, dbPass, connectionLimit };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = resolveBaseConfig(overrides, 'POSTGRES');
+    const dbConfig = resolveDatabaseConfig(overrides);
+    const signingConfig = resolveBaseSigningConfig(overrides, 'POSTGRES');
+    const poolOptions = {
+        host: dbConfig.dbHost,
+        port: dbConfig.dbPort,
+        database: dbConfig.dbName,
+        user: dbConfig.dbUser,
+        password: dbConfig.dbPass,
+        max: dbConfig.connectionLimit <= 0 ? 50 : dbConfig.connectionLimit,
+    };
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        poolOptions,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+    };
+};
+const normalizeSql = (sql) => {
+    if (!sql.includes('?'))
+        return sql;
+    let index = 0;
+    return sql.replaceAll('?', () => {
+        index += 1;
+        return `$${index}`;
+    });
+};
+const handleEndpoint = (path, result) => {
+    if (path === '/zin/postgres/query') {
+        return { status: 200, body: { rows: result.rows, rowCount: result.rowCount } };
+    }
+    if (path === '/zin/postgres/queryOne') {
+        const row = result.rows[0] ?? null;
+        return { status: 200, body: { row } };
+    }
+    if (path === '/zin/postgres/exec') {
+        return {
+            status: 200,
+            body: {
+                ok: true,
+                meta: { changes: result.rowCount },
+            },
+        };
+    }
+    return ErrorHandler.toProxyError(404, 'NOT_FOUND', 'Unknown endpoint');
+};
+const createBackend = (pool) => ({
+    name: 'postgres',
+    async handle(request) {
+        const methodError = RequestValidator.requirePost(request.method);
+        if (methodError) {
+            return ErrorHandler.toProxyError(405, methodError.code, methodError.message);
+        }
+        const parsed = RequestValidator.parseJson(request.body);
+        if (!parsed.ok) {
+            return ErrorHandler.toProxyError(400, parsed.error.code, parsed.error.message);
+        }
+        const sqlValidation = validateSqlPayload(parsed.value);
+        if (!sqlValidation.valid) {
+            const error = sqlValidation.error ?? {
+                code: 'VALIDATION_ERROR',
+                message: 'Invalid SQL payload',
+            };
+            return ErrorHandler.toProxyError(400, error.code, error.message);
+        }
+        try {
+            const sql = normalizeSql(sqlValidation.sql ?? '');
+            const result = await pool.query(sql, sqlValidation.params ?? []);
+            return handleEndpoint(request.path, {
+                rows: (result.rows ?? []),
+                rowCount: result.rowCount ?? result.rows?.length ?? 0,
+            });
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(500, 'POSTGRES_ERROR', String(error));
+        }
+    },
+    async health() {
+        try {
+            await pool.query('SELECT 1');
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(503, 'UNHEALTHY', String(error));
+        }
+    },
+});
+export const PostgresProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        try {
+            Logger.info(`Postgres proxy config: proxyHost=${config.host} proxyPort=${config.port} dbHost=${String(config.poolOptions.host)} dbPort=${String(config.poolOptions.port)} dbName=${String(config.poolOptions.database)} dbUser=${String(config.poolOptions.user)}`);
+        }
+        catch {
+            // noop - logging must not block startup
+        }
+        const pool = new Pool(config.poolOptions);
+        const backend = createBackend(pool);
+        const proxy = createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: async (req, body) => {
+                const verified = await verifyRequestSignature(req, body, config, 'PostgresProxyServer');
+                if (!verified.ok && verified.error) {
+                    return { ok: false, status: verified.error.status, message: verified.error.message };
+                }
+                return { ok: true };
+            },
+        });
+        await proxy.start();
+        Logger.info(`Postgres proxy listening on http://${config.host}:${config.port}`);
+    },
+});
+export default PostgresProxyServer;

package/src/proxy/postgres/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/src/proxy/postgres/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/proxy/postgres/register.ts"],"names":[],"mappings":""}

package/src/proxy/postgres/register.js

@@ -0,0 +1,5 @@
+import { ProxyRegistry } from '../ProxyRegistry.js';
+ProxyRegistry.register({
+    name: 'postgres',
+    description: 'PostgreSQL HTTP proxy server',
+});

package/src/proxy/redis/RedisProxyServer.d.ts

@@ -0,0 +1,12 @@
+import { type BaseProxyOverrides } from '../ProxyServerUtils';
+type ProxyOverrides = BaseProxyOverrides & Partial<{
+    redisHost: string;
+    redisPort: number;
+    redisPassword: string;
+    redisDb: number;
+}>;
+export declare const RedisProxyServer: Readonly<{
+    start(overrides?: ProxyOverrides): Promise<void>;
+}>;
+export default RedisProxyServer;
+//# sourceMappingURL=RedisProxyServer.d.ts.map

package/src/proxy/redis/RedisProxyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisProxyServer.d.ts","sourceRoot":"","sources":["../../../../src/proxy/redis/RedisProxyServer.ts"],"names":[],"mappings":"AAOA,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAiBjC,KAAK,cAAc,GAAG,kBAAkB,GACtC,OAAO,CAAC;IACN,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,CAAC;AAyNL,eAAO,MAAM,gBAAgB;sBACJ,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EAqB1D,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/proxy/redis/RedisProxyServer.js

@@ -0,0 +1,192 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { ErrorHandler } from '../ErrorHandler.js';
+import { createProxyServer } from '../ProxyServer.js';
+import { resolveBaseConfig, resolveBaseSigningConfig, verifyRequestSignature, } from '../ProxyServerUtils.js';
+import { RequestValidator } from '../RequestValidator.js';
+const resolveRedisConfig = (overrides = {}) => {
+    const host = overrides.redisHost ?? Env.get('REDIS_PROXY_TARGET_HOST', Env.get('REDIS_HOST', '127.0.0.1'));
+    const port = overrides.redisPort ?? Env.getInt('REDIS_PROXY_TARGET_PORT', Env.getInt('REDIS_PORT', 6379));
+    const password = overrides.redisPassword ??
+        Env.get('REDIS_PROXY_TARGET_PASSWORD', Env.get('REDIS_PASSWORD', ''));
+    const db = overrides.redisDb ?? Env.getInt('REDIS_PROXY_TARGET_DB', Env.getInt('REDIS_DB', 0));
+    return { host, port, password, db };
+};
+const resolveConfig = (overrides = {}) => {
+    const proxyConfig = resolveBaseConfig(overrides, 'REDIS');
+    const redisConfig = resolveRedisConfig(overrides);
+    const signingConfig = resolveBaseSigningConfig(overrides, 'REDIS');
+    return {
+        host: proxyConfig.host,
+        port: proxyConfig.port,
+        maxBodyBytes: proxyConfig.maxBodyBytes,
+        redis: redisConfig,
+        signing: {
+            keyId: signingConfig.keyId,
+            secret: signingConfig.secret,
+            require: signingConfig.requireSigning,
+            windowMs: signingConfig.signingWindowMs,
+        },
+    };
+};
+const validateCommandPayload = (payload) => {
+    const command = payload['command'];
+    const args = Array.isArray(payload['args']) ? payload['args'] : [];
+    if (typeof command !== 'string' || command.trim() === '') {
+        return { valid: false, error: { code: 'VALIDATION_ERROR', message: 'command is required' } };
+    }
+    return { valid: true, command, args };
+};
+const getRedisModule = async () => {
+    const mod = await import('ioredis');
+    return mod;
+};
+const createClient = async (config) => {
+    const module = (await getRedisModule());
+    const moduleDefault = module['default'];
+    const candidates = [
+        module['Redis'],
+        module['default'],
+        moduleDefault?.['Redis'],
+        moduleDefault?.['default'],
+        module,
+    ];
+    const RedisCtor = candidates.find((candidate) => typeof candidate === 'function');
+    if (typeof RedisCtor !== 'function') {
+        throw ErrorFactory.createConfigError("Redis proxy could not resolve a Redis constructor from 'ioredis'.");
+    }
+    const maxReconnectRetries = Math.max(0, Env.getInt('REDIS_PROXY_CONNECT_MAX_RETRIES', 3));
+    const reconnectBaseMs = Math.max(50, Env.getInt('REDIS_PROXY_CONNECT_RETRY_BASE_MS', 200));
+    const reconnectCapMs = Math.max(reconnectBaseMs, Env.getInt('REDIS_PROXY_CONNECT_RETRY_CAP_MS', 2000));
+    const client = new RedisCtor({
+        host: config.redis.host,
+        port: config.redis.port,
+        password: config.redis.password,
+        db: config.redis.db,
+        maxRetriesPerRequest: 1,
+        enableOfflineQueue: false,
+        lazyConnect: true,
+        reconnectOnError: () => false,
+        retryStrategy: (times) => {
+            if (times > maxReconnectRetries) {
+                return null;
+            }
+            return Math.min(times * reconnectBaseMs, reconnectCapMs);
+        },
+    });
+    let lastErrorLogAt = 0;
+    client.on('error', (error) => {
+        const now = Date.now();
+        if (now - lastErrorLogAt < 5000) {
+            return;
+        }
+        lastErrorLogAt = now;
+        Logger.warn('[RedisProxyServer] redis client error', error);
+    });
+    if (typeof client.connect === 'function') {
+        await client.connect();
+    }
+    return client;
+};
+const executeCommand = async (client, command, args) => {
+    const trimmed = command.trim();
+    const lower = trimmed.toLowerCase();
+    const candidate = client[lower];
+    if (typeof candidate === 'function') {
+        return candidate.apply(client, args);
+    }
+    if (typeof client.call === 'function') {
+        return client.call(trimmed, ...args);
+    }
+    throw ErrorFactory.createValidationError(`Unsupported Redis command: ${trimmed}`);
+};
+const createBackend = (config) => ({
+    name: 'redis',
+    handle: async (request) => {
+        const methodError = RequestValidator.requirePost(request.method);
+        if (methodError) {
+            return {
+                status: 405,
+                body: { code: methodError.code, message: methodError.message },
+            };
+        }
+        if (request.path !== '/zin/redis/command') {
+            return { status: 404, body: { code: 'NOT_FOUND', message: 'Unknown endpoint' } };
+        }
+        const parsed = RequestValidator.parseJson(request.body);
+        if (!parsed.ok) {
+            return { status: 400, body: { code: parsed.error.code, message: parsed.error.message } };
+        }
+        const validated = validateCommandPayload(parsed.value);
+        if (!validated.valid) {
+            return {
+                status: 400,
+                body: {
+                    code: validated.error?.code ?? 'VALIDATION_ERROR',
+                    message: validated.error?.message ?? 'Invalid request',
+                },
+            };
+        }
+        const command = validated.command ?? '';
+        if (command.trim() === '') {
+            return {
+                status: 400,
+                body: { code: 'VALIDATION_ERROR', message: 'command is required' },
+            };
+        }
+        try {
+            const client = await createClient(config);
+            try {
+                const result = await executeCommand(client, command, validated.args ?? []);
+                return { status: 200, body: { result } };
+            }
+            finally {
+                await client.quit();
+            }
+        }
+        catch (error) {
+            return ErrorHandler.toProxyError(500, 'REDIS_PROXY_ERROR', String(error));
+        }
+    },
+    health: async () => {
+        try {
+            const client = await createClient(config);
+            const pingFn = client.ping;
+            if (typeof pingFn === 'function') {
+                await pingFn.apply(client);
+            }
+            else {
+                await executeCommand(client, 'PING', []);
+            }
+            await client.quit();
+            return { status: 200, body: { status: 'healthy' } };
+        }
+        catch (error) {
+            Logger.warn('[RedisProxyServer] health check failed', error);
+            return { status: 503, body: { status: 'unhealthy', error: String(error) } };
+        }
+    },
+});
+export const RedisProxyServer = Object.freeze({
+    async start(overrides = {}) {
+        const config = resolveConfig(overrides);
+        const backend = createBackend(config);
+        const server = createProxyServer({
+            host: config.host,
+            port: config.port,
+            maxBodyBytes: config.maxBodyBytes,
+            backend,
+            verify: async (req, body) => {
+                const verified = await verifyRequestSignature(req, body, config, 'RedisProxyServer');
+                if (!verified.ok && verified.error) {
+                    return { ok: false, status: verified.error.status, message: verified.error.message };
+                }
+                return { ok: true };
+            },
+        });
+        await server.start();
+        Logger.info(`[redis-proxy] Listening on http://${config.host}:${config.port}`);
+    },
+});
+export default RedisProxyServer;

package/src/proxy/redis/register.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=register.d.ts.map

package/src/proxy/redis/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/proxy/redis/register.ts"],"names":[],"mappings":""}

package/src/proxy/redis/register.js

@@ -0,0 +1,5 @@
+import { ProxyRegistry } from '../ProxyRegistry.js';
+ProxyRegistry.register({
+    name: 'redis',
+    description: 'Redis HTTP proxy server',
+});

package/src/proxy/smtp/SmtpProxyServer.d.ts

@@ -0,0 +1,19 @@
+type ProxyOverrides = Partial<{
+    host: string;
+    port: number;
+    maxBodyBytes: number;
+    smtpHost: string;
+    smtpPort: number;
+    smtpUsername: string;
+    smtpPassword: string;
+    smtpSecure: boolean | string;
+    requireSigning: boolean;
+    keyId: string;
+    secret: string;
+    signingWindowMs: number;
+}>;
+export declare const SmtpProxyServer: Readonly<{
+    start(overrides?: ProxyOverrides): Promise<void>;
+}>;
+export default SmtpProxyServer;
+//# sourceMappingURL=SmtpProxyServer.d.ts.map

package/src/proxy/smtp/SmtpProxyServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SmtpProxyServer.d.ts","sourceRoot":"","sources":["../../../../src/proxy/smtp/SmtpProxyServer.ts"],"names":[],"mappings":"AA2BA,KAAK,cAAc,GAAG,OAAO,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,OAAO,GAAG,MAAM,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC,CAAC;AAqUH,eAAO,MAAM,eAAe;sBACH,cAAc,GAAQ,OAAO,CAAC,IAAI,CAAC;EA2B1D,CAAC;AAEH,eAAe,eAAe,CAAC"}