@livx.cc/appwrap 0.23.2 → 0.25.0

package/runtime/app/shell/handlers-fs.ts

@@ -0,0 +1,372 @@
+import { Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+import { startActivityForResult } from './android-helpers';
+
+declare const android: any, java: any;
+
+const err = (code: string, message: string) => Object.assign(new Error(message), { code });
+
+type Dir = 'documents' | 'data' | 'cache';
+
+/** Strip a leading slash and reject any `..` segment so a path can't escape its sandbox root. */
+function safeRelPath(path: string): string {
+  const rel = String(path).replace(/^\/+/, '');
+  if (rel.split('/').some((seg) => seg === '..')) throw err('NATIVE_ERROR', `Path traversal rejected: ${path}`);
+  return rel;
+}
+
+/**
+ * `kit.fs` shell handlers — app-sandbox file I/O + a system document picker, ONE API across iOS
+ * and Android. No runtime permission: every root is inside the app sandbox and the picker returns
+ * user-chosen security-scoped (iOS) / SAF (Android) URIs.
+ *
+ * iOS uses `FileManager` + `NSData`/`NSString`; dirs resolve via `NSSearchPathForDirectoriesInDomains`.
+ * Android uses `java.io.File` under `getFilesDir()`/`getCacheDir()`/`getExternalFilesDir()`, the
+ * existing share FileProvider for `getUri` content:// URIs, and `ACTION_OPEN_DOCUMENT` for the picker.
+ *
+ * DEVICE-GATED / UNVERIFIED this session: the iOS `UIDocumentPickerViewController` delegate and the
+ * Android `ACTION_OPEN_DOCUMENT` activity-result plumbing (both async, new to the repo).
+ */
+export function registerFsHandlers(): void {
+  if (isIOS) registerIosFs();
+  else if (isAndroid) registerAndroidFs();
+}
+
+// ─────────────────────────────── iOS ───────────────────────────────
+
+/** NSSearchPath domain index per dir; `documents`/`cache` are first-class, `data` → Application Support. */
+function iosBaseDir(dir: Dir): string {
+  // NSDocumentDirectory=9, NSCachesDirectory=13, NSApplicationSupportDirectory=14; NSUserDomainMask=1.
+  const which = dir === 'documents' ? 9 : dir === 'cache' ? 13 : 14;
+  const paths = NSSearchPathForDirectoriesInDomains(which as any, 1 as any, true);
+  const base = paths.objectAtIndex(0) as string;
+  // Application Support isn't auto-created; ensure it exists so `data` writes don't fail.
+  if (which === 14) NSFileManager.defaultManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(base, true, null, null);
+  return base;
+}
+
+function iosResolve(path: string, dir: Dir): string {
+  return iosBaseDir(dir) + '/' + safeRelPath(path);
+}
+
+function registerIosFs(): void {
+  const fm = () => NSFileManager.defaultManager;
+
+  bridge.register('fs.read', ({ path, dir = 'data', encoding = 'utf8' }: any) => {
+    const full = iosResolve(path, dir);
+    if (!fm().fileExistsAtPath(full)) throw err('NATIVE_ERROR', `No such file: ${path}`);
+    const data = NSData.dataWithContentsOfFile(full);
+    if (!data) throw err('NATIVE_ERROR', `Read failed: ${path}`);
+    // String(...) FORCES a JS string. Without it the NSString proxy goes over the bridge and
+    // JSON-serializes to `{}` — `as unknown as string` is a compile-time no-op, not a conversion.
+    if (encoding === 'base64') return String(data.base64EncodedStringWithOptions(0 as unknown as NSDataBase64EncodingOptions));
+    return String(NSString.alloc().initWithDataEncoding(data, 4 /* NSUTF8StringEncoding */));
+  });
+
+  bridge.register('fs.write', ({ path, data, dir = 'data', encoding = 'utf8' }: any) => {
+    const full = iosResolve(path, dir);
+    // Always create the parent dir — writing to a sub-path (e.g. 'demo/note.txt') otherwise fails
+    // ("Write failed"), which is a footgun. fs.append already does this; match it.
+    ensureParentIos(full);
+    const blob = encoding === 'base64'
+      ? NSData.alloc().initWithBase64EncodedStringOptions(data, 0 as unknown as NSDataBase64DecodingOptions)
+      : (NSString.stringWithString(String(data ?? '')) as any).dataUsingEncoding(4);
+    if (!blob) throw err('NATIVE_ERROR', `Encode failed: ${path}`);
+    if (!blob.writeToFileAtomically(full, true)) throw err('NATIVE_ERROR', `Write failed: ${path}`);
+    return { uri: NSURL.fileURLWithPath(full).absoluteString };
+  });
+
+  bridge.register('fs.append', ({ path, data, dir = 'data', encoding = 'utf8' }: any) => {
+    const full = iosResolve(path, dir);
+    ensureParentIos(full);
+    const blob = encoding === 'base64'
+      ? NSData.alloc().initWithBase64EncodedStringOptions(data, 0 as unknown as NSDataBase64DecodingOptions)
+      : (NSString.stringWithString(String(data ?? '')) as any).dataUsingEncoding(4);
+    if (!blob) throw err('NATIVE_ERROR', `Encode failed: ${path}`);
+    if (!fm().fileExistsAtPath(full)) {
+      blob.writeToFileAtomically(full, true);
+      return;
+    }
+    const handle = NSFileHandle.fileHandleForWritingAtPath(full);
+    handle.seekToEndOfFile();
+    handle.writeData(blob);
+    handle.closeFile();
+  });
+
+  bridge.register('fs.delete', ({ path, dir = 'data' }: any) => {
+    fm().removeItemAtPathError(iosResolve(path, dir), null); // no-throw if absent
+  });
+
+  bridge.register('fs.list', ({ path, dir = 'data' }: any) => {
+    const full = iosResolve(path, dir);
+    const names = fm().contentsOfDirectoryAtPathError(full, null);
+    if (!names) throw err('NATIVE_ERROR', `No such dir: ${path}`);
+    const out: any[] = [];
+    for (let i = 0; i < names.count; i++) {
+      const name = names.objectAtIndex(i) as string;
+      out.push(iosStat(full + '/' + name, name));
+    }
+    return out;
+  });
+
+  bridge.register('fs.mkdir', ({ path, dir = 'data', recursive = true }: any) => {
+    const ok = fm().createDirectoryAtPathWithIntermediateDirectoriesAttributesError(
+      iosResolve(path, dir), recursive !== false, null, null
+    );
+    if (!ok) throw err('NATIVE_ERROR', `mkdir failed: ${path}`);
+  });
+
+  bridge.register('fs.stat', ({ path, dir = 'data' }: any) => {
+    const full = iosResolve(path, dir);
+    if (!fm().fileExistsAtPath(full)) throw err('NATIVE_ERROR', `No such path: ${path}`);
+    return iosStat(full, path);
+  });
+
+  bridge.register('fs.getUri', ({ path, dir = 'data' }: any) =>
+    NSURL.fileURLWithPath(iosResolve(path, dir)).absoluteString
+  );
+
+  bridge.register('fs.pickFile', ({ types, multiple }: any) => pickFileIos(types, !!multiple));
+}
+
+function ensureParentIos(full: string): void {
+  const parent = (NSString.stringWithString(full) as any).stringByDeletingLastPathComponent;
+  NSFileManager.defaultManager.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(parent, true, null, null);
+}
+
+function iosStat(full: string, name: string): any {
+  const fm = NSFileManager.defaultManager;
+  const isDirRef = new interop.Reference<boolean>(interop.types.bool, false);
+  const exists = fm.fileExistsAtPathIsDirectory(full, isDirRef as any);
+  const isDir = !!isDirRef.value;
+  const attrs = exists ? fm.attributesOfItemAtPathError(full, null) : null;
+  const size = attrs && !isDir ? Number(attrs.objectForKey(NSFileSize) ?? 0) : undefined;
+  const modDate = attrs ? attrs.objectForKey(NSFileModificationDate) : null;
+  const mtime = modDate ? Math.round(modDate.timeIntervalSince1970 * 1000) : undefined;
+  return {
+    name,
+    type: isDir ? 'dir' : 'file',
+    size,
+    mtime,
+    uri: NSURL.fileURLWithPath(full).absoluteString,
+  };
+}
+
+/**
+ * iOS document picker via UIDocumentPickerViewController. Reads each chosen URL's bytes (under a
+ * security-scoped access window) and returns them base64-inline. DEVICE-GATED — the delegate
+ * callbacks (didPickDocumentsAtURLs / wasCancelled) are not exercised in this session.
+ */
+function pickFileIos(types: string[] | undefined, multiple: boolean): Promise<any[]> {
+  return new Promise((resolve, reject) => {
+    Utils.dispatchToMainThread(() => {
+      try {
+        const utis = NSMutableArray.new();
+        // Map common MIME/extension hints to UTTypes; default to "any item".
+        (types ?? []).forEach((t) => {
+          const ut = (UTType as any).typeWithMIMEType?.(t) ?? (UTType as any).typeWithFilenameExtension?.(t.replace(/^\./, ''));
+          if (ut) utis.addObject(ut);
+        });
+        if (utis.count === 0) utis.addObject(UTTypeItem);
+
+        const picker = UIDocumentPickerViewController.alloc().initForOpeningContentTypes(utis as any);
+        picker.allowsMultipleSelection = multiple;
+
+        const DelegateClass = (NSObject as any).extend(
+          {
+            documentPickerDidPickDocumentsAtURLs(_p: any, urls: any) {
+              const out: any[] = [];
+              for (let i = 0; i < urls.count; i++) {
+                const url = urls.objectAtIndex(i);
+                const scoped = url.startAccessingSecurityScopedResource?.();
+                try {
+                  const data = NSData.dataWithContentsOfURL(url);
+                  if (data) {
+                    out.push({
+                      name: url.lastPathComponent,
+                      mimeType: mimeForUrlIos(url),
+                      size: data.length,
+                      base64: data.base64EncodedStringWithOptions(0 as unknown as NSDataBase64EncodingOptions),
+                    });
+                  }
+                } finally {
+                  if (scoped) url.stopAccessingSecurityScopedResource?.();
+                }
+              }
+              resolve(out);
+            },
+            documentPickerWasCancelled() {
+              resolve([]);
+            },
+          },
+          { protocols: [UIDocumentPickerDelegate] }
+        );
+        const delegate = DelegateClass.new();
+        (picker as any)._appwrapDelegate = delegate; // retain past the present call
+        picker.delegate = delegate;
+        Utils.ios.getRootViewController().presentViewControllerAnimatedCompletion(picker, true, null);
+      } catch (e: any) {
+        reject(err('NATIVE_ERROR', e?.message ?? 'document picker failed'));
+      }
+    });
+  });
+}
+
+function mimeForUrlIos(url: any): string {
+  const ut = (UTType as any).typeWithFilenameExtension?.(url.pathExtension);
+  return ut?.preferredMIMEType ?? 'application/octet-stream';
+}
+
+// ───────────────────────────── Android ─────────────────────────────
+
+function androidBaseDir(dir: Dir): any {
+  const ctx = Utils.android.getApplicationContext();
+  if (dir === 'cache') return ctx.getCacheDir();
+  if (dir === 'documents') return ctx.getExternalFilesDir(null) ?? ctx.getFilesDir();
+  return ctx.getFilesDir(); // 'data'
+}
+
+function androidFile(path: string, dir: Dir): any {
+  return new java.io.File(androidBaseDir(dir), safeRelPath(path));
+}
+
+function readBytesAndroid(file: any): any {
+  const fis = new java.io.FileInputStream(file);
+  const baos = new java.io.ByteArrayOutputStream();
+  const buf = Array.create('byte', 8192);
+  let n: number;
+  while ((n = fis.read(buf)) !== -1) baos.write(buf, 0, n);
+  fis.close();
+  return baos.toByteArray();
+}
+
+function registerAndroidFs(): void {
+  bridge.register('fs.read', ({ path, dir = 'data', encoding = 'utf8' }: any) => {
+    const file = androidFile(path, dir);
+    if (!file.exists()) throw err('NATIVE_ERROR', `No such file: ${path}`);
+    const bytes = readBytesAndroid(file);
+    if (encoding === 'base64') return android.util.Base64.encodeToString(bytes, android.util.Base64.NO_WRAP);
+    return new java.lang.String(bytes, 'UTF-8').toString();
+  });
+
+  bridge.register('fs.write', ({ path, data, dir = 'data', encoding = 'utf8' }: any) => {
+    const file = androidFile(path, dir);
+    // Always create the parent dir (match fs.append + iOS) — writing to a sub-path otherwise fails.
+    file.getParentFile()?.mkdirs();
+    writeAndroid(file, data, encoding, false);
+    return { uri: android.net.Uri.fromFile(file).toString() };
+  });
+
+  bridge.register('fs.append', ({ path, data, dir = 'data', encoding = 'utf8' }: any) => {
+    const file = androidFile(path, dir);
+    file.getParentFile()?.mkdirs();
+    writeAndroid(file, data, encoding, true);
+  });
+
+  bridge.register('fs.delete', ({ path, dir = 'data' }: any) => {
+    androidFile(path, dir).delete(); // no-throw if absent
+  });
+
+  bridge.register('fs.list', ({ path, dir = 'data' }: any) => {
+    const file = androidFile(path, dir);
+    const children = file.listFiles();
+    if (!children) throw err('NATIVE_ERROR', `No such dir: ${path}`);
+    const out: any[] = [];
+    for (let i = 0; i < children.length; i++) out.push(androidStat(children[i], children[i].getName()));
+    return out;
+  });
+
+  bridge.register('fs.mkdir', ({ path, dir = 'data', recursive = true }: any) => {
+    const file = androidFile(path, dir);
+    const ok = recursive !== false ? file.mkdirs() : file.mkdir();
+    if (!ok && !file.isDirectory()) throw err('NATIVE_ERROR', `mkdir failed: ${path}`);
+  });
+
+  bridge.register('fs.stat', ({ path, dir = 'data' }: any) => {
+    const file = androidFile(path, dir);
+    if (!file.exists()) throw err('NATIVE_ERROR', `No such path: ${path}`);
+    return androidStat(file, path);
+  });
+
+  bridge.register('fs.getUri', ({ path, dir = 'data' }: any) => {
+    // Hand out a content:// via the existing share FileProvider so other apps (kit.share) can read it.
+    const ctx = Utils.android.getApplicationContext();
+    const authority = ctx.getPackageName() + '.fileprovider';
+    return androidx.core.content.FileProvider.getUriForFile(ctx, authority, androidFile(path, dir)).toString();
+  });
+
+  bridge.register('fs.pickFile', ({ types, multiple }: any) => pickFileAndroid(types, !!multiple));
+}
+
+function writeAndroid(file: any, data: string, encoding: string, append: boolean): void {
+  const bytes = encoding === 'base64'
+    ? android.util.Base64.decode(String(data ?? ''), android.util.Base64.DEFAULT)
+    : new java.lang.String(String(data ?? '')).getBytes('UTF-8');
+  const fos = new java.io.FileOutputStream(file, append);
+  fos.write(bytes);
+  fos.close();
+}
+
+function androidStat(file: any, name: string): any {
+  const isDir = file.isDirectory();
+  return {
+    name,
+    type: isDir ? 'dir' : 'file',
+    size: isDir ? undefined : file.length(),
+    mtime: file.lastModified(),
+    uri: android.net.Uri.fromFile(file).toString(),
+  };
+}
+
+/**
+ * Android document picker via ACTION_OPEN_DOCUMENT (reuses the shared startActivityForResult).
+ * Reads each chosen content:// URI's bytes via the ContentResolver and returns them base64-inline.
+ * DEVICE-GATED — the activity-result plumbing is not exercised in this session.
+ */
+async function pickFileAndroid(types: string[] | undefined, multiple: boolean): Promise<any[]> {
+  const intent = new android.content.Intent(android.content.Intent.ACTION_OPEN_DOCUMENT);
+  intent.addCategory(android.content.Intent.CATEGORY_OPENABLE);
+  intent.setType((types && types.length === 1) ? types[0] : '*/*');
+  if (types && types.length > 1) {
+    // EXTRA_MIME_TYPES needs a Java String[]; NativeScript won't auto-marshal a JS array here.
+    const arr = Array.create('java.lang.String', types.length);
+    types.forEach((t, i) => { arr[i] = t; });
+    intent.putExtra(android.content.Intent.EXTRA_MIME_TYPES, arr);
+  }
+  if (multiple) intent.putExtra(android.content.Intent.EXTRA_ALLOW_MULTIPLE, true);
+
+  const { resultCode, intent: result } = await startActivityForResult(intent);
+  if (resultCode !== android.app.Activity.RESULT_OK || !result) return [];
+
+  const uris: any[] = [];
+  const clip = result.getClipData?.();
+  if (clip) for (let i = 0; i < clip.getItemCount(); i++) uris.push(clip.getItemAt(i).getUri());
+  else if (result.getData()) uris.push(result.getData());
+
+  const cr = Utils.android.getApplicationContext().getContentResolver();
+  return uris.map((uri) => {
+    const stream = cr.openInputStream(uri);
+    const baos = new java.io.ByteArrayOutputStream();
+    const buf = Array.create('byte', 8192);
+    let n: number;
+    while ((n = stream.read(buf)) !== -1) baos.write(buf, 0, n);
+    stream.close();
+    const bytes = baos.toByteArray();
+    return {
+      name: queryDisplayName(cr, uri),
+      mimeType: cr.getType(uri) ?? 'application/octet-stream',
+      size: bytes.length,
+      base64: android.util.Base64.encodeToString(bytes, android.util.Base64.NO_WRAP),
+    };
+  });
+}
+
+function queryDisplayName(cr: any, uri: any): string {
+  const cursor = cr.query(uri, [android.provider.OpenableColumns.DISPLAY_NAME], null, null, null);
+  let name = 'file';
+  if (cursor) {
+    if (cursor.moveToFirst()) name = String(cursor.getString(0) ?? 'file');
+    cursor.close();
+  }
+  return name;
+}

package/runtime/app/shell/handlers-oauth.ts

@@ -1,9 +1,11 @@
-import { Utils, isIOS } from '@nativescript/core';
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
+import { setDeepLinkInterceptor } from './events';
 
 // AuthenticationServices globals (NS auto-links the framework via metadata when referenced).
 declare const ASWebAuthenticationSession: any;
 declare const ASWebAuthenticationPresentationContextProviding: any;
+declare const android: any, androidx: any;
 
 const err = (code: string, message: string) => Object.assign(new Error(message), { code });
 
@@ -19,6 +21,7 @@ let activeProvider: any = null;
  * the auth URL + does token exchange; this only opens the browser and hands back the callback.
  */
 export function registerOAuthHandlers(): void {
+  if (isAndroid) { registerAndroid(); return; }
   if (!isIOS) return;
 
   bridge.register(
@@ -67,3 +70,89 @@ export function registerOAuthHandlers(): void {
       })
   );
 }
