@aws/ml-container-creator 0.10.0 → 0.10.3

package/src/lib/bootstrap-config.js

@@ -29,6 +29,8 @@
  * Optional CI fields (added by bootstrap --ci):
  *   - ciInfraProvisioned (boolean): Whether CI harness infrastructure has been deployed. Defaults to false.
  *   - ciTableName (string): Name of the DynamoDB CI table. Defaults to "mlcc-ci-table".
+ *   - ciGlueDatabase (string|null): Name of the Glue database for benchmark results. Defaults to null (benchmark infra not provisioned).
+ *   - ciBenchmarkResultsBucket (string|null): Name of the S3 bucket for benchmark Parquet files. Defaults to null (benchmark infra not provisioned).
  */
 
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
@@ -134,6 +136,8 @@ export default class BootstrapConfig {
         return {
             ciInfraProvisioned: false,
             ciTableName: 'mlcc-ci-table',
+            ciGlueDatabase: null,
+            ciBenchmarkResultsBucket: null,
             ...profile
         };
     }
@@ -156,11 +160,43 @@ export default class BootstrapConfig {
             config: {
                 ciInfraProvisioned: false,
                 ciTableName: 'mlcc-ci-table',
+                ciGlueDatabase: null,
+                ciBenchmarkResultsBucket: null,
                 ...active.config
             }
         };
     }
 
