@livx.cc/appwrap 0.19.0

package/runtime/app/shell/web-quirks.ts

@@ -0,0 +1,131 @@
+import { SHELL_CONFIG } from './config';
+
+/**
+ * Framework globals injected at document-start, BEFORE the page's own scripts. `__APPWRAP_BACKEND_ORIGIN__`
+ * is the absolute backend origin (empty on web / when unset) — exposed for any page code that wants it
+ * (e.g. the SDK's ingestUrl override for the WebSocket, which can't be proxied). Relative HTTP backend
+ * calls (`/api/*`, `/functions/*`) are NOT rewritten here — the native app:// scheme handler PROXIES
+ * them to the backend so they stay same-origin to the WebView (no CORS dependency). Empty = no-op on web.
+ */
+export const APPWRAP_GLOBALS_JS = `
+window.__APPWRAP_BACKEND_ORIGIN__=${JSON.stringify(SHELL_CONFIG.backendOrigin || '')};
+window.__APPWRAP_DEBUG__=${SHELL_CONFIG.debug ? 'true' : 'false'};
+(function(){
+  if (!window.__APPWRAP_DEBUG__ || window.__appwrapLogPatched) return;
+  window.__appwrapLogPatched = true;
+  // Dev: turn the PWA's own logger verbose (common localStorage.DEBUG convention) so the forwarded
+  // [appwrap-web] stream isn't empty. Set before the app's modules read it (document-start).
+  try { localStorage.setItem('DEBUG', ${JSON.stringify(SHELL_CONFIG.debugLog || '*')}); } catch (e) {}
+  // Debug only: forward the WebView's console + uncaught errors to the native log so they're
+  // readable HEADLESSLY (\`appwrap logs ios\` → devicectl --console). iOS posts to a message handler
+  // → NSLog; on Android webkit.messageHandlers is absent (caught) — use logcat / onConsoleMessage.
+  var post = function(s){ try { window.webkit.messageHandlers.appwrapLog.postMessage(s); } catch (e) {} };
+  post('[boot] web console forwarding active @ ' + (location && location.href || ''));
+  ['log','debug','info','warn','error'].forEach(function(lvl){
+    var orig = console[lvl] ? console[lvl].bind(console) : function(){};
+    console[lvl] = function(){
+      try {
+        var parts = [];
+        for (var i = 0; i < arguments.length; i++) {
+          var a = arguments[i];
+          try { parts.push(typeof a === 'string' ? a : JSON.stringify(a)); } catch (e) { parts.push(String(a)); }
+        }
+        post('[' + lvl + '] ' + parts.join(' '));
+      } catch (e) {}
+      orig.apply(null, arguments);
+    };
+  });
+  window.addEventListener('error', function(e){ post('[uncaught] ' + (e.message || e) + ' @ ' + (e.filename || '') + ':' + (e.lineno || 0)); });
+  window.addEventListener('unhandledrejection', function(e){ var r = e.reason; post('[rejection] ' + ((r && (r.stack || r.message)) || r)); });
+})();`;
+
+/**
+ * Reject `getUserMedia` for a capability this build did NOT declare (no Info.plist usage key), in JS at
+ * document-start — BEFORE the request reaches WebKit's native capture path. This is the ONLY layer that
+ * can stop the crash: to set up a capture session WebKit asks TCC to authorize the camera/mic, and on iOS
+ * a request for a privacy class with no usage string is a HARD PROCESS-KILL (not a catchable error). That
+ * request fires around the WKUIDelegate decision, so a native `deny` there can't prevent it — but if the
+ * call is rejected in JS, WebKit's native path is never entered. `camera`/`microphone` = the declared
+ * flags (iOS: presence of NSCamera/NSMicrophoneUsageDescription). Patches the prototype so a page can't
+ * dodge it via `MediaDevices.prototype.getUserMedia.call(...)`. Declared capabilities pass straight through.
+ */
+export function mediaCaptureGuardJs(camera: boolean, microphone: boolean): string {
+  return `(function(){
+  var proto = window.MediaDevices && window.MediaDevices.prototype;
+  if (!proto || !proto.getUserMedia || window.__appwrapGumGuard) return;
+  window.__appwrapGumGuard = true;
+  var DECLARED = { video: ${!!camera}, audio: ${!!microphone} };
+  function missing(c){
+    var m = [];
+    if (c && c.video && !DECLARED.video) m.push('camera');
+    if (c && c.audio && !DECLARED.audio) m.push('microphone');
+    return m;
+  }
+  var orig = proto.getUserMedia;
+  proto.getUserMedia = function(constraints){
+    var m = missing(constraints);
+    if (m.length) return Promise.reject(new DOMException(
+      m.join(' & ') + ' not available (capability not enabled for this app)', 'NotAllowedError'));
+    return orig.call(this, constraints);
+  };
+})();`;
+}
+
+/**
+ * Native-feel injection shared by both CustomWebViews. Suppresses the "it's a
+ * web page" tells: pinch / double-tap zoom, long-press callout & selection,
+ * overscroll glow/bounce, and iOS text auto-resizing. Injected at document
+ * start (and re-applied on DOMContentLoaded — at document-start <head> may be
+ * empty). Idempotent via a window guard, so double-injection is a no-op.
+ *
+ * Text selection is preserved inside inputs / [contenteditable] so forms and
+ * chat composers still work. Native zoom controls / overscroll mode are also
+ * turned off at the WebView level by each platform (belt-and-suspenders).
+ */
+const NATIVE_FEEL_CSS = [
+  'html{-webkit-text-size-adjust:100%;text-size-adjust:100%}',
+  'html,body{overscroll-behavior:none;touch-action:manipulation}',
+  '*{-webkit-touch-callout:none;-webkit-tap-highlight-color:transparent}',
+  ':where(:not(input,textarea,[contenteditable],[contenteditable] *)){-webkit-user-select:none;user-select:none}',
+].join('');
+
+/** Accessibility-standard reduced-motion reset — collapse animation/transition durations to ~0 and
+ * stop infinite loops (animation-iteration-count:1). Injected only when the env hint is set. */
+const REDUCE_MOTION_CSS =
+  '*,*::before,*::after{animation-duration:.001ms!important;animation-iteration-count:1!important;' +
+  'transition-duration:.001ms!important;scroll-behavior:auto!important}';
+
+export const NATIVE_FEEL_JS = `(function(){
+  if (window.__appwrapNativeFeel) return;
+  window.__appwrapNativeFeel = true;
+  function apply(){
+    var head = document.head || document.documentElement;
+    var vp = document.querySelector('meta[name=viewport]');
+    if (!vp){ vp = document.createElement('meta'); vp.setAttribute('name','viewport'); head.appendChild(vp); }
+    var c = vp.getAttribute('content') || 'width=device-width, initial-scale=1';
+    if (!/user-scalable\\s*=\\s*no/.test(c)) c += ', maximum-scale=1, user-scalable=no';
+    // viewport-fit=cover makes env(safe-area-inset-*) resolve to real notch /
+    // home-indicator insets — the WebView owns the safe areas (contentInset .never).
+    if (!/viewport-fit/.test(c)) c += ', viewport-fit=cover';
+    vp.setAttribute('content', c);
+    if (!document.getElementById('__appwrap_feel')){
+      var s = document.createElement('style'); s.id = '__appwrap_feel';
+      s.textContent = ${JSON.stringify(NATIVE_FEEL_CSS)};
+      head.appendChild(s);
+    }
+    // Reduced-motion / software-GPU (emulator) safety net: neutralize infinite CSS animations &
+    // long transitions — they're free on a real GPU but continuously re-composite on the emulator's
+    // software rasterizer (host-CPU burn) and fight the OS reduce-motion setting. Gated on the env
+    // hint (see env.ts) so production on real devices is untouched; apps can still override.
+    var env = window.__APPWRAP__ || {};
+    if ((env.reduceMotion || env.isEmulator) && !document.getElementById('__appwrap_reduce_motion')){
+      var rm = document.createElement('style'); rm.id = '__appwrap_reduce_motion';
+      rm.textContent = ${JSON.stringify(REDUCE_MOTION_CSS)};
+      head.appendChild(rm);
+    }
+  }
+  apply();
+  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', apply);
+  // Pinch-zoom on iOS fires gesture* even with user-scalable=no in some builds.
+  document.addEventListener('gesturestart', function(e){ e.preventDefault(); }, { passive: false });
+})();`;

