AWS CodeStar & CodeCatalyst

# Example CodeStar project template structure
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::CodeStar

Parameters:
  ProjectId:
    Type: String
    Description: CodeStar project ID
  
  CodeCommitRepoName:
    Type: String
    Description: CodeCommit repository name

Resources:
  # CodeCommit Repository
  CodeCommitRepo:
    Type: AWS::CodeCommit::Repository
    Properties:
      RepositoryName: !Ref CodeCommitRepoName
      RepositoryDescription: !Sub 'Repository for ${ProjectId}'

  # CodeBuild Project
  CodeBuildProject:
    Type: AWS::CodeBuild::Project
    Properties:
      Name: !Sub '${ProjectId}-build'
      ServiceRole: !GetAtt CodeBuildRole.Arn
      Artifacts:
        Type: CODEPIPELINE
      Environment:
        Type: LINUX_CONTAINER
        ComputeType: BUILD_GENERAL1_SMALL
        Image: aws/codebuild/amazonlinux2-x86_64-standard:3.0
      Source:
        Type: CODEPIPELINE
        BuildSpec: |
          version: 0.2
          phases:
            install:
              runtime-versions:
                python: 3.8
            build:
              commands:
                - echo "Building the application"
                - pip install -r requirements.txt
                - python -m pytest tests/
          artifacts:
            files:
              - '**/*'

  # CodePipeline
  CodePipeline:
    Type: AWS::CodePipeline::Pipeline
    Properties:
      Name: !Sub '${ProjectId}-pipeline'
      RoleArn: !GetAtt CodePipelineRole.Arn
      ArtifactStore:
        Type: S3
        Location: !Ref ArtifactBucket
      Stages:
        - Name: Source
          Actions:
            - Name: SourceAction
              ActionTypeId:
                Category: Source
                Owner: AWS
                Provider: CodeCommit
                Version: 1
              Configuration:
                RepositoryName: !Ref CodeCommitRepoName
                BranchName: main
              OutputArtifacts:
                - Name: SourceOutput

        - Name: Build
          Actions:
            - Name: BuildAction
              ActionTypeId:
                Category: Build
                Owner: AWS
                Provider: CodeBuild
                Version: 1
              Configuration:
                ProjectName: !Ref CodeBuildProject
              InputArtifacts:
                - Name: SourceOutput
              OutputArtifacts:
                - Name: BuildOutput

        - Name: Deploy
          Actions:
            - Name: DeployAction
              ActionTypeId:
                Category: Deploy
                Owner: AWS
                Provider: CloudFormation
                Version: 1
              Configuration:
                ActionMode: CREATE_UPDATE
                StackName: !Sub '${ProjectId}-stack'
                TemplatePath: BuildOutput::template.yaml
                Capabilities: CAPABILITY_IAM
                RoleArn: !GetAtt CloudFormationRole.Arn
              InputArtifacts:
                - Name: BuildOutput

# CodeCatalyst space configuration
Space:
  Name: MyOrganization
  Description: Development space for my organization
  
Projects:
  - Name: WebApplication
    Description: Customer-facing web application
    
    SourceRepositories:
      - Name: frontend
        Description: React frontend application
      - Name: backend
        Description: Node.js backend API
      - Name: infrastructure
        Description: Infrastructure as code
    
    Workflows:
      - Name: CI-CD-Pipeline
        Definition: .codecatalyst/workflows/ci-cd.yaml
    
    DevEnvironments:
      - Name: development
        InstanceType: dev.standard1.small
        Image: public.ecr.aws/amazonlinux/amazonlinux:2
    
    Issues:
      - Enabled: true
      - Labels: [bug, feature, enhancement]
      - Priorities: [low, medium, high, critical]

# .codecatalyst/workflows/ci-cd.yaml
Name: CI-CD-Pipeline
SchemaVersion: "1.0"

Triggers:
  - Type: PUSH
    Branches:
      - main
      - develop
  - Type: PULLREQUEST
    Branches:
      - main

