konokenj.cdk-api-mcp-server 0.57.0__py3-none-any.whl → 0.58.0__py3-none-any.whl

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/aws-imagebuilder-alpha/README.md

@@ -36,6 +36,202 @@ EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketpl
 that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
 test phase during the test stage.
 
+### Image Recipe
+
+#### Image Recipe Basic Usage
+
+Create an image recipe with the required base image:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'MyImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  )
+});
+```
+
+#### Image Recipe Base Images
+
+To create a recipe, you have to select a base image to build and customize from. This base image can be referenced from
+various sources, such as from SSM parameters, AWS Marketplace products, and AMI IDs directly.
+
+##### SSM Parameters
+
+Using SSM parameter references:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'SsmImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  )
+});
+
+// Using an SSM parameter construct
+const parameter = ssm.StringParameter.fromStringParameterName(
+  this,
+  'BaseImageParameter',
+  '/aws/service/ami-windows-latest/Windows_Server-2022-English-Full-Base'
+);
+const windowsRecipe = new imagebuilder.ImageRecipe(this, 'WindowsImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameter(parameter)
+});
+```
+
+##### AMI IDs
+
+When you have a specific AMI to use:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'AmiImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromAmiId('ami-12345678')
+});
+```
+
+##### Marketplace Images
+
+For marketplace base images:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'MarketplaceImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromMarketplaceProductId('prod-1234567890abcdef0')
+});
+```
+
+#### Image Recipe Components
+
+Components from various sources, such as custom-owned, AWS-owned, or AWS Marketplace-owned, can optionally be included
+in recipes. For parameterized components, you are able to provide the parameters to use in the recipe, which will be
+applied during the image build when executing components.
+
+##### Custom Components in Image Recipes
+
+Add your own components to the recipe:
+
+```ts
+const customComponent = new imagebuilder.Component(this, 'MyComponent', {
+  platform: imagebuilder.Platform.LINUX,
+  data: imagebuilder.ComponentData.fromJsonObject({
+    schemaVersion: imagebuilder.ComponentSchemaVersion.V1_0,
+    phases: [
+      {
+        name: imagebuilder.ComponentPhaseName.BUILD,
+        steps: [
+          {
+            name: 'install-app',
+            action: imagebuilder.ComponentAction.EXECUTE_BASH,
+            inputs: {
+              commands: ['yum install -y my-application']
+            }
+          }
+        ]
+      }
+    ]
+  })
+});
+
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'ComponentImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  components: [
+    {
+      component: customComponent
+    }
+  ]
+});
+```
+
+##### AWS-Managed Components in Image Recipes
+
+Use pre-built AWS components:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'AwsManagedImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  components: [
+    {
+      component: imagebuilder.AwsManagedComponent.updateOS(this, 'UpdateOS', {
+        platform: imagebuilder.Platform.LINUX
+      })
+    },
+    {
+      component: imagebuilder.AwsManagedComponent.awsCliV2(this, 'AwsCli', {
+        platform: imagebuilder.Platform.LINUX
+      })
+    }
+  ]
+});
+```
+
+##### Component Parameters in Image Recipes
+
+Pass parameters to components that accept them:
+
+```ts
+const parameterizedComponent = imagebuilder.Component.fromComponentName(
+  this,
+  'ParameterizedComponent',
+  'my-parameterized-component'
+);
+
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'ParameterizedImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  components: [
+    {
+      component: parameterizedComponent,
+      parameters: {
+        environment: imagebuilder.ComponentParameterValue.fromString('production'),
+        version: imagebuilder.ComponentParameterValue.fromString('1.0.0')
+      }
+    }
+  ]
+});
+```
+
+#### Image Recipe Configuration
+
+##### Block Device Configuration
+
+Configure storage for the build instance:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'BlockDeviceImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  blockDevices: [
+    {
+      deviceName: '/dev/sda1',
+      volume: ec2.BlockDeviceVolume.ebs(100, {
+        encrypted: true,
+        volumeType: ec2.EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3
+      })
+    }
+  ]
+});
+```
+
+##### AMI Tagging
+
+Tag the output AMI:
+
+```ts
+const imageRecipe = new imagebuilder.ImageRecipe(this, 'TaggedImageRecipe', {
+  baseImage: imagebuilder.BaseImage.fromSsmParameterName(
+    '/aws/service/ami-amazon-linux-latest/al2023-ami-minimal-kernel-default-x86_64'
+  ),
+  amiTags: {
+    Environment: 'Production',
+    Application: 'WebServer',
+    Owner: 'DevOps Team'
+  }
+});
+```
+
 ### Container Recipe
 
 A container recipe is similar to an image recipe but specifically for container images. It defines the base container
