Docker Containerization

# Dependencies
node_modules
npm-debug.log*
yarn-debug.log*
yarn-error.log*
.pnpm-debug.log*

# Testing
coverage
*.lcov
.nyc_output

# Next.js
.next/
out/
build
dist

# Production
.vercel
.netlify

# Misc
.DS_Store
*.pem
.env*.local
.env.development
.env.test
.env.production

# Debug
logs
*.log

# Git
.git
.gitignore
.gitattributes

# IDE
.vscode
.idea
*.swp
*.swo
*~

# Documentation
README.md
docs/
*.md

# CI/CD
.github/
.gitlab-ci.yml
.circleci/

# Docker
Dockerfile*
docker-compose*.yml
.dockerignore

# Temporary files
tmp/
temp/

version: '3.8'

services:
  # Next.js Application - Development
  app-dev:
    build:
      context: .
      dockerfile: Dockerfile.development
    container_name: nextjs-app-dev
    ports:
      - "3000:3000"
    volumes:
      - .:/app
      - /app/node_modules
      - /app/.next
    environment:
      - NODE_ENV=development
      - PORT=3000
    networks:
      - app-network
    restart: unless-stopped

  # Next.js Application - Production
  app-prod:
    build:
      context: .
      dockerfile: Dockerfile.production
    container_name: nextjs-app-prod
    ports:
      - "3001:3000"
    environment:
      - NODE_ENV=production
      - PORT=3000
    networks:
      - app-network
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "node", "-e", "require('http').get('http://localhost:3000/api/health', (r) => {process.exit(r.statusCode === 200 ? 0 : 1)})"]
      interval: 30s
      timeout: 3s
      retries: 3
      start_period: 10s

  # Nginx Reverse Proxy (optional)
  nginx:
    image: nginx:alpine
    container_name: nginx-proxy
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - app-prod
    networks:
      - app-network
    restart: unless-stopped

networks:
  app-network:
    driver: bridge

# Dockerfile for Next.js Development
# Optimized for fast rebuilds and hot reloading

FROM node:18-alpine

LABEL maintainer="your-email@example.com"
LABEL description="Next.js Application - Development"

# Install dependencies for native modules
RUN apk add --no-cache libc6-compat python3 make g++

WORKDIR /app

# Copy package files
COPY package.json package-lock.json* ./

# Install all dependencies (including devDependencies)
RUN npm install && \
    npm cache clean --force

# Copy application source
COPY . .

# Expose port for dev server
EXPOSE 3000

ENV PORT=3000
ENV NODE_ENV=development

# Start development server with hot reload
CMD ["npm", "run", "dev"]

# Multi-stage Dockerfile for Next.js with Nginx
# For static export deployment with Nginx reverse proxy

# Stage 1: Build the Next.js application
FROM node:18-alpine AS builder

WORKDIR /app

# Copy package files
COPY package.json package-lock.json* ./

# Install dependencies
RUN npm ci && npm cache clean --force

# Copy application source
COPY . .

# Build static export
ENV NODE_ENV=production
ENV NEXT_TELEMETRY_DISABLED=1

RUN npm run build

# Stage 2: Nginx server
FROM nginx:alpine AS runner

LABEL maintainer="your-email@example.com"
LABEL description="Next.js Application - Nginx Static"

# Copy built files from builder
COPY --from=builder /app/out /usr/share/nginx/html

# Copy nginx configuration
COPY nginx.conf /etc/nginx/conf.d/default.conf

# Expose port
EXPOSE 80

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD wget --quiet --tries=1 --spider http://localhost:80/ || exit 1

# Start nginx
CMD ["nginx", "-g", "daemon off;"]

# Multi-stage Dockerfile for Next.js Production
# Optimized for minimal image size and security

# Stage 1: Dependencies
FROM node:18-alpine AS deps
LABEL stage=deps

# Install dependencies only when needed
RUN apk add --no-cache libc6-compat

WORKDIR /app

# Copy package files
COPY package.json package-lock.json* ./

# Install dependencies with clean install
RUN npm ci --only=production && \
    npm cache clean --force

# Stage 2: Builder
FROM node:18-alpine AS builder
LABEL stage=builder

