@zintrust/core 0.1.0

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

@@ -0,0 +1,15 @@
+/**
+ * Config Command - Configuration management CLI command
+ * Handles configuration operations: get, set, list, reset, edit, export
+ */
+import { IBaseCommand } from '../BaseCommand';
+/**
+ * Config Command Factory
+ */
+export declare const ConfigCommand: Readonly<{
+    /**
+     * Create a new config command instance
+     */
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=ConfigCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/ConfigCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA2T7E;;GAEG;AACH,eAAO,MAAM,aAAa;IACxB;;OAEG;cACO,YAAY;EA4EtB,CAAC"}

package/src/cli/commands/ConfigCommand.js

@@ -0,0 +1,273 @@
+/**
+ * Config Command - Configuration management CLI command
+ * Handles configuration operations: get, set, list, reset, edit, export
+ */
+import { BaseCommand } from '../BaseCommand';
+import { ConfigManager } from '../config/ConfigManager';
+import { ConfigValidator } from '../config/ConfigValidator';
+import { ErrorHandler } from '../ErrorHandler';
+import { PromptHelper } from '../PromptHelper';
+import { Logger } from '../../config/logger';
+import chalk from 'chalk';
+const addOptions = (command) => {
+    command.argument('[action]', 'Action: get, set, list, reset, edit, export');
+    command.argument('[key]', 'Configuration key (for get/set)');
+    command.argument('[value]', 'Configuration value (for set)');
+    command.option('--global', 'Use global config instead of project config');
+    command.option('--json', 'Output as JSON');
+    command.option('--show-defaults', 'Show default values in list');
+};
+const getGlobalConfigManager = async () => ConfigManager.getGlobalConfig();
+const getProjectConfigManager = async () => ConfigManager.getProjectConfig();
+const formatConfigValue = (value) => {
+    if (value === undefined || value === null)
+        return chalk.gray('null');
+    if (typeof value === 'object')
+        return JSON.stringify(value, null, 2);
+    if (typeof value === 'boolean')
+        return value ? chalk.green('true') : chalk.red('false');
+    if (typeof value === 'number')
+        return chalk.yellow(value.toString());
+    return String(value);
+};
+const parseConfigValue = (value) => {
+    if (value === undefined)
+        return undefined;
+    if (value === '')
+        return '';
+    const lower = value.toLowerCase();
+    if (lower === 'true')
+        return true;
+    if (lower === 'false')
+        return false;
+    if (lower === 'null')
+        return null;
+    if (/^-?\d+$/.test(value))
+        return Number.parseInt(value, 10);
+    if (/^-?\d+\.\d+$/.test(value))
+        return Number.parseFloat(value);
+    if (value.startsWith('{') || value.startsWith('[')) {
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            Logger.error('Failed to parse JSON config value', error);
+            return value;
+        }
+    }
+    return value;
+};
+const displayValidationStatus = (cmd, config) => {
+    const validation = ConfigValidator.validate(config);
+    if (validation?.valid === true) {
+        cmd.info(chalk.green('  ✅ Configuration is valid'));
+        return;
+    }
+    const errors = validation?.errors ?? [];
+    cmd.info(chalk.red(`  ❌ Configuration has ${errors.length} errors:`));
+    for (const error of errors) {
+        cmd.info(chalk.red(`     - ${error}`));
+    }
+};
+const displayConfigurationKeys = (cmd, keys) => {
+    const sorted = keys.slice().sort((a, b) => a.localeCompare(b));
+    cmd.info(chalk.cyan('\n  Available Keys:'));
+    for (const key of sorted) {
+        cmd.info(`  • ${key}`);
+    }
+};
+const displayConfigurationValues = (cmd, config) => {
+    cmd.info('');
+    const entries = Object.entries(config).sort(([a], [b]) => a.localeCompare(b));
+    for (const [key, value] of entries) {
+        cmd.info(`${chalk.cyan(key)}: ${formatConfigValue(value)}`);
+    }
+};
+const handleGet = async (cmd, manager, key) => {
+    if (key === undefined) {
+        ErrorHandler.usageError('Configuration key is required for "get"');
+        return;
+    }
+    if (typeof manager.get !== 'function') {
+        cmd.warn('Configuration manager does not support "get"');
+        return;
+    }
+    const value = manager.get(key);
+    if (value === undefined) {
+        cmd.warn(`Configuration key "${key}" not found`);
+        return;
+    }
+    cmd.info(formatConfigValue(value));
+};
+const handleSet = async (cmd, manager, key, value) => {
+    if (key === undefined || value === undefined) {
+        ErrorHandler.usageError('Both key and value are required for "set"');
+        return;
+    }
+    if (typeof manager.set !== 'function') {
+        cmd.warn('Configuration manager does not support "set"');
+        return;
+    }
+    const parsedValue = parseConfigValue(value);
+    const validationError = ConfigValidator.validateValue(key, parsedValue);
+    if (validationError) {
+        cmd.warn(`Validation error for "${key}": ${validationError}`);
+        return;
+    }
+    manager.set(key, parsedValue);
+    if (typeof manager.save === 'function') {
+        await manager.save();
+    }
+    cmd.success(`Configuration updated: ${key} = ${value}`);
+};
+const handleList = async (cmd, manager, options) => {
+    if (options['json'] === true && typeof manager.export === 'function') {
+        cmd.info(manager.export());
+        return;
+    }
+    const config = typeof manager.getConfig === 'function' ? manager.getConfig() : {};
+    cmd.info(chalk.bold('\n🛠️  Current Configuration:\n'));
+    displayValidationStatus(cmd, config);
+    displayConfigurationKeys(cmd, Object.keys(config));
+    displayConfigurationValues(cmd, config);
+    if (options['showDefaults'] === true) {
+        cmd.info(chalk.gray('\n(Default values shown above)'));
+    }
+};
+const handleReset = async (cmd, manager) => {
+    const confirmed = await PromptHelper.confirm('Are you sure you want to reset configuration to defaults?', false);
+    if (!confirmed) {
+        cmd.info('Reset cancelled');
+        return;
+    }
+    if (typeof manager.reset === 'function') {
+        await manager.reset();
+    }
+    cmd.success('Configuration reset to defaults');
+};
+const editSingleConfig = async (cmd, manager, selectedKey) => {
+    const currentValue = typeof manager.get === 'function' ? manager.get(selectedKey) : undefined;
+    let defaultValue = '';
+    if (currentValue !== undefined) {
+        defaultValue =
+            typeof currentValue === 'object' ? JSON.stringify(currentValue) : String(currentValue);
+    }
+    const newValue = await PromptHelper.textInput(`Enter new value for "${selectedKey}":`, defaultValue);
+    if (newValue === undefined)
+        return;
+    const parsedValue = parseConfigValue(newValue);
+    const validationError = ConfigValidator.validateValue(selectedKey, parsedValue);
+    if (validationError) {
+        cmd.warn(`Validation error: ${validationError}`);
+        return;
+    }
+    if (typeof manager.set === 'function') {
+        manager.set(selectedKey, parsedValue);
+    }
+    if (typeof manager.save === 'function') {
+        await manager.save();
+    }
+    cmd.success(`Updated ${selectedKey}`);
+};
+const handleEdit = async (cmd, manager) => {
+    cmd.info(chalk.bold('\n📝 Interactive Configuration Editor\n'));
+    const config = typeof manager.getConfig === 'function' ? manager.getConfig() : {};
+    const keys = Object.keys(config);
+    const fallbackKeys = typeof manager.getAllKeys === 'function' ? manager.getAllKeys() : [];
+    const availableKeys = keys.length > 0 ? keys : fallbackKeys;
+    if (availableKeys.length === 0) {
+        cmd.warn('No configuration keys found');
+        return;
+    }
+    const menuKeys = [...availableKeys].sort((a, b) => a.localeCompare(b)).concat(['(Done)']);
+    while (true) {
+        const selectedKey = await PromptHelper.chooseFrom('Select configuration key to edit:', menuKeys);
+        if (selectedKey === '' || selectedKey === '(Done)')
+            break;
+        await editSingleConfig(cmd, manager, selectedKey);
+    }
+    cmd.success('Configuration editing complete');
+};
+const handleExport = (cmd, manager) => {
+    cmd.info(typeof manager.export === 'function' ? manager.export() : '{}');
+};
+const isUnknownArray = (value) => Array.isArray(value);
+const getArg = (args, index) => {
+    if (!isUnknownArray(args))
+        return undefined;
+    const value = args[index];
+    return typeof value === 'string' ? value : undefined;
+};
+const executeConfig = async (cmd, options) => {
+    const typedCmd = cmd;
+    const command = cmd.getCommand();
+    const toRecord = (value) => {
+        if (value === null || typeof value !== 'object' || Array.isArray(value))
+            return {};
+        return value;
+    };
+    const commandOpts = typeof command.opts === 'function' ? toRecord(command.opts()) : {};
+    const mergedOptions = {
+        ...commandOpts,
+        ...options,
+    };
+    const action = getArg(options.args, 0) ?? getArg(command.args, 0) ?? 'list';
+    const key = getArg(options.args, 1) ?? getArg(command.args, 1);
+    const value = getArg(options.args, 2) ?? getArg(command.args, 2);
+    const manager = await typedCmd.getConfigManager(mergedOptions['global'] === true);
+    await typedCmd.handleAction(action, manager, key, value, mergedOptions);
+};
+/**
+ * Config Command Factory
+ */
+export const ConfigCommand = Object.freeze({
+    /**
+     * Create a new config command instance
+     */
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'config',
+            description: 'Manage application configuration',
+            addOptions,
+            execute: async (options) => executeConfig(cmd, options),
+        });
+        cmd.getConfigManager = async (isGlobal) => isGlobal ? getGlobalConfigManager() : getProjectConfigManager();
+        cmd.handleGet = async (manager, key, value) => handleGet(cmd, manager, key ?? value);
+        cmd.handleSet = async (manager, key, value) => handleSet(cmd, manager, key, value);
+        cmd.handleList = async (manager, options) => handleList(cmd, manager, options);
+        cmd.handleReset = async (manager) => handleReset(cmd, manager);
+        cmd.handleEdit = async (manager) => handleEdit(cmd, manager);
+        cmd.handleExport = (manager) => handleExport(cmd, manager);
+        cmd.handleAction = async (action, manager, key, value, options) => {
+            switch (action.toLowerCase()) {
+                case 'get':
+                    await cmd.handleGet(manager, key, value);
+                    return;
+                case 'set':
+                    await cmd.handleSet(manager, key, value, options);
+                    return;
+                case 'list':
+                    await cmd.handleList(manager, options ?? {});
+                    return;
+                case 'reset':
+                    await cmd.handleReset(manager);
+                    return;
+                case 'edit':
+                    await cmd.handleEdit(manager);
+                    return;
+                case 'export':
+                    cmd.handleExport(manager);
+                    return;
+                default:
+                    ErrorHandler.usageError(`Unknown action: ${action}`);
+            }
+        };
+        cmd.parseConfigValue = (value) => parseConfigValue(value);
+        cmd.formatConfigValue = (value) => formatConfigValue(value);
+        cmd.displayValidationStatus = (config) => displayValidationStatus(cmd, config);
+        cmd.displayConfigurationKeys = (keys) => displayConfigurationKeys(cmd, keys);
+        cmd.displayConfigurationValues = (config) => displayConfigurationValues(cmd, config);
+        cmd.editSingleConfig = async (manager, selectedKey) => editSingleConfig(cmd, manager, selectedKey);
+        return cmd;
+    },
+});

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

