@quiltdata/benchling-webhook 0.7.10 → 0.8.0-20251117T215047Z

package/dist/bin/xdg-launch.d.ts

@@ -0,0 +1,74 @@
+#!/usr/bin/env ts-node
+/**
+ * XDG Launch: Unified Configuration Bridge
+ *
+ * Single command to launch Flask application in different modes (native, docker, docker-dev)
+ * using profile-based XDG configuration as the single source of truth.
+ *
+ * Eliminates .env files and manual environment variable management.
+ *
+ * @module xdg-launch
+ * @version 0.8.0
+ */
+import { ProfileConfig } from "../lib/types/config";
+/**
+ * Launch mode options
+ */
+type LaunchMode = "native" | "docker" | "docker-dev";
+/**
+ * Launch configuration options
+ */
+interface LaunchOptions {
+    mode: LaunchMode;
+    profile: string;
+    port?: number;
+    verbose: boolean;
+    test: boolean;
+}
+/**
+ * Environment variables map
+ */
+type EnvVars = Record<string, string>;
+/**
+ * Parse command-line arguments
+ *
+ * @param argv - Command-line arguments
+ * @returns Parsed launch options
+ */
+declare function parseArguments(argv: string[]): LaunchOptions;
+/**
+ * Load XDG profile configuration
+ *
+ * @param profileName - Profile name
+ * @returns Profile configuration
+ */
+declare function loadProfile(profileName: string): ProfileConfig;
+/**
+ * Build environment variables from profile configuration
+ *
+ * Maps XDG config fields to service-specific environment variables.
+ *
+ * @param config - Profile configuration
+ * @param mode - Launch mode
+ * @param options - Launch options
+ * @returns Environment variables map
+ */
+declare function buildEnvVars(config: ProfileConfig, mode: LaunchMode, options: LaunchOptions): EnvVars;
+/**
+ * Validate required configuration
+ *
+ * Ensures all required service variables are present and well-formed.
+ *
+ * @param envVars - Environment variables to validate
+ * @param profile - Profile name (for error messages)
+ */
+declare function validateConfig(envVars: EnvVars, profile: string): void;
+/**
+ * Filter secrets from environment variables for verbose logging
+ *
+ * @param envVars - Environment variables
+ * @returns Filtered environment variables (secrets masked)
+ */
+declare function filterSecrets(envVars: EnvVars): EnvVars;
+export { parseArguments, loadProfile, buildEnvVars, validateConfig, filterSecrets };
+//# sourceMappingURL=xdg-launch.d.ts.map

package/dist/bin/xdg-launch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xdg-launch.d.ts","sourceRoot":"","sources":["../../bin/xdg-launch.ts"],"names":[],"mappings":";AACA;;;;;;;;;;GAUG;AAMH,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD;;GAEG;AACH,KAAK,UAAU,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;AAErD;;GAEG;AACH,UAAU,aAAa;IACnB,IAAI,EAAE,UAAU,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,KAAK,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEtC;;;;;GAKG;AACH,iBAAS,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,aAAa,CAyCrD;AA2BD;;;;;GAKG;AACH,iBAAS,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,aAAa,CAmBvD;AAgCD;;;;;;;;;GASG;AACH,iBAAS,YAAY,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CA+C9F;AAED;;;;;;;GAOG;AACH,iBAAS,cAAc,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CA2C/D;AAED;;;;;GAKG;AACH,iBAAS,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAWhD;AAgZD,OAAO,EAAE,cAAc,EAAE,WAAW,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,CAAC"}

package/dist/bin/xdg-launch.js

