@aws/ml-container-creator 0.2.1 → 0.2.2

package/src/lib/deployment-registry.js

@@ -15,23 +15,23 @@
  * }
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
-import { dirname } from 'node:path'
-import { createHash } from 'node:crypto'
-import Ajv from 'ajv'
-import { minimatch } from 'minimatch'
-import deploymentEntrySchema from './deployment-entry-schema.js'
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { createHash } from 'node:crypto';
+import Ajv from 'ajv';
+import { minimatch } from 'minimatch';
+import deploymentEntrySchema from './deployment-entry-schema.js';
 
-const CURRENT_SCHEMA_VERSION = '2026-03-20'
+const CURRENT_SCHEMA_VERSION = '2026-03-20';
 
 export default class DeploymentRegistry {
     /**
      * @param {string} registryPath - Absolute path to the registry JSON file
      */
     constructor(registryPath) {
-        this.registryPath = registryPath
-        this._ajv = new Ajv({ allErrors: true, strict: false })
-        this._validate = this._ajv.compile(deploymentEntrySchema)
+        this.registryPath = registryPath;
+        this._ajv = new Ajv({ allErrors: true, strict: false });
+        this._validate = this._ajv.compile(deploymentEntrySchema);
     }
 
     /**
@@ -46,27 +46,27 @@ export default class DeploymentRegistry {
      */
     _readRegistry() {
         if (!existsSync(this.registryPath)) {
-            return []
+            return [];
         }
 
-        const raw = readFileSync(this.registryPath, 'utf8')
+        const raw = readFileSync(this.registryPath, 'utf8');
 
-        let data
+        let data;
         try {
-            data = JSON.parse(raw)
+            data = JSON.parse(raw);
         } catch (err) {
-            throw new Error(`Invalid JSON in registry file ${this.registryPath}: ${err.message}`)
+            throw new Error(`Invalid JSON in registry file ${this.registryPath}: ${err.message}`);
         }
 
-        const migrated = this._migrateIfNeeded(data)
+        const migrated = this._migrateIfNeeded(data);
 
         if (!migrated.schemaVersion) {
-            console.warn(`Warning: Registry file ${this.registryPath} has no schemaVersion. Attempting best-effort read.`)
+            console.warn(`Warning: Registry file ${this.registryPath} has no schemaVersion. Attempting best-effort read.`);
         } else if (migrated.schemaVersion !== CURRENT_SCHEMA_VERSION) {
-            console.warn(`Warning: Registry file ${this.registryPath} has unrecognized schemaVersion "${migrated.schemaVersion}". Attempting best-effort read.`)
+            console.warn(`Warning: Registry file ${this.registryPath} has unrecognized schemaVersion "${migrated.schemaVersion}". Attempting best-effort read.`);
         }
 
-        return Array.isArray(migrated.entries) ? migrated.entries : []
+        return Array.isArray(migrated.entries) ? migrated.entries : [];
     }
 
     /**
@@ -78,17 +78,17 @@ export default class DeploymentRegistry {
      * @param {Array<Object>} entries - The entries array to write
      */
     _writeRegistry(entries) {
-        const dir = dirname(this.registryPath)
+        const dir = dirname(this.registryPath);
         if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true })
+            mkdirSync(dir, { recursive: true });
         }
 
         const envelope = {
             schemaVersion: CURRENT_SCHEMA_VERSION,
             entries
-        }
+        };
 
