@zintrust/core 0.4.17 → 0.4.19

package/src/cli/commands/SecretsCommand.js

@@ -0,0 +1,91 @@
+/**
+ * Secrets Command
+ *
+ * CLI-first secrets sync using the core internal toolkit.
+ *
+ * Usage:
+ *   zin secrets pull   --provider aws|cloudflare [--manifest secrets.manifest.json] [--out .env.pull] [--dry-run]
+ *   zin secrets push   --provider aws|cloudflare [--manifest secrets.manifest.json] [--in .env] [--dry-run]
+ *   zin secrets doctor --provider aws|cloudflare
+ */
+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 getArg = (args, index) => {
+    if (!isArray(args))
+        return undefined;
+    const v = args[index];
+    return typeof v === 'string' ? v : undefined;
+};
+const coerceProvider = (provider) => provider === 'aws' || provider === 'cloudflare' ? provider : undefined;
+const parseOptions = (options) => {
+    const cwd = process.cwd();
+    const action = getArg(options.args, 0) ?? 'pull';
+    const provider = typeof options.provider === 'string' ? coerceProvider(options.provider) : undefined;
+    const manifestPath = typeof options.manifest === 'string' ? options.manifest : undefined;
+    const outFile = typeof options.out === 'string' ? options.out : undefined;
+    const inFile = typeof options.in === 'string' ? options.in : undefined;
+    const dryRun = options.dryRun === true;
+    return { cwd, action, provider, manifestPath, outFile, inFile, dryRun };
+};
+const addOptions = (command) => {
+    command
+        .argument('[action]', 'pull | push | doctor', 'pull')
+        .option('--provider <provider>', 'aws | cloudflare')
+        .option('--manifest <path>', 'Manifest path (default: secrets.manifest.json)', 'secrets.manifest.json')
+        .option('--out <path>', 'Output env file for pull (default: .env.pull)', '.env.pull')
+        .option('--in <path>', 'Input env file for push (default: .env)', '.env')
+        .option('--dry-run', 'Do not write/upload, just show what would change');
+};
+const execute = async (cmd, options) => {
+    const parsed = parseOptions(options);
+    switch (parsed.action) {
+        case 'pull': {
+            const result = await SecretsToolkit.pull({
+                cwd: parsed.cwd,
+                provider: parsed.provider,
+                manifestPath: parsed.manifestPath,
+                outFile: parsed.outFile,
+                dryRun: parsed.dryRun,
+            });
+            cmd.success(`Pulled ${result.keys.length} keys to ${result.outFile}${parsed.dryRun ? ' (dry-run)' : ''}`);
+            return;
+        }
+        case 'push': {
+            const result = await SecretsToolkit.push({
+                cwd: parsed.cwd,
+                provider: parsed.provider,
+                manifestPath: parsed.manifestPath,
+                inFile: parsed.inFile,
+                dryRun: parsed.dryRun,
+            });
+            cmd.success(`Pushed ${result.keys.length} keys from ${result.inFile}${parsed.dryRun ? ' (dry-run)' : ''}`);
+            return;
+        }
+        case 'doctor': {
+            const result = SecretsToolkit.doctor({ provider: parsed.provider });
+            if (result.ok) {
+                cmd.success(`Secrets doctor OK (${result.provider})`);
+            }
+            else {
+                cmd.warn(`Secrets doctor failed (${result.provider}). Missing: ${result.missing.join(', ')}`);
+            }
+            return;
+        }
+        default:
+            throw ErrorFactory.createCliError(`Unknown secrets action: ${parsed.action}`);
+    }
+};
+export const SecretsCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'secrets',
+            description: 'Pull/push secrets to local .env.pull via core toolkit',
+            addOptions,
+            execute: async (options) => execute(cmd, options),
+        });
+        return cmd;
+    },
+});
+export default SecretsCommand;

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

@@ -0,0 +1,12 @@
+/**
+ * Simulate Command
+ * Internal dev tool that generates a simulated ZinTrust app under ./simulate/
+ * IMPORTANT: this uses the same ProjectScaffolder as `zin new`.
+ * Usage: zin -sim my-blog
+ */
+import type { IBaseCommand } from '../BaseCommand';
+/**
+ * SimulateCommand - Generate simulated apps for testing
+ */
+export declare const SimulateCommand: IBaseCommand;
+//# sourceMappingURL=SimulateCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"SimulateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/SimulateCommand.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA+BrD;;GAEG;AACH,eAAO,MAAM,eAAe,EAuDvB,YAAY,CAAC"}

