What if instead of a CLI, Plugins? Part 4, Prebuild plugins & misc

//Plugin and target in same package example 
        .executableTarget(
            name:"plugin-tester",
            dependencies: [
                .product(name: "ArgumentParser", package: "swift-argument-parser"),
            ],
            path:"Sources/PluginTesterCLI",
            exclude: ["Data"],
            plugins: ["MyInBuildPlugin", "MyPreBuildPlugin"]
        ),
        //...
        .plugin(name: "MyPreBuildPlugin", capability: .buildTool()),
        //...

└── MyFancyPackage
    └── Plugins
    │   └── MyPreBuildPlugin
    │       └──plugin.swift
    └── Package.swift
    └── .git
    └── .gitignore

   func zipFileCommand(outputDir:Path, folderToZip:Path) -> PackagePlugin.Command {
        let parentDirectory = folderToZip.removingLastComponent().string
        let folderOnly = folderToZip.lastComponent

        let zipNCleanCommand = "cd \(parentDirectory) && zip -r \(outputDir)/snapshot_$(date +'%Y-%m-%dT%H-%M-%S').zip \(folderOnly) && cd - && cd \(outputDir) && ls -1t | tail -n +6 | xargs rm -f"
        
        return .prebuildCommand(
            displayName: "------------ MyPreBuildPlugin ------------",
            executable: .init("/bin/zsh"), //also Path("/bin/zsh")
            arguments: ["-c", zipNCleanCommand],
            //environment: [:], in case it's needed... 
            outputFilesDirectory: outputDir)
        
    }

 //...
@main
struct MyPreBuildPlugin:BuildToolPlugin {
    func createBuildCommands(context: PackagePlugin.PluginContext, target: PackagePlugin.Target) async throws -> [PackagePlugin.Command] {   
        let outputDir = context.pluginWorkDirectory
        let folderToZip = Path("/Users/{your path here}/TestZipFolder") 
        print("from MPBP:", outputDir)
        return [ zipFileCommand(outputDir: outputDir, folderToZip: folderToZip)]
    }
}
#if canImport(XcodeProjectPlugin)
import XcodeProjectPlugin

extension MyPreBuildPlugin: XcodeBuildToolPlugin {
    // Entry point for creating build commands for targets in Xcode projects.
    func createBuildCommands(context: XcodePluginContext, target: XcodeTarget) throws -> [Command] {
        let outputDir = context.pluginWorkDirectory
        let folderToZip = context.xcodeProject.directory.appending([target.displayName])
       print("from MPBP:", outputDir)
       return [ zipFileCommand(outputDir: outputDir, folderToZip: folderToZip)]
    }
}

#endif