package/runtime/modules-native/health/App_Resources/Android/src/main/java/cc/livx/appwrap/HealthConnectBridge.kt

@@ -0,0 +1,74 @@
+package cc.livx.appwrap
+
+import android.content.Context
+import android.content.Intent
+import androidx.health.connect.client.HealthConnectClient
+import androidx.health.connect.client.PermissionController
+import androidx.health.connect.client.permission.HealthPermission
+import androidx.health.connect.client.records.StepsRecord
+import androidx.health.connect.client.request.AggregateRequest
+import androidx.health.connect.client.time.TimeRangeFilter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.time.Instant
+import java.time.LocalDate
+import java.time.ZoneId
+
+/**
+ * NS-callable bridge over Health Connect (whose client API is Kotlin-`suspend`-only). Wraps each
+ * suspend call in a coroutine and delivers the result through a plain callback ON THE MAIN THREAD —
+ * so the JS continuation (and the WebView response delivery) runs on the UI thread. Shipped via the
+ * app's overrides/ until the framework grows first-class Health Connect support.
+ */
+object HealthConnectBridge {
+    interface LongCallback { fun onResult(value: Long) }
+    interface BoolCallback { fun onResult(value: Boolean) }
+
+    private val READ_STEPS = HealthPermission.getReadPermission(StepsRecord::class)
+
+    @JvmStatic
+    fun isAvailable(context: Context): Boolean =
+        HealthConnectClient.getSdkStatus(context) == HealthConnectClient.SDK_AVAILABLE
+
+    /** Intent that launches the Health Connect permission UI (for startActivityForResult). */
+    @JvmStatic
+    fun permissionIntent(context: Context): Intent =
+        PermissionController.createRequestPermissionResultContract().createIntent(context, setOf(READ_STEPS))
+
+    @JvmStatic
+    fun hasPermission(context: Context, cb: BoolCallback) {
+        val client = HealthConnectClient.getOrCreate(context)
+        CoroutineScope(Dispatchers.IO).launch {
+            val granted = try {
+                client.permissionController.getGrantedPermissions().contains(READ_STEPS)
+            } catch (e: Exception) { false }
+            withContext(Dispatchers.Main) { cb.onResult(granted) }
+        }
+    }
+
+    /** Today's total steps. Prefers `aggregate` (dedupes across sources incl. Wear on real devices);
+     * falls back to summing raw records when aggregate yields null (a known HC quirk — e.g. the
+     * emulator provider / a single app's manual records). Returns -1 when permission isn't granted. */
+    private suspend fun todayTotal(client: HealthConnectClient): Long {
+        val zone = ZoneId.systemDefault()
+        val range = TimeRangeFilter.between(LocalDate.now(zone).atStartOfDay(zone).toInstant(), Instant.now())
+        val agg = client.aggregate(AggregateRequest(setOf(StepsRecord.COUNT_TOTAL), range))[StepsRecord.COUNT_TOTAL]
+        if (agg != null) return agg
+        val read = client.readRecords(androidx.health.connect.client.request.ReadRecordsRequest(StepsRecord::class, range))
+        return read.records.sumOf { it.count }
+    }
+
+    @JvmStatic
+    fun readTodaySteps(context: Context, cb: LongCallback) {
+        val client = HealthConnectClient.getOrCreate(context)
+        CoroutineScope(Dispatchers.IO).launch {
+            val result: Long = try {
+                if (!client.permissionController.getGrantedPermissions().contains(READ_STEPS)) -1L
+                else todayTotal(client)
+            } catch (e: Exception) { -2L }
+            withContext(Dispatchers.Main) { cb.onResult(result) }
+        }
+    }
+}

