@livx.cc/appwrap 0.42.1 → 0.42.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.42.1",
+  "version": "0.42.2",
   "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/iOS/PrivacyInfo.xcprivacy

@@ -8,13 +8,16 @@
     - FileTimestamp (C617.1)  — NativeScript reads bundle/app file metadata at runtime
     - SystemBootTime (35F9.1) — NativeScript timers/uptime
     - DiskSpace (E174.1)      — NativeScript file I/O
-  NSPrivacyTracking is false (no IDFA, no cross-app/third-party linkage). The shell surfaces install
-  context for FIRST-PARTY analytics via kit.context():
-    - DeviceID (CRC0)  — identifierForVendor (IDFV), app-scoped, reset on uninstall; NOT IDFA.
-    - ProductInteraction (385F.1) — usage/app-environment props (platform, version, install source).
-  Both are declared NOT linked to identity and NOT used for tracking. If your PWA collects MORE
-  (account, location, contacts) or DOES track (ads/3rd-party linkage), add the matching
-  NSPrivacyCollectedDataTypes / set NSPrivacyTracking=true here — see tracking-analytics + store-readiness.
+  NSPrivacyTracking is false (no IDFA, no cross-app/third-party linkage) and NSPrivacyCollectedDataTypes
+  is EMPTY by default: the stock runtime does NOT collect or transmit any data. kit.context() merely
+  RETURNS install context (IDFV, platform, version) to the app on request — it never sends it anywhere —
+  so the default binary matches a "Data Not Collected" App Store privacy label.
+
+  If YOUR app wires analytics that actually transmits data (DeviceID/IDFV, ProductInteraction, account,
+  location, …) you MUST declare it here — replace this whole file via your app's overrides dir
+  (appwrap.overrides/App_Resources/iOS/PrivacyInfo.xcprivacy). `applyOverrides` copies overrides over
+  the generated native/ last, so your file wins. Add the matching NSPrivacyCollectedDataTypes entries
+  (and set NSPrivacyTracking=true if you track) — see tracking-analytics + store-readiness.
 -->
 <plist version="1.0">
 <dict>
@@ -23,32 +26,7 @@
 	<key>NSPrivacyTrackingDomains</key>
 	<array/>
 	<key>NSPrivacyCollectedDataTypes</key>
-	<array>
-		<dict>
-			<key>NSPrivacyCollectedDataType</key>
-			<string>NSPrivacyCollectedDataTypeDeviceID</string>
-			<key>NSPrivacyCollectedDataTypeLinked</key>
-			<false/>
-			<key>NSPrivacyCollectedDataTypeTracking</key>
-			<false/>
-			<key>NSPrivacyCollectedDataTypePurposes</key>
-			<array>
-				<string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
-			</array>
-		</dict>
-		<dict>
-			<key>NSPrivacyCollectedDataType</key>
-			<string>NSPrivacyCollectedDataTypeProductInteraction</string>
-			<key>NSPrivacyCollectedDataTypeLinked</key>
-			<false/>
-			<key>NSPrivacyCollectedDataTypeTracking</key>
-			<false/>
-			<key>NSPrivacyCollectedDataTypePurposes</key>
-			<array>
-				<string>NSPrivacyCollectedDataTypePurposeAnalytics</string>
-			</array>
-		</dict>
-	</array>
+	<array/>
 	<key>NSPrivacyAccessedAPITypes</key>
 	<array>
 		<dict>

package/src/cli.ts

