@aws/ml-container-creator 0.2.1 → 0.2.2

package/bin/cli.js

@@ -2,35 +2,35 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { createRequire } from 'module'
-import path from 'path'
-import { program, Option, Help } from 'commander'
-import { run } from '../src/app.js'
+import { createRequire } from 'module';
+import path from 'path';
+import { program, Option, Help } from 'commander';
+import { run } from '../src/app.js';
 
-const require = createRequire(import.meta.url)
-const { version } = require('../package.json')
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
 
 /**
  * Collect repeatable options into an array.
  * Used for --model-env and --server-env which can be specified multiple times.
  */
 function collect(value, previous) {
-    return previous.concat([value])
+    return previous.concat([value]);
 }
 
 program
     .name('ml-container-creator')
     .version(version)
     .enablePositionalOptions()
-    .passThroughOptions()
     .helpCommand('help [command]', 'Display help for command')
-    .argument('[project-name]', 'Name for the generated project')
+    .argument('[project-name...]', 'Name for the generated project')
 
     // --- General ---
     .addOption(new Option('--skip-prompts', 'Skip interactive prompts and use configuration from other sources'))
     .addOption(new Option('--config <path>', 'Path to configuration file'))
     .addOption(new Option('--project-name <name>', 'Project name'))
     .addOption(new Option('--project-dir <dir>', 'Output directory path'))
+    .addOption(new Option('--force', 'Overwrite existing output directory without prompting'))
 
     // --- Model & Framework ---
     .addOption(new Option('--deployment-config <config>', 'Deployment configuration (e.g. http-flask, transformers-vllm, triton-fil)'))
@@ -104,7 +104,7 @@ program
     .addOption(new Option('--validate-with-docker', 'Enable Docker introspection validation (opt-in)'))
     .addOption(new Option('--offline', 'Disable HuggingFace API lookups'))
 
