@livx.cc/appwrap 0.60.1 → 0.61.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.60.1",
+  "version": "0.61.1",
   "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/shell/config.ts

@@ -54,6 +54,10 @@ export const SHELL_CONFIG = {
    * WebView — regular-native-app behavior. Same-origin SPA navigation is untouched. Off by default.
    * See `externalNavGuardJs`. */
   openNewWindowsInBrowser: false,
+  /** Android only. Lock the WebView's text zoom to 100% so the device's system font-size setting
+   * doesn't scale text inside the app. Default true (native-app behavior). False = respect the
+   * user's OS font-size preference. No effect on iOS (WKWebView ignores Dynamic Type). */
+  androidLockTextZoom: true,
   /** Remote push configured, per platform (iOS aps-environment entitlement / Android FCM). Drives the
    * `push` capability flag at runtime by platform — off unless `appwrap.json.push` enables it, so an
    * un-provisioned build honestly reports 'none' (and a personal-team iOS build keeps `pushIos:false`). */

package/runtime/app/shell/custom-webview.android.ts

@@ -168,6 +168,9 @@ export class CustomWebView extends WebView {
     settings.setSupportZoom(false);
     settings.setBuiltInZoomControls(false);
     settings.setDisplayZoomControls(false);
+    // Lock text zoom to 100% so Android system font scaling doesn't inflate WebView text.
+    // Controlled by appwrap config `androidLockTextZoom` (default true — native-app behavior).
+    if (SHELL_CONFIG.androidLockTextZoom !== false) settings.setTextZoom(100);
     // No rubber-band overscroll glow.
     wv.setOverScrollMode(android.view.View.OVER_SCROLL_NEVER);
 

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

@@ -5,6 +5,7 @@ import { geoAuthAction } from './geo-auth';
 import { onRemoteMessage } from './handlers-push';
 import { uiImageToDataUrl } from './ios-image';
 import { notifIdentity, type NotifIdentity } from './notif-identity';
+import { resolveSoundName } from './notif-sound';
 import { maskForLock, setIosOrientationMask } from './orientation';
 
 interface GeoResult { lat: number; lng: number; accuracy: number; }
@@ -227,10 +228,14 @@ export function registerExtendedHandlers(): void {
     });
   });
 
