@raindancers/raindancers-crew 0.0.0 → 0.0.2

package/lib/ecs-crew-host.js

@@ -0,0 +1,383 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsCrewHost = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const autoscaling = __importStar(require("aws-cdk-lib/aws-autoscaling"));
+const ec2 = __importStar(require("aws-cdk-lib/aws-ec2"));
+const ecs = __importStar(require("aws-cdk-lib/aws-ecs"));
+const iam = __importStar(require("aws-cdk-lib/aws-iam"));
+const constructs_1 = require("constructs");
+const fargate_crew_1 = require("./fargate-crew");
+const fargate_crew_base_1 = require("./fargate-crew-base");
+const remote_crew_instance_props_1 = require("./remote-crew-instance-props");
+const STACK_TAG_RE = /^[a-zA-Z0-9-]{1,51}$/;
+const CREW_RE = /^[a-z0-9]([a-z0-9-]{0,30}[a-z0-9])?$/;
+const DEFAULT_STACK_TAG = 'kirocrew';
+const DEFAULT_CREW_COUNT = 1;
+const MAX_CREW_COUNT = 8;
+const DEFAULT_ROOT_VOLUME_GB = 60;
+const DEFAULT_CREW_VOLUME_GB = 20;
+const DEFAULT_MEMORY_RESERVATION_MIB = 1024;
+const DEFAULT_MEMORY_HARD_LIMIT_MIB = 2048;
+/**
+ * One self-provisioned EC2 host running the ECS agent, hosting `crewCount`
+ * Kiro Crew instances as ECS-on-EC2 container tasks.
+ *
+ * The host registers to the {@link FargateCrewBase} cluster and does the NAT
+ * for the crew tasks itself, so the tasks stay fully private with no public
+ * IPs and no NAT Gateway, fck-nat, VPC endpoints, or ALB. Each task runs in
+ * awsvpc mode with its own ENI and private VPC IP; each crew keeps its durable
+ * `~/.kiro/crew` state on its own encrypted EBS volume that survives instance
+ * replacement.
+ *
+ * Isolation is container-level (shared kernel), accepted as sufficient:
+ * Graviton Nitro protects the box from other AWS tenants, containers cover
+ * crew-to-crew separation. See the host-OOM caution: hard per-task memory caps
+ * bound each crew's ceiling but a busy crew can still pressure siblings when
+ * the sum of actual usage exceeds physical RAM.
+ *
+ * `crewCount` defaults to 1, identical to the single-crew shape, so a plain
+ * instantiation with no new props gains no extra resources.
+ */
+class EcsCrewHost extends constructs_1.Construct {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.EcsCrewHost", version: "0.0.2" };
+    /** The shared ECS scaffolding (cluster + egress-only task SG). */
+    base;
+    /** The size-1 Auto Scaling Group holding the single ECS-registered EC2 host. */
+    autoScalingGroup;
+    /** The capacity provider registering the host with the cluster. */
+    capacityProvider;
+    /** The host instance's IAM role (carries the permissions boundary). */
+    role;
+    /** The host's SSM-only security group (no inbound). */
+    hostSecurityGroup;
+    /** The per-crew scaffolding (roles + log group), one per crew. */
+    crews;
+    /** The per-crew EC2 services. */
+    services;
+    /** The per-crew durable data volumes (device/label/mount metadata). */
+    dataVolumes;
+    /** The discovery tag value written as `kirocrew:ecs-host`. */
+    stackTag;
+    /** The resolved crew names. */
+    crewNames;
+    constructor(scope, id, props) {
+        super(scope, id);
+        const stackTag = props.stackTag ?? DEFAULT_STACK_TAG;
+        if (!STACK_TAG_RE.test(stackTag)) {
+            throw new Error(`stackTag must match ${STACK_TAG_RE} (got '${stackTag}')`);
+        }
+        this.stackTag = stackTag;
+        const crewCount = props.crewCount ?? DEFAULT_CREW_COUNT;
+        if (!Number.isInteger(crewCount) || crewCount < 1 || crewCount > MAX_CREW_COUNT) {
+            throw new Error(`crewCount must be an integer 1..${MAX_CREW_COUNT} (got ${crewCount}); ` +
+                'awsvpc needs (crewCount + 1) ENIs to fit the instance type');
+        }
+        const crewNames = props.crews ?? defaultCrewNames(crewCount);
+        if (crewNames.length !== crewCount) {
+            throw new Error(`crews must list exactly crewCount (${crewCount}) names (got ${crewNames.length})`);
+        }
+        for (const crew of crewNames) {
+            if (!CREW_RE.test(crew)) {
+                throw new Error(`crew name must match ${CREW_RE} (got '${crew}'); it derives the ` +
+                    'log group, roles, and secret namespace');
+            }
+        }
+        if (new Set(crewNames).size !== crewNames.length) {
+            throw new Error(`crew names must be unique (got ${crewNames.join(', ')})`);
+        }
+        this.crewNames = crewNames;
+        const arch = props.architecture ?? remote_crew_instance_props_1.CrewArchitecture.ARM64;
+        const fargateArch = arch === remote_crew_instance_props_1.CrewArchitecture.ARM64
+            ? fargate_crew_base_1.FargateCpuArchitecture.ARM64
+            : fargate_crew_base_1.FargateCpuArchitecture.X86_64;
+        // --- Shared ECS scaffolding: reuse FargateCrewBase for the cluster and the
+        // egress-only task security group, so there is one code path for the
+        // cluster the tasks register to.
+        this.base = new fargate_crew_base_1.FargateCrewBase(this, 'Base', {
+            vpc: props.vpc,
+            vpcSubnets: props.taskSubnets,
+            cpuArchitecture: fargateArch,
+            stackTag,
+        });
+        // --- Host instance role: SSM core + required boundary, mirroring
+        // RemoteCrewInstance. Plus the ECS-agent register/telemetry permissions so
+        // this box can join the cluster and run tasks.
+        this.role = new iam.Role(this, 'HostRole', {
+            assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),
+            permissionsBoundary: iam.ManagedPolicy.fromManagedPolicyArn(this, 'Boundary', props.permissionsBoundaryArn),
+            managedPolicies: [
+                iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+                // The ECS container-instance role: RegisterContainerInstance, Poll,
+                // Submit*, and the ECR/log actions the agent needs. Standard for an
+                // ECS-on-EC2 capacity host.
+                iam.ManagedPolicy.fromAwsManagedPolicyName('service-role/AmazonEC2ContainerServiceforEC2Role'),
+            ],
+        });
+        // --- Host security group: SSM-only, no inbound. Egress open for image
+        // pulls, the model endpoint, and forwarding the tasks' NATed traffic.
+        this.hostSecurityGroup = new ec2.SecurityGroup(this, 'HostSecurityGroup', {
+            vpc: props.vpc,
+            description: `KiroCrew ECS host ${stackTag} - SSM-only (no inbound), does NAT for crew tasks`,
+            allowAllOutbound: true,
+        });
+        // --- Arch-aware ECS-optimized Amazon Linux 2023 AMI (the agent is
+        // pre-installed), resolved via the public SSM parameter, no hardcoded id.
+        const amiHardwareType = arch === remote_crew_instance_props_1.CrewArchitecture.ARM64
+            ? ecs.AmiHardwareType.ARM
+            : ecs.AmiHardwareType.STANDARD;
+        const machineImage = ecs.EcsOptimizedImage.amazonLinux2023(amiHardwareType);
+        const instanceType = props.instanceType ??
+            (arch === remote_crew_instance_props_1.CrewArchitecture.ARM64
+                ? new ec2.InstanceType('m7g.2xlarge')
+                : new ec2.InstanceType('m7i.2xlarge'));
+        // --- Per-crew durable data volumes: one gp3 EBS each, encrypted,
+        // deleteOnTermination:false, resolved in the bootstrap by a stable LABEL
+        // (never /dev/sdf, which the Nitro NVMe layer renames).
+        const volumeType = props.crewDataVolumeType ?? ec2.EbsDeviceVolumeType.GP3;
+        const volumeSize = props.crewDataVolumeSizeGb ?? DEFAULT_CREW_VOLUME_GB;
+        this.dataVolumes = crewNames.map((crew, i) => ({
+            crew,
+            // Device letters f.. (sdf, sdg, ...) are attach-time hints; the kernel
+            // renames them on Nitro, so the bootstrap ignores them and uses label.
+            deviceName: `/dev/sd${String.fromCharCode('f'.charCodeAt(0) + i)}`,
+            label: `crew-${crew}`,
+            mountPath: `/var/lib/kirocrew/${crew}`,
+        }));
+        // The ASG uses the autoscaling module's own BlockDevice types (distinct
+        // from ec2's). The public crewDataVolumeType prop stays ec2-typed for
+        // library consistency; translate it by its shared string value here.
+        const asgVolumeType = volumeType;
+        const rootBlockDevice = {
+            deviceName: '/dev/xvda',
+            volume: autoscaling.BlockDeviceVolume.ebs(props.rootVolumeSizeGb ?? DEFAULT_ROOT_VOLUME_GB, {
+                volumeType: autoscaling.EbsDeviceVolumeType.GP3,
+                encrypted: true,
+                deleteOnTermination: true,
+            }),
+        };
+        const crewBlockDevices = this.dataVolumes.map((v) => ({
+            deviceName: v.deviceName,
+            volume: autoscaling.BlockDeviceVolume.ebs(volumeSize, {
+                volumeType: asgVolumeType,
+                encrypted: true,
+                // The whole point: a crew's memory outlives an instance replacement.
+                deleteOnTermination: false,
+            }),
+        }));
+        // --- UserData: a small header the bootstrap body reads (per-crew volume
+        // labels + mount paths, ECS cluster name), then the ECS-host bootstrap
+        // asset (host NAT + resolve-by-label EBS mount). The AsgCapacityProvider
+        // below ALSO appends the ECS-cluster join to this UserData; writing
+        // ECS_CLUSTER here is a harmless idempotent belt-and-braces.
+        const bootstrapBody = fs.readFileSync(resolveAsset('ecs-host-bootstrap.sh'), 'utf8');
+        const userData = ec2.UserData.forLinux();
+        userData.addCommands('ECS_CLUSTER=' + shellQuote(this.base.cluster.clusterName), 'CREW_COUNT=' + String(crewCount), 'CREW_VOLUME_LABELS=' + shellQuote(this.dataVolumes.map((v) => v.label).join(' ')), 'CREW_MOUNT_PATHS=' + shellQuote(this.dataVolumes.map((v) => v.mountPath).join(' ')), 'export ECS_CLUSTER CREW_COUNT CREW_VOLUME_LABELS CREW_MOUNT_PATHS');
+        userData.addCommands(bootstrapBody);
+        // --- The single ECS-registered host, as a size-1 Auto Scaling Group behind
+        // an AsgCapacityProvider. A size-1 ASG (min=max=desired=1) is still ONE
+        // self-provisioned EC2 host and still ECS-on-EC2 (no Fargate); the capacity
+        // provider is what registers that capacity with the cluster so the L2
+        // Ec2Services below can schedule onto it. IMDSv2 enforced (a
+        // prompt-injectable agent must not read role creds via IMDSv1), encrypted
+        // gp3 root, plus the per-crew durable data volumes.
+        this.autoScalingGroup = new autoscaling.AutoScalingGroup(this, 'HostAsg', {
+            vpc: props.vpc,
+            vpcSubnets: props.hostSubnets ?? { subnetType: ec2.SubnetType.PUBLIC },
+            instanceType,
+            machineImage,
+            role: this.role,
+            securityGroup: this.hostSecurityGroup,
+            userData,
+            requireImdsv2: true,
+            minCapacity: 1,
+            maxCapacity: 1,
+            desiredCapacity: 1,
+            // The host is in the PUBLIC subnet and carries the public IP so it
+            // egresses via the IGW and can NAT the tasks. Tasks get none.
+            associatePublicIpAddress: true,
+            blockDevices: [rootBlockDevice, ...crewBlockDevices],
+        });
+        aws_cdk_lib_1.Tags.of(this.autoScalingGroup).add('Name', `kirocrew-ecs-host-${stackTag}`);
+        // --- Host does the NAT: it must forward packets that are neither from nor
+        // to its own address, which requires source/dest check DISABLED on the host
+        // ENI. CloudFormation cannot set SourceDestCheck on an ASG-launched instance
+        // declaratively, so the bootstrap disables it on the host itself via
+        // ec2:ModifyInstanceAttribute (scoped by an instance-tag condition so the
+        // host can only ever modify a KiroCrew ECS host, not an arbitrary instance).
+        // The bootstrap also sets ip_forward=1 and the iptables MASQUERADE rule.
+        this.role.addToPolicy(new iam.PolicyStatement({
+            actions: ['ec2:ModifyInstanceAttribute'],
+            resources: ['*'],
+            conditions: {
+                StringEquals: { 'aws:ResourceTag/kirocrew:ecs-host': stackTag },
+            },
+        }));
+        // --- Register this ASG's capacity with the cluster. This is what makes the
+        // cluster have Ec2 capacity as far as CDK's Ec2Service validation is
+        // concerned, and it appends the ECS-cluster join to the host UserData.
+        this.capacityProvider = new ecs.AsgCapacityProvider(this, 'HostCapacity', {
+            autoScalingGroup: this.autoScalingGroup,
+            // The instances are long-lived crew hosts; do not let ECS scale them in
+            // or terminate them from under running crews.
+            enableManagedTerminationProtection: false,
+        });
+        this.base.cluster.addAsgCapacityProvider(this.capacityProvider);
+        // --- Per-crew: FargateCrew scaffolding (roles + log group), an EC2 task
+        // definition (awsvpc), a container definition, and an Ec2Service.
+        this.crews = [];
+        this.services = [];
+        const crewImage = props.crewImage ?? 'public.ecr.aws/kirocrew/crew:latest';
+        const memoryReservationMiB = props.crewMemoryReservationMiB ?? DEFAULT_MEMORY_RESERVATION_MIB;
+        const memoryHardLimitMiB = props.crewMemoryHardLimitMiB ?? DEFAULT_MEMORY_HARD_LIMIT_MIB;
+        if (memoryReservationMiB > memoryHardLimitMiB) {
+            throw new Error(`crewMemoryReservationMiB (${memoryReservationMiB}) must not exceed ` +
+                `crewMemoryHardLimitMiB (${memoryHardLimitMiB}): the soft reservation ` +
+                'cannot be higher than the hard ceiling');
+        }
+        crewNames.forEach((crew, i) => {
+            const dataVolume = this.dataVolumes[i];
+            const crewScaffold = new fargate_crew_1.FargateCrew(this, `Crew${i}`, {
+                crew,
+                logRetentionDays: props.logRetentionDays,
+                permissionsBoundaryArn: props.crewPermissionsBoundaryArn,
+                ecrRepositoryArn: props.ecrRepositoryArn,
+                backupBucket: props.backupBucket,
+            });
+            this.crews.push(crewScaffold);
+            const taskDef = new ecs.Ec2TaskDefinition(this, `TaskDef${i}`, {
+                // awsvpc: each task gets its own ENI + private VPC IP.
+                networkMode: ecs.NetworkMode.AWS_VPC,
+                taskRole: crewScaffold.taskRole,
+                executionRole: crewScaffold.executionRole,
+                // No runtimePlatform: an EC2 task's architecture is that of the host it
+                // lands on (the arm64 ECS-optimized AMI here), not a task-def field
+                // (that is Fargate-only).
+                // A host volume mapping the crew's mounted EBS path so ~/.kiro/crew is
+                // durable across task/instance replacement.
+                volumes: [
+                    {
+                        name: `crew-data-${crew}`,
+                        host: { sourcePath: dataVolume.mountPath },
+                    },
+                ],
+            });
+            const container = taskDef.addContainer(`Crew${i}Container`, {
+                image: ecs.ContainerImage.fromRegistry(crewImage),
+                // SOFT reservation for scheduling; idle crews cost little.
+                memoryReservationMiB,
+                // HARD cap so a runaway crew cannot exceed its ceiling (host-OOM
+                // blast-radius caution in the README).
+                memoryLimitMiB: memoryHardLimitMiB,
+                // Optional soft CPU shares; unset => shared CPU under contention.
+                cpu: props.crewCpuShares,
+                logging: ecs.LogDriver.awsLogs({
+                    streamPrefix: crew,
+                    logGroup: crewScaffold.logGroup,
+                }),
+            });
+            container.addMountPoints({
+                containerPath: '/home/kirocrew/.kiro/crew',
+                sourceVolume: `crew-data-${crew}`,
+                readOnly: false,
+            });
+            const service = new ecs.Ec2Service(this, `Service${i}`, {
+                cluster: this.base.cluster,
+                taskDefinition: taskDef,
+                desiredCount: 1,
+                // awsvpc placement: the PRIVATE task subnet, the egress-only task SG,
+                // no public IP (tasks are fully private; the host NATs their egress).
+                securityGroups: [this.base.securityGroup],
+                vpcSubnets: props.taskSubnets ?? {
+                    subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,
+                },
+            });
+            // The service depends on the host capacity being registered.
+            service.node.addDependency(this.capacityProvider);
+            this.services.push(service);
+        });
+        // Tag the ASG (tags propagate to launched instances by default), so the
+        // kirocrew:ecs-host tag the ModifyInstanceAttribute condition keys off is
+        // present on the host, and the SG.
+        for (const taggable of [this.autoScalingGroup, this.hostSecurityGroup]) {
+            aws_cdk_lib_1.Tags.of(taggable).add('kirocrew:managed', 'true');
+            aws_cdk_lib_1.Tags.of(taggable).add('kirocrew:ecs-host', stackTag);
+        }
+    }
+    /** The region the host runs in (read from the stack env, never a prop). */
+    get region() {
+        return aws_cdk_lib_1.Stack.of(this).region;
+    }
+}
+exports.EcsCrewHost = EcsCrewHost;
+/** Generate default crew names crew-1 .. crew-<count>. */
+function defaultCrewNames(count) {
+    const names = [];
+    for (let i = 1; i <= count; i++) {
+        names.push(`crew-${i}`);
+    }
+    return names;
+}
+/** Single-quote a literal for safe embedding; pass CDK tokens through. */
+function shellQuote(value) {
+    if (aws_cdk_lib_1.Token.isUnresolved(value)) {
+        return value;
+    }
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+/**
+ * Resolve a bundled asset by name. Works whether the module runs from `src/`
+ * (ts-jest during tests, `__dirname` = src) or `lib/` (a consumer's compiled
+ * install, `__dirname` = lib): the asset ships under `src/assets`, so walk up
+ * to the package root and read it there. Reading from `lib/assets` would fail
+ * for consumers because jsii/tsc does not copy non-TS files into `lib`.
+ */
+function resolveAsset(name) {
+    const candidates = [
+        path.join(__dirname, 'assets', name),
+        path.join(__dirname, '..', 'src', 'assets', name),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`bundled asset '${name}' not found (looked in: ${candidates.join(', ')})`);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs-crew-host.js","sourceRoot":"","sources":["../src/ecs-crew-host.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport { Stack, Tags, Token } from 'aws-cdk-lib';\nimport * as autoscaling from 'aws-cdk-lib/aws-autoscaling';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { Construct } from 'constructs';\nimport { FargateCrew } from './fargate-crew';\nimport { FargateCpuArchitecture, FargateCrewBase } from './fargate-crew-base';\nimport { CrewArchitecture, ICrewBackupBucket } from './remote-crew-instance-props';\n\nconst STACK_TAG_RE = /^[a-zA-Z0-9-]{1,51}$/;\nconst CREW_RE = /^[a-z0-9]([a-z0-9-]{0,30}[a-z0-9])?$/;\n\nconst DEFAULT_STACK_TAG = 'kirocrew';\nconst DEFAULT_CREW_COUNT = 1;\nconst MAX_CREW_COUNT = 8;\nconst DEFAULT_ROOT_VOLUME_GB = 60;\nconst DEFAULT_CREW_VOLUME_GB = 20;\nconst DEFAULT_MEMORY_RESERVATION_MIB = 1024;\nconst DEFAULT_MEMORY_HARD_LIMIT_MIB = 2048;\n\n/**\n * How a per-crew durable EBS volume is exposed to the host and its container.\n *\n * The device name the construct asks for (for example `/dev/sdf`) is NOT the\n * kernel device name on Nitro/Graviton, where every EBS volume surfaces as an\n * unpredictable `/dev/nvmeXn1`. The bootstrap therefore resolves each volume by\n * a stable filesystem LABEL, never by the device path.\n */\nexport interface CrewDataVolume {\n  /** The crew this volume belongs to. */\n  readonly crew: string;\n  /** The block device name requested at attach time (a hint, not the kernel name). */\n  readonly deviceName: string;\n  /** The stable filesystem label the bootstrap resolves and mounts by. */\n  readonly label: string;\n  /** The host mount path the container bind-mounts for `~/.kiro/crew`. */\n  readonly mountPath: string;\n}\n\n/**\n * Properties for {@link EcsCrewHost}.\n */\nexport interface EcsCrewHostProps {\n  /**\n   * VPC to run in. Passed in, never created here.\n   *\n   * The construct consumes a two-subnet host-NAT topology it does not build:\n   * one PUBLIC subnet (host ENI + Elastic IP + IGW route) and one PRIVATE\n   * subnet (task ENIs, `0.0.0.0/0` -> the host ENI, no IGW route). Select them\n   * with {@link hostSubnets} and {@link taskSubnets}.\n   */\n  readonly vpc: ec2.IVpc;\n\n  /**\n   * ARN of an IAM permissions boundary applied to the host instance role.\n   *\n   * The host runs a prompt-injectable agent per crew, so its role MUST carry a\n   * boundary that caps blast radius. Required, not optional, matching\n   * {@link RemoteCrewInstanceProps.permissionsBoundaryArn}. Any valid managed-\n   * policy ARN is accepted here (this is the EC2/host boundary).\n   *\n   * The per-crew task/execution roles take {@link crewPermissionsBoundaryArn},\n   * which is validated separately against the `kirocrew-crew-boundary` pattern\n   * the crew roles require.\n   */\n  readonly permissionsBoundaryArn: string;\n\n  /**\n   * ARN of the pre-created shared crew permissions boundary\n   * (`arn:aws:iam::<account>:policy/kirocrew-crew-boundary`), applied to every\n   * per-crew task and execution role.\n   *\n   * Separate from {@link permissionsBoundaryArn} because the crew roles enforce\n   * the `kirocrew-crew-boundary` policy name (a different boundary from the\n   * host's), and validating them together would force one ARN to satisfy two\n   * distinct patterns. Optional, mirroring {@link FargateCrew}'s declared\n   * degraded mode: omit it only when no crew-boundary creator exists yet.\n   *\n   * @default - no crew boundary (declared degraded mode; see FargateCrew)\n   */\n  readonly crewPermissionsBoundaryArn?: string;\n\n  /**\n   * EC2 instance type for the single ECS-registered host.\n   *\n   * The type STAYS a settable prop: the 55minutes consumer passes\n   * `new ec2.InstanceType('m9g.xlarge')`. Never hardcoded to one family.\n   *\n   * @default - m7g.2xlarge (arm64) / m7i.2xlarge (x86_64), matching\n   * RemoteCrewInstance\n   */\n  readonly instanceType?: ec2.InstanceType;\n\n  /**\n   * CPU architecture of the host and the crew container images. Must match\n   * {@link instanceType} when that is set.\n   *\n   * @default CrewArchitecture.ARM64\n   */\n  readonly architecture?: CrewArchitecture;\n\n  /**\n   * Number of Kiro Crew instances to host, each one ECS task/service.\n   *\n   * DEFAULT 1 — identical to today's single-crew behaviour, so existing\n   * consumers gain nothing new. The 55minutes consumer passes 3. Validated\n   * 1..8: awsvpc gives each task its own ENI, and (crewCount + 1) ENIs (the\n   * host ENI plus one per task) must fit the instance type's ENI budget.\n   *\n   * @default 1\n   */\n  readonly crewCount?: number;\n\n  /**\n   * Explicit crew names. Each must match the {@link FargateCrew} regex\n   * `^[a-z0-9]([a-z0-9-]{0,30}[a-z0-9])?$`; the log group, roles, and secret\n   * namespace are derived from it. When omitted, names are generated as\n   * `crew-1`..`crew-<crewCount>`. When set, the list length must equal\n   * {@link crewCount}.\n   *\n   * @default - crew-1 .. crew-<crewCount>\n   */\n  readonly crews?: string[];\n\n  /**\n   * Subnet selection for the host ENI. This is the PUBLIC subnet (IGW-routed,\n   * carries the Elastic IP), because the host does the NAT for the tasks.\n   *\n   * @default - one public subnet in the VPC\n   */\n  readonly hostSubnets?: ec2.SubnetSelection;\n\n  /**\n   * Subnet selection for the crew task ENIs. This is the PRIVATE subnet whose\n   * `0.0.0.0/0` route points at the host ENI (no IGW route). Tasks get no\n   * public IP.\n   *\n   * @default - the VPC's private-with-egress subnets\n   */\n  readonly taskSubnets?: ec2.SubnetSelection;\n\n  /**\n   * gp3 root volume size in GiB for the host. Always encrypted.\n   *\n   * @default 60\n   */\n  readonly rootVolumeSizeGb?: number;\n\n  /**\n   * Per-crew durable EBS data volume size in GiB. Always encrypted, always\n   * `deleteOnTermination: false` (a crew's `~/.kiro/crew` learnings must\n   * outlive an instance replacement, matching the CrewBackupBucket RETAIN\n   * intent).\n   *\n   * @default 20\n   */\n  readonly crewDataVolumeSizeGb?: number;\n\n  /**\n   * Per-crew EBS volume type.\n   *\n   * @default ec2.EbsDeviceVolumeType.GP3\n   */\n  readonly crewDataVolumeType?: ec2.EbsDeviceVolumeType;\n\n  /**\n   * SOFT memory reservation (MiB) per crew container. ECS uses it for\n   * placement; a crew may burst above it when the host has spare RAM, so idle\n   * crews cost little.\n   *\n   * @default 1024\n   */\n  readonly crewMemoryReservationMiB?: number;\n\n  /**\n   * HARD memory cap (MiB) per crew container. A crew is OOM-killed at this\n   * ceiling, so no single crew can consume the whole host. Set the SUM of hard\n   * caps at or below (physical RAM minus host + ECS-agent headroom) for a hard\n   * cross-crew guarantee — see the host-OOM caution in the README.\n   *\n   * @default 2048\n   */\n  readonly crewMemoryHardLimitMiB?: number;\n\n  /**\n   * Optional SOFT CPU shares per crew container (1024 = one vCPU). Omit to\n   * leave CPU unconstrained (crews share the host CPU fairly under contention).\n   *\n   * @default - unset (shared CPU)\n   */\n  readonly crewCpuShares?: number;\n\n  /**\n   * ARN of the private ECR repository holding the crew image. Leave unset when\n   * the image is pulled from a public registry. When set, each per-crew\n   * execution role gets a pull grant scoped to this one repository.\n   *\n   * @default - public registry; no pull grant\n   */\n  readonly ecrRepositoryArn?: string;\n\n  /**\n   * Container image reference for the crew task. When {@link ecrRepositoryArn}\n   * is set this is typically the repo URI with a tag; otherwise a public\n   * registry reference.\n   *\n   * @default 'public.ecr.aws/kirocrew/crew:latest'\n   */\n  readonly crewImage?: string;\n\n  /**\n   * Days a crew's task logs are kept. One of the CloudWatch retention values\n   * (see {@link FargateCrew}).\n   *\n   * @default 30\n   */\n  readonly logRetentionDays?: number;\n\n  /**\n   * An S3 backup bucket. When set, each per-crew TASK role is granted write so\n   * the running container pushes its own snapshots off-box.\n   *\n   * @default - no off-box backup\n   */\n  readonly backupBucket?: ICrewBackupBucket;\n\n  /**\n   * Discovery tag value written as `kirocrew:ecs-host`. Must match\n   * `[a-zA-Z0-9-]{1,51}`. The cluster is named `kirocrew-crew-<stackTag>`.\n   *\n   * @default 'kirocrew'\n   */\n  readonly stackTag?: string;\n}\n\n/**\n * One self-provisioned EC2 host running the ECS agent, hosting `crewCount`\n * Kiro Crew instances as ECS-on-EC2 container tasks.\n *\n * The host registers to the {@link FargateCrewBase} cluster and does the NAT\n * for the crew tasks itself, so the tasks stay fully private with no public\n * IPs and no NAT Gateway, fck-nat, VPC endpoints, or ALB. Each task runs in\n * awsvpc mode with its own ENI and private VPC IP; each crew keeps its durable\n * `~/.kiro/crew` state on its own encrypted EBS volume that survives instance\n * replacement.\n *\n * Isolation is container-level (shared kernel), accepted as sufficient:\n * Graviton Nitro protects the box from other AWS tenants, containers cover\n * crew-to-crew separation. See the host-OOM caution: hard per-task memory caps\n * bound each crew's ceiling but a busy crew can still pressure siblings when\n * the sum of actual usage exceeds physical RAM.\n *\n * `crewCount` defaults to 1, identical to the single-crew shape, so a plain\n * instantiation with no new props gains no extra resources.\n */\nexport class EcsCrewHost extends Construct {\n  /** The shared ECS scaffolding (cluster + egress-only task SG). */\n  public readonly base: FargateCrewBase;\n  /** The size-1 Auto Scaling Group holding the single ECS-registered EC2 host. */\n  public readonly autoScalingGroup: autoscaling.AutoScalingGroup;\n  /** The capacity provider registering the host with the cluster. */\n  public readonly capacityProvider: ecs.AsgCapacityProvider;\n  /** The host instance's IAM role (carries the permissions boundary). */\n  public readonly role: iam.Role;\n  /** The host's SSM-only security group (no inbound). */\n  public readonly hostSecurityGroup: ec2.SecurityGroup;\n  /** The per-crew scaffolding (roles + log group), one per crew. */\n  public readonly crews: FargateCrew[];\n  /** The per-crew EC2 services. */\n  public readonly services: ecs.Ec2Service[];\n  /** The per-crew durable data volumes (device/label/mount metadata). */\n  public readonly dataVolumes: CrewDataVolume[];\n  /** The discovery tag value written as `kirocrew:ecs-host`. */\n  public readonly stackTag: string;\n  /** The resolved crew names. */\n  public readonly crewNames: string[];\n\n  constructor(scope: Construct, id: string, props: EcsCrewHostProps) {\n    super(scope, id);\n\n    const stackTag = props.stackTag ?? DEFAULT_STACK_TAG;\n    if (!STACK_TAG_RE.test(stackTag)) {\n      throw new Error(`stackTag must match ${STACK_TAG_RE} (got '${stackTag}')`);\n    }\n    this.stackTag = stackTag;\n\n    const crewCount = props.crewCount ?? DEFAULT_CREW_COUNT;\n    if (!Number.isInteger(crewCount) || crewCount < 1 || crewCount > MAX_CREW_COUNT) {\n      throw new Error(\n        `crewCount must be an integer 1..${MAX_CREW_COUNT} (got ${crewCount}); ` +\n          'awsvpc needs (crewCount + 1) ENIs to fit the instance type',\n      );\n    }\n\n    const crewNames = props.crews ?? defaultCrewNames(crewCount);\n    if (crewNames.length !== crewCount) {\n      throw new Error(\n        `crews must list exactly crewCount (${crewCount}) names (got ${crewNames.length})`,\n      );\n    }\n    for (const crew of crewNames) {\n      if (!CREW_RE.test(crew)) {\n        throw new Error(\n          `crew name must match ${CREW_RE} (got '${crew}'); it derives the ` +\n            'log group, roles, and secret namespace',\n        );\n      }\n    }\n    if (new Set(crewNames).size !== crewNames.length) {\n      throw new Error(`crew names must be unique (got ${crewNames.join(', ')})`);\n    }\n    this.crewNames = crewNames;\n\n    const arch = props.architecture ?? CrewArchitecture.ARM64;\n    const fargateArch =\n      arch === CrewArchitecture.ARM64\n        ? FargateCpuArchitecture.ARM64\n        : FargateCpuArchitecture.X86_64;\n\n    // --- Shared ECS scaffolding: reuse FargateCrewBase for the cluster and the\n    // egress-only task security group, so there is one code path for the\n    // cluster the tasks register to.\n    this.base = new FargateCrewBase(this, 'Base', {\n      vpc: props.vpc,\n      vpcSubnets: props.taskSubnets,\n      cpuArchitecture: fargateArch,\n      stackTag,\n    });\n\n    // --- Host instance role: SSM core + required boundary, mirroring\n    // RemoteCrewInstance. Plus the ECS-agent register/telemetry permissions so\n    // this box can join the cluster and run tasks.\n    this.role = new iam.Role(this, 'HostRole', {\n      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),\n      permissionsBoundary: iam.ManagedPolicy.fromManagedPolicyArn(\n        this,\n        'Boundary',\n        props.permissionsBoundaryArn,\n      ),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n        // The ECS container-instance role: RegisterContainerInstance, Poll,\n        // Submit*, and the ECR/log actions the agent needs. Standard for an\n        // ECS-on-EC2 capacity host.\n        iam.ManagedPolicy.fromAwsManagedPolicyName(\n          'service-role/AmazonEC2ContainerServiceforEC2Role',\n        ),\n      ],\n    });\n\n    // --- Host security group: SSM-only, no inbound. Egress open for image\n    // pulls, the model endpoint, and forwarding the tasks' NATed traffic.\n    this.hostSecurityGroup = new ec2.SecurityGroup(this, 'HostSecurityGroup', {\n      vpc: props.vpc,\n      description: `KiroCrew ECS host ${stackTag} - SSM-only (no inbound), does NAT for crew tasks`,\n      allowAllOutbound: true,\n    });\n\n    // --- Arch-aware ECS-optimized Amazon Linux 2023 AMI (the agent is\n    // pre-installed), resolved via the public SSM parameter, no hardcoded id.\n    const amiHardwareType =\n      arch === CrewArchitecture.ARM64\n        ? ecs.AmiHardwareType.ARM\n        : ecs.AmiHardwareType.STANDARD;\n    const machineImage = ecs.EcsOptimizedImage.amazonLinux2023(amiHardwareType);\n\n    const instanceType =\n      props.instanceType ??\n      (arch === CrewArchitecture.ARM64\n        ? new ec2.InstanceType('m7g.2xlarge')\n        : new ec2.InstanceType('m7i.2xlarge'));\n\n    // --- Per-crew durable data volumes: one gp3 EBS each, encrypted,\n    // deleteOnTermination:false, resolved in the bootstrap by a stable LABEL\n    // (never /dev/sdf, which the Nitro NVMe layer renames).\n    const volumeType = props.crewDataVolumeType ?? ec2.EbsDeviceVolumeType.GP3;\n    const volumeSize = props.crewDataVolumeSizeGb ?? DEFAULT_CREW_VOLUME_GB;\n    this.dataVolumes = crewNames.map((crew, i) => ({\n      crew,\n      // Device letters f.. (sdf, sdg, ...) are attach-time hints; the kernel\n      // renames them on Nitro, so the bootstrap ignores them and uses label.\n      deviceName: `/dev/sd${String.fromCharCode('f'.charCodeAt(0) + i)}`,\n      label: `crew-${crew}`,\n      mountPath: `/var/lib/kirocrew/${crew}`,\n    }));\n\n    // The ASG uses the autoscaling module's own BlockDevice types (distinct\n    // from ec2's). The public crewDataVolumeType prop stays ec2-typed for\n    // library consistency; translate it by its shared string value here.\n    const asgVolumeType = volumeType as unknown as autoscaling.EbsDeviceVolumeType;\n    const rootBlockDevice: autoscaling.BlockDevice = {\n      deviceName: '/dev/xvda',\n      volume: autoscaling.BlockDeviceVolume.ebs(props.rootVolumeSizeGb ?? DEFAULT_ROOT_VOLUME_GB, {\n        volumeType: autoscaling.EbsDeviceVolumeType.GP3,\n        encrypted: true,\n        deleteOnTermination: true,\n      }),\n    };\n    const crewBlockDevices: autoscaling.BlockDevice[] = this.dataVolumes.map((v) => ({\n      deviceName: v.deviceName,\n      volume: autoscaling.BlockDeviceVolume.ebs(volumeSize, {\n        volumeType: asgVolumeType,\n        encrypted: true,\n        // The whole point: a crew's memory outlives an instance replacement.\n        deleteOnTermination: false,\n      }),\n    }));\n\n    // --- UserData: a small header the bootstrap body reads (per-crew volume\n    // labels + mount paths, ECS cluster name), then the ECS-host bootstrap\n    // asset (host NAT + resolve-by-label EBS mount). The AsgCapacityProvider\n    // below ALSO appends the ECS-cluster join to this UserData; writing\n    // ECS_CLUSTER here is a harmless idempotent belt-and-braces.\n    const bootstrapBody = fs.readFileSync(resolveAsset('ecs-host-bootstrap.sh'), 'utf8');\n    const userData = ec2.UserData.forLinux();\n    userData.addCommands(\n      'ECS_CLUSTER=' + shellQuote(this.base.cluster.clusterName),\n      'CREW_COUNT=' + String(crewCount),\n      'CREW_VOLUME_LABELS=' + shellQuote(this.dataVolumes.map((v) => v.label).join(' ')),\n      'CREW_MOUNT_PATHS=' + shellQuote(this.dataVolumes.map((v) => v.mountPath).join(' ')),\n      'export ECS_CLUSTER CREW_COUNT CREW_VOLUME_LABELS CREW_MOUNT_PATHS',\n    );\n    userData.addCommands(bootstrapBody);\n\n    // --- The single ECS-registered host, as a size-1 Auto Scaling Group behind\n    // an AsgCapacityProvider. A size-1 ASG (min=max=desired=1) is still ONE\n    // self-provisioned EC2 host and still ECS-on-EC2 (no Fargate); the capacity\n    // provider is what registers that capacity with the cluster so the L2\n    // Ec2Services below can schedule onto it. IMDSv2 enforced (a\n    // prompt-injectable agent must not read role creds via IMDSv1), encrypted\n    // gp3 root, plus the per-crew durable data volumes.\n    this.autoScalingGroup = new autoscaling.AutoScalingGroup(this, 'HostAsg', {\n      vpc: props.vpc,\n      vpcSubnets: props.hostSubnets ?? { subnetType: ec2.SubnetType.PUBLIC },\n      instanceType,\n      machineImage,\n      role: this.role,\n      securityGroup: this.hostSecurityGroup,\n      userData,\n      requireImdsv2: true,\n      minCapacity: 1,\n      maxCapacity: 1,\n      desiredCapacity: 1,\n      // The host is in the PUBLIC subnet and carries the public IP so it\n      // egresses via the IGW and can NAT the tasks. Tasks get none.\n      associatePublicIpAddress: true,\n      blockDevices: [rootBlockDevice, ...crewBlockDevices],\n    });\n    Tags.of(this.autoScalingGroup).add('Name', `kirocrew-ecs-host-${stackTag}`);\n\n    // --- Host does the NAT: it must forward packets that are neither from nor\n    // to its own address, which requires source/dest check DISABLED on the host\n    // ENI. CloudFormation cannot set SourceDestCheck on an ASG-launched instance\n    // declaratively, so the bootstrap disables it on the host itself via\n    // ec2:ModifyInstanceAttribute (scoped by an instance-tag condition so the\n    // host can only ever modify a KiroCrew ECS host, not an arbitrary instance).\n    // The bootstrap also sets ip_forward=1 and the iptables MASQUERADE rule.\n    this.role.addToPolicy(\n      new iam.PolicyStatement({\n        actions: ['ec2:ModifyInstanceAttribute'],\n        resources: ['*'],\n        conditions: {\n          StringEquals: { 'aws:ResourceTag/kirocrew:ecs-host': stackTag },\n        },\n      }),\n    );\n\n    // --- Register this ASG's capacity with the cluster. This is what makes the\n    // cluster have Ec2 capacity as far as CDK's Ec2Service validation is\n    // concerned, and it appends the ECS-cluster join to the host UserData.\n    this.capacityProvider = new ecs.AsgCapacityProvider(this, 'HostCapacity', {\n      autoScalingGroup: this.autoScalingGroup,\n      // The instances are long-lived crew hosts; do not let ECS scale them in\n      // or terminate them from under running crews.\n      enableManagedTerminationProtection: false,\n    });\n    this.base.cluster.addAsgCapacityProvider(this.capacityProvider);\n\n    // --- Per-crew: FargateCrew scaffolding (roles + log group), an EC2 task\n    // definition (awsvpc), a container definition, and an Ec2Service.\n    this.crews = [];\n    this.services = [];\n    const crewImage = props.crewImage ?? 'public.ecr.aws/kirocrew/crew:latest';\n    const memoryReservationMiB =\n      props.crewMemoryReservationMiB ?? DEFAULT_MEMORY_RESERVATION_MIB;\n    const memoryHardLimitMiB =\n      props.crewMemoryHardLimitMiB ?? DEFAULT_MEMORY_HARD_LIMIT_MIB;\n    if (memoryReservationMiB > memoryHardLimitMiB) {\n      throw new Error(\n        `crewMemoryReservationMiB (${memoryReservationMiB}) must not exceed ` +\n          `crewMemoryHardLimitMiB (${memoryHardLimitMiB}): the soft reservation ` +\n          'cannot be higher than the hard ceiling',\n      );\n    }\n\n    crewNames.forEach((crew, i) => {\n      const dataVolume = this.dataVolumes[i];\n      const crewScaffold = new FargateCrew(this, `Crew${i}`, {\n        crew,\n        logRetentionDays: props.logRetentionDays,\n        permissionsBoundaryArn: props.crewPermissionsBoundaryArn,\n        ecrRepositoryArn: props.ecrRepositoryArn,\n        backupBucket: props.backupBucket,\n      });\n      this.crews.push(crewScaffold);\n\n      const taskDef = new ecs.Ec2TaskDefinition(this, `TaskDef${i}`, {\n        // awsvpc: each task gets its own ENI + private VPC IP.\n        networkMode: ecs.NetworkMode.AWS_VPC,\n        taskRole: crewScaffold.taskRole,\n        executionRole: crewScaffold.executionRole,\n        // No runtimePlatform: an EC2 task's architecture is that of the host it\n        // lands on (the arm64 ECS-optimized AMI here), not a task-def field\n        // (that is Fargate-only).\n        // A host volume mapping the crew's mounted EBS path so ~/.kiro/crew is\n        // durable across task/instance replacement.\n        volumes: [\n          {\n            name: `crew-data-${crew}`,\n            host: { sourcePath: dataVolume.mountPath },\n          },\n        ],\n      });\n\n      const container = taskDef.addContainer(`Crew${i}Container`, {\n        image: ecs.ContainerImage.fromRegistry(crewImage),\n        // SOFT reservation for scheduling; idle crews cost little.\n        memoryReservationMiB,\n        // HARD cap so a runaway crew cannot exceed its ceiling (host-OOM\n        // blast-radius caution in the README).\n        memoryLimitMiB: memoryHardLimitMiB,\n        // Optional soft CPU shares; unset => shared CPU under contention.\n        cpu: props.crewCpuShares,\n        logging: ecs.LogDriver.awsLogs({\n          streamPrefix: crew,\n          logGroup: crewScaffold.logGroup,\n        }),\n      });\n      container.addMountPoints({\n        containerPath: '/home/kirocrew/.kiro/crew',\n        sourceVolume: `crew-data-${crew}`,\n        readOnly: false,\n      });\n\n      const service = new ecs.Ec2Service(this, `Service${i}`, {\n        cluster: this.base.cluster,\n        taskDefinition: taskDef,\n        desiredCount: 1,\n        // awsvpc placement: the PRIVATE task subnet, the egress-only task SG,\n        // no public IP (tasks are fully private; the host NATs their egress).\n        securityGroups: [this.base.securityGroup],\n        vpcSubnets: props.taskSubnets ?? {\n          subnetType: ec2.SubnetType.PRIVATE_WITH_EGRESS,\n        },\n      });\n      // The service depends on the host capacity being registered.\n      service.node.addDependency(this.capacityProvider);\n      this.services.push(service);\n    });\n\n    // Tag the ASG (tags propagate to launched instances by default), so the\n    // kirocrew:ecs-host tag the ModifyInstanceAttribute condition keys off is\n    // present on the host, and the SG.\n    for (const taggable of [this.autoScalingGroup, this.hostSecurityGroup]) {\n      Tags.of(taggable).add('kirocrew:managed', 'true');\n      Tags.of(taggable).add('kirocrew:ecs-host', stackTag);\n    }\n  }\n\n  /** The region the host runs in (read from the stack env, never a prop). */\n  public get region(): string {\n    return Stack.of(this).region;\n  }\n}\n\n/** Generate default crew names crew-1 .. crew-<count>. */\nfunction defaultCrewNames(count: number): string[] {\n  const names: string[] = [];\n  for (let i = 1; i <= count; i++) {\n    names.push(`crew-${i}`);\n  }\n  return names;\n}\n\n/** Single-quote a literal for safe embedding; pass CDK tokens through. */\nfunction shellQuote(value: string): string {\n  if (Token.isUnresolved(value)) {\n    return value;\n  }\n  return `'${value.replace(/'/g, \"'\\\\''\")}'`;\n}\n\n/**\n * Resolve a bundled asset by name. Works whether the module runs from `src/`\n * (ts-jest during tests, `__dirname` = src) or `lib/` (a consumer's compiled\n * install, `__dirname` = lib): the asset ships under `src/assets`, so walk up\n * to the package root and read it there. Reading from `lib/assets` would fail\n * for consumers because jsii/tsc does not copy non-TS files into `lib`.\n */\nfunction resolveAsset(name: string): string {\n  const candidates = [\n    path.join(__dirname, 'assets', name),\n    path.join(__dirname, '..', 'src', 'assets', name),\n  ];\n  for (const candidate of candidates) {\n    if (fs.existsSync(candidate)) {\n      return candidate;\n    }\n  }\n  throw new Error(\n    `bundled asset '${name}' not found (looked in: ${candidates.join(', ')})`,\n  );\n}\n"]}

package/lib/fargate-crew-base.js

@@ -60,7 +60,7 @@ var FargateCpuArchitecture;
  * Port of the upstream `kirocrew-fargate-base` CloudFormation template.
  */
 class FargateCrewBase extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.FargateCrewBase", version: "0.0.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.FargateCrewBase", version: "0.0.2" };
     /** The ECS cluster crew tasks run on. */
     cluster;
     /** The egress-only task security group (no inbound). */

package/lib/fargate-crew.js

@@ -68,7 +68,7 @@ const ALLOWED_RETENTION_DAYS = [1, 3, 5, 7, 14, 30, 60, 90, 120, 150, 180, 365];
  *   roles are not assumable on behalf of an unrelated stack's task.
  */
 class FargateCrew extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.FargateCrew", version: "0.0.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.FargateCrew", version: "0.0.2" };
     /** Role ECS assumes BEFORE the container starts (secret fetch + log stream). */
     executionRole;
     /** Identity the RUNNING container carries. Created with no policies. */

package/lib/index.d.ts

@@ -3,3 +3,5 @@ export * from './remote-crew-instance-props';
 export * from './fargate-crew-base';
 export * from './fargate-crew';
 export * from './crew-backup-bucket';
+export * from './ecs-crew-host';
+export * from './crew-webhook-ingress';

package/lib/index.js

@@ -19,4 +19,6 @@ __exportStar(require("./remote-crew-instance-props"), exports);
 __exportStar(require("./fargate-crew-base"), exports);
 __exportStar(require("./fargate-crew"), exports);
 __exportStar(require("./crew-backup-bucket"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUF1QztBQUN2QywrREFBNkM7QUFDN0Msc0RBQW9DO0FBQ3BDLGlEQUErQjtBQUMvQix1REFBcUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3JlbW90ZS1jcmV3LWluc3RhbmNlJztcbmV4cG9ydCAqIGZyb20gJy4vcmVtb3RlLWNyZXctaW5zdGFuY2UtcHJvcHMnO1xuZXhwb3J0ICogZnJvbSAnLi9mYXJnYXRlLWNyZXctYmFzZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZhcmdhdGUtY3Jldyc7XG5leHBvcnQgKiBmcm9tICcuL2NyZXctYmFja3VwLWJ1Y2tldCc7XG4iXX0=
+__exportStar(require("./ecs-crew-host"), exports);
+__exportStar(require("./crew-webhook-ingress"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlEQUF1QztBQUN2QywrREFBNkM7QUFDN0Msc0RBQW9DO0FBQ3BDLGlEQUErQjtBQUMvQix1REFBcUM7QUFDckMsa0RBQWdDO0FBQ2hDLHlEQUF1QyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcmVtb3RlLWNyZXctaW5zdGFuY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9yZW1vdGUtY3Jldy1pbnN0YW5jZS1wcm9wcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZhcmdhdGUtY3Jldy1iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vZmFyZ2F0ZS1jcmV3JztcbmV4cG9ydCAqIGZyb20gJy4vY3Jldy1iYWNrdXAtYnVja2V0JztcbmV4cG9ydCAqIGZyb20gJy4vZWNzLWNyZXctaG9zdCc7XG5leHBvcnQgKiBmcm9tICcuL2NyZXctd2ViaG9vay1pbmdyZXNzJztcbiJdfQ==

package/lib/remote-crew-instance.js

@@ -68,7 +68,7 @@ const DEFAULT_TIMEOUT_MIN = 25;
  * diagnostics.
  */
 class RemoteCrewInstance extends constructs_1.Construct {
-    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.RemoteCrewInstance", version: "0.0.0" };
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@raindancers/raindancers-crew.RemoteCrewInstance", version: "0.0.2" };
     /** The EC2 instance (SSM target). */
     instance;
     /** The instance's IAM role (carries the permissions boundary). */

package/package.json

@@ -21,7 +21,7 @@
     "post-compile": "projen post-compile",
     "post-upgrade": "projen post-upgrade",
     "pre-compile": "projen pre-compile",
-    "release": "projen release",
+    "release:feat/remote-crew-instance": "projen release:feat/remote-crew-instance",
     "test": "projen test",
     "test:watch": "projen test:watch",
     "unbump": "projen unbump",
@@ -81,7 +81,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0",
+  "version": "0.0.2",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [