stackport 0.3.0__tar.gz → 0.3.1__tar.gz

{stackport-0.3.0/stackport.egg-info → stackport-0.3.1}/PKG-INFO

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

stackport-0.3.1/backend/routes/secretsmanager.py

@@ -0,0 +1,256 @@
+"""Secrets Manager service-specific routes."""
+
+import base64
+from typing import Any
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from backend.aws_client import get_client
+from backend.routes.common import EndpointInfo, get_endpoint_info
+from backend.schemas.secretsmanager import (
+    CreateSecretBody,
+    UpdateSecretMetadataBody,
+    UpdateSecretValueBody,
+)
+
+router = APIRouter()
+
+
+def _format_date(dt) -> str | None:
+    """Format a datetime to ISO string, or return None."""
+    if dt is None:
+        return None
+    try:
+        return dt.isoformat()
+    except Exception:
+        return str(dt)
+
+
+@router.get("/secrets")
+def list_secrets(ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """List all secrets with metadata."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+        paginator = client.get_paginator("list_secrets")
+
+        secrets = []
+        for page in paginator.paginate():
+            for secret in page.get("SecretList", []):
+                secrets.append(
+                    {
+                        "name": secret.get("Name"),
+                        "arn": secret.get("ARN"),
+                        "description": secret.get("Description", ""),
+                        "createdDate": _format_date(secret.get("CreatedDate")),
+                        "lastChangedDate": _format_date(
+                            secret.get("LastChangedDate")
+                        ),
+                        "lastAccessedDate": _format_date(
+                            secret.get("LastAccessedDate")
+                        ),
+                        "rotationEnabled": secret.get("RotationEnabled", False),
+                        "tags": {
+                            tag["Key"]: tag["Value"]
+                            for tag in secret.get("Tags", [])
+                        },
+                    }
+                )
+
+        return {"secrets": secrets}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/secrets/{secret_id:path}")
+def get_secret_detail(secret_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Get secret metadata and value."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        # Get metadata
+        try:
+            meta = client.describe_secret(SecretId=secret_id)
+        except client.exceptions.ResourceNotFoundException:
+            raise HTTPException(
+                status_code=404, detail=f"Secret '{secret_id}' not found"
+            )
+
+        # Get value
+        secret_value = None
+        secret_binary = None
+        version_id = None
+        version_stages = None
+        try:
+            value_resp = client.get_secret_value(SecretId=secret_id)
+            secret_value = value_resp.get("SecretString")
+            raw_binary = value_resp.get("SecretBinary")
+            if raw_binary is not None:
+                secret_binary = base64.b64encode(raw_binary).decode("utf-8")
+            version_id = value_resp.get("VersionId")
+            version_stages = value_resp.get("VersionStages")
+        except Exception:
+            # Value may not be retrievable (e.g., pending deletion)
+            pass
+
+        return {
+            "name": meta.get("Name"),
+            "arn": meta.get("ARN"),
+            "description": meta.get("Description", ""),
+            "createdDate": _format_date(meta.get("CreatedDate")),
+            "lastChangedDate": _format_date(meta.get("LastChangedDate")),
+            "lastAccessedDate": _format_date(meta.get("LastAccessedDate")),
+            "rotationEnabled": meta.get("RotationEnabled", False),
+            "rotationRules": meta.get("RotationRules"),
+            "rotationLambdaARN": meta.get("RotationLambdaARN"),
+            "deletedDate": _format_date(meta.get("DeletedDate")),
+            "tags": {
+                tag["Key"]: tag["Value"]
+                for tag in meta.get("Tags", [])
+            },
+            "versionId": version_id,
+            "versionStages": version_stages,
+            "secretValue": secret_value,
+            "secretBinary": secret_binary,
+        }
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/secrets", status_code=201)
+def create_secret(body: CreateSecretBody, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Create a new secret."""
+    if not body.secret_string and not body.secret_binary:
+        raise HTTPException(status_code=400, detail="Must provide either secret_string or secret_binary")
+
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        kwargs: dict[str, Any] = {"Name": body.name}
+        if body.description:
+            kwargs["Description"] = body.description
+        if body.secret_string:
+            kwargs["SecretString"] = body.secret_string
+        if body.secret_binary:
+            kwargs["SecretBinary"] = base64.b64decode(body.secret_binary)
+        if body.tags:
+            kwargs["Tags"] = [{"Key": k, "Value": v} for k, v in body.tags.items()]
+
+        resp = client.create_secret(**kwargs)
+        return {
+            "name": resp["Name"],
+            "arn": resp["ARN"],
+            "versionId": resp.get("VersionId"),
+        }
+    except client.exceptions.ResourceExistsException:
+        raise HTTPException(status_code=409, detail=f"Secret '{body.name}' already exists")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/secrets/{secret_id:path}/value")
+def update_secret_value(secret_id: str, body: UpdateSecretValueBody, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Update a secret's value."""
+    if not body.secret_string and not body.secret_binary:
+        raise HTTPException(status_code=400, detail="Must provide either secret_string or secret_binary")
+
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        kwargs: dict[str, Any] = {"SecretId": secret_id}
+        if body.secret_string:
+            kwargs["SecretString"] = body.secret_string
+        if body.secret_binary:
+            kwargs["SecretBinary"] = base64.b64decode(body.secret_binary)
+
+        resp = client.put_secret_value(**kwargs)
+        return {
+            "arn": resp["ARN"],
+            "name": resp["Name"],
+            "versionId": resp["VersionId"],
+            "versionStages": resp.get("VersionStages"),
+        }
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.put("/secrets/{secret_id:path}/metadata")
+def update_secret_metadata(secret_id: str, body: UpdateSecretMetadataBody, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Update a secret's description and/or tags."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        # Update description
+        if body.description is not None:
+            client.update_secret(SecretId=secret_id, Description=body.description)
+
+        # Update tags (replace all)
+        if body.tags is not None:
+            arn = client.describe_secret(SecretId=secret_id)["ARN"]
+            # Remove all existing tags first
+            existing_tags_resp = client.describe_secret(SecretId=secret_id)
+            existing_tag_keys = [tag["Key"] for tag in existing_tags_resp.get("Tags", [])]
+            if existing_tag_keys:
+                client.untag_resource(SecretId=arn, TagKeys=existing_tag_keys)
+            # Add new tags
+            if body.tags:
+                client.tag_resource(
+                    SecretId=arn,
+                    Tags=[{"Key": k, "Value": v} for k, v in body.tags.items()],
+                )
+
+        return {"success": True, "message": "Metadata updated"}
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/secrets/{secret_id:path}")
+def delete_secret(
+    secret_id: str,
+    force: bool = Query(False, description="Skip recovery window (immediate deletion)"),
+    ep: EndpointInfo = Depends(get_endpoint_info),
+) -> dict[str, Any]:
+    """Delete a secret."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+
+        kwargs: dict[str, Any] = {"SecretId": secret_id}
+        if force:
+            kwargs["ForceDeleteWithoutRecovery"] = True
+        else:
+            kwargs["RecoveryWindowInDays"] = 7
+
+        resp = client.delete_secret(**kwargs)
+        return {
+            "arn": resp["ARN"],
+            "name": resp["Name"],
+            "deletionDate": _format_date(resp.get("DeletionDate")),
+        }
+    except client.exceptions.ResourceNotFoundException:
+        raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/secrets/{secret_id:path}/restore")
+def restore_secret(secret_id: str, ep: EndpointInfo = Depends(get_endpoint_info)) -> dict[str, Any]:
+    """Restore a deleted secret."""
+    try:
+        client = get_client("secretsmanager", **ep.client_kwargs())
+        resp = client.restore_secret(SecretId=secret_id)
+        return {
+            "arn": resp["ARN"],
+            "name": resp["Name"],
+        }
+    except Exception as e:
+        error_code = getattr(e, "response", {}).get("Error", {}).get("Code", "")
+        if error_code == "ResourceNotFoundException":
+            raise HTTPException(status_code=404, detail=f"Secret '{secret_id}' not found")
+        elif error_code == "InvalidRequestException":
+            raise HTTPException(status_code=400, detail=str(e))
+        raise HTTPException(status_code=500, detail=str(e))

stackport-0.3.1/backend/schemas/secretsmanager.py

@@ -0,0 +1,33 @@
+"""Pydantic schemas for Secrets Manager API requests."""
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class CreateSecretBody(BaseModel):
+    """Request body for creating a new secret."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    name: str = Field(..., description="Secret name")
+    description: str | None = Field(None, description="Secret description")
+    secret_string: str | None = Field(None, alias="secretString", description="Secret value as string")
+    secret_binary: str | None = Field(None, alias="secretBinary", description="Secret value as base64-encoded binary")
+    tags: dict[str, str] = Field(default_factory=dict, description="Resource tags")
+
+
+class UpdateSecretValueBody(BaseModel):
+    """Request body for updating a secret's value."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    secret_string: str | None = Field(None, alias="secretString", description="New secret value as string")
+    secret_binary: str | None = Field(None, alias="secretBinary", description="New secret value as base64-encoded binary")
+
+
+class UpdateSecretMetadataBody(BaseModel):
+    """Request body for updating a secret's metadata."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    description: str | None = Field(None, description="New description")
+    tags: dict[str, str] | None = Field(None, description="New tags (replaces existing)")

{stackport-0.3.0 → stackport-0.3.1}/pyproject.toml

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

{stackport-0.3.0 → stackport-0.3.1/stackport.egg-info}/PKG-INFO

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

{stackport-0.3.0 → stackport-0.3.1}/stackport.egg-info/SOURCES.txt

@@ -13,8 +13,8 @@ backend/websocket.py
 backend/../ui/dist/favicon.png
 backend/../ui/dist/favicon.svg
 backend/../ui/dist/index.html
-backend/../ui/dist/assets/index-Cda_0qu5.css
-backend/../ui/dist/assets/index-tW-8e4eS.js
+backend/../ui/dist/assets/index-CAZXHF4B.js
+backend/../ui/dist/assets/index-DLd-xBZq.css
 backend/../ui/dist/aws-icons/acm.svg
 backend/../ui/dist/aws-icons/apigateway.svg
 backend/../ui/dist/aws-icons/appsync.svg
@@ -67,6 +67,7 @@ backend/schemas/__init__.py
 backend/schemas/dynamodb.py
 backend/schemas/endpoints.py
 backend/schemas/s3.py
+backend/schemas/secretsmanager.py
 backend/schemas/sqs.py
 backend/schemas/tags.py
 stackport.egg-info/PKG-INFO
@@ -99,8 +100,8 @@ tests/test_websocket.py
 ui/dist/favicon.png
 ui/dist/favicon.svg
 ui/dist/index.html
-ui/dist/assets/index-Cda_0qu5.css
-ui/dist/assets/index-tW-8e4eS.js
+ui/dist/assets/index-CAZXHF4B.js
+ui/dist/assets/index-DLd-xBZq.css
 ui/dist/aws-icons/acm.svg
 ui/dist/aws-icons/apigateway.svg
 ui/dist/aws-icons/appsync.svg

{stackport-0.3.0 → stackport-0.3.1}/tests/test_secretsmanager_routes.py

@@ -279,3 +279,230 @@ class TestGetSecretDetail:
         assert resp.status_code == 200
         data = resp.json()
         assert data["secretValue"] == "sk-abc123def456"
+
+
+class TestCreateSecret:
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_create_secret_with_string(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.create_secret.return_value = {
+            "Name": "test-secret",
+            "ARN": "arn:aws:secretsmanager:us-east-1:000:secret:test-secret-abc",
+            "VersionId": "v1",
+        }
+
+        resp = client.post(
+            "/api/secretsmanager/secrets",
+            json={
+                "name": "test-secret",
+                "description": "Test secret",
+                "secret_string": "my-secret-value",
+                "tags": {"env": "test"},
+            },
+        )
+        assert resp.status_code == 201
+        data = resp.json()
+        assert data["name"] == "test-secret"
+        assert data["arn"] == "arn:aws:secretsmanager:us-east-1:000:secret:test-secret-abc"
+        assert data["versionId"] == "v1"
+
+        mock_sm.create_secret.assert_called_once()
+        call_kwargs = mock_sm.create_secret.call_args[1]
+        assert call_kwargs["Name"] == "test-secret"
+        assert call_kwargs["Description"] == "Test secret"
+        assert call_kwargs["SecretString"] == "my-secret-value"
+        assert call_kwargs["Tags"] == [{"Key": "env", "Value": "test"}]
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_create_secret_with_binary(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.create_secret.return_value = {
+            "Name": "binary-secret",
+            "ARN": "arn:binary",
+            "VersionId": "v1",
+        }
+
+        import base64
+        binary_data = base64.b64encode(b"\x00\x01\x02").decode("utf-8")
+
+        resp = client.post(
+            "/api/secretsmanager/secrets",
+            json={"name": "binary-secret", "secret_binary": binary_data},
+        )
+        assert resp.status_code == 201
+
+        call_kwargs = mock_sm.create_secret.call_args[1]
+        assert call_kwargs["SecretBinary"] == b"\x00\x01\x02"
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_create_secret_duplicate_name(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.exceptions.ResourceExistsException = type(
+            "ResourceExistsException", (Exception,), {}
+        )
+        mock_sm.create_secret.side_effect = mock_sm.exceptions.ResourceExistsException()
+
+        resp = client.post(
+            "/api/secretsmanager/secrets",
+            json={"name": "existing", "secret_string": "value"},
+        )
+        assert resp.status_code == 409
+        assert "already exists" in resp.json()["detail"]
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_create_secret_no_value(self, mock_get_client):
+        resp = client.post(
+            "/api/secretsmanager/secrets",
+            json={"name": "test"},
+        )
+        assert resp.status_code == 400
+        assert "secret_string or secret_binary" in resp.json()["detail"]
+
+
+class TestUpdateSecretValue:
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_update_secret_value(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.put_secret_value.return_value = {
+            "ARN": "arn:test",
+            "Name": "test-secret",
+            "VersionId": "v2",
+            "VersionStages": ["AWSCURRENT"],
+        }
+
+        resp = client.put(
+            "/api/secretsmanager/secrets/test-secret/value",
+            json={"secret_string": "new-value"},
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["name"] == "test-secret"
+        assert data["versionId"] == "v2"
+
+        mock_sm.put_secret_value.assert_called_once()
+        call_kwargs = mock_sm.put_secret_value.call_args[1]
+        assert call_kwargs["SecretId"] == "test-secret"
+        assert call_kwargs["SecretString"] == "new-value"
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_update_secret_value_not_found(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.exceptions.ResourceNotFoundException = type(
+            "ResourceNotFoundException", (Exception,), {}
+        )
+        mock_sm.put_secret_value.side_effect = (
+            mock_sm.exceptions.ResourceNotFoundException()
+        )
+
+        resp = client.put(
+            "/api/secretsmanager/secrets/nonexistent/value",
+            json={"secret_string": "value"},
+        )
+        assert resp.status_code == 404
+
+
+class TestUpdateSecretMetadata:
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_update_description(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+
+        resp = client.put(
+            "/api/secretsmanager/secrets/test-secret/metadata",
+            json={"description": "New description"},
+        )
+        assert resp.status_code == 200
+        mock_sm.update_secret.assert_called_once_with(
+            SecretId="test-secret", Description="New description"
+        )
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_update_tags(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.describe_secret.return_value = {
+            "ARN": "arn:test",
+            "Tags": [{"Key": "old", "Value": "tag"}],
+        }
+
+        resp = client.put(
+            "/api/secretsmanager/secrets/test-secret/metadata",
+            json={"tags": {"new": "tag"}},
+        )
+        assert resp.status_code == 200
+        mock_sm.untag_resource.assert_called_once()
+        mock_sm.tag_resource.assert_called_once()
+
+
+class TestDeleteSecret:
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_delete_secret_with_recovery(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.delete_secret.return_value = {
+            "ARN": "arn:test",
+            "Name": "test-secret",
+            "DeletionDate": CHANGED,
+        }
+
+        resp = client.delete("/api/secretsmanager/secrets/test-secret")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["name"] == "test-secret"
+        assert data["deletionDate"] == CHANGED.isoformat()
+
+        call_kwargs = mock_sm.delete_secret.call_args[1]
+        assert call_kwargs["RecoveryWindowInDays"] == 7
+        assert "ForceDeleteWithoutRecovery" not in call_kwargs
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_delete_secret_force(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.delete_secret.return_value = {
+            "ARN": "arn:test",
+            "Name": "test-secret",
+            "DeletionDate": CHANGED,
+        }
+
+        resp = client.delete("/api/secretsmanager/secrets/test-secret?force=true")
+        assert resp.status_code == 200
+
+        call_kwargs = mock_sm.delete_secret.call_args[1]
+        assert call_kwargs["ForceDeleteWithoutRecovery"] is True
+        assert "RecoveryWindowInDays" not in call_kwargs
+
+
+class TestRestoreSecret:
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_restore_secret(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+        mock_sm.restore_secret.return_value = {
+            "ARN": "arn:test",
+            "Name": "test-secret",
+        }
+
+        resp = client.post("/api/secretsmanager/secrets/test-secret/restore")
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["name"] == "test-secret"
+
+    @patch("backend.routes.secretsmanager.get_client")
+    def test_restore_secret_not_deleted(self, mock_get_client):
+        mock_sm = MagicMock()
+        mock_get_client.return_value = mock_sm
+
+        error = Exception("Invalid request")
+        error.response = {
+            "Error": {"Code": "InvalidRequestException", "Message": "Secret not in deleted state"}
+        }
+        mock_sm.restore_secret.side_effect = error
+
+        resp = client.post("/api/secretsmanager/secrets/test-secret/restore")
+        assert resp.status_code == 400