blokctl 0.2.0

package/dist/commands/graph/index.js

@@ -0,0 +1,69 @@
+import fs from "node:fs";
+import * as p from "@clack/prompts";
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { loadWorkflows } from "../../services/workflow-loader.js";
+async function getNodeDependencyGraph() {
+    const { NodeDependencyGraph } = await import("@blok/runner");
+    return NodeDependencyGraph;
+}
+program
+    .command("graph")
+    .description("Visualize node dependencies across workflows")
+    .option("--format <format>", "Output format: ascii, mermaid, dot, json", "ascii")
+    .option("--workflow <name>", "Filter to a specific workflow")
+    .option("--node <name>", "Show dependencies for a specific node")
+    .option("--output <file>", "Write output to file instead of stdout")
+    .option("--direction <dir>", "Graph direction: TB, LR, BT, RL", "TB")
+    .option("-d, --directory [value]", "Project directory", process.cwd())
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "graph",
+        args: options,
+        execution: async () => {
+            const logger = p.spinner();
+            logger.start("Loading workflows...");
+            const workflows = await loadWorkflows(options.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 NodeDependencyGraph = await getNodeDependencyGraph();
+            const graph = new NodeDependencyGraph({
+                direction: options.direction || "TB",
+                filterWorkflow: options.workflow || "",
+                filterNode: options.node || "",
+                showWorkflowBoundaries: true,
+                showOrphanNodes: true,
+            });
+            for (const wf of workflows) {
+                graph.addWorkflow(wf.def);
+            }
+            let output;
+            const format = options.format;
+            switch (format) {
+                case "mermaid":
+                    output = graph.toMermaid();
+                    break;
+                case "dot":
+                    output = graph.toDot();
+                    break;
+                case "json":
+                    output = graph.toJson();
+                    break;
+                default:
+                    output = graph.toAscii();
+            }
+            if (options.output) {
+                fs.writeFileSync(options.output, output, "utf-8");
+                p.log.success(`Graph written to ${options.output}`);
+            }
+            else {
+                console.log(output);
+            }
+            const stats = graph.getStats();
+            p.log.info(`Nodes: ${stats.totalNodes} | Edges: ${stats.totalEdges} | Shared: ${stats.sharedNodes} | Orphans: ${stats.orphanNodes}`);
+        },
+    });
+});

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

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

package/dist/commands/install/index.js

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

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

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

package/dist/commands/install/node.js