WORKDIR /app

# Copy dependencies from deps stage
COPY --from=deps /app/node_modules ./node_modules

# Copy application source
COPY . .

# Set environment variables for build
ENV NODE_ENV=production
ENV NEXT_TELEMETRY_DISABLED=1

# Build the application
RUN npm run build

# Stage 3: Runner (Production)
FROM node:18-alpine AS runner
LABEL maintainer="your-email@example.com"
LABEL description="Next.js Application - Production"

WORKDIR /app

# Don't run production as root
RUN addgroup --system --gid 1001 nodejs && \
    adduser --system --uid 1001 nextjs

# Set environment
ENV NODE_ENV=production
ENV NEXT_TELEMETRY_DISABLED=1

# Copy necessary files from builder
COPY --from=builder /app/public ./public
COPY --from=builder /app/.next/standalone ./
COPY --from=builder /app/.next/static ./.next/static

# Change ownership to nextjs user
RUN chown -R nextjs:nodejs /app

# Switch to non-root user
USER nextjs

# Expose port
EXPOSE 3000

ENV PORT=3000
ENV HOSTNAME="0.0.0.0"

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
    CMD node -e "require('http').get('http://localhost:3000/api/health', (r) => {process.exit(r.statusCode === 200 ? 0 : 1)})" || exit 1

# Start the application
CMD ["node", "server.js"]

server {
    listen 80;
    server_name localhost;

    # Gzip compression
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/json;

    # Security headers
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-XSS-Protection "1; mode=block" always;

    # Root location - serve static files
    location / {
        root /usr/share/nginx/html;
        try_files $uri $uri/ $uri.html /index.html;

        # Cache static assets
        location ~* \.(jpg|jpeg|png|gif|ico|css|js|svg|woff|woff2|ttf|eot)$ {
            expires 1y;
            add_header Cache-Control "public, immutable";
        }
    }

    # API proxy (if needed)
    location /api/ {
        proxy_pass http://app-prod:3000/api/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # Health check endpoint
    location /health {
        access_log off;
        return 200 "healthy\n";
        add_header Content-Type text/plain;
    }

    # Error pages
    error_page 404 /404.html;
    error_page 500 502 503 504 /50x.html;

    location = /50x.html {
        root /usr/share/nginx/html;
    }
}

export default async function docker_containerization(input) {
  console.log("🧠 Running skill: docker-containerization");
  
  // TODO: implement actual logic for this skill
  return {
    message: "Skill 'docker-containerization' executed successfully!",
    input
  };
}

{
  "name": "@ai-labs-claude-skills/docker-containerization",
  "version": "1.0.0",
  "description": "Claude AI skill: docker-containerization",
  "main": "index.js",
  "files": [
    "."
  ],
  "license": "MIT",
  "author": "AI Labs"
}

#!/bin/bash

# Docker Build Script for Next.js Applications
# Builds Docker images with various configurations

set -e  # Exit on error

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Default values
IMAGE_NAME="nextjs-app"
TAG="latest"
DOCKERFILE="Dockerfile.production"
BUILD_ARGS=""
NO_CACHE=false
PLATFORM=""

# Print usage
usage() {
    echo -e "${BLUE}Usage:${NC} $0 [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  -n, --name NAME          Image name (default: nextjs-app)"
    echo "  -t, --tag TAG            Image tag (default: latest)"
    echo "  -f, --file DOCKERFILE    Dockerfile to use (default: Dockerfile.production)"
    echo "  -e, --env ENV            Environment (dev|prod|nginx)"
    echo "  -b, --build-arg ARG      Build argument (can be used multiple times)"
    echo "  --no-cache               Build without cache"
    echo "  --platform PLATFORM      Target platform (e.g., linux/amd64, linux/arm64)"
    echo "  -h, --help               Show this help message"
    echo ""
    echo "Examples:"
    echo "  $0 -e prod -t v1.0.0"
    echo "  $0 -n my-app -e dev --no-cache"
    echo "  $0 --platform linux/amd64 -e prod"
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -n|--name)
            IMAGE_NAME="$2"
            shift 2
            ;;
        -t|--tag)
            TAG="$2"
            shift 2
            ;;
        -f|--file)
            DOCKERFILE="$2"
            shift 2
            ;;
        -e|--env)
            ENV="$2"
            case $ENV in
                dev|development)
                    DOCKERFILE="Dockerfile.development"
                    ;;
                prod|production)
                    DOCKERFILE="Dockerfile.production"
                    ;;
                nginx)
                    DOCKERFILE="Dockerfile.nginx"
                    ;;
                *)
                    echo -e "${RED}Error: Invalid environment: $ENV${NC}"
                    echo "Valid options: dev, prod, nginx"
                    exit 1
                    ;;
            esac
            shift 2
            ;;
        -b|--build-arg)
            BUILD_ARGS="$BUILD_ARGS --build-arg $2"
            shift 2
            ;;
        --no-cache)
            NO_CACHE=true
            shift
            ;;
        --platform)
            PLATFORM="$2"
            shift 2
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        *)
            echo -e "${RED}Error: Unknown option: $1${NC}"
            usage
            exit 1
            ;;
    esac