Actions:
  Build:
    Identifier: aws/build@v1
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo "Installing dependencies"
        - Run: npm install
        - Run: echo "Running tests"
        - Run: npm test
        - Run: echo "Building application"
        - Run: npm run build
    Outputs:
      Artifacts:
        - Name: BuildArtifacts
          Files:
            - "dist/**"
            - "package.json"

  SecurityScan:
    Identifier: aws/managed-test@v1
    DependsOn:
      - Build
    Inputs:
      Sources:
        - WorkflowSource
    Configuration:
      Steps:
        - Run: echo "Running security scan"
        - Run: npm audit
        - Run: echo "Running SAST scan"
        - Run: npm run security-scan

  Deploy-Dev:
    Identifier: aws/build@v1
    DependsOn:
      - Build
      - SecurityScan
    Environment:
      Name: development
      Connections:
        - Name: aws-connection
          Role: CodeCatalystWorkflowDevelopmentRole-MySpace
    Inputs:
      Artifacts:
        - BuildArtifacts
    Configuration:
      Steps:
        - Run: echo "Deploying to development environment"
        - Run: aws s3 sync dist/ s3://my-dev-bucket/
        - Run: aws cloudfront create-invalidation --distribution-id $DEV_DISTRIBUTION_ID --paths "/*"

  Deploy-Prod:
    Identifier: aws/build@v1
    DependsOn:
      - Deploy-Dev
    Environment:
      Name: production
      Connections:
        - Name: aws-connection
          Role: CodeCatalystWorkflowProductionRole-MySpace
    Inputs:
      Artifacts:
        - BuildArtifacts
    Configuration:
      Steps:
        - Run: echo "Deploying to production environment"
        - Run: aws s3 sync dist/ s3://my-prod-bucket/
        - Run: aws cloudfront create-invalidation --distribution-id $PROD_DISTRIBUTION_ID --paths "/*"
    Compute:
      Type: Lambda

# Dev environment configuration
DevEnvironment:
  Name: full-stack-dev
  InstanceType: dev.standard1.medium
  Image: public.ecr.aws/amazonlinux/amazonlinux:2
  
  PersistentStorage:
    SizeInGiB: 16
  
  Ides:
    - Name: VSCode
      Runtime: public.ecr.aws/aws-cloud9/ide:latest
  
  Repositories:
    - Name: frontend
      BranchName: main
    - Name: backend
      BranchName: main
  
  EnvironmentVariables:
    - Name: NODE_ENV
      Value: development
    - Name: API_URL
      Value: http://localhost:3001
  
  Timeout:
    InactivityTimeoutMinutes: 30
    
  PostCreationScript: |
    #!/bin/bash
    # Install Node.js
    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash
    source ~/.bashrc
    nvm install 18
    nvm use 18
    
    # Install dependencies
    cd /projects/frontend && npm install
    cd /projects/backend && npm install
    
    # Start development servers
    cd /projects/backend && npm run dev &
    cd /projects/frontend && npm start

import boto3
import json

def migrate_codestar_to_codecatalyst():
    """
    Migration strategy from CodeStar to CodeCatalyst
    """
    
    # Step 1: Inventory existing CodeStar projects
    codestar_projects = inventory_codestar_projects()
    
    # Step 2: Create CodeCatalyst space
    codecatalyst_space = create_codecatalyst_space()
    
    # Step 3: Migrate each project
    for project in codestar_projects:
        migrate_project(project, codecatalyst_space)
    
    # Step 4: Update team access and permissions
    migrate_team_permissions(codestar_projects, codecatalyst_space)
    
    # Step 5: Validate migration
    validate_migration(codecatalyst_space)

def inventory_codestar_projects():
    """
    Inventory existing CodeStar projects
    """
    
    codestar = boto3.client('codestar')
    
    projects = []
    paginator = codestar.get_paginator('list_projects')
    
    for page in paginator.paginate():
        for project in page['projects']:
            project_details = codestar.describe_project(id=project['projectId'])
            
            # Get project resources
            resources = codestar.list_resources(projectId=project['projectId'])
            
            # Get team members
            team_members = codestar.list_team_members(projectId=project['projectId'])
            
            projects.append({
                'id': project['projectId'],
                'name': project['projectId'],
                'description': project_details['description'],
                'resources': resources['resources'],
                'team_members': team_members['teamMembers'],
                'created_time': project['createdTimeStamp']
            })
    
    return projects

def create_codecatalyst_space():
    """
    Create CodeCatalyst space for migrated projects
    """
    
    # CodeCatalyst space creation (via API or console)
    space_config = {
        'name': 'MigratedFromCodeStar',
        'description': 'Projects migrated from AWS CodeStar',
        'region': 'us-west-2'
    }
    
    return space_config

def migrate_project(codestar_project, codecatalyst_space):
    """
    Migrate individual CodeStar project to CodeCatalyst
    """
    
    migration_plan = {
        'source_repositories': extract_repositories(codestar_project),
        'ci_cd_pipeline': extract_pipeline_config(codestar_project),
        'deployment_targets': extract_deployment_config(codestar_project),
        'team_members': codestar_project['team_members']
    }
    
    # Create CodeCatalyst project
    codecatalyst_project = {
        'name': codestar_project['name'],
        'description': codestar_project['description'],
        'space': codecatalyst_space['name']
    }
    
    # Migrate source repositories
    migrate_repositories(migration_plan['source_repositories'], codecatalyst_project)
    
    # Convert CodePipeline to CodeCatalyst workflow
    migrate_pipeline(migration_plan['ci_cd_pipeline'], codecatalyst_project)
    
    # Set up environments and connections
    setup_environments(migration_plan['deployment_targets'], codecatalyst_project)
    
    return codecatalyst_project

