blokctl 0.2.0

package/dist/commands/create/workflow.d.ts

@@ -0,0 +1,2 @@
+import type { OptionValues } from "commander";
+export declare function createWorkflow(opts: OptionValues, currentPath?: boolean): Promise<void>;

package/dist/commands/create/workflow.js

@@ -0,0 +1,109 @@
+import os from "node:os";
+import path from "node:path";
+import * as p from "@clack/prompts";
+import figlet from "figlet";
+import fsExtra from "fs-extra";
+import color from "picocolors";
+import { isNonInteractive, resolveOrThrow } from "../../services/non-interactive.js";
+import { workflow_template } from "./utils/Examples.js";
+const HOME_DIR = `${os.homedir()}/.blok`;
+const GITHUB_REPO_LOCAL = `${HOME_DIR}/blok`;
+export async function createWorkflow(opts, currentPath = false) {
+    const nonInteractive = isNonInteractive();
+    const isDefault = opts.name !== undefined;
+    const skipPrompts = isDefault || nonInteractive;
+    let workflowName = opts.name ? opts.name : "";
+    if (!skipPrompts) {
+        console.log(figlet.textSync("blok CLI".toUpperCase(), {
+            font: "Digital",
+            horizontalLayout: "default",
+            verticalLayout: "default",
+            width: 100,
+            whitespaceBreak: true,
+        }));
+        console.log("");
+        const resolveWorkflowName = async () => {
+            if (workflowName !== "") {
+                return workflowName;
+            }
+            return (await p.text({
+                message: "Please provide a name for the workflow",
+                placeholder: "workflow-name",
+                defaultValue: "",
+            }));
+        };
+        p.intro(color.inverse(" Creating a new Workflow "));
+        const blokctlNode = await p.group({
+            workflowName: () => resolveWorkflowName(),
+        }, {
+            onCancel: () => {
+                p.cancel("Operation canceled.");
+                process.exit(0);
+            },
+        });
+        workflowName = blokctlNode.workflowName;
+    }
+    else if (nonInteractive) {
+        workflowName = resolveOrThrow("name", opts.name);
+    }
+    const s = p.spinner();
+    if (!skipPrompts)
+        s.start("Creating the workflow...");
+    try {
+        const mainDirExists = fsExtra.existsSync(GITHUB_REPO_LOCAL);
+        if (!mainDirExists)
+            throw new Error("The blok repository was not found. Please run 'npx blokctl@latest create project' to clone the repository.");
+        let dirPath = process.cwd();
+        if (!currentPath) {
+            const currentDir = `${process.cwd()}/src`;
+            const nodeProjectDirExists = fsExtra.existsSync(currentDir);
+            if (!nodeProjectDirExists)
+                throw new Error("ops1");
+            const currentWorkflowsDir = `${dirPath}/workflows/json`;
+            if (!skipPrompts) {
+                fsExtra.ensureDirSync(currentWorkflowsDir);
+            }
+            else {
+                const workflowDirExists = fsExtra.existsSync(currentWorkflowsDir);
+                if (!workflowDirExists)
+                    throw new Error("ops1");
+            }
+            dirPath = path.join(currentWorkflowsDir, `${workflowName.replaceAll(" ", "-").toLowerCase()}.json`);
+        }
+        else {
+            dirPath = path.join(dirPath, `${workflowName.replaceAll(" ", "-").toLowerCase()}.json`);
+        }
+        if (!skipPrompts)
+            s.message("Creating workflow...");
+        if (!currentPath) {
+            const workflowDirExists = fsExtra.existsSync(dirPath);
+            if (workflowDirExists)
+                throw new Error("ops2");
+        }
+        const workflow_json = JSON.parse(workflow_template);
+        workflow_json.name = workflowName;
+        fsExtra.writeFileSync(dirPath, JSON.stringify(workflow_json, null, 2));
+        if (!skipPrompts)
+            s.stop(`Node "${workflowName}" created successfully.`);
+        if (!currentPath)
+            console.log("\nNavigate to the workflow directory by running: cd workflows/json");
+        console.log("For more documentation, visit https://blok.build/docs/d/core-concepts/workflows");
+    }
+    catch (error) {
+        if (!skipPrompts)
+            s.stop("An error occurred");
+        const message = error.message;
+        if (message === "ops1") {
+            console.log("Oops! It seems like you haven't created a project yet... or have you? 🤔\n" +
+                "If you already did, you can navigate to it using: cd project-name\n" +
+                "Otherwise, you can create a new project with: npx blokctl@latest create project");
+        }
+        if (message === "ops2") {
+            console.log("The workflow you are trying to create already exists in the project.\n" +
+                "Please use a different name, or delete the existing workflow to create a new one.");
+        }
+        if (message !== "ops1" && message !== "ops2") {
+            console.log(error.message);
+        }
+    }
+}

