@livx.cc/appwrap 0.57.0 → 0.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.57.0",
+  "version": "0.58.0",
   "description": "Wrap any PWA into a native app with native capabilities (appwrap runtime + @livx.cc/native-kit).",
   "license": "MIT",
   "author": "Elya Livshitz",

package/runtime/App_Resources/Android/src/main/AndroidManifest.xml

@@ -58,6 +58,8 @@
 		<!-- App Links (https) — autoVerify intent-filters stamped per host from config.androidAppLinks
 		     (or derived from iOS associated-domains applinks:). Needs assetlinks.json on the host. -->
 		<!-- appwrap:app-links --><!-- /appwrap:app-links -->
+		<!-- Main-activity XML from active modules (e.g. shareTarget's ACTION_SEND filter) -->
+		<!-- appwrap:activity --><!-- /appwrap:activity -->
 	</activity>
 		<activity android:name="com.tns.ErrorReportActivity"/>
 

package/runtime/app/shell/capabilities.manifest.ts

@@ -56,6 +56,9 @@ export interface ModuleManifest {
     /** Raw XML injected inside the AndroidManifest `<application>` (activities, providers,
      * intent-filters a capability needs — e.g. Health Connect's permission-rationale activity). */
     manifestApplication?: string;
+    /** Raw XML injected inside the MAIN `<activity>` (intent-filters a capability needs on the
+     * launcher activity — e.g. shareTarget's ACTION_SEND filter). */
+    manifestActivity?: string;
   };
   /** Module-owned native source: a dir under `runtime/modules-native/<nativeSrc>/` mirroring the
    * App_Resources layout, copied into `native/` ONLY when the module is active (stays strippable).
@@ -272,13 +275,44 @@ export const MODULES: ModuleManifest[] = [
     android: { gradleDeps: ['androidx.work:work-runtime:2.9.1', 'com.google.guava:guava:33.3.1-android'] },
   },
 
+  // ── shareTarget — INBOUND OS share sheet (receive shared text/images) — opt-in, STRIPPABLE ──
+  // Android: an ACTION_SEND(_MULTIPLE) intent-filter on the main activity puts the app in the share
+  // sheet; the strippable handler reads the SEND intent (cold launch + warm onNewIntent) and
+  // re-delivers it through the EXISTING deep-link path as `<urlScheme>://share?text=…` — riding the
+  // proven cold-start buffering (handshake `deepLink`) + warm `deeplink.open` event with zero new
+  // bridge surface. iOS: a generated share-extension TARGET (`AppwrapShare`, from this module's
+  // nativeSrc via NS's App_Resources/iOS/extensions seam — same machinery as the widget pack) that
+  // forwards to the host app over `urlScheme` (REQUIRED in config); images cross via the App Group
+  // container (entitlement below, stamped on both targets) and the host shell relocates them into the
+  // app cache so the JS contract is platform-identical. Consume via `kit.shareTarget.onReceive` (or
+  // raw `kit.lifecycle.onDeepLink`).
+  {
+    name: 'shareTarget', group: 'shareTarget', nativeSrc: 'shareTarget',
+    capabilities: { shareTarget: 'native' },
+    ios: { entitlements: { 'com.apple.security.application-groups': ['__APP_GROUP__'] } },
+    android: {
+      manifestActivity:
+        `<intent-filter>\n` +
+        `\t\t\t<action android:name="android.intent.action.SEND" />\n` +
+        `\t\t\t<category android:name="android.intent.category.DEFAULT" />\n` +
+        `\t\t\t<data android:mimeType="text/plain" />\n` +
+        `\t\t\t<data android:mimeType="image/*" />\n` +
+        `\t\t</intent-filter>\n` +
+        `\t\t<intent-filter>\n` +
+        `\t\t\t<action android:name="android.intent.action.SEND_MULTIPLE" />\n` +
+        `\t\t\t<category android:name="android.intent.category.DEFAULT" />\n` +
+        `\t\t\t<data android:mimeType="image/*" />\n` +
+        `\t\t</intent-filter>`,
+    },
+  },
+
   // NOTE: billing, health, and widget are NOT part of CE — they live in host-provided module packs
   // (a consumer opts in via `modulePacks`).
 ];
 
 /** Opt-in registration groups that own their own NS handler file (strippable when inactive). Core
  * groups (core/extended/parity/system/media) are always bundled; only these are CLI-gated. */
-export const OPTIONAL_GROUPS = ['oauth', 'reviews', 'scanner', 'speech', 'tracking', 'appleSignIn', 'backgroundTask'] as const;
+export const OPTIONAL_GROUPS = ['oauth', 'reviews', 'scanner', 'speech', 'tracking', 'appleSignIn', 'backgroundTask', 'shareTarget'] as const;
 
 /** CLI-gated groups (strippable in explicit mode) that legacy mode (no `modules` key) STILL auto-bundles
  * for back-compat. Empty now that billing (its only member) moved to a host-provided pack — kept as the

package/runtime/app/shell/events.ts

@@ -25,8 +25,20 @@ export function setDeepLinkInterceptor(fn: ((url: string) => boolean) | null): v
   deepLinkInterceptor = fn;
 }
 
+/** A pending native-side REWRITER of an inbound deep link (e.g. shareTarget on iOS relocating shared
+ * files from the App Group container into the app cache and rewriting the link to point at them).
+ * Runs before the interceptor; returns the URL to deliver (usually unchanged). Set by
+ * handlers-share-target. Distinct from the interceptor: a transform forwards, an interceptor consumes. */
+let deepLinkTransformer: ((url: string) => string) | null = null;
+export function setDeepLinkTransformer(fn: ((url: string) => string) | null): void {
+  deepLinkTransformer = fn;
+}
+
 /** Called by the iOS delegate (cold start or while running) and Android intents. */
 export function onDeepLink(url: string): void {
+  if (deepLinkTransformer) {
+    try { url = deepLinkTransformer(url); } catch (e) { console.warn('AppWrap: deep-link transform failed', e); }
+  }
   // Give a native consumer (OAuth callback) first refusal — a matched OAuth redirect is internal
   // plumbing, not an app deep link, so it's swallowed here and never forwarded to the PWA.
   if (deepLinkInterceptor?.(url)) return;
@@ -48,8 +60,15 @@ export function onDeepLink(url: string): void {
  * Returns null when the launch wasn't from a link (or it was already consumed / delivered warm).
  */
 export function consumePendingDeepLink(): string | null {
-  const url = pendingDeepLink;
+  let url = pendingDeepLink;
   pendingDeepLink = null;
+  // Re-apply the transformer: an iOS cold-launch link is ingested in didFinishLaunching, BEFORE
+  // main-page init registers transformers (e.g. shareTarget's gfile=→file= relocation) — so the
+  // buffered URL may still be raw. Transformers are idempotent (guard on their own markers), so a
+  // link already transformed at ingress passes through unchanged.
+  if (url && deepLinkTransformer) {
+    try { url = deepLinkTransformer(url); } catch (e) { console.warn('AppWrap: deep-link transform failed', e); }
+  }
   return url;
 }
 

package/runtime/app/shell/handlers-share-target.ts

@@ -0,0 +1,155 @@
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import type { AndroidActivityNewIntentEventData } from '@nativescript/core';
+import { SHELL_CONFIG } from './config';
+import { onDeepLink, setDeepLinkTransformer } from './events';
+
+/**
+ * shareTarget (INBOUND share sheet) — Android. The manifest's ACTION_SEND(_MULTIPLE) intent-filter
+ * (stamped by the CLI when the module is active) lands the shared payload on the main activity as a
+ * SEND intent; this handler reads it (cold launch + warm onNewIntent) and re-delivers through the
+ * EXISTING deep-link path as a synthetic URL — so it inherits the proven cold-start buffering
+ * (delivered in the handshake `deepLink`) and warm `deeplink.open` event with no new bridge surface.
+ *
+ * URL contract (parsed by kit.shareTarget, also directly consumable via kit.lifecycle.onDeepLink):
+ *   <urlScheme>://share?text=<enc>&title=<enc>&file=<enc>&file=<enc>…
+ *  - `text`  — EXTRA_TEXT (shared text / URL), when present.
+ *  - `title` — EXTRA_SUBJECT, when present.
+ *  - `file`  — repeated; each is a path RELATIVE TO THE APP CACHE DIR (`appwrap-share/…`) where the
+ *    shared stream (image) was copied — read it via `kit.fs.read(p, { dir: 'cache', encoding: 'base64' })`.
+ *
+ * iOS: the generated `AppwrapShare` extension (this module's nativeSrc) forwards the payload as the
+ * SAME URL over the app's urlScheme — that link enters through the normal openURL delegate path. Text
+ * rides in the URL directly; images land in the App Group container as `gfile=<name>` params, which
+ * the transformer below relocates into the app cache and rewrites to `file=` (cache-relative) so the
+ * contract the web app sees is platform-identical.
+ */
+export function registerShareTargetHandlers(): void {
+  if (isIOS) {
+    // Rewrite share links carrying App-Group files (gfile=) → cache files (file=). Text-only share
+    // links (no gfile) pass through untouched.
+    setDeepLinkTransformer((url) => (url.includes('://share?') && url.includes('gfile=') ? iosRelocateGroupFiles(url) : url));
+    return;
+  }
+  if (!isAndroid) return;
+  Application.android.on(Application.android.activityNewIntentEvent, (args: AndroidActivityNewIntentEventData) =>
+    deliverShareIntent(args.intent)
+  );
+  // Cold start: the SEND intent IS the launch intent (events.ts only reads getData(), null for SEND).
+  deliverShareIntent(Application.android.startActivity?.getIntent?.());
+}
+
+/** iOS: move each `gfile=<name>` from `<AppGroup>/appwrap-share/` into `<Caches>/appwrap-share/` and
+ * rewrite the param to `file=appwrap-share/<name>` (the fs `cache` root), matching Android's shape.
+ * Any file that can't be moved (missing group container, purged file) is dropped from the link;
+ * text/title params always survive. */
+function iosRelocateGroupFiles(url: string): string {
+  try {
+    const [head, query = ''] = url.split('?');
+    const fm = NSFileManager.defaultManager;
+    const groupRoot = fm.containerURLForSecurityApplicationGroupIdentifier(`group.${SHELL_CONFIG.appId}`);
+    const cacheBase = NSSearchPathForDirectoriesInDomains(13 /* Caches */, 1, true).objectAtIndex(0) as string;
+    const destDir = `${cacheBase}/appwrap-share`;
+    fm.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(destDir, true, null, null);
+    const params: string[] = [];
+    for (const pair of query.split('&')) {
+      if (!pair.startsWith('gfile=')) { if (pair) params.push(pair); continue; }
+      if (!groupRoot) continue; // no group entitlement in this build — drop the file, keep the text
+      const name = decodeURIComponent(pair.slice('gfile='.length));
+      if (!name || name.includes('/') || name.includes('..')) continue; // extension controls names — don't let one escape the dir
+      const src = `${String(groupRoot.path)}/appwrap-share/${name}`;
+      const dest = `${destDir}/${name}`;
+      fm.removeItemAtPathError(dest, null); // overwrite-safe (moveItem fails on an existing dest)
+      if (fm.moveItemAtPathToPathError(src, dest, null)) params.push(`file=${encodeURIComponent(`appwrap-share/${name}`)}`);
+    }
+    return `${head}?${params.join('&')}`;
+  } catch (e) {
+    console.warn('AppWrap: share group-file relocation failed', e);
+    return url;
+  }
+}
+
+const CONSUMED = 'appwrap_share_consumed';
+
+function deliverShareIntent(intent: android.content.Intent | null | undefined): void {
+  try {
+    const action = intent?.getAction?.();
+    if (action !== 'android.intent.action.SEND' && action !== 'android.intent.action.SEND_MULTIPLE') return;
+    if (intent!.getBooleanExtra?.(CONSUMED, false)) return; // relayout re-read of the same launch intent
+    intent!.putExtra?.(CONSUMED, true);
+
+    const params: string[] = [];
+    const text = intent!.getStringExtra?.(android.content.Intent.EXTRA_TEXT);
+    if (text) params.push(`text=${encodeURIComponent(String(text))}`);
+    const subject = intent!.getStringExtra?.(android.content.Intent.EXTRA_SUBJECT);
+    if (subject) params.push(`title=${encodeURIComponent(String(subject))}`);
+    for (const rel of copySharedStreams(intent!, action)) params.push(`file=${encodeURIComponent(rel)}`);
+    if (!params.length) return;
+
+    // Scheme is cosmetic here — the URL goes straight into onDeepLink, never through the OS.
+    const scheme = SHELL_CONFIG.urlScheme || 'app';
+    onDeepLink(`${scheme}://share?${params.join('&')}`);
+  } catch (e) {
+    console.warn('AppWrap: share intent read failed', e);
+  }
+}
+
+/** Copy each EXTRA_STREAM content:// URI into `<cacheDir>/appwrap-share/`; return cache-relative paths. */
+function copySharedStreams(intent: android.content.Intent, action: string): string[] {
+  const uris: android.net.Uri[] = [];
+  try {
+    if (action === 'android.intent.action.SEND_MULTIPLE') {
+      const list = intent.getParcelableArrayListExtra?.(android.content.Intent.EXTRA_STREAM);
+      for (let i = 0; list && i < list.size(); i++) uris.push(list.get(i) as android.net.Uri);
+    } else {
+      const one = intent.getParcelableExtra?.(android.content.Intent.EXTRA_STREAM) as android.net.Uri | null;
+      if (one) uris.push(one);
+    }
+  } catch (e) {
+    console.warn('AppWrap: share stream extras read failed', e);
+  }
+
+  const out: string[] = [];
+  if (!uris.length) return out;
+  const ctx = Utils.android.getApplicationContext() as android.content.Context;
+  const dir = new java.io.File(ctx.getCacheDir(), 'appwrap-share');
+  dir.mkdirs();
+  const resolver = ctx.getContentResolver();
+  uris.forEach((uri, i) => {
+    try {
+      const name = fileNameFor(resolver, uri, i);
+      const dest = new java.io.File(dir, name);
+      const input = resolver.openInputStream(uri);
+      if (!input) return;
+      const output = new java.io.FileOutputStream(dest);
+      const buf = Array.create('byte', 64 * 1024);
+      let n: number;
+      while ((n = input.read(buf)) > 0) output.write(buf, 0, n);
+      output.close();
+      input.close();
+      out.push(`appwrap-share/${name}`);
+    } catch (e) {
+      console.warn('AppWrap: shared stream copy failed', e);
+    }
+  });
+  return out;
+}
+
+/** A safe, unique-enough filename: display name when the provider offers one, else mime-derived. */
+function fileNameFor(resolver: android.content.ContentResolver, uri: android.net.Uri, i: number): string {
+  let name = '';
+  try {
+    const c = resolver.query(uri, null, null, null, null);
+    if (c) {
+      const idx = c.getColumnIndex('_display_name');
+      if (idx >= 0 && c.moveToFirst()) name = String(c.getString(idx) ?? '');
+      c.close();
+    }
+  } catch { /* fall through to mime-derived name */ }
+  if (!name) {
+    const mime = String(resolver.getType(uri) ?? '');
+    const ext = mime.startsWith('image/') ? mime.slice(6).replace(/[^a-z0-9]/gi, '') || 'img' : 'bin';
+    name = `shared-${i}.${ext}`;
+  }
+  // Sanitize (providers control display names) + prefix a timestamp so repeated shares don't collide.
+  return `${Date.now()}-${i}-${name.replace(/[^\w.-]/g, '_')}`;
+}

package/runtime/app/shell/handlers.ts

@@ -10,7 +10,7 @@ import { ACTIVE_MODULE_NAMES, PACK_MODULES } from './active-modules.generated';
 import { consumePendingBackgroundTaskId } from './background-context';
 
 /** Build identifier for the native shell bundle — bump per deploy to spot stale bundles. */
-export const SHELL_BUILD = 'apple-signin-1';
+export const SHELL_BUILD = 'share-target-1';
 
 /** Version status the web side (native-kit `kit.updates`) reports via `app.reportWebVersion`. */
 export interface WebVersionInfo { current?: string; latest?: string; build?: string | number; updateAvailable?: boolean; }

package/runtime/modules-native/shareTarget/App_Resources/iOS/extensions/AppwrapShare/AppwrapShare.entitlements

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>com.apple.security.application-groups</key>
+	<array>
+		<string>__APP_GROUP__</string>
+	</array>
+</dict>
+</plist>

package/runtime/modules-native/shareTarget/App_Resources/iOS/extensions/AppwrapShare/Info.plist

@@ -0,0 +1,43 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>en</string>
+	<key>CFBundleDisplayName</key>
+	<string>__APP_NAME__</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>XPC!</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0.0</string>
+	<key>CFBundleVersion</key>
+	<string>1</string>
+	<key>NSExtension</key>
+	<dict>
+		<key>NSExtensionPointIdentifier</key>
+		<string>com.apple.share-services</string>
+		<key>NSExtensionPrincipalClass</key>
+		<string>$(PRODUCT_MODULE_NAME).ShareViewController</string>
+		<key>NSExtensionAttributes</key>
+		<dict>
+			<key>NSExtensionActivationRule</key>
+			<dict>
+				<key>NSExtensionActivationSupportsText</key>
+				<true/>
+				<key>NSExtensionActivationSupportsWebURLWithMaxCount</key>
+				<integer>1</integer>
+				<key>NSExtensionActivationSupportsImageWithMaxCount</key>
+				<integer>10</integer>
+			</dict>
+		</dict>
+	</dict>
+</dict>
+</plist>

package/runtime/modules-native/shareTarget/App_Resources/iOS/extensions/AppwrapShare/ShareViewController.swift

@@ -0,0 +1,124 @@
+import UIKit
+import MobileCoreServices
+
+/// appwrap shareTarget — iOS share extension (`AppwrapShare` target, generated per-app by the CLI).
+///
+/// Collects the shared attachments (text / web URL / images), then forwards them to the HOST app as
+/// the SAME deep-link contract Android uses:
+///   __URL_SCHEME__://share?text=<enc>&title=<enc>&gfile=<enc>&gfile=<enc>…
+///  - text / web URLs ride entirely in the URL (no files involved).
+///  - images are written into the shared App Group container under `appwrap-share/`; each `gfile`
+///    param is the file NAME there. The host shell relocates them into the app cache and rewrites
+///    `gfile=` → `file=` (cache-relative) before the link reaches the web app — so the JS contract
+///    is identical on both platforms (see runtime/app/shell/handlers-share-target.ts).
+///
+/// Build-time tokens (stamped by `appwrap init`/`sync`): __URL_SCHEME__ (config `urlScheme`),
+/// __APP_GROUP__ (`group.<appId>`), __APP_NAME__ (Info.plist display name).
+class ShareViewController: UIViewController {
+    private var processed = false
+
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        guard !processed else { return }
+        processed = true
+        collectPayload { [weak self] params in
+            guard let self = self else { return }
+            if params.isEmpty {
+                self.extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
+                return
+            }
+            let url = URL(string: "__URL_SCHEME__://share?" + params.joined(separator: "&"))
+            if let url = url { self.openHostApp(url) }
+            // Give the openURL hand-off a beat before the extension process is torn down.
+            DispatchQueue.main.asyncAfter(deadline: .now() + 0.4) {
+                self.extensionContext?.completeRequest(returningItems: nil, completionHandler: nil)
+            }
+        }
+    }
+
+    // MARK: payload collection
+
+    private func collectPayload(_ done: @escaping ([String]) -> Void) {
+        var texts: [String] = []
+        var files: [String] = []
+        let group = DispatchGroup()
+
+        let items = (extensionContext?.inputItems as? [NSExtensionItem]) ?? []
+        for item in items {
+            for provider in item.attachments ?? [] {
+                if provider.hasItemConformingToTypeIdentifier("public.url") && !provider.hasItemConformingToTypeIdentifier("public.file-url") {
+                    group.enter()
+                    provider.loadItem(forTypeIdentifier: "public.url", options: nil) { data, _ in
+                        if let u = data as? URL { texts.append(u.absoluteString) }
+                        group.leave()
+                    }
+                } else if provider.hasItemConformingToTypeIdentifier("public.plain-text") {
+                    group.enter()
+                    provider.loadItem(forTypeIdentifier: "public.plain-text", options: nil) { data, _ in
+                        if let s = data as? String, !s.isEmpty { texts.append(s) }
+                        else if let d = data as? Data, let s = String(data: d, encoding: .utf8), !s.isEmpty { texts.append(s) }
+                        group.leave()
+                    }
+                } else if provider.hasItemConformingToTypeIdentifier("public.image") {
+                    group.enter()
+                    provider.loadItem(forTypeIdentifier: "public.image", options: nil) { data, _ in
+                        if let name = self.stashImage(data) { files.append(name) }
+                        group.leave()
+                    }
+                }
+            }
+        }
+
+        group.notify(queue: .main) {
+            var params: [String] = []
+            let enc = { (s: String) in s.addingPercentEncoding(withAllowedCharacters: .alphanumerics) ?? "" }
+            if !texts.isEmpty { params.append("text=" + enc(texts.joined(separator: "\n"))) }
+            for f in files { params.append("gfile=" + enc(f)) }
+            done(params)
+        }
+    }
+
+    /// Write a shared image (URL / Data / UIImage, whatever the provider hands over) into the App
+    /// Group container `appwrap-share/` dir; returns the file name there, or nil on any failure
+    /// (missing group entitlement included — text still goes through).
+    private func stashImage(_ data: Any?) -> String? {
+        guard let root = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: "__APP_GROUP__") else { return nil }
+        let dir = root.appendingPathComponent("appwrap-share", isDirectory: true)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        let stamp = Int(Date().timeIntervalSince1970 * 1000)
+        do {
+            if let src = data as? URL {
+                let name = "\(stamp)-\(src.lastPathComponent.replacingOccurrences(of: "[^\\w.-]", with: "_", options: .regularExpression))"
+                try FileManager.default.copyItem(at: src, to: dir.appendingPathComponent(name))
+                return name
+            }
+            if let d = data as? Data {
+                let name = "\(stamp)-shared.img"
+                try d.write(to: dir.appendingPathComponent(name))
+                return name
+            }
+            if let img = data as? UIImage, let d = img.pngData() {
+                let name = "\(stamp)-shared.png"
+                try d.write(to: dir.appendingPathComponent(name))
+                return name
+            }
+        } catch { return nil }
+        return nil
+    }
+
+    // MARK: host-app hand-off
+
+    /// An app extension has no UIApplication.shared — the established path is walking the responder
+    /// chain to the hosting app's UIApplication and performing `openURL:` on it.
+    private func openHostApp(_ url: URL) {
+        var responder: UIResponder? = self as UIResponder
+        let selector = NSSelectorFromString("openURL:")
+        while let r = responder {
+            if r.responds(to: selector) && !(r is UIViewController) {
+                r.perform(selector, with: url)
+                return
+            }
+            responder = r.next
+        }
+    }
+}

package/runtime/modules-native/shareTarget/App_Resources/iOS/extensions/AppwrapShare/extension.json

@@ -0,0 +1,3 @@
+{
+	"frameworks": ["UIKit.framework"]
+}

package/src/cli.ts

@@ -240,6 +240,7 @@ interface NativeReqs {
   androidGradleDeps: string[];
   androidKotlin: boolean;        // any active module ships Kotlin native source
   androidManifestApp: string[];  // raw XML injected inside AndroidManifest <application>
+  androidManifestActivity: string[];  // raw XML injected inside the main <activity> (intent-filters)
   nativeSrc: string[];           // active BUILT-IN modules' nativeSrc dir names (under runtime/modules-native/)
   packNativeSrc: Array<{ name: string; srcDir: string }>;  // active PACK modules' native source (absolute src dirs)
   packHandlers: Array<{ name: string; source: string; packDir: string; file: string; fn: string }>; // active pack modules with a register handler (for the generated barrel + staging)
@@ -270,6 +271,7 @@ function nativeReqs(cfg: AppwrapConfig): NativeReqs {
   const packHandlers: NativeReqs['packHandlers'] = [];
   const packModules: NativeReqs['packModules'] = [];
   const androidManifestApp: string[] = [];
+  const androidManifestActivity: string[] = [];
   let androidKotlin = false;
 
   if (cfg.modules) {
@@ -285,6 +287,7 @@ function nativeReqs(cfg: AppwrapConfig): NativeReqs {
       Object.assign(iosEntitlements, m.ios?.entitlements ?? {});
       if (m.android?.kotlin) androidKotlin = true;
       if (m.android?.manifestApplication) androidManifestApp.push(m.android.manifestApplication);
+      if (m.android?.manifestActivity) androidManifestActivity.push(m.android.manifestActivity);
       // built-in native source resolves under runtime/modules-native/; pack native source (below)
       // resolves under the pack's own dir, so it must not be conflated with the built-in dir names.
       if (m.nativeSrc && !packInfo(m.name)) nativeSrc.push(m.nativeSrc);
@@ -321,6 +324,7 @@ function nativeReqs(cfg: AppwrapConfig): NativeReqs {
     androidGradleDeps: [...gradle],
     androidKotlin,
     androidManifestApp,
+    androidManifestActivity,
     nativeSrc,
     packNativeSrc,
     packHandlers,
@@ -337,6 +341,7 @@ const OPTIONAL_GROUP_HANDLERS: Record<string, { file: string; fn: string }> = {
   tracking: { file: './handlers-tracking', fn: 'registerTrackingHandlers' },
   appleSignIn: { file: './handlers-apple-signin', fn: 'registerAppleSignInHandlers' },
   backgroundTask: { file: './handlers-background', fn: 'registerBackgroundTaskHandlers' },
+  shareTarget: { file: './handlers-share-target', fn: 'registerShareTargetHandlers' },
   // billing/health/widget live in host-provided module packs (not part of CE) — a consumer opts in via modulePacks.
 };
 
@@ -664,10 +669,11 @@ function copyModuleNativeSrc(outDir: string, req: NativeReqs): Set<string> {
 
 /** Build-time tokens a module's native source / entitlements may reference — resolved from the app
  * config so a module ships app-agnostic and the CLI stamps the app-specific value in. Not module-
- * specific: any module (built-in or pack) can use these tokens. Currently `__APP_GROUP__` → the App
- * Group id shared by the app + an extension (e.g. widget); extend here as new app-derived needs arise. */
+ * specific: any module (built-in or pack) can use these tokens. `__APP_GROUP__` → the App Group id
+ * shared by the app + an extension (e.g. widget, shareTarget); `__URL_SCHEME__` → config `urlScheme`
+ * (the shareTarget extension forwards to the host app through it); `__APP_NAME__` → display name. */
 function buildTokens(cfg: AppwrapConfig): Record<string, string> {
-  return { __APP_GROUP__: `group.${cfg.id}` };
+  return { __APP_GROUP__: `group.${cfg.id}`, __URL_SCHEME__: cfg.urlScheme ?? '', __APP_NAME__: cfg.name };
 }
 
 /** Substitute any {@link buildTokens} in a stamped string (entitlement value or native-source file). */
@@ -1598,6 +1604,11 @@ function stampAndroidAppName(outDir: string, cfg: AppwrapConfig, req: NativeReqs
       /<!-- appwrap:application -->[\s\S]*?<!-- \/appwrap:application -->/,
       `<!-- appwrap:application -->\n\t\t${req.androidManifestApp.join('\n\t\t')}\n\t\t<!-- /appwrap:application -->`
     );
+    // Main-<activity> XML from active modules (e.g. shareTarget's ACTION_SEND filter) — idempotent marker.
+    src = src.replace(
+      /<!-- appwrap:activity -->[\s\S]*?<!-- \/appwrap:activity -->/,
+      `<!-- appwrap:activity -->\n\t\t${req.androidManifestActivity.join('\n\t\t')}\n\t\t<!-- /appwrap:activity -->`
+    );
     // <queries> for kit.app.canOpenUrl() visibility probes (API 30+) — idempotent marker. queryPackages
     // → explicit <package>; queryUrlSchemes → a VIEW <intent> per scheme (symmetric with iOS's
     // LSApplicationQueriesSchemes). See stampAndroidQueries.
@@ -2114,6 +2125,11 @@ function regenerateCore(cwd: string, outDir: string, cfg: AppwrapConfig, opts: {
   if (opts.firstRun && !req.explicit) {
     console.log('  ℹ no `modules` in the appwrap config → all capabilities active. Declare `modules` to shrink the store build (strip unused handlers/perms).');
   }
+  // shareTarget forwards the shared payload to the host app over the custom URL scheme — without one
+  // the iOS share extension has no way back into the app (Android delivery still works via intents).
+  if (req.activeOptIn.includes('shareTarget') && !cfg.urlScheme) {
+    console.warn('  ⚠ `shareTarget` is active but `urlScheme` is unset — the iOS share extension cannot forward to the app. Set `urlScheme` in the appwrap config.');
+  }
   // Copy each template root in order — later roots OVERLAY earlier (file-level last-wins), so a
   // consumer template can add or replace shell files without forking CE. Single root (default) is
   // exactly the pre-overlay copy.