@zintrust/core 0.1.40 → 0.1.42

package/src/cli/commands/ScheduleListCommand.js

@@ -0,0 +1,62 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { ScheduleCliSupport } from '../commands/schedule/ScheduleCliSupport.js';
+import { Logger } from '../../config/logger.js';
+import { SchedulerRuntime } from '../../scheduler/SchedulerRuntime.js';
+const execute = async (options) => {
+    try {
+        await ScheduleCliSupport.registerAll();
+        const toIso = (ms) => typeof ms === 'number' && Number.isFinite(ms) ? new Date(ms).toISOString() : undefined;
+        const rows = (await SchedulerRuntime.listWithState())
+            .map(({ schedule: s, state }) => ({
+            name: s.name,
+            enabled: s.enabled !== false,
+            intervalMs: s.intervalMs,
+            cron: s.cron,
+            timezone: s.timezone,
+            runOnStart: s.runOnStart === true,
+            consecutiveFailures: state?.consecutiveFailures,
+            lastRunAt: toIso(state?.lastRunAt),
+            lastSuccessAt: toIso(state?.lastSuccessAt),
+            lastErrorAt: toIso(state?.lastErrorAt),
+            lastErrorMessage: state?.lastErrorMessage,
+            nextRunAt: toIso(state?.nextRunAt),
+        }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        if (options.json === true) {
+            Logger.info(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            Logger.info('No schedules registered');
+            return;
+        }
+        rows.forEach((row) => {
+            const hasText = (value) => typeof value === 'string' && value.trim().length > 0;
+            const tzSuffix = hasText(row.timezone) ? ` tz=${row.timezone}` : '';
+            const cadence = typeof row.cron === 'string' && row.cron.trim().length > 0
+                ? `cron=${row.cron}${tzSuffix}`
+                : `intervalMs=${row.intervalMs ?? 'manual'}`;
+            const hasStateInfo = [row.nextRunAt, row.lastSuccessAt, row.lastErrorAt].some(hasText);
+            const extra = hasStateInfo
+                ? ` next=${row.nextRunAt ?? '-'} lastOk=${row.lastSuccessAt ?? '-'} lastErr=${row.lastErrorAt ?? '-'}`
+                : '';
+            Logger.info(`${row.name} (enabled=${row.enabled}, ${cadence}, runOnStart=${row.runOnStart}, failures=${row.consecutiveFailures ?? 0})${extra}`);
+        });
+    }
+    finally {
+        await ScheduleCliSupport.shutdownCliResources();
+    }
+};
+export const ScheduleListCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'schedule:list',
+            description: 'List all registered schedules',
+            addOptions: (command) => {
+                command.option('--json', 'Output JSON');
+            },
+            execute,
+        });
+    },
+});
+export default ScheduleListCommand;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleRunCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ScheduleRunCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA0BrE,eAAO,MAAM,kBAAkB;cACnB,YAAY;EAUtB,CAAC;AAEH,eAAe,kBAAkB,CAAC"}

package/src/cli/commands/ScheduleRunCommand.js

@@ -0,0 +1,32 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { ScheduleCliSupport } from '../commands/schedule/ScheduleCliSupport.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { SchedulerRuntime } from '../../scheduler/SchedulerRuntime.js';
+const execute = async (options) => {
+    const name = (options.name ?? '').trim();
+    if (name.length === 0)
+        throw ErrorFactory.createConfigError('--name is required');
+    try {
+        await ScheduleCliSupport.registerAll();
+        Logger.info('Running schedule once', { name });
+        await SchedulerRuntime.runOnce(name);
+        Logger.info('Schedule run completed', { name });
+    }
+    finally {
+        await ScheduleCliSupport.shutdownCliResources();
+    }
+};
+export const ScheduleRunCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'schedule:run',
+            description: 'Run a specific schedule once and exit',
+            addOptions: (command) => {
+                command.option('--name <name>', 'Schedule name to run');
+            },
+            execute,
+        });
+    },
+});
+export default ScheduleRunCommand;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"ScheduleStartCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ScheduleStartCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA6CrE,eAAO,MAAM,oBAAoB;cACrB,YAAY;EAOtB,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/src/cli/commands/ScheduleStartCommand.js

