@zintrust/core 0.1.39 → 0.1.41

package/src/cli/commands/RedisProxyCommand.js

@@ -0,0 +1,53 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { maybeRunProxyWatchMode, parseIntOption, trimOption, } from '../commands/ProxyCommandUtils.js';
+import { Env } from '../../config/env.js';
+import { RedisProxyServer } from '../../proxy/redis/RedisProxyServer.js';
+const addOptions = (command) => {
+    command.option('--host <host>', 'Host to bind', Env.get('REDIS_PROXY_HOST', '127.0.0.1'));
+    command.option('--port <port>', 'Port to bind', String(Env.getInt('REDIS_PROXY_PORT', 8791)));
+    command.option('--max-body-bytes <bytes>', 'Max request size in bytes', String(Env.getInt('REDIS_PROXY_MAX_BODY_BYTES', 131072)));
+    command.option('--watch', 'Auto-restart proxy on file changes');
+    command.option('--redis-host <host>', 'Redis host');
+    command.option('--redis-port <port>', 'Redis port');
+    command.option('--redis-password <password>', 'Redis password');
+    command.option('--redis-db <db>', 'Redis database');
+    command.option('--require-signing', 'Require signed requests', Env.REDIS_PROXY_REQUIRE_SIGNING);
+    command.option('--key-id <id>', 'Signing key id', Env.get('REDIS_PROXY_KEY_ID', ''));
+    command.option('--secret <secret>', 'Signing secret', Env.get('REDIS_PROXY_SECRET', ''));
+    command.option('--signing-window-ms <ms>', 'Signing time window in ms', String(Env.getInt('REDIS_PROXY_SIGNING_WINDOW_MS', 60000)));
+};
+export const RedisProxyCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'proxy:redis',
+            aliases: ['redis:proxy', 'redis-proxy', 'proxy:red'],
+            description: 'Start the Redis 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 redisHost = trimOption(options.redisHost);
+                const redisPort = parseIntOption(options.redisPort, 'redis-port', 'non-negative');
+                const redisPassword = options.redisPassword;
+                const redisDb = parseIntOption(options.redisDb, 'redis-db', 'non-negative');
+                const signingWindowMs = parseIntOption(options.signingWindowMs, 'signing-window-ms');
+                await RedisProxyServer.start({
+                    host,
+                    port,
+                    maxBodyBytes,
+                    redisHost,
+                    redisPort,
+                    redisPassword,
+                    redisDb,
+                    requireSigning: options.requireSigning === true,
+                    keyId: options.keyId,
+                    secret: options.secret,
+                    signingWindowMs,
+                });
+            },
+        });
+    },
+});
+export default RedisProxyCommand;

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

package/src/cli/commands/StartCommand.js

@@ -1,32 +1,51 @@
 import { BaseCommand } from '../BaseCommand.js';
-import { DENO_RUNNER_SOURCE, LAMBDA_RUNNER_SOURCE } from '../commands/runner/index.js';
+import { createDenoRunnerSource, createLambdaRunnerSource } from '../commands/runner/index.js';
 import { EnvFileLoader } from '../utils/EnvFileLoader.js';
 import { SpawnUtil } from '../utils/spawn.js';
 import { readEnvString } from '../../common/ExternalServiceUtils.js';
-import { resolveNpmPath } from '../../common/index.js';
+import * as Common from '../../common/index.js';
 import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from '../../node-singletons/fs.js';
 import * as path from '../../node-singletons/path.js';
+const resolveNpmPath = () => {
+    try {
+        return typeof Common.resolveNpmPath === 'function' ? Common.resolveNpmPath() : 'npm';
+    }
+    catch {
+        return 'npm';
+    }
+};
+const runFromSource = () => {
+    try {
+        return typeof Common.runFromSource === 'function' ? Common.runFromSource() : false;
+    }
+    catch {
+        return false;
+    }
+};
 const isValidModeInput = (value) => value === 'development' ||
     value === 'dev' ||
     value === 'production' ||
     value === 'pro' ||
     value === 'prod' ||
