@c15t/cli 1.5.0 → 1.6.0

package/dist/index.mjs

@@ -3,9 +3,8 @@ import * as __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__ from "@clack/pro
 import "dotenv/config";
 import * as __WEBPACK_EXTERNAL_MODULE_open__ from "open";
 import * as __WEBPACK_EXTERNAL_MODULE_picocolors__ from "picocolors";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
 import * as __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__ from "node:path";
-import * as __WEBPACK_EXTERNAL_MODULE_c12__ from "c12";
+import * as __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__ from "node:fs/promises";
 import * as __WEBPACK_EXTERNAL_MODULE_node_crypto_9ba42079__ from "node:crypto";
 import * as __WEBPACK_EXTERNAL_MODULE_node_os_74b4b876__ from "node:os";
 import * as __WEBPACK_EXTERNAL_MODULE_posthog_node_1b07bdf4__ from "posthog-node";
@@ -13,213 +12,12 @@ import * as __WEBPACK_EXTERNAL_MODULE_node_child_process_27f17141__ from "node:c
 import * as __WEBPACK_EXTERNAL_MODULE_node_events_0a6aefe7__ from "node:events";
 import * as __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__ from "@doubletie/logger";
 import * as __WEBPACK_EXTERNAL_MODULE_ts_morph_07c7ce60__ from "ts-morph";
-import * as __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__ from "node:fs";
-import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__ from "@c15t/backend/pkgs/db-adapters";
-import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__ from "@c15t/backend/pkgs/migrations";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_v2_db_migrator_64e67b79__ from "@c15t/backend/v2/db/migrator";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_backend_v2_db_schema_c18e255b__ from "@c15t/backend/v2/db/schema";
+import * as __WEBPACK_EXTERNAL_MODULE_c12__ from "c12";
 import * as __WEBPACK_EXTERNAL_MODULE_figlet__ from "figlet";
 import * as __WEBPACK_EXTERNAL_MODULE_fs_extra_ce68a66b__ from "fs-extra";
 import * as __WEBPACK_EXTERNAL_MODULE_package_manager_detector_detect_94d6a9ae__ from "package-manager-detector/detect";
-function isC15TOptions(obj) {
-    return 'object' == typeof obj && null !== obj && 'appName' in obj;
-}
-function isClientOptions(obj) {
-    return 'object' == typeof obj && null !== obj && ('mode' in obj || 'backendURL' in obj);
-}
-function tryGetFunctionResult(fn) {
-    if ('function' == typeof fn) try {
-        return fn();
-    } catch (error) {
-        console.warn('Error executing config function:', error);
-    }
-    return null;
-}
-function extractOptionsFromConfig(config) {
-    if (config.c15tConfig && isClientOptions(config.c15tConfig)) return config.c15tConfig;
-    if (config.c15tOptions && isClientOptions(config.c15tOptions)) return config.c15tOptions;
-    if (isClientOptions(config)) return config;
-    if (isC15TOptions(config.c15t)) return config.c15t;
-    if ('function' == typeof config.c15t) {
-        const result = tryGetFunctionResult(config.c15t);
-        if (isC15TOptions(result)) return result;
-    }
-    if (isC15TOptions(config.default)) return config.default;
-    if ('function' == typeof config.default) {
-        const result = tryGetFunctionResult(config.default);
-        if (isC15TOptions(result)) return result;
-    }
-    if (isC15TOptions(config.c15tInstance)) return config.c15tInstance;
-    if ('function' == typeof config.c15tInstance) {
-        const result = tryGetFunctionResult(config.c15tInstance);
-        if (isC15TOptions(result)) return result;
-    }
-    if (isC15TOptions(config.consent)) return config.consent;
-    if ('function' == typeof config.consent) {
-        const result = tryGetFunctionResult(config.consent);
-        if (isC15TOptions(result)) return result;
-    }
-    if ('object' == typeof config.c15t && null !== config.c15t && isC15TOptions(config.c15t.options)) return config.c15t.options;
-    if ('object' == typeof config.default && null !== config.default && isC15TOptions(config.default.options)) return config.default.options;
-    if ('object' == typeof config.c15tInstance && null !== config.c15tInstance && isC15TOptions(config.c15tInstance.options)) return config.c15tInstance.options;
-    if ('object' == typeof config.instance && null !== config.instance && isC15TOptions(config.instance.options)) return config.instance.options;
-    if ('object' == typeof config.consent && null !== config.consent && isC15TOptions(config.consent.options)) return config.consent.options;
-    if ('object' == typeof config.config && null !== config.config && isC15TOptions(config.config.options)) return config.config.options;
-    console.debug('No valid configuration found in any of the expected locations');
-    return null;
-}
-const configFileNames = [
-    'c15t.config',
-    'c15t.backend',
-    'c15t',
-    'c15t.client',
-    'consent.config',
-    'consent.backend',
-    'consent',
-    'cmp.config',
-    'cmp.backend',
-    'cmp'
-];
-const constants_extensions = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.cjs',
-    '.cts',
-    '.mjs',
-    '.mts',
-    '.server.cjs',
-    '.server.cts',
-    '.server.js',
-    '.server.jsx',
-    '.server.mjs',
-    '.server.mts',
-    '.server.ts',
-    '.server.tsx'
-];
-let possiblePaths = configFileNames.flatMap((name)=>constants_extensions.map((ext)=>`${name}${ext}`));
-const directories = [
-    '',
-    'lib/server/',
-    'server/',
-    'lib/',
-    'utils/',
-    'config/',
-    'src/',
-    'app/'
-];
-possiblePaths = directories.flatMap((dir)=>possiblePaths.map((file)=>`${dir}${file}`));
-const jitiOptions = (context, cwd)=>{
-    const alias = context.config.getPathAliases(cwd) || {};
-    return {
-        extensions: [
-            '.ts',
-            '.tsx',
-            '.js',
-            '.jsx',
-            '.mjs',
-            '.cjs',
-            '.mts',
-            '.cts'
-        ],
-        alias
-    };
-};
-async function getConfig(contextOrOptions) {
-    const context = 'logger' in contextOrOptions ? contextOrOptions : {
-        ...contextOrOptions,
-        logger: {
-            debug: console.debug,
-            info: console.info,
-            warn: console.warn,
-            error: console.error
-        },
-        flags: {
-            config: contextOrOptions.configPath
-        },
-        error: {
-            handleError: (error)=>{
-                console.error('Error loading configuration:', error);
-                return null;
-            }
-        }
-    };
-    const { cwd, logger, flags } = context;
-    const configPath = flags.config;
-    let foundConfigPath = null;
-    try {
-        let options = null;
-        const customJitiOptions = jitiOptions(context, cwd);
-        if (configPath) {
-            foundConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(cwd, configPath);
-            logger.debug(`Using explicitly provided config path: ${foundConfigPath}`);
-        } else {
-            const prioritizedDirs = [
-                cwd,
-                __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'packages/cli')
-            ];
-            const primaryName = 'c15t.config';
-            const extensions = [
-                '.ts',
-                '.js',
-                '.mjs'
-            ];
-            for (const dir of prioritizedDirs){
-                for (const ext of extensions){
-                    const checkPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(dir, `${primaryName}${ext}`);
-                    try {
-                        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(checkPath);
-                        foundConfigPath = checkPath;
-                        logger.debug(`Found config via manual check: ${foundConfigPath}`);
-                        break;
-                    } catch  {}
-                }
-                if (foundConfigPath) break;
-            }
-        }
-        if (foundConfigPath) try {
-            logger.debug(`Loading configuration from resolved path: ${foundConfigPath}`);
-            const result = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
-                configFile: foundConfigPath,
-                jitiOptions: customJitiOptions
-            });
-            logger.debug('Raw config loading result:', result);
-            if (result.config) {
-                logger.debug('Trying to extract config from result.config');
-                options = extractOptionsFromConfig(result.config);
-            }
-            if (options) {
-                logger.debug('Extracted config:', options);
-                if (isC15TOptions(options) || isClientOptions(options)) {
-                    logger.debug('Configuration validated successfully.');
-                    return options;
-                }
-                logger.debug('Loaded config does not match expected schema');
-            } else logger.debug('No configuration extracted from loaded file');
-            logger.debug('Raw loaded configuration:', result);
-            return null;
-        } catch (error) {
-            logger.debug('Error loading config from explicit path:', error);
-            try {
-                logger.debug(`Trying to require module directly: ${foundConfigPath}`);
-                const importedModule = await import(foundConfigPath);
-                logger.debug('Directly imported module:', importedModule);
-                const extracted = extractOptionsFromConfig(importedModule);
-                if (extracted && (isC15TOptions(extracted) || isClientOptions(extracted))) {
-                    logger.debug('Found valid config through direct import');
-                    return extracted;
-                }
-            } catch (importError) {
-                logger.debug('Error importing module directly:', importError);
-            }
-            return null;
-        }
-        return options;
-    } catch (error) {
-        if ('error' in context && context.error && 'function' == typeof context.error.handleError) return context.error.handleError(error, 'Error loading configuration');
-        console.error('Error loading configuration:', error);
-        return null;
-    }
-}
 function showHelpMenu(context, version, commands, flags) {
     const { logger } = context;
     logger.debug('Displaying help menu using command and flag structures.');
@@ -288,7 +86,7 @@ async function detectFramework(projectRoot, logger) {
         return {
             framework: null,
             frameworkVersion: null,
-            pkg: null,
+            pkg: 'c15t',
             hasReact: false,
             reactVersion: null
         };
@@ -368,7 +166,10 @@ const TelemetryEventName = {
     MIGRATION_FAILED: 'migration.failed',
     GENERATE_STARTED: 'generate.started',
     GENERATE_COMPLETED: 'generate.completed',
-    GENERATE_FAILED: 'generate.failed'
+    GENERATE_FAILED: 'generate.failed',
+    SELF_HOST_STARTED: 'self-host.started',
+    SELF_HOST_COMPLETED: 'self-host.completed',
+    SELF_HOST_FAILED: 'self-host.failed'
 };
 class Telemetry {
     client = null;
@@ -591,6 +392,58 @@ function getManualInstallCommand(dependencies, packageManager) {
             return `npm install ${dependencies.join(' ')}`;
     }
 }
+async function installDependencies({ context, dependenciesToAdd, handleCancel, autoInstall = false }) {
+    const { telemetry, logger } = context;
+    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
+    if (0 === dependenciesToAdd.length) return {
+        installDepsConfirmed: false,
+        ranInstall: false
+    };
+    const depsString = dependenciesToAdd.map((d)=>__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(d)).join(', ');
+    if (!autoInstall) {
+        const addDepsSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+            message: `Add required dependencies using ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(context.packageManager.name)}? (${depsString})`,
+            initialValue: true
+        });
+        if (handleCancel?.(addDepsSelection)) return {
+            installDepsConfirmed: false,
+            ranInstall: false
+        };
+        if (!addDepsSelection) return {
+            installDepsConfirmed: false,
+            ranInstall: false
+        };
+    }
+    s.start(`Running ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(context.packageManager.name)} to add and install dependencies... (this might take a moment)`);
+    try {
+        await addAndInstallDependenciesViaPM(context.projectRoot, dependenciesToAdd, context.packageManager.name);
+        s.stop(`✅ Dependencies installed: ${dependenciesToAdd.map((d)=>__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(d)).join(', ')}`);
+        telemetry.trackEvent(TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
+            success: true,
+            dependencies: dependenciesToAdd.join(','),
+            packageManager: context.packageManager.name
+        });
+        return {
+            installDepsConfirmed: true,
+            ranInstall: true
+        };
+    } catch (installError) {
+        s.stop(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow('⚠️ Dependency installation failed.'));
+        logger.error('Installation Error:', installError);
+        telemetry.trackEvent(TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
+            success: false,
+            error: installError instanceof Error ? installError.message : String(installError),
+            dependencies: dependenciesToAdd.join(','),
+            packageManager: context.packageManager.name
+        });
+        const pmCommand = getManualInstallCommand(dependenciesToAdd, context.packageManager.name);
+        logger.info(`Please try running '${pmCommand}' manually in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(context.cwd, context.projectRoot))}.`);
+        return {
+            installDepsConfirmed: true,
+            ranInstall: false
+        };
+    }
+}
 const validLogLevels = [
     'error',
     'warn',
@@ -1471,10 +1324,11 @@ async function handleEnvFiles(options) {
         throw error;
     }
 }