-        writeFileSync(this.registryPath, JSON.stringify(envelope, null, 2) + '\n')
+        writeFileSync(this.registryPath, `${JSON.stringify(envelope, null, 2)  }\n`);
     }
 
     /**
@@ -100,17 +100,17 @@ export default class DeploymentRegistry {
      * @returns {string} 8-character hex string
      */
     _generateId(entry, existingEntries = []) {
-        const baseInput = `${entry.timestamp}:${entry.deployment.deploymentConfig}`
-        let id = createHash('sha256').update(baseInput).digest('hex').slice(0, 8)
+        const baseInput = `${entry.timestamp}:${entry.deployment.deploymentConfig}`;
+        let id = createHash('sha256').update(baseInput).digest('hex').slice(0, 8);
 
-        const existingIds = new Set(existingEntries.map(e => e.id))
+        const existingIds = new Set(existingEntries.map(e => e.id));
 
         while (existingIds.has(id)) {
-            const entropy = Math.random().toString(36).slice(2)
-            id = createHash('sha256').update(baseInput + entropy).digest('hex').slice(0, 8)
+            const entropy = Math.random().toString(36).slice(2);
+            id = createHash('sha256').update(baseInput + entropy).digest('hex').slice(0, 8);
         }
 
-        return id
+        return id;
     }
 
     /**
@@ -120,11 +120,11 @@ export default class DeploymentRegistry {
      * @returns {{ valid: boolean, errors: Array|null }} Validation result
      */
     _validateEntry(entry) {
-        const valid = this._validate(entry)
+        const valid = this._validate(entry);
         return {
             valid: !!valid,
             errors: valid ? null : this._validate.errors
-        }
+        };
     }
 
     /**
@@ -143,19 +143,19 @@ export default class DeploymentRegistry {
             return {
                 schemaVersion: CURRENT_SCHEMA_VERSION,
                 entries: data
-            }
+            };
         }
 
         // Already an envelope with schemaVersion and entries
         if (data && typeof data === 'object' && 'entries' in data) {
-            return data
+            return data;
         }
 
         // Unknown format — wrap in envelope with empty entries
         return {
             schemaVersion: undefined,
             entries: []
-        }
+        };
     }
 
     /**
@@ -169,21 +169,21 @@ export default class DeploymentRegistry {
      * @throws {Error} If the entry fails schema validation
      */
     add(entry) {
-        const existingEntries = this._readRegistry()
-        const id = this._generateId(entry, existingEntries)
+        const existingEntries = this._readRegistry();
+        const id = this._generateId(entry, existingEntries);
 
-        const fullEntry = { ...entry, id }
+        const fullEntry = { ...entry, id };
 
-        const { valid, errors } = this._validateEntry(fullEntry)
+        const { valid, errors } = this._validateEntry(fullEntry);
         if (!valid) {
-            const details = errors.map(e => `${e.instancePath || '/'} ${e.message}`).join(', ')
-            throw new Error(`Validation failed: ${details}`)
+            const details = errors.map(e => `${e.instancePath || '/'} ${e.message}`).join(', ');
+            throw new Error(`Validation failed: ${details}`);
         }
 
-        existingEntries.push(fullEntry)
-        this._writeRegistry(existingEntries)
+        existingEntries.push(fullEntry);
+        this._writeRegistry(existingEntries);
 
-        return id
+        return id;
     }
 
     /**
@@ -193,8 +193,8 @@ export default class DeploymentRegistry {
      * @returns {Object|null} The matching entry, or null if not found
      */
     get(id) {
-        const entries = this._readRegistry()
-        return entries.find(e => e.id === id) || null
+        const entries = this._readRegistry();
+        return entries.find(e => e.id === id) || null;
     }
 
     /**
@@ -204,15 +204,15 @@ export default class DeploymentRegistry {
      * @returns {boolean} true if an entry was removed, false if not found
      */
     remove(id) {
-        const entries = this._readRegistry()
-        const filtered = entries.filter(e => e.id !== id)
+        const entries = this._readRegistry();
+        const filtered = entries.filter(e => e.id !== id);
 
         if (filtered.length === entries.length) {
-            return false
+            return false;
         }
 
-        this._writeRegistry(filtered)
-        return true
+        this._writeRegistry(filtered);
+        return true;
     }
 
     /**
@@ -231,36 +231,36 @@ export default class DeploymentRegistry {
      */
     _matchesFilters(entry, filters) {
         if (!filters || typeof filters !== 'object') {
-            return true
+            return true;
         }
 
         for (const [key, value] of Object.entries(filters)) {
             if (value === undefined || value === null) {
-                continue
+                continue;
             }
 
             switch (key) {
-                case 'backend':
-                    if (entry.deployment?.backend !== value) return false
-                    break
-                case 'architecture':
-                    if (entry.deployment?.architecture !== value) return false
-                    break
-                case 'model':
-                    if (!entry.model?.modelName?.toLowerCase().includes(value.toLowerCase())) return false
-                    break
-                case 'instance-type':
-                    if (entry.infrastructure?.instanceType !== value) return false
-                    break
-                case 'status':
-                    if (entry.status !== value) return false
-                    break
-                default:
-                    break
+            case 'backend':
+                if (entry.deployment?.backend !== value) return false;
+                break;
+            case 'architecture':
+                if (entry.deployment?.architecture !== value) return false;
+                break;
+            case 'model':
+                if (!entry.model?.modelName?.toLowerCase().includes(value.toLowerCase())) return false;
+                break;
+            case 'instance-type':
+                if (entry.infrastructure?.instanceType !== value) return false;
+                break;
+            case 'status':
+                if (entry.status !== value) return false;
+                break;
+            default:
+                break;
             }
         }
 
-        return true
+        return true;
     }
 
     /**
@@ -273,13 +273,13 @@ export default class DeploymentRegistry {
      * @returns {Array<Object>} Matching entries
      */
     list(filters) {
-        const entries = this._readRegistry()
+        const entries = this._readRegistry();
 
         if (!filters || Object.keys(filters).length === 0) {
-            return entries
+            return entries;
         }
 
-        return entries.filter(entry => this._matchesFilters(entry, filters))
+        return entries.filter(entry => this._matchesFilters(entry, filters));
     }
 
     /**
@@ -292,41 +292,41 @@ export default class DeploymentRegistry {
      * @returns {Array<Object>} Matching entries
      */
     search(query) {
-        const entries = this._readRegistry()
+        const entries = this._readRegistry();
 
         if (!query || Object.keys(query).length === 0) {
-            return entries
+            return entries;
         }
 
         return entries.filter(entry => {
             for (const [key, value] of Object.entries(query)) {
                 if (value === undefined || value === null) {
-                    continue
+                    continue;
                 }
 
                 switch (key) {
-                    case 'model':
-                        if (!entry.model?.modelName || !minimatch(entry.model.modelName, value)) return false
-                        break
-                    case 'backend':
-                        if (entry.deployment?.backend !== value) return false
-                        break
-                    case 'architecture':
-                        if (entry.deployment?.architecture !== value) return false
-                        break
-                    case 'instance-type':
-                        if (entry.infrastructure?.instanceType !== value) return false
-                        break
-                    case 'status':
-                        if (entry.status !== value) return false
-                        break
-                    default:
-                        break
+                case 'model':
+                    if (!entry.model?.modelName || !minimatch(entry.model.modelName, value)) return false;
+                    break;
+                case 'backend':
+                    if (entry.deployment?.backend !== value) return false;
+                    break;
+                case 'architecture':
+                    if (entry.deployment?.architecture !== value) return false;
+                    break;
+                case 'instance-type':
+                    if (entry.infrastructure?.instanceType !== value) return false;
+                    break;
+                case 'status':
+                    if (entry.status !== value) return false;
+                    break;
+                default:
+                    break;
                 }
             }
 
-            return true
-        })
+            return true;
+        });
     }
 
     /**
@@ -344,19 +344,19 @@ export default class DeploymentRegistry {
      * @returns {Object} A sanitized deep copy of the entry
      */
     _stripSensitiveFields(entry) {
-        const copy = JSON.parse(JSON.stringify(entry))
+        const copy = JSON.parse(JSON.stringify(entry));
 
         if (copy.infrastructure) {
-            delete copy.infrastructure.roleArn
-            delete copy.infrastructure.region
+            delete copy.infrastructure.roleArn;
+            delete copy.infrastructure.region;
         }
 
         if (copy.configuration?.parameters) {
-            delete copy.configuration.parameters.HF_TOKEN
-            delete copy.configuration.parameters.NGC_API_KEY
+            delete copy.configuration.parameters.HF_TOKEN;
+            delete copy.configuration.parameters.NGC_API_KEY;
         }
 
-        return copy
+        return copy;
     }
 
     /**
@@ -373,25 +373,25 @@ export default class DeploymentRegistry {
      * @returns {Object} Export_Format object with version, exportedAt, exportedBy, entries
      */
     exportEntries(id, options = {}) {
-        const entries = this._readRegistry()
-        const statusFilter = options.status || 'success'
+        const entries = this._readRegistry();
+        const statusFilter = options.status || 'success';
 
-        let filtered
+        let filtered;
         if (id) {
-            const entry = entries.find(e => e.id === id)
-            filtered = entry ? [entry] : []
+            const entry = entries.find(e => e.id === id);
+            filtered = entry ? [entry] : [];
         } else {
-            filtered = entries.filter(e => e.status === statusFilter)
+            filtered = entries.filter(e => e.status === statusFilter);
         }
 
-        const sanitized = filtered.map(e => this._stripSensitiveFields(e))
+        const sanitized = filtered.map(e => this._stripSensitiveFields(e));
 
         return {
             version: '1.0',
             exportedAt: new Date().toISOString(),
             exportedBy: 'anonymous',
             entries: sanitized
-        }
+        };
     }
 
     /**
@@ -403,7 +403,7 @@ export default class DeploymentRegistry {
      * @returns {Object} CLI flag key-value pairs
      */
     reconstructReplayFlags(entry, overrides = {}) {
-        return reconstructReplayFlags(entry, overrides)
+        return reconstructReplayFlags(entry, overrides);
     }
 
     /**
@@ -428,61 +428,61 @@ export default class DeploymentRegistry {
      */
     importEntries(json, strategy = 'skip', filename = 'unknown') {
         if (!json || typeof json !== 'object' || !json.version || !Array.isArray(json.entries)) {
-            throw new Error('Invalid export format: missing required "version" or "entries" fields')
+            throw new Error('Invalid export format: missing required "version" or "entries" fields');
         }
 
-        const existingEntries = this._readRegistry()
-        let added = 0
-        let skipped = 0
-        let conflicts = 0
+        const existingEntries = this._readRegistry();
+        let added = 0;
+        let skipped = 0;
+        let conflicts = 0;
 
         for (const importedEntry of json.entries) {
-            const entry = JSON.parse(JSON.stringify(importedEntry))
+            const entry = JSON.parse(JSON.stringify(importedEntry));
 
             if (!entry.metadata) {
-                entry.metadata = {}
+                entry.metadata = {};
             }
-            entry.metadata.source = 'imported'
-            entry.metadata.importedFrom = filename
+            entry.metadata.source = 'imported';
+            entry.metadata.importedFrom = filename;
 
             const isConflict = existingEntries.some(existing =>
                 existing.model?.modelName === entry.model?.modelName &&
                 existing.deployment?.backend === entry.deployment?.backend &&
                 existing.infrastructure?.instanceType === entry.infrastructure?.instanceType &&
                 JSON.stringify(existing.configuration?.parameters) === JSON.stringify(entry.configuration?.parameters)
-            )
+            );
 
             if (isConflict) {
-                conflicts++
+                conflicts++;
                 if (strategy === 'merge') {
-                    const id = this._generateId(entry, existingEntries)
-                    entry.id = id
-                    existingEntries.push(entry)
+                    const id = this._generateId(entry, existingEntries);
+                    entry.id = id;
+                    existingEntries.push(entry);
                 } else if (strategy === 'replace') {
                     const conflictIndex = existingEntries.findIndex(existing =>
                         existing.model?.modelName === entry.model?.modelName &&
                         existing.deployment?.backend === entry.deployment?.backend &&
                         existing.infrastructure?.instanceType === entry.infrastructure?.instanceType &&
                         JSON.stringify(existing.configuration?.parameters) === JSON.stringify(entry.configuration?.parameters)
-                    )
+                    );
                     if (conflictIndex !== -1) {
-                        entry.id = existingEntries[conflictIndex].id
-                        existingEntries[conflictIndex] = entry
+                        entry.id = existingEntries[conflictIndex].id;
+                        existingEntries[conflictIndex] = entry;
                     }
                 } else {
-                    skipped++
+                    skipped++;
                 }
             } else {
-                const id = this._generateId(entry, existingEntries)
-                entry.id = id
-                existingEntries.push(entry)
-                added++
+                const id = this._generateId(entry, existingEntries);
+                entry.id = id;
+                existingEntries.push(entry);
+                added++;
             }
         }
 
