Compare commits

...

8 Commits

29 changed files with 2491 additions and 370 deletions
+19 -1
View File
@@ -1,5 +1,5 @@
{
"originHash" : "eb2a57fb4e4c2c83ff1f1fa55631db81988fc6e2e576a05a3cc5c8ed69432c3a",
"originHash" : "9ec3992e7de864bad568faa552cdf4c9fff40eebb41c0c05faf964bc172df5d4",
"pins" : [
{
"identity" : "aexml",
@@ -352,6 +352,15 @@
"version" : "2.11.0"
}
},
{
"identity" : "swift-subprocess",
"kind" : "remoteSourceControl",
"location" : "https://github.com/swiftlang/swift-subprocess",
"state" : {
"revision" : "13d087685b95d64d6aac9b94500d347bbe84c39b",
"version" : "0.4.0"
}
},
{
"identity" : "swift-syntax",
"kind" : "remoteSourceControl",
@@ -370,6 +379,15 @@
"version" : "1.6.4"
}
},
{
"identity" : "swift-tools-protocols",
"kind" : "remoteSourceControl",
"location" : "https://github.com/swiftlang/swift-tools-protocols",
"state" : {
"revision" : "d81024558da3bcd53748c4cfdaba10a49242442e",
"version" : "0.0.10"
}
},
{
"identity" : "swiftcli",
"kind" : "remoteSourceControl",
+15 -2
View File
@@ -23,7 +23,7 @@ let package = Package(
name: "xtool",
platforms: [
.iOS(.v16),
.macOS(.v13),
.macOS(.v14),
],
products: [
.library(
@@ -55,6 +55,8 @@ let package = Package(
.package(url: "https://github.com/apple/swift-nio", from: "2.77.0"),
.package(url: "https://github.com/swiftlang/swift-docc-plugin", from: "1.0.0"),
.package(url: "https://github.com/swiftlang/swift-subprocess", .upToNextMinor(from: "0.4.0")),
.package(url: "https://github.com/swiftlang/swift-tools-protocols", exact: "0.0.10"),
.package(url: "https://github.com/swift-server/async-http-client.git", from: "1.23.0"),
.package(url: "https://github.com/swift-server/swift-openapi-async-http-client", from: "1.0.0"),
@@ -92,7 +94,16 @@ let package = Package(
exclude: ["openapi-generator-config.yaml", "patch.js"]
),
// common utilities shared across xtool targets
.target(name: "XUtils"),
.target(
name: "XUtils",
dependencies: [
.product(
name: "Subprocess",
package: "swift-subprocess",
condition: .when(platforms: [.linux, .macOS])
),
]
),
.target(
name: "XKit",
dependencies: [
@@ -149,6 +160,7 @@ let package = Package(
.product(name: "NIOPosix", package: "swift-nio"),
.product(name: "Version", package: "Version"),
.product(name: "libunxip", package: "unxip"),
.product(name: "LanguageServerProtocolTransport", package: "swift-tools-protocols"),
],
cSettings: cSettings
),
@@ -156,6 +168,7 @@ let package = Package(
name: "PackLib",
dependencies: [
"XUtils",
.product(name: "Superutils", package: "xtool-core"),
.product(name: "Yams", package: "Yams"),
.product(name: "XcodeGenKit", package: "XcodeGen", condition: .when(platforms: [.macOS])),
]
+4
View File
@@ -0,0 +1,4 @@
#include "inotify_shim.h"
#include "stdout_shim.h"
#include "version.h"
#include "mobileprovision.h"
+21
View File
@@ -0,0 +1,21 @@
#ifndef CINOTIFY_SHIMS_H
#define CINOTIFY_SHIMS_H
#ifdef __linux__
#include <stdio.h>
#include <stdint.h>
#include <sys/inotify.h>
static inline const char *cin_event_name(const struct inotify_event *event) {
if (event->len)
return event->name;
else
return NULL;
}
static const uint32_t cin_all_events = IN_ALL_EVENTS;
#endif
#endif /* CINOTIFY_SHIMS_H */
+132 -40
View File
@@ -1,64 +1,124 @@
import Foundation
import Subprocess
import XUtils
import Superutils
public struct BuildSettings: Sendable {
private static let customBinDir =
// this is the same option used by SwiftPM itself for dev builds
ProcessInfo.processInfo.environment["SWIFTPM_CUSTOM_BIN_DIR"].map { URL(fileURLWithPath: $0) }
ProcessInfo.processInfo.environment["SWIFTPM_CUSTOM_BIN_DIR"].map { FilePath($0) }
private static let envURL = URL(fileURLWithPath: "/usr/bin/env")
public let packagePath: String
public var packagePath: String
public let configuration: BuildConfiguration
public let triple: String
public let sdkOptions: [String]
public let options: [String]
public let buildSystem: BuildSystem
public let customOptions: [String]
public var sdkOptions: [String]
public var sdkEnvironment: [Environment.Key: String?]
private var configOptions: [String] {
return [
"--configuration", configuration.rawValue,
"--build-system", buildSystem.pmName,
"--package-path", packagePath,
]
}
private var resolvedBaseOptions: [String] {
configOptions + sdkOptions + customOptions
}
public init(
configuration: BuildConfiguration,
triple: String,
buildSystem: BuildSystem = .default,
packagePath: String = ".",
options: [String] = []
) async throws {
self.packagePath = packagePath
self.configuration = configuration
self.options = options
self.customOptions = options
self.triple = triple
self.buildSystem = buildSystem
// on macOS we don't explicitly install a Swift SDK but
// SwiftPM vends "implicit" Darwin SDKs as of Swift 6.1,
// i.e. we can pass `--swift-sdk arm64-apple-ios` and it
// just works. See:
// https://github.com/swiftlang/swift-package-manager/pull/6828
self.sdkOptions = ["--swift-sdk", triple]
self.sdkEnvironment = [
// xcrun passes an SDKROOT that messes with our sdk configuration
"SDKROOT": nil,
]
switch buildSystem {
case .swiftPM:
// on macOS we don't explicitly install a Swift SDK but
// SwiftPM vends "implicit" Darwin SDKs as of Swift 6.1,
// i.e. we can pass `--swift-sdk arm64-apple-ios` and it
// just works. See:
// https://github.com/swiftlang/swift-package-manager/pull/6828
self.sdkOptions = ["--swift-sdk", triple]
case .swiftBuild:
self.sdkOptions = ["--triple", triple]
#if !os(macOS)
let darwinSDK = try await DarwinSDK.current()
.orThrow(StringError("No Darwin SDK configured. Please run `xtool setup`."))
self.sdkOptions += [
"--toolset", "\(darwinSDK.bundle.path)/toolset-swb.json",
]
self.sdkEnvironment.merge([
"XCODE_EXTRA_PLATFORM_FOLDERS": "\(darwinSDK.bundle.path)/Developer/Platforms",
]) { $1 }
#endif
}
}
#if os(macOS)
private static func xcrun(_ arguments: [String]) async throws -> String {
let xcrun = Process()
let pipe = Pipe()
xcrun.executableURL = URL(fileURLWithPath: "/usr/bin/xcrun")
xcrun.arguments = arguments
xcrun.standardOutput = pipe
try await xcrun.runUntilExit()
return String(decoding: pipe.fileHandleForReading.readDataToEndOfFile(), as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
let result = try await Subprocess.run(
.path("/usr/bin/xcrun"),
arguments: .init(arguments),
output: .string(limit: .max)
).checkSuccess()
return result.standardOutput?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
}
private static let swiftURL = Task {
try await URL(fileURLWithPath: xcrun(["-f", "swift"]))
private static let _swiftURL = Task {
try await FilePath(xcrun(["-f", "swift"]))
}
public static func swiftURL() async throws -> FilePath {
try await _swiftURL.value
}
private static let _swiftcURL = Task {
try await FilePath(xcrun(["-f", "swiftc"]))
}
public static func swiftcURL() async throws -> FilePath {
try await _swiftcURL.value
}
#else
public static func swiftURL() async throws -> FilePath {
try await FilePath(ToolRegistry.locate("swift")).orThrow(StringError("Got bad path for swift executable"))
}
public static func swiftcURL() async throws -> FilePath {
try await FilePath(ToolRegistry.locate("swiftc")).orThrow(StringError("Got bad path for swiftc executable"))
}
#endif
public func withPackagePath(_ path: String) -> Self {
var copy = self
copy.packagePath = path
return copy
}
public func swiftPMInvocation(
forTool tool: String,
arguments: [String],
packagePathOverride: String? = nil
) async throws -> Process {
let process = Process()
) async throws -> Subprocess.Configuration {
let executable: Executable
let baseArguments: [String]
if let customBinDir = Self.customBinDir {
process.executableURL = customBinDir.appendingPathComponent("swift-\(tool)")
executable = .path(customBinDir.appending("swift-\(tool)"))
baseArguments = []
} else {
#if os(macOS)
@@ -66,28 +126,60 @@ public struct BuildSettings: Sendable {
// to add SDKROOT=.../MacOSX.sdk to our invocations. We avoid this by
// 1) invoking the real swift executable (located with `xcrun -f`) and
// 2) explicitly removing SDKROOT from the env, as it may be inherited
// through the `swift run pack` invocation.
process.executableURL = try await Self.swiftURL.value
// through a parent process (e.g. `swift run xtool`).
executable = .path(try await Self.swiftURL())
#else
process.executableURL = try await ToolRegistry.locate("swift")
executable = .name("swift")
#endif
baseArguments = [tool]
}
let extraArguments: [String] = [
"--package-path", packagePathOverride ?? packagePath,
"--configuration", configuration.rawValue,
]
return Configuration(
executable,
arguments: .init(baseArguments + resolvedBaseOptions + arguments),
environment: .inherit.updating(sdkEnvironment),
platformOptions: .withGracefulShutDown,
)
}
var env = ProcessInfo.processInfo.environment
env.removeValue(forKey: "SDKROOT")
process.environment = env
process.arguments = baseArguments + extraArguments + sdkOptions + options + arguments
return process
public var buildServerArguments: [String] {
return [
"package", "experimental-build-server",
"--disable-automatic-resolution",
// TODO: once https://github.com/swiftlang/swift-package-manager/pull/9819 makes it into a release
// (Swift 6.4), pass --experimental-skip-acquiring-lock
] + resolvedBaseOptions
}
}
public enum BuildConfiguration: String, CaseIterable, Sendable {
case debug
case release
var swiftBuildValue: String {
switch self {
case .debug: "Debug"
case .release: "Release"
}
}
}
public enum BuildSystem: Sendable {
case swiftPM
case swiftBuild
public static var `default`: Self {
#if os(macOS)
return .swiftBuild
#else
return .swiftBuild
#endif
}
var pmName: String {
switch self {
case .swiftPM: "native"
case .swiftBuild: "swiftbuild"
}
}
}
+95
View File
@@ -0,0 +1,95 @@
import Foundation
import Subprocess
import XUtils
public struct DarwinSDK {
public let bundle: URL
public let version: String
public init?(bundle: URL) {
self.bundle = bundle
if let version = try? Data(contentsOf: bundle.appendingPathComponent("darwin-sdk-version.txt")) {
self.version = String(decoding: version, as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
} else if ["darwin.xtoolsdk", "darwin.artifactbundle"].contains(bundle.lastPathComponent) {
self.version = "unknown"
} else {
return nil
}
}
public static func install(from path: String) async throws {
// we can't just move into ~/.swiftpm/swift-sdks because the swiftpm directory
// location depends on factors like $XDG_CONFIG_HOME. Rather than replicating
// SwiftPM's logic, which may change, it's more reliable to directly invoke
// `swift sdk install`. See: https://github.com/xtool-org/xtool/pull/40
let url = URL(fileURLWithPath: path)
guard DarwinSDK(bundle: url) != nil else { throw StringError("Invalid Darwin SDK at '\(path)'")}
try await addHostClangResourceDir(to: url)
try await Subprocess.run(
.name("swift"),
arguments: ["sdk", "install", url.path],
output: .discarded
)
.checkSuccess()
}
private static func addHostClangResourceDir(to sdk: URL) async throws {
let clangURL = try await ToolRegistry.locate("clang")
let process = try await Subprocess.run(
.path(FilePath(clangURL.path)),
arguments: ["-print-resource-dir"],
output: .string(limit: .max)
).checkSuccess()
let output = process.standardOutput ?? ""
let hostClangResources = URL(filePath: output.trimmingCharacters(in: .whitespacesAndNewlines))
let hostInclude = hostClangResources.appending(path: "include")
let sdkInclude = sdk.appending(path: "Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/clang/include")
try FileManager.default.copyItem(at: hostInclude, to: sdkInclude)
}
public static func current() async throws -> DarwinSDK? {
let outputString: String
do {
outputString = try await Subprocess.run(
.name("swift"),
arguments: ["sdk", "configure", "darwin", "arm64-apple-ios", "--show-configuration"],
output: .string(limit: .max)
)
.checkSuccess()
.standardOutput
?? ""
} catch SubprocessFailure.exited {
return nil
}
// should be something like
// swiftResourcesPath: /home/user/.swiftpm/swift-sdks/darwin.artifactbundle/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift
// swiftlint:disable:previous line_length
let resourcesPathPrefix = "swiftResourcesPath: "
guard let resourcesPath = outputString
.split(separator: "\n")
.first(where: { $0.hasPrefix(resourcesPathPrefix) })?
.dropFirst(resourcesPathPrefix.count)
else { return nil }
var resourcesURL = URL(fileURLWithPath: String(resourcesPath))
for _ in 0..<6 {
resourcesURL = resourcesURL.deletingLastPathComponent()
}
return DarwinSDK(bundle: resourcesURL)
}
public func isUpToDate() -> Bool {
true
}
public func remove() throws {
try FileManager.default.removeItem(at: bundle)
}
}
+30 -16
View File
@@ -1,5 +1,6 @@
import Foundation
import XUtils
import Subprocess
public struct Packer: Sendable {
public let buildSettings: BuildSettings
@@ -54,22 +55,27 @@ public struct Packer: Sendable {
try Data().write(to: sources.appendingPathComponent("stub.c", isDirectory: false))
}
let builder = try await buildSettings.swiftPMInvocation(
forTool: "build",
arguments: [
"--package-path", packageDir.path,
"--scratch-path", ".build",
// resolving can cause SwiftPM to overwrite the root package deps
// with just the deps needed for the builder package (which is to
// say, any "dev dependencies" of the root package may be removed.)
// fortunately we've already resolved the root package by this point
// in order to dump the plan, so we can skip resolution here to skirt
// the issue.
"--disable-automatic-resolution",
]
let buildConfig = try await buildSettings
.withPackagePath(packageDir.path)
.swiftPMInvocation(
forTool: "build",
arguments: [
"--scratch-path", ".build",
// resolving can cause SwiftPM to overwrite the root package deps
// with just the deps needed for the builder package (which is to
// say, any "dev dependencies" of the root package may be removed.)
// fortunately we've already resolved the root package by this point
// in order to dump the plan, so we can skip resolution here to skirt
// the issue.
"--disable-automatic-resolution",
],
)
try await Subprocess.run(
buildConfig,
output: .standardError,
error: .standardError,
)
builder.standardOutput = FileHandle.standardError
try await builder.runUntilExit()
.checkSuccess()
}
public func pack() async throws -> URL {
@@ -79,8 +85,16 @@ public struct Packer: Sendable {
let outputURL = output.url
let binPath: String
switch buildSettings.buildSystem {
case .swiftPM:
binPath = "\(buildSettings.triple)/\(buildSettings.configuration.rawValue)"
case .swiftBuild:
let platformName = buildSettings.triple.contains("simulator") ? "iphonesimulator" : "iphoneos"
binPath = "out/Products/\(buildSettings.configuration.swiftBuildValue)-\(platformName)"
}
let binDir = URL(
fileURLWithPath: ".build/\(buildSettings.triple)/\(buildSettings.configuration.rawValue)",
fileURLWithPath: ".build/\(binPath)",
isDirectory: true
)
+9 -7
View File
@@ -1,5 +1,6 @@
import Foundation
import XUtils
import Subprocess
public struct Planner: Sendable {
public var buildSettings: BuildSettings
@@ -243,16 +244,17 @@ public struct Planner: Sendable {
}
private func _dumpAction(arguments: [String], path: String) async throws -> Data {
let dump = try await buildSettings.swiftPMInvocation(
let dumpConfig = try await buildSettings.withPackagePath(path).swiftPMInvocation(
forTool: "package",
arguments: arguments,
packagePathOverride: path
)
let pipe = Pipe()
dump.standardOutput = pipe
async let task = Data(reading: pipe.fileHandleForReading)
try await dump.runUntilExit()
return try await task
return try await Subprocess.run(
dumpConfig,
output: .data(limit: .max),
error: .standardError,
)
.checkSuccess()
.standardOutput
}
private func selectLibrary(
-63
View File
@@ -1,63 +0,0 @@
import Foundation
extension Process {
/// Launches the process and suspends until the receiver is finished.
///
/// - Parameter onCancel: The action to take if the current
/// task is cancelled.
public func runUntilExit(onCancel: TaskCancelAction = .interrupt) async throws {
try Task.checkCancellation()
let (terminationStream, terminationContinuation) = AsyncStream<Never>.makeStream()
terminationHandler = { _ in
terminationContinuation.finish()
}
do {
try run()
} catch {
terminationContinuation.finish()
throw error
}
await withTaskCancellationHandler {
for await _ in terminationStream {}
} onCancel: {
switch onCancel {
case .interrupt:
interrupt()
case .terminate:
terminate()
case .ignore:
break
}
}
try Task.checkCancellation()
switch terminationReason {
case .exit where terminationStatus == 0:
break
case .exit:
throw Failure.exit(terminationStatus)
case .uncaughtSignal:
throw Failure.uncaughtSignal(terminationStatus)
@unknown default:
break
}
}
public enum Failure: Error {
case exit(CInt)
case uncaughtSignal(CInt)
}
public enum TaskCancelAction: Sendable {
/// Sends `SIGINT` to the process.
case interrupt
/// Sends `SIGTERM` to the process.
case terminate
/// Don't participate in cooperative cancellation.
case ignore
}
}
+5 -19
View File
@@ -1,4 +1,5 @@
import Foundation
import Subprocess
package enum ToolRegistry {
package enum Errors: Error, CustomStringConvertible {
@@ -16,11 +17,6 @@ package enum ToolRegistry {
/// Obtain the full path to a tool in the user's `PATH`.
///
/// This effectively invokes `/bin/sh -c "command -v '$tool'"`.
///
/// - Warning: Make sure you trust/sanitize the `tool` parameter. If it
/// contains a single quote, it can be used in a shell escape.
///
/// - Throws: `Errors.toolNotFound` if the tool could not be located.
package static func locate(_ tool: String) async throws -> URL {
try await cache.locate(tool: tool)
@@ -30,20 +26,10 @@ package enum ToolRegistry {
private var cache: [String: Task<URL, Error>] = [:]
private func _locate(tool: String) async throws -> URL {
let pipe = Pipe()
let proc = Process()
proc.executableURL = URL(fileURLWithPath: "/bin/sh")
proc.arguments = ["-c", "command -v '\(tool)'"]
proc.standardOutput = pipe
async let bytes = pipe.fileHandleForReading.readToEnd()
do {
try await proc.runUntilExit()
} catch is Process.Failure {
throw Errors.toolNotFound(tool)
}
let path = String(decoding: try await bytes ?? Data(), as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
return URL(fileURLWithPath: path)
guard let path = try? Executable.name(tool).resolveExecutablePath(in: .inherit),
let url = URL(filePath: path)
else { throw Errors.toolNotFound(tool) }
return url
}
func locate(tool: String) async throws -> URL {
@@ -3,6 +3,7 @@
import Foundation
import XADI
import Dependencies
import Subprocess
public actor XADIProvider: RawADIProvider {
@MainActor private static var loadTask: Task<Void, Error>?
@@ -45,17 +46,17 @@ public actor XADIProvider: RawADIProvider {
let archDir = "lib/\(arch)"
// TODO: Use ZIPFoundation
let proc = Process()
proc.executableURL = URL(filePath: "/usr/bin/env")
proc.arguments = [
"unzip", "-q",
applemusic.path(),
"\(archDir)/libCoreADI.so",
"\(archDir)/libstoreservicescore.so",
"-d", tmp.path()
]
try proc.run()
proc.waitUntilExit()
try await Subprocess.run(
.name("unzip"),
arguments: [
"-q",
applemusic.path,
"\(archDir)/libCoreADI.so",
"\(archDir)/libstoreservicescore.so",
"-d", tmp.path
],
output: .discarded
).checkSuccess()
try FileManager.default.moveItem(
at: tmp.appending(path: archDir),
to: libDir
+1 -1
View File
@@ -1,6 +1,6 @@
import Foundation
import XKit
import SystemPackage
import XUtils
import NIOPosix
import NIOCore
+30
View File
@@ -0,0 +1,30 @@
import ArgumentParser
import Foundation
import XKit
import PackLib
import Subprocess
struct DevBSPCommand: AsyncParsableCommand {
static let configuration = CommandConfiguration(
commandName: "build-server",
abstract: "Run build server",
)
@Option
var triple: String?
func run() async throws {
let settings = try await BuildSettings(
configuration: .debug,
triple: triple ?? PackOperation.defaultTriple
)
try await Subprocess.run(
.path(BuildSettings.swiftURL()),
arguments: .init(settings.buildServerArguments),
input: .standardInput,
output: .standardOutput,
error: .standardError,
)
.checkSuccess()
}
}
+71 -45
View File
@@ -23,10 +23,30 @@ struct PackOperation {
var triple: String?
var buildOptions = BuildOptions(configuration: .debug)
var extraOptions: [String] = []
var watchMode = false
var xcode = false
func buildSettings() async throws -> BuildSettings {
try await BuildSettings(
configuration: buildOptions.configuration,
triple: triple ?? Self.defaultTriple,
options: extraOptions + (
watchMode
? [
"-Xlinker", "-interposable",
// https://kyleye.top/posts/debugreplaceableview-multiple-type-erasers/
"-Xswiftc", "-enable-experimental-feature", "-Xswiftc", "OpaqueTypeErasure",
// https://www.guardsquare.com/blog/behind-swiftui-previews
"-Xswiftc", "-Xfrontend", "-Xswiftc", "-enable-private-imports",
]
: []
)
)
}
@discardableResult
func run() async throws -> URL {
func run() async throws -> (Plan, URL) {
print("Planning...")
let schema: PackSchema
@@ -41,11 +61,7 @@ struct PackOperation {
""")
}
let buildSettings = try await BuildSettings(
configuration: buildOptions.configuration,
triple: triple ?? Self.defaultTriple,
options: []
)
let buildSettings = try await buildSettings()
let planner = Planner(
buildSettings: buildSettings,
@@ -55,7 +71,8 @@ struct PackOperation {
#if os(macOS)
if xcode {
return try await XcodePacker(plan: plan).createProject()
let url = try await XcodePacker(plan: plan).createProject()
return (plan, url)
}
#endif
@@ -68,28 +85,26 @@ struct PackOperation {
let productsWithEntitlements = plan
.allProducts
.compactMap { p in p.entitlementsPath.map { (p, $0) } }
if !productsWithEntitlements.isEmpty {
let mapping = try await withThrowingTaskGroup(of: (URL, Entitlements).self) { group in
for (product, path) in productsWithEntitlements {
group.addTask {
let data = try await Data(reading: URL(fileURLWithPath: path))
let decoder = PropertyListDecoder()
let entitlements = try decoder.decode(Entitlements.self, from: data)
return (product.directory(inApp: bundle), entitlements)
}
let mapping = try await withThrowingTaskGroup(of: (URL, Entitlements?).self) { group in
for (product, path) in productsWithEntitlements {
group.addTask {
let data = try await Data(reading: URL(fileURLWithPath: path))
let decoder = PropertyListDecoder()
let entitlements = try decoder.decode(Entitlements.self, from: data)
return (product.directory(inApp: bundle), entitlements)
}
return try await group.reduce(into: [:]) { $0[$1.0] = $1.1 }
}
print("Applying entitlements...")
try await Signer.first().sign(
app: bundle,
identity: .adhoc,
entitlementMapping: mapping,
progress: { _ in }
)
return try await group.reduce(into: [:]) { $0[$1.0] = $1.1 }
}
print("Applying entitlements...")
try await Signer.first().sign(
app: bundle,
identity: .adhoc,
entitlementMapping: mapping,
progress: { _ in }
)
return bundle
return (plan, bundle)
}
}
@@ -144,7 +159,7 @@ struct DevBuildCommand: AsyncParsableCommand {
signingAuthToken = nil
}
let url = try await PackOperation(
let (_, url) = try await PackOperation(
triple: triple,
buildOptions: packOptions
).run()
@@ -209,6 +224,13 @@ struct DevRunCommand: AsyncParsableCommand {
help: "Target the iOS Simulator"
) var simulator = false
@Flag(
name: .shortAndLong,
help: "Hot reload files on change. Requires simulator."
) var watch = false
@Option var xloadPath: String?
var triple: String? {
if simulator {
#if arch(arm64)
@@ -222,17 +244,37 @@ struct DevRunCommand: AsyncParsableCommand {
return nil
}
#else
var watch: Bool { false }
var triple: String? { nil }
#endif
@OptionGroup var connectionOptions: ConnectionOptions
func validate() throws {
#if os(macOS)
if watch && !simulator {
throw ValidationError("--watch requires --simulator")
}
#endif
}
func run() async throws {
let output = try await PackOperation(triple: triple, buildOptions: packOptions).run()
let operation = PackOperation(
triple: triple,
buildOptions: packOptions,
watchMode: watch,
)
let (plan, output) = try await operation.run()
#if os(macOS)
if simulator {
try await SimInstallOperation(path: output).run()
try await SimInstallOperation(
operation: operation,
plan: plan,
path: output,
watch: watch,
xLoadLibrary: xloadPath,
).run()
return
}
#endif
@@ -274,26 +316,10 @@ struct DevCommand: AsyncParsableCommand {
DevXcodeCommand.self,
DevBuildCommand.self,
DevRunCommand.self,
DevBSPCommand.self,
],
defaultSubcommand: DevRunCommand.self
)
}
extension BuildConfiguration: ExpressibleByArgument {}
#if os(macOS)
struct SimInstallOperation {
var path: URL
// TODO: allow customizing this
var simulator = "booted"
func run() async throws {
let process = Process()
process.executableURL = URL(fileURLWithPath: "/usr/bin/xcrun")
process.arguments = ["simctl", "install", simulator, path.path]
try await process.runUntilExit()
print("Installed to simulator")
}
}
#endif
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,97 @@
import Foundation
import ArgumentParser
import PackLib
import XUtils
import Subprocess
struct HotReloadCommand: AsyncParsableCommand {
static let configuration = CommandConfiguration(
commandName: "hot-reload",
abstract: "Run an app with support for hot reloading",
)
@Flag(
help: "Use the SwiftPM build system to determine compile commands"
) var swiftpm = false
@Option(
help: .init(
"Use the specified Build Server to determine compile commands",
discussion: """
The file at the specified path should correspond to the BSP \
Connection Details specification. See:
https://build-server-protocol.github.io/docs/overview/server-discovery
""",
)
) var buildServerPath: String?
@Option(
help: "The directory in which to store scratch files"
) var scratchDirectory: String?
@Option(
help: "String to prepend to all env var names"
) var envPrefix: String = ""
@Option(
help: .hidden
) var xloadLibrary: String?
@Argument(
help: .init(
"The command to run with hot reloading",
discussion: """
xtool spawns the provided process with env vars set to enable hot reloading.
"""
)
) var command: [String]
func run() async throws {
let configuration: BuildServerConfiguration
switch (swiftpm, buildServerPath) {
case (true, _?):
throw ValidationError("Both --swiftpm or --build-server-path were provided; please only provide one.")
case (true, nil):
configuration = try await .swiftPM(settings: BuildSettings(configuration: .debug, triple: "arm64-apple-ios-simulator"))
case (false, let serverPath?):
configuration = try await .external(definition: URL(filePath: serverPath))
case (false, nil):
if let discovered = try await BuildServerConfiguration.discover(in: URL(filePath: ".")) {
configuration = discovered
} else {
throw ValidationError("Could not guess build system. Please specify one with --swiftpm or --build-server-path")
}
}
let reloader = try await HotReloader(
configuration: configuration,
scratchDirectory: scratchDirectory.map { FilePath($0) },
xLoadLibrary: xloadLibrary
)
let watchTask = Task {
do {
try await reloader.watch()
} catch {
print("Error: watcher failed: \(error)")
}
}
var arguments = command
let executable = arguments.removeFirst()
try await Subprocess.run(
.name(executable),
arguments: Arguments(arguments),
environment: .inherit.updating(reloader.subprocessEnvironment(prefix: envPrefix)),
platformOptions: .withGracefulShutDown,
output: .standardOutput,
error: .standardError,
)
.checkSuccess()
watchTask.cancel()
await watchTask.value
}
}
+112
View File
@@ -0,0 +1,112 @@
#if os(macOS)
import Subprocess
import PackLib
import Foundation
import XUtils
import Dependencies
import XKit
actor HotReloader {
var configuration: BuildServerConfiguration
var scratchDirectory: FilePath
var xLoadLibrary: String?
private let scratchTemporaryDirectory: TemporaryDirectory?
private let xLoadPath: String
private let buildDirectory: FilePath
private let outDirectory: FilePath
init(
configuration: BuildServerConfiguration,
scratchDirectory: FilePath? = nil,
xLoadLibrary: String? = nil,
) async throws {
self.configuration = configuration
if let scratchDirectory {
self.scratchDirectory = FilePath(URL(filePath: scratchDirectory.string).absoluteURL.path)
self.scratchTemporaryDirectory = nil
} else {
let scratchTemporaryDirectory = try TemporaryDirectory(name: "scratch")
self.scratchDirectory = FilePath(scratchTemporaryDirectory.url.path)
self.scratchTemporaryDirectory = consume scratchTemporaryDirectory
}
self.xLoadLibrary = xLoadLibrary
xLoadPath = if let xLoadLibrary {
URL(filePath: xLoadLibrary).absoluteURL.path
} else {
try await Self.getXLoad(platform: "iphonesimulator").path
}
buildDirectory = self.scratchDirectory.appending("build")
try FileManager.default.createDirectory(at: URL(filePath: buildDirectory)!, withIntermediateDirectories: true)
outDirectory = self.scratchDirectory.appending("out")
try FileManager.default.createDirectory(at: URL(filePath: outDirectory)!, withIntermediateDirectories: true)
}
nonisolated func environment(prefix: String = "SIMCTL_CHILD_") -> [String: String] {
[
"\(prefix)DYLD_INSERT_LIBRARIES": xLoadPath,
"\(prefix)XLOAD_WATCH_DIR": outDirectory.string,
"\(prefix)XLOAD_INTERCEPT": "1",
]
}
nonisolated func subprocessEnvironment(prefix: String = "SIMCTL_CHILD_") -> [Environment.Key: String] {
Dictionary(uniqueKeysWithValues: environment(prefix: prefix).map {
(Environment.Key(rawValue: $0)!, $1)
})
}
func watch() async throws {
let workspace = try await SwiftWorkspace(
configuration: configuration,
buildDirectory: buildDirectory,
outDirectory: outDirectory,
)
@Dependency(\.fileSystemMonitor) var fileSystemMonitor
let events = try await fileSystemMonitor.watch(FilePath(FileManager.default.currentDirectoryPath))
for await event in events {
do {
try await workspace.fileDidChange(event.file)
} catch {
print("Reload failed: \(error)")
}
}
}
private static func getXLoad(platform: String) async throws -> URL {
let version = "0.3.0"
let remote = URL(string: "https://github.com/xtool-org/xload/releases/download/v\(version)/libXLoad.\(platform).dylib")!
@Dependency(\.httpClient) var httpClient
@Dependency(\.persistentDirectory) var persistentDirectory
let platformDir = persistentDirectory.appending(path: "xload/\(platform)")
let versionDir = platformDir.appending(path: version)
let local = versionDir.appending(path: "libXLoad.dylib")
if local.exists { return local }
print("Downloading xload...")
try? FileManager.default.removeItem(at: platformDir)
try FileManager.default.createDirectory(at: versionDir, withIntermediateDirectories: true)
let data = try await httpClient.makeRequest(HTTPRequest(url: remote))
guard data.response.status.kind == .successful else {
throw StringError("Failed to download xload: got HTTP \(data.response.status)")
}
try data.body.write(to: local)
return local
}
}
#endif
@@ -2,6 +2,8 @@ import Foundation
import XKit
import Dependencies
import PackLib
import Subprocess
import XUtils
extension ZIPCompressor: DependencyKey {
// TODO: Use `powershell Compress-Archive` and `powershell Expand-Archive` on Windows
@@ -12,20 +14,23 @@ extension ZIPCompressor: DependencyKey {
let dest = dir.deletingLastPathComponent().appendingPathComponent("app.ipa")
let zip = Process()
zip.executableURL = try await ToolRegistry.locate("zip")
zip.currentDirectoryURL = dir.deletingLastPathComponent()
zip.arguments = ["-yqru0", dest.path, dir.lastPathComponent]
try await zip.runUntilExit()
try await Subprocess.run(
.name("zip"),
arguments: ["-yqru0", dest.path, dir.lastPathComponent],
workingDirectory: FilePath(dir.deletingLastPathComponent()),
output: .discarded,
).checkSuccess()
return dest
},
decompress: { ipa, directory, progress in
progress(nil)
let unzip = Process()
unzip.executableURL = try await ToolRegistry.locate("unzip")
unzip.arguments = ["-q", ipa.path, "-d", directory.path]
try await unzip.runUntilExit()
try await Subprocess.run(
.name("unzip"),
arguments: ["-q", ipa.path, "-d", directory.path],
output: .discarded,
).checkSuccess()
}
)
}
+85 -32
View File
@@ -1,9 +1,9 @@
import Foundation
import Dependencies
import SystemPackage
import libunxip
import Subprocess
import XKit // HTTPClient, stdoutSafe
import PackLib // ToolRegistry
import XUtils // System.File{Path,Descriptor}
struct SDKBuilder {
enum Arch: String {
@@ -56,6 +56,7 @@ struct SDKBuilder {
let output: URL
let arch: Arch
// swiftlint:disable:next function_body_length
func buildSDK() async throws {
// TODO: store relevant info for staleness check
let sdkVersion = "develop"
@@ -136,6 +137,9 @@ struct SDKBuilder {
"linker": {
"path": "ld64.lld"
},
"librarian": {
"path": "llvm-lib"
},
"swiftCompiler": {
"extraCLIOptions": [
"-Xfrontend", "-enable-cross-import-overlays",
@@ -149,6 +153,26 @@ struct SDKBuilder {
encoding: .utf8
)
// this toolset works with the swiftbuild system on Linux
// note that we need Swift 6.4+ because 6.3 has bugs in
// resolving the librarian and linker paths.
try """
{
"schemaVersion": "1.0",
"rootPath": "toolset/bin",
"linker": {
"path": "ld"
},
"librarian": {
"path": "llvm-lib"
}
}
""".write(
to: output.appendingPathComponent("toolset-swb.json"),
atomically: false,
encoding: .utf8
)
let sdkDefinition = SDKDefinition(
schemaVersion: "4.0",
targetTriples: [
@@ -180,14 +204,6 @@ struct SDKBuilder {
withIntermediateDirectories: false
)
let pipe = Pipe()
let untar = Process()
untar.currentDirectoryURL = toolsetDir
untar.executableURL = try await ToolRegistry.locate("tar")
untar.arguments = ["xzf", "-"]
untar.standardInput = pipe.fileHandleForReading
async let tarExit: Void = untar.runUntilExit()
@Dependency(\.httpClient) var httpClient
let url = URL(string: """
https://github.com/xtool-org/darwin-tools-linux-llvm/releases/download/\
@@ -199,25 +215,43 @@ struct SDKBuilder {
case .known(let known): known
case .unknown: nil
}
let writer = pipe.fileHandleForWriting
var written: Int64 = 0
do {
defer { try? writer.close() }
defer { print() }
try await Subprocess.run(
.name("tar"),
arguments: ["xzf", "-"],
workingDirectory: FilePath(toolsetDir),
) { _, input, _ in
var totalWritten: Int64 = 0
for try await chunk in body {
try writer.write(contentsOf: chunk)
written += Int64(chunk.count)
if let length {
let progress = Int(Double(written) / Double(length) * 100)
var remaining = chunk
while !remaining.isEmpty {
let written = try await input.write(Array(remaining))
remaining = remaining.dropFirst(written)
totalWritten += Int64(written)
guard let length else { continue }
let progress = Int(Double(totalWritten) / Double(length) * 100)
print("\r[Downloading toolset] \(progress)%", terminator: "")
fflush(stdoutSafe)
}
}
try await input.finish()
}
print()
try await tarExit
.checkSuccess()
// swift-build assumes we have an Apple-flavored librarian for Apple platforms
// (https://github.com/swiftlang/swift-build/blob/b2433e74e/Sources/SWBCore/SpecImplementations/Tools/LinkerTools.swift#L1735)
// but allows us to override this assumption if we explicitly provide the name llvm-lib (look a few lines above in that file)
try FileManager.default.moveItem(
at: toolsetDir.appending(path: "bin/libtool"),
to: toolsetDir.appending(path: "bin/llvm-lib")
)
// TODO: install cctools ld as well
}
// swiftlint:disable:next cyclomatic_complexity function_body_length
// swiftlint:disable:next cyclomatic_complexity
private func installDeveloper(in output: URL) async throws -> URL {
let dev = output.appendingPathComponent("Developer")
@@ -321,10 +355,11 @@ struct SDKBuilder {
for platform in ["iPhoneOS", "MacOSX", "iPhoneSimulator"] {
let lib = "../../../../../Library"
let dest = dev.appendingPathComponent("""
Platforms/\(platform).platform/Developer/SDKs/\(platform).sdk\
/System/Library/Frameworks
""").path
let platformDir = dev.appending(path: "Platforms/\(platform).platform")
try patchPlatformManifest(path: platformDir.appending(path: "Info.plist"))
let dest = platformDir.appending(path: "Developer/SDKs/\(platform).sdk/System/Library/Frameworks").path
try FileManager.default.createSymbolicLink(
atPath: "\(dest)/Testing.framework",
@@ -354,6 +389,21 @@ struct SDKBuilder {
return dev
}
private func patchPlatformManifest(path: URL) throws {
let data = try Data(contentsOf: path)
guard var plist = try PropertyListSerialization.propertyList(from: data, options: [], format: nil) as? [String: Any] else {
throw Console.Error("Could not read '\(path.path)'")
}
var defaultProperties = (plist["DefaultProperties"] as? [String: Any]) ?? [:]
defaultProperties["SWIFT_RESOURCE_DIR"] = "$(PLATFORM_DIR)/../../Toolchains/XcodeDefault.xctoolchain/usr/lib/swift"
defaultProperties["CLANG_RESOURCE_DIR"] = "$(SWIFT_RESOURCE_DIR)/clang"
plist["DefaultProperties"] = defaultProperties
let newData = try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)
try newData.write(to: path)
}
// returns the number of files we actually want to keep,
// useful for computing progress % during fs traversal
private func extractXIP(inputPath: String, outDir: String) async throws -> Int {
@@ -497,13 +547,16 @@ struct SDKEntry {
E("clang"),
]),
E("Platforms", ["iPhoneOS", "MacOSX", "iPhoneSimulator"].map {
E("\($0).platform/Developer", [
E("SDKs"),
E("Library", [
E("Frameworks"),
E("PrivateFrameworks"),
]),
E("usr/lib"),
E("\($0).platform", [
E("Info.plist"),
E("Developer", [
E("SDKs"),
E("Library", [
E("Frameworks"),
E("PrivateFrameworks"),
]),
E("usr/lib"),
])
])
}),
])
+11 -115
View File
@@ -5,6 +5,7 @@ import ArgumentParser
import Dependencies
import PackLib
import XUtils
import Subprocess
struct SDKCommand: AsyncParsableCommand {
static let configuration = CommandConfiguration(
@@ -124,127 +125,22 @@ struct DevSDKStatusCommand: AsyncParsableCommand {
}
}
struct DarwinSDK {
let bundle: URL
let version: String
init?(bundle: URL) {
self.bundle = bundle
if let version = try? Data(contentsOf: bundle.appendingPathComponent("darwin-sdk-version.txt")) {
self.version = String(decoding: version, as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
} else if ["darwin.xtoolsdk", "darwin.artifactbundle"].contains(bundle.lastPathComponent) {
self.version = "unknown"
} else {
return nil
}
}
static func install(from path: String) async throws {
// we can't just move into ~/.swiftpm/swift-sdks because the swiftpm directory
// location depends on factors like $XDG_CONFIG_HOME. Rather than replicating
// SwiftPM's logic, which may change, it's more reliable to directly invoke
// `swift sdk install`. See: https://github.com/xtool-org/xtool/pull/40
let url = URL(fileURLWithPath: path)
guard DarwinSDK(bundle: url) != nil else { throw Console.Error("Invalid Darwin SDK at '\(path)'")}
try await addHostClangResourceDir(to: url)
let process = Process()
process.executableURL = try await ToolRegistry.locate("swift")
process.arguments = ["sdk", "install", url.path]
try await process.runUntilExit()
}
private static func addHostClangResourceDir(to sdk: URL) async throws {
let outPipe = Pipe()
let clang = Process()
clang.executableURL = try await ToolRegistry.locate("clang")
clang.arguments = ["-print-resource-dir"]
clang.standardOutput = outPipe
clang.standardError = FileHandle.standardError
async let outputData = Data(reading: outPipe.fileHandleForReading)
do {
try await clang.runUntilExit()
} catch is Process.Failure {
throw Console.Error("Failed to query host clang -print-resource-dir")
}
let path = String(decoding: try await outputData, as: UTF8.self)
.trimmingCharacters(in: .whitespacesAndNewlines)
guard !path.isEmpty else {
throw Console.Error("Host clang returned an empty resource directory")
}
let hostClangResources = URL(fileURLWithPath: path, isDirectory: true)
let hostInclude = hostClangResources.appending(path: "include")
let sdkInclude = sdk.appending(path: "Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift/clang/include")
try FileManager.default.copyItem(at: hostInclude, to: sdkInclude)
}
static func current() async throws -> DarwinSDK? {
let output = Pipe()
let process = Process()
process.executableURL = try await ToolRegistry.locate("swift")
process.arguments = ["sdk", "configure", "darwin", "arm64-apple-ios", "--show-configuration"]
process.standardOutput = output
process.standardError = FileHandle.nullDevice
async let outputData = Data(reading: output.fileHandleForReading)
do {
try await process.runUntilExit()
} catch Process.Failure.exit {
return nil
}
// should be something like
// swiftResourcesPath: /home/user/.swiftpm/swift-sdks/darwin.artifactbundle/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift
// swiftlint:disable:previous line_length
let resourcesPathPrefix = "swiftResourcesPath: "
let outputString = String(decoding: try await outputData, as: UTF8.self)
guard let resourcesPath = outputString
.split(separator: "\n")
.first(where: { $0.hasPrefix(resourcesPathPrefix) })?
.dropFirst(resourcesPathPrefix.count)
else { return nil }
var resourcesURL = URL(fileURLWithPath: String(resourcesPath))
for _ in 0..<6 {
resourcesURL = resourcesURL.deletingLastPathComponent()
}
return DarwinSDK(bundle: resourcesURL)
}
func isUpToDate() -> Bool {
true
}
func remove() throws {
try FileManager.default.removeItem(at: bundle)
}
}
private enum SwiftVersion {}
extension SwiftVersion {
static func current() async throws -> Version {
let outPipe = Pipe()
let errPipe = Pipe()
let swift = Process()
swift.executableURL = try await ToolRegistry.locate("swift")
swift.arguments = ["--version"]
swift.standardOutput = outPipe
swift.standardError = errPipe
async let outputTask = outPipe.fileHandleForReading.readToEnd()
let outputString: String?
do {
try await swift.runUntilExit()
} catch is Process.Failure {
outputString = try await Subprocess.run(
.name("swift"),
arguments: ["--version"],
output: .string(limit: .max)
)
.checkSuccess()
.standardOutput
} catch {
throw Console.Error("Failed to obtain Swift version")
}
let outputData = try await outputTask
var output = String(decoding: outputData ?? Data(), as: UTF8.self)[...]
var output = outputString?[...] ?? ""
if output.hasPrefix("Apple ") {
output = output.dropFirst("Apple ".count)
}
+1
View File
@@ -1,6 +1,7 @@
import ArgumentParser
import Foundation
import XKit
import PackLib
struct SetupCommand: AsyncParsableCommand {
static let configuration = CommandConfiguration(
@@ -0,0 +1,81 @@
#if os(macOS)
import Subprocess
import PackLib
import Foundation
import XUtils
import Dependencies
import XKit
struct SimInstallOperation {
var operation: PackOperation
var plan: Plan
var path: URL
var watch = false
var xLoadLibrary: String?
// TODO: allow customizing this
var simulator = "booted"
func run() async throws {
try await Subprocess.run(
.path("/usr/bin/xcrun"),
arguments: ["simctl", "install", simulator, path.path],
output: .discarded
)
.checkSuccess()
print("Installed to simulator")
let tmp = URL(filePath: FileManager.default.currentDirectoryPath)
.appending(path: "xtool/.xload")
try? FileManager.default.removeItem(at: tmp)
defer { try? FileManager.default.removeItem(at: tmp) }
let watchTask: Task<Void, Error>?
let envVars: [Environment.Key: String?]
if watch {
try FileManager.default.createDirectory(at: tmp, withIntermediateDirectories: true)
guard let temporaryDirectoryPath = FilePath(tmp) else {
throw Console.Error("Bad temporaryDirectory path")
}
let hotReloader = try await HotReloader(
configuration: .swiftPM(settings: operation.buildSettings()),
scratchDirectory: temporaryDirectoryPath,
xLoadLibrary: xLoadLibrary
)
watchTask = Task {
do {
try await hotReloader.watch()
} catch {
print("Error: watch task failed: \(error)")
}
}
envVars = hotReloader.subprocessEnvironment()
} else {
watchTask = nil
envVars = [:]
}
try await Subprocess.run(
.path("/usr/bin/xcrun"),
arguments: [
"simctl", "launch",
"--console-pty",
simulator, plan.app.bundleID,
],
environment: .inherit.updating(envVars),
platformOptions: .withGracefulShutDown,
output: .standardOutput,
error: .standardError,
)
.checkSuccess()
watchTask?.cancel()
try await watchTask?.value
}
}
#endif
+397
View File
@@ -0,0 +1,397 @@
import Foundation
import XUtils
import PackLib
import BuildServerProtocol
import LanguageServerProtocol
import LanguageServerProtocolTransport
import Subprocess
import Dependencies
actor SwiftWorkspace {
private let connection: JSONRPCConnection
private let buildDirectory: FilePath
private let outDirectory: FilePath
private var counter = 0
struct FileInfo {
let file: FilePath
let target: BuildTarget
let sources: SourcesItem
let source: SourceItem
init?(target: BuildTarget, sources: SourcesItem, source: SourceItem) {
guard let path = FilePath(source.uri.arbitrarySchemeURL) else { return nil }
self.file = path
self.target = target
self.sources = sources
self.source = source
}
}
private var filesToWatch: [FilePath: [FileInfo]] = [:]
private var sources: [(BuildTarget, SourcesItem)] {
didSet { updateFilesToWatch() }
}
private var cachedCommands: [FilePath: FrontendCommand] = [:]
struct FrontendCommand {
let commandLine: CommandInvocation
let output: FilePath
let module: String
}
init(
configuration: BuildServerConfiguration,
buildDirectory: FilePath,
outDirectory: FilePath,
) async throws {
self.buildDirectory = buildDirectory
self.outDirectory = outDirectory
let handler = StreamingMessageHandler()
let (connection, _) = try JSONRPCConnection.start(
executable: configuration.executable,
arguments: configuration.arguments,
name: "xtool",
protocol: .bspProtocol,
stderrLoggingCategory: "xtool-error",
client: handler,
terminationHandler: { print("Terminated: \($0)") }
)
self.connection = connection
_ = try await connection.send(InitializeBuildRequest(
displayName: "xtool",
version: "1.0.0",
bspVersion: "2.2.0",
rootUri: .init(URL(filePath: FileManager.default.currentDirectoryPath)),
capabilities: BuildClientCapabilities(
languageIds: [.swift, .c, .cpp, .objective_c, .objective_cpp],
)
))
connection.send(OnBuildInitializedNotification())
// some BSP servers (eg SourceKit-Bazel-BSP) require an initial build targets request
// before they send OnBuildTargetDidChange
_ = try await connection.send(WorkspaceBuildTargetsRequest())
for await case _ as OnBuildTargetDidChangeNotification in handler.notifications { break }
let result = try await connection.send(WorkspaceBuildTargetsRequest())
let targets = Dictionary(uniqueKeysWithValues: result.targets.map { ($0.id, $0) })
let targetInfos = try await connection.send(BuildTargetSourcesRequest(
targets: result.targets.map(\.id)
))
sources = targetInfos.items.compactMap {
guard let target = targets[$0.target] else { return nil }
return (target, $0)
}
updateFilesToWatch()
}
deinit {
connection.close()
}
func updateFilesToWatch() {
filesToWatch = Dictionary(
grouping: sources.flatMap { target, sources in
sources.sources.compactMap { source in
// guard !target.id.uri.stringValue.contains("&targetGUID=PACKAGE-TARGET:") else { return nil }
FileInfo(target: target, sources: sources, source: source)
}
},
by: \.file
)
}
func fileDidChange(_ path: FilePath) async throws {
guard filesToWatch[path] != nil else { return }
print("Reloading \(path)")
_ = try await rebuild(path: path)
}
@discardableResult
func rebuild(path: FilePath) async throws -> FilePath {
let command = try await frontendCommand(for: path)
try await Subprocess.run(
.path(FilePath(String(command.commandLine.command))),
arguments: .init(command.commandLine.arguments.map { String($0) }),
output: .standardOutput,
error: .standardError,
)
.checkSuccess()
let sdk = try command.commandLine.value(for: "-sdk")
.orThrow(Console.Error("Could not find -sdk"))
let target = try command.commandLine.value(for: "-target")
.orThrow(Console.Error("Could not find -target"))
counter += 1
let outputFile = outDirectory
.appending("lib\(path.lastComponent!.stem).\(counter).dylib")
// link
try await Subprocess.run(
.path(try await BuildSettings.swiftcURL()),
arguments: [
command.output.string,
"-emit-library",
"-sdk", sdk, "-target", target,
"-Xlinker", "-undefined", "-Xlinker", "dynamic_lookup",
"-o", outputFile.string
],
output: .standardOutput,
error: .standardError,
)
.checkSuccess()
return outputFile
}
func frontendCommand(for path: FilePath) async throws -> FrontendCommand {
if let cached = cachedCommands[path] {
return cached
}
let targets = filesToWatch[path] ?? []
let target: FileInfo
switch targets.count {
case 0:
throw Console.Error("No targets for file")
case 1:
target = targets[0]
default:
print("warning: multiple targets contain this file: \(targets.map(\.target.id.uri))")
target = targets[0]
}
guard let fileURL = URL(filePath: path)?.absoluteURL, let lastComponent = path.lastComponent else {
throw Console.Error("Bad file path \(path.string)")
}
let options = try await connection.send(TextDocumentSourceKitOptionsRequest(
textDocument: .init(target.source.uri),
target: target.target.id,
language: .swift,
))
.orThrow(Console.Error("No options"))
guard let moduleNameIndex = options.compilerArguments.firstIndex(of: "-module-name"),
moduleNameIndex < options.compilerArguments.count - 2 else {
throw Console.Error("Could not determine module name for file at \(path)")
}
let moduleName = options.compilerArguments[moduleNameIndex + 1]
let moduleBuildDirectory = buildDirectory.appending(moduleName)
let moduleBuildDirectoryURL = try URL(filePath: moduleBuildDirectory).orThrow(Console.Error("Bad module name"))
try? FileManager.default.createDirectory(at: moduleBuildDirectoryURL, withIntermediateDirectories: true)
let swiftcOutput = try await Subprocess.run(
.path(try await BuildSettings.swiftcURL()),
arguments: .init(
["-c", "-driver-print-jobs"]
+ options.compilerArguments
+ ["-working-directory", moduleBuildDirectory.string]
),
output: .string(limit: .max),
error: .standardError
).checkSuccess()
let frontendCommands = (swiftcOutput.standardOutput ?? "").split(separator: "\n")
guard let invocation = frontendCommands.lazy.compactMap({ line -> CommandInvocation? in
guard let invocation = CommandInvocation(line) else { return nil }
guard invocation.value(for: "-primary-file") == fileURL.path else { return nil }
return invocation
}).first else { throw Console.Error("Could not find frontend command") }
let command = FrontendCommand(
commandLine: invocation,
output: moduleBuildDirectory.appending("\(lastComponent.stem).o"),
module: moduleName,
)
cachedCommands[path] = command
return command
}
private final class StreamingMessageHandler: MessageHandler {
private let (_notifications, onNotification) = AsyncStream<NotificationType>.makeStream()
var notifications: AsyncStream<NotificationType> { _notifications }
deinit { onNotification.finish() }
func handle(_ notification: some NotificationType) {
onNotification.yield(notification)
}
func handle<Request: RequestType>(
_ request: Request,
id: LanguageServerProtocol.RequestID,
reply: @escaping @Sendable (LanguageServerProtocol.LSPResult<Request.Response>) -> Void
) {
fatalError("Can't handle request \(Request.method)")
}
}
}
// https://github.com/swiftlang/sourcekit-lsp/blob/3278ca0e3/Sources/BuildServerIntegration/ExternalBuildServerAdapter.swift#L66
struct BuildServerConfiguration {
var executable: URL
var arguments: [String]
}
// https://build-server-protocol.github.io/docs/overview/server-discovery#the-bsp-connection-details
struct BuildServerDefinition: Codable {
var name: String
var version: String
var bspVersion: String
var languages: [String]
var argv: [String]
}
extension BuildServerConfiguration {
static func swiftPM(settings: BuildSettings) async throws -> Self {
guard let swiftURL = URL(filePath: try await BuildSettings.swiftURL()) else {
throw Console.Error("Swift URL invalid")
}
return BuildServerConfiguration(
executable: swiftURL,
arguments: settings.buildServerArguments
)
}
static func swiftPM(in url: URL) async throws -> Self? {
if url.appending(path: "Package.swift").exists {
return try await .swiftPM(settings: .init(configuration: .debug, triple: "arm64-apple-ios-simulator"))
}
return nil
}
static func external(definition: BuildServerDefinition) async throws -> Self {
guard !definition.argv.isEmpty else {
throw Console.Error("BSP argv must be non-empty")
}
var arguments = definition.argv
let executable = URL(filePath: arguments.removeFirst())
return BuildServerConfiguration(
executable: executable,
arguments: arguments
)
}
static func external(definition url: URL) async throws -> Self {
let data = try Data(contentsOf: url)
let definition = try JSONDecoder().decode(BuildServerDefinition.self, from: data)
return try await .external(definition: definition)
}
static func external(in directory: URL) async throws -> Self? {
let bsp = directory.appending(path: ".bsp")
let bspContents = (try? FileManager.default.contentsOfDirectory(at: bsp, includingPropertiesForKeys: nil)) ?? []
let bspFiles = bspContents.filter { $0.pathExtension == "json" }
switch bspFiles.count {
case 0:
return nil
case 1:
return try await .external(definition: bspFiles[0])
default:
throw Console.Error("""
Found multiple Build Server definitions in '\(bsp.absoluteURL.path)'.
Please explicitly specify the one you want to use.
""")
}
}
static func discover(in directory: URL) async throws -> Self? {
if let external = try await external(in: directory) {
return external
}
if let swiftPM = try await swiftPM(in: directory) {
return swiftPM
}
return nil
}
}
struct CommandInvocation {
var command: String
var arguments: [String]
init?(_ string: some StringProtocol) {
guard let all = try? CommandParser.parse(string), !all.isEmpty else { return nil }
command = all[0]
arguments = Array(all.dropFirst())
}
func value(for option: some StringProtocol) -> String? {
guard let optionIndex = arguments.firstIndex(where: { $0 == option }) else { return nil }
guard optionIndex < arguments.count - 2 else { return nil }
return arguments[optionIndex + 1]
}
}
enum CommandParser {
enum Errors: Error, Hashable {
case unclosedQuote
case unpairedEscape
}
static func parse(_ string: some StringProtocol) throws -> [String] {
try sequence(
state: (
current: string[...],
isInsideQuote: false,
)
) { state -> Token? in
while !state.current.isEmpty {
switch state.current.removeFirst() {
case "'":
state.isInsideQuote.toggle()
case "\\" where !state.isInsideQuote:
guard !state.current.isEmpty else { return .error(.unpairedEscape) }
let actual = state.current.removeFirst()
return .value(actual)
case " " where !state.isInsideQuote:
return .sentinelSpace
case let value:
return .value(value)
}
}
guard !state.isInsideQuote else {
state.isInsideQuote = false
return .error(.unclosedQuote)
}
return nil
}
.lazy
.split(separator: .sentinelSpace)
.map {
let characters = try $0.compactMap { token -> Character? in
switch token {
case .sentinelSpace: nil
case .error(let error): throw error
case .value(let value): value
}
}
return String(characters)
}
}
private enum Token: Hashable {
case sentinelSpace
case value(Character)
case error(Errors)
}
}
+1
View File
@@ -30,6 +30,7 @@ private struct XToolCommand: AsyncParsableCommand {
NewCommand.self,
DevCommand.self,
DSCommand.self,
HotReloadCommand.self,
]
),
CommandGroup(
+65
View File
@@ -0,0 +1,65 @@
#if canImport(Subprocess)
import Subprocess
import Foundation
extension ExecutionRecord {
@discardableResult
public func checkSuccess() throws(SubprocessFailure) -> Self {
try terminationStatus.checkSuccess()
return self
}
}
extension ExecutionOutcome {
@discardableResult
public func checkSuccess() throws(SubprocessFailure) -> Self {
try terminationStatus.checkSuccess()
return self
}
}
extension TerminationStatus {
fileprivate func checkSuccess() throws(SubprocessFailure) {
if let failure { throw failure }
}
private var failure: SubprocessFailure? {
if isSuccess { return nil }
switch self {
case .exited(let code): return .exited(code)
case .signaled(let code): return .signaled(code)
}
}
}
public enum SubprocessFailure: Error {
case exited(TerminationStatus.Code)
case signaled(TerminationStatus.Code)
}
extension PlatformOptions {
public static var withGracefulShutDown: Self {
.init().withGracefulShutDown
}
public var withGracefulShutDown: Self {
var copy = self
copy.teardownSequence = [
.gracefulShutDown(
allowedDurationToNextStep: .milliseconds(500)
)
]
return copy
}
}
extension Environment {
public static func currentMap() -> [Environment.Key: String] {
Dictionary(
uniqueKeysWithValues: ProcessInfo.processInfo.environment.map {
(Environment.Key(rawValue: $0)!, $1)
}
)
}
}
#endif
+53
View File
@@ -0,0 +1,53 @@
import Foundation
#if canImport(System)
import System
public typealias FilePath = System.FilePath
public typealias FileDescriptor = System.FileDescriptor
public typealias Errno = System.Errno
#else
import SystemPackage
public typealias FilePath = SystemPackage.FilePath
public typealias FileDescriptor = SystemPackage.FileDescriptor
public typealias Errno = SystemPackage.Errno
extension URL {
public init?(filePath: FilePath) {
self.init(filePath: filePath.string)
}
}
extension FilePath {
public init?(_ url: URL) {
guard url.isFileURL else { return nil }
self.init(url.path)
}
}
#endif
extension FileDescriptor {
enum LockMode {
case shared
case exclusive
fileprivate var raw: CInt {
switch self {
case .shared: LOCK_SH
case .exclusive: LOCK_EX
}
}
}
func tryLock(mode: LockMode) throws -> Bool {
if flock(rawValue, mode.raw | LOCK_NB) == 0 {
return true
}
let err = errno
if err == EWOULDBLOCK {
return false
}
throw Errno(rawValue: err)
}
}
+65 -8
View File
@@ -83,23 +83,80 @@ private struct TemporaryDirectoryRoot {
url = FileManager.default.temporaryDirectory.appendingPathComponent("sh.xtool")
#endif
}
try? FileManager.default.removeItem(at: url)
do {
try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
} catch {
self._url = .failure(Errors.tmpdirCreationFailed(url, error))
return
Self.pruneOrphans(in: url)
self._url = Result {
let childDir = try Self.claimDirectory(in: url)
try FileManager.default.createDirectory(at: childDir, withIntermediateDirectories: true)
return childDir
}
.mapError { $0 as? Errors ?? .tmpdirCreationFailed(url, $0) }
}
private static func claimDirectory(in url: URL) throws -> URL {
try FileManager.default.createDirectory(at: url, withIntermediateDirectories: true)
// #if os(macOS)
// let random = UUID().uuidString
// let lockFile = url.appending(path: "\(random).lock")
// print("Locking")
// _ = try FileDescriptor.open(FilePath(lockFile.path), .readWrite, options: [.create, .exclusiveLock])
// print("Locked")
// return url.appending(path: random)
// #else
for _ in 0..<10 {
let random = UUID().uuidString
let lockFile = url.appending(path: "\(random).lock")
FileManager.default.createFile(atPath: lockFile.path, contents: nil)
let fd = try FileDescriptor.open(FilePath(lockFile.path), .writeOnly, options: [])
guard try fd.tryLock(mode: .exclusive) else {
// someone else raced us and claimed the right to prune between when we created the file and
// when we tried to lock it
continue
}
return url.appending(path: random)
}
throw Errors.tmpdirClaimFailed(url)
// #endif
}
private static func pruneOrphans(in url: URL) {
guard let children = try? FileManager.default.contentsOfDirectory(at: url, includingPropertiesForKeys: nil)
else { return }
for lock in children {
do {
let basename = lock.lastPathComponent
guard basename.hasSuffix(".lock") && basename != ".lock" else { continue }
let lockFD = try FileDescriptor.open(FilePath(lock.path), .readWrite)
defer { try? lockFD.close() }
if try lockFD.tryLock(mode: .exclusive) {
// we must remove the directory first. if we instead removed the lock first,
// we could be killed after the lock was removed but before the dir was
// removed and therefore leave it hanging around.
do {
try FileManager.default.removeItem(at: lock.deletingPathExtension())
} catch CocoaError.fileNoSuchFile {
// pass
}
try FileManager.default.removeItem(at: lock)
}
} catch {
// continue
}
}
self._url = .success(url)
}
enum Errors: Error, CustomStringConvertible {
case tmpdirCreationFailed(URL, Error)
case tmpdirClaimFailed(URL)
var description: String {
switch self {
case let .tmpdirCreationFailed(url, error):
"Could not create temporary directory at '\(url.path)': \(error)"
"Could not create temporary directory in '\(url.path)': \(error)"
case let .tmpdirClaimFailed(url):
"Could not claim temporary directory in '\(url.path)'"
}
}
}
@@ -0,0 +1,25 @@
import Testing
@testable import XToolSupport
@Test func commandParser() throws {
func sut(_ string: some StringProtocol) throws -> [String] {
try CommandParser.parse(string)
}
#expect(try sut(#""#).isEmpty)
#expect(try sut(#"foo"#) == ["foo"])
#expect(try sut(#"foo "#) == ["foo"])
#expect(try sut(#"foo one two"#) == ["foo", "one", "two"])
#expect(try sut(#"foo 'one two' three"#) == ["foo", "one two", "three"])
#expect(try sut(#"foo 'one!two' three"#) == ["foo", "one!two", "three"])
#expect(try sut(#"foo one\!two three"#) == ["foo", "one!two", "three"])
#expect(try sut(#"foo one\'two three"#) == ["foo", "one'two", "three"])
#expect(try sut(#"foo one'two three'four five"#) == ["foo", "onetwo threefour", "five"])
#expect(throws: CommandParser.Errors.unclosedQuote) {
try sut(#"foo one two' three"#)
}
#expect(throws: CommandParser.Errors.unpairedEscape) {
try sut(#"foo a b \"#)
}
}
+1 -1
View File
@@ -11,7 +11,7 @@ targets:
XToolMac:
type: application
platform: macOS
deploymentTarget: "13.0"
deploymentTarget: "14.0"
sources:
- path: XToolMac
- path: Resources/xtool