@@ -0,0 +1,136 @@
+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 { manager as pm } from "../../services/package-manager.js";
+import { registryManager } from "../../services/registry-manager.js";
+const discoveryNodeRuntime = async () => {
+    return "npm";
+};
+export async function install(opts) {
+    const token = tokenManager.getToken();
+    const npmrcFile = `${opts.directory}/.npmrc`;
+    const logger = p.spinner();
+    try {
+        if (!token)
+            throw new Error("Token is invalid.");
+        if (!opts.node)
+            throw new Error("Node name is required.");
+        const nodeFilePath = path.resolve(opts.directory, "./src/Nodes.ts");
+        if (!fs.existsSync(nodeFilePath)) {
+            throw new Error("Node.ts file does not exist in the specified directory.");
+        }
+        const packageJsonPath = path.resolve(opts.directory, "./package.json");
+        if (!fs.existsSync(packageJsonPath)) {
+            throw new Error("package.json file does not exist in the specified directory.");
+        }
+        const availableManagers = await pm.getAvailableManagers();
+        let manager = await pm.getManager();
+        logger.start("Installing node...");
+        const runtime = await discoveryNodeRuntime();
+        if (runtime === "npm" && availableManagers.length > 1) {
+            if (opts.packageManager) {
+                manager = await pm.getManager(opts.packageManager);
+            }
+            else if (isNonInteractive()) {
+            }
+            else {
+                logger.message("Multiple package managers detected. Please select one.");
+                const selectedManager = await p.select({
+                    message: "Select the package manager",
+                    options: availableManagers.map((manager) => ({
+                        label: manager,
+                        value: manager,
+                    })),
+                });
+                manager = await pm.getManager(selectedManager);
+            }
+        }
+        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.namespace}:registry=${REGISTRY_URL}\n//${registry.url}:_authToken=${registry.token}`;
+        fs.writeFileSync(npmrcFile, npmrcContent);
+        logger.message("Created .npmrc file for authentication.");
+        const nodeName = `@${registry.namespace}/${opts.node}`;
+        logger.message(`Installing node: ${opts.node}...`);
+        const exec = util.promisify(child_process.exec);
+        const { stdout, stderr } = await exec(manager.INSTALL_NODE({ node: nodeName, registry: REGISTRY_URL, npmrcDir: npmrcFile }), { cwd: opts.directory });
+        if (stdout)
+            p.log.info(stdout);
+        else if (stderr)
+            throw new Error(stderr);
+        updateNodeFile(nodeFilePath, {
+            importName: toPascalCase(opts.node),
+            importPath: nodeName,
+        });
+        logger.stop("Node installed successfully.");
+    }
+    catch (error) {
+        if (fs.existsSync(npmrcFile))
+            fs.unlinkSync(npmrcFile);
+        logger.error(error.message);
+    }
+    finally {
+        if (fs.existsSync(npmrcFile))
+            fs.unlinkSync(npmrcFile);
+    }
+}
+function toPascalCase(input) {
+    return input.replace(/[^a-zA-Z0-9]+(.)/g, (_, chr) => chr.toUpperCase()).replace(/^./, (s) => s.toLowerCase());
+}
+function updateNodeFile(filePath, newModule) {
+    let fileContent = fs.readFileSync(filePath, "utf-8");
+    const { importName, importPath } = newModule;
+    const importStatement = `import ${importName} from "${importPath}";`;
+    if (!fileContent.includes(importStatement)) {
+        const importLines = fileContent.match(/^import .*;$/gm) || [];
+        const lastImport = importLines[importLines.length - 1];
+        fileContent = fileContent.replace(lastImport, `${lastImport}\n${importStatement}`);
+    }
+    const nodesRegex = /const\s+nodes\s*:\s*\{[^}]+\}\s*=\s*\{([\s\S]*?)\n\};/;
+    const match = fileContent.match(nodesRegex);
+    if (!match)
+        throw new Error("Could not find the `nodes` object.");
+    const objectBody = match[1].trimEnd();
+    const entryKey = importPath.replace(/^@[^/]+\//, "");
+    const newEntry = `\t"${entryKey}": new ${importName}()`;
+    if (objectBody.includes(`"${entryKey}"`)) {
+        p.log.warn(`Node "${entryKey}" is already installed. Skipping...`);
+        return;
+    }
+    const lines = objectBody
+        .split("\n")
+        .filter(Boolean)
+        .map((line) => line.trimEnd());
+    if (lines.length > 0 && !lines[lines.length - 1].endsWith(",")) {
+        lines[lines.length - 1] += ",";
+    }
+    lines.push(newEntry);
+    const newObject = `const nodes: {\n\t[key: string]: NodeBase;\n} = {\n${lines.join("\n")}\n};`;
+    fileContent = fileContent.replace(nodesRegex, newObject);
+    fs.writeFileSync(filePath, `${fileContent.trimEnd()}\n`, "utf-8");
+}
+export default new Command()
+    .command("node")
+    .description("Install a node from the bloks registry")
+    .option("-d, --directory <value>", "Directory to publish")
+    .option("-m, --package-manager <value>", "Package manager to use (npm, yarn, pnpm, bun)")
+    .argument("<node>", "Node name")
+    .action(async (node, options) => {
+    await trackCommandExecution({
+        command: "install",
+        args: options,
+        execution: async () => {
+            options.node = node;
+            if (!options.directory)
+                options.directory = process.cwd();
+            await install(options);
+        },
+    });
+});

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

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

package/dist/commands/install/workflow.js

