apple-crates

@@ -461,7 +461,7 @@ pub(crate) async fn sign_ipa(

     )]);

     let mut profile_requests = vec![(effective_bundle_id.clone(), app_id.developer_id)];

-    for (nested_bundle, target) in request.app.nested_bundles.iter().zip(targets.nested) {

+    for (nested_bundle, target) in request.app.nested_bundles_for_signing().zip(targets.nested) {

         let (nested_app_id, account_update) = resolve_signing_app_id(

             request.developer_context.clone(),

             &request.team_id,

@@ -521,6 +521,7 @@ pub(crate) async fn sign_ipa(

             metadata,

             bundle_id_replacements,

             icon_override_path: request.app.icon_override_path.as_deref().map(PathBuf::from),

+            strip_extensions: request.app.strip_extensions,

             team_id: request.team_id,

             provisioning_profiles,

             private_key_pem: signing_material.private_key_pem,

@@ -690,8 +691,7 @@ fn nested_app_id_targets(

     app: &AppOption,

     root_bundle_identifier: &str,

 ) -> Vec<SigningAppIdTarget> {

-    app.nested_bundles

-        .iter()

+    app.nested_bundles_for_signing()

         .map(|nested_bundle| {

             let desired_identifier = rebased_nested_bundle_identifier(

                 app.original_bundle_id(),

@@ -1037,7 +1037,8 @@ pub(crate) async fn download_provisioning_profile(

 mod tests {

     use super::*;

     use crate::app::models::{

-        AppMetadata, EntitlementsSource, NestedBundleOption, SupportedDeviceFamily,

+        AppMetadata, EntitlementsSource, NestedBundleKind, NestedBundleOption,

+        SupportedDeviceFamily,

     };

     fn app_id(identifier: &str) -> AppIdOption {

@@ -1066,8 +1067,10 @@ mod tests {

                 .map(|bundle_id| NestedBundleOption {

                     name: bundle_id.rsplit('.').next().unwrap().to_string(),

                     bundle_id: (*bundle_id).to_string(),

+                    kind: NestedBundleKind::AppExtension,

                 })

                 .collect(),

+            strip_extensions: false,

             path: "/tmp/Example.ipa".to_string(),

             icon_path: None,

             icon_override_path: None,

@@ -1186,6 +1189,26 @@ mod tests {

         assert_eq!(plan.remaining_after_signing(), Some(3));

     }

+    #[test]

+    fn provisioning_plan_omits_stripped_extensions_but_keeps_nested_apps() {

+        let mut app = app(

+            "com.example.app",

+            &["com.example.app.widget", "com.example.app.watch"],

+        );

+        app.nested_bundles[1].kind = NestedBundleKind::App;

+        app.strip_extensions = true;

+

+        let plan = app_id_provisioning_plan(&team(Vec::new(), Some(5)), true, None, &app).unwrap();

+

+        assert_eq!(

+            plan.app_ids

+                .iter()

+                .map(|app_id| app_id.identifier.as_str())

+                .collect::<Vec<_>>(),

+            vec!["com.example.app.TEAM", "com.example.app.TEAM.watch"]

+        );

+    }

+

     #[test]

     fn provisioning_plan_reuses_unchanged_registered_app_ids() {

         let app = app("com.example.app", &["com.example.app.widget"]);

@@ -316,6 +316,7 @@ mod tests {

                 vec![SupportedDeviceFamily::IPhone],

             ),

             nested_bundles: Vec::new(),

+            strip_extensions: false,

             path: "/tmp/Example.ipa".to_string(),

             icon_path: None,

             icon_override_path: None,

@@ -437,6 +437,7 @@ pub(crate) enum EntitlementsSource {

 pub(crate) struct AppOption {

     pub(crate) metadata: AppMetadata,

     pub(crate) nested_bundles: Vec<NestedBundleOption>,

+    pub(crate) strip_extensions: bool,

     pub(crate) path: String,

     pub(crate) icon_path: Option<String>,

     pub(crate) icon_override_path: Option<String>,

@@ -450,6 +451,13 @@ pub(crate) struct AppOption {

 pub(crate) struct NestedBundleOption {

     pub(crate) name: String,

     pub(crate) bundle_id: String,

+    pub(crate) kind: NestedBundleKind,

+}

+

+#[derive(Clone, Copy, Debug, Eq, PartialEq)]

+pub(crate) enum NestedBundleKind {

+    App,

+    AppExtension,

 }

 impl AppOption {

@@ -473,6 +481,19 @@ impl AppOption {

         self.metadata.build.value()

     }

+    pub(crate) fn app_extension_count(&self) -> usize {

+        self.nested_bundles

+            .iter()

+            .filter(|bundle| bundle.kind == NestedBundleKind::AppExtension)

+            .count()

+    }

+

+    pub(crate) fn nested_bundles_for_signing(&self) -> impl Iterator<Item = &NestedBundleOption> {

+        self.nested_bundles.iter().filter(|bundle| {

+            !self.strip_extensions || bundle.kind != NestedBundleKind::AppExtension

+        })

+    }

+

     pub(crate) fn field(&self, field: AppMetadataField) -> &AppFieldValue {

         self.metadata.field(field)

     }

@@ -89,6 +89,8 @@ pub(crate) struct AppOverridePreferences {

     pub(crate) supported_devices: Option<String>,

     pub(crate) icon_path: Option<String>,

     pub(crate) entitlements: Option<Vec<EntitlementPreferences>>,

+    #[serde(default)]

+    pub(crate) strip_extensions: bool,

 }

 #[derive(Clone, Debug, Deserialize, Serialize)]

@@ -255,6 +257,7 @@ impl From<&AppOption> for AppOverridePreferences {

                     .map(EntitlementPreferences::from)

                     .collect()

             }),

+            strip_extensions: app.strip_extensions,

         }

     }

 }

@@ -277,6 +280,7 @@ pub(crate) fn apply_app_overrides(app: &mut AppOption, overrides: &AppOverridePr

             .map(AppEntitlement::from)

             .collect::<Vec<_>>()

     });

+    app.strip_extensions = overrides.strip_extensions && app.app_extension_count() > 0;

 }

 pub(crate) fn load_preferences() -> AppResult<SideloaderPreferences> {

@@ -299,7 +303,9 @@ pub(crate) fn save_preferences(preferences: &SideloaderPreferences) -> AppResult

 #[cfg(test)]

 mod tests {

     use super::*;

-    use crate::app::models::{AppMetadata, EntitlementsSource, PatchOption};

+    use crate::app::models::{

+        AppMetadata, EntitlementsSource, NestedBundleKind, NestedBundleOption, PatchOption,

+    };

     fn sample_app() -> AppOption {

         AppOption {

@@ -312,7 +318,12 @@ mod tests {

                 "16.0",

                 vec![SupportedDeviceFamily::IPhone],

             ),

-            nested_bundles: Vec::new(),

+            nested_bundles: vec![NestedBundleOption {

+                name: "Widget".to_string(),

+                bundle_id: "com.example.original.widget".to_string(),

+                kind: NestedBundleKind::AppExtension,

+            }],

+            strip_extensions: false,

             path: "/tmp/App.ipa".to_string(),

             icon_path: None,

             icon_override_path: None,

@@ -346,6 +357,7 @@ mod tests {

                     value: "true".to_string(),

                     values: None,

                 }]),

+                strip_extensions: true,

             },

         );

@@ -360,6 +372,8 @@ mod tests {

             &[SupportedDeviceFamily::IPhone, SupportedDeviceFamily::IPad]

         );

         assert_eq!(app.icon_override_path.as_deref(), Some("/tmp/icon.png"));

+        assert!(app.strip_extensions);

+        assert!(AppOverridePreferences::from(&app).strip_extensions);

         assert_eq!(

             app.entitlement_overrides,

             Some(vec![AppEntitlement {

@@ -368,4 +382,11 @@ mod tests {

             }])

         );

     }

+

+    #[test]

+    fn older_app_overrides_default_to_preserving_extensions() {

+        let overrides = toml::from_str::<AppOverridePreferences>("").unwrap();

+

+        assert!(!overrides.strip_extensions);

+    }

 }

@@ -126,6 +126,7 @@ mod tests {

                 vec![SupportedDeviceFamily::IPhone],

             ),

             nested_bundles: Vec::new(),

+            strip_extensions: false,

             path: path.to_string(),

             icon_path: None,

             icon_override_path: None,

@@ -762,6 +762,7 @@ mod tests {

                 vec![SupportedDeviceFamily::IPhone],

             ),

             nested_bundles: Vec::new(),

+            strip_extensions: false,

             path: "/tmp/Example.ipa".to_string(),

             icon_path: None,

             icon_override_path: None,

@@ -2,8 +2,8 @@ use crate::app::models::{

     AccountOption, AdiBackendAvailability, AdiBackendDetail, AdiBackendKind, AdiBackendOption,

     AdiProvisioningState, AdiRepairAction, AppEntitlement, AppIdCapabilityOption, AppIdOption,

     AppMetadata, AppOption, DeveloperDeviceOption, DevelopmentCertificateOption, DeviceOption,

-    EntitlementValue, EntitlementsSource, MachineIdentity, NestedBundleOption, PatchOption,

-    SupportedDeviceFamily, TeamOption,

+    EntitlementValue, EntitlementsSource, MachineIdentity, NestedBundleKind, NestedBundleOption,

+    PatchOption, SupportedDeviceFamily, TeamOption,

 };

 use crate::domain::{

     adi as domain_adi, device as domain_device, identity as domain_identity, ipa as domain_ipa,

@@ -100,8 +100,13 @@ pub(crate) fn app_option(app: domain_ipa::IpaApp) -> AppOption {

             .map(|bundle| NestedBundleOption {

                 name: bundle.name,

                 bundle_id: bundle.bundle_id,

+                kind: match bundle.kind {

+                    domain_ipa::NestedBundleKind::App => NestedBundleKind::App,

+                    domain_ipa::NestedBundleKind::AppExtension => NestedBundleKind::AppExtension,

+                },

             })

             .collect(),

+        strip_extensions: false,

         path: app.path,

         icon_path: app.icon_path,

         icon_override_path: None,

@@ -495,6 +500,7 @@ mod tests {

             nested_bundles: vec![domain_ipa::NestedBundle {

                 name: "Widget".to_string(),

                 bundle_id: "com.example.app.Widget".to_string(),

+                kind: domain_ipa::NestedBundleKind::AppExtension,

             }],

             path: "/tmp/Example.ipa".to_string(),

             icon_path: Some("/tmp/icon.png".to_string()),

@@ -512,6 +518,10 @@ mod tests {

         assert_eq!(option.name(), "Example");

         assert_eq!(option.bundle_id(), "com.example.app");

         assert_eq!(option.nested_bundles[0].bundle_id, "com.example.app.Widget");

+        assert_eq!(

+            option.nested_bundles[0].kind,

+            NestedBundleKind::AppExtension

+        );

         assert_eq!(

             option.supported_devices(),

             &[SupportedDeviceFamily::IPhone, SupportedDeviceFamily::IPad]

@@ -5,8 +5,8 @@ use crate::backend::icon::{

 use crate::backend::paths::app_data_dir;

 use crate::backend::{runtime as backend_runtime, BackendError, BackendResult};

 use crate::domain::{

-    AppEntitlement, AppMetadata, EntitlementValue, EntitlementsSource, IpaApp, NestedBundle, Patch,

-    SupportedDeviceFamily,

+    AppEntitlement, AppMetadata, EntitlementValue, EntitlementsSource, IpaApp, NestedBundle,

+    NestedBundleKind, Patch, SupportedDeviceFamily,

 };

 use apple_codesign::{

     sign_bundle, BundleSigningSettings, ProvisioningProfile, RustCryptoCmsSigner,

@@ -42,6 +42,7 @@ pub(crate) struct IpaSigningRequest {

     pub(crate) metadata: AppMetadata,

     pub(crate) bundle_id_replacements: BTreeMap<String, String>,

     pub(crate) icon_override_path: Option<PathBuf>,

+    pub(crate) strip_extensions: bool,

     pub(crate) team_id: String,

     pub(crate) provisioning_profiles: BTreeMap<String, Vec<u8>>,

     pub(crate) private_key_pem: Vec<u8>,

@@ -162,12 +163,13 @@ async fn read_nested_signable_bundles(

         .enumerate()

         .filter_map(|(index, entry)| {

             let path = entry_name(entry)?;

-            is_nested_signable_info_plist(path, app_prefix).then(|| (index, path.to_string()))

+            nested_signable_bundle_kind(path, app_prefix)

+                .map(|kind| (index, path.to_string(), kind))

         })

         .collect::<Vec<_>>();

     let mut bundles = Vec::with_capacity(candidates.len());

-    for (index, path) in candidates {

+    for (index, path, kind) in candidates {

         let bytes = read_entry(reader, index, &path).await?;

         let info = plist::from_bytes::<Dictionary>(&bytes)

             .map_err(|error| BackendError::Plist(format!("{path}: {error}")))?;

@@ -179,7 +181,11 @@ async fn read_nested_signable_bundles(

             .or_else(|| plist_string(&info, "CFBundleName"))

             .unwrap_or(&bundle_id)

             .to_string();

-        bundles.push(NestedBundle { name, bundle_id });

+        bundles.push(NestedBundle {

+            name,

+            bundle_id,

+            kind,

+        });

     }

     bundles.sort_by(|left, right| left.bundle_id.cmp(&right.bundle_id));

@@ -187,18 +193,23 @@ async fn read_nested_signable_bundles(

     Ok(bundles)

 }

-fn is_nested_signable_info_plist(path: &str, app_prefix: &str) -> bool {

-    let Some(relative) = path

+fn nested_signable_bundle_kind(path: &str, app_prefix: &str) -> Option<NestedBundleKind> {

+    let relative = path

         .strip_prefix(app_prefix)

-        .and_then(|path| path.strip_suffix("/Info.plist"))

-    else {

-        return false;

-    };

-    !relative.is_empty()

-        && relative

-            .rsplit('/')

-            .next()

-            .is_some_and(|folder| folder.ends_with(".appex") || folder.ends_with(".app"))

+        .and_then(|path| path.strip_suffix("/Info.plist"))?;

+    if relative.is_empty() {

+        return None;

+    }

+    let extension = Path::new(relative)

+        .extension()

+        .and_then(|extension| extension.to_str())?;

+    if extension.eq_ignore_ascii_case("appex") {

+        Some(NestedBundleKind::AppExtension)

+    } else if extension.eq_ignore_ascii_case("app") {

+        Some(NestedBundleKind::App)

+    } else {

+        None

+    }

 }

 fn is_app_info_plist(path: &str) -> bool {

@@ -470,6 +481,9 @@ async fn sign_ipa_async(

     extract_ipa(&request.source_path, work_dir.path(), &mut progress).await?;

     let app_path = root_app_bundle(work_dir.path())?;

     progress(IpaSigningProgress::Patching);

+    if request.strip_extensions {

+        strip_app_extensions(&app_path)?;

+    }

     patch_app_bundle(

         &app_path,

         &request.metadata,

@@ -523,6 +537,39 @@ async fn sign_ipa_async(

     Ok(SigningArtifact::Ipa(output_path))

 }

+fn strip_app_extensions(app_path: &Path) -> BackendResult<()> {

+    let mut entries = WalkDir::new(app_path).follow_links(false).into_iter();

+    let mut extension_paths = Vec::new();

+

+    while let Some(entry) = entries.next() {

+        let entry = entry.map_err(|error| {

+            BackendError::Message(format!(

+                "Failed to inspect app extensions under {}: {error}",

+                app_path.display()

+            ))

+        })?;

+        if entry.file_type().is_dir()

+            && entry

+                .path()

+                .extension()

+                .and_then(|extension| extension.to_str())

+                .is_some_and(|extension| extension.eq_ignore_ascii_case("appex"))

+        {

+            extension_paths.push(entry.into_path());

+            entries.skip_current_dir();

+        }

+    }

+

+    for path in extension_paths {

+        fs::remove_dir_all(&path).map_err(|source| BackendError::Io {

+            action: "Remove app extension",

+            path,

+            source,

+        })?;

+    }

+    Ok(())

+}

+

 async fn extract_ipa(

     source_path: &Path,

     destination: &Path,

@@ -1474,22 +1521,51 @@ mod tests {

     fn nested_signable_bundle_paths_include_extensions_and_nested_apps() {

         let root = "Payload/App.app/";

-        assert!(is_nested_signable_info_plist(

-            "Payload/App.app/PlugIns/Widget.appex/Info.plist",

-            root

-        ));

-        assert!(is_nested_signable_info_plist(

-            "Payload/App.app/Watch/WatchApp.app/Info.plist",

-            root

-        ));

-        assert!(!is_nested_signable_info_plist(

+        assert_eq!(

+            nested_signable_bundle_kind("Payload/App.app/PlugIns/Widget.appex/Info.plist", root),

+            Some(NestedBundleKind::AppExtension)

+        );

+        assert_eq!(

+            nested_signable_bundle_kind("Payload/App.app/Watch/WatchApp.app/Info.plist", root),

+            Some(NestedBundleKind::App)

+        );

+        assert_eq!(

+            nested_signable_bundle_kind(

                 "Payload/App.app/Frameworks/Example.framework/Info.plist",

                 root

-        ));

-        assert!(!is_nested_signable_info_plist(

-            "Payload/App.app/Info.plist",

-            root

-        ));

+            ),

+            None

+        );

+        assert_eq!(

+            nested_signable_bundle_kind("Payload/App.app/Info.plist", root),

+            None

+        );

+    }

+

+    #[test]

+    fn stripping_extensions_preserves_nested_apps_and_frameworks() {

+        let temp = tempfile::tempdir().unwrap();

+        let app_path = temp.path().join("Payload").join("Test.app");

+        let extension_path = app_path.join("PlugIns").join("Widget.appex");

+        let nested_app_path = app_path.join("Watch").join("WatchApp.app");

+        let nested_extension_path = nested_app_path.join("PlugIns").join("Companion.appex");

+        let framework_path = app_path.join("Frameworks").join("Example.framework");

+        for path in [

+            &extension_path,

+            &nested_app_path,

+            &nested_extension_path,

+            &framework_path,

+        ] {

+            fs::create_dir_all(path).unwrap();

+            fs::write(path.join("content"), b"test").unwrap();

+        }

+

+        strip_app_extensions(&app_path).unwrap();

+

+        assert!(!extension_path.exists());

+        assert!(!nested_extension_path.exists());

+        assert!(nested_app_path.exists());

+        assert!(framework_path.exists());

     }

     #[test]

@@ -41,6 +41,13 @@ pub(crate) struct AppMetadata {

 pub(crate) struct NestedBundle {

     pub(crate) name: String,

     pub(crate) bundle_id: String,

+    pub(crate) kind: NestedBundleKind,

+}

+

+#[derive(Clone, Copy, Debug, Eq, PartialEq)]

+pub(crate) enum NestedBundleKind {

+    App,

+    AppExtension,

 }

 #[derive(Clone, Debug, PartialEq)]

@@ -2883,6 +2883,24 @@ impl SettingsWindow {

         .detach();

     }

+    fn set_strip_extensions(

+        &mut self,

+        checked: &bool,

+        window: &mut Window,

+        cx: &mut Context<Self>,

+    ) {

+        window.focus(&self.focus_handle, cx);

+        let Some(mut snapshot) = self.app_settings_snapshot(cx) else {

+            return;

+        };

+        if snapshot.app.app_extension_count() == 0 {

+            return;

+        }

+        snapshot.app.strip_extensions = *checked;

+        self.replace_app_in_parent(snapshot.app_index, snapshot.app, cx);

+        cx.notify();

+    }

+

     fn begin_app_detail_edit(

         &mut self,

         field: AppMetadataField,

@@ -3430,6 +3448,7 @@ mod tests {

                 vec![SupportedDeviceFamily::IPhone],

             ),

             nested_bundles: Vec::new(),

+            strip_extensions: false,

             path: format!("/tmp/{name}.ipa"),

             icon_path: None,

             icon_override_path: None,

@@ -1,5 +1,5 @@

 use super::*;

-use gpui_component::{checkbox::Checkbox, Sizable as _};

+use gpui_component::{checkbox::Checkbox, Disableable as _, Sizable as _};

 pub(super) struct AppViewProps<'a> {

     pub(super) focus_handle: &'a FocusHandle,

@@ -130,6 +130,7 @@ pub(super) fn render(props: AppViewProps<'_>, cx: &mut Context<SettingsWindow>)

                         .child(read_only_app_detail_row("IPA", app.path.to_string()))

                         .child(read_only_app_detail_row("Patches", patch_summary)),

                 )

+                .child(strip_extensions_checkbox(app, cx))

                 .child(entitlements_table(

                     app,

                     team_id,

@@ -141,6 +142,56 @@ pub(super) fn render(props: AppViewProps<'_>, cx: &mut Context<SettingsWindow>)

         ))

 }

+fn strip_extensions_checkbox(

+    app: &AppOption,

+    cx: &mut Context<SettingsWindow>,

+) -> impl IntoElement {

+    let extension_count = app.app_extension_count();

+    let detail = match extension_count {

+        0 => "No embedded app extensions were detected in this IPA.".to_string(),

+        1 => "Remove the embedded app extension before signing. Its App ID and profile will not be required."

+            .to_string(),

+        count => format!(

+            "Remove {count} embedded app extensions before signing. Their App IDs and profiles will not be required."

+        ),

+    };

+

+    Checkbox::new("strip-app-extensions")

+        .p_3()

+        .rounded_md()

+        .border_1()

+        .border_color(rgb(0xd8e0df))

+        .bg(rgb(0xffffff))

+        .hover(|style| style.bg(rgb(0xf6f9f9)))

+        .items_center()

+        .small()

+        .checked(app.strip_extensions)

+        .disabled(extension_count == 0)

+        .on_click(cx.listener(SettingsWindow::set_strip_extensions))

+        .child(

+            div()

+                .min_w_0()

+                .flex()

+                .flex_1()

+                .flex_col()

+                .gap_0p5()

+                .child(

+                    div()

+                        .text_sm()

+                        .font_weight(FontWeight::SEMIBOLD)

+                        .text_color(rgb(0x24333a))

+                        .child("Strip app extensions"),

+                )

+                .child(

+                    div()

+                        .text_xs()

+                        .text_color(rgb(0x6a7a81))

+                        .whitespace_normal()

+                        .child(detail),

+                ),

+        )

+}

+

 fn app_settings_error(error: SharedString) -> impl IntoElement {

     div()

         .rounded_md()