package/src/cli/commands/SimulateCommand.js

@@ -0,0 +1,79 @@
+/**
+ * Simulate Command
+ * Internal dev tool that generates a simulated ZinTrust app under ./simulate/
+ * IMPORTANT: this uses the same ProjectScaffolder as `zin new`.
+ * Usage: zin -sim my-blog
+ */
+import { ProjectScaffolder } from '../scaffolding/ProjectScaffolder.js';
+import { DistPackager } from '../utils/DistPackager.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import fs from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+import chalk from 'chalk';
+import { Command } from 'commander';
+const rewriteSimulatedAppDependencyToDist = (appPath, distPath) => {
+    const packageJsonPath = path.join(appPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw ErrorFactory.createCliError(`Missing simulated app package.json at: ${packageJsonPath}`);
+    }
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const dependencies = { ...pkg.dependencies };
+    dependencies['@zintrust/core'] = `file:${distPath}`;
+    const nextPkg = {
+        ...pkg,
+        dependencies,
+    };
+    fs.writeFileSync(packageJsonPath, JSON.stringify(nextPkg, null, 2) + '\n');
+};
+/**
+ * SimulateCommand - Generate simulated apps for testing
+ */
+export const SimulateCommand = {
+    name: 'simulate',
+    description: '[INTERNAL] Generate simulated ZinTrust app for testing new developer experience',
+    getCommand() {
+        const command = new Command('simulate')
+            .alias('-sim')
+            .alias('--sim')
+            .description('[INTERNAL DEV] Create a simulated ZinTrust application in simulate/ folder')
+            .argument('<name>', 'Name of the simulated app')
+            .action(async (appName) => {
+            try {
+                const simulateBasePath = path.join(process.cwd(), 'simulate');
+                if (!appName || appName.trim() === '') {
+                    throw ErrorFactory.createValidationError('App name is required');
+                }
+                // Delegate validation + file generation to the same scaffolder used by `zin new`.
+                Logger.info(`Creating simulated app via ProjectScaffolder: ${chalk.cyan(appName)}`);
+                const result = await ProjectScaffolder.scaffold(simulateBasePath, {
+                    name: appName,
+                    template: 'basic',
+                    database: 'sqlite',
+                    author: 'Internal',
+                    description: `Simulated ZinTrust app - ${appName}`,
+                });
+                if (!result.success) {
+                    throw ErrorFactory.createCliError(result.message, result.error);
+                }
+                const appPath = path.join(simulateBasePath, appName);
+                // For simulate apps only: install the locally-built framework from dist/
+                // so the dev experience matches "fresh install" of the current build output.
+                const distPath = path.join(process.cwd(), 'dist');
+                DistPackager.prepare(distPath, process.cwd());
+                rewriteSimulatedAppDependencyToDist(appPath, distPath);
+                Logger.info('✅ Simulated app created successfully!');
+                Logger.info(`📁 Location: ${chalk.cyan(appPath)}`);
+                Logger.info(`\n${chalk.bold('Next steps:')}`);
+                Logger.info(`  cd ${path.relative(process.cwd(), appPath)}`);
+                Logger.info('  npm install');
+                Logger.info('  zin start');
+            }
+            catch (error) {
+                Logger.error('Failed to create simulated app', error);
+                process.exit(1);
+            }
+        });
+        return command;
+    },
+};

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

@@ -0,0 +1,12 @@
+import { type IBaseCommand } from '../BaseCommand';
+export declare const StartCommand: Readonly<{
+    create(): IBaseCommand;
+    _helpers: {
+        isWranglerVarName: (value: string) => boolean;
+        toUpperSnakeCaseIdentifier: (value: string) => string;
+        isWindowsDriveAbsolutePath: (value: string) => boolean;
+        containsCommandToken: (value: string, command: string) => boolean;
+        containsZinCommand: (value: string) => boolean;
+    };
+}>;
+//# sourceMappingURL=StartCommand.d.ts.map

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

@@ -0,0 +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;AAmhCvF,eAAO,MAAM,YAAY;cACb,YAAY;;mCAr9BU,MAAM,KAAG,OAAO;4CAaP,MAAM,KAAG,MAAM;4CA4Bf,MAAM,KAAG,OAAO;sCAetB,MAAM,WAAW,MAAM,KAAG,OAAO;oCAmBnC,MAAM,KAAG,OAAO;;EAq7BjD,CAAC"}