Fail fast when a REPL target is not a launchable app

Summary:
`idb-repl app --bundle-id com.apple.springboard` now fails immediately, naming the app and explaining why, instead of hanging for the client's full two-minute deadline and then reporting only a hashed socket path.

SpringBoard is a launchd job, not a launchable app. Launching one still reports success, because CoreSimulator resolves it to the process already running -- so the injected environment is dropped, `libRepl` is never loaded, and nothing ever binds the control socket the client is waiting for. The wait cannot succeed, and the message it eventually produced named neither the app nor the cause.

The guard runs after the launch and asks whether the bundle id now has a `UIKitApplication:` service in the simulator's launchd. A real app registers one; a launchd-managed target never does. This is the same lookup `confirmApplicationLaunchState` already trusts to decide whether an app is running, so it introduces no new signal -- it just stops discarding the one case the two cannot distinguish, where "no service" means "not an app" rather than "not running".

Deliberately not keyed on install type. Apple's system apps are ordinary launchable apps as far as injection is concerned -- Safari, Photos, Settings, Messages, Maps, Calendar, Contacts, Reminders, Files and Health all host a REPL with full access to their own UIKit state -- so refusing a target for being Apple-signed would be wrong. A comment at the call site says so, because the install-type predicate already exists nearby for uninstall and is the tempting thing to reach for.

Reviewed By: williamtwilson

Differential Revision: D119189291

fbshipit-source-id: 805ad2d2efb356f96ce98daecf95b98e54330d72

Author: lawrencelomax

FBSimulatorControl/Commands/SimulatorReplCommands.swift

@@ -12,6 +12,7 @@ import Foundation
 public enum FBSimulatorReplError: Error {
   case bundledResourceMissing(item: String)
   case socketDirectoryCreationFailed(path: String)
+  case targetIsNotALaunchableApp(bundleID: String, processIdentifier: pid_t)
 }
 
 extension FBSimulatorReplError: LocalizedError {
@@ -21,6 +22,12 @@ extension FBSimulatorReplError: LocalizedError {
       return "\(item) not found in the companion Resources directory"
     case let .socketDirectoryCreationFailed(path):
       return "Could not create a private REPL socket directory at \(path)"
+    case let .targetIsNotALaunchableApp(bundleID, processIdentifier):
+      return """
+        \(bundleID) is managed by launchd (pid \(processIdentifier)), not launched as an app, \
+        so launching it returns the process already running and the REPL dylib is never injected. \
+        Target an app bundle instead.
+        """
     }
   }
 }
@@ -168,7 +175,24 @@ public final class FBSimulatorReplCommands {
       io: io,
       launchMode: .relaunchIfRunning
     )
-    _ = try await simulator.launchApplication(configuration)
+    let launched = try await simulator.launchApplication(configuration)
+
+    // A launched app registers a `UIKitApplication:` service with the simulator's
+    // launchd; a launchd-managed target such as SpringBoard never does. CoreSimulator
+    // still reports success for one -- it resolves to the process already running, so
+    // the injected environment is dropped and nothing ever binds the control socket.
+    // Without this the client spends its entire deadline waiting for a socket that
+    // cannot appear, then reports only a hashed path.
+    //
+    // This is the same lookup `confirmApplicationLaunchState` already trusts to decide
+    // whether an app is running, so it introduces no new signal. It is deliberately not
+    // `installType == .system`: Apple's system apps host a REPL perfectly well, and
+    // refusing them would be wrong.
+    guard (try? await simulator.processID(forBundleID: bundleID)) != nil else {
+      throw FBSimulatorReplError.targetIsNotALaunchableApp(
+        bundleID: bundleID,
+        processIdentifier: launched.processIdentifier)
+    }
 
     // The app outlives the REPL session -- it keeps running and resets for the
     // next client on disconnect -- so `run` is already resolved: teardown must not

FBSimulatorControlTests/Tests/Unit/FBSimulatorReplErrorTests.swift

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+@testable import FBSimulatorControl
+import Foundation
+import Testing
+
+/// Coverage of the REPL error descriptions. These strings are the only thing a
+/// user sees when a session fails to start, so each is pinned to keep it naming
+/// the thing that went wrong rather than an internal detail.
+@Suite
+struct FBSimulatorReplErrorTests {
+
+  @Test
+  func bundledResourceMissingNamesTheItem() throws {
+    let message = try #require(
+      FBSimulatorReplError.bundledResourceMissing(item: "libRepl-iOS.dylib").errorDescription)
+    #expect(message.contains("libRepl-iOS.dylib"))
+  }
+
+  @Test
+  func socketDirectoryCreationFailedNamesThePath() throws {
+    let message = try #require(
+      FBSimulatorReplError.socketDirectoryCreationFailed(path: "/tmp/idb_repl_501").errorDescription)
+    #expect(message.contains("/tmp/idb_repl_501"))
+  }
+
+  // MARK: - targetIsNotALaunchableApp
+
+  @Test
+  func notALaunchableAppNamesTheBundleIDAndProcess() throws {
+    let message = try #require(
+      FBSimulatorReplError
+        .targetIsNotALaunchableApp(bundleID: "com.apple.springboard", processIdentifier: 53_820)
+        .errorDescription)
+    #expect(message.contains("com.apple.springboard"))
+    #expect(message.contains("53820"))
+  }
+
+  @Test
+  func notALaunchableAppExplainsTheCauseAndTheRemedy() throws {
+    // The whole point of this error is that the previous behaviour -- waiting out
+    // the client's deadline and then reporting a hashed socket path -- told the
+    // reader neither what had failed nor what to do instead.
+    let message = try #require(
+      FBSimulatorReplError
+        .targetIsNotALaunchableApp(bundleID: "com.apple.springboard", processIdentifier: 1)
+        .errorDescription)
+    #expect(message.contains("launchd"))
+    #expect(message.contains("never injected"))
+    #expect(message.contains("Target an app bundle instead."))
+  }
+
+  @Test
+  func notALaunchableAppIsASingleLine() throws {
+    // It is rendered into a gRPC status message, where embedded newlines are unreadable.
+    let message = try #require(
+      FBSimulatorReplError
+        .targetIsNotALaunchableApp(bundleID: "com.apple.springboard", processIdentifier: 1)
+        .errorDescription)
+    #expect(!message.contains("\n"))
+  }
+}