+
+/**
+ * Android: launch the auth URL in a Chrome Custom Tab. Unlike iOS ASWebAuthenticationSession, a
+ * Custom Tab does NOT auto-close on the provider redirect — the redirect to `callbackScheme://…`
+ * re-launches our (singleTask) activity as a VIEW intent, which the shell's existing deep-link path
+ * (events.wireAndroidDeepLinks → onDeepLink) already surfaces. We register a deep-link interceptor
+ * that matches the pending callbackScheme, swallows that URL (it's OAuth plumbing, not an app deep
+ * link), and resolves the pending authorize() with the same { url } shape the iOS path returns.
+ *
+ * Cancel contract (matches iOS user-dismiss → CANCELLED): Custom Tabs gives no dismissal callback, so
+ * we infer cancellation on app.resume — if the app comes back to the foreground after the tab opened
+ * and NO matching redirect arrived within a short grace window, the user backed out → reject CANCELLED.
+ *
+ * DEVICE-UNVERIFIED (any-typed FFI, no device run this session): the CustomTabsIntent launch + the
+ * redirect→deep-link round-trip + the resume-based cancel inference. Compile-clean only.
+ */
+function registerAndroid(): void {
+  // Single in-flight authorize at a time (mirrors the iOS single-session model).
+  let pending:
+    | { scheme: string; resolve: (v: any) => void; reject: (e: any) => void; settled: boolean; resumeOff: () => void }
+    | null = null;
+
+  const finish = (fn: () => void) => {
+    if (!pending || pending.settled) return;
+    pending.settled = true;
+    pending.resumeOff();
+    const p = pending;
+    pending = null;
+    fn.call(p);
+  };
+
+  // First refusal on every inbound deep link: consume the one that matches the pending callbackScheme.
+  setDeepLinkInterceptor((url: string): boolean => {
+    if (!pending || pending.settled) return false;
+    const scheme = pending.scheme;
+    if (!scheme || !String(url ?? '').toLowerCase().startsWith(scheme.toLowerCase() + ':')) return false;
+    finish(function (this: any) { this.resolve({ url: String(url) }); });
+    return true; // swallow — internal OAuth callback, not an app deep link
+  });
+
+  bridge.register(
+    'oauth.authorize',
+    ({ url, callbackScheme, ephemeral }: { url: string; callbackScheme: string; ephemeral?: boolean }) =>
+      new Promise((resolve, reject) => {
+        const target = String(url ?? '');
+        const scheme = String(callbackScheme ?? '');
+        if (!target) { reject(err('NATIVE_ERROR', 'oauth.authorize: empty url')); return; }
+        if (!scheme) { reject(err('NATIVE_ERROR', 'oauth.authorize: empty callbackScheme')); return; }
+        if (pending && !pending.settled) { reject(err('NATIVE_ERROR', 'oauth.authorize: a flow is already in progress')); return; }
+
+        Utils.dispatchToMainThread(() => {
+          try {
+            const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+            if (!activity) { reject(err('NATIVE_ERROR', 'oauth.authorize: no foreground activity')); return; }
+
+            // Cancel inference: the tab launch will background us; the FIRST resume afterwards means
+            // the user is back in our app. If no redirect consumed the flow by then (+grace), it's a
+            // user-cancel. A small delay lets a redirect that arrives in the same resume win the race.
+            let launched = false;
+            const onResume = () => {
+              if (!launched || !pending || pending.settled) return;
+              setTimeout(() => finish(function (this: any) { this.reject(err('CANCELLED', 'oauth cancelled')); }), 400);
+            };
+            Application.on(Application.resumeEvent, onResume);
+            const resumeOff = () => Application.off(Application.resumeEvent, onResume);
+            pending = { scheme, resolve, reject, settled: false, resumeOff };
+
+            const builder = new androidx.browser.customtabs.CustomTabsIntent.Builder();
+            // `ephemeral` (fresh login) → don't share the persisted browser session. Custom Tabs has
+            // no per-launch incognito API; the closest honest knob is disabling the recents/share
+            // surface so the auth page isn't trivially resumable. Cookie isolation isn't guaranteed.
+            if (ephemeral) builder.setShareState(androidx.browser.customtabs.CustomTabsIntent.SHARE_STATE_OFF);
+            const tabs = builder.build();
+            // No extra intent flags: the `callbackScheme://…` redirect re-launches our singleTask
+            // activity to the front (consumed by the deep-link interceptor), leaving the tab behind it.
+            tabs.launchUrl(activity, android.net.Uri.parse(target));
+            launched = true;
+          } catch (e: any) {
+            const fail = err('NATIVE_ERROR', e?.message ?? 'oauth failed to start');
+            if (pending && !pending.settled) finish(function (this: any) { this.reject(fail); });
+            else reject(fail); // failed before `pending` was wired
+          }
+        });
+      })
+  );
+}