-    .action(run)
+    .action((projectNameArgs, options) => run(projectNameArgs?.[0] || null, options));
 
 // Custom help formatting — group options into logical sections (root command only)
 program.configureHelp({
@@ -112,28 +112,28 @@ program.configureHelp({
         // Only apply custom grouping to the root command
         if (cmd !== program) {
             // Fall back to default Commander formatting for subcommands
-            return Help.prototype.formatHelp.call(this, cmd, helper)
+            return Help.prototype.formatHelp.call(this, cmd, helper);
         }
 
-        const termWidth = helper.padWidth(cmd, helper)
+        const termWidth = helper.padWidth(cmd, helper);
 
         function callFormatItem(term, description) {
-            return helper.formatItem(term, termWidth, description, helper)
+            return helper.formatItem(term, termWidth, description, helper);
         }
 
         function formatSection(title, options) {
-            if (options.length === 0) return []
+            if (options.length === 0) return [];
             const lines = options.map(opt => {
                 return callFormatItem(
                     helper.styleOptionTerm(helper.optionTerm(opt)),
                     helper.styleOptionDescription(helper.optionDescription(opt))
-                )
-            })
-            return [helper.styleTitle(`${title}:`), ...lines, '']
+                );
+            });
+            return [helper.styleTitle(`${title}:`), ...lines, ''];
         }
 
         // Collect all visible options
-        const allOptions = helper.visibleOptions(cmd)
+        const allOptions = helper.visibleOptions(cmd);
 
         // Partition options into groups by flag prefix/purpose
         const groups = {
@@ -150,38 +150,38 @@ program.configureHelp({
             features: [],
             mcp: [],
             validation: []
-        }
+        };
 
         for (const opt of allOptions) {
-            const long = opt.long || ''
-            if (['--skip-prompts', '--config', '--project-name', '--project-dir', '--version', '--help'].includes(long)) {
-                groups.general.push(opt)
+            const long = opt.long || '';
+            if (['--skip-prompts', '--config', '--project-name', '--project-dir', '--force', '--version', '--help'].includes(long)) {
+                groups.general.push(opt);
             } else if (['--deployment-config', '--framework', '--model-format', '--model-name', '--model-server', '--base-image'].includes(long)) {
-                groups.model.push(opt)
+                groups.model.push(opt);
             } else if (['--deployment-target', '--instance-type', '--region', '--role-arn', '--build-target', '--codebuild-compute-type'].includes(long)) {
-                groups.infra.push(opt)
+                groups.infra.push(opt);
             } else if (long.startsWith('--endpoint-')) {
-                groups.endpoint.push(opt)
+                groups.endpoint.push(opt);
             } else if (long.startsWith('--ic-')) {
-                groups.ic.push(opt)
+                groups.ic.push(opt);
             } else if (long.startsWith('--async-')) {
-                groups.async.push(opt)
+                groups.async.push(opt);
             } else if (long.startsWith('--batch-')) {
-                groups.batch.push(opt)
+                groups.batch.push(opt);
             } else if (long.startsWith('--hyperpod-') || long === '--fsx-volume-handle') {
-                groups.hyperpod.push(opt)
+                groups.hyperpod.push(opt);
             } else if (['--model-env', '--server-env'].includes(long)) {
-                groups.env.push(opt)
+                groups.env.push(opt);
             } else if (['--hf-token'].includes(long)) {
-                groups.auth.push(opt)
+                groups.auth.push(opt);
             } else if (['--include-sample', '--include-testing', '--test-types'].includes(long)) {
-                groups.features.push(opt)
+                groups.features.push(opt);
             } else if (['--smart', '--discover'].includes(long)) {
-                groups.mcp.push(opt)
+                groups.mcp.push(opt);
             } else if (['--validate-env-vars', '--validate-with-docker', '--offline'].includes(long)) {
-                groups.validation.push(opt)
+                groups.validation.push(opt);
             } else {
-                groups.general.push(opt)
+                groups.general.push(opt);
             }
         }
 
@@ -189,56 +189,57 @@ program.configureHelp({
         let output = [
             `${helper.styleTitle('Usage:')} ${helper.styleUsage(helper.commandUsage(cmd))}`,
             ''
-        ]
+        ];
 
         // Arguments
-        const args = helper.visibleArguments(cmd)
+        const args = helper.visibleArguments(cmd);
         if (args.length > 0) {
             const argList = args.map(arg => {
                 return callFormatItem(
                     helper.styleArgumentTerm(helper.argumentTerm(arg)),
                     helper.styleArgumentDescription(helper.argumentDescription(arg))
-                )
-            })
-            output = output.concat([helper.styleTitle('Arguments:'), ...argList, ''])
+                );
+            });
+            output = output.concat([helper.styleTitle('Arguments:'), ...argList, '']);
         }
 
         // Option sections
-        output = output.concat(formatSection('General', groups.general))
-        output = output.concat(formatSection('Model & Framework', groups.model))
-        output = output.concat(formatSection('Build & Infrastructure', groups.infra))
-        output = output.concat(formatSection('Endpoint (Real-Time Inference)', groups.endpoint))
-        output = output.concat(formatSection('Inference Component', groups.ic))
-        output = output.concat(formatSection('Async Inference', groups.async))
-        output = output.concat(formatSection('Batch Transform', groups.batch))
-        output = output.concat(formatSection('HyperPod (EKS)', groups.hyperpod))
-        output = output.concat(formatSection('Environment Variables', groups.env))
-        output = output.concat(formatSection('Authentication', groups.auth))
-        output = output.concat(formatSection('Optional Features', groups.features))
-        output = output.concat(formatSection('MCP & Discovery', groups.mcp))
-        output = output.concat(formatSection('Validation', groups.validation))
+        output = output.concat(formatSection('General', groups.general));
+        output = output.concat(formatSection('Model & Framework', groups.model));
+        output = output.concat(formatSection('Build & Infrastructure', groups.infra));
+        output = output.concat(formatSection('Endpoint (Real-Time Inference)', groups.endpoint));
+        output = output.concat(formatSection('Inference Component', groups.ic));
+        output = output.concat(formatSection('Async Inference', groups.async));
+        output = output.concat(formatSection('Batch Transform', groups.batch));
+        output = output.concat(formatSection('HyperPod (EKS)', groups.hyperpod));
+        output = output.concat(formatSection('Environment Variables', groups.env));
+        output = output.concat(formatSection('Authentication', groups.auth));
+        output = output.concat(formatSection('Optional Features', groups.features));
+        output = output.concat(formatSection('MCP & Discovery', groups.mcp));
+        output = output.concat(formatSection('Validation', groups.validation));
 
         // Commands
-        const cmds = helper.visibleCommands(cmd)
+        const cmds = helper.visibleCommands(cmd);
         if (cmds.length > 0) {
             const cmdList = cmds.map(sub => {
                 return callFormatItem(
                     helper.styleSubcommandTerm(helper.subcommandTerm(sub)),
                     helper.styleSubcommandDescription(helper.subcommandDescription(sub))
-                )
-            })
-            output = output.concat([helper.styleTitle('Commands:'), ...cmdList, ''])
+                );
+            });
+            output = output.concat([helper.styleTitle('Commands:'), ...cmdList, '']);
         }
 