-    value === 'testing';
+    value === 'testing' ||
+    value === 'split';
 const normalizeMode = (value) => {
     if (value === 'production' || value === 'pro' || value === 'prod')
         return 'production';
     if (value === 'testing')
         return 'testing';
+    if (value === 'split')
+        return 'split';
     return 'development';
 };
 const resolveModeFromAppMode = () => {
-    const raw = readEnvString('APP_MODE').trim();
+    const raw = readEnvString('NODE_ENV').trim();
     const normalized = raw.toLowerCase();
     if (normalized === 'production' || normalized === 'pro' || normalized === 'prod') {
         return 'production';
     }
-    // Per spec: any other APP_MODE is treated as development.
+    // Per spec: any other NODE_ENV is treated as development.
     return 'development';
 };
 const resolveMode = (options) => {
@@ -76,6 +95,28 @@ const resolveStartVariant = (options) => {
         return 'lambda';
     return 'node';
 };
+const getMySqlProxyHint = () => {
+    const connection = readEnvString('DB_CONNECTION', '').toLowerCase();
+    if (connection !== 'mysql')
+        return null;
+    const proxyUrl = readEnvString('MYSQL_PROXY_URL', '').trim();
+    if (proxyUrl !== '')
+        return null;
+    const host = readEnvString('MYSQL_PROXY_HOST', '127.0.0.1').trim() || '127.0.0.1';
+    const port = readEnvString('MYSQL_PROXY_PORT', '8789').trim() || '8789';
+    return {
+        command: `zin proxy:mysql --host ${host} --port ${port}`,
+        url: `http://${host}:${port}`,
+    };
+};
+const logMySqlProxyHint = (cmd) => {
+    const hint = getMySqlProxyHint();
+    if (!hint)
+        return;
+    cmd.warn('MySQL proxy not configured for Cloudflare Workers. Start it in another terminal:');
+    cmd.warn(hint.command);
+    cmd.warn(`Then set MYSQL_PROXY_URL=${hint.url}`);
+};
 const hasFlag = (flag) => process.argv.includes(flag);
 const resolveWatchPreference = (options, mode) => {
     const hasWatch = hasFlag('--watch');
@@ -134,6 +175,14 @@ const resolveBootstrapEntryTs = (cwd) => {
         return 'src/boot/bootstrap.ts';
     return undefined;
 };
+const resolveRuntimeStartModuleSpecifier = (cwd) => {
+    const localStart = path.join(cwd, 'src/start.ts');
+    if (existsSync(localStart)) {
+        // Runner files are created under `<cwd>/tmp`, so `../src/start.ts` is stable.
+        return '../src/start.ts';
+    }
+    return '@zintrust/core/start';
+};
 const resolveNodeDevCommand = (cwd, packageJson) => {
     if (isFrameworkRepo(packageJson)) {
         const bootstrap = resolveBootstrapEntryTs(cwd);
@@ -160,15 +209,25 @@ const resolveNodeDevCommand = (cwd, packageJson) => {
 const resolveNodeProdCommand = (cwd) => {
     const compiledBoot = path.join(cwd, 'dist/src/boot/bootstrap.js');
     let compiled;
-    if (existsSync(compiledBoot)) {
+    if (existsSync(compiledBoot) && !runFromSource()) {
         compiled = 'dist/src/boot/bootstrap.js';
     }
+    // If compiled app isn't available (or the env forces running from source),
+    // fall back to running the source entry with `tsx` so developers can test
+    // core files with production semantics without building.
     if (compiled === undefined) {
-        throw ErrorFactory.createCliError("Error: Compiled app not found at dist/src/boot/bootstrap.js Run 'npm run build' first.");
+        const bootstrap = resolveBootstrapEntryTs(cwd);
+        if (bootstrap !== undefined) {
+            return { command: 'tsx', args: [bootstrap] };
+        }
+        if (existsSync(path.join(cwd, 'src/index.ts'))) {
+            return { command: 'tsx', args: ['src/index.ts'] };
+        }
+        throw ErrorFactory.createCliError("Error: Compiled app not found at dist/src/boot/bootstrap.js. Run 'npm run build' first or set ZINTRUST_RUN_FROM_SOURCE=1 to run source in production.");
     }
     return { command: 'node', args: [compiled] };
 };
-const executeWranglerStart = async (cmd, cwd, port, runtime) => {
+const executeWranglerStart = async (cmd, cwd, port, runtime, envName) => {
     if (runtime !== undefined) {
         throw ErrorFactory.createCliError('Error: --runtime is not supported with --wrangler (Wrangler controls Workers runtime).');
     }
@@ -184,8 +243,16 @@ const executeWranglerStart = async (cmd, cwd, port, runtime) => {
     if (typeof port === 'number') {
         wranglerArgs.push('--port', String(port));
     }
+    if (envName !== undefined && envName.trim() !== '') {
+        wranglerArgs.push('--env', envName.trim());
+    }
+    logMySqlProxyHint(cmd);
     cmd.info('Starting in Wrangler dev mode...');
-    const exitCode = await SpawnUtil.spawnAndWait({ command: 'wrangler', args: wranglerArgs });
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: 'wrangler',
+        args: wranglerArgs,
+        env: process.env,
+    });
     process.exit(exitCode);
 };
 const ensureTmpRunnerFile = (cwd, filename, content) => {
@@ -212,13 +279,14 @@ const executeDenoStart = async (cmd, cwd, mode, watchEnabled, _port, runtime) =>
     if (mode === 'testing') {
         throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use development or production.');
     }
-    const denoRunner = ensureTmpRunnerFile(cwd, 'zin-start-deno.ts', DENO_RUNNER_SOURCE);
+    const startModuleSpecifier = resolveRuntimeStartModuleSpecifier(cwd);
+    const denoRunner = ensureTmpRunnerFile(cwd, 'zin-start-deno.ts', createDenoRunnerSource(startModuleSpecifier));
     const args = [];
     if (mode === 'development' && watchEnabled)
         args.push('watch');
     args.push(denoRunner);
     cmd.info('Starting in Deno adapter mode...');
-    const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args });
+    const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args, env: process.env });
     process.exit(exitCode);
 };
 const executeLambdaStart = async (cmd, cwd, mode, watchEnabled, _port, runtime) => {
@@ -228,16 +296,17 @@ const executeLambdaStart = async (cmd, cwd, mode, watchEnabled, _port, runtime)
     if (mode === 'testing') {
         throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use development or production.');
     }
-    const lambdaRunner = ensureTmpRunnerFile(cwd, 'zin-start-lambda.ts', LAMBDA_RUNNER_SOURCE);
+    const startModuleSpecifier = resolveRuntimeStartModuleSpecifier(cwd);
+    const lambdaRunner = ensureTmpRunnerFile(cwd, 'zin-start-lambda.ts', createLambdaRunnerSource(startModuleSpecifier));
     const args = [];
     if (mode === 'development' && watchEnabled)
         args.push('watch');
     args.push(lambdaRunner);
     cmd.info('Starting in Lambda adapter mode...');
-    const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args });
+    const exitCode = await SpawnUtil.spawnAndWait({ command: 'tsx', args, env: process.env });
     process.exit(exitCode);
 };