@@ -1275,10 +1275,18 @@ function stampVersionManifest(outDir: string, cfg: AppwrapConfig): void {
 
 /** Pure-native escape hatch: copy the consumer's overrides dir OVER the generated wrapper, last,
  * so it wins. For legacy/custom native code the declarative config can't express. */
-function applyOverrides(cwd: string, outDir: string, cfg: AppwrapConfig): void {
+export function applyOverrides(cwd: string, outDir: string, cfg: AppwrapConfig): void {
   const dir = resolve(cwd, cfg.overrides ?? 'appwrap.overrides');
-  if (!existsSync(dir)) return;
+  // Files the template still provides must survive an override removal (regenerateCore ran first and
+  // re-copied them) → protect them from the override prune.
+  const templateFiles = existsSync(TEMPLATE_DIR) ? collectRelFiles(TEMPLATE_DIR, templateCopyFilter) : new Set<string>();
+  if (!existsSync(dir)) {
+    // No overrides now: prune anything a PRIOR overrides run left behind (renamed/removed override files).
+    pruneStale(outDir, OVERRIDES_MANIFEST, new Set(), templateFiles);
+    return;
+  }
   cpSync(dir, outDir, { recursive: true, force: true });
+  pruneStale(outDir, OVERRIDES_MANIFEST, collectRelFiles(dir), templateFiles);
   console.log(`  over ← ${dir} (native overrides applied)`);
 }
 
@@ -1422,6 +1430,54 @@ function copyCiTemplates(cwd: string, outDir: string, cfg: AppwrapConfig, force
   console.log(ci);
 }
 
+// Manifests of what the two sync-owned sources (runtime template, consumer overrides) generated LAST run.
+// Used to prune files that were REMOVED/renamed in the source — cpSync(force) overwrites but never deletes,
+// so without this a relocated source lingers in native/ and gets re-bundled.
+const TEMPLATE_MANIFEST = '.appwrap-template-manifest.json';
+const OVERRIDES_MANIFEST = '.appwrap-overrides-manifest.json';
+
+/** Files under TEMPLATE_DIR to skip when copying/walking it (deps, build output, PWA staging, per-module
+ * native — those are handled selectively elsewhere). Shared by the cpSync filter and the prune walk so
+ * the copied set and the pruned set are defined identically. */
+const templateCopyFilter = (src: string): boolean =>
+  !/(?:^|\/)(node_modules|platforms|hooks|app\/www|modules-native)(\/|$)/.test(src.slice(TEMPLATE_DIR.length));
+
+/** File (not dir) paths under `root`, relative to it, skipping entries `accept` rejects. */
+function collectRelFiles(root: string, accept: (abs: string) => boolean = () => true): Set<string> {
+  const out = new Set<string>();
+  const rec = (dir: string, rel: string): void => {
+    let entries;
+    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      const abs = join(dir, e.name);
+      if (!accept(abs)) continue;
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) rec(abs, r);
+      else out.add(r);
+    }
+  };
+  rec(root, '');
+  return out;
+}
+
+/** Prune generated files sync OWNS that vanished from their source. Deletes only paths recorded in the
+ * PRIOR manifest that are absent from the `current` source set — so it never touches user data or any
+ * region absent from a previous run's manifest. `protect` keeps paths another owned source still ships
+ * (e.g. an override was removed but the template still provides that file). */
+function pruneStale(outDir: string, manifest: string, current: Set<string>, protect?: Set<string>): void {
+  const mf = join(outDir, manifest);
+  let prev: string[] = [];
+  try { prev = JSON.parse(readFileSync(mf, 'utf8')) as string[]; } catch { /* first run — nothing to prune */ }
+  for (const rel of prev) {
+    if (current.has(rel) || protect?.has(rel)) continue;
+    const abs = join(outDir, rel);
+    try {
+      if (existsSync(abs)) { rmSync(abs, { force: true }); console.log(`  prune ✕ ${rel} (removed from source)`); }
+    } catch { /* non-fatal */ }
+  }
+  try { writeFileSync(mf, JSON.stringify([...current])); } catch { /* non-fatal */ }
+}
+
 /**
  * Reproduce native/ from source — the shared core of `init` and `sync`. Copies the runtime shell
  * template, re-stamps EVERY config artifact, and re-copies the built PWA. `native/` is disposable, so a
@@ -1441,8 +1497,10 @@ function regenerateCore(cwd: string, outDir: string, cfg: AppwrapConfig, opts: {
     // modules-native/ is copied selectively per active module (copyModuleNativeSrc), not wholesale.
     // Match RELATIVE to TEMPLATE_DIR — when installed from npm, TEMPLATE_DIR itself sits under
     // node_modules/, so testing the absolute path would wrongly exclude the entire template.
-    filter: (src) => !/(?:^|\/)(node_modules|platforms|hooks|app\/www|modules-native)(\/|$)/.test(src.slice(TEMPLATE_DIR.length)),
+    filter: templateCopyFilter,
   });
+  // Delete template files removed/renamed since the last regenerate (cpSync only overwrites, never deletes).
+  pruneStale(outDir, TEMPLATE_MANIFEST, collectRelFiles(TEMPLATE_DIR, templateCopyFilter));
   stampShellConfig(outDir, cfg);
   stampNativeScriptConfig(outDir, cfg);
   stampIOSDisplayName(outDir, cfg, req);
@@ -2176,7 +2234,7 @@ function pinTeamIdToConfig(configPath: string, teamId: string): void {
  * App_Resources/ is intentionally excluded — sync() rewrites it every run, so its mtime always
  * changes and would make the fingerprint permanently stale.
  * Collision risk is acceptable — a false "match" just skips a redundant build, not a correctness bug. */