@@ -0,0 +1,40 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { ScheduleCliSupport } from '../commands/schedule/ScheduleCliSupport.js';
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { SchedulerRuntime } from '../../scheduler/SchedulerRuntime.js';
+const waitForSignal = async () => {
+    if (typeof process === 'undefined' || typeof process.once !== 'function') {
+        throw ErrorFactory.createGeneralError('schedule:start is only supported in Node.js runtimes');
+    }
+    return new Promise((resolve) => {
+        process.once('SIGTERM', () => resolve('SIGTERM'));
+        process.once('SIGINT', () => resolve('SIGINT'));
+    });
+};
+const execute = async (_options) => {
+    if (Env.getBool('SCHEDULES_ENABLED', false) === false) {
+        Logger.info('Schedules are disabled (SCHEDULES_ENABLED=false); exiting');
+        return;
+    }
+    await ScheduleCliSupport.registerAll();
+    const registeredCount = SchedulerRuntime.list().length;
+    Logger.info('Starting schedules daemon', { registeredCount });
+    SchedulerRuntime.start();
+    const signal = await waitForSignal();
+    Logger.info('Stopping schedules daemon', { signal });
+    const timeoutMs = Env.getInt('SCHEDULE_SHUTDOWN_TIMEOUT_MS', 30000);
+    await SchedulerRuntime.stop(timeoutMs);
+    Logger.info('Schedules daemon stopped');
+};
+export const ScheduleStartCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'schedule:start',
+            description: 'Start schedules and keep running until SIGINT/SIGTERM',
+            execute,
+        });
+    },
+});
+export default ScheduleStartCommand;

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

@@ -1 +1 @@
-{"version":3,"file":"SecretsCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SecretsCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAsHvF,eAAO,MAAM,cAAc;cACf,YAAY;EAWtB,CAAC;AAEH,eAAe,cAAc,CAAC"}
+{"version":3,"file":"SecretsCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SecretsCommand.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAqHvF,eAAO,MAAM,cAAc;cACf,YAAY;EAWtB,CAAC;AAEH,eAAe,cAAc,CAAC"}

package/src/cli/commands/SecretsCommand.js

@@ -10,10 +10,10 @@
  */
 import { BaseCommand } from '../BaseCommand.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isArray } from '../../helper/index.js';
 import { SecretsToolkit } from '../../toolkit/Secrets/index.js';