package/runtime/app/shell/handlers-parity.ts

@@ -6,7 +6,7 @@ const err = (code: string, message: string) => Object.assign(new Error(message),
 const iosOnly = () => err('UNSUPPORTED', 'iOS only for now');
 
 /**
- * Extended-parity handlers: dialogs, reviews, storage.clear, geo watch, theme color,
+ * Extended-parity handlers: dialogs, storage.clear, geo watch, theme color,
  * motion, contacts, calendar, camera. iOS-first like handlers-extended.
  */
 export function registerParityHandlers(): void {
@@ -31,18 +31,8 @@ export function registerParityHandlers(): void {
     return idx >= 0 ? idx : null;
   });
 
-  // ── reviews (SKStoreReviewController) ──────────────────────────────
-  bridge.register('reviews.requestReview', () => {
-    if (!isIOS) throw iosOnly();
-    Utils.dispatchToMainThread(() => {
-      const scene = UIApplication.sharedApplication.keyWindow?.windowScene;
-      if (scene && SKStoreReviewController.requestReviewInWindowScene) {
-        SKStoreReviewController.requestReviewInWindowScene(scene);
-      } else {
-        SKStoreReviewController.requestReview();
-      }
-    });
-  });
+  // reviews → moved to the strippable `reviews` module (handlers-reviews.ts): its Android Play
+  // In-App Review path carries a gradle dep that must not bundle into builds without `reviews`.
 
   // ── storage.clear ──────────────────────────────────────────────────
   bridge.register('storage.clear', () => {
@@ -184,6 +174,44 @@ export function registerParityHandlers(): void {
     });
   });
 
