blokctl 0.2.0

package/dist/commands/trace/index.js

@@ -0,0 +1,26 @@
+import { program, trackCommandExecution } from "../../services/commander.js";
+import { startStudio } from "./startStudio.js";
+program
+    .command("trace")
+    .alias("studio")
+    .description("Open Blok Studio — real-time workflow trace UI")
+    .option("-p, --port <port>", "Studio UI port", "5555")
+    .option("-u, --url <url>", "Blok backend URL", "http://localhost:4000")
+    .option("--workflow <name>", "Open specific workflow")
+    .option("--run <id>", "Open specific run")
+    .option("--no-open", "Don't auto-open browser")
+    .action(async (options) => {
+    await trackCommandExecution({
+        command: "trace",
+        args: options,
+        execution: async () => {
+            await startStudio({
+                port: Number.parseInt(options.port, 10),
+                url: options.url,
+                workflow: options.workflow,
+                run: options.run,
+                open: options.open,
+            });
+        },
+    });
+});

package/dist/commands/trace/startStudio.d.ts

@@ -0,0 +1,8 @@
+export interface StudioOptions {
+    port: number;
+    url: string;
+    workflow?: string;
+    run?: string;
+    open: boolean;
+}
+export declare function startStudio(options: StudioOptions): Promise<void>;

package/dist/commands/trace/startStudio.js

