@aws/ml-container-creator 0.2.1 → 0.2.2

package/src/copy-tpl.js

@@ -1,10 +1,10 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import ejs from 'ejs'
-import { globSync } from 'tinyglobby'
-import fs from 'fs'
-import path from 'path'
+import ejs from 'ejs';
+import { globSync } from 'tinyglobby';
+import fs from 'fs';
+import path from 'path';
 
 /**
  * Binary file extensions that should be copied without EJS rendering.
@@ -16,7 +16,7 @@ const BINARY_EXTENSIONS = new Set([
     '.pdf',
     '.exe', '.dll', '.so', '.dylib',
     '.pyc', '.pyo', '.class', '.jar', '.war', '.ear'
-])
+]);
 
 /**
  * Determines whether a file is binary based on its extension.
@@ -25,8 +25,8 @@ const BINARY_EXTENSIONS = new Set([
  * @returns {boolean} True if the file has a known binary extension
  */
 function isBinaryFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase()
-    return BINARY_EXTENSIONS.has(ext)
+    const ext = path.extname(filePath).toLowerCase();
+    return BINARY_EXTENSIONS.has(ext);
 }
 
 /**
@@ -47,31 +47,31 @@ export function copyTpl(templateDir, destDir, vars, ignorePatterns = []) {
         ignore: ignorePatterns,
         dot: true,
         onlyFiles: true
-    })
+    });
 
     for (const file of files) {
-        const src = path.join(templateDir, file)
-        const dest = path.join(destDir, file)
+        const src = path.join(templateDir, file);
+        const dest = path.join(destDir, file);
 
-        fs.mkdirSync(path.dirname(dest), { recursive: true })
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
 
         if (isBinaryFile(file)) {
-            fs.copyFileSync(src, dest)
-            continue
+            fs.copyFileSync(src, dest);
+            continue;
         }
 
-        const content = fs.readFileSync(src, 'utf8')
+        const content = fs.readFileSync(src, 'utf8');
 
-        let rendered
+        let rendered;
         try {
-            rendered = ejs.render(content, vars, { filename: src })
+            rendered = ejs.render(content, vars, { filename: src });
         } catch (err) {
-            const line = err.line ? ` (line ${err.line})` : ''
+            const line = err.line ? ` (line ${err.line})` : '';
             throw new Error(
                 `EJS rendering failed for "${file}"${line}: ${err.message}`
-            )
+            );
         }
 
-        fs.writeFileSync(dest, rendered)
+        fs.writeFileSync(dest, rendered);
     }
 }

package/src/lib/asset-manager.js

@@ -29,11 +29,11 @@
  * }
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
-import { join, dirname } from 'node:path'
-import { homedir } from 'node:os'
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
 
-const SCHEMA_VERSION = '2026-05-04'
+const SCHEMA_VERSION = '2026-05-04';
 
 const VALID_RESOURCE_TYPES = [
     'sagemaker-endpoint',
@@ -48,11 +48,11 @@ const VALID_RESOURCE_TYPES = [
     'sns-topic',
     'k8s-deployment',
     'k8s-service'
-]
+];
 
-const VALID_STATUSES = ['active', 'deleted', 'unknown']
+const VALID_STATUSES = ['active', 'deleted', 'unknown'];
 
-export { SCHEMA_VERSION, VALID_RESOURCE_TYPES, VALID_STATUSES }
+export { SCHEMA_VERSION, VALID_RESOURCE_TYPES, VALID_STATUSES };
 
 export default class AssetManager {
     /**
@@ -62,8 +62,8 @@ export default class AssetManager {
      *   Defaults to ~/.ml-container-creator
      */
     constructor(profileName, options = {}) {
-        this.profileName = profileName
-        this.configDir = options.configDir || join(homedir(), '.ml-container-creator')
+        this.profileName = profileName;
+        this.configDir = options.configDir || join(homedir(), '.ml-container-creator');
     }
 
     /**
@@ -72,7 +72,7 @@ export default class AssetManager {
      * @returns {string} Absolute path to the manifest JSON file
      */
     get manifestPath() {
-        return join(this.configDir, 'manifests', `${this.profileName}.json`)
+        return join(this.configDir, 'manifests', `${this.profileName}.json`);
     }
 
     /**
@@ -87,34 +87,34 @@ export default class AssetManager {
      */
     _readManifest() {
         if (!existsSync(this.manifestPath)) {
-            return { schemaVersion: SCHEMA_VERSION, resources: [] }
+            return { schemaVersion: SCHEMA_VERSION, resources: [] };
         }
 
-        const raw = readFileSync(this.manifestPath, 'utf8')
+        const raw = readFileSync(this.manifestPath, 'utf8');
 
-        let data
+        let data;
         try {
-            data = JSON.parse(raw)
+            data = JSON.parse(raw);
         } catch (err) {
             throw new Error(
                 `Invalid JSON in manifest file ${this.manifestPath}: ${err.message}`
-            )
+            );
         }
 
         if (!data.schemaVersion) {
             console.warn(
                 `Warning: Manifest file ${this.manifestPath} has no schemaVersion. Attempting best-effort read.`
-            )
+            );
         } else if (data.schemaVersion !== SCHEMA_VERSION) {
             console.warn(
                 `Warning: Manifest file ${this.manifestPath} has unrecognized schemaVersion "${data.schemaVersion}". Attempting best-effort read.`
-            )
+            );
         }
 
         return {
             schemaVersion: data.schemaVersion || SCHEMA_VERSION,
             resources: Array.isArray(data.resources) ? data.resources : []
-        }
+        };
     }
 
     /**
@@ -125,15 +125,15 @@ export default class AssetManager {
      * @param {{ schemaVersion: string, resources: Array<Object> }} manifest
      */
     _writeManifest(manifest) {
-        const dir = dirname(this.manifestPath)
+        const dir = dirname(this.manifestPath);
         if (!existsSync(dir)) {
-            mkdirSync(dir, { recursive: true })
+            mkdirSync(dir, { recursive: true });
         }
 
         writeFileSync(
             this.manifestPath,
             `${JSON.stringify(manifest, null, 2)}\n`
-        )
+        );
     }
 
     /**
@@ -150,7 +150,7 @@ export default class AssetManager {
      * @returns {{ valid: boolean, errors: string[] }}
      */
     _validateRecord(record) {
-        const errors = []
+        const errors = [];
 
         const requiredFields = [
             'resourceId',
@@ -160,11 +160,11 @@ export default class AssetManager {
             'project',
             'status',
             'metadata'
-        ]
+        ];
 
         for (const field of requiredFields) {
             if (record[field] === undefined || record[field] === null) {
-                errors.push(`Missing required field: ${field}`)
+                errors.push(`Missing required field: ${field}`);
             }
         }
 
@@ -172,7 +172,7 @@ export default class AssetManager {
             if (!VALID_RESOURCE_TYPES.includes(record.resourceType)) {
                 errors.push(
                     `Invalid resourceType: "${record.resourceType}". Must be one of: ${VALID_RESOURCE_TYPES.join(', ')}`
-                )
+                );
             }
         }
 