def convert_pipeline_to_workflow(codepipeline_config):
    """
    Convert CodePipeline configuration to CodeCatalyst workflow
    """
    
    workflow = {
        'Name': f"{codepipeline_config['Name']}-workflow",
        'SchemaVersion': '1.0',
        'Triggers': [],
        'Actions': {}
    }
    
    # Convert triggers
    workflow['Triggers'] = [
        {
            'Type': 'PUSH',
            'Branches': ['main']
        }
    ]
    
    # Convert stages to actions
    for stage in codepipeline_config['Stages']:
        stage_name = stage['Name']
        
        if stage_name == 'Source':
            # Source stage becomes trigger
            continue
        elif stage_name == 'Build':
            workflow['Actions']['Build'] = convert_build_stage(stage)
        elif stage_name == 'Test':
            workflow['Actions']['Test'] = convert_test_stage(stage)
        elif stage_name == 'Deploy':
            workflow['Actions']['Deploy'] = convert_deploy_stage(stage)
    
    return workflow

def convert_build_stage(stage):
    """
    Convert CodeBuild stage to CodeCatalyst build action
    """
    
    build_action = stage['Actions'][0]  # Assume single build action
    
    return {
        'Identifier': 'aws/build@v1',
        'Inputs': {
            'Sources': ['WorkflowSource']
        },
        'Configuration': {
            'Steps': [
                'Run: echo "Building application"',
                'Run: npm install',
                'Run: npm run build'
            ]
        },
        'Outputs': {
            'Artifacts': [
                {
                    'Name': 'BuildArtifacts',
                    'Files': ['dist/**', 'package.json']
                }
            ]
        }
    }

def convert_deploy_stage(stage):
    """
    Convert CodeDeploy/CloudFormation stage to CodeCatalyst deploy action
    """
    
    deploy_action = stage['Actions'][0]
    provider = deploy_action['ActionTypeId']['Provider']
    
    if provider == 'CloudFormation':
        return {
            'Identifier': 'aws/build@v1',
            'DependsOn': ['Build'],
            'Environment': {
                'Name': 'production',
                'Connections': [
                    {
                        'Name': 'aws-connection',
                        'Role': 'CodeCatalystWorkflowRole'
                    }
                ]
            },
            'Configuration': {
                'Steps': [
                    'Run: echo "Deploying with CloudFormation"',
                    f"Run: aws cloudformation deploy --template-file {deploy_action['Configuration']['TemplatePath']} --stack-name {deploy_action['Configuration']['StackName']}"
                ]
            }
        }
    
    return {}

# Integration with AWS services through connections
Connections:
  - Name: aws-production
    Type: AWS
    Role: arn:aws:iam::123456789012:role/CodeCatalystProductionRole
    
  - Name: aws-development  
    Type: AWS
    Role: arn:aws:iam::123456789012:role/CodeCatalystDevelopmentRole

Environments:
  development:
    Connections:
      - aws-development
    
  production:
    Connections:
      - aws-production
    ApprovalRequired: true
    Approvers:
      - team-lead
      - devops-engineer

# Workflow using connections
Actions:
  DeployInfrastructure:
    Identifier: aws/build@v1
    Environment:
      Name: production
      Connections:
        - Name: aws-production
    Configuration:
      Steps:
        - Run: |
            aws cloudformation deploy \
              --template-file infrastructure/template.yaml \
              --stack-name myapp-infrastructure \
              --capabilities CAPABILITY_IAM \
              --parameter-overrides Environment=production

# Integration with external services
Actions:
  NotifySlack:
    Identifier: aws/build@v1
    DependsOn:
      - Deploy
    Configuration:
      Steps:
        - Run: |
            curl -X POST -H 'Content-type: application/json' \
              --data '{"text":"Deployment completed successfully!"}' \
              $SLACK_WEBHOOK_URL
    
  UpdateJira:
    Identifier: aws/build@v1
    DependsOn:
      - Deploy
    Configuration:
      Steps:
        - Run: |
            curl -X POST \
              -H "Authorization: Bearer $JIRA_TOKEN" \
              -H "Content-Type: application/json" \
              --data '{"transition":{"id":"31"}}' \
              "https://mycompany.atlassian.net/rest/api/3/issue/$JIRA_ISSUE_KEY/transitions"

# Note: CodeCatalyst primarily uses web console and API
# CLI operations are limited compared to other AWS services

# List spaces (via AWS CLI v2 with CodeCatalyst extension)
aws codecatalyst list-spaces

# Create project (typically done via console or API)
aws codecatalyst create-project \
  --space-name MySpace \
  --display-name "My Project" \
  --description "Project description"