nextjs-cms 0.6.8 → 0.7.0

package/dist/cli/program/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+declare const program: Command;
+export default program;
+//# sourceMappingURL=program.d.ts.map

package/dist/cli/program/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../../src/cli/program/program.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAA;AAmB3C,QAAA,MAAM,OAAO,SAAgB,CAAA;AA4F7B,eAAe,OAAO,CAAA"}

package/dist/cli/program/program.js

@@ -0,0 +1,95 @@
+import { Command, Option } from 'commander';
+import chalk from 'chalk';
+import process from 'node:process';
+import * as p from '@clack/prompts';
+import { displayIntro } from '../utils/display-intro.js';
+import { packageVersion, validateNextjsCmsApp } from '../utils/check-version.js';
+const handleSigTerm = () => {
+    p.log.message('\n');
+    p.cancel(`Aborted\n`);
+    process.exit(1);
+};
+process.on('SIGINT', handleSigTerm);
+process.on('SIGTERM', handleSigTerm);
+// Validate nextjs-cms app and dependencies before proceeding
+validateNextjsCmsApp();
+const program = new Command();
+program
+    .name('nextjs-cms')
+    .option('-d, --dev', 'use development environment file, use -d/--dev before any command to use the development environment file (e.g. nextjs-cms -d setup)', false)
+    .addOption(new Option('-f, --force', 'force the command to run even when version mismatch is detected').hideHelp())
+    .description(chalk.green('nextjs-cms CLI toolkit for managing your nextjs-cms application'))
+    .version(packageVersion)
+    // Include -v option to show the version number
+    .addOption(new Option('-v').hideHelp())
+    .enablePositionalOptions();
+program
+    .command('setup')
+    .description('Complete nextjs-cms setup')
+    .option('--continue', 'continue the setup if you have already setup the database', false)
+    .passThroughOptions()
+    .action(async function () {
+    const c = Boolean(this.opts().continue);
+    const { runSetup } = await import('../commands/setup.js');
+    displayIntro({ command: 'setup', dev: Boolean(program.opts().dev), title: 'Setting up nextjs-cms 🚀' });
+    await runSetup(Boolean(program.opts().dev), c);
+});
+program
+    .command('db-config')
+    .description('Initialize nextjs-cms database configuration')
+    .passThroughOptions()
+    .action(async () => {
+    const { runDbConfig } = await import('../commands/db-config.js');
+    displayIntro({
+        command: 'db-config',
+        dev: Boolean(program.opts().dev),
+        title: 'Configuring database',
+    });
+    await runDbConfig(Boolean(program.opts().dev));
+});
+program
+    .command('set-master-admin')
+    .description('Set or update master admin password')
+    .passThroughOptions()
+    .action(async () => {
+    const { runSetMasterAdmin } = await import('../commands/set-master-admin.js');
+    displayIntro({
+        command: 'set-master-admin',
+        dev: Boolean(program.opts().dev),
+        title: 'Setting master admin',
+    });
+    await runSetMasterAdmin();
+});
+program
+    .command('fix-master-admin')
+    .description('Fix master admin privileges for all sections')
+    .passThroughOptions()
+    .action(async () => {
+    const { runFixMasterAdmin } = await import('../commands/fix-master-admin.js');
+    displayIntro({
+        command: 'fix-master-admin',
+        dev: Boolean(program.opts().dev),
+        title: 'Fixing master admin privileges',
+    });
+    await runFixMasterAdmin();
+});
+program
+    .command('update-sections')
+    .description('Update database tables based on current sections and update master admin privileges')
+    .passThroughOptions()
+    .action(async () => {
+    const { runUpdateSections } = await import('../commands/update-sections.js');
+    displayIntro({
+        command: 'update-sections',
+        dev: Boolean(program.opts().dev),
+        title: 'Updating sections',
+    });
+    await runUpdateSections(Boolean(program.opts().dev));
+});
+program.showHelpAfterError('(add --help for additional information)');
+// Show the version number when the -v option is used
+program.on('option:v', () => {
+    console.log(program.version());
+    process.exit();
+});
+export default program;

package/dist/cli/utils/add-table-keys.d.ts

