@quiltdata/benchling-webhook 0.4.13

package/bin/benchling-webhook.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import * as cdk from "aws-cdk-lib";
+import { BenchlingWebhookStack } from "../lib/benchling-webhook-stack";
+
+// Import get-env to infer configuration from catalog
+const { inferStackConfig } = require("./get-env.js");
+const { execSync } = require("child_process");
+
+/**
+ * Check if CDK is bootstrapped for the given account/region
+ */
+async function checkCdkBootstrap(account: string, region: string): Promise<void> {
+    try {
+        console.log(`Checking CDK bootstrap for account ${account} in ${region}...`);
+
+        // Check if bootstrap stack exists
+        const result = execSync(
+            `aws cloudformation describe-stacks --region ${region} --stack-name CDKToolkit --query "Stacks[0].StackStatus" --output text 2>&1`,
+            { encoding: "utf-8" }
+        );
+
+        const stackStatus = result.trim();
+
+        if (stackStatus.includes("does not exist") || stackStatus.includes("ValidationError")) {
+            console.error("\n❌ CDK Bootstrap Error");
+            console.error("=".repeat(80));
+            console.error(`CDK is not bootstrapped for account ${account} in region ${region}`);
+            console.error("\nTo bootstrap CDK, run:");
+            console.error(`  npx cdk bootstrap aws://${account}/${region}`);
+            console.error("\nOr source your .env and run:");
+            console.error(`  source .env`);
+            console.error(`  npx cdk bootstrap aws://\${CDK_DEFAULT_ACCOUNT}/\${CDK_DEFAULT_REGION}`);
+            console.error("=".repeat(80));
+            process.exit(1);
+        }
+
+        // Check if the stack is in a good state
+        if (!stackStatus.includes("COMPLETE")) {
+            console.error("\n⚠️  CDK Bootstrap Warning");
+            console.error("=".repeat(80));
+            console.error(`CDKToolkit stack is in state: ${stackStatus}`);
+            console.error("This may cause deployment issues.");
+            console.error("=".repeat(80));
+        } else {
+            console.log(`✓ CDK is bootstrapped (CDKToolkit stack: ${stackStatus})\n`);
+        }
+    } catch (error) {
+        console.error("\n⚠️  Warning: Could not verify CDK bootstrap status");
+        console.error(`Error: ${(error as Error).message}`);
+        console.error("\nProceeding anyway, but deployment may fail if CDK is not bootstrapped.\n");
+    }
+}
+
+/**
+ * Get environment configuration with catalog inference
+ *
+ * This combines user-provided values from .env with inferred values from the Quilt catalog.
+ * User values always take precedence over inferred values.
+ */
+async function getConfig() {
+    const userEnv = process.env;
+    let inferredEnv: Record<string, string> = {};
+
+    // If QUILT_CATALOG is provided, try to infer additional configuration
+    if (userEnv.QUILT_CATALOG) {
+        try {
+            console.log(`Inferring configuration from catalog: ${userEnv.QUILT_CATALOG}`);
+            const result = await inferStackConfig(`https://${userEnv.QUILT_CATALOG.replace(/^https?:\/\//, '')}`);
+            inferredEnv = result.inferredVars;
+            console.log("✓ Successfully inferred stack configuration\n");
+        } catch (error) {
+            console.error(`Warning: Could not infer configuration from catalog: ${(error as Error).message}`);
+            console.error("Falling back to environment variables only.\n");
+        }
+    }
+
+    // Merge: user env takes precedence over inferred values
+    const config = { ...inferredEnv, ...userEnv };
+
+    // Validate required user-provided values
+    const requiredUserVars = [
+        "QUILT_CATALOG",
+        "QUILT_USER_BUCKET",
+        "BENCHLING_CLIENT_ID",
+        "BENCHLING_CLIENT_SECRET",
+        "BENCHLING_TENANT",
+    ];
+
+    const missingVars = requiredUserVars.filter((varName) => !config[varName]);
+
+    if (missingVars.length > 0) {
+        console.error("Error: Missing required environment variables:");
+        missingVars.forEach((varName) => {
+            console.error(`  - ${varName}`);
+        });
+        console.error("\nPlease set these variables in your .env file.");
+        console.error("See env.template for guidance.");
+        process.exit(1);
+    }
+
+    // Validate inferred values are present (should be available if catalog lookup succeeded)
+    const requiredInferredVars = [
+        "CDK_DEFAULT_ACCOUNT",
+        "CDK_DEFAULT_REGION",
+        "QUEUE_NAME",
+        "SQS_QUEUE_URL",
+        "QUILT_DATABASE",
+    ];
+
+    const missingInferredVars = requiredInferredVars.filter((varName) => !config[varName]);
+
+    if (missingInferredVars.length > 0) {
+        console.error("Error: Could not infer required configuration:");
+        missingInferredVars.forEach((varName) => {
+            console.error(`  - ${varName}`);
+        });
+        console.error("\nThese values should be automatically inferred from your Quilt catalog.");
+        console.error("Please ensure:");
+        console.error("  1. QUILT_CATALOG is set correctly");
+        console.error("  2. Your AWS credentials have CloudFormation read permissions");
+        console.error("  3. The Quilt stack is deployed and accessible");
+        console.error("\nAlternatively, you can manually set these values in your .env file.");
+        process.exit(1);
+    }
+
+    // Validate conditional requirements
+    if (config.ENABLE_WEBHOOK_VERIFICATION !== "false" && !config.BENCHLING_APP_DEFINITION_ID) {
+        console.error("Error: BENCHLING_APP_DEFINITION_ID is required when webhook verification is enabled.");
+        console.error("Either set BENCHLING_APP_DEFINITION_ID or set ENABLE_WEBHOOK_VERIFICATION=false");
+        process.exit(1);
+    }
+
+    return config;
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+    const config = await getConfig();
+
+    // Validate CDK bootstrap before proceeding
+    await checkCdkBootstrap(config.CDK_DEFAULT_ACCOUNT!, config.CDK_DEFAULT_REGION!);
+
+    const app = new cdk.App();
+    new BenchlingWebhookStack(app, "BenchlingWebhookStack", {
+        env: {
+            account: config.CDK_DEFAULT_ACCOUNT,
+            region: config.CDK_DEFAULT_REGION,
+        },
+        bucketName: config.QUILT_USER_BUCKET!, // User's data bucket
+        queueName: config.QUEUE_NAME!,
+        environment: "production",
+        prefix: config.PKG_PREFIX || "benchling",
+        benchlingClientId: config.BENCHLING_CLIENT_ID!,
+        benchlingClientSecret: config.BENCHLING_CLIENT_SECRET!,
+        benchlingTenant: config.BENCHLING_TENANT!,
+        quiltCatalog: config.QUILT_CATALOG!,
+        quiltDatabase: config.QUILT_DATABASE!,
+        webhookAllowList: config.WEBHOOK_ALLOW_LIST,
+        logLevel: config.LOG_LEVEL || "INFO",
+        // ECR repository configuration
+        createEcrRepository: config.CREATE_ECR_REPOSITORY === "true",
+        ecrRepositoryName: config.ECR_REPOSITORY_NAME || "quiltdata/benchling",
+    });
+}
+
+main().catch((error) => {
+    console.error("Fatal error during CDK synthesis:", error);
+    process.exit(1);
+});