@@ -180,7 +180,7 @@ export default class AssetManager {
             if (!VALID_STATUSES.includes(record.status)) {
                 errors.push(
                     `Invalid status: "${record.status}". Must be one of: ${VALID_STATUSES.join(', ')}`
-                )
+                );
             }
         }
 
@@ -188,7 +188,7 @@ export default class AssetManager {
             if (!_isValidISO8601(record.createdAt)) {
                 errors.push(
                     `Invalid createdAt: "${record.createdAt}". Must be a valid ISO 8601 timestamp.`
-                )
+                );
             }
         }
 
@@ -196,17 +196,17 @@ export default class AssetManager {
             if (!_isValidISO8601(record.lastUpdatedAt)) {
                 errors.push(
                     `Invalid lastUpdatedAt: "${record.lastUpdatedAt}". Must be a valid ISO 8601 timestamp.`
-                )
+                );
             }
         }
 
         if (record.metadata !== undefined && record.metadata !== null) {
             if (typeof record.metadata !== 'object' || Array.isArray(record.metadata)) {
-                errors.push('Invalid metadata: must be a non-null object.')
+                errors.push('Invalid metadata: must be a non-null object.');
             }
         }
 
-        return { valid: errors.length === 0, errors }
+        return { valid: errors.length === 0, errors };
     }
 
     /**
@@ -219,24 +219,24 @@ export default class AssetManager {
      * @throws {Error} If the record fails validation
      */
     addResource(record) {
-        const { valid, errors } = this._validateRecord(record)
+        const { valid, errors } = this._validateRecord(record);
         if (!valid) {
-            throw new Error(`Invalid asset record: ${errors.join('; ')}`)
+            throw new Error(`Invalid asset record: ${errors.join('; ')}`);
         }
 
-        const manifest = this._readManifest()
+        const manifest = this._readManifest();
         const existingIndex = manifest.resources.findIndex(
             r => r.resourceId === record.resourceId
-        )
+        );
 
         if (existingIndex !== -1) {
-            manifest.resources[existingIndex].lastUpdatedAt = record.lastUpdatedAt
-            manifest.resources[existingIndex].status = record.status
+            manifest.resources[existingIndex].lastUpdatedAt = record.lastUpdatedAt;
+            manifest.resources[existingIndex].status = record.status;
         } else {
-            manifest.resources.push(record)
+            manifest.resources.push(record);
         }
 
