blokctl 1.3.0 → 1.4.1

package/dist/scaffold-repo/sdks/php/tests/Types/ExecutionResultTest.php

@@ -0,0 +1,136 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blok\Blok\Tests\Types;
+
+use Blok\Blok\Types\ExecutionMetrics;
+use Blok\Blok\Types\ExecutionResult;
+use PHPUnit\Framework\TestCase;
+
+final class ExecutionResultTest extends TestCase
+{
+    public function testSuccessFactory(): void
+    {
+        $result = ExecutionResult::success(['message' => 'hi']);
+
+        $this->assertTrue($result->success);
+        $this->assertSame(['message' => 'hi'], $result->data);
+        $this->assertNull($result->errors);
+        $this->assertNull($result->logs);
+        $this->assertNull($result->metrics);
+    }
+
+    public function testSuccessWithMetricsFactory(): void
+    {
+        $metrics = new ExecutionMetrics(durationMs: 12.5);
+        $result = ExecutionResult::successWithMetrics(['data' => true], $metrics);
+
+        $this->assertTrue($result->success);
+        $this->assertSame(['data' => true], $result->data);
+        $this->assertNotNull($result->metrics);
+        $this->assertSame(12.5, $result->metrics->durationMs);
+    }
+
+    public function testErrorFactory(): void
+    {
+        $result = ExecutionResult::error('something broke');
+
+        $this->assertFalse($result->success);
+        $this->assertNull($result->data);
+        $this->assertNotNull($result->errors);
+        $this->assertSame('something broke', $result->errors['message']);
+    }
+
+    public function testErrorWithDetailsFactory(): void
+    {
+        $result = ExecutionResult::errorWithDetails('bad input', ['field' => 'name']);
+
+        $this->assertFalse($result->success);
+        $this->assertSame('bad input', $result->errors['message']);
+        $this->assertSame(['field' => 'name'], $result->errors['details']);
+    }
+
+    public function testWithLogs(): void
+    {
+        $result = ExecutionResult::success(['ok' => true]);
+        $result->withLogs(['log line 1', 'log line 2']);
+
+        $this->assertNotNull($result->logs);
+        $this->assertCount(2, $result->logs);
+        $this->assertSame('log line 1', $result->logs[0]);
+    }
+
+    public function testWithMetrics(): void
+    {
+        $result = ExecutionResult::success(['ok' => true]);
+        $metrics = new ExecutionMetrics(durationMs: 5.0, memoryBytes: 1024);
+        $result->withMetrics($metrics);
+
+        $this->assertNotNull($result->metrics);
+        $this->assertSame(5.0, $result->metrics->durationMs);
+        $this->assertSame(1024, $result->metrics->memoryBytes);
+    }
+
+    public function testToArraySuccess(): void
+    {
+        $result = ExecutionResult::success(['message' => 'hello']);
+        $array = $result->toArray();
+
+        $this->assertTrue($array['success']);
+        $this->assertSame(['message' => 'hello'], $array['data']);
+        $this->assertArrayNotHasKey('errors', $array);
+        $this->assertArrayNotHasKey('logs', $array);
+        $this->assertArrayNotHasKey('metrics', $array);
+    }
+
+    public function testToArrayError(): void
+    {
+        $result = ExecutionResult::error('failed');
+        $array = $result->toArray();
+
+        $this->assertFalse($array['success']);
+        $this->assertNull($array['data']);
+        $this->assertArrayHasKey('errors', $array);
+        $this->assertSame('failed', $array['errors']['message']);
+    }
+
+    public function testToArrayWithMetrics(): void
+    {
+        $metrics = new ExecutionMetrics(durationMs: 10.0);
+        $result = ExecutionResult::successWithMetrics(['done' => true], $metrics);
+        $array = $result->toArray();
+
+        $this->assertArrayHasKey('metrics', $array);
+        $this->assertSame(10.0, $array['metrics']['duration_ms']);
+    }
+
+    public function testFromArray(): void
+    {
+        $data = [
+            'success' => true,
+            'data' => ['key' => 'value'],
+            'errors' => null,
+            'logs' => ['line1'],
+            'metrics' => ['duration_ms' => 3.14],
+        ];
+
+        $result = ExecutionResult::fromArray($data);
+
+        $this->assertTrue($result->success);
+        $this->assertSame(['key' => 'value'], $result->data);
+        $this->assertSame(['line1'], $result->logs);
+        $this->assertNotNull($result->metrics);
+        $this->assertSame(3.14, $result->metrics->durationMs);
+    }
+
+    public function testMetricsOmitsNullValues(): void
+    {
+        $metrics = new ExecutionMetrics(durationMs: 5.0);
+        $array = $metrics->toArray();
+
+        $this->assertArrayHasKey('duration_ms', $array);
+        $this->assertArrayNotHasKey('cpu_ms', $array);
+        $this->assertArrayNotHasKey('memory_bytes', $array);
+    }
+}

