arkitekt-next 0.7.36__py3-none-any.whl → 0.7.38__py3-none-any.whl

arkitekt_next/__blok__.py

@@ -14,6 +14,9 @@ from arkitekt_next.bloks.mount import MountBlok
 from arkitekt_next.bloks.internal_docker import InternalDockerBlok
 from arkitekt_next.bloks.socket import DockerSocketBlok
 from arkitekt_next.bloks.rekuest import RekuestBlok
+from arkitekt_next.bloks.tailscale import TailscaleBlok
+from arkitekt_next.bloks.secret import SecretBlok
+from arkitekt_next.bloks.namegen import PreformedNamesBlok
 
 
 def get_bloks():
@@ -34,4 +37,7 @@ def get_bloks():
         InternalDockerBlok(),
         DockerSocketBlok(),
         RekuestBlok(),
+        TailscaleBlok(),
+        SecretBlok(),
+        PreformedNamesBlok(),
     ]

arkitekt_next/bloks/arkitekt.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel
 from typing import Dict, Any
+from arkitekt_next.bloks.tailscale import TailscaleBlok
 from blok import blok, InitContext, Renderer, Panel
 from .livekit import LocalLiveKitBlok
 from .mikro import MikroBlok
@@ -29,7 +30,7 @@ class ArkitektBlok:
             )
         )
 
-    def preflight(self, lok: LocalLiveKitBlok, mikro: MikroBlok, kabinet: KabinetBlok, rekuest: RekuestBlok, fluss: FlussBlok, gateway: GatewayBlok, internal_engine: InternalDockerBlok):
+    def preflight(self, lok: LocalLiveKitBlok, mikro: MikroBlok, kabinet: KabinetBlok, rekuest: RekuestBlok, fluss: FlussBlok, gateway: GatewayBlok, internal_engine: InternalDockerBlok, scale: TailscaleBlok):
         print (lok, mikro, kabinet, rekuest, fluss, gateway, internal_engine)
 
 

arkitekt_next/bloks/fluss.py

@@ -58,13 +58,13 @@ class FlussBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
-            is_flag=True,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
-            is_flag=True,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/gateway.py

@@ -36,6 +36,15 @@ class GatewayBlok:
         self.public_ips = DEFAULT_PUBLIC_URLS
         self.public_hosts = DEFAULT_PUBLIC_HOSTS
 
+    def get_internal_host(self):
+        return "caddy"
+    
+    def get_https_port(self):
+        return 443
+    
+    def get_http_port(self):
+        return 80
+
     def preflight(self, init: InitContext, dns: DnsService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)

arkitekt_next/bloks/internal_docker.py

@@ -1,7 +1,11 @@
 from typing import Dict, Any
 import secrets
 
+from arkitekt_next.bloks.lok import LokBlok
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.socket import DockerSocketBlok
 from blok import blok, InitContext, ExecutionContext, Option
+from blok.bloks.services.dns import DnsService
 from blok.tree import YamlFile, Repo
 
 
@@ -9,16 +13,12 @@ from blok.tree import YamlFile, Repo
 class InternalDockerBlok:
     def __init__(self) -> None:
         self.host = "internal_docker"
-        self.command = (
-            "arkitekt-next run prod --redeem-token=mylittletoken --url http://caddy:80"
-        )
+        
         self.image = "jhnnsrs/deployer:0.0.1-vanilla"
         self.instance_id = "INTERNAL_DOCKER"
 
-    def get_dependencies(self):
-        return ["live.arkitekt.docker_socket"]
 
-    def preflight(self, init: InitContext):
+    def preflight(self, init: InitContext, gateway: GatewayService, lok: LokBlok, socket: DockerSocketBlok):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -27,7 +27,15 @@ class InternalDockerBlok:
         if self.skip:
             return
 
-        self._socket = deps["live.arkitekt.docker_socket"].register_socket(self.host)
+        self._socket = socket.register_socket(self.host)
+        self.gateway_host = gateway.get_internal_host()
+        self.gateway_port = gateway.get_http_port()
+
+        self.token = lok.retrieve_token()
+
+        self.command = (
+           f"arkitekt-next run prod --redeem-token={self.token} --url http://{self.gateway_host}:{self.gateway_port}"
+        )
 
         self.initialized = True
 