+  // ── contacts bulk read (CNContactStore — requires permission) ──────
+  bridge.register('contacts.getAll', () => {
+    if (!isIOS) throw iosOnly();
+    const store = CNContactStore.new();
+    return new Promise((resolve, reject) => {
+      store.requestAccessForEntityTypeCompletionHandler(CNEntityType.Contacts, (granted: boolean, error: NSError | null) => {
+        if (!granted) {
+          return reject(err('DENIED', error?.localizedDescription ?? 'contacts access denied'));
+        }
+        try {
+          const collect = (labeled: NSArray<any>, map: (v: any) => string) => {
+            const out: string[] = [];
+            for (let i = 0; i < labeled.count; i++) out.push(map(labeled.objectAtIndex(i).value));
+            return out;
+          };
+          const keys = NSArray.arrayWithArray([
+            CNContactGivenNameKey,
+            CNContactFamilyNameKey,
+            CNContactPhoneNumbersKey,
+            CNContactEmailAddressesKey,
+          ] as any);
+          const request = CNContactFetchRequest.alloc().initWithKeysToFetch(keys);
+          const contacts: Array<{ name: string; phones: string[]; emails: string[] }> = [];
+          store.enumerateContactsWithFetchRequestErrorUsingBlock(request, null as any, (contact: any) => {
+            contacts.push({
+              name: `${contact.givenName ?? ''} ${contact.familyName ?? ''}`.trim(),
+              phones: collect(contact.phoneNumbers, (v) => String(v.stringValue)),
+              emails: collect(contact.emailAddresses, (v) => String(v)),
+            });
+          });
+          resolve({ contacts });
+        } catch (e: any) {
+          reject(err('NATIVE_ERROR', e.message));
+        }
+      });
+    });
+  });
+
   // ── calendar (EventKit) ────────────────────────────────────────────
   bridge.register('calendar.createEvent', ({ title, start, durationMin, notes }: any) => {
     if (!isIOS) throw iosOnly();

package/runtime/app/shell/handlers-push.ts

@@ -1,4 +1,4 @@
-import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { Application, Http, Utils, isAndroid, isIOS } from '@nativescript/core';
 import { bridge } from './bridge';
 import { SHELL_CONFIG } from './config';
 
@@ -21,9 +21,32 @@ let cachedToken: string | null = null;
 
 interface PushToken { platform: 'apns' | 'fcm'; token: string; }
 
+/** POST the device token to the app's configured backend NATIVELY (no WKWebView fetch → no app://
+ * cross-origin/CORS wall). The backend stores it + sends pushes. No-op when no URL is configured. */
+function registerTokenWithBackend(platform: 'ios' | 'android', token: string): void {
+  const url = SHELL_CONFIG.pushRegistrationUrl;
+  if (!url) return;
+  // NativeScript Http (NOT the global fetch — unreliable in the NS runtime). Native HTTP, no CORS.
+  // Guarded: never let a backend-register hiccup break token resolution (this runs before resolve()).
+  try {
+    Http.request({
+      url, method: 'POST', headers: { 'Content-Type': 'application/json' },
+      content: JSON.stringify({ token, platform }),
+    })
+      .then((res) => console.log('[push] token registered with backend → ' + res.statusCode))
+      .catch((e: any) => console.log('[push] backend register failed: ' + (e?.message ?? e)));
+  } catch (e: any) {
+    console.log('[push] backend register threw: ' + (e?.message ?? e));
+  }
+}
+
 /** iOS AppDelegate → APNs device token arrived. Resolve any pending register() + cache. */
 export function onApnsToken(hexToken: string): void {
   cachedToken = hexToken;
+  // Log the FULL token so it's readable headlessly (`appwrap logs ios`) to send a test push —
+  // mirrors the Android FCM boot-log. The token alone isn't a secret (you still need the APNs key).
+  console.log('[push] APNs token: ' + hexToken);
+  registerTokenWithBackend('ios', hexToken);
   if (pendingRegister) {
     pendingRegister.resolve({ platform: 'apns', token: hexToken });
     pendingRegister = null;

package/runtime/app/shell/handlers-reviews.ts

@@ -0,0 +1,73 @@
+import { Application, Utils, isAndroid, isIOS } from '@nativescript/core';
+import { bridge } from './bridge';
+
+// SKStoreReviewController is declared globally in ios-frameworks.d.ts. `com` is the Android namespace.
+declare const com: any;
+
+/**
+ * In-app store review prompt — opt-in, strippable (its own handler file + group). Lives apart from
+ * the always-bundled parity/system handlers because the Android path references the Play In-App
+ * Review classes (`com.google.android.play:review`), a gradle dep that must NOT land in builds that
+ * don't enable `reviews` (missing-class crash / dead weight otherwise).
+ *
+ * iOS: SKStoreReviewController — the OS rate-limits display (may show nothing). Fire-and-forget.
+ * Android: Play In-App Review (ReviewManager). HONEST LIMIT — the dialog only actually surfaces for a
+ * Play-Store-track install; on a bare emulator / sideload the API resolves WITHOUT showing UI (same
+ * class as android-billing). We call the API and resolve gracefully; we never fabricate "shown".
+ *
+ * DEVICE-UNVERIFIED (any-typed FFI, no device run this session): the Android ReviewManager
+ * requestReviewFlow → launchReviewFlow task/listener chain. Compile-clean only.
+ */
+export function registerReviewsHandlers(): void {
+  if (isIOS) registerIos();
+  else if (isAndroid) registerAndroid();
+}
+
+function registerIos(): void {
+  bridge.register('reviews.requestReview', () => {
+    Utils.dispatchToMainThread(() => {
+      const scene = UIApplication.sharedApplication.keyWindow?.windowScene;
+      if (scene && SKStoreReviewController.requestReviewInWindowScene) {
+        SKStoreReviewController.requestReviewInWindowScene(scene);
+      } else {
+        SKStoreReviewController.requestReview();
+      }
+    });
+  });
+}
+
+function registerAndroid(): void {
+  bridge.register('reviews.requestReview', () =>
+    new Promise<void>((resolve) => {
+      Utils.dispatchToMainThread(() => {
+        try {
+          const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+          if (!activity) { resolve(); return; }
+          const manager = com.google.android.play.core.review.ReviewManagerFactory.create(activity);
+          const request = manager.requestReviewFlow();
+          // requestReviewFlow() → Task<ReviewInfo>; on success launchReviewFlow() → Task<Void>.
+          // Both tasks COMPLETE even when the OS shows nothing (no Play track / rate-limited), so we
+          // resolve on completion regardless — never block, never fabricate a "shown" signal.
+          request.addOnCompleteListener(new com.google.android.gms.tasks.OnCompleteListener({
+            onComplete(infoTask: any) {
+              if (!infoTask.isSuccessful()) { resolve(); return; }
+              try {
+                const flow = manager.launchReviewFlow(activity, infoTask.getResult());
+                flow.addOnCompleteListener(new com.google.android.gms.tasks.OnCompleteListener({
+                  onComplete() { resolve(); },
+                }));
+              } catch (e) {
+                console.warn('AppWrap: reviews.launchReviewFlow failed', e);
+                resolve();
+              }
+            },
+          }));
+        } catch (e) {
+          // Play services / review lib absent (e.g. non-GMS device) → honest no-op, don't reject.
+          console.warn('AppWrap: reviews.requestReview unavailable', e);
+          resolve();
+        }
+      });
+    })
+  );
+}