done

# Build the command
DOCKER_CMD="docker build"
DOCKER_CMD="$DOCKER_CMD -t ${IMAGE_NAME}:${TAG}"
DOCKER_CMD="$DOCKER_CMD -f ${DOCKERFILE}"

if [ "$NO_CACHE" = true ]; then
    DOCKER_CMD="$DOCKER_CMD --no-cache"
fi

if [ -n "$PLATFORM" ]; then
    DOCKER_CMD="$DOCKER_CMD --platform $PLATFORM"
fi

if [ -n "$BUILD_ARGS" ]; then
    DOCKER_CMD="$DOCKER_CMD $BUILD_ARGS"
fi

DOCKER_CMD="$DOCKER_CMD ."

# Print configuration
echo -e "${BLUE}╔═══════════════════════════════════════╗${NC}"
echo -e "${BLUE}║      Docker Build Configuration       ║${NC}"
echo -e "${BLUE}╠═══════════════════════════════════════╣${NC}"
echo -e "${BLUE}║${NC} Image Name:    ${GREEN}${IMAGE_NAME}${NC}"
echo -e "${BLUE}║${NC} Tag:           ${GREEN}${TAG}${NC}"
echo -e "${BLUE}║${NC} Dockerfile:    ${GREEN}${DOCKERFILE}${NC}"
echo -e "${BLUE}║${NC} No Cache:      ${GREEN}${NO_CACHE}${NC}"
if [ -n "$PLATFORM" ]; then
    echo -e "${BLUE}║${NC} Platform:      ${GREEN}${PLATFORM}${NC}"
fi
echo -e "${BLUE}╚═══════════════════════════════════════╝${NC}"
echo ""

# Check if Dockerfile exists
if [ ! -f "$DOCKERFILE" ]; then
    echo -e "${RED}Error: Dockerfile not found: $DOCKERFILE${NC}"
    exit 1
fi

# Execute build
echo -e "${YELLOW}Building Docker image...${NC}"
echo -e "${BLUE}Command:${NC} $DOCKER_CMD"
echo ""

if eval $DOCKER_CMD; then
    echo ""
    echo -e "${GREEN}✓ Build successful!${NC}"
    echo ""
    echo -e "${BLUE}Image details:${NC}"
    docker images | grep "$IMAGE_NAME" | grep "$TAG"
    echo ""
    echo -e "${BLUE}Next steps:${NC}"
    echo "  Run:    docker run -p 3000:3000 ${IMAGE_NAME}:${TAG}"
    echo "  Push:   docker push ${IMAGE_NAME}:${TAG}"
    echo "  Inspect: docker inspect ${IMAGE_NAME}:${TAG}"
else
    echo ""
    echo -e "${RED}✗ Build failed!${NC}"
    exit 1
fi

#!/bin/bash

# Docker Cleanup Script
# Removes unused Docker resources to free up disk space

set -e  # Exit on error

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Flags
DRY_RUN=false
FORCE=false
ALL=false
CONTAINERS=false
IMAGES=false
VOLUMES=false
NETWORKS=false