-const isUnknownArray = (value) => Array.isArray(value);
 const getArg = (args, index) => {
-    if (!isUnknownArray(args))
+    if (!isArray(args))
         return undefined;
     const v = args[index];
     return typeof v === 'string' ? v : undefined;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SmtpProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SmtpProxyCommand.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyDrE,eAAO,MAAM,gBAAgB;cACjB,YAAY;EAsCtB,CAAC;AAEH,eAAe,gBAAgB,CAAC"}

package/src/cli/commands/SmtpProxyCommand.js

@@ -0,0 +1,56 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { maybeRunProxyWatchMode, parseIntOption, trimOption, } from '../commands/ProxyCommandUtils.js';
+import { Env } from '../../config/env.js';
+import { SmtpProxyServer } from '../../proxy/smtp/SmtpProxyServer.js';
+const addOptions = (command) => {
+    command.option('--host <host>', 'Host to bind', Env.get('SMTP_PROXY_HOST', '127.0.0.1'));
+    command.option('--port <port>', 'Port to bind', String(Env.getInt('SMTP_PROXY_PORT', 8794)));
+    command.option('--max-body-bytes <bytes>', 'Max request size in bytes', String(Env.getInt('SMTP_PROXY_MAX_BODY_BYTES', 131072)));
+    command.option('--watch', 'Auto-restart proxy on file changes');
+    command.option('--smtp-host <host>', 'SMTP host');
+    command.option('--smtp-port <port>', 'SMTP port');
+    command.option('--smtp-username <user>', 'SMTP username');
+    command.option('--smtp-password <password>', 'SMTP password');
+    command.option('--smtp-secure <mode>', "SMTP secure: true, false, or 'starttls'");
+    command.option('--require-signing', 'Require signed requests', Env.getBool('SMTP_PROXY_REQUIRE_SIGNING', true));
+    command.option('--key-id <id>', 'Signing key id', Env.get('SMTP_PROXY_KEY_ID', ''));
+    command.option('--secret <secret>', 'Signing secret', Env.get('SMTP_PROXY_SECRET', ''));
+    command.option('--signing-window-ms <ms>', 'Signing time window in ms', String(Env.getInt('SMTP_PROXY_SIGNING_WINDOW_MS', 60000)));
+};
+export const SmtpProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'proxy:smtp',
+            aliases: ['smtp:proxy', 'smtp-proxy', 'proxy:mail'],
+            description: 'Start the SMTP HTTP proxy for Cloudflare Workers',
+            addOptions,
+            execute: async (options) => {
+                await maybeRunProxyWatchMode(options.watch);
+                const host = trimOption(options.host);
+                const port = parseIntOption(options.port, 'port');
+                const maxBodyBytes = parseIntOption(options.maxBodyBytes, 'max-body-bytes');
+                const smtpHost = trimOption(options.smtpHost);
+                const smtpPort = parseIntOption(options.smtpPort, 'smtp-port');
+                const smtpUsername = trimOption(options.smtpUsername);
+                const smtpPassword = options.smtpPassword;
+                const smtpSecure = options.smtpSecure;
+                const signingWindowMs = parseIntOption(options.signingWindowMs, 'signing-window-ms');
+                await SmtpProxyServer.start({
+                    host,
+                    port,
+                    maxBodyBytes,
+                    smtpHost,
+                    smtpPort,
+                    smtpUsername,
+                    smtpPassword,
+                    smtpSecure,
+                    requireSigning: options.requireSigning === true,
+                    keyId: options.keyId,
+                    secret: options.secret,
+                    signingWindowMs,
+                });
+            },
+        });
+    },
+});
+export default SmtpProxyCommand;

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

@@ -0,0 +1,46 @@
+import type { CommandOptions } from '../BaseCommand';
+import type { Command } from 'commander';
+export type SqlProxyCommandOptions = CommandOptions & {
+    host?: string;
+    port?: string;
+    maxBodyBytes?: string;
+    dbHost?: string;
+    dbPort?: string;
+    dbName?: string;
+    dbUser?: string;
+    dbPass?: string;
+    connectionLimit?: string;
+    requireSigning?: boolean;
+    keyId?: string;
+    secret?: string;
+    signingWindowMs?: string;
+    watch?: boolean;
+};
+export type ParsedSqlProxyStartOptions = {
+    host: string | undefined;
+    port: number | undefined;
+    maxBodyBytes: number | undefined;
+    dbHost: string | undefined;
+    dbPort: number | undefined;
+    dbName: string | undefined;
+    dbUser: string | undefined;
+    dbPass: string | undefined;
+    connectionLimit: number | undefined;
+    requireSigning: boolean;
+    keyId: string | undefined;
+    secret: string | undefined;
+    signingWindowMs: number | undefined;
+};
+export declare const addSqlProxyOptions: (command: Command, input: {
+    hostDefault: string;
+    portDefault: number;
+    maxBodyBytesDefault: number;
+    dbVendorLabel: string;
+    requireSigningDefault: boolean;
+    keyIdDefault: string;
+    secretDefault: string;
+    signingWindowMsDefault: number;
+}) => void;
+export declare const parseSqlProxyStartOptions: (options: SqlProxyCommandOptions) => ParsedSqlProxyStartOptions;
+export declare const runSqlProxyCommand: (options: SqlProxyCommandOptions, start: (input: ReturnType<typeof parseSqlProxyStartOptions>) => Promise<void>) => Promise<void>;
+//# sourceMappingURL=SqlProxyCommandUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SqlProxyCommandUtils.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SqlProxyCommandUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAMvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG;IACvC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,cAAc,EAAE,OAAO,CAAC;IACxB,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACrC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,OAAO,EAChB,OAAO;IACL,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE,OAAO,CAAC;IAC/B,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,sBAAsB,EAAE,MAAM,CAAC;CAChC,KACA,IAyBF,CAAC;AAEF,eAAO,MAAM,yBAAyB,GACpC,SAAS,sBAAsB,KAC9B,0BA6BF,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,sBAAsB,EAC/B,OAAO,CAAC,KAAK,EAAE,UAAU,CAAC,OAAO,yBAAyB,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,KAC5E,OAAO,CAAC,IAAI,CAGd,CAAC"}

