blokctl 0.3.0 → 0.6.1

package/dist/commands/migrate/paths.js

@@ -0,0 +1,267 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import color from "picocolors";
+export async function migratePaths(opts) {
+    const cwd = process.cwd();
+    const explicitDir = opts.dir ?? null;
+    const dryRun = opts.dryRun === true;
+    const writeBackup = opts.backup !== false;
+    console.log(color.cyan("\n🛣  Workflow path migrator"));
+    console.log(color.dim("Adds explicit `trigger.http.path` to every JSON HTTP workflow.\n"));
+    const root = await resolveJsonRoot(cwd, explicitDir);
+    if (!root) {
+        console.log(color.red("❌ Could not find a JSON workflows directory. Looked in: " +
+            "workflows/json/, triggers/http/workflows/json/. Pass --dir <path> to override."));
+        process.exit(1);
+    }
+    console.log(color.dim(`Scanning ${color.cyan(root)} (recursive)\n`));
+    const files = await collectJsonFiles(root);
+    if (files.length === 0) {
+        console.log(color.yellow("No JSON workflow files found."));
+        return;
+    }
+    const results = [];
+    for (const file of files) {
+        const result = await migrateOne(file, root, { dryRun, writeBackup });
+        results.push(result);
+        printResult(result);
+    }
+    console.log("");
+    printSummary(results, dryRun, writeBackup);
+    const tsRoots = [path.join(cwd, "triggers", "http", "src", "workflows"), path.join(cwd, "src", "workflows")];
+    for (const tsRoot of tsRoots) {
+        if (await dirExists(tsRoot)) {
+            const tsFiles = await collectTsFiles(tsRoot);
+            if (tsFiles.length > 0) {
+                console.log("");
+                console.log(color.yellow("⚠ TS workflows detected — these are NOT migrated by this codemod."));
+                console.log(color.dim(`  Found at: ${tsRoot}`));
+                console.log(color.dim("  Migrate them manually: ensure each workflow's `trigger.http.path` is set explicitly."));
+                console.log(color.dim(`  Files: ${tsFiles.length}`));
+            }
+        }
+    }
+}
+async function migrateOne(file, root, opts) {
+    let raw;
+    let parsed;
+    try {
+        raw = await fsp.readFile(file, "utf8");
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        return { kind: "error", file, error: err.message };
+    }
+    if (!isPlainObject(parsed)) {
+        return { kind: "error", file, error: "Workflow must be a JSON object" };
+    }
+    const wf = parsed;
+    const trigger = wf.trigger;
+    if (!isPlainObject(trigger)) {
+        return { kind: "no-trigger", file };
+    }
+    const httpCfg = trigger.http;
+    if (!isPlainObject(httpCfg)) {
+        return { kind: "not-http", file };
+    }
+    const http = httpCfg;
+    const existingPath = typeof http.path === "string" ? http.path : undefined;
+    const relative = path.relative(root, file);
+    const derivedUrl = deriveUrlFromFilePath(relative);
+    if (existingPath === undefined) {
+        http.path = derivedUrl;
+    }
+    else if (existingPath === "/" && derivedUrl !== "/") {
+        http.path = derivedUrl;
+        const serialized = `${JSON.stringify(wf, null, "\t")}\n`;
+        if (serialized.trimEnd() === raw.trimEnd()) {
+            return { kind: "already-explicit", file, path: derivedUrl };
+        }
+        const writeResult = await maybeWrite(file, raw, serialized, opts);
+        if (writeResult)
+            return writeResult;
+        return { kind: "rewrote-root", file, from: "/", to: derivedUrl };
+    }
+    else {
+        return { kind: "already-explicit", file, path: existingPath };
+    }
+    const serialized = `${JSON.stringify(wf, null, "\t")}\n`;
+    if (serialized.trimEnd() === raw.trimEnd()) {
+        return { kind: "already-explicit", file, path: existingPath ?? derivedUrl };
+    }
+    const writeResult = await maybeWrite(file, raw, serialized, opts);
+    if (writeResult)
+        return writeResult;
+    return { kind: "added", file, path: http.path };
+}
+async function maybeWrite(file, raw, serialized, opts) {
+    if (opts.dryRun)
+        return null;
+    if (opts.writeBackup) {
+        try {
+            await fsp.writeFile(`${file}.bak`, raw);
+        }
+        catch (err) {
+            return { kind: "error", file, error: `Failed to write backup: ${err.message}` };
+        }
+    }
+    try {
+        await fsp.writeFile(file, serialized);
+    }
+    catch (err) {
+        return { kind: "error", file, error: err.message };
+    }
+    return null;
+}
+function deriveUrlFromFilePath(relativePath) {
+    const noExt = relativePath.replace(/\.json$/i, "");
+    const segments = noExt.split(path.sep).filter((s) => s.length > 0);
+    if (segments.length === 0)
+        return "/";
+    if (segments[segments.length - 1] === "index")
+        segments.pop();
+    if (segments.length === 0)
+        return "/";
+    const converted = segments.map((seg) => {
+        const match = seg.match(/^\[(\.{3})?([A-Za-z_][A-Za-z0-9_]*)\]$/);
+        if (!match)
+            return seg;
+        return `:${match[2]}`;
+    });
+    return `/${converted.join("/")}`;
+}
+function printResult(result) {
+    const rel = path.relative(process.cwd(), result.file);
+    switch (result.kind) {
+        case "added":
+            console.log(`  ${color.green("✓")} ${rel} ${color.dim("→")} ${color.cyan(`path: "${result.path}"`)}`);
+            break;
+        case "rewrote-root":
+            console.log(`  ${color.green("✓")} ${rel} ${color.dim("→")} ${color.cyan(`"${result.from}"`)} → ${color.cyan(`"${result.to}"`)}`);
+            break;
+        case "already-explicit":
+            console.log(`  ${color.dim("·")} ${rel} ${color.dim(`(already explicit: "${result.path}")`)}`);
+            break;
+        case "no-trigger":
+            console.log(`  ${color.dim("·")} ${rel} ${color.dim("(no trigger)")}`);
+            break;
+        case "not-http":
+            console.log(`  ${color.dim("·")} ${rel} ${color.dim("(non-HTTP trigger)")}`);
+            break;
+        case "error":
+            console.log(`  ${color.red("✗")} ${rel} ${color.red(`error: ${result.error}`)}`);
+            break;
+    }
+}
+function printSummary(results, dryRun, writeBackup) {
+    const counts = {
+        added: results.filter((r) => r.kind === "added").length,
+        rewrote: results.filter((r) => r.kind === "rewrote-root").length,
+        already: results.filter((r) => r.kind === "already-explicit").length,
+        skipped: results.filter((r) => r.kind === "no-trigger" || r.kind === "not-http").length,
+        errors: results.filter((r) => r.kind === "error").length,
+    };
+    const action = dryRun ? "would be" : "were";
+    console.log(color.bold("Summary:"));
+    console.log(`  ${color.green(`${counts.added} ${action} updated`)} (added explicit path)`);
+    if (counts.rewrote > 0)
+        console.log(`  ${color.green(`${counts.rewrote} ${action} updated`)} (rewrote "/" → file-derived)`);
+    console.log(`  ${color.dim(`${counts.already} already explicit`)}`);
+    if (counts.skipped > 0)
+        console.log(`  ${color.dim(`${counts.skipped} skipped (non-HTTP / no trigger)`)}`);
+    if (counts.errors > 0)
+        console.log(`  ${color.red(`${counts.errors} errors`)}`);
+    if (!dryRun && (counts.added > 0 || counts.rewrote > 0) && writeBackup) {
+        console.log("");
+        console.log(color.dim("Backups written as <name>.json.bak. Delete them once verified."));
+    }
+    if (dryRun && (counts.added > 0 || counts.rewrote > 0)) {
+        console.log("");
+        console.log(color.cyan("Re-run without --dry-run to apply."));
+    }
+}
+async function resolveJsonRoot(cwd, explicit) {
+    if (explicit) {
+        const abs = path.isAbsolute(explicit) ? explicit : path.resolve(cwd, explicit);
+        if (await dirExists(abs))
+            return abs;
+        return null;
+    }
+    const candidates = [path.join(cwd, "workflows", "json"), path.join(cwd, "triggers", "http", "workflows", "json")];
+    for (const c of candidates) {
+        if (await dirExists(c))
+            return c;
+    }
+    return null;
+}
+async function dirExists(p) {
+    try {
+        const stat = await fsp.stat(p);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function collectJsonFiles(root) {
+    const out = [];
+    await walkJson(root, out);
+    out.sort();
+    return out;
+}
+async function collectTsFiles(root) {
+    const out = [];
+    await walkTs(root, out);
+    out.sort();
+    return out;
+}
+async function walkJson(dir, out) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkJson(full, out);
+        }
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".json")) {
+            out.push(full);
+        }
+    }
+}
+async function walkTs(dir, out) {
+    let entries;
+    try {
+        entries = await fsp.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith(".") || entry.name.startsWith("_") || entry.name === "node_modules")
+            continue;
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walkTs(full, out);
+        }
+        else if (entry.isFile() &&
+            (entry.name.toLowerCase().endsWith(".ts") || entry.name.toLowerCase().endsWith(".js")) &&
+            entry.name !== "index.ts" &&
+            entry.name !== "index.js") {
+            out.push(full);
+        }
+    }
+}
+function isPlainObject(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (Array.isArray(value))
+        return false;
+    return typeof value === "object";
+}

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 {};