@@ -50,27 +58,21 @@ class InternalDockerBlok:
         context.docker_compose.set_nested("services", self.host, db_service)
 
     def get_options(self):
-        with_command = Option(
-            subcommand="command",
-            help="The fakts url for connection",
-            default=self.command,
-        )
         with_host = Option(
             subcommand="host",
-            help="The fakts url for connection",
+            help="The host of this service",
             default=self.host,
         )
         with_skip = Option(
             subcommand="skip",
-            help="The fakts url for connection",
+            help="Should we skip creating this service?",
             default=False,
             type=bool,
-            is_flag=True,
+           
         )
 
         return [
             with_host,
-            with_command,
             with_skip,
         ]
 

arkitekt_next/bloks/kabinet.py

@@ -57,13 +57,13 @@ class KabinetBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
-            is_flag=True,
+           type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
-            is_flag=True,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/livekit.py

@@ -77,7 +77,7 @@ class LocalLiveKitBlok:
             help="The fakts url for connection",
             default=False,
             type=bool,
-            is_flag=True,
+            
         )
 
         return [

arkitekt_next/bloks/lok.py

@@ -5,6 +5,7 @@ from cryptography.hazmat.primitives import serialization as crypto_serialization
 from cryptography.hazmat.primitives.asymmetric import rsa
 from cryptography.hazmat.backends import default_backend as crypto_default_backend
 from typing import Dict
+from arkitekt_next.bloks.secret import SecretBlok
 from arkitekt_next.bloks.services.admin import AdminService
 from arkitekt_next.bloks.services.db import DBService
 from arkitekt_next.bloks.services.gateway import GatewayService
@@ -145,15 +146,9 @@ class LokBlok:
             "accounts",
         ]
         self.token_expiry_seconds = 700000
+        self.preformed_redeem_tokens = [secrets.token_hex(16) for i in range(80)]
+        self.registered_tokens = {}
 
-    def get_dependencies(self):
-        return [
-            "io.livekit.livekit",
-            "live.arkitekt.postgres",
-            "live.arkitekt.redis",
-            "live.arkitekt.admin",
-            "live.arkitekt.gateway",
-        ]
 
     def retrieve_credentials(self) -> LokCredentials:
         return LokCredentials(
@@ -165,11 +160,17 @@ class LokBlok:
             f"fakts.service={service_name}",
             f"fakts.builder=arkitekt.{service_name}",
         ]
+    
+    def retrieve_token(self, user: str = "admin") -> str:
+        new_token = self.secret_blok.retrieve_secret()
+        self.registered_tokens[user] = new_token
+
+        return new_token
 
     def register_scopes(self, scopes_dict: Dict[str, str]) -> LokCredentials:
         self.scopes = self.scopes | scopes_dict
 
-    def preflight(self, init: InitContext, gateway: GatewayService, db: DBService, redis: RedisService, admin: AdminService, livekit: LivekitService, scopes: list[Dict[str, str]]):
+    def preflight(self, init: InitContext, gateway: GatewayService, db: DBService, redis: RedisService, admin: AdminService, secrets: SecretBlok, livekit: LivekitService, scopes: list[Dict[str, str]]):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
@@ -183,6 +184,7 @@ class LokBlok:
                 i, 80, self.host, strip_prefix=False
             )
 
+        self.secret_blok = secrets
         self.postgress_access = db.register_db(self.host)
         self.redis_access = redis.register()
         self.admin_access = admin.retrieve()
@@ -235,7 +237,7 @@ class LokBlok:
                 "private_key": self.private_key,
                 "public_key": self.public_key,
                 "scopes": self.scopes,
-                "redeem_tokens": [token for token in self.tokens],
+                "redeem_tokens": [token for token in self.registered_tokens],
                 "groups": [group for group in self.groups],
                 "deployment": {"name": self.deployment_name},
                 "livekit": asdict(self.local_access),
