blokctl 0.6.20 → 0.7.0

package/dist/services/observability-mutations.test.js

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import { rewriteObservabilityEnvBlock, withObservabilityModule, withoutObservabilityModule, } from "./observability-mutations.js";
+const mod = (addedAt = "2026-01-01T00:00:00.000Z") => ({ enabled: true, addedAt });
+describe("withObservabilityModule / withoutObservabilityModule", () => {
+    it("adds a module while preserving runtimes + triggers", () => {
+        const base = { runtimes: { go: { port: 0, startCmd: "", cwd: "", kind: "go", label: "Go" } } };
+        const next = withObservabilityModule(base, "metrics", mod());
+        expect(next.observability).toEqual({ metrics: mod() });
+        expect(next.runtimes).toBe(base.runtimes);
+    });
+    it("re-adding the same module is a no-op (identical output)", () => {
+        const a = withObservabilityModule({}, "tracing", mod());
+        const b = withObservabilityModule(a, "tracing", mod());
+        expect(b).toEqual(a);
+    });
+    it("removing the last module drops the observability key entirely", () => {
+        const one = withObservabilityModule({}, "metrics", mod());
+        const gone = withoutObservabilityModule(one, "metrics");
+        expect(gone.observability).toBeUndefined();
+    });
+    it("removing an absent module is a no-op", () => {
+        const cfg = { observability: { metrics: mod() } };
+        expect(withoutObservabilityModule(cfg, "tracing")).toBe(cfg);
+    });
+    it("removing one of several keeps the rest", () => {
+        const cfg = withObservabilityModule(withObservabilityModule({}, "metrics", mod()), "tracing", mod());
+        const next = withoutObservabilityModule(cfg, "metrics");
+        expect(Object.keys(next.observability ?? {})).toEqual(["tracing"]);
+    });
+});
+describe("rewriteObservabilityEnvBlock", () => {
+    it("appends a fenced block and is idempotent (run twice = identical)", () => {
+        const blocks = ["BLOK_TRACE_STORE=sqlite", "# BLOK_METRICS_DISABLED=1"];
+        const once = rewriteObservabilityEnvBlock("PORT=4000\n", blocks);
+        const twice = rewriteObservabilityEnvBlock(once, blocks);
+        expect(twice).toBe(once);
+        expect(once).toContain("PORT=4000");
+        expect(once).toContain("BLOK_TRACE_STORE=sqlite");
+        expect(once.match(/managed by blokctl/g)?.length).toBe(2);
+    });
+    it("preserves unrelated env vars when the module set changes", () => {
+        const first = rewriteObservabilityEnvBlock("SECRET=abc\n", ["BLOK_TRACE_STORE=sqlite"]);
+        const second = rewriteObservabilityEnvBlock(first, ["CONSOLE_LOG_ACTIVE=true"]);
+        expect(second).toContain("SECRET=abc");
+        expect(second).toContain("CONSOLE_LOG_ACTIVE=true");
+        expect(second).not.toContain("BLOK_TRACE_STORE");
+    });
+    it("removes the block when no modules remain", () => {
+        const withBlock = rewriteObservabilityEnvBlock("SECRET=abc\n", ["BLOK_TRACE_STORE=sqlite"]);
+        const cleared = rewriteObservabilityEnvBlock(withBlock, []);
+        expect(cleared).toBe("SECRET=abc\n");
+        expect(cleared).not.toContain("managed by blokctl");
+    });
+    it("rejects BLOK_METRICS_ENABLED (only the DISABLED kill-switch is supported)", () => {
+        expect(() => rewriteObservabilityEnvBlock("", ["BLOK_METRICS_ENABLED=false"])).toThrow(/BLOK_METRICS_ENABLED/);
+    });
+});

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

@@ -23,13 +23,24 @@ export interface TriggerConfig {
     entryPoint: string;
     startCmd: string;
 }
+export interface ObservabilityModuleConfig {
+    enabled: boolean;
+    addedAt: string;
+    version?: string;
+    settings?: Record<string, unknown>;
+}
 export interface ProjectConfig {
     triggers?: Record<string, TriggerConfig>;
     runtimes?: Record<string, RuntimeConfig>;
+    observability?: Record<string, ObservabilityModuleConfig>;
 }
 export type ProjectRuntimeConfig = ProjectConfig;
 export declare function setupRuntime(runtime: RuntimeInfo, githubRepoLocal: string, projectDir: string, spinner: SpinnerHandler): Promise<RuntimeConfig>;
