stackport 0.1.0__py3-none-any.whl

backend/aws_client.py

@@ -0,0 +1,22 @@
+import functools
+
+import boto3
+
+from backend.config import (
+    AWS_ACCESS_KEY_ID,
+    AWS_ENDPOINT_URL,
+    AWS_REGION,
+    AWS_SECRET_ACCESS_KEY,
+)
+
+
+@functools.lru_cache(maxsize=64)
+def get_client(service_name: str):
+    """Return a boto3 client configured for the target AWS-compatible endpoint."""
+    return boto3.client(
+        service_name,
+        endpoint_url=AWS_ENDPOINT_URL,
+        region_name=AWS_REGION,
+        aws_access_key_id=AWS_ACCESS_KEY_ID,
+        aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+    )

backend/cache.py

@@ -0,0 +1,24 @@
+import threading
+import time
+
+
+class TTLCache:
+    def __init__(self):
+        self._store: dict = {}
+        self._lock = threading.Lock()
+
+    def get(self, key: str):
+        with self._lock:
+            if key in self._store:
+                value, expiry = self._store[key]
+                if time.time() < expiry:
+                    return value
+                del self._store[key]
+        return None
+
+    def set(self, key: str, value, ttl: float = 5):
+        with self._lock:
+            self._store[key] = (value, time.time() + ttl)
+
+
+cache = TTLCache()

backend/config.py

@@ -0,0 +1,14 @@
+import os
+
+AWS_ENDPOINT_URL: str = os.environ.get("AWS_ENDPOINT_URL", "http://localhost:4566")
+AWS_REGION: str = os.environ.get("AWS_REGION", "us-east-1")
+AWS_ACCESS_KEY_ID: str = os.environ.get("AWS_ACCESS_KEY_ID", "test")
+AWS_SECRET_ACCESS_KEY: str = os.environ.get("AWS_SECRET_ACCESS_KEY", "test")
+STACKPORT_PORT: int = int(os.environ.get("STACKPORT_PORT", "8080"))
+STACKPORT_SERVICES: str = os.environ.get(
+    "STACKPORT_SERVICES",
+    "s3,sqs,sns,dynamodb,lambda,iam,logs,ssm,secretsmanager,kinesis,events,ec2,"
+    "route53,kms,cloudformation,stepfunctions,rds,ecs,monitoring,ses,acm,wafv2,"
+    "ecr,elasticache,glue,athena,apigateway,firehose,cognito-idp,cognito-identity,"
+    "elasticmapreduce,elasticloadbalancing,elasticfilesystem,cloudfront,appsync",
+)

backend/main.py

@@ -0,0 +1,53 @@
+import logging
+import os
+import time
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from backend.config import STACKPORT_PORT
+from backend.routes import resources, s3, stats
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s %(name)s %(levelname)s %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="StackPort", docs_url="/api/docs")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(stats.router, prefix="/api")
+app.include_router(s3.router, prefix="/api/s3")
+app.include_router(resources.router, prefix="/api")
+
+# Serve UI static files — mount assets under /assets, SPA fallback for everything else
+ui_dist = os.path.join(os.path.dirname(__file__), "..", "ui", "dist")
+if os.path.isdir(ui_dist):
+    app.mount("/assets", StaticFiles(directory=os.path.join(ui_dist, "assets")), name="assets")
+
+    @app.get("/{path:path}")
+    def spa_fallback(path: str):
+        # Try to serve the file directly
+        file_path = os.path.join(ui_dist, path)
+        if path and os.path.isfile(file_path):
+            return FileResponse(file_path)
+        # SPA fallback: return index.html
+        return FileResponse(os.path.join(ui_dist, "index.html"))
+
+
+def cli():
+    uvicorn.run("backend.main:app", host="0.0.0.0", port=STACKPORT_PORT, reload=False)
+
+
+if __name__ == "__main__":
+    cli()

backend/routes/resources.py

