blokctl 0.2.0

package/dist/commands/create/project.js

@@ -0,0 +1,941 @@
+import child_process from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import util from "node:util";
+import * as p from "@clack/prompts";
+import figlet from "figlet";
+import fsExtra from "fs-extra";
+import color from "picocolors";
+import simpleGit from "simple-git";
+import { isNonInteractive, parseCommaSeparated, resolveOrThrow } from "../../services/non-interactive.js";
+import { manager as pm } from "../../services/package-manager.js";
+import { detectRuntimes } from "../../services/runtime-detector.js";
+import { createTriggerConfig, generateRuntimeEnvVars, generateSupervisordConfig, generateTriggerEnvVars, generateTriggerSupervisordConfig, setupRuntime, writeProjectConfig, } from "../../services/runtime-setup.js";
+import { agents_md, claude_md, examples_url, node_file, package_dependencies, package_dev_dependencies, } from "./utils/Examples.js";
+const exec = util.promisify(child_process.exec);
+const HOME_DIR = `${os.homedir()}/.blok`;
+const GITHUB_REPO_LOCAL = `${HOME_DIR}/blok`;
+const GITHUB_REPO_REMOTE = "https://github.com/well-prado/blok.git";
+const GITHUB_REPO_RELEASE_TAG = "v0.0.1-beta.5";
+fsExtra.ensureDirSync(HOME_DIR);
+const options = {
+    baseDir: HOME_DIR,
+    binary: "git",
+    maxConcurrentProcesses: 6,
+    trimmed: false,
+};
+const git = simpleGit(options);
+export async function createProject(opts, version, currentPath = false, localRepoPath) {
+    const availableManagers = await pm.getAvailableManagers();
+    let manager = await pm.getManager();
+    const nonInteractive = isNonInteractive();
+    const isDefault = opts.name !== undefined;
+    const skipPrompts = isDefault || nonInteractive;
+    let projectName = opts.name ? opts.name : "";
+    let selectedTriggers = opts.triggers
+        ? parseCommaSeparated(opts.triggers)
+        : opts.trigger
+            ? [opts.trigger]
+            : ["http"];
+    let examples = opts.examples ?? false;
+    let selectedRuntimeKinds = opts.runtimes ? parseCommaSeparated(opts.runtimes) : ["node"];
+    let selectedManager = opts.packageManager || "npm";
+    let pubsubProvider = opts.pubsubProvider || "gcp";
+    let queueProvider = opts.queueProvider || "kafka";
+    let detectedRuntimes = [];
+    if (!skipPrompts) {
+        console.log(figlet.textSync("blok CLI".toUpperCase(), {
+            font: "Digital",
+            horizontalLayout: "default",
+            verticalLayout: "default",
+            width: 100,
+            whitespaceBreak: true,
+        }));
+        console.log("");
+        p.intro(color.inverse(" Create a New Project "));
+        const detectSpinner = p.spinner();
+        detectSpinner.start("Detecting installed language runtimes...");
+        detectedRuntimes = await detectRuntimes();
+        detectSpinner.stop("Runtime detection complete.");
+        const resolveProjectName = async () => {
+            if (projectName !== "") {
+                return projectName;
+            }
+            return (await p.text({
+                message: "Please provide a name for the project",
+                placeholder: "blok-service",
+                defaultValue: "blok-service",
+            }));
+        };
+        const resolveSelectedManager = async () => {
+            if (opts.packageManager) {
+                return opts.packageManager;
+            }
+            if (availableManagers.length === 1) {
+                return availableManagers[0];
+            }
+            return (await p.select({
+                message: "Select the package manager",
+                options: availableManagers.map((manager) => ({
+                    label: manager,
+                    value: manager,
+                })),
+            }));
+        };
+        const runtimeOptions = [
+            { label: "NodeJS", value: "node", hint: "always included" },
+            ...detectedRuntimes.map((rt) => {
+                let hint;
+                if (rt.available) {
+                    hint = `${rt.toolchain} ${rt.version || ""} detected`.trim();
+                }
+                else if (rt.secondaryTool && !rt.secondaryTool.available) {
+                    hint = `${rt.secondaryTool.name} not found - will be skipped`;
+                }
+                else {
+                    hint = `${rt.toolchain} not found - will be skipped`;
+                }
+                return { label: rt.label, value: rt.kind, hint };
+            }),
+        ];
+        const blokctlProject = await p.group({
+            projectName: () => resolveProjectName(),
+            triggers: () => opts.triggers || opts.trigger
+                ? Promise.resolve(opts.triggers ? parseCommaSeparated(opts.triggers) : [opts.trigger])
+                : p.multiselect({
+                    message: "Select triggers to install",
+                    options: [
+                        { label: "HTTP", value: "http", hint: "REST APIs (port 4000)" },
+                        { label: "SSE", value: "sse", hint: "Real-time push (port 4001)" },
+                        { label: "Queue", value: "queue", hint: "Kafka/RabbitMQ/SQS/Redis (port 4005)" },
+                        { label: "Pub/Sub", value: "pubsub", hint: "GCP/AWS/Azure messaging (port 4006)" },
+                    ],
+                    initialValues: ["http"],
+                    required: true,
+                }),
+            pubsubProvider: ({ results }) => opts.pubsubProvider
+                ? Promise.resolve(opts.pubsubProvider)
+                : results.triggers?.includes("pubsub")
+                    ? p.select({
+                        message: "Select Pub/Sub provider",
+                        options: [
+                            { label: "Google Cloud Pub/Sub", value: "gcp" },
+                            { label: "AWS SNS/SQS", value: "aws" },
+                            { label: "Azure Service Bus", value: "azure" },
+                        ],
+                    })
+                    : Promise.resolve(null),
+            queueProvider: ({ results }) => opts.queueProvider
+                ? Promise.resolve(opts.queueProvider)
+                : results.triggers?.includes("queue")
+                    ? p.select({
+                        message: "Select Queue provider",
+                        options: [
+                            { label: "Apache Kafka", value: "kafka" },
+                            { label: "RabbitMQ", value: "rabbitmq" },
+                            { label: "AWS SQS", value: "sqs" },
+                            { label: "Redis/BullMQ", value: "redis" },
+                        ],
+                    })
+                    : Promise.resolve(null),
+            runtimes: () => opts.runtimes
+                ? Promise.resolve(parseCommaSeparated(opts.runtimes))
+                : p.multiselect({
+                    message: "Select the runtimes to install",
+                    options: runtimeOptions,
+                    initialValues: ["node"],
+                    required: true,
+                }),
+            selectedManager: () => resolveSelectedManager(),
+        }, {
+            onCancel: () => {
+                p.cancel("Operation canceled.");
+                process.exit(0);
+            },
+        });
+        projectName = blokctlProject.projectName;
+        selectedTriggers = blokctlProject.triggers;
+        pubsubProvider = blokctlProject.pubsubProvider || "gcp";
+        queueProvider = blokctlProject.queueProvider || "kafka";
+        selectedRuntimeKinds = blokctlProject.runtimes;
+        selectedManager = blokctlProject.selectedManager;
+        const unavailableSelected = selectedRuntimeKinds.filter((kind) => {
+            if (kind === "node")
+                return false;
+            const rt = detectedRuntimes.find((r) => r.kind === kind);
+            return rt && !rt.available;
+        });
+        if (unavailableSelected.length > 0) {
+            console.log("");
+            for (const kind of unavailableSelected) {
+                const rt = detectedRuntimes.find((r) => r.kind === kind);
+                if (rt) {
+                    console.log(color.yellow(`  ${rt.label}: ${rt.toolchain} not found. Skipping setup.`));
+                    if (rt.secondaryTool && !rt.secondaryTool.available) {
+                        console.log(color.yellow(`    ${rt.secondaryTool.installHint}`));
+                    }
+                    else {
+                        console.log(color.yellow(`    ${rt.installHint}`));
+                    }
+                }
+            }
+            console.log("");
+            selectedRuntimeKinds = selectedRuntimeKinds.filter((kind) => {
+                if (kind === "node")
+                    return true;
+                const rt = detectedRuntimes.find((r) => r.kind === kind);
+                return rt?.available ?? false;
+            });
+        }
+        const blokctlExamplesProject = await p.group({
+            examples: () => opts.examples !== undefined
+                ? Promise.resolve(opts.examples)
+                : p.select({
+                    message: "Install the examples?",
+                    options: [
+                        { label: "NO", value: false, hint: "recommended" },
+                        { label: "YES", value: true },
+                    ],
+                }),
+        }, {
+            onCancel: () => {
+                p.cancel("Operation canceled.");
+                process.exit(0);
+            },
+        });
+        examples = blokctlExamplesProject.examples;
+    }
+    else if (nonInteractive) {
+        projectName = resolveOrThrow("name", opts.name);
+        if (selectedRuntimeKinds.some((k) => k !== "node")) {
+            detectedRuntimes = await detectRuntimes();
+        }
+    }
+    const s = p.spinner();
+    if (!skipPrompts)
+        s.start("Creating the project...");
+    try {
+        const dirPath = !currentPath ? path.join(process.cwd(), projectName) : process.cwd();
+        if (!skipPrompts)
+            s.message("Gathering project files");
+        const repoSource = localRepoPath ? path.resolve(localRepoPath) : GITHUB_REPO_LOCAL;
+        if (localRepoPath) {
+            if (!fsExtra.existsSync(repoSource)) {
+                throw new Error(`Local repo path not found: ${repoSource}`);
+            }
+            console.log(color.dim(`  Using local repo: ${repoSource}`));
+        }
+        else {
+            const githubLocalExists = fsExtra.existsSync(GITHUB_REPO_LOCAL);
+            if (githubLocalExists) {
+                fsExtra.removeSync(GITHUB_REPO_LOCAL);
+            }
+            if (GITHUB_REPO_RELEASE_TAG) {
+                await git.clone(GITHUB_REPO_REMOTE, GITHUB_REPO_LOCAL, ["--branch", GITHUB_REPO_RELEASE_TAG, "--depth", "1"]);
+            }
+            else {
+                await git.clone(GITHUB_REPO_REMOTE, GITHUB_REPO_LOCAL);
+            }
+        }
+        if (!skipPrompts)
+            s.message("Copying project files...");
+        if (!currentPath) {
+            const projectDirExists = fsExtra.existsSync(dirPath);
+            if (projectDirExists) {
+                throw new Error("A project already exists in the current directory. Please remove it and try again.");
+            }
+        }
+        fsExtra.ensureDirSync(dirPath);
+        fsExtra.ensureDirSync(`${dirPath}/src`);
+        fsExtra.ensureDirSync(`${dirPath}/src/triggers`);
+        fsExtra.ensureDirSync(`${dirPath}/src/nodes`);
+        fsExtra.ensureDirSync(`${dirPath}/src/workflows`);
+        const triggerConfigs = selectedTriggers.map((kind) => createTriggerConfig(kind));
+        const primaryTrigger = selectedTriggers[0];
+        const primaryTriggerDir = primaryTrigger === "pubsub" || primaryTrigger === "queue"
+            ? `${repoSource}/triggers/${primaryTrigger}/template`
+            : `${repoSource}/triggers/${primaryTrigger}`;
+        const baseFiles = ["package.json", "tsconfig.json", ".env.example", ".gitignore", "vitest.config.ts"];
+        for (const file of baseFiles) {
+            const src = `${primaryTriggerDir}/${file}`;
+            if (fsExtra.existsSync(src)) {
+                fsExtra.copySync(src, `${dirPath}/${file}`);
+            }
+        }
+        if (fsExtra.existsSync(`${primaryTriggerDir}/Dockerfile`)) {
+            fsExtra.copySync(`${primaryTriggerDir}/Dockerfile`, `${dirPath}/Dockerfile`);
+        }
+        if (fsExtra.existsSync(`${primaryTriggerDir}/Dockerfile.dev`)) {
+            fsExtra.copySync(`${primaryTriggerDir}/Dockerfile.dev`, `${dirPath}/Dockerfile.dev`);
+        }
+        for (const triggerKind of selectedTriggers) {
+            const triggerDestDir = `${dirPath}/src/triggers/${triggerKind}`;
+            fsExtra.ensureDirSync(triggerDestDir);
+            if (triggerKind === "pubsub" || triggerKind === "queue") {
+                const templateDir = `${repoSource}/triggers/${triggerKind}/template/src`;
+                if (fsExtra.existsSync(templateDir)) {
+                    fsExtra.copySync(templateDir, triggerDestDir);
+                    if (fsExtra.existsSync(`${templateDir}/workflows`)) {
+                        fsExtra.copySync(`${templateDir}/workflows`, `${dirPath}/src/workflows/${triggerKind}`);
+                        fsExtra.removeSync(`${triggerDestDir}/workflows`);
+                    }
+                    fsExtra.removeSync(`${triggerDestDir}/Nodes.ts`);
+                    fsExtra.removeSync(`${triggerDestDir}/Workflows.ts`);
+                    if (triggerKind === "pubsub") {
+                        updatePubSubProvider(triggerDestDir, pubsubProvider);
+                    }
+                    else if (triggerKind === "queue") {
+                        updateQueueProvider(triggerDestDir, queueProvider);
+                    }
+                }
+            }
+            else {
+                const triggerSrcDir = `${repoSource}/triggers/${triggerKind}/src`;
+                if (fsExtra.existsSync(`${triggerSrcDir}/runner`)) {
+                    fsExtra.copySync(`${triggerSrcDir}/runner`, `${triggerDestDir}/runner`);
+                }
+                if (fsExtra.existsSync(`${triggerSrcDir}/AppRoutes.ts`)) {
+                    fsExtra.copySync(`${triggerSrcDir}/AppRoutes.ts`, `${triggerDestDir}/AppRoutes.ts`);
+                }
+                if (fsExtra.existsSync(`${triggerSrcDir}/workflows`)) {
+                    fsExtra.copySync(`${triggerSrcDir}/workflows`, `${dirPath}/src/workflows/${triggerKind}`);
+                }
+                if (triggerKind === "sse" && fsExtra.existsSync(`${triggerSrcDir}/SSETrigger.ts`)) {
+                    fsExtra.copySync(`${triggerSrcDir}/SSETrigger.ts`, `${triggerDestDir}/SSETrigger.ts`);
+                }
+                if (fsExtra.existsSync(`${triggerSrcDir}/lib.ts`)) {
+                    fsExtra.copySync(`${triggerSrcDir}/lib.ts`, `${triggerDestDir}/lib.ts`);
+                }
+            }
+        }
+        for (const triggerKind of selectedTriggers) {
+            const triggerDestDir = `${dirPath}/src/triggers/${triggerKind}`;
+            fixRunnerImportPaths(triggerDestDir, triggerKind);
+        }
+        const sharedNodesContent = generateSharedNodesFile(selectedTriggers, repoSource);
+        fsExtra.writeFileSync(`${dirPath}/src/Nodes.ts`, sharedNodesContent);
+        const sharedWorkflowsContent = generateSharedWorkflowsFile(selectedTriggers);
+        fsExtra.writeFileSync(`${dirPath}/src/Workflows.ts`, sharedWorkflowsContent);
+        for (const triggerKind of selectedTriggers) {
+            const entryContent = generateTriggerEntryFile(triggerKind);
+            fsExtra.writeFileSync(`${dirPath}/src/triggers/${triggerKind}/index.ts`, entryContent);
+        }
+        for (const triggerKind of selectedTriggers) {
+            const triggerNodesDir = `${repoSource}/triggers/${triggerKind}/src/nodes`;
+            if (fsExtra.existsSync(triggerNodesDir)) {
+                fsExtra.copySync(triggerNodesDir, `${dirPath}/src/nodes`);
+            }
+        }
+        if (!skipPrompts) {
+            s.message("Installing example workflows and nodes");
+        }
+        const nodesDir = `${dirPath}/src/nodes`;
+        const workflowsDir = `${dirPath}/workflows`;
+        fsExtra.ensureDirSync(nodesDir);
+        fsExtra.copySync(`${repoSource}/workflows`, workflowsDir);
+        try {
+            fsExtra.chownSync(dirPath, os.userInfo().uid, os.userInfo().gid);
+        }
+        catch (error) {
+            console.error(`Failed to change ownership of directory ${dirPath}:`, error);
+        }
+        fsExtra.ensureDirSync(`${dirPath}/infra`);
+        fsExtra.ensureDirSync(`${dirPath}/infra/metrics`);
+        fsExtra.copySync(`${repoSource}/infra/metrics`, `${dirPath}/infra/metrics`);
+        fsExtra.removeSync(`${dirPath}/public/metric`);
+        if (!examples) {
+            fsExtra.removeSync(`${nodesDir}/examples`);
+            fsExtra.removeSync(`${workflowsDir}`);
+            fsExtra.ensureDirSync(`${workflowsDir}`);
+            fsExtra.ensureDirSync(`${workflowsDir}/json`);
+            fsExtra.ensureDirSync(`${workflowsDir}/yaml`);
+            fsExtra.ensureDirSync(`${workflowsDir}/toml`);
+        }
+        else {
+            fsExtra.ensureDirSync(`${dirPath}/infra/postgresql`);
+            fsExtra.ensureDirSync(`${dirPath}/infra/milvus`);
+            fsExtra.copySync(`${repoSource}/infra/development`, `${dirPath}/infra/postgresql`);
+            fsExtra.copySync(`${repoSource}/infra/milvus`, `${dirPath}/infra/milvus`);
+            fsExtra.writeFileSync(`${dirPath}/src/Nodes.ts`, node_file);
+            fsExtra.copySync(`${repoSource}/sdk`, `${dirPath}/public/sdk`);
+        }
+        const envExample = `${dirPath}/.env.example`;
+        const envLocal = `${dirPath}/.env.local`;
+        const envContent = fsExtra.readFileSync(envExample, "utf8");
+        const result = envContent.replaceAll("PROJECT_PATH", dirPath);
+        fsExtra.writeFileSync(envLocal, result);
+        const packageJson = `${dirPath}/package.json`;
+        const packageJsonContent = JSON.parse(fsExtra.readFileSync(packageJson, "utf8"));
+        packageJsonContent.name = projectName;
+        packageJsonContent.version = "1.0.0";
+        packageJsonContent.author = "";
+        const workspacePackageMap = {
+            "@blok/api-call": "nodes/web/api-call@1.0.0",
+            "@blok/helper": "core/workflow-helper",
+            "@blok/if-else": "nodes/control-flow/if-else@1.0.0",
+            "@blok/runner": "core/runner",
+            "@blok/shared": "core/shared",
+            "@blok/trigger-pubsub": "triggers/pubsub",
+            "@blok/trigger-queue": "triggers/queue",
+        };
+        for (const depGroup of ["dependencies", "devDependencies", "peerDependencies"]) {
+            const deps = packageJsonContent[depGroup];
+            if (!deps)
+                continue;
+            for (const [pkg, ver] of Object.entries(deps)) {
+                if (typeof ver === "string" && ver.startsWith("workspace:")) {
+                    if (localRepoPath && workspacePackageMap[pkg]) {
+                        deps[pkg] = `file:${path.resolve(repoSource, workspacePackageMap[pkg])}`;
+                    }
+                    else {
+                        deps[pkg] = "^0.1.0";
+                    }
+                }
+            }
+        }
+        if (localRepoPath) {
+            const fileLinks = {};
+            for (const [pkg, relativePath] of Object.entries(workspacePackageMap)) {
+                fileLinks[pkg] = `file:${path.resolve(repoSource, relativePath)}`;
+            }
+            packageJsonContent.overrides = fileLinks;
+            packageJsonContent.resolutions = fileLinks;
+        }
+        manager = await pm.getManager(selectedManager);
+        const triggerScripts = {
+            dev: "blokctl dev",
+        };
+        for (const tc of triggerConfigs) {
+            triggerScripts[`start:${tc.kind}`] = tc.startCmd;
+        }
+        packageJsonContent.scripts = {
+            ...packageJsonContent.scripts,
+            ...triggerScripts,
+        };
+        const blokctlRef = localRepoPath ? `file:${path.resolve(repoSource, "packages/cli")}` : `^${version}`;
+        packageJsonContent.devDependencies = {
+            ...packageJsonContent.devDependencies,
+            blokctl: blokctlRef,
+        };
+        const providerDeps = getProviderDependencies(selectedTriggers, pubsubProvider, queueProvider);
+        if (Object.keys(providerDeps).length > 0) {
+            packageJsonContent.dependencies = {
+                ...packageJsonContent.dependencies,
+                ...providerDeps,
+            };
+        }
+        const triggerPackageDeps = {};
+        if (selectedTriggers.includes("pubsub")) {
+            const pubsubRef = localRepoPath ? `file:${path.resolve(repoSource, "triggers/pubsub")}` : "@blok/trigger-pubsub";
+            triggerPackageDeps["@blok/trigger-pubsub"] = localRepoPath ? pubsubRef : "workspace:*";
+        }
+        if (selectedTriggers.includes("queue")) {
+            const queueRef = localRepoPath ? `file:${path.resolve(repoSource, "triggers/queue")}` : "@blok/trigger-queue";
+            triggerPackageDeps["@blok/trigger-queue"] = localRepoPath ? queueRef : "workspace:*";
+        }
+        if (Object.keys(triggerPackageDeps).length > 0) {
+            packageJsonContent.dependencies = {
+                ...packageJsonContent.dependencies,
+                ...triggerPackageDeps,
+            };
+        }
+        const nonNodeRuntimes = selectedRuntimeKinds.filter((kind) => kind !== "node");
+        const runtimeConfigs = [];
+        if (nonNodeRuntimes.length > 0) {
+            for (const kind of nonNodeRuntimes) {
+                const rt = detectedRuntimes.find((r) => r.kind === kind);
+                if (!rt)
+                    continue;
+                try {
+                    const config = await setupRuntime(rt, repoSource, dirPath, s);
+                    runtimeConfigs.push(config);
+                }
+                catch (error) {
+                    console.log(color.yellow(`\n  Warning: Failed to setup ${rt.label} runtime: ${error.message}`));
+                    console.log(color.yellow("  You can set it up manually later.\n"));
+                }
+            }
+            if (runtimeConfigs.length > 0) {
+                const envVars = generateRuntimeEnvVars(runtimeConfigs);
+                fsExtra.appendFileSync(envLocal, envVars);
+            }
+        }
+        writeProjectConfig(dirPath, runtimeConfigs, triggerConfigs);
+        if (triggerConfigs.length > 0) {
+            const triggerEnvVars = generateTriggerEnvVars(triggerConfigs);
+            fsExtra.appendFileSync(envLocal, triggerEnvVars);
+        }
+        const providerEnvVars = getProviderEnvVars(selectedTriggers, pubsubProvider, queueProvider);
+        if (providerEnvVars) {
+            fsExtra.appendFileSync(envLocal, providerEnvVars);
+        }
+        if (examples) {
+            packageJsonContent.dependencies = {
+                ...packageJsonContent.dependencies,
+                ...package_dependencies,
+            };
+            packageJsonContent.devDependencies = {
+                ...packageJsonContent.devDependencies,
+                ...package_dev_dependencies,
+            };
+        }
+        fsExtra.writeFileSync(packageJson, JSON.stringify(packageJsonContent, null, 2));
+        const supervisordConfPath = `${dirPath}/supervisord.conf`;
+        let supervisordConfContent = "[supervisord]\nnodaemon=true\n";
+        if (triggerConfigs.length > 0) {
+            supervisordConfContent += generateTriggerSupervisordConfig(triggerConfigs);
+        }
+        if (runtimeConfigs.length > 0) {
+            supervisordConfContent += generateSupervisordConfig(runtimeConfigs);
+        }
+        fsExtra.writeFileSync(supervisordConfPath, supervisordConfContent);
+        fsExtra.writeFileSync(`${dirPath}/AGENTS.md`, agents_md.trimStart());
+        fsExtra.writeFileSync(`${dirPath}/CLAUDE.md`, claude_md.trimStart());
+        s.message("Installing packages...");
+        const cmd_install_ts_response = await exec(manager.INSTALL, { cwd: dirPath });
+        s.message("Packages installed successfully!");
+        console.log("\n", cmd_install_ts_response.stdout);
+        if (!fsExtra.existsSync(`${dirPath}/node_modules`)) {
+            throw new Error("Failed to install packages. Please check your internet connection and try again.");
+        }
+        if (!skipPrompts)
+            s.stop(`Project "${projectName}" created successfully.`);
+        const triggerNames = triggerConfigs.map((tc) => tc.label).join(", ");
+        console.log(`\nTriggers: ${triggerNames}`);
+        const installedRuntimes = ["NodeJS", ...runtimeConfigs.map((rc) => rc.label)];
+        console.log(`Runtimes: ${installedRuntimes.join(", ")}\n`);
+        if (!currentPath)
+            console.log(`Change to the project directory: cd ${projectName}`);
+        console.log(`Run the command "npm run dev" to start the development server.`);
+        console.log("\nTrigger endpoints:");
+        for (const tc of triggerConfigs) {
+            console.log(`  ${tc.label}: http://localhost:${tc.port}/health-check`);
+        }
+        if (runtimeConfigs.length > 0) {
+            console.log("\nRuntime health checks:");
+            for (const rc of runtimeConfigs) {
+                console.log(`  ${rc.label}: http://localhost:${rc.port}/health`);
+            }
+        }
+        console.log("\nFor more documentation, visit https://blok.build/");
+        if (examples) {
+            console.log(examples_url);
+        }
+    }
+    catch (error) {
+        if (!skipPrompts)
+            s.stop(error.message);
+        if (skipPrompts)
+            console.log(error.message);
+    }
+}
+function generateSharedNodesFile(triggers, _repoSource) {
+    const nodeImports = new Set();
+    const nodeExports = new Map();
+    nodeImports.add('import ApiCall from "@blok/api-call";');
+    nodeImports.add('import IfElse from "@blok/if-else";');
+    nodeImports.add('import type { BlokService } from "@blok/runner";');
+    nodeExports.set("@blok/api-call", "ApiCall");
+    nodeExports.set("@blok/if-else", "IfElse");
+    for (const trigger of triggers) {
+        if (trigger === "sse") {
+            nodeImports.add('import WelcomeMessage from "./nodes/welcome-message/index";');
+            nodeExports.set("welcome-message", "WelcomeMessage");
+        }
+    }
+    const importLines = Array.from(nodeImports).join("\n");
+    const exportEntries = Array.from(nodeExports.entries())
+        .map(([key, value]) => `\t"${key}": ${value},`)
+        .join("\n");
+    return `${importLines}
+
+const nodes: Record<string, BlokService<unknown>> = {
+${exportEntries}
+};
+
+export default nodes;
+`;
+}
+function generateSharedWorkflowsFile(triggers) {
+    const imports = [];
+    const workflowEntries = [];
+    for (const trigger of triggers) {
+        if (trigger === "http") {
+            imports.push("// Import HTTP workflows here");
+        }
+        else if (trigger === "sse") {
+            imports.push('import OnConnect from "./workflows/sse/notifications/on-connect";');
+            imports.push('import OnSubscribe from "./workflows/sse/notifications/on-subscribe";');
+            workflowEntries.push('\t"on-connect": OnConnect,');
+            workflowEntries.push('\t"on-subscribe": OnSubscribe,');
+        }
+        else if (trigger === "pubsub") {
+            imports.push('import OnPubSubMessage from "./workflows/pubsub/messages/on-message";');
+            workflowEntries.push('\t"on-pubsub-message": OnPubSubMessage,');
+        }
+        else if (trigger === "queue") {
+            imports.push('import OnQueueMessage from "./workflows/queue/messages/on-message";');
+            workflowEntries.push('\t"on-queue-message": OnQueueMessage,');
+        }
+    }
+    const importSection = imports.length > 0 ? `${imports.join("\n")}\n` : "";
+    const entriesSection = workflowEntries.length > 0 ? workflowEntries.join("\n") : "\t// Add your workflows here";
+    return `import type { HelperResponse } from "@blok/helper";
+
+${importSection}
+const workflows: Record<string, HelperResponse> = {
+${entriesSection}
+};
+
+export default workflows;
+`;
+}
+function generateTriggerEntryFile(triggerKind) {
+    if (triggerKind === "http") {
+        return `import { DefaultLogger } from "@blok/runner";
+import { type Span, metrics, trace } from "@opentelemetry/api";
+import HttpTrigger from "./runner/HttpTrigger";
+
+export default class App {
+	private httpTrigger: HttpTrigger = <HttpTrigger>{};
+	protected trigger_initializer = 0;
+	protected initializer = 0;
+	protected tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-http-server",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	private logger = new DefaultLogger();
+	protected app_cold_start = metrics.getMeter("default").createGauge("initialization", {
+		description: "Application cold start",
+	});
+
+	constructor() {
+		this.initializer = performance.now();
+		this.httpTrigger = new HttpTrigger();
+	}
+
+	async run() {
+		this.tracer.startActiveSpan("initialization", async (span: Span) => {
+			await this.httpTrigger.listen();
+			this.initializer = performance.now() - this.initializer;
+
+			this.logger.log(\`Server initialized in \${(this.initializer).toFixed(2)}ms\`);
+			this.app_cold_start.record(this.initializer, {
+				pid: process.pid,
+				env: process.env.NODE_ENV,
+				app: process.env.APP_NAME,
+			});
+			span.end();
+		});
+	}
+
+	getHttpApp() {
+		return this.httpTrigger.getApp();
+	}
+}
+
+if (process.env.DISABLE_TRIGGER_RUN !== "true") {
+	new App().run();
+}
+`;
+    }
+    if (triggerKind === "sse") {
+        return `import { DefaultLogger } from "@blok/runner";
+import { type Span, metrics, trace } from "@opentelemetry/api";
+import SSEServer from "./runner/SSEServer";
+
+export default class App {
+	private sseServer: SSEServer = <SSEServer>{};
+	protected trigger_initializer = 0;
+	protected initializer = 0;
+	protected tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-sse-server",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	private logger = new DefaultLogger();
+	protected app_cold_start = metrics.getMeter("default").createGauge("initialization", {
+		description: "Application cold start",
+	});
+
+	constructor() {
+		this.initializer = performance.now();
+		this.sseServer = new SSEServer();
+	}
+
+	async run() {
+		this.tracer.startActiveSpan("initialization", async (span: Span) => {
+			await this.sseServer.listen();
+			this.initializer = performance.now() - this.initializer;
+
+			this.logger.log(\`Server initialized in \${(this.initializer).toFixed(2)}ms\`);
+			this.app_cold_start.record(this.initializer, {
+				pid: process.pid,
+				env: process.env.NODE_ENV,
+				app: process.env.APP_NAME,
+			});
+			span.end();
+		});
+	}
+
+	getApp() {
+		return this.sseServer.getApp();
+	}
+}
+
+ {
+	new App().run();
+}
+`;
+    }
+    if (triggerKind === "pubsub") {
+        return `import { DefaultLogger } from "@blok/runner";
+import { type Span, metrics, trace } from "@opentelemetry/api";
+import PubSubServer from "./runner/PubSubServer";
+
+export default class App {
+	private pubsubServer: PubSubServer = <PubSubServer>{};
+	protected trigger_initializer = 0;
+	protected initializer = 0;
+	protected tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-pubsub-server",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	private logger = new DefaultLogger();
+	protected app_cold_start = metrics.getMeter("default").createGauge("initialization", {
+		description: "Application cold start",
+	});
+
+	constructor() {
+		this.initializer = performance.now();
+		this.pubsubServer = new PubSubServer();
+	}
+
+	async run() {
+		this.tracer.startActiveSpan("initialization", async (span: Span) => {
+			await this.pubsubServer.listen();
+			this.initializer = performance.now() - this.initializer;
+
+			this.logger.log(\`Pub/Sub trigger initialized in \${(this.initializer).toFixed(2)}ms\`);
+			this.app_cold_start.record(this.initializer, {
+				pid: process.pid,
+				env: process.env.NODE_ENV,
+				app: process.env.APP_NAME,
+			});
+			span.end();
+		});
+	}
+}
+
+if (process.env.DISABLE_TRIGGER_RUN !== "true") {
+	new App().run();
+}
+`;
+    }
+    if (triggerKind === "queue") {
+        return `import { DefaultLogger } from "@blok/runner";
+import { type Span, metrics, trace } from "@opentelemetry/api";
+import QueueServer from "./runner/QueueServer";
+
+export default class App {
+	private queueServer: QueueServer = <QueueServer>{};
+	protected trigger_initializer = 0;
+	protected initializer = 0;
+	protected tracer = trace.getTracer(
+		process.env.PROJECT_NAME || "trigger-queue-server",
+		process.env.PROJECT_VERSION || "0.0.1",
+	);
+	private logger = new DefaultLogger();
+	protected app_cold_start = metrics.getMeter("default").createGauge("initialization", {
+		description: "Application cold start",
+	});
+
+	constructor() {
+		this.initializer = performance.now();
+		this.queueServer = new QueueServer();
+	}
+
+	async run() {
+		this.tracer.startActiveSpan("initialization", async (span: Span) => {
+			await this.queueServer.listen();
+			this.initializer = performance.now() - this.initializer;
+
+			this.logger.log(\`Queue trigger initialized in \${(this.initializer).toFixed(2)}ms\`);
+			this.app_cold_start.record(this.initializer, {
+				pid: process.pid,
+				env: process.env.NODE_ENV,
+				app: process.env.APP_NAME,
+			});
+			span.end();
+		});
+	}
+}
+
+if (process.env.DISABLE_TRIGGER_RUN !== "true") {
+	new App().run();
+}
+`;
+    }
+    return `// Entry point for ${triggerKind} trigger
+// Implement trigger-specific initialization here
+console.log("${triggerKind} trigger not yet implemented");
+`;
+}
+function fixRunnerImportPaths(triggerDestDir, triggerKind) {
+    const filesToFix = [];
+    if (triggerKind === "http") {
+        filesToFix.push(`${triggerDestDir}/runner/HttpTrigger.ts`);
+    }
+    else if (triggerKind === "sse") {
+        filesToFix.push(`${triggerDestDir}/runner/SSEServer.ts`);
+    }
+    else if (triggerKind === "pubsub") {
+        filesToFix.push(`${triggerDestDir}/runner/PubSubServer.ts`);
+    }
+    else if (triggerKind === "queue") {
+        filesToFix.push(`${triggerDestDir}/runner/QueueServer.ts`);
+    }
+    for (const filePath of filesToFix) {
+        if (!fsExtra.existsSync(filePath))
+            continue;
+        let content = fsExtra.readFileSync(filePath, "utf8");
+        content = content.replace(/from ["']\.\.\/Nodes["']/g, 'from "../../../Nodes"');
+        content = content.replace(/from ["']\.\.\/Workflows["']/g, 'from "../../../Workflows"');
+        fsExtra.writeFileSync(filePath, content);
+    }
+}
+function updatePubSubProvider(triggerDestDir, provider) {
+    const serverPath = `${triggerDestDir}/runner/PubSubServer.ts`;
+    if (!fsExtra.existsSync(serverPath))
+        return;
+    let content = fsExtra.readFileSync(serverPath, "utf8");
+    const adapterConfigs = {
+        gcp: {
+            importName: "GCPPubSubAdapter",
+            init: `new GCPPubSubAdapter({
+		projectId: process.env.GCP_PROJECT_ID || "my-project",
+	})`,
+        },
+        aws: {
+            importName: "AWSSNSAdapter",
+            init: `new AWSSNSAdapter({
+		region: process.env.AWS_REGION || "us-east-1",
+	})`,
+        },
+        azure: {
+            importName: "AzureServiceBusAdapter",
+            init: `new AzureServiceBusAdapter({
+		connectionString: process.env.AZURE_SERVICE_BUS_CONNECTION_STRING || "",
+	})`,
+        },
+    };
+    const config = adapterConfigs[provider];
+    if (!config)
+        return;
+    content = content.replace(/import \{ PubSubTrigger, \w+ \} from "@blok\/trigger-pubsub";/, `import { PubSubTrigger, ${config.importName} } from "@blok/trigger-pubsub";`);
+    content = content.replace(/(export default class \w+ extends PubSubTrigger \{[\s\S]*?)\n\tprotected adapter = new \w+\(\{[\s\S]*?\}\);/, `$1\n\tprotected adapter = ${config.init};`);
+    fsExtra.writeFileSync(serverPath, content);
+}
+function updateQueueProvider(triggerDestDir, provider) {
+    const serverPath = `${triggerDestDir}/runner/QueueServer.ts`;
+    if (!fsExtra.existsSync(serverPath))
+        return;
+    let content = fsExtra.readFileSync(serverPath, "utf8");
+    const adapterConfigs = {
+        kafka: {
+            importName: "KafkaAdapter",
+            init: `new KafkaAdapter({
+		brokers: (process.env.KAFKA_BROKERS || "localhost:9092").split(","),
+		clientId: process.env.KAFKA_CLIENT_ID || "blok-queue-trigger",
+	})`,
+        },
+        rabbitmq: {
+            importName: "RabbitMQAdapter",
+            init: `new RabbitMQAdapter({
+		url: process.env.RABBITMQ_URL || "amqp://localhost",
+	})`,
+        },
+        sqs: {
+            importName: "SQSAdapter",
+            init: `new SQSAdapter({
+		region: process.env.AWS_REGION || "us-east-1",
+	})`,
+        },
+        redis: {
+            importName: "RedisAdapter",
+            init: `new RedisAdapter({
+		host: process.env.REDIS_HOST || "localhost",
+		port: Number(process.env.REDIS_PORT) || 6379,
+	})`,
+        },
+    };
+    const config = adapterConfigs[provider];
+    if (!config)
+        return;
+    content = content.replace(/import \{ QueueTrigger, \w+ \} from "@blok\/trigger-queue";/, `import { QueueTrigger, ${config.importName} } from "@blok/trigger-queue";`);
+    content = content.replace(/(export default class \w+ extends QueueTrigger \{[\s\S]*?)\n\tprotected adapter = new \w+\(\{[\s\S]*?\}\);/, `$1\n\tprotected adapter = ${config.init};`);
+    fsExtra.writeFileSync(serverPath, content);
+}
+function getProviderDependencies(triggers, pubsubProvider, queueProvider) {
+    const deps = {};
+    const pubsubProviderDeps = {
+        gcp: { "@google-cloud/pubsub": "^4.0.0" },
+        aws: { "@aws-sdk/client-sns": "^3.980.0", "@aws-sdk/client-sqs": "^3.980.0" },
+        azure: { "@azure/service-bus": "^7.9.5" },
+    };
+    const queueProviderDeps = {
+        kafka: { kafkajs: "^2.2.4" },
+        rabbitmq: { amqplib: "^0.10.9" },
+        sqs: { "@aws-sdk/client-sqs": "^3.980.0" },
+        redis: { ioredis: "^5.9.2", bullmq: "^5.67.2" },
+    };
+    if (triggers.includes("pubsub") && pubsubProviderDeps[pubsubProvider]) {
+        Object.assign(deps, pubsubProviderDeps[pubsubProvider]);
+    }
+    if (triggers.includes("queue") && queueProviderDeps[queueProvider]) {
+        Object.assign(deps, queueProviderDeps[queueProvider]);
+    }
+    return deps;
+}
+function getProviderEnvVars(triggers, pubsubProvider, queueProvider) {
+    const lines = [];
+    const pubsubEnvVars = {
+        gcp: `
+# Google Cloud Pub/Sub
+GCP_PROJECT_ID=my-project
+GOOGLE_APPLICATION_CREDENTIALS=./credentials.json`,
+        aws: `
+# AWS SNS/SQS
+AWS_REGION=us-east-1
+AWS_ACCESS_KEY_ID=
+AWS_SECRET_ACCESS_KEY=`,
+        azure: `
+# Azure Service Bus
+AZURE_SERVICE_BUS_CONNECTION_STRING=`,
+    };
+    const queueEnvVars = {
+        kafka: `
+# Apache Kafka
+KAFKA_BROKERS=localhost:9092
+KAFKA_CLIENT_ID=blok-queue-trigger
+KAFKA_GROUP_ID=blok-consumer-group`,
+        rabbitmq: `
+# RabbitMQ
+RABBITMQ_URL=amqp://localhost`,
+        sqs: `
+# AWS SQS
+AWS_REGION=us-east-1
+SQS_QUEUE_URL=`,
+        redis: `
+# Redis/BullMQ
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_PASSWORD=`,
+    };
+    if (triggers.includes("pubsub") && pubsubEnvVars[pubsubProvider]) {
+        lines.push(pubsubEnvVars[pubsubProvider]);
+    }
+    if (triggers.includes("queue") && queueEnvVars[queueProvider]) {
+        lines.push(queueEnvVars[queueProvider]);
+    }
+    return lines.join("\n");
+}