# Print usage
usage() {
    echo -e "${BLUE}Usage:${NC} $0 [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  --all                    Clean all unused resources"
    echo "  --containers             Remove stopped containers"
    echo "  --images                 Remove dangling images"
    echo "  --volumes                Remove unused volumes"
    echo "  --networks               Remove unused networks"
    echo "  --dry-run                Show what would be removed without actually removing"
    echo "  -f, --force              Force removal without confirmation"
    echo "  -h, --help               Show this help message"
    echo ""
    echo "Examples:"
    echo "  $0 --all                 # Clean everything"
    echo "  $0 --containers --images  # Clean containers and images"
    echo "  $0 --all --dry-run       # Preview cleanup without removing"
}

# Parse arguments
if [ $# -eq 0 ]; then
    usage
    exit 0
fi

while [[ $# -gt 0 ]]; do
    case $1 in
        --all)
            ALL=true
            shift
            ;;
        --containers)
            CONTAINERS=true
            shift
            ;;
        --images)
            IMAGES=true
            shift
            ;;
        --volumes)
            VOLUMES=true
            shift
            ;;
        --networks)
            NETWORKS=true
            shift
            ;;
        --dry-run)
            DRY_RUN=true
            shift
            ;;
        -f|--force)
            FORCE=true
            shift
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        *)
            echo -e "${RED}Error: Unknown option: $1${NC}"
            usage
            exit 1
            ;;
    esac
done

# If --all is specified, enable all cleanup options
if [ "$ALL" = true ]; then
    CONTAINERS=true
    IMAGES=true
    VOLUMES=true
    NETWORKS=true
fi

# Show current disk usage
echo -e "${BLUE}╔═══════════════════════════════════════╗${NC}"
echo -e "${BLUE}║      Current Docker Disk Usage        ║${NC}"
echo -e "${BLUE}╚═══════════════════════════════════════╝${NC}"
docker system df
echo ""

# Confirmation prompt (unless --force or --dry-run)
if [ "$FORCE" = false ] && [ "$DRY_RUN" = false ]; then
    echo -e "${YELLOW}This will remove unused Docker resources.${NC}"
    read -p "Continue? (y/n) " -n 1 -r
    echo
    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
        echo -e "${RED}Aborted.${NC}"
        exit 0
    fi
fi

# Cleanup functions
cleanup_containers() {
    echo -e "${BLUE}Cleaning up stopped containers...${NC}"

    if [ "$DRY_RUN" = true ]; then
        STOPPED=$(docker ps -aq -f status=exited)
        if [ -n "$STOPPED" ]; then
            echo -e "${YELLOW}Would remove:${NC}"
            docker ps -a -f status=exited --format "table {{.ID}}\t{{.Names}}\t{{.Status}}"
        else
            echo -e "${GREEN}No stopped containers to remove.${NC}"
        fi
    else
        REMOVED=$(docker container prune -f 2>&1 | grep "Total reclaimed space" || echo "")
        if [ -n "$REMOVED" ]; then
            echo -e "${GREEN}✓ $REMOVED${NC}"
        else
            echo -e "${GREEN}✓ No stopped containers to remove.${NC}"
        fi
    fi
    echo ""
}

cleanup_images() {
    echo -e "${BLUE}Cleaning up dangling images...${NC}"

    if [ "$DRY_RUN" = true ]; then
        DANGLING=$(docker images -f "dangling=true" -q)
        if [ -n "$DANGLING" ]; then
            echo -e "${YELLOW}Would remove:${NC}"
            docker images -f "dangling=true" --format "table {{.ID}}\t{{.Repository}}\t{{.Tag}}\t{{.Size}}"
        else
            echo -e "${GREEN}No dangling images to remove.${NC}"
        fi
    else
        REMOVED=$(docker image prune -f 2>&1 | grep "Total reclaimed space" || echo "")
        if [ -n "$REMOVED" ]; then
            echo -e "${GREEN}✓ $REMOVED${NC}"
        else
            echo -e "${GREEN}✓ No dangling images to remove.${NC}"
        fi
    fi
    echo ""
}