-export declare function writeProjectConfig(projectDir: string, runtimeConfigs: RuntimeConfig[], triggerConfigs?: TriggerConfig[]): void;
+export declare function generateGoNodeRegistry(projectDir: string): string;
+export declare function generateRustNodeRegistry(projectDir: string): string;
+export declare function generateJavaNodeRegistry(projectDir: string): string;
+export declare function generateCSharpNodeRegistry(projectDir: string): string;
+export declare function writeProjectConfig(projectDir: string, runtimeConfigs: RuntimeConfig[], triggerConfigs?: TriggerConfig[], observabilityConfigs?: Record<string, ObservabilityModuleConfig>): void;
 export declare function readProjectConfig(projectDir: string): ProjectConfig | null;
 export declare function generateRuntimeEnvVars(runtimeConfigs: RuntimeConfig[]): string;
 export declare function generateSupervisordConfig(runtimeConfigs: RuntimeConfig[]): 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, projectRuntimeDir, spinner);
+            await setupPython3(blokctlRuntimeDir, spinner);
             break;
         case "go":
             await setupGo(blokctlRuntimeDir, spinner);
@@ -42,6 +42,18 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
             startCmdOverride = await setupRuby(blokctlRuntimeDir, spinner, runtime.defaultPort);
             break;
     }
+    if (runtime.kind === "go") {
+        generateGoNodeRegistry(projectDir);
+    }
+    else if (runtime.kind === "rust") {
+        generateRustNodeRegistry(projectDir);
+    }
+    else if (runtime.kind === "java") {
+        generateJavaNodeRegistry(projectDir);
+    }
+    else if (runtime.kind === "csharp") {
+        generateCSharpNodeRegistry(projectDir);
+    }
     spinner.message(`${runtime.label} runtime setup complete.`);
     return {
         port: runtime.defaultPort,
@@ -56,7 +68,7 @@ export async function setupRuntime(runtime, githubRepoLocal, projectDir, spinner
         transport: "grpc",
     };
 }
