@zintrust/core 0.1.28 → 0.1.30

package/src/cli/commands/DbSeedCommand.js

@@ -0,0 +1,139 @@
+/**
+ * Db Seed Command
+ * Run database seeders from database/seeders
+ */
+import { SeederDiscovery } from '../../seeders/SeederDiscovery.js';
+import { SeederLoader } from '../../seeders/SeederLoader.js';
+import { BaseCommand } from '../BaseCommand.js';
+import { confirmProductionRun, mapConnectionToOrmConfig } from '../utils/DatabaseCliUtils.js';
+import { databaseConfig } from '../../config/database.js';
+import { Env } from '../../config/env.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { resetDatabase, useDatabase } from '../../orm/Database.js';
+const addSeedOptions = (command) => {
+    command
+        .option('--dir <path>', 'Seeders directory (relative to project root)', databaseConfig.seeders.directory)
+        .option('--service <domain/name>', 'Run global + service-local seeders')
+        .option('--only-service <domain/name>', 'Run only service-local seeders')
+        .option('--no-interactive', 'Skip interactive prompts');
+};
+const getInteractive = (options) => options['interactive'] !== false && Env.CI !== 'true';
+const ensureNonD1Driver = (driver) => {
+    if (driver === 'd1' || driver === 'd1-remote') {
+        throw ErrorFactory.createCliError('This project is configured for D1. Seeding via `zin db:seed` is not supported yet.');
+    }
+};
+const getServiceArgs = (options) => {
+    let serviceArg;
+    if (typeof options['onlyService'] === 'string') {
+        serviceArg = String(options['onlyService']);
+    }
+    else if (typeof options['service'] === 'string') {
+        serviceArg = String(options['service']);
+    }
+    const includeGlobal = typeof options['onlyService'] !== 'string';
+    return { service: serviceArg, includeGlobal };
+};
+const parseServiceRef = (raw) => {
+    const trimmed = raw.trim();
+    const parts = trimmed.split('/').filter((p) => p.trim().length > 0);
+    if (parts.length !== 2) {
+        throw ErrorFactory.createCliError(`Invalid service reference: '${raw}'. Expected format: <domain>/<name>`);
+    }
+    return { domain: parts[0], name: parts[1] };
+};
+const normalizeSeederNameArg = (raw) => {
+    const trimmed = raw.trim();
+    if (trimmed.endsWith('.ts'))
+        return trimmed.slice(0, -3);
+    if (trimmed.endsWith('.js'))
+        return trimmed.slice(0, -3);
+    return trimmed;
+};
+const selectSeederFiles = (files, seederName) => {
+    if (seederName !== undefined) {
+        return files.filter((filePath) => {
+            const base = filePath.split('/').pop() ?? '';
+            const withoutExt = base.replace(/\.(ts|js)$/u, '');
+            return withoutExt === seederName;
+        });
+    }
+    const databaseSeeder = files.find((filePath) => {
+        const base = filePath.split('/').pop() ?? '';
+        const withoutExt = base.replace(/\.(ts|js)$/u, '');
+        return withoutExt === 'DatabaseSeeder';
+    });
+    if (databaseSeeder !== undefined)
+        return [databaseSeeder];
+    return files;
+};
+const executeSeed = async (options, cmd) => {
+    const interactive = getInteractive(options);
+    const okToProceed = await confirmProductionRun({
+        cmd,
+        interactive,
+        message: 'NODE_ENV=production. Continue running seeders?',
+    });
+    if (!okToProceed)
+        return;
+    const conn = databaseConfig.getConnection();
+    ensureNonD1Driver(conn.driver);
+    const ormConfig = mapConnectionToOrmConfig(conn);
+    const db = useDatabase(ormConfig, 'default');
+    const dirOpt = typeof options['dir'] === 'string' ? options['dir'] : databaseConfig.seeders.directory;
+    const { service, includeGlobal } = getServiceArgs(options);
+    const projectRoot = process.cwd();
+    const globalDir = SeederDiscovery.resolveDir(projectRoot, dirOpt);
+    const globalFiles = includeGlobal ? SeederDiscovery.listSeederFiles(globalDir) : [];
+    let serviceFiles = [];
+    if (service !== undefined) {
+        const { domain, name } = parseServiceRef(service);
+        const serviceRoot = `${projectRoot}/services/${domain}/${name}`;
+        const serviceDir = SeederDiscovery.resolveDir(serviceRoot, dirOpt);
+        serviceFiles = SeederDiscovery.listSeederFiles(serviceDir);
+    }
+    const seederArgRaw = Array.isArray(options.args) ? options.args[0] : undefined;
+    const seederName = typeof seederArgRaw === 'string' && seederArgRaw.trim() !== ''
+        ? normalizeSeederNameArg(seederArgRaw)
+        : undefined;
+    const selectedGlobal = selectSeederFiles(globalFiles, seederName);
+    const selectedService = selectSeederFiles(serviceFiles, seederName);
+    const selected = [...selectedGlobal, ...selectedService];
+    if (seederName !== undefined) {
+        if (selected.length === 0) {
+            throw ErrorFactory.createCliError(`Seeder not found: ${seederName} (dir=${dirOpt}, global=${globalFiles.length}, service=${serviceFiles.length})`);
+        }
+        if (selected.length > 1) {
+            throw ErrorFactory.createCliError(`Seeder name is ambiguous: ${seederName} (matches=${selected.length}). Use --only-service or adjust name.`);
+        }
+    }
+    if (selected.length === 0) {
+        cmd.info('No seeders found.');
+        return;
+    }
+    cmd.info(`Running ${selected.length} seeder(s)...`);
+    await db.connect();
+    try {
+        await selected.reduce(async (previous, filePath) => {
+            await previous;
+            const loaded = await SeederLoader.load(filePath);
+            cmd.info(`→ ${loaded.name}`);
+            await loaded.run(db);
+            cmd.success(`✓ Seeded: ${loaded.name}`);
+        }, Promise.resolve());
+    }
+    finally {
+        await resetDatabase();
+    }
+};
+export const DbSeedCommand = Object.freeze({
+    create() {
+        const cmd = BaseCommand.create({
+            name: 'db:seed',
+            description: 'Run database seeders',
+            addOptions: addSeedOptions,
+            execute: async (options) => executeSeed(options, cmd),
+        });
+        return cmd;
+    },
+});

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