-async function generateFiles({ context, projectRoot, mode, pkg, backendURL, spinner, useEnvFile, proxyNextjs }) {
+async function generateFiles({ context, mode, spinner, useEnvFile, proxyNextjs, backendURL }) {
     const result = {
         layoutUpdated: false
     };
+    const { projectRoot, framework: { pkg } } = context;
     if ('@c15t/nextjs' === pkg || '@c15t/react' === pkg) {
         const layoutResult = await handleReactLayout({
             projectRoot,
@@ -1514,6 +1368,39 @@ async function generateFiles({ context, projectRoot, mode, pkg, backendURL, spin
     });
     return result;
 }
+async function getSharedFrontendOptions({ backendURL, context, handleCancel }) {
+    let useEnvFile = false;
+    let proxyNextjs;
+    if (!backendURL) return {
+        proxyNextjs: void 0,
+        useEnvFile: void 0
+    };
+    const useEnvFileSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Store the backendURL in a .env file? (Recommended, URL is public)',
+        initialValue: true
+    });
+    if (handleCancel?.(useEnvFileSelection)) context.error.handleCancel('Setup cancelled.', {
+        command: 'onboarding',
+        stage: 'self_hosted_env_file_setup'
+    });
+    useEnvFile = useEnvFileSelection;
+    if ('@c15t/nextjs' === context.framework.pkg) {
+        context.logger.info('Learn more about Next.js Rewrites: https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites');
+        const proxyNextjsSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+            message: 'Proxy requests to your instance with Next.js Rewrites? (Recommended)',
+            initialValue: true
+        });
+        if (handleCancel?.(proxyNextjsSelection)) context.error.handleCancel('Setup cancelled.', {
+            command: 'onboarding',
+            stage: 'self_hosted_proxy_nextjs_setup'
+        });
+        proxyNextjs = proxyNextjsSelection;
+    }
+    return {
+        proxyNextjs,
+        useEnvFile
+    };
+}
 async function handleAccountCreation(context, handleCancel) {
     const { logger } = context;
     const needsAccount = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
@@ -1572,218 +1459,567 @@ async function getBackendURL(context, initialBackendURL, handleCancel) {
     });
     return backendURLSelection;
 }
-async function setupC15tMode({ context, projectRoot, spinner, packageName, initialBackendURL, handleCancel }) {
+async function setupC15tMode({ context, spinner, initialBackendURL, handleCancel }) {
     await handleAccountCreation(context, handleCancel);
     const backendURL = await getBackendURL(context, initialBackendURL, handleCancel);
-    const useEnvFileSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
-        message: 'Store the backendURL in a .env file? (Recommended, URL is public)',
-        initialValue: true
-    });
-    if (handleCancel?.(useEnvFileSelection)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'c15t_env_file_setup'
+    const { useEnvFile, proxyNextjs } = await getSharedFrontendOptions({
+        backendURL: backendURL,
+        context,
+        handleCancel
     });
-    const useEnvFile = useEnvFileSelection;
-    let proxyNextjs;
-    if ('@c15t/nextjs' === packageName) {
-        context.logger.info('Learn more about Next.js Rewrites: https://nextjs.org/docs/app/api-reference/config/next-config-js/rewrites');
-        const proxyNextjsSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
-            message: 'Proxy requests to your instance with Next.js Rewrites? (Recommended)',
-            initialValue: true
-        });
-        if (handleCancel?.(proxyNextjsSelection)) context.error.handleCancel('Setup cancelled.', {
-            command: 'onboarding',
-            stage: 'c15t_proxy_nextjs_setup'
-        });
-        proxyNextjs = proxyNextjsSelection;
-    }
     await generateFiles({
         context,
-        projectRoot,
         mode: 'c15t',
-        pkg: packageName,
         backendURL,
         spinner,
         useEnvFile,
         proxyNextjs
     });
+    const { ranInstall, installDepsConfirmed } = await installDependencies({
+        context,
+        dependenciesToAdd: [
+            context.framework.pkg
+        ],
+        handleCancel
+    });
     return {
         backendURL,
-        usingEnvFile: useEnvFile,
-        proxyNextjs
+        usingEnvFile: useEnvFile ?? false,
+        proxyNextjs,
+        installDepsConfirmed,
+        ranInstall
     };
 }
-async function setupCustomMode({ context, projectRoot, spinner, pkg }) {
-    const { logger, cwd } = context;
+async function setupCustomMode({ context, spinner }) {
+    const { logger, cwd, framework: { pkg } } = context;
+    if (!pkg) throw new Error('Error detecting framework');
     const result = await generateFiles({
         context,
-        projectRoot,
         mode: 'custom',
-        pkg,
         spinner
     });
     logger.info(`Remember to implement custom endpoint handlers ${result.configPath ? `(see ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, result.configPath))})` : ''}`);
+    const { ranInstall, installDepsConfirmed } = await installDependencies({
+        context,
+        dependenciesToAdd: [
+            context.framework.pkg
+        ]
+    });
     return {
-        clientConfigContent: result.configContent ?? ''
+        clientConfigContent: result.configContent ?? '',
+        installDepsConfirmed,
+        ranInstall
     };
 }
