@zintrust/core 0.4.17 → 0.4.19

package/src/cli/services/VersionChecker.d.ts

@@ -0,0 +1,90 @@
+/**
+ * VersionChecker - CLI Version Update Notification Service
+ *
+ * Checks if the current CLI version is outdated and warns users
+ * when a newer version is available from npm registry.
+ */
+import { type IHttpResponse } from '../../tools/http/Http';
+interface VersionCheckResult {
+    currentVersion: string;
+    latestVersion: string;
+    isOutdated: boolean;
+    updateAvailable: boolean;
+}
+interface VersionCheckConfig {
+    enabled: boolean;
+    checkInterval: number;
+    skipVersionCheck: boolean;
+}
+export declare const VersionChecker: Readonly<{
+    /**
+     * Resolve the nearest package.json from a starting directory.
+     */
+    findNearestPackageJson(startDir: string): string | null;
+    /**
+     * Get current version from package.json
+     */
+    getCurrentVersion(): string;
+    /**
+     * Get version check configuration
+     */
+    getConfig(): VersionCheckConfig;
+    /**
+     * Check if version check should be performed
+     */
+    shouldCheckVersion(): boolean;
+    /**
+     * Fetch cached version if available and fresh
+     */
+    getCachedVersion(checkInterval: number): string | null;
+    /**
+     * Cache the latest version and timestamp
+     */
+    cacheLatestVersion(version: string): void;
+    /**
+     * Fetch latest version from npm registry
+     */
+    fetchLatestVersion(): Promise<string>;
+    /**
+     * Make request to npm registry
+     */
+    fetchFromNpmRegistry(): Promise<IHttpResponse>;
+    /**
+     * Handle HTTP errors from npm registry
+     */
+    handleHttpError(): string;
+    /**
+     * Extract version from npm registry response
+     */
+    extractVersionFromResponse(data: unknown): string;
+    /**
+     * Check if response data is valid object
+     */
+    isValidResponseData(data: unknown): data is Record<string, unknown>;
+    /**
+     * Extract version from dist-tags
+     */
+    getVersionFromDistTags(dataRecord: Record<string, unknown>): string | null;
+    /**
+     * Extract version from version field
+     */
+    getVersionFromField(dataRecord: Record<string, unknown>): string | null;
+    /**
+     * Compare versions using semver-like comparison
+     */
+    compareVersions(current: string, latest: string): number;
+    /**
+     * Perform version check and return result
+     */
+    checkVersion(): Promise<VersionCheckResult | null>;
+    /**
+     * Display update notification to user
+     */
+    displayUpdateNotification(result: VersionCheckResult): void;
+    /**
+     * Run version check and display notification if needed
+     */
+    runVersionCheck(): Promise<void>;
+}>;
+export {};
+//# sourceMappingURL=VersionChecker.d.ts.map

package/src/cli/services/VersionChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VersionChecker.d.ts","sourceRoot":"","sources":["../../../../src/cli/services/VersionChecker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAKlE,UAAU,kBAAkB;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,UAAU,kBAAkB;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,OAAO,CAAC;CAC3B;AAED,eAAO,MAAM,cAAc;IACzB;;OAEG;qCAC8B,MAAM,GAAG,MAAM,GAAG,IAAI;IAcvD;;OAEG;yBACkB,MAAM;IAkB3B;;OAEG;iBACU,kBAAkB;IAQ/B;;OAEG;0BACmB,OAAO;IAyC7B;;OAEG;oCAC6B,MAAM,GAAG,MAAM,GAAG,IAAI;IAwBtD;;OAEG;gCACyB,MAAM,GAAG,IAAI;IAezC;;OAEG;0BACyB,OAAO,CAAC,MAAM,CAAC;IA6B3C;;OAEG;4BAC2B,OAAO,CAAC,aAAa,CAAC;IAQpD;;OAEG;uBACgB,MAAM;IAIzB;;OAEG;qCAC8B,OAAO,GAAG,MAAM;IAuBjD;;OAEG;8BACuB,OAAO,GAAG,IAAI,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAInE;;OAEG;uCACgC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAY1E;;OAEG;oCAC6B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,GAAG,IAAI;IAQvE;;OAEG;6BACsB,MAAM,UAAU,MAAM,GAAG,MAAM;IAuBxD;;OAEG;oBACmB,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAyBxD;;OAEG;sCAC+B,kBAAkB,GAAG,IAAI;IA4B3D;;OAEG;uBACsB,OAAO,CAAC,IAAI,CAAC;EAUtC,CAAC"}

