@quiltdata/benchling-webhook 0.7.8-20251115T063729Z → 0.7.10

package/dist/bin/commands/status.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Stack Status Command
+ *
+ * Reports CloudFormation stack status and BenchlingIntegration parameter state
+ * for a given configuration profile.
+ *
+ * @module commands/status
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatStackStatus = formatStackStatus;
+exports.statusCommand = statusCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const client_cloudformation_1 = require("@aws-sdk/client-cloudformation");
+const client_ecs_1 = require("@aws-sdk/client-ecs");
+const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2");
+const client_secrets_manager_1 = require("@aws-sdk/client-secrets-manager");
+const credential_providers_1 = require("@aws-sdk/credential-providers");
+const xdg_config_1 = require("../../lib/xdg-config");
+/**
+ * Gets stack status from CloudFormation
+ */
+async function getStackStatus(stackArn, region, awsProfile) {
+    try {
+        // Extract stack name from ARN
+        const stackNameMatch = stackArn.match(/stack\/([^/]+)\//);
+        if (!stackNameMatch) {
+            throw new Error(`Invalid stack ARN format: ${stackArn}`);
+        }
+        const stackName = stackNameMatch[1];
+        // Configure AWS SDK client
+        const clientConfig = { region };
+        if (awsProfile) {
+            clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile: awsProfile });
+        }
+        const client = new client_cloudformation_1.CloudFormationClient(clientConfig);
+        // Describe stack
+        const command = new client_cloudformation_1.DescribeStacksCommand({
+            StackName: stackName,
+        });
+        const response = await client.send(command);
+        const stack = response.Stacks?.[0];
+        if (!stack) {
+            throw new Error(`Stack not found: ${stackName}`);
+        }
+        // Extract BenchlingIntegration parameter
+        const param = stack.Parameters?.find((p) => p.ParameterKey === "BenchlingIntegration");
+        const benchlingIntegrationEnabled = param?.ParameterValue === "Enabled";
+        // Extract stack outputs
+        const outputs = stack.Outputs || [];
+        const stackOutputs = {
+            benchlingUrl: outputs.find((o) => o.OutputKey === "BenchlingUrl")?.OutputValue,
+            secretArn: outputs.find((o) => o.OutputKey === "BenchlingSecretArn" || o.OutputKey === "BenchlingClientSecretArn" || o.OutputKey === "SecretArn")?.OutputValue,
+            dockerImage: outputs.find((o) => o.OutputKey === "BenchlingDockerImage" || o.OutputKey === "DockerImage")?.OutputValue,
+            ecsLogGroup: outputs.find((o) => o.OutputKey === "EcsLogGroup")?.OutputValue,
+            apiGatewayLogGroup: outputs.find((o) => o.OutputKey === "ApiGatewayLogGroup")?.OutputValue,
+        };
+        return {
+            success: true,
+            stackStatus: stack.StackStatus,
+            benchlingIntegrationEnabled,
+            lastUpdateTime: stack.LastUpdatedTime?.toISOString() || stack.CreationTime?.toISOString(),
+            stackArn,
+            region,
+            stackOutputs,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error.message,
+            stackArn,
+            region,
+        };
+    }
+}
+/**
+ * Formats stack status with color coding
+ */
+function formatStackStatus(status) {
+    if (status.includes("COMPLETE") && !status.includes("ROLLBACK")) {
+        return chalk_1.default.green(status);
+    }
+    else if (status.includes("IN_PROGRESS")) {
+        return chalk_1.default.yellow(status);
+    }
+    else if (status.includes("FAILED") || status.includes("ROLLBACK")) {
+        return chalk_1.default.red(status);
+    }
+    else {
+        return chalk_1.default.dim(status);
+    }
+}
+/**
+ * Checks if stack status is terminal (no further updates expected)
+ */
+function isTerminalStatus(status) {
+    if (!status)
+        return false;
+    return status.endsWith("_COMPLETE") || status.endsWith("_FAILED");
+}
+/**
+ * Parses timer value (string or number) and returns interval in milliseconds
+ * Returns null if timer is disabled (0 or non-numeric string)
+ */
+function parseTimerValue(timer) {
+    if (timer === undefined)
+        return 10000; // Default 10 seconds
+    const numValue = typeof timer === "string" ? parseFloat(timer) : timer;
+    // If NaN or 0, disable timer
+    if (isNaN(numValue) || numValue === 0) {
+        return null;
+    }
+    // Return milliseconds
+    return numValue * 1000;
+}
+/**
+ * Sleep helper
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Clear screen and move cursor to top
+ */
+function clearScreen() {
+    process.stdout.write("\x1b[2J\x1b[H");
+}
+/**
+ * Gets ECS service health information
+ */
+async function getEcsServiceHealth(stackName, region, awsProfile) {
+    try {
+        // Configure AWS SDK clients
+        const clientConfig = { region };
+        if (awsProfile) {
+            clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile: awsProfile });
+        }
+        const cfClient = new client_cloudformation_1.CloudFormationClient(clientConfig);
+        const ecsClient = new client_ecs_1.ECSClient(clientConfig);
+        // Find ECS resources in stack
+        const resourcesCommand = new client_cloudformation_1.DescribeStackResourcesCommand({
+            StackName: stackName,
+        });
+        const resourcesResponse = await cfClient.send(resourcesCommand);
+        const ecsServices = resourcesResponse.StackResources?.filter((r) => r.ResourceType === "AWS::ECS::Service") || [];
+        if (ecsServices.length === 0) {
+            return undefined;
+        }
+        // Get cluster name (assuming all services use the same cluster)
+        const clusterResource = resourcesResponse.StackResources?.find((r) => r.ResourceType === "AWS::ECS::Cluster");
+        const clusterName = clusterResource?.PhysicalResourceId || stackName;
+        // Describe all ECS services
+        const serviceArns = ecsServices
+            .map((s) => s.PhysicalResourceId)
+            .filter((arn) => !!arn);
+        if (serviceArns.length === 0) {
+            return undefined;
+        }
+        const servicesCommand = new client_ecs_1.DescribeServicesCommand({
+            cluster: clusterName,
+            services: serviceArns,
+        });
+        const servicesResponse = await ecsClient.send(servicesCommand);
+        // Get log groups from task definitions
+        const servicesWithLogs = await Promise.all((servicesResponse.services || []).map(async (svc) => {
+            let logGroup;
+            let logStreamPrefix;
+            // Get task definition ARN from the current deployment
+            const taskDefArn = svc.deployments?.[0]?.taskDefinition;
+            if (taskDefArn) {
+                try {
+                    const taskDefCommand = new client_ecs_1.DescribeTaskDefinitionCommand({
+                        taskDefinition: taskDefArn,
+                    });
+                    const taskDefResponse = await ecsClient.send(taskDefCommand);
+                    // Extract log group and stream prefix from first container's log configuration
+                    const logConfig = taskDefResponse.taskDefinition?.containerDefinitions?.[0]?.logConfiguration;
+                    if (logConfig?.logDriver === "awslogs") {
+                        logGroup = logConfig.options?.["awslogs-group"];
+                        logStreamPrefix = logConfig.options?.["awslogs-stream-prefix"];
+                    }
+                }
+                catch (error) {
+                    // Log group query failed, continue without it
+                    console.error(chalk_1.default.dim(`  Could not retrieve log group for ${svc.serviceName}: ${error.message}`));
+                }
+            }
+            return {
+                serviceName: svc.serviceName || "Unknown",
+                status: svc.status || "UNKNOWN",
+                desiredCount: svc.desiredCount || 0,
+                runningCount: svc.runningCount || 0,
+                pendingCount: svc.pendingCount || 0,
+                rolloutState: svc.deployments?.[0]?.rolloutState,
+                logGroup,
+                logStreamPrefix,
+            };
+        }));
+        return servicesWithLogs;
+    }
+    catch (error) {
+        // ECS health check is optional, don't fail the entire command
+        console.error(chalk_1.default.dim(`  Could not retrieve ECS service health: ${error.message}`));
+        return undefined;
+    }
+}
+/**
+ * Gets recent stack events
+ */
+async function getRecentStackEvents(stackName, region, awsProfile, maxEvents = 10) {
+    try {
+        // Configure AWS SDK client
+        const clientConfig = { region };
+        if (awsProfile) {
+            clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile: awsProfile });
+        }
+        const client = new client_cloudformation_1.CloudFormationClient(clientConfig);
+        const command = new client_cloudformation_1.DescribeStackEventsCommand({
+            StackName: stackName,
+        });
+        const response = await client.send(command);
+        return response.StackEvents?.slice(0, maxEvents).map((event) => ({
+            timestamp: event.Timestamp || new Date(),
+            resourceId: event.LogicalResourceId || "Unknown",
+            status: event.ResourceStatus || "UNKNOWN",
+            reason: event.ResourceStatusReason,
+        }));
+    }
+    catch (error) {
+        // Stack events are optional, don't fail the entire command
+        console.error(chalk_1.default.dim(`  Could not retrieve stack events: ${error.message}`));
+        return undefined;
+    }
+}
+/**
+ * Gets ALB target group health information
+ */
+async function getAlbTargetHealth(stackName, region, awsProfile) {
+    try {
+        // Configure AWS SDK clients
+        const clientConfig = { region };
+        if (awsProfile) {
+            clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile: awsProfile });
+        }
+        const cfClient = new client_cloudformation_1.CloudFormationClient(clientConfig);
+        const elbClient = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client(clientConfig);
+        // Find Target Group resources in stack
+        const resourcesCommand = new client_cloudformation_1.DescribeStackResourcesCommand({
+            StackName: stackName,
+        });
+        const resourcesResponse = await cfClient.send(resourcesCommand);
+        const targetGroups = resourcesResponse.StackResources?.filter((r) => r.ResourceType === "AWS::ElasticLoadBalancingV2::TargetGroup") || [];
+        if (targetGroups.length === 0) {
+            return undefined;
+        }
+        // Get target group ARNs
+        const targetGroupArns = targetGroups
+            .map((tg) => tg.PhysicalResourceId)
+            .filter((arn) => !!arn);
+        if (targetGroupArns.length === 0) {
+            return undefined;
+        }
+        // Get target group names
+        const tgInfoCommand = new client_elastic_load_balancing_v2_1.DescribeTargetGroupsCommand({
+            TargetGroupArns: targetGroupArns,
+        });
+        const tgInfoResponse = await elbClient.send(tgInfoCommand);
+        const result = [];
+        // Get health for each target group
+        for (const tgArn of targetGroupArns) {
+            const healthCommand = new client_elastic_load_balancing_v2_1.DescribeTargetHealthCommand({
+                TargetGroupArn: tgArn,
+            });
+            const healthResponse = await elbClient.send(healthCommand);
+            const tgInfo = tgInfoResponse.TargetGroups?.find((tg) => tg.TargetGroupArn === tgArn);
+            const tgName = tgInfo?.TargetGroupName || tgArn.split("/").pop() || "Unknown";
+            const targets = healthResponse.TargetHealthDescriptions?.map((target) => ({
+                id: target.Target?.Id || "Unknown",
+                health: target.TargetHealth?.State || "unknown",
+                reason: target.TargetHealth?.Reason,
+            })) || [];
+            const healthyCount = targets.filter((t) => t.health === "healthy").length;
+            const unhealthyCount = targets.filter((t) => t.health === "unhealthy").length;
+            const drainingCount = targets.filter((t) => t.health === "draining").length;
+            result.push({
+                targetGroupName: tgName,
+                healthyCount,
+                unhealthyCount,
+                drainingCount,
+                targets,
+            });
+        }
+        return result.length > 0 ? result : undefined;
+    }
+    catch (error) {
+        // ALB health check is optional, don't fail the entire command
+        console.error(chalk_1.default.dim(`  Could not retrieve ALB target health: ${error.message}`));
+        return undefined;
+    }
+}
+/**
+ * Gets Secrets Manager secret information
+ */
+async function getSecretInfo(secretArn, region, awsProfile) {
+    try {
+        // Configure AWS SDK client
+        const clientConfig = { region };
+        if (awsProfile) {
+            clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile: awsProfile });
+        }
+        const client = new client_secrets_manager_1.SecretsManagerClient(clientConfig);
+        const command = new client_secrets_manager_1.DescribeSecretCommand({
+            SecretId: secretArn,
+        });
+        const response = await client.send(command);
+        // Only use LastChangedDate - do NOT fall back to CreatedDate
+        // If LastChangedDate is undefined, the secret has never been modified
+        // Extract full secret name from ARN (includes random suffix)
+        // ARN format: arn:aws:secretsmanager:region:account:secret:name-suffix
+        const fullSecretName = secretArn.split(":secret:")[1] || response.Name || secretArn;
+        return {
+            name: fullSecretName,
+            lastModified: response.LastChangedDate,
+            accessible: true,
+        };
+    }
+    catch (error) {
+        // Extract secret name from ARN: arn:aws:secretsmanager:region:account:secret:name-6chars
+        // The secret name is everything after "secret:" in the ARN
+        const secretName = secretArn.split(":secret:")[1] || secretArn.split(":").pop() || secretArn;
+        return {
+            name: secretName,
+            accessible: false,
+            error: error.message,
+        };
+    }
+}
+/**
+ * Gets ALB listener rules information
+ */
+async function getListenerRules(stackName, region, awsProfile) {
+    try {
+        // Configure AWS SDK clients
+        const clientConfig = { region };
+        if (awsProfile) {
+            clientConfig.credentials = (0, credential_providers_1.fromIni)({ profile: awsProfile });
+        }
+        const cfClient = new client_cloudformation_1.CloudFormationClient(clientConfig);
+        const elbClient = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client(clientConfig);
+        // Find Listener Rule resources in stack
+        const resourcesCommand = new client_cloudformation_1.DescribeStackResourcesCommand({
+            StackName: stackName,
+        });
+        const resourcesResponse = await cfClient.send(resourcesCommand);
+        const listenerRules = resourcesResponse.StackResources?.filter((r) => r.ResourceType === "AWS::ElasticLoadBalancingV2::ListenerRule") || [];
+        if (listenerRules.length === 0) {
+            return undefined;
+        }
+        const result = [];
+        // Get details for each listener rule
+        for (const ruleResource of listenerRules) {
+            const ruleArn = ruleResource.PhysicalResourceId;
+            if (!ruleArn)
+                continue;
+            // Extract listener ARN from rule ARN
+            const listenerArnMatch = ruleArn.match(/(arn:aws:elasticloadbalancing:[^:]+:[^:]+:listener\/[^/]+\/[^/]+\/[^/]+)/);
+            if (!listenerArnMatch)
+                continue;
+            const listenerArn = listenerArnMatch[1];
+            const rulesCommand = new client_elastic_load_balancing_v2_1.DescribeRulesCommand({
+                ListenerArn: listenerArn,
+            });
+            const rulesResponse = await elbClient.send(rulesCommand);
+            const rule = rulesResponse.Rules?.find((r) => r.RuleArn === ruleArn);
+            if (rule) {
+                const pathCondition = rule.Conditions?.find((c) => c.Field === "path-pattern");
+                const path = pathCondition?.Values?.[0] || "N/A";
+                const targetGroupArn = rule.Actions?.[0]?.TargetGroupArn || "N/A";
+                result.push({
+                    priority: rule.Priority || "N/A",
+                    path,
+                    targetGroupArn: targetGroupArn.split("/").pop() || targetGroupArn,
+                });
+            }
+        }
+        return result.length > 0 ? result : undefined;
+    }
+    catch (error) {
+        // Listener rules are optional, don't fail the entire command
+        console.error(chalk_1.default.dim(`  Could not retrieve listener rules: ${error.message}`));
+        return undefined;
+    }
+}
+/**
+ * Fetches complete status including all health checks
+ */
+async function fetchCompleteStatus(stackArn, stackName, region, awsProfile) {
+    const result = await getStackStatus(stackArn, region, awsProfile);
+    if (!result.success) {
+        return result;
+    }
+    // Get additional info in parallel
+    const secretArn = result.stackOutputs?.secretArn;
+    const [ecsServices, albTargetGroups, secretInfo, listenerRules, stackEvents] = await Promise.all([
+        getEcsServiceHealth(stackName, region, awsProfile),
+        getAlbTargetHealth(stackName, region, awsProfile),
+        secretArn ? getSecretInfo(secretArn, region, awsProfile) : Promise.resolve(undefined),
+        getListenerRules(stackName, region, awsProfile),
+        getRecentStackEvents(stackName, region, awsProfile, 3),
+    ]);
+    result.ecsServices = ecsServices;
+    result.albTargetGroups = albTargetGroups;
+    result.secretInfo = secretInfo;
+    result.listenerRules = listenerRules;
+    result.stackEvents = stackEvents;
+    return result;
+}
+/**
+ * Displays status result to console
+ */
+/* istanbul ignore next */
+function displayStatusResult(result, profile) {
+    const stackName = result.stackArn?.match(/stack\/([^/]+)\//)?.[1] || result.stackArn || "Unknown";
+    const region = result.region || "Unknown";
+    // Format last updated time in local timezone
+    let lastUpdatedStr = "";
+    if (result.lastUpdateTime) {
+        const lastUpdated = new Date(result.lastUpdateTime);
+        const timeStr = lastUpdated.toLocaleString("en-US", {
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            hour12: false,
+        });
+        const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+        lastUpdatedStr = ` @ ${timeStr} (${timezone})`;
+    }
+    // Display header with last updated time
+    console.log(chalk_1.default.bold(`\nStack Status for Profile: ${profile}${lastUpdatedStr}\n`));
+    console.log(chalk_1.default.dim("─".repeat(80)));
+    console.log(`${chalk_1.default.bold("Stack:")} ${chalk_1.default.cyan(stackName)}  ${chalk_1.default.bold("Region:")} ${chalk_1.default.cyan(region)}`);
+    console.log(`${chalk_1.default.bold("Stack Status:")} ${formatStackStatus(result.stackStatus)}  ${chalk_1.default.bold("BenchlingIntegration:")} ${result.benchlingIntegrationEnabled ? chalk_1.default.green("✓ Enabled") : chalk_1.default.yellow("⚠ Disabled")}`);
+    console.log("");
+    // Display stack outputs and secret info on one line each
+    if (result.stackOutputs) {
+        if (result.stackOutputs.benchlingUrl) {
+            console.log(`${chalk_1.default.bold("Benchling URL:")} ${chalk_1.default.cyan(result.stackOutputs.benchlingUrl)}`);
+        }
+        if (result.stackOutputs.dockerImage) {
+            console.log(`${chalk_1.default.bold("Docker Image:")} ${chalk_1.default.dim(result.stackOutputs.dockerImage)}`);
+        }
+    }
+    // Display secret info on one line
+    if (result.secretInfo) {
+        let secretLine = `${chalk_1.default.bold("Secrets Manager:")} `;
+        if (result.secretInfo.accessible) {
+            if (result.secretInfo.lastModified) {
+                // Secret has been modified - show with green checkmark
+                secretLine += `${chalk_1.default.green("✓")} ${chalk_1.default.cyan(result.secretInfo.name)}`;
+                const deltaMs = Date.now() - result.secretInfo.lastModified.getTime();
+                const minutes = Math.floor(deltaMs / 60000);
+                const hours = Math.floor(minutes / 60);
+                const days = Math.floor(hours / 24);
+                let timeStr;
+                if (days > 0) {
+                    timeStr = `${days} day${days !== 1 ? "s" : ""} ago`;
+                }
+                else if (hours > 0) {
+                    timeStr = `${hours} hour${hours !== 1 ? "s" : ""} ago`;
+                }
+                else if (minutes > 0) {
+                    timeStr = `${minutes} minute${minutes !== 1 ? "s" : ""} ago`;
+                }
+                else {
+                    timeStr = "just now";
+                }
+                secretLine += chalk_1.default.dim(` (Last modified: ${timeStr})`);
+            }
+            else {
+                // Secret never modified - needs attention!
+                secretLine += `${chalk_1.default.red(result.secretInfo.name)} ${chalk_1.default.red("(NEVER MODIFIED - needs updating)")}`;
+            }
+        }
+        else {
+            secretLine += `${chalk_1.default.red("✗")} ${chalk_1.default.red(result.secretInfo.name)} - ${chalk_1.default.dim(result.secretInfo.error || "Inaccessible")}`;
+        }
+        console.log(secretLine);
+    }
+    // Display log groups
+    if (result.stackOutputs?.ecsLogGroup || result.stackOutputs?.apiGatewayLogGroup) {
+        console.log(`${chalk_1.default.bold("CloudWatch Logs:")}`);
+        if (result.stackOutputs.ecsLogGroup) {
+            console.log(`  ${chalk_1.default.cyan("ECS:")} ${chalk_1.default.dim(result.stackOutputs.ecsLogGroup)}`);
+        }
+        if (result.stackOutputs.apiGatewayLogGroup) {
+            console.log(`  ${chalk_1.default.cyan("API Gateway:")} ${chalk_1.default.dim(result.stackOutputs.apiGatewayLogGroup)}`);
+        }
+    }
+    console.log("");
+    // Display listener rules
+    if (result.listenerRules && result.listenerRules.length > 0) {
+        console.log(chalk_1.default.bold("ALB Listener Rules:"));
+        for (const rule of result.listenerRules) {
+            console.log(`  ${chalk_1.default.cyan(rule.path)} ${chalk_1.default.dim(`(priority: ${rule.priority})`)}`);
+            console.log(`    → ${chalk_1.default.dim(rule.targetGroupArn)}`);
+        }
+        console.log("");
+    }
+    // Display ECS service health in compact table format
+    if (result.ecsServices && result.ecsServices.length > 0) {
+        console.log(chalk_1.default.bold("ECS Services:"));
+        // Table header
+        const statusHeader = "Status";
+        const nameHeader = "Service";
+        const tasksHeader = "Tasks";
+        const rolloutHeader = "Rollout";
+        const logHeader = "Log Group";
+        // Calculate column widths
+        const maxNameLen = Math.max(nameHeader.length, ...result.ecsServices.map(s => s.serviceName.length));
+        const nameWidth = Math.min(maxNameLen + 2, 40); // Cap at 40 chars
+        const tasksWidth = 12;
+        const rolloutWidth = 15;
+        // Print header
+        console.log(`  ${statusHeader.padEnd(8)} ${nameHeader.padEnd(nameWidth)} ${tasksHeader.padEnd(tasksWidth)} ${rolloutHeader.padEnd(rolloutWidth)} ${logHeader}`);
+        console.log(`  ${chalk_1.default.dim("─".repeat(8))} ${chalk_1.default.dim("─".repeat(nameWidth))} ${chalk_1.default.dim("─".repeat(tasksWidth))} ${chalk_1.default.dim("─".repeat(rolloutWidth))} ${chalk_1.default.dim("─".repeat(30))}`);
+        // Print rows
+        for (const svc of result.ecsServices) {
+            const statusIcon = svc.status === "ACTIVE" ? "✓" : "⚠";
+            const statusColor = svc.status === "ACTIVE" ? chalk_1.default.green : chalk_1.default.yellow;
+            const tasksMatch = svc.runningCount === svc.desiredCount;
+            const tasksColor = tasksMatch ? chalk_1.default.green : chalk_1.default.yellow;
+            const statusCol = `${statusColor(statusIcon)} ${statusColor(svc.status)}`.padEnd(8 + 10); // +10 for ANSI codes
+            const nameCol = chalk_1.default.cyan(svc.serviceName.padEnd(nameWidth));
+            const tasksText = svc.pendingCount > 0
+                ? `${svc.runningCount}/${svc.desiredCount} (${svc.pendingCount} pending)`
+                : `${svc.runningCount}/${svc.desiredCount}`;
+            const tasksCol = tasksColor(tasksText).padEnd(tasksWidth + (tasksMatch ? 10 : 10)); // Account for ANSI
+            let rolloutCol = "";
+            if (svc.rolloutState) {
+                if (svc.rolloutState === "COMPLETED") {
+                    rolloutCol = chalk_1.default.green(svc.rolloutState).padEnd(rolloutWidth + 10);
+                }
+                else if (svc.rolloutState === "FAILED") {
+                    rolloutCol = chalk_1.default.red(svc.rolloutState + " ❌").padEnd(rolloutWidth + 10);
+                }
+                else {
+                    rolloutCol = chalk_1.default.yellow(svc.rolloutState).padEnd(rolloutWidth + 10);
+                }
+            }
+            else {
+                rolloutCol = chalk_1.default.dim("-").padEnd(rolloutWidth + 10);
+            }
+            let logCol;
+            if (svc.logGroup) {
+                if (svc.logStreamPrefix) {
+                    logCol = chalk_1.default.dim(`${svc.logGroup}/${svc.logStreamPrefix}`);
+                }
+                else {
+                    logCol = chalk_1.default.dim(svc.logGroup);
+                }
+            }
+            else {
+                logCol = chalk_1.default.dim("-");
+            }
+            console.log(`  ${statusCol} ${nameCol} ${tasksCol} ${rolloutCol} ${logCol}`);
+        }
+        console.log("");
+    }
+    // Display ALB target group health
+    if (result.albTargetGroups && result.albTargetGroups.length > 0) {
+        console.log(chalk_1.default.bold("ALB Target Groups:"));
+        for (const tg of result.albTargetGroups) {
+            const allHealthy = tg.healthyCount > 0 && tg.unhealthyCount === 0;
+            const hasUnhealthy = tg.unhealthyCount > 0;
+            const statusIcon = allHealthy ? "✓" : hasUnhealthy ? "✗" : "⚠";
+            const statusColor = allHealthy ? chalk_1.default.green : hasUnhealthy ? chalk_1.default.red : chalk_1.default.yellow;
+            console.log(`  ${statusColor(statusIcon)} ${chalk_1.default.cyan(tg.targetGroupName)}`);
+            console.log(`    Targets: ${chalk_1.default.green(`${tg.healthyCount} healthy`)}${tg.unhealthyCount > 0 ? chalk_1.default.red(` / ${tg.unhealthyCount} unhealthy`) : ""}${tg.drainingCount > 0 ? chalk_1.default.dim(` / ${tg.drainingCount} draining`) : ""}`);
+            // Show unhealthy target details
+            const unhealthyTargets = tg.targets.filter((t) => t.health === "unhealthy");
+            if (unhealthyTargets.length > 0) {
+                for (const target of unhealthyTargets) {
+                    console.log(`      ${chalk_1.default.red("✗")} ${chalk_1.default.dim(target.id)}: ${chalk_1.default.red(target.health)}`);
+                    if (target.reason) {
+                        console.log(`        ${chalk_1.default.dim(target.reason)}`);
+                    }
+                }
+            }
+        }
+        console.log("");
+    }
+    // Display recent stack events
+    if (result.stackEvents && result.stackEvents.length > 0) {
+        const now = new Date();
+        console.log(chalk_1.default.bold("Recent Stack Events:"));
+        console.log(chalk_1.default.dim(`  Current time: ${now.toISOString().replace("T", " ").substring(0, 19)} UTC\n`));
+        for (const event of result.stackEvents) {
+            // Calculate time delta
+            const deltaMs = now.getTime() - event.timestamp.getTime();
+            const deltaMinutes = Math.floor(deltaMs / 60000);
+            const deltaHours = Math.floor(deltaMinutes / 60);
+            const deltaDays = Math.floor(deltaHours / 24);
+            let deltaStr;
+            if (deltaDays > 0) {
+                deltaStr = `${deltaDays}d ${deltaHours % 24}h ago`;
+            }
+            else if (deltaHours > 0) {
+                deltaStr = `${deltaHours}h ${deltaMinutes % 60}m ago`;
+            }
+            else if (deltaMinutes > 0) {
+                deltaStr = `${deltaMinutes}m ago`;
+            }
+            else {
+                deltaStr = "just now";
+            }
+            const statusStr = formatStackStatus(event.status);
+            console.log(`  ${chalk_1.default.dim(deltaStr.padEnd(15))} ${statusStr}`);
+            console.log(`    ${chalk_1.default.cyan(event.resourceId)}`);
+            if (event.reason && event.reason !== "None") {
+                console.log(`    ${chalk_1.default.dim(event.reason)}`);
+            }
+        }
+        console.log("");
+    }
+    // Show next steps based on status
+    if (result.stackStatus?.includes("IN_PROGRESS")) {
+        console.log(chalk_1.default.bold("Status:"));
+        console.log(chalk_1.default.yellow("  ⏳ Stack update in progress..."));
+        console.log(chalk_1.default.dim("  Auto-refreshing until complete...\n"));
+    }
+    else if (result.stackStatus?.includes("COMPLETE") && !result.stackStatus.includes("ROLLBACK")) {
+        console.log(chalk_1.default.bold("Status:"));
+        console.log(chalk_1.default.green("  ✓ Stack is up to date\n"));
+        if (!result.benchlingIntegrationEnabled) {
+            console.log(chalk_1.default.bold("Action Required:"));
+            console.log(chalk_1.default.yellow("  BenchlingIntegration is Disabled"));
+            console.log(chalk_1.default.dim("  Enable it via CloudFormation console or re-run setup\n"));
+        }
+    }
+    else if (result.stackStatus?.includes("FAILED") || result.stackStatus?.includes("ROLLBACK")) {
+        console.log(chalk_1.default.bold("Status:"));
+        console.log(chalk_1.default.red("  ❌ Stack update failed or rolled back"));
+        console.log(chalk_1.default.dim("  Check CloudFormation console for detailed error messages\n"));
+    }
+    // CloudFormation console link
+    const stackArn = result.stackArn || "";
+    const consoleUrl = `https://${region}.console.aws.amazon.com/cloudformation/home?region=${region}#/stacks/stackinfo?stackId=${encodeURIComponent(stackArn)}`;
+    console.log(chalk_1.default.bold("CloudFormation Console:"));
+    console.log(chalk_1.default.cyan(`  ${consoleUrl}\n`));
+    console.log(chalk_1.default.dim("─".repeat(80)));
+}
+/**
+ * Status command implementation
+ */
+async function statusCommand(options = {}) {
+    const { profile = "default", awsProfile, configStorage, timer, } = options;
+    const xdg = configStorage || new xdg_config_1.XDGConfig();
+    // Load configuration
+    let config;
+    try {
+        config = xdg.readProfile(profile);
+    }
+    catch {
+        const errorMsg = `Profile '${profile}' not found. Run setup first.`;
+        console.error(chalk_1.default.red(`\n❌ ${errorMsg}\n`));
+        return {
+            success: false,
+            error: errorMsg,
+        };
+    }
+    // Check if integrated stack
+    if (!config.integratedStack) {
+        const errorMsg = "Status command is only available for integrated stack mode";
+        console.log(chalk_1.default.yellow(`\n⚠️  ${errorMsg}\n`));
+        console.log(chalk_1.default.dim("This profile is configured for standalone deployment."));
+        console.log(chalk_1.default.dim("Use CloudFormation console to check webhook stack status.\n"));
+        return {
+            success: false,
+            error: errorMsg,
+        };
+    }
+    // Extract stack info
+    const stackArn = config.quilt.stackArn;
+    const region = config.deployment.region;
+    const stackName = stackArn.match(/stack\/([^/]+)\//)?.[1] || stackArn;
+    // Parse timer value
+    const refreshInterval = parseTimerValue(timer);
+    // Setup Ctrl+C handler for graceful exit
+    let shouldExit = false;
+    const exitHandler = () => {
+        shouldExit = true;
+        console.log(chalk_1.default.dim("\n\n⚠️  Interrupted by user. Exiting...\n"));
+        process.exit(0);
+    };
+    process.on("SIGINT", exitHandler);
+    try {
+        let result;
+        let isFirstRun = true;
+        // Watch loop
+        while (true) {
+            // Clear screen on subsequent runs
+            if (!isFirstRun && refreshInterval) {
+                clearScreen();
+            }
+            // Fetch and display status
+            result = await fetchCompleteStatus(stackArn, stackName, region, awsProfile);
+            if (!result.success) {
+                console.error(chalk_1.default.red(`❌ Failed to get stack status: ${result.error}\n`));
+                return result;
+            }
+            displayStatusResult(result, profile);
+            // Check if we should exit (no timer or user disabled it)
+            if (!refreshInterval) {
+                break;
+            }
+            // If terminal status, announce completion and exit
+            if (isTerminalStatus(result.stackStatus)) {
+                if (result.stackStatus?.includes("COMPLETE") && !result.stackStatus.includes("ROLLBACK")) {
+                    console.log(chalk_1.default.green("✓ Stack reached stable state. Monitoring complete.\n"));
+                }
+                else if (result.stackStatus?.includes("FAILED") || result.stackStatus?.includes("ROLLBACK")) {
+                    console.log(chalk_1.default.red("✗ Stack operation failed. Monitoring stopped.\n"));
+                }
+                else {
+                    console.log(chalk_1.default.dim("⟳ Stack reached terminal state. Auto-refresh stopped.\n"));
+                }
+                break;
+            }
+            // Show countdown with live updates
+            const totalSeconds = Math.floor(refreshInterval / 1000);
+            const spinner = (0, ora_1.default)({
+                text: chalk_1.default.dim(`⟳ Refreshing in ${totalSeconds} second${totalSeconds !== 1 ? "s" : ""}... (Ctrl+C to exit)`),
+                color: "gray",
+            }).start();
+            for (let i = totalSeconds; i > 0; i--) {
+                spinner.text = chalk_1.default.dim(`⟳ Refreshing in ${i} second${i !== 1 ? "s" : ""}... (Ctrl+C to exit)`);
+                await sleep(1000);
+                if (shouldExit)
+                    break;
+            }
+            spinner.stop();
+            if (shouldExit) {
+                break;
+            }
+            isFirstRun = false;
+        }
+        // Clean up handler
+        process.off("SIGINT", exitHandler);
+        return result;
+    }
+    catch (error) {
+        // Clean up handler on error
+        process.off("SIGINT", exitHandler);
+        throw error;
+    }
+}
+//# sourceMappingURL=status.js.map