@@ -0,0 +1,32 @@
+import type { FieldConfig } from '../../core/fields/index.js';
+export declare function addTableKeys(table: {
+    name: string;
+    primaryKey: FieldConfig[];
+    index?: {
+        name?: string;
+        columns: FieldConfig[];
+    }[];
+    unique?: {
+        name?: string;
+        columns: FieldConfig[];
+    }[];
+    fulltext?: {
+        name?: string;
+        columns: FieldConfig[];
+    }[];
+}, existingKeys?: {
+    primaryKeys: string[];
+    uniqueKeys: {
+        name: string;
+        columns: string[];
+    }[];
+    indexKeys: {
+        name: string;
+        columns: string[];
+    }[];
+    fullTextKeys: {
+        name: string;
+        columns: string[];
+    }[];
+}): Promise<number>;
+//# sourceMappingURL=add-table-keys.d.ts.map

package/dist/cli/utils/add-table-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-table-keys.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/add-table-keys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AAG7D,wBAAsB,YAAY,CAC9B,KAAK,EAAE;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,WAAW,EAAE,CAAA;IACzB,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,EAAE,CAAA;KAAE,EAAE,CAAA;IACnD,MAAM,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,EAAE,CAAA;KAAE,EAAE,CAAA;IACpD,QAAQ,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,WAAW,EAAE,CAAA;KAAE,EAAE,CAAA;CACzD,EACD,YAAY,CAAC,EAAE;IACX,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,UAAU,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;IACjD,SAAS,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;IAChD,YAAY,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAA;CACtD,mBAoPJ"}

package/dist/cli/utils/add-table-keys.js