package/src/cli/services/VersionChecker.js

@@ -0,0 +1,315 @@
+/**
+ * VersionChecker - CLI Version Update Notification Service
+ *
+ * Checks if the current CLI version is outdated and warns users
+ * when a newer version is available from npm registry.
+ */
+import { HttpClient } from '../../tools/http/Http.js';
+import { existsSync, readFileSync } from '../../node-singletons/fs.js';
+import { dirname, join } from '../../node-singletons/path.js';
+import { fileURLToPath } from '../../node-singletons/url.js';
+export const VersionChecker = Object.freeze({
+    /**
+     * Resolve the nearest package.json from a starting directory.
+     */
+    findNearestPackageJson(startDir) {
+        let current = startDir;
+        for (let i = 0; i < 8; i++) {
+            const candidate = join(current, 'package.json');
+            if (existsSync(candidate))
+                return candidate;
+            const parent = dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        return null;
+    },
+    /**
+     * Get current version from package.json
+     */
+    getCurrentVersion() {
+        try {
+            const moduleDir = dirname(fileURLToPath(import.meta.url));
+            const modulePackagePath = this.findNearestPackageJson(moduleDir);
+            const cwdPackagePath = this.findNearestPackageJson(process.cwd());
+            const packagePath = modulePackagePath ?? cwdPackagePath;
+            if (packagePath === null)
+                return '0.0.0';
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            return typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+        }
+        catch {
+            return '0.0.0';
+        }
+    },
+    /**
+     * Get version check configuration
+     */
+    getConfig() {
+        return {
+            enabled: process.env['ZINTRUST_VERSION_CHECK'] !== 'false',
+            checkInterval: Number.parseInt(process.env['ZINTRUST_VERSION_CHECK_INTERVAL'] ?? '24', 10),
+            skipVersionCheck: process.env['ZINTRUST_SKIP_VERSION_CHECK'] === 'true',
+        };
+    },
+    /**
+     * Check if version check should be performed
+     */
+    shouldCheckVersion() {
+        const config = this.getConfig();
+        // Skip if disabled
+        if (!config.enabled || config.skipVersionCheck) {
+            return false;
+        }
+        // Skip for version commands
+        const args = new Set(process.argv.slice(2));
+        if (args.has('-v') ||
+            args.has('--version') ||
+            args.has('help') ||
+            args.has('new') ||
+            args.has('migrate') ||
+            // One-shot schedule commands should exit cleanly and not keep the event loop alive
+            // due to background network requests/keep-alive sockets.
+            args.has('schedule:run') ||
+            args.has('schedule:list')) {
+            return false;
+        }
+        // Check last check time
+        const lastCheckKey = 'zintrust_last_version_check';
+        const lastCheck = globalThis.localStorage?.getItem?.(lastCheckKey);
+        if (lastCheck !== null && lastCheck !== undefined) {
+            const lastCheckTime = Number.parseInt(lastCheck, 10);
+            const now = Date.now();
+            const hoursSinceLastCheck = (now - lastCheckTime) / (1000 * 60 * 60);
+            if (hoursSinceLastCheck < config.checkInterval) {
+                return false;
+            }
+        }
+        return true;
+    },
+    /**
+     * Fetch cached version if available and fresh
+     */
+    getCachedVersion(checkInterval) {
+        const LAST_CHECK_KEY = 'zintrust_last_version_check';
+        const CACHED_VERSION_KEY = 'zintrust_cached_latest_version';
+        try {
+            const ls = globalThis.localStorage;
+            if (!ls?.getItem)
+                return null;
+            const last = ls.getItem(LAST_CHECK_KEY);
+            const cached = ls.getItem(CACHED_VERSION_KEY);
+            if (last === null || cached === null)
+                return null;
+            const lastTime = Number.parseInt(last, 10);
+            if (Number.isNaN(lastTime))
+                return null;
+            const hoursSince = (Date.now() - lastTime) / (1000 * 60 * 60);
+            return hoursSince < checkInterval ? cached : null;
+        }
+        catch {
+            // Ignore localStorage failures
+            return null;
+        }
+    },
+    /**
+     * Cache the latest version and timestamp
+     */
+    cacheLatestVersion(version) {
+        const LAST_CHECK_KEY = 'zintrust_last_version_check';
+        const CACHED_VERSION_KEY = 'zintrust_cached_latest_version';
+        try {
+            const ls = globalThis.localStorage;
+            if (ls?.setItem) {
+                ls.setItem(CACHED_VERSION_KEY, version);
+                ls.setItem(LAST_CHECK_KEY, Date.now().toString());
+            }
+        }
+        catch {
+            // Best-effort caching
+        }
+    },
+    /**
+     * Fetch latest version from npm registry
+     */
+    async fetchLatestVersion() {
+        try {
+            const cfg = this.getConfig();
+            // Try to get cached version first
+            const cachedVersion = this.getCachedVersion(cfg.checkInterval);
+            if (cachedVersion !== null) {
+                return cachedVersion;
+            }
+            // Fetch from network
+            const response = await this.fetchFromNpmRegistry();
+            if (!response.ok) {
+                return this.handleHttpError();
+            }
+            const data = await response.json();
+            const latest = this.extractVersionFromResponse(data);
+            // Cache for future use
+            this.cacheLatestVersion(latest);
+            return latest;
+        }
+        catch {
+            // For network errors or other issues, don't block CLI usage
+            return this.getCurrentVersion();
+        }
+    },
+    /**
+     * Make request to npm registry
+     */
+    async fetchFromNpmRegistry() {
+        return HttpClient.get('https://registry.npmjs.org/@zintrust/core/latest')
+            .withHeader('Accept', 'application/json')
+            .withHeader('User-Agent', 'ZinTrust-CLI-Version-Check')
+            .withTimeout(5000) // 5 second timeout
+            .send();
+    },
+    /**
+     * Handle HTTP errors from npm registry
+     */
+    handleHttpError() {
+        return this.getCurrentVersion();
+    },
+    /**
+     * Extract version from npm registry response
+     */
+    extractVersionFromResponse(data) {
+        if (!this.isValidResponseData(data)) {
+            return this.getCurrentVersion();
+        }
+        const dataRecord = data;
+        // Try to get version from dist-tags.latest (standard npm response)
+        const latestVersion = this.getVersionFromDistTags(dataRecord);
+        if (latestVersion !== null && latestVersion !== undefined && latestVersion !== '') {
+            return latestVersion;
+        }
+        // Fallback to version field
+        const fallbackVersion = this.getVersionFromField(dataRecord);
+        if (fallbackVersion !== null && fallbackVersion !== undefined && fallbackVersion !== '') {
+            return fallbackVersion;
+        }
+        // Final fallback
+        return this.getCurrentVersion();
+    },
+    /**
+     * Check if response data is valid object
+     */
+    isValidResponseData(data) {
+        return data !== null && data !== undefined && typeof data === 'object';
+    },
+    /**
+     * Extract version from dist-tags
+     */
+    getVersionFromDistTags(dataRecord) {
+        const distTags = dataRecord['dist-tags'];
+        if (distTags !== null && distTags !== undefined) {
+            const distTagsRecord = distTags;
+            const latest = distTagsRecord['latest'];
+            if (typeof latest === 'string' && latest !== '') {
+                return latest;
+            }
+        }
+        return null;
+    },
+    /**
+     * Extract version from version field
+     */
+    getVersionFromField(dataRecord) {
+        const version = dataRecord['version'];
+        if (typeof version === 'string' && version !== '') {
+            return version;
+        }
+        return null;
+    },
+    /**
+     * Compare versions using semver-like comparison
+     */
+    compareVersions(current, latest) {
+        const cleanVersion = (version) => {
+            // Remove leading 'v' and trailing pre-release identifiers safely
+            // Using specific patterns instead of greedy quantifiers to prevent ReDoS
+            return version.replace(/^v/, '').replace(/-[^-]*$/, '');
+        };
+        const currentParts = cleanVersion(current).split('.').map(Number);
+        const latestParts = cleanVersion(latest).split('.').map(Number);
+        const maxLength = Math.max(currentParts.length, latestParts.length);
+        for (let i = 0; i < maxLength; i++) {
+            const currentPart = currentParts[i] || 0;
+            const latestPart = latestParts[i] || 0;
+            if (currentPart < latestPart)
+                return -1;
+            if (currentPart > latestPart)
+                return 1;
+        }
+        return 0;
+    },
+    /**
+     * Perform version check and return result
+     */
+    async checkVersion() {
+        if (!this.shouldCheckVersion()) {
+            return null;
+        }
+        try {
+            const currentVersion = this.getCurrentVersion();
+            const latestVersion = await this.fetchLatestVersion();
+            const comparison = this.compareVersions(currentVersion, latestVersion);
+            const isOutdated = comparison < 0;
+            const updateAvailable = isOutdated;
+            return {
+                currentVersion,
+                latestVersion,
+                isOutdated,
+                updateAvailable,
+            };
+        }
+        catch {
+            // Silently fail - version check should never block CLI usage
+            return null;
+        }
+    },
+    /**
+     * Display update notification to user
+     */
+    displayUpdateNotification(result) {
+        if (!result.updateAvailable) {
+            return;
+        }
+        const { currentVersion, latestVersion } = result;
+        // Use process.stdout.write for better control and to avoid eslint console errors
+        const output = [
+            '',
+            '⚠️  Update Available',
+            '┌' + '─'.repeat(50) + '┐',
+            `│ Current:  ${currentVersion.padEnd(40)}│`,
+            `│ Latest:   ${latestVersion.padEnd(40)}│`,
+            '└' + '─'.repeat(50) + '┘',
+            '',
+            '💡 Update to get the latest features and bug fixes:',
+            `   npm install -g @zintrust/core@${latestVersion}`,
+            '   or: npx @zintrust/core@latest [command]',
+            '',
+            '🔧 To disable version checks:',
+            '   export ZINTRUST_VERSION_CHECK=false',
+            '',
+        ].join('\n');
+        process.stdout.write(output);
+    },
+    /**
+     * Run version check and display notification if needed
+     */
+    async runVersionCheck() {
+        try {
+            const result = await this.checkVersion();
+            if (result) {
+                this.displayUpdateNotification(result);
+            }
+        }
+        catch {
+            // Version check should never crash the CLI
+        }
+    },
+});

package/src/cli/utils/DatabaseCliUtils.d.ts

@@ -0,0 +1,20 @@
+import type { CommandOptions, IBaseCommand } from '../BaseCommand';
+import type { DatabaseConfig as OrmDatabaseConfig } from '../../orm/DatabaseAdapter';
+export type ConnectionConfig = {
+    driver: string;
+    host?: string;
+    port?: number;
+    database?: string;
+    username?: string;
+    password?: string;
+};
+export declare const mapConnectionToOrmConfig: (conn: ConnectionConfig) => OrmDatabaseConfig;
+export declare const parseRollbackSteps: (options: CommandOptions) => number;
+export declare const confirmProductionRun: (params: {
+    cmd: IBaseCommand;
+    interactive: boolean;
+    message: string;
+    destructive?: boolean;
+    force?: boolean;
+}) => Promise<boolean>;
+//# sourceMappingURL=DatabaseCliUtils.d.ts.map

package/src/cli/utils/DatabaseCliUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatabaseCliUtils.d.ts","sourceRoot":"","sources":["../../../../src/cli/utils/DatabaseCliUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAIrE,OAAO,KAAK,EAAE,cAAc,IAAI,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAEhF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,MAAM,gBAAgB,KAAG,iBAwCjE,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS,cAAc,KAAG,MAG5D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAU,QAAQ;IACjD,GAAG,EAAE,YAAY,CAAC;IAClB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,KAAG,OAAO,CAAC,OAAO,CAalB,CAAC"}

package/src/cli/utils/DatabaseCliUtils.js

@@ -0,0 +1,59 @@
+import { PromptHelper } from '../PromptHelper.js';
+import { Env } from '../../config/env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+export const mapConnectionToOrmConfig = (conn) => {
+    switch (conn.driver) {
+        case 'd1':
+            return { driver: 'd1' };
+        case 'd1-remote':
+            return { driver: 'd1-remote' };
+        case 'sqlite':
+            return { driver: 'sqlite', database: conn.database ?? ':memory:' };
+        case 'postgresql':
+            return {
+                driver: 'postgresql',
+                host: conn.host,
+                port: conn.port,
+                database: conn.database,
+                username: conn.username,
+                password: conn.password,
+            };
+        case 'mysql':
+            return {
+                driver: 'mysql',
+                host: conn.host,
+                port: conn.port,
+                database: conn.database,
+                username: conn.username,
+                password: conn.password,
+            };
+        case 'sqlserver':
+            return {
+                driver: 'sqlserver',
+                host: conn.host,
+                port: conn.port,
+                database: conn.database,
+                username: conn.username,
+                password: conn.password,
+            };
+        default:
+            throw ErrorFactory.createCliError(`Unsupported database driver for ORM migrations: ${String(conn.driver)}`);
+    }
+};
+export const parseRollbackSteps = (options) => {
+    const stepRaw = typeof options['step'] === 'string' ? options['step'] : '1';
+    return Math.max(1, Number.parseInt(stepRaw, 10) || 1);
+};
+export const confirmProductionRun = async (params) => {
+    if (Env.NODE_ENV !== 'production')
+        return true;
+    if (params.force === true)
+        return true;
+    const prompt = params.destructive === true ? `${params.message} (destructive)` : params.message;
+    const confirmed = await PromptHelper.confirm(prompt, false, params.interactive);
+    if (!confirmed) {
+        params.cmd.warn('Cancelled.');
+        return false;
+    }
+    return true;
+};

