@leverege/build-tools 2.93.0-beta.15 → 2.93.0-beta.2

package/README.md

@@ -18,15 +18,7 @@ npm install -g @leverege/build-tools
 ```bash
   . `build-tools --bashfun`
 ```
-* **docker-to-registry**: used to build and deploy application docker images to the GCP artifact registry
-* **pull-artifact**: used to pull generic artifacts from the GCP artifact registry
-```bash
-Usage: pull-artifact -f <artifact schema file path> -n <package name> -v <package version>
-```
-* **push-artifact**: used to push generic artifacts to the GCP artifact registry
-```bash
-Usage: push-artifact -f <artifact schema file path> -n <package name> -v <package version>
-```
+* **docker-to-registry**: used to build and deploy docker images to the GCP image area
 
 ### Helm Helpers:
 * **overwhelm**: a k8s context helper and yaml replacer *${REPLACE_ME}*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leverege/build-tools",
-  "version": "2.93.0-beta.15",
+  "version": "2.93.0-beta.2",
   "description": "A collection of build / support tools for Leverege developers",
   "main": "index.js",
   "repository": {
@@ -50,13 +50,12 @@
     "npm-link": "src/npm-link.sh",
     "npm-unlink": "src/npm-unlink.sh",
     "overwhelm": "src/overwhelm.mjs",
+    "package-artifact": "src/package-artifact/command.mjs",
     "pkgck": "src/pkgck.sh",
     "pkglint": "src/pkglint.sh",
     "prepack": "src/prepack.mjs",
     "prune-git": "src/prune-git.sh",
-    "pull-artifact": "src/artifacts/pull-artifact.mjs",
     "pull-git": "src/pull-git.sh",
-    "push-artifact": "src/artifacts/push-artifact.mjs",
     "push-my-chart": "src/push-my-chart.mjs",
     "refresh-npm-token": "src/refresh-npm-token.mjs",
     "refresh-py-idx": "src/refresh-py-idx.sh",

package/src/package-artifact/Packager.mjs

@@ -0,0 +1,118 @@
+import crypto from 'crypto'
+import fs from 'fs'
+
+class ArtifactPackager {
+  constructor( artifact ) {
+    this.artifact = artifact
+  }
+  
+  calculateHash() {
+    try {
+      const hash = crypto.createHash( 'sha256' )
+      hash.update( fs.readFileSync( this.artifact.source_path ) )
+      return hash.digest( 'base64url' )
+    } catch ( error ) {
+      throw new Error( `Failed to calculate hash for artifact ${this.artifact.name}: ${error.message}` )
+    }
+  }
+
+  async exists() {
+    throw new Error( 'Not implemented' )
+  }
+
+  async build() {
+    throw new Error( 'Not implemented' )
+  }
+
+  async publish() {
+    throw new Error( 'Not implemented' )
+  }
+
+  async package() {
+    if ( await this.exists() ) {
+      console.log( 'Artifact already exists in the registry' )
+      return false
+    }
+    await this.build()
+    return this.publish()
+  }
+}
+
+class GenericArtifactPackager extends ArtifactPackager {
+
+  async exists() {
+    // Check if artifact already exists in the registry
+    console.log( 'Checking if artifact already exists in the registry...' )
+        
+    const artifactHash = this.calculateHash()
+        
+    const command = `gcloud artifacts files list \
+            --project=${this.artifact.gcp_project_id} \
+            --location=${this.artifact.gcp_location} \
+            --repository=${this.artifact.gcp_artifact_registry_repository_name} \
+            --package=${this.artifact.gcp_artifact_registry_package_name} \
+            --version ${this.artifact.gcp_artifact_registry_package_version} \
+            --filter="name:${this.artifact.destination_path}" \
+            --format="json"`
+    
+    try {
+      const { execSync } = await import( 'child_process' )
+      const result = execSync( command, { encoding : 'utf8', stdio : 'pipe' } )
+
+      // Parse the JSON response
+      const files = JSON.parse( result )
+    
+      // Check if any files were found and match our hash
+      if ( files && files.length > 0 ) {
+        for ( const file of files ) {
+          for ( const hash of file.hashes ) {
+            // Compare without padding since base64url may omit trailing '=' 
+            const normalizedOurHash = artifactHash.replace( /=+$/, '' )
+            const normalizedRegistryHash = hash.value.replace( /=+$/, '' )
+            if ( hash.type === 'SHA256' && normalizedRegistryHash === normalizedOurHash ) {
+              console.log( `Artifact already exists in the registry: ${this.artifact.gcp_artifact_registry_package_name}:${this.artifact.gcp_artifact_registry_package_version}` )
+              return true
+            }
+          }
+        }
+      }
+      console.log( 'Artifact does not exist in the registry' )
+      return false
+          
+    } catch ( error ) {
+      console.error( 'Error checking artifact existence:', error.message )
+      throw error
+    }
+  }
+
+  async build() {
+    return true
+  }
+    
+  async publish() {
+    console.log( 'Publishing artifact to registry...' )
+        
+    const command = `gcloud artifacts generic upload \
+        --project=${this.artifact.gcp_project_id} \
+        --location=${this.artifact.gcp_location} \
+        --repository=${this.artifact.gcp_artifact_registry_repository_name} \
+        --package=${this.artifact.gcp_artifact_registry_package_name} \
+        --version=${this.artifact.gcp_artifact_registry_package_version} \
+        --source=${this.artifact.source_path} \
+        --destination-path=${this.artifact.destination_path}`
+    
+    // console.log( 'Command:', command )
+        
+    try {
+      const { execSync } = await import( 'child_process' )
+      execSync( command, { encoding : 'utf8', stdio : 'pipe' } )
+      console.log( `Successfully published artifact: ${this.artifact.gcp_artifact_registry_package_name}:${this.artifact.gcp_artifact_registry_package_version}` )
+      return true
+    } catch ( error ) {
+      console.error( 'Error publishing artifact:', error.message )
+      return false
+    }
+  }
+}
+
+export { ArtifactPackager, GenericArtifactPackager }

package/src/package-artifact/Structs.mjs

@@ -0,0 +1,60 @@
+import { assign, object, string, array, optional, enums, union } from 'superstruct'
+
+const ArtifactTypeEnum = enums( [ 'generic' ] )
+
+// Superstruct schema for individual artifact configuration
+const PartialArtifactEntrySchema = object( {
+  name : string(),
+  type : optional( ArtifactTypeEnum ),
+  gcp_project_id : optional( string() ),
+  gcp_location : optional( string() ),
+  gcp_artifact_registry_repository_name : optional( string() ),
+  gcp_artifact_registry_package_name : optional( string() ),
+  gcp_artifact_registry_package_version : optional( string() )
+} )
+
+const ArtifactEntrySchema = assign( PartialArtifactEntrySchema, object( {
+  name : string(),
+  type : ArtifactTypeEnum,
+  gcp_project_id : string(),
+  gcp_location : string(),
+  gcp_artifact_registry_repository_name : string(),
+  gcp_artifact_registry_package_name : string(),
+  gcp_artifact_registry_package_version : string()
+} ) )
+
+const PartialGenericArtifactEntrySchema = assign( PartialArtifactEntrySchema, object( {
+  type : enums( [ 'generic' ] ),
+  source_path : string(),
+  destination_path : string()
+} ) )
+
+const GenericArtifactEntrySchema = assign( ArtifactEntrySchema, object( {
+  source_path : string(),
+  destination_path : string()
+} ) )
+
+// Superstruct schema for defaults configuration
+const DefaultsSchema = object( {
+  gcp_project_id : optional( string() ),
+  gcp_location : optional( string() ),
+  gcp_artifact_registry_repository_name : optional( string() ),
+  gcp_artifact_registry_package_name : optional( string() ),
+  gcp_artifact_registry_package_version : optional( string() )
+} )
+
+// Superstruct schema for the complete artifacts configuration with defaults
+const ArtifactEntriesSchema = object( {
+  defaults : DefaultsSchema,
+  artifacts : array( union( [ PartialArtifactEntrySchema, PartialGenericArtifactEntrySchema ] ) )
+} )
+
+const FlattenedArtifactEntriesSchema = array( assign( union( [ ArtifactEntrySchema, GenericArtifactEntrySchema ] ) ) )
+
+export {
+  ArtifactEntriesSchema,
+  FlattenedArtifactEntriesSchema,
+  ArtifactEntrySchema,
+  DefaultsSchema,
+  GenericArtifactEntrySchema,
+}

package/src/package-artifact/Utils.mjs

@@ -0,0 +1,49 @@
+import { validate } from 'superstruct'
+
+import { parseYamlFile, warning } from '../Utils.mjs'
+
+import { ArtifactEntriesSchema, GenericArtifactEntrySchema } from './Structs.mjs'
+
+const getArtifactEntriesSchema = async ( artifactsConfigPath = './artifacts.yml' ) => {
+  const artifactsConfig = await parseYamlFile( artifactsConfigPath )
+  const [ error, result ] = validate( artifactsConfig, ArtifactEntriesSchema )
+  if ( error ) {
+    throw new Error( `Invalid artifacts.yml file: ${error.message}` )
+  }
+  return result
+}
+
+const flattenArtifactEntriesSchema = ( artifactsSchema ) => {
+  return artifactsSchema.artifacts.reduce( ( flattenedArtifacts, artifact ) => {
+    const mergedArtifact = {
+      ...artifactsSchema.defaults,
+      ...artifact
+    }
+    
+    let schema
+    switch ( mergedArtifact.type ) {
+      case 'generic':
+        schema = GenericArtifactEntrySchema
+        break
+      default:
+        warning( `Unsupported artifact type "${mergedArtifact.type}"` )
+        break
+    }
+
+    if ( !schema ) {
+      warning( `Invalid artifact type "${mergedArtifact.type}"` )
+      return flattenedArtifacts
+    }
+    
+    const [ error, validatedArtifact ] = validate( mergedArtifact, schema )
+    
+    if ( error ) {
+      warning( `Invalid artifact "${mergedArtifact.name}": ${error.message}` )
+      return flattenedArtifacts
+    }
+    
+    return [ ...flattenedArtifacts, validatedArtifact ]
+  }, [] )
+}
+
+export { getArtifactEntriesSchema, flattenArtifactEntriesSchema }

package/src/package-artifact/command.mjs

@@ -0,0 +1,49 @@
+import { warning } from '../Utils.mjs'
+
+import { getArtifactEntriesSchema, flattenArtifactEntriesSchema } from './Utils.mjs'
+import { GenericArtifactEntryPackager } from './Packager.mjs'
+
+async function main() {
+
+  // If an argument is provided, use it as the artifacts.yml file path
+  const artifactsYmlPath = process.argv[2]
+  const artifactPackageName = process.argv[3]
+  const artifactPackageVersion = process.argv[4]
+
+  if ( artifactsYmlPath ) {
+    const artifactsSchema = await getArtifactEntriesSchema( artifactsYmlPath )
+    const flattenedArtifactsSchema = flattenArtifactEntriesSchema( artifactsSchema )
+    
+    // Open for unexpected matches if we end up re-using the same package name and version for
+    // multiple artifacts spread across multiple repositories and/or projects.
+    const filteredArtifactSchemas = flattenedArtifactsSchema.filter(
+      artifact => artifact.gcp_artifact_registry_package_name === artifactPackageName &&
+      artifact.gcp_artifact_registry_package_version === artifactPackageVersion )
+    
+    if ( filteredArtifactSchemas.length === 0 ) {
+      console.error( `No artifact entries found for ${artifactPackageName} version ${artifactPackageVersion} in ${artifactsYmlPath}` )
+      process.exit( 1 )
+    }
+    for ( const artifactSchema of filteredArtifactSchemas ) {
+      let packager
+      switch ( artifactSchema.type ) {
+        case 'generic':
+          packager = new GenericArtifactEntryPackager( artifactSchema )
+          break
+        default:
+          warning( `Unsupported artifact type "${artifactSchema.type}"` )
+          continue
+      }
+      
+      if ( !packager ) {
+        warning( `Unsupported artifact type "${artifactSchema.type}"` )
+        continue
+      }
+      
+      // eslint-disable-next-line no-await-in-loop
+      await packager.package()
+    }
+  }
+}
+
+main()

package/src/artifacts/ArtifactPuller.mjs

@@ -1,155 +0,0 @@
-/* eslint-disable security/detect-non-literal-fs-filename */
-import fs from 'node:fs'
-
-import { shellCmd, log, debug, err } from '../Utils.mjs'
-
-import { toExplicitPath } from './Utils.mjs'
-
-class ArtifactPuller {
-  constructor( artifact ) {
-    this.artifact = artifact
-  }
-
-  async pull() {
-    throw new Error( 'Not implemented' )
-  }
-}
-
-class GenericArtifactPuller extends ArtifactPuller {
-
-  async downloadFile( remoteFilePath, localFilePath ) {
-    debug( { remoteFilePath, localFilePath }, '<==Download File' )
-
-    const command = `gcloud artifacts generic download \
-      --project=${this.artifact.gcp_project_id} \
-      --location=${this.artifact.gcp_location} \
-      --repository=${this.artifact.gcp_artifact_registry_repository_name} \
-      --package=${this.artifact.gcp_artifact_registry_package_name} \
-      --version=${this.artifact.gcp_artifact_registry_package_version} \
-      --name="${remoteFilePath}" \
-      --destination=/tmp`
-
-    const oldPath = `/tmp/${remoteFilePath.split( '/' ).pop()}`
-    const newPath = localFilePath
-
-    // if file exists in the old path, delete it
-    if ( fs.existsSync( oldPath ) ) {
-      fs.unlinkSync( oldPath )
-    }
-
-    // if file exists in the new path, delete it
-    if ( fs.existsSync( newPath ) ) {
-      fs.unlinkSync( newPath )
-    }
-
-    // Ensure the directory exists
-    fs.mkdirSync( localFilePath.split( '/' ).slice( 0, -1 ).join( '/' ), { recursive : true } )
-
-    debug( { command }, '<==Download File Command' )
-
-    await shellCmd( command )
-
-    // Check if file exists in the old path
-    if ( !fs.existsSync( oldPath ) ) {
-      debug( { oldPath }, '<==File does not exist in the old path' )
-      return false
-    }
-
-    debug( { oldPath, newPath }, '<==Copying file' )
-
-    await fs.copyFileSync( oldPath, newPath )
-
-    // Check if file exists in the new path
-    if ( !fs.existsSync( newPath ) ) {
-      debug( { newPath }, '<==File does not exist in the new path' )
-      return false
-    }
-
-    return true
-  }
-
-  async downloadDirectory( localPath ) {
-    const command = `gcloud artifacts generic download \
-      --project=${this.artifact.gcp_project_id} \
-      --location=${this.artifact.gcp_location} \
-      --repository=${this.artifact.gcp_artifact_registry_repository_name} \
-      --package=${this.artifact.gcp_artifact_registry_package_name} \
-      --version=${this.artifact.gcp_artifact_registry_package_version} \
-      --destination=${localPath}`
-
-    debug( { command }, '<==Download Directory Command' )
-
-    await shellCmd( command )
-  }
-
-  async downloadNestedDirectory( remotePath, localPath ) {
-    debug( { remotePath, localPath }, '<==Download Nested Directory' )
-
-    const files = await this.listFiles( remotePath )
-    await Promise.all(
-      files
-        .filter( file => file.name.split( ':' ).pop().replaceAll( '%2F', '/' ).startsWith( remotePath ) )
-        .map( async ( file ) => {
-          const remoteFilePath = file.name.split( ':' ).pop().replaceAll( '%2F', '/' )
-          const localFilePath = `${localPath}${remoteFilePath.replaceAll( remotePath, '' )}`
-          await this.downloadFile( remoteFilePath, localFilePath )
-        } )
-    )
-  }
-
-  async listFiles( ) {
-    const command = `gcloud artifacts files list \
-        --project=${this.artifact.gcp_project_id} \
-        --location=${this.artifact.gcp_location} \
-        --repository=${this.artifact.gcp_artifact_registry_repository_name} \
-        --package=${this.artifact.gcp_artifact_registry_package_name} \
-        --version ${this.artifact.gcp_artifact_registry_package_version} \
-        --format="json"`
-
-    debug( { command }, '<==List Files Command' )
-      
-    const result = await shellCmd( command )
-  
-    // Parse the JSON response
-    const files = JSON.parse( result )
-    return files
-  }
-
-  async pull() {
-    log( `Pulling artifact: ${this.artifact.name}` )
-    
-    debug( { artifact : this.artifact }, '<==Pulling artifact' )
-
-    try {
-      if ( this.artifact.remote_file_path && this.artifact.local_file_path ) {
-        await this.downloadFile( this.artifact.remote_file_path, toExplicitPath( this.artifact.local_file_path ) )
-      } else if ( this.artifact.remote_file_path && this.artifact.local_path ) {
-        await this.downloadFile( this.artifact.remote_file_path, toExplicitPath( `${this.artifact.local_path}/${this.artifact.remote_file_path.split( '/' ).pop()}` ) )
-      } else if ( this.artifact.remote_path && this.artifact.local_path ) {
-        await this.downloadNestedDirectory( this.artifact.remote_path, toExplicitPath( this.artifact.local_path ) )
-      } else if ( this.artifact.remote_path && !this.artifact.local_path && !this.artifact.local_file_path ) {
-        await this.downloadDirectory( this.artifact.remote_path, '.' )
-      } else if ( !this.artifact.remote_path && !this.artifact.remote_file_path && this.artifact.local_path ) {
-        await this.downloadDirectory( toExplicitPath( this.artifact.local_path ) )
-      } else {
-        throw new Error( 'No valid paths provided' )
-      }
-
-      log( `Successfully pulled artifact: ${this.artifact.name}` )
-
-      return true
-      
-      // if ( !this.artifact.remote_path && !this.artifact.remote_file_path && this.local_file_path ) {
-      //   throw new Error( '' )
-      // }
-      // if ( this.artifact.remote_path && this.artifact.local_file_path ) {
-      //   throw new Error( '' )
-      // }
-    } catch ( error ) {
-      err( `Error pulling artifact: ${this.artifact.name} ${error.message}` )
-    }
-    return false
-  }
-}
-
-export { ArtifactPuller, GenericArtifactPuller }

package/src/artifacts/ArtifactPusher.mjs

@@ -1,84 +0,0 @@
-/* eslint-disable security/detect-non-literal-fs-filename */
-import { shellCmd, log, err, debug } from '../Utils.mjs'
-
-class ArtifactPusher {
-  constructor( artifact ) {
-    this.artifact = artifact
-  }
-
-  async push() {
-    throw new Error( 'Not implemented' )
-  }
-}
-
-class GenericArtifactPusher extends ArtifactPusher {
-
-  async listFiles( ) {
-    const command = `gcloud artifacts files list \
-        --project=${this.artifact.gcp_project_id} \
-        --location=${this.artifact.gcp_location} \
-        --repository=${this.artifact.gcp_artifact_registry_repository_name} \
-        --package=${this.artifact.gcp_artifact_registry_package_name} \
-        --version ${this.artifact.gcp_artifact_registry_package_version} \
-        --format="json"`
-
-    debug( { command }, '<==List Files Command' )
-      
-    const result = await shellCmd( command )
-  
-    // Parse the JSON response
-    const files = JSON.parse( result )
-
-    return files
-  }
-    
-  async push() {
-    log( `Pushing artifact: ${this.artifact.name}` )
-
-    if ( this.artifact.remote_file_path ) {
-      err( 'Remote file path is not supported for pushing artifacts' )
-      return false
-    }
-
-    try {
-   
-      let command = ''
-
-      command = `gcloud artifacts generic upload \
-      --project=${this.artifact.gcp_project_id} \
-      --location=${this.artifact.gcp_location} \
-      --repository=${this.artifact.gcp_artifact_registry_repository_name} \
-      --package=${this.artifact.gcp_artifact_registry_package_name} \
-      --version=${this.artifact.gcp_artifact_registry_package_version}`
-
-      if ( this.artifact.local_path ) {
-        command += ` --source-directory=${this.artifact.local_path}`
-        command += ' --skip-existing'
-      } else if ( this.artifact.local_file_path ) {
-        const files = await this.listFiles( this.artifact.remote_path )
-        if ( files.some( file => file.name.split( ':' ).pop().replaceAll( '%2F', '/' ) === `${this.artifact.remote_path}/${this.artifact.remote_file_path.split( '/' ).pop()}` ) ) {
-          err( `File already exists in the artifact registry: ${this.artifact.local_file_path}` )
-          return false
-        }
-        command += ` --source=${this.artifact.local_file_path}`
-      }
-
-      if ( this.artifact.remote_path ) {
-        command += ` --destination-path=${this.artifact.remote_path}`
-      }
-
-      debug( { command }, '<==Upload Command' )
-        
-      await shellCmd( command )
-      
-      log( `Successfully pushed artifact: ${this.artifact.name}` )
-
-      return true
-    } catch ( error ) {
-      err( `Error pushing artifact: ${this.artifact.name} ${error.message}` )
-      return false
-    }
-  }
-}
-
-export { ArtifactPusher, GenericArtifactPusher }

package/src/artifacts/Structs.mjs

@@ -1,91 +0,0 @@
-import { assign, object, string, array, optional, enums, union, refine } from 'superstruct'
-
-const ArtifactTypeEnum = {
-  GENERIC : 'generic',
-}
-
-// Superstruct schema for individual artifact configuration
-const PartialArtifactSchema = object( {
-  name : string(),
-  type : optional( enums( Object.values( ArtifactTypeEnum ) ) ),
-  gcp_project_id : optional( string() ),
-  gcp_location : optional( string() ),
-  gcp_artifact_registry_repository_name : optional( string() ),
-  gcp_artifact_registry_package_name : optional( string() ),
-  gcp_artifact_registry_package_version : optional( string() )
-} )
-
-const ArtifactSchema = assign( PartialArtifactSchema, object( {
-  name : string(),
-  type : enums( Object.values( ArtifactTypeEnum ) ),
-  gcp_project_id : string(),
-  gcp_location : string(),
-  gcp_artifact_registry_repository_name : string(),
-  gcp_artifact_registry_package_name : string(),
-  gcp_artifact_registry_package_version : string()
-} ) )
-
-const PartialGenericArtifactSchema = refine(
-  assign( PartialArtifactSchema, object( {
-    type : enums( [ ArtifactTypeEnum.GENERIC ] ),
-    local_file_path : optional( string() ),
-    local_path : optional( string() ),
-    remote_file_path : optional( string() ),
-    remote_path : optional( string() )
-  } ) ),
-  'ConflictingPaths',
-  ( value ) => {
-    if ( value.local_file_path && value.local_path ) {
-      return 'Only one of local_file_path or local_path must be provided'
-    }
-    if ( value.remote_file_path && value.remote_path ) {
-      return 'Only one of remote_file_path or remote_path must be provided'
-    }
-    return true
-  }
-)
-
-const GenericArtifactSchema = refine(
-  assign( ArtifactSchema, object( {
-    local_file_path : optional( string() ),
-    local_path : optional( string() ),
-    remote_file_path : optional( string() ),
-    remote_path : optional( string() )
-  } ) ),
-  'ConflictingPaths',
-  ( value ) => {
-    if ( value.local_file_path && value.local_path ) {
-      return 'Only one of local_file_path or local_path must be provided'
-    }
-    if ( value.remote_file_path && value.remote_path ) {
-      return 'Only one of remote_file_path or remote_path must be provided'
-    }
-    return true
-  }
-)
-
-// Superstruct schema for defaults configuration
-const DefaultsSchema = object( {
-  gcp_project_id : optional( string() ),
-  gcp_location : optional( string() ),
-  gcp_artifact_registry_repository_name : optional( string() ),
-  gcp_artifact_registry_package_name : optional( string() ),
-  gcp_artifact_registry_package_version : optional( string() )
-} )
-
-// Superstruct schema for the complete artifacts configuration with defaults
-const ArtifactsSchema = object( {
-  defaults : optional( DefaultsSchema ),
-  artifacts : array( union( [ PartialArtifactSchema, PartialGenericArtifactSchema ] ) )
-} )
-
-const FlattenedArtifactsSchema = array( assign( union( [ ArtifactSchema, GenericArtifactSchema ] ) ) )
-
-export {
-  ArtifactTypeEnum,
-  ArtifactsSchema,
-  FlattenedArtifactsSchema,
-  ArtifactSchema,
-  DefaultsSchema,
-  GenericArtifactSchema,
-}

package/src/artifacts/Utils.mjs

@@ -1,84 +0,0 @@
-import fs from 'node:fs'
-import crypto from 'crypto'
-
-import { validate } from 'superstruct'
-
-import { parseYamlFile, warning } from '../Utils.mjs'
-
-import { ArtifactTypeEnum, ArtifactsSchema, GenericArtifactSchema } from './Structs.mjs'
-
-const getArtifactsSchema = async ( artifactsFilePath = './artifacts.yml' ) => {
-  const artifactsConfig = await parseYamlFile( artifactsFilePath )
-  const [ error, result ] = validate( artifactsConfig, ArtifactsSchema )
-  if ( error ) {
-    throw new Error( `Invalid artifacts.yml file: ${error.message}` )
-  }
-  return result
-}
-
-const flattenArtifactsSchema = ( artifactsSchema ) => {
-  return artifactsSchema.artifacts.reduce( ( flattenedArtifacts, artifact ) => {
-    const mergedArtifact = {
-      ...artifactsSchema.defaults,
-      ...artifact
-    }
-    
-    let schema
-    switch ( mergedArtifact.type ) {
-      case ArtifactTypeEnum.GENERIC:
-        schema = GenericArtifactSchema
-        break
-      default:
-        warning( `Unsupported artifact type "${mergedArtifact.type}"` )
-        break
-    }
-
-    if ( !schema ) {
-      warning( `Invalid artifact type "${mergedArtifact.type}"` )
-      return flattenedArtifacts
-    }
-    
-    const [ error, validatedArtifact ] = validate( mergedArtifact, schema )
-    
-    if ( error ) {
-      warning( `Invalid artifact "${mergedArtifact.name}": ${error.message}` )
-      return flattenedArtifacts
-    }
-    
-    return [ ...flattenedArtifacts, validatedArtifact ]
-  }, [] )
-}
-
-const toImplicitPath = ( path ) => {
-  let implicitPath = path
-  // Remove leading './' if present
-  if ( implicitPath.startsWith( './' ) ) {
-    implicitPath = implicitPath.slice( 2 )
-  }
-  // Remove trailing slash
-  implicitPath = implicitPath.replace( /\/+$/, '' )
-  return implicitPath
-}
-
-const toExplicitPath = ( path ) => {
-  let explicitPath = path
-  // Keep absolute paths and paths already starting with '.' as-is
-  if ( !path.startsWith( '/' ) && !path.startsWith( '.' ) ) {
-    // Add './' to relative paths
-    explicitPath = `./${explicitPath}`
-  }
-  return explicitPath
-}
-
-const calculateHash = ( path ) => {
-  try {
-    const hash = crypto.createHash( 'sha256' )
-    hash.update( fs.readFileSync( path ) )
-    return hash.digest( 'base64url' )
-  } catch ( error ) {
-    console.error( error )
-    throw new Error( `Failed to calculate hash for artifact ${path}: ${error.message}` )
-  }
-}
-
-export { calculateHash, getArtifactsSchema, flattenArtifactsSchema, toImplicitPath, toExplicitPath }

package/src/artifacts/pull-artifact.mjs

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { program } from 'commander'
-
-import { warning, log } from '../Utils.mjs'
-
-import { getArtifactsSchema, flattenArtifactsSchema } from './Utils.mjs'
-import { ArtifactTypeEnum } from './Structs.mjs'
-import { GenericArtifactPuller } from './ArtifactPuller.mjs'
-
-program
-  .name( 'pull-artifact' )
-  .description( 'Pull artifacts from GCP Artifact Registry' )
-  .requiredOption( '-f, --file-path <path>', 'Path to artifacts.yaml file' )
-  .option( '-n, --package-name <name>', 'Filter by artifact package name' )
-  .option( '-v, --package-version <version>', 'Filter by artifact package version' )
-  .parse()
-
-const options = program.opts()
-
-async function main() {
-  const artifactsYmlPath = options.filePath
-  const artifactPackageName = options.packageName || null
-  const artifactPackageVersion = options.packageVersion || null
-  
-  const artifactsSchema = await getArtifactsSchema( artifactsYmlPath )
-  const flattenedArtifactsSchema = flattenArtifactsSchema( artifactsSchema )
-  
-  let filteredArtifactsSchema
-  if ( artifactPackageName && artifactPackageVersion ) {
-    filteredArtifactsSchema = flattenedArtifactsSchema.filter(
-      artifact => artifact.gcp_artifact_registry_package_name === artifactPackageName &&
-      artifact.gcp_artifact_registry_package_version === artifactPackageVersion )
-  } else if ( artifactPackageName ) {
-    filteredArtifactsSchema = flattenedArtifactsSchema.filter(
-      artifact => artifact.gcp_artifact_registry_package_name === artifactPackageName )
-  } else {
-    filteredArtifactsSchema = flattenedArtifactsSchema
-  }
-  
-  let counter = 0
-
-  const pullResults = await Promise.all(
-    filteredArtifactsSchema.map( async ( artifactSchema ) => {
-      let puller
-      switch ( artifactSchema.type ) {
-        case ArtifactTypeEnum.GENERIC:
-          puller = new GenericArtifactPuller( artifactSchema )
-          break
-        default:
-          warning( `Unsupported artifact type "${artifactSchema.type}"` )
-          return false
-      }
-
-      if ( !puller ) {
-        warning( `Unsupported artifact type "${artifactSchema.type}"` )
-        return false
-      }
-
-      try {
-        return await puller.pull()
-      } catch ( error ) {
-        warning( `Error pulling artifact "${artifactSchema.name}": ${error.message}` )
-        return false
-      }
-    } )
-  )
-
-  counter = pullResults.filter( Boolean ).length
-
-  log( `Successfully pulled ${counter}/${filteredArtifactsSchema.length} artifacts` )
-}
-
-main()

package/src/artifacts/push-artifact.mjs

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-
-import { program } from 'commander'
-
-import { warning, log } from '../Utils.mjs'
-
-import { getArtifactsSchema, flattenArtifactsSchema } from './Utils.mjs'
-import { ArtifactTypeEnum } from './Structs.mjs'
-import { GenericArtifactPusher } from './ArtifactPusher.mjs'
-
-program
-  .name( 'push-artifact' )
-  .description( 'Push artifacts to GCP Artifact Registry' )
-  .requiredOption( '-f, --file-path <path>', 'Path to artifacts.yaml file' )
-  .option( '-n, --package-name <name>', 'Filter by artifact package name' )
-  .option( '-v, --package-version <version>', 'Filter by artifact package version' )
-  .parse()
-
-const options = program.opts()
-
-async function main() {
-  const artifactsYmlPath = options.filePath
-  const artifactPackageName = options.packageName || null
-  const artifactPackageVersion = options.packageVersion || null
-  
-  const artifactsSchema = await getArtifactsSchema( artifactsYmlPath )
-  const flattenedArtifactsSchema = flattenArtifactsSchema( artifactsSchema )
-  
-  let filteredArtifactsSchema
-  if ( artifactPackageName && artifactPackageVersion ) {
-    filteredArtifactsSchema = flattenedArtifactsSchema.filter(
-      artifact => artifact.gcp_artifact_registry_package_name === artifactPackageName &&
-      artifact.gcp_artifact_registry_package_version === artifactPackageVersion )
-  } else if ( artifactPackageName ) {
-    filteredArtifactsSchema = flattenedArtifactsSchema.filter(
-      artifact => artifact.gcp_artifact_registry_package_name === artifactPackageName )
-  } else {
-    filteredArtifactsSchema = flattenedArtifactsSchema
-  }
-
-  let counter = 0
-
-  const pushResults = await Promise.all(
-    filteredArtifactsSchema.map( async ( artifactSchema ) => {
-      let pusher
-      switch ( artifactSchema.type ) {
-        case ArtifactTypeEnum.GENERIC:
-          pusher = new GenericArtifactPusher( artifactSchema )
-          break
-        default:
-          warning( `Unsupported artifact type "${artifactSchema.type}"` )
-          return false
-      }
-
-      if ( !pusher ) {
-        warning( `Unsupported artifact type "${artifactSchema.type}"` )
-        return false
-      }
-
-      try {
-        return await pusher.push()
-      } catch ( error ) {
-        warning( `Error pushing artifact "${artifactSchema.name}": ${error.message}` )
-        return false
-      }
-    } )
-  )
-
-  counter = pushResults.filter( Boolean ).length
-
-  log( `Successfully pushed ${counter}/${filteredArtifactsSchema.length} artifacts` )
-}
-
-main()