-        return output.join('\n')
+        return output.join('\n');
     }
-})
+});
 
 // Sub-commands — wired to actual handlers
 
 program
     .command('bootstrap')
     .description('Set up AWS infrastructure (IAM role, ECR repo, S3 buckets)')
+    .passThroughOptions()
     .argument('[action]', 'Bootstrap action (status, use, list, remove, scan, prune, update)')
     .argument('[args...]', 'Additional arguments')
     .option('--profile <profile>', 'AWS profile name')
@@ -249,15 +250,16 @@ program
     .option('--verify', 'Verify resources exist (for status)')
     .option('--delete-stack', 'Delete CloudFormation stack on remove')
     .action(async (action, args, options) => {
-        const { default: BootstrapCommandHandler } = await import('../src/lib/bootstrap-command-handler.js')
-        const handler = new BootstrapCommandHandler()
-        const allArgs = action ? [action, ...args] : []
-        await handler.handle(allArgs, options)
-    })
+        const { default: BootstrapCommandHandler } = await import('../src/lib/bootstrap-command-handler.js');
+        const handler = new BootstrapCommandHandler();
+        const allArgs = action ? [action, ...args] : [];
+        await handler.handle(allArgs, options);
+    });
 
 program
     .command('mcp')
     .description('Manage MCP servers (add, list, get, remove, init)')
+    .passThroughOptions()
     .argument('<action>', 'MCP action (add, list, get, remove, init)')
     .argument('[args...]', 'Additional arguments')
     .option('-e <env>', 'Environment variable in KEY=VALUE format (for add)')
@@ -265,25 +267,26 @@ program
     .option('--limit <n>', 'Result limit for MCP server (for add)')
     .option('--bundled', 'Use a bundled server from servers/ directory')
     .action(async (action, args, options) => {
-        const { default: McpCommandHandler } = await import('../src/lib/mcp-command-handler.js')
-        const { runPrompts } = await import('../src/prompt-adapter.js')
+        const { default: McpCommandHandler } = await import('../src/lib/mcp-command-handler.js');
+        const { runPrompts } = await import('../src/prompt-adapter.js');
         // McpCommandHandler expects a generator-like object with destinationPath() and prompt()
         const generatorAdapter = {
             destinationPath(...segments) {
-                if (segments.length === 0) return process.cwd()
-                return path.join(process.cwd(), ...segments)
+                if (segments.length === 0) return process.cwd();
+                return path.join(process.cwd(), ...segments);
             },
             async prompt(prompts) {
-                return runPrompts(prompts)
+                return runPrompts(prompts);
             }
-        }
-        const handler = new McpCommandHandler(generatorAdapter)
-        await handler.handle([action, ...args], options)
-    })
+        };
+        const handler = new McpCommandHandler(generatorAdapter);
+        await handler.handle([action, ...args], options);
+    });
 
 program
     .command('registry')
     .description('Registry operations (list, get, remove, replay, export, import, search) — experimental, may be reconciled with do/register')
