blokctl 0.4.0 → 0.6.2

package/dist/index.js

@@ -5,6 +5,7 @@ import util from "node:util";
 import * as p from "@clack/prompts";
 import fsExtra from "fs-extra";
 import color from "picocolors";
+import { checkProject } from "./commands/check/index.js";
 import { createNode } from "./commands/create/node.js";
 import { createProject } from "./commands/create/project.js";
 import { createWorkflow } from "./commands/create/workflow.js";
@@ -165,10 +166,22 @@ async function main() {
         create.addCommand(node);
         create.addCommand(workflow);
         program.addCommand(create);
+        program
+            .command("check")
+            .description("Validate runtime version requirements")
+            .action(async (options) => {
+            await analytics.trackCommandExecution({
+                command: "check",
+                args: options,
+                execution: async () => {
+                    await checkProject(options);
+                },
+            });
+        });
         program
             .command("dev")
             .description("Start the development server")
-            .option("--with-http-fallback", "Spawn SDKs on HTTP transport instead of gRPC. Use only when one of your SDKs lacks a working gRPC listener (e.g. PHP without RoadRunner). Removed in v0.4.0.")
+            .option("--skip-version-check", "Skip runtime version validation")
             .action(async (options) => {
             await analytics.trackCommandExecution({
                 command: "dev",

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

@@ -13,7 +13,7 @@ class LocalTokenManager {
     ensureStorage() {
         try {
             if (!fs.existsSync(this.storageDir)) {
-                fs.mkdirSync(this.storageDir, { mode: 0o700 });
+                fs.mkdirSync(this.storageDir, { mode: 0o700, recursive: true });
             }
             else {
                 fs.chmodSync(this.storageDir, 0o700);

package/dist/services/runtime-detector.d.ts

@@ -22,5 +22,6 @@ export interface RuntimeInfo {
 }
 export declare function detectRr(): string | null;
 export declare function detectRuntimes(): Promise<RuntimeInfo[]>;
+export declare function detectRuntimeVersion(kind: string): Promise<string | undefined>;
 export declare function getRuntimeDefinition(kind: string): Omit<RuntimeInfo, "available" | "version"> | undefined;
 export declare function getAllRuntimeDefinitions(): Omit<RuntimeInfo, "available" | "version">[];

package/dist/services/runtime-detector.js

@@ -192,6 +192,18 @@ export async function detectRuntimes() {
     }
     return results;
 }
+export async function detectRuntimeVersion(kind) {
+    const def = RUNTIME_DEFINITIONS.find((r) => r.kind === kind);
+    if (!def)
+        return undefined;
+    for (const cmd of def.commands) {
+        const output = await tryExec(cmd);
+        if (output) {
+            return parseVersion(output, def.kind);
+        }
+    }
+    return undefined;
+}
 export function getRuntimeDefinition(kind) {
     return RUNTIME_DEFINITIONS.find((r) => r.kind === kind);
 }

package/dist/services/runtime-setup.d.ts

@@ -12,7 +12,9 @@ export interface RuntimeConfig {
     cwd: string;
     kind: string;
     label: string;
-    transport?: "grpc" | "http";
+    version?: string;
+    requiredVersion?: string;
+    transport?: "grpc";
 }
 export interface TriggerConfig {
     kind: string;
@@ -31,6 +33,15 @@ export declare function writeProjectConfig(projectDir: string, runtimeConfigs: R
 export declare function readProjectConfig(projectDir: string): ProjectConfig | null;
 export declare function generateRuntimeEnvVars(runtimeConfigs: RuntimeConfig[]): string;
 export declare function generateSupervisordConfig(runtimeConfigs: RuntimeConfig[]): string;
+export interface RuntimeValidationResult {
+    kind: string;
+    label: string;
+    required: string;
+    found: string | undefined;
+    satisfied: boolean;
+    message: string;
+}
+export declare function validateProjectRuntimes(projectDir: string): Promise<RuntimeValidationResult[]>;
 export declare function getTriggerPort(triggerKind: string): number;
 export declare function getTriggerLabel(triggerKind: string): string;
 export declare function createTriggerConfig(triggerKind: string): TriggerConfig;

package/dist/services/runtime-setup.js

@@ -2,6 +2,8 @@ import child_process from "node:child_process";
 import path from "node:path";
 import util from "node:util";
 import fsExtra from "fs-extra";
+import { detectRuntimeVersion } from "./runtime-detector.js";
+import { computeDefaultConstraint, formatVersionMismatch, formatVersionSuccess, satisfiesConstraint, } from "./semver-utils.js";
 const exec = util.promisify(child_process.exec);
 export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner) {
     const sdkSourcePath = path.join(githubRepoLocal, "sdks", runtime.sdkDir);
@@ -49,6 +51,8 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
         cwd: path.relative(projectDir, blokctlRuntimeDir),
         kind: runtime.kind,
         label: runtime.label,
+        version: runtime.version,
+        requiredVersion: runtime.version ? computeDefaultConstraint(runtime.version) : undefined,
         transport: "grpc",
     };
 }
@@ -194,6 +198,30 @@ stdout_logfile=/var/log/${rc.kind}.out.log
     }
     return config;
 }
+export async function validateProjectRuntimes(projectDir) {
+    const config = readProjectConfig(projectDir);
+    if (!config?.runtimes)
+        return [];
+    const results = [];
+    for (const [kind, rc] of Object.entries(config.runtimes)) {
+        if (!rc.requiredVersion)
+            continue;
+        const currentVersion = await detectRuntimeVersion(kind);
+        const satisfied = currentVersion ? satisfiesConstraint(currentVersion, rc.requiredVersion) : false;
+        const message = satisfied
+            ? formatVersionSuccess(rc.label, currentVersion, rc.requiredVersion)
+            : formatVersionMismatch(rc.label, currentVersion, rc.requiredVersion);
+        results.push({
+            kind,
+            label: rc.label,
+            required: rc.requiredVersion,
+            found: currentVersion,
+            satisfied,
+            message,
+        });
+    }
+    return results;
+}
 const TRIGGER_PORTS = {
     http: 4000,
     sse: 4001,

package/dist/services/semver-utils.d.ts

@@ -0,0 +1,18 @@
+export interface SemverParts {
+    major: number;
+    minor: number;
+    patch: number;
+}
+export interface ParsedConstraint {
+    operator: ">=" | "^" | "~" | "=" | "";
+    version: string;
+    parts: SemverParts;
+}
+export declare function parseSemver(version: string): SemverParts;
+export declare function compareSemver(a: string, b: string): number;
+export declare function semverGte(a: SemverParts, b: SemverParts): boolean;
+export declare function parseConstraint(constraint: string): ParsedConstraint;
+export declare function satisfiesConstraint(version: string, constraint: string): boolean;
+export declare function computeDefaultConstraint(version: string): string;
+export declare function formatVersionMismatch(runtime: string, found: string | undefined, required: string, installHint?: string): string;
+export declare function formatVersionSuccess(runtime: string, found: string, required: string): string;

package/dist/services/semver-utils.js

@@ -0,0 +1,82 @@
+export function parseSemver(version) {
+    const cleaned = version.trim();
+    const parts = cleaned.split(".").map(Number);
+    return {
+        major: parts[0] || 0,
+        minor: parts[1] || 0,
+        patch: parts[2] || 0,
+    };
+}
+export function compareSemver(a, b) {
+    const pa = parseSemver(a);
+    const pb = parseSemver(b);
+    if (pa.major !== pb.major)
+        return pa.major - pb.major;
+    if (pa.minor !== pb.minor)
+        return pa.minor - pb.minor;
+    return pa.patch - pb.patch;
+}
+export function semverGte(a, b) {
+    if (a.major !== b.major)
+        return a.major > b.major;
+    if (a.minor !== b.minor)
+        return a.minor > b.minor;
+    return a.patch >= b.patch;
+}
+export function parseConstraint(constraint) {
+    const trimmed = constraint.trim();
+    if (trimmed.startsWith(">=")) {
+        const ver = trimmed.slice(2);
+        return { operator: ">=", version: ver, parts: parseSemver(ver) };
+    }
+    if (trimmed.startsWith("^")) {
+        const ver = trimmed.slice(1);
+        return { operator: "^", version: ver, parts: parseSemver(ver) };
+    }
+    if (trimmed.startsWith("~")) {
+        const ver = trimmed.slice(1);
+        return { operator: "~", version: ver, parts: parseSemver(ver) };
+    }
+    const ver = trimmed.startsWith("=") ? trimmed.slice(1) : trimmed;
+    return { operator: trimmed.startsWith("=") ? "=" : "", version: ver, parts: parseSemver(ver) };
+}
+export function satisfiesConstraint(version, constraint) {
+    const actual = parseSemver(version);
+    const parsed = parseConstraint(constraint);
+    const base = parsed.parts;
+    switch (parsed.operator) {
+        case ">=":
+            return semverGte(actual, base);
+        case "^": {
+            if (base.major !== 0) {
+                return actual.major === base.major && semverGte(actual, base);
+            }
+            if (base.minor !== 0) {
+                return actual.major === 0 && actual.minor === base.minor && actual.patch >= base.patch;
+            }
+            return actual.major === 0 && actual.minor === 0 && actual.patch === base.patch;
+        }
+        case "~":
+            return actual.major === base.major && actual.minor === base.minor && actual.patch >= base.patch;
+        case "=":
+        case "":
+            return actual.major === base.major && actual.minor === base.minor && actual.patch === base.patch;
+        default:
+            return false;
+    }
+}
+export function computeDefaultConstraint(version) {
+    const parts = parseSemver(version);
+    return `>=${parts.major}.${parts.minor}.0`;
+}
+export function formatVersionMismatch(runtime, found, required, installHint) {
+    const lines = [`  x ${runtime}`, `    Required: ${required}`, `    Found:    ${found || "not installed"}`];
+    if (installHint) {
+        lines.push(`    Fix:      ${installHint}`);
+    }
+    lines.push("              Or update constraint in .blok/config.json");
+    return lines.join("\n");
+}
+export function formatVersionSuccess(runtime, found, required) {
+    return `  ✓ ${runtime}  ${found} (requires ${required})`;
+}

package/dist/services/semver-utils.test.d.ts

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

package/dist/services/semver-utils.test.js

@@ -0,0 +1,233 @@
+import { describe, expect, it } from "vitest";
+import { compareSemver, computeDefaultConstraint, formatVersionMismatch, formatVersionSuccess, parseConstraint, parseSemver, satisfiesConstraint, semverGte, } from "./semver-utils.js";
+describe("parseSemver", () => {
+    it("parses a full semver string", () => {
+        expect(parseSemver("3.12.0")).toEqual({ major: 3, minor: 12, patch: 0 });
+    });
+    it("parses a two-part version", () => {
+        expect(parseSemver("1.22")).toEqual({ major: 1, minor: 22, patch: 0 });
+    });
+    it("parses a single-part version", () => {
+        expect(parseSemver("17")).toEqual({ major: 17, minor: 0, patch: 0 });
+    });
+    it("handles 0.x versions", () => {
+        expect(parseSemver("0.2.3")).toEqual({ major: 0, minor: 2, patch: 3 });
+        expect(parseSemver("0.0.3")).toEqual({ major: 0, minor: 0, patch: 3 });
+    });
+    it("handles large version numbers", () => {
+        expect(parseSemver("17.0.11")).toEqual({ major: 17, minor: 0, patch: 11 });
+    });
+    it("trims whitespace", () => {
+        expect(parseSemver("  3.12.0  ")).toEqual({ major: 3, minor: 12, patch: 0 });
+    });
+});
+describe("compareSemver", () => {
+    it("returns 0 for equal versions", () => {
+        expect(compareSemver("1.2.3", "1.2.3")).toBe(0);
+    });
+    it("returns positive when a > b (major)", () => {
+        expect(compareSemver("2.0.0", "1.9.9")).toBeGreaterThan(0);
+    });
+    it("returns positive when a > b (minor)", () => {
+        expect(compareSemver("1.3.0", "1.2.9")).toBeGreaterThan(0);
+    });
+    it("returns positive when a > b (patch)", () => {
+        expect(compareSemver("1.2.4", "1.2.3")).toBeGreaterThan(0);
+    });
+    it("returns negative when a < b", () => {
+        expect(compareSemver("1.2.3", "1.2.4")).toBeLessThan(0);
+    });
+    it("treats missing patch as 0", () => {
+        expect(compareSemver("1.22", "1.22.0")).toBe(0);
+    });
+});
+describe("semverGte", () => {
+    it("returns true for equal versions", () => {
+        expect(semverGte({ major: 3, minor: 10, patch: 0 }, { major: 3, minor: 10, patch: 0 })).toBe(true);
+    });
+    it("returns true when major is greater", () => {
+        expect(semverGte({ major: 4, minor: 0, patch: 0 }, { major: 3, minor: 10, patch: 0 })).toBe(true);
+    });
+    it("returns true when minor is greater", () => {
+        expect(semverGte({ major: 3, minor: 11, patch: 0 }, { major: 3, minor: 10, patch: 0 })).toBe(true);
+    });
+    it("returns true when patch is greater", () => {
+        expect(semverGte({ major: 3, minor: 10, patch: 1 }, { major: 3, minor: 10, patch: 0 })).toBe(true);
+    });
+    it("returns false when less than", () => {
+        expect(semverGte({ major: 3, minor: 9, patch: 7 }, { major: 3, minor: 10, patch: 0 })).toBe(false);
+    });
+});
+describe("parseConstraint", () => {
+    it("parses >= operator", () => {
+        const result = parseConstraint(">=3.10.0");
+        expect(result.operator).toBe(">=");
+        expect(result.version).toBe("3.10.0");
+        expect(result.parts).toEqual({ major: 3, minor: 10, patch: 0 });
+    });
+    it("parses ^ operator", () => {
+        const result = parseConstraint("^1.22.0");
+        expect(result.operator).toBe("^");
+        expect(result.version).toBe("1.22.0");
+    });
+    it("parses ~ operator", () => {
+        const result = parseConstraint("~1.22.0");
+        expect(result.operator).toBe("~");
+        expect(result.version).toBe("1.22.0");
+    });
+    it("parses exact version (no operator)", () => {
+        const result = parseConstraint("3.12.0");
+        expect(result.operator).toBe("");
+        expect(result.version).toBe("3.12.0");
+    });
+    it("parses = operator", () => {
+        const result = parseConstraint("=3.12.0");
+        expect(result.operator).toBe("=");
+        expect(result.version).toBe("3.12.0");
+    });
+    it("trims whitespace", () => {
+        const result = parseConstraint("  >=3.10.0  ");
+        expect(result.operator).toBe(">=");
+        expect(result.version).toBe("3.10.0");
+    });
+});
+describe("satisfiesConstraint", () => {
+    describe(">= operator", () => {
+        it("satisfies when equal", () => {
+            expect(satisfiesConstraint("3.10.0", ">=3.10.0")).toBe(true);
+        });
+        it("satisfies when greater (patch)", () => {
+            expect(satisfiesConstraint("3.10.1", ">=3.10.0")).toBe(true);
+        });
+        it("satisfies when greater (minor)", () => {
+            expect(satisfiesConstraint("3.11.0", ">=3.10.0")).toBe(true);
+        });
+        it("satisfies when greater (major)", () => {
+            expect(satisfiesConstraint("4.0.0", ">=3.10.0")).toBe(true);
+        });
+        it("fails when less than (minor)", () => {
+            expect(satisfiesConstraint("3.9.7", ">=3.10.0")).toBe(false);
+        });
+        it("fails when less than (major)", () => {
+            expect(satisfiesConstraint("2.99.99", ">=3.10.0")).toBe(false);
+        });
+        it("Python 3.12.0 satisfies >=3.10.0", () => {
+            expect(satisfiesConstraint("3.12.0", ">=3.10.0")).toBe(true);
+        });
+        it("Python 3.9.7 does not satisfy >=3.10.0", () => {
+            expect(satisfiesConstraint("3.9.7", ">=3.10.0")).toBe(false);
+        });
+        it("Go 1.22.5 satisfies >=1.21.0", () => {
+            expect(satisfiesConstraint("1.22.5", ">=1.21.0")).toBe(true);
+        });
+        it("Java 17.0.11 satisfies >=17.0.0", () => {
+            expect(satisfiesConstraint("17.0.11", ">=17.0.0")).toBe(true);
+        });
+        it("Java 11.0.2 does not satisfy >=17.0.0", () => {
+            expect(satisfiesConstraint("11.0.2", ">=17.0.0")).toBe(false);
+        });
+    });
+    describe("^ (caret) operator", () => {
+        it("satisfies when equal", () => {
+            expect(satisfiesConstraint("1.22.0", "^1.22.0")).toBe(true);
+        });
+        it("satisfies when patch is higher", () => {
+            expect(satisfiesConstraint("1.22.5", "^1.22.0")).toBe(true);
+        });
+        it("satisfies when minor is higher", () => {
+            expect(satisfiesConstraint("1.23.0", "^1.22.0")).toBe(true);
+        });
+        it("fails when major is different", () => {
+            expect(satisfiesConstraint("2.0.0", "^1.22.0")).toBe(false);
+        });
+        it("fails when version is lower", () => {
+            expect(satisfiesConstraint("1.21.9", "^1.22.0")).toBe(false);
+        });
+        it("^0.2.3 requires minor match", () => {
+            expect(satisfiesConstraint("0.2.3", "^0.2.3")).toBe(true);
+            expect(satisfiesConstraint("0.2.4", "^0.2.3")).toBe(true);
+            expect(satisfiesConstraint("0.3.0", "^0.2.3")).toBe(false);
+        });
+        it("^0.0.3 requires exact patch match", () => {
+            expect(satisfiesConstraint("0.0.3", "^0.0.3")).toBe(true);
+            expect(satisfiesConstraint("0.0.4", "^0.0.3")).toBe(false);
+        });
+    });
+    describe("~ (tilde) operator", () => {
+        it("satisfies when equal", () => {
+            expect(satisfiesConstraint("1.22.0", "~1.22.0")).toBe(true);
+        });
+        it("satisfies when patch is higher", () => {
+            expect(satisfiesConstraint("1.22.5", "~1.22.0")).toBe(true);
+        });
+        it("fails when minor is different", () => {
+            expect(satisfiesConstraint("1.23.0", "~1.22.0")).toBe(false);
+        });
+        it("fails when major is different", () => {
+            expect(satisfiesConstraint("2.22.0", "~1.22.0")).toBe(false);
+        });
+        it("fails when patch is lower", () => {
+            expect(satisfiesConstraint("1.22.0", "~1.22.3")).toBe(false);
+        });
+    });
+    describe("exact version", () => {
+        it("satisfies when exact match", () => {
+            expect(satisfiesConstraint("3.12.0", "3.12.0")).toBe(true);
+        });
+        it("fails when patch differs", () => {
+            expect(satisfiesConstraint("3.12.1", "3.12.0")).toBe(false);
+        });
+        it("fails when minor differs", () => {
+            expect(satisfiesConstraint("3.13.0", "3.12.0")).toBe(false);
+        });
+        it("works with = prefix", () => {
+            expect(satisfiesConstraint("3.12.0", "=3.12.0")).toBe(true);
+            expect(satisfiesConstraint("3.12.1", "=3.12.0")).toBe(false);
+        });
+    });
+});
+describe("computeDefaultConstraint", () => {
+    it("computes >=major.minor.0 from full version", () => {
+        expect(computeDefaultConstraint("3.12.4")).toBe(">=3.12.0");
+    });
+    it("computes >=major.minor.0 when patch is already 0", () => {
+        expect(computeDefaultConstraint("1.22.0")).toBe(">=1.22.0");
+    });
+    it("handles two-part version", () => {
+        expect(computeDefaultConstraint("1.22")).toBe(">=1.22.0");
+    });
+    it("handles large major version (Java)", () => {
+        expect(computeDefaultConstraint("17.0.11")).toBe(">=17.0.0");
+    });
+    it("handles 0.x versions", () => {
+        expect(computeDefaultConstraint("0.2.3")).toBe(">=0.2.0");
+    });
+});
+describe("formatVersionMismatch", () => {
+    it("formats a mismatch with install hint", () => {
+        const result = formatVersionMismatch("Python 3", "3.9.7", ">=3.10.0", "Install Python 3.10+: https://python.org/downloads/");
+        expect(result).toContain("x Python 3");
+        expect(result).toContain("Required: >=3.10.0");
+        expect(result).toContain("Found:    3.9.7");
+        expect(result).toContain("Fix:      Install Python 3.10+");
+        expect(result).toContain("Or update constraint in .blok/config.json");
+    });
+    it("formats a mismatch when not installed", () => {
+        const result = formatVersionMismatch("Go", undefined, ">=1.22.0", "Install Go: https://go.dev/dl/");
+        expect(result).toContain("Found:    not installed");
+    });
+    it("formats without install hint", () => {
+        const result = formatVersionMismatch("Rust", "1.70.0", ">=1.75.0");
+        expect(result).not.toContain("Fix:");
+        expect(result).toContain("Or update constraint");
+    });
+});
+describe("formatVersionSuccess", () => {
+    it("formats a success message", () => {
+        const result = formatVersionSuccess("Python 3", "3.12.0", ">=3.10.0");
+        expect(result).toContain("✓");
+        expect(result).toContain("Python 3");
+        expect(result).toContain("3.12.0");
+        expect(result).toContain("requires >=3.10.0");
+    });
+});