package/dist/commands/deploy/index.d.ts

@@ -0,0 +1,2 @@
+import { type OptionValues } from "../../services/commander.js";
+export declare function deploy(opts: OptionValues): Promise<boolean>;

package/dist/commands/deploy/index.js

@@ -0,0 +1,176 @@
+import * as p from "@clack/prompts";
+import fs from "fs-extra";
+import color from "picocolors";
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { isNonInteractive } from "../../services/non-interactive.js";
+import { BLOK_URL } from "../../services/constants.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+import { build as buildCommand } from "../build/index.js";
+async function getDeploymentStatus(opts) {
+    const deploymentStatus = await fetch(`${BLOK_URL}/deploy-status/${opts.name}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+        },
+    });
+    if (!deploymentStatus.ok)
+        throw new Error(deploymentStatus.statusText);
+    const deploymentStatusData = await deploymentStatus.json();
+    return deploymentStatusData.data;
+}
+export async function deploy(opts) {
+    const logger = p.spinner();
+    try {
+        logger.start("Deploying blok...");
+        const blokFile = `${opts.directory}/.blok.json`;
+        logger.message("Checking files...");
+        if (!fs.existsSync(opts.directory))
+            throw new Error(`Directory ${opts.directory} does not exist`);
+        if (!fs.existsSync(blokFile))
+            throw new Error(`.blok.json file not found in ${opts.directory}`);
+        logger.message("Loading .blok.json file...");
+        const json = fs.readJSONSync(blokFile);
+        const nameRegex = /^[a-z](?:[a-z-]*[a-z])?$/;
+        if (!nameRegex.test(opts.name))
+            throw new Error(`Invalid name ${opts.name}. Name should only contain letters and dashes.`);
+        if (!json.name || json.name === "") {
+            json.name = opts.name;
+            fs.writeJSONSync(blokFile, json, { spaces: 2 });
+            logger.message(`Updated .blok.json name to ${opts.name}`);
+        }
+        else {
+            if (json.name !== opts.name) {
+                logger.message(`.blok.json name is ${json.name}, but you provided ${opts.name}`);
+                if (opts.yes || isNonInteractive()) {
+                    json.name = opts.name;
+                    fs.writeJSONSync(blokFile, json, { spaces: 2 });
+                    logger.message(`Updated .blok.json name to ${opts.name}`);
+                }
+                else {
+                    const confirm = await p.confirm({
+                        message: `Do you want to update the name in .blok.json to ${opts.name}?`,
+                        initialValue: false,
+                    });
+                    if (!confirm)
+                        throw new Error("Aborting deployment");
+                    json.name = opts.name;
+                    fs.writeJSONSync(blokFile, json, { spaces: 2 });
+                    logger.message(`Updated .blok.json name to ${opts.name}`);
+                }
+            }
+        }
+        if (!json.lastBuild)
+            throw new Error("No last build found. Please build first.");
+        if (!json.lastBuild.id)
+            throw new Error("No last build id found. Please build first.");
+        if (!json.lastBuild.reason)
+            throw new Error("No last build status found. Please build first.");
+        if (json.lastBuild.reason !== "Succeeded")
+            throw new Error("Last build was not successful. Please build again.");
+        opts.id = json.lastBuild.id;
+        logger.message("Validating authentication...");
+        opts.token = tokenManager.getToken();
+        if (!opts.token)
+            throw new Error("No token found. Please login first.");
+        logger.message("Deployment started...");
+        const deployment = await fetch(`${BLOK_URL}/deploy/${opts.id}`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${opts.token}`,
+            },
+            body: JSON.stringify({
+                serviceName: opts.name,
+                access: opts.public ? "public" : "private",
+            }),
+        });
+        if (!deployment.ok)
+            throw new Error(deployment.statusText);
+        const deploymentData = await deployment.json();
+        if (deploymentData.error)
+            throw new Error(deploymentData.error);
+        let isReady = false;
+        let deploymentStatus = {};
+        let errorCount = 0;
+        do {
+            logger.message("Deploying...");
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            deploymentStatus = await getDeploymentStatus(opts);
+            isReady = true;
+            for (const condition of deploymentStatus?.conditions || []) {
+                if (condition.reason?.includes("Failed")) {
+                    errorCount++;
+                    if (errorCount > 3)
+                        throw new Error(condition.message);
+                }
+                if (condition.status !== "True") {
+                    isReady = false;
+                    break;
+                }
+            }
+        } while (!isReady);
+        logger.message("Updating .blok.json with deployment results...");
+        deploymentData.data.status = deploymentStatus;
+        json.deployments = json.deployments || [];
+        json.deployments.push(deploymentData);
+        json.lastDeployment = deploymentData;
+        fs.writeJSONSync(blokFile, json, { spaces: 2 });
+        logger.message("Deployment completed");
+        logger.stop(`Blok deployed successfully! ${color.gray(`Version: ${deploymentStatus?.latestReadyRevisionName}`)}`);
+        p.log.success(`Service live at: ${color.greenBright(deploymentData?.data?.url)}`);
+        p.log.success(`Monitoring live at: ${color.greenBright(deploymentData?.data?.prometheusUrl)}`);
+        return true;
+    }
+    catch (error) {
+        logger.error(`Error: ${error}`);
+        return false;
+    }
+}
+const deployCmd = program
+    .command("deploy")
+    .description("Deploy blok")
+    .requiredOption("-n, --name <name>", "Name of the blok")
+    .option("--build", "Build before deploying", () => true)
+    .option("--public", "Make the blok public (default: false)", false)
+    .option("-d, --directory [value]", "Directory of the blok (defaults to current directory)", process.cwd())
+    .option("-y, --yes", "Auto-confirm name mismatch update")
+    .action(async (options) => {
+    if (options.build) {
+        await trackCommandExecution({
+            command: "deploy --build",
+            args: options,
+            execution: async () => {
+                await buildCommand(options);
+            },
+        });
+    }
+    await trackCommandExecution({
+        command: "deploy",
+        args: options,
+        execution: async () => {
+            await deploy(options);
+        },
+    });
+});
+deployCmd
+    .command(".")
+    .description("Deploy blok in the current directory")
+    .action(async (options) => {
+    if (options.build) {
+        await trackCommandExecution({
+            command: "deploy . --build",
+            args: options,
+            execution: async () => {
+                await buildCommand(options);
+            },
+        });
+    }
+    await trackCommandExecution({
+        command: "deploy .",
+        args: options,
+        execution: async () => {
+            options.directory = process.cwd();
+            await deploy(options);
+        },
+    });
+});

