iOS: launch agent workspaces from the task composer

.github/swift-file-length-budget.tsv

@@ -12,7 +12,7 @@
 9497	cmuxTests/CLINotifyProcessIntegrationRegressionTests.swift
 8016	CLI/cmux_open.swift
 7959	Sources/Panels/BrowserPanelView.swift
-7736	Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite.swift
+7669	Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite.swift
 7489	cmuxTests/WorkspaceUnitTests.swift
 7312	cmuxTests/WorkspaceRemoteConnectionTests.swift
 6359	cmuxTests/SessionPersistenceTests.swift

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+RouteSelection.swift

@@ -0,0 +1,83 @@
+internal import CMUXMobileCore
+internal import Foundation
+
+// Route selection for reconnect/attach: which published route a phone should
+// dial for a Mac, and why loopback routes are only valid on the simulator.
+// Extracted from MobileShellComposite.swift (Swift file length budget).
+extension MobileShellComposite {
+    /// Whether route selection should avoid loopback routes. A loopback route
+    /// (`.debugLoopback`, `127.0.0.1`) names the host it runs on, so on a
+    /// physical device it can only ever reach the phone itself, never a remote
+    /// Mac. On the simulator `127.0.0.1` IS the host Mac, so loopback is valid
+    /// (and is how the dev/UI-test mock host attaches).
+    static var prefersNonLoopbackRoutes: Bool {
+        #if targetEnvironment(simulator)
+        false
+        #else
+        true
+        #endif
+    }
+
+    /// The first reachable host/port route to a Mac, in priority order.
+    ///
+    /// When `preferNonLoopback` is set (physical devices), a real route
+    /// (`.tailscale` etc.) is always chosen over a `.debugLoopback` route even
+    /// if the loopback route has a lower (more-preferred) priority, because a
+    /// loopback route can never reach a remote Mac from a physical phone. A
+    /// loopback route is used only when it is the sole supported route — the
+    /// on-device XCUITest mock host, which serves a real listener on `127.0.0.1`
+    /// inside the test runner. This is what lets a restored Mac (whose published
+    /// routes include both `debug_loopback` and `tailscale`) actually connect
+    /// over Tailscale instead of dialing the phone's own loopback and failing.
+    static func firstReconnectHostPortRoute(
+        _ routes: [CmxAttachRoute],
+        supportedKinds: [CmxAttachTransportKind],
+        preferNonLoopback: Bool = false
+    ) -> (String, Int)? {
+        let supportedKinds = Set(supportedKinds)
+        let ordered = routes.sorted(by: Self.routeSortsBefore)
+        func firstHostPort(where predicate: (CmxAttachRoute) -> Bool) -> (String, Int)? {
+            for route in ordered {
+                if !supportedKinds.isEmpty, !supportedKinds.contains(route.kind) {
+                    continue
+                }
+                guard predicate(route), case let .hostPort(host, port) = route.endpoint else {
+                    continue
+                }
+                return (host, port)
+            }
+            return nil
+        }
+        if preferNonLoopback {
+            // Among non-loopback routes, prefer one whose host is a numeric IP: a
+            // raw tailscale/LAN IP is dialable without DNS, whereas a MagicDNS
+            // hostname (e.g. "<node>.<tailnet>.ts.net") depends on the client
+            // having tailscale DNS active and resolving it. On devices where
+            // MagicDNS isn't resolving, dialing the hostname times out and the Mac
+            // silently drops out of the list, even though its IP route is fine.
+            if let ip = firstHostPort(where: { route in
+                guard route.kind != .debugLoopback,
+                      case let .hostPort(host, _) = route.endpoint else { return false }
+                return Self.isIPLiteralHost(host)
+            }) {
+                return ip
+            }
+            if let real = firstHostPort(where: { $0.kind != .debugLoopback }) {
+                return real
+            }
+        }
+        return firstHostPort(where: { _ in true })
+    }
+
+    /// Whether `host` is a numeric IP literal (IPv4 or IPv6) rather than a name
+    /// that needs DNS resolution. Used to prefer directly-dialable IP routes over
+    /// MagicDNS hostnames, which fail to resolve on some clients.
+    static func isIPLiteralHost(_ host: String) -> Bool {
+        if host.contains(":") { return true } // IPv6 literal
+        let octets = host.split(separator: ".", omittingEmptySubsequences: false)
+        return octets.count == 4 && octets.allSatisfy { part in
+            guard let value = Int(part), (0...255).contains(value), !part.isEmpty else { return false }
+            return String(value) == part // reject leading zeros / non-canonical
+        }
+    }
+}

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+TaskComposer.swift

