Wrong object in pipeline when trying to use Get-ChildItem piped to Copy-Item and using $PSItem

Provide the full path of the destination files via a calculated property named Destination to your Copy-Item call, which makes the pipeline input bind to the -Destination parameter:

Get-ChildItem -LiteralPath 'C:\path\to\folder' -Recurse -Filter 'target-file.ps1' |
  Select-Object @{ Name='Destination'; Expression={ $_.FullName } } |  
  Copy-Item -LiteralPath $sourceFile -Force -PassThru -WhatIf

^{Note: The -WhatIf common parameter in the command above previews the operation. Remove -WhatIf and re-execute once you're sure the operation will do what you want.}

As for what you tried:

• A given cmdlet's pipeline-binding parameters must be bound either via the pipeline or via an argument; if you try both, you'll get the error you saw.

  • See the bottom section of this answer for how to discover a given cmdlet's pipeline-binding parameters.

  • Re your ... | Copy-Item -Path $sourceFile -Destination $PSItem attempts:

    • The Copy-Item call is complete without pipeline input, and the conflicting attempt to also bind parameters via the pipeline therefore fails:

      • In Version 1, the (filtered) Get-ChildItem input binds to Copy-Item's -LiteralPath parameter (see this answer), which conflicts with the bound-by-argument -Path parameter.

      • In Version 2, the string pipeline input binds to Copy-Item's -Path parameter, which conflicts with that parameter already having been bound by argument.

  • Re your ... | Write-Host $PSItem attempt:

    • In Version 3, the pipeline input binds to Write-Host's -Object parameter, which conflicts with that parameter already having been bound by argument, positionally.

  • Re your Version 4:

    • You're passing only an argument to Write-Host - and not also pipeline input - which is why the calls succeed.

    • As an aside: Write-Host is typically the wrong tool to use, unless the intent is to write to the display only, bypassing the success output stream and with it the ability to send output to other commands, capture it in a variable, redirect it to a file. To output a value, use it by itself; e.g., $value instead of Write-Host $value (or use Write-Output $value, though that is rarely needed). See also: the bottom section of this answer.

• The automatic $PSItem variable (as well as its more commonly used alias, $_) cannot meaningfully be used outside script blocks ({ ... }) - see this answer.

A note on terminology:

• A parameter is a formal placeholder declared by a command (cmdlet, function, or script) that represents input data to operate on at runtime.

• Binding a parameter is the act of assigning a value to it, i.e. the act of instantiating a placeholder.

  • Note that binding fundamentally only succeeds if the value to be assigned is either of the same type as the parameter or convertible to the latter.

• There two binding mechanisms:

  • By argument, i.e. as a whitespace-separated token following the command name or path; e.g.:

    Write-Host -Object hi!
    

    • Because the argument above (the string `'hi!') is preceded by the name of the target parameter, it is called a named argument.

    • Many commands also accept arguments without indicating the target parameter, in which case it is the argument's position among other such arguments, if any, that implies the target parameter; therefore passing values this way is called a positional argument, but note any parameters targeted this way must have been declared as positional, i.e. must be positional parameters; e.g.:

       # Target parameter -Object is positionally implied.
       Write-Host hi!
      

  • Via the pipeline, i.e. via the output of another command or expression provided as input via |, the pipeline operator; e.g.:

    # Target parameter -Object is implied by the data type
    # of the pipeline input data.
    'hi!' | Write-Host
    

    • Parameters that can be bound by pipeline input must be declared as such and are called pipeline-binding parameters. Pipeline input can be bound by value, i.e. using each input object as a whole, or by property value, i.e. by the value of the property of each input object whose name is the same as the target parameter's (or any of its aliases).

      • E.g., The -Id parameter of Get-Process is declared as accepting pipeline input by property value, which means that input objects that either have an .Id property or a .PID property (because -PID is an alias of -Id) are bound to it; e.g., the following two commands are equivalent to Get-Process -Id $PID:

         # By-property-value pipeline binding to parameter -Id
         [pscustomobject] @{ Id = $PID } | Get-Process
        
         # Ditto, via parameter alias -PID.
         [pscustomobject] @{ PID = $PID } | Get-Process
        

    • Note that binding by pipeline means that each input object supplies a value to the target parameter, which in turn means that the target command must be designed to process pipeline input object by object. In the case of functions and scripts, i.e. commands written in PowerShell, a process block is required - see the relevant section of the conceptual about_Functions help topic.

      • E.g., in terms of output, 'hi', 'there' | Write-Host is equivalent to Write-Host 'hi'; Write-Host 'there', because the -Object parameter is bound twice with pipeline binding, once for each input string.

    • As noted, this answer has instructions on how to discover a given command's pipeline-binding parameters, if any, as well as their data types.

• Note:

  • In a given call, a given parameter can only be bound by one of the binding mechanisms. Attempting to do both results in the The input object cannot be bound to any parameters for the command ... error you saw.

  • By contrast, combining the two binding mechanism to target different parameters is a very common and useful technique.

  • Binding by argument happens first, followed by binding via the pipeline, once for each input object.

    • Only parameters that haven't already been bound by arguments are candidates for pipeline binding.