blokctl 0.2.0

package/dist/commands/monitor/static-web-server.d.ts

@@ -0,0 +1 @@
+export default function startWebMonitorUI(host?: string, token?: string): Promise<void>;

package/dist/commands/monitor/static-web-server.js

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import http from "node:http";
+import https from "node:https";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import open from "open";
+import serveHandler from "serve-handler";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let signalHandlerRegistered = false;
+export default async function startWebMonitorUI(host, token) {
+    const staticPath = path.join(__dirname, "./static");
+    const port = 4040;
+    if (!fs.existsSync(staticPath)) {
+        console.error(`❌ Static path not found: ${staticPath}`);
+        process.exit(1);
+    }
+    const server = http.createServer((req, res) => {
+        handleRequest(req, res, host, token, staticPath);
+    });
+    server.listen(port, async () => {
+        const url = `http://localhost:${port}`;
+        console.log(`📂 Serving UI from: ${staticPath}`);
+        console.log(`🧪 Monitor UI available at: ${url}`);
+        await open(url);
+    });
+    const stop = () => {
+        server.close(() => {
+            console.log("🛑 Monitor UI server stopped.");
+            process.exit(0);
+        });
+    };
+    if (!signalHandlerRegistered) {
+        const signals = ["SIGQUIT", "SIGHUP"];
+        for (const signal of signals) {
+            process.once(signal, stop);
+        }
+        signalHandlerRegistered = true;
+    }
+}
+function handleRequest(req, res, host, token, staticPath) {
+    const url = req.url || "/";
+    const parsedUrl = new URL(url, `http://${req.headers.host}`);
+    const isRootOrIndex = parsedUrl.pathname === "/" || parsedUrl.pathname.startsWith("/index.html");
+    if (parsedUrl.pathname.startsWith("/api/metrics")) {
+        if (!host) {
+            res.writeHead(400, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Missing Prometheus host." }));
+            return;
+        }
+        let query_path = "query_range";
+        if (req.headers["x-table"]) {
+            query_path = "query";
+        }
+        let proxiedUrl = `${host}/api/v1/${query_path}${parsedUrl.search}`;
+        if (req.headers["x-label"]) {
+            const label = req.headers["x-label"];
+            proxiedUrl = `${host}/api/v1/label/${label}/values`;
+        }
+        const isSecure = host.startsWith("https://");
+        const httpModule = isSecure ? https : http;
+        const proxyReq = httpModule.request(proxiedUrl, {
+            method: "GET",
+            headers: {
+                ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                Accept: "application/json",
+                "Accept-Encoding": "identity",
+            },
+        }, (proxyRes) => {
+            res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+            proxyRes.pipe(res, { end: true });
+        });
+        proxyReq.on("error", (err) => {
+            console.error("Proxy error:", err);
+            res.writeHead(500, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Failed to proxy Prometheus request." }));
+        });
+        proxyReq.end();
+        return;
+    }
+    if (isRootOrIndex || parsedUrl.pathname.endsWith(".js") || parsedUrl.pathname.endsWith(".css")) {
+        return serveHandler(req, res, {
+            public: staticPath,
+            cleanUrls: true,
+        });
+    }
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("404 Not Found");
+}

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

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

package/dist/commands/profile/index.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import * as p from "@clack/prompts";
+import { program, trackCommandExecution } from "../../services/commander.js";
+async function getPerformanceProfiler() {
+    const { PerformanceProfiler } = await import("@blok/runner");
+    return PerformanceProfiler;
+}
+async function queryPrometheus(query, host, token) {
+    try {
+        const headers = { "Content-Type": "application/x-www-form-urlencoded" };
+        if (token)
+            headers.Authorization = `Bearer ${token}`;
+        const response = await fetch(`${host}/api/v1/query`, {
+            method: "POST",
+            headers,
+            body: `query=${encodeURIComponent(query)}`,
+        });
+        if (!response.ok)
+            return [];
+        const data = (await response.json());
+        return data?.data?.result ?? [];
+    }
+    catch {
+        return [];
+    }
+}
+program
+    .command("profile [workflow-name]")
+    .description("Profile workflow execution performance and identify bottlenecks")
+    .option("--duration <seconds>", "Duration to collect metrics", "30")
+    .option("--format <format>", "Output format: table, flamechart, json", "table")
+    .option("--output <file>", "Write output to file")
+    .option("--host <host>", "Prometheus host", "http://localhost:9090")
+    .option("--token <token>", "Prometheus auth token")
+    .option("--top <count>", "Show top N bottlenecks", "10")
+    .action(async (workflowName, options) => {
+    await trackCommandExecution({
+        command: "profile",
+        args: options,
+        execution: async () => {
+            const logger = p.spinner();
+            logger.start("Collecting performance metrics from Prometheus...");
+            const host = options.host || "http://localhost:9090";
+            const token = options.token;
+            const topN = Number.parseInt(options.top, 10) || 10;
+            const [nodeTimeResults, _nodeCountResults, nodeMemResults, _nodeCpuResults, _nodeErrResults] = await Promise.all([
+                queryPrometheus("node_time", host, token),
+                queryPrometheus("node_total", host, token),
+                queryPrometheus("node_memory", host, token),
+                queryPrometheus("node_cpu", host, token),
+                queryPrometheus("node_errors_total", host, token),
+            ]);
+            const PerformanceProfiler = await getPerformanceProfiler();
+            const profiler = new PerformanceProfiler({ topN });
+            let hasData = false;
+            for (const result of nodeTimeResults) {
+                const wf = result.metric.workflow || "unknown";
+                const node = result.metric.node || result.metric.name || "unknown";
+                if (workflowName && wf !== workflowName)
+                    continue;
+                const timeMs = Number.parseFloat(result.value[1]) || 0;
+                if (timeMs > 0) {
+                    profiler.addSample(wf, node, timeMs);
+                    hasData = true;
+                }
+            }
+            for (const result of nodeMemResults) {
+                const wf = result.metric.workflow || "unknown";
+                const node = result.metric.node || result.metric.name || "unknown";
+                if (workflowName && wf !== workflowName)
+                    continue;
+                const memMb = Number.parseFloat(result.value[1]) || 0;
+                if (memMb > 0) {
+                    profiler.addSample(wf, node, 0, memMb);
+                }
+            }
+            if (!hasData) {
+                logger.error("No profiling data available.");
+                p.log.warn("Make sure Prometheus is running and workflows have been executed.");
+                p.log.info(`Tried connecting to: ${host}`);
+                return;
+            }
+            logger.stop("Metrics collected.");
+            let output;
+            const format = options.format;
+            switch (format) {
+                case "flamechart":
+                    output = profiler.toFlameChart();
+                    break;
+                case "json":
+                    output = profiler.toJson();
+                    break;
+                default:
+                    output = profiler.toTable();
+            }
+            if (options.output) {
+                fs.writeFileSync(options.output, output, "utf-8");
+                p.log.success(`Profile written to ${options.output}`);
+            }
+            else {
+                console.log(output);
+            }
+            const bottlenecks = profiler.getBottlenecks(3);
+            if (bottlenecks.length > 0) {
+                p.log.info("Top bottlenecks:");
+                for (const b of bottlenecks) {
+                    p.log.message(`  ${b.nodeName}: avg ${b.avgTimeMs.toFixed(1)}ms (${b.percentOfTotal.toFixed(0)}% of total)`);
+                }
+            }
+        },
+    });
+});

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

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

package/dist/commands/publish/index.js

@@ -0,0 +1,4 @@
+import { program } from "../../services/commander.js";
+import node from "./node.js";
+import workflow from "./workflow.js";
+program.command("publish").description("Publish commands").addCommand(node).addCommand(workflow);

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

@@ -0,0 +1,4 @@
+import { Command, type OptionValues } from "../../services/commander.js";
+export declare function publish(opts: OptionValues): Promise<void>;
+declare const _default: Command;
+export default _default;

package/dist/commands/publish/node.js

@@ -0,0 +1,231 @@
+import child_process from "node:child_process";
+import * as fs from "node:fs";
+import path from "node:path";
+import util from "node:util";
+import * as p from "@clack/prompts";
+import { Command, trackCommandExecution } from "../../services/commander.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+import { isNonInteractive } from "../../services/non-interactive.js";
+import { VersionUpdateType, manager as pm } from "../../services/package-manager.js";
+import { registryManager } from "../../services/registry-manager.js";
+const exec = util.promisify(child_process.exec);
+const packagePublisherRuntimes = [
+    {
+        label: "node",
+        value: "npm",
+    },
+];
+const packagePublishVerion = [VersionUpdateType.PATCH, VersionUpdateType.MINOR, VersionUpdateType.MAJOR];
+function findSimilarDirectories(directory, searchTerm) {
+    if (!fs.existsSync(directory))
+        return [];
+    const dirs = fs.readdirSync(directory).filter((file) => fs.statSync(path.join(directory, file)).isDirectory());
+    return dirs.filter((dir) => {
+        const dirName = dir.toLowerCase();
+        const search = searchTerm.toLowerCase();
+        if (dirName === search)
+            return true;
+        if (dirName.startsWith(search))
+            return true;
+        const words = dirName.split(/[-_]/);
+        if (words.some((word) => word.startsWith(search)))
+            return true;
+        if (search.length >= 3) {
+            let matches = 0;
+            let searchIndex = 0;
+            for (let i = 0; i < dirName.length && searchIndex < search.length; i++) {
+                if (dirName[i] === search[searchIndex]) {
+                    matches++;
+                    searchIndex++;
+                }
+            }
+            return matches >= search.length * 0.5;
+        }
+        return false;
+    });
+}
+async function loadNodeDirectories(baseDir) {
+    const nodesDir = path.join(baseDir, "src/nodes");
+    if (!fs.existsSync(nodesDir)) {
+        throw new Error("src/nodes directory not found");
+    }
+    const dirs = fs.readdirSync(nodesDir).filter((file) => fs.statSync(path.join(nodesDir, file)).isDirectory());
+    return dirs.map((dir) => ({
+        label: dir,
+        value: dir,
+    }));
+}
+export async function publish(opts) {
+    const token = tokenManager.getToken();
+    const npmrcFile = `${opts.directory}/.npmrc`;
+    const logger = p.spinner();
+    let packageJsonOriginal = null;
+    try {
+        if (!token)
+            throw new Error("Authentication token not found. Please run 'blokctl login' before publishing.");
+        if (!opts.directory)
+            throw new Error("Directory is required.");
+        logger.start("Publishing node to the registry...");
+        if (opts.node === ".") {
+            logger.message("Using current directory for publishing");
+        }
+        else {
+            const nodesDir = path.join(opts.directory, "src/nodes");
+            let targetNodeDir;
+            if (opts.node) {
+                const nodePath = path.join(nodesDir, opts.node);
+                if (!fs.existsSync(nodePath)) {
+                    const similarDirs = findSimilarDirectories(nodesDir, opts.node);
+                    if (similarDirs.length > 0) {
+                        if (isNonInteractive()) {
+                            throw new Error(`Node "${opts.node}" not found. Similar nodes: ${similarDirs.join(", ")}. Provide an exact node name in non-interactive mode.`);
+                        }
+                        logger.message("Similar nodes found");
+                        const selection = await p.select({
+                            message: "Select a node to publish",
+                            options: similarDirs.map((dir) => ({
+                                label: dir,
+                                value: dir,
+                            })),
+                        });
+                        if (p.isCancel(selection)) {
+                            throw new Error("Operation cancelled");
+                        }
+                        targetNodeDir = selection;
+                        opts.directory = path.join(nodesDir, targetNodeDir);
+                    }
+                    else {
+                        throw new Error(`Node "${opts.node}" not found and no similar nodes found in src/nodes directory`);
+                    }
+                }
+                else {
+                    targetNodeDir = opts.node;
+                    opts.directory = nodePath;
+                }
+            }
+            else {
+                if (isNonInteractive()) {
+                    throw new Error("Missing required argument <node> (non-interactive mode). Provide the node name as an argument.");
+                }
+                logger.message("Select a node to publish");
+                const nodeOptions = await loadNodeDirectories(opts.directory);
+                if (nodeOptions.length === 0) {
+                    throw new Error("No nodes found in src/nodes directory");
+                }
+                const selection = await p.select({
+                    message: "Select a node to publish",
+                    options: nodeOptions,
+                });
+                if (p.isCancel(selection)) {
+                    throw new Error("Operation cancelled");
+                }
+                targetNodeDir = selection;
+                opts.directory = path.join(nodesDir, targetNodeDir);
+            }
+        }
+        const runtimesToPublish = opts.runtime
+            ? opts.runtime
+            : isNonInteractive()
+                ? "npm"
+                : await p.select({
+                    message: "Select node runtime",
+                    options: packagePublisherRuntimes,
+                    initialValue: "npm",
+                });
+        const manager = await pm.getManager(runtimesToPublish);
+        const versionType = opts.bump
+            ? opts.bump
+            : isNonInteractive()
+                ? "patch"
+                : await p.select({
+                    message: "Select the version bump type",
+                    options: packagePublishVerion.map((v) => ({ label: v, value: v })),
+                    initialValue: "patch",
+                });
+        if (opts.build) {
+            logger.start("Running build before publishing...");
+            const { stderr: buildError } = await exec(manager.BUILD, { cwd: opts.directory });
+            if (buildError) {
+                logger.stop(buildError);
+                throw new Error(`Error running build: ${buildError}`);
+            }
+            logger.stop("Build completed successfully.");
+        }
+        logger.message(`Updating package version to ${String(versionType)}...`);
+        const { stderr: versionError } = await exec(manager.UPDATE_VERSION({ type: versionType }), {
+            cwd: opts.directory,
+        });
+        if (versionError) {
+            throw new Error(`Error updating package version: ${versionError}`);
+        }
+        const registry = await registryManager.getRegistryToken(token);
+        if (registry.error)
+            throw new Error("Failed to get registry token.");
+        const REGISTRY_URL = `https://${registry.url}`;
+        const npmrcContent = `registry=${REGISTRY_URL}\n//${registry.url}:_authToken=${registry.token}`;
+        fs.writeFileSync(npmrcFile, npmrcContent);
+        logger.message("Created .npmrc file for authentication.");
+        const packageJsonPath = `${opts.directory}/package.json`;
+        if (!fs.existsSync(packageJsonPath)) {
+            logger.stop("package.json not found in the specified directory.");
+            throw new Error("package.json not found in the specified directory.");
+        }
+        packageJsonOriginal = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = { ...packageJsonOriginal };
+        if (!packageJson.name) {
+            logger.stop("package.json does not have a name field.");
+            throw new Error("package.json does not have a name field.");
+        }
+        if (packageJson.name.startsWith("@") && !packageJson.name.startsWith(`@${registry.namespace}`)) {
+            throw new Error("If you are publishing to the bloks registry, the package.json shouldn't be scoped.");
+        }
+        if (!packageJson.name.startsWith(`@${registry.namespace}`)) {
+            packageJson.name = `@${registry.namespace}/${packageJson.name}`;
+            packageJson.private = false;
+            packageJson.files = ["dist"];
+        }
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+        const { stdout } = await exec(manager.PUBLISH({ registry: REGISTRY_URL, npmrcDir: npmrcFile }), {
+            cwd: opts.directory,
+        });
+        const publishResult = JSON.parse(stdout);
+        if (publishResult.error) {
+            logger.stop(publishResult.error);
+            throw new Error(`Error publishing node: ${publishResult.error}`);
+        }
+        logger.stop(`Node published successfully \n Node: ${publishResult.id} \n Version: ${publishResult.version} \n Packed Size: ${publishResult.size} bytes / Unpacked Size: ${publishResult.unpackedSize} bytes \n Amount of files: ${publishResult.entryCount}`);
+    }
+    catch (error) {
+        if (fs.existsSync(npmrcFile))
+            fs.unlinkSync(npmrcFile);
+        logger.error(error.message);
+    }
+    finally {
+        if (fs.existsSync(npmrcFile))
+            fs.unlinkSync(npmrcFile);
+        if (packageJsonOriginal) {
+            const packageJsonPath = `${opts.directory}/package.json`;
+            fs.writeFileSync(packageJsonPath, JSON.stringify(packageJsonOriginal, null, 2));
+        }
+    }
+}
+export default new Command()
+    .command("node")
+    .description("Publish a node to the bloks registry")
+    .option("-d, --directory <value>", "Directory to publish")
+    .option("-b, --build", "Run build before publishing")
+    .option("-r, --runtime <value>", "Publishing runtime (default: npm)")
+    .option("--bump <value>", "Version bump: patch, minor, major (default: patch)")
+    .argument("<node>", "Node name")
+    .action(async (node, options) => {
+    await trackCommandExecution({
+        command: "publish",
+        args: options,
+        execution: async () => {
+            if (!options.directory)
+                options.directory = process.cwd();
+            options.node = node;
+            await publish(options);
+        },
+    });
+});

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

@@ -0,0 +1,4 @@
+import { Command, type OptionValues } from "../../services/commander.js";
+export declare function publish(opts: OptionValues): Promise<void>;
+declare const _default: Command;
+export default _default;

package/dist/commands/publish/workflow.js

@@ -0,0 +1,165 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as p from "@clack/prompts";
+import { Command, trackCommandExecution } from "../../services/commander.js";
+import { BLOK_URL } from "../../services/constants.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+import { isNonInteractive } from "../../services/non-interactive.js";
+function findSimilarFiles(directory, searchTerm) {
+    const files = fs.readdirSync(directory);
+    return files
+        .filter((file) => file.endsWith(".json"))
+        .filter((file) => {
+        const fileName = file.toLowerCase().replace(".json", "");
+        const search = searchTerm.toLowerCase();
+        if (fileName === search)
+            return true;
+        if (fileName.startsWith(search))
+            return true;
+        const words = fileName.split(/[-_]/);
+        if (words.some((word) => word.startsWith(search)))
+            return true;
+        if (search.length >= 3) {
+            let matches = 0;
+            let searchIndex = 0;
+            for (let i = 0; i < fileName.length && searchIndex < search.length; i++) {
+                if (fileName[i] === search[searchIndex]) {
+                    matches++;
+                    searchIndex++;
+                }
+            }
+            return matches >= search.length * 0.5;
+        }
+        return false;
+    });
+}
+async function loadWorkflowFiles(directory) {
+    const workflowsDir = path.join(directory, "workflows/json");
+    if (!fs.existsSync(workflowsDir)) {
+        throw new Error("workflows/json directory not found");
+    }
+    const files = fs.readdirSync(workflowsDir);
+    return files
+        .filter((file) => file.endsWith(".json"))
+        .map((file) => {
+        const content = JSON.parse(fs.readFileSync(path.join(workflowsDir, file), "utf-8"));
+        return {
+            label: file.replace(".json", ""),
+            value: {
+                id: file.replace(".json", ""),
+                content: content,
+            },
+        };
+    });
+}
+async function publishWorkflow(token, workflow, name) {
+    const response = await fetch(`${BLOK_URL}/publish-workflow`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`,
+        },
+        body: JSON.stringify({
+            workflow: workflow,
+            id: name,
+        }),
+    });
+    if (!response.ok)
+        throw new Error(response.statusText);
+    const responseJson = await response.json();
+    return responseJson;
+}
+export async function publish(opts) {
+    const token = tokenManager.getToken();
+    const logger = p.spinner();
+    try {
+        if (!token)
+            throw new Error("Authentication token not found. Please run 'blokctl login' before publishing.");
+        if (!opts.directory)
+            throw new Error("Directory is required.");
+        logger.start("Loading workflows...");
+        const workflowsDir = path.join(opts.directory, "workflows/json");
+        if (!fs.existsSync(workflowsDir)) {
+            throw new Error("workflows/json directory not found");
+        }
+        let workflow;
+        let workflowId = "";
+        if (opts.workflow) {
+            const workflowPath = path.join(workflowsDir, `${opts.workflow}.json`);
+            if (!fs.existsSync(workflowPath)) {
+                const similarFiles = findSimilarFiles(workflowsDir, opts.workflow);
+                if (similarFiles.length > 0) {
+                    if (isNonInteractive()) {
+                        throw new Error(`Workflow "${opts.workflow}" not found. Similar workflows: ${similarFiles.map((f) => f.replace(".json", "")).join(", ")}. Provide an exact workflow name in non-interactive mode.`);
+                    }
+                    logger.stop("Similar workflows found");
+                    const selection = await p.select({
+                        message: "Select a workflow to publish",
+                        options: similarFiles.map((file) => ({
+                            label: file.replace(".json", ""),
+                            value: {
+                                id: file.replace(".json", ""),
+                                content: JSON.parse(fs.readFileSync(path.join(workflowsDir, file), "utf-8")),
+                            },
+                        })),
+                    });
+                    if (p.isCancel(selection)) {
+                        throw new Error("Operation cancelled");
+                    }
+                    workflow = selection.content;
+                    workflowId = selection.id;
+                }
+                else {
+                    throw new Error(`Workflow with ID "${opts.workflow}" not found and no similar workflows found`);
+                }
+            }
+            else {
+                workflow = JSON.parse(fs.readFileSync(workflowPath, "utf-8"));
+                workflowId = opts.workflow;
+            }
+        }
+        else {
+            if (isNonInteractive()) {
+                throw new Error("Missing required argument <workflow> (non-interactive mode). Provide the workflow name as an argument.");
+            }
+            logger.stop("Select a workflow to publish");
+            const workflowOptions = await loadWorkflowFiles(opts.directory);
+            if (workflowOptions.length === 0) {
+                throw new Error("No workflows found in workflows/json directory");
+            }
+            const selection = await p.select({
+                message: "Select a workflow to publish",
+                options: workflowOptions,
+            });
+            if (p.isCancel(selection)) {
+                throw new Error("Operation cancelled");
+            }
+            workflow = selection.content;
+            workflowId = selection.id;
+        }
+        logger.start("Publishing workflow...");
+        const name = opts.name || workflowId;
+        await publishWorkflow(token, workflow, name);
+        logger.stop("Workflow published successfully");
+    }
+    catch (error) {
+        logger.error(error.message);
+    }
+}
+export default new Command()
+    .command("workflow")
+    .description("Publish a workflow")
+    .option("-d, --directory <value>", "Directory to publish")
+    .argument("<workflow>", "Workflow name")
+    .action(async (workflow, options) => {
+    await trackCommandExecution({
+        command: "publish workflow",
+        args: options,
+        execution: async () => {
+            options.workflow = workflow;
+            if (!options.directory)
+                options.directory = process.cwd();
+            await publish(options);
+        },
+    });
+});

package/dist/commands/search/docs.d.ts

@@ -0,0 +1,17 @@
+import { Command } from "../../services/commander.js";
+interface SearchOptions {
+    noCache?: boolean;
+    useAI?: boolean;
+}
+export declare class SearchService {
+    private readonly MAX_TOKENS;
+    private readonly indexer;
+    private extractKeywords;
+    private estimateTokens;
+    private getRankedFilesFromIndex;
+    private getLimitedContext;
+    ask(question: string, options?: SearchOptions): Promise<void>;
+    private formatResponseText;
+}
+declare const _default: Command;
+export default _default;