@@ -222,7 +418,7 @@ EC2 Image Builder supports AWS-managed components for common tasks, AWS Marketpl
 that you create. Components run during specific workflow phases: build and validate phases during the build stage, and
 test phase during the test stage.
 
-#### Basic Usage
+#### Basic Component Usage
 
 Create a component with the required properties: platform and component data.
 
@@ -407,13 +603,13 @@ const component = new imagebuilder.Component(this, 'EncryptedComponent', {
             name: 'secure-setup',
             action: imagebuilder.ComponentAction.EXECUTE_BASH,
             inputs: {
-              commands: ['echo "This component data is encrypted with KMS"'],
-            },
-          },
-        ],
-      },
-    ],
-  }),
+              commands: ['echo "This component data is encrypted with KMS"']
+            }
+          }
+        ]
+      }
+    ]
+  })
 });
 ```
 
@@ -654,3 +850,227 @@ containerDistributionConfiguration.addContainerDistributions({
   containerTags: ['latest', 'latest-1.0']
 });
 ```
+
+### Workflow
+
+Workflows define the sequence of steps that Image Builder performs during image creation. There are three workflow types: BUILD (image building), TEST (testing images), and DISTRIBUTION (distributing container images).
+
+#### Basic Workflow Usage
+
+Create a workflow with the required properties: workflow type and workflow data.
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'MyWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromJsonObject({
+    schemaVersion: imagebuilder.WorkflowSchemaVersion.V1_0,
+    steps: [
+      {
+        name: 'LaunchBuildInstance',
+        action: imagebuilder.WorkflowAction.LAUNCH_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          waitFor: 'ssmAgent',
+        },
+      },
+      {
+        name: 'ExecuteComponents',
+        action: imagebuilder.WorkflowAction.EXECUTE_COMPONENTS,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+      {
+        name: 'CreateImage',
+        action: imagebuilder.WorkflowAction.CREATE_IMAGE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+      {
+        name: 'TerminateInstance',
+        action: imagebuilder.WorkflowAction.TERMINATE_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.CONTINUE,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+    ],
+    outputs: [
+      {
+        name: 'ImageId',
+        value: '$.stepOutputs.CreateImage.imageId',
+      },
+    ],
+  }),
+});
+```
+
+#### Workflow Data Sources
+
+##### Inline Workflow Data
+
+Use `WorkflowData.fromInline()` for existing YAML/JSON definitions:
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'InlineWorkflow', {
+  workflowType: imagebuilder.WorkflowType.TEST,
+  data: imagebuilder.WorkflowData.fromInline(`
+schemaVersion: 1.0
+steps:
+  - name: LaunchTestInstance
+    action: LaunchInstance
+    onFailure: Abort
+    inputs:
+      waitFor: ssmAgent
+  - name: RunTests
+    action: RunCommand
+    onFailure: Abort
+    inputs:
+      instanceId.$: "$.stepOutputs.LaunchTestInstance.instanceId"
+      commands: ['./run-tests.sh']
+  - name: TerminateTestInstance
+    action: TerminateInstance
+    onFailure: Continue
+    inputs:
+      instanceId.$: "$.stepOutputs.LaunchTestInstance.instanceId"
+`),
+});
+```
+
+##### JSON Object Workflow Data
+
+Most developer-friendly approach using JavaScript objects:
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'JsonWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromJsonObject({
+    schemaVersion: imagebuilder.WorkflowSchemaVersion.V1_0,
+    steps: [
+      {
+        name: 'LaunchBuildInstance',
+        action: imagebuilder.WorkflowAction.LAUNCH_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          waitFor: 'ssmAgent'
+        }
+      },
+      {
+        name: 'ExecuteComponents',
+        action: imagebuilder.WorkflowAction.EXECUTE_COMPONENTS,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123'
+        }
+      },
+      {
+        name: 'CreateImage',
+        action: imagebuilder.WorkflowAction.CREATE_IMAGE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123'
+        }
+      },
+      {
+        name: 'TerminateInstance',
+        action: imagebuilder.WorkflowAction.TERMINATE_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.CONTINUE,
+        inputs: {
+          'instanceId': 'i-123'
+        }
+      }
+    ],
+    outputs: [
+      {
+        name: 'ImageId',
+        value: '$.stepOutputs.CreateImage.imageId'
+      }
+    ]
+  })
+});
+```
+
+##### S3 Workflow Data
+
+For those workflows you want to upload or have uploaded to S3:
+
+```ts
+// Upload a local file
+const workflowFromAsset = new imagebuilder.Workflow(this, 'AssetWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromAsset(this, 'WorkflowAsset', './my-workflow.yml'),
+});
+
+// Reference an existing S3 object
+const bucket = s3.Bucket.fromBucketName(this, 'WorkflowBucket', 'my-workflows-bucket');
+const workflowFromS3 = new imagebuilder.Workflow(this, 'S3Workflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  data: imagebuilder.WorkflowData.fromS3(bucket, 'workflows/my-workflow.yml'),
+});
+```
+
+#### Encrypt workflow data with a KMS key
+
+You can encrypt workflow data with a KMS key, so that only principals with access to decrypt with the key are able to access the workflow data.
+
+```ts
+const workflow = new imagebuilder.Workflow(this, 'EncryptedWorkflow', {
+  workflowType: imagebuilder.WorkflowType.BUILD,
+  kmsKey: new kms.Key(this, 'WorkflowKey'),
+  data: imagebuilder.WorkflowData.fromJsonObject({
+    schemaVersion: imagebuilder.WorkflowSchemaVersion.V1_0,
+    steps: [
+      {
+        name: 'LaunchBuildInstance',
+        action: imagebuilder.WorkflowAction.LAUNCH_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          waitFor: 'ssmAgent',
+        },
+      },
+      {
+        name: 'CreateImage',
+        action: imagebuilder.WorkflowAction.CREATE_IMAGE,
+        onFailure: imagebuilder.WorkflowOnFailure.ABORT,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+      {
+        name: 'TerminateInstance',
+        action: imagebuilder.WorkflowAction.TERMINATE_INSTANCE,
+        onFailure: imagebuilder.WorkflowOnFailure.CONTINUE,
+        inputs: {
+          'instanceId': 'i-123',
+        },
+      },
+    ],
+    outputs: [
+      {
+        name: 'ImageId',
+        value: '$.stepOutputs.CreateImage.imageId',
+      },
+    ],
+  }),
+});
+```
+
+#### AWS-Managed Workflows
+
+AWS provides a collection of workflows for common scenarios:
+
+```ts
+// Build workflows
+const buildImageWorkflow = imagebuilder.AwsManagedWorkflow.buildImage(this, 'BuildImage');
+const buildContainerWorkflow = imagebuilder.AwsManagedWorkflow.buildContainer(this, 'BuildContainer');
+
+// Test workflows  
+const testImageWorkflow = imagebuilder.AwsManagedWorkflow.testImage(this, 'TestImage');
+const testContainerWorkflow = imagebuilder.AwsManagedWorkflow.testContainer(this, 'TestContainer');
+
+// Distribution workflows
+const distributeContainerWorkflow = imagebuilder.AwsManagedWorkflow.distributeContainer(this, 'DistributeContainer');
+```

cdk_api_mcp_server/resources/aws-cdk/constructs/@aws-cdk/mixins-preview/README.md

@@ -55,11 +55,11 @@ The `.with()` method is available after importing `@aws-cdk/mixins-preview/with`
 
 ## Creating Custom Mixins
 
-Mixins are simple classes that implement the `IMixin` interface:
+Mixins are simple classes that implement the `IMixin` interface (usually by extending the abstract `Mixin` class:
 
 ```typescript
 // Simple mixin that enables versioning