@@ -0,0 +1,15 @@
+import { IBaseCommand } from '../BaseCommand';
+/**
+ * D1 Migrate Command
+ * Run Cloudflare D1 migrations using Wrangler
+ */
+/**
+ * D1 Migrate Command Factory
+ */
+export declare const D1MigrateCommand: Readonly<{
+    /**
+     * Create a new D1 migrate command instance
+     */
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=D1MigrateCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"D1MigrateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/D1MigrateCommand.ts"],"names":[],"mappings":"AAQA,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAiD7E;;;GAGG;AAEH;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;cACO,YAAY;EAqBtB,CAAC"}

package/src/cli/commands/D1MigrateCommand.js

@@ -0,0 +1,73 @@
+import { appConfig } from '../../config/app';
+/**
+ * D1 Migrate Command
+ * Run Cloudflare D1 migrations using Wrangler
+ */
+import { resolveNpmPath } from '../../common';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { BaseCommand } from '../BaseCommand';
+import { Logger } from '../../config/logger';
+import { execFileSync } from '../../node-singletons/child-process';
+const runWrangler = async (cmd, args) => {
+    const npmPath = resolveNpmPath();
+    cmd.debug(`Executing: npm exec --yes -- wrangler ${args.join(' ')}`);
+    return execFileSync(npmPath, ['exec', '--yes', '--', 'wrangler', ...args], {
+        stdio: 'pipe',
+        encoding: 'utf8',
+        env: appConfig.getSafeEnv(),
+    });
+};
+const executeD1Migrate = async (cmd, options) => {
+    const isLocal = options['local'] === true || options['remote'] !== true;
+    const dbName = typeof options['database'] === 'string' ? options['database'] : 'zintrust_db';
+    const target = isLocal ? '--local' : '--remote';
+    cmd.info(`Running D1 migrations for ${dbName} (${isLocal ? 'local' : 'remote'})...`);
+    try {
+        const output = await runWrangler(cmd, ['d1', 'migrations', 'apply', dbName, target]);
+        if (output !== '')
+            cmd.info(output);
+        cmd.info('✓ D1 migrations completed successfully');
+    }
+    catch (error) {
+        Logger.error('D1 Migration failed', error);
+        ErrorFactory.createCliError('D1 Migration failed', error);
+        const err = error;
+        if (err.stdout !== undefined && err.stdout.length > 0)
+            cmd.info(err.stdout.toString());
+        if (err.stderr !== undefined && err.stderr.length > 0)
+            Logger.error('Wrangler stderr', err.stderr.toString());
+        if (err.stderr !== undefined && err.stderr.length > 0)
+            ErrorFactory.createCliError('Wrangler stderr', err.stderr.toString());
+        throw error;
+    }
+};
+/**
+ * D1 Migrate Command
+ * Run Cloudflare D1 migrations using Wrangler
+ */
+/**
+ * D1 Migrate Command Factory
+ */
+export const D1MigrateCommand = Object.freeze({
+    /**
+     * Create a new D1 migrate command instance
+     */
+    create() {
+        const addOptions = (command) => {
+            command
+                .option('--local', 'Run migrations against local D1 database')
+                .option('--remote', 'Run migrations against remote D1 database')
+                .option('--database <name>', 'D1 database name', 'zintrust_db');
+        };
+        const cmd = BaseCommand.create({
+            name: 'd1:migrate',
+            description: 'Run Cloudflare D1 migrations',
+            addOptions,
+            execute: async (options) => executeD1Migrate(cmd, options),
+        });
+        cmd.resolveNpmPath = () => resolveNpmPath();
+        cmd.getSafeEnv = () => appConfig.getSafeEnv();
+        cmd.runWrangler = async (args) => runWrangler(cmd, args);
+        return cmd;
+    },
+});

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

