@zintrust/core 0.4.41 → 0.4.43

package/src/cli/commands/DebuggerCommands.js

@@ -0,0 +1,500 @@
+import { BaseCommand } from '../BaseCommand.js';
+import { D1SqlMigrations } from '../d1/D1SqlMigrations.js';
+import { WranglerConfig } from '../d1/WranglerConfig.js';
+import { WranglerD1 } from '../d1/WranglerD1.js';
+import { confirmProductionRun, mapConnectionToOrmConfig, parseRollbackSteps, } from '../utils/DatabaseCliUtils.js';
+import { readEnvString } from '../../common/ExternalServiceUtils.js';
+import { databaseConfig } from '../../config/database.js';
+import { Logger } from '../../config/logger.js';
+import { ErrorFactory } from '../../exceptions/ZintrustError.js';
+import { isNonEmptyString } from '../../helper/index.js';
+import { Migrator } from '../../migrations/Migrator.js';
+import { createRequire } from '../../node-singletons/module.js';
+import * as path from '../../node-singletons/path.js';
+import { Database } from '../../orm/Database.js';
+import { DatabaseAdapterRegistry } from '../../orm/DatabaseAdapterRegistry.js';
+const loadDebuggerModule = async () => {
+    try {
+        return (await import('../../../packages/system-debugger/src/index.js'));
+    }
+    catch (error) {
+        Logger.error('Failed to load optional package "@zintrust/system-debugger"', error);
+        throw ErrorFactory.createCliError('Package "@zintrust/system-debugger" is not installed. Add it to your project first.');
+    }
+};
+const addPruneOptions = (command) => {
+    command
+        .option('--hours <number>', 'Remove entries older than N hours (default: from config)', '')
+        .option('--local', 'D1 only: run against local D1 database')
+        .option('--remote', 'D1 only: run against remote D1 database')
+        .option('--database <name>', 'D1 only: Wrangler D1 database binding name')
+        .option('--keep-exceptions', 'Keep exception entries regardless of age', false);
+};
+const addMigrateOptions = (command) => {
+    command
+        .option('--status', 'Display migration status (applied, pending, failed)')
+        .option('--fresh', 'Reset database: drop all tables and re-run all migrations')
+        .option('--reset', 'Rollback all migrations to initial state')
+        .option('--rollback', 'Rollback last migration batch')
+        .option('--step <number>', 'Number of batches to rollback (use with --rollback)', '1')
+        .option('--force', 'Skip production confirmation (allow unsafe operations in production)')
+        .option('--all', 'Run migrations for all configured database connections')
+        .option('--connection <name>', 'Use a specific database connection for debugger migrations')
+        .option('--local', 'D1 only: run against local D1 database')
+        .option('--remote', 'D1 only: run against remote D1 database')
+        .option('--database <name>', 'D1 only: Wrangler D1 database binding name')
+        .option('--no-interactive', 'Disable interactive prompts (useful for CI/CD)');
+};
+const resolveDashboardBasePath = () => {
+    const raw = readEnvString('DEBUGGER_BASE_PATH').trim();
+    if (raw === '')
+        return '/debugger';
+    return raw.startsWith('/') ? raw : `/${raw}`;
+};
+const resolveDashboardUrl = () => {
+    const host = readEnvString('HOST').trim() || '127.0.0.1';
+    const port = readEnvString('PORT').trim() || readEnvString('APP_PORT').trim() || '7777';
+    return `http://${host}:${port}${resolveDashboardBasePath()}`;
+};
+const resolveDebuggerMigrationDir = () => {
+    const requireFromProject = createRequire(path.join(process.cwd(), 'package.json'));
+    try {
+        const resolved = requireFromProject.resolve('@zintrust/system-debugger/migrations');
+        return path.dirname(resolved);
+    }
+    catch {
+        return path.join(process.cwd(), 'packages', 'system-debugger', 'migrations');
+    }
+};
+const getD1DatabaseName = (options) => {
+    const optionValue = options['database'];
+    if (typeof optionValue === 'string' && optionValue.trim() !== '') {
+        return optionValue.trim();
+    }
+    const projectRoot = process.cwd();
+    const resolution = WranglerConfig.resolveD1Database(projectRoot);
+    if (resolution.status === 'resolved') {
+        return WranglerConfig.getDefaultD1DatabaseName(projectRoot) ?? 'zintrust_db';
+    }
+    if (resolution.status === 'ambiguous') {
+        throw ErrorFactory.createCliError('Multiple D1 targets are configured. Re-run with --database <database_name|binding> to choose the intended Wrangler D1 target.');
+    }
+    return 'zintrust_db';
+};
+const getInteractive = (options) => options['interactive'] !== false;
+const resolveRuntimeDefaultConnectionName = () => {
+    const configuredDefault = String(databaseConfig.default ?? '').trim();
+    return configuredDefault === '' ? 'default' : configuredDefault;
+};
+const normalizeConnectionName = (value) => {
+    const normalized = value.trim();
+    if (normalized === '' || normalized === 'default') {
+        return resolveRuntimeDefaultConnectionName();
+    }
+    return normalized;
+};
+const resolveDebuggerConnectionName = (options) => {
+    if (isNonEmptyString(options['connection'])) {
+        return normalizeConnectionName(String(options['connection']));
+    }
+    return normalizeConnectionName(readEnvString('DEBUGGER_DB_CONNECTION').trim());
+};
+const withConfiguredDebuggerConnection = (options, configuredConnection) => {
+    if (isNonEmptyString(options['connection'])) {
+        return {
+            ...options,
+            connection: resolveDebuggerConnectionName(options),
+        };
+    }
+    if (isNonEmptyString(configuredConnection)) {
+        return {
+            ...options,
+            connection: normalizeConnectionName(configuredConnection),
+        };
+    }
+    return {
+        ...options,
+        connection: resolveDebuggerConnectionName(options),
+    };
+};
+const resolveDebuggerConnectionConfig = (options) => {
+    const selected = resolveDebuggerConnectionName(options);
+    const connections = databaseConfig.connections;
+    return connections[selected] ?? databaseConfig.getConnection();
+};
+const isD1ConnectionDriver = (driver) => driver === 'd1' || driver === 'd1-remote';
+const resolveD1ExecutionMode = (options) => {
+    return options['local'] === true || options['remote'] !== true;
+};
+const ANSI_ESCAPE = String.fromCodePoint(27);
+const stripAnsi = (value) => {
+    let output = '';
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index];
+        if (char !== ANSI_ESCAPE) {
+            output += char;
+            continue;
+        }
+        if (value[index + 1] !== '[') {
+            continue;
+        }
+        index += 2;
+        while (index < value.length && value[index] !== 'm') {
+            index += 1;
+        }
+    }
+    return output;
+};
+const extractWranglerJson = (output) => {
+    const normalized = stripAnsi(output);
+    const jsonStart = normalized.indexOf('[\n  {');
+    if (jsonStart === -1)
+        return null;
+    try {
+        return JSON.parse(normalized.slice(jsonStart));
+    }
+    catch {
+        return null;
+    }
+};
+const parseWranglerTable = (output) => {
+    const lines = output.split('\n').map((line) => stripAnsi(line).trim());
+    const dataLines = lines.filter((line) => line.startsWith('│') && line.endsWith('│'));
+    if (dataLines.length < 2)
+        return [];
+    const toCells = (line) => {
+        return line
+            .split('│')
+            .slice(1, -1)
+            .map((cell) => cell.trim());
+    };
+    const headers = toCells(dataLines[0] ?? '');
+    const rows = dataLines.slice(1);
+    return rows.map((line) => {
+        const cells = toCells(line);
+        return Object.fromEntries(headers.map((header, index) => [header, cells[index] ?? '']));
+    });
+};
+const buildStatsFromJsonPayload = (payload) => {
+    const stats = {};
+    for (const row of payload[0]?.results ?? []) {
+        if (typeof row.type === 'string') {
+            stats[row.type] = typeof row.cnt === 'number' ? row.cnt : 0;
+        }
+    }
+    return stats;
+};
+const buildStatsFromTableRows = (rows) => {
+    const stats = {};
+    for (const row of rows) {
+        const key = row['type'] ?? '';
+        const count = Number.parseInt(row['cnt'] ?? '0', 10);
+        if (key !== '') {
+            stats[key] = Number.isNaN(count) ? 0 : count;
+        }
+    }
+    return stats;
+};
+const withSqlDebuggerStorage = async (options, callback) => {
+    const { DebuggerStorage } = await loadDebuggerModule();
+    const conn = resolveDebuggerConnectionConfig(options);
+    const db = Database.create(mapConnectionToOrmConfig(conn));
+    await db.connect();
+    try {
+        const storage = DebuggerStorage.resolveStorage(db);
+        return await callback(storage);
+    }
+    finally {
+        await db.disconnect();
+    }
+};
+const executeD1Stats = (options) => {
+    const output = WranglerD1.executeSql({
+        dbName: getD1DatabaseName(options),
+        isLocal: resolveD1ExecutionMode(options),
+        sql: 'SELECT type, COUNT(*) as cnt FROM zin_debugger_entries GROUP BY type ORDER BY type',
+    });
+    const payload = extractWranglerJson(output);
+    if (payload !== null) {
+        return buildStatsFromJsonPayload(payload);
+    }
+    return buildStatsFromTableRows(parseWranglerTable(output));
+};
+const executeD1Delete = (options, sql) => {
+    const output = WranglerD1.executeSql({
+        dbName: getD1DatabaseName(options),
+        isLocal: resolveD1ExecutionMode(options),
+        sql: `${sql}; SELECT changes() as cnt`,
+    });
+    const payload = extractWranglerJson(output);
+    if (payload !== null) {
+        const count = payload.at(-1)?.results?.[0]?.cnt;
+        return typeof count === 'number' ? count : 0;
+    }
+    const rows = parseWranglerTable(output);
+    const count = Number.parseInt(rows.at(-1)?.['cnt'] ?? '0', 10);
+    return Number.isNaN(count) ? 0 : count;
+};
+const isBuiltInDriver = (driver) => driver === 'sqlite' ||
+    driver === 'mysql' ||
+    driver === 'postgresql' ||
+    driver === 'sqlserver' ||
+    driver === 'd1' ||
+    driver === 'd1-remote';
+const isDestructiveAction = (options) => options['fresh'] === true || options['reset'] === true || options['rollback'] === true;
+const executePrune = async (options) => {
+    const { DebuggerConfig } = await loadDebuggerModule();
+    const config = DebuggerConfig.merge();
+    const resolvedOptions = withConfiguredDebuggerConnection(options, config.connection);
+    const hours = typeof options['hours'] === 'string' && options['hours'] !== ''
+        ? Number.parseInt(options['hours'], 10)
+        : config.pruneAfterHours;
+    const olderThanMs = hours * 60 * 60 * 1000;
+    const keepExceptions = options['keepExceptions'] === true;
+    const conn = resolveDebuggerConnectionConfig(resolvedOptions);
+    const threshold = Date.now() - olderThanMs;
+    const pruneSql = keepExceptions
+        ? `DELETE FROM zin_debugger_entries WHERE created_at < ${String(threshold)} AND type != 'exception'`
+        : `DELETE FROM zin_debugger_entries WHERE created_at < ${String(threshold)}`;
+    Logger.info(`Pruning debugger entries older than ${hours}h...`);
+    const deleted = isD1ConnectionDriver(conn.driver)
+        ? executeD1Delete(options, pruneSql)
+        : await withSqlDebuggerStorage(resolvedOptions, async (storage) => storage.prune(olderThanMs, keepExceptions));
+    Logger.info(`Done - removed ${deleted} entries.`);
+};
+const executeClear = async (options) => {
+    const { DebuggerConfig } = await loadDebuggerModule();
+    const config = DebuggerConfig.merge();
+    const resolvedOptions = withConfiguredDebuggerConnection(options, config.connection);
+    const conn = resolveDebuggerConnectionConfig(resolvedOptions);
+    Logger.info('Clearing all debugger entries...');
+    if (isD1ConnectionDriver(conn.driver)) {
+        executeD1Delete(options, 'DELETE FROM zin_debugger_entries');
+    }
+    else {
+        await withSqlDebuggerStorage(resolvedOptions, async (storage) => storage.clear());
+    }
+    Logger.info('Done - all entries cleared.');
+};
+const executeStatus = async (options, cmd) => {
+    const { DebuggerConfig } = await loadDebuggerModule();
+    const config = DebuggerConfig.merge();
+    const resolvedOptions = withConfiguredDebuggerConnection(options, config.connection);
+    const connection = resolveDebuggerConnectionName(resolvedOptions);
+    const conn = resolveDebuggerConnectionConfig(resolvedOptions);
+    const stats = isD1ConnectionDriver(conn.driver)
+        ? executeD1Stats(options)
+        : await withSqlDebuggerStorage(resolvedOptions, async (storage) => storage.stats());
+    cmd.info(`Debugger enabled via env: ${readEnvString('DEBUGGER_ENABLED').trim() || 'false'}`);
+    cmd.info(`Connection: ${connection}`);
+    cmd.info(`Prune after hours: ${String(config.pruneAfterHours)}`);
+    cmd.info(`Dashboard: ${resolveDashboardUrl()}`);
+    const keys = Object.keys(stats).sort((left, right) => left.localeCompare(right));
+    if (keys.length === 0) {
+        cmd.info('Stored entries: 0');
+        return;
+    }
+    for (const key of keys) {
+        cmd.info(`${key}: ${String(stats[key] ?? 0)}`);
+    }
+};
+const printMigrationStatus = async (migrator, cmd) => {
+    const rows = await migrator.status();
+    if (rows.length === 0) {
+        cmd.info('No debugger migrations found.');
+        return;
+    }
+    for (const row of rows) {
+        const tag = row.status ?? (row.applied ? 'applied' : 'pending');
+        const extra = row.applied ? ` (batch=${row.batch ?? '?'}, at=${row.appliedAt ?? '?'})` : '';
+        cmd.info(`${tag}: ${row.name}${extra}`);
+    }
+};
+const applyDebuggerMigrations = async (migrator, cmd) => {
+    const result = await migrator.migrate();
+    if (result.appliedNames.length === 0) {
+        cmd.info('No pending debugger migrations.');
+        return;
+    }
+    cmd.success('Debugger migrations applied.');
+    for (const name of result.appliedNames) {
+        cmd.info(`\u2713 ${name}`);
+    }
+};
+const runMigrationActions = async (migrator, options, cmd, driver) => {
+    if (options['status'] === true) {
+        cmd.info(`Adapter: ${driver}`);
+        await printMigrationStatus(migrator, cmd);
+        return;
+    }
+    if (options['fresh'] === true) {
+        await migrator.fresh();
+        cmd.success('Debugger migrations applied (fresh).');
+        return;
+    }
+    if (options['reset'] === true) {
+        await migrator.resetAll();
+        cmd.success('Debugger migrations reset.');
+        return;
+    }
+    if (options['rollback'] === true) {
+        const steps = parseRollbackSteps(options);
+        const result = await migrator.rollbackLastBatch(steps);
+        cmd.success(`Debugger migrations rolled back (${result.rolledBack}).`);
+        return;
+    }
+    await applyDebuggerMigrations(migrator, cmd);
+};
+const runMigrationsForConnection = async (conn, options, cmd, interactive) => {
+    const destructive = isDestructiveAction(options);
+    const proceed = await confirmProductionRun({
+        cmd,
+        interactive,
+        destructive,
+        force: options['force'] === true,
+        message: 'NODE_ENV=production. Continue running debugger migrations?',
+    });
+    if (!proceed)
+        return;
+    if (!isBuiltInDriver(conn.driver) && !DatabaseAdapterRegistry.has(conn.driver)) {
+        cmd.warn(`Missing adapter for driver: ${conn.driver}`);
+        cmd.warn(`Install via 'zin plugin install adapter:${conn.driver}' (or 'zin add db:${conn.driver}').`);
+    }
+    const previousD1RemoteMode = typeof process === 'undefined' ? undefined : process.env['D1_REMOTE_MODE'];
+    if (conn.driver === 'd1' || conn.driver === 'd1-remote') {
+        if (options['status'] === true ||
+            options['fresh'] === true ||
+            options['reset'] === true ||
+            options['rollback'] === true) {
+            throw ErrorFactory.createCliError('D1-backed debugger migrations currently support apply only. Run `zin migrate:debugger --local|--remote` without status or rollback flags.');
+        }
+        const projectRoot = process.cwd();
+        const dbName = getD1DatabaseName(options);
+        const isLocal = options['local'] === true || options['remote'] !== true;
+        const outputDir = path.join(projectRoot, WranglerConfig.getD1MigrationsDir(projectRoot, dbName));
+        await D1SqlMigrations.compileAndWrite({
+            projectRoot,
+            globalDir: resolveDebuggerMigrationDir(),
+            extension: databaseConfig.migrations.extension,
+            includeGlobal: true,
+            outputDir,
+        });
+        const output = WranglerD1.applyMigrations({ cmd, dbName, isLocal });
+        if (output !== '') {
+            cmd.info(output);
+        }
+        cmd.success('Debugger D1 migrations applied.');
+        return;
+    }
+    const ormConfig = mapConnectionToOrmConfig(conn);
+    const db = Database.create(ormConfig);
+    await db.connect();
+    try {
+        const migrator = Migrator.create({
+            db,
+            projectRoot: process.cwd(),
+            globalDir: resolveDebuggerMigrationDir(),
+            extension: databaseConfig.migrations.extension,
+            separateTracking: true,
+        });
+        await runMigrationActions(migrator, options, cmd, conn.driver);
+    }
+    finally {
+        if (typeof process !== 'undefined') {
+            if (previousD1RemoteMode === undefined) {
+                delete process.env['D1_REMOTE_MODE'];
+            }
+            else {
+                process.env['D1_REMOTE_MODE'] = previousD1RemoteMode;
+            }
+        }
+        await db.disconnect();
+    }
+};
+const executeMigrateDebugger = async (options, cmd) => {
+    const interactive = getInteractive(options);
+    const targets = [];
+    if (options['all'] === true) {
+        for (const [name, config] of Object.entries(databaseConfig.connections)) {
+            targets.push({ name, config });
+        }
+    }
+    else if (isNonEmptyString(options['connection'])) {
+        const selected = String(options['connection']).trim();
+        const connections = databaseConfig.connections;
+        targets.push({
+            name: selected,
+            config: connections[selected] ?? databaseConfig.getConnection(),
+        });
+    }
+    else {
+        const selected = readEnvString('DEBUGGER_DB_CONNECTION').trim() || 'default';
+        const connections = databaseConfig.connections;
+        targets.push({
+            name: selected,
+            config: connections[selected] ?? databaseConfig.getConnection(),
+        });
+    }
+    let sequence = Promise.resolve();
+    for (const { name, config } of targets) {
+        sequence = sequence.then(async () => {
+            if (targets.length > 1) {
+                cmd.info(`\n--- Connection: ${name} (${config.driver}) ---`);
+            }
+            await runMigrationsForConnection(config, options, cmd, interactive);
+        });
+    }
+    await sequence;
+};
+const createProvider = (name, getCommand) => {
+    return Object.freeze({
+        name,
+        getCommand: () => getCommand().getCommand(),
+    });
+};
+export const DebuggerCommands = Object.freeze({
+    createDebuggerPruneCommand: () => BaseCommand.create({
+        name: 'debugger:prune',
+        description: 'Prune old entries from the debugger storage',
+        addOptions: addPruneOptions,
+        execute: executePrune,
+    }),
+    createDebuggerClearCommand: () => BaseCommand.create({
+        name: 'debugger:clear',
+        description: 'Clear all entries from the debugger storage',
+        addOptions: (command) => {
+            command
+                .option('--local', 'D1 only: run against local D1 database')
+                .option('--remote', 'D1 only: run against remote D1 database')
+                .option('--database <name>', 'D1 only: Wrangler D1 database binding name');
+        },
+        execute: async (options) => executeClear(options),
+    }),
+    createDebuggerStatusCommand: () => {
+        const cmd = BaseCommand.create({
+            name: 'debugger:status',
+            description: 'Show debugger storage stats and dashboard location',
+            addOptions: (command) => {
+                command
+                    .option('--local', 'D1 only: run against local D1 database')
+                    .option('--remote', 'D1 only: run against remote D1 database')
+                    .option('--database <name>', 'D1 only: Wrangler D1 database binding name');
+            },
+            execute: async (options) => executeStatus(options, cmd),
+        });
+        return cmd;
+    },
+    createDebuggerMigrateCommand: () => {
+        const cmd = BaseCommand.create({
+            name: 'migrate:debugger',
+            description: 'Run debugger package migrations',
+            addOptions: addMigrateOptions,
+            execute: async (options) => executeMigrateDebugger(options, cmd),
+        });
+        return cmd;
+    },
+    createDebuggerPruneProvider: () => createProvider('debugger:prune', DebuggerCommands.createDebuggerPruneCommand),
+    createDebuggerClearProvider: () => createProvider('debugger:clear', DebuggerCommands.createDebuggerClearCommand),
+    createDebuggerStatusProvider: () => createProvider('debugger:status', DebuggerCommands.createDebuggerStatusCommand),
+    createDebuggerMigrateProvider: () => createProvider('migrate:debugger', DebuggerCommands.createDebuggerMigrateCommand),
+});

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

