@aws/ml-container-creator 0.2.6 → 0.3.0

package/src/lib/bootstrap-command-handler.js

@@ -24,6 +24,8 @@ import { fileURLToPath } from 'node:url';
 import BootstrapConfig from './bootstrap-config.js';
 import AwsProfileParser from './aws-profile-parser.js';
 import AssetManager from './asset-manager.js';
+import McpCommandHandler from './mcp-command-handler.js';
+import RegistryCommandHandler from './registry-command-handler.js';
 import { runPrompts } from '../prompt-adapter.js';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -311,6 +313,9 @@ export default class BootstrapCommandHandler {
 
         // Display summary
         this._displaySummary(profileName, profileData);
+
+        // Step 6: Post-setup chain (mcp init → sync-architectures → sync-schemas)
+        await this._runPostSetupChain(options);
     }
 
     /**
@@ -1054,6 +1059,74 @@ export default class BootstrapCommandHandler {
         // Save updated profile
         this.config.setProfile(name, profileConfig);
         console.log(`\n✅ Update complete for profile "${name}"`);
+
+        // Re-run post-setup chain after updating AWS resources
+        await this._runPostSetupChain(options);
+    }
+
+    /**
+     * Run the post-setup chain: mcp init → registry sync-architectures → sync-schemas.
+     * Each step is independent — failures are collected and reported at the end.
+     *
+     * @param {object} options - Parsed CLI options (checks skipPostSetup)
+     */
+    async _runPostSetupChain(options = {}) {
+        if (options['skip-post-setup']) {
+            console.log('\n⏭️  Skipping post-setup chain (--skip-post-setup)');
+            return;
+        }
+
+        console.log('\n🔗 Running post-setup configuration...\n');
+
+        const failures = [];
+
+        // 1. MCP init — register bundled MCP servers
+        console.log('📡 Registering MCP servers...');
+        try {
+            const generatorAdapter = {
+                destinationPath(...segments) {
+                    return path.resolve(process.cwd(), ...segments);
+                }
+            };
+            const mcpHandler = new McpCommandHandler(generatorAdapter);
+            await mcpHandler.handle(['init'], {});
+        } catch (error) {
+            failures.push({ step: 'mcp init', error: error.message });
+            console.log(`  ⚠️  mcp init failed: ${error.message}`);
+        }
+
+        // 2. Registry sync-architectures — populate supportedModelTypes
+        console.log('\n📋 Syncing model architecture registry...');
+        try {
+            const registryHandler = new RegistryCommandHandler();
+            await registryHandler.handle(['sync-architectures'], {});
+        } catch (error) {
+            failures.push({ step: 'registry sync-architectures', error: error.message });
+            console.log(`  ⚠️  registry sync-architectures failed: ${error.message}`);
+        }
+
+        // 3. Schema sync — download AWS service models
+        console.log('\n📐 Syncing service schemas...');
+        try {
+            await this._handleSyncSchemas();
+        } catch (error) {
+            failures.push({ step: 'sync-schemas', error: error.message });
+            console.log(`  ⚠️  sync-schemas failed: ${error.message}`);
+        }
+
+        // Report results
+        if (failures.length === 0) {
+            console.log('\n✅ Bootstrap complete — all systems operational');
+        } else {
+            console.log(`\n⚠️  Bootstrap complete with ${failures.length} warning${failures.length === 1 ? '' : 's'}:`);
+            for (const { step, error } of failures) {
+                console.log(`  • ${step}: ${error}`);
+            }
+            console.log('\n  These steps can be re-run individually:');
+            console.log('    ml-container-creator mcp init');
+            console.log('    ml-container-creator registry sync-architectures');
+            console.log('    ml-container-creator bootstrap sync-schemas');
+        }
     }
 
     /**
@@ -1242,12 +1315,20 @@ export default class BootstrapCommandHandler {
                     Effect: 'Allow',
                     Action: [
                         's3:GetObject',
+                        's3:PutObject',
+                        's3:AbortMultipartUpload',
                         's3:ListBucket'
                     ],
                     Resource: [
                         'arn:aws:s3:::ml-container-creator-*',
                         'arn:aws:s3:::ml-container-creator-*/*'
                     ]
+                },
+                {
+                    Sid: 'SNSPublish',
+                    Effect: 'Allow',
+                    Action: 'sns:Publish',
+                    Resource: 'arn:aws:sns:*:*:ml-container-creator-*'
                 }
             ]
         };
@@ -1649,6 +1730,7 @@ SETUP OPTIONS:
   --skip-s3                           Skip S3 bucket creation
   --ci                                Provision CI testing infrastructure
   --skip-ci                           Skip CI infrastructure provisioning
