@aws/ml-container-creator 0.2.5 → 0.3.0

package/src/lib/prompts.js

@@ -14,7 +14,7 @@ import { fileURLToPath } from 'node:url';
 
 const __promptsFilename = fileURLToPath(import.meta.url);
 const __promptsDir = dirname(__promptsFilename);
-const instancesCatalogPath = resolve(__promptsDir, '../../servers/instance-recommender/catalogs/instances.json');
+const instancesCatalogPath = resolve(__promptsDir, '../../servers/lib/catalogs/instances.json');
 
 /**
  * Load instance types from the instances.json catalog and transform
@@ -1053,7 +1053,7 @@ function formatImageChoices(entries, isTransformer) {
             ? `${entry.repository.padEnd(30)} ${entry.tag.padEnd(16)} ${entry.architecture.padEnd(7)} ${cuda.padEnd(6)} ${python.padEnd(8)} ${date}`
             : `${entry.repository.padEnd(30)} ${entry.tag.padEnd(16)} ${entry.architecture.padEnd(7)} ${python.padEnd(8)} ${date}`;
 
-        return { name, value: entry.image };
+        return { name, value: entry.image, _meta: { labels: entry.labels, accelerator: entry.accelerator } };
     });
 }
 

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

@@ -24,6 +24,8 @@ import { readFileSync } from 'node:fs';
 import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import DeploymentRegistry, { reconstructReplayFlags } from './deployment-registry.js';
+import { syncArchitectures } from './architecture-sync.js';
+import HuggingFaceClient from './huggingface-client.js';
 
 const PERSONAL_REGISTRY_PATH = path.join(os.homedir(), '.ml-container-creator', 'registry.json');
 const PROJECT_REGISTRY_PATH = path.join(process.cwd(), '.ml-container-creator', 'registry.json');
@@ -71,6 +73,15 @@ export default class RegistryCommandHandler {
         case 'search':
             this._handleSearch(options);
             break;
+        case 'sync-architectures':
+            await this._handleSyncArchitectures();
+            break;
+        case 'list-architectures':
+            this._handleListArchitectures(args, options);
+            break;
+        case 'check':
+            await this._handleCheck(args);
+            break;
         default:
             console.log(`Unknown registry subcommand: ${subcommand}`);
             this._showRegistryHelp();
@@ -431,6 +442,220 @@ export default class RegistryCommandHandler {
         console.log('');
     }
 
+    /**
+     * registry sync-architectures
+     *
+     * Fetches model registry source files from server GitHub repositories
+     * and populates supportedModelTypes in the model-servers catalog.
+     */
+    async _handleSyncArchitectures() {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const catalogPath = path.resolve(__dirname, '../../servers/lib/catalogs/model-servers.json');
+
+        console.log('\n📋 Syncing model architecture registry...\n');
+
+        const summary = await syncArchitectures(catalogPath);
+
+        console.log('\n── Summary ──────────────────────────────────────');
+        if (summary.servers.length > 0) {
+            console.log('\n   Architectures synced:');
+            for (const { server, version, count } of summary.servers) {
+                console.log(`     ${server} ${version}: ${count} architectures`);
+            }
+        }
+        if (summary.failures.length > 0) {
+            console.log('\n   Failures:');
+            for (const { server, version, reason } of summary.failures) {
+                console.log(`     ${server} ${version}: ${reason}`);
+            }
+        }
+        if (summary.servers.length === 0 && summary.failures.length === 0) {
+            console.log('\n   No server entries found with matching registry sources.');
+        }
+        console.log('');
+    }
+
+    /**
+     * registry list-architectures [--server <name>] [--verbose]
+     *
+     * Displays a table of server versions and their supported architecture counts.
+     * With --server or --verbose, shows the full list of supported model types.
+     *
+     * @param {object} options - Parsed CLI options
+     */
+    _handleListArchitectures(args, options) {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const catalogPath = path.resolve(__dirname, '../../servers/lib/catalogs/model-servers.json');
+
+        let catalog;
+        try {
+            catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+        } catch (err) {
+            console.log(`Error: Could not read model-servers catalog: ${err.message}`);
+            return;
+        }
+
+        // Parse --server and --verbose from pass-through args (Commander's passThroughOptions
+        // puts options after the subcommand into the args array)
+        let serverFilter = options.server || null;
+        let verbose = options.verbose || false;
+        for (const arg of args) {
+            if (arg.startsWith('--server=')) {
+                serverFilter = arg.split('=')[1];
+            } else if (arg === '--server' && args.indexOf(arg) + 1 < args.length) {
+                serverFilter = args[args.indexOf(arg) + 1];
+            } else if (arg === '--verbose') {
+                verbose = true;
+            }
+        }
+
+        // Collect rows: { server, version, count, types }
+        const rows = [];
+        for (const [server, entries] of Object.entries(catalog)) {
+            if (serverFilter && server !== serverFilter) continue;
+            for (const entry of entries) {
+                const version = entry.labels?.framework_version || '(unknown)';
+                const types = entry.supportedModelTypes || [];
+                rows.push({ server, version, count: types.length, types });
+            }
+        }
+
+        if (rows.length === 0) {
+            if (serverFilter) {
+                console.log(`No entries found for server "${serverFilter}".`);
+            } else {
+                console.log('No server entries found in catalog.');
+            }
+            return;
+        }
+
+        // Display summary table
+        console.log('\nModel Architecture Support:\n');
+        console.log('  Server                Version      Architectures');
+        console.log('  ────────────────────  ───────────  ─────────────');
+        for (const row of rows) {
+            const srv = row.server.padEnd(20);
+            const ver = row.version.padEnd(11);
+            const cnt = row.count === 0 ? '(not synced)' : String(row.count);
+            console.log(`  ${srv}  ${ver}  ${cnt}`);
+        }
+        console.log('');
+
+        // Show full list when --server or --verbose is set
+        if (serverFilter || verbose) {
+            for (const row of rows) {
+                if (row.types.length === 0) continue;
+                console.log(`  ${row.server} ${row.version} supported model types:`);
+                console.log(`    ${row.types.join(', ')}`);
+                console.log('');
+            }
+        }
+    }
+
+    /**
+     * registry check <model-id>
+     *
+     * Fetches a model's config.json from HuggingFace, extracts the model_type,
+     * and checks compatibility against all server versions in the catalog.
+     *
+     * @param {string[]} args - Remaining positional args (args[1] = model-id)
+     */
+    async _handleCheck(args) {
+        const modelId = args[1];
+
+        if (!modelId) {
+            console.log('Usage: ml-container-creator registry check <model-id>');
+            console.log('Example: ml-container-creator registry check meta-llama/Llama-2-7b-chat-hf');
+            return;
+        }
+
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const catalogPath = path.resolve(__dirname, '../../servers/lib/catalogs/model-servers.json');
+
+        // Fetch model's config.json from HuggingFace
+        console.log(`\n🔍 Checking model: ${modelId}\n`);
+        console.log('   Fetching model config from HuggingFace...');
+
+        const hfClient = new HuggingFaceClient({ timeout: 10000 });
+        const config = await hfClient.fetchModelConfig(modelId);
+
+        if (!config) {
+            console.log(`\n   ❌ Could not fetch config.json for "${modelId}".`);
+            console.log('      Verify the model ID is correct and accessible on HuggingFace.');
+            return;
+        }
+
+        const modelType = config.model_type;
+        if (!modelType) {
+            console.log(`\n   ❌ No "model_type" field found in config.json for "${modelId}".`);
+            return;
+        }
+
+        console.log(`   Model type: ${modelType}`);
+
+        // Load model-servers catalog
+        let catalog;
+        try {
+            catalog = JSON.parse(readFileSync(catalogPath, 'utf8'));
+        } catch (err) {
+            console.log(`\n   ❌ Could not read model-servers catalog: ${err.message}`);
+            return;
+        }
+
+        // Check model_type against all server entries
+        const compatible = [];
+        const incompatible = [];
+        let hasAnyData = false;
+
+        for (const [server, entries] of Object.entries(catalog)) {
+            for (const entry of entries) {
+                const version = entry.labels?.framework_version || '(unknown)';
+                const supported = entry.supportedModelTypes;
+
+                if (!supported || supported.length === 0) continue;
+
+                hasAnyData = true;
+                const modelTypeLower = modelType.toLowerCase();
+                if (supported.includes(modelTypeLower) || supported.includes(modelType)) {
+                    compatible.push({ server, version });
+                } else {
+                    incompatible.push({ server, version });
+                }
+            }
+        }
+
+        // Display results
+        if (!hasAnyData) {
+            console.log('\n   ⚠️  No architecture data available. Run "registry sync-architectures" first.');
+            return;
+        }
+
+        if (compatible.length > 0) {
+            console.log('\n   ✅ Compatible server versions:');
+            for (const { server, version } of compatible) {
+                console.log(`      • ${server} ${version}`);
+            }
+        }
+
+        if (incompatible.length > 0) {
+            console.log('\n   ⚠️  Potentially incompatible server versions:');
+            for (const { server, version } of incompatible) {
+                console.log(`      • ${server} ${version}`);
+            }
+        }
+
+        if (compatible.length === 0) {
+            console.log(`\n   ⚠️  Model architecture "${modelType}" was not found in any server's supported types.`);
+            console.log('      This may indicate the model requires a newer server version,');
+            console.log('      or it may work via trust_remote_code. Check server documentation for details.');
+        }
+
+        console.log('');
+    }
+
     /**
      * Show registry usage help.
      */