@@ -0,0 +1,116 @@
+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 * as p from "@clack/prompts";
+import open from "open";
+import color from "picocolors";
+import serveHandler from "serve-handler";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+function resolveStaticPath() {
+    const bundled = path.resolve(__dirname, "../../studio-dist");
+    if (fs.existsSync(path.join(bundled, "index.html")))
+        return bundled;
+    const workspace = path.resolve(__dirname, "../../../../apps/studio/dist");
+    if (fs.existsSync(path.join(workspace, "index.html")))
+        return workspace;
+    return null;
+}
+async function checkBackendHealth(backendUrl) {
+    return new Promise((resolve) => {
+        const url = new URL("/__blok/health", backendUrl);
+        const client = url.protocol === "https:" ? https : http;
+        const req = client.get(url, { timeout: 3000 }, (res) => {
+            resolve(res.statusCode === 200);
+        });
+        req.on("error", () => resolve(false));
+        req.on("timeout", () => {
+            req.destroy();
+            resolve(false);
+        });
+    });
+}
+function proxyRequest(req, res, backendUrl) {
+    const targetUrl = new URL(req.url, backendUrl);
+    const client = targetUrl.protocol === "https:" ? https : http;
+    const proxyReq = client.request(targetUrl, {
+        method: req.method,
+        headers: {
+            ...req.headers,
+            host: targetUrl.host,
+        },
+    }, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+        proxyRes.pipe(res, { end: true });
+    });
+    proxyReq.on("error", () => {
+        if (!res.headersSent) {
+            res.writeHead(502, { "Content-Type": "application/json" });
+            res.end(JSON.stringify({ error: "Backend unavailable" }));
+        }
+    });
+    req.on("close", () => {
+        proxyReq.destroy();
+    });
+    req.pipe(proxyReq, { end: true });
+}
+export async function startStudio(options) {
+    const { port, url: backendUrl, open: shouldOpen } = options;
+    p.intro(color.bgCyan(color.black(" Blok Studio ")));
+    const staticPath = resolveStaticPath();
+    if (!staticPath) {
+        p.log.error(`Studio assets not found.\n` + `  Build them first: ${color.cyan("pnpm --filter @blok/studio build")}`);
+        process.exit(1);
+    }
+    const s = p.spinner();
+    s.start("Checking backend health...");
+    const healthy = await checkBackendHealth(backendUrl);
+    if (!healthy) {
+        s.stop(color.yellow("Backend not reachable"));
+        p.log.warn(`Blok backend not found at ${color.cyan(backendUrl)}\n` + `  Start it first: ${color.cyan("blokctl dev")}`);
+        p.log.info("Starting Studio anyway — it will connect when the backend is up.");
+    }
+    else {
+        s.stop(color.green("Backend healthy"));
+    }
+    const server = http.createServer((req, res) => {
+        const url = req.url || "/";
+        if (url.startsWith("/__blok")) {
+            return proxyRequest(req, res, backendUrl);
+        }
+        serveHandler(req, res, {
+            public: staticPath,
+            rewrites: [{ source: "**", destination: "/index.html" }],
+        });
+    });
+    return new Promise(() => {
+        server.listen(port, async () => {
+            let studioUrl = `http://localhost:${port}`;
+            if (options.workflow) {
+                studioUrl += `/workflows/${encodeURIComponent(options.workflow)}`;
+            }
+            else if (options.run) {
+                studioUrl += `/runs/${encodeURIComponent(options.run)}`;
+            }
+            p.log.success(`Studio running at ${color.cyan(studioUrl)}`);
+            p.log.info(`Connected to backend at ${color.dim(backendUrl)}`);
+            console.log(color.dim("  Press Ctrl+C to stop\n"));
+            if (shouldOpen) {
+                await open(studioUrl);
+            }
+        });
+        const stop = () => {
+            console.log();
+            server.close(() => {
+                p.outro(color.dim("Blok Studio stopped."));
+                process.exit(0);
+            });
+            setTimeout(() => process.exit(0), 3000);
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        process.once("SIGQUIT", stop);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+#! /usr/bin/env bun
+import "./commands/login/index.js";
+import "./commands/logout/index.js";
+import "./commands/build/index.js";
+import "./commands/deploy/index.js";
+import "./commands/monitor/index.js";
+import "./commands/publish/index.js";
+import "./commands/install/index.js";
+import "./commands/search/index.js";
+import "./commands/generate/index.js";
+import "./commands/config/index.js";
+import "./commands/migrate/index.js";
+import "./commands/graph/index.js";
+import "./commands/profile/index.js";
+import "./commands/cost/index.js";
+import "./commands/trace/index.js";
+export declare const CLI_NAME = "blokctl";

package/dist/index.js

@@ -0,0 +1,186 @@
+#! /usr/bin/env bun
+import child_process from "node:child_process";
+import os from "node:os";
+import util from "node:util";
+import * as p from "@clack/prompts";
+import fsExtra from "fs-extra";
+import color from "picocolors";
+import { createNode } from "./commands/create/node.js";
+import { createProject } from "./commands/create/project.js";
+import { createWorkflow } from "./commands/create/workflow.js";
+import { devProject } from "./commands/dev/index.js";
+import { program } from "./services/commander.js";
+import { setNonInteractive } from "./services/non-interactive.js";
+import { PosthogAnalytics } from "./services/posthog.js";
+import { getPackageVersion } from "./services/utils.js";
+import "./commands/login/index.js";
+import "./commands/logout/index.js";
+import "./commands/build/index.js";
+import "./commands/deploy/index.js";
+import "./commands/monitor/index.js";
+import "./commands/publish/index.js";
+import "./commands/install/index.js";
+import "./commands/search/index.js";
+import "./commands/generate/index.js";
+import "./commands/config/index.js";
+import "./commands/migrate/index.js";
+import "./commands/graph/index.js";
+import "./commands/profile/index.js";
+import "./commands/cost/index.js";
+import "./commands/trace/index.js";
+import { Command } from "commander";
+const version = await getPackageVersion();
+const exec = util.promisify(child_process.exec);
+export const CLI_NAME = "blokctl";
+const validateVersion = async (currentVersion) => {
+    let latestVersion;
+    try {
+        const execResponse = await exec(`npm view ${CLI_NAME} version`);
+        latestVersion = execResponse.stdout.trim();
+    }
+    catch {
+        return { currentVersion, latestVersion: currentVersion, isLatest: true };
+    }
+    const [latestMajor, latestMinor, latestPatch] = latestVersion.split(".").map(Number);
+    const [currentMajor, currentMinor, currentPatch] = currentVersion.split(".").map(Number);
+    let isLatest = true;
+    if (latestMajor > currentMajor ||
+        (latestMajor === currentMajor && latestMinor > currentMinor) ||
+        (latestMajor === currentMajor && latestMinor === currentMinor && latestPatch > currentPatch)) {
+        p.log.warn(`A new version of ${CLI_NAME} CLI is available.\nPlease update to the latest version.\nVersion:\t${color.red(currentVersion)} > ${color.green(latestVersion)}`);
+        isLatest = false;
+    }
+    return {
+        currentVersion,
+        latestVersion,
+        isLatest,
+    };
+};
+async function main() {
+    try {
+        const HOME_DIR = `${os.homedir()}/.blok`;
+        const cliConfigPath = `${HOME_DIR}/blokctl.json`;
+        fsExtra.ensureDirSync(HOME_DIR);
+        const analytics = new PosthogAnalytics({
+            version: version,
+            cliConfigPath: cliConfigPath,
+        });
+        program.version(`${version}`, "-v, --version").description(`Blok CLI ${version}`);
+        program.option("--non-interactive", "Disable interactive prompts (fail if required flags are missing)");
+        program.hook("preAction", (thisCommand) => {
+            const opts = thisCommand.opts();
+            if (opts.nonInteractive) {
+                setNonInteractive(true);
+            }
+        });
+        await validateVersion(version);
+        const create = new Command("create").description("Create a new blok component");
+        const project = new Command("project")
+            .description("Create a new Project")
+            .option("-n, --name <value>", "Create a default Project")
+            .option("-l, --local <path>", "Use a local repo path instead of cloning from remote")
+            .option("-t, --trigger <value>", "Single trigger type (backwards compat, default: http)")
+            .option("-T, --triggers <value>", "Comma-separated trigger list: http,sse,pubsub,queue (default: http)")
+            .option("-r, --runtimes <value>", "Comma-separated runtime list (default: node)")
+            .option("-m, --package-manager <value>", "Package manager: npm, yarn, pnpm, bun")
+            .option("--pubsub-provider <value>", "Pub/Sub provider: gcp, aws, azure (default: gcp)")
+            .option("--queue-provider <value>", "Queue provider: kafka, rabbitmq, sqs, redis (default: kafka)")
+            .option("--examples", "Install example workflows and nodes")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "create project",
+                args: options,
+                execution: async () => {
+                    createProject(options, version, false, options.local);
+                },
+            });
+        });
+        project
+            .command(".")
+            .description("Create a new Project")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "create project .",
+                args: options,
+                execution: async () => {
+                    createProject(options, version, true, project.opts().local);
+                },
+            });
+        });
+        const node = new Command("node")
+            .description("Create a new Node")
+            .option("-n, --name <value>", "Create a default Node")
+            .option("-s, --style <value>", "Node style: 'function' (recommended) or 'class'")
+            .option("-r, --runtime <value>", "Runtime: typescript, python3, go, java, rust, csharp, php, ruby")
+            .option("-m, --package-manager <value>", "Package manager: npm, yarn, pnpm, bun")
+            .option("--node-type <value>", "Node type: module, class (TypeScript only)")
+            .option("--template <value>", "Template: standard, ui (TypeScript only)")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "create node",
+                args: options,
+                execution: async () => {
+                    createNode(options, false);
+                },
+            });
+        });
+        node
+            .command(".")
+            .description("Create a new Node")
+            .option("-s, --style <value>", "Node style: 'function' (recommended) or 'class'")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "create node",
+                args: options,
+                execution: async () => {
+                    createNode(options, true);
+                },
+            });
+        });
+        const workflow = new Command("workflow")
+            .description("Create a new Workflow")
+            .option("-n, --name <value>", "Create a default Workflow")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "create workflow",
+                args: options,
+                execution: async () => {
+                    createWorkflow(options, false);
+                },
+            });
+        });
+        workflow
+            .command(".")
+            .description("Create a new Workflow")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "create workflow",
+                args: options,
+                execution: async () => {
+                    createWorkflow(options, true);
+                },
+            });
+        });
+        create.addCommand(project);
+        create.addCommand(node);
+        create.addCommand(workflow);
+        program.addCommand(create);
+        program
+            .command("dev")
+            .description("Start the development server")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "dev",
+                args: options,
+                execution: async () => {
+                    devProject(options);
+                },
+            });
+        });
+        program.parse(process.argv);
+    }
+    catch (err) {
+        console.log(err.message);
+    }
+}
+main();