@@ -0,0 +1,62 @@
+import * as fs from "node:fs";
+import 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";
+async function searchWorkflow(opts) {
+    const response = await fetch(`${BLOK_URL}/published-workflow-by-id/${opts.workflow}`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${opts.token}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(response.statusText);
+    const searchs = await response.json();
+    return searchs.documents;
+}
+export async function install(opts) {
+    const token = tokenManager.getToken();
+    const logger = p.spinner();
+    try {
+        if (!token)
+            throw new Error("Token is invalid.");
+        if (!opts.workflow)
+            throw new Error("Workflow name is required.");
+        opts.token = token;
+        const workflowInfo = await searchWorkflow(opts);
+        if (workflowInfo.length === 0) {
+            throw new Error("No workflow found.");
+        }
+        const workflow = workflowInfo[0].workflow;
+        logger.start("Installing workflow...");
+        const workflowsDir = path.join(opts.directory, "workflows/json");
+        if (!fs.existsSync(workflowsDir)) {
+            fs.mkdirSync(workflowsDir, { recursive: true });
+        }
+        const workflowPath = path.join(workflowsDir, `${opts.workflow}.json`);
+        fs.writeFileSync(workflowPath, JSON.stringify(workflow, null, 2));
+        logger.stop("Workflow installed successfully.");
+    }
+    catch (error) {
+        logger.error(error.message);
+    }
+}
+export default new Command()
+    .command("workflow")
+    .description("Install a workflow")
+    .option("-d, --directory <value>", "Directory to publish")
+    .argument("<workflow>", "Workflow name")
+    .action(async (workflow, options) => {
+    await trackCommandExecution({
+        command: "install",
+        args: options,
+        execution: async () => {
+            options.workflow = workflow;
+            if (!options.directory)
+                options.directory = process.cwd();
+            await install(options);
+        },
+    });
+});

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

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

package/dist/commands/login/index.js

@@ -0,0 +1,77 @@
+import * as p from "@clack/prompts";
+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";
+async function verifyToken(token) {
+    const response = await fetch(`${BLOK_URL}/login`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${token}`,
+        },
+    });
+    if (!response.ok)
+        throw new Error(response.statusText);
+    const responseJson = await response.json();
+    return responseJson;
+}
+export async function login(opts) {
+    let token = tokenManager.getToken();
+    const BLOKS_TOKEN = process.env.BLOKS_TOKEN;
+    const resolveToken = async () => {
+        let token = process.env.BLOKS_TOKEN;
+        if (token)
+            return token;
+        token = (await p.password({
+            message: "Please provide the token for authentication. You can create it on https://atomic.deskree.com/auth/access/token",
+        }));
+        if (p.isCancel(token)) {
+            p.cancel("Authentication cancelled.");
+            process.exit(0);
+        }
+        return token;
+    };
+    try {
+        if (!token && !BLOKS_TOKEN && !opts.token) {
+            if (isNonInteractive()) {
+                throw new Error("Missing required flag --token or BLOKS_TOKEN env var (non-interactive mode). " +
+                    "Run without --non-interactive to use interactive prompts, or provide --token.");
+            }
+            token = await resolveToken();
+        }
+        else if (opts.token) {
+            token = opts.token;
+        }
+        else if (BLOKS_TOKEN) {
+            token = BLOKS_TOKEN;
+        }
+        if (!token)
+            throw new Error("Token is required.");
+        const isTokenValid = await verifyToken(token);
+        if (!isTokenValid.active)
+            throw new Error("Token is inactive.");
+        p.log.success("Login successful.");
+        const isStored = tokenManager.storeToken(token);
+        if (!isStored)
+            throw new Error("Failed to store the token.");
+        p.log.info("You can now use the CLI commands. For help, run: blokctl --help");
+    }
+    catch (error) {
+        p.log.error("Login failed. Please try again.");
+        p.log.error(error.message);
+        process.exit(1);
+    }
+}
+program
+    .command("login")
+    .description("Login to Bloks")
+    .option("-t, --token <value>", "Login with a token")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "login",
+        args: options,
+        execution: async () => {
+            await login(options);
+        },
+    });
+});

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

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

package/dist/commands/logout/index.js

@@ -0,0 +1,20 @@
+import * as p from "@clack/prompts";
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { tokenManager } from "../../services/local-token-manager.js";
+export async function logout(opts) {
+    tokenManager.clearToken();
+    p.log.success("Logged out successfully.");
+    p.log.info("You can log in again using: blokctl login");
+}
+program
+    .command("logout")
+    .description("Logout from Bloks")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "logout",
+        args: options,
+        execution: async () => {
+            await logout(options);
+        },
+    });
+});

package/dist/commands/marketplace/runtime.d.ts

@@ -0,0 +1,54 @@
+import type { CatalogStats, RuntimeKind, RuntimePackageManifest } from "@blok/runner";
+import { Command } from "../../services/commander.js";
+export interface MarketplaceConfig {
+    registryUrl: string;
+    cacheDir: string;
+    cacheTtlMs: number;
+}
+export interface MarketplaceListOptions {
+    runtime?: RuntimeKind;
+    query?: string;
+    tags?: string[];
+    verified?: boolean;
+    sortBy?: "name" | "downloads" | "rating" | "updated";
+    limit?: number;
+    format?: "table" | "json";
+}
+export interface MarketplaceInstallOptions {
+    name: string;
+    version?: string;
+    runtime?: RuntimeKind;
+    force?: boolean;
+}
+export interface MarketplacePublishOptions {
+    manifestPath: string;
+    dockerImage: string;
+    runtime: RuntimeKind;
+    tags?: string[];
+    description?: string;
+}
+export declare class RuntimeMarketplaceCommand {
+    private config;
+    constructor(config?: Partial<MarketplaceConfig>);
+    search(options: MarketplaceListOptions): Promise<RuntimePackageManifest[]>;
+    install(options: MarketplaceInstallOptions): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    publish(options: MarketplacePublishOptions): Promise<{
+        success: boolean;
+        packageId: string;
+        version: string;
+    }>;
+    info(name: string, version?: string): Promise<RuntimePackageManifest | null>;
+    stats(): Promise<CatalogStats>;
+    list(runtime: RuntimeKind): Promise<RuntimePackageManifest[]>;
+    formatTable(packages: RuntimePackageManifest[]): string;
+    formatJson(packages: RuntimePackageManifest[]): string;
+    private getCacheKey;
+    private readCache;
+    private writeCache;
+    private fetchFromApi;
+}
+declare const _default: Command;
+export default _default;