@@ -0,0 +1,15 @@
+/**
+ * Debug Command
+ * Launch debug mode with profiling and monitoring
+ */
+import type { 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,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAyDrE;;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.js';
+import { Dashboard } from '../debug/Dashboard.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+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 type { 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,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAoDrE;;GAEG;AACH,eAAO,MAAM,UAAU;IACrB;;OAEG;cACO,YAAY;EAkBtB,CAAC"}

package/src/cli/commands/FixCommand.js

@@ -0,0 +1,68 @@
+/**
+ * Fix Command - Automated Code Cleanup
+ * Runs ESLint fix and other automated tools
+ */
+import { appConfig } from '../../config/index.js';
+import { BaseCommand } from '../BaseCommand.js';
+import { resolveNpmPath } from '../../common/index.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { execFileSync } from '../../node-singletons/child-process.js';
+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 = (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: (options) => executeFix(cmd, options),
+        });
+        cmd.resolveNpmPath = () => resolveNpmPath();
+        cmd.getSafeEnv = () => appConfig.getSafeEnv();
+        cmd.runNpmExec = (args) => runNpmScript(cmd, args);
+        return cmd;
+    },
+});

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

@@ -0,0 +1,8 @@
+/**
+ * JWT Dev Command
+ * Mint a local development JWT for quick manual API testing.
+ */
+import { type IBaseCommand } from '../BaseCommand';
+export declare const JwtDevCommand: IBaseCommand;
+export default JwtDevCommand;
+//# sourceMappingURL=JwtDevCommand.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"JwtDevCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/JwtDevCommand.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAoC,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AA6FvF,eAAO,MAAM,aAAa,EAAE,YAqD3B,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/src/cli/commands/JwtDevCommand.js