-async function setupPython3(sdkDir, projectRuntimeDir, spinner) {
+async function setupPython3(sdkDir, spinner) {
     spinner.message("Creating Python3 virtual environment...");
     await createPythonVenv(sdkDir);
     spinner.message("Python3 virtual environment created.");
@@ -67,16 +79,6 @@ async function setupPython3(sdkDir, projectRuntimeDir, spinner) {
         await exec(`"${venvPip}" install -r "${requirementsFile}"`, { cwd: sdkDir });
     }
     spinner.message("Python3 packages installed.");
-    const nodesLink = path.join(projectRuntimeDir, "nodes");
-    const sdkNodesDir = path.join(sdkDir, "nodes");
-    if (fsExtra.existsSync(sdkNodesDir) && !fsExtra.existsSync(nodesLink)) {
-        fsExtra.symlinkSync(sdkNodesDir, nodesLink, "junction");
-    }
-    const coreLink = path.join(projectRuntimeDir, "core");
-    const sdkCoreDir = path.join(sdkDir, "core");
-    if (fsExtra.existsSync(sdkCoreDir) && !fsExtra.existsSync(coreLink)) {
-        fsExtra.symlinkSync(sdkCoreDir, coreLink, "junction");
-    }
 }
 async function createPythonVenv(sdkDir) {
     await exec("python3 -m venv python3_runtime", { cwd: sdkDir, timeout: 60000 });
@@ -86,6 +88,258 @@ async function setupGo(sdkDir, spinner) {
     await exec("go mod download", { cwd: sdkDir, timeout: 120000 });
     spinner.message("Go dependencies installed.");
 }
+export function generateGoNodeRegistry(projectDir) {
+    const goSdkDir = path.join(projectDir, ".blok", "runtimes", "go");
+    const nodesSrcDir = path.join(projectDir, "runtimes", "go", "nodes");
+    const usernodesDir = path.join(goSdkDir, "usernodes");
+    const registryFile = path.join(goSdkDir, "cmd", "server", "register_user_nodes.go");
+    fsExtra.removeSync(usernodesDir);
+    const nodes = [];
+    if (fsExtra.existsSync(nodesSrcDir)) {
+        let i = 0;
+        for (const entry of fsExtra.readdirSync(nodesSrcDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const srcDir = path.join(nodesSrcDir, entry.name);
+            const goFiles = fsExtra.readdirSync(srcDir).filter((f) => f.endsWith(".go"));
+            if (goFiles.length === 0)
+                continue;
+            const exportsRegister = goFiles.some((f) => /func\s+Register\s*\(/.test(fsExtra.readFileSync(path.join(srcDir, f), "utf8")));
+            if (!exportsRegister) {
+                console.warn(`[blokctl] skipping Go node '${entry.name}': no exported Register(registry) found`);
+                continue;
+            }
+            const destDir = path.join(usernodesDir, entry.name);
+            fsExtra.ensureDirSync(destDir);
+            for (const f of goFiles) {
+                fsExtra.copySync(path.join(srcDir, f), path.join(destDir, f));
+            }
+            nodes.push({
+                alias: `usernode${i++}`,
+                importPath: `github.com/nickincloud/blok-go/usernodes/${entry.name}`,
+            });
+        }
+    }
+    const importLines = [
+        '\tblok "github.com/nickincloud/blok-go"',
+        ...nodes.map((n) => `\t${n.alias} "${n.importPath}"`),
+    ];
+    const callLines = nodes.map((n) => `\t${n.alias}.Register(registry)`);
+    const content = `// Code generated by blokctl. DO NOT EDIT.
+package main
+
+import (
+${importLines.join("\n")}
+)
+
+// registerUserNodes registers nodes scaffolded under runtimes/go/nodes.
+func registerUserNodes(registry *blok.NodeRegistry) {
+${callLines.join("\n")}
+}
+`;
+    fsExtra.ensureDirSync(path.dirname(registryFile));
+    fsExtra.writeFileSync(registryFile, content);
+    return registryFile;
+}
+export function generateRustNodeRegistry(projectDir) {
+    const rustSdkDir = path.join(projectDir, ".blok", "runtimes", "rust");
+    const nodesSrcDir = path.join(projectDir, "runtimes", "rust", "nodes");
+    const usernodesDir = path.join(rustSdkDir, "src", "user_nodes");
+    fsExtra.removeSync(usernodesDir);
+    fsExtra.ensureDirSync(usernodesDir);
+    const toModIdent = (name) => {
+        let id = name.replace(/[^a-zA-Z0-9_]/g, "_");
+        if (/^[0-9]/.test(id))
+            id = `_${id}`;
+        return id;
+    };
+    const mods = [];
+    if (fsExtra.existsSync(nodesSrcDir)) {
+        for (const entry of fsExtra.readdirSync(nodesSrcDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const srcDir = path.join(nodesSrcDir, entry.name);
+            const rsFiles = fsExtra.readdirSync(srcDir).filter((f) => f.endsWith(".rs"));
+            if (rsFiles.length === 0)
+                continue;
+            const rootFile = rsFiles.find((f) => /fn\s+register\s*\(/.test(fsExtra.readFileSync(path.join(srcDir, f), "utf8")));
+            if (!rootFile) {
+                console.warn(`[blokctl] skipping Rust node '${entry.name}': no .rs exporting fn register(registry) found`);
+                continue;
+            }
+            const modIdent = toModIdent(entry.name);
+            const destDir = path.join(usernodesDir, modIdent);
+            fsExtra.ensureDirSync(destDir);
+            const siblings = rsFiles.filter((f) => f !== rootFile);
+            for (const f of siblings) {
+                fsExtra.copySync(path.join(srcDir, f), path.join(destDir, f));
+            }
+            let rootSrc = fsExtra.readFileSync(path.join(srcDir, rootFile), "utf8");
+            if (siblings.length > 0) {
+                const subMods = siblings.map((f) => `mod ${path.basename(f, ".rs")};`).join("\n");
+                rootSrc = `${subMods}\n\n${rootSrc}`;
+            }
+            fsExtra.writeFileSync(path.join(destDir, "mod.rs"), rootSrc);
+            mods.push(modIdent);
+        }
+    }
+    const modLines = mods.map((m) => `pub mod ${m};`);
+    const callLines = mods.map((m) => `\t${m}::register(registry);`);
+    const content = `// Code generated by blokctl. DO NOT EDIT.
+use blok::registry::NodeRegistry;
+
+${modLines.join("\n")}
+
+/// Registers nodes scaffolded under runtimes/rust/nodes.
+pub fn register_user_nodes(${mods.length > 0 ? "registry" : "_registry"}: &mut NodeRegistry) {
+${callLines.join("\n")}
+}
+`;
+    const registryFile = path.join(usernodesDir, "mod.rs");
+    fsExtra.writeFileSync(registryFile, content);
+    return registryFile;
+}
+export function generateJavaNodeRegistry(projectDir) {
+    const javaSdkDir = path.join(projectDir, ".blok", "runtimes", "java");
+    const nodesSrcDir = path.join(projectDir, "runtimes", "java", "nodes");
+    const sdkJavaRoot = path.join(javaSdkDir, "src", "main", "java");
+    const usernodesDir = path.join(sdkJavaRoot, "usernodes");
+    const registryFile = path.join(sdkJavaRoot, "com", "blok", "blok", "UserNodeRegistry.java");
+    fsExtra.removeSync(usernodesDir);
+    const registrations = [];
+    if (fsExtra.existsSync(nodesSrcDir)) {
+        for (const entry of fsExtra.readdirSync(nodesSrcDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const nodeSrcRoot = path.join(nodesSrcDir, entry.name, "src", "main", "java");
+            if (!fsExtra.existsSync(nodeSrcRoot)) {
+                console.warn(`[blokctl] skipping Java node '${entry.name}': no src/main/java found`);
+                continue;
+            }
+            const javaFiles = [];
+            const walk = (dir) => {
+                for (const f of fsExtra.readdirSync(dir, { withFileTypes: true })) {
+                    const full = path.join(dir, f.name);
+                    if (f.isDirectory())
+                        walk(full);
+                    else if (f.name.endsWith(".java"))
+                        javaFiles.push(full);
+                }
+            };
+            walk(nodeSrcRoot);
+            let fqcn;
+            for (const file of javaFiles) {
+                const src = fsExtra.readFileSync(file, "utf8");
+                const classMatch = src.match(/class\s+(\w+)\s+implements\s+NodeHandler/);
+                if (!classMatch)
+                    continue;
+                const pkgMatch = src.match(/package\s+([\w.]+)\s*;/);
+                fqcn = pkgMatch ? `${pkgMatch[1]}.${classMatch[1]}` : classMatch[1];
+                break;
+            }
+            if (!fqcn) {
+                console.warn(`[blokctl] skipping Java node '${entry.name}': no class implementing NodeHandler found`);
+                continue;
+            }
+            fsExtra.copySync(nodeSrcRoot, path.join(usernodesDir, entry.name));
+            registrations.push(`\t\tregistry.register("${entry.name}", new ${fqcn}());`);
+        }
+    }
+    const content = `// Code generated by blokctl. DO NOT EDIT.
+package com.blok.blok;
+
+import com.blok.blok.node.NodeRegistry;
+
+public final class UserNodeRegistry {
+
+\tprivate UserNodeRegistry() {
+\t}
+
+\t/** Registers nodes scaffolded under runtimes/java/nodes. */
+\tpublic static void registerUserNodes(NodeRegistry registry) {
+${registrations.join("\n")}
+\t}
+}
+`;
+    fsExtra.ensureDirSync(path.dirname(registryFile));
+    fsExtra.writeFileSync(registryFile, content);
+    return registryFile;
+}
+export function generateCSharpNodeRegistry(projectDir) {
+    const csSdkDir = path.join(projectDir, ".blok", "runtimes", "csharp");
+    const nodesSrcDir = path.join(projectDir, "runtimes", "csharp", "nodes");
+    const usernodesDir = path.join(csSdkDir, "src", "Blok.Core", "Nodes", "UserNodes");
+    const registryFile = path.join(csSdkDir, "src", "Blok.Core", "UserNodeRegistry.cs");
+    fsExtra.removeSync(usernodesDir);
+    const seenClasses = new Set();
+    const registrations = [];
+    if (fsExtra.existsSync(nodesSrcDir)) {
+        for (const entry of fsExtra.readdirSync(nodesSrcDir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const srcDir = path.join(nodesSrcDir, entry.name);
+            const csFiles = collectFilesRecursive(srcDir, ".cs");
+            if (csFiles.length === 0)
+                continue;
+            let className;
+            for (const file of csFiles) {
+                const match = fsExtra.readFileSync(file, "utf8").match(/class\s+(\w+)\s*:\s*INodeHandler\b/);
+                if (match) {
+                    className = match[1];
+                    break;
+                }
+            }
+            if (!className) {
+                console.warn(`[blokctl] skipping C# node '${entry.name}': no 'class X : INodeHandler' found`);
+                continue;
+            }
+            if (seenClasses.has(className)) {
+                console.warn(`[blokctl] skipping C# node '${entry.name}': duplicate class name '${className}' (single namespace Blok.Core.Nodes)`);
+                continue;
+            }
+            seenClasses.add(className);
+            const destDir = path.join(usernodesDir, entry.name);
+            fsExtra.ensureDirSync(destDir);
+            for (const file of csFiles) {
+                fsExtra.copySync(file, path.join(destDir, path.basename(file)));
+            }
+            registrations.push({ nodeName: entry.name, className });
+        }
+    }
+    const callLines = registrations.map((r) => `\t\tregistry.Register("${r.nodeName}", new Blok.Core.Nodes.${r.className}());`);
+    const content = `// Code generated by blokctl. DO NOT EDIT.
+using Blok.Core.Node;
+
+namespace Blok.Core;
+
+/// <summary>
+/// Registers user nodes scaffolded under runtimes/csharp/nodes.
+/// </summary>
+public static class UserNodeRegistry
+{
+	public static void RegisterUserNodes(NodeRegistry registry)
+	{
+${callLines.join("\n")}
+	}
+}
+`;
+    fsExtra.ensureDirSync(path.dirname(registryFile));
+    fsExtra.writeFileSync(registryFile, content);
+    return registryFile;
+}
+function collectFilesRecursive(dir, ext) {
+    const out = [];
+    for (const entry of fsExtra.readdirSync(dir, { withFileTypes: true })) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...collectFilesRecursive(full, ext));
+        }
+        else if (entry.name.endsWith(ext)) {
+            out.push(full);
+        }
+    }
+    return out;
+}
 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 });
@@ -140,7 +394,7 @@ async function setupRuby(sdkDir, spinner, port) {
     spinner.message("Ruby dependencies installed.");
     return `${resolvedBundle} exec rackup --host 0.0.0.0 -p ${port} config.ru`;
 }
-export function writeProjectConfig(projectDir, runtimeConfigs, triggerConfigs) {
+export function writeProjectConfig(projectDir, runtimeConfigs, triggerConfigs, observabilityConfigs) {
     const config = {};
     if (runtimeConfigs.length > 0) {
         config.runtimes = {};
@@ -154,6 +408,9 @@ export function writeProjectConfig(projectDir, runtimeConfigs, triggerConfigs) {
             config.triggers[tc.kind] = tc;
         }
     }
+    if (observabilityConfigs && Object.keys(observabilityConfigs).length > 0) {
+        config.observability = observabilityConfigs;
+    }
     const configPath = path.join(projectDir, ".blok", "config.json");
     fsExtra.ensureDirSync(path.dirname(configPath));
     fsExtra.writeFileSync(configPath, JSON.stringify(config, null, 2));
@@ -185,11 +442,14 @@ export function generateSupervisordConfig(runtimeConfigs) {
     for (const rc of runtimeConfigs) {
         const cmd = rc.grpcStartCmd ?? rc.startCmd;
         const grpcPortLine = rc.grpcPort !== undefined ? `,GRPC_PORT="${rc.grpcPort}"` : "";
+        const nodesDirLine = rc.kind === "python3" || rc.kind === "ruby" || rc.kind === "php"
+            ? `,BLOK_NODES_DIR="/app/runtimes/${rc.kind}/nodes"`
+            : "";
         config += `
 [program:${rc.kind}_runtime]
 command=${cmd}
 directory=/app/${rc.cwd}
-environment=PORT="${rc.port}"${grpcPortLine},HOST="0.0.0.0",BLOK_TRANSPORT="grpc"
+environment=PORT="${rc.port}"${grpcPortLine}${nodesDirLine},HOST="0.0.0.0",BLOK_TRANSPORT="grpc"
 autostart=true
 autorestart=true
 stderr_logfile=/var/log/${rc.kind}.err.log