cleanup_volumes() {
    echo -e "${BLUE}Cleaning up unused volumes...${NC}"

    if [ "$DRY_RUN" = true ]; then
        UNUSED=$(docker volume ls -qf dangling=true)
        if [ -n "$UNUSED" ]; then
            echo -e "${YELLOW}Would remove:${NC}"
            docker volume ls -f dangling=true --format "table {{.Name}}\t{{.Driver}}\t{{.Mountpoint}}"
        else
            echo -e "${GREEN}No unused volumes to remove.${NC}"
        fi
    else
        REMOVED=$(docker volume prune -f 2>&1 | grep "Total reclaimed space" || echo "")
        if [ -n "$REMOVED" ]; then
            echo -e "${GREEN}✓ $REMOVED${NC}"
        else
            echo -e "${GREEN}✓ No unused volumes to remove.${NC}"
        fi
    fi
    echo ""
}

cleanup_networks() {
    echo -e "${BLUE}Cleaning up unused networks...${NC}"

    if [ "$DRY_RUN" = true ]; then
        UNUSED=$(docker network ls -qf "dangling=true")
        if [ -n "$UNUSED" ]; then
            echo -e "${YELLOW}Would remove:${NC}"
            docker network ls -f "dangling=true" --format "table {{.ID}}\t{{.Name}}\t{{.Driver}}"
        else
            echo -e "${GREEN}No unused networks to remove.${NC}"
        fi
    else
        REMOVED=$(docker network prune -f 2>&1 | grep "Total reclaimed space" || echo "")
        if [ -n "$REMOVED" ]; then
            echo -e "${GREEN}✓ $REMOVED${NC}"
        else
            echo -e "${GREEN}✓ No unused networks to remove.${NC}"
        fi
    fi
    echo ""
}

# Execute cleanup operations
if [ "$CONTAINERS" = true ]; then
    cleanup_containers
fi

if [ "$IMAGES" = true ]; then
    cleanup_images
fi

if [ "$VOLUMES" = true ]; then
    cleanup_volumes
fi

if [ "$NETWORKS" = true ]; then
    cleanup_networks
fi

# Show final disk usage
echo -e "${BLUE}╔═══════════════════════════════════════╗${NC}"
echo -e "${BLUE}║       Final Docker Disk Usage         ║${NC}"
echo -e "${BLUE}╚═══════════════════════════════════════╝${NC}"
docker system df
echo ""

if [ "$DRY_RUN" = true ]; then
    echo -e "${YELLOW}Dry run complete. No resources were removed.${NC}"
    echo -e "${BLUE}Run without --dry-run to actually remove resources.${NC}"
else
    echo -e "${GREEN}✓ Cleanup complete!${NC}"
fi

#!/bin/bash

# Docker Push Script for Next.js Applications
# Pushes Docker images to registries (Docker Hub, ECR, GCR, etc.)

set -e  # Exit on error

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Default values
IMAGE_NAME="nextjs-app"
TAG="latest"
REGISTRY=""
REPOSITORY=""
ADDITIONAL_TAGS=""

# Print usage
usage() {
    echo -e "${BLUE}Usage:${NC} $0 [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  -n, --name NAME          Image name (default: nextjs-app)"
    echo "  -t, --tag TAG            Image tag (default: latest)"
    echo "  -r, --registry REG       Registry URL (e.g., docker.io, gcr.io, 123456789012.dkr.ecr.us-east-1.amazonaws.com)"
    echo "  --repo REPO              Repository name (e.g., mycompany/myapp)"
    echo "  --also-tag TAG           Additional tags to create and push (can be used multiple times)"
    echo "  -h, --help               Show this help message"
    echo ""
    echo "Examples:"
    echo "  $0 -n my-app -t v1.0.0 --repo username/my-app"
    echo "  $0 -r gcr.io/my-project --repo my-app -t latest --also-tag stable"
    echo "  $0 -r 123456789012.dkr.ecr.us-east-1.amazonaws.com --repo my-app"
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -n|--name)
            IMAGE_NAME="$2"
            shift 2
            ;;
        -t|--tag)
            TAG="$2"
            shift 2
            ;;
        -r|--registry)
            REGISTRY="$2"
            shift 2
            ;;
        --repo)
            REPOSITORY="$2"
            shift 2
            ;;
        --also-tag)
            ADDITIONAL_TAGS="$ADDITIONAL_TAGS $2"
            shift 2
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        *)
            echo -e "${RED}Error: Unknown option: $1${NC}"
            usage
            exit 1
            ;;
    esac