package/src/cli/commands/SqlProxyCommandUtils.js

@@ -0,0 +1,48 @@
+import { maybeRunProxyWatchMode, parseIntOption, trimOption, } from '../commands/ProxyCommandUtils.js';
+export const addSqlProxyOptions = (command, input) => {
+    command.option('--host <host>', 'Host to bind', input.hostDefault);
+    command.option('--port <port>', 'Port to bind', String(input.portDefault));
+    command.option('--max-body-bytes <bytes>', 'Max request size in bytes', String(input.maxBodyBytesDefault));
+    command.option('--watch', 'Auto-restart proxy on file changes');
+    command.option('--db-host <host>', `${input.dbVendorLabel} host`);
+    command.option('--db-port <port>', `${input.dbVendorLabel} port`);
+    command.option('--db-name <name>', `${input.dbVendorLabel} database`);
+    command.option('--db-user <user>', `${input.dbVendorLabel} username`);
+    command.option('--db-pass <pass>', `${input.dbVendorLabel} password`);
+    command.option('--connection-limit <max>', `${input.dbVendorLabel} connection pool limit`);
+    command.option('--require-signing', 'Require signed requests', input.requireSigningDefault);
+    command.option('--key-id <id>', 'Signing key id', input.keyIdDefault);
+    command.option('--secret <secret>', 'Signing secret', input.secretDefault);
+    command.option('--signing-window-ms <ms>', 'Signing time window in ms', String(input.signingWindowMsDefault));
+};
+export const parseSqlProxyStartOptions = (options) => {
+    const host = trimOption(options.host);
+    const port = parseIntOption(options.port, 'port');
+    const maxBodyBytes = parseIntOption(options.maxBodyBytes, 'max-body-bytes');
+    const dbHost = trimOption(options.dbHost);
+    const dbPort = parseIntOption(options.dbPort, 'db-port');
+    const dbName = trimOption(options.dbName);
+    const dbUser = trimOption(options.dbUser);
+    const dbPass = options.dbPass;
+    const connectionLimit = parseIntOption(options.connectionLimit, 'connection-limit');
+    const signingWindowMs = parseIntOption(options.signingWindowMs, 'signing-window-ms');
+    return {
+        host,
+        port,
+        maxBodyBytes,
+        dbHost,
+        dbPort,
+        dbName,
+        dbUser,
+        dbPass,
+        connectionLimit,
+        requireSigning: options.requireSigning === true,
+        keyId: options.keyId,
+        secret: options.secret,
+        signingWindowMs,
+    };
+};
+export const runSqlProxyCommand = async (options, start) => {
+    await maybeRunProxyWatchMode(options.watch);
+    await start(parseSqlProxyStartOptions(options));
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"SqlServerProxyCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SqlServerProxyCommand.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA2DpC,eAAO,MAAM,qBAAqB;cACtB,OAAO;EAsEjB,CAAC"}

package/src/cli/commands/SqlServerProxyCommand.js