-        this._writeManifest(manifest)
+        this._writeManifest(manifest);
     }
 
     /**
@@ -247,17 +247,17 @@ export default class AssetManager {
      * @returns {boolean} true if the resource was found and updated, false otherwise
      */
     updateStatus(resourceId, newStatus) {
-        const manifest = this._readManifest()
-        const resource = manifest.resources.find(r => r.resourceId === resourceId)
+        const manifest = this._readManifest();
+        const resource = manifest.resources.find(r => r.resourceId === resourceId);
 
         if (!resource) {
-            return false
+            return false;
         }
 
-        resource.status = newStatus
-        resource.lastUpdatedAt = new Date().toISOString()
-        this._writeManifest(manifest)
-        return true
+        resource.status = newStatus;
+        resource.lastUpdatedAt = new Date().toISOString();
+        this._writeManifest(manifest);
+        return true;
     }
 
     /**
@@ -267,8 +267,8 @@ export default class AssetManager {
      * @returns {Object|null} The matching Asset_Record, or null if not found
      */
     getResource(resourceId) {
-        const manifest = this._readManifest()
-        return manifest.resources.find(r => r.resourceId === resourceId) || null
+        const manifest = this._readManifest();
+        return manifest.resources.find(r => r.resourceId === resourceId) || null;
     }
 
     /**
@@ -278,18 +278,18 @@ export default class AssetManager {
      * @returns {boolean} true if the resource was found and removed, false otherwise
      */
     removeResource(resourceId) {
-        const manifest = this._readManifest()
-        const originalLength = manifest.resources.length
+        const manifest = this._readManifest();
+        const originalLength = manifest.resources.length;
         manifest.resources = manifest.resources.filter(
             r => r.resourceId !== resourceId
-        )
+        );
 
         if (manifest.resources.length === originalLength) {
-            return false
+            return false;
         }
 
