awscdk-construct-mediaconnect-flow 0.0.0

package/lib/LiveFeedFromFile.js

@@ -0,0 +1,300 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveFeedFromFile = void 0;
+exports.startFlow = startFlow;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const crypto = require("crypto");
+const cdk = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_mediaconnect_1 = require("aws-cdk-lib/aws-mediaconnect");
+const asm = require("aws-cdk-lib/aws-secretsmanager");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const awscdk_construct_medialive_channel_1 = require("awscdk-construct-medialive-channel");
+const constructs_1 = require("constructs");
+const sourceIngestPort = 5000;
+const discoveryServerPort = 5959;
+const VPC_INTERFACE_NAME = 'vpcInterfaceName';
+class LiveFeedFromFile extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { file, source = {
+            protocol: 'SRT',
+            type: 'STANDARD-SOURCE',
+        }, vpcConfig, autoStart = true, } = props;
+        const uuid = `${crypto.randomUUID()}`;
+        const protocol = (() => {
+            switch (source.protocol) {
+                case 'RTP':
+                    return 'rtp';
+                case 'RTP-FEC':
+                    return 'rtp-fec';
+                case 'SRT':
+                default:
+                    return 'srt-listener';
+            }
+        })();
+        // Create a VPC
+        const vpc = vpcConfig ? new ec2.Vpc(this, 'VPC', vpcConfig.props) : undefined;
+        vpc && vpc.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+        // Allocate an Elastic IP for the VPC interface
+        const eip = vpc ? new ec2.CfnEIP(this, 'EIP', {
+            domain: 'vpc', // Ensure the EIP is allocated in the VPC
+        }) : undefined;
+        // Create a security group to allow push input
+        const description = 'Allow Push input from MediaLive';
+        const sg = vpc ? new ec2.SecurityGroup(this, 'SecurityGroup', {
+            vpc,
+            description,
+            allowAllOutbound: true,
+        }) : undefined;
+        sg && sg.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+        sg && sg.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.udp(sourceIngestPort), description);
+        // Create an NDI discovery server
+        let ndiConfig;
+        if (vpc && vpcConfig?.enableNDI) {
+            const instance = createNdiDiscoveryServer(this, vpc);
+            ndiConfig = {
+                ndiDiscoveryServers: [{
+                        discoveryServerAddress: instance.instancePrivateIp, // Use the private IP of the NDI Discovery Server
+                        vpcInterfaceAdapter: VPC_INTERFACE_NAME,
+                        discoveryServerPort,
+                    }],
+                ndiState: 'ENABLED',
+            };
+        }
+        // Create a secret
+        const randomstring = Math.random().toString(36).slice(-8);
+        const sourcePassword = new asm.Secret(this, 'SourcePassword', {
+            secretName: `secret-${uuid}`,
+            generateSecretString: {
+                secretStringTemplate: JSON.stringify({ password: randomstring }),
+                generateStringKey: 'password',
+                excludePunctuation: true,
+            },
+            removalPolicy: cdk.RemovalPolicy.DESTROY,
+        });
+        // Create an IAM role for MediaConnect to access the VPC
+        const role = new iam.Role(this, 'MediaConnectRole', {
+            assumedBy: new iam.ServicePrincipal('mediaconnect.amazonaws.com'),
+            inlinePolicies: {
+                policy: new iam.PolicyDocument({
+                    statements: [
+                        new iam.PolicyStatement({
+                            resources: [sourcePassword.secretArn],
+                            actions: [
+                                'secretsmanager:GetResourcePolicy',
+                                'secretsmanager:GetSecretValue',
+                                'secretsmanager:DescribeSecret',
+                                'secretsmanager:ListSecretVersionIds',
+                            ],
+                        }),
+                    ],
+                }),
+            },
+            managedPolicies: [
+                iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonVPCFullAccess'),
+            ],
+        });
+        // Create a MediaConnect flow
+        const flow = new aws_mediaconnect_1.CfnFlow(this, 'MyCfnFlow', {
+            name: `lcp-demo-${uuid}`,
+            source: {
+                name: `lcp-demo-source-${uuid}`,
+                protocol,
+                // maxLatency: 2000,
+                // minLatency: 1000,
+                // vpcInterfaceName: VPC_INTERFACE_NAME,
+                whitelistCidr: source.type === 'STANDARD-SOURCE' ? '0.0.0.0/0' : undefined,
+                decryption: {
+                    // algorithm: 'aes128',
+                    roleArn: role.roleArn,
+                    secretArn: sourcePassword.secretArn,
+                },
+                // sourceIngestPort: `${sourceIngestPort}`,
+                vpcInterfaceName: source.type === 'VPC-SOURCE' ? VPC_INTERFACE_NAME : undefined,
+            },
+            availabilityZone: vpcConfig?.availabilityZone ?? vpc?.availabilityZones[0],
+            flowSize: vpcConfig?.enableNDI ? 'LARGE' : 'MEDIUM',
+            ndiConfig,
+            sourceMonitoringConfig: {
+                thumbnailState: 'ENABLED',
+                contentQualityAnalysisState: 'ENABLED',
+            },
+            vpcInterfaces: vpc ? [{
+                    name: VPC_INTERFACE_NAME,
+                    roleArn: role.roleArn,
+                    securityGroupIds: [sg.securityGroupId],
+                    subnetId: vpcConfig?.subnetId ?? vpc.privateSubnets[0].subnetId,
+                }] : [],
+        });
+        flow.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+        // Start the MediaConnect Flow
+        autoStart && startFlow(this, 'StartMediaConnectFlow', flow.attrFlowArn);
+        // Create MediaLive channel
+        const eml = new awscdk_construct_medialive_channel_1.MediaLive(this, 'MediaLive', {
+            sources: [{ url: file.url.replace('s3://', 's3ssl://'), type: file.type ?? 'MP4_FILE' }],
+            destinations: [{
+                    id: 'SRT',
+                    srtSettings: [{
+                            url: `srt://${flow.attrSourceIngestIp}:${flow.attrSourceSourceIngestPort}`, // Use the MediaConnect Flow URL
+                            encryptionPassphraseSecretArn: sourcePassword.secretArn,
+                        }],
+                }],
+            channelClass: 'SINGLE_PIPELINE',
+            encoderSpec: {
+                outputGroupSettingsList: [{
+                        srtGroupSettings: {
+                            inputLossAction: 'DROP_TS',
+                        },
+                    }],
+                outputSettingsList: [{
+                        // Add valid OutputSettingsProperty fields here if needed
+                        srtOutputSettings: {
+                            latency: 2000, // Latency in milliseconds
+                            destination: {
+                                destinationRefId: 'SRT',
+                            },
+                            encryptionType: 'AES128', // Encryption type
+                            containerSettings: {
+                                m2TsSettings: {},
+                            },
+                        },
+                    }],
+                gopLengthInSeconds: 2, // The length of the GOP in seconds.
+                timecodeBurninPrefix: 'Ch', // The prefix for the timecode burn-in.
+            },
+            vpc: source.type === 'VPC-SOURCE' && vpc ? {
+                publicAddressAllocationIds: [eip.attrAllocationId],
+                subnetIds: [vpc.privateSubnets[0].subnetId],
+                securityGroupIds: [sg.securityGroupId],
+            } : undefined,
+            secret: sourcePassword,
+        });
+        // Start the MediaLive channel
+        autoStart && (0, awscdk_construct_medialive_channel_1.startChannel)(this, 'StartMediaLiveChannel', eml.channel.ref);
+        this.flow = flow;
+        this.vpc = vpc;
+    }
+}
+exports.LiveFeedFromFile = LiveFeedFromFile;
+_a = JSII_RTTI_SYMBOL_1;
+LiveFeedFromFile[_a] = { fqn: "awscdk-construct-mediaconnect-flow.LiveFeedFromFile", version: "0.0.0" };
+function createNdiDiscoveryServer(scope, vpc) {
+    const description = 'Allow NDI Discovery Service';
+    const sg = new ec2.SecurityGroup(scope, 'NDISecurityGroup', {
+        vpc,
+        description,
+        allowAllOutbound: true,
+    });
+    sg.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+    sg.addIngressRule(ec2.Peer.anyIpv4(), ec2.Port.tcp(discoveryServerPort), description);
+    const instance = new ec2.Instance(scope, 'Instance', {
+        vpc,
+        instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MICRO),
+        machineImage: ec2.MachineImage.latestAmazonLinux2023(),
+        vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },
+        securityGroup: sg,
+    });
+    instance.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);
+    // Get the CloudFormation logical ID for the instance
+    const cfnInstance = instance.node.defaultChild;
+    const logicalId = cfnInstance.logicalId;
+    instance.applyCloudFormationInit(ec2.CloudFormationInit.fromConfigSets({
+        configSets: {
+            // Applies the configs below in this order
+            default: ['configInstance', 'finalize'],
+        },
+        configs: {
+            configInstance: new ec2.InitConfig([
+                // NDI Discovery Service script
+                ec2.InitFile.fromString('/etc/systemd/ndi-discovery.service', `[Unit]
+          Description=NDI Discovery Service
+          
+          [Service]
+          ExecStartPre=/bin/sleep 30
+          User=ec2-user
+          WorkingDirectory=/home/ec2-user/bin/x86_64-linux-gnu
+          ExecStart=/home/ec2-user/bin/x86_64-linux-gnu/ndi-discovery-server
+          Restart=always
+
+          [Install]
+          WantedBy=multi-user.target
+        `),
+                // NDI Discovery Server Installation script
+                ec2.InitFile.fromString('/tmp/install-ndi-discovery.sh', `#!/bin/bash -xe
+          cd /home/ec2-user
+
+          #Install updates
+          yum update -y
+
+          #Download the NDI Linux SDK and extract it and run the install script
+          wget https://downloads.ndi.tv/SDK/NDI_SDK_Linux/Install_NDI_SDK_v6_Linux.tar.gz
+          tar -xzf Install_NDI_SDK_v6_Linux.tar.gz
+          yes | sudo ./Install_NDI_SDK_v6_Linux.sh
+
+          #Clean up and prepare directories
+          rm -f Install_NDI_SDK_v6_Linux.tar.gz
+          rm -f Install_NDI_SDK_v6_Linux.sh
+          cp -r 'NDI SDK for Linux'/* ./
+          rm -r 'NDI SDK for Linux'/
+        `),
+                // Install the NDI Discovery Service
+                ec2.InitCommand.shellCommand('sudo bash /tmp/install-ndi-discovery.sh'),
+                // Run the NDI Discovery Service
+                ec2.InitCommand.shellCommand('sudo systemctl enable /etc/systemd/ndi-discovery.service'),
+            ]),
+            finalize: new ec2.InitConfig([
+                // Start the NDI Discovery Service
+                ec2.InitCommand.shellCommand(cdk.Fn.sub('/opt/aws/bin/cfn-signal -e $? --stack ${StackName} --resource ${Resource} --region ${Region}', {
+                    StackName: cdk.Aws.STACK_NAME,
+                    Resource: logicalId,
+                    Region: cdk.Aws.REGION,
+                })),
+            ]),
+        },
+    }));
+    instance.addUserData(cdk.Fn.sub(`
+    #!/bin/bash -xe
+    yum install -y aws-cfn-bootstrap
+    sudo /opt/aws/bin/cfn-init --configsets default -v --stack \${StackName} --resource \${Resource} --region \${Region}
+    sudo reboot
+  `, {
+        StackName: cdk.Aws.STACK_NAME,
+        Resource: logicalId,
+        Region: cdk.Aws.REGION,
+    }));
+    return instance;
+}
+function startFlow(scope, id, flowArn) {
+    // Start channel
+    new custom_resources_1.AwsCustomResource(scope, id, {
+        onCreate: {
+            service: 'MediaConnect',
+            action: 'StartFlow',
+            parameters: {
+                FlowArn: flowArn,
+            },
+            physicalResourceId: custom_resources_1.PhysicalResourceId.of(`${crypto.randomUUID()}`),
+            // ignoreErrorCodesMatching: '*',
+            outputPaths: ['FlowArn', 'Status'],
+        },
+        onDelete: {
+            service: 'MediaConnect',
+            action: 'StopFlow',
+            parameters: {
+                FlowArn: flowArn,
+            },
+            physicalResourceId: custom_resources_1.PhysicalResourceId.of(`${crypto.randomUUID()}`),
+            // ignoreErrorCodesMatching: '*',
+            outputPaths: ['FlowArn', 'Status'],
+        },
+        //Will ignore any resource and use the assumedRoleArn as resource and 'sts:AssumeRole' for service:action
+        policy: custom_resources_1.AwsCustomResourcePolicy.fromSdkCalls({
+            resources: custom_resources_1.AwsCustomResourcePolicy.ANY_RESOURCE,
+        }),
+    });
+    return new Date();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LiveFeedFromFile.js","sourceRoot":"","sources":["../src/LiveFeedFromFile.ts"],"names":[],"mappings":";;;;AAoUA,8BA6BC;;AAjWD,iCAAiC;AACjC,mCAAmC;AACnC,2CAA2C;AAC3C,2CAA2C;AAC3C,mEAAuD;AACvD,sDAAsD;AACtD,mEAA8G;AAC9G,2FAA6E;AAC7E,2CAAuC;AA0BvC,MAAM,gBAAgB,GAAG,IAAI,CAAC;AAC9B,MAAM,mBAAmB,GAAG,IAAI,CAAC;AACjC,MAAM,kBAAkB,GAAG,kBAAkB,CAAC;AAE9C,MAAa,gBAAiB,SAAQ,sBAAS;IAI7C,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA4B;QACpE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EACJ,IAAI,EACJ,MAAM,GAAG;YACP,QAAQ,EAAE,KAAK;YACf,IAAI,EAAE,iBAAiB;SACxB,EACD,SAAS,EACT,SAAS,GAAG,IAAI,GACjB,GAAG,KAAK,CAAC;QAEV,MAAM,IAAI,GAAG,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;QACtC,MAAM,QAAQ,GAAG,CAAC,GAAG,EAAE;YACrB,QAAQ,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACxB,KAAK,KAAK;oBACR,OAAO,KAAK,CAAC;gBACf,KAAK,SAAS;oBACZ,OAAO,SAAS,CAAC;gBACnB,KAAK,KAAK,CAAC;gBACX;oBACE,OAAO,cAAc,CAAC;YAC1B,CAAC;QACH,CAAC,CAAC,EAAE,CAAC;QAEL,eAAe;QACf,MAAM,GAAG,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAC9E,GAAG,IAAI,GAAG,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAEzD,+CAA+C;QAC/C,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE;YAC5C,MAAM,EAAE,KAAK,EAAE,yCAAyC;SACzD,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAEf,8CAA8C;QAC9C,MAAM,WAAW,GAAG,iCAAiC,CAAC;QACtD,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,aAAa,CAAC,IAAI,EAAE,eAAe,EAAE;YAC5D,GAAG;YACH,WAAW;YACX,gBAAgB,EAAE,IAAI;SACvB,CAAC,CAAA,CAAC,CAAC,SAAS,CAAC;QACd,EAAE,IAAI,EAAE,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QACvD,EAAE,IAAI,EAAE,CAAC,cAAc,CACrB,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,EAClB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAC9B,WAAW,CACZ,CAAC;QAEF,iCAAiC;QACjC,IAAI,SAAgD,CAAC;QACrD,IAAI,GAAG,IAAI,SAAS,EAAE,SAAS,EAAE,CAAC;YAChC,MAAM,QAAQ,GAAG,wBAAwB,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;YACrD,SAAS,GAAG;gBACV,mBAAmB,EAAE,CAAC;wBACpB,sBAAsB,EAAE,QAAQ,CAAC,iBAAiB,EAAE,iDAAiD;wBACrG,mBAAmB,EAAE,kBAAkB;wBACvC,mBAAmB;qBACpB,CAAC;gBACF,QAAQ,EAAE,SAAS;aACpB,CAAC;QACJ,CAAC;QAED,kBAAkB;QAClB,MAAM,YAAY,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1D,MAAM,cAAc,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,gBAAgB,EAAE;YAC5D,UAAU,EAAE,UAAU,IAAI,EAAE;YAC5B,oBAAoB,EAAE;gBACpB,oBAAoB,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,YAAY,EAAE,CAAC;gBAChE,iBAAiB,EAAE,UAAU;gBAC7B,kBAAkB,EAAE,IAAI;aACzB;YACD,aAAa,EAAE,GAAG,CAAC,aAAa,CAAC,OAAO;SACzC,CAAC,CAAC;QAEH,wDAAwD;QACxD,MAAM,IAAI,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,kBAAkB,EAAE;YAClD,SAAS,EAAE,IAAI,GAAG,CAAC,gBAAgB,CAAC,4BAA4B,CAAC;YACjE,cAAc,EAAE;gBACd,MAAM,EAAE,IAAI,GAAG,CAAC,cAAc,CAAC;oBAC7B,UAAU,EAAE;wBACV,IAAI,GAAG,CAAC,eAAe,CAAC;4BACtB,SAAS,EAAE,CAAC,cAAc,CAAC,SAAS,CAAC;4BACrC,OAAO,EAAE;gCACP,kCAAkC;gCAClC,+BAA+B;gCAC/B,+BAA+B;gCAC/B,qCAAqC;6BACtC;yBACF,CAAC;qBACH;iBACF,CAAC;aACH;YACD,eAAe,EAAE;gBACf,GAAG,CAAC,aAAa,CAAC,wBAAwB,CAAC,qBAAqB,CAAC;aAClE;SACF,CAAC,CAAC;QAEH,6BAA6B;QAC7B,MAAM,IAAI,GAAG,IAAI,0BAAO,CAAC,IAAI,EAAE,WAAW,EAAE;YAC1C,IAAI,EAAE,YAAY,IAAI,EAAE;YACxB,MAAM,EAAE;gBACN,IAAI,EAAE,mBAAmB,IAAI,EAAE;gBAC/B,QAAQ;gBACR,oBAAoB;gBACpB,oBAAoB;gBACpB,wCAAwC;gBACxC,aAAa,EAAE,MAAM,CAAC,IAAI,KAAK,iBAAiB,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS;gBAC1E,UAAU,EAAE;oBACV,uBAAuB;oBACvB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,SAAS,EAAE,cAAc,CAAC,SAAS;iBACpC;gBACD,2CAA2C;gBAC3C,gBAAgB,EAAE,MAAM,CAAC,IAAI,KAAK,YAAY,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,SAAS;aAChF;YACD,gBAAgB,EAAE,SAAS,EAAE,gBAAgB,IAAI,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAC;YAC1E,QAAQ,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,QAAQ;YACnD,SAAS;YACT,sBAAsB,EAAE;gBACtB,cAAc,EAAE,SAAS;gBACzB,2BAA2B,EAAE,SAAS;aACvC;YACD,aAAa,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;oBACpB,IAAI,EAAE,kBAAkB;oBACxB,OAAO,EAAE,IAAI,CAAC,OAAO;oBACrB,gBAAgB,EAAE,CAAC,EAAG,CAAC,eAAe,CAAC;oBACvC,QAAQ,EAAE,SAAS,EAAE,QAAQ,IAAI,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,QAAQ;iBAChE,CAAC,CAAC,CAAC,CAAC,EAAE;SACR,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;QAEnD,8BAA8B;QAC9B,SAAS,IAAI,SAAS,CAAC,IAAI,EAAE,uBAAuB,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAExE,2BAA2B;QAC3B,MAAM,GAAG,GAAG,IAAI,8CAAS,CAAC,IAAI,EAAE,WAAW,EAAE;YAC3C,OAAO,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;YACxF,YAAY,EAAE,CAAC;oBACb,EAAE,EAAE,KAAK;oBACT,WAAW,EAAE,CAAC;4BACZ,GAAG,EAAE,SAAS,IAAI,CAAC,kBAAkB,IAAI,IAAI,CAAC,0BAA0B,EAAE,EAAE,gCAAgC;4BAC5G,6BAA6B,EAAE,cAAc,CAAC,SAAS;yBACxD,CAAC;iBACH,CAAC;YACF,YAAY,EAAE,iBAAiB;YAC/B,WAAW,EAAE;gBACX,uBAAuB,EAAE,CAAC;wBACxB,gBAAgB,EAAE;4BAChB,eAAe,EAAE,SAAS;yBAC3B;qBACF,CAAC;gBACF,kBAAkB,EAAE,CAAC;wBACnB,yDAAyD;wBACzD,iBAAiB,EAAE;4BACjB,OAAO,EAAE,IAAI,EAAE,0BAA0B;4BACzC,WAAW,EAAE;gCACX,gBAAgB,EAAE,KAAK;6BACxB;4BACD,cAAc,EAAE,QAAQ,EAAE,kBAAkB;4BAC5C,iBAAiB,EAAE;gCACjB,YAAY,EAAE,EAAE;6BACjB;yBACF;qBACF,CAAC;gBACF,kBAAkB,EAAE,CAAC,EAAE,oCAAoC;gBAC3D,oBAAoB,EAAE,IAAI,EAAE,uCAAuC;aACpE;YACD,GAAG,EAAE,MAAM,CAAC,IAAI,KAAK,YAAY,IAAI,GAAG,CAAC,CAAC,CAAC;gBACzC,0BAA0B,EAAE,CAAC,GAAI,CAAC,gBAAgB,CAAC;gBACnD,SAAS,EAAE,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC;gBAC3C,gBAAgB,EAAE,CAAC,EAAG,CAAC,eAAe,CAAC;aACxC,CAAC,CAAC,CAAC,SAAS;YACb,MAAM,EAAE,cAAc;SACvB,CAAC,CAAC;QAEH,8BAA8B;QAC9B,SAAS,IAAI,IAAA,iDAAY,EAAC,IAAI,EAAE,uBAAuB,EAAE,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAE1E,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;;AAzLH,4CA0LC;;;AAED,SAAS,wBAAwB,CAAC,KAAgB,EAAE,GAAa;IAC/D,MAAM,WAAW,GAAG,6BAA6B,CAAC;IAClD,MAAM,EAAE,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE;QAC1D,GAAG;QACH,WAAW;QACX,gBAAgB,EAAE,IAAI;KACvB,CAAC,CAAC;IACH,EAAE,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACjD,EAAE,CAAC,cAAc,CACf,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,EAClB,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,mBAAmB,CAAC,EACjC,WAAW,CACZ,CAAC;IACF,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,UAAU,EAAE;QACnD,GAAG;QACH,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,EAAE,CAAC,GAAG,CAAC,aAAa,CAAC,UAAU,EAAE,GAAG,CAAC,YAAY,CAAC,KAAK,CAAC;QACvF,YAAY,EAAE,GAAG,CAAC,YAAY,CAAC,qBAAqB,EAAE;QACtD,UAAU,EAAE,EAAE,UAAU,EAAE,GAAG,CAAC,UAAU,CAAC,mBAAmB,EAAE;QAC9D,aAAa,EAAE,EAAE;KAClB,CAAC,CAAC;IACH,QAAQ,CAAC,kBAAkB,CAAC,GAAG,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;IACvD,qDAAqD;IACrD,MAAM,WAAW,GAAG,QAAQ,CAAC,IAAI,CAAC,YAA+B,CAAC;IAClE,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC;IACxC,QAAQ,CAAC,uBAAuB,CAAC,GAAG,CAAC,kBAAkB,CAAC,cAAc,CAAC;QACrE,UAAU,EAAE;YACV,0CAA0C;YAC1C,OAAO,EAAE,CAAC,gBAAgB,EAAE,UAAU,CAAC;SACxC;QACD,OAAO,EAAE;YACP,cAAc,EAAE,IAAI,GAAG,CAAC,UAAU,CAAC;gBACjC,+BAA+B;gBAC/B,GAAG,CAAC,QAAQ,CAAC,UAAU,CACrB,oCAAoC,EACpC;;;;;;;;;;;;SAYD,CAAC;gBACF,2CAA2C;gBAC3C,GAAG,CAAC,QAAQ,CAAC,UAAU,CACrB,+BAA+B,EAC/B;;;;;;;;;;;;;;;;SAgBD,CAAC;gBACF,oCAAoC;gBACpC,GAAG,CAAC,WAAW,CAAC,YAAY,CAAC,yCAAyC,CAAC;gBACvE,gCAAgC;gBAChC,GAAG,CAAC,WAAW,CAAC,YAAY,CAAC,0DAA0D,CAAC;aACzF,CAAC;YACF,QAAQ,EAAE,IAAI,GAAG,CAAC,UAAU,CAAC;gBAC3B,kCAAkC;gBAClC,GAAG,CAAC,WAAW,CAAC,YAAY,CAC1B,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,8FAA8F,EACvG;oBACE,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,UAAU;oBAC7B,QAAQ,EAAE,SAAS;oBACnB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM;iBACvB,CAAC,CACL;aACF,CAAC;SACH;KACF,CAAC,CAAC,CAAC;IACJ,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC;;;;;GAK/B,EAAE;QACD,SAAS,EAAE,GAAG,CAAC,GAAG,CAAC,UAAU;QAC7B,QAAQ,EAAE,SAAS;QACnB,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM;KACvB,CAAC,CAAC,CAAC;IACJ,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,SAAgB,SAAS,CAAC,KAAgB,EAAE,EAAU,EAAE,OAAe;IACrE,gBAAgB;IAChB,IAAI,oCAAiB,CAAC,KAAK,EAAE,EAAE,EAAE;QAC/B,QAAQ,EAAE;YACR,OAAO,EAAE,cAAc;YACvB,MAAM,EAAE,WAAW;YACnB,UAAU,EAAE;gBACV,OAAO,EAAE,OAAO;aACjB;YACD,kBAAkB,EAAE,qCAAkB,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;YACnE,iCAAiC;YACjC,WAAW,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;SACnC;QACD,QAAQ,EAAE;YACR,OAAO,EAAE,cAAc;YACvB,MAAM,EAAE,UAAU;YAClB,UAAU,EAAE;gBACV,OAAO,EAAE,OAAO;aACjB;YACD,kBAAkB,EAAE,qCAAkB,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC;YACnE,iCAAiC;YACjC,WAAW,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC;SACnC;QACD,yGAAyG;QACzG,MAAM,EAAE,0CAAuB,CAAC,YAAY,CAAC;YAC3C,SAAS,EAAE,0CAAuB,CAAC,YAAY;SAChD,CAAC;KACH,CAAC,CAAC;IACH,OAAO,IAAI,IAAI,EAAE,CAAC;AACpB,CAAC","sourcesContent":["import * as crypto from 'crypto';\nimport * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CfnFlow } from 'aws-cdk-lib/aws-mediaconnect';\nimport * as asm from 'aws-cdk-lib/aws-secretsmanager';\nimport { AwsCustomResource, AwsCustomResourcePolicy, PhysicalResourceId } from 'aws-cdk-lib/custom-resources';\nimport { MediaLive, startChannel } from 'awscdk-construct-medialive-channel';\nimport { Construct } from 'constructs';\n\nexport interface FileSpec {\n  readonly type?: 'MP4_FILE' | 'TS_FILE'; // Type of the input file\n  readonly url: string; // S3 URL of the input file\n}\n\nexport interface LiveSourceSpec {\n  readonly protocol: 'RTP' | 'RTP-FEC' | 'SRT'; // Protocol of the live source\n  readonly type: 'STANDARD-SOURCE' | 'VPC-SOURCE'; // Type of the live source\n}\n\nexport interface VpcConfig {\n  readonly props: ec2.VpcProps;\n  readonly availabilityZone?: string;\n  readonly subnetId?: string;\n  readonly enableNDI?: boolean; // Settings for NDI output\n}\n\nexport interface LiveFeedFromFileProps {\n  readonly file: FileSpec; // File specification\n  readonly source?: LiveSourceSpec; // Optional live source specification\n  readonly vpcConfig?: VpcConfig; // Settings for VPC. Required when the source type is VPC-SOURCE and/or VPC outputs will be added to this flow.\n  readonly autoStart?: boolean; // Whether to automatically start the MediaLive channel and MediaConnect flow\n}\n\nconst sourceIngestPort = 5000;\nconst discoveryServerPort = 5959;\nconst VPC_INTERFACE_NAME = 'vpcInterfaceName';\n\nexport class LiveFeedFromFile extends Construct {\n  public readonly flow: CfnFlow;\n  public readonly vpc?: ec2.IVpc;\n\n  constructor(scope: Construct, id: string, props: LiveFeedFromFileProps) {\n    super(scope, id);\n\n    const {\n      file,\n      source = {\n        protocol: 'SRT',\n        type: 'STANDARD-SOURCE',\n      },\n      vpcConfig,\n      autoStart = true,\n    } = props;\n\n    const uuid = `${crypto.randomUUID()}`;\n    const protocol = (() => {\n      switch (source.protocol) {\n        case 'RTP':\n          return 'rtp';\n        case 'RTP-FEC':\n          return 'rtp-fec';\n        case 'SRT':\n        default:\n          return 'srt-listener';\n      }\n    })();\n\n    // Create a VPC\n    const vpc = vpcConfig ? new ec2.Vpc(this, 'VPC', vpcConfig.props) : undefined;\n    vpc && vpc.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n\n    // Allocate an Elastic IP for the VPC interface\n    const eip = vpc ? new ec2.CfnEIP(this, 'EIP', {\n      domain: 'vpc', // Ensure the EIP is allocated in the VPC\n    }) : undefined;\n\n    // Create a security group to allow push input\n    const description = 'Allow Push input from MediaLive';\n    const sg = vpc ? new ec2.SecurityGroup(this, 'SecurityGroup', {\n      vpc,\n      description,\n      allowAllOutbound: true,\n    }): undefined;\n    sg && sg.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n    sg && sg.addIngressRule(\n      ec2.Peer.anyIpv4(),\n      ec2.Port.udp(sourceIngestPort),\n      description,\n    );\n\n    // Create an NDI discovery server\n    let ndiConfig: CfnFlow.NdiConfigProperty | undefined;\n    if (vpc && vpcConfig?.enableNDI) {\n      const instance = createNdiDiscoveryServer(this, vpc);\n      ndiConfig = {\n        ndiDiscoveryServers: [{\n          discoveryServerAddress: instance.instancePrivateIp, // Use the private IP of the NDI Discovery Server\n          vpcInterfaceAdapter: VPC_INTERFACE_NAME,\n          discoveryServerPort,\n        }],\n        ndiState: 'ENABLED',\n      };\n    }\n\n    // Create a secret\n    const randomstring = Math.random().toString(36).slice(-8);\n    const sourcePassword = new asm.Secret(this, 'SourcePassword', {\n      secretName: `secret-${uuid}`,\n      generateSecretString: {\n        secretStringTemplate: JSON.stringify({ password: randomstring }),\n        generateStringKey: 'password',\n        excludePunctuation: true,\n      },\n      removalPolicy: cdk.RemovalPolicy.DESTROY,\n    });\n\n    // Create an IAM role for MediaConnect to access the VPC\n    const role = new iam.Role(this, 'MediaConnectRole', {\n      assumedBy: new iam.ServicePrincipal('mediaconnect.amazonaws.com'),\n      inlinePolicies: {\n        policy: new iam.PolicyDocument({\n          statements: [\n            new iam.PolicyStatement({\n              resources: [sourcePassword.secretArn],\n              actions: [\n                'secretsmanager:GetResourcePolicy',\n                'secretsmanager:GetSecretValue',\n                'secretsmanager:DescribeSecret',\n                'secretsmanager:ListSecretVersionIds',\n              ],\n            }),\n          ],\n        }),\n      },\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonVPCFullAccess'),\n      ],\n    });\n\n    // Create a MediaConnect flow\n    const flow = new CfnFlow(this, 'MyCfnFlow', {\n      name: `lcp-demo-${uuid}`,\n      source: {\n        name: `lcp-demo-source-${uuid}`,\n        protocol,\n        // maxLatency: 2000,\n        // minLatency: 1000,\n        // vpcInterfaceName: VPC_INTERFACE_NAME,\n        whitelistCidr: source.type === 'STANDARD-SOURCE' ? '0.0.0.0/0' : undefined,\n        decryption: {\n          // algorithm: 'aes128',\n          roleArn: role.roleArn,\n          secretArn: sourcePassword.secretArn,\n        },\n        // sourceIngestPort: `${sourceIngestPort}`,\n        vpcInterfaceName: source.type === 'VPC-SOURCE' ? VPC_INTERFACE_NAME : undefined,\n      },\n      availabilityZone: vpcConfig?.availabilityZone ?? vpc?.availabilityZones[0],\n      flowSize: vpcConfig?.enableNDI ? 'LARGE' : 'MEDIUM',\n      ndiConfig,\n      sourceMonitoringConfig: {\n        thumbnailState: 'ENABLED',\n        contentQualityAnalysisState: 'ENABLED',\n      },\n      vpcInterfaces: vpc ? [{\n        name: VPC_INTERFACE_NAME,\n        roleArn: role.roleArn,\n        securityGroupIds: [sg!.securityGroupId],\n        subnetId: vpcConfig?.subnetId ?? vpc.privateSubnets[0].subnetId,\n      }] : [],\n    });\n    flow.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n\n    // Start the MediaConnect Flow\n    autoStart && startFlow(this, 'StartMediaConnectFlow', flow.attrFlowArn);\n\n    // Create MediaLive channel\n    const eml = new MediaLive(this, 'MediaLive', {\n      sources: [{ url: file.url.replace('s3://', 's3ssl://'), type: file.type ?? 'MP4_FILE' }],\n      destinations: [{\n        id: 'SRT',\n        srtSettings: [{\n          url: `srt://${flow.attrSourceIngestIp}:${flow.attrSourceSourceIngestPort}`, // Use the MediaConnect Flow URL\n          encryptionPassphraseSecretArn: sourcePassword.secretArn,\n        }],\n      }],\n      channelClass: 'SINGLE_PIPELINE',\n      encoderSpec: {\n        outputGroupSettingsList: [{\n          srtGroupSettings: {\n            inputLossAction: 'DROP_TS',\n          },\n        }],\n        outputSettingsList: [{\n          // Add valid OutputSettingsProperty fields here if needed\n          srtOutputSettings: {\n            latency: 2000, // Latency in milliseconds\n            destination: {\n              destinationRefId: 'SRT',\n            },\n            encryptionType: 'AES128', // Encryption type\n            containerSettings: {\n              m2TsSettings: {},\n            },\n          },\n        }],\n        gopLengthInSeconds: 2, // The length of the GOP in seconds.\n        timecodeBurninPrefix: 'Ch', // The prefix for the timecode burn-in.\n      },\n      vpc: source.type === 'VPC-SOURCE' && vpc ? {\n        publicAddressAllocationIds: [eip!.attrAllocationId],\n        subnetIds: [vpc.privateSubnets[0].subnetId],\n        securityGroupIds: [sg!.securityGroupId],\n      } : undefined,\n      secret: sourcePassword,\n    });\n\n    // Start the MediaLive channel\n    autoStart && startChannel(this, 'StartMediaLiveChannel', eml.channel.ref);\n\n    this.flow = flow;\n    this.vpc = vpc;\n  }\n}\n\nfunction createNdiDiscoveryServer(scope: Construct, vpc: ec2.IVpc): ec2.Instance {\n  const description = 'Allow NDI Discovery Service';\n  const sg = new ec2.SecurityGroup(scope, 'NDISecurityGroup', {\n    vpc,\n    description,\n    allowAllOutbound: true,\n  });\n  sg.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n  sg.addIngressRule(\n    ec2.Peer.anyIpv4(),\n    ec2.Port.tcp(discoveryServerPort),\n    description,\n  );\n  const instance = new ec2.Instance(scope, 'Instance', {\n    vpc,\n    instanceType: ec2.InstanceType.of(ec2.InstanceClass.BURSTABLE3, ec2.InstanceSize.MICRO),\n    machineImage: ec2.MachineImage.latestAmazonLinux2023(),\n    vpcSubnets: { subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS },\n    securityGroup: sg,\n  });\n  instance.applyRemovalPolicy(cdk.RemovalPolicy.DESTROY);\n  // Get the CloudFormation logical ID for the instance\n  const cfnInstance = instance.node.defaultChild as cdk.CfnResource;\n  const logicalId = cfnInstance.logicalId;\n  instance.applyCloudFormationInit(ec2.CloudFormationInit.fromConfigSets({\n    configSets: {\n      // Applies the configs below in this order\n      default: ['configInstance', 'finalize'],\n    },\n    configs: {\n      configInstance: new ec2.InitConfig([\n        // NDI Discovery Service script\n        ec2.InitFile.fromString(\n          '/etc/systemd/ndi-discovery.service',\n          `[Unit]\n          Description=NDI Discovery Service\n          \n          [Service]\n          ExecStartPre=/bin/sleep 30\n          User=ec2-user\n          WorkingDirectory=/home/ec2-user/bin/x86_64-linux-gnu\n          ExecStart=/home/ec2-user/bin/x86_64-linux-gnu/ndi-discovery-server\n          Restart=always\n\n          [Install]\n          WantedBy=multi-user.target\n        `),\n        // NDI Discovery Server Installation script\n        ec2.InitFile.fromString(\n          '/tmp/install-ndi-discovery.sh',\n          `#!/bin/bash -xe\n          cd /home/ec2-user\n\n          #Install updates\n          yum update -y\n\n          #Download the NDI Linux SDK and extract it and run the install script\n          wget https://downloads.ndi.tv/SDK/NDI_SDK_Linux/Install_NDI_SDK_v6_Linux.tar.gz\n          tar -xzf Install_NDI_SDK_v6_Linux.tar.gz\n          yes | sudo ./Install_NDI_SDK_v6_Linux.sh\n\n          #Clean up and prepare directories\n          rm -f Install_NDI_SDK_v6_Linux.tar.gz\n          rm -f Install_NDI_SDK_v6_Linux.sh\n          cp -r 'NDI SDK for Linux'/* ./\n          rm -r 'NDI SDK for Linux'/\n        `),\n        // Install the NDI Discovery Service\n        ec2.InitCommand.shellCommand('sudo bash /tmp/install-ndi-discovery.sh'),\n        // Run the NDI Discovery Service\n        ec2.InitCommand.shellCommand('sudo systemctl enable /etc/systemd/ndi-discovery.service'),\n      ]),\n      finalize: new ec2.InitConfig([\n        // Start the NDI Discovery Service\n        ec2.InitCommand.shellCommand(\n          cdk.Fn.sub('/opt/aws/bin/cfn-signal -e $? --stack ${StackName} --resource ${Resource} --region ${Region}',\n            {\n              StackName: cdk.Aws.STACK_NAME,\n              Resource: logicalId,\n              Region: cdk.Aws.REGION,\n            }),\n        ),\n      ]),\n    },\n  }));\n  instance.addUserData(cdk.Fn.sub(`\n    #!/bin/bash -xe\n    yum install -y aws-cfn-bootstrap\n    sudo /opt/aws/bin/cfn-init --configsets default -v --stack \\${StackName} --resource \\${Resource} --region \\${Region}\n    sudo reboot\n  `, {\n    StackName: cdk.Aws.STACK_NAME,\n    Resource: logicalId,\n    Region: cdk.Aws.REGION,\n  }));\n  return instance;\n}\n\nexport function startFlow(scope: Construct, id: string, flowArn: string): Date {\n  // Start channel\n  new AwsCustomResource(scope, id, {\n    onCreate: {\n      service: 'MediaConnect',\n      action: 'StartFlow',\n      parameters: {\n        FlowArn: flowArn,\n      },\n      physicalResourceId: PhysicalResourceId.of(`${crypto.randomUUID()}`),\n      // ignoreErrorCodesMatching: '*',\n      outputPaths: ['FlowArn', 'Status'],\n    },\n    onDelete: {\n      service: 'MediaConnect',\n      action: 'StopFlow',\n      parameters: {\n        FlowArn: flowArn,\n      },\n      physicalResourceId: PhysicalResourceId.of(`${crypto.randomUUID()}`),\n      // ignoreErrorCodesMatching: '*',\n      outputPaths: ['FlowArn', 'Status'],\n    },\n    //Will ignore any resource and use the assumedRoleArn as resource and 'sts:AssumeRole' for service:action\n    policy: AwsCustomResourcePolicy.fromSdkCalls({\n      resources: AwsCustomResourcePolicy.ANY_RESOURCE,\n    }),\n  });\n  return new Date();\n}\n"]}

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './LiveFeedFromFile';

package/lib/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./LiveFeedFromFile"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vTGl2ZUZlZWRGcm9tRmlsZSc7Il19

package/package.json

@@ -0,0 +1,134 @@
+{
+  "name": "awscdk-construct-mediaconnect-flow",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kuu/awscdk-construct-mediaconnect-flow.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Kuu Miyazaki",
+    "email": "miyazaqui@gmail.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@stylistic/eslint-plugin": "^2",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^24.0.7",
+    "@typescript-eslint/eslint-plugin": "^8",
+    "@typescript-eslint/parser": "^8",
+    "commit-and-tag-version": "^12",
+    "eslint": "^9",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "jest": "^30.0.3",
+    "jest-junit": "^16",
+    "jsii": "~5.8.9",
+    "jsii-diff": "^1.112.0",
+    "jsii-docgen": "^10.5.0",
+    "jsii-pacmak": "^1.112.0",
+    "jsii-rosetta": "~5.8.9",
+    "projen": "^0.94.0",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.202.0",
+    "constructs": "^10.0.5"
+  },
+  "dependencies": {
+    "aws-cdk-lib": "^2.202.0",
+    "awscdk-construct-medialive-channel": "^0.0.6",
+    "constructs": "^10.4.2"
+  },
+  "keywords": [
+    "MediaConnect",
+    "cdk",
+    "cdk-construct"
+  ],
+  "main": "lib/index.js",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.0",
+  "jest": {
+    "coverageProvider": "v8",
+    "testMatch": [
+      "<rootDir>/@(src|test)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(src|test)/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/@(projenrc)/**/*(*.)@(spec|test).ts?(x)",
+      "<rootDir>/@(projenrc)/**/__tests__/**/*.ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "transform": {
+      "^.+\\.[t]sx?$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.dev.json"
+        }
+      ]
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}