@@ -0,0 +1,171 @@
+import chalk from 'chalk';
+export async function addTableKeys(table, existingKeys) {
+    // Lazy import heavy dependencies to avoid eager database connection initialization
+    const { db } = await import('../../db/client.js');
+    // console.log(chalk.gray(`  - Checking table keys`))
+    /**
+     * Number of SQL errors
+     */
+    let sqlErrors = 0;
+    /**
+     * Add the primary key, but first, check if the primary key exists or has changed
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (table.primaryKey) {
+        if (existingKeys) {
+            const { primaryKeys } = existingKeys;
+            /**
+             * Check if the existing primary key matches the new primary key
+             */
+            const primaryKeyChanged = primaryKeys.length !== table.primaryKey.length ||
+                !table.primaryKey.every((key) => primaryKeys.includes(key.name));
+            /**
+             * If primary key doesn't exist or has changed, update it
+             */
+            if ((primaryKeys.length === 0 && table.primaryKey.length > 0) || primaryKeyChanged) {
+                /**
+                 * Drop existing primary key if it exists
+                 */
+                if (primaryKeys.length > 0) {
+                    console.log(chalk.gray(`  - Dropping existing primary key from '${table.name}: [${primaryKeys.join(', ')}]`));
+                    try {
+                        await db.execute(`ALTER TABLE \`${table.name}\` DROP PRIMARY KEY`);
+                    }
+                    catch (error) {
+                        sqlErrors++;
+                        console.error(chalk.red(`  - Error dropping primary key for table '${table.name}':`, error));
+                    }
+                }
+                /**
+                 * Add the new primary key
+                 */
+                console.log(chalk.gray(`  - Adding primary key to '${table.name}': [${table.primaryKey.map((key) => key.name).join(', ')}]`));
+                try {
+                    const primaryKeyColumns = table.primaryKey.map((column) => `\`${column.name}\``).join(', ');
+                    await db.execute(`ALTER TABLE \`${table.name}\` ADD PRIMARY KEY (${primaryKeyColumns})`);
+                }
+                catch (error) {
+                    sqlErrors++;
+                    console.error(chalk.red(`  - Error updating primary key for table '${table.name}':`, error));
+                    /**
+                     * Reverting to the old primary key
+                     */
+                    if (primaryKeys.length > 0) {
+                        console.log(chalk.gray(`  - Re-adding old primary key to '${table.name}': [${primaryKeys.map((key) => key).join(', ')}]`));
+                        try {
+                            const primaryKeyColumns = primaryKeys.map((column) => `\`${column}\``).join(', ');
+                            await db.execute(`ALTER TABLE \`${table.name}\` ADD PRIMARY KEY (${primaryKeyColumns})`);
+                        }
+                        catch (error) {
+                            sqlErrors++;
+                            console.error(chalk.red(`  - Error re-adding primary key for table '${table.name}':`, error));
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            // TODO: What is this?
+            sqlErrors++;
+        }
+    }
+    /**
+     * Modify unique keys
+     */
+    if (table.unique) {
+        const existingUniqueKeys = existingKeys?.uniqueKeys ?? [];
+        for (const requestedUnique of table.unique) {
+            /**
+             * Check if the unique key already exists
+             */
+            const matchingUnique = existingUniqueKeys.find((u) => {
+                return (requestedUnique.columns.length === u.columns.length &&
+                    requestedUnique.columns.every((col) => u.columns.includes(col.name)));
+            });
+            const uniqueColumns = requestedUnique.columns.map((col) => `\`${col.name}\``).join(', ');
+            /**
+             * If key doesn't exist, add it
+             */
+            if (!matchingUnique) {
+                console.log(chalk.gray(`  - Adding unique key with columns [${requestedUnique.columns.map((col) => col.name).join(', ')}] to '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` ADD UNIQUE ${requestedUnique.name ?? ''}(${uniqueColumns})`);
+            }
+        }
+        /**
+         * Drop any existing unique keys that are not in the new set (based on columns)
+         */
+        for (const existingUnique of existingUniqueKeys) {
+            if (!table.unique.find((unique) => {
+                return (unique.columns.length === existingUnique.columns.length &&
+                    unique.columns.every((col) => existingUnique.columns.includes(col.name)));
+            })) {
+                console.log(chalk.gray(`  - Dropping unique key with columns [${existingUnique.columns.join(', ')}] from '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` DROP INDEX \`${existingUnique.name}\``);
+            }
+        }
+    }
+    /**
+     * Modify indexes
+     */
+    if (table.index) {
+        const existingIndexes = existingKeys?.indexKeys ?? [];
+        for (const index of table.index) {
+            const matchingIndex = existingIndexes.find((i) => {
+                return (index.columns.length === i.columns.length &&
+                    index.columns.every((col) => i.columns.includes(col.name)));
+            });
+            const indexColumns = index.columns.map((col) => `\`${col.name}\``).join(', ');
+            if (!matchingIndex) {
+                // Add index
+                console.log(chalk.gray(`  - Adding index with columns [${index.columns.map((col) => col.name).join(', ')}] to '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` ADD INDEX ${index.name ?? ''}(${indexColumns})`);
+            }
+        }
+        /**
+         * Drop any existing indexes that are not in the new set (based on columns)
+         */
+        for (const existingIndex of existingIndexes) {
+            if (!table.index.find((index) => {
+                return (index.columns.length === existingIndex.columns.length &&
+                    index.columns.every((col) => existingIndex.columns.includes(col.name)));
+            })) {
+                console.log(chalk.gray(`  - Dropping index with columns [${existingIndex.columns.join(', ')}] from '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` DROP INDEX \`${existingIndex.name}\``);
+            }
+        }
+    }
+    /**
+     * Modify fulltext indexes
+     */
+    if (table.fulltext) {
+        const existingIndexes = existingKeys?.fullTextKeys ?? [];
+        for (const requestedFullTextIndex of table.fulltext) {
+            const matchingFulltext = existingIndexes.find((i) => {
+                return (requestedFullTextIndex.columns.length === i.columns.length &&
+                    requestedFullTextIndex.columns.every((col) => i.columns.includes(col.name)));
+            });
+            const fulltextColumns = requestedFullTextIndex.columns.map((col) => `\`${col.name}\``).join(', ');
+            /**
+             * If fulltext index doesn't exist, add it
+             */
+            if (!matchingFulltext) {
+                // Add fulltext index
+                console.log(chalk.gray(`  - Adding fulltext index with columns [${requestedFullTextIndex.columns.map((col) => col.name).join(', ')}] to '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` ADD FULLTEXT ${requestedFullTextIndex.name ?? ''}(${fulltextColumns})`);
+            }
+        }
+        /**
+         * Drop any existing fulltext indexes that are not in the new set (based on columns)
+         */
+        for (const existingFulltext of existingIndexes) {
+            if (!table.fulltext.find((fulltext) => {
+                return (fulltext.columns.length === existingFulltext.columns.length &&
+                    fulltext.columns.every((col) => existingFulltext.columns.includes(col.name)));
+            })) {
+                console.log(chalk.gray(`  - Dropping fulltext index with columns [${existingFulltext.columns.join(', ')}] from '${table.name}'`));
+                await db.execute(`ALTER TABLE \`${table.name}\` DROP INDEX \`${existingFulltext.name}\``);
+            }
+        }
+    }
+    return sqlErrors;
+}

package/dist/cli/utils/check-version.d.ts

@@ -0,0 +1,3 @@
+export declare function validateNextjsCmsApp(): void;
+export declare const packageVersion: string;
+//# sourceMappingURL=check-version.d.ts.map

package/dist/cli/utils/check-version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-version.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/check-version.ts"],"names":[],"mappings":"AAoIA,wBAAgB,oBAAoB,IAAI,IAAI,CAsC3C;AAED,eAAO,MAAM,cAAc,QAAsB,CAAA"}

package/dist/cli/utils/check-version.js

@@ -0,0 +1,125 @@
+import { readFileSync, existsSync, realpathSync } from 'node:fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import chalk from 'chalk';
+function findPackageJson(startDir) {
+    let dir = startDir ?? process.cwd();
+    while (true) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+function findConfigFile(startDir) {
+    let dir = startDir ?? process.cwd();
+    while (true) {
+        const candidate = join(dir, 'cms.config.ts');
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+// Get version dynamically from package.json
+const currentFilePath = fileURLToPath(import.meta.url);
+const currentDir = dirname(currentFilePath);
+const packageJsonPath = join(currentDir, '../../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+function checkNextjsCmsInstallation() {
+    const requireFromCwd = createRequire(join(process.cwd(), 'index.js'));
+    // Check for cms.config.ts file
+    const configFile = findConfigFile();
+    if (configFile === undefined) {
+        return { error: 'not-nextjs-cms-app' };
+    }
+    // Check for nextjs-cms dependency in package.json
+    const pkgPath = findPackageJson();
+    if (pkgPath === undefined) {
+        return { error: 'not-nextjs-cms-app' };
+    }
+    const packageJson = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const deps = {
+        ...(packageJson.dependencies ?? {}),
+        ...(packageJson.devDependencies ?? {}),
+    };
+    const versionInProjectPackageJson = deps['nextjs-cms'];
+    if (versionInProjectPackageJson === undefined) {
+        return { error: 'local-not-found' };
+    }
+    // Hard check for installed version
+    // Resolve whatever the package exports at "." (this IS allowed)
+    const entryPath = requireFromCwd.resolve('nextjs-cms');
+    // Follow symlinks (helps with pnpm layouts)
+    const startPath = realpathSync(entryPath);
+    const installedPackageJson = findPackageJson(startPath);
+    if (installedPackageJson === undefined) {
+        return {
+            error: 'local-needs-update',
+            installedVersion: 'undefined',
+            packageVersion: versionInProjectPackageJson,
+        };
+    }
+    const installedPackageJsonParsed = JSON.parse(readFileSync(installedPackageJson, 'utf8'));
+    const localInstalledVersion = installedPackageJsonParsed?.version ?? undefined;
+    if (localInstalledVersion !== versionInProjectPackageJson) {
+        return {
+            error: 'local-needs-update',
+            installedVersion: localInstalledVersion ?? 'undefined',
+            packageVersion: versionInProjectPackageJson,
+        };
+    }
+    return true;
+}
+function shouldSkipValidation() {
+    const args = process.argv.slice(2); // Remove 'node' and script path
+    return (args.includes('-h') ||
+        args.includes('--help') ||
+        args.includes('-V') ||
+        args.includes('--version') ||
+        args.includes('-v') ||
+        args.includes('--force'));
+}
+export function validateNextjsCmsApp() {
+    // Skip validation for help and version commands
+    if (shouldSkipValidation()) {
+        return;
+    }
+    const result = checkNextjsCmsInstallation();
+    if (typeof result === 'object' && 'error' in result) {
+        switch (result.error) {
+            case 'not-nextjs-cms-app':
+                console.error(chalk.red('❌ Error: This command must be run in a nextjs-cms application directory.'));
+                console.error(chalk.gray('Make sure you have:'));
+                console.error(chalk.gray('  - cms.config.ts file'));
+                console.error(chalk.gray('  - nextjs-cms as a dependency in package.json'));
+                console.error(chalk.gray('  - Did you forget to run `pnpm install`?'));
+                console.error('');
+                console.error(chalk.gray('To create a new nextjs-cms application, run:'));
+                console.error(chalk.gray('  - pnpm create nextjs-cms@latest'));
+                break;
+            case 'local-not-found':
+                console.error(chalk.red('❌ Error: nextjs-cms is not a dependency in package.json'));
+                console.error(chalk.gray('Make sure you have:'));
+                console.error(chalk.gray('  - nextjs-cms as a dependency in package.json'));
+                console.error(chalk.gray('  - Did you forget to run `pnpm install`?'));
+                break;
+            case 'local-needs-update':
+                console.error(chalk.red('❌ Error: the version of installed nextjs-cms in your cms is different from the version in package.json'));
+                console.error(chalk.gray('  - Installed version: ' + result.installedVersion));
+                console.error(chalk.gray('  - Package version: ' + result.packageVersion));
+                console.error(chalk.green('  - Please run `pnpm install and try again'));
+                break;
+        }
+        process.exit(1);
+    }
+}
+export const packageVersion = packageJson.version;

package/dist/cli/utils/display-intro.d.ts

@@ -0,0 +1,6 @@
+export declare const displayIntro: ({ command, dev, title }: {
+    command: string;
+    dev: boolean;
+    title: string;
+}) => void;
+//# sourceMappingURL=display-intro.d.ts.map

package/dist/cli/utils/display-intro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-intro.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/display-intro.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,YAAY,GAAI,yBAAyB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,SASrG,CAAA"}

package/dist/cli/utils/display-intro.js

@@ -0,0 +1,9 @@
+import { getTitle } from './render-title.js';
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+export const displayIntro = ({ command, dev, title }) => {
+    console.log();
+    console.log(chalk.white.bold(`${getTitle()} > ${chalk.cyan.italic(command)} ${dev ? chalk.gray('(development)') : chalk.gray('(production)')}`));
+    console.log();
+    p.intro(chalk.inverse(` ${title} `));
+};

package/dist/cli/utils/exec-utils.d.ts

@@ -0,0 +1,19 @@
+import type { Ora } from 'ora';
+export interface ExecWithSpinnerOptions {
+    command: string;
+    args: string[];
+    cwd?: string;
+    stdout?: 'pipe' | 'ignore' | 'inherit';
+    stderr?: 'pipe' | 'ignore' | 'inherit';
+    spinnerText?: string;
+    onDataHandle?: (spinner: Ora) => (data: Buffer) => void;
+    onStderrHandle?: (data: Buffer) => void;
+    checkExitCode?: boolean;
+    checkStderrForErrors?: boolean;
+}
+/**
+ * Execute a command with a spinner, handling different stdio configurations
+ * and optional data handlers for progress updates.
+ */
+export declare const execWithSpinner: (options: ExecWithSpinnerOptions) => Promise<Ora | null>;
+//# sourceMappingURL=exec-utils.d.ts.map

package/dist/cli/utils/exec-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exec-utils.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/exec-utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AAE9B,MAAM,WAAW,sBAAsB;IACnC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAA;IACtC,MAAM,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAA;IACtC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACvD,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,oBAAoB,CAAC,EAAE,OAAO,CAAA;CACjC;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe,GAAU,SAAS,sBAAsB,KAAG,OAAO,CAAC,GAAG,GAAG,IAAI,CAuGzF,CAAA"}

package/dist/cli/utils/exec-utils.js

@@ -0,0 +1,95 @@
+import { execa } from 'execa';
+import ora from 'ora';
+/**
+ * Execute a command with a spinner, handling different stdio configurations
+ * and optional data handlers for progress updates.
+ */
+export const execWithSpinner = async (options) => {
+    const { command, args, cwd, stdout = 'pipe', stderr = 'pipe', spinnerText = `Running ${command}...`, onDataHandle, onStderrHandle, checkExitCode = false, checkStderrForErrors = false, } = options;
+    const spinner = ora(spinnerText).start();
+    // If we need to check for errors in stderr but want to show it, we need to pipe it
+    const actualStderr = checkStderrForErrors && stderr === 'inherit' ? 'pipe' : stderr;
+    const actualStdout = checkStderrForErrors && stdout === 'inherit' ? 'pipe' : stdout;
+    const subprocess = execa(command, args, {
+        cwd,
+        stdout: actualStdout,
+        stderr: actualStderr,
+        reject: false, // Don't reject on non-zero exit codes - we handle it manually
+    });
+    let stderrOutput = '';
+    let stdoutOutput = '';
+    await new Promise((res, rej) => {
+        if (onDataHandle) {
+            subprocess.stdout?.on('data', onDataHandle(spinner));
+        }
+        else if (actualStdout === 'pipe') {
+            // Capture stdout to check for errors
+            subprocess.stdout?.on('data', (data) => {
+                const text = data.toString();
+                stdoutOutput += text;
+                // If we're supposed to inherit stdout, output it
+                if (stdout === 'inherit') {
+                    process.stdout.write(data);
+                }
+            });
+        }
+        if (onStderrHandle) {
+            subprocess.stderr?.on('data', (data) => {
+                onStderrHandle(data);
+            });
+        }
+        else if (actualStderr === 'pipe') {
+            // Capture stderr to check for specific errors
+            subprocess.stderr?.on('data', (data) => {
+                const text = data.toString();
+                stderrOutput += text;
+                // If we're supposed to inherit stderr, output it
+                if (stderr === 'inherit') {
+                    process.stderr.write(data);
+                }
+            });
+        }
+        void subprocess.on('error', (e) => rej(e));
+        void subprocess.on('close', (code) => {
+            // Check for errors in stderr/stdout even if exit code is 0
+            if (checkStderrForErrors) {
+                const combinedOutput = (stderrOutput + stdoutOutput).toLowerCase();
+                const hasError = combinedOutput.includes('error:') ||
+                    combinedOutput.includes('errno:') ||
+                    combinedOutput.includes('sqlstate:') ||
+                    combinedOutput.includes('multiple primary key') ||
+                    combinedOutput.includes('er_multiple_pri_key') ||
+                    /error\s+\d+/.test(combinedOutput);
+                if (hasError) {
+                    const error = new Error(`${command} encountered an error during execution`);
+                    if (stderrOutput) {
+                        ;
+                        error.stderr = stderrOutput;
+                    }
+                    if (stdoutOutput) {
+                        ;
+                        error.stdout = stdoutOutput;
+                    }
+                    rej(error);
+                    return;
+                }
+            }
+            if (checkExitCode && code !== 0) {
+                const error = new Error(`${command} exited with code ${code}`);
+                if (stderrOutput) {
+                    ;
+                    error.stderr = stderrOutput;
+                }
+                if (stdoutOutput) {
+                    ;
+                    error.stdout = stdoutOutput;
+                }
+                rej(error);
+            }
+            else {
+                res();
+            }
+        });
+    });
+    return spinner;
+};

package/dist/cli/utils/get-package-manager.d.ts

@@ -0,0 +1,4 @@
+/** Detect preferred package manager */
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+export declare function detectPackageManager(): 'pnpm' | 'npm' | 'yarn' | 'bun';
+//# sourceMappingURL=get-package-manager.d.ts.map

package/dist/cli/utils/get-package-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-package-manager.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/get-package-manager.ts"],"names":[],"mappings":"AAAA,uCAAuC;AACvC,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAA;AAC5D,wBAAgB,oBAAoB,IAAI,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAkBtE"}

package/dist/cli/utils/get-package-manager.js

@@ -0,0 +1,22 @@
+export function detectPackageManager() {
+    // This environment variable is set by npm and yarn but pnpm seems less consistent
+    const userAgent = process.env.npm_config_user_agent;
+    if (userAgent) {
+        if (userAgent.startsWith('yarn')) {
+            return 'yarn';
+        }
+        else if (userAgent.startsWith('pnpm')) {
+            return 'pnpm';
+        }
+        else if (userAgent.startsWith('bun')) {
+            return 'bun';
+        }
+        else {
+            return 'npm';
+        }
+    }
+    else {
+        // If no user agent is set, assume npm
+        return 'npm';
+    }
+}

package/dist/cli/utils/reload-env.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Reloads environment variables from .env files
+ * This is useful after programmatically writing to .env files
+ */
+export declare function reloadEnvironmentVariables(envFile?: string): boolean;
+/**
+ * Updates specific environment variables in process.env
+ * This provides immediate availability without requiring a full reload
+ */
+export declare function updateEnvironmentVariables(variables: Record<string, string>): void;
+/**
+ * Reloads environment variables and updates specific ones in process.env
+ * This combines both approaches for maximum compatibility
+ */
+export declare function reloadAndUpdateEnvironmentVariables(variables?: Record<string, string>, envFile?: string): boolean;
+//# sourceMappingURL=reload-env.d.ts.map

package/dist/cli/utils/reload-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reload-env.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/reload-env.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAepE;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAIlF;AAED;;;GAGG;AACH,wBAAgB,mCAAmC,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAQjH"}