-        this._writeRegistry(existingEntries)
+        this._writeRegistry(existingEntries);
 
-        return { added, skipped, conflicts }
+        return { added, skipped, conflicts };
     }
 
 }
@@ -505,35 +505,35 @@ export default class DeploymentRegistry {
  * @returns {Object} CLI flag key-value pairs
  */
 export function reconstructReplayFlags(entry, overrides = {}) {
-    const flags = {}
+    const flags = {};
 
     const mappings = [
         { field: entry?.deployment?.deploymentConfig, flag: '--deployment-config' },
         { field: entry?.model?.modelName, flag: '--model-name' },
         { field: entry?.infrastructure?.instanceType, flag: '--instance-type' },
-        { field: entry?.infrastructure?.region, flag: '--region' },
-    ]
+        { field: entry?.infrastructure?.region, flag: '--region' }
+    ];
 
     for (const { field, flag } of mappings) {
-        if (field != null) {
-            flags[flag] = field
+        if (field !== null && field !== undefined) {
+            flags[flag] = field;
         }
     }
 
     // Omit --model-format for transformers architecture
-    const isTransformers = entry?.deployment?.architecture === 'transformers'
-    if (!isTransformers && entry?.model?.modelFormat != null) {
-        flags['--model-format'] = entry.model.modelFormat
+    const isTransformers = entry?.deployment?.architecture === 'transformers';
+    if (!isTransformers && entry?.model?.modelFormat !== null && entry?.model?.modelFormat !== undefined) {
+        flags['--model-format'] = entry.model.modelFormat;
     }
 
     // Apply user overrides with higher precedence
     for (const [key, value] of Object.entries(overrides)) {
-        if (value != null) {
-            flags[key] = value
+        if (value !== null && value !== undefined) {
+            flags[key] = value;
         }
     }
 
-    return flags
+    return flags;
 }
 
 /**
@@ -551,8 +551,8 @@ const HTTP_SYSTEM_VARS = new Set([
     'PYTHON_PIP_VERSION',
     'PYTHON_SETUPTOOLS_VERSION',
     'PYTHON_GET_PIP_URL',
-    'PYTHON_GET_PIP_SHA256',
-])
+    'PYTHON_GET_PIP_SHA256'
+]);
 
 /**
  * Filter environment variables for transformer architecture deployments.
@@ -565,15 +565,15 @@ const HTTP_SYSTEM_VARS = new Set([
  * @returns {Object} Filtered key-value pairs
  */
 export function filterTransformerEnvVars(envVars, enginePrefix) {
-    const result = {}
+    const result = {};
 
     for (const [key, value] of Object.entries(envVars)) {
         if (key.startsWith(enginePrefix) || key === 'HF_TOKEN' || key === 'HF_MODEL_ID') {
-            result[key] = value
+            result[key] = value;
         }
     }
 
-    return result
+    return result;
 }
 
 /**
@@ -586,13 +586,13 @@ export function filterTransformerEnvVars(envVars, enginePrefix) {
  * @returns {Object} Filtered key-value pairs with system vars removed
  */
 export function filterHttpEnvVars(envVars) {
-    const result = {}
+    const result = {};
 
     for (const [key, value] of Object.entries(envVars)) {
         if (!HTTP_SYSTEM_VARS.has(key)) {
-            result[key] = value
+            result[key] = value;
         }
     }
 
-    return result
+    return result;
 }

package/src/lib/engine-prefix-resolver.js

@@ -23,7 +23,7 @@ export const ENGINE_PREFIX_MAP = {
     'tensorrt-llm': 'TRTLLM_',
     'lmi': 'LMI_',
     'djl': 'DJL_'
-}
+};
 
 /**
  * Resolve the prefixed key for a given engine and user-provided key.
@@ -35,11 +35,11 @@ export const ENGINE_PREFIX_MAP = {
  * @returns {string} The resolved key with engine prefix applied (or unchanged)
  */
 export function resolvePrefix(engine, key) {
-    const prefix = ENGINE_PREFIX_MAP[engine]
+    const prefix = ENGINE_PREFIX_MAP[engine];
     if (prefix) {
-        return `${prefix}${key}`
+        return `${prefix}${key}`;
     }
-    return key
+    return key;
 }
 
 /**
@@ -51,10 +51,10 @@ export function resolvePrefix(engine, key) {
  * @returns {Object<string, string>} New object with prefixed keys and original values
  */
 export function resolvePrefixedEnvVars(engine, serverEnvVars) {
-    const result = {}
+    const result = {};
     for (const [key, value] of Object.entries(serverEnvVars)) {
-        const prefixedKey = resolvePrefix(engine, key)
-        result[prefixedKey] = value
+        const prefixedKey = resolvePrefix(engine, key);
+        result[prefixedKey] = value;
     }
-    return result
+    return result;
 }

package/src/lib/key-value-parser.js

@@ -11,7 +11,7 @@
  * Requirements: 3.4, 3.5, 4.4, 4.5
  */
 
-import { ValidationError } from './config-manager.js'
+import { ValidationError } from './config-manager.js';
 
 /**
  * Parse a KEY=VALUE string, splitting only on the first '=' character.
@@ -20,18 +20,18 @@ import { ValidationError } from './config-manager.js'
  * @throws {ValidationError} if no '=' is present
  */
 export function parseKeyValue(input) {
-    const idx = input.indexOf('=')
+    const idx = input.indexOf('=');
 
     if (idx === -1) {
         throw new ValidationError(
             `Invalid format for env var: expected KEY=VALUE, got '${input}'`,
             'env',
             input
-        )
+        );
     }
 
-    const key = input.substring(0, idx)
-    const value = input.substring(idx + 1)
+    const key = input.substring(0, idx);
+    const value = input.substring(idx + 1);
 
-    return { key, value }
+    return { key, value };
 }