done

# Check if image exists locally
if ! docker images --format '{{.Repository}}:{{.Tag}}' | grep -q "^${IMAGE_NAME}:${TAG}$"; then
    echo -e "${RED}Error: Image not found: ${IMAGE_NAME}:${TAG}${NC}"
    echo -e "${YELLOW}Available images:${NC}"
    docker images | grep "$IMAGE_NAME" || echo "No images found for $IMAGE_NAME"
    exit 1
fi

# Build the target image name
if [ -n "$REGISTRY" ] && [ -n "$REPOSITORY" ]; then
    TARGET_IMAGE="${REGISTRY}/${REPOSITORY}:${TAG}"
elif [ -n "$REPOSITORY" ]; then
    TARGET_IMAGE="${REPOSITORY}:${TAG}"
else
    TARGET_IMAGE="${IMAGE_NAME}:${TAG}"
fi

# Print configuration
echo -e "${BLUE}╔═══════════════════════════════════════╗${NC}"
echo -e "${BLUE}║       Docker Push Configuration       ║${NC}"
echo -e "${BLUE}╠═══════════════════════════════════════╣${NC}"
echo -e "${BLUE}║${NC} Source Image:  ${GREEN}${IMAGE_NAME}:${TAG}${NC}"
echo -e "${BLUE}║${NC} Target Image:  ${GREEN}${TARGET_IMAGE}${NC}"
if [ -n "$ADDITIONAL_TAGS" ]; then
    echo -e "${BLUE}║${NC} Also pushing:  ${GREEN}${ADDITIONAL_TAGS}${NC}"
fi
echo -e "${BLUE}╚═══════════════════════════════════════╝${NC}"
echo ""

# Tag the image if source and target are different
if [ "${IMAGE_NAME}:${TAG}" != "$TARGET_IMAGE" ]; then
    echo -e "${YELLOW}Tagging image...${NC}"
    if docker tag "${IMAGE_NAME}:${TAG}" "$TARGET_IMAGE"; then
        echo -e "${GREEN}✓ Tagged successfully${NC}"
    else
        echo -e "${RED}✗ Failed to tag image${NC}"
        exit 1
    fi
    echo ""
fi

# Push the main image
echo -e "${YELLOW}Pushing image: ${TARGET_IMAGE}${NC}"
if docker push "$TARGET_IMAGE"; then
    echo -e "${GREEN}✓ Pushed successfully: ${TARGET_IMAGE}${NC}"
else
    echo -e "${RED}✗ Failed to push image${NC}"
    exit 1
fi
echo ""

# Push additional tags
for EXTRA_TAG in $ADDITIONAL_TAGS; do
    if [ -n "$REGISTRY" ] && [ -n "$REPOSITORY" ]; then
        EXTRA_IMAGE="${REGISTRY}/${REPOSITORY}:${EXTRA_TAG}"
    elif [ -n "$REPOSITORY" ]; then
        EXTRA_IMAGE="${REPOSITORY}:${EXTRA_TAG}"
    else
        EXTRA_IMAGE="${IMAGE_NAME}:${EXTRA_TAG}"
    fi

    echo -e "${YELLOW}Tagging and pushing: ${EXTRA_IMAGE}${NC}"

    if docker tag "${IMAGE_NAME}:${TAG}" "$EXTRA_IMAGE"; then
        if docker push "$EXTRA_IMAGE"; then
            echo -e "${GREEN}✓ Pushed successfully: ${EXTRA_IMAGE}${NC}"
        else
            echo -e "${RED}✗ Failed to push: ${EXTRA_IMAGE}${NC}"
        fi
    else
        echo -e "${RED}✗ Failed to tag: ${EXTRA_IMAGE}${NC}"
    fi
    echo ""
done