@@ -0,0 +1,29 @@
+public import CmuxMobilePairedMac
+public import CmuxMobileShellModel
+internal import Foundation
+
+extension MobileShellComposite {
+    /// Submit a task-composer workspace create request to the selected Mac.
+    /// - Parameters:
+    ///   - macDeviceID: Target Mac device id.
+    ///   - spec: Workspace-create parameters derived from the selected template.
+    /// - Returns: `success` when the workspace was created; otherwise the failure to display.
+    @discardableResult
+    public func submitTaskComposer(
+        macDeviceID: String,
+        spec: MobileWorkspaceCreateSpec
+    ) async -> Result<Void, MobileWorkspaceMutationFailure> {
+        if macDeviceID != foregroundMacDeviceID {
+            guard await switchToMac(macDeviceID: macDeviceID) else {
+                return .failure(.notConnected(hostDisplayName: taskComposerTargetName(macDeviceID: macDeviceID)))
+            }
+        }
+        return await createWorkspaceRequest(spec: spec)
+    }
+
+    private func taskComposerTargetName(macDeviceID: String) -> String {
+        displayPairedMacs.first { $0.macDeviceID == macDeviceID }?.resolvedName
+            ?? pairedMacs.first { $0.macDeviceID == macDeviceID }?.resolvedName
+            ?? macDeviceID
+    }
+}

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite+WorkspaceCreateRequest.swift