package/runtime/nativescript.config.ts

@@ -0,0 +1,15 @@
+import { NativeScriptConfig } from '@nativescript/core';
+
+export default {
+  // Stamped by `appwrap init` from appwrap.json
+  id: 'cc.livx.hellowrap',
+  appPath: 'app',
+  appResourcesPath: 'App_Resources',
+  ios: {
+    discardUncaughtJsExceptions: false,
+  },
+  android: {
+    v8Flags: '--expose_gc',
+    markingMode: 'none',
+  },
+} as NativeScriptConfig;

package/runtime/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "appwrap-shell",
+  "main": "app/app.ts",
+  "version": "0.18.0",
+  "private": true,
+  "scripts": {
+    "dev:ios": "ns run ios",
+    "build:ios": "ns build ios"
+  },
+  "dependencies": {
+    "@nativescript/core": "~9.0.0",
+    "@nativescript/secure-storage": "^4.0.1"
+  },
+  "devDependencies": {
+    "@nativescript/ios": "9.0.2",
+    "@nativescript/types": "~9.0.0",
+    "@nativescript/webpack": "~5.0.25",
+    "copy-webpack-plugin": "^13.0.1",
+    "typescript": "~5.4.0"
+  }
+}

package/runtime/references.d.ts

@@ -0,0 +1,2 @@
+/// <reference path="./node_modules/@nativescript/types-ios/index.d.ts" />
+/// <reference path="./node_modules/@nativescript/types-android/lib/android-32.d.ts" />