package/bin/check-logs.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+/**
+ * Check CloudWatch logs for the deployed Benchling webhook ECS service
+ * Uses CloudFormation stack outputs to find the correct log group
+ */
+
+require("dotenv/config");
+const { execSync } = require("child_process");
+
+const STACK_NAME = "BenchlingWebhookStack";
+
+// Validate required environment variables
+if (!process.env.CDK_DEFAULT_REGION) {
+    console.error("Error: CDK_DEFAULT_REGION is not set in .env file");
+    console.error("Please set CDK_DEFAULT_REGION in your .env file");
+    process.exit(1);
+}
+
+const AWS_REGION = process.env.CDK_DEFAULT_REGION;
+
+function getStackOutputs() {
+    try {
+        const output = execSync(
+            `aws cloudformation describe-stacks --stack-name ${STACK_NAME} --region ${AWS_REGION} --query 'Stacks[0].Outputs' --output json`,
+            { encoding: "utf-8" },
+        );
+        return JSON.parse(output);
+    } catch (error) {
+        console.error(`Error: Could not get stack outputs for ${STACK_NAME}`);
+        console.error("Make sure the stack is deployed and AWS credentials are configured.");
+        process.exit(1);
+    }
+}
+
+function getLogGroupFromOutputs(outputs, logType) {
+    let outputKey;
+    if (logType === "ecs") {
+        outputKey = "EcsLogGroup";
+    } else if (logType === "api") {
+        outputKey = "ApiGatewayLogGroup";
+    } else if (logType === "api-exec") {
+        outputKey = "ApiGatewayExecutionLogGroup";
+    }
+
+    const logGroupOutput = outputs.find((o) => o.OutputKey === outputKey);
+
+    if (!logGroupOutput) {
+        console.error(`Error: Could not find ${outputKey} in stack outputs`);
+        console.error("Make sure the stack has been deployed with the latest changes.");
+        process.exit(1);
+    }
+
+    return logGroupOutput.OutputValue;
+}
+
+function printStackInfo(outputs, logGroup, logType) {
+    console.log("=".repeat(80));
+    console.log("Benchling Webhook Stack Information");
+    console.log("=".repeat(80));
+
+    const clusterName = outputs.find((o) => o.OutputKey === "FargateServiceClusterNameCD3B109F");
+    const serviceName = outputs.find((o) => o.OutputKey === "FargateServiceServiceName24CFD869");
+    const webhookEndpoint = outputs.find((o) => o.OutputKey === "WebhookEndpoint");
+    const version = outputs.find((o) => o.OutputKey === "StackVersion");
+    const ecsLogGroup = outputs.find((o) => o.OutputKey === "EcsLogGroup");
+    const apiLogGroup = outputs.find((o) => o.OutputKey === "ApiGatewayLogGroup");
+    const apiExecLogGroup = outputs.find((o) => o.OutputKey === "ApiGatewayExecutionLogGroup");
+    const albDns = outputs.find((o) => o.OutputKey === "LoadBalancerDNS");
+
+    if (clusterName) console.log(`Cluster:   ${clusterName.OutputValue}`);
+    if (serviceName) console.log(`Service:   ${serviceName.OutputValue}`);
+    if (webhookEndpoint) console.log(`Endpoint:  ${webhookEndpoint.OutputValue}`);
+    if (albDns) console.log(`ALB DNS:   ${albDns.OutputValue}`);
+    if (version) console.log(`Version:   ${version.OutputValue}`);
+
+    console.log("");
+    console.log("Log Groups:");
+    if (ecsLogGroup) console.log(`  ECS:         ${ecsLogGroup.OutputValue}${logType === "ecs" ? " (viewing)" : ""}`);
+    if (apiLogGroup) console.log(`  API Access:  ${apiLogGroup.OutputValue}${logType === "api" ? " (viewing)" : ""}`);
+    if (apiExecLogGroup) console.log(`  API Exec:    ${apiExecLogGroup.OutputValue}${logType === "api-exec" ? " (viewing)" : ""}`);
+
+    console.log("=".repeat(80));
+    console.log("");
+}
+
+function main() {
+    const args = process.argv.slice(2);
+    const logType = args.find((arg) => arg.startsWith("--type="))?.split("=")[1] || "all";
+    const filterPattern = args.find((arg) => arg.startsWith("--filter="))?.split("=")[1];
+    const since = args.find((arg) => arg.startsWith("--since="))?.split("=")[1] || "5m";
+    const follow = args.includes("--follow") || args.includes("-f");
+    const tail = args.find((arg) => arg.startsWith("--tail="))?.split("=")[1] || "100";
+
+    // Validate log type
+    if (!["ecs", "api", "api-exec", "all"].includes(logType)) {
+        console.error("Error: --type must be 'ecs', 'api', 'api-exec', or 'all'");
+        process.exit(1);
+    }
+
+    // Get stack outputs
+    const outputs = getStackOutputs();
+
+    // Handle 'all' type - show all three log groups
+    if (logType === "all") {
+        printStackInfo(outputs, null, "all");
+        console.log("Showing logs from all sources (most recent first):\n");
+
+        const logGroupDefs = [
+            { type: "ECS", group: outputs.find((o) => o.OutputKey === "EcsLogGroup")?.OutputValue },
+            { type: "API-Access", group: outputs.find((o) => o.OutputKey === "ApiGatewayLogGroup")?.OutputValue },
+            { type: "API-Exec", group: outputs.find((o) => o.OutputKey === "ApiGatewayExecutionLogGroup")?.OutputValue },
+        ];
+
+        // Warn about missing log groups
+        const missingGroups = logGroupDefs.filter(lg => !lg.group);
+        if (missingGroups.length > 0) {
+            console.log("⚠️  WARNING: Some log groups are not available in stack outputs:");
+            missingGroups.forEach(({ type }) => {
+                console.log(`   - ${type}: Stack output not found (may need to redeploy stack)`);
+            });
+            console.log("");
+        }
+
+        const logGroups = logGroupDefs.filter(lg => lg.group);
+
+        for (const { type, group } of logGroups) {
+            console.log(`\n${"=".repeat(80)}`);
+            console.log(`${type}: ${group}`);
+            console.log("=".repeat(80));
+
+            let command = `aws logs tail "${group}"`;
+            command += ` --region ${AWS_REGION}`;
+            command += ` --since ${since}`;
+            command += ` --format short`;
+            if (filterPattern) {
+                command += ` --filter-pattern "${filterPattern}"`;
+            }
+            command += ` 2>&1 | tail -${tail}`;
+
+            try {
+                const output = execSync(command, { encoding: "utf-8", shell: "/bin/bash" });
+                if (output.trim()) {
+                    console.log(output);
+                } else {
+                    console.log(`(No logs in the last ${since})`);
+                }
+            } catch (error) {
+                console.log(`Error reading ${type} logs: ${error.message}`);
+            }
+        }
+        return;
+    }
+
+    const logGroup = getLogGroupFromOutputs(outputs, logType);
+    printStackInfo(outputs, logGroup, logType);
+
+    // Build AWS logs command
+    let command = `aws logs tail ${logGroup}`;
+    command += ` --region ${AWS_REGION}`;
+    command += ` --since ${since}`;
+    command += ` --format short`;
+
+    if (filterPattern) {
+        command += ` --filter-pattern "${filterPattern}"`;
+    }
+
+    if (follow) {
+        command += " --follow";
+        console.log("Following logs (Press Ctrl+C to stop)...\n");
+    } else {
+        command += ` | tail -${tail}`;
+        console.log(`Showing last ${tail} log entries from the past ${since}...\n`);
+    }
+
+    // Execute logs command
+    try {
+        execSync(command, { stdio: "inherit" });
+    } catch (error) {
+        if (error.status !== 130) {
+            // Ignore Ctrl+C exit (status 130)
+            console.error("\nError fetching logs. Make sure:");
+            console.error("1. The stack is deployed");
+            console.error("2. AWS CLI is configured with proper credentials");
+            console.error("3. You have CloudWatch Logs read permissions");
+            process.exit(1);
+        }
+    }
+}
+
+function printHelp() {
+    console.log("Usage: npm run logs [options]");
+    console.log("");
+    console.log("Options:");
+    console.log("  --type=TYPE        Log group to view (default: all)");
+    console.log("                     all      = All logs (ECS, API Access, API Execution)");
+    console.log("                     ecs      = ECS container logs (application logs)");
+    console.log("                     api      = API Gateway access logs (requests/responses)");
+    console.log("                     api-exec = API Gateway execution logs (detailed debugging)");
+    console.log("  --since=TIME       Time period to fetch logs (default: 5m)");
+    console.log("                     Examples: 1h, 30m, 2d, 5m");
+    console.log("  --filter=PATTERN   Filter logs by pattern");
+    console.log("                     Examples: --filter=ERROR, --filter=canvas, --filter=500");
+    console.log("  --follow, -f       Follow log output (like tail -f, not available with --type=all)");
+    console.log("  --tail=N           Show last N lines (default: 100, only without --follow)");
+    console.log("  --help, -h         Show this help message");
+    console.log("");
+    console.log("Examples:");
+    console.log("  npm run logs                                   # View all logs from past 5 min");
+    console.log("  npm run logs -- --type=ecs                     # View only ECS logs");
+    console.log("  npm run logs -- --type=api-exec                # View API Gateway execution logs");
+    console.log("  npm run logs -- --since=1h                     # Last hour of all logs");
+    console.log("  npm run logs -- --filter=ERROR                 # Filter for errors in all logs");
+    console.log("  npm run logs -- --type=api-exec --filter=500   # API Gateway execution errors");
+    console.log("  npm run logs -- --type=ecs --follow            # Follow ECS logs");
+    console.log("  npm run logs -- --type=api-exec --since=10m    # Last 10 min of execution logs");
+}
+
+if (require.main === module) {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) {
+        printHelp();
+        process.exit(0);
+    }
+
+    try {
+        main();
+    } catch (error) {
+        console.error("Error:", error.message);
+        process.exit(1);
+    }
+}