@@ -5,11 +5,13 @@ internal import Foundation
 extension MobileShellComposite {
     /// Create a workspace and surface success/failure to the caller.
     /// - Parameter groupID: Optional destination group for the new workspace.
+    /// - Parameter spec: Optional workspace-create parameters for task creation.
     /// - Returns: `success` when the connected Mac created the workspace,
     ///   otherwise the failure the UI should surface.
     @discardableResult
     public func createWorkspaceRequest(
-        inGroup groupID: MobileWorkspaceGroupPreview.ID? = nil
+        inGroup groupID: MobileWorkspaceGroupPreview.ID? = nil,
+        spec: MobileWorkspaceCreateSpec? = nil
     ) async -> Result<Void, MobileWorkspaceMutationFailure> {
         guard remoteClient != nil else {
             return .failure(.notConnected(hostDisplayName: connectedHostName))
@@ -18,7 +20,7 @@ extension MobileShellComposite {
             return .failure(.authorizationFailed(hostDisplayName: connectedHostName))
         }
         if let createWorkspaceTask {
-            guard createWorkspaceTaskGroupID == groupID else {
+            guard spec == nil, createWorkspaceTaskSpec == nil, createWorkspaceTaskGroupID == groupID else {
                 return .failure(.busy(hostDisplayName: connectedHostName))
             }
             return await createWorkspaceTask.value
@@ -30,17 +32,20 @@ extension MobileShellComposite {
             guard let self else { return .success(()) }
             return await self.createRemoteWorkspace(
                 inGroup: groupID,
-                appliesOperationalError: false
+                appliesOperationalError: false,
+                spec: spec
             )
         }
         createWorkspaceTask = task
         createWorkspaceTaskGroupID = groupID
+        createWorkspaceTaskSpec = spec
         return await task.value
     }
 
     func createRemoteWorkspace(
         inGroup groupID: MobileWorkspaceGroupPreview.ID? = nil,
-        appliesOperationalError: Bool = true
+        appliesOperationalError: Bool = true,
+        spec: MobileWorkspaceCreateSpec? = nil
     ) async -> Result<Void, MobileWorkspaceMutationFailure> {
         guard let client = remoteClient else {
             return .failure(.notConnected(hostDisplayName: connectedHostName))
@@ -54,6 +59,20 @@ extension MobileShellComposite {
             if let groupID {
                 params["group_id"] = groupID.rawValue
             }
+            if let title = spec?.title?.trimmingCharacters(in: .whitespacesAndNewlines), !title.isEmpty {
+                params["title"] = title
+            }
+            if let workingDirectory = spec?.workingDirectory?.trimmingCharacters(in: .whitespacesAndNewlines),
+               !workingDirectory.isEmpty {
+                params["working_directory"] = workingDirectory
+            }
+            if let initialCommand = spec?.initialCommand?.trimmingCharacters(in: .whitespacesAndNewlines),
+               !initialCommand.isEmpty {
+                params["initial_command"] = initialCommand
+            }
+            if let initialEnv = spec?.initialEnv, !initialEnv.isEmpty {
+                params["initial_env"] = initialEnv
+            }
             let resultData = try await client.sendRequest(
                 MobileCoreRPCClient.requestData(method: "workspace.create", params: params)
             )

Packages/iOS/CmuxMobileShell/Sources/CmuxMobileShell/MobileShellComposite.swift

@@ -300,6 +300,8 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
     /// Mac, then phone-owned. `@ObservationIgnored` (views read `workspaceGroups`);
     /// injected so tests/previews can pass a suite-scoped `UserDefaults`.
     @ObservationIgnored var groupCollapseStore: MobileWorkspaceGroupCollapseStore
+    /// Device-local task templates used by the iOS task composer.
+    @ObservationIgnored public let taskTemplateStore: (any MobileTaskTemplateStoring)?
     /// The connected Mac's `mobile.host.status` capabilities. Feature gates are
     /// computed from this set so version-skew checks cannot drift from the raw
     /// host payload.
@@ -714,6 +716,7 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
     private var terminalSubscriptionRefreshTask: Task<Void, Never>?
     var createWorkspaceTask: Task<Result<Void, MobileWorkspaceMutationFailure>, Never>?
     var createWorkspaceTaskGroupID: MobileWorkspaceGroupPreview.ID?
+    var createWorkspaceTaskSpec: MobileWorkspaceCreateSpec?
     private var createTerminalTask: Task<Void, Never>?
     private var workspaceListRefreshTask: Task<Void, Never>?
     /// The user pull-to-refresh round-trip, kept on its own handle so the
@@ -903,11 +906,13 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
         feedbackEmailSubmitter: (any MobileFeedbackEmailSubmitting)? = nil,
         feedbackStampProvider: @escaping @MainActor () -> MobileFeedbackStamp = { MobileShellComposite.emptyFeedbackStamp },
         draftStore: (any TerminalDraftStoring)? = nil,
-        groupCollapseStore: MobileWorkspaceGroupCollapseStore = MobileWorkspaceGroupCollapseStore()
+        groupCollapseStore: MobileWorkspaceGroupCollapseStore = MobileWorkspaceGroupCollapseStore(),
+        taskTemplateStore: (any MobileTaskTemplateStoring)? = nil
     ) {
         self.runtime = runtime
         self.draftStore = draftStore
         self.groupCollapseStore = groupCollapseStore
+        self.taskTemplateStore = taskTemplateStore
         self.pairedMacStore = pairedMacStore
         self.pairedMacRestoreBoundary = pairedMacRestoreBoundary
         self.deviceRegistry = deviceRegistry
@@ -964,6 +969,7 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
         self.terminalSubscriptionRefreshTask = nil
         self.createWorkspaceTask = nil
         self.createWorkspaceTaskGroupID = nil
+        self.createWorkspaceTaskSpec = nil
         self.createTerminalTask = nil
         self.workspaceListRefreshTask = nil
         self.pullToRefreshTask = nil
@@ -2766,82 +2772,6 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
         didFinishStoredMacReconnectAttempt = false
     }
 
-    /// Whether route selection should avoid loopback routes. A loopback route
-    /// (`.debugLoopback`, `127.0.0.1`) names the host it runs on, so on a
-    /// physical device it can only ever reach the phone itself, never a remote
-    /// Mac. On the simulator `127.0.0.1` IS the host Mac, so loopback is valid
-    /// (and is how the dev/UI-test mock host attaches).
-    static var prefersNonLoopbackRoutes: Bool {
-        #if targetEnvironment(simulator)
-        false
-        #else
-        true
-        #endif
-    }
-
-    /// The first reachable host/port route to a Mac, in priority order.
-    ///
-    /// When `preferNonLoopback` is set (physical devices), a real route
-    /// (`.tailscale` etc.) is always chosen over a `.debugLoopback` route even
-    /// if the loopback route has a lower (more-preferred) priority, because a
-    /// loopback route can never reach a remote Mac from a physical phone. A
-    /// loopback route is used only when it is the sole supported route — the
-    /// on-device XCUITest mock host, which serves a real listener on `127.0.0.1`
-    /// inside the test runner. This is what lets a restored Mac (whose published
-    /// routes include both `debug_loopback` and `tailscale`) actually connect
-    /// over Tailscale instead of dialing the phone's own loopback and failing.
-    static func firstReconnectHostPortRoute(
-        _ routes: [CmxAttachRoute],
-        supportedKinds: [CmxAttachTransportKind],
-        preferNonLoopback: Bool = false
-    ) -> (String, Int)? {
-        let supportedKinds = Set(supportedKinds)
-        let ordered = routes.sorted(by: Self.routeSortsBefore)
-        func firstHostPort(where predicate: (CmxAttachRoute) -> Bool) -> (String, Int)? {
-            for route in ordered {
-                if !supportedKinds.isEmpty, !supportedKinds.contains(route.kind) {
-                    continue
-                }
-                guard predicate(route), case let .hostPort(host, port) = route.endpoint else {
-                    continue
-                }
-                return (host, port)
-            }
-            return nil
-        }
-        if preferNonLoopback {
-            // Among non-loopback routes, prefer one whose host is a numeric IP: a
-            // raw tailscale/LAN IP is dialable without DNS, whereas a MagicDNS
-            // hostname (e.g. "<node>.<tailnet>.ts.net") depends on the client
-            // having tailscale DNS active and resolving it. On devices where
-            // MagicDNS isn't resolving, dialing the hostname times out and the Mac
-            // silently drops out of the list, even though its IP route is fine.
-            if let ip = firstHostPort(where: { route in
-                guard route.kind != .debugLoopback,
-                      case let .hostPort(host, _) = route.endpoint else { return false }
-                return Self.isIPLiteralHost(host)
-            }) {
-                return ip
-            }
-            if let real = firstHostPort(where: { $0.kind != .debugLoopback }) {
-                return real
-            }
-        }
-        return firstHostPort(where: { _ in true })
-    }
-
-    /// Whether `host` is a numeric IP literal (IPv4 or IPv6) rather than a name
-    /// that needs DNS resolution. Used to prefer directly-dialable IP routes over
-    /// MagicDNS hostnames, which fail to resolve on some clients.
-    static func isIPLiteralHost(_ host: String) -> Bool {
-        if host.contains(":") { return true } // IPv6 literal
-        let octets = host.split(separator: ".", omittingEmptySubsequences: false)
-        return octets.count == 4 && octets.allSatisfy { part in
-            guard let value = Int(part), (0...255).contains(value), !part.isEmpty else { return false }
-            return String(value) == part // reject leading zeros / non-canonical
-        }
-    }
-
     /// Enqueues one paired-Mac store mutation on the serialized write chain.
     ///
     /// All `markActive` writes go through here so they execute strictly in
@@ -4139,6 +4069,7 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
                 return await self.createRemoteWorkspace(inGroup: groupID)
             }
             createWorkspaceTaskGroupID = groupID
+            createWorkspaceTaskSpec = nil
             return
         }
         guard groupID == nil else { return }
@@ -5326,6 +5257,7 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
         createWorkspaceTask?.cancel()
         createWorkspaceTask = nil
         createWorkspaceTaskGroupID = nil
+        createWorkspaceTaskSpec = nil
         createWorkspaceTaskID = nil
         createTerminalTask?.cancel()
         createTerminalTask = nil
@@ -5662,6 +5594,7 @@ public final class MobileShellComposite: MobileTerminalOutputSinking {
         guard createWorkspaceTaskID == id else { return }
         createWorkspaceTask = nil
         createWorkspaceTaskGroupID = nil
+        createWorkspaceTaskSpec = nil
         createWorkspaceTaskID = nil
     }