package/dist/scaffold-repo/sdks/php/tests/Validation/SchemaValidatorTest.php

@@ -0,0 +1,191 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Blok\Blok\Tests\Validation;
+
+use Blok\Blok\Validation\SchemaValidator;
+use PHPUnit\Framework\TestCase;
+
+final class SchemaValidatorTest extends TestCase
+{
+    private SchemaValidator $validator;
+
+    protected function setUp(): void
+    {
+        $this->validator = new SchemaValidator();
+    }
+
+    public function testTypeValidationString(): void
+    {
+        $this->assertEmpty($this->validator->validate('hello', ['type' => 'string']));
+        $this->assertNotEmpty($this->validator->validate(42, ['type' => 'string']));
+    }
+
+    public function testTypeValidationNumber(): void
+    {
+        $this->assertEmpty($this->validator->validate(42, ['type' => 'number']));
+        $this->assertEmpty($this->validator->validate(3.14, ['type' => 'number']));
+        $this->assertNotEmpty($this->validator->validate('hello', ['type' => 'number']));
+    }
+
+    public function testTypeValidationInteger(): void
+    {
+        $this->assertEmpty($this->validator->validate(42, ['type' => 'integer']));
+        $this->assertNotEmpty($this->validator->validate(3.14, ['type' => 'integer']));
+        $this->assertNotEmpty($this->validator->validate('hello', ['type' => 'integer']));
+    }
+
+    public function testTypeValidationBoolean(): void
+    {
+        $this->assertEmpty($this->validator->validate(true, ['type' => 'boolean']));
+        $this->assertEmpty($this->validator->validate(false, ['type' => 'boolean']));
+        $this->assertNotEmpty($this->validator->validate(1, ['type' => 'boolean']));
+    }
+
+    public function testTypeValidationObject(): void
+    {
+        $this->assertEmpty($this->validator->validate(['key' => 'value'], ['type' => 'object']));
+        $this->assertNotEmpty($this->validator->validate('hello', ['type' => 'object']));
+    }
+
+    public function testTypeValidationArray(): void
+    {
+        $this->assertEmpty($this->validator->validate([1, 2, 3], ['type' => 'array']));
+        $this->assertEmpty($this->validator->validate([], ['type' => 'array']));
+        $this->assertNotEmpty($this->validator->validate('hello', ['type' => 'array']));
+    }
+
+    public function testTypeValidationNull(): void
+    {
+        $this->assertEmpty($this->validator->validate(null, ['type' => 'null']));
+        $this->assertNotEmpty($this->validator->validate('hello', ['type' => 'null']));
+    }
+
+    public function testRequiredFields(): void
+    {
+        $schema = [
+            'type' => 'object',
+            'required' => ['name', 'email'],
+        ];
+
+        $valid = ['name' => 'John', 'email' => 'john@example.com'];
+        $this->assertEmpty($this->validator->validate($valid, $schema));
+
+        $missing = ['name' => 'John'];
+        $errors = $this->validator->validate($missing, $schema);
+        $this->assertCount(1, $errors);
+        $this->assertStringContainsString('email', $errors[0]);
+    }
+
+    public function testRequiredFieldsAllMissing(): void
+    {
+        $schema = [
+            'type' => 'object',
+            'required' => ['a', 'b', 'c'],
+        ];
+
+        $errors = $this->validator->validate([], $schema);
+        $this->assertCount(3, $errors);
+    }
+
+    public function testStringConstraints(): void
+    {
+        $schema = ['type' => 'string', 'minLength' => 2, 'maxLength' => 10];
+
+        $this->assertEmpty($this->validator->validate('hello', $schema));
+        $this->assertNotEmpty($this->validator->validate('x', $schema));
+        $this->assertNotEmpty($this->validator->validate('this is way too long', $schema));
+    }
+
+    public function testNumericConstraints(): void
+    {
+        $schema = ['type' => 'number', 'minimum' => 0, 'maximum' => 100];
+
+        $this->assertEmpty($this->validator->validate(50, $schema));
+        $this->assertNotEmpty($this->validator->validate(-1, $schema));
+        $this->assertNotEmpty($this->validator->validate(101, $schema));
+    }
+
+    public function testEnumValidation(): void
+    {
+        $schema = ['type' => 'string', 'enum' => ['red', 'green', 'blue']];
+
+        $this->assertEmpty($this->validator->validate('red', $schema));
+        $this->assertNotEmpty($this->validator->validate('yellow', $schema));
+    }
+
+    public function testNestedObjectValidation(): void
+    {
+        $schema = [
+            'type' => 'object',
+            'properties' => [
+                'user' => [
+                    'type' => 'object',
+                    'required' => ['name'],
+                    'properties' => [
+                        'name' => ['type' => 'string'],
+                    ],
+                ],
+            ],
+        ];
+
+        $valid = ['user' => ['name' => 'John']];
+        $this->assertEmpty($this->validator->validate($valid, $schema));
+
+        $invalid = ['user' => []];
+        $errors = $this->validator->validate($invalid, $schema);
+        $this->assertCount(1, $errors);
+        $this->assertStringContainsString('name', $errors[0]);
+    }
+
+    public function testArrayItemsValidation(): void
+    {
+        $schema = [
+            'type' => 'array',
+            'items' => ['type' => 'string'],
+        ];
+
+        $this->assertEmpty($this->validator->validate(['a', 'b', 'c'], $schema));
+        $this->assertNotEmpty($this->validator->validate(['a', 42, 'c'], $schema));
+    }
+
+    public function testArrayConstraints(): void
+    {
+        $schema = [
+            'type' => 'array',
+            'minItems' => 2,
+            'maxItems' => 5,
+        ];
+
+        $this->assertEmpty($this->validator->validate([1, 2, 3], $schema));
+        $this->assertNotEmpty($this->validator->validate([1], $schema));
+        $this->assertNotEmpty($this->validator->validate([1, 2, 3, 4, 5, 6], $schema));
+    }
+
+    public function testPropertyTypeValidation(): void
+    {
+        $schema = [
+            'type' => 'object',
+            'properties' => [
+                'name' => ['type' => 'string'],
+                'age' => ['type' => 'integer'],
+            ],
+        ];
+
+        $valid = ['name' => 'John', 'age' => 30];
+        $this->assertEmpty($this->validator->validate($valid, $schema));
+
+        $invalid = ['name' => 'John', 'age' => 'thirty'];
+        $errors = $this->validator->validate($invalid, $schema);
+        $this->assertCount(1, $errors);
+        $this->assertStringContainsString('age', $errors[0]);
+    }
+
+    public function testEmptySchemaAcceptsAnything(): void
+    {
+        $this->assertEmpty($this->validator->validate('hello', []));
+        $this->assertEmpty($this->validator->validate(42, []));
+        $this->assertEmpty($this->validator->validate(null, []));
+    }
+}