@@ -0,0 +1,248 @@
+import logging
+
+from fastapi import APIRouter, HTTPException
+
+from backend.aws_client import get_client
+from backend.cache import cache
+from backend.routes.stats import SERVICE_REGISTRY, _METHOD_KWARGS, _count_items
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+# Maps (service, resource_type) -> (boto3_service, method, id_param, response_key)
+# response_key=None means return the full response (minus ResponseMetadata)
+DESCRIBE_REGISTRY: dict[tuple[str, str], tuple[str, str, str, str | None]] = {
+    # Storage
+    ("s3", "buckets"): ("s3", "list_objects_v2", "Bucket", "Contents"),
+    # Compute
+    ("lambda", "functions"): ("lambda", "get_function", "FunctionName", None),
+    ("ecs", "clusters"): ("ecs", "describe_clusters", "clusters", "clusters"),
+    ("ecs", "task_definitions"): ("ecs", "describe_task_definition", "taskDefinition", "taskDefinition"),
+    # Database
+    ("dynamodb", "tables"): ("dynamodb", "describe_table", "TableName", "Table"),
+    ("rds", "db_instances"): ("rds", "describe_db_instances", "DBInstanceIdentifier", "DBInstances"),
+    ("rds", "db_clusters"): ("rds", "describe_db_clusters", "DBClusterIdentifier", "DBClusters"),
+    ("elasticache", "cache_clusters"): ("elasticache", "describe_cache_clusters", "CacheClusterId", None),
+    # Messaging
+    ("sqs", "queues"): ("sqs", "get_queue_attributes", "QueueUrl", "Attributes"),
+    ("sns", "topics"): ("sns", "get_topic_attributes", "TopicArn", "Attributes"),
+    ("kinesis", "streams"): ("kinesis", "describe_stream", "StreamName", "StreamDescription"),
+    ("firehose", "delivery_streams"): ("firehose", "describe_delivery_stream", "DeliveryStreamName", "DeliveryStreamDescription"),
+    ("events", "rules"): ("events", "describe_rule", "Name", None),
+    ("events", "event_buses"): ("events", "describe_event_bus", "Name", None),
+    # Security & Identity
+    ("iam", "roles"): ("iam", "get_role", "RoleName", "Role"),
+    ("iam", "users"): ("iam", "get_user", "UserName", "User"),
+    ("iam", "policies"): ("iam", "get_policy", "PolicyArn", "Policy"),
+    ("secretsmanager", "secrets"): ("secretsmanager", "describe_secret", "SecretId", None),
+    ("kms", "keys"): ("kms", "describe_key", "KeyId", "KeyMetadata"),
+    ("acm", "certificates"): ("acm", "describe_certificate", "CertificateArn", "Certificate"),
+    ("cognito-idp", "user_pools"): ("cognito-idp", "describe_user_pool", "UserPoolId", "UserPool"),
+    ("cognito-identity", "identity_pools"): ("cognito-identity", "describe_identity_pool", "IdentityPoolId", None),
+    # Management
+    ("logs", "log_groups"): ("logs", "describe_log_groups", "logGroupNamePrefix", "logGroups"),
+    ("ssm", "parameters"): ("ssm", "get_parameter", "Name", "Parameter"),
+    ("cloudformation", "stacks"): ("cloudformation", "describe_stacks", "StackName", "Stacks"),
+    ("stepfunctions", "state_machines"): ("stepfunctions", "describe_state_machine", "stateMachineArn", None),
+    ("monitoring", "alarms"): ("cloudwatch", "describe_alarms", "AlarmNames", "MetricAlarms"),
+    ("monitoring", "dashboards"): ("cloudwatch", "get_dashboard", "DashboardName", None),
+    # Networking & CDN
+    ("route53", "hosted_zones"): ("route53", "get_hosted_zone", "Id", "HostedZone"),
+    ("cloudfront", "distributions"): ("cloudfront", "get_distribution", "Id", "Distribution"),
+    ("elasticloadbalancing", "load_balancers"): ("elbv2", "describe_load_balancers", "LoadBalancerArns", "LoadBalancers"),
+    # EC2
+    ("ec2", "instances"): ("ec2", "describe_instances", "InstanceIds", "Reservations"),
+    ("ec2", "vpcs"): ("ec2", "describe_vpcs", "VpcIds", "Vpcs"),
+    ("ec2", "subnets"): ("ec2", "describe_subnets", "SubnetIds", "Subnets"),
+    ("ec2", "security_groups"): ("ec2", "describe_security_groups", "GroupIds", "SecurityGroups"),
+    ("ec2", "volumes"): ("ec2", "describe_volumes", "VolumeIds", "Volumes"),
+    ("elasticfilesystem", "file_systems"): ("efs", "describe_file_systems", "FileSystemId", "FileSystems"),
+    # Containers
+    ("ecr", "repositories"): ("ecr", "describe_repositories", "repositoryNames", "repositories"),
+    # Analytics & ETL
+    ("glue", "databases"): ("glue", "get_database", "Name", "Database"),
+    ("glue", "crawlers"): ("glue", "get_crawler", "Name", "Crawler"),
+    ("athena", "workgroups"): ("athena", "get_work_group", "WorkGroup", "WorkGroup"),
+    # API
+    ("apigateway", "apis"): ("apigatewayv2", "get_api", "ApiId", None),
+    ("appsync", "graphql_apis"): ("appsync", "get_graphql_api", "apiId", "graphqlApi"),
+    # EMR
+    ("elasticmapreduce", "clusters"): ("emr", "describe_cluster", "ClusterId", "Cluster"),
+}
+
+# Known ID field names for extracting a resource identifier from list results
+_ID_FIELDS = [
+    "BucketName",
+    "FunctionName",
+    "TableName",
+    "TopicArn",
+    "QueueUrl",
+    "RoleName",
+    "UserName",
+    "PolicyName",
+    "Arn",
+    "PolicyArn",
+    "logGroupName",
+    "Name",
+    "SecretName",
+    "StreamName",
+    "RuleName",
+    "InstanceId",
+    "VpcId",
+    "SubnetId",
+    "GroupId",
+    "VolumeId",
+    "HostedZoneId",
+    "Id",
+    "KeyId",
+    "StackName",
+    "stateMachineArn",
+    "DBInstanceIdentifier",
+    "DBClusterIdentifier",
+    "clusterArn",
+    "CertificateArn",
+    "repositoryName",
+    "CacheClusterId",
+    "DeliveryStreamName",
+    "WorkGroupName",
+    "ApiId",
+    "UserPoolId",
+    "IdentityPoolId",
+    "LoadBalancerArn",
+    "FileSystemId",
+    "AlarmName",
+    "DashboardName",
+    "CrawlerName",
+    "DatabaseName",
+    "DistributionId",
+]
+
+
+def _extract_id(item) -> str:
+    """Extract a usable ID from a list API result item."""
+    if isinstance(item, str):
+        return item
+    if isinstance(item, dict):
+        for field in _ID_FIELDS:
+            if field in item:
+                return str(item[field])
+        # Fallback: first string value
+        for v in item.values():
+            if isinstance(v, str):
+                return v
+    return str(item)
+
+
+def _summarize_item(item) -> dict:
+    """Create a summary dict from a list API result item."""
+    if isinstance(item, str):
+        return {"id": item}
+    if isinstance(item, dict):
+        summary = {"id": _extract_id(item)}
+        for key, value in item.items():
+            if isinstance(value, (str, int, float, bool)) or value is None:
+                summary[key] = value
+            elif hasattr(value, "isoformat"):
+                summary[key] = value.isoformat()
+        return summary
+    return {"id": str(item)}
+
+
+@router.get("/resources/{service}")
+def list_resources(service: str):
+    cache_key = f"resources:{service}"
+    cached = cache.get(cache_key)
+    if cached is not None:
+        return cached
+
+    registry_entries = SERVICE_REGISTRY.get(service)
+    if not registry_entries:
+        raise HTTPException(status_code=404, detail=f"Unknown service: {service}")
+
+    resources: dict[str, list[dict]] = {}
+    for resource_type, boto3_service, method_name, response_key in registry_entries:
+        try:
+            client = get_client(boto3_service)
+            method = getattr(client, method_name)
+            kwargs = _METHOD_KWARGS.get((boto3_service, method_name), {})
+            resp = method(**kwargs)
+            items = resp.get(response_key, [])
+            # Handle nested structures (e.g., cloudfront DistributionList.Items)
+            if isinstance(items, dict) and "Items" in items:
+                items = items.get("Items", []) or []
+            resources[resource_type] = [_summarize_item(item) for item in items]
+        except Exception:
+            logger.debug("Failed to list %s/%s", service, resource_type, exc_info=True)
+            resources[resource_type] = []
+
+    result = {"service": service, "resources": resources}
+    cache.set(cache_key, result, ttl=5)
+    return result
+
+
+@router.get("/resources/{service}/{res_type}/{res_id:path}")
+def get_resource_detail(service: str, res_type: str, res_id: str):
+    cache_key = f"detail:{service}:{res_type}:{res_id}"
+    cached = cache.get(cache_key)
+    if cached is not None:
+        return cached
+
+    lookup = DESCRIBE_REGISTRY.get((service, res_type))
+    if not lookup:
+        raise HTTPException(
+            status_code=404,
+            detail=f"No detail lookup registered for {service}/{res_type}",
+        )
+
+    boto3_service, method_name, id_param, response_key = lookup
+
+    # Some APIs take list parameters (e.g., InstanceIds, VpcIds)
+    _LIST_PARAMS = {
+        "InstanceIds", "VpcIds", "SubnetIds", "GroupIds", "VolumeIds",
+        "repositoryNames", "clusters", "AlarmNames", "LoadBalancerArns",
+    }
+
+    try:
+        client = get_client(boto3_service)
+        method = getattr(client, method_name)
+        if id_param in _LIST_PARAMS:
+            resp = method(**{id_param: [res_id]})
+        else:
+            resp = method(**{id_param: res_id})
+
+        # Remove boto3 metadata
+        resp.pop("ResponseMetadata", None)
+
+        if response_key is not None:
+            detail = resp.get(response_key, resp)
+        else:
+            detail = resp
+
+        # Convert datetime objects for JSON serialization
+        detail = _serialize(detail)
+
+        result = {
+            "service": service,
+            "type": res_type,
+            "id": res_id,
+            "detail": detail,
+        }
+        cache.set(cache_key, result, ttl=5)
+        return result
+    except Exception as exc:
+        logger.warning("Failed to get detail for %s/%s/%s", service, res_type, res_id, exc_info=True)
+        raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+def _serialize(obj):
+    """Recursively convert non-JSON-serializable types."""
+    if isinstance(obj, dict):
+        return {k: _serialize(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [_serialize(v) for v in obj]
+    if hasattr(obj, "isoformat"):
+        return obj.isoformat()
+    if isinstance(obj, bytes):
+        return obj.decode("utf-8", errors="replace")
+    return obj

backend/routes/s3.py

@@ -0,0 +1,169 @@
+import logging
+
+from fastapi import APIRouter, Query
+from fastapi.responses import StreamingResponse
+
+from backend.aws_client import get_client
+from backend.cache import cache
+from backend.config import AWS_REGION
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+def _get_bucket_stats(bucket_name: str) -> tuple[int, int]:
+    """Return (object_count, total_size_bytes) for a bucket. Cached 30s."""
+    cache_key = f"s3:bucket_stats:{bucket_name}"
+    cached = cache.get(cache_key)
+    if cached is not None:
+        return cached
+
+    s3 = get_client("s3")
+    paginator = s3.get_paginator("list_objects_v2")
+    obj_count = 0
+    total_size = 0
+
+    try:
+        for page in paginator.paginate(Bucket=bucket_name):
+            for obj in page.get("Contents", []):
+                obj_count += 1
+                total_size += obj.get("Size", 0)
+    except Exception:
+        logger.debug("Failed to get bucket stats for %s", bucket_name, exc_info=True)
+
+    result = (obj_count, total_size)
+    cache.set(cache_key, result, ttl=30)
+    return result
+
+
+@router.get("/buckets")
+def list_buckets():
+    s3 = get_client("s3")
+    response = s3.list_buckets()
+    buckets = []
+
+    for b in response.get("Buckets", []):
+        name = b["Name"]
+        obj_count, total_size = _get_bucket_stats(name)
+
+        versioning = "Disabled"
+        try:
+            ver = s3.get_bucket_versioning(Bucket=name)
+            versioning = ver.get("Status", "Disabled")
+        except Exception:
+            logger.debug("Failed to get versioning for %s", name, exc_info=True)
+
+        encryption = "Disabled"
+        try:
+            s3.get_bucket_encryption(Bucket=name)
+            encryption = "Enabled"
+        except Exception:
+            logger.debug("Failed to get encryption for %s", name, exc_info=True)
+
+        tags: dict[str, str] = {}
+        try:
+            tag_resp = s3.get_bucket_tagging(Bucket=name)
+            tags = {t["Key"]: t["Value"] for t in tag_resp.get("TagSet", [])}
+        except Exception:
+            logger.debug("Failed to get tags for %s", name, exc_info=True)
+
+        buckets.append(
+            {
+                "name": name,
+                "created": b["CreationDate"].isoformat(),
+                "region": AWS_REGION,
+                "object_count": obj_count,
+                "total_size": total_size,
+                "versioning": versioning,
+                "encryption": encryption,
+                "tags": tags,
+            }
+        )
+
+    return {"buckets": buckets}
+
+
+@router.get("/buckets/{name}/objects")
+def list_objects(
+    name: str,
+    prefix: str = Query(default="", description="Key prefix filter"),
+    delimiter: str = Query(default="/", description="Hierarchy delimiter"),
+):
+    s3 = get_client("s3")
+    paginator = s3.get_paginator("list_objects_v2")
+
+    folders: list[str] = []
+    files: list[dict] = []
+
+    paginate_params: dict = {"Bucket": name, "Prefix": prefix}
+    if delimiter:
+        paginate_params["Delimiter"] = delimiter
+
+    for page in paginator.paginate(**paginate_params):
+        for cp in page.get("CommonPrefixes", []):
+            folders.append(cp["Prefix"])
+        for obj in page.get("Contents", []):
+            key = obj["Key"]
+            if key == prefix:
+                continue
+            file_name = key[len(prefix) :] if prefix else key
+            files.append(
+                {
+                    "key": key,
+                    "name": file_name,
+                    "size": obj["Size"],
+                    "content_type": "application/octet-stream",
+                    "etag": obj["ETag"].strip('"'),
+                    "last_modified": obj["LastModified"].isoformat(),
+                }
+            )
+
+    return {
+        "bucket": name,
+        "prefix": prefix,
+        "delimiter": delimiter,
+        "folders": folders,
+        "files": files,
+    }
+
+
+@router.get("/buckets/{name}/objects/{key:path}")
+def get_object_detail(
+    name: str,
+    key: str,
+    download: int = Query(default=0, description="Set to 1 to download the object"),
+):
+    s3 = get_client("s3")
+
+    if download == 1:
+        resp = s3.get_object(Bucket=name, Key=key)
+        filename = key.rsplit("/", 1)[-1] or key
+        return StreamingResponse(
+            resp["Body"],
+            media_type=resp.get("ContentType", "application/octet-stream"),
+            headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+        )
+
+    resp = s3.head_object(Bucket=name, Key=key)
+
+    tags: dict[str, str] = {}
+    try:
+        tag_resp = s3.get_object_tagging(Bucket=name, Key=key)
+        tags = {t["Key"]: t["Value"] for t in tag_resp.get("TagSet", [])}
+    except Exception:
+        logger.debug("Failed to get object tags for %s/%s", name, key, exc_info=True)
+
+    return {
+        "bucket": name,
+        "key": key,
+        "size": resp["ContentLength"],
+        "content_type": resp.get("ContentType", "application/octet-stream"),
+        "content_encoding": resp.get("ContentEncoding"),
+        "etag": resp["ETag"].strip('"'),
+        "last_modified": resp["LastModified"].isoformat(),
+        "version_id": resp.get("VersionId"),
+        "metadata": resp.get("Metadata", {}),
+        "preserved_headers": {},
+        "tags": tags,
+    }