+  --skip-post-setup                   Skip post-setup chain (mcp init, sync-architectures, sync-schemas)
 
 STATUS OPTIONS:
   --verify                            Check each active resource against AWS APIs for drift detection

package/src/lib/config-manager.js

@@ -300,6 +300,15 @@ export default class ConfigManager {
             finalConfig.hfToken = this._resolveHfToken(finalConfig.hfToken);
         }
 
+        // Mutual exclusion: ARN takes precedence over plaintext when both are set
+        // (CLI validation should prevent this, but enforce at config level too)
+        if (finalConfig.hfTokenArn) {
+            finalConfig.hfToken = null;
+        }
+        if (finalConfig.ngcTokenArn) {
+            finalConfig.ngcApiKey = null;
+        }
+
         // Map awsRoleArn to roleArn for templates
         if (finalConfig.awsRoleArn) {
             finalConfig.roleArn = finalConfig.awsRoleArn;
@@ -643,6 +652,28 @@ export default class ConfigManager {
                 default: null,
                 valueSpace: 'bounded'
             },
+            hfTokenArn: {
+                cliOption: 'hf-token-arn',
+                envVar: null,
+                configFile: true,
+                packageJson: false,
+                mcp: false,
+                promptable: false,
+                required: false,
+                default: null,
+                valueSpace: 'bounded'
+            },
+            ngcTokenArn: {
+                cliOption: 'ngc-token-arn',
+                envVar: null,
+                configFile: true,
+                packageJson: false,
+                mcp: false,
+                promptable: false,
+                required: false,
+                default: null,
+                valueSpace: 'bounded'
+            },
             deploymentTarget: {
                 cliOption: 'deployment-target',
                 envVar: 'ML_DEPLOYMENT_TARGET',
@@ -1675,6 +1706,18 @@ export default class ConfigManager {
             }
         }
 
+        // Validate mutual exclusion: plaintext token and ARN cannot both be set
+        if (this.config.hfToken && this.config.hfTokenArn) {
+            errors.push('Cannot specify both --hf-token and --hf-token-arn. Use one or the other.');
+        }
+        if (this.config.ngcTokenArn) {
+            // Check ngcToken from CLI options (Commander converts --ngc-token to ngcToken)
+            const ngcTokenFromCli = this.options['ngc-token'];
+            if (ngcTokenFromCli) {
+                errors.push('Cannot specify both --ngc-token and --ngc-token-arn. Use one or the other.');
+            }
+        }
+
         // Validate AWS Role ARN format if provided
         if (this.config.awsRoleArn) {
             try {

package/src/lib/cross-cutting-checker.js

@@ -22,6 +22,7 @@ export default class CrossCuttingChecker {
         findings.push(...this.checkRoleArnFormat(context));
         findings.push(...this.checkCudaCompatibility(context, instanceCatalog));
         findings.push(...this.checkModelTypeInstanceAlignment(context, instanceCatalog));
+        findings.push(...this.checkKvCacheMemoryFit(context, instanceCatalog));
 
         return findings;
     }
@@ -298,6 +299,45 @@ export default class CrossCuttingChecker {
         return findings;
     }
 
+    /**
+     * Verify model architecture compatibility with the selected server version.
+     * Checks model_type against the server's supportedModelTypes from the catalog.
+     * Skips silently when supportedModelTypes is empty (sync not run).
+     *
+     * @param {Object} context - ValidationContext
+     * @param {Object} modelServersCatalog - Model servers catalog (from servers/lib/catalogs/model-servers.json)
+     * @returns {Array} Findings
+     */
+    checkModelArchitectureCompatibility(context, modelServersCatalog) {
+        const findings = [];
+        const config = context.config || {};
+
+        const modelType = config.modelType;
+        const serverVersion = config.baseImageVersion;
+        const server = config.modelServer;
+
+        if (!modelType || !server || !serverVersion) return findings;
+
+        const entries = modelServersCatalog[server] || [];
+        const entry = entries.find(e => e.labels?.framework_version === serverVersion);
+        if (!entry?.supportedModelTypes?.length) return findings;
+
+        if (!entry.supportedModelTypes.includes(modelType.toLowerCase())) {
+            findings.push({
+                service: 'cross-cutting',
+                operation: 'configuration',
+                fieldPath: 'MODEL_NAME',
+                invalidValue: modelType,
+                constraint: { type: 'architecture-compatibility', server, version: serverVersion },
+                severity: 'warning',
+                confidence: 'medium',
+                source: 'cross-cutting',
+                remediationHint: `Model architecture "${modelType}" may not be supported by ${server} ${serverVersion}. Consider a newer server version.`
+            });
+        }
+        return findings;
+    }
+
     /**
      * Verify predictor models are not assigned GPU instances.
      * @param {Object} context - ValidationContext
@@ -338,4 +378,83 @@ export default class CrossCuttingChecker {
 
         return findings;
     }
+
+    /**
+     * Verify that the model's estimated VRAM (weights + KV cache at configured max_model_len)
+     * fits in the instance's available GPU memory.
+     *
+     * Uses the same estimation formula as the instance-sizer's vram-estimator:
+     * total = weights + KV cache + 10% overhead
+     *
+     * @param {Object} context - ValidationContext
+     * @param {Object} instanceCatalog - Instance catalog
+     * @returns {Array} Findings
+     */
+    checkKvCacheMemoryFit(context, instanceCatalog) {
+        const findings = [];
+        const config = context.config || {};
+        const catalog = instanceCatalog?.catalog || instanceCatalog || {};
+
+        const instanceType = config.INSTANCE_TYPE;
+        if (!instanceType) return findings;
+
+        const instanceInfo = catalog[instanceType];
+        if (!instanceInfo || !instanceInfo.gpus || instanceInfo.gpus <= 0) return findings;
+
+        // Need parameter count to estimate weights
+        const parameterCount = config._parameterCount || config.parameterCount;
+        if (!parameterCount) return findings;
+
+        // Resolve max sequence length: explicit env var > model's max_position_embeddings > skip
+        const maxModelLen = parseInt(config.VLLM_MAX_MODEL_LEN || config.SGLANG_MAX_MODEL_LEN || '0', 10);
+        const maxPosEmbed = parseInt(config._maxPositionEmbeddings || '0', 10);
+        const seqLen = maxModelLen || maxPosEmbed;
+        if (!seqLen) return findings;
+
+        // Estimate per-GPU VRAM from instance catalog
+        let perGpuVramGb = instanceInfo.gpuMemoryGb;
+        if (!perGpuVramGb && instanceInfo.accelerator) {
+            const match = instanceInfo.accelerator.match(/(\d+)GB/);
+            if (match) {
+                const totalGb = parseInt(match[1], 10);
+                const hasMultiplier = instanceInfo.accelerator.match(/^(\d+)x\s/);
+                perGpuVramGb = hasMultiplier ? totalGb / instanceInfo.gpus : totalGb;
+            }
+        }
+        if (!perGpuVramGb) return findings;
+
+        const totalVramGb = perGpuVramGb * instanceInfo.gpus;
+
+        // Estimate VRAM needed (same formula as vram-estimator.js)
+        const dtype = config._dtype || 'float16';
+        const bytesPerParam = dtype === 'float32' ? 4.0 : dtype === 'int8' ? 1.0 : 2.0;
+        const weightsGb = (parameterCount * bytesPerParam) / (1024 ** 3);
+        const kvCacheGb = (parameterCount * (seqLen / 4096) * 0.05) / (1024 ** 3);
+        const overheadGb = weightsGb * 0.1;
+        const estimatedTotalGb = weightsGb + kvCacheGb + overheadGb;
+
+        if (estimatedTotalGb > totalVramGb) {
+            findings.push({
+                service: 'cross-cutting',
+                operation: 'configuration',
+                fieldPath: 'INSTANCE_TYPE',
+                invalidValue: instanceType,
+                constraint: {
+                    type: 'kv-cache-memory-fit',
+                    estimatedVramGb: Math.round(estimatedTotalGb * 10) / 10,
+                    weightsGb: Math.round(weightsGb * 10) / 10,
+                    kvCacheGb: Math.round(kvCacheGb * 10) / 10,
+                    totalVramGb,
+                    maxModelLen: seqLen,
+                    instanceType
+                },
+                severity: 'warning',
+                confidence: 'medium',
+                source: 'cross-cutting',
+                remediationHint: `Estimated VRAM needed: ${estimatedTotalGb.toFixed(1)}GB (weights: ${weightsGb.toFixed(1)}GB + KV cache: ${kvCacheGb.toFixed(1)}GB at seq_len=${seqLen}) exceeds instance capacity (${totalVramGb}GB). Reduce VLLM_MAX_MODEL_LEN, use quantization, or select a larger instance.`
+            });
+        }
+
+        return findings;
+    }
 }

package/src/lib/deployment-entry-schema.js

@@ -65,8 +65,7 @@ export default {
             required: ['modelName'],
             properties: {
                 modelName: {
-                    type: 'string',
-                    minLength: 1
+                    type: ['string', 'null']
                 },
                 modelFormat: {
                     type: ['string', 'null']