-        this._writeManifest(manifest)
-        return true
+        this._writeManifest(manifest);
+        return true;
     }
 
     /**
@@ -302,24 +302,24 @@ export default class AssetManager {
      * @returns {Array<Object>} Matching Asset_Records
      */
     listResources(filters = {}) {
-        const manifest = this._readManifest()
+        const manifest = this._readManifest();
 
         if (!filters || Object.keys(filters).length === 0) {
-            return manifest.resources
+            return manifest.resources;
         }
 
         return manifest.resources.filter(resource => {
             if (filters.resourceType && resource.resourceType !== filters.resourceType) {
-                return false
+                return false;
             }
             if (filters.project && resource.project !== filters.project) {
-                return false
+                return false;
             }
             if (filters.status && resource.status !== filters.status) {
-                return false
+                return false;
             }
-            return true
-        })
+            return true;
+        });
     }
 
     /**
@@ -328,18 +328,18 @@ export default class AssetManager {
      * @returns {Map<string, Array<Object>>} Map of project name → Asset_Record array
      */
     getResourcesByProject() {
-        const manifest = this._readManifest()
-        const grouped = new Map()
+        const manifest = this._readManifest();
+        const grouped = new Map();
 
         for (const resource of manifest.resources) {
-            const project = resource.project
+            const project = resource.project;
             if (!grouped.has(project)) {
-                grouped.set(project, [])
+                grouped.set(project, []);
             }
-            grouped.get(project).push(resource)
+            grouped.get(project).push(resource);
         }
 
-        return grouped
+        return grouped;
     }
 
     /**
@@ -348,16 +348,16 @@ export default class AssetManager {
      * @returns {{ active: number, deleted: number, unknown: number }}
      */
     getStatusCounts() {
-        const manifest = this._readManifest()
-        const counts = { active: 0, deleted: 0, unknown: 0 }
+        const manifest = this._readManifest();
+        const counts = { active: 0, deleted: 0, unknown: 0 };
 
         for (const resource of manifest.resources) {
             if (resource.status in counts) {
-                counts[resource.status]++
+                counts[resource.status]++;
             }
         }
 
-        return counts
+        return counts;
     }
 }
 
@@ -374,12 +374,12 @@ export default class AssetManager {
  */
 function _isValidISO8601(str) {
     if (typeof str !== 'string' || str.length === 0) {
-        return false
+        return false;
     }
-    const date = new Date(str)
+    const date = new Date(str);
     if (isNaN(date.getTime())) {
-        return false
+        return false;
     }
     // Ensure the string looks like an ISO 8601 timestamp (not just any parseable date string)
-    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(str)
+    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/.test(str);
 }

package/src/lib/aws-profile-parser.js

@@ -15,9 +15,9 @@
  * - 'default' is always sorted first if present
  */
 
-import { readFileSync, existsSync } from 'node:fs'
-import { join } from 'node:path'
-import { homedir } from 'node:os'
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
 
 export default class AwsProfileParser {
     /**
@@ -26,8 +26,8 @@ export default class AwsProfileParser {
      * @param {string} [options.credentialsPath] - Override path to ~/.aws/credentials
      */
     constructor(options = {}) {
-        this._configPath = options.configPath || null
-        this._credentialsPath = options.credentialsPath || null
+        this._configPath = options.configPath || null;
+        this._credentialsPath = options.credentialsPath || null;
     }
 
     /**
@@ -37,18 +37,18 @@ export default class AwsProfileParser {
      * @returns {string[]} Profile names, with 'default' first if it exists
      */
     getProfiles() {
-        const configProfiles = this._getProfilesFromConfig()
-        const credentialsProfiles = this._getProfilesFromCredentials()
+        const configProfiles = this._getProfilesFromConfig();
+        const credentialsProfiles = this._getProfilesFromCredentials();
 
-        const allNames = new Set([...configProfiles, ...credentialsProfiles])
+        const allNames = new Set([...configProfiles, ...credentialsProfiles]);
 
         const sorted = [...allNames].sort((a, b) => {
-            if (a === 'default') return -1
-            if (b === 'default') return 1
-            return a.localeCompare(b)
-        })
+            if (a === 'default') return -1;
+            if (b === 'default') return 1;
+            return a.localeCompare(b);
+        });
 
-        return sorted
+        return sorted;
     }
 
     /**
@@ -58,52 +58,52 @@ export default class AwsProfileParser {
      * @returns {Map<string, Object>} Map of section names to parsed key-value pairs
      */
     _parseIniFile(filePath) {
-        const sections = new Map()
+        const sections = new Map();
 
         if (!existsSync(filePath)) {
-            return sections
+            return sections;
         }
 
-        let content
+        let content;
         try {
-            content = readFileSync(filePath, 'utf8')
+            content = readFileSync(filePath, 'utf8');
         } catch {
-            return sections
+            return sections;
         }
 
-        let currentSection = null
-        const lines = content.split(/\r?\n/)
+        let currentSection = null;
+        const lines = content.split(/\r?\n/);
 
         for (const rawLine of lines) {
-            const line = rawLine.trim()
+            const line = rawLine.trim();
 
             // Skip empty lines and comments
             if (!line || line.startsWith('#') || line.startsWith(';')) {
-                continue
+                continue;
             }
 
             // Check for section header
-            const sectionMatch = line.match(/^\[([^\]]+)\]$/)
+            const sectionMatch = line.match(/^\[([^\]]+)\]$/);
             if (sectionMatch) {
-                currentSection = sectionMatch[1].trim()
+                currentSection = sectionMatch[1].trim();
                 if (!sections.has(currentSection)) {
-                    sections.set(currentSection, {})
+                    sections.set(currentSection, {});
                 }
-                continue
+                continue;
             }
 
             // Parse key = value pairs
             if (currentSection) {
-                const kvMatch = line.match(/^([^=]+?)=(.*)$/)
+                const kvMatch = line.match(/^([^=]+?)=(.*)$/);
                 if (kvMatch) {
-                    const key = kvMatch[1].trim()
-                    const value = kvMatch[2].trim()
-                    sections.get(currentSection)[key] = value
+                    const key = kvMatch[1].trim();
+                    const value = kvMatch[2].trim();
+                    sections.get(currentSection)[key] = value;
                 }
             }
         }
 
