blokctl 0.2.0

package/dist/commands/marketplace/runtime.js

@@ -0,0 +1,350 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import * as p from "@clack/prompts";
+import { Command, trackCommandExecution } from "../../services/commander.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+const DEFAULT_REGISTRY_URL = "https://marketplace.blok.dev/api/v1";
+const DEFAULT_CACHE_DIR = path.join(os.homedir(), ".blok", "marketplace-cache");
+const DEFAULT_CACHE_TTL_MS = 3_600_000;
+export class RuntimeMarketplaceCommand {
+    config;
+    constructor(config) {
+        this.config = {
+            registryUrl: config?.registryUrl ?? process.env.BLOK_MARKETPLACE_URL ?? DEFAULT_REGISTRY_URL,
+            cacheDir: config?.cacheDir ?? DEFAULT_CACHE_DIR,
+            cacheTtlMs: config?.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS,
+        };
+        if (!fs.existsSync(this.config.cacheDir)) {
+            fs.mkdirSync(this.config.cacheDir, { recursive: true });
+        }
+    }
+    async search(options) {
+        const cacheKey = this.getCacheKey(options);
+        const cached = this.readCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        const searchOptions = {
+            query: options.query,
+            runtime: options.runtime,
+            tags: options.tags,
+            verified: options.verified,
+            sortBy: options.sortBy,
+            limit: options.limit,
+        };
+        const params = {};
+        if (searchOptions.query)
+            params.query = searchOptions.query;
+        if (searchOptions.runtime)
+            params.runtime = searchOptions.runtime;
+        if (searchOptions.tags && searchOptions.tags.length > 0)
+            params.tags = searchOptions.tags.join(",");
+        if (searchOptions.verified !== undefined)
+            params.verified = String(searchOptions.verified);
+        if (searchOptions.sortBy)
+            params.sortBy = searchOptions.sortBy;
+        if (searchOptions.limit)
+            params.limit = String(searchOptions.limit);
+        const result = await this.fetchFromApi("/packages/search", params);
+        const packages = result.packages;
+        this.writeCache(cacheKey, packages);
+        return packages;
+    }
+    async install(options) {
+        try {
+            let version = options.version;
+            if (!version) {
+                const versionInfo = await this.fetchFromApi(`/packages/${encodeURIComponent(options.name)}/versions/latest`);
+                version = versionInfo.latest;
+            }
+            const manifest = await this.fetchFromApi(`/packages/${encodeURIComponent(options.name)}/versions/${encodeURIComponent(version)}`);
+            if (options.runtime && manifest.runtime !== options.runtime) {
+                return {
+                    success: false,
+                    message: `Package "${options.name}" is for runtime "${manifest.runtime}", not "${options.runtime}".`,
+                };
+            }
+            if (manifest.dockerImage) {
+                const { exec } = await import("node:child_process");
+                const { promisify } = await import("node:util");
+                const execAsync = promisify(exec);
+                const pullCommand = options.force
+                    ? `docker pull --force ${manifest.dockerImage}`
+                    : `docker pull ${manifest.dockerImage}`;
+                try {
+                    await execAsync(pullCommand);
+                }
+                catch (dockerError) {
+                    return {
+                        success: false,
+                        message: `Failed to pull Docker image "${manifest.dockerImage}": ${dockerError.message}`,
+                    };
+                }
+            }
+            const catalogDir = path.join(os.homedir(), ".blok", "catalog");
+            if (!fs.existsSync(catalogDir)) {
+                fs.mkdirSync(catalogDir, { recursive: true });
+            }
+            const catalogFile = path.join(catalogDir, "installed.json");
+            let catalog = {};
+            if (fs.existsSync(catalogFile)) {
+                catalog = JSON.parse(fs.readFileSync(catalogFile, "utf-8"));
+            }
+            const catalogKey = `${manifest.name}@${manifest.version}`;
+            if (catalog[catalogKey] && !options.force) {
+                return {
+                    success: false,
+                    message: `Package "${catalogKey}" is already installed. Use --force to reinstall.`,
+                };
+            }
+            catalog[catalogKey] = manifest;
+            fs.writeFileSync(catalogFile, JSON.stringify(catalog, null, 2), "utf-8");
+            return {
+                success: true,
+                message: `Successfully installed ${manifest.name}@${manifest.version} (${manifest.runtime} runtime).`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to install "${options.name}": ${error.message}`,
+            };
+        }
+    }
+    async publish(options) {
+        try {
+            const manifestPath = path.resolve(options.manifestPath);
+            if (!fs.existsSync(manifestPath)) {
+                return {
+                    success: false,
+                    packageId: "",
+                    version: "",
+                };
+            }
+            const rawManifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+            const manifest = {
+                name: rawManifest.name,
+                version: rawManifest.version,
+                runtime: options.runtime,
+                description: options.description ?? rawManifest.description ?? "",
+                author: rawManifest.author ?? "",
+                license: rawManifest.license ?? "MIT",
+                repository: rawManifest.repository,
+                tags: options.tags ?? rawManifest.tags ?? [],
+                protocols: rawManifest.protocols ?? ["http"],
+                dockerImage: options.dockerImage,
+                minBlokVersion: rawManifest.minBlokVersion,
+                nodeCount: rawManifest.nodes?.length ?? 0,
+                nodes: rawManifest.nodes ?? [],
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                downloads: 0,
+                rating: 0,
+                verified: false,
+            };
+            if (!manifest.name) {
+                return { success: false, packageId: "", version: "" };
+            }
+            if (!manifest.version) {
+                return { success: false, packageId: "", version: "" };
+            }
+            const token = tokenManager.getToken();
+            if (!token) {
+                return { success: false, packageId: "", version: "" };
+            }
+            const response = await fetch(`${this.config.registryUrl}/packages`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${token}`,
+                },
+                body: JSON.stringify(manifest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`API error (${response.status}): ${errorText}`);
+            }
+            const result = await response.json();
+            return {
+                success: true,
+                packageId: result.packageId ?? manifest.name,
+                version: manifest.version,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                packageId: "",
+                version: "",
+            };
+        }
+    }
+    async info(name, version) {
+        try {
+            const versionPath = version
+                ? `/packages/${encodeURIComponent(name)}/versions/${encodeURIComponent(version)}`
+                : `/packages/${encodeURIComponent(name)}`;
+            return await this.fetchFromApi(versionPath);
+        }
+        catch {
+            return null;
+        }
+    }
+    async stats() {
+        return this.fetchFromApi("/stats");
+    }
+    async list(runtime) {
+        const params = { runtime };
+        const result = await this.fetchFromApi("/packages", params);
+        return result.packages;
+    }
+    formatTable(packages) {
+        if (packages.length === 0) {
+            return "No packages found.";
+        }
+        const headers = ["Name", "Version", "Runtime", "Downloads", "Rating", "Verified", "Description"];
+        const rows = packages.map((pkg) => [
+            pkg.name,
+            pkg.version,
+            pkg.runtime,
+            String(pkg.downloads),
+            pkg.rating.toFixed(1),
+            pkg.verified ? "Yes" : "No",
+            pkg.description.length > 40 ? `${pkg.description.substring(0, 37)}...` : pkg.description,
+        ]);
+        const colWidths = headers.map((header, index) => {
+            const maxDataWidth = rows.reduce((max, row) => Math.max(max, row[index].length), 0);
+            return Math.max(header.length, maxDataWidth);
+        });
+        const separator = `+-${colWidths.map((w) => "-".repeat(w)).join("-+-")}-+`;
+        const headerRow = `| ${headers.map((h, i) => h.padEnd(colWidths[i])).join(" | ")} |`;
+        const dataRows = rows.map((row) => `| ${row.map((cell, i) => cell.padEnd(colWidths[i])).join(" | ")} |`);
+        return [separator, headerRow, separator, ...dataRows, separator].join("\n");
+    }
+    formatJson(packages) {
+        return JSON.stringify(packages, null, 2);
+    }
+    getCacheKey(options) {
+        const parts = [];
+        if (options.runtime)
+            parts.push(`runtime:${options.runtime}`);
+        if (options.query)
+            parts.push(`query:${options.query}`);
+        if (options.tags && options.tags.length > 0)
+            parts.push(`tags:${options.tags.sort().join(",")}`);
+        if (options.verified !== undefined)
+            parts.push(`verified:${options.verified}`);
+        if (options.sortBy)
+            parts.push(`sortBy:${options.sortBy}`);
+        if (options.limit)
+            parts.push(`limit:${options.limit}`);
+        const key = parts.length > 0 ? parts.join("|") : "all";
+        return hashToSafeFilename(key);
+    }
+    readCache(key) {
+        try {
+            const cacheFile = path.join(this.config.cacheDir, `${key}.json`);
+            if (!fs.existsSync(cacheFile)) {
+                return null;
+            }
+            const raw = fs.readFileSync(cacheFile, "utf-8");
+            const entry = JSON.parse(raw);
+            if (Date.now() - entry.timestamp > this.config.cacheTtlMs) {
+                fs.unlinkSync(cacheFile);
+                return null;
+            }
+            return entry.data;
+        }
+        catch {
+            return null;
+        }
+    }
+    writeCache(key, data) {
+        try {
+            const cacheFile = path.join(this.config.cacheDir, `${key}.json`);
+            const entry = {
+                timestamp: Date.now(),
+                data,
+            };
+            fs.writeFileSync(cacheFile, JSON.stringify(entry), "utf-8");
+        }
+        catch {
+        }
+    }
+    async fetchFromApi(apiPath, params) {
+        const url = new URL(`${this.config.registryUrl}${apiPath}`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                url.searchParams.set(key, value);
+            }
+        }
+        const token = tokenManager.getToken();
+        const headers = {
+            "Content-Type": "application/json",
+        };
+        if (token) {
+            headers.Authorization = `Bearer ${token}`;
+        }
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers,
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Marketplace API error (${response.status}): ${errorText}`);
+        }
+        return (await response.json());
+    }
+}
+function hashToSafeFilename(input) {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+        const char = input.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0;
+    }
+    return Math.abs(hash).toString(36);
+}
+export default new Command()
+    .command("runtime")
+    .description("Manage runtime packages from the Blok marketplace")
+    .option("-r, --runtime <value>", "Filter by runtime kind (nodejs, python3, go, rust, etc.)")
+    .option("-q, --query <value>", "Search query string")
+    .option("-t, --tags <value>", "Comma-separated tags to filter by")
+    .option("--verified", "Show only verified packages")
+    .option("-s, --sort-by <value>", "Sort by: name, downloads, rating, updated", "downloads")
+    .option("-l, --limit <value>", "Limit number of results", "20")
+    .option("-f, --format <value>", "Output format: table or json", "table")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "marketplace runtime",
+        args: options,
+        execution: async () => {
+            const logger = p.spinner();
+            try {
+                logger.start("Searching marketplace for runtime packages...");
+                const marketplace = new RuntimeMarketplaceCommand();
+                const listOptions = {
+                    runtime: options.runtime,
+                    query: options.query,
+                    tags: options.tags ? options.tags.split(",") : undefined,
+                    verified: options.verified,
+                    sortBy: options.sortBy ?? "downloads",
+                    limit: options.limit ? Number.parseInt(options.limit, 10) : 20,
+                    format: options.format ?? "table",
+                };
+                const packages = await marketplace.search(listOptions);
+                if (packages.length === 0) {
+                    logger.stop("No packages found matching your criteria.");
+                    return;
+                }
+                const output = listOptions.format === "json" ? marketplace.formatJson(packages) : marketplace.formatTable(packages);
+                logger.stop(`Found ${packages.length} package(s):\n\n${output}`);
+            }
+            catch (error) {
+                logger.error(error.message);
+            }
+        },
+    });
+});

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

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

package/dist/commands/migrate/index.js

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { program } from "../../services/commander.js";
+import { migrateNode } from "./node.js";
+const migrate = new Command("migrate").description("Migrate nodes and workflows to newer patterns");
+const node = new Command("node")
+    .description("Migrate a class-based node to function-first pattern")
+    .option("-p, --path <value>", "Path to the node file to migrate")
+    .option("--backup", "Create backup before migration (default in non-interactive mode)")
+    .option("--no-backup", "Skip backup creation")
+    .action(async (options) => {
+    await migrateNode(options);
+});
+migrate.addCommand(node);
+program.addCommand(migrate);

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

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

package/dist/commands/migrate/node.js

@@ -0,0 +1,110 @@
+import path from "node:path";
+import * as p from "@clack/prompts";
+import fsExtra from "fs-extra";
+import color from "picocolors";
+import { isNonInteractive } from "../../services/non-interactive.js";
+export async function migrateNode(opts) {
+    console.log(color.cyan("\n🔄 Node Migration Tool"));
+    console.log(color.dim("Converts class-based nodes to function-first pattern\n"));
+    const nodePath = opts.path;
+    if (!nodePath) {
+        p.cancel("Error: Please provide a node path using --path");
+        process.exit(1);
+    }
+    const s = p.spinner();
+    s.start("Analyzing node...");
+    try {
+        const absolutePath = path.isAbsolute(nodePath) ? nodePath : path.resolve(process.cwd(), nodePath);
+        if (!fsExtra.existsSync(absolutePath)) {
+            s.stop("Error: File not found");
+            console.log(color.red(`\n❌ File not found: ${absolutePath}`));
+            process.exit(1);
+        }
+        const fileContent = fsExtra.readFileSync(absolutePath, "utf8");
+        if (fileContent.includes("defineNode")) {
+            s.stop("Already using function-first pattern");
+            console.log(color.yellow("\n⚠️  This node is already using the function-first pattern!"));
+            console.log(color.dim("No migration needed.\n"));
+            process.exit(0);
+        }
+        if (!fileContent.includes("extends BlokService")) {
+            s.stop("Not a class-based node");
+            console.log(color.red("\n❌ This doesn't appear to be a class-based BlokService node."));
+            console.log(color.dim("Migration is only supported for nodes extending BlokService.\n"));
+            process.exit(1);
+        }
+        s.stop("Node analyzed");
+        console.log(color.green("\n✅ This is a class-based node that can be migrated!"));
+        console.log(`\n${color.bold("Migration Steps:")}\n`);
+        console.log(`1. ${color.cyan("Backup your current file:")}`);
+        console.log(color.dim(`   cp ${nodePath} ${nodePath}.backup`));
+        console.log(`\n2. ${color.cyan("Follow the migration guide:")}`);
+        console.log(color.dim("   https://github.com/yourrepo/blok/blob/main/MIGRATION_GUIDE.md"));
+        console.log(`\n3. ${color.cyan("Key changes needed:")}`);
+        console.log(color.dim("   • Replace class with defineNode()"));
+        console.log(color.dim("   • Convert JSON Schema to Zod schemas"));
+        console.log(color.dim("   • Move handle() logic to execute()"));
+        console.log(color.dim("   • Remove BlokResponse boilerplate"));
+        console.log(color.dim("   • Return plain objects instead of response.setSuccess()"));
+        console.log(`\n4. ${color.cyan("Example transformation:")}`);
+        console.log(color.dim("\n   Before (class-based):"));
+        console.log(color.dim(`
+   export default class MyNode extends BlokService<InputType> {
+     async handle(ctx: Context, inputs: InputType) {
+       const response = new BlokResponse();
+       try {
+         const result = await doSomething(inputs.value);
+         response.setSuccess({ result });
+       } catch (error) {
+         const nodeError = new GlobalError(error.message);
+         response.setError(nodeError);
+       }
+       return response;
+     }
+   }`));
+        console.log(color.dim("\n   After (function-first):"));
+        console.log(color.dim(`
+   export default defineNode({
+     name: "my-node",
+     input: z.object({ value: z.string() }),
+     output: z.object({ result: z.string() }),
+     async execute(ctx, input) {
+       const result = await doSomething(input.value);
+       return { result };
+     }
+   });`));
+        console.log(`\n5. ${color.cyan("Test your migrated node:")}`);
+        console.log(color.dim("   • Run existing tests to verify behavior"));
+        console.log(color.dim("   • Check that input/output validation works"));
+        console.log(color.dim("   • Verify error handling is correct"));
+        console.log(`\n6. ${color.cyan("Resources:")}`);
+        console.log(color.dim("   • Full Migration Guide: MIGRATION_GUIDE.md"));
+        console.log(color.dim("   • defineNode API Docs: core/runner/FUNCTION_FIRST_NODES.md"));
+        console.log(color.dim("   • Example Nodes: core/runner/examples/function-first/"));
+        let shouldBackup;
+        if (opts.backup !== undefined) {
+            shouldBackup = opts.backup;
+        }
+        else if (isNonInteractive()) {
+            shouldBackup = true;
+        }
+        else {
+            shouldBackup = await p.confirm({
+                message: "Would you like to create a backup of this file now?",
+                initialValue: true,
+            });
+        }
+        if (shouldBackup) {
+            const backupPath = `${absolutePath}.backup`;
+            fsExtra.copyFileSync(absolutePath, backupPath);
+            console.log(color.green(`\n✅ Backup created: ${backupPath}`));
+        }
+        console.log(color.cyan("\n💡 Tip:") +
+            color.dim(" Start by migrating one node as a reference, then use it as a template for others.\n"));
+    }
+    catch (error) {
+        s.stop("Error occurred");
+        console.log(color.red(`\n❌ Error: ${error.message}\n`));
+        process.exit(1);
+    }
+}

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

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

package/dist/commands/monitor/index.js

@@ -0,0 +1,28 @@
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+import { runMonitor } from "./monitor-component.js";
+import startWebMonitorUI from "./static-web-server.js";
+program
+    .command("monitor")
+    .description("Monitor the performance of your workflows")
+    .option("--web", "Open the metrics dashboard in your browser")
+    .option("--host <host>", "Remote prometheus host")
+    .option("--token <token>", "Remote prometheus token")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "monitor",
+        args: options,
+        execution: async () => {
+            let token = tokenManager.getToken();
+            if (!token) {
+                token = options.token;
+            }
+            if (options.web) {
+                await startWebMonitorUI(options.host || "http://localhost:9090", token);
+            }
+            else {
+                runMonitor(options.host, token);
+            }
+        },
+    });
+});

package/dist/commands/monitor/monitor-component.d.ts

@@ -0,0 +1 @@
+export declare const runMonitor: (host?: string, token?: string) => void;