echo -e "${GREEN}✓ All images pushed successfully!${NC}"
echo ""
echo -e "${BLUE}Pushed images:${NC}"
echo "  - ${TARGET_IMAGE}"
for EXTRA_TAG in $ADDITIONAL_TAGS; do
    if [ -n "$REGISTRY" ] && [ -n "$REPOSITORY" ]; then
        echo "  - ${REGISTRY}/${REPOSITORY}:${EXTRA_TAG}"
    elif [ -n "$REPOSITORY" ]; then
        echo "  - ${REPOSITORY}:${EXTRA_TAG}"
    else
        echo "  - ${IMAGE_NAME}:${EXTRA_TAG}"
    fi
done

#!/bin/bash

# Docker Run Script for Next.js Applications
# Runs Docker containers with various configurations

set -e  # Exit on error

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Default values
IMAGE_NAME="nextjs-app"
TAG="latest"
CONTAINER_NAME="nextjs-container"
HOST_PORT="3000"
CONTAINER_PORT="3000"
DETACHED=false
ENV_FILE=""
VOLUMES=""
NETWORK=""
RESTART_POLICY=""

# Print usage
usage() {
    echo -e "${BLUE}Usage:${NC} $0 [OPTIONS]"
    echo ""
    echo "Options:"
    echo "  -n, --name NAME          Container name (default: nextjs-container)"
    echo "  -i, --image IMAGE        Image name (default: nextjs-app)"
    echo "  -t, --tag TAG            Image tag (default: latest)"
    echo "  -p, --port HOST:CONT     Port mapping (default: 3000:3000)"
    echo "  -d, --detach             Run in detached mode"
    echo "  -e, --env-file FILE      Environment file"
    echo "  -v, --volume VOL         Volume mount (can be used multiple times)"
    echo "  --network NETWORK        Docker network to use"
    echo "  --restart POLICY         Restart policy (no|on-failure|always|unless-stopped)"
    echo "  -h, --help               Show this help message"
    echo ""
    echo "Examples:"
    echo "  $0 -i my-app -t v1.0.0 -d"
    echo "  $0 -p 8080:3000 --env-file .env.production"
    echo "  $0 -v ./data:/app/data --restart unless-stopped"
}

# Parse arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -n|--name)
            CONTAINER_NAME="$2"
            shift 2
            ;;
        -i|--image)
            IMAGE_NAME="$2"
            shift 2
            ;;
        -t|--tag)
            TAG="$2"
            shift 2
            ;;
        -p|--port)
            IFS=':' read -r HOST_PORT CONTAINER_PORT <<< "$2"
            shift 2
            ;;
        -d|--detach)
            DETACHED=true
            shift
            ;;
        -e|--env-file)
            ENV_FILE="$2"
            shift 2
            ;;
        -v|--volume)
            VOLUMES="$VOLUMES -v $2"
            shift 2
            ;;
        --network)
            NETWORK="$2"
            shift 2
            ;;
        --restart)
            RESTART_POLICY="$2"
            shift 2
            ;;
        -h|--help)
            usage
            exit 0
            ;;
        *)
            echo -e "${RED}Error: Unknown option: $1${NC}"
            usage
            exit 1
            ;;
    esac
done

# Build the command
DOCKER_CMD="docker run"
DOCKER_CMD="$DOCKER_CMD --name ${CONTAINER_NAME}"
DOCKER_CMD="$DOCKER_CMD -p ${HOST_PORT}:${CONTAINER_PORT}"

if [ "$DETACHED" = true ]; then
    DOCKER_CMD="$DOCKER_CMD -d"
fi

if [ -n "$ENV_FILE" ]; then
    if [ -f "$ENV_FILE" ]; then
        DOCKER_CMD="$DOCKER_CMD --env-file $ENV_FILE"
    else
        echo -e "${YELLOW}Warning: Environment file not found: $ENV_FILE${NC}"
    fi
fi

if [ -n "$VOLUMES" ]; then
    DOCKER_CMD="$DOCKER_CMD $VOLUMES"
fi

if [ -n "$NETWORK" ]; then
    DOCKER_CMD="$DOCKER_CMD --network $NETWORK"
