blokctl 0.2.0

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

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

package/dist/commands/build/index.js

@@ -0,0 +1,210 @@
+import child_process from "node:child_process";
+import crypto from "node:crypto";
+import * as p from "@clack/prompts";
+import fs from "fs-extra";
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { BLOK_URL } from "../../services/constants.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+const blokJsonModel = {
+    name: "",
+    builds: [],
+    lastBuild: {},
+    deployments: [],
+    lastDeployment: {},
+};
+async function initBuild(opts) {
+    const initBuild = await fetch(`${BLOK_URL}/build-init`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+        },
+    });
+    if (!initBuild.ok)
+        throw new Error(initBuild.statusText);
+    const initBuildData = await initBuild.json();
+    return initBuildData;
+}
+async function exec(command, args) {
+    await new Promise((resolve, reject) => {
+        const tarProcess = child_process.spawn(command, args);
+        tarProcess.on("close", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Tar process exited with code ${code}`));
+            }
+        });
+        tarProcess.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+async function createTarBall(opts) {
+    const fileName = `${crypto.randomUUID()}.tar.gz`;
+    const args = [
+        "-czf",
+        `${opts.directory}/${fileName}`,
+        "-C",
+        opts.directory,
+        `--exclude=${fileName}`,
+        "--exclude=.blok.json",
+        "--exclude=.git",
+        "--exclude=node_modules",
+        "--exclude=package-lock.json",
+        "--exclude=README.md",
+        "--exclude=.blok/runtimes/python3/python3_runtime/lib",
+        ".",
+    ];
+    try {
+        await exec("tar", args);
+    }
+    catch (error) {
+        throw new Error(`Failed to create tarball: ${error}`);
+    }
+    return fileName;
+}
+async function storeFiles(opts) {
+    const file = await fs.readFile(`${opts.directory}/${opts.tarball}`);
+    const requestOptions = {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/x-gzip",
+        },
+        body: file,
+        redirect: "follow",
+    };
+    const storing = await fetch(opts.url, requestOptions);
+    if (!storing.ok)
+        throw new Error("Failed to store file in S3 bucket");
+}
+async function building(opts) {
+    const build = await fetch(`${BLOK_URL}/build/${opts.id}`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${opts.token}`,
+        },
+        body: JSON.stringify({
+            key: opts.key,
+        }),
+    });
+    if (!build.ok)
+        throw new Error(build.statusText);
+    const buildData = await build.json();
+    return buildData;
+}
+async function getBuildStatus(opts) {
+    const buildStatus = await fetch(`${BLOK_URL}/build-status/${opts.id}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+        },
+    });
+    if (!buildStatus.ok)
+        throw new Error(buildStatus.statusText);
+    const buildStatusData = await buildStatus.json();
+    return buildStatusData;
+}
+export async function build(opts) {
+    const logger = p.spinner();
+    try {
+        logger.start(`Building blok in ${opts.directory}...`);
+        logger.message("Validating authentication...");
+        opts.token = tokenManager.getToken();
+        if (!opts.token)
+            throw new Error("No token found. Please login first.");
+        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(`${opts.directory}/Dockerfile`))
+            throw new Error(`Dockerfile not found in ${opts.directory}`);
+        if (!fs.existsSync(blokFile)) {
+            fs.ensureFileSync(blokFile);
+            fs.writeJSONSync(blokFile, blokJsonModel, { spaces: 2 });
+            logger.message("Creating .blok.json file...");
+        }
+        logger.message("Loading .blok.json file...");
+        const json = fs.readJSONSync(blokFile);
+        logger.message("Creating tarball...");
+        opts.tarball = await createTarBall(opts);
+        fs.ensureFileSync(opts.tarball);
+        logger.message("Tarball created");
+        logger.message("Initializing build...");
+        const init = await initBuild(opts);
+        opts.id = init.id;
+        opts.url = init.data.url;
+        opts.key = init.data.key;
+        logger.message("Build initialized");
+        logger.message("Storing files...");
+        await storeFiles(opts);
+        fs.removeSync(opts.tarball);
+        logger.message("Files stored");
+        logger.message("Building blok...");
+        const build = await building(opts);
+        let status;
+        do {
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+            status = await getBuildStatus(opts);
+            logger.message(`Build ${status?.status?.condition?.reason}`);
+        } while (status?.status?.condition?.status === "Unknown");
+        logger.message("Storing build result...");
+        const initBuildModel = {
+            id: opts.id,
+            tarball: opts.tarball,
+            key: opts.key,
+            buildMessage: build.data.message,
+            creationTimestamp: build.data.creationTimestamp,
+            startTime: status?.status?.startTime,
+            completionTime: status?.status?.completionTime,
+            reason: status?.status?.condition?.reason,
+            status: status?.status?.condition?.status,
+            statusMessage: status?.status?.condition?.message,
+            updatedAt: new Date().toISOString(),
+        };
+        json.builds.push(initBuildModel);
+        json.lastBuild = initBuildModel;
+        fs.writeJSONSync(blokFile, json, { spaces: 2 });
+        if (status?.status?.condition?.status !== "True")
+            throw new Error(status?.status?.condition?.message);
+        logger.stop("Build completed successfully");
+        return true;
+    }
+    catch (error) {
+        if (opts.tarball && fs.existsSync(opts.tarball))
+            fs.removeSync(opts.tarball);
+        if (opts.id)
+            logger.error(`Build Failed. ${error} - Build ID: ${opts.id}`);
+        else
+            logger.error(`Build Failed. ${error}`);
+        console.error(error);
+        return false;
+    }
+}
+const buildCmd = program
+    .command("build")
+    .option("-d, --directory [value]", "Directory of the blok (defaults to current directory)", process.cwd())
+    .description("Build blok")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "build",
+        args: options,
+        execution: async () => {
+            await build(options);
+        },
+    });
+});
+buildCmd
+    .command(".")
+    .description("Build blok in the current directory")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "build .",
+        args: options,
+        execution: async () => {
+            options.directory = process.cwd();
+            await build(options);
+        },
+    });
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/commands/config/index.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import os from "node:os";
+import { Command } from "commander";
+import { program } from "../../services/commander.js";
+const create = new Command("config").description("Configure CLI settings");
+create
+    .command("set")
+    .description("Configure CLI settings")
+    .option("--editor <editor>", "Set default editor 'Visual Studio Code', 'Cursor', 'Sublime Text', 'Atom', 'WebStorm'", (value) => {
+    const validEditors = ["Visual Studio Code", "Cursor", "Sublime Text", "Atom", "WebStorm"];
+    if (!validEditors.includes(value)) {
+        throw new Error(`Editor must be one of: ${validEditors.join(", ")}`);
+    }
+    return value;
+})
+    .action(async (options) => {
+    const configDir = `${os.homedir()}/.blok`;
+    const configPath = `${configDir}/config.json`;
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+    }
+    if (options.editor) {
+        config.defaultEditor = options.editor;
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        console.log(`Default editor set to: ${options.editor}`);
+    }
+});
+create
+    .command("list")
+    .description("Show current CLI configuration")
+    .action(() => {
+    const configPath = `${os.homedir()}/.blok/config.json`;
+    if (fs.existsSync(configPath)) {
+        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        console.log("Current configuration:");
+        console.log(JSON.stringify(config, null, 2));
+    }
+    else {
+        console.log("No configuration file found. Using defaults.");
+    }
+});
+program.addCommand(create);

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

@@ -0,0 +1 @@
+export {};

package/dist/commands/cost/index.js

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import * as p from "@clack/prompts";
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { loadWorkflow, loadWorkflows } from "../../services/workflow-loader.js";
+async function getCostEstimator() {
+    const { CostEstimator } = await import("@blok/runner");
+    return CostEstimator;
+}
+program
+    .command("cost [workflow-name]")
+    .description("Estimate execution costs for workflows")
+    .option("--executions <count>", "Monthly execution count", "10000")
+    .option("--provider <provider>", "Cloud provider: aws, gcp, azure, local", "aws")
+    .option("--format <format>", "Output format: table, json", "table")
+    .option("--output <file>", "Write output to file")
+    .option("-d, --directory [value]", "Project directory", process.cwd())
+    .action(async (workflowName, options) => {
+    await trackCommandExecution({
+        command: "cost",
+        args: options,
+        execution: async () => {
+            const logger = p.spinner();
+            logger.start("Loading workflows...");
+            const directory = options.directory;
+            const provider = options.provider || "aws";
+            const executions = Number.parseInt(options.executions, 10) || 10_000;
+            let workflows = [];
+            if (workflowName) {
+                const wf = await loadWorkflow(directory, workflowName);
+                if (!wf) {
+                    logger.error(`Workflow "${workflowName}" not found.`);
+                    return;
+                }
+                workflows = [wf];
+            }
+            else {
+                workflows = await loadWorkflows(directory);
+            }
+            if (workflows.length === 0) {
+                logger.error("No workflow files found.");
+                p.log.warn("Make sure your project has workflow JSON files in the workflows/ directory.");
+                return;
+            }
+            logger.stop(`Found ${workflows.length} workflow(s).`);
+            const CostEstimator = await getCostEstimator();
+            const estimator = new CostEstimator({
+                provider: provider,
+                executionsPerMonth: executions,
+            });
+            for (const wf of workflows) {
+                estimator.estimateWorkflow(wf.def);
+            }
+            let output;
+            const format = options.format;
+            switch (format) {
+                case "json":
+                    output = estimator.toJson();
+                    break;
+                default:
+                    output = estimator.toTable();
+            }
+            if (options.output) {
+                fs.writeFileSync(options.output, output, "utf-8");
+                p.log.success(`Cost estimate written to ${options.output}`);
+            }
+            else {
+                console.log(output);
+            }
+            const estimates = estimator.getEstimates();
+            const totalMonthly = estimates.reduce((sum, e) => sum + e.monthlyCost, 0);
+            p.log.info(`Total estimated monthly cost (${provider.toUpperCase()}, ${executions.toLocaleString()} exec/month): $${totalMonthly.toFixed(2)}`);
+        },
+    });
+});

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

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