+    /**
+     * Find the profile that has CI infrastructure provisioned.
+     * Scans all profiles and returns the first one with ciInfraProvisioned: true.
+     *
+     * @returns {{ name: string, config: Object }|null} The CI profile, or null if none found
+     */
+    findCiProfile() {
+        const config = this.read();
+        if (!config || !config.profiles) return null;
+
+        for (const [name, profileConfig] of Object.entries(config.profiles)) {
+            if (profileConfig.ciInfraProvisioned) {
+                return { name, config: profileConfig };
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Get the sharedInfraFrom field, handling legacy sharedStackFrom.
+     * Returns the source stack name if infrastructure was shared from another profile,
+     * or null if this profile has standalone infrastructure.
+     *
+     * @param {Object} profileConfig - A profile configuration object
+     * @returns {string|null} The source stack name or null
+     */
+    getSharedInfraSource(profileConfig) {
+        return profileConfig.sharedInfraFrom || profileConfig.sharedStackFrom || null;
+    }
+
     /**
      * Create or update a profile in the config.
      * Sets the given profile as the active profile and writes the config.

package/src/lib/bootstrap-profile-manager.js

@@ -313,7 +313,12 @@ export default class BootstrapProfileManager {
     }
 
     /**
-     * Remove a bootstrap profile.
+     * Remove a bootstrap profile (metadata-only).
+     *
+     * Only removes the profile entry from config.json and the local manifest file.
+     * AWS resources (CloudFormation stack, S3 buckets, ECR repo, IAM roles) are
+     * intentionally retained — they may be shared across profiles or still in use.
+     *
      * @param {string} profileName - Profile name to remove
      * @param {object} options - Parsed CLI options (e.g., --force)
      */
@@ -340,23 +345,6 @@ export default class BootstrapProfileManager {
             }
         }
 
-        // Check for CloudFormation stack
-        const stackName = profile.stackName || `${STACK_NAME_PREFIX}-${profileName}`;
-        let hasStack = false;
-        try {
-            hasStack = this.handler._resourceExists(
-                `cloudformation describe-stacks --stack-name ${stackName} --region ${profile.awsRegion}`,
-                profile.awsProfile
-            );
-        } catch {
-            // ignore
-        }
-
-        if (hasStack && !options.force) {
-            console.log(`⚠️  Profile "${profileName}" has a CloudFormation stack: ${stackName}`);
-            console.log('   Use --delete-stack to also delete the AWS resources, or --force to remove the profile only.');
-        }
-
         if (!options.force) {
             const { confirm } = await this.handler._promptFn([{
                 type: 'confirm',
@@ -371,29 +359,6 @@ export default class BootstrapProfileManager {
             }
         }
 
-        // Delete CloudFormation stack if requested
-        if (hasStack && options['delete-stack']) {
-            try {
-                console.log(`🗑️  Deleting CloudFormation stack: ${stackName}`);
-                execSync(
-                    `aws cloudformation delete-stack --stack-name ${stackName} --region ${profile.awsRegion} --profile ${profile.awsProfile}`,
-                    { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-                );
-                console.log('⏳ Waiting for stack deletion...');
-                execSync(
-                    `aws cloudformation wait stack-delete-complete --stack-name ${stackName} --region ${profile.awsRegion} --profile ${profile.awsProfile}`,
-                    { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-                );
-                console.log(`✅ Stack "${stackName}" deleted.`);
-            } catch (err) {
-                console.log(`⚠️  Could not delete stack "${stackName}": ${err.message}`);
-                console.log('   You may need to delete it manually from the CloudFormation console.');
-            }
-        } else if (hasStack) {
-            console.log(`Note: CloudFormation stack "${stackName}" was left in place.`);
-            console.log('   To delete AWS resources, re-run with --delete-stack');
-        }
-
         // Delete manifest file if it exists
         if (hasManifest) {
             try {
@@ -406,6 +371,12 @@ export default class BootstrapProfileManager {
 
         this.handler.config.removeProfile(profileName);
         console.log(`Profile "${profileName}" removed.`);
+
+        // Advisory: AWS resources are retained for safety
+        const stackName = profile.stackName || `${STACK_NAME_PREFIX}-${profileName}`;
+        console.log('');
+        console.log('ℹ️  Profile removed from config. AWS resources (CloudFormation stack, S3 buckets, ECR repo, IAM roles) have been retained.');
+        console.log(`   To delete AWS resources, manually delete the CloudFormation stack "${stackName}" in the AWS console.`);
     }
 
     /**
@@ -631,4 +602,40 @@ export default class BootstrapProfileManager {
 
         console.log(`  Manifest written: lastSynced = ${result.manifest.lastSynced}\n`);
     }
+
+    /**
+     * Handle sync-model-families subcommand: discover tune-eligible models from
+     * the SageMaker JumpStart Hub and update the tune catalog.
+     *
+     * Requires AWS credentials with sagemaker:ListHubContents and
+     * sagemaker:DescribeHubContent permissions.
+     */
+    async _handleSyncModelFamilies() {
+        console.log('\n📦 Sync Model Families — Discovering supported models...\n');
+
+        // Determine region from active profile or environment
+        const profile = this.handler.config.getActiveProfile();
+        const region = profile?.config?.awsRegion || process.env.AWS_REGION || 'us-west-2';
+
+        try {
+            const { syncModelFamilies } = await import('../../scripts/sync-model-families.js');
+            const result = await syncModelFamilies({ region });
+            console.log(`\n✅ Sync complete: ${result.added} new, ${result.total} total models`);
+        } catch (err) {
+            if (err.name === 'CredentialsProviderError' || err.message?.includes('credentials') || err.message?.includes('Could not load credentials')) {
+                console.log('❌ AWS credentials not available or insufficient permissions.');
+                console.log('');
+                console.log('   Required permissions:');
+                console.log('     • sagemaker:ListHubContents');
+                console.log('     • sagemaker:DescribeHubContent');
+                console.log('');
+                console.log('   Ensure your AWS credentials are configured:');
+                console.log('     aws configure');
+                console.log('     # or set AWS_PROFILE to a profile with SageMaker AI access');
+            } else {
+                console.log(`❌ Sync failed: ${err.message}`);
+            }
+            process.exit(1);
+        }
+    }
 }

package/src/lib/ci-register-helpers.js

@@ -104,6 +104,15 @@ export function applyRecordDefaults(record) {
     if (!record.projectName) {
         record.projectName = '';
     }
+    // Benchmark fields — optional, backward-compatible defaults (Requirement 7.1, 7.4)
+    if (record.benchmarkEnabled === undefined || record.benchmarkEnabled === null) {
+        record.benchmarkEnabled = false;
+    }
+    if (!record.benchmarkConcurrencyLevels) {
+        record.benchmarkConcurrencyLevels = [1, 4, 8];
+    }
+    // lastBenchmarkRunId, lastBenchmarkTimestamp, lastBenchmarkStatus are intentionally
+    // NOT defaulted — their absence indicates "never benchmarked" (Requirement 7.4)
     return record;
 }
 
@@ -122,3 +131,68 @@ export function extractBaseImageVersion(baseImage) {
     }
     return baseImage.split(':').pop();
 }
+
+/**
+ * Build the benchmark fields to update on a DynamoDB CI record after
+ * a benchmark stage completes (or fails).
+ *
+ * Only returns the benchmark-specific fields — caller merges into the
+ * existing record. Existing fields (testStatus, configJson, etc.) are
+ * intentionally NOT included to satisfy Requirement 7.3.
+ *
+ * @param {string} runId - Benchmark run identifier (e.g., "bmk-20260609T143022Z")
+ * @param {string} status - One of: "completed", "failed", "in-progress"
+ * @param {string} [timestamp] - ISO 8601 timestamp; defaults to current time
+ * @returns {object} Object with lastBenchmarkRunId, lastBenchmarkTimestamp, lastBenchmarkStatus
+ */
+export function buildBenchmarkFields(runId, status, timestamp) {
+    const validStatuses = ['completed', 'failed', 'in-progress'];
+    if (!validStatuses.includes(status)) {
+        throw new Error(`Invalid benchmark status: '${status}'. Must be one of: ${validStatuses.join(', ')}`);
+    }
+    if (!runId || typeof runId !== 'string') {
+        throw new Error('Benchmark runId is required and must be a non-empty string');
+    }
+    return {
+        lastBenchmarkRunId: runId,
+        lastBenchmarkTimestamp: timestamp || new Date().toISOString().replace(/\.\d{3}Z$/, 'Z'),
+        lastBenchmarkStatus: status
+    };
+}
+
+/**
+ * Check whether a CI record has ever been benchmarked.
+ *
+ * Per Requirement 7.4, absence of `lastBenchmarkRunId` indicates
+ * "never benchmarked" — this is the canonical check.
+ *
+ * @param {object} record - A CI DynamoDB record
+ * @returns {boolean} True if the record has benchmark data
+ */
+export function hasBeenBenchmarked(record) {
+    return !!(record && record.lastBenchmarkRunId);
+}
+
+/**
+ * Check whether benchmarking is enabled for a CI record/config.
+ *
+ * @param {object} record - A CI DynamoDB record (with defaults applied)
+ * @returns {boolean} True if benchmarkEnabled is true
+ */
+export function isBenchmarkEnabled(record) {
+    if (!record) return false;
+    return record.benchmarkEnabled === true;
+}
+
+/**
+ * Get the benchmark concurrency levels for a CI record/config.
+ *
+ * @param {object} record - A CI DynamoDB record (with defaults applied)
+ * @returns {number[]} Array of concurrency level integers
+ */
+export function getBenchmarkConcurrencyLevels(record) {
+    if (!record || !Array.isArray(record.benchmarkConcurrencyLevels)) {
+        return [1, 4, 8];
+    }
+    return record.benchmarkConcurrencyLevels;
+}

package/src/lib/config-loader.js

@@ -41,6 +41,9 @@ export default class ConfigLoader {
             if (profileConfig.awsProfile) {
                 mapped.awsProfile = profileConfig.awsProfile;
             }
+            if (profileConfig.ciBenchmarkResultsBucket) {
+                mapped.ciBenchmarkResultsBucket = profileConfig.ciBenchmarkResultsBucket;
+            }
 
             this.manager._mergeConfig(mapped);
         } catch (error) {

package/src/lib/config-manager.js

@@ -300,6 +300,13 @@ export default class ConfigManager {
             (!finalConfig.destinationDir || finalConfig.destinationDir === '.')) {
             finalConfig.destinationDir = `./${finalConfig.projectName}`;
         }
+
+        // Ensure destinationDir is never null — derive from projectName if not set.
+        // This covers interactive mode where destinationDir is non-promptable and no
+        // CLI positional argument was provided.
+        if (!finalConfig.destinationDir) {
+            finalConfig.destinationDir = `./${finalConfig.projectName}`;
+        }
         
         // Generate CodeBuild project name if buildTarget is codebuild
         if ((finalConfig.buildTarget === 'codebuild' || finalConfig.deployTarget === 'codebuild') && !finalConfig.codebuildProjectName) {

package/src/lib/cuda-resolver.js

@@ -96,22 +96,31 @@ export default class CudaResolver {
             return inferenceAmiVersion ? { cudaVersion, inferenceAmiVersion } : null;
         }
 
-        // Multiple options — let the user choose (or auto-select in auto-prompt mode)
+        // Multiple options — determine the best default
         const defaultVersion = frameworkAccel?.version
             && compatibleVersions.includes(frameworkAccel.version)
             ? frameworkAccel.version
             : instanceInfo.accelerator.default || compatibleVersions[compatibleVersions.length - 1];
 
-        // In auto-prompt mode, auto-select the default without prompting
-        if (this.runner.configManager?.isAutoPrompt()) {
+        // Auto-select when we have a reliable default — no need to prompt the user about
+        // AMI internals they shouldn't need to care about. The default is derived from:
+        //   1. Framework's declared CUDA version (highest confidence)
+        //   2. Instance catalog's defaultCudaVersion (hardware-appropriate)
+        //   3. Highest compatible version (safe fallback)
+        // Only prompt if none of these sources provide a default (shouldn't happen in practice).
+        if (defaultVersion && CUDA_AMI_MAP[defaultVersion]) {
             const inferenceAmiVersion = CUDA_AMI_MAP[defaultVersion];
-            if (inferenceAmiVersion) {
-                console.log(`\n🔧 CUDA ${defaultVersion} auto-selected (auto-prompt mode)`);
-                console.log(`   AMI: ${inferenceAmiVersion}`);
-            }
-            return inferenceAmiVersion ? { cudaVersion: defaultVersion, inferenceAmiVersion } : null;
+            const source = frameworkAccel?.version && compatibleVersions.includes(frameworkAccel.version)
+                ? 'framework requirement'
+                : instanceInfo.accelerator.default === defaultVersion
+                    ? 'instance default'
+                    : 'highest compatible';
+            console.log(`\n🔧 CUDA ${defaultVersion} auto-selected (${source})`);
+            console.log(`   AMI: ${inferenceAmiVersion}`);
+            return { cudaVersion: defaultVersion, inferenceAmiVersion };
         }
 
+        // Fallback: prompt only when no reliable default exists (edge case)
         const choices = compatibleVersions.map(v => {
             const ami = CUDA_AMI_MAP[v] || 'unknown';
             const isDefault = v === defaultVersion ? ' (recommended)' : '';