@@ -0,0 +1,85 @@
+import { Env } from '../../config/env.js';
+import { Logger } from '../../config/logger.js';
+import { Command } from 'commander';
+const startWatchMode = async (options) => {
+    Logger.info('Starting SQL Server proxy in watch mode...');
+    const { watch } = await import('node:fs');
+    const { spawn } = await import('node:child_process');
+    let child = null;
+    const startProxy = () => {
+        if (child) {
+            child.kill();
+        }
+        const args = ['run', 'cli', 'proxy:sqlserver'];
+        Object.entries(options).forEach(([key, value]) => {
+            if (key !== 'watch' && value !== undefined) {
+                args.push(`--${key}`, String(value));
+            }
+        });
+        child = spawn('npm', args, { stdio: 'inherit' });
+    };
+    const watcher = watch('./src', { recursive: true }, (_eventType, filename) => {
+        if (filename !== null &&
+            filename.length > 0 &&
+            (filename.endsWith('.ts') || filename.endsWith('.js'))) {
+            Logger.info(`File changed: ${String(filename)}, restarting proxy...`);
+            startProxy();
+        }
+    });
+    startProxy();
+    process.on('SIGINT', () => {
+        watcher.close();
+        if (child)
+            child.kill();
+        process.exit(0);
+    });
+};
+export const SqlServerProxyCommand = Object.freeze({
+    create() {
+        const cmd = new Command('proxy:sqlserver');
+        cmd.description('Start SQL Server HTTP proxy server');
+        const configureOptions = () => {
+            cmd.option('--host <host>', 'Proxy host', Env.get('SQLSERVER_PROXY_HOST', '127.0.0.1'));
+            cmd.option('--port <port>', 'Proxy port', String(Env.getInt('SQLSERVER_PROXY_PORT', 8793)));
+            cmd.option('--db-host <host>', 'SQL Server host', Env.get('DB_HOST_MSSQL', '127.0.0.1'));
+            cmd.option('--db-port <port>', 'SQL Server port', String(Env.getInt('DB_PORT_MSSQL', 1433)));
+            cmd.option('--db-name <name>', 'Database name', Env.get('DB_DATABASE_MSSQL', 'zintrust'));
+            cmd.option('--db-user <user>', 'Database user', Env.get('DB_USERNAME_MSSQL', 'sa'));
+            cmd.option('--db-pass <pass>', 'Database password', Env.get('DB_PASSWORD_MSSQL', ''));
+            cmd.option('--connection-limit <limit>', 'Connection pool limit', String(Env.getInt('SQLSERVER_PROXY_POOL_LIMIT', 10)));
+            cmd.option('--key-id <keyId>', 'Signing key ID', Env.get('SQLSERVER_PROXY_KEY_ID', 'default'));
+            cmd.option('--secret <secret>', 'Signing secret', Env.get('SQLSERVER_PROXY_SECRET', ''));
+            cmd.option('--require-signing', 'Require request signing', Env.SQLSERVER_PROXY_REQUIRE_SIGNING);
+            cmd.option('--signing-window-ms <ms>', 'Signing window in milliseconds', String(Env.getInt('SQLSERVER_PROXY_SIGNING_WINDOW_MS', 60000)));
+            cmd.option('--watch', 'Watch mode: restart on file changes');
+        };
+        const buildServerConfig = (options) => ({
+            host: String(options['host']),
+            port: Number(options['port']),
+            dbHost: String(options['dbHost']),
+            dbPort: Number(options['dbPort']),
+            dbName: String(options['dbName']),
+            dbUser: String(options['dbUser']),
+            dbPass: String(options['dbPass']),
+            connectionLimit: Number(options['connectionLimit']),
+            keyId: String(options['keyId']),
+            secret: String(options['secret']),
+            requireSigning: Boolean(options['requireSigning']),
+            signingWindowMs: Number(options['signingWindowMs']),
+        });
+        const startNormalMode = async (options) => {
+            const { SqlServerProxyServer } = await import('../../proxy/sqlserver/SqlServerProxyServer.js');
+            await SqlServerProxyServer.start(buildServerConfig(options));
+        };
+        const execute = async (options) => {
+            if (options['watch'] === true) {
+                await startWatchMode(options);
+                return;
+            }
+            await startNormalMode(options);
+        };
+        configureOptions();
+        cmd.action(execute);
+        return cmd;
+    },
+});

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;AAobvF,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;AAqkBvF,eAAO,MAAM,YAAY;cACb,YAAY;EA0BtB,CAAC"}