@@ -449,6 +674,9 @@ SUBCOMMANDS:
   export [id] [--status <status>]     Export entries as JSON
   import <file> [--merge|--replace]   Import entries from JSON
   search [filters]                    Search entries with glob matching
+  sync-architectures                  Sync supported model types from server repos
+  list-architectures                  Show supported architectures per server version
+  check <model-id>                    Check model compatibility with server versions
 
 FILTER OPTIONS (for list and search):
   --backend <backend>                 Filter by backend (e.g., vllm, flask)
@@ -467,6 +695,10 @@ IMPORT OPTIONS:
   --merge                             Keep both existing and imported on conflict
   --replace                           Overwrite existing with imported on conflict
 
+LIST-ARCHITECTURES OPTIONS:
+  --server <name>                     Show full model type list for a specific server
+  --verbose                           Show full model type list for all servers
+
 OTHER OPTIONS:
   --project                           Use project-level registry instead of personal
 
@@ -481,6 +713,10 @@ EXAMPLES:
   ml-container-creator registry export a1b2c3d4
   ml-container-creator registry import team-deployments.json --merge
   ml-container-creator registry search --model "meta-llama/*" --backend vllm
+  ml-container-creator registry list-architectures
+  ml-container-creator registry list-architectures --server vllm
+  ml-container-creator registry list-architectures --verbose
+  ml-container-creator registry check meta-llama/Llama-2-7b-chat-hf
 `);
     }
 

package/src/lib/registry-loader.js

@@ -18,11 +18,11 @@ const __dirname = dirname(__filename);
 
 // Catalog file paths relative to this module
 const CATALOG_PATHS = {
-    modelServers: resolve(__dirname, '../../servers/base-image-picker/catalogs/model-servers.json'),
-    tritonBackends: resolve(__dirname, '../../servers/base-image-picker/catalogs/triton-backends.json'),
-    instances: resolve(__dirname, '../../servers/instance-recommender/catalogs/instances.json'),
-    popularTransformers: resolve(__dirname, '../../servers/model-picker/catalogs/popular-transformers.json'),
-    popularDiffusors: resolve(__dirname, '../../servers/model-picker/catalogs/popular-diffusors.json')
+    modelServers: resolve(__dirname, '../../servers/lib/catalogs/model-servers.json'),
+    tritonBackends: resolve(__dirname, '../../servers/lib/catalogs/triton-backends.json'),
+    instances: resolve(__dirname, '../../servers/lib/catalogs/instances.json'),
+    popularTransformers: resolve(__dirname, '../../servers/lib/catalogs/popular-transformers.json'),
+    popularDiffusors: resolve(__dirname, '../../servers/lib/catalogs/popular-diffusors.json')
 };
 
 class RegistryLoader {

package/src/lib/schema-sync.js

@@ -0,0 +1,203 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Schema Sync — Downloads AWS service model files from the AWS SDK GitHub source
+ * and stores them in the local schema registry.
+ *
+ * Requirements: 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 10.1
+ */
+
+import https from 'node:https';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const SERVICES = ['sagemaker', 'iam', 'ecr', 's3'];
+
+const SOURCE_BASE_URL = 'https://raw.githubusercontent.com/aws/aws-sdk-js-v3/main/codegen/sdk-codegen/aws-models';
+
+/**
+ * Get the default schema registry path.
+ * @returns {string}
+ */
+export function getRegistryPath() {
+    return path.join(os.homedir(), '.ml-container-creator', 'schemas');
+}
+
+/**
+ * Download a file from a URL using the built-in https module.
+ * @param {string} url - URL to download
+ * @returns {Promise<string>} - Response body as string
+ */
+function downloadFile(url) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                downloadFile(res.headers.location).then(resolve).catch(reject);
+                return;
+            }
+
+            if (res.statusCode !== 200) {
+                reject(new Error(`HTTP ${res.statusCode} for ${url}`));
+                return;
+            }
+
+            const chunks = [];
+            res.on('data', (chunk) => chunks.push(chunk));
+            res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+            res.on('error', reject);
+        }).on('error', reject);
+    });
+}
+
+/**
+ * Count shapes and enums in a service model.
+ * @param {object} model - Parsed service model JSON
+ * @returns {{ shapeCount: number, enumCount: number, version: string }}
+ */
+function getModelStats(model) {
+    const shapes = model.shapes || {};
+    let shapeCount = 0;
+    let enumCount = 0;
+
+    for (const shape of Object.values(shapes)) {
+        shapeCount++;
+        if (shape.type === 'string' && shape.enum) {
+            enumCount++;
+        }
+        // Smithy models use traits for enums
+        if (shape.traits && shape.traits['smithy.api#enum']) {
+            enumCount++;
+        }
+        // Smithy v2 enum shapes
+        if (shape.type === 'enum') {
+            enumCount++;
+        }
+    }
+
+    const version = model.metadata?.apiVersion || '';
+
+    return { shapeCount, enumCount, version };
+}
+
+/**
+ * Sync all service models from the AWS SDK GitHub source.
+ * @param {object} [options]
+ * @param {string} [options.registryPath] - Override registry path
+ * @param {function} [options.downloadFn] - Override download function (for testing)
+ * @returns {Promise<{ success: boolean, services: object }>}
+ */
+export async function syncSchemas(options = {}) {
+    const registryPath = options.registryPath || getRegistryPath();
+    const download = options.downloadFn || downloadFile;
+
+    // Ensure registry directory exists
+    mkdirSync(registryPath, { recursive: true });
+
+    const serviceStats = {};
+    let hasErrors = false;
+
+    for (const service of SERVICES) {
+        const url = `${SOURCE_BASE_URL}/${service}.json`;
+        const serviceDir = path.join(registryPath, service);
+
+        try {
+            console.log(`  Syncing ${service}...`);
+            const content = await download(url);
+
+            // Parse to extract stats
+            let model;
+            try {
+                model = JSON.parse(content);
+            } catch (parseErr) {
+                console.log(`  ⚠️  ${service}: Failed to parse model — ${parseErr.message}`);
+                hasErrors = true;
+                continue;
+            }
+
+            const stats = getModelStats(model);
+
+            // Store the file
+            mkdirSync(serviceDir, { recursive: true });
+            writeFileSync(path.join(serviceDir, 'service-2.json'), content, 'utf8');
+
+            serviceStats[service] = {
+                shapeCount: stats.shapeCount,
+                enumCount: stats.enumCount,
+                version: stats.version
+            };
+
+            console.log(`  ✅ ${service}: ${stats.shapeCount} shapes, ${stats.enumCount} enums`);
+        } catch (err) {
+            console.log(`  ⚠️  ${service}: ${err.message}`);
+            hasErrors = true;
+        }
+    }
+
+    // Write manifest
+    const manifest = {
+        lastSynced: new Date().toISOString(),
+        services: serviceStats,
+        source: 'https://github.com/aws/aws-sdk-js-v3/tree/main/codegen/sdk-codegen/aws-models'
+    };
+
+    writeFileSync(
+        path.join(registryPath, 'manifest.json'),
+        JSON.stringify(manifest, null, 4),
+        'utf8'
+    );
+
+    return { success: !hasErrors, services: serviceStats, manifest };
+}
+
+/**
+ * Load the manifest from the schema registry.
+ * @param {string} [registryPath] - Override registry path
+ * @returns {object|null} Parsed manifest or null if not found
+ */
+export function loadManifest(registryPath) {
+    const regPath = registryPath || getRegistryPath();
+    const manifestPath = path.join(regPath, 'manifest.json');
+
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+
+    try {
+        return JSON.parse(readFileSync(manifestPath, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Load a service model from the registry.
+ * @param {string} serviceName - Service name (e.g., 'sagemaker')
+ * @param {string} [registryPath] - Override registry path
+ * @returns {string|null} Raw file content or null if not found
+ */
+export function loadServiceModel(serviceName, registryPath) {
+    const regPath = registryPath || getRegistryPath();
+    const modelPath = path.join(regPath, serviceName, 'service-2.json');
+
+    if (!existsSync(modelPath)) {
+        return null;
+    }
+
+    return readFileSync(modelPath, 'utf8');
+}
+
+/**
+ * Store a service model in the registry.
+ * @param {string} serviceName - Service name (e.g., 'sagemaker')
+ * @param {string} content - Raw file content to store
+ * @param {string} [registryPath] - Override registry path
+ */
+export function storeServiceModel(serviceName, content, registryPath) {
+    const regPath = registryPath || getRegistryPath();
+    const serviceDir = path.join(regPath, serviceName);
+
+    mkdirSync(serviceDir, { recursive: true });
+    writeFileSync(path.join(serviceDir, 'service-2.json'), content, 'utf8');
+}