package/bin/cli-auth.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+
+# Ensure environment variables are set
+if [[ -z "$BENCHLING_CLIENT_ID" || -z "$BENCHLING_TENANT" || -z "$BENCHLING_CLIENT_SECRET" ]]; then
+    echo "Error: Required environment variables are not set. Please source .env first."
+    exit 1
+fi
+
+# Debugging: Print the extracted values
+echo "BENCHLING_CLIENT_ID: $BENCHLING_CLIENT_ID"
+echo "BENCHLING_TENANT: $BENCHLING_TENANT"
+
+API_ROOT="https://${BENCHLING_TENANT}.benchling.com/api/v2"
+
+# Function to get OAuth Token
+get_token() {
+    curl -s -X POST "$API_ROOT/token" \
+        -H "Content-Type: application/x-www-form-urlencoded" \
+        -d "client_id=${BENCHLING_CLIENT_ID}" \
+        -d "client_secret=${BENCHLING_CLIENT_SECRET}" \
+        -d "grant_type=client_credentials" | jq -r '.access_token'
+}
+
+# Generic function to make API requests
+api_request() {
+    local method=$1
+    local endpoint=$2
+    local data=$3
+
+    curl -v -X "$method" "$API_ROOT/$endpoint" \
+        -H "Authorization: Bearer $TOKEN" \
+        -H "Content-Type: application/json" \
+        ${data:+--data "$data"}
+}
+
+# Get OAuth Token
+TOKEN=$(get_token)
+
+# Export TOKEN globally
+export TOKEN
+
+# Debugging: Print the token
+if [[ -z "$TOKEN" || "$TOKEN" == "null" ]]; then
+    echo "Error: Failed to retrieve access token."
+    exit 1
+fi
+echo "TOKEN: $TOKEN"
+
+# Check if CANVAS_ID is provided as an argument
+if [[ -n "$1" ]]; then
+    CANVAS_ID="$1"
+    echo "Fetching canvas with ID: $CANVAS_ID"
+    echo "=== $CANVAS_ID ==="
+    api_request "GET" "app-canvases/${CANVAS_ID}"
+    echo "=== $CANVAS_ID ==="
+
+    echo "Updating canvas with ID: $CANVAS_ID"
+    api_request "PATCH" "app-canvases/${CANVAS_ID}" '{
+        "blocks": [
+            {
+                "enabled": true,
+                "id": "user_defined_id",
+                "text": "Click me to submit",
+                "type": "BUTTON"
+            }
+        ],
+        "enabled": true,
+        "featureId": "quilt_integration"
+    }'
+
+else
+    echo "No canvas ID provided. Fetching apps instead."
+    api_request "GET" "apps"
+fi