package/runtime/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "module": "esnext",
+    "target": "es2020",
+    "moduleResolution": "bundler",
+    "lib": ["es2021", "dom"],
+    "experimentalDecorators": true,
+    "removeComments": false,
+    "noEmitHelpers": true,
+    "noEmitOnError": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "~/*": ["app/*"]
+    }
+  },
+  "include": ["app/**/*.ts", "references.d.ts"],
+  "exclude": ["node_modules", "platforms", "app/www"]
+}

package/runtime/webpack.config.js

@@ -0,0 +1,27 @@
+const webpack = require('@nativescript/webpack');
+const CopyWebpackPlugin = require('copy-webpack-plugin');
+const path = require('path');
+
+module.exports = (env) => {
+  webpack.init(env);
+
+  webpack.chainWebpack((config) => {
+    // Ship the PWA bundle inside the app package
+    config.plugin('CopyWww').use(CopyWebpackPlugin, [
+      {
+        patterns: [
+          {
+            // Staged OUTSIDE appPath (see CLI copyPwa) so NS loaders never touch the web
+            // app's CSS/assets — copied verbatim into the bundle's `www`, served at app://.
+            from: path.resolve(__dirname, 'www-src'),
+            to: 'www',
+            noErrorOnMissing: true, // server loader: no bundled www (loads serverUrl live)
+            force: true,
+          },
+        ],
+      },
+    ]);
+  });
+
+  return webpack.resolveConfig();
+};

package/scripts/stage-assets.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+// prepack: stage runtime/ + templates/ into the package so the published tarball is self-contained.
+// The CLI resolves them at the package root (see resolveAssetRoot in src/cli.ts). Excludes build
+// artifacts (node_modules, platforms, hooks, app/www) and OS cruft. Gitignored — tarball-only.
+import { cpSync, rmSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const repoRoot = resolve(pkgDir, '../..');
+const EXCLUDE = /(?:^|\/)(?:node_modules|platforms|hooks|app\/www|\.DS_Store)(?:\/|$)/;
+
+for (const name of ['runtime', 'templates']) {
+  const srcRoot = resolve(repoRoot, name);
+  const dest = resolve(pkgDir, name);
+  rmSync(dest, { recursive: true, force: true });
+  // Match RELATIVE to srcRoot — testing the absolute path would wrongly exclude everything when the
+  // repo is checked out under a path containing "node_modules"/"hooks" (e.g. some CI layouts).
+  cpSync(srcRoot, dest, { recursive: true, filter: (src) => !EXCLUDE.test(src.slice(srcRoot.length)) });
+  console.log(`staged ${name}/`);
+}