+    .passThroughOptions()
     .argument('<action>', 'Registry action (log, list, get, remove, replay, export, import, search)')
     .argument('[args...]', 'Additional arguments')
     .option('--backend <backend>', 'Filter by backend')
@@ -306,20 +309,19 @@ program
     .option('--parameters <json>', 'Parameters JSON string')
     .option('--generator-version <version>', 'Generator version')
     .action(async (action, args, options) => {
-        const { default: RegistryCommandHandler } = await import('../src/lib/registry-command-handler.js')
-        const handler = new RegistryCommandHandler()
-        await handler.handle([action, ...args], options)
-    })
+        const { default: RegistryCommandHandler } = await import('../src/lib/registry-command-handler.js');
+        const handler = new RegistryCommandHandler();
+        await handler.handle([action, ...args], options);
+    });
 
 program
     .command('configure')
     .description('Interactive configuration setup (experimental)')
     .action(async () => {
-        const { runPrompts } = await import('../src/prompt-adapter.js')
-        const { default: ConfigurationExporter } = await import('../src/lib/configuration-exporter.js')
+        const { runPrompts } = await import('../src/prompt-adapter.js');
 
-        console.log('\n🔧 ML Container Creator Configuration (experimental)')
-        console.log('\nThis will help you set up configuration files for your project.\n')
+        console.log('\n🔧 ML Container Creator Configuration (experimental)');
+        console.log('\nThis will help you set up configuration files for your project.\n');
 
         const answers = await runPrompts([
             {
@@ -331,7 +333,7 @@ program
                     { name: 'Show environment variable examples', value: 'env' }
                 ]
             }
-        ])
+        ]);
 
         if (answers.configType === 'cli') {
             console.log(`
@@ -347,7 +349,7 @@ program
 
   # Using a config file
   ml-container-creator --config=my-config.json --skip-prompts
-`)
+`);
         } else if (answers.configType === 'env') {
             console.log(`
 🌍 Environment Variables:
@@ -358,8 +360,8 @@ program
   export HF_TOKEN="hf_..."
 
   Then run: ml-container-creator --deployment-config=http-flask --skip-prompts
-`)
+`);
         }
-    })
+    });
 
-program.parse()
+program.parse();

package/config/bootstrap-stack.json