-function buildFingerprint(cwd: string, cfg: { pwaDist?: string }, _outDir: string): string {
+export function buildFingerprint(cwd: string, cfg: { pwaDist?: string; overrides?: string }, flags: Record<string, string> = {}): string {
   const mtime = (p: string): number => {
     if (!existsSync(p)) return 0;
     try {
@@ -2190,8 +2248,12 @@ function buildFingerprint(cwd: string, cfg: { pwaDist?: string }, _outDir: strin
       return s.mtimeMs;
     } catch { return 0; }
   };
+  // Fingerprint EVERY app source the build actually consumes — not just dist. Missing the overrides dir
+  // (native escape hatch) or a `.js`/`.json`/`--config` config file made edits there produce a stale
+  // "inputs unchanged" skip. Resolve the real config path (ts→js→json / --config) instead of hardcoding.
   const distDir = cfg.pwaDist ? resolve(cwd, cfg.pwaDist) : join(cwd, 'dist');
-  const parts = [mtime(distDir), mtime(join(cwd, 'appwrap.config.ts'))];
+  const overridesDir = resolve(cwd, cfg.overrides ?? 'appwrap.overrides');
+  const parts = [mtime(distDir), mtime(overridesDir), mtime(resolveConfigPath(cwd, flags))];
   // Simple djb2-style hash — good enough for a build-skip check (not cryptographic).
   let h = 5381;
   for (const n of parts) h = (((h << 5) + h) ^ (n | 0)) >>> 0;
@@ -2499,7 +2561,7 @@ async function deployAndroid(cwd: string, flags: Record<string, string>, cfgOver
   // unchanged since the last build. --force/-f always rebuilds. (Rebuilding the web above usually
   // bumps the fingerprint; pair with --no-web-build to actually hit this fast-path.)
   const force = 'force' in flags || 'f' in flags;
-  const fp = buildFingerprint(cwd, cfg, outDir);
+  const fp = buildFingerprint(cwd, cfg, flags);
   const cache = readBuildCache(outDir, 'android');
   if (!force && existsSync(apk) && cache?.fingerprint === fp && cache?.artifactPath === apk) {
     console.log(`⚡ Skipping build — inputs unchanged since last build (${apk.split('/').pop()})`);
@@ -2577,7 +2639,7 @@ async function deploy(cwd: string, flags: Record<string, string>, positionals: s
   // Auto: always checks fingerprint; never skips if sources/deps changed.
   const resume = 'resume' in flags || 'r' in flags;
   const force = 'force' in flags || 'f' in flags;
-  const fp = buildFingerprint(cwd, cfg, outDir);
+  const fp = buildFingerprint(cwd, cfg, flags);
   const cache = readBuildCache(outDir, 'ios');
   const existingIpa = existsSync(ipaDir)
     ? readdirSync(ipaDir).find((f) => f.endsWith('.ipa'))