blokctl 0.2.11 → 0.4.0

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/commands/migrate/workflows.d.ts

@@ -0,0 +1,3 @@
+import type { OptionValues } from "commander";
+export declare function migrateWorkflows(opts: OptionValues): Promise<void>;
+export declare function rewriteLegacyExpressions<T>(value: T): T;

package/dist/commands/migrate/workflows.js

@@ -0,0 +1,333 @@
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import color from "picocolors";
+export async function migrateWorkflows(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 v1 → v2 migrator"));
+    console.log(color.dim("Converts legacy JSON workflows to the canonical v2 shape.\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, { dryRun, writeBackup });
+        results.push(result);
+        printResult(result);
+    }
+    console.log("");
+    printSummary(results, dryRun, writeBackup);
+}
+async function migrateOne(file, 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 triggerKind = detectTriggerKind(wf);
+    const v2 = convertToV2(wf);
+    const serialized = `${JSON.stringify(v2, null, "\t")}\n`;
+    if (serialized.trimEnd() === raw.trimEnd()) {
+        return { kind: "already-v2", file };
+    }
+    if (opts.dryRun) {
+        return { kind: "migrated", file };
+    }
+    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 {
+        kind: triggerKind === "http" ? "migrated" : "not-http",
+        file,
+        trigger: triggerKind,
+    };
+}
+function convertToV2(wf) {
+    const out = {};
+    if (typeof wf.name === "string")
+        out.name = wf.name;
+    if (typeof wf.version === "string")
+        out.version = wf.version;
+    if (typeof wf.description === "string")
+        out.description = wf.description;
+    out.trigger = convertTrigger(wf.trigger);
+    out.steps = convertSteps(Array.isArray(wf.steps) ? wf.steps : [], isPlainObject(wf.nodes) ? wf.nodes : {});
+    return out;
+}
+function convertTrigger(rawTrigger) {
+    if (!isPlainObject(rawTrigger))
+        return {};
+    const out = {};
+    for (const [kind, cfg] of Object.entries(rawTrigger)) {
+        if (kind === "http" && isPlainObject(cfg)) {
+            const httpCfg = { ...cfg };
+            if (httpCfg.method === "*")
+                httpCfg.method = "ANY";
+            out[kind] = httpCfg;
+        }
+        else {
+            out[kind] = cfg;
+        }
+    }
+    return out;
+}
+function convertSteps(steps, nodes) {
+    const out = [];
+    for (const rawStep of steps) {
+        if (!isPlainObject(rawStep))
+            continue;
+        const step = rawStep;
+        const id = pickString(step.name) ?? pickString(step.id);
+        if (!id)
+            continue;
+        if (isPlainObject(step.branch)) {
+            const rawBranch = step.branch;
+            const branchStep = {
+                id,
+                branch: {
+                    when: rewriteLegacyExpressions(typeof rawBranch.when === "string" ? rawBranch.when : "true"),
+                    then: convertSteps(Array.isArray(rawBranch.then) ? rawBranch.then : [], {}),
+                },
+            };
+            if (Array.isArray(rawBranch.else)) {
+                branchStep.branch.else = convertSteps(rawBranch.else, {});
+            }
+            if (step.active === false)
+                branchStep.active = false;
+            if (step.stop === true)
+                branchStep.stop = true;
+            out.push(branchStep);
+            continue;
+        }
+        const nodeRef = pickString(step.node) ?? pickString(step.use);
+        if (!nodeRef)
+            continue;
+        const v1NodeConfig = isPlainObject(nodes[id]) ? nodes[id] : null;
+        const inputs = (() => {
+            if (isPlainObject(step.inputs))
+                return step.inputs;
+            if (v1NodeConfig && isPlainObject(v1NodeConfig.inputs))
+                return v1NodeConfig.inputs;
+            return null;
+        })();
+        if (v1NodeConfig && Array.isArray(v1NodeConfig.conditions)) {
+            const conds = v1NodeConfig.conditions;
+            const ifCond = conds.find((c) => isPlainObject(c) && c.type === "if");
+            const elseCond = conds.find((c) => isPlainObject(c) && c.type === "else");
+            if (ifCond) {
+                const branchStep = {
+                    id,
+                    branch: {
+                        when: rewriteLegacyExpressions(typeof ifCond.condition === "string" ? ifCond.condition : "true"),
+                        then: convertSteps(Array.isArray(ifCond.steps) ? ifCond.steps : [], {}),
+                    },
+                };
+                if (elseCond) {
+                    branchStep.branch.else = convertSteps(Array.isArray(elseCond.steps) ? elseCond.steps : [], {});
+                }
+                if (step.active === false)
+                    branchStep.active = false;
+                if (step.stop === true)
+                    branchStep.stop = true;
+                out.push(branchStep);
+                continue;
+            }
+        }
+        const v2Step = { id, use: nodeRef };
+        if (typeof step.type === "string")
+            v2Step.type = step.type;
+        if (inputs)
+            v2Step.inputs = rewriteLegacyExpressions(inputs);
+        if (step.set_var === false)
+            v2Step.ephemeral = true;
+        if (typeof step.as === "string")
+            v2Step.as = step.as;
+        if (step.spread === true)
+            v2Step.spread = true;
+        if (step.ephemeral === true)
+            v2Step.ephemeral = true;
+        if (step.active === false)
+            v2Step.active = false;
+        if (step.stop === true)
+            v2Step.stop = true;
+        if (typeof step.stream_logs === "boolean")
+            v2Step.stream_logs = step.stream_logs;
+        out.push(v2Step);
+    }
+    return out;
+}
+export function rewriteLegacyExpressions(value) {
+    if (typeof value === "string") {
+        return rewriteOneString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => rewriteLegacyExpressions(v));
+    }
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = rewriteLegacyExpressions(v);
+        }
+        return out;
+    }
+    return value;
+}
+function rewriteOneString(input) {
+    let s = input;
+    s = s.replace(/js\/ctx\.vars\b/g, "js/ctx.state");
+    s = s.replace(/js\/ctx\.response\.data\b/g, "js/ctx.prev.data");
+    s = s.replace(/\$\{ctx\.vars\b/g, "${ctx.state");
+    s = s.replace(/\$\{ctx\.response\.data\b/g, "${ctx.prev.data");
+    return s;
+}
+function detectTriggerKind(wf) {
+    if (!isPlainObject(wf.trigger))
+        return "unknown";
+    const keys = Object.keys(wf.trigger);
+    return keys[0] ?? "unknown";
+}
+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 walk(root, out);
+    out.sort();
+    return out;
+}
+async function walk(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 walk(full, out);
+        }
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".json")) {
+            out.push(full);
+        }
+    }
+}
+function isPlainObject(value) {
+    if (value === null || value === undefined)
+        return false;
+    if (typeof value !== "object")
+        return false;
+    if (Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === null || proto === Object.prototype;
+}
+function pickString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function printResult(result) {
+    const file = path.relative(process.cwd(), result.file);
+    switch (result.kind) {
+        case "migrated":
+            console.log(`  ${color.green("✓")} ${color.cyan(file)}`);
+            break;
+        case "already-v2":
+            console.log(`  ${color.dim("⊙")} ${color.dim(file)} ${color.dim("(already v2)")}`);
+            break;
+        case "not-http":
+            console.log(`  ${color.green("✓")} ${color.cyan(file)} ${color.dim(`(${result.trigger} trigger; no URL preserved)`)}`);
+            break;
+        case "skipped":
+            console.log(`  ${color.dim("→")} ${color.dim(file)} ${color.dim(`(${result.reason})`)}`);
+            break;
+        case "error":
+            console.log(`  ${color.red("✗")} ${color.cyan(file)} ${color.red(`— ${result.error}`)}`);
+            break;
+    }
+}
+function printSummary(results, dryRun, writeBackup) {
+    const counts = {
+        migrated: 0,
+        alreadyV2: 0,
+        notHttp: 0,
+        skipped: 0,
+        error: 0,
+    };
+    for (const r of results) {
+        if (r.kind === "migrated")
+            counts.migrated++;
+        else if (r.kind === "already-v2")
+            counts.alreadyV2++;
+        else if (r.kind === "not-http")
+            counts.notHttp++;
+        else if (r.kind === "skipped")
+            counts.skipped++;
+        else if (r.kind === "error")
+            counts.error++;
+    }
+    const total = results.length;
+    const verb = dryRun ? "would migrate" : "migrated";
+    const summary = `Total: ${total}  ·  ${color.green(`${verb}: ${counts.migrated + counts.notHttp}`)}${counts.alreadyV2 > 0 ? `  ·  ${color.dim(`already v2: ${counts.alreadyV2}`)}` : ""}${counts.error > 0 ? `  ·  ${color.red(`errors: ${counts.error}`)}` : ""}`;
+    console.log(summary);
+    if (dryRun) {
+        console.log(color.dim("\nDry run — no files written. Re-run without --dry-run to apply."));
+    }
+    else if (writeBackup && counts.migrated + counts.notHttp > 0) {
+        console.log(color.dim("\nBackups written next to each file as <name>.json.bak. Run with --no-backup to skip backups."));
+    }
+    if (counts.error > 0)
+        process.exit(1);
+}

package/dist/commands/trace/index.js

@@ -3,9 +3,11 @@ import { startStudio } from "./startStudio.js";
 program
     .command("trace")
     .alias("studio")
-    .description("Open Blok Studio — real-time workflow trace UI")
+    .description("Open Blok Studio — real-time workflow trace UI (Prisma-Studio-style)")
     .option("-p, --port <port>", "Studio UI port", "5555")
-    .option("-u, --url <url>", "Blok backend URL", "http://localhost:4000")
+    .option("-u, --url <url>", "Proxy mode: Blok backend URL to connect to", "http://localhost:4000")
+    .option("--db <path>", "Standalone mode: serve directly from a SQLite trace file (no trigger needed). Auto-detects .blok/trace.db when present.")
+    .option("--standalone", "Force standalone mode (mount /__blok/* on this server reading from .blok/trace.db)")
     .option("--workflow <name>", "Open specific workflow")
     .option("--run <id>", "Open specific run")
     .option("--no-open", "Don't auto-open browser")
@@ -17,6 +19,8 @@ program
             await startStudio({
                 port: Number.parseInt(options.port, 10),
                 url: options.url,
+                db: options.db,
+                standalone: options.standalone,
                 workflow: options.workflow,
                 run: options.run,
                 open: options.open,

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

@@ -1,6 +1,8 @@
 export interface StudioOptions {
     port: number;
     url: string;
+    db?: string;
+    standalone?: boolean;
     workflow?: string;
     run?: string;
     open: boolean;