@@ -1 +1 @@
-{"version":3,"file":"PrepareCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PrepareCommand.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAerD,eAAO,MAAM,cAAc,EA2CtB,YAAY,CAAC"}
+{"version":3,"file":"PrepareCommand.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/PrepareCommand.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAiFrD,eAAO,MAAM,cAAc,EAgCtB,YAAY,CAAC"}

package/src/cli/commands/PrepareCommand.js

@@ -3,6 +3,7 @@
  * Makes the local dist/ folder installable via `file:/.../dist`.
  * Usage: zintrust prepare
  */
+import { materializeWranglerDevVars } from '../cloudflare/CloudflareWranglerDevEnv.js';
 import { DistPackager } from '../utils/DistPackager.js';
 import { SpawnUtil } from '../utils/spawn.js';
 import { resolveNpmPath } from '../../common/index.js';
@@ -11,6 +12,56 @@ import { ErrorFactory } from '../../exceptions/ZintrustError.js';
 import * as path from '../../node-singletons/path.js';
 import chalk from 'chalk';
 import { Command } from 'commander';
+const resolveDistPath = (options) => {
+    const distRel = typeof options.dist === 'string' && options.dist.trim() !== '' ? options.dist : 'dist';
+    return path.resolve(process.cwd(), distRel);
+};
+const logPreparedDist = () => {
+    Logger.info(chalk.green('✅ Dist prepared.'));
+    Logger.info('Docs roots:');
+    Logger.info(`- Production/new apps: ${chalk.cyan('dist/public')}`);
+    Logger.info(`- Framework dev:      ${chalk.cyan('docs-website/public')}`);
+};
+const prepareWranglerDevVars = async (options) => {
+    if (options.devVars === undefined)
+        return;
+    const wranglerEnv = typeof options.devVars === 'string' ? options.devVars.trim() : '';
+    const result = await materializeWranglerDevVars({
+        cwd: process.cwd(),
+        projectRoot: process.cwd(),
+        ...(wranglerEnv === '' ? {} : { envName: wranglerEnv }),
+        ...(typeof options.envPath === 'string' ? { envPath: options.envPath } : {}),
+        ...(typeof options.target === 'string' ? { target: options.target } : {}),
+        ...(typeof options.config === 'string' ? { configPath: options.config } : {}),
+        requireSelection: true,
+    });
+    Logger.info(chalk.green(`✅ Wrangler dev vars prepared at ${path.basename(result.filePath)}.`));
+    Logger.info(`Selected keys: ${result.selectedKeys.length}`);
+    if (result.missingKeys.length > 0) {
+        Logger.info(`Missing keys: ${result.missingKeys.join(', ')}`);
+    }
+};
+const maybeLinkCli = async (options) => {
+    if (options.link !== true)
+        return;
+    Logger.info(chalk.bold('\nLinking CLI globally (npm link)...'));
+    const npm = resolveNpmPath();
+    const exitCode = await SpawnUtil.spawnAndWait({
+        command: npm,
+        args: ['link'],
+        cwd: process.cwd(),
+    });
+    if (exitCode !== 0) {
+        throw ErrorFactory.createCliError(`npm link exited with code ${exitCode}`);
+    }
+    Logger.info(chalk.green('✅ Linked. You can now run `zintrust` from your shell.'));
+};
+const executePrepare = async (options) => {
+    DistPackager.prepare(resolveDistPath(options), process.cwd());
+    logPreparedDist();
+    await prepareWranglerDevVars(options);
+    await maybeLinkCli(options);
+};
 export const PrepareCommand = {
     name: 'prepare',
     description: 'Prepare local dist/ for file: installs (simulate/fresh install workflow)',
@@ -18,29 +69,14 @@ export const PrepareCommand = {
         return new Command('prepare')
             .description('Prepare local dist/ so it can be installed via file:/.../dist')
             .option('--dist <path>', 'Dist folder path (default: ./dist)')
+            .option('--dev-vars [env]', 'Generate Wrangler .dev.vars or .dev.vars.<env> from .zintrust.json cloudflare env groups')
+            .option('--env-path <path>', 'Env file used as source values for generated Wrangler dev vars', '.env')
+            .option('--target <id>', 'Cloudflare worker target key from .zintrust.json cloudflare.targets')
+            .option('-c, --config <path>', 'Wrangler config file used for target inference (optional)')
             .option('--link', 'Also run `npm link` to expose zintrust/zin/z/zt on PATH (dev-only)')
             .action(async (options) => {
             try {
-                const distRel = typeof options.dist === 'string' && options.dist.trim() !== '' ? options.dist : 'dist';
-                const distPath = path.resolve(process.cwd(), distRel);
-                DistPackager.prepare(distPath, process.cwd());
-                Logger.info(chalk.green('✅ Dist prepared.'));
-                Logger.info('Docs roots:');
-                Logger.info(`- Production/new apps: ${chalk.cyan('dist/public')}`);
-                Logger.info(`- Framework dev:      ${chalk.cyan('docs-website/public')}`);
-                if (options.link === true) {
-                    Logger.info(chalk.bold('\nLinking CLI globally (npm link)...'));
-                    const npm = resolveNpmPath();
-                    const exitCode = await SpawnUtil.spawnAndWait({
-                        command: npm,
-                        args: ['link'],
-                        cwd: process.cwd(),
-                    });
-                    if (exitCode !== 0) {
-                        throw ErrorFactory.createCliError(`npm link exited with code ${exitCode}`);
-                    }
-                    Logger.info(chalk.green('✅ Linked. You can now run `zintrust` from your shell.'));
-                }
+                await executePrepare(options);
             }
             catch (error) {
                 Logger.error('Failed to prepare dist', error);

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;AA6lCvF,eAAO,MAAM,YAAY;cACb,YAAY;;mCA3hCU,MAAM,KAAG,OAAO;4CAaP,MAAM,KAAG,MAAM;4CA4Bf,MAAM,KAAG,OAAO;sCAetB,MAAM,WAAW,MAAM,KAAG,OAAO;oCAmBnC,MAAM,KAAG,OAAO;;EA2/BjD,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;AA2+BvF,eAAO,MAAM,YAAY;cACb,YAAY;;mCAn7BU,MAAM,KAAG,OAAO;4CAaP,MAAM,KAAG,MAAM;4CA4Bf,MAAM,KAAG,OAAO;sCAetB,MAAM,WAAW,MAAM,KAAG,OAAO;oCAmBnC,MAAM,KAAG,OAAO;;EAm5BjD,CAAC"}