fi

if [ -n "$RESTART_POLICY" ]; then
    DOCKER_CMD="$DOCKER_CMD --restart $RESTART_POLICY"
fi

DOCKER_CMD="$DOCKER_CMD ${IMAGE_NAME}:${TAG}"

# Check if container already exists
if docker ps -a --format '{{.Names}}' | grep -q "^${CONTAINER_NAME}$"; then
    echo -e "${YELLOW}Container ${CONTAINER_NAME} already exists.${NC}"
    read -p "Do you want to remove it and create a new one? (y/n) " -n 1 -r
    echo
    if [[ $REPLY =~ ^[Yy]$ ]]; then
        echo -e "${BLUE}Removing existing container...${NC}"
        docker rm -f "$CONTAINER_NAME"
    else
        echo -e "${RED}Aborted.${NC}"
        exit 1
    fi
fi

# Check if image exists
if ! docker images --format '{{.Repository}}:{{.Tag}}' | grep -q "^${IMAGE_NAME}:${TAG}$"; then
    echo -e "${RED}Error: Image not found: ${IMAGE_NAME}:${TAG}${NC}"
    echo -e "${YELLOW}Available images:${NC}"
    docker images | grep "$IMAGE_NAME" || echo "No images found for $IMAGE_NAME"
    exit 1
fi

# Print configuration
echo -e "${BLUE}╔═══════════════════════════════════════╗${NC}"
echo -e "${BLUE}║       Docker Run Configuration        ║${NC}"
echo -e "${BLUE}╠═══════════════════════════════════════╣${NC}"
echo -e "${BLUE}║${NC} Container:     ${GREEN}${CONTAINER_NAME}${NC}"
echo -e "${BLUE}║${NC} Image:         ${GREEN}${IMAGE_NAME}:${TAG}${NC}"
echo -e "${BLUE}║${NC} Port:          ${GREEN}${HOST_PORT}:${CONTAINER_PORT}${NC}"
echo -e "${BLUE}║${NC} Detached:      ${GREEN}${DETACHED}${NC}"
if [ -n "$ENV_FILE" ]; then
    echo -e "${BLUE}║${NC} Env File:      ${GREEN}${ENV_FILE}${NC}"
fi
if [ -n "$NETWORK" ]; then
    echo -e "${BLUE}║${NC} Network:       ${GREEN}${NETWORK}${NC}"
fi
if [ -n "$RESTART_POLICY" ]; then
    echo -e "${BLUE}║${NC} Restart:       ${GREEN}${RESTART_POLICY}${NC}"
fi
echo -e "${BLUE}╚═══════════════════════════════════════╝${NC}"
echo ""

# Execute run
echo -e "${YELLOW}Starting Docker container...${NC}"
echo -e "${BLUE}Command:${NC} $DOCKER_CMD"
echo ""

if eval $DOCKER_CMD; then
    echo ""
    echo -e "${GREEN}✓ Container started successfully!${NC}"
    echo ""

    if [ "$DETACHED" = true ]; then
        echo -e "${BLUE}Container is running in background.${NC}"
        echo ""
        echo -e "${BLUE}Container details:${NC}"
        docker ps --filter "name=${CONTAINER_NAME}" --format "table {{.ID}}\t{{.Names}}\t{{.Status}}\t{{.Ports}}"
        echo ""
        echo -e "${BLUE}Access application:${NC}"
        echo "  URL:  http://localhost:${HOST_PORT}"
        echo ""
        echo -e "${BLUE}Useful commands:${NC}"
        echo "  Logs:    docker logs -f ${CONTAINER_NAME}"
        echo "  Stop:    docker stop ${CONTAINER_NAME}"
        echo "  Restart: docker restart ${CONTAINER_NAME}"
        echo "  Remove:  docker rm -f ${CONTAINER_NAME}"
        echo "  Exec:    docker exec -it ${CONTAINER_NAME} sh"
    else
        echo -e "${BLUE}Container running in foreground. Press Ctrl+C to stop.${NC}"
    fi
else
    echo ""
    echo -e "${RED}✗ Failed to start container!${NC}"
    exit 1
fi