@@ -0,0 +1,211 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "ML Container Creator — shared bootstrap infrastructure (IAM role, ECR repository, optional S3 buckets). Re-run bootstrap to apply updates from new versions.",
+
+  "Parameters": {
+    "CreateS3Buckets": {
+      "Type": "String",
+      "Default": "false",
+      "AllowedValues": ["true", "false"],
+      "Description": "Whether to create S3 buckets for async inference and batch transform"
+    },
+    "UseExistingRoleArn": {
+      "Type": "String",
+      "Default": "",
+      "Description": "ARN of an existing IAM role to use instead of creating one. Leave empty to create a new role."
+    }
+  },
+
+  "Conditions": {
+    "ShouldCreateS3Buckets": { "Fn::Equals": [{ "Ref": "CreateS3Buckets" }, "true"] },
+    "ShouldCreateRole": { "Fn::Equals": [{ "Ref": "UseExistingRoleArn" }, ""] }
+  },
+
+  "Resources": {
+    "SageMakerExecutionRole": {
+      "Type": "AWS::IAM::Role",
+      "Condition": "ShouldCreateRole",
+      "Properties": {
+        "RoleName": "mlcc-sagemaker-execution-role",
+        "AssumeRolePolicyDocument": {
+          "Version": "2012-10-17",
+          "Statement": [
+            {
+              "Effect": "Allow",
+              "Principal": { "Service": "sagemaker.amazonaws.com" },
+              "Action": "sts:AssumeRole"
+            }
+          ]
+        },
+        "Policies": [
+          {
+            "PolicyName": "mlcc-execution-policy",
+            "PolicyDocument": {
+              "Version": "2012-10-17",
+              "Statement": [
+                {
+                  "Sid": "SageMakerEndpoints",
+                  "Effect": "Allow",
+                  "Action": [
+                    "sagemaker:CreateEndpoint",
+                    "sagemaker:CreateEndpointConfig",
+                    "sagemaker:CreateModel",
+                    "sagemaker:CreateInferenceComponent",
+                    "sagemaker:UpdateEndpoint",
+                    "sagemaker:UpdateEndpointWeightsAndCapacities",
+                    "sagemaker:UpdateInferenceComponent",
+                    "sagemaker:DeleteEndpoint",
+                    "sagemaker:DeleteEndpointConfig",
+                    "sagemaker:DeleteModel",
+                    "sagemaker:DeleteInferenceComponent",
+                    "sagemaker:DescribeEndpoint",
+                    "sagemaker:DescribeEndpointConfig",
+                    "sagemaker:DescribeModel",
+                    "sagemaker:DescribeInferenceComponent",
+                    "sagemaker:InvokeEndpoint",
+                    "sagemaker:InvokeEndpointAsync"
+                  ],
+                  "Resource": "*"
+                },
+                {
+                  "Sid": "ECRPull",
+                  "Effect": "Allow",
+                  "Action": [
+                    "ecr:GetAuthorizationToken",
+                    "ecr:BatchCheckLayerAvailability",
+                    "ecr:GetDownloadUrlForLayer",
+                    "ecr:BatchGetImage"
+                  ],
+                  "Resource": { "Fn::Sub": "arn:aws:ecr:*:${AWS::AccountId}:repository/ml-container-creator" }
+                },
+                {
+                  "Sid": "ECRAuth",
+                  "Effect": "Allow",
+                  "Action": "ecr:GetAuthorizationToken",
+                  "Resource": "*"
+                },
+                {
+                  "Sid": "CloudWatchLogs",
+                  "Effect": "Allow",
+                  "Action": [
+                    "logs:CreateLogGroup",
+                    "logs:CreateLogStream",
+                    "logs:PutLogEvents"
+                  ],
+                  "Resource": "arn:aws:logs:*:*:*"
+                },
+                {
+                  "Sid": "S3ModelRead",
+                  "Effect": "Allow",
+                  "Action": [
+                    "s3:GetObject",
+                    "s3:ListBucket"
+                  ],
+                  "Resource": [
+                    "arn:aws:s3:::ml-container-creator-*",
+                    "arn:aws:s3:::ml-container-creator-*/*"
+                  ]
+                }
+              ]
+            }
+          }
+        ],
+        "Tags": [
+          { "Key": "mlcc:managed-by", "Value": "ml-container-creator" },
+          { "Key": "mlcc:created-by", "Value": "bootstrap" }
+        ]
+      }
+    },
+
+    "EcrRepository": {
+      "Type": "AWS::ECR::Repository",
+      "Properties": {
+        "RepositoryName": "ml-container-creator",
+        "ImageScanningConfiguration": { "ScanOnPush": true },
+        "EncryptionConfiguration": { "EncryptionType": "AES256" },
+        "LifecyclePolicy": {
+          "LifecyclePolicyText": "{\"rules\":[{\"rulePriority\":1,\"description\":\"Expire untagged images after 30 days\",\"selection\":{\"tagStatus\":\"untagged\",\"countType\":\"sinceImagePushed\",\"countUnit\":\"days\",\"countNumber\":30},\"action\":{\"type\":\"expire\"}}]}"
+        },
+        "Tags": [
+          { "Key": "mlcc:managed-by", "Value": "ml-container-creator" },
+          { "Key": "mlcc:created-by", "Value": "bootstrap" }
+        ]
+      }
+    },
+
+    "AsyncS3Bucket": {
+      "Type": "AWS::S3::Bucket",
+      "Condition": "ShouldCreateS3Buckets",
+      "DeletionPolicy": "Retain",
+      "UpdateReplacePolicy": "Retain",
+      "Properties": {
+        "BucketName": { "Fn::Sub": "${AWS::AccountId}-${AWS::Region}-ml-container-creator-async" },
+        "VersioningConfiguration": { "Status": "Enabled" },
+        "BucketEncryption": {
+          "ServerSideEncryptionConfiguration": [
+            { "ServerSideEncryptionByDefault": { "SSEAlgorithm": "AES256" } }
+          ]
+        },
+        "Tags": [
+          { "Key": "mlcc:managed-by", "Value": "ml-container-creator" },
+          { "Key": "mlcc:created-by", "Value": "bootstrap" }
+        ]
+      }
+    },
+
+    "BatchS3Bucket": {
+      "Type": "AWS::S3::Bucket",
+      "Condition": "ShouldCreateS3Buckets",
+      "DeletionPolicy": "Retain",
+      "UpdateReplacePolicy": "Retain",
+      "Properties": {
+        "BucketName": { "Fn::Sub": "${AWS::AccountId}-${AWS::Region}-ml-container-creator-batch" },
+        "VersioningConfiguration": { "Status": "Enabled" },
+        "BucketEncryption": {
+          "ServerSideEncryptionConfiguration": [
+            { "ServerSideEncryptionByDefault": { "SSEAlgorithm": "AES256" } }
+          ]
+        },
+        "Tags": [
+          { "Key": "mlcc:managed-by", "Value": "ml-container-creator" },
+          { "Key": "mlcc:created-by", "Value": "bootstrap" }
+        ]
+      }
+    }
+  },
+
+  "Outputs": {
+    "RoleArn": {
+      "Description": "SageMaker execution role ARN",
+      "Value": {
+        "Fn::If": [
+          "ShouldCreateRole",
+          { "Fn::GetAtt": ["SageMakerExecutionRole", "Arn"] },
+          { "Ref": "UseExistingRoleArn" }
+        ]
+      }
+    },
+    "EcrRepositoryName": {
+      "Description": "ECR repository name",
+      "Value": { "Ref": "EcrRepository" }
+    },
+    "EcrRepositoryUri": {
+      "Description": "ECR repository URI",
+      "Value": { "Fn::GetAtt": ["EcrRepository", "RepositoryUri"] }
+    },
+    "AsyncS3BucketName": {
+      "Condition": "ShouldCreateS3Buckets",
+      "Description": "S3 bucket for async inference output",
+      "Value": { "Ref": "AsyncS3Bucket" }
+    },
+    "BatchS3BucketName": {
+      "Condition": "ShouldCreateS3Buckets",
+      "Description": "S3 bucket for batch transform I/O",
+      "Value": { "Ref": "BatchS3Bucket" }
+    },
+    "StackVersion": {
+      "Description": "Bootstrap stack template version for forward compatibility tracking",
+      "Value": "2026-05-04"
+    }
+  }
+}

