stackport 0.3.6__tar.gz → 0.3.7__tar.gz

{stackport-0.3.6/stackport.egg-info → stackport-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.3.6
+Version: 0.3.7
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT

{stackport-0.3.6 → stackport-0.3.7}/backend/routes/ec2.py

@@ -301,6 +301,162 @@ def list_security_groups(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[
         raise HTTPException(status_code=500, detail=str(e))
 
 
+def _get_rule_id(rule: dict, rule_type: str, idx: int) -> str:
+    """Generate a rule ID based on rule properties."""
+    return f"{rule_type}-sgrule-{idx:04d}"
+
+
+def _get_ip_version(ip_range: dict | None, ipv6_range: dict | None) -> str:
+    """Determine IP version from rule."""
+    if ipv6_range:
+        return "IPv6"
+    if ip_range:
+        cidr = ip_range.get("CidrIp", "")
+        return "IPv6" if ":" in cidr else "IPv4"
+    return "IPv4"
+
+
+def _format_port_range(protocol: str, from_port: int | None, to_port: int | None) -> str:
+    """Format port range for display."""
+    if protocol == "-1" or protocol == "all":
+        return "All"
+    if from_port is None and to_port is None:
+        return "All"
+    if from_port is not None and to_port is not None and from_port != to_port:
+        return f"{from_port}-{to_port}"
+    if from_port is not None:
+        return str(from_port)
+    return "All"
+
+
+def _expand_rules(ip_permissions: list[dict], rule_type: str) -> list[dict]:
+    """Expand IP permissions into individual rule rows."""
+    expanded = []
+    rule_idx = 0
+    
+    for perm in ip_permissions:
+        protocol = perm.get("IpProtocol", "tcp")
+        from_port = perm.get("FromPort")
+        to_port = perm.get("ToPort")
+        
+        # Normalize protocol display
+        if protocol == "-1":
+            protocol = "All"
+        
+        # Expand IPv4 ranges
+        for ip_range in perm.get("IpRanges", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv4",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": ip_range.get("CidrIp", ""),
+                "description": ip_range.get("Description", ""),
+            })
+            rule_idx += 1
+        
+        # Expand IPv6 ranges
+        for ipv6_range in perm.get("Ipv6Ranges", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv6",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": ipv6_range.get("CidrIpv6", ""),
+                "description": ipv6_range.get("Description", ""),
+            })
+            rule_idx += 1
+        
+        # Expand prefix list IDs
+        for prefix_list in perm.get("PrefixListIds", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv4",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": prefix_list.get("PrefixListId", ""),
+                "description": "",
+            })
+            rule_idx += 1
+        
+        # Expand user ID group pairs (security group references)
+        for group_pair in perm.get("UserIdGroupPairs", []):
+            expanded.append({
+                "ruleId": _get_rule_id(perm, rule_type, rule_idx),
+                "ipVersion": "IPv4",
+                "type": rule_type.capitalize(),
+                "protocol": protocol,
+                "portRange": _format_port_range(protocol, from_port, to_port),
+                "source": group_pair.get("GroupId", "") or group_pair.get("GroupName", ""),
+                "description": group_pair.get("Description", ""),
+            })
+            rule_idx += 1
+    
+    # If no rules found, return empty list (don't add placeholder)
+    return expanded
+
+
+@router.get("/security-groups/{group_id}/inbound")
+def get_security_group_inbound_rules(group_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get inbound rules for a specific security group with detailed rule information."""
+    try:
+        client = get_client("ec2", **ep.client_kwargs())
+        response = client.describe_security_groups(GroupIds=[group_id])
+
+        if not response.get("SecurityGroups"):
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+
+        sg = response["SecurityGroups"][0]
+        inbound_rules = _expand_rules(sg.get("IpPermissions", []), "inbound")
+
+        return {
+            "groupId": group_id,
+            "groupName": sg["GroupName"],
+            "inboundRules": inbound_rules,
+        }
+    except HTTPException:
+        raise
+    except client.exceptions.ClientError as e:
+        error_code = e.response["Error"]["Code"]
+        if error_code == "InvalidGroupId.NotFound":
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/security-groups/{group_id}/outbound")
+def get_security_group_outbound_rules(group_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get outbound rules for a specific security group with detailed rule information."""
+    try:
+        client = get_client("ec2", **ep.client_kwargs())
+        response = client.describe_security_groups(GroupIds=[group_id])
+
+        if not response.get("SecurityGroups"):
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+
+        sg = response["SecurityGroups"][0]
+        outbound_rules = _expand_rules(sg.get("IpPermissionsEgress", []), "outbound")
+
+        return {
+            "groupId": group_id,
+            "groupName": sg["GroupName"],
+            "outboundRules": outbound_rules,
+        }
+    except HTTPException:
+        raise
+    except client.exceptions.ClientError as e:
+        error_code = e.response["Error"]["Code"]
+        if error_code == "InvalidGroupId.NotFound":
+            raise HTTPException(status_code=404, detail=f"Security group {group_id} not found")
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 @router.get("/vpcs")
 def list_vpcs(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
     """List all VPCs with their subnets."""

{stackport-0.3.6 → stackport-0.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stackport"
-version = "0.3.6"
+version = "0.3.7"
 description = "Universal AWS resource browser for local emulators"
 readme = "README.md"
 license = {text = "MIT"}

{stackport-0.3.6 → stackport-0.3.7/stackport.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stackport
-Version: 0.3.6
+Version: 0.3.7
 Summary: Universal AWS resource browser for local emulators
 Author: Davi Reis Vieira
 License: MIT

{stackport-0.3.6 → stackport-0.3.7}/stackport.egg-info/SOURCES.txt

@@ -13,9 +13,9 @@ backend/websocket.py
 backend/../ui/dist/favicon.png
 backend/../ui/dist/favicon.svg
 backend/../ui/dist/index.html
-backend/../ui/dist/assets/StateMachineGraph-DnspmX4c.js
-backend/../ui/dist/assets/index-BoJK2una.css
-backend/../ui/dist/assets/index-CVBAWnD3.js
+backend/../ui/dist/assets/StateMachineGraph-C3a2WdTx.js
+backend/../ui/dist/assets/index-B-seC0pm.js
+backend/../ui/dist/assets/index-BZr5kWvs.css
 backend/../ui/dist/assets/stepfunctions-graph-B6nvU4OB.js
 backend/../ui/dist/aws-icons/acm.svg
 backend/../ui/dist/aws-icons/apigateway.svg
@@ -107,9 +107,9 @@ tests/test_websocket.py
 ui/dist/favicon.png
 ui/dist/favicon.svg
 ui/dist/index.html
-ui/dist/assets/StateMachineGraph-DnspmX4c.js
-ui/dist/assets/index-BoJK2una.css
-ui/dist/assets/index-CVBAWnD3.js
+ui/dist/assets/StateMachineGraph-C3a2WdTx.js
+ui/dist/assets/index-B-seC0pm.js
+ui/dist/assets/index-BZr5kWvs.css
 ui/dist/assets/stepfunctions-graph-B6nvU4OB.js
 ui/dist/aws-icons/acm.svg
 ui/dist/aws-icons/apigateway.svg

{stackport-0.3.6 → stackport-0.3.7}/tests/test_ec2_routes.py

@@ -362,3 +362,276 @@ class TestListAutoscalingGroups:
         assert instance["lifecycleState"] == "InService"
         assert instance["healthStatus"] == "Healthy"
         assert instance["availabilityZone"] == "us-east-1a"
+
+
+class TestGetSecurityGroupInboundRules:
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_inbound_rules(self, mock_get_client):
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {
+            "SecurityGroups": [
+                {
+                    "GroupId": "sg-123456",
+                    "GroupName": "web-sg",
+                    "Description": "Web security group",
+                    "VpcId": "vpc-abc123",
+                    "IpPermissions": [
+                        {
+                            "IpProtocol": "tcp",
+                            "FromPort": 80,
+                            "ToPort": 80,
+                            "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "HTTP access"}],
+                        },
+                        {
+                            "IpProtocol": "tcp",
+                            "FromPort": 443,
+                            "ToPort": 443,
+                            "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "HTTPS access"}],
+                        },
+                        {
+                            "IpProtocol": "tcp",
+                            "FromPort": 22,
+                            "ToPort": 22,
+                            "IpRanges": [{"CidrIp": "10.0.0.0/8", "Description": "SSH access"}],
+                        },
+                    ],
+                    "IpPermissionsEgress": [],
+                    "Tags": [],
+                }
+            ]
+        }
+
+        resp = client.get("/api/ec2/security-groups/sg-123456/inbound")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["groupId"] == "sg-123456"
+        assert data["groupName"] == "web-sg"
+        assert len(data["inboundRules"]) == 3
+        rule = data["inboundRules"][0]
+        assert rule["ruleId"].startswith("inbound-sgrule-")
+        assert rule["protocol"] == "tcp"
+        assert rule["portRange"] == "80"
+        assert rule["ipVersion"] == "IPv4"
+        assert rule["type"] == "Inbound"
+        assert rule["source"] == "0.0.0.0/0"
+        assert rule["description"] == "HTTP access"
+
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_inbound_rules_not_found(self, mock_get_client):
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {"SecurityGroups": []}
+
+        resp = client.get("/api/ec2/security-groups/sg-nonexistent/inbound")
+        assert resp.status_code == 404
+
+
+class TestGetSecurityGroupOutboundRules:
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_outbound_rules(self, mock_get_client):
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {
+            "SecurityGroups": [
+                {
+                    "GroupId": "sg-123456",
+                    "GroupName": "web-sg",
+                    "Description": "Web security group",
+                    "VpcId": "vpc-abc123",
+                    "IpPermissions": [],
+                    "IpPermissionsEgress": [
+                        {
+                            "IpProtocol": "tcp",
+                            "FromPort": 443,
+                            "ToPort": 443,
+                            "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "HTTPS outbound"}],
+                        },
+                        {
+                            "IpProtocol": "tcp",
+                            "FromPort": 80,
+                            "ToPort": 80,
+                            "IpRanges": [{"CidrIp": "0.0.0.0/0", "Description": "HTTP outbound"}],
+                        },
+                    ],
+                    "Tags": [],
+                }
+            ]
+        }
+
+        resp = client.get("/api/ec2/security-groups/sg-123456/outbound")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["groupId"] == "sg-123456"
+        assert data["groupName"] == "web-sg"
+        assert len(data["outboundRules"]) == 2
+        rule = data["outboundRules"][0]
+        assert rule["ruleId"].startswith("outbound-sgrule-")
+        assert rule["protocol"] == "tcp"
+        assert rule["portRange"] == "443"
+        assert rule["ipVersion"] == "IPv4"
+        assert rule["type"] == "Outbound"
+        assert rule["source"] == "0.0.0.0/0"
+        assert rule["description"] == "HTTPS outbound"
+
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_outbound_rules_not_found(self, mock_get_client):
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {"SecurityGroups": []}
+
+        resp = client.get("/api/ec2/security-groups/sg-nonexistent/outbound")
+        assert resp.status_code == 404
+
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_outbound_rules_empty(self, mock_get_client):
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {
+            "SecurityGroups": [
+                {
+                    "GroupId": "sg-123456",
+                    "GroupName": "empty-sg",
+                    "Description": "Empty security group",
+                    "VpcId": "vpc-abc123",
+                    "IpPermissions": [],
+                    "IpPermissionsEgress": [],
+                    "Tags": [],
+                }
+            ]
+        }
+
+        resp = client.get("/api/ec2/security-groups/sg-123456/outbound")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["groupId"] == "sg-123456"
+        assert data["groupName"] == "empty-sg"
+        assert len(data["outboundRules"]) == 0
+
+
+class TestGetSecurityGroupInboundRulesProtocolAll:
+    """Test handling of protocol -1 (all traffic)."""
+
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_inbound_rules_protocol_all(self, mock_get_client):
+        """Test that protocol -1 is converted to 'All' and port range shows 'All'."""
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {
+            "SecurityGroups": [
+                {
+                    "GroupId": "sg-123456",
+                    "GroupName": "ecs-tasks-sg",
+                    "Description": "ECS tasks security group",
+                    "VpcId": "vpc-abc123",
+                    "IpPermissions": [
+                        {
+                            "IpProtocol": "-1",
+                            "FromPort": None,
+                            "ToPort": None,
+                            "IpRanges": [{"CidrIp": "10.1.0.0/16", "Description": "VPC traffic"}],
+                        },
+                    ],
+                    "IpPermissionsEgress": [],
+                    "Tags": [],
+                }
+            ]
+        }
+
+        resp = client.get("/api/ec2/security-groups/sg-123456/inbound")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["groupId"] == "sg-123456"
+        assert data["groupName"] == "ecs-tasks-sg"
+        assert len(data["inboundRules"]) == 1
+        rule = data["inboundRules"][0]
+        assert rule["ruleId"].startswith("inbound-sgrule-")
+        assert rule["protocol"] == "All"
+        assert rule["portRange"] == "All"
+        assert rule["ipVersion"] == "IPv4"
+        assert rule["type"] == "Inbound"
+        assert rule["source"] == "10.1.0.0/16"
+        assert rule["description"] == "VPC traffic"
+
+
+class TestGetSecurityGroupOutboundRulesProtocolAll:
+    """Test handling of protocol -1 (all traffic) for outbound rules."""
+
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_outbound_rules_protocol_all(self, mock_get_client):
+        """Test that protocol -1 is converted to 'All' and port range shows 'All' for outbound."""
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {
+            "SecurityGroups": [
+                {
+                    "GroupId": "sg-00220f1150c89205a",
+                    "GroupName": "web-saas-development-ecs-tasks-sg",
+                    "Description": "ECS tasks security group",
+                    "VpcId": "vpc-abc123",
+                    "IpPermissions": [],
+                    "IpPermissionsEgress": [
+                        {
+                            "IpProtocol": "-1",
+                            "FromPort": None,
+                            "ToPort": None,
+                            "IpRanges": [{"CidrIp": "0.0.0.0/0"}],
+                        },
+                    ],
+                    "Tags": [],
+                }
+            ]
+        }
+
+        resp = client.get("/api/ec2/security-groups/sg-00220f1150c89205a/outbound")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["groupId"] == "sg-00220f1150c89205a"
+        assert data["groupName"] == "web-saas-development-ecs-tasks-sg"
+        assert len(data["outboundRules"]) == 1
+        rule = data["outboundRules"][0]
+        assert rule["ruleId"].startswith("outbound-sgrule-")
+        assert rule["protocol"] == "All"
+        assert rule["portRange"] == "All"
+        assert rule["ipVersion"] == "IPv4"
+        assert rule["type"] == "Outbound"
+        assert rule["source"] == "0.0.0.0/0"
+
+
+class TestSecurityGroupRulesPortRanges:
+    """Test handling of port ranges."""
+
+    @patch("backend.routes.ec2.get_client")
+    def test_get_security_group_port_range(self, mock_get_client):
+        """Test that port ranges are formatted correctly."""
+        mock_ec2 = MagicMock()
+        mock_get_client.return_value = mock_ec2
+        mock_ec2.describe_security_groups.return_value = {
+            "SecurityGroups": [
+                {
+                    "GroupId": "sg-123456",
+                    "GroupName": "port-range-sg",
+                    "Description": "Security group with port range",
+                    "VpcId": "vpc-abc123",
+                    "IpPermissions": [
+                        {
+                            "IpProtocol": "tcp",
+                            "FromPort": 8000,
+                            "ToPort": 9000,
+                            "IpRanges": [{"CidrIp": "10.0.0.0/8"}],
+                        },
+                    ],
+                    "IpPermissionsEgress": [],
+                    "Tags": [],
+                }
+            ]
+        }
+
+        resp = client.get("/api/ec2/security-groups/sg-123456/inbound")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert len(data["inboundRules"]) == 1
+        rule = data["inboundRules"][0]
+        assert rule["protocol"] == "tcp"
+        assert rule["portRange"] == "8000-9000"
+        assert rule["source"] == "10.0.0.0/8"

stackport-0.3.6/ui/dist/assets/StateMachineGraph-DnspmX4c.js → stackport-0.3.7/ui/dist/assets/StateMachineGraph-C3a2WdTx.js

@@ -1,4 +1,4 @@
-import{c as L,C as z,a as O,b as Y,G as J,j as n,r as m,B as j}from"./index-CVBAWnD3.js";import{T as B}from"./stepfunctions-graph-B6nvU4OB.js";/**
+import{c as L,C as z,a as O,b as Y,G as J,j as n,r as m,B as j}from"./index-B-seC0pm.js";import{T as B}from"./stepfunctions-graph-B6nvU4OB.js";/**
  * @license lucide-react v1.7.0 - ISC
  *
  * This source code is licensed under the ISC license.