package/dist/services/commander.d.ts

@@ -0,0 +1,9 @@
+import { Command, type OptionValues } from "commander";
+declare const program: Command;
+type TrackCommandExecutionParams = {
+    command: string;
+    args: OptionValues;
+    execution: () => Promise<void>;
+};
+declare const trackCommandExecution: ({ command, args, execution }: TrackCommandExecutionParams) => Promise<void>;
+export { program, trackCommandExecution, Command, type OptionValues, type TrackCommandExecutionParams };

package/dist/services/commander.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+import { Command } from "commander";
+import { PosthogAnalytics } from "./posthog.js";
+import { getPackageVersion } from "./utils.js";
+const version = await getPackageVersion();
+const program = new Command();
+const HOME_DIR = `${os.homedir()}/.blok`;
+const cliConfigPath = `${HOME_DIR}/blokctl.json`;
+const analytics = new PosthogAnalytics({
+    version: version,
+    cliConfigPath: cliConfigPath,
+});
+const trackCommandExecution = async ({ command, args, execution }) => {
+    await analytics.trackCommandExecution({
+        command: command,
+        args: args,
+        execution,
+    });
+};
+export { program, trackCommandExecution, Command };

package/dist/services/constants.d.ts

@@ -0,0 +1 @@
+export declare const BLOK_URL: string;