-        return sections
+        return sections;
     }
 
     /**
@@ -115,26 +115,26 @@ export default class AwsProfileParser {
      * @returns {string[]} Array of profile names
      */
     _extractProfileNames(parsed, isConfig = false) {
-        const names = []
+        const names = [];
 
         for (const sectionName of parsed.keys()) {
             if (isConfig) {
                 // ~/.aws/config uses [profile name] except for [default]
                 if (sectionName === 'default') {
-                    names.push('default')
+                    names.push('default');
                 } else if (sectionName.startsWith('profile ')) {
-                    const name = sectionName.slice('profile '.length).trim()
+                    const name = sectionName.slice('profile '.length).trim();
                     if (name) {
-                        names.push(name)
+                        names.push(name);
                     }
                 }
             } else {
                 // ~/.aws/credentials uses [name] directly
-                names.push(sectionName)
+                names.push(sectionName);
             }
         }
 
-        return names
+        return names;
     }
 
     /**
@@ -143,7 +143,7 @@ export default class AwsProfileParser {
      * @returns {string} Absolute path to ~/.aws/config
      */
     _getConfigPath() {
-        return this._configPath || join(homedir(), '.aws', 'config')
+        return this._configPath || join(homedir(), '.aws', 'config');
     }
 
     /**
@@ -152,7 +152,7 @@ export default class AwsProfileParser {
      * @returns {string} Absolute path to ~/.aws/credentials
      */
     _getCredentialsPath() {
-        return this._credentialsPath || join(homedir(), '.aws', 'credentials')
+        return this._credentialsPath || join(homedir(), '.aws', 'credentials');
     }
 
     /**
@@ -162,9 +162,9 @@ export default class AwsProfileParser {
      * @private
      */
     _getProfilesFromConfig() {
-        const configPath = this._getConfigPath()
-        const parsed = this._parseIniFile(configPath)
-        return this._extractProfileNames(parsed, true)
+        const configPath = this._getConfigPath();
+        const parsed = this._parseIniFile(configPath);
+        return this._extractProfileNames(parsed, true);
     }
 
     /**
@@ -174,8 +174,8 @@ export default class AwsProfileParser {
      * @private
      */
     _getProfilesFromCredentials() {
-        const credentialsPath = this._getCredentialsPath()
-        const parsed = this._parseIniFile(credentialsPath)
-        return this._extractProfileNames(parsed, false)
+        const credentialsPath = this._getCredentialsPath();
+        const parsed = this._parseIniFile(credentialsPath);
+        return this._extractProfileNames(parsed, false);
     }
 }