@@ -0,0 +1,15 @@
+/**
+ * Debug Command
+ * Launch debug mode with profiling and monitoring
+ */
+import { IBaseCommand } from '../BaseCommand';
+/**
+ * Debug Command Factory
+ */
+export declare const DebugCommand: Readonly<{
+    /**
+     * Create a new debug command instance
+     */
+    create: () => IBaseCommand;
+}>;
+//# sourceMappingURL=DebugCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DebugCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/DebugCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAwD7E;;GAEG;AACH,eAAO,MAAM,YAAY;IACvB;;OAEG;kBApBc,YAAY;EAsB7B,CAAC"}

package/src/cli/commands/DebugCommand.js

@@ -0,0 +1,52 @@
+/**
+ * Debug Command
+ * Launch debug mode with profiling and monitoring
+ */
+import { BaseCommand } from '../BaseCommand';
+import { Dashboard } from '../debug/Dashboard';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+const addOptions = (command) => {
+    command
+        .option('--port <number>', 'Debug server port', '3000')
+        .option('--enable-profiling', 'Enable memory profiling')
+        .option('--enable-tracing', 'Enable request tracing');
+};
+const executeDebug = (cmd, options) => {
+    cmd.info(`Debug command executed with options: ${JSON.stringify(options)}`);
+    try {
+        cmd.dashboard = Dashboard.create();
+        cmd.dashboard.start();
+        process.on('SIGINT', () => {
+            cmd.dashboard?.stop();
+            process.exit(0);
+        });
+    }
+    catch (error) {
+        cmd.dashboard?.stop();
+        throw ErrorFactory.createTryCatchError(`Debug failed: ${error.message}`, error);
+    }
+};
+/**
+ * Debug Command
+ * Launch debug mode with profiling and monitoring
+ */
+const create = () => {
+    const ext = (options) => executeDebug(cmd, options);
+    const cmd = BaseCommand.create({
+        name: 'debug',
+        description: 'Launch debug mode with real-time monitoring dashboard',
+        addOptions,
+        execute: ext,
+    });
+    cmd.dashboard = undefined;
+    return cmd;
+};
+/**
+ * Debug Command Factory
+ */
+export const DebugCommand = Object.freeze({
+    /**
+     * Create a new debug command instance
+     */
+    create,
+});

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