/usr/bin/sandbox-exec -p "(version 1)
(deny default)
(import \"system.sb\")
(allow file-read*)
(allow process*)
(allow mach-lookup (global-name \"com.apple.lsd.mapdb\"))
(allow file-write*
    (subpath \"/private/tmp\")
    (subpath \"/private/var/folders/px/cd_t0mkd6gq0ntb0v6kqj__00000gn/T\")
)
(deny file-write*
    (subpath \"/Users/{...}/Developer/GitHub/PluginExplorer\")
)
(allow file-write*
    (subpath \"/Users/{...}/DerivedData/PluginExplorer-dikuycmkyjcfkhffudvbwxrkjxih/SourcePackages/plugins/pluginexplorer.output/plugin-tester/MyPreBuildPlugin\")
)
" /bin/zsh -c "cd /Users/{...}/Developer/GitHub && zip -r /Users/{...}/Library/Developer/Xcode/DerivedData/PluginExplorer-dikuycmkyjcfkhffudvbwxrkjxih/SourcePackages/plugins/pluginexplorer.output/plugin-tester/MyPreBuildPlugin/snapshot_$(date +'%Y-%m-%dT%H-%M-%S').zip TestZipFolder && cd - && cd /Users/{...}/Library/Developer/Xcode/DerivedData/PluginExplorer-dikuycmkyjcfkhffudvbwxrkjxih/SourcePackages/plugins/pluginexplorer.output/plugin-tester/MyPreBuildPlugin && ls -1t | tail -n +6 | xargs rm -f"

  adding: TestZipFolder/ (stored 0%)
  adding: TestZipFolder/robot_stylized_bc.png (deflated 3%)
  adding: TestZipFolder/robot_realistic_m.png (deflated 0%)
  adding: TestZipFolder/robot_stylized_m.png (deflated 24%)
  adding: TestZipFolder/robot_papercraft_r.png (deflated 0%)

        // could also try some  Path("/Users/{---}/")
        let outputDir = context.package.directory.appending(["Storage"])
        
        let inputDir = target.directory

zip I/O error: Operation not permitted
zip error: Could not create output file

## plugin-tester is the name of the executable target the 
## prebuild plugin is attached to. 
cd $TARGET_PACKAGE
swift run  plugin-tester ## get same message
swift run --disable-sandbox plugin-tester ## smooth sailing
ls Storage ## archive should be listed

//
//  CustomBuildNRun.swift
//
//
//  Created by Carlyn Maw on 1/29/24.
//  
//

//Use style ONE  or TWO, not both like the below.

import PackagePlugin
import Foundation

@main
struct CustomBuildNRun: CommandPlugin {
    // Entry point for command plugins applied to Swift Packages.
    func performCommand(context: PackagePlugin.PluginContext, arguments: [String]) async throws {

        //DO WORK
        
        let targetToRunName = "DemoFruitStore"
        let arguments = ["fruit_list", "citrus"]
        
        let parameters = PackageManager.BuildParameters()
        //parameters.logging = printCommands ? .verbose : .concise
        //parameters.configuration = release ? .release : .debug
        //print(parameters)
        
        //------------------------------------  STYLE ONE
        //rebuilds EVERYBODY, result has all the artifacts from every
        //plugin, etc.
        let result = try packageManager.build(.all(includingTests: false), parameters: parameters)
        print(result.logText)
        print("-----------")
        print(result.builtArtifacts)
        if result.succeeded {
            if let resultToRun = result.builtArtifacts.first(where: {
                $0.kind == .executable && $0.path.lastComponent == targetToRunName
            }) {
                let message = try runProcess(URL(fileURLWithPath: resultToRun.path.string), arguments: arguments)
                print(message)
            }
        }
        
        //------------------------------------  END STYLE ONE
        
        //------------------------------------  STYLE TWO
        //the .build() function can also filter on product.
        //Does not rebuild plugins, etc.
        
        let targets = try context.package.targets(named: [targetToRunName])
        
       let targetsToRun = try targets.flatMap {
           try extractRunnableTargets($0, parameters: parameters)
        }
        
       try targetsToRun.forEach { targetToRun in
            let message = try runProcess(URL(fileURLWithPath: targetToRun.path.string), arguments: arguments)
            print(message)
        }
        
        //------------------------------------  END STYLE TWO
    }
    
    func extractRunnableTargets(_ target:Target, parameters:PackageManager.BuildParameters) throws -> [PackageManager.BuildResult.BuiltArtifact] {
        print("trying for target... \(target.name)")
        let result = try packageManager.build(.target(target.name), parameters: parameters)
        print(result.logText)
        if result.succeeded  {
           return result.builtArtifacts.filter({$0.kind == .executable })
        } else {
            return []
        }
        
    }
}

@discardableResult
func runProcess(_ tool:URL, arguments:[String] = [], workingDirectory:URL? = nil) throws -> String {
    let task = Process()
    let pipe = Pipe()
    
    task.standardOutput = pipe
    task.standardError = pipe
    task.arguments = arguments
    
    if let workingDirectory {
        task.currentDirectoryURL = workingDirectory
    }
    //task.qualityOfService
    //task.environment

    task.standardInput = nil
    task.executableURL = tool
    try task.run()
    
    let data = pipe.fileHandleForReading.readDataToEndOfFile()
    let output = String(data: data, encoding: .utf8)!
    
    task.waitUntilExit()

    if task.terminationStatus == 0 || task.terminationStatus == 2 {
      return output
    } else {
      print(output)
      throw CustomProcessError.unknownError(exitCode: task.terminationStatus)
    }
}

enum CustomProcessError: Error {
  case unknownError(exitCode: Int32)
}