@@ -270,82 +272,82 @@ class LokBlok:
 
         with_fakts_url = Option(
             subcommand="db_name",
-            help="The fakts url for connection",
+            help="The name of the database",
             default="db_name",
+            show_default=True,
         )
         with_users = Option(
             subcommand="users",
-            help="The fakts url for connection",
+            help="Users that should be greated by default. Format is name:password",
             default=["admin:admin"],
             multiple=True,
             type=USER,
+            show_default=True,
         )
         with_groups = Option(
             subcommand="groups",
-            help="The fakts url for connection",
+            help="Groups that should be greated by default. Format is name:description",
             default=["admin:admin_group"],
             multiple=True,
             type=GROUP,
-        )
-        with_redeem_token = Option(
-            subcommand="tokens",
-            help="The fakts url for connection",
-            default=[],
-            multiple=True,
-            type=TOKEN,
+            show_default=True,
         )
         with_scopes = Option(
             subcommand="scopes",
-            help="The scopes",
+            help="Additional scopes that should be created (normally handled by the bloks)",
             default=[f"{key}:{value}" for key, value in self.scopes.items()],
             multiple=True,
             type=SCOPE,
         )
         with_repo = Option(
             subcommand="with_repo",
-            help="The fakts url for connection",
+            help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
             default=self.repo,
+            show_default=True,
         )
         with_repo = Option(
             subcommand="command",
-            help="The fakts url for connection",
+            help="Which command should be run when starting the service?",
             default=self.command,
+            show_default=True,
         )
         mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
-            is_flag=True,
+           type=bool,
             default=False,
         )
         build_repo = Option(
             subcommand="build_repo",
-            help="The fakts url for connection",
-            is_flag=True,
+            help="Should we build the container from the repo?",
+            type=bool,
             default=False,
+            show_default=True,
         )
         with_host = Option(
             subcommand="host",
-            help="The fakts url for connection",
+            help="Which internal hostname should be used",
             default=self.host,
+            show_default=True,
         )
         #
         with_public_key = Option(
             subcommand="public_key",
-            help="The fakts url for connection",
+            help="The public key for the JWT creation",
             default=public_key,
             required=True,
             callback=validate_public_key,
         )
         with_private_key = Option(
             subcommand="private_key",
-            help="The fakts url for connection",
+            help="The corresponding private key for the JWT creation",
             default=private_key,
             callback=validate_private_key,
             required=True,
         )
         with_secret_key = Option(
             subcommand="secret_key",
-            help="The fakts url for connection",
+            help="The secret key to use for the django service",
             default=self.secret_key,
         )
 
@@ -357,7 +359,6 @@ class LokBlok:
             with_groups,
             build_repo,
             with_host,
-            with_redeem_token,
             with_private_key,
             with_public_key,
             with_scopes,

arkitekt_next/bloks/mikro.py

@@ -23,7 +23,7 @@ class MikroBlok:
     def __init__(self) -> None:
         self.host = "mikro"
         self.command = "bash run-debug.sh"
-        self.repo = "https://github.com/jhnnsrs/mikro-server-next"
+        self.repo = "https://github.com/arkitektio/mikro-server-next"
         self.scopes = {"read_image": "Read image from the database"}
         self.image = "jhnnsrs/mikro:next"
         self.mount_repo = False