@@ -0,0 +1,588 @@
+#!/usr/bin/env ts-node
+"use strict";
+/**
+ * XDG Launch: Unified Configuration Bridge
+ *
+ * Single command to launch Flask application in different modes (native, docker, docker-dev)
+ * using profile-based XDG configuration as the single source of truth.
+ *
+ * Eliminates .env files and manual environment variable management.
+ *
+ * @module xdg-launch
+ * @version 0.8.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArguments = parseArguments;
+exports.loadProfile = loadProfile;
+exports.buildEnvVars = buildEnvVars;
+exports.validateConfig = validateConfig;
+exports.filterSecrets = filterSecrets;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const xdg_config_1 = require("../lib/xdg-config");
+/**
+ * Parse command-line arguments
+ *
+ * @param argv - Command-line arguments
+ * @returns Parsed launch options
+ */
+function parseArguments(argv) {
+    const args = argv.slice(2);
+    const options = {
+        profile: "default",
+        verbose: false,
+        test: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--mode" && i + 1 < args.length) {
+            const mode = args[++i];
+            if (mode !== "native" && mode !== "docker" && mode !== "docker-dev") {
+                throw new Error(`Invalid mode: ${mode}. Must be: native, docker, or docker-dev`);
+            }
+            options.mode = mode;
+        }
+        else if (arg === "--profile" && i + 1 < args.length) {
+            options.profile = args[++i];
+        }
+        else if (arg === "--port" && i + 1 < args.length) {
+            options.port = parseInt(args[++i], 10);
+            if (isNaN(options.port) || options.port < 1 || options.port > 65535) {
+                throw new Error(`Invalid port: ${args[i]}. Must be between 1 and 65535`);
+            }
+        }
+        else if (arg === "--verbose") {
+            options.verbose = true;
+        }
+        else if (arg === "--test") {
+            options.test = true;
+        }
+        else if (arg === "--help" || arg === "-h") {
+            printUsage();
+            process.exit(0);
+        }
+        else {
+            throw new Error(`Unknown option: ${arg}`);
+        }
+    }
+    if (!options.mode) {
+        throw new Error("Missing required option: --mode");
+    }
+    return options;
+}
+/**
+ * Print usage information
+ */
+function printUsage() {
+    console.log(`
+XDG Launch - Unified Configuration Bridge
+
+Usage: npx ts-node bin/xdg-launch.ts [OPTIONS]
+
+Options:
+  --mode <mode>         Execution mode: native, docker, docker-dev (required)
+  --profile <name>      XDG profile name (default: "default")
+  --port <number>       Override default port
+  --verbose             Enable verbose logging
+  --test                Run in test mode
+  --help, -h            Show this help message
+
+Examples:
+  npx ts-node bin/xdg-launch.ts --mode native --profile dev
+  npx ts-node bin/xdg-launch.ts --mode docker --profile default
+  npx ts-node bin/xdg-launch.ts --mode docker-dev --profile dev --verbose
+  npx ts-node bin/xdg-launch.ts --mode native --profile dev --test
+    `.trim());
+}
+/**
+ * Load XDG profile configuration
+ *
+ * @param profileName - Profile name
+ * @returns Profile configuration
+ */
+function loadProfile(profileName) {
+    const xdg = new xdg_config_1.XDGConfig();
+    if (!xdg.profileExists(profileName)) {
+        const available = xdg.listProfiles();
+        throw new Error(`Profile not found: "${profileName}"\n\n` +
+            "Available profiles:\n" +
+            (available.length > 0
+                ? available.map((p) => `  - ${p}`).join("\n")
+                : "  (none)") +
+            "\n\n" +
+            "Create a new profile:\n" +
+            `  npm run setup -- --profile ${profileName}`);
+    }
+    return xdg.readProfile(profileName);
+}
+/**
+ * Extract secret name from Secrets Manager ARN
+ *
+ * AWS Secrets Manager automatically appends a 6-character random suffix to secret names
+ * in ARNs (e.g., "my-secret-Ab12Cd"). This function extracts the base secret name by
+ * removing the suffix.
+ *
+ * @param arn - Secrets Manager ARN
+ * @returns Secret name without the random suffix
+ */
+function extractSecretName(arn) {
+    if (!arn) {
+        return "";
+    }
+    // ARN format: arn:aws:secretsmanager:region:account:secret:name-XXXXXX
+    // where XXXXXX is a 6-character random suffix added by AWS
+    const match = arn.match(/secret:([^:]+)/);
+    if (!match) {
+        return arn;
+    }
+    const fullName = match[1];
+    // Remove the AWS-generated 6-character suffix (format: -XXXXXX)
+    // The suffix is always a hyphen followed by 6 alphanumeric characters
+    const withoutSuffix = fullName.replace(/-[A-Za-z0-9]{6}$/, "");
+    return withoutSuffix;
+}
+/**
+ * Build environment variables from profile configuration
+ *
+ * Maps XDG config fields to service-specific environment variables.
+ *
+ * @param config - Profile configuration
+ * @param mode - Launch mode
+ * @param options - Launch options
+ * @returns Environment variables map
+ */
+function buildEnvVars(config, mode, options) {
+    const envVars = {
+        // Preserve existing process.env
+        ...process.env,
+        // Quilt Services (v0.8.0+ service-specific - NO MORE STACK ARN!)
+        QUILT_WEB_HOST: config.quilt.catalog,
+        ATHENA_USER_DATABASE: config.quilt.database,
+        ATHENA_USER_WORKGROUP: config.quilt.athenaUserWorkgroup || "primary",
+        ATHENA_RESULTS_BUCKET: config.quilt.athenaResultsBucket || "",
+        ICEBERG_DATABASE: config.quilt.icebergDatabase || "",
+        ICEBERG_WORKGROUP: config.quilt.icebergWorkgroup || "",
+        PACKAGER_SQS_URL: config.quilt.queueUrl,
+        // AWS Configuration
+        AWS_REGION: config.quilt.region || config.deployment.region,
+        AWS_DEFAULT_REGION: config.quilt.region || config.deployment.region,
+        // Benchling Configuration (credentials from Secrets Manager, NOT environment)
+        BenchlingSecret: extractSecretName(config.benchling.secretArn || ""),
+        // Security Configuration
+        ENABLE_WEBHOOK_VERIFICATION: String(config.security?.enableVerification !== false),
+    };
+    // Mode-specific variables
+    if (mode === "native" || mode === "docker-dev") {
+        envVars.FLASK_ENV = "development";
+        envVars.FLASK_DEBUG = "true";
+        envVars.LOG_LEVEL = config.logging?.level || "DEBUG";
+        // Disable verification in dev mode for easier testing
+        if (mode === "docker-dev") {
+            envVars.ENABLE_WEBHOOK_VERIFICATION = "false";
+        }
+    }
+    else {
+        // docker (production)
+        envVars.FLASK_ENV = "production";
+        envVars.LOG_LEVEL = config.logging?.level || "INFO";
+    }
+    // Test mode flag
+    if (options.test) {
+        envVars.BENCHLING_TEST_MODE = "true";
+    }
+    return envVars;
+}
+/**
+ * Validate required configuration
+ *
+ * Ensures all required service variables are present and well-formed.
+ *
+ * @param envVars - Environment variables to validate
+ * @param profile - Profile name (for error messages)
+ */
+function validateConfig(envVars, profile) {
+    // Required service variables (NO BENCHLING_TENANT - comes from Secrets Manager!)
+    const required = [
+        "QUILT_WEB_HOST",
+        "ATHENA_USER_DATABASE",
+        "PACKAGER_SQS_URL",
+        "AWS_REGION",
+        "BenchlingSecret",
+    ];
+    const missing = required.filter((key) => !envVars[key]);
+    if (missing.length > 0) {
+        throw new Error("Missing required configuration:\n" +
+            missing.map((key) => `  - ${key}`).join("\n") +
+            "\n\n" +
+            "Check profile configuration at:\n" +
+            `  ~/.config/benchling-webhook/${profile}/config.json\n\n` +
+            "Run setup wizard to configure:\n" +
+            `  npm run setup -- --profile ${profile}`);
+    }
+    // Format validation
+    if (!envVars.PACKAGER_SQS_URL.match(/^https:\/\/sqs\.[a-z0-9-]+\.amazonaws\.com\/\d+\/.+/)) {
+        throw new Error(`Invalid SQS URL format: ${envVars.PACKAGER_SQS_URL}\n\n` +
+            "Expected format:\n" +
+            "  https://sqs.{region}.amazonaws.com/{account}/{queue-name}\n\n" +
+            "Example:\n" +
+            "  https://sqs.us-east-1.amazonaws.com/123456789012/packager-queue");
+    }
+    // Validate BenchlingSecret is present (secret name, not ARN)
+    if (!envVars.BenchlingSecret) {
+        throw new Error("Missing BenchlingSecret\n\n" +
+            "BenchlingSecret must be the name of your AWS Secrets Manager secret.\n" +
+            "Example: benchling-webhook-prod");
+    }
+}
+/**
+ * Filter secrets from environment variables for verbose logging
+ *
+ * @param envVars - Environment variables
+ * @returns Filtered environment variables (secrets masked)
+ */
+function filterSecrets(envVars) {
+    const filtered = {};
+    for (const [key, value] of Object.entries(envVars)) {
+        const upperKey = key.toUpperCase();
+        if (upperKey.includes("SECRET") || upperKey.includes("PASSWORD") || upperKey.includes("TOKEN")) {
+            filtered[key] = "***REDACTED***";
+        }
+        else {
+            filtered[key] = value;
+        }
+    }
+    return filtered;
+}
+/**
+ * Spawn docker-compose command with consistent environment
+ *
+ * @param args - docker-compose arguments
+ * @param dockerDir - Docker working directory
+ * @param envVars - Environment variables
+ * @param stdio - stdio option for spawn
+ * @returns Child process
+ */
+function spawnDockerCompose(args, dockerDir, envVars, stdio = "inherit") {
+    return (0, child_process_1.spawn)("docker-compose", args, {
+        cwd: dockerDir,
+        env: envVars,
+        stdio,
+    });
+}
+/**
+ * Wait for server to be healthy
+ *
+ * @param url - Server URL to check
+ * @param maxAttempts - Maximum number of attempts
+ * @param delayMs - Delay between attempts in milliseconds
+ * @returns Promise that resolves when server is healthy
+ */
+async function waitForHealth(url, maxAttempts = 30, delayMs = 1000) {
+    console.log(`\n⏳ Waiting for server to be healthy at ${url}...`);
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const response = await fetch(`${url}/health`, {
+                signal: AbortSignal.timeout(5000),
+            });
+            if (response.ok) {
+                console.log(`✅ Server is healthy (attempt ${attempt}/${maxAttempts})\n`);
+                return;
+            }
+        }
+        catch {
+            // Ignore errors and retry
+        }
+        if (attempt < maxAttempts) {
+            await new Promise(resolve => setTimeout(resolve, delayMs));
+        }
+    }
+    throw new Error(`Server did not become healthy after ${maxAttempts} attempts`);
+}
+/**
+ * Run tests against the server
+ *
+ * @param url - Server URL to test
+ * @param profile - Profile name
+ * @returns Promise that resolves with test exit code
+ */
+async function runTests(url, profile) {
+    console.log("🧪 Running tests...\n");
+    const dockerDir = (0, path_1.resolve)(__dirname, "..", "docker");
+    const testScript = (0, path_1.resolve)(dockerDir, "scripts", "test_webhook.py");
+    if (!(0, fs_1.existsSync)(testScript)) {
+        throw new Error(`Test script not found: ${testScript}`);
+    }
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)("uv", ["run", "python", testScript, url, "--profile", profile], {
+            cwd: dockerDir,
+            stdio: "inherit",
+        });
+        proc.on("exit", (code) => {
+            resolve(code || 0);
+        });
+        proc.on("error", (error) => {
+            console.error(`\n❌ Failed to run tests: ${error.message}`);
+            resolve(1);
+        });
+    });
+}
+/**
+ * Launch Flask application in native mode
+ *
+ * Runs Flask directly on host using uv.
+ *
+ * @param envVars - Environment variables
+ * @param options - Launch options
+ */
+async function launchNative(envVars, options) {
+    const port = options.port || 5001;
+    envVars.PORT = String(port);
+    console.log(`🚀 Launching native Flask (port ${port})...`);
+    if (options.verbose) {
+        console.log("\nEnvironment Variables:");
+        const filtered = filterSecrets(envVars);
+        Object.entries(filtered)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([key, value]) => console.log(`  ${key}=${value}`));
+        console.log();
+    }
+    // Check if uv is installed
+    const dockerDir = (0, path_1.resolve)(__dirname, "..", "docker");
+    if (!(0, fs_1.existsSync)(dockerDir)) {
+        throw new Error(`Docker directory not found: ${dockerDir}`);
+    }
+    console.log(`Working directory: ${dockerDir}`);
+    console.log("Command: uv run python -m src.app\n");
+    const proc = (0, child_process_1.spawn)("uv", ["run", "python", "-m", "src.app"], {
+        cwd: dockerDir,
+        env: envVars,
+        stdio: options.test ? "pipe" : "inherit",
+    });
+    // If in test mode, run tests after server is healthy
+    if (options.test) {
+        try {
+            const serverUrl = `http://localhost:${port}`;
+            await waitForHealth(serverUrl);
+            const exitCode = await runTests(serverUrl, options.profile);
+            console.log("\n🛑 Shutting down server...");
+            proc.kill("SIGTERM");
+            // Wait a moment for cleanup
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            process.exit(exitCode);
+        }
+        catch (error) {
+            console.error(`\n❌ Test failed: ${error.message}`);
+            proc.kill("SIGTERM");
+            process.exit(1);
+        }
+    }
+    else {
+        // Non-test mode: run server interactively with graceful shutdown
+        const cleanup = () => {
+            console.log("\n\n🛑 Shutting down...");
+            proc.kill("SIGTERM");
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        proc.on("error", (error) => {
+            console.error(`\n❌ Failed to start native Flask: ${error.message}`);
+            if (error.code === "ENOENT") {
+                console.error("\nIs \"uv\" installed and in your PATH?");
+                console.error("Install uv: https://docs.astral.sh/uv/getting-started/installation/");
+            }
+            process.exit(1);
+        });
+        proc.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`\n❌ Native Flask exited with code ${code}`);
+            }
+            process.exit(code || 0);
+        });
+    }
+}
+/**
+ * Launch Flask application in Docker production mode
+ *
+ * Runs production Docker container via docker-compose.
+ *
+ * @param envVars - Environment variables
+ * @param options - Launch options
+ */
+async function launchDocker(envVars, options) {
+    const port = options.port || 5003;
+    envVars.PORT = String(port);
+    console.log(`🐳 Launching Docker production (port ${port})...`);
+    if (options.verbose) {
+        console.log("\nEnvironment Variables:");
+        const filtered = filterSecrets(envVars);
+        Object.entries(filtered)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([key, value]) => console.log(`  ${key}=${value}`));
+        console.log();
+    }
+    const dockerDir = (0, path_1.resolve)(__dirname, "..", "docker");
+    if (!(0, fs_1.existsSync)(dockerDir)) {
+        throw new Error(`Docker directory not found: ${dockerDir}`);
+    }
+    console.log(`Working directory: ${dockerDir}`);
+    console.log("Command: docker-compose up app\n");
+    const proc = spawnDockerCompose(["up", "app"], dockerDir, envVars, options.test ? "pipe" : "inherit");
+    // If in test mode, run tests after server is healthy
+    if (options.test) {
+        const dockerCleanup = () => {
+            spawnDockerCompose(["down"], dockerDir, envVars);
+        };
+        try {
+            const serverUrl = `http://localhost:${port}`;
+            await waitForHealth(serverUrl);
+            const exitCode = await runTests(serverUrl, options.profile);
+            console.log("\n🛑 Shutting down Docker container...");
+            dockerCleanup();
+            // Wait a moment for cleanup
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            process.exit(exitCode);
+        }
+        catch (error) {
+            console.error(`\n❌ Test failed: ${error.message}`);
+            dockerCleanup();
+            process.exit(1);
+        }
+    }
+    else {
+        // Non-test mode: run server interactively with graceful shutdown
+        const cleanup = () => {
+            console.log("\n\n🛑 Shutting down Docker container...");
+            spawnDockerCompose(["down"], dockerDir, envVars);
+            proc.kill("SIGTERM");
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        proc.on("error", (error) => {
+            console.error(`\n❌ Failed to start Docker: ${error.message}`);
+            if (error.code === "ENOENT") {
+                console.error("\nIs \"docker-compose\" installed and in your PATH?");
+            }
+            process.exit(1);
+        });
+        proc.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`\n❌ Docker exited with code ${code}`);
+            }
+            process.exit(code || 0);
+        });
+    }
+}
+/**
+ * Launch Flask application in Docker development mode
+ *
+ * Runs Docker container with hot-reload enabled via docker-compose --profile dev.
+ *
+ * @param envVars - Environment variables
+ * @param options - Launch options
+ */
+async function launchDockerDev(envVars, options) {
+    const port = options.port || 5002;
+    envVars.PORT = String(port);
+    console.log(`🐳 Launching Docker development (port ${port}, hot-reload enabled)...`);
+    if (options.verbose) {
+        console.log("\nEnvironment Variables:");
+        const filtered = filterSecrets(envVars);
+        Object.entries(filtered)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .forEach(([key, value]) => console.log(`  ${key}=${value}`));
+        console.log();
+    }
+    const dockerDir = (0, path_1.resolve)(__dirname, "..", "docker");
+    if (!(0, fs_1.existsSync)(dockerDir)) {
+        throw new Error(`Docker directory not found: ${dockerDir}`);
+    }
+    console.log(`Working directory: ${dockerDir}`);
+    console.log("Command: docker-compose --profile dev up app-dev\n");
+    const proc = spawnDockerCompose(["--profile", "dev", "up", "app-dev"], dockerDir, envVars, options.test ? "pipe" : "inherit");
+    // If in test mode, run tests after server is healthy
+    if (options.test) {
+        const dockerCleanup = () => {
+            spawnDockerCompose(["--profile", "dev", "down"], dockerDir, envVars);
+        };
+        try {
+            const serverUrl = `http://localhost:${port}`;
+            await waitForHealth(serverUrl);
+            const exitCode = await runTests(serverUrl, options.profile);
+            console.log("\n🛑 Shutting down Docker dev container...");
+            dockerCleanup();
+            // Wait a moment for cleanup
+            await new Promise(resolve => setTimeout(resolve, 2000));
+            process.exit(exitCode);
+        }
+        catch (error) {
+            console.error(`\n❌ Test failed: ${error.message}`);
+            dockerCleanup();
+            process.exit(1);
+        }
+    }
+    else {
+        // Non-test mode: run server interactively with graceful shutdown
+        const cleanup = () => {
+            console.log("\n\n🛑 Shutting down Docker dev container...");
+            spawnDockerCompose(["--profile", "dev", "down"], dockerDir, envVars);
+            proc.kill("SIGTERM");
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        proc.on("error", (error) => {
+            console.error(`\n❌ Failed to start Docker dev: ${error.message}`);
+            if (error.code === "ENOENT") {
+                console.error("\nIs \"docker-compose\" installed and in your PATH?");
+            }
+            process.exit(1);
+        });
+        proc.on("exit", (code) => {
+            if (code !== 0 && code !== null) {
+                console.error(`\n❌ Docker dev exited with code ${code}`);
+            }
+            process.exit(code || 0);
+        });
+    }
+}
+/**
+ * Main entry point
+ */
+async function main() {
+    try {
+        // Parse command-line arguments
+        const options = parseArguments(process.argv);
+        // Load XDG profile configuration
+        const config = loadProfile(options.profile);
+        // Build environment variables
+        const envVars = buildEnvVars(config, options.mode, options);
+        // Validate configuration
+        validateConfig(envVars, options.profile);
+        // Launch appropriate mode
+        switch (options.mode) {
+            case "native":
+                await launchNative(envVars, options);
+                break;
+            case "docker":
+                await launchDocker(envVars, options);
+                break;
+            case "docker-dev":
+                await launchDockerDev(envVars, options);
+                break;
+            default:
+                throw new Error(`Unknown mode: ${options.mode}`);
+        }
+    }
+    catch (error) {
+        console.error(`\n❌ Error: ${error.message}\n`);
+        process.exit(1);
+    }
+}
+// Run if called directly
+if (require.main === module) {
+    main().catch((error) => {
+        console.error(`\n❌ Fatal error: ${error.message}\n`);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=xdg-launch.js.map