blokctl 0.2.11 → 0.3.0

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;

package/dist/commands/trace/startStudio.js

@@ -4,6 +4,7 @@ import https from "node:https";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as p from "@clack/prompts";
+import express from "express";
 import open from "open";
 import color from "picocolors";
 import serveHandler from "serve-handler";
@@ -18,6 +19,10 @@ function resolveStaticPath() {
         return workspace;
     return null;
 }
+function autoDetectDbPath() {
+    const candidate = path.resolve(process.cwd(), ".blok", "trace.db");
+    return fs.existsSync(candidate) ? candidate : null;
+}
 async function checkBackendHealth(backendUrl) {
     return new Promise((resolve) => {
         const url = new URL("/__blok/health", backendUrl);
@@ -33,7 +38,7 @@ async function checkBackendHealth(backendUrl) {
     });
 }
 function proxyRequest(req, res, backendUrl) {
-    const targetUrl = new URL(req.url, backendUrl);
+    const targetUrl = new URL(req.url ?? "/", backendUrl);
     const client = targetUrl.protocol === "https:" ? https : http;
     const proxyReq = client.request(targetUrl, {
         method: req.method,
@@ -56,28 +61,83 @@ function proxyRequest(req, res, backendUrl) {
     });
     req.pipe(proxyReq, { end: true });
 }
+async function buildStandaloneApp(dbPath) {
+    const runner = (await import("@blokjs/runner"));
+    const { RunTracker, createStore, registerTraceRoutes } = runner;
+    const absoluteDb = path.resolve(dbPath);
+    const dir = path.dirname(absoluteDb);
+    if (dir && !fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const store = createStore({ type: "sqlite", sqlitePath: absoluteDb });
+    const tracker = new RunTracker(undefined, store);
+    RunTracker.instance = tracker;
+    const app = express();
+    app.use(express.json({ limit: "10mb" }));
+    const traceRouter = express.Router();
+    registerTraceRoutes(traceRouter, tracker);
+    app.use("/__blok", traceRouter);
+    return app;
+}
 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 @blokjs/studio build")}`);
+        p.log.error(`Studio assets not found.\n  Build them first: ${color.cyan("bun run --filter @blokjs/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.");
+    let mode = "proxy";
+    let dbPath = null;
+    if (options.db) {
+        mode = "standalone";
+        dbPath = path.resolve(options.db);
+    }
+    else if (options.standalone) {
+        mode = "standalone";
+        dbPath = autoDetectDbPath() ?? path.resolve(process.cwd(), ".blok", "trace.db");
     }
     else {
-        s.stop(color.green("Backend healthy"));
+        const s = p.spinner();
+        s.start("Checking backend health...");
+        const healthy = await checkBackendHealth(backendUrl);
+        if (healthy) {
+            s.stop(color.green("Backend healthy"));
+        }
+        else {
+            const auto = autoDetectDbPath();
+            if (auto) {
+                s.stop(color.green(`Backend not reachable; serving from ${color.cyan(path.relative(process.cwd(), auto))}`));
+                mode = "standalone";
+                dbPath = auto;
+            }
+            else {
+                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")}\n` +
+                    `  Or open a trace file directly: ${color.cyan("blokctl studio --db <path>")}`);
+                p.log.info("Starting Studio anyway — it will connect when the backend is up.");
+            }
+        }
+    }
+    let standaloneApp = null;
+    if (mode === "standalone" && dbPath) {
+        try {
+            standaloneApp = await buildStandaloneApp(dbPath);
+            p.log.success(`Standalone mode · reading ${color.cyan(path.relative(process.cwd(), dbPath))}`);
+        }
+        catch (e) {
+            p.log.error(`Failed to open trace file ${color.cyan(dbPath)}\n  ${e.message}\n` +
+                `  Make sure better-sqlite3 is available: ${color.cyan("npm install better-sqlite3")}`);
+            process.exit(1);
+        }
     }
     const server = http.createServer((req, res) => {
         const url = req.url || "/";
         if (url.startsWith("/__blok")) {
+            if (standaloneApp) {
+                return standaloneApp(req, res);
+            }
             return proxyRequest(req, res, backendUrl);
         }
         serveHandler(req, res, {
@@ -95,7 +155,12 @@ export async function startStudio(options) {
                 studioUrl += `/runs/${encodeURIComponent(options.run)}`;
             }
             p.log.success(`Studio running at ${color.cyan(studioUrl)}`);
-            p.log.info(`Connected to backend at ${color.dim(backendUrl)}`);
+            if (mode === "standalone" && dbPath) {
+                p.log.info(`Standalone · ${color.dim(`reading ${path.relative(process.cwd(), dbPath)}`)}`);
+            }
+            else {
+                p.log.info(`Proxying to backend at ${color.dim(backendUrl)}`);
+            }
             console.log(color.dim("  Press Ctrl+C to stop\n"));
             if (shouldOpen) {
                 await open(studioUrl);

package/dist/index.js

@@ -168,6 +168,7 @@ async function main() {
         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.")
             .action(async (options) => {
             await analytics.trackCommandExecution({
                 command: "dev",

package/dist/services/health-probe.d.ts

@@ -0,0 +1,5 @@
+export declare function tryConnect(host: string, port: number, timeoutMs: number): Promise<boolean>;
+export declare function waitForGrpcPort(port: number, timeoutMs: number, proc?: {
+    exitCode: number | null;
+    on(event: "exit", listener: () => void): void;
+}): Promise<boolean>;

package/dist/services/health-probe.js

@@ -0,0 +1,35 @@
+import { Socket } from "node:net";
+export function tryConnect(host, port, timeoutMs) {
+    return new Promise((resolve) => {
+        const sock = new Socket();
+        const done = (ok) => {
+            sock.destroy();
+            resolve(ok);
+        };
+        sock.setTimeout(timeoutMs);
+        sock
+            .once("connect", () => done(true))
+            .once("timeout", () => done(false))
+            .once("error", () => done(false));
+        sock.connect(port, host);
+    });
+}
+export async function waitForGrpcPort(port, timeoutMs, proc) {
+    if (proc && proc.exitCode !== null)
+        return false;
+    const start = Date.now();
+    let exited = false;
+    proc?.on("exit", () => {
+        exited = true;
+    });
+    while (Date.now() - start < timeoutMs) {
+        if (exited)
+            return false;
+        if (await tryConnect("127.0.0.1", port, 500))
+            return true;
+        if (await tryConnect("::1", port, 500))
+            return true;
+        await new Promise((r) => setTimeout(r, 200));
+    }
+    return false;
+}

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

@@ -5,10 +5,12 @@ export interface RuntimeInfo {
     version?: string;
     installHint: string;
     defaultPort: number;
+    defaultGrpcPort: number;
     commands: string[];
     toolchain: string;
     installDeps: string;
     startCmd: string;
+    grpcStartCmd?: string;
     sdkDir: string;
     secondaryTool?: {
         name: string;
@@ -18,6 +20,7 @@ export interface RuntimeInfo {
         installHint: string;
     };
 }
+export declare function detectRr(): string | null;
 export declare function detectRuntimes(): Promise<RuntimeInfo[]>;
 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

@@ -1,12 +1,24 @@
 import child_process from "node:child_process";
 import util from "node:util";
 const exec = util.promisify(child_process.exec);
+export function detectRr() {
+    for (const bin of ["/opt/homebrew/bin/rr", "rr"]) {
+        try {
+            child_process.execSync(`${bin} --version`, { stdio: "ignore" });
+            return bin;
+        }
+        catch {
+        }
+    }
+    return null;
+}
 const RUNTIME_DEFINITIONS = [
     {
         kind: "python3",
         label: "Python 3",
         installHint: "Install Python: https://python.org/downloads/",
         defaultPort: 9007,
+        defaultGrpcPort: 10007,
         commands: ["python3 --version"],
         toolchain: "python3",
         installDeps: "pip3 install -r requirements.txt",
@@ -18,6 +30,7 @@ const RUNTIME_DEFINITIONS = [
         label: "Go",
         installHint: "Install Go: https://go.dev/dl/",
         defaultPort: 9001,
+        defaultGrpcPort: 10001,
         commands: ["go version"],
         toolchain: "go",
         installDeps: "go mod download",
@@ -29,6 +42,7 @@ const RUNTIME_DEFINITIONS = [
         label: "Rust",
         installHint: "Install Rust: https://rustup.rs/",
         defaultPort: 9002,
+        defaultGrpcPort: 10002,
         commands: ["rustc --version"],
         toolchain: "rustc + cargo",
         installDeps: "cargo build --release",
@@ -40,6 +54,7 @@ const RUNTIME_DEFINITIONS = [
         label: "Java",
         installHint: "Install JDK 17+: https://adoptium.net/",
         defaultPort: 9003,
+        defaultGrpcPort: 10003,
         commands: [
             "java --version",
             "/opt/homebrew/opt/openjdk/bin/java --version",
@@ -60,6 +75,7 @@ const RUNTIME_DEFINITIONS = [
         label: "C# / .NET",
         installHint: "Install .NET SDK: https://dotnet.microsoft.com/download",
         defaultPort: 9004,
+        defaultGrpcPort: 10004,
         commands: ["dotnet --version"],
         toolchain: "dotnet",
         installDeps: "dotnet restore",
@@ -69,12 +85,14 @@ const RUNTIME_DEFINITIONS = [
     {
         kind: "php",
         label: "PHP",
-        installHint: "Install PHP 8.2+: https://php.net/downloads",
+        installHint: "Install PHP 8.2+ + RoadRunner: https://php.net/downloads (rr: brew install roadrunner)",
         defaultPort: 9005,
+        defaultGrpcPort: 10005,
         commands: ["php --version"],
-        toolchain: "php + composer",
+        toolchain: "php + composer + rr",
         installDeps: "composer install",
         startCmd: "php bin/serve.php",
+        grpcStartCmd: "rr serve -c .rr.yaml --override grpc.listen=tcp://127.0.0.1:10005",
         sdkDir: "php",
         secondaryTool: {
             name: "Composer",
@@ -87,6 +105,7 @@ const RUNTIME_DEFINITIONS = [
         label: "Ruby",
         installHint: "Install Ruby 3.2+: https://ruby-lang.org/en/downloads/",
         defaultPort: 9006,
+        defaultGrpcPort: 10006,
         commands: ["ruby --version", "/opt/homebrew/opt/ruby/bin/ruby --version"],
         toolchain: "ruby + bundler",
         installDeps: "bundle install",

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

@@ -6,10 +6,13 @@ type SpinnerHandler = {
 };
 export interface RuntimeConfig {
     port: number;
+    grpcPort?: number;
     startCmd: string;
+    grpcStartCmd?: string;
     cwd: string;
     kind: string;
     label: string;
+    transport?: "grpc" | "http";
 }
 export interface TriggerConfig {
     kind: string;