model-compose 0.4.12__tar.gz → 0.4.14__tar.gz

{model_compose-0.4.12/src/model_compose.egg-info → model_compose-0.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.12
+Version: 0.4.14
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT

{model_compose-0.4.12 → model_compose-0.4.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "model-compose"
-version = "0.4.12"
+version = "0.4.14"
 description = "model-compose: Declarative AI Workflow Orchestrator"
 authors = [
     { name = "Hanyeol Cho", email = "hanyeol.cho@gmail.com" }

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/core/gateway/gateway.py

@@ -22,4 +22,5 @@ def find_gateway_by_port(port: int) -> Optional[GatewayService]:
     for gateway in GatewayInstances.values():
         if gateway.serves_port(port):
             return gateway
+
     return None

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/core/gateway/services/http_tunnel/base.py

@@ -6,22 +6,33 @@ from mindor.core.logger import logging
 class CommonHttpTunnelGateway:
     def __init__(self, config: HttpTunnelGatewayConfig):
         self.config: HttpTunnelGatewayConfig = config
-        self.public_url: Optional[str] = None
+        self.public_urls = Optional[Dict[int, str]]
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return None
 
     async def serve(self) -> None:
-        self.public_url = await self._serve()
-        logging.info("HTTP tunnel started on port %d: %s", self.config.port, self.public_url)
+        self.public_urls = await self._serve()
+
+        for port, public_url in (self.public_urls or {}).items():
+            logging.info("HTTP tunnel started on port %d: %s", port, public_url)
 
     async def shutdown(self) -> None:
         await self._shutdown()
-        logging.info("HTTP tunnel stopped on port %d: %s", self.config.port, self.public_url)
-        self.public_url = None
+
+        for port, public_url in (self.public_urls or {}).items():
+            logging.info("HTTP tunnel stopped on port %d: %s", port, public_url)
+
+        self.public_urls = None
+
+    def get_public_url(self, port: int) -> Optional[str]:
+        if self.public_urls:
+            return self.public_urls.get(port)
+
+        return None
 
     @abstractmethod
-    async def _serve(self) -> str:
+    async def _serve(self) -> Optional[Dict[int, str]]:
         pass
 
     @abstractmethod

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/core/gateway/services/http_tunnel/drivers/ngrok.py

@@ -13,24 +13,29 @@ class NgrokHttpTunnelGateway(CommonHttpTunnelGateway):
     def __init__(self, config: HttpTunnelGatewayConfig):
         super().__init__(config)
 
-        self.tunnel: Optional[ngrok.NgrokTunnel] = None
+        self.tunnels: Optional[Dict[int, ngrok.NgrokTunnel]] = None
 
     def get_setup_requirements(self) -> Optional[List[str]]:
         return [ "pyngrok" ]
 
-    async def _serve(self) -> str:
+    async def _serve(self) -> Optional[Dict[int, str]]:
         from pyngrok import ngrok
 
-        self.tunnel = await asyncio.to_thread(
-            ngrok.connect,
-            addr=self.config.port,
-            bind_tls=True
-        )
-        return self.tunnel.public_url
+        self.tunnels = {}
+
+        for port in self.config.port:
+            self.tunnels[port] = await asyncio.to_thread(
+                ngrok.connect,
+                addr=port,
+                bind_tls=True
+            )
+        
+        return { port: tunnel.public_url for port, tunnel in self.tunnels.items() }
 
     async def _shutdown(self) -> None:
         from pyngrok import ngrok
 
-        if self.tunnel:
-            await asyncio.to_thread(ngrok.disconnect, self.tunnel.public_url)
-            self.tunnel = None
+        for tunnel in self.tunnels.values():
+            await asyncio.to_thread(ngrok.disconnect, tunnel.public_url)
+
+        self.tunnels = None

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/core/gateway/services/http_tunnel/http_tunnel.py

@@ -29,14 +29,18 @@ class HttpTunnelGateway(GatewayService):
         return self.driver.get_setup_requirements()
 
     def get_context(self, port: int) -> Optional[Dict[str, Any]]:
-        if port == self.config.port:
+        public_url = self.driver.get_public_url(port)
+
+        if public_url:
             return {
-                "public_url": self.driver.public_url
+                "driver": self.config.driver.value,
+                "public_url": public_url
             }
+
         return None
 
     def serves_port(self, port: int) -> bool:
-        return port == self.config.port
+        return bool(self.driver.get_public_url(port))
 
     async def _serve(self) -> None:
         await self.driver.serve()

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/core/gateway/services/ssh_tunnel.py

@@ -17,23 +17,22 @@ class SshTunnelGateway(GatewayService):
         super().__init__(id, config, daemon)
 
         self.client: Optional[SshClient] = None
-        self.local_ports: List[int] = []
-        self.remote_ports: List[int] = []
+        self.ports: Dict[int, int] = {}  # {local_port: remote_port}
         self._shutdown_event: Optional[asyncio.Event] = None
 
     def _get_setup_requirements(self) -> Optional[List[str]]:
         return [ "paramiko" ]
 
     def get_context(self, port: int) -> Optional[Dict[str, Any]]:
-        if port in self.local_ports:
-            index = self.local_ports.index(port)
+        remote_port = self.ports.get(port)
+        if remote_port is not None:
             return {
-                "public_address": f"{self.config.connection.host}:{self.remote_ports[index]}"
+                "public_address": f"{self.config.connection.host}:{remote_port}"
             }
         return None
 
     def serves_port(self, port: int) -> bool:
-        return port in self.local_ports
+        return port in self.ports
 
     async def _serve(self) -> None:
         """Establish SSH tunnel and start remote port forwarding"""
@@ -47,18 +46,17 @@ class SshTunnelGateway(GatewayService):
         await self.client.connect()
 
         # Start remote port forwarding for each port mapping
-        for remote_port, local_port in self.config.port:
+        for remote_port, local_host, local_port in self.config.port:
             actual_remote_port = await self.client.start_remote_port_forwarding(
                 remote_port=remote_port,
                 local_port=local_port,
-                local_host="localhost"
+                local_host=local_host
             )
 
-            self.local_ports.append(local_port)
-            self.remote_ports.append(actual_remote_port)
+            self.ports[local_port] = actual_remote_port
 
             logging.info(
-                f"Remote port forwarding started: {self.config.connection.host}:{remote_port} -> localhost:{local_port}"
+                f"Remote port forwarding started: {self.config.connection.host}:{remote_port} -> {local_host}:{local_port}"
             )
 
         # Keep the SSH connection alive until shutdown event is set
@@ -77,6 +75,5 @@ class SshTunnelGateway(GatewayService):
 
             await self.client.close()
             self.client = None
-            self.local_ports = []
-            self.remote_ports = []
+            self.ports = {}
             self._shutdown_event = None

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/core/utils/ssh_client.py

@@ -13,8 +13,8 @@ class SshClient:
     """SSH client with remote port forwarding support"""
     shared_instance: Optional["SshClient"] = None
 
-    def __init__(self, connection_config: SshConnectionConfig):
-        self.config: SshConnectionConfig = connection_config
+    def __init__(self, config: SshConnectionConfig):
+        self.config: SshConnectionConfig = config
         self.client: Optional[paramiko.SSHClient] = None
         self.transport: Optional[paramiko.Transport] = None
         self.port_forwards: List[Tuple[int, int]] = []
@@ -199,8 +199,8 @@ class SshClient:
         return self.client is not None and self.transport is not None and self.transport.is_active()
 
     @classmethod
-    def get_shared_instance(cls, connection_config: SshConnectionConfig) -> "SshClient":
+    def get_shared_instance(cls, config: SshConnectionConfig) -> "SshClient":
         """Get or create shared SSH client instance"""
         if not cls.shared_instance:
-            cls.shared_instance = SshClient(connection_config)
+            cls.shared_instance = SshClient(config)
         return cls.shared_instance

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/dsl/schema/gateway/impl/http_tunnel/impl/common.py

@@ -11,4 +11,12 @@ class HttpTunnelGatewayDriver(str, Enum):
 class CommonHttpTunnelGatewayConfig(CommonGatewayConfig):
     type: Literal[GatewayType.HTTP_TUNNEL]
     driver: HttpTunnelGatewayDriver = Field(..., description="HTTP tunneling service provider.")
-    port: int = Field(default=8090, ge=1, le=65535, description="Local port to tunnel through the gateway to the public.")
+    port: List[int] = Field(..., min_length=1, description="One or more local ports to tunnel through the gateway to the public.")
+    
+    @model_validator(mode="before")
+    def normalize_port(cls, values):
+        port = values.get("port", 8090)  # Default to 8090 if not specified
+        if not isinstance(port, list):
+            port = [ port ]
+        values["port"] = port
+        return values

{model_compose-0.4.12 → model_compose-0.4.14}/src/mindor/dsl/schema/gateway/impl/ssh_tunnel.py

@@ -7,20 +7,33 @@ from .common import GatewayType, CommonGatewayConfig
 class SshTunnelGatewayConfig(CommonGatewayConfig):
     type: Literal[GatewayType.SSH_TUNNEL]
     connection: SshConnectionConfig = Field(..., description="SSH connection configuration.")
-    port: List[Tuple[int, int]] = Field(..., min_length=1, description="One or more port forwarding configuration.")
+    port: List[Tuple[int, str, int]] = Field(..., min_length=1, description="One or more port forwarding configuration.")
 
     @model_validator(mode="before")
     def normalize_port(cls, values):
-        port = values.get("port")
+        port = values.get("port", 8090)  # Default to 8090 if not specified
         if not isinstance(port, list):
             port = [ port ]
         values["port"] = [ cls.normalize_single_port(value) for value in port ]
         return values
 
     @classmethod
-    def normalize_single_port(cls, value) -> Optional[Tuple[int, int]]:
+    def normalize_single_port(cls, value) -> Optional[Tuple[int, str, int]]:
         if isinstance(value, str):
-            return tuple(int(port) for port in value.split(":"))
+            parts = value.split(":")
+
+            if len(parts) == 2 and parts[0].isdigit():
+                if parts[1].isdigit():  # "8080:3000" (port:port)
+                    return (int(parts[0]), "localhost", int(parts[1]))
+                else:  # "8080:192.168.1.107" or "8080:example.com" (port:host)
+                    return (int(parts[0]), parts[1], int(parts[0]))
+
+            if len(parts) == 3:  # "8080:192.168.1.107:3000" (port:host:port)
+                return (int(parts[0]), parts[1], int(parts[2]))
+
+            return None
+
         if isinstance(value, int):
-            return ( value, value )
+            return (value, "localhost", value)
+
         return None

{model_compose-0.4.12 → model_compose-0.4.14/src/model_compose.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-compose
-Version: 0.4.12
+Version: 0.4.14
 Summary: model-compose: Declarative AI Workflow Orchestrator
 Author-email: Hanyeol Cho <hanyeol.cho@gmail.com>
 License-Expression: MIT