blokctl 1.1.0 → 1.3.0

package/dist/commands/runtime/add.js

@@ -5,7 +5,7 @@ import color from "picocolors";
 import { isNonInteractive } from "../../services/non-interactive.js";
 import { detectRuntimes, getRuntimeDefinition } from "../../services/runtime-detector.js";
 import { ensureRuntimeGitignore, rewriteRuntimeEnvBlock, rewriteSupervisordRuntimes, runtimeEnvKey, withRuntime, } from "../../services/runtime-mutations.js";
-import { setupRuntime } from "../../services/runtime-setup.js";
+import { buildRuntimeConfig, setupRuntime, } from "../../services/runtime-setup.js";
 import { RuntimeCommandError, assertGrpcPortFree, assertSidecarKind, readConfigSafe, reportRuntimeError, resolveProjectRoot, resolveSdkSource, } from "./shared.js";
 export async function runtimeAdd(kindArg, options) {
     try {
@@ -54,6 +54,31 @@ export async function runtimeAdd(kindArg, options) {
         const sdkDir = path.join(root, ".blok", "runtimes", kind);
         const alreadyInstalled = Boolean(config.runtimes?.[kind]) || fs.existsSync(sdkDir);
         p.intro(color.inverse(` Add ${def.label} runtime `));
+        if (options.enable === true) {
+            if (config.runtimes?.[kind]) {
+                p.outro(color.dim(`${def.label} is already wired into .blok/config.json.`));
+                return;
+            }
+            if (!fs.existsSync(sdkDir)) {
+                throw new RuntimeCommandError(`${def.label} isn't scaffolded at ${path.relative(root, sdkDir)}. Run \`blokctl runtime add ${kind}\` (without --enable) to install it first.`);
+            }
+            const rt = (detected ?? (await detectRuntimes())).find((d) => d.kind === kind);
+            if (!rt)
+                throw new RuntimeCommandError(`Unknown runtime "${kind}".`);
+            const grpcPort = grpcPortOverride ?? rt.defaultGrpcPort;
+            const clash = Object.values(config.runtimes ?? {}).find((rc) => rc.kind !== kind && rc.grpcPort === grpcPort);
+            if (clash) {
+                throw new RuntimeCommandError(`gRPC port ${grpcPort} is already used by the ${clash.label} runtime. Pass --grpc-port <n> to pick another.`);
+            }
+            const rc = buildRuntimeConfig(rt, root);
+            if (grpcPortOverride !== undefined) {
+                rc.grpcPort = grpcPortOverride;
+                if (rc.grpcStartCmd)
+                    rc.grpcStartCmd = rc.grpcStartCmd.split(String(rt.defaultGrpcPort)).join(String(grpcPortOverride));
+            }
+            finalizeRuntime(root, config, rc, kind, def.label);
+            return;
+        }
         if (alreadyInstalled && options.force !== true) {
             if (nonInteractive) {
                 p.outro(color.dim(`${def.label} is already installed. Re-run with --force to reinstall.`));
@@ -107,37 +132,75 @@ export async function runtimeAdd(kindArg, options) {
                 rc.grpcStartCmd = rc.grpcStartCmd.split(String(rt.defaultGrpcPort)).join(String(grpcPortOverride));
         }
         s.stop(`${def.label} runtime ready`);
-        const nextConfig = withRuntime(config, rc);
-        const remaining = Object.values(nextConfig.runtimes ?? {});
-        fs.mkdirSync(path.join(root, ".blok"), { recursive: true });
-        fs.writeFileSync(path.join(root, ".blok", "config.json"), `${JSON.stringify(nextConfig, null, 2)}\n`);
-        const envPath = path.join(root, ".env.local");
-        const envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : "";
-        fs.writeFileSync(envPath, rewriteRuntimeEnvBlock(envContent, remaining));
-        const supervisordPath = path.join(root, "supervisord.conf");
-        if (fs.existsSync(supervisordPath)) {
-            fs.writeFileSync(supervisordPath, rewriteSupervisordRuntimes(fs.readFileSync(supervisordPath, "utf8"), remaining));
-        }
-        const gitignorePath = path.join(root, ".gitignore");
-        if (fs.existsSync(gitignorePath)) {
-            const before = fs.readFileSync(gitignorePath, "utf8");
-            const after = ensureRuntimeGitignore(before);
-            if (after !== before)
-                fs.writeFileSync(gitignorePath, after);
+        if (stampHelloExample(root, source, kind)) {
+            p.log.success(`Shipped the ${def.label} hello example — ${color.cyan(`POST /runtimes/${kind}/hello`)} (registered in src/Workflows.ts)`);
         }
-        p.note([
-            `${color.green("✓")} .blok/config.json   ${color.dim(`runtimes.${kind}`)}`,
-            `${color.green("✓")} .env.local          ${color.dim(`RUNTIME_${runtimeEnvKey(kind)}_GRPC_PORT=${rc.grpcPort}`)}`,
-            fs.existsSync(supervisordPath)
-                ? `${color.green("✓")} supervisord.conf    ${color.dim(`[program:${kind}_runtime]`)}`
-                : "",
-            `${color.green("✓")} runtimes/${kind}/nodes/  ${color.dim("(your runtime nodes go here)")}`,
-        ]
-            .filter(Boolean)
-            .join("\n"), `${def.label} added`);
-        p.outro(`Run ${color.cyan("blokctl dev")} to start it, then add ${color.cyan(`type: "runtime.${kind}"`)} steps to your workflows.`);
+        finalizeRuntime(root, config, rc, kind, def.label);
     }
     catch (err) {
         reportRuntimeError(err);
     }
 }
+function stampHelloExample(root, source, kind) {
+    const file = `runtime-${kind}-hello.ts`;
+    const srcFile = path.join(source, "examples", "ts-workflows", file);
+    const examplesDir = path.join(root, "src", "workflows", "examples");
+    const workflowsTs = path.join(root, "src", "Workflows.ts");
+    if (!fs.existsSync(srcFile) || !fs.existsSync(examplesDir) || !fs.existsSync(workflowsTs))
+        return false;
+    const importName = `Runtime${kind.charAt(0).toUpperCase()}${kind.slice(1)}Hello`;
+    const importLine = `import ${importName} from "./workflows/examples/runtime-${kind}-hello";`;
+    const entryLine = `\t"runtime-${kind}-hello": ${importName},`;
+    const content = fs.readFileSync(workflowsTs, "utf8");
+    if (content.includes(`./workflows/examples/runtime-${kind}-hello`)) {
+        fs.copyFileSync(srcFile, path.join(examplesDir, file));
+        return true;
+    }
+    const lines = content.split("\n");
+    const openIdx = lines.findIndex((l) => /^const workflows\b.*=\s*\{\s*$/.test(l));
+    let lastImport = -1;
+    for (let i = 0; i < (openIdx === -1 ? lines.length : openIdx); i++) {
+        if (/^import /.test(lines[i]))
+            lastImport = i;
+    }
+    if (openIdx === -1 || lastImport === -1) {
+        p.log.warn(`src/Workflows.ts doesn't look generated — register the ${kind} hello example yourself:\n  ${importLine}\n  ${entryLine.trim()}`);
+        return false;
+    }
+    lines.splice(openIdx + 1, 0, entryLine);
+    lines.splice(lastImport + 1, 0, importLine);
+    fs.copyFileSync(srcFile, path.join(examplesDir, file));
+    fs.writeFileSync(workflowsTs, lines.join("\n"));
+    return true;
+}
+function finalizeRuntime(root, config, rc, kind, label) {
+    const nextConfig = withRuntime(config, rc);
+    const remaining = Object.values(nextConfig.runtimes ?? {});
+    fs.mkdirSync(path.join(root, ".blok"), { recursive: true });
+    fs.writeFileSync(path.join(root, ".blok", "config.json"), `${JSON.stringify(nextConfig, null, 2)}\n`);
+    const envPath = path.join(root, ".env.local");
+    const envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf8") : "";
+    fs.writeFileSync(envPath, rewriteRuntimeEnvBlock(envContent, remaining));
+    const supervisordPath = path.join(root, "supervisord.conf");
+    if (fs.existsSync(supervisordPath)) {
+        fs.writeFileSync(supervisordPath, rewriteSupervisordRuntimes(fs.readFileSync(supervisordPath, "utf8"), remaining));
+    }
+    const gitignorePath = path.join(root, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+        const before = fs.readFileSync(gitignorePath, "utf8");
+        const after = ensureRuntimeGitignore(before);
+        if (after !== before)
+            fs.writeFileSync(gitignorePath, after);
+    }
+    p.note([
+        `${color.green("✓")} .blok/config.json   ${color.dim(`runtimes.${kind}`)}`,
+        `${color.green("✓")} .env.local          ${color.dim(`RUNTIME_${runtimeEnvKey(kind)}_GRPC_PORT=${rc.grpcPort}`)}`,
+        fs.existsSync(supervisordPath)
+            ? `${color.green("✓")} supervisord.conf    ${color.dim(`[program:${kind}_runtime]`)}`
+            : "",
+        `${color.green("✓")} runtimes/${kind}/nodes/  ${color.dim("(your runtime nodes go here)")}`,
+    ]
+        .filter(Boolean)
+        .join("\n"), `${label} added`);
+    p.outro(`Run ${color.cyan("blokctl dev")} to start it, then add ${color.cyan(`type: "runtime.${kind}"`)} steps to your workflows.`);
+}

package/dist/commands/runtime/index.js

@@ -15,6 +15,7 @@ runtime
     .option("--local <path>", "Use a local blok repo for SDK source instead of fetching by version")
     .option("--grpc-port <port>", "Override the gRPC port for this runtime")
     .option("--force", "Reinstall if the runtime is already present")
+    .option("--enable", "Wire an already-scaffolded runtime (SDK dir on disk) into config.json without reinstalling")
     .option("--skip-toolchain-check", "Add even if the language toolchain isn't detected")
     .option("-y, --yes", "Skip prompts (non-interactive)")
     .action(async (runtimeArg, options) => {

package/dist/services/observability-stack.real-prometheus.test.d.ts

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

package/dist/services/observability-stack.real-prometheus.test.js

@@ -0,0 +1,95 @@
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { describe, expect, it } from "vitest";
+const RUN = process.env.BLOK_INTEGRATION_PROMETHEUS;
+const d = RUN ? describe : describe.skip;
+const PROMETHEUS_API = process.env.BLOK_PROMETHEUS_API_URL ?? "http://localhost:9090";
+function run(command, args) {
+    const result = spawnSync(command, args, { encoding: "utf8" });
+    if (result.status !== 0)
+        throw new Error(result.stderr || result.stdout || `${command} ${args.join(" ")} failed`);
+    return `${result.stdout}\n${result.stderr}`;
+}
+function removeContainer(name) {
+    spawnSync("docker", ["rm", "-f", name], { encoding: "utf8" });
+}
+async function queryPrometheus(query) {
+    const response = await fetch(`${PROMETHEUS_API}/api/v1/query?query=${encodeURIComponent(query)}`);
+    expect(response.status).toBe(200);
+    return (await response.json());
+}
+async function activeTargets() {
+    const response = await fetch(`${PROMETHEUS_API}/api/v1/targets?state=active`);
+    expect(response.status).toBe(200);
+    const body = (await response.json());
+    return body.data?.activeTargets ?? [];
+}
+async function waitForTarget(instance) {
+    let target;
+    for (let i = 0; i < 30; i++) {
+        target = (await activeTargets()).find((candidate) => candidate.labels.instance === instance);
+        if (target?.health === "up")
+            return target;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return target;
+}
+async function waitForQuery(query) {
+    let last;
+    for (let i = 0; i < 30; i++) {
+        last = await queryPrometheus(query);
+        if ((last.data?.result?.length ?? 0) > 0)
+            return last;
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+    return last ?? queryPrometheus(query);
+}
+d("observability stack - Prometheus live", () => {
+    it("scrapes the gRPC metrics target on the shared metrics port", async () => {
+        const name = `blok-prom-target-${randomBytes(4).toString("hex")}`;
+        const metricsServer = [
+            "from http.server import BaseHTTPRequestHandler, HTTPServer",
+            "class H(BaseHTTPRequestHandler):",
+            "    def log_message(self, *args): pass",
+            "    def do_GET(self):",
+            "        body = b'# TYPE blok_prom_port_live_test_total counter\\nblok_prom_port_live_test_total 7\\n'",
+            "        self.send_response(200)",
+            "        self.send_header('Content-Type', 'text/plain; version=0.0.4')",
+            "        self.send_header('Content-Length', str(len(body)))",
+            "        self.end_headers()",
+            "        self.wfile.write(body)",
+            "HTTPServer(('0.0.0.0', 9464), H).serve_forever()",
+        ].join("\n");
+        try {
+            run("docker", [
+                "run",
+                "--rm",
+                "-d",
+                "--name",
+                name,
+                "--network",
+                "shared-network",
+                "--network-alias",
+                "blok-grpc",
+                "python:3.12-alpine",
+                "python",
+                "-c",
+                metricsServer,
+            ]);
+            const target = await waitForTarget("blok-grpc:9464");
+            expect(target?.scrapeUrl).toBe("http://blok-grpc:9464/metrics");
+            expect(target?.health).toBe("up");
+            const up = await waitForQuery('up{job="blok-grpc",instance="blok-grpc:9464"} == 1');
+            expect(up.status).toBe("success");
+            expect(up.data?.result).toHaveLength(1);
+            expect(up.data?.result?.[0]?.value[1]).toBe("1");
+            const metric = await waitForQuery("blok_prom_port_live_test_total");
+            expect(metric.status).toBe("success");
+            expect(metric.data?.result).toHaveLength(1);
+            expect(metric.data?.result?.[0]?.value[1]).toBe("7");
+        }
+        finally {
+            removeContainer(name);
+        }
+    }, 60_000);
+});

package/dist/services/observability-stack.real-tempo.test.d.ts

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

package/dist/services/observability-stack.real-tempo.test.js

@@ -0,0 +1,86 @@
+import { spawnSync } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+const RUN = process.env.BLOK_INTEGRATION_TEMPO;
+const d = RUN ? describe : describe.skip;
+const TEMPO_API = process.env.BLOK_TEMPO_API_URL ?? "http://localhost:3201";
+const TEMPO_OTLP = process.env.BLOK_TEMPO_OTLP_URL ?? "http://localhost:4318/v1/traces";
+function findRepoRoot() {
+    let dir = import.meta.dirname;
+    for (let i = 0; i < 8; i++) {
+        if (fs.existsSync(path.join(dir, "infra", "metrics", "tempo.yaml")))
+            return dir;
+        const up = path.dirname(dir);
+        if (up === dir)
+            break;
+        dir = up;
+    }
+    return null;
+}
+function hex(bytes) {
+    return randomBytes(bytes).toString("hex");
+}
+function dockerLogs(container) {
+    const result = spawnSync("docker", ["logs", container], { encoding: "utf8" });
+    if (result.status !== 0)
+        throw new Error(result.stderr || result.stdout || `docker logs ${container} failed`);
+    return `${result.stdout}\n${result.stderr}`;
+}
+async function waitForTrace(traceId) {
+    let last;
+    for (let i = 0; i < 20; i++) {
+        last = await fetch(`${TEMPO_API}/api/traces/${traceId}`);
+        if (last.ok)
+            return last;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+    }
+    return last ?? fetch(`${TEMPO_API}/api/traces/${traceId}`);
+}
+d("observability stack - Tempo live", () => {
+    it("boots without the dangling memcached cache and ingests an OTLP span", async () => {
+        const repo = findRepoRoot();
+        if (!repo)
+            throw new Error("repo root not found");
+        const tempoConfig = fs.readFileSync(path.join(repo, "infra", "metrics", "tempo.yaml"), "utf8");
+        expect(tempoConfig).not.toContain("memcached:11211");
+        const traceId = hex(16);
+        const spanId = hex(8);
+        const now = BigInt(Date.now()) * 1000000n;
+        const response = await fetch(TEMPO_OTLP, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+                resourceSpans: [
+                    {
+                        resource: { attributes: [{ key: "service.name", value: { stringValue: "blok-tempo-live-test" } }] },
+                        scopeSpans: [
+                            {
+                                scope: { name: "blokctl-live-test" },
+                                spans: [
+                                    {
+                                        traceId,
+                                        spanId,
+                                        name: "tempo-memcached-regression",
+                                        kind: 1,
+                                        startTimeUnixNano: now.toString(),
+                                        endTimeUnixNano: (now + 1000000n).toString(),
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            }),
+        });
+        expect(response.status).toBe(200);
+        const trace = await waitForTrace(traceId);
+        expect(trace.ok).toBe(true);
+        const traceBody = await trace.text();
+        expect(traceBody).toContain("blok-tempo-live-test");
+        expect(traceBody).toContain("tempo-memcached-regression");
+        const logs = dockerLogs("tempo");
+        expect(logs.toLowerCase()).not.toContain("memcached");
+    });
+});

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

@@ -3,6 +3,7 @@ export interface RuntimeInfo {
     label: string;
     available: boolean;
     version?: string;
+    minVersion?: string;
     installHint: string;
     defaultPort: number;
     defaultGrpcPort: number;
@@ -21,6 +22,7 @@ export interface RuntimeInfo {
     };
 }
 export declare function detectRr(): string | null;
+export declare function detectJava(): 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;

package/dist/services/runtime-detector.js

@@ -1,8 +1,24 @@
 import child_process from "node:child_process";
 import util from "node:util";
+import { compareSemver } from "./semver-utils.js";
 const exec = util.promisify(child_process.exec);
 export function detectRr() {
     for (const bin of ["/opt/homebrew/bin/rr", "rr"]) {
+        try {
+            const out = child_process
+                .execSync(`${bin} --version`, { stdio: ["ignore", "pipe", "ignore"] })
+                .toString()
+                .trim();
+            if (/^rr version/i.test(out))
+                return bin;
+        }
+        catch {
+        }
+    }
+    return null;
+}
+export function detectJava() {
+    for (const bin of ["java", "/opt/homebrew/opt/openjdk/bin/java"]) {
         try {
             child_process.execSync(`${bin} --version`, { stdio: "ignore" });
             return bin;
@@ -45,8 +61,9 @@ const RUNTIME_DEFINITIONS = [
         defaultGrpcPort: 10002,
         commands: ["rustc --version"],
         toolchain: "rustc + cargo",
-        installDeps: "cargo build --release",
+        installDeps: "cargo build --features grpc",
         startCmd: "cargo run",
+        grpcStartCmd: "cargo run --features grpc",
         sdkDir: "rust",
     },
     {
@@ -85,6 +102,7 @@ const RUNTIME_DEFINITIONS = [
     {
         kind: "php",
         label: "PHP",
+        minVersion: "8.2.0",
         installHint: "Install PHP 8.2+ + RoadRunner: https://php.net/downloads (rr: brew install roadrunner)",
         defaultPort: 9005,
         defaultGrpcPort: 10005,
@@ -103,13 +121,14 @@ const RUNTIME_DEFINITIONS = [
     {
         kind: "ruby",
         label: "Ruby",
-        installHint: "Install Ruby 3.2+: https://ruby-lang.org/en/downloads/",
+        minVersion: "3.1.0",
+        installHint: "Install Ruby 3.1+: https://ruby-lang.org/en/downloads/ (macOS: brew install ruby)",
         defaultPort: 9006,
         defaultGrpcPort: 10006,
         commands: ["ruby --version", "/opt/homebrew/opt/ruby/bin/ruby --version"],
         toolchain: "ruby + bundler",
         installDeps: "bundle install",
-        startCmd: "bundle exec rackup --host 0.0.0.0 config.ru",
+        startCmd: "bundle exec ruby bin/serve.rb",
         sdkDir: "ruby",
         secondaryTool: {
             name: "Bundler",
@@ -171,10 +190,12 @@ export async function detectRuntimes() {
         };
         for (const cmd of def.commands) {
             const output = await tryExec(cmd);
-            if (output) {
-                info.available = true;
-                info.version = parseVersion(output, def.kind);
-                break;
+            if (!output)
+                continue;
+            info.available = true;
+            const parsed = parseVersion(output, def.kind);
+            if (parsed && (!info.version || compareSemver(parsed, info.version) > 0)) {
+                info.version = parsed;
             }
         }
         if (def.secondaryTool) {
@@ -196,13 +217,16 @@ export async function detectRuntimeVersion(kind) {
     const def = RUNTIME_DEFINITIONS.find((r) => r.kind === kind);
     if (!def)
         return undefined;
+    let best;
     for (const cmd of def.commands) {
         const output = await tryExec(cmd);
-        if (output) {
-            return parseVersion(output, def.kind);
-        }
+        if (!output)
+            continue;
+        const parsed = parseVersion(output, def.kind);
+        if (parsed && (!best || compareSemver(parsed, best) > 0))
+            best = parsed;
     }
-    return undefined;
+    return best;
 }
 export function getRuntimeDefinition(kind) {
     return RUNTIME_DEFINITIONS.find((r) => r.kind === kind);

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

@@ -36,6 +36,7 @@ export interface ProjectConfig {
 }
 export type ProjectRuntimeConfig = ProjectConfig;
 export declare function setupRuntime(runtime: RuntimeInfo, githubRepoLocal: string, projectDir: string, spinner: SpinnerHandler): Promise<RuntimeConfig>;
+export declare function buildRuntimeConfig(runtime: RuntimeInfo, projectDir: string, startCmd?: string): RuntimeConfig;
 export declare function generateGoNodeRegistry(projectDir: string): string;
 export declare function generateRustNodeRegistry(projectDir: string): string;
 export declare function generateJavaNodeRegistry(projectDir: string): string;

package/dist/services/runtime-setup.js

@@ -21,7 +21,7 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
     let startCmdOverride;
     switch (runtime.kind) {
         case "python3":
-            await setupPython3(blokctlRuntimeDir, spinner);
+            startCmdOverride = await setupPython3(blokctlRuntimeDir, spinner);
             break;
         case "go":
             await setupGo(blokctlRuntimeDir, spinner);
@@ -39,7 +39,7 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
             await setupPhp(blokctlRuntimeDir, spinner);
             break;
         case "ruby":
-            startCmdOverride = await setupRuby(blokctlRuntimeDir, spinner, runtime.defaultPort);
+            startCmdOverride = await setupRuby(blokctlRuntimeDir, spinner);
             break;
     }
     if (runtime.kind === "go") {
@@ -55,16 +55,24 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
         generateCSharpNodeRegistry(projectDir);
     }
     spinner.message(`${runtime.label} runtime setup complete.`);
+    return buildRuntimeConfig(runtime, projectDir, startCmdOverride || runtime.startCmd);
+}
+export function buildRuntimeConfig(runtime, projectDir, startCmd) {
+    const blokctlRuntimeDir = path.join(projectDir, ".blok", "runtimes", runtime.kind);
     return {
         port: runtime.defaultPort,
         grpcPort: runtime.defaultGrpcPort,
-        startCmd: startCmdOverride || runtime.startCmd,
+        startCmd: startCmd ?? runtime.startCmd,
         grpcStartCmd: runtime.grpcStartCmd,
         cwd: path.relative(projectDir, blokctlRuntimeDir),
         kind: runtime.kind,
         label: runtime.label,
         version: runtime.version,
-        requiredVersion: runtime.version ? computeDefaultConstraint(runtime.version) : undefined,
+        requiredVersion: runtime.minVersion
+            ? computeDefaultConstraint(runtime.minVersion)
+            : runtime.version
+                ? computeDefaultConstraint(runtime.version)
+                : undefined,
         transport: "grpc",
     };
 }
@@ -79,6 +87,7 @@ async function setupPython3(sdkDir, spinner) {
         await exec(`"${venvPip}" install -r "${requirementsFile}"`, { cwd: sdkDir });
     }
     spinner.message("Python3 packages installed.");
+    return "python3_runtime/bin/python3 bin/serve.py";
 }
 async function createPythonVenv(sdkDir) {
     await exec("python3 -m venv python3_runtime", { cwd: sdkDir, timeout: 60000 });
@@ -342,7 +351,7 @@ function collectFilesRecursive(dir, ext) {
 }
 async function setupRust(sdkDir, spinner) {
     spinner.message("Building Rust project (this may take a few minutes on first build)...");
-    await exec("cargo build --release", { cwd: sdkDir, timeout: 600000 });
+    await exec("cargo build --features grpc", { cwd: sdkDir, timeout: 600000 });
     spinner.message("Rust project built.");
 }
 async function setupJava(sdkDir, spinner) {
@@ -373,7 +382,7 @@ async function setupPhp(sdkDir, spinner) {
     await exec("composer install --no-dev --optimize-autoloader", { cwd: sdkDir, timeout: 120000 });
     spinner.message("PHP dependencies installed.");
 }
-async function setupRuby(sdkDir, spinner, port) {
+async function setupRuby(sdkDir, spinner) {
     const bundleCandidates = ["bundle", "/opt/homebrew/opt/ruby/bin/bundle"];
     let resolvedBundle = "bundle";
     for (const bin of bundleCandidates) {
@@ -392,7 +401,8 @@ async function setupRuby(sdkDir, spinner, port) {
     spinner.message("Installing Ruby dependencies...");
     await exec(`"${resolvedBundle}" install`, { cwd: sdkDir, timeout: 120000 });
     spinner.message("Ruby dependencies installed.");
-    return `${resolvedBundle} exec rackup --host 0.0.0.0 -p ${port} config.ru`;
+    const resolvedRuby = resolvedBundle.includes("/") ? path.join(path.dirname(resolvedBundle), "ruby") : "ruby";
+    return `${resolvedBundle} exec ${resolvedRuby} bin/serve.rb`;
 }
 export function writeProjectConfig(projectDir, runtimeConfigs, triggerConfigs, observabilityConfigs) {
     const config = {};