package/dist/services/constants.js

@@ -0,0 +1,3 @@
+export const BLOK_URL = process.env.BLOK_DEV === "true"
+    ? "https://runner-dev.dac-us-east-1.deskree.com/public/deployment"
+    : "https://runner.dac-us-east-1.deskree.com/public/deployment";

package/dist/services/local-token-manager.d.ts

@@ -0,0 +1,14 @@
+declare class LocalTokenManager {
+    private storageDir;
+    private tokenFile;
+    constructor();
+    private ensureStorage;
+    private getEncryptionKey;
+    private encrypt;
+    private decrypt;
+    storeToken(token: string): boolean;
+    getToken(): string | null;
+    clearToken(): boolean;
+}
+declare const tokenManager: LocalTokenManager;
+export { LocalTokenManager, tokenManager };

package/dist/services/local-token-manager.js

@@ -0,0 +1,99 @@
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+class LocalTokenManager {
+    storageDir;
+    tokenFile;
+    constructor() {
+        this.storageDir = path.join(os.homedir(), ".blok/token");
+        this.tokenFile = path.join(this.storageDir, "token.enc");
+        this.ensureStorage();
+    }
+    ensureStorage() {
+        try {
+            if (!fs.existsSync(this.storageDir)) {
+                fs.mkdirSync(this.storageDir, { mode: 0o700 });
+            }
+            else {
+                fs.chmodSync(this.storageDir, 0o700);
+            }
+            if (!fs.existsSync(this.tokenFile)) {
+                fs.writeFileSync(this.tokenFile, "", { mode: 0o600 });
+            }
+            else {
+                fs.chmodSync(this.tokenFile, 0o600);
+            }
+        }
+        catch (error) {
+            console.error("Failed to initialize secure storage:", error.message);
+            throw new Error("Could not set up secure token storage, please check permissions.");
+        }
+    }
+    getEncryptionKey() {
+        const machineId = os.hostname();
+        const salt = crypto
+            .createHash("sha256")
+            .update(os.userInfo().username + os.arch() + os.platform())
+            .digest("hex");
+        return crypto.scryptSync(machineId + salt, "salt", 32);
+    }
+    encrypt(text) {
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv("aes-256-gcm", this.getEncryptionKey(), iv);
+        let encrypted = cipher.update(text, "utf8", "hex");
+        encrypted += cipher.final("hex");
+        const authTag = cipher.getAuthTag().toString("hex");
+        return `${iv.toString("hex")}:${authTag}:${encrypted}`;
+    }
+    decrypt(encryptedText) {
+        const parts = encryptedText.split(":");
+        if (parts.length !== 3) {
+            throw new Error("Invalid encrypted text format");
+        }
+        const [ivHex, authTagHex, encrypted] = parts;
+        const iv = Buffer.from(ivHex, "hex");
+        const authTag = Buffer.from(authTagHex, "hex");
+        const decipher = crypto.createDecipheriv("aes-256-gcm", this.getEncryptionKey(), iv);
+        decipher.setAuthTag(authTag);
+        let decrypted = decipher.update(encrypted, "hex", "utf8");
+        decrypted += decipher.final("utf8");
+        return decrypted;
+    }
+    storeToken(token) {
+        try {
+            const encrypted = this.encrypt(token);
+            fs.writeFileSync(this.tokenFile, encrypted, { mode: 0o600 });
+            return true;
+        }
+        catch (error) {
+            console.error("Failed to store token:", error.message);
+            return false;
+        }
+    }
+    getToken() {
+        try {
+            if (!fs.existsSync(this.tokenFile))
+                return null;
+            const encrypted = fs.readFileSync(this.tokenFile, "utf8");
+            return this.decrypt(encrypted);
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    clearToken() {
+        try {
+            if (fs.existsSync(this.tokenFile)) {
+                fs.unlinkSync(this.tokenFile);
+            }
+            return true;
+        }
+        catch (error) {
+            console.error("Failed to clear token:", error.message);
+            return false;
+        }
+    }
+}
+const tokenManager = new LocalTokenManager();
+export { LocalTokenManager, tokenManager };

package/dist/services/non-interactive.d.ts

@@ -0,0 +1,5 @@
+export declare function isNonInteractive(): boolean;
+export declare function setNonInteractive(value: boolean): void;
+export declare function resolveOrThrow<T>(flagName: string, flagValue: T | undefined, defaultValue?: T): T;
+export declare function validateChoice<T extends string>(flagName: string, value: T, allowed: readonly T[]): T;
+export declare function parseCommaSeparated(value: string): string[];

package/dist/services/non-interactive.js

@@ -0,0 +1,30 @@
+let _nonInteractive = false;
+export function isNonInteractive() {
+    return _nonInteractive || process.env.BLOK_NON_INTERACTIVE === "1";
+}
+export function setNonInteractive(value) {
+    _nonInteractive = value;
+}
+export function resolveOrThrow(flagName, flagValue, defaultValue) {
+    if (flagValue !== undefined)
+        return flagValue;
+    if (defaultValue !== undefined)
+        return defaultValue;
+    if (isNonInteractive()) {
+        throw new Error(`Missing required flag --${flagName} (non-interactive mode). ` +
+            `Run without --non-interactive to use interactive prompts, or provide --${flagName}.`);
+    }
+    return undefined;
+}
+export function validateChoice(flagName, value, allowed) {
+    if (!allowed.includes(value)) {
+        throw new Error(`Invalid value "${value}" for --${flagName}. Allowed: ${allowed.join(", ")}`);
+    }
+    return value;
+}
+export function parseCommaSeparated(value) {
+    return value
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}

package/dist/services/package-manager.d.ts

@@ -0,0 +1,35 @@
+export declare enum VersionUpdateType {
+    PATCH = "patch",
+    MINOR = "minor",
+    MAJOR = "major"
+}
+type PackageManagerType = {
+    [key: string]: {
+        INSTALL: string;
+        BUILD: string;
+        PUBLISH: (opts: {
+            registry: string;
+            npmrcDir: string;
+        }) => string;
+        INSTALL_NODE: (opts: {
+            node: string;
+            registry: string;
+            npmrcDir: string;
+        }) => string;
+        UPDATE_VERSION: (opts: {
+            type: VersionUpdateType;
+        }) => string;
+    };
+};
+declare class PackageManager {
+    private static instance;
+    private detectedManager;
+    private constructor();
+    static getInstance(): PackageManager;
+    private isAvailable;
+    getAvailableManagers(): Promise<string[]>;
+    getManager(preferedManager?: string): Promise<PackageManagerType[string]>;
+}
+export default PackageManager;
+declare const manager: PackageManager;
+export { manager };