@@ -0,0 +1,15 @@
+/**
+ * Fix Command - Automated Code Cleanup
+ * Runs ESLint fix and other automated tools
+ */
+import { IBaseCommand } from '../BaseCommand';
+/**
+ * Fix Command Factory
+ */
+export declare const FixCommand: Readonly<{
+    /**
+     * Create a new fix command instance
+     */
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=FixCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FixCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/FixCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAqE7E;;GAEG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;cACO,YAAY;EAkBtB,CAAC"}

package/src/cli/commands/FixCommand.js

@@ -0,0 +1,80 @@
+/**
+ * Fix Command - Automated Code Cleanup
+ * Runs ESLint fix and other automated tools
+ */
+import { appConfig } from '../../config';
+import { BaseCommand } from '../BaseCommand';
+import { ErrorFactory } from '../../exceptions/ZintrustError';
+import { execFileSync } from '../../node-singletons/child-process';
+import fs from '../../node-singletons/fs';
+import * as path from '../../node-singletons/path';
+const resolveNpmPath = () => {
+    const nodeBinDir = path.dirname(process.execPath);
+    const candidates = process.platform === 'win32'
+        ? [path.join(nodeBinDir, 'npm.cmd'), path.join(nodeBinDir, 'npm.exe')]
+        : [path.join(nodeBinDir, 'npm')];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    throw ErrorFactory.createCliError('Unable to locate npm executable. Ensure Node.js (with npm) is installed in the standard location.');
+};
+const runNpmScript = (cmd, args) => {
+    const npmPath = resolveNpmPath();
+    cmd.debug(`Executing: npm run ${args.join(' ')}`);
+    execFileSync(npmPath, ['run', ...args], {
+        stdio: 'inherit',
+        encoding: 'utf8',
+        env: appConfig.getSafeEnv(),
+    });
+};
+const executeFix = async (cmd, options) => {
+    cmd.info('Starting automated code fixes...');
+    try {
+        const isDryRun = options['dryRun'] === true;
+        cmd.info('Running ESLint fix...');
+        try {
+            runNpmScript(cmd, ['lint', '--', isDryRun ? '--fix-dry-run' : '--fix']);
+        }
+        catch (error) {
+            ErrorFactory.createCliError('ESLint fix failed', error);
+            cmd.warn('ESLint fix encountered some issues, continuing...');
+        }
+        cmd.info('Running Prettier format...');
+        try {
+            runNpmScript(cmd, ['format']);
+        }
+        catch (error) {
+            ErrorFactory.createCliError('Prettier format failed', error);
+            cmd.warn('Prettier format encountered some issues.');
+        }
+        cmd.success('Code fixes completed successfully!');
+    }
+    catch (error) {
+        ErrorFactory.createCliError('Fix command failed', error);
+        cmd.warn('Some fixes could not be applied automatically.');
+    }
+};
+/**
+ * Fix Command Factory
+ */
+export const FixCommand = Object.freeze({
+    /**
+     * Create a new fix command instance
+     */
+    create() {
+        const addOptions = (command) => {
+            command.option('--dry-run', 'Show what would be fixed without applying changes');
+        };
+        const cmd = BaseCommand.create({
+            name: 'fix',
+            description: 'Run automated code fixes',
+            addOptions,
+            execute: async (options) => executeFix(cmd, options),
+        });
+        cmd.resolveNpmPath = () => resolveNpmPath();
+        cmd.getSafeEnv = () => appConfig.getSafeEnv();
+        cmd.runNpmExec = (args) => runNpmScript(cmd, args);
+        return cmd;
+    },
+});

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

@@ -0,0 +1,9 @@
+/**
+ * Key Generate Command
+ * Generates and sets the application key
+ */
+import { IBaseCommand } from '../BaseCommand';
+export declare const KeyGenerateCommand: Readonly<{
+    create(): IBaseCommand;
+}>;
+//# sourceMappingURL=KeyGenerateCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"KeyGenerateCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/KeyGenerateCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAO7E,eAAO,MAAM,kBAAkB;cACnB,YAAY;EAmEtB,CAAC"}

package/src/cli/commands/KeyGenerateCommand.js

@@ -0,0 +1,76 @@
+/**
+ * Key Generate Command
+ * Generates and sets the application key
+ */
+import { BaseCommand } from '../BaseCommand';
+import { Logger } from '../../config/logger';
+import * as crypto from '../../node-singletons/crypto';
+import { fsPromises as fs } from '../../node-singletons/fs';
+import * as path from '../../node-singletons/path';
+export const KeyGenerateCommand = Object.freeze({
+    create() {
+        return BaseCommand.create({
+            name: 'key:generate',
+            description: 'Set the application key',
+            addOptions: (command) => {
+                command.option('--show', 'Display the key instead of modifying files');
+                command.option('--force', 'Force the operation to run when in production');
+            },
+            execute: async (options) => {
+                const key = generateRandomKey();
+                if (options['show'] === true) {
+                    Logger.info(`Application key: [${key}]`);
+                    return;
+                }
+                const envPath = path.resolve(process.cwd(), '.env');
+                try {
+                    let envContent = '';
+                    try {
+                        envContent = await fs.readFile(envPath, 'utf-8');
+                    }
+                    catch (error) {
+                        Logger.warn('Could not read .env file, attempting to create from example', { error });
+                        // If .env doesn't exist, try to copy .env.example
+                        const examplePath = path.resolve(process.cwd(), '.env.example');
+                        try {
+                            envContent = await fs.readFile(examplePath, 'utf-8');
+                            await fs.writeFile(envPath, envContent);
+                            Logger.info('.env file created from .env.example');
+                        }
+                        catch (copyError) {
+                            Logger.error('Failed to create .env from example', { error: copyError });
+                            Logger.warn('.env file not found and .env.example not found. Creating new .env file.');
+                        }
+                    }
+                    // Backup existing key if present
+                    const appKeyMatch = /^APP_KEY=(.*)$/m.exec(envContent);
+                    const currentKey = appKeyMatch?.[1]?.trim();
+                    if (currentKey !== undefined && currentKey.length > 0) {
+                        const oldKey = currentKey;
+                        if (envContent.includes('APP_KEY_BK=')) {
+                            envContent = envContent.replace(/^APP_KEY_BK=.*$/m, `APP_KEY_BK=${oldKey}`);
+                        }
+                        else {
+                            envContent += `\nAPP_KEY_BK=${oldKey}`;
+                        }
+                    }
+                    if (envContent.includes('APP_KEY=')) {
+                        const regex = /^APP_KEY=.*/m;
+                        envContent = envContent.replace(regex, `APP_KEY=${key}`);
+                    }
+                    else {
+                        envContent += `\nAPP_KEY=${key}\n`;
+                    }
+                    await fs.writeFile(envPath, envContent);
+                    Logger.info(`Application key set successfully. [${key}]`);
+                }
+                catch (error) {
+                    Logger.error('Failed to update .env file', error);
+                }
+            },
+        });
+    },
+});
+function generateRandomKey() {
+    return 'base64:' + crypto.randomBytes(32).toString('base64');
+}

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

@@ -0,0 +1,19 @@
+/**
+ * LogsCommand - CLI command for viewing and managing logs
+ * Commands: zin logs, zin logs --follow, zin logs --level error, zin logs --clear
+ */
+import { IBaseCommand } from '../BaseCommand';
+import { Command } from 'commander';
+export declare const LogsCommand: Readonly<{
+    /**
+     * Create a new logs command instance
+     */
+    create(): IBaseCommand;
+    /**
+     * Register the command with Commander
+     * @deprecated Use create() instead
+     */
+    register(program: Command): void;
+}>;
+export default LogsCommand;
+//# sourceMappingURL=LogsCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LogsCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/LogsCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAA+B,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAM7E,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8KpC,eAAO,MAAM,WAAW;IACtB;;OAEG;cACO,YAAY;IAwBtB;;;OAGG;sBACe,OAAO,GAAG,IAAI;EAchC,CAAC;AAEH,eAAe,WAAW,CAAC"}