blokctl 1.4.0 → 1.4.1

package/dist/commands/create/project.js

@@ -23,7 +23,7 @@ const exec = util.promisify(child_process.exec);
 const HOME_DIR = `${os.homedir()}/.blok`;
 const GITHUB_REPO_LOCAL = `${HOME_DIR}/blok`;
 const GITHUB_REPO_REMOTE = "https://github.com/well-prado/blok.git";
-const GITHUB_REPO_RELEASE_TAG = "v1.4.0";
+const GITHUB_REPO_RELEASE_TAG = "v1.4.1";
 const BUNDLED_SCAFFOLD_REPO = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../scaffold-repo");
 const RUNTIME_HELLO_EXAMPLES = {
     go: "runtime-go-hello.ts",
@@ -564,7 +564,7 @@ export async function createProject(opts, version, currentPath = false, localRep
             "@blokjs/trigger-worker": "triggers/worker",
             "@blokjs/core": "core/core",
         };
-        const BLOKJS_DEP_RANGE = "^1.4.0";
+        const BLOKJS_DEP_RANGE = "^1.4.1";
         for (const depGroup of ["dependencies", "devDependencies", "peerDependencies"]) {
             const deps = packageJsonContent[depGroup];
             if (!deps)

package/dist/scaffold-repo/sdks/php/bin/serve.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+require_once __DIR__ . '/../vendor/autoload.php';
+
+use Blok\Blok\Config\ServerConfig;
+use Blok\Blok\Config\Transport;
+use Blok\Blok\Examples\ApiCallNode;
+use Blok\Blok\Examples\BlokErrorDemoNode;
+use Blok\Blok\Examples\ChainTestNode;
+use Blok\Blok\Examples\HelloWorldNode;
+use Blok\Blok\Examples\TransformDataNode;
+use Blok\Blok\Examples\TypedGreetNode;
+use Blok\Blok\Node\NodeHandler;
+use Blok\Blok\Node\NodeRegistry;
+use Blok\Blok\Server\BlokNodeRuntimeService;
+use Blok\Blok\Server\NodeRuntimeInterface;
+use Blok\Blok\Server\Server;
+use Spiral\RoadRunner\GRPC\Server as GrpcServer;
+
+$config = ServerConfig::fromEnv();
+
+$registry = new NodeRegistry($config->version);
+$registry->register('hello-world', new HelloWorldNode());
+$registry->register('api-call', new ApiCallNode());
+$registry->register('transform-data', new TransformDataNode());
+$registry->register('chain-test', new ChainTestNode());
+$registry->register('blok-error-demo', new BlokErrorDemoNode());
+$registry->register('typed-greet', new TypedGreetNode());
+
+// Discover user nodes scaffolded under runtimes/php/nodes/ (mirrors Python's
+// BLOK_NODES_DIR scan). The CLI sets BLOK_NODES_DIR; each node lives at
+// <dir>/<name>/src/Nodes/<Pascal>Node.php with class
+// Blok\Blok\Nodes\<Pascal>\<Pascal>Node implementing NodeHandler, registered
+// under its directory name. require_once is enough — nodes use the SDK's
+// already-autoloaded classes, so no composer-autoloader merge is needed.
+$nodesDir = getenv('BLOK_NODES_DIR') ?: '';
+if ($nodesDir !== '' && is_dir($nodesDir)) {
+    $discovered = 0;
+    foreach (glob($nodesDir . '/*/src/Nodes/*Node.php') ?: [] as $file) {
+        // ponytail: name = the node's top dir; convention class lives under it.
+        $name = basename(dirname($file, 3));
+        $pascal = str_replace(' ', '', ucwords(str_replace(['-', '_'], ' ', $name)));
+        $class = "Blok\\Blok\\Nodes\\{$pascal}\\{$pascal}Node";
+
+        require_once $file;
+        if (!class_exists($class)) {
+            fwrite(STDERR, sprintf("[blok] skipping user node '%s': class %s not found\n", $name, $class));
+            continue;
+        }
+        $handler = new $class();
+        if (!$handler instanceof NodeHandler) {
+            fwrite(STDERR, sprintf("[blok] skipping user node '%s': %s does not implement NodeHandler\n", $name, $class));
+            continue;
+        }
+        $registry->register($name, $handler);
+        $discovered++;
+    }
+    if ($discovered > 0) {
+        fwrite(STDERR, sprintf("Discovered %d user node(s) from %s\n", $discovered, $nodesDir));
+    }
+}
+
+fwrite(
+    STDERR,
+    sprintf("Registered %d nodes: %s\n", $registry->count(), implode(', ', $registry->nodeNames())),
+);
+
+switch ($config->transport) {
+    case Transport::Grpc:
+        // Worker mode: the RoadRunner daemon (started via `rr serve -c .rr.yaml`)
+        // handles HTTP/2 + gRPC framing in Go and dispatches each call to this
+        // PHP worker over goridge pipes. Server::serve() blocks reading payloads
+        // from stdin until rr signals shutdown.
+        $service = new BlokNodeRuntimeService($registry, sdkVersion: $config->version);
+        $server = new GrpcServer();
+        $server->registerService(NodeRuntimeInterface::class, $service);
+        fwrite(STDERR, "Blok PHP gRPC worker entering spiral/roadrunner-grpc loop\n");
+        $server->serve();
+        break;
+
+    case Transport::Both:
+        // PHP cannot run two transports in one process without OS threads.
+        // Operators run `rr serve` (gRPC) and `php bin/serve.php` (HTTP) side
+        // by side; here we fall through to HTTP so this command still serves
+        // half the matrix on its own.
+        fwrite(STDERR, "BLOK_TRANSPORT=both: this process serves HTTP only; run `rr serve -c .rr.yaml` separately for gRPC\n");
+        // intentional fallthrough
+    case Transport::Http:
+    default:
+        $server = new Server($registry, $config);
+        $server->start();
+        break;
+}

package/dist/scaffold-repo/sdks/python3/bin/serve.py

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+"""Entry point for the Blok blok Python3 runtime server.
+
+Usage:
+    python bin/serve.py
+
+Environment variables:
+    PORT             HTTP port (default: 9007)
+    HOST             Bind address (default: 0.0.0.0)
+    VERSION          Runtime version (default: 1.0.0)
+    GRPC_PORT        gRPC port (default: 10007)
+    BLOK_TRANSPORT   "http" | "grpc" | "both" (default: "http")
+    LOG_LEVEL        DEBUG | INFO | WARN | ERROR (default: INFO)
+    ENABLE_CORS      true / false (default: false)
+    BLOK_GRPC_MAX_MESSAGE_BYTES  Max gRPC message size, send+recv (default: 16777216).
+                     Must match the runner client + other sidecars.
+    BLOK_NODES_DIR   Directory of user-authored nodes to discover (each node in
+                     a `<name>/node.py` using the `@node` decorator). Set by
+                     blokctl to the project's `runtimes/python3/nodes`. When
+                     unset, only the SDK's built-in example nodes load.
+"""
+
+import logging
+import os
+import signal
+import sys
+import threading
+
+# Add the SDK root to the path so imports work
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from blok.config.server_config import ServerConfig
+from blok.middleware.logging_middleware import logging_middleware
+from blok.middleware.recovery_middleware import recovery_middleware
+from blok.node.node_registry import NodeRegistry
+from blok.server.runtime_server import RuntimeServer
+from examples import register_all
+
+
+def _start_http(registry: NodeRegistry, config: ServerConfig) -> RuntimeServer:
+    """Start the HTTP runtime server in the calling thread.
+
+    Returns the started server so the caller can stop it cleanly.
+    """
+    server = RuntimeServer(registry, config)
+    server.start()
+    return server
+
+
+def _start_grpc(registry: NodeRegistry, config: ServerConfig):
+    """Start the gRPC runtime server. Lazy-imports grpcio so the base SDK
+    install doesn't pull it in unless `BLOK_TRANSPORT` selects gRPC.
+
+    Returns the started ``grpc.Server`` instance.
+    """
+    try:
+        from blok.server.grpc_server import serve_grpc
+    except ImportError as exc:  # pragma: no cover — depends on optional install
+        logging.error(
+            "BLOK_TRANSPORT=%s requires grpcio. Install with: pip install 'blok-blok-python3[grpc]'",
+            config.transport,
+        )
+        raise SystemExit(1) from exc
+
+    # Max gRPC message size (decode + encode), default 16 MiB. MUST match the
+    # runner client's BLOK_GRPC_MAX_MESSAGE_BYTES and the other sidecars — a
+    # client-only raise leaves this server rejecting oversized messages with
+    # RESOURCE_EXHAUSTED. Invalid / non-positive falls back to the default.
+    default_max = 16 * 1024 * 1024
+    try:
+        max_message_bytes = int(os.environ.get("BLOK_GRPC_MAX_MESSAGE_BYTES", default_max))
+        if max_message_bytes <= 0:
+            max_message_bytes = default_max
+    except (TypeError, ValueError):
+        max_message_bytes = default_max
+
+    return serve_grpc(
+        registry,
+        port=config.grpc_port,
+        host=config.host,
+        sdk_version=config.version,
+        max_message_bytes=max_message_bytes,
+    )
+
+
+def _load_user_nodes(registry: NodeRegistry) -> int:
+    """Discover user nodes from ``BLOK_NODES_DIR`` (delegates to the SDK).
+
+    `@node` authoring requires pydantic; if it isn't installed there are no
+    user nodes to load, so a missing import is a no-op.
+    """
+    try:
+        from blok.node.define_node import load_user_nodes
+    except ImportError:
+        return 0
+    return load_user_nodes(registry, os.environ.get("BLOK_NODES_DIR"))
+
+
+def main():
+    config = ServerConfig.from_env()
+
+    log_level = getattr(logging, config.log_level, logging.INFO)
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        stream=sys.stdout,
+    )
+
+    registry = NodeRegistry(version=config.version)
+    register_all(registry)
+    user_node_count = _load_user_nodes(registry)
+    registry.use(recovery_middleware)
+    registry.use(logging_middleware)
+
+    transport = config.transport
+    log = logging.getLogger("blok.serve")
+    log.info(
+        "Blok Python3 SDK starting (transport=%s, http_port=%d, grpc_port=%d, %d nodes, %d user)",
+        transport,
+        config.port,
+        config.grpc_port,
+        len(registry.node_names()),
+        user_node_count,
+    )
+
+    if transport == "http":
+        _start_http(registry, config)
+        return
+
+    if transport == "grpc":
+        grpc_server = _start_grpc(registry, config)
+        _block_until_signal_then_stop(grpc=grpc_server, http=None)
+        return
+
+    if transport == "both":
+        # Start gRPC in background, HTTP in foreground (HTTP server's
+        # ``start()`` blocks until shutdown). On signal we stop gRPC, then
+        # the HTTP server unwinds.
+        grpc_server = _start_grpc(registry, config)
+        http_thread = threading.Thread(
+            target=_start_http,
+            args=(registry, config),
+            daemon=True,
+            name="blok-http",
+        )
+        http_thread.start()
+        _block_until_signal_then_stop(grpc=grpc_server, http=None)
+        return
+
+    log.error("Unknown BLOK_TRANSPORT=%r — expected http | grpc | both", transport)
+    sys.exit(1)
+
+
+def _block_until_signal_then_stop(*, grpc, http) -> None:
+    """Block on SIGINT/SIGTERM, then stop the gRPC server (and HTTP if owned)."""
+    stop_event = threading.Event()
+
+    def _handler(signum, _frame):
+        logging.getLogger("blok.serve").info("Received signal %d, shutting down…", signum)
+        stop_event.set()
+
+    signal.signal(signal.SIGINT, _handler)
+    signal.signal(signal.SIGTERM, _handler)
+    stop_event.wait()
+
+    if grpc is not None:
+        grpc.stop(grace=3.0)
+    # The HTTP server in dual-listen runs in a daemon thread; it tears down
+    # automatically on process exit. ``http`` is reserved for future shapes
+    # (e.g. promoting HTTP into a stoppable abstraction).
+
+
+if __name__ == "__main__":
+    main()

package/dist/scaffold-repo/sdks/python3/bin/worker.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Entry point for the Blok NATS JetStream worker.
+
+Usage:
+    python bin/worker.py
+
+Environment variables:
+    NATS_SERVERS          - Comma-separated NATS server URLs (default: localhost:4222)
+    NATS_TOKEN            - Authentication token (optional)
+    NATS_USER             - Username (optional)
+    NATS_PASS             - Password (optional)
+    NATS_STREAM_NAME      - JetStream stream name (default: blok-worker)
+    WORKER_CONCURRENCY    - Max concurrent jobs (default: 1)
+    WORKER_MAX_RETRIES    - Max delivery attempts (default: 3)
+    WORKER_ACK_WAIT_SECS  - Job timeout in seconds (default: 30)
+    WORKER_QUEUES         - Comma-separated queue names
+    PORT                  - HTTP health server port (default: 8080)
+    VERSION               - Runtime version (default: 1.0.0)
+    LOG_LEVEL             - Log level: DEBUG, INFO, WARN, ERROR (default: INFO)
+"""
+
+import logging
+import os
+import sys
+
+# Add the SDK root to the path so imports work
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from blok.config.server_config import ServerConfig
+from blok.middleware.logging_middleware import logging_middleware
+from blok.middleware.recovery_middleware import recovery_middleware
+from blok.node.node_registry import NodeRegistry
+from blok.worker import listen_and_serve_worker
+from examples import register_all
+
+
+def main():
+    # Configure logging
+    config = ServerConfig.from_env()
+    log_level = getattr(logging, config.log_level, logging.INFO)
+    logging.basicConfig(
+        level=log_level,
+        format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
+        stream=sys.stdout,
+    )
+
+    # Create registry and register nodes
+    registry = NodeRegistry(version=config.version)
+    register_all(registry)
+
+    # Add middleware
+    registry.use(recovery_middleware)
+    registry.use(logging_middleware)
+
+    # Start worker (blocks until shutdown)
+    listen_and_serve_worker(registry)
+
+
+if __name__ == "__main__":
+    main()

package/dist/scaffold-repo/sdks/ruby/bin/serve.rb

@@ -0,0 +1,105 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Entry point for the Blok Ruby runtime.
+#
+# Boots the configured server(s) based on +BLOK_TRANSPORT+:
+#   - "http" (default): Sinatra HTTP server only.
+#   - "grpc": gRPC server only on +GRPC_PORT+.
+#   - "both": HTTP in foreground + gRPC in a background thread (dual-listen).
+#
+# Usage:
+#   ruby bin/serve.rb
+#
+# Environment:
+#   PORT           HTTP port (default: 9006)
+#   GRPC_PORT      gRPC port (default: 10006)
+#   BLOK_TRANSPORT "http" | "grpc" | "both" (default: "http")
+#   HOST           Bind address (default: 0.0.0.0)
+#   LOG_LEVEL      DEBUG | INFO | WARN | ERROR (default: INFO)
+#   BLOK_NODES_DIR Directory of user-authored nodes to discover (each in a
+#                  `<name>/node.rb` subclassing Blok::Node::NodeHandler). Set by
+#                  blokctl to the project's `runtimes/ruby/nodes`. When unset,
+#                  only the SDK's built-in example nodes load.
+
+$LOAD_PATH.unshift File.expand_path("../lib", __dir__)
+
+require "blok"
+require_relative "../examples/hello_world_node"
+require_relative "../examples/api_call_node"
+require_relative "../examples/transform_data_node"
+require_relative "../examples/chain_test_node"
+require_relative "../examples/blok_error_demo_node"
+require_relative "../examples/typed_greet_node"
+
+config = Blok::Config::ServerConfig.from_env
+
+registry = Blok::Node::NodeRegistry.new(config.version)
+registry.register("hello-world", HelloWorldNode.new)
+registry.register("api-call", ApiCallNode.new)
+registry.register("transform-data", TransformDataNode.new)
+registry.register("chain-test", ChainTestNode.new)
+registry.register("blok-error-demo", BlokErrorDemoNode.new)
+registry.register("typed-greet", TypedGreetNode.new)
+
+# Discover user-authored nodes from BLOK_NODES_DIR (set by blokctl to the
+# project's runtimes/ruby/nodes). Each lives in <name>/node.rb subclassing
+# Blok::Node::NodeHandler; no manual registration. Unset => built-ins only.
+user_node_count = Blok::Node.load_user_nodes(registry, ENV["BLOK_NODES_DIR"])
+
+logger = Blok::Logging::Logger.new(config.log_level)
+registry.use(Blok::Middleware::RecoveryMiddleware.new)
+registry.use(Blok::Middleware::LoggingMiddleware.new(logger))
+
+warn "Blok Ruby SDK starting (transport=#{config.transport}, http_port=#{config.port}, " \
+     "grpc_port=#{config.grpc_port}, #{registry.node_names.length} nodes, #{user_node_count} user)"
+
+# Lazy-load the gRPC server only when we actually need it. This keeps the
+# HTTP-only path free of grpc dependency load time.
+def start_grpc(registry, config, blocking:)
+  require_relative "../lib/blok/server/grpc_server"
+  Blok::Server::GrpcServer.new(
+    registry,
+    port: config.grpc_port,
+    host: config.host,
+    sdk_version: config.version
+  ).tap { |s| s.start(blocking: blocking) }
+end
+
+def start_http(registry, config)
+  Blok::Server::RuntimeApp.registry = registry
+  # Sinatra/Puma: bind on host:port and run in the foreground.
+  require "rackup"
+  app = Rack::Builder.new { run Blok::Server::RuntimeApp }.to_app
+  Rackup::Server.start(
+    app: app,
+    server: "puma",
+    Host: config.host,
+    Port: config.port,
+    quiet: false
+  )
+end
+
+case config.transport
+when Blok::Config::ServerConfig::Transport::HTTP
+  start_http(registry, config)
+when Blok::Config::ServerConfig::Transport::GRPC
+  grpc_server = start_grpc(registry, config, blocking: false)
+  # Hand the stop signal off the trap context to the main thread.
+  # `GrpcServer#stop` calls `RpcServer#stop` which acquires a Mutex,
+  # and `Mutex#synchronize` raises `ThreadError: can't be called from
+  # trap context` under Ruby 3.x. `Queue#<<` is signal-safe in MRI.
+  stop_queue = Queue.new
+  trap("INT")  { stop_queue << "INT" }
+  trap("TERM") { stop_queue << "TERM" }
+  stop_queue.pop
+  grpc_server.stop
+  exit 0
+when Blok::Config::ServerConfig::Transport::BOTH
+  grpc_server = start_grpc(registry, config, blocking: false)
+  at_exit { grpc_server.stop }
+  start_http(registry, config)
+else
+  warn "Unknown transport: #{config.transport}"
+  exit 1
+end

package/dist/scaffold-repo/triggers/cron/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-cron",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "Cron/scheduled trigger for Blok workflows - supports cron expressions and interval-based scheduling",
 	"type": "module",
@@ -15,9 +15,9 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"cron": "^4.4.0",
 		"uuid": "^11.1.0"

package/dist/scaffold-repo/triggers/grpc/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-grpc",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "",
 	"type": "module",
@@ -36,11 +36,11 @@
 		"@connectrpc/connect": "^2.1.1",
 		"@connectrpc/connect-fastify": "^2.1.1",
 		"@connectrpc/connect-node": "^2.1.1",
-		"@blokjs/api-call": "^1.4.0",
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/if-else": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/api-call": "^1.4.1",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/if-else": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/exporter-prometheus": "^0.57.2",
 		"@opentelemetry/resources": "^1.30.1",

package/dist/scaffold-repo/triggers/http/package.json

@@ -31,17 +31,17 @@
 	},
 	"dependencies": {
 		"@ai-sdk/openai": "^1.3.22",
-		"@blokjs/api-call": "^1.4.0",
-		"@blokjs/core": "^1.4.0",
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/helpers": "^1.4.0",
-		"@blokjs/if-else": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
-		"@blokjs/trigger-mcp": "^1.4.0",
-		"@blokjs/trigger-sse": "^1.4.0",
-		"@blokjs/trigger-webhook": "^1.4.0",
-		"@blokjs/trigger-websocket": "^1.4.0",
+		"@blokjs/api-call": "^1.4.1",
+		"@blokjs/core": "^1.4.1",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/helpers": "^1.4.1",
+		"@blokjs/if-else": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
+		"@blokjs/trigger-mcp": "^1.4.1",
+		"@blokjs/trigger-sse": "^1.4.1",
+		"@blokjs/trigger-webhook": "^1.4.1",
+		"@blokjs/trigger-websocket": "^1.4.1",
 		"@hono/node-server": "^1.19.9",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/exporter-prometheus": "^0.57.2",

package/dist/scaffold-repo/triggers/mcp/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-mcp",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "Model Context Protocol (MCP) trigger for Blok workflows — expose workflows as MCP tools over SSE + Streamable-HTTP on the shared Hono port.",
 	"type": "module",
@@ -15,9 +15,9 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@modelcontextprotocol/sdk": "^1.29.0",
 		"@opentelemetry/api": "^1.9.0",
 		"hono": "^4.11.7",

package/dist/scaffold-repo/triggers/pubsub/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-pubsub",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "Pub/Sub trigger for Blok workflows — supports NATS (Core + JetStream), Redis Streams, Kafka, GCP Pub/Sub, AWS SNS+SQS, and Azure Service Bus.",
 	"type": "module",
@@ -15,9 +15,9 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"uuid": "^11.1.0"
 	},

package/dist/scaffold-repo/triggers/pubsub/template/package.json

@@ -25,13 +25,13 @@
 		"vitest": "^4.0.18"
 	},
 	"dependencies": {
-		"@blokjs/api-call": "^1.4.0",
-		"@blokjs/core": "^1.4.0",
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/if-else": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
-		"@blokjs/trigger-pubsub": "^1.4.0",
+		"@blokjs/api-call": "^1.4.1",
+		"@blokjs/core": "^1.4.1",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/if-else": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
+		"@blokjs/trigger-pubsub": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/exporter-prometheus": "^0.57.2",
 		"@opentelemetry/resources": "^1.30.1",

package/dist/scaffold-repo/triggers/sse/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-sse",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "Server-Sent Events (SSE) trigger for Blok workflows — real-time server push on the shared Hono port.",
 	"type": "module",
@@ -15,15 +15,15 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"hono": "^4.11.7",
 		"uuid": "^11.1.0"
 	},
 	"devDependencies": {
-		"@blokjs/core": "^1.4.0",
+		"@blokjs/core": "^1.4.1",
 		"@hono/node-server": "^1.19.9",
 		"@types/node": "^22.15.21",
 		"@types/uuid": "^11.0.0",

package/dist/scaffold-repo/triggers/webhook/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-webhook",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "Webhook trigger for Blok workflows - supports GitHub, Stripe, Shopify, and custom webhooks",
 	"type": "module",
@@ -15,9 +15,9 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"hono": "^4.11.7",
 		"uuid": "^11.1.0"

package/dist/scaffold-repo/triggers/websocket/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-websocket",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "WebSocket trigger for Blok workflows - real-time bidirectional communication",
 	"type": "module",
@@ -15,15 +15,15 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@hono/node-ws": "^1.3.1",
 		"@opentelemetry/api": "^1.9.0",
 		"uuid": "^11.1.0"
 	},
 	"peerDependencies": {
-		"@blokjs/trigger-pubsub": "^1.4.0",
+		"@blokjs/trigger-pubsub": "^1.4.1",
 		"ws": "^8.19.0"
 	},
 	"peerDependenciesMeta": {
@@ -35,7 +35,7 @@
 		}
 	},
 	"devDependencies": {
-		"@blokjs/core": "^1.4.0",
+		"@blokjs/core": "^1.4.1",
 		"@types/node": "^22.15.21",
 		"@types/uuid": "^11.0.0",
 		"@types/ws": "^8.18.1",

package/dist/scaffold-repo/triggers/worker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@blokjs/trigger-worker",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"files": ["dist"],
 	"description": "Worker-based trigger for Blok workflows - supports background job processing with concurrency, retries, and scheduling",
 	"type": "module",
@@ -15,9 +15,9 @@
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"dependencies": {
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"uuid": "^11.1.0"
 	},

package/dist/scaffold-repo/triggers/worker/template/package.json

@@ -25,13 +25,13 @@
 		"vitest": "^4.0.18"
 	},
 	"dependencies": {
-		"@blokjs/api-call": "^1.4.0",
-		"@blokjs/core": "^1.4.0",
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/if-else": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
-		"@blokjs/shared": "^1.4.0",
-		"@blokjs/trigger-worker": "^1.4.0",
+		"@blokjs/api-call": "^1.4.1",
+		"@blokjs/core": "^1.4.1",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/if-else": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
+		"@blokjs/shared": "^1.4.1",
+		"@blokjs/trigger-worker": "^1.4.1",
 		"@opentelemetry/api": "^1.9.0",
 		"@opentelemetry/exporter-prometheus": "^0.57.2",
 		"@opentelemetry/resources": "^1.30.1",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "blokctl",
-	"version": "1.4.0",
+	"version": "1.4.1",
 	"author": "Deskree Technologies Inc.",
 	"license": "Apache-2.0",
 	"description": "cli for blok",
@@ -30,8 +30,8 @@
 	"keywords": ["blokctl", "cli", "blok", "blok"],
 	"dependencies": {
 		"@ai-sdk/openai": "^1.3.22",
-		"@blokjs/helper": "^1.4.0",
-		"@blokjs/runner": "^1.4.0",
+		"@blokjs/helper": "^1.4.1",
+		"@blokjs/runner": "^1.4.1",
 		"@clack/prompts": "^1.0.0",
 		"ai": "^4.3.16",
 		"better-sqlite3": "^12.6.2",