-const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
+const executeNodeStart = async (cmd, cwd, mode, watchEnabled, _port) => {
     if (mode === 'testing') {
         throw ErrorFactory.createCliError('Error: Cannot start server in testing mode. Use --force to override (not supported).');
     }
@@ -250,6 +319,7 @@ const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
                 command: 'tsx',
                 args,
                 forwardSignals: false,
+                env: process.env,
             });
             process.exit(exitCode);
         }
@@ -260,6 +330,7 @@ const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
             command: dev.command,
             args: dev.args,
             forwardSignals: false,
+            env: process.env,
         });
         process.exit(exitCode);
     }
@@ -269,9 +340,56 @@ const executeNodeStart = async (cmd, cwd, mode, watchEnabled) => {
         command: prod.command,
         args: prod.args,
         forwardSignals: false,
+        env: process.env,
     });
     process.exit(exitCode);
 };
+const executeSplitStart = async (cmd, cwd, _options) => {
+    cmd.info('🚀 Starting in split mode (Producer + Consumer)...');
+    const packageJson = readPackageJson(cwd);
+    const webDev = resolveNodeDevCommand(cwd, packageJson);
+    // Producer Environment
+    const producerEnv = {
+        ...process.env,
+        WORKER_ENABLED: 'false',
+        QUEUE_ENABLED: 'true',
+        RUNTIME_MODE: 'node-server',
+    };
+    // Consumer Environment
+    const consumerEnv = {
+        ...process.env,
+        WORKER_ENABLED: 'true',
+        QUEUE_ENABLED: 'true',
+        RUNTIME_MODE: 'containers',
+        WORKER_AUTO_START: 'true',
+        // Prevent consumer from binding to the web port
+        APP_PORT: '0',
+        PORT: '0',
+    };
+    // Resolve Consumer Command (zintrust worker:start-all)
+    // We try to use tsx against the source bin if possible
+    const workerArgs = existsSync(path.join(cwd, 'bin/zin.ts'))
+        ? ['bin/zin.ts', 'worker:start-all']
+        : ['dist/bin/zin.js', 'worker:start-all'];
+    const workerCommand = existsSync(path.join(cwd, 'bin/zin.ts')) ? 'tsx' : 'node';
+    cmd.info('-------------------------------------------');
+    cmd.info('🔹 [Producer] Web Server starting...');
+    cmd.info('🔸 [Consumer] Worker Process starting...');
+    cmd.info('-------------------------------------------');
+    const pProducer = SpawnUtil.spawnAndWait({
+        command: webDev.command,
+        args: webDev.args,
+        env: producerEnv,
+        forwardSignals: true,
+    });
+    const pConsumer = SpawnUtil.spawnAndWait({
+        command: workerCommand,
+        args: workerArgs,
+        env: consumerEnv,
+        forwardSignals: true,
+    });
+    await Promise.all([pProducer, pConsumer]);
+};
 const executeStart = async (options, cmd) => {
     const cwd = process.cwd();
     EnvFileLoader.ensureLoaded();
@@ -279,16 +397,24 @@ const executeStart = async (options, cmd) => {
     const port = resolvePort(options);
     const runtime = resolveRuntime(options);
     const variant = resolveStartVariant(options);
+    const envName = typeof options.env === 'string' ? options.env.trim() : '';
     let effectiveRuntime = runtime;
     if (variant === 'deno')
         effectiveRuntime = 'deno';
     if (variant === 'lambda')
         effectiveRuntime = 'lambda';
+    if (mode === 'split') {
+        await executeSplitStart(cmd, cwd, options);
+        return;
+    }
     EnvFileLoader.applyCliOverrides({ nodeEnv: mode, port, runtime: effectiveRuntime });
     if (variant === 'wrangler') {
-        await executeWranglerStart(cmd, cwd, port, runtime);
+        await executeWranglerStart(cmd, cwd, port, runtime, envName === '' ? undefined : envName);
         return;
     }
+    if (envName !== '') {
+        throw ErrorFactory.createCliError('Error: --env is only supported with --wrangler/--wg.');
+    }
     const watchEnabled = resolveWatchPreference(options, mode);
     if (variant === 'deno') {
         await executeDenoStart(cmd, cwd, mode, watchEnabled, port, runtime);
@@ -298,22 +424,23 @@ const executeStart = async (options, cmd) => {
         await executeLambdaStart(cmd, cwd, mode, watchEnabled, port, runtime);
         return;
     }
-    await executeNodeStart(cmd, cwd, mode, watchEnabled);
+    await executeNodeStart(cmd, cwd, mode, watchEnabled, port);
 };
 export const StartCommand = Object.freeze({
     create() {
         const addOptions = (command) => {
             command.alias('s');
             command
-                .option('-w, --wrangler', 'Start with Wrangler dev mode (Cloudflare Workers)')
+                .option('--wrangler', 'Start with Wrangler dev mode (Cloudflare Workers)')
                 .option('--wg', 'Alias for --wrangler')
                 .option('--deno', 'Start a local server using the Deno runtime adapter')
                 .option('--lambda', 'Start a local server using the AWS Lambda runtime adapter')
                 .option('--watch', 'Force watch mode (Node only)')
                 .option('--no-watch', 'Disable watch mode (Node only)')
                 .option('--mode <development|production|testing>', 'Override app mode')
+                .option('--env <name>', 'Wrangler environment name (Wrangler mode only)')
                 .option('--runtime <nodejs|cloudflare|lambda|deno|auto>', 'Set RUNTIME for spawned Node')
-                .option('--port <number>', 'Override server port');
+                .option('-p, --port <number>', 'Override server port');
         };
         const cmd = BaseCommand.create({
             name: 'start',

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

@@ -10,6 +10,7 @@ export declare const WorkerCommands: {
     createWorkerListCommand: () => IBaseCommand;
     createWorkerStatusCommand: () => IBaseCommand;
     createWorkerStartCommand: () => IBaseCommand;
+    createWorkerStartAllCommand: () => IBaseCommand;
     createWorkerStopCommand: () => IBaseCommand;
     createWorkerRestartCommand: () => IBaseCommand;
     createWorkerSummaryCommand: () => IBaseCommand;

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

@@ -1 +1 @@
-{"version":3,"file":"WorkerCommands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/WorkerCommands.ts"],"names":[],"mappings":"AACA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmWrD;;GAEG;AACH,eAAO,MAAM,cAAc;mCAjPS,YAAY;qCA4CV,YAAY;oCAiDb,YAAY;mCA+Bb,YAAY;sCAgCT,YAAY;sCAgCZ,YAAY;CA4DlD,CAAC"}
+{"version":3,"file":"WorkerCommands.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/WorkerCommands.ts"],"names":[],"mappings":"AACA;;;GAGG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA2hBrD;;GAEG;AACH,eAAO,MAAM,cAAc;mCA/XS,YAAY;qCA4CV,YAAY;oCAiDb,YAAY;uCAkFT,YAAY;mCA0FhB,YAAY;sCAgCT,YAAY;sCAgCZ,YAAY;CA8DlD,CAAC"}