@@ -0,0 +1,114 @@
+/**
+ * JWT Dev Command
+ * Mint a local development JWT for quick manual API testing.
+ */
+import { BaseCommand } from '../BaseCommand.js';
+import { appConfig } from '../../config/app.js';
+import { securityConfig } from '../../config/security.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { JwtManager } from '../../security/JwtManager.js';
+const parseExpiresToSeconds = (value) => {
+    const raw = typeof value === 'string' ? value.trim() : '';
+    if (raw === '')
+        return 60 * 60;
+    // Allow raw seconds
+    if (/^\d+$/.test(raw)) {
+        const seconds = Number.parseInt(raw, 10);
+        if (!Number.isFinite(seconds) || seconds <= 0) {
+            throw ErrorFactory.createCliError(`Invalid --expires '${raw}'. Must be > 0 seconds.`);
+        }
+        return seconds;
+    }
+    const match = /^(\d+)([smhd])$/i.exec(raw);
+    if (!match) {
+        throw ErrorFactory.createCliError(`Invalid --expires '${raw}'. Use seconds (e.g. 3600) or a duration like 30m, 1h, 7d.`);
+    }
+    const amount = Number.parseInt(match[1] ?? '', 10);
+    const unit = (match[2] ?? '').toLowerCase();
+    if (!Number.isFinite(amount) || amount <= 0) {
+        throw ErrorFactory.createCliError(`Invalid --expires '${raw}'. Must be > 0.`);
+    }
+    const multipliers = {
+        s: 1,
+        m: 60,
+        h: 60 * 60,
+        d: 24 * 60 * 60,
+    };
+    const multiplier = multipliers[unit];
+    if (multiplier === undefined) {
+        throw ErrorFactory.createCliError(`Invalid --expires '${raw}'. Supported units: s, m, h, d (e.g. 30m, 1h).`);
+    }
+    return amount * multiplier;
+};
+const assertNotProduction = (allowProduction) => {
+    if (!appConfig.isProduction())
+        return;
+    if (allowProduction === true)
+        return;
+    throw ErrorFactory.createCliError("Refusing to mint a dev JWT in production. Use --allow-production only if you know what you're doing.");
+};
+const createJwt = (payload, expiresInSeconds) => {
+    const algorithm = securityConfig.jwt.algorithm;
+    const secret = securityConfig.jwt.secret;
+    const jwt = JwtManager.create();
+    if (algorithm === 'HS256' || algorithm === 'HS512') {
+        jwt.setHmacSecret(secret);
+    }
+    else {
+        throw ErrorFactory.createCliError(`JWT algorithm '${algorithm}' is not supported by zin jwt:dev (HS256/HS512 only).`);
+    }
+    return jwt.sign(payload, {
+        algorithm,
+        expiresIn: expiresInSeconds,
+        issuer: securityConfig.jwt.issuer,
+        audience: securityConfig.jwt.audience,
+        subject: typeof payload.sub === 'string' ? payload.sub : undefined,
+        jwtId: jwt.generateJwtId(),
+    });
+};
+export const JwtDevCommand = Object.freeze(BaseCommand.create({
+    name: 'jwt:dev',
+    description: 'Mint a local development JWT (for manual API testing)',
+    aliases: ['jwt:token', 'jwt:mint'],
+    addOptions: (command) => {
+        command
+            .option('--sub <sub>', 'JWT subject claim (default: 1)', '1')
+            .option('--email <email>', 'Email claim')
+            .option('--role <role>', 'Role claim')
+            .option('--expires <duration>', "Expiry: seconds or 30m/1h/7d (default: '1h')", '1h')
+            .option('--json', 'Output machine-readable JSON')
+            .option('--allow-production', 'Allow running in production (dangerous)');
+    },
+    execute: (options) => {
+        assertNotProduction(options.allowProduction);
+        const expiresInSeconds = parseExpiresToSeconds(options.expires);
+        const payload = {
+            ...(typeof options.sub === 'string' && options.sub.trim() !== ''
+                ? { sub: options.sub.trim() }
+                : {}),
+            ...(typeof options.email === 'string' && options.email.trim() !== ''
+                ? { email: options.email.trim() }
+                : {}),
+            ...(typeof options.role === 'string' && options.role.trim() !== ''
+                ? { role: options.role.trim() }
+                : {}),
+        };
+        const token = createJwt(payload, expiresInSeconds);
+        /* eslint-disable no-console */
+        if (options.json === true) {
+            const nowSeconds = Math.floor(Date.now() / 1000);
+            console.log(JSON.stringify({
+                token,
+                algorithm: securityConfig.jwt.algorithm,
+                expiresIn: expiresInSeconds,
+                issuedAt: nowSeconds,
+                expiresAt: nowSeconds + expiresInSeconds,
+                payload,
+            }));
+            return;
+        }
+        console.log(token);
+        /* eslint-enable no-console */
+    },
+}));
+export default JwtDevCommand;

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

@@ -0,0 +1,9 @@
+/**
+ * Key Generate Command
+ * Generates and sets the application key
+ */
+import type { 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,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAQrE,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.js';
+import { Logger } from '../../config/logger.js';
+import * as crypto from '../../node-singletons/crypto.js';
+import { fsPromises as fs } from '../../node-singletons/fs.js';
+import * as path from '../../node-singletons/path.js';
+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/LogsCleanupCommand.d.ts

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

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

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

package/src/cli/commands/LogsCleanupCommand.js

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { cleanLogsOnce } from '../../config/logger.js';
+export const LogsCleanupCommand = Object.freeze({
+    create() {
+        // Create the command first, then assign the execute implementation so we can
+        // safely reference the instance (`cmd`) from inside the handler.
+        const cmd = BaseCommand.create({
+            name: 'logs:cleanup',
+            description: 'Run a one-off log cleanup based on configured retention',
+            execute: async () => { },
+        });
+        cmd.execute = async (_options) => {
+            cmd.info('Running log cleanup...');
+            const deleted = await cleanLogsOnce();
+            cmd.info(`Deleted ${deleted.length} log files`);
+        };
+        return cmd;
+    },
+});
+export default LogsCleanupCommand;

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 type { IBaseCommand } from '../BaseCommand';
+import type { 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,KAAK,EAAkB,YAAY,EAAE,MAAM,kBAAkB,CAAC;AASrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA+MzC,eAAO,MAAM,WAAW;IACtB;;OAEG;cACO,YAAY;IAwBtB;;;OAGG;sBACe,OAAO,GAAG,IAAI;EAchC,CAAC;AAEH,eAAe,WAAW,CAAC"}