-class CustomVersioningMixin implements IMixin {
+class CustomVersioningMixin extends Mixin implements IMixin {
   supports(construct: any): boolean {
     return construct instanceof s3.CfnBucket;
   }
@@ -131,7 +131,7 @@ For every CloudFormation resource, CDK Mixins automatically generates type-safe
 
 ```typescript
 import '@aws-cdk/mixins-preview/with';
-import { CfnBucketPropsMixin } from '@aws-cdk/mixins-preview/aws-s3/mixins';
+
 
 const bucket = new s3.Bucket(scope, "Bucket")
   .with(new CfnBucketPropsMixin({
@@ -146,6 +146,8 @@ const bucket = new s3.Bucket(scope, "Bucket")
 Property mixins support two merge strategies:
 
 ```typescript
+declare const bucket: s3.CfnBucket;
+
 // MERGE (default): Deep merges properties with existing values
 Mixins.of(bucket).apply(new CfnBucketPropsMixin(
   { versioningConfiguration: { status: "Enabled" } },
@@ -155,16 +157,16 @@ Mixins.of(bucket).apply(new CfnBucketPropsMixin(
 // OVERWRITE: Replaces existing property values
 Mixins.of(bucket).apply(new CfnBucketPropsMixin(
   { versioningConfiguration: { status: "Enabled" } },
-  { strategy: PropertyMergeStrategy.OVERWRITE }
+  { strategy: PropertyMergeStrategy.OVERRIDE }
 ));
 ```
 
 Property mixins are available for all AWS services:
 
 ```typescript
-import { CfnLogGroupMixin } from '@aws-cdk/mixins-preview/aws-logs/mixins';
-import { CfnFunctionMixin } from '@aws-cdk/mixins-preview/aws-lambda/mixins';
-import { CfnTableMixin } from '@aws-cdk/mixins-preview/aws-dynamodb/mixins';
+import { CfnLogGroupPropsMixin } from '@aws-cdk/mixins-preview/aws_logs/mixins';
+import { CfnFunctionPropsMixin } from '@aws-cdk/mixins-preview/aws_lambda/mixins';
+import { CfnTablePropsMixin } from '@aws-cdk/mixins-preview/aws_dynamodb/mixins';
 ```
 
 ## Error Handling

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appconfig/integ.configuration-kms.ts

@@ -6,6 +6,7 @@ import {
   ConfigurationContent,
   HostedConfiguration,
 } from 'aws-cdk-lib/aws-appconfig';
+import * as path from 'path';
 
 const app = new App();
 
@@ -21,7 +22,7 @@ const appConfigApp = new Application(stack, 'MyAppConfig', {
 
 new HostedConfiguration(stack, 'MyHostedConfigFromFile', {
   application: appConfigApp,
-  content: ConfigurationContent.fromFile('config.json'),
+  content: ConfigurationContent.fromFile(path.join(__dirname, 'config.json')),
   kmsKey,
 });
 

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appconfig/integ.configuration.ts

@@ -21,6 +21,7 @@ import {
   RolloutStrategy,
   SourcedConfiguration,
 } from 'aws-cdk-lib/aws-appconfig';
+import * as path from 'path';
 
 const SCHEMA_STR =
 `{
@@ -58,7 +59,7 @@ const deploymentStrategy = new DeploymentStrategy(stack, 'MyDeployStrategy', {
 // hosted config from file
 new HostedConfiguration(stack, 'MyHostedConfigFromFile', {
   application: appConfigApp,
-  content: ConfigurationContent.fromFile('config.json'),
+  content: ConfigurationContent.fromFile(path.join(__dirname, 'config.json')),
   deletionProtectionCheck: DeletionProtectionCheck.BYPASS,
 });
 
@@ -70,7 +71,7 @@ new HostedConfiguration(stack, 'MyHostedConfig', {
   deployTo: [hostedEnv],
   validators: [
     JsonSchemaValidator.fromInline(SCHEMA_STR),
-    JsonSchemaValidator.fromFile('schema.json'),
+    JsonSchemaValidator.fromFile(path.join(__dirname, 'schema.json')),
   ],
   deploymentStrategy,
 });

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-appmesh/README.md

@@ -913,8 +913,8 @@ appmesh.Mesh.fromMeshName(this, 'imported-mesh', 'abc');
 
 ## IAM Grants
 
-`VirtualNode` and `VirtualGateway` provide `grantStreamAggregatedResources` methods that grant identities that are running
-Envoy access to stream generated config from App Mesh.
+`VirtualNode` and `VirtualGateway` have a `grants` property that provides a `streamAggregatedResources` 
+methods that grant identities that are running Envoy access to stream generated config from App Mesh.
 
 ```ts
 declare const mesh: appmesh.Mesh;
@@ -922,9 +922,9 @@ const gateway = new appmesh.VirtualGateway(this, 'testGateway', { mesh });
 const envoyUser = new iam.User(this, 'envoyUser');
 
 /**
- * This will grant `grantStreamAggregatedResources` ONLY for this gateway.
+ * This will grant `appmesh:StreamAggregatedResources` ONLY for this gateway.
  */
-gateway.grantStreamAggregatedResources(envoyUser)
+gateway.grants.streamAggregatedResources(envoyUser)
 ```
 
 ## Adding Resources to shared meshes

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codecommit/integ.codecommit-code-asset-zip.ts

@@ -1,13 +1,14 @@
 import * as cdk from 'aws-cdk-lib';
 import * as codecommit from 'aws-cdk-lib/aws-codecommit';
 import { Code } from 'aws-cdk-lib/aws-codecommit';
+import * as path from 'path';
 
 const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-cdk-codecommit-repo-contents-zip-file');
 
 new codecommit.Repository(stack, 'Repo', {
   repositoryName: 'aws-cdk-codecommit-repo-contents-zip-file',
-  code: Code.fromZipFile('./asset-test.zip'),
+  code: Code.fromZipFile(path.join(__dirname, 'asset-test.zip')),
 });
 
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-codecommit/integ.codecommit-code-asset.ts

@@ -1,13 +1,14 @@
 import * as cdk from 'aws-cdk-lib';
 import * as codecommit from 'aws-cdk-lib/aws-codecommit';
 import { Code } from 'aws-cdk-lib/aws-codecommit';
+import * as path from 'path';
 
 const app = new cdk.App();
 const stack = new cdk.Stack(app, 'aws-cdk-codecommit-repo-contents-assets');
 
 new codecommit.Repository(stack, 'Repo', {
   repositoryName: 'aws-cdk-codecommit-repo-contents-assets',
-  code: Code.fromDirectory('./asset-test'),
+  code: Code.fromDirectory(path.join(__dirname, 'asset-test')),
 });
 
 app.synth();

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2/integ.alb.oidc.ts

@@ -10,6 +10,7 @@ import * as route53targets from 'aws-cdk-lib/aws-route53-targets';
 import { App, Duration, RemovalPolicy, Stack, StackProps } from 'aws-cdk-lib/core';
 import { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from 'aws-cdk-lib/custom-resources';
 import { Construct } from 'constructs';
+import * as path from 'path';
 
 interface CognitoUserProps {
   userPool: cognito.UserPool;
@@ -184,7 +185,7 @@ const testUser = new CognitoUser(testCase, 'User', cognitoUserProps);
 // this function signs in to the website and returns text content of the authenticated page body
 const signinFunction = new lambda.Function(testCase, 'Signin', {
   functionName: 'cdk-integ-alb-oidc-signin-handler',
-  code: lambda.Code.fromAsset('alb-oidc-signin-handler', { exclude: ['*.ts'] }),
+  code: lambda.Code.fromAsset(path.join(__dirname, 'alb-oidc-signin-handler'), { exclude: ['*.ts'] }),
   handler: 'index.handler',
   runtime: lambda.Runtime.NODEJS_20_X,
   environment: {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-elasticloadbalancingv2-actions/integ.cognito.ts

@@ -11,6 +11,7 @@ import * as iam from 'aws-cdk-lib/aws-iam';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as route53 from 'aws-cdk-lib/aws-route53';
 import * as route53targets from 'aws-cdk-lib/aws-route53-targets';
+import * as path from 'path';
 
 interface CognitoUserProps {
   userPool: cognito.UserPool;
@@ -204,7 +205,7 @@ const testUser = new CognitoUser(testCase, 'User', cognitoUserProps);
 // this function signs in to the website and returns text content of the authenticated page body
 const signinFunction = new lambda.Function(testCase, 'Signin', {
   functionName: 'cdk-integ-alb-cognito-signin-handler',
-  code: lambda.Code.fromAsset('alb-cognito-signin-handler', { exclude: ['*.ts'] }),
+  code: lambda.Code.fromAsset(path.join(__dirname, 'alb-cognito-signin-handler'), { exclude: ['*.ts'] }),
   handler: 'index.handler',
   runtime: lambda.Runtime.NODEJS_20_X,
   environment: {

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.lambda-snapstart.ts

@@ -33,7 +33,7 @@ new Function(stack, 'Python313SnapstartLambda', {
 });
 
 new Function(stack, 'DotnetSnapstartLambda', {
-  code: Code.fromAsset('dotnet-handler'),
+  code: Code.fromAsset(path.join(__dirname, 'dotnet-handler')),
   handler: 'Handler',
   runtime: Runtime.DOTNET_8,
   snapStart: SnapStartConf.ON_PUBLISHED_VERSIONS,

cdk_api_mcp_server/resources/aws-cdk/constructs/aws-cdk-lib/aws-lambda/integ.lambda-sourceKMSKeyArn.ts

@@ -80,7 +80,7 @@ class TestStack extends Stack {
       bucketName: 's3sourcekmskeyarnbucket',
     });
     const deployment = new s3deploy.BucketDeployment(this, 'DeployLambdaCode', {
-      sources: [s3deploy.Source.asset('lambda-zip')],
+      sources: [s3deploy.Source.asset(path.join(__dirname, 'lambda-zip'))],
       destinationBucket: bucket,
     });
     const fnBucket = new lambda.Function(this, 'myFunction2', {
@@ -96,7 +96,7 @@ class TestStack extends Stack {
     this.functionName2 = fnBucket.functionName;
 
     // Using Custom Command
-    const command = 'lambda-zip/python-lambda-handler.zip';
+    const command = path.join(__dirname, 'lambda-zip/python-lambda-handler.zip');
     const fnCustom = new lambda.Function(this, 'myFunction3', {
       runtime: lambda.Runtime.PYTHON_3_11,
       handler: 'index.handler',