-  bridge.register('notifications.schedule', ({ id, title, body, delaySec, deepLink, sender, icon, badge, silent }: { id?: number; title?: string; body?: string; delaySec?: number; deepLink?: string; sender?: string; icon?: string; badge?: number; silent?: boolean }) => {
+  bridge.register('notifications.schedule', async ({ id, title, body, delaySec, deepLink, sender, icon, badge, silent, sound }: { id?: number; title?: string; body?: string; delaySec?: number; deepLink?: string; sender?: string; icon?: string; badge?: number; silent?: boolean; sound?: string }) => {
     if (!isIOS) throw Object.assign(new Error('iOS only for now'), { code: 'UNSUPPORTED' });
     const nid = id ?? Math.floor(Math.random() * 100000);
     const ident = notifIdentity({ title, body, sender, icon });
+    // A custom sound is a FILE the OS reads, never a URL it fetches — resolve (download + transcode +
+    // cache) before building the content. Null means "unusable", and the default alert takes over
+    // below: the app rings with the wrong sound rather than not at all.
+    const soundName = !silent && sound ? await resolveSoundName(String(sound)) : null;
     return new Promise((resolve, reject) => {
       const content = UNMutableNotificationContent.new();
       content.title = ident.title;
@@ -244,7 +249,11 @@ export function registerExtendedHandlers(): void {
       // is IMPORTANCE_DEFAULT), so the platforms disagreed on the same call. Default to the system
       // alert sound and let a caller opt out with `silent: true`; set BEFORE the communication-style
       // wrap so contentByUpdatingWithProvider carries it through.
-      if (!silent) content.sound = UNNotificationSound.defaultSound;
+      if (!silent) {
+        content.sound = soundName
+          ? UNNotificationSound.soundNamed(soundName)
+          : UNNotificationSound.defaultSound;
+      }
       // Group per-sender so the mini-app's notifications thread together (iOS 15+ also
       // uses this alongside the communication-style avatar below).
       if (ident.useIdentity && ident.senderName) content.threadIdentifier = ident.senderName;

package/runtime/app/shell/notif-sound.ts

@@ -0,0 +1,138 @@
+/**
+ * Custom notification sounds on iOS — turn a remote audio URL into something the OS will actually
+ * ring.
+ *
+ * WHY THIS IS NOT JUST "pass the url": iOS never fetches a notification sound. `UNNotificationSound`
+ * resolves a FILE NAME against the app bundle and the app container's `Library/Sounds/` directory,
+ * and it will only play LinearPCM/MA4/µ-law/a-law wrapped in caf/aiff/wav, ≤30s. An mp3 from a sound
+ * library — which is what a media search hands you — satisfies none of that, so a `sound: <url>`
+ * option that merely forwards the string is a lie that fails silently at delivery time.
+ *
+ * So: download once, transcode with AVAudioFile (AVFoundation decodes mp3/ogg/wav on the way in and
+ * writes LinearPCM on the way out — no ffmpeg, no server round-trip), trim to the OS ceiling, and
+ * cache under a hash of the URL so the second notification is instant.
+ *
+ * Every failure path returns null, and the caller falls back to the DEFAULT alert sound — a wrong
+ * ring is a cosmetic miss, but silence is the bug this whole lane exists to fix.
+ */
+import { sha256Hex } from './sha256';
+
+// CoreAudioTypes isn't in the bundled iOS typings (AVFoundation is), so spell the one constant we
+// need: kAudioFormatLinearPCM is the four-char code 'lpcm'. Declaring the literal beats referencing a
+// whole framework's d.ts for a single integer.
+const kAudioFormatLinearPCM = 0x6c70636d; // 'lpcm'
+
+/** The OS ceiling for a notification sound. Longer audio is truncated, not rejected. */
+const MAX_SECONDS = 30;
+/** A sound is a one-shot alert, not a download: give up rather than hold the schedule call open. */
+const FETCH_TIMEOUT_MS = 15_000;
+
+/** `<app container>/Library/Sounds`, created on demand — the only writable dir UNNotificationSound reads. */
+function soundsDir(): string | null {
+  const libs = NSSearchPathForDirectoriesInDomains(
+    NSSearchPathDirectory.LibraryDirectory, NSSearchPathDomainMask.UserDomainMask, true
+  );
+  if (!libs || libs.count === 0) return null;
+  const dir = `${libs.objectAtIndex(0)}/Sounds`;
+  const fm = NSFileManager.defaultManager;
+  if (!fm.fileExistsAtPath(dir)) {
+    fm.createDirectoryAtPathWithIntermediateDirectoriesAttributesError(dir, true, null);
+  }
+  return fm.fileExistsAtPath(dir) ? dir : null;
+}
+
+/** Download to a temp file. Resolves null on any transport failure (offline, 404, timeout). */
+function download(url: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    const nsUrl = NSURL.URLWithString(url);
+    if (!nsUrl) return resolve(null);
+    const cfg = NSURLSessionConfiguration.defaultSessionConfiguration;
+    cfg.timeoutIntervalForRequest = FETCH_TIMEOUT_MS / 1000;
+    const session = NSURLSession.sessionWithConfiguration(cfg);
+    const task = session.downloadTaskWithURLCompletionHandler(nsUrl, (tmp, response, error) => {
+      const status = (response as NSHTTPURLResponse)?.statusCode ?? 0;
+      if (error || !tmp || (status && (status < 200 || status >= 300))) {
+        console.warn(`[appwrap] notification sound download failed (${status || error?.localizedDescription})`);
+        return resolve(null);
+      }
+      // The temp file is deleted the moment this handler returns, so copy it out synchronously.
+      const keep = `${NSTemporaryDirectory()}appwrap-sound-${Date.now()}`;
+      const fm = NSFileManager.defaultManager;
+      if (fm.fileExistsAtPath(keep)) fm.removeItemAtPathError(keep, null);
+      const ok = fm.copyItemAtPathToPathError(tmp.path, keep, null);
+      resolve(ok ? keep : null);
+    });
+    task.resume();
+  });
+}
+
+/**
+ * Decode `srcPath` (any format AVFoundation reads) and write ≤30s of LinearPCM to `destPath` (.caf).
+ * Returns false if either end refuses the file — a format AVFoundation can't open, or a settings
+ * combination the writer rejects.
+ */
+function transcodeToCaf(srcPath: string, destPath: string): boolean {
+  try {
+    const src = AVAudioFile.alloc().initForReadingError(NSURL.fileURLWithPath(srcPath), null);
+    if (!src) return false;
+    const format = src.processingFormat;
+    const frames = Math.min(Number(src.length), Math.floor(format.sampleRate * MAX_SECONDS));
+    if (frames <= 0) return false;
+
+    // Write settings mirror the source's rate/channels but force 16-bit LinearPCM — the writer
+    // infers the container from the .caf extension.
+    const settings = NSMutableDictionary.dictionaryWithDictionary(format.settings as never);
+    settings.setObjectForKey(kAudioFormatLinearPCM, 'AVFormatIDKey');
+    settings.setObjectForKey(16, 'AVLinearPCMBitDepthKey');
+    settings.setObjectForKey(false, 'AVLinearPCMIsFloatKey');
+    const fm = NSFileManager.defaultManager;
+    if (fm.fileExistsAtPath(destPath)) fm.removeItemAtPathError(destPath, null);
+    const dest = AVAudioFile.alloc().initForWritingSettingsError(
+      NSURL.fileURLWithPath(destPath), settings as never, null
+    );
+    if (!dest) return false;
+
+    // Stream in chunks: a 30s buffer at 48kHz stereo is ~11MB, and a notification sound is not worth
+    // that resident all at once.
+    const chunk = Math.floor(format.sampleRate); // ~1s
+    let written = 0;
+    while (written < frames) {
+      const want = Math.min(chunk, frames - written);
+      const buf = AVAudioPCMBuffer.alloc().initWithPCMFormatFrameCapacity(format, want);
+      if (!buf) return false;
+      if (!src.readIntoBufferFrameCountError(buf, want, null)) break;
+      if (buf.frameLength === 0) break;
+      if (!dest.writeFromBufferError(buf, null)) return false;
+      written += buf.frameLength;
+    }
+    return written > 0 && fm.fileExistsAtPath(destPath);
+  } catch (e) {
+    console.warn('[appwrap] notification sound transcode failed:', String(e));
+    return false;
+  }
+}
+
+/**
+ * Resolve a `sound` option to the FILE NAME UNNotificationSound wants, or null to fall back to the
+ * default alert. A bare name (no scheme) is passed through untouched — that's a sound the app already
+ * ships in its bundle, and it must not be treated as a URL.
+ */
+export async function resolveSoundName(sound: string): Promise<string | null> {
+  const value = String(sound ?? '').trim();
+  if (!value) return null;
+  if (!/^https?:\/\//i.test(value)) return value;
+
+  const dir = soundsDir();
+  if (!dir) return null;
+  const name = `appwrap-${sha256Hex(value).slice(0, 32)}.caf`;
+  const dest = `${dir}/${name}`;
+  // Cached from an earlier schedule — the common case once a timer app has fired once.
+  if (NSFileManager.defaultManager.fileExistsAtPath(dest)) return name;
+
+  const src = await download(value);
+  if (!src) return null;
+  const ok = transcodeToCaf(src, dest);
+  NSFileManager.defaultManager.removeItemAtPathError(src, null);
+  if (!ok) console.warn('[appwrap] notification sound unusable, falling back to the default alert');
+  return ok ? name : null;
+}

package/src/cli.ts

@@ -948,6 +948,7 @@ export const SHELL_CONFIG = {
   neutralizeServiceWorker: ${JSON.stringify(cfg.neutralizeServiceWorker ?? true)},
   appBoundDomains: ${JSON.stringify(cfg.appBoundDomains ?? [])} as string[],
   openNewWindowsInBrowser: ${JSON.stringify(cfg.openNewWindowsInBrowser ?? false)},
+  androidLockTextZoom: ${JSON.stringify(cfg.androidLockTextZoom ?? true)},
   pushIos: ${JSON.stringify(!!cfg.push?.enabled && cfg.push?.ios !== false)},
   pushAndroid: ${JSON.stringify(!!cfg.push?.enabled && cfg.push?.android !== false)},
   pushRegistrationUrl: ${JSON.stringify(cfg.push?.registrationUrl ?? '')},

package/src/config.ts

@@ -239,6 +239,11 @@ export interface AppwrapConfig {
    * same-origin SPA navigation, subframes/iframes and `tel:`/`mailto:` are left untouched. Default
    * `false` (unchanged in-WebView navigation). See `externalNavGuardJs`. */
   openNewWindowsInBrowser?: boolean;
+  /** Android only. Lock the WebView's text zoom to 100% so the device's system font-size setting
+   * doesn't scale text inside the app. Default `true` — the app controls its own sizing (native-app
+   * behavior). Set `false` to let the WebView respect the user's OS-level font-size preference
+   * (accessibility). Has no effect on iOS — WKWebView does not apply Dynamic Type to web content. */
+  androidLockTextZoom?: boolean;
   /** Apple Development Team ID for device builds (Xcode → Settings → Accounts). */
   teamId?: string;
   /** Path (relative to the PWA project) to a StoreKit configuration file for LOCAL IAP
@@ -383,7 +388,7 @@ export function defineConfig(config: AppwrapConfig): AppwrapConfig {
 export const KNOWN_CONFIG_KEYS: ReadonlySet<string> = new Set([
   'androidAppLinks', 'appBoundDomains', 'backendOrigin', 'backgroundAudio', 'backgroundColor', 'backgroundTasks', 'buildNumber', 'ci', 'debug',
   'debugLog', 'desktop', 'devMenu', 'edgeToEdge', 'entry', 'icon', 'id', 'iosKeyboardExtraLift', 'loader', 'modules', 'modulePacks', 'name',
-  'envSwitcher', 'iosEntitlements', 'neutralizeServiceWorker', 'oauthRedirectSchemes', 'openNewWindowsInBrowser', 'orientation', 'overrides', 'permissions',
+  'androidLockTextZoom', 'envSwitcher', 'iosEntitlements', 'neutralizeServiceWorker', 'oauthRedirectSchemes', 'openNewWindowsInBrowser', 'orientation', 'overrides', 'permissions',
   'plugins', 'push', 'pwaDist', 'queryPackages', 'queryUrlSchemes', 'serverUrl', 'shareTarget', 'signing', 'signingProfiles', 'statusBarStyle', 'store',
   'splashIcon', 'storekitConfig', 'targetedDevices', 'teamId', 'themeColor', 'trackingDomains', 'urlScheme',
   'usesNonExemptEncryption', 'vendorPaths', 'version',