-async function setupOfflineMode({ context, projectRoot, spinner, pkg }) {
+async function setupOfflineMode({ context, spinner }) {
     const result = await generateFiles({
         context,
-        projectRoot,
         mode: 'offline',
-        pkg,
         spinner
     });
+    const { ranInstall, installDepsConfirmed } = await installDependencies({
+        context,
+        dependenciesToAdd: [
+            context.framework.pkg
+        ]
+    });
     return {
-        clientConfigContent: result.configContent ?? ''
+        clientConfigContent: result.configContent ?? '',
+        installDepsConfirmed,
+        ranInstall
     };
 }
-function generateBackendConfigContent(adapterChoice, connectionString, filePath) {
-    let adapterImport = '';
-    let adapterConfig = '';
-    switch(adapterChoice){
-        case 'kysely-postgres':
-            adapterImport = `import { kyselyAdapter } from '@c15t/backend/db/adapters/kysely';\nimport { PostgresDialect } from 'kysely';\nimport { Pool } from 'pg';`;
-            adapterConfig = `kyselyAdapter({
-      dialect: new PostgresDialect({
-        pool: new Pool({
-          connectionString: ${connectionString ? `"${connectionString}"` : 'process.env.DATABASE_URL || "postgresql://user:password@host:port/db"'}
-        })
-      })
-    })`;
-            break;
-        case 'kysely-sqlite':
-            adapterImport = `import { kyselyAdapter } from '@c15t/backend/db/adapters/kysely';\nimport { SqliteDialect } from 'kysely';\nimport Database from 'better-sqlite3';`;
-            adapterConfig = `kyselyAdapter({
-      dialect: new SqliteDialect({
-        database: new Database("${filePath || './db.sqlite'}")
-      })
-    })`;
-            break;
-        default:
-            adapterImport = "import { memoryAdapter } from '@c15t/backend/db/adapters/memory';";
-            adapterConfig = 'memoryAdapter({})';
-            break;
+const ADAPTER_LABELS = {
+    kyselyAdapter: 'kysely',
+    drizzleAdapter: 'drizzle',
+    prismaAdapter: 'prisma',
+    typeormAdapter: 'typeorm',
+    mongoAdapter: 'mongo'
+};
+const PROVIDERS_BY_ADAPTER = {
+    kyselyAdapter: [
+        {
+            label: 'PostgreSQL',
+            value: 'postgresql'
+        },
+        {
+            label: 'MySQL',
+            value: 'mysql'
+        },
+        {
+            label: 'SQLite',
+            value: 'sqlite'
+        },
+        {
+            label: 'CockroachDB',
+            value: 'cockroachdb'
+        },
+        {
+            label: 'Microsoft SQL Server',
+            value: 'mssql'
+        }
+    ],
+    drizzleAdapter: [
+        {
+            label: 'PostgreSQL',
+            value: 'postgresql'
+        },
+        {
+            label: 'MySQL',
+            value: 'mysql'
+        },
+        {
+            label: 'SQLite',
+            value: 'sqlite'
+        }
+    ],
+    prismaAdapter: [
+        {
+            label: 'PostgreSQL',
+            value: 'postgresql'
+        },
+        {
+            label: 'MySQL',
+            value: 'mysql'
+        },
+        {
+            label: 'SQLite',
+            value: 'sqlite'
+        },
+        {
+            label: 'MongoDB',
+            value: 'mongodb'
+        }
+    ],
+    typeormAdapter: [
+        {
+            label: 'PostgreSQL',
+            value: 'postgresql'
+        },
+        {
+            label: 'MySQL',
+            value: 'mysql'
+        },
+        {
+            label: 'SQLite',
+            value: 'sqlite'
+        },
+        {
+            label: 'SQL Server',
+            value: 'mssql'
+        }
+    ],
+    mongoAdapter: [
+        {
+            label: 'MongoDB',
+            value: 'mongodb'
+        }
+    ]
+};
+class Cancelled extends Error {
+    stage;
+    constructor(stage){
+        super('Operation cancelled.');
+        this.stage = stage;
+    }
+}
+const CONFIG_BUILDERS = {
+    kyselyAdapter: (provider)=>`kyselyAdapter({ provider: '${provider}', db })`,
+    drizzleAdapter: (provider)=>`drizzleAdapter({ provider: '${provider}', db })`,
+    prismaAdapter: (provider)=>`prismaAdapter({ provider: '${provider}', prisma })`,
+    typeormAdapter: (provider)=>`typeormAdapter({ provider: '${provider}', source })`,
+    mongoAdapter: ()=>'mongoAdapter({ client })'
+};
+async function pathExists(filePath) {
+    try {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(filePath);
+        return true;
+    } catch  {
+        return false;
     }
-    return `// c15t Backend Configuration
-// Generated by c15t CLI onboarding
-
-import { c15tInstance } from '@c15t/backend';
-${adapterImport}
-
-// WARNING: Database connection strings often contain sensitive credentials.
-// Consider using environment variables instead of hardcoding these values.
-
-// Define your c15t instance
-const instance = c15tInstance({
-  appName: 'Your App Name',
-  basePath: '/api/c15t',
-  database: ${adapterConfig},
-  trustedOrigins: ['http://localhost:3000'],
+}
+function buildDatabaseConfig(adapter, provider, connection) {
+    const builder = CONFIG_BUILDERS[adapter];
+    return builder(provider, connection);
+}
+function buildKyselyPrelude(provider, connection) {
+    const connExpr = connection.useEnv ? `process.env.${connection.envVar || 'DATABASE_URL'}!` : `"${connection.value || ''}"`;
+    if ('postgresql' === provider || 'cockroachdb' === provider) return {
+        imports: "import { Kysely, PostgresDialect } from 'kysely';\nimport { Pool } from 'pg';",
+        prelude: `const db = new Kysely({\n\tdialect: new PostgresDialect({\n\t\tpool: new Pool({ connectionString: ${connExpr} }),\n\t}),\n});`
+    };
+    if ('mysql' === provider) return {
+        imports: "import { Kysely, MysqlDialect } from 'kysely';\nimport mysql from 'mysql2/promise';",
+        prelude: `const db = new Kysely({\n\tdialect: new MysqlDialect({\n\t\tpool: mysql.createPool(${connExpr}),\n\t}),\n});`
+    };
+    if ('mssql' === provider) return {
+        imports: "import { Kysely, MssqlDialect } from 'kysely';\nimport mssql from 'mssql';",
+        prelude: `const db = new Kysely({\n\tdialect: new MssqlDialect({\n\t\tpool: new mssql.ConnectionPool(${connExpr}),\n\t}),\n});`
+    };
+    return {
+        imports: '',
+        prelude: ''
+    };
+}
+function buildSqliteKyselyPrelude(file) {
+    return {
+        imports: "import { Kysely, SqliteDialect } from 'kysely';\nimport Database from 'better-sqlite3';",
+        prelude: `const db = new Kysely({\n\tdialect: new SqliteDialect({\n\t\tdatabase: new Database("${file}"),\n\t}),\n});`
+    };
+}
+function buildDrizzlePrelude(provider, connection) {
+    const connExpr = connection.useEnv ? `process.env.${connection.envVar || 'DATABASE_URL'}!` : `"${connection.value || ''}"`;
+    if ('postgresql' === provider) return {
+        imports: "import { drizzle } from 'drizzle-orm/node-postgres';\nimport { Pool } from 'pg';",
+        prelude: `const db = drizzle(new Pool({ connectionString: ${connExpr} }));`
+    };
+    if ('mysql' === provider) return {
+        imports: "import { drizzle } from 'drizzle-orm/mysql2';\nimport mysql from 'mysql2/promise';",
+        prelude: `const db = drizzle(await mysql.createConnection(${connExpr}));`
+    };
+    if ('sqlite' === provider) {
+        const file = connection.sqliteFile || './db.sqlite';
+        return {
+            imports: "import { drizzle } from 'drizzle-orm/better-sqlite3';\nimport Database from 'better-sqlite3';",
+            prelude: `const db = drizzle(new Database("${file}"));`
+        };
+    }
+    return {
+        imports: '',
+        prelude: ''
+    };
+}
+function buildPrismaPrelude(_provider, _connection) {
+    return {
+        imports: "import { PrismaClient } from '@prisma/client';",
+        prelude: 'const prisma = new PrismaClient();'
+    };
+}
+function buildTypeormPrelude(provider, connection) {
+    const connExpr = connection.useEnv ? `process.env.${connection.envVar || 'DATABASE_URL'}!` : `"${connection.value || ''}"`;
+    if ('sqlite' === provider) {
+        const file = connection.sqliteFile || './db.sqlite';
+        return {
+            imports: "import { DataSource } from 'typeorm';",
+            prelude: `const source = new DataSource({ type: 'sqlite', database: "${file}" });`
+        };
+    }
+    const typeMap = {
+        postgresql: 'postgres',
+        mysql: 'mysql',
+        mssql: 'mssql'
+    };
+    return {
+        imports: "import { DataSource } from 'typeorm';",
+        prelude: `const source = new DataSource({ type: '${typeMap[String(provider)]}', url: ${connExpr} });`
+    };
+}
+function buildMongoPrelude(connection) {
+    const urlExpr = connection.useEnv ? `process.env.${connection.envVar || 'MONGODB_URI'}!` : `"${connection.value || ''}"`;
+    return {
+        imports: "import { MongoClient } from 'mongodb';",
+        prelude: `const client = new MongoClient(${urlExpr});`
+    };
+}
+function buildFileContent(adapter, provider, dbConfig, connection) {
+    const adapterPath = 'mongoAdapter' === adapter ? 'mongo' : adapter.replace('Adapter', '');
+    const importAdapter = `import { ${adapter} } from '@c15t/backend/v2/db/adapters/${adapterPath}';`;
+    let extras = {
+        imports: '',
+        prelude: ''
+    };
+    if ('kyselyAdapter' === adapter) if ('sqlite' === provider) {
+        const file = connection.sqliteFile || './db.sqlite';
+        extras = buildSqliteKyselyPrelude(file);
+    } else extras = buildKyselyPrelude(provider, connection);
+    else if ('drizzleAdapter' === adapter) extras = buildDrizzlePrelude(provider, connection);
+    else if ('prismaAdapter' === adapter) extras = buildPrismaPrelude(provider, connection);
+    else if ('typeormAdapter' === adapter) extras = buildTypeormPrelude(provider, connection);
+    else if ('mongoAdapter' === adapter) extras = buildMongoPrelude(connection);
+    return `import { defineConfig } from '@c15t/backend/v2';
+${importAdapter}
+${extras.imports ? `${extras.imports}\n` : ''}
+${extras.prelude ? `${extras.prelude}\n` : ''}
+export default defineConfig({
+	adapter: ${dbConfig},
 });
-
-export default instance;
 `;
 }
-async function setupSelfHostedMode(context, projectRoot, spinner, handleCancel) {
-    const { cwd } = context;
-    let backendConfigContent = null;
-    const dependencies = [
-        '@c15t/backend'
-    ];
-    const setupBackendSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
-        message: 'Set up the backend configuration now?',
-        initialValue: true
+async function promptSelectAdapter() {
+    const selection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+        message: 'Select database adapter:',
+        options: Object.keys(ADAPTER_LABELS).map((key)=>({
+                value: key,
+                label: ADAPTER_LABELS[key]
+            }))
     });
-    if (handleCancel?.(setupBackendSelection)) context.error.handleCancel('Setup cancelled.', {
-        command: 'onboarding',
-        stage: 'self_hosted_backend_setup'
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selection)) throw new Cancelled('adapter_select');
+    return selection;
+}
+async function promptSelectProvider(adapter) {
+    const providers = PROVIDERS_BY_ADAPTER[adapter];
+    if (0 === providers.length) throw new Error('No providers available for selected adapter');
+    if (1 === providers.length) {
+        const [first] = providers;
+        return first.value;
+    }
+    const selection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+        message: 'Select database provider:',
+        options: providers.map((opt)=>({
+                value: opt.value,
+                label: opt.label
+            }))
     });
-    const setupBackend = setupBackendSelection;
-    let adapterChoice = 'memory';
-    if (setupBackend) {
-        const adapterSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
-            message: 'Choose a database adapter:',
-            initialValue: 'kysely-sqlite',
-            options: [
-                {
-                    value: 'kysely-sqlite',
-                    label: 'Kysely (SQLite)',
-                    hint: 'Simple setups/local dev'
-                },
-                {
-                    value: 'kysely-postgres',
-                    label: 'Kysely (PostgreSQL)',
-                    hint: 'Production'
-                },
-                {
-                    value: 'memory',
-                    label: 'Memory',
-                    hint: 'Testing/development only'
-                }
-            ]
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selection)) throw new Cancelled('provider_select');
+    return selection;
+}
+async function promptConnection(adapter, provider) {
+    const connection = {
+        useEnv: true
+    };
+    if ('sqlite' === provider) {
+        const sqliteFile = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+            message: 'SQLite file path:',
+            initialValue: './db.sqlite'
         });
-        if (handleCancel?.(adapterSelection)) context.error.handleCancel('Setup cancelled.', {
-            command: 'onboarding',
-            stage: 'self_hosted_adapter_selection'
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(sqliteFile)) throw new Cancelled('sqlite_path');
+        connection.sqliteFile = String(sqliteFile);
+        return connection;
+    }
+    const useEnv = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Store connection string in an environment variable?',
+        initialValue: true
+    });
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(useEnv)) throw new Cancelled('use_env_confirm');
+    connection.useEnv = Boolean(useEnv);
+    if (connection.useEnv) {
+        const defaultVar = 'mongoAdapter' === adapter ? 'MONGODB_URI' : 'DATABASE_URL';
+        const envVarName = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+            message: 'Env var name for connection string:',
+            initialValue: defaultVar
         });
-        adapterChoice = adapterSelection;
-        let connectionString;
-        let dbPath;
-        if ('kysely-postgres' === adapterChoice) {
-            const connectionStringSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
-                message: 'Enter PostgreSQL connection string:',
-                placeholder: 'postgresql://user:pass@host:port/db'
-            });
-            if (handleCancel?.(connectionStringSelection)) context.error.handleCancel('Setup cancelled.', {
-                command: 'onboarding',
-                stage: 'self_hosted_postgres_setup'
-            });
-            if (!connectionStringSelection || '' === connectionStringSelection) context.error.handleCancel('A valid PostgreSQL connection string is required', {
-                command: 'onboarding',
-                stage: 'self_hosted_postgres_validation'
-            });
-            connectionString = connectionStringSelection;
-        } else if ('kysely-sqlite' === adapterChoice) {
-            const dbPathSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
-                message: 'Enter path for SQLite database file:',
-                placeholder: './db.sqlite',
-                initialValue: './db.sqlite'
-            });
-            if (handleCancel?.(dbPathSelection)) context.error.handleCancel('Setup cancelled.', {
-                command: 'onboarding',
-                stage: 'self_hosted_sqlite_setup'
-            });
-            if (!dbPathSelection || '' === dbPathSelection) context.error.handleCancel('A valid database path is required', {
-                command: 'onboarding',
-                stage: 'self_hosted_sqlite_validation'
-            });
-            dbPath = dbPathSelection;
-        }
-        backendConfigContent = generateBackendConfigContent(adapterChoice, connectionString, dbPath);
-        const backendConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.backend.ts');
-        spinner.start('Creating backend configuration file...');
-        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(backendConfigPath, backendConfigContent);
-        spinner.stop(formatLogMessage('info', `Backend configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, backendConfigPath))}`));
+        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(envVarName)) throw new Cancelled('env_var_name');
+        connection.envVar = String(envVarName);
+        return connection;
+    }
+    const placeholder = 'mongoAdapter' === adapter ? 'mongodb+srv://user:pass@host/db' : 'postgresql://user:pass@host:5432/db';
+    const connectionString = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+        message: 'Connection string:',
+        placeholder
+    });
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(connectionString)) throw new Cancelled('connection_string');
+    connection.value = String(connectionString);
+    return connection;
+}
+async function ensureBackendConfig(context) {
+    const { cwd, logger } = context;
+    const targetPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'c15t-backend.config.ts');
+    if (await pathExists(targetPath)) {
+        logger.debug(`Backend config already exists at ${targetPath}`);
+        return {
+            path: targetPath,
+            dependencies: []
+        };
     }
-    const clientConfigContent = generateClientConfigContent('c15t', '/api/c15t', false);
-    const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
-    spinner.start('Creating client configuration file...');
-    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(configPath, clientConfigContent);
-    spinner.stop(formatLogMessage('info', `Client configuration created: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath))}`));
-    return {
-        clientConfigContent,
-        backendConfigContent,
-        dependencies,
-        adapterChoice
-    };
-}
-const WINDOWS_PATH_SEPARATOR_REGEX = /\\/g;
+    try {
+        const adapter = await promptSelectAdapter();
+        const provider = await promptSelectProvider(adapter);
+        const connection = await promptConnection(adapter, provider);
+        const dependencies = [];
+        if ('kyselyAdapter' === adapter) {
+            dependencies.push('kysely');
+            if ('postgresql' === provider || 'cockroachdb' === provider) dependencies.push('pg');
+            else if ('mysql' === provider) dependencies.push('mysql2');
+            else if ('mssql' === provider) dependencies.push('mssql');
+            else if ('sqlite' === provider) dependencies.push('better-sqlite3');
+        } else if ('drizzleAdapter' === adapter) {
+            dependencies.push('drizzle-orm');
+            if ('postgresql' === provider) dependencies.push('pg');
+            else if ('mysql' === provider) dependencies.push('mysql2');
+            else if ('sqlite' === provider) dependencies.push('better-sqlite3');
+        } else if ('prismaAdapter' === adapter) dependencies.push('@prisma/client');
+        else if ('typeormAdapter' === adapter) dependencies.push('typeorm');
+        else if ('mongoAdapter' === adapter) dependencies.push('mongodb');
+        const dbConfig = buildDatabaseConfig(adapter, provider, connection);
+        const fileContent = buildFileContent(adapter, String(provider), dbConfig, connection);
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(targetPath, fileContent, 'utf8');
+        context.logger.success(`Created ${__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, targetPath)}`);
+        if ('sqlite' !== provider && connection.useEnv && connection.envVar) context.logger.note(`Remember to set ${connection.envVar} in your environment or .env file.`, 'Environment');
+        return {
+            path: targetPath,
+            dependencies
+        };
+    } catch (err) {
+        if (err instanceof Cancelled) return context.error.handleCancel('Operation cancelled.', {
+            command: 'ensure-backend-config',
+            stage: err.stage
+        });
+        throw err;
+    }
+}
+async function handleMigrationResult(context, result) {
+    const { logger, telemetry } = context;
+    telemetry.trackEvent(TelemetryEventName.MIGRATION_PLANNED, {
+        success: true
+    });
+    const viewSQL = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'View SQL for this migration?',
+        initialValue: true
+    });
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(viewSQL)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
+        viewSQL: false
+    });
+    if (viewSQL) {
+        const sql = result.getSQL?.() ?? '';
+        logger.info(sql);
+    }
+    const execute = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Execute this migration?',
+        initialValue: false
+    });
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(execute)) return void telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
+        execute: false
+    });
+    await result.execute();
+    logger.success('Migration completed.');
+    telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
+        success: true
+    });
+}
+async function handleORMResult(context, result) {
+    const { logger, telemetry, cwd } = context;
+    const filePath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, result.path);
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].mkdir(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].dirname(filePath), {
+        recursive: true
+    });
+    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].writeFile(filePath, result.code);
+    logger.info(`Migration file created at ${filePath}`);
+    telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
+        success: true,
+        migrationFileCreated: true
+    });
+}
+async function readConfigAndGetDb(context, absoluteConfigPath) {
+    const { logger } = context;
+    logger.info(`Loading backend config from ${absoluteConfigPath}`);
+    const resolvedPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].resolve(absoluteConfigPath);
+    try {
+        await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(resolvedPath);
+    } catch  {
+        throw new Error(`Backend config not found at: ${resolvedPath}`);
+    }
+    try {
+        const { config } = await (0, __WEBPACK_EXTERNAL_MODULE_c12__.loadConfig)({
+            configFile: absoluteConfigPath,
+            jitiOptions: {
+                extensions: [
+                    '.ts',
+                    '.tsx',
+                    '.js',
+                    '.jsx',
+                    '.mjs',
+                    '.cjs',
+                    '.mts',
+                    '.cts',
+                    '.cjs'
+                ]
+            }
+        });
+        logger.debug('Imported Config');
+        return {
+            db: __WEBPACK_EXTERNAL_MODULE__c15t_backend_v2_db_schema_c18e255b__.DB.client(config.adapter)
+        };
+    } catch (error) {
+        logger.error('Failed to load backend config', error);
+        if (error instanceof Error) throw error;
+        throw new Error(`Unknown error loading backend config: ${String(error)}`);
+    }
+}
+async function migrate(context) {
+    const { logger } = context;
+    logger.info('Starting migration process...');
+    const configResult = await ensureBackendConfig(context);
+    if (!configResult || !configResult.path) return void logger.error('No backend config found.');
+    const { path, dependencies } = configResult;
+    if (dependencies.length > 0) await installDependencies({
+        context,
+        dependenciesToAdd: dependencies,
+        autoInstall: true
+    });
+    const { db } = await readConfigAndGetDb(context, path);
+    logger.info('Loaded c15t-backend.config.ts');
+    const result = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_v2_db_migrator_64e67b79__.migrator)({
+        db,
+        schema: 'latest'
+    });
+    if ('path' in result) await handleORMResult(context, result);
+    else await handleMigrationResult(context, result);
+}
+async function setupSelfHostedMode({ context, spinner, handleCancel }) {
+    const dependenciesToAdd = [
+        context.framework.pkg,
+        '@c15t/backend'
+    ];
+    const targetPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(context.cwd, 'c15t-backend.config.ts');
+    let createBackendConfig = false;
+    if (!await pathExists(targetPath)) {
+        if (createBackendConfig) {
+            const config = await ensureBackendConfig(context);
+            createBackendConfig = true;
+            dependenciesToAdd.push(...config?.dependencies ?? []);
+        }
+    }
+    const backendURL = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.text({
+        message: 'Enter the backend URL:',
+        initialValue: 'http://localhost:3000'
+    });
+    if (handleCancel?.(backendURL)) context.error.handleCancel('Setup cancelled.', {
+        command: 'onboarding',
+        stage: 'self_hosted_backend_url_setup'
+    });
+    const { useEnvFile, proxyNextjs } = await getSharedFrontendOptions({
+        backendURL: backendURL,
+        context,
+        handleCancel
+    });
+    await generateFiles({
+        context,
+        mode: 'c15t',
+        backendURL: backendURL,
+        spinner,
+        useEnvFile,
+        proxyNextjs
+    });
+    const { ranInstall, installDepsConfirmed } = await installDependencies({
+        context,
+        dependenciesToAdd,
+        handleCancel
+    });
+    const runMigrations = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
+        message: 'Would you like to run migrations?',
+        initialValue: true
+    });
+    if (handleCancel?.(runMigrations)) context.error.handleCancel('Setup cancelled.', {
+        command: 'onboarding',
+        stage: 'self_hosted_run_migrations_setup'
+    });
+    if (runMigrations) await migrate(context);
+    return {
+        backendURL: backendURL,
+        usingEnvFile: useEnvFile ?? false,
+        proxyNextjs,
+        createBackendConfig: createBackendConfig,
+        installDepsConfirmed,
+        ranInstall,
+        runMigrations: runMigrations
+    };
+}
+const WINDOWS_PATH_SEPARATOR_REGEX = /\\/g;
 const FILE_EXTENSION_REGEX = /\.(ts|js|tsx|jsx)$/;
-async function startOnboarding(context, existingConfig) {
+async function generate(context, mode) {
     const { logger, telemetry } = context;
-    const isUpdate = !!existingConfig;
+    logger.debug('Starting generate command...');
+    logger.debug(`Mode: ${mode}`);
     const handleCancel = (value)=>{
         if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(value)) {
             telemetry.trackEvent(TelemetryEventName.ONBOARDING_EXITED, {
@@ -1799,12 +2035,10 @@ async function startOnboarding(context, existingConfig) {
         return false;
     };
     try {
-        logger.info(isUpdate ? 'Starting configuration update...' : 'Starting onboarding process...');
-        telemetry.trackEvent(isUpdate ? TelemetryEventName.CONFIG_UPDATED : TelemetryEventName.ONBOARDING_STARTED, {
-            isUpdate
-        });
+        logger.info('Starting onboarding process...');
+        telemetry.trackEvent(TelemetryEventName.ONBOARDING_STARTED, {});
         telemetry.flushSync();
-        await performOnboarding(context, existingConfig, handleCancel);
+        await performOnboarding(context, handleCancel, mode);
         logger.success('🚀 Setup completed successfully!');
     } catch (error) {
         if (!__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(error)) telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
@@ -1813,70 +2047,78 @@ async function startOnboarding(context, existingConfig) {
         });
     }
 }
-async function performOnboarding(context, existingConfig, handleCancel) {
+async function performOnboarding(context, handleCancel, mode) {
     const { telemetry, logger, packageManager } = context;
-    const isUpdate = !!existingConfig;
     const projectRoot = await detectProjectRoot(context.cwd, logger);
     const { pkg } = await detectFramework(projectRoot, logger);
     if (!pkg) throw new Error('Error detecting framework');
-    const storageMode = await handleStorageModeSelection(context, handleCancel, existingConfig);
-    if (!storageMode) return;
-    const dependenciesToAdd = [
-        pkg
-    ];
-    switch(storageMode){
+    let selectedMode = mode ?? null;
+    logger.debug(`Selected mode: ${selectedMode}`);
+    if (!selectedMode) selectedMode = await handleStorageModeSelection(context, handleCancel);
+    if (!selectedMode) return;
+    const sharedOptions = {
+        context,
+        spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner(),
+        handleCancel
+    };
+    let installDepsConfirmed = false;
+    let ranInstall = false;
+    const dependenciesToAdd = [];
+    switch(selectedMode){
         case 'c15t':
             {
-                const initialBackendURL = isUpdate && existingConfig && isClientOptions(existingConfig) ? existingConfig.backendURL : void 0;
-                const c15tResult = await setupC15tMode({
-                    context,
-                    projectRoot,
-                    spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner(),
-                    packageName: pkg,
-                    initialBackendURL,
-                    handleCancel
-                });
+                const c15tResult = await setupC15tMode(sharedOptions);
+                installDepsConfirmed = c15tResult.installDepsConfirmed;
+                ranInstall = c15tResult.ranInstall;
+                dependenciesToAdd.push(context.framework.pkg);
                 telemetry.trackEvent(TelemetryEventName.ONBOARDING_C15T_MODE_CONFIGURED, {
                     usingEnvFile: c15tResult.usingEnvFile,
-                    hasInitialBackendURL: !!initialBackendURL,
                     proxyNextjs: c15tResult.proxyNextjs
                 });
                 break;
             }
         case 'offline':
-            await setupOfflineMode({
-                context,
-                projectRoot,
-                spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner(),
-                pkg
-            });
-            telemetry.trackEvent(TelemetryEventName.ONBOARDING_OFFLINE_MODE_CONFIGURED, {});
-            break;
+            {
+                const offlineResult = await setupOfflineMode({
+                    context,
+                    spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner()
+                });
+                installDepsConfirmed = offlineResult.installDepsConfirmed;
+                ranInstall = offlineResult.ranInstall;
+                dependenciesToAdd.push(context.framework.pkg);
+                telemetry.trackEvent(TelemetryEventName.ONBOARDING_OFFLINE_MODE_CONFIGURED, {});
+                break;
+            }
         case 'self-hosted':
             {
-                const selfHostedResult = await setupSelfHostedMode(context, projectRoot, __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner(), handleCancel);
-                dependenciesToAdd.push(...selfHostedResult.dependencies);
-                telemetry.trackEvent(TelemetryEventName.ONBOARDING_SELF_HOSTED_CONFIGURED, {
-                    databaseType: selfHostedResult.adapterChoice,
-                    dependencies: selfHostedResult.dependencies.join(',')
+                const selfHostedResult = await setupSelfHostedMode({
+                    context,
+                    spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner(),
+                    handleCancel
                 });
+                installDepsConfirmed = selfHostedResult.installDepsConfirmed;
+                ranInstall = selfHostedResult.ranInstall;
+                dependenciesToAdd.push(context.framework.pkg);
+                telemetry.trackEvent(TelemetryEventName.ONBOARDING_SELF_HOSTED_CONFIGURED, {});
                 break;
             }
         default:
-            await setupCustomMode({
-                context,
-                projectRoot,
-                spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner(),
-                pkg
-            });
-            telemetry.trackEvent(TelemetryEventName.ONBOARDING_CUSTOM_MODE_CONFIGURED, {});
-            break;
+            {
+                const customResult = await setupCustomMode({
+                    context,
+                    spinner: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner()
+                });
+                installDepsConfirmed = customResult.installDepsConfirmed;
+                ranInstall = customResult.ranInstall;
+                dependenciesToAdd.push(context.framework.pkg);
+                telemetry.trackEvent(TelemetryEventName.ONBOARDING_CUSTOM_MODE_CONFIGURED, {});
+                break;
+            }
     }
-    const { installDepsConfirmed, ranInstall } = await handleDependencyInstallation(context, projectRoot, dependenciesToAdd, packageManager, handleCancel, isUpdate);
     await displayNextSteps({
         context,
         projectRoot,
-        storageMode,
+        storageMode: selectedMode,
         installDepsConfirmed,
         ranInstall,
         dependenciesToAdd,
@@ -1885,16 +2127,15 @@ async function performOnboarding(context, existingConfig, handleCancel) {
     await handleGitHubStar(context);
     telemetry.trackEvent(TelemetryEventName.ONBOARDING_COMPLETED, {
         success: true,
-        storageMode,
+        selectedMode,
         installDependencies: ranInstall
     });
 }
-async function handleStorageModeSelection(context, handleCancel, existingConfig) {
+async function handleStorageModeSelection(context, handleCancel) {
     const { telemetry } = context;
-    const initialStorageMode = getInitialStorageMode(existingConfig);
     const storageModeSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
-        message: existingConfig ? `Select storage mode (current: ${initialStorageMode || 'unknown'}):` : 'How would you like to store consent decisions?',
-        initialValue: initialStorageMode || 'c15t',
+        message: 'How would you like to store consent decisions?',
+        initialValue: 'c15t',
         options: [
             {
                 value: 'c15t',
@@ -1921,71 +2162,15 @@ async function handleStorageModeSelection(context, handleCancel, existingConfig)
     if (handleCancel(storageModeSelection)) return null;
     const storageMode = storageModeSelection;
     telemetry.trackEvent(TelemetryEventName.ONBOARDING_STORAGE_MODE_SELECTED, {
-        storageMode,
-        isUpdate: !!existingConfig
+        storageMode
     });
     return storageMode;
 }
-async function handleDependencyInstallation(context, projectRoot, dependenciesToAdd, packageManager, handleCancel, isUpdate) {
-    const { telemetry, logger } = context;
-    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
-    if (0 === dependenciesToAdd.length) return {
-        installDepsConfirmed: false,
-        ranInstall: false
-    };
-    const depsString = dependenciesToAdd.map((d)=>__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(d)).join(', ');
-    const addDepsSelection = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
-        message: `${isUpdate ? 'Update' : 'Add'} required dependencies using ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(packageManager.name)}? (${depsString})`,
-        initialValue: true
-    });
-    if (handleCancel(addDepsSelection)) return {
-        installDepsConfirmed: false,
-        ranInstall: false
-    };
-    if (!addDepsSelection) return {
-        installDepsConfirmed: false,
-        ranInstall: false
-    };
-    s.start(`Running ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(packageManager.name)} to add and install dependencies... (this might take a moment)`);
-    try {
-        await addAndInstallDependenciesViaPM(projectRoot, dependenciesToAdd, packageManager.name);
-        s.stop(`✅ Dependencies installed: ${dependenciesToAdd.map((d)=>__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(d)).join(', ')}`);
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
-            success: true,
-            dependencies: dependenciesToAdd.join(','),
-            packageManager: packageManager.name
-        });
-        return {
-            installDepsConfirmed: true,
-            ranInstall: true
-        };
-    } catch (installError) {
-        s.stop(__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow('⚠️ Dependency installation failed.'));
-        logger.error('Installation Error:', installError);
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_DEPENDENCIES_INSTALLED, {
-            success: false,
-            error: installError instanceof Error ? installError.message : String(installError),
-            dependencies: dependenciesToAdd.join(','),
-            packageManager: packageManager.name
-        });
-        const pmCommand = getManualInstallCommand(dependenciesToAdd, packageManager.name);
-        logger.info(`Please try running '${pmCommand}' manually in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(context.cwd, projectRoot))}.`);
-        return {
-            installDepsConfirmed: true,
-            ranInstall: false
-        };
-    }
-}
-function getInitialStorageMode(config) {
-    if (!config) return;
-    if ('mode' in config) return isClientOptions(config) ? config.mode : 'c15t';
-}
 async function displayNextSteps(options) {
     const { context, projectRoot, storageMode, installDepsConfirmed, ranInstall, dependenciesToAdd, packageManager } = options;
     const { logger, cwd } = context;
     const { log } = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__;
     const configPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.config.ts');
-    const backendConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(projectRoot, 'c15t.backend.ts');
     const relativeConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, configPath);
     const importPath = `./${relativeConfigPath.replace(WINDOWS_PATH_SEPARATOR_REGEX, '/').replace(FILE_EXTENSION_REGEX, '')}`;
     const importStatement = __WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(`import { c15tConfig } from '${importPath}';`);
@@ -1995,20 +2180,9 @@ async function displayNextSteps(options) {
         case 'offline':
             break;
         case 'self-hosted':
-            {
-                log.step('Configuration Complete! Next Steps:');
-                let steps = '';
-                try {
-                    await __WEBPACK_EXTERNAL_MODULE_node_fs_promises_153e37e0__["default"].access(backendConfigPath);
-                    steps += `1. Configure database connection in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(__WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].relative(cwd, backendConfigPath))}.\n`;
-                    steps += '      2. Set up API routes using the exported backend instance.\n';
-                } catch  {
-                    steps += '1. Set up your c15t backend instance and API routes.\n';
-                }
-                steps += `3. Ensure ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('backendURL')} in ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan(relativeConfigPath)} points to your API.\n`;
-                logger.info(steps);
-                break;
-            }
+            log.step('Setup your backend with the c15t docs:');
+            logger.info('https://c15t.com/docs/self-host/v2');
+            break;
         case 'custom':
             {
                 log.step('Configuration Complete! Next Steps:');
@@ -2054,335 +2228,90 @@ If you find this useful, we'd really appreciate a GitHub star - it helps others
         logger.info(`You can star us later by visiting: ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('https://github.com/c15t/c15t')}`);
     }
 }
-async function setupGenerateEnvironment(context) {
-    const { logger, flags, cwd, error, telemetry } = context;
-    logger.debug('Setting up generate environment...');
-    logger.debug('Context flags:', flags);
-    logger.debug(`Context CWD: ${cwd}`);
-    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) {
-        telemetry.trackEvent(TelemetryEventName.GENERATE_FAILED, {
-            error: `Directory ${cwd} does not exist`,
-            stage: 'setup'
-        });
-        return error.handleError(new Error(`The directory "${cwd}" does not exist`), 'Generate setup failed');
-    }
-    logger.debug('Attempting to load configuration...');
-    const config = await context.config.loadConfig();
-    if (!config) {
-        logger.debug('No config found during setup, generate command will handle onboarding.');
-        try {
-            const memAdapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)({
-                appName: 'temp-for-setup',
-                database: {
-                    adapter: 'memory'
-                }
-            });
-            return {
-                config: null,
-                adapter: memAdapter
-            };
-        } catch (adapterError) {
-            telemetry.trackEvent(TelemetryEventName.GENERATE_FAILED, {
-                error: adapterError instanceof Error ? adapterError.message : String(adapterError),
-                stage: 'adapter_initialization'
-            });
-            return error.handleError(adapterError, 'Failed to initialize default memory adapter');
-        }
-    }
-    logger.debug('Config loaded, initializing adapter...');
-    let adapter;
-    try {
-        adapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config);
-        logger.debug('Adapter initialized successfully');
-    } catch (e) {
-        telemetry.trackEvent(TelemetryEventName.GENERATE_FAILED, {
-            error: e instanceof Error ? e.message : String(e),
-            stage: 'adapter_initialization_with_config'
-        });
-        return error.handleError(e, 'Failed to initialize database adapter');
-    }
-    if (!adapter) {
-        telemetry.trackEvent(TelemetryEventName.GENERATE_FAILED, {
-            error: 'Adapter initialization returned undefined',
-            stage: 'adapter_initialization_check'
-        });
-        return error.handleError(new Error('Adapter initialization returned undefined'), 'Database adapter could not be initialized');
+const subcommands = [
+    {
+        name: 'generate',
+        label: 'Generate',
+        hint: 'Generate code for your c15t project',
+        action: generate
+    },
+    {
+        name: 'migrate',
+        label: 'Migrate',
+        hint: 'Run database migrations',
+        action: migrate
     }
-    logger.debug('Environment setup complete');
-    return {
-        config,
-        adapter
-    };
-}
-async function generate(context) {
-    const { logger, error, telemetry } = context;
-    logger.debug('Starting generate command...');
-    telemetry.trackEvent(TelemetryEventName.GENERATE_STARTED, {});
-    const setupResult = await setupGenerateEnvironment(context);
-    let { config, adapter } = setupResult;
-    if (config) {
-        let currentMode = 'unknown';
-        if (isClientOptions(config)) {
-            if (config.mode) currentMode = config.mode;
-        } else if (isC15TOptions(config)) currentMode = 'backend';
-        telemetry.trackEvent(TelemetryEventName.CONFIG_LOADED, {
-            type: currentMode,
-            exists: true
-        });
-        const shouldUpdate = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
-            message: formatLogMessage('warn', `A c15t configuration already exists. Would you like to update it before generating? (${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].dim(`Current mode: ${currentMode}`)})`),
-            initialValue: false
-        });
-        if (!shouldUpdate) {
-            telemetry.trackEvent(TelemetryEventName.GENERATE_COMPLETED, {
-                success: false,
-                reason: 'user_cancelled'
-            });
-            return error.handleCancel('Operation cancelled.', {
-                command: 'generate',
-                stage: 'config_update_prompt'
-            });
-        }
-        if (shouldUpdate) {
-            await startOnboarding(context, config);
-            logger.debug('Reloading configuration after update...');
-            const postUpdateResult = await setupGenerateEnvironment(context);
-            if (!postUpdateResult.config) {
-                telemetry.trackEvent(TelemetryEventName.GENERATE_FAILED, {
-                    error: 'Failed to load configuration after update'
+];
+async function selfHost(context) {
+    const { logger, telemetry, commandArgs, error } = context;
+    logger.debug('Starting self-host command...');
+    telemetry.trackEvent(TelemetryEventName.SELF_HOST_STARTED, {});
+    const [subcommand] = commandArgs;
+    if (subcommand) {
+        switch(subcommand){
+            case 'generate':
+                await generate(context, 'self-hosted');
+                break;
+            case 'migrate':
+                await migrate(context);
+                break;
+            default:
+                logger.error(`Unknown self-host subcommand: ${subcommand}`);
+                logger.info('Available subcommands: generate, migrate');
+                telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
+                    success: false,
+                    reason: 'unknown_subcommand'
                 });
-                return error.handleError(new Error('Failed to load configuration after update.'), 'Configuration Error');
-            }
-            config = postUpdateResult.config;
-            postUpdateResult.adapter;
-            logger.info('Configuration updated successfully.');
-            telemetry.trackEvent(TelemetryEventName.GENERATE_COMPLETED, {
-                success: true,
-                configUpdated: true
-            });
-        } else {
-            logger.debug('Proceeding with existing configuration.');
-            telemetry.trackEvent(TelemetryEventName.GENERATE_COMPLETED, {
-                success: true,
-                configUpdated: false
-            });
-        }
-    } else {
-        logger.info('No configuration found.');
-        telemetry.trackEvent(TelemetryEventName.CONFIG_LOADED, {
-            exists: false
-        });
-        const shouldOnboard = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.confirm({
-            message: 'No c15t configuration found. Would you like to create one now?',
-            initialValue: true
-        });
-        if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(shouldOnboard) || !shouldOnboard) {
-            telemetry.trackEvent(TelemetryEventName.GENERATE_COMPLETED, {
-                success: false,
-                reason: 'onboarding_declined'
-            });
-            return error.handleCancel('Configuration setup cancelled.', {
-                command: 'generate',
-                stage: 'onboarding_prompt'
-            });
-        }
-        await startOnboarding(context);
-        logger.debug('Reloading configuration after onboarding...');
-        const postOnboardResult = await setupGenerateEnvironment(context);
-        if (!postOnboardResult.config) {
-            telemetry.trackEvent(TelemetryEventName.GENERATE_FAILED, {
-                error: 'Failed to load configuration even after onboarding'
-            });
-            return error.handleError(new Error('Failed to load configuration even after onboarding.'), 'Configuration Error');
+                break;
         }
-        config = postOnboardResult.config;
-        postOnboardResult.adapter;
-        logger.info('New configuration loaded successfully.');
-        telemetry.trackEvent(TelemetryEventName.GENERATE_COMPLETED, {
-            success: true,
-            newConfigCreated: true
-        });
+        return;
     }
-}
-async function executeMigrations(context, runMigrationsFn) {
-    const { logger, telemetry } = context;
-    logger.info('Executing migrations...');
-    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
-    s.start('Running migrations...');
-    telemetry.trackEvent(TelemetryEventName.MIGRATION_EXECUTED, {
-        status: 'started'
+    logger.debug('No subcommand specified, entering interactive selection.');
+    telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_OPENED, {
+        context: 'self-host'
     });
-    try {
-        await runMigrationsFn();
-        s.stop('Migrations completed successfully!');
-        logger.success('🚀 Database migrated successfully');
-        telemetry.trackEvent(TelemetryEventName.MIGRATION_EXECUTED, {
-            status: 'completed'
+    const promptOptions = subcommands.map((cmd)=>({
+            value: cmd.name,
+            label: cmd.label,
+            hint: cmd.hint
+        }));
+    promptOptions.push({
+        value: 'exit',
+        label: 'Exit',
+        hint: 'Return to main menu'
+    });
+    const selectedSubcommandName = await __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.select({
+        message: formatLogMessage('info', 'Which self-host command would you like to run?'),
+        options: promptOptions
+    });
+    if (__WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selectedSubcommandName) || 'exit' === selectedSubcommandName) {
+        logger.debug('Interactive selection cancelled or exit chosen.');
+        telemetry.trackEvent(TelemetryEventName.INTERACTIVE_MENU_EXITED, {
+            action: __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.isCancel(selectedSubcommandName) ? 'cancelled' : 'exit',
+            context: 'self-host'
         });
-    } catch (error) {
-        logger.error('Migration failed.');
-        telemetry.trackEvent(TelemetryEventName.MIGRATION_EXECUTED, {
-            status: 'failed',
-            error: error instanceof Error ? error.message : String(error)
+        error.handleCancel('Operation cancelled.', {
+            command: 'self-host',
+            stage: 'menu_selection'
         });
-        context.error.handleError(error, 'Error running migrations');
-    }
-}
-async function planMigrations(context, config, skipConfirmation) {
-    const { logger } = context;
-    logger.info('Planning migrations...');
-    logger.debug('Config:', config);
-    logger.debug(`Skip confirmation: ${skipConfirmation}`);
-    const s = __WEBPACK_EXTERNAL_MODULE__clack_prompts_3cae1695__.spinner();
-    s.start('Preparing migration plan...');
-    let migrationData;
-    try {
-        migrationData = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_migrations_80b6e3bd__.getMigrations)(config);
-        logger.debug('Migration data:', migrationData);
-    } catch (err) {
-        s.stop('Migration preparation failed.');
-        if (err instanceof Error) logger.error(err.message);
-        else logger.error(String(err));
-        logger.failed('Migration planning failed');
-        return {
-            shouldRun: false,
-            runMigrationsFn: null
-        };
-    }
-    if (!migrationData) {
-        s.stop('Could not retrieve migration data.');
-        logger.failed('Migration planning failed');
-        return {
-            shouldRun: false,
-            runMigrationsFn: null
-        };
-    }
-    const { toBeAdded, toBeCreated, runMigrations } = migrationData;
-    logger.debug('Migrations to be added:', toBeAdded);
-    logger.debug('Migrations to be created:', toBeCreated);
-    if (!toBeAdded.length && !toBeCreated.length) {
-        s.stop('No migrations needed.');
-        logger.info('🚀 Database is up to date');
-        return {
-            shouldRun: false,
-            runMigrationsFn: null
-        };
-    }
-    s.stop('Migration plan prepared.');
-    logger.info('🔑 The following migrations will be applied:');
-    for (const table of [
-        ...toBeCreated,
-        ...toBeAdded
-    ]){
-        const fields = Object.keys(table.fields).join(', ');
-        const tableName = table.table;
-        logger.info(`  + Table ${tableName}: Add fields [${fields}]`);
-        logger.message(`  ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('+')} Table ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].yellow(tableName)}: Add fields [${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].green(fields)}]`);
-    }
-    logger.message('');
-    let shouldMigrate = skipConfirmation;
-    if (!shouldMigrate) {
-        shouldMigrate = await context.confirm('Apply these migrations to the database?', false);
-        logger.debug(`User confirmation: ${shouldMigrate}`);
-    }
-    if (!shouldMigrate) {
-        logger.failed('Migration cancelled');
-        return {
-            shouldRun: false,
-            runMigrationsFn: null
-        };
-    }
-    logger.debug('Proceeding with migration execution');
-    return {
-        shouldRun: true,
-        runMigrationsFn: runMigrations
-    };
-}
-async function loadConfigAndOnboard(context) {
-    const { logger } = context;
-    logger.debug('Checking for existing configuration...');
-    let config;
-    try {
-        config = await context.config.loadConfig();
-    } catch (error) {
-        return context.error.handleError(error, 'Unexpected error during configuration loading');
-    }
-    if (!config) {
-        logger.info('No config found, starting onboarding.');
-        await startOnboarding(context);
-        logger.debug('Exiting after triggering onboarding.');
-        process.exit(0);
+        return;
     }
-    logger.debug('Configuration loaded successfully.');
-    return config;
-}
-function validateAdapterIsKysely(context, adapter) {
-    const { logger, error } = context;
-    logger.debug('Validating adapter:', adapter);
-    if (!adapter || 'kysely' !== adapter.id) {
-        let message = 'Invalid or unsupported database configuration for migrate. Migrate command only works with built-in Kysely adapter.';
-        if (adapter?.id === 'prisma') message = "The migrate command only works with the built-in Kysely adapter. For Prisma, run `npx @c15t/cli generate` to create the schema, then use Prisma's migrate or push to apply it.";
-        else if (adapter?.id === 'drizzle') message = "The migrate command only works with the built-in Kysely adapter. For Drizzle, run `npx @c15t/cli generate` to create the schema, then use Drizzle's migrate or push to apply it.";
-        error.handleError(new Error('Adapter validation failed: Not using Kysely'), message);
-    }
-}
-async function setupEnvironment(context) {
-    const { logger, flags, cwd, error } = context;
-    logger.info('Setting up migration environment...');
-    logger.debug('Flags:', flags);
-    logger.debug(`Working directory: ${cwd}`);
-    if (!(0, __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__.existsSync)(cwd)) return error.handleError(new Error(`The directory "${cwd}" does not exist`), 'Migration setup failed');
-    const config = await loadConfigAndOnboard(context);
-    logger.debug('Config loaded:', config);
-    let adapter;
-    try {
-        logger.debug('Initializing database adapter...');
-        adapter = await (0, __WEBPACK_EXTERNAL_MODULE__c15t_backend_pkgs_db_adapters_cee37d0f__.getAdapter)(config);
-        logger.debug('Adapter initialized:', adapter);
-    } catch (e) {
-        return error.handleError(e, 'Failed to initialize database adapter');
-    }
-    validateAdapterIsKysely(context, adapter);
-    logger.info('✅ Environment setup complete');
-    return {
-        config,
-        adapter: adapter
-    };
-}
-async function migrate(context) {
-    const { logger, flags, telemetry } = context;
-    logger.info('Starting migration process...');
-    logger.debug('Context:', context);
-    telemetry.trackEvent(TelemetryEventName.MIGRATION_STARTED, {
-        skipConfirmation: true === flags.y
-    });
-    const skipConfirmation = flags.y;
-    try {
-        const { config } = await setupEnvironment(context);
-        const planResult = await planMigrations(context, config, skipConfirmation);
-        logger.debug('Plan result:', planResult);
-        telemetry.trackEvent(TelemetryEventName.MIGRATION_PLANNED, {
-            shouldRun: planResult.shouldRun,
-            hasMigrations: !!planResult.runMigrationsFn
-        });
-        if (planResult.shouldRun && planResult.runMigrationsFn) {
-            await executeMigrations(context, planResult.runMigrationsFn);
-            telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
-                success: true
-            });
-        } else {
-            logger.debug('Skipping migration execution based on plan result');
-            telemetry.trackEvent(TelemetryEventName.MIGRATION_COMPLETED, {
-                success: true,
-                reason: planResult.shouldRun ? 'no_migrations_needed' : 'user_cancelled'
-            });
-        }
-    } catch (error) {
-        telemetry.trackEvent(TelemetryEventName.MIGRATION_FAILED, {
-            error: error instanceof Error ? error.message : String(error)
+    const selectedSubcommand = subcommands.find((cmd)=>cmd.name === selectedSubcommandName);
+    if (selectedSubcommand) {
+        logger.debug(`User selected subcommand: ${selectedSubcommand.name}`);
+        if ('generate' === selectedSubcommand.name) await generate(context, 'self-hosted');
+        else await selectedSubcommand.action(context);
+    } else {
+        logger.error(`Unknown subcommand: ${selectedSubcommandName}`);
+        telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
+            success: false,
+            reason: 'invalid_selection'
         });
-        context.error.handleError(error, 'An unexpected error occurred during the migration process');
+        return;
     }
+    telemetry.trackEvent(TelemetryEventName.SELF_HOST_COMPLETED, {
+        success: true
+    });
 }
 async function displayIntro(context, version) {
     const { logger } = context;
@@ -2431,86 +2360,6 @@ async function displayIntro(context, version) {
     });
     logger.message(coloredLines.join('\n'));
 }
-function createConfigManagement(context) {
-    const { logger, error } = context;
-    return {
-        loadConfig: async ()=>{
-            logger.debug('Attempting to load configuration...');
-            try {
-                const configResult = await getConfig(context);
-                const config = configResult ?? null;
-                logger.debug('Config loading result:', config);
-                if (config) logger.debug('Configuration loaded successfully.');
-                else logger.debug('No configuration found.');
-                return config;
-            } catch (err) {
-                return error.handleError(err, 'Error loading configuration');
-            }
-        },
-        requireConfig: async ()=>{
-            const config = await context.config.loadConfig();
-            if (!config) return error.handleError(new Error('Configuration required but not found'), 'Missing required configuration');
-            return config;
-        },
-        getPathAliases: (configDir)=>{
-            const cwd = configDir || context.cwd;
-            const tsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'tsconfig.json');
-            const jsConfigPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'jsconfig.json');
-            const configPath = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(tsConfigPath) ? tsConfigPath : __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(jsConfigPath) ? jsConfigPath : null;
-            if (!configPath) return null;
-            try {
-                return extractAliasesFromConfigFile(context, configPath, cwd);
-            } catch (extractError) {
-                logger.warn(`Error extracting path aliases from ${configPath}:`, extractError);
-                return null;
-            }
-        }
-    };
-}
-function stripJsonComments(jsonString) {
-    return jsonString.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (m, g)=>g ? '' : m).replace(/,(?=\s*[}\]])/g, '');
-}
-function extractAliasesFromConfigFile(context, configPath, cwd) {
-    try {
-        const configContent = __WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(configPath, 'utf8');
-        const strippedConfigContent = stripJsonComments(configContent);
-        const config = JSON.parse(strippedConfigContent);
-        const { paths = {}, baseUrl = '.' } = config.compilerOptions || {};
-        const result = {};
-        const obj = Object.entries(paths);
-        for (const [alias, aliasPaths] of obj)for (const aliasedPath of aliasPaths){
-            const resolvedBaseUrl = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, baseUrl);
-            const finalAlias = '*' === alias.slice(-1) ? alias.slice(0, -1) : alias;
-            const finalAliasedPath = '*' === aliasedPath.slice(-1) ? aliasedPath.slice(0, -1) : aliasedPath;
-            result[finalAlias || ''] = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(resolvedBaseUrl, finalAliasedPath);
-        }
-        if (hasSvelteKit(cwd)) addSvelteKitEnvModules(result);
-        return result;
-    } catch (error) {
-        context.logger.warn(`Error parsing config file ${configPath}`, error);
-        return null;
-    }
-}
-function hasSvelteKit(cwd) {
-    try {
-        const packageJsonPath = __WEBPACK_EXTERNAL_MODULE_node_path_c5b9b54f__["default"].join(cwd, 'package.json');
-        if (!__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].existsSync(packageJsonPath)) return false;
-        const packageJson = JSON.parse(__WEBPACK_EXTERNAL_MODULE_node_fs_5ea92f0c__["default"].readFileSync(packageJsonPath, 'utf8'));
-        const deps = {
-            ...packageJson.dependencies,
-            ...packageJson.devDependencies
-        };
-        return '@sveltejs/kit' in deps;
-    } catch (error) {
-        return false;
-    }
-}
-function addSvelteKitEnvModules(aliases) {
-    aliases['$app/'] = '$app/';
-    aliases['$lib/'] = '$lib/';
-    aliases['$env/'] = '$env/';
-    aliases['$service-worker'] = '$service-worker';
-}
 function createErrorHandlers(context) {
     const { logger, telemetry } = context;
     return {
@@ -2737,7 +2586,7 @@ function createUserInteraction(context) {
 }
 async function createCliContext(rawArgs, cwd, commands) {
     const { commandName, commandArgs, parsedFlags } = parseCliArgs(rawArgs, commands);
-    let desiredLogLevel = 'info';
+    let desiredLogLevel = 'debug';
     const levelArg = parsedFlags.logger;
     if ('string' == typeof levelArg) if (validLogLevels.includes(levelArg)) desiredLogLevel = levelArg;
     else console.warn(`[CLI Setup] Invalid log level '${levelArg}' provided via --logger. Using default 'info'.`);
@@ -2755,11 +2604,10 @@ async function createCliContext(rawArgs, cwd, commands) {
     context.error = createErrorHandlers(context);
     const userInteraction = createUserInteraction(context);
     context.confirm = userInteraction.confirm;
-    context.config = createConfigManagement(context);
     context.fs = createFileSystem(context);
-    const projectRoot = await detectProjectRoot(cwd, logger);
-    context.framework = await detectFramework(projectRoot, logger);
-    context.packageManager = await detectPackageManager(projectRoot, logger);
+    context.projectRoot = await detectProjectRoot(cwd, logger);
+    context.framework = await detectFramework(context.projectRoot, logger);
+    context.packageManager = await detectPackageManager(context.projectRoot, logger);
     const telemetryDisabled = true === parsedFlags['no-telemetry'];
     const telemetryDebug = true === parsedFlags['telemetry-debug'];
     try {
@@ -2794,17 +2642,17 @@ async function createCliContext(rawArgs, cwd, commands) {
 const src_commands = [
     {
         name: 'generate',
-        label: 'generate',
-        hint: 'Generate schema/code',
-        description: 'Generate schema/code based on your c15t config.',
+        label: 'Generate (Recommended)',
+        hint: 'Add c15t to your project',
+        description: 'Setup your c15t project',
         action: (context)=>generate(context)
     },
     {
-        name: 'migrate',
-        label: 'migrate',
-        hint: 'Run database migrations',
-        description: 'Run database migrations based on your c15t config.',
-        action: (context)=>migrate(context)
+        name: 'self-host',
+        label: 'Self Host',
+        hint: 'Host c15t backend on your own infra',
+        description: 'Commands for self-hosting c15t (generate, migrate).',
+        action: (context)=>selfHost(context)
     },
     {
         name: 'github',
@@ -2878,34 +2726,6 @@ flag or set ${__WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyan('C15T_TELEM
     await displayIntro(context, version);
     logger.debug(`Current working directory: ${cwd}`);
     logger.debug(`Config path flag: ${flags.config}`);
-    let clientConfig;
-    let backendConfig;
-    try {
-        const loadedConfig = await getConfig(context);
-        if (loadedConfig) if (isClientOptions(loadedConfig)) clientConfig = loadedConfig;
-        else if (isC15TOptions(loadedConfig)) backendConfig = loadedConfig;
-        else logger.warn('Loaded configuration is of an unknown type.');
-        if (loadedConfig) telemetry.trackEvent(TelemetryEventName.CONFIG_LOADED, {
-            configType: clientConfig ? 'client' : backendConfig ? 'backend' : 'unknown',
-            hasBackend: Boolean(backendConfig)
-        });
-    } catch (loadError) {
-        telemetry.trackEvent(TelemetryEventName.CONFIG_ERROR, {
-            error: loadError instanceof Error ? loadError.message : String(loadError)
-        });
-        return error.handleError(loadError, 'An unexpected error occurred during configuration loading');
-    }
-    if (!clientConfig) {
-        telemetry.trackEvent(TelemetryEventName.ONBOARDING_STARTED, {});
-        await startOnboarding(context);
-        await telemetry.shutdown();
-        return;
-    }
-    const coloredConsentIo = __WEBPACK_EXTERNAL_MODULE_picocolors__["default"].cyanBright('consent.io');
-    const backendStatus = backendConfig ? 'Backend configuration loaded' : `Using ${coloredConsentIo} for your c15t deployment`;
-    logger.info(`Client configuration successfully loaded and validated \n        ${backendStatus}`);
-    logger.debug('Client config details:', clientConfig);
-    if (backendConfig) logger.debug('Backend config details:', backendConfig);
     try {
         if (commandName) {
             const command = src_commands.find((cmd)=>cmd.name === commandName);