genbox 1.0.47 → 1.0.49

package/dist/db-utils.js

@@ -0,0 +1,416 @@
+"use strict";
+/**
+ * Database Utilities
+ *
+ * Handles local mongodump/mongorestore operations and
+ * uploading database dumps to genboxes.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMongoDumpAvailable = isMongoDumpAvailable;
+exports.getMongoDumpInstallInstructions = getMongoDumpInstallInstructions;
+exports.runLocalMongoDump = runLocalMongoDump;
+exports.uploadDumpToGenbox = uploadDumpToGenbox;
+exports.runRemoteMongoRestore = runRemoteMongoRestore;
+exports.cleanupDump = cleanupDump;
+exports.formatBytes = formatBytes;
+exports.waitForSshAccess = waitForSshAccess;
+exports.uploadDumpToS3 = uploadDumpToS3;
+exports.createAndUploadSnapshot = createAndUploadSnapshot;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Check if mongodump is available locally
+ */
+function isMongoDumpAvailable() {
+    try {
+        (0, child_process_1.execSync)('mongodump --version', { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get instructions for installing mongodb-database-tools
+ */
+function getMongoDumpInstallInstructions() {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+        return `Install MongoDB Database Tools:
+  ${chalk_1.default.cyan('brew tap mongodb/brew')}
+  ${chalk_1.default.cyan('brew install mongodb-database-tools')}`;
+    }
+    else if (platform === 'linux') {
+        return `Install MongoDB Database Tools:
+  ${chalk_1.default.cyan('# For Ubuntu/Debian:')}
+  ${chalk_1.default.cyan('wget -qO- https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-server-7.0.gpg')}
+  ${chalk_1.default.cyan('echo "deb [ signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list')}
+  ${chalk_1.default.cyan('sudo apt-get update && sudo apt-get install -y mongodb-database-tools')}`;
+    }
+    else {
+        return `Install MongoDB Database Tools from:
+  ${chalk_1.default.cyan('https://www.mongodb.com/try/download/database-tools')}`;
+    }
+}
+/**
+ * Run mongodump locally
+ */
+async function runLocalMongoDump(sourceUrl, options = {}) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'genbox-dbdump-'));
+    const dumpPath = path.join(tempDir, 'dump.gz');
+    return new Promise((resolve) => {
+        const args = [
+            `--uri=${sourceUrl}`,
+            `--archive=${dumpPath}`,
+            '--gzip',
+        ];
+        // Add collection filters
+        if (options.collections && options.collections.length > 0) {
+            for (const col of options.collections) {
+                args.push(`--collection=${col}`);
+            }
+        }
+        if (options.excludeCollections && options.excludeCollections.length > 0) {
+            for (const col of options.excludeCollections) {
+                args.push(`--excludeCollection=${col}`);
+            }
+        }
+        options.onProgress?.('Starting mongodump...');
+        const proc = (0, child_process_1.spawn)('mongodump', args, {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+            const line = data.toString();
+            stderr += line;
+            // Parse progress from mongodump output
+            if (line.includes('done dumping')) {
+                options.onProgress?.(line.trim());
+            }
+        });
+        proc.on('close', (code) => {
+            if (code === 0 && fs.existsSync(dumpPath)) {
+                const stats = fs.statSync(dumpPath);
+                resolve({
+                    success: true,
+                    dumpPath,
+                    sizeBytes: stats.size,
+                });
+            }
+            else {
+                // Cleanup on failure
+                fs.rmSync(tempDir, { recursive: true, force: true });
+                // Parse common errors
+                let errorMessage = 'mongodump failed';
+                if (stderr.includes('authentication failed')) {
+                    errorMessage = 'Authentication failed - check your database credentials';
+                }
+                else if (stderr.includes('connection refused') || stderr.includes('no reachable servers')) {
+                    errorMessage = 'Connection failed - check if the database URL is correct and accessible';
+                }
+                else if (stderr.includes('timed out')) {
+                    errorMessage = 'Connection timed out - the database may not be accessible from your network';
+                }
+                else if (stderr) {
+                    errorMessage = stderr.split('\n')[0] || errorMessage;
+                }
+                resolve({
+                    success: false,
+                    error: errorMessage,
+                });
+            }
+        });
+        proc.on('error', (err) => {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            resolve({
+                success: false,
+                error: `Failed to run mongodump: ${err.message}`,
+            });
+        });
+    });
+}
+/**
+ * Upload dump file to genbox via SCP
+ */
+async function uploadDumpToGenbox(dumpPath, ipAddress, options = {}) {
+    return new Promise((resolve) => {
+        const remotePath = '/home/dev/.db-dump.gz';
+        options.onProgress?.(`Uploading dump to genbox (${formatBytes(fs.statSync(dumpPath).size)})...`);
+        const proc = (0, child_process_1.spawn)('scp', [
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'ConnectTimeout=30',
+            dumpPath,
+            `dev@${ipAddress}:${remotePath}`,
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                let errorMessage = 'SCP upload failed';
+                if (stderr.includes('Connection refused') || stderr.includes('Connection timed out')) {
+                    errorMessage = 'Cannot connect to genbox - it may still be provisioning';
+                }
+                else if (stderr.includes('Permission denied')) {
+                    errorMessage = 'Permission denied - SSH key may not be configured';
+                }
+                else if (stderr) {
+                    errorMessage = stderr.split('\n')[0] || errorMessage;
+                }
+                resolve({ success: false, error: errorMessage });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: `Failed to run scp: ${err.message}` });
+        });
+    });
+}
+/**
+ * Run mongorestore on genbox via SSH
+ */
+async function runRemoteMongoRestore(ipAddress, dbName, options = {}) {
+    return new Promise((resolve) => {
+        options.onProgress?.('Restoring database on genbox...');
+        // The restore command - uses the uploaded dump file
+        const restoreCmd = `
+      # Wait for MongoDB to be ready
+      for i in {1..30}; do
+        if docker exec goodpass-mongodb mongosh --quiet --eval "db.runCommand({ping:1})" 2>/dev/null; then
+          break
+        fi
+        echo "Waiting for MongoDB... ($i/30)"
+        sleep 2
+      done
+
+      # Restore the database
+      if [ -f /home/dev/.db-dump.gz ]; then
+        echo "Restoring database..."
+        mongorestore --uri="mongodb://localhost:27017" --db="${dbName}" --archive=/home/dev/.db-dump.gz --gzip --drop
+        rm -f /home/dev/.db-dump.gz
+        echo "Database restored successfully"
+      else
+        echo "Error: Dump file not found"
+        exit 1
+      fi
+    `;
+        const proc = (0, child_process_1.spawn)('ssh', [
+            '-o', 'StrictHostKeyChecking=no',
+            '-o', 'UserKnownHostsFile=/dev/null',
+            '-o', 'ConnectTimeout=30',
+            `dev@${ipAddress}`,
+            'bash', '-c', `'${restoreCmd.replace(/'/g, "'\\''")}'`,
+        ], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            const line = data.toString();
+            stdout += line;
+            if (line.includes('Restoring') || line.includes('restored')) {
+                options.onProgress?.(line.trim());
+            }
+        });
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code === 0) {
+                resolve({ success: true });
+            }
+            else {
+                resolve({
+                    success: false,
+                    error: stderr || stdout || 'Restore failed',
+                });
+            }
+        });
+        proc.on('error', (err) => {
+            resolve({ success: false, error: `Failed to run ssh: ${err.message}` });
+        });
+    });
+}
+/**
+ * Clean up temporary dump files
+ */
+function cleanupDump(dumpPath) {
+    try {
+        const dir = path.dirname(dumpPath);
+        if (dir.includes('genbox-dbdump-')) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+        else {
+            fs.rmSync(dumpPath, { force: true });
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Format bytes to human readable
+ */
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+/**
+ * Wait for genbox to be accessible via SSH
+ */
+async function waitForSshAccess(ipAddress, maxWaitSeconds = 300, onProgress) {
+    const startTime = Date.now();
+    const checkInterval = 5000; // 5 seconds
+    while (Date.now() - startTime < maxWaitSeconds * 1000) {
+        try {
+            (0, child_process_1.execSync)(`ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o ConnectTimeout=5 dev@${ipAddress} echo ok`, { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            onProgress?.(`Waiting for genbox to be ready (${elapsed}s)...`);
+            await new Promise((r) => setTimeout(r, checkInterval));
+        }
+    }
+    return false;
+}
+/**
+ * Upload dump file to S3 using pre-signed URL
+ */
+async function uploadDumpToS3(dumpPath, uploadUrl, options = {}) {
+    const fileSize = fs.statSync(dumpPath).size;
+    options.onProgress?.(`Uploading snapshot to cloud (${formatBytes(fileSize)})...`, 0);
+    try {
+        // Read file as buffer
+        const fileBuffer = fs.readFileSync(dumpPath);
+        // Upload to S3 using pre-signed URL
+        const response = await fetch(uploadUrl, {
+            method: 'PUT',
+            headers: {
+                'Content-Type': 'application/gzip',
+                'Content-Length': fileSize.toString(),
+            },
+            body: fileBuffer,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                success: false,
+                error: `Upload failed: ${response.status} ${response.statusText} - ${errorText}`,
+            };
+        }
+        options.onProgress?.('Upload complete', 100);
+        return { success: true };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Upload failed: ${error.message}`,
+        };
+    }
+}
+async function createAndUploadSnapshot(dumpPath, projectId, source, options = {}) {
+    // Import API functions dynamically to avoid circular deps
+    const { initiateSnapshotUpload, completeSnapshotUpload, failSnapshotUpload, } = await Promise.resolve().then(() => __importStar(require('./api')));
+    const fileSize = fs.statSync(dumpPath).size;
+    const snapshotName = options.name || `${source}-${new Date().toISOString().split('T')[0]}`;
+    let snapshotId;
+    try {
+        // Step 1: Initiate upload to get pre-signed URL
+        options.onProgress?.('Preparing snapshot upload...');
+        const initResult = await initiateSnapshotUpload({
+            name: snapshotName,
+            projectId,
+            source,
+            sizeBytes: fileSize,
+            contentType: 'application/gzip',
+        });
+        snapshotId = initResult.snapshotId;
+        // Step 2: Upload to S3
+        const uploadResult = await uploadDumpToS3(dumpPath, initResult.uploadUrl, {
+            onProgress: options.onProgress,
+        });
+        if (!uploadResult.success) {
+            // Mark as failed
+            await failSnapshotUpload(snapshotId, uploadResult.error || 'Upload failed');
+            return { success: false, error: uploadResult.error };
+        }
+        // Step 3: Complete the upload
+        options.onProgress?.('Finalizing snapshot...');
+        await completeSnapshotUpload(snapshotId, {
+            sizeBytes: fileSize,
+            compressedSizeBytes: fileSize, // Already gzipped
+            sourceUrl: options.sourceUrl,
+        });
+        return {
+            success: true,
+            snapshotId,
+            s3Key: initResult.s3Key,
+        };
+    }
+    catch (error) {
+        // Try to mark as failed if we have a snapshot ID
+        if (snapshotId) {
+            try {
+                await failSnapshotUpload(snapshotId, error.message);
+            }
+            catch {
+                // Ignore cleanup error
+            }
+        }
+        return {
+            success: false,
+            error: error.message,
+        };
+    }
+}

package/dist/index.js

@@ -8,7 +8,7 @@ const program = new commander_1.Command();
 const { version } = require('../package.json');
 program
     .name('genbox')
-    .description('Genbox CLI - AI-Powered Development Environments')
+    .description('Genbox CLI - AI-Powered Development Environments\n\nTIP: Use "gb" as a shorthand (e.g., gb list, gb create)')
     .version(version, '-v, --version', 'Output the current version');
 const create_1 = require("./commands/create");
 const list_1 = require("./commands/list");

package/dist/profile-resolver.js

@@ -60,7 +60,6 @@ class ProfileResolver {
      */
     async resolve(config, options) {
         const warnings = [];
-        const isV4Config = (0, config_loader_1.isV4)(config);
         // Step 1: Get base profile (if specified)
         let profile = {};
         if (options.profile) {
@@ -193,12 +192,13 @@ class ProfileResolver {
         const dependencies = {};
         const infrastructure = (0, config_loader_1.getInfrastructure)(config);
         // Process each dependency (v3: requires, v4: connects_to)
-        const appDeps = (0, config_loader_1.isV4)(config)
+        const appDeps = true
             ? Object.entries(appConfig.connects_to || {})
-            : Object.entries(appConfig.requires || {});
+            : Object.entries(appConfig.connects_to || {});
         for (const [depName, requirement] of appDeps) {
-            // v3 uses 'none', v4 uses { required: false }
-            if (requirement === 'none' || (typeof requirement === 'object' && !requirement.required))
+            // Skip if not required
+            const reqObj = requirement;
+            if (!reqObj.required)
                 continue;
             // Check if dependency is already in selected apps
             const isLocalApp = selectedApps.includes(depName);
@@ -218,12 +218,12 @@ class ProfileResolver {
                     url,
                 };
             }
-            else if ((requirement === 'required' || (typeof requirement === 'object' && requirement.required)) && !options.yes) {
+            else if (reqObj.required && !options.yes) {
                 // Prompt user for resolution
                 const resolution = await this.promptDependencyResolution(config, appName, depName, isInfra ? 'infrastructure' : 'app');
                 dependencies[depName] = resolution;
             }
-            else if (requirement === 'optional' || (typeof requirement === 'object' && !requirement.required)) {
+            else if (!reqObj.required) {
                 // Skip optional dependencies if not explicitly included
                 continue;
             }
@@ -250,13 +250,13 @@ class ProfileResolver {
             type,
             framework,
             port,
-            services: appConfig.services,
             commands: appConfig.commands,
             env: appConfig.env,
             runner,
             docker,
             healthcheck,
             dependsOn,
+            connections: [], // Will be populated later if needed
             dependencies,
         };
     }
@@ -314,26 +314,25 @@ class ProfileResolver {
      * Get URL for a dependency from environment config
      */
     getUrlForDependency(depName, envConfig) {
-        // Check if it's an API dependency
-        if (depName === 'api' && envConfig.api) {
-            // Check common fields: url, gateway, api, or first string value
-            const apiConfig = envConfig.api;
-            return apiConfig.url || apiConfig.gateway || apiConfig.api ||
-                Object.values(apiConfig).find(v => typeof v === 'string' && v.startsWith('http'));
-        }
-        // Check infrastructure
-        const infraConfig = envConfig[depName];
-        return infraConfig?.url;
+        // Check the urls map in the environment config
+        return envConfig.urls?.[depName];
     }
     /**
      * Resolve database mode
      */
     async resolveDatabaseMode(config, options, profile) {
+        // Helper to get MongoDB URL for an environment
+        const getMongoUrl = (source) => {
+            const envConfig = config.environments?.[source];
+            return envConfig?.urls?.mongodb;
+        };
         // CLI flag takes precedence
         if (options.db) {
+            const source = options.dbSource || profile.database?.source || 'staging';
             return {
                 mode: options.db,
-                source: options.dbSource || profile.database?.source || 'staging',
+                source,
+                url: options.db === 'copy' ? getMongoUrl(source) : undefined,
             };
         }
         // Profile setting
@@ -341,16 +340,16 @@ class ProfileResolver {
             return {
                 mode: profile.database.mode,
                 source: profile.database.source,
+                url: profile.database.mode === 'copy' && profile.database.source
+                    ? getMongoUrl(profile.database.source)
+                    : undefined,
             };
         }
-        // If connect_to (v3) or default_connection (v4) is set, use remote
+        // If default_connection is set, use remote
         const profileConnection = (0, config_loader_1.getProfileConnection)(profile);
         if (profileConnection) {
             const envConfig = config.environments?.[profileConnection];
-            // v4 uses urls.mongodb, v3 uses mongodb.url
-            const mongoUrl = (0, config_loader_1.isV4)(config)
-                ? envConfig?.urls?.mongodb
-                : envConfig?.mongodb?.url;
+            const mongoUrl = envConfig?.urls?.mongodb;
             return {
                 mode: 'remote',
                 source: profileConnection,
@@ -362,9 +361,12 @@ class ProfileResolver {
             return await this.selectDatabaseModeInteractive(config);
         }
         // Default
+        const defaultMode = config.defaults?.database?.mode || 'local';
+        const defaultSource = config.defaults?.database?.source;
         return {
-            mode: config.defaults?.database?.mode || 'local',
-            source: config.defaults?.database?.source,
+            mode: defaultMode,
+            source: defaultSource,
+            url: defaultMode === 'copy' && defaultSource ? getMongoUrl(defaultSource) : undefined,
         };
     }
     /**
@@ -403,15 +405,14 @@ class ProfileResolver {
         }
         else if (answer.startsWith('copy-')) {
             const source = answer.replace('copy-', '');
-            return { mode: 'copy', source };
+            const envConfig = config.environments?.[source];
+            const mongoUrl = envConfig?.urls?.mongodb;
+            return { mode: 'copy', source, url: mongoUrl };
         }
         else if (answer.startsWith('remote-')) {
             const source = answer.replace('remote-', '');
             const envConfig = config.environments?.[source];
-            // v4 uses urls.mongodb, v3 uses mongodb.url
-            const mongoUrl = (0, config_loader_1.isV4)(config)
-                ? envConfig?.urls?.mongodb
-                : envConfig?.mongodb?.url;
+            const mongoUrl = envConfig?.urls?.mongodb;
             return {
                 mode: 'remote',
                 source,
@@ -427,9 +428,9 @@ class ProfileResolver {
         const localApps = apps.length;
         const localInfra = infrastructure.filter(i => i.mode === 'local').length;
         const total = localApps + localInfra;
-        // Check for heavy services
-        const hasHeavyService = apps.some(a => a.services && Object.keys(a.services).length > 3);
-        if (total > 8 || hasHeavyService)
+        // Check for heavy apps (many dependencies)
+        const hasHeavyApp = apps.some(a => Object.keys(a.dependencies).length > 3);
+        if (total > 8 || hasHeavyApp)
             return 'xl';
         if (total > 5)
             return 'large';

package/dist/schema-v4.js

@@ -2,53 +2,53 @@
 /**
  * Genbox Configuration Schema v4
  *
- * Key changes from v3:
- * - Explicit `connects_to` replacing implicit dependency resolution
- * - `provides` section for infrastructure definitions
- * - `$detect` markers for opt-in auto-detection
- * - Strict mode by default (no implicit inference)
- * - Better separation of concerns
+ * This is the ONLY supported schema version.
+ * All legacy v2/v3 support has been removed.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEPRECATED_V3_FIELDS = void 0;
-exports.isV4Config = isV4Config;
+exports.DETECTABLE_APP_FIELDS = exports.DETECT_MARKER = void 0;
+exports.isDetectMarker = isDetectMarker;
+exports.isValidConfig = isValidConfig;
 exports.getConfigVersion = getConfigVersion;
 // ============================================
-// Migration Helpers
+// $detect Marker Support
 // ============================================
 /**
- * Check if a config is v4
+ * Special marker indicating a value should be auto-detected.
  */
-function isV4Config(config) {
+exports.DETECT_MARKER = '$detect';
+/**
+ * List of fields that support $detect markers in AppConfig
+ */
+exports.DETECTABLE_APP_FIELDS = [
+    'type',
+    'framework',
+    'port',
+    'commands.install',
+    'commands.dev',
+    'commands.build',
+    'commands.start',
+];
+/**
+ * Check if a value is a $detect marker
+ */
+function isDetectMarker(value) {
+    return value === exports.DETECT_MARKER;
+}
+// ============================================
+// Helper Functions
+// ============================================
+/**
+ * Check if a config is valid v4
+ */
+function isValidConfig(config) {
     return config.version === 4;
 }
 /**
- * Get the version of a config
+ * Get the version of a config (only v4 is valid now)
  */
 function getConfigVersion(config) {
     if (config.version === 4)
         return 4;
-    if (config.version === 3 || config.version === '3.0')
-        return 3;
-    return 'unknown';
+    return 'invalid';
 }
-/**
- * List of deprecated fields from v3
- */
-exports.DEPRECATED_V3_FIELDS = [
-    {
-        path: 'apps.*.requires',
-        replacement: 'apps.*.connects_to',
-        message: 'Use connects_to with explicit connection modes',
-    },
-    {
-        path: 'infrastructure',
-        replacement: 'provides',
-        message: 'Renamed to provides for clarity',
-    },
-    {
-        path: 'profiles.*.connect_to',
-        replacement: 'profiles.*.default_connection',
-        message: 'Use default_connection or per-app connections override',
-    },
-];