package/dist/commands/dev/index.d.ts

@@ -0,0 +1,2 @@
+import type { OptionValues } from "commander";
+export declare function devProject(opts: OptionValues): Promise<void>;

package/dist/commands/dev/index.js

@@ -0,0 +1,190 @@
+import { spawn } from "node:child_process";
+import http from "node:http";
+import path from "node:path";
+import fsExtra from "fs-extra";
+import { readProjectConfig } from "../../services/runtime-setup.js";
+const runningProcesses = [];
+function spawnProcess(cmd, args, name, currentPath, cwd, env) {
+    const child = spawn(cmd, args, {
+        stdio: "inherit",
+        cwd: cwd || currentPath,
+        env: { ...process.env, BLOK_HMR: "true", NODE_ENV: "development", ...env },
+        detached: true,
+    });
+    console.log(`  ${name} started (PID: ${child.pid})`);
+    runningProcesses.push(child);
+    child.on("exit", (code) => {
+        console.log(`  ${name} exited with code ${code}`);
+    });
+    child.on("error", (err) => {
+        console.error(`  ${name} error: ${err}`);
+    });
+    return child;
+}
+function killAllGroups(signal) {
+    const sig = signal === "SIGKILL" ? "9" : "15";
+    for (const child of runningProcesses) {
+        if (child.pid && child.exitCode === null) {
+            try {
+                spawn("kill", [`-${sig}`, "--", `-${child.pid}`], { stdio: "ignore" });
+            }
+            catch {
+                try {
+                    child.kill(signal);
+                }
+                catch {
+                }
+            }
+        }
+    }
+}
+function waitForHealth(port, timeoutMs, proc) {
+    return new Promise((resolve) => {
+        if (proc && proc.exitCode !== null) {
+            resolve(false);
+            return;
+        }
+        const start = Date.now();
+        let done = false;
+        function finish(result) {
+            if (done)
+                return;
+            done = true;
+            clearInterval(interval);
+            resolve(result);
+        }
+        proc?.on("exit", () => finish(false));
+        const interval = setInterval(() => {
+            if (done)
+                return;
+            if (Date.now() - start > timeoutMs) {
+                finish(false);
+                return;
+            }
+            const req = http.get(`http://localhost:${port}/health`, (res) => {
+                res.resume();
+                if (res.statusCode === 200)
+                    finish(true);
+            });
+            req.on("error", () => {
+            });
+            req.setTimeout(1000, () => req.destroy());
+        }, 500);
+    });
+}
+export async function devProject(opts) {
+    const currentPath = process.cwd();
+    console.log("Starting the development server...");
+    console.log("Current path: ", currentPath);
+    const config = readProjectConfig(currentPath);
+    const runtimeDefs = [];
+    if (config?.runtimes) {
+        for (const [, rt] of Object.entries(config.runtimes)) {
+            const cmdParts = rt.startCmd.split(" ");
+            const cmd = cmdParts[0];
+            const args = cmdParts.slice(1);
+            const runtimeCwd = path.resolve(currentPath, rt.cwd);
+            if (!fsExtra.existsSync(runtimeCwd)) {
+                console.log(`  Warning: ${rt.label} runtime directory not found at ${rt.cwd}. Skipping.`);
+                continue;
+            }
+            runtimeDefs.push({
+                cmd,
+                args,
+                name: `${rt.label} Runtime (port ${rt.port})`,
+                cwd: runtimeCwd,
+                env: {
+                    PORT: String(rt.port),
+                    HOST: "0.0.0.0",
+                },
+                port: rt.port,
+            });
+        }
+    }
+    else {
+        const legacyPythonConfig = path.join(currentPath, ".blok", "runtimes", "python3", "nodemon.json");
+        if (fsExtra.existsSync(legacyPythonConfig)) {
+            runtimeDefs.push({
+                cmd: "npx",
+                args: [
+                    "nodemon@3.1.9",
+                    "--config",
+                    "./.blok/runtimes/python3/nodemon.json",
+                    "--exec",
+                    "./.blok/runtimes/python3/python3_runtime/bin/python3",
+                    "./.blok/runtimes/python3/server.py",
+                ],
+                name: "Python3 Runner (legacy)",
+            });
+        }
+    }
+    const healthChecks = [];
+    for (const def of runtimeDefs) {
+        const child = spawnProcess(def.cmd, def.args, def.name, currentPath, def.cwd, def.env);
+        if (def.port) {
+            healthChecks.push({ port: def.port, proc: child });
+        }
+    }
+    if (config?.triggers && Object.keys(config.triggers).length > 0) {
+        console.log("\nTrigger endpoints:");
+        for (const [, trigger] of Object.entries(config.triggers)) {
+            console.log(`  ${trigger.label}: http://localhost:${trigger.port}/health-check`);
+        }
+    }
+    if (config?.runtimes && Object.keys(config.runtimes).length > 0) {
+        console.log("\nRuntime health endpoints:");
+        for (const [, rt] of Object.entries(config.runtimes)) {
+            console.log(`  ${rt.label}: http://localhost:${rt.port}/health`);
+        }
+    }
+    if (healthChecks.length > 0) {
+        console.log("\nWaiting for runtimes to be ready...");
+        const maxWait = 120_000;
+        const results = await Promise.all(healthChecks.map((hc) => waitForHealth(hc.port, maxWait, hc.proc)));
+        const allReady = results.every(Boolean);
+        if (allReady) {
+            console.log("All runtimes ready.\n");
+        }
+        else {
+            const failedPorts = healthChecks.filter((_, i) => !results[i]).map((hc) => hc.port);
+            console.log(`Warning: Some runtimes did not become healthy: ports ${failedPorts.join(", ")}`);
+            console.log("Starting NodeJS runner anyway.\n");
+        }
+    }
+    if (config?.triggers && Object.keys(config.triggers).length > 0) {
+        console.log("Starting triggers...");
+        for (const [, trigger] of Object.entries(config.triggers)) {
+            const cmdParts = trigger.startCmd.split(" ");
+            const cmd = cmdParts[0];
+            const args = cmdParts.slice(1);
+            if (cmd === "bun" && !args.includes("--watch")) {
+                args.unshift("--watch");
+            }
+            spawnProcess(cmd, args, `${trigger.label} (port ${trigger.port})`, currentPath, undefined, {
+                PORT: String(trigger.port),
+            });
+        }
+    }
+    else {
+        spawnProcess("bun", ["--watch", "run", "src/index.ts"], "Blok Runner", currentPath);
+    }
+    const keepAlive = setInterval(() => { }, 60_000);
+    let stopping = false;
+    function shutdown() {
+        if (stopping)
+            return;
+        stopping = true;
+        console.log("\nStopping processes...");
+        clearInterval(keepAlive);
+        killAllGroups("SIGTERM");
+        setTimeout(() => {
+            killAllGroups("SIGKILL");
+            process.exit(0);
+        }, 3000);
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    process.on("exit", () => {
+        killAllGroups("SIGKILL");
+    });
+}

package/dist/commands/generate/GenerationAnalytics.d.ts

@@ -0,0 +1,61 @@
+export type GenerationType = "node" | "workflow" | "trigger";
+export interface GenerationEvent {
+    id: string;
+    timestamp: string;
+    type: GenerationType;
+    subtype: string;
+    name: string;
+    success: boolean;
+    attempts: number;
+    durationMs: number;
+    errors: string[];
+    promptVersion: string;
+}
+export interface GenerationStats {
+    totalGenerations: number;
+    successCount: number;
+    failureCount: number;
+    successRate: number;
+    averageAttempts: number;
+    averageDurationMs: number;
+    topErrors: Array<{
+        pattern: string;
+        count: number;
+    }>;
+    byType: Record<GenerationType, TypeStats>;
+}
+export interface TypeStats {
+    total: number;
+    success: number;
+    failure: number;
+    successRate: number;
+    averageAttempts: number;
+}
+export declare class GenerationAnalytics {
+    private events;
+    private static instance;
+    static getInstance(): GenerationAnalytics;
+    recordEvent(event: Omit<GenerationEvent, "id" | "timestamp">): GenerationEvent;
+    startTimer(): () => number;
+    getStats(): GenerationStats;
+    private getTypeStats;
+    private getTopErrors;
+    private normalizeErrorPattern;
+    getEvents(filter?: {
+        type?: GenerationType;
+        success?: boolean;
+        since?: string;
+    }): GenerationEvent[];
+    getFirstAttemptSuccessRate(): number;
+    getSuccessRateByPromptVersion(): Record<string, {
+        total: number;
+        success: number;
+        rate: number;
+    }>;
+    toJSON(): string;
+    fromJSON(json: string): void;
+    clear(): void;
+    static resetInstance(): void;
+    private generateId;
+}
+export default GenerationAnalytics;