@@ -68,13 +68,13 @@ class MikroBlok:
         mount_repo = Option(
             subcommand="mount_repo",
             help="The fakts url for connection",
-            is_flag=True,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="The fakts url for connection",
-            is_flag=True,
+            type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/minio.py

@@ -1,5 +1,9 @@
 import click
 
+from arkitekt_next.bloks.services.config import ConfigService
+from arkitekt_next.bloks.services.gateway import GatewayService
+from arkitekt_next.bloks.services.name import NameService
+from arkitekt_next.bloks.services.secret import SecretService
 from blok import blok, InitContext, ExecutionContext, Option
 from blok.tree import YamlFile, Repo
 from pydantic import BaseModel
@@ -50,20 +54,16 @@ class MinioBlok:
         self.preformed_access_keys = [secrets.token_hex(16) for i in range(100)]
         self.preformed_secret_keys = [secrets.token_hex(16) for i in range(100)]
 
-    def get_identifier(self):
-        return "live.arkitekt.s3"
 
-    def get_dependencies(self):
-        return ["live.arkitekt.config", "live.arkitekt.gateway"]
 
     def create_buckets(self, buckets: list[str]) -> S3Credentials:
-        new_access_key = self.preformed_access_keys.pop()
-        new_secret_key = self.preformed_secret_keys.pop()
+        new_access_key = self.secret_service.retrieve_secret()
+        new_secret_key = self.secret_service.retrieve_secret()
 
         bucket_map = {}
 
         for bucket in buckets:
-            bucket_map[bucket] = self.preformed_bucket_names.pop()
+            bucket_map[bucket] = self.name_service.retrieve_name()
 
         self.buckets.extend(bucket_map.values())
 
@@ -81,19 +81,15 @@ class MinioBlok:
 
         return creds
 
-    def preflight(self, init: InitContext):
+    def preflight(self, init: InitContext, secret: SecretService, name: NameService, gateway: GatewayService, config: ConfigService):
         for key, value in init.kwargs.items():
             setattr(self, key, value)
 
-        self.preformed_bucket_names = list(
-            init.kwargs.get("preformed_bucket_names", [])
-        )
-        self.preformed_access_keys = list(init.kwargs.get("preformed_access_keys", []))
-        self.preformed_secret_keys = list(init.kwargs.get("preformed_secret_keys", []))
-
-        init.dependencies["live.arkitekt.gateway"].expose_default(9000, self.host)
+        gateway.expose_default(9000, self.host)
+        self.secret_service = secret
+        self.name_service = name
 
-        self.config_path = init.dependencies["live.arkitekt.config"].get_path(
+        self.config_path = config.get_path(
             self.host + ".yaml"
         )
 
@@ -151,30 +147,9 @@ class MinioBlok:
             help="The fakts url for connection",
             default=self.password,
         )
-        with_preformed_bucket_names = Option(
-            subcommand="preformed_bucket_names",
-            help="The fakts url for connection",
-            multiple=True,
-            default=self.preformed_bucket_names,
-        )
-        with_preformed_acces_key = Option(
-            subcommand="preformed_access_keys",
-            help="The fakts url for connection",
-            multiple=True,
-            default=self.preformed_access_keys,
-        )
-        with_preformed_secret_keys = Option(
-            subcommand="preformed_secret_keys",
-            help="The fakts url for connection",
-            multiple=True,
-            default=self.preformed_secret_keys,
-        )
 
         return [
             with_host,
             with_password,
             with_username,
-            with_preformed_bucket_names,
-            with_preformed_acces_key,
-            with_preformed_secret_keys,
         ]

arkitekt_next/bloks/namegen.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from arkitekt_next.bloks.services.name import NameService
+from blok import blok, InitContext, Option, ExecutionContext
+from blok.tree import YamlFile
+from arkitekt_next.bloks.services.secret import SecretService
+import secrets
+import namegenerator
+
+@blok(NameService)
+class PreformedNamesBlok:
+    def __init__(self) -> None:
+        self.preformed_names = [namegenerator.gen() for _ in range(100)]
+        self.used_names = []
+
+    def preflight(self, init: InitContext, preformed_names: list[str]):
+        self.preformed_names = list(preformed_names)
+        self.used_names = []
+
+    def retrieve_name(self) -> str:
+        name = self.preformed_names.pop()
+        self.used_names.append(name)
+        return name
+
+
+    def get_options(self):
+        config_path = Option(
+            subcommand="preformed_names",
+            help="A list of preformed names",
+            default=self.preformed_names,
+            multiple=True,
+        )
+
+        return [config_path]

arkitekt_next/bloks/redis.py

@@ -65,7 +65,7 @@ class RedisBlok:
         with_skip = Option(
             subcommand="skip",
             help="Skip docker creation (if using external redis?)",
-            is_flag=True,
+           type=bool,
             default=self.skip,
         )
         with_image = Option(

arkitekt_next/bloks/rekuest.py

@@ -47,23 +47,25 @@ class RekuestBlok:
         with_repo = Option(
             subcommand="with_repo",
             help="Which repo should we use when building the service? Only active if build_repo or mount_repo is active",
+            type=str,
             default=self.repo,
         )
         with_command = Option(
             subcommand="command",
             help="Which command should be run when starting the service",
+            type=str,
             default=self.command,
         )
         mount_repo = Option(
             subcommand="mount_repo",
             help="Should we mount the repo into the container?",
-            is_flag=True,
+            type=bool,
             default=self.mount_repo,
         )
         build_repo = Option(
             subcommand="build_repo",
             help="Should we build the container from the repo?",
-            is_flag=True,
+           type=bool,
             default=self.build_repo,
         )
         with_host = Option(

arkitekt_next/bloks/secret.py

@@ -0,0 +1,33 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from blok import blok, InitContext, Option, ExecutionContext
+from blok.tree import YamlFile
+from arkitekt_next.bloks.services.secret import SecretService
+import secrets
+
+@blok(SecretService)
+class SecretBlok:
+    def __init__(self) -> None:
+        self.preformed_secrets = [secrets.token_urlsafe(32) for _ in range(100)]
+        self.registered_secrets = []
+
+    def preflight(self, init: InitContext, preformed_secrets: list[str]):
+        self.preformed_secrets = list(preformed_secrets)
+
+    def retrieve_secret(self) -> str:
+        new_secret = self.preformed_secrets.pop()
+        self.registered_secrets.append(new_secret)
+        return new_secret
+
+
+
+    def get_options(self):
+        config_path = Option(
+            subcommand="preformed_secrets",
+            help="Which path to use for configs",
+            default=self.preformed_secrets,
+            multiple=True,
+            show_default=False,
+        )
+
+        return [config_path]

arkitekt_next/bloks/services/gateway.py

@@ -17,4 +17,14 @@ class GatewayService(Protocol):
 
     def expose_port(self, port: int, host: str, tls: bool = False):
         ...
+
+    def get_internal_host(self):
+        ...
+
+
+    def get_https_port(self):
+        ...
+
+    def get_http_port(self):
+        ...
     

arkitekt_next/bloks/services/name.py

@@ -0,0 +1,12 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+
+
+@service("live.arkitekt.names")
+class NameService(Protocol):
+
+    def retrieve_name(self) -> str:
+        pass

arkitekt_next/bloks/services/secret.py

@@ -0,0 +1,17 @@
+from typing import Dict, Any, Protocol
+from blok import blok, InitContext, Option
+from blok import service
+from dataclasses import dataclass
+
+@dataclass
+class AdminCredentials:
+    password: str
+    username: str
+    email: str
+
+
+@service("live.arkitekt.secrets")
+class SecretService(Protocol):
+
+    def retrieve_secret() -> str:
+        pass

arkitekt_next/bloks/tailscale.py

@@ -0,0 +1,68 @@
+from pydantic import BaseModel
+from typing import Dict, Any
+from arkitekt_next.bloks.services.mount import MountService
+from blok import blok, InitContext, Option, ExecutionContext
+from arkitekt_next.bloks.services.gateway import GatewayService
+from blok.bloks.services.dns import DnsService
+from blok.tree import YamlFile
+
+
+@blok("live.arkitekt.tailscale")
+class TailscaleBlok:
+
+    def __init__(self, name: str = "arkitekt") -> None:
+        self.name = name
+
+    def preflight(self, gateway: GatewayService, mount_service: MountService, dns: DnsService, net_name: str, auth_key: str, host_name: str):
+        assert auth_key, "You need to provide an auth_key"
+
+        self.caddy_service = gateway.get_internal_host()
+        self.caddy_port = gateway.get_http_port()
+        self.mount = mount_service.register_mount("tailscale_state", {})
+        self.tailnet_name = net_name
+        self.auth_key = auth_key
+        self.dns_service = dns.get_dns_result()
+        self.host_name = host_name
+
+    def build(self, ex: ExecutionContext):
+
+        if not self.tailnet_name:
+            # Trying to automatically find the hostname
+            for i in self.dns_service.hostnames:
+                if i.endswith(".ts.net"):
+                    self.tailnet_name = i.split(".")[1]
+                    break
+
+        service = {
+            "image": "jhnnsrs/tailproxy:latest",
+            "volumes": [
+                f"{self.mount}:/var/lib/tailscale" # Persist the tailscale state directory
+            ],
+            "environment": [
+                "TS_STATE_DIR=/var/lib/tailscale",
+                f"TS_AUTH_KEY={self.auth_key}",
+               f"TS_HOSTNAME={self.host_name}",
+                f"TS_TAILNET={self.tailnet_name}",
+                f"CADDY_TARGET={self.caddy_service}:{self.caddy_port}",
+            ],
+
+
+        }
+
+        ex.docker_compose.set_nested("services", "tailscale_proxy", service)
+
+    def get_options(self):
+        return [Option(
+            subcommand="net_name",
+            help="The name of your tailnet",
+            type=str,
+        ), Option(
+            subcommand="auth_key",
+            help="The auth_key of your tailnet",
+            type=str,
+        ),Option(
+            subcommand="host_name",
+            help="The hostname of your tailnet",
+            default=self.name,
+            type=str,
+        )]

{arkitekt_next-0.7.36.dist-info → arkitekt_next-0.7.38.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.7.36
+Version: 0.7.38
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -17,7 +17,7 @@ Provides-Extra: all
 Provides-Extra: cli
 Provides-Extra: server
 Requires-Dist: blok (>=0.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
-Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "server")
+Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
 Requires-Dist: dokker (>=0.1.21)
 Requires-Dist: fakts (>=0.5.0)
 Requires-Dist: fluss-next (>=0.1.69) ; extra == "all"
@@ -25,6 +25,7 @@ Requires-Dist: herre (>=0.4.3)
 Requires-Dist: kabinet (>=0.1.7) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
 Requires-Dist: koil (>=0.3.6)
 Requires-Dist: mikro-next (>=0.1.24) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: namegenerator (>=1.0.6) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
 Requires-Dist: netifaces (>=0.11.0) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all" or extra == "server")
 Requires-Dist: reaktion-next (>=0.1.59) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
 Requires-Dist: rekuest-next (>=0.2.13) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")

{arkitekt_next-0.7.36.dist-info → arkitekt_next-0.7.38.dist-info}/RECORD

@@ -1,4 +1,4 @@
-arkitekt_next/__blok__.py,sha256=k4ZLfVMDgdkGXHrG3ilX7G-siKG3g0wSzat-c6eMciw,1234
+arkitekt_next/__blok__.py,sha256=MednehD5TP0rhi4Y3JGOinwTVfja-0F-YliY2p83hkU,1476
 arkitekt_next/__init__.py,sha256=KFM_HlnIQWX7hXSZnYba3rdmZrsBE69K58rwh8ewxoM,970
 arkitekt_next/apps/__init__.py,sha256=cx_5Y-RkJFkSQJH-hUEC_L3eW1jU2E426c4e6_csIyM,42
 arkitekt_next/apps/easy.py,sha256=8eu-0DCWit2Ok4SPw_QCyriBZHPnLc1oK9qxPUxnElg,3135
@@ -14,33 +14,38 @@ arkitekt_next/apps/service/herre_qt.py,sha256=GntkKHmwcQqEFab02SWwdd3xONo0fLVGEP
 arkitekt_next/apps/types.py,sha256=cKRqHyKlNcGamPUxzvY0wyz0sEI4sBPa4CnvFnT1sTo,1140
 arkitekt_next/bloks/__init__.py,sha256=gXny6-WJ3alV1__xveI_0wcvgDuglR1WB7v7-8h1Olo,30
 arkitekt_next/bloks/admin.py,sha256=MlUQUYCHxCWtSD75mVHgs3DcDa0s8_D6_AIBslnYjZw,1300
-arkitekt_next/bloks/arkitekt.py,sha256=-ZITnWpkzpniUZQ7ZPjCH_RVqyCNPBtYnXWNTHd4eYw,1185
+arkitekt_next/bloks/arkitekt.py,sha256=1h2fyJK-TcuiOVFyE7iO2S1jwLv52APsQpfxddmHWjk,1263
 arkitekt_next/bloks/config.py,sha256=SqJg9kB0AQ62b_WpIKgJ8Jpcqpc-AKN7gdEj87O-UGY,1268
-arkitekt_next/bloks/fluss.py,sha256=0It4jxafGH-ehzXvd1eC9Tq9ZP4Kjra24eaHBCIaHJM,2820
+arkitekt_next/bloks/fluss.py,sha256=WXsE1M-0vDCVj5Fxi6MvHcPQiezkJPQ5GvUq93t4nt8,2814
 arkitekt_next/bloks/funcs.py,sha256=6QImH3eOSd6KXd8XfaulexAzy16A_J8GJi58Q18MQms,2641
-arkitekt_next/bloks/gateway.py,sha256=pym9pw8ycGgTzeskirkUZ19akvCitLabgQlU1r-wZdM,5021
-arkitekt_next/bloks/internal_docker.py,sha256=HWGgt4Jjr1ftEFwkYiw7m02eTiNAK5vaRYVtn0Jskd8,2255
-arkitekt_next/bloks/kabinet.py,sha256=ELGAkBQWarS5A-leTE2tXLgwrcXQBPz_FgLbMkYdJcU,3002
-arkitekt_next/bloks/livekit.py,sha256=Es0CJcQJJjyYD4OBa3_6K8bHmQRsikrECgnPflFCO4E,2694
-arkitekt_next/bloks/lok.py,sha256=7Fxk8U-hX7MgnIj1C1vGTA7yPBDTnqRLL31vPzAbEVE,11996
-arkitekt_next/bloks/mikro.py,sha256=A0Q3SkVpZYYp1nhQFiW6gCzv5D0h8fKm_p8KdoJauXI,2817
-arkitekt_next/bloks/minio.py,sha256=XkhApIyM7wwI1NPFBZWi5ES0grzDXPbe_RwEHCCxZcs,5823
+arkitekt_next/bloks/gateway.py,sha256=1seqZkU0yMai60JB0Rz1J--uNv21osiTVZVSjlusRjE,5184
+arkitekt_next/bloks/internal_docker.py,sha256=q9gPPtU1m0-0eeqF4zxtCELp4lF8TVZSJi1qVwnSWus,2421
+arkitekt_next/bloks/kabinet.py,sha256=gvoXeA4W6Aoc26wWK8nN9i6Gj5bxYE3by28MTLtJNyM,2995
+arkitekt_next/bloks/livekit.py,sha256=8_7YgsTnV3zZ_RonZZaOHyKkCoiKqLVv6-h74yGlB0A,2681
+arkitekt_next/bloks/lok.py,sha256=x1bu2b03sARVF4mxSBJzzdyCNJVx0feyhCz1qWjRRN4,12466
+arkitekt_next/bloks/mikro.py,sha256=x58fbw6INDfiRYwMRFYm8RIygmXoYj28gtn7mS6bEro,2814
+arkitekt_next/bloks/minio.py,sha256=6Mi1flePiwIA-durcRsQSE3OtCYwGzVLTJI7jHMrlgk,4918
 arkitekt_next/bloks/mount.py,sha256=d14w7bMiaWbl5wgvanh4PwfIqEYsDEsw91360xfX0fU,1031
+arkitekt_next/bloks/namegen.py,sha256=0k4PYya5J4EQyt3XZ3UKhDlO_k29pmUEQSaklZGN8MA,1035
 arkitekt_next/bloks/postgres.py,sha256=FRUF2fobUlU6OmK1VC7aN_WuX1NctLmZhzJJA1uOOeY,2773
-arkitekt_next/bloks/redis.py,sha256=XKuujfu1j85IZEab9ZG2m0G09g7Jba8o28q2PIBg_0I,2134
-arkitekt_next/bloks/rekuest.py,sha256=NfYbobDzlpTfPf88_-YwEDTwgOCg-OTLwiaWw5vssNU,3007
+arkitekt_next/bloks/redis.py,sha256=_ddmcD3WwX7VA7zzzQ7-yjSM7f4reV0C8Pl70s7R2k8,2130
+arkitekt_next/bloks/rekuest.py,sha256=_Er2mgiH0bQS62PWlGDolulpLkeYrQJ8TvQ2jqf6aOU,3044
+arkitekt_next/bloks/secret.py,sha256=P4Z56FhcgVD0KbokhcMNAXwDjo_86rI99nWh3gUGXSQ,1014
 arkitekt_next/bloks/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 arkitekt_next/bloks/services/admin.py,sha256=OXMAHph5lABNPFsXm8aboWffJ7CzSSNvke7xpmj9raI,463
 arkitekt_next/bloks/services/config.py,sha256=BLtbKXRRWmuZxvaaksuxt9EiDcazYwKL_IUIRhXBin8,393
 arkitekt_next/bloks/services/db.py,sha256=jMO751KJYjNmvHD0tOTWgkkemwTXc6mLHAge_i68JSA,600
-arkitekt_next/bloks/services/gateway.py,sha256=3tA1pS2vniVC3LhJ4O6chGRG6wUA44EPLAML4aiHm3k,530
+arkitekt_next/bloks/services/gateway.py,sha256=YUpz7qkqfOTXS74gU0C7s3o7MHe_9xQJHQLWg7aGhyc,662
 arkitekt_next/bloks/services/livekit.py,sha256=5u-GThgKsgXiiobEL4arm3JJOgNTZae15Q-75i-4D8g,366
 arkitekt_next/bloks/services/lok.py,sha256=OYC5BVr3MxeP8AuARO56UFL4490Yygcscdm5DQq-fVs,517
 arkitekt_next/bloks/services/mount.py,sha256=MDlwHl5cTfBO8IgkofuFjQBbfIMKDm_R9suWkiyVG48,289
+arkitekt_next/bloks/services/name.py,sha256=ZMDlZwnSaoIUj7STlpFo32nHKMuOibKzetYWSjh-t-c,254
 arkitekt_next/bloks/services/redis.py,sha256=d5cSk2v6A6CvYULocwd2Cnx9RkHKYHmZT1mZmZQNKgs,633
 arkitekt_next/bloks/services/s3.py,sha256=njXlLzUssj46w90bMdqO-7HSAVQtZHH2r1yVNlR-mfU,492
+arkitekt_next/bloks/services/secret.py,sha256=iUG1ZH_dR0tL48rueNOK2ILjEnyqNJjQCY-4KKrB_Zg,342
 arkitekt_next/bloks/services/socket.py,sha256=eXACQPldS9I1xGVDcbF6LrVkHHsBcjvG1VtlvHnM-14,427
 arkitekt_next/bloks/socket.py,sha256=YIrSKfQezrsKwRKDPdT1aXhlQzjgnx_UaNaQ9LiEfGY,1008
+arkitekt_next/bloks/tailscale.py,sha256=YXsiIxjqJV5WeQTO81yIa2Ajj40K-95X0cxH46Sq66c,2356
 arkitekt_next/builders.py,sha256=8HeQsNqyxpbFsnTrA9AAm0_BqxGjU1_ylS1Z-hbjAFw,6074
 arkitekt_next/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 arkitekt_next/cli/commands/call/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -140,8 +145,8 @@ arkitekt_next/qt/utils.py,sha256=MgBPtPmCSBkIuATov3UgREESwxAHh77lWNNxyE7Qs48,773
 arkitekt_next/service_registry.py,sha256=pczUuP_Nve7OYwB7-oDBLIw6bkjZPnzL3xFca5TF1io,3405
 arkitekt_next/tqdm.py,sha256=DlrxPluHao7TvW-Cqgt0UokRS-fM2_ZNiWiddqvCqCc,1488
 arkitekt_next/utils.py,sha256=gmKWy9M51vimohmmaoIpAJ0CaB22TFP0w3JszRrwiak,2379
-arkitekt_next-0.7.36.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
-arkitekt_next-0.7.36.dist-info/METADATA,sha256=AdGBXeVCXQPdWaVn5OPOJ_y-1RFMYVtuDcr2JceNMZ0,5901
-arkitekt_next-0.7.36.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-arkitekt_next-0.7.36.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
-arkitekt_next-0.7.36.dist-info/RECORD,,
+arkitekt_next-0.7.38.dist-info/LICENSE,sha256=YZ2oRjC248t-GpoEyw7J13vwKYNG6zhYMaEAix6EzF0,1089
+arkitekt_next-0.7.38.dist-info/METADATA,sha256=NJrnRs82cPUTEThfUuwjRUAm0W1lgcLoVqcT7FITWzQ,6055
+arkitekt_next-0.7.38.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+arkitekt_next-0.7.38.dist-info/entry_points.txt,sha256=-hxikQx4xZ6TiOnWVDOlTN_kcAISgGFvTHXIchsCHSc,60
+arkitekt_next-0.7.38.dist-info/RECORD,,