package/src/cli/utils/DistPackager.d.ts

@@ -0,0 +1,8 @@
+export declare const DistPackager: Readonly<{
+    /**
+     * Creates minimal metadata so `dist/` can be installed via `file:/.../dist`.
+     * This is intended for local dev/simulate apps, not publishing.
+     */
+    prepare(distPath: string, rootPath?: string): void;
+}>;
+//# sourceMappingURL=DistPackager.d.ts.map

package/src/cli/utils/DistPackager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DistPackager.d.ts","sourceRoot":"","sources":["../../../../src/cli/utils/DistPackager.ts"],"names":[],"mappings":"AAsLA,eAAO,MAAM,YAAY;IACvB;;;OAGG;sBACe,MAAM,aAAY,MAAM,GAAmB,IAAI;EAgBjE,CAAC"}

package/src/cli/utils/DistPackager.js

@@ -0,0 +1,127 @@
+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';
+const readRootPackageJson = (rootPath) => {
+    const rootPackageJsonPath = path.join(rootPath, 'package.json');
+    if (!fs.existsSync(rootPackageJsonPath)) {
+        throw ErrorFactory.createConfigError(`Missing package.json at: ${rootPackageJsonPath}`);
+    }
+    try {
+        const raw = fs.readFileSync(rootPackageJsonPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw ErrorFactory.createTryCatchError('Failed to read root package.json', error);
+    }
+};
+const coerceDependencies = (value) => {
+    if (typeof value !== 'object' || value === null)
+        return {};
+    return value;
+};
+const buildDistPackageJson = (rootPkg) => {
+    const name = typeof rootPkg.name === 'string' && rootPkg.name.trim() !== ''
+        ? rootPkg.name
+        : '@zintrust/core';
+    const version = typeof rootPkg.version === 'string' && rootPkg.version.trim() !== ''
+        ? rootPkg.version
+        : '0.0.0';
+    return {
+        name,
+        version,
+        private: true,
+        type: 'module',
+        main: './index.js',
+        types: './index.d.ts',
+        bin: {
+            zintrust: './bin/zintrust.js',
+            zin: './bin/zin.js',
+            z: './bin/z.js',
+            zt: './bin/zt.js',
+        },
+        exports: {
+            '.': {
+                types: './index.d.ts',
+                default: './index.js',
+            },
+            './start': {
+                types: './start.d.ts',
+                default: './start.js',
+            },
+            './cli': {
+                types: './src/cli.d.ts',
+                default: './src/cli.js',
+            },
+            './proxy': {
+                types: './src/proxy.d.ts',
+                default: './src/proxy.js',
+            },
+            './collections': {
+                types: './src/collections/index.d.ts',
+                default: './src/collections/index.js',
+            },
+            './helper': {
+                types: './src/helper/index.d.ts',
+                default: './src/helper/index.js',
+            },
+            './node': {
+                types: './src/node.d.ts',
+                default: './src/node.js',
+            },
+            './routes/*': {
+                types: './routes/*.d.ts',
+                default: './routes/*.js',
+            },
+            './package.json': './package.json',
+        },
+        dependencies: coerceDependencies(rootPkg.dependencies),
+    };
+};
+const writeDistEntrypoints = (distPath) => {
+    const distIndexJsPath = path.join(distPath, 'index.js');
+    const distIndexDtsPath = path.join(distPath, 'index.d.ts');
+    const distStartJsPath = path.join(distPath, 'start.js');
+    const distStartDtsPath = path.join(distPath, 'start.d.ts');
+    fs.writeFileSync(distIndexJsPath, "export * from './src/index.js';\n");
+    fs.writeFileSync(distIndexDtsPath, "export * from './src/index';\n");
+    fs.writeFileSync(distStartJsPath, "export * from './src/start.js'; export { default } from './src/start.js';\n");
+    fs.writeFileSync(distStartDtsPath, "export * from './src/start'; export { default } from './src/start';\n");
+};
+const writeDistPackageJson = (distPath, pkg) => {
+    const distPackageJsonPath = path.join(distPath, 'package.json');
+    fs.writeFileSync(distPackageJsonPath, JSON.stringify(pkg, null, 2) + '\n');
+};
+const warnIfMissingDistArtifacts = (distPath) => {
+    const expected = [
+        path.join(distPath, 'src', 'index.js'),
+        path.join(distPath, 'bin', 'zintrust.js'),
+        path.join(distPath, 'bin', 'zin.js'),
+    ];
+    for (const candidate of expected) {
+        if (!fs.existsSync(candidate)) {
+            Logger.warn(`Dist artifact missing (did you run build?): ${candidate}`);
+        }
+    }
+    const docsRoot = path.join(distPath, 'public');
+    if (!fs.existsSync(docsRoot)) {
+        Logger.warn(`Docs public root missing at ${docsRoot} (expected dist/public)`);
+    }
+};
+export const DistPackager = Object.freeze({
+    /**
+     * Creates minimal metadata so `dist/` can be installed via `file:/.../dist`.
+     * This is intended for local dev/simulate apps, not publishing.
+     */
+    prepare(distPath, rootPath = process.cwd()) {
+        if (!fs.existsSync(distPath)) {
+            throw ErrorFactory.createConfigError(`Missing dist output at: ${distPath}. Run 'npm run build' first.`);
+        }
+        const rootPkg = readRootPackageJson(rootPath);
+        const distPkg = buildDistPackageJson(rootPkg);
+        writeDistPackageJson(distPath, distPkg);
+        writeDistEntrypoints(distPath);
+        warnIfMissingDistArtifacts(distPath);
+        Logger.info(`✅ Prepared dist package metadata at: ${path.join(distPath, 'package.json')}`);
+    },
+});

package/src/cli/utils/EnvFileLoader.d.ts

@@ -0,0 +1,26 @@
+type node_env = 'development' | 'production' | 'testing';
+type LoadOptions = {
+    cwd?: string;
+    includeCwd?: boolean;
+    extraCwds?: string[];
+    envPaths?: string[];
+    overrideExisting?: boolean;
+};
+type LoadState = {
+    loadedFiles: string[];
+    mode?: string;
+};
+type CliOverrides = {
+    nodeEnv?: node_env;
+    port?: number;
+    runtime?: string;
+    cacheEnabled?: boolean;
+};
+export declare const EnvFileLoader: Readonly<{
+    load: (options?: LoadOptions) => LoadState;
+    ensureLoaded: (options?: Omit<LoadOptions, "overrideExisting">) => LoadState;
+    applyCliOverrides: (overrides: CliOverrides) => void;
+    getState: () => LoadState;
+}>;
+export {};
+//# sourceMappingURL=EnvFileLoader.d.ts.map

package/src/cli/utils/EnvFileLoader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvFileLoader.d.ts","sourceRoot":"","sources":["../../../../src/cli/utils/EnvFileLoader.ts"],"names":[],"mappings":"AASA,KAAK,QAAQ,GAAG,aAAa,GAAG,YAAY,GAAG,SAAS,CAAC;AAmIzD,KAAK,WAAW,GAAG;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAaF,KAAK,YAAY,GAAG;IAClB,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAgMF,eAAO,MAAM,aAAa;qBAjDH,WAAW,KAAQ,SAAS;6BAapB,IAAI,CAAC,WAAW,EAAE,kBAAkB,CAAC,KAAQ,SAAS;mCAG/C,YAAY,KAAG,IAAI;oBA+BpC,SAAS;EAO5B,CAAC"}