blokctl 0.2.11 → 0.4.0

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;

package/dist/services/runtime-setup.js

@@ -43,10 +43,13 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
     spinner.message(`${runtime.label} runtime setup complete.`);
     return {
         port: runtime.defaultPort,
+        grpcPort: runtime.defaultGrpcPort,
         startCmd: startCmdOverride || runtime.startCmd,
+        grpcStartCmd: runtime.grpcStartCmd,
         cwd: path.relative(projectDir, blokctlRuntimeDir),
         kind: runtime.kind,
         label: runtime.label,
+        transport: "grpc",
     };
 }
 async function setupPython3(sdkDir, projectRuntimeDir, spinner) {
@@ -166,17 +169,23 @@ export function generateRuntimeEnvVars(runtimeConfigs) {
         const envKey = rc.kind === "csharp" ? "CSHARP" : rc.kind.toUpperCase();
         lines.push(`RUNTIME_${envKey}_HOST=localhost`);
         lines.push(`RUNTIME_${envKey}_PORT=${rc.port}`);
+        if (rc.grpcPort !== undefined) {
+            lines.push(`RUNTIME_${envKey}_GRPC_PORT=${rc.grpcPort}`);
+        }
     }
+    lines.push("BLOK_TRANSPORT=grpc");
     return lines.join("\n");
 }
 export function generateSupervisordConfig(runtimeConfigs) {
     let config = "";
     for (const rc of runtimeConfigs) {
+        const cmd = rc.grpcStartCmd ?? rc.startCmd;
+        const grpcPortLine = rc.grpcPort !== undefined ? `,GRPC_PORT="${rc.grpcPort}"` : "";
         config += `
 [program:${rc.kind}_runtime]
-command=${rc.startCmd}
+command=${cmd}
 directory=/app/${rc.cwd}
-environment=PORT="${rc.port}",HOST="0.0.0.0"
+environment=PORT="${rc.port}"${grpcPortLine},HOST="0.0.0.0",BLOK_TRANSPORT="grpc"
 autostart=true
 autorestart=true
 stderr_logfile=/var/log/${rc.kind}.err.log