package/config/parameter-schema.json

@@ -0,0 +1,88 @@
+{
+    "schemaVersion": "1.0.0",
+    "deploymentTargets": {
+        "managed-inference": {
+            "endpoint": {
+                "initialInstanceCount": {
+                    "type": "integer",
+                    "min": 1,
+                    "max": 100,
+                    "default": 1,
+                    "description": "Number of instances for the endpoint",
+                    "apiReference": "CreateEndpointConfig.ProductionVariants.InitialInstanceCount"
+                },
+                "dataCapturePercent": {
+                    "type": "integer",
+                    "min": 0,
+                    "max": 100,
+                    "default": 0,
+                    "description": "Percentage of requests to capture",
+                    "apiReference": "CreateEndpointConfig.DataCaptureConfig.InitialSamplingPercentage"
+                },
+                "variantName": {
+                    "type": "string",
+                    "pattern": "^[a-zA-Z0-9]([\\w-]{0,62}[a-zA-Z0-9])?$",
+                    "default": "AllTraffic",
+                    "description": "Name of the production variant",
+                    "apiReference": "CreateEndpointConfig.ProductionVariants.VariantName"
+                },
+                "volumeSize": {
+                    "type": "integer",
+                    "min": 1,
+                    "max": 16384,
+                    "default": null,
+                    "description": "Size of the ML storage volume in GB",
+                    "apiReference": "CreateEndpointConfig.ProductionVariants.VolumeSizeInGB"
+                }
+            },
+            "inferenceComponent": {
+                "cpuCount": {
+                    "type": "number",
+                    "min": 0.25,
+                    "max": 768,
+                    "default": null,
+                    "description": "Number of vCPUs allocated",
+                    "apiReference": "CreateInferenceComponent.Specification.ComputeResourceRequirements.NumberOfCpuCoresRequired"
+                },
+                "memorySize": {
+                    "type": "integer",
+                    "min": 128,
+                    "max": 3145728,
+                    "default": null,
+                    "description": "Memory allocation in MB",
+                    "apiReference": "CreateInferenceComponent.Specification.ComputeResourceRequirements.MinMemoryRequiredInMb"
+                },
+                "gpuCount": {
+                    "type": "integer",
+                    "min": 0,
+                    "max": 8,
+                    "default": null,
+                    "description": "Number of GPUs allocated",
+                    "apiReference": "CreateInferenceComponent.Specification.ComputeResourceRequirements.NumberOfAcceleratorDevicesRequired"
+                },
+                "copyCount": {
+                    "type": "integer",
+                    "min": 0,
+                    "max": 100,
+                    "default": 1,
+                    "description": "Number of inference component copies",
+                    "apiReference": "CreateInferenceComponent.RuntimeConfig.CopyCount"
+                },
+                "modelWeight": {
+                    "type": "number",
+                    "min": 0,
+                    "max": 1,
+                    "default": 1.0,
+                    "description": "Traffic routing weight for the model",
+                    "apiReference": "UpdateEndpointWeightsAndCapacities.DesiredWeightsAndCapacities.DesiredWeight"
+                }
+            }
+        },
+        "eks": {},
+        "async": {},
+        "batch": {}
+    },
+    "extensionPoints": {
+        "engines": {}
+    }
+}

package/infra/ci-harness/bin/ci-harness.ts

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import 'source-map-support/register';
+import * as cdk from 'aws-cdk-lib';
+import { MlccCiHarnessStack } from '../lib/ci-harness-stack';
+
+const app = new cdk.App();
+
+// Region and account can be configured via:
+// 1. CDK context: -c region=us-east-1 -c account=123456789012
+// 2. Environment variables: CDK_DEFAULT_REGION, CDK_DEFAULT_ACCOUNT
+// 3. AWS CLI profile (automatic via CDK)
+const region = app.node.tryGetContext('region')
+    || process.env.CDK_DEFAULT_REGION
+    || process.env.AWS_REGION;
+
+const account = app.node.tryGetContext('account')
+    || process.env.CDK_DEFAULT_ACCOUNT
+    || process.env.AWS_ACCOUNT_ID;
+
+new MlccCiHarnessStack(app, 'MlccCiHarnessStack', {
+    env: {
+        region,
+        account,
+    },
+    description: 'ML Container Creator CI Integration Harness - automated lifecycle testing infrastructure',
+});