package/dist/scaffold-repo/sdks/python3/Dockerfile

@@ -0,0 +1,62 @@
+# Build stage
+FROM python:3.12-slim AS builder
+
+WORKDIR /app
+
+# Copy requirements first for layer caching
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy source
+COPY . .
+
+# Runtime stage (HTTP server - default)
+FROM python:3.12-slim AS runtime
+
+WORKDIR /app
+
+COPY --from=builder /app /app
+
+# Runtime deps: pydantic (the typed @node contract, declared in requirements.txt
+# — without it `typed-greet` silently de-registers) + grpcio (the runner speaks
+# gRPC). The builder stage's site-packages aren't copied into this stage, so
+# install against the requirements.txt copied above.
+RUN pip install --no-cache-dir -r requirements.txt 'grpcio>=1.60' 'grpcio-health-checking>=1.60'
+
+# HTTP port (informational /health) + gRPC port (the runner only speaks gRPC).
+EXPOSE 8080 10007
+
+ENV PORT=8080
+ENV HOST=0.0.0.0
+ENV GRPC_PORT=10007
+ENV VERSION=1.0.0
+
+HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
+  CMD python3 -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health')" || exit 1
+
+ENTRYPOINT ["python3", "bin/serve.py"]
+
+# Worker stage (NATS JetStream background jobs)
+FROM python:3.12-slim AS worker
+
+WORKDIR /app
+
+COPY --from=builder /app /app
+
+RUN pip install --no-cache-dir nats-py>=2.9.0
+
+EXPOSE 8080
+
+ENV PORT=8080
+ENV HOST=0.0.0.0
+ENV VERSION=1.0.0
+ENV NATS_SERVERS=localhost:4222
+ENV NATS_STREAM_NAME=blok-worker
+ENV WORKER_CONCURRENCY=1
+ENV WORKER_MAX_RETRIES=3
+ENV WORKER_ACK_WAIT_SECS=30
+
+HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
+  CMD python3 -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health')" || exit 1
+
+ENTRYPOINT ["python3", "bin/worker.py"]

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/python3/blok/__init__.py

@@ -0,0 +1,61 @@
+# Blok Blok Python3 SDK
+#
+# This SDK enables building workflow nodes that integrate with the Blok
+# orchestration framework. Nodes communicate via HTTP (POST /execute, GET /health)
+# and can be deployed as Docker containers.
+
+__version__ = "1.0.0"
+
+from blok.types.context import Context, Request, Response
+from blok.types.execution_request import ExecutionRequest, NodeConfig
+from blok.types.execution_result import ExecutionResult, ExecutionMetrics
+from blok.node.node_handler import NodeHandler
+from blok.node.node_registry import NodeRegistry
+from blok.server.runtime_server import RuntimeServer
+from blok.config.server_config import ServerConfig
+from blok.errors.blok_error import BlokError
+from blok.errors.node_error import NodeError, ErrorCategory
+from blok.logging.logger import Logger, LogLevel
+
+__all__ = [
+    "Context",
+    "Request",
+    "Response",
+    "ExecutionRequest",
+    "NodeConfig",
+    "ExecutionResult",
+    "ExecutionMetrics",
+    "NodeHandler",
+    "NodeRegistry",
+    "RuntimeServer",
+    "ServerConfig",
+    # Preferred structured error API (master plan §17).
+    "BlokError",
+    # Legacy error type — kept for back-compat.
+    "NodeError",
+    "ErrorCategory",
+    "Logger",
+    "LogLevel",
+]
+
+# Typed node authoring via @node (optional — requires pydantic). Legacy
+# Dict-based NodeHandler nodes keep working without pydantic installed.
+try:
+    from blok.node.define_node import (
+        FunctionNode,
+        node,
+        register_decorated,
+        registered_nodes,
+    )
+
+    __all__ += ["node", "FunctionNode", "register_decorated", "registered_nodes"]
+except ImportError:
+    pass
+
+# Worker (optional — requires nats-py)
+try:
+    from blok.worker import Worker, WorkerConfig, JobMessage, listen_and_serve_worker
+
+    __all__ += ["Worker", "WorkerConfig", "JobMessage", "listen_and_serve_worker"]
+except ImportError:
+    pass

package/dist/scaffold-repo/sdks/python3/blok/config/__init__.py

@@ -0,0 +1,3 @@
+from blok.config.server_config import ServerConfig
+
+__all__ = ["ServerConfig"]