@livx.cc/appwrap 0.46.1 → 0.46.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livx.cc/appwrap",
-  "version": "0.46.1",
+  "version": "0.46.3",
   "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

@@ -53,6 +53,7 @@
 			<category android:name="android.intent.category.DEFAULT" />
 			<category android:name="android.intent.category.BROWSABLE" />
 			<data android:scheme="appwrap" />
+			<!-- appwrap:oauth-redirect-schemes --><!-- /appwrap:oauth-redirect-schemes -->
 		</intent-filter>
 	</activity>
 		<activity android:name="com.tns.ErrorReportActivity"/>

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

@@ -93,6 +93,15 @@ export class CustomWebView extends WebView {
   /** Set by the bridge before load; receives raw envelope JSON. */
   onAppwrapMessage: ((json: string) => void) | null = null;
 
+  // STRONG JS references to the native clients. Chromium holds the Java WebViewClient /
+  // WebChromeClient, but NativeScript's mark-and-sweep does NOT treat that native hold as a
+  // GC root — so without a JS-side reference the JS peer gets collected under memory pressure
+  // (e.g. heavy scrolling), and the next background-thread shouldInterceptRequest crashes with
+  // "Cannot find runtime for instance". Retaining here (mirrors @nativescript/core's
+  // `nativeView.client = client`) keeps the peer alive for the WebView's lifetime.
+  private webViewClient: android.webkit.WebViewClient | null = null;
+  private webChromeClient: android.webkit.WebChromeClient | null = null;
+
   // Native-view → owning CustomWebView, keyed by the Java identity hash (stable per native
   // object, robust to NS re-wrapping the arg passed into the ChromeClient callback). WeakRef
   // so a destroyed view can be GC'd; entry pruned on dispose.
@@ -131,15 +140,23 @@ export class CustomWebView extends WebView {
     wv.setOverScrollMode(android.view.View.OVER_SCROLL_NEVER);
 
     this.installDocumentStartShim(wv);
-    wv.setWebViewClient(createAssetServingClient());
+    // Retain both clients in long-lived JS fields (see field docs) so their JS peers survive GC
+    // for the WebView's lifetime — otherwise a background-thread shouldInterceptRequest can fire
+    // after the peer is collected and crash with "Cannot find runtime for instance".
+    this.webViewClient = createAssetServingClient();
+    wv.setWebViewClient(this.webViewClient);
     // Bind THIS native view to THIS instance before wiring the (shared, extend-once) client.
     CustomWebView.registry.set(wv.hashCode(), new WeakRef<CustomWebView>(this));
-    wv.setWebChromeClient(new (getChromeClientClass())());
+    this.webChromeClient = new (getChromeClientClass())();
+    wv.setWebChromeClient(this.webChromeClient);
   }
 
   disposeNativeView(): void {
     const wv = this.android as android.webkit.WebView | undefined;
     if (wv) CustomWebView.registry.delete(wv.hashCode());
+    // Drop the retained clients now that the native view is going away, so their peers can be GC'd.
+    this.webViewClient = null;
+    this.webChromeClient = null;
     super.disposeNativeView();
   }
 

package/runtime-desktop/bridge-shim/shim.ts

@@ -16,27 +16,13 @@ const RUST_PORT = Number(process.env.APPWRAP_BRIDGE_RUST_PORT || 9237);
 
 const log = (m: string, ...a: unknown[]) => console.log(`[shim] ${m}`, ...a);
 
-// ---------------------------------------------------------------------------
-// Tab registry: Tauri window label <-> numeric tabId (chrome.tabs.Tab-ish shape)
-// ---------------------------------------------------------------------------
-interface TabEntry { tabId: number; label: string; url: string; title: string; registered: boolean; profileId?: string }
-const tabs = new Map<string, TabEntry>(); // by label
-let tabCounter = 0;
-let activeLabel: string | null = null;
-
-function tabShape(t: TabEntry, active = t.label === activeLabel) {
-  return { id: t.tabId, url: t.url, title: t.title, active, windowId: 1, status: t.registered ? 'complete' : 'loading', label: t.label, profileId: t.profileId };
-}
-function byTabId(tabId?: number): TabEntry {
-  if (tabId != null) {
-    const t = [...tabs.values()].find(t => t.tabId === Number(tabId));
-    if (!t) throw new Error(`No such tab: ${tabId}`);
-    return t;
-  }
-  const t = (activeLabel && tabs.get(activeLabel)) || [...tabs.values()].pop();
-  if (!t) throw new Error('No windows open (use newTab first)');
-  return t;
-}
+// The transport-agnostic browser-automation PRODUCT (tab registry + bod-browser routing +
+// handleCommand) was lifted into the `browser-driver` package inside mcp-desktop-browser (Phase 1b).
+// This file is now a thin TRANSPORT shell: WS client + TCP control channel + page WS, delegating all
+// command handling and page-beacon parsing to the driver below. Consumed as a proper package
+// (`mcp-desktop-browser/browser-driver`, a file: dep in the root package.json → resolves by name,
+// not a fragile cross-repo relative path — the TS analogue of the crate-consumption decision).
+import { createBrowserDriver } from 'mcp-desktop-browser/browser-driver';
 
 // ---------------------------------------------------------------------------
 // Rust control channel (TCP, newline-delimited JSON)
@@ -56,6 +42,9 @@ function rustRequest(op: string, params: Record<string, unknown> = {}, timeoutMs
   });
 }
 
+// The product layer — driven through our transport (rustRequest) + fed page beacons via onPageMsg.
+const driver = createBrowserDriver({ rustRequest, log });
+
 Bun.listen({
   hostname: '127.0.0.1',
   port: RUST_PORT,
@@ -75,7 +64,7 @@ Bun.listen({
         if (!line) continue;
         try {
           const msg = JSON.parse(line);
-          if (msg.type === 'pageMsg') { onPageMsg(String(msg.payload)); continue; }
+          if (msg.type === 'pageMsg') { driver.onPageMsg(String(msg.payload)); continue; }
           const p = rustPending.get(msg.id);
           if (p) {
             rustPending.delete(msg.id);
@@ -91,34 +80,6 @@ Bun.listen({
   },
 });
 
-// ---------------------------------------------------------------------------
-// Page messages (via the shell's WKScriptMessageHandler -> pageMsg lines) and
-// command dispatch (via evalJs -> window.__bridgeDispatch)
-// ---------------------------------------------------------------------------
-const pagePending = new Map<string, Pending>();
-
-function onPageMsg(payload: string) {
-  let msg: Record<string, unknown>;
-  try { msg = JSON.parse(payload); } catch { log('bad pageMsg:', payload.slice(0, 200)); return; }
-  const label = String(msg.label || '');
-  if (msg.type === 'register') {
-    let t = tabs.get(label);
-    if (!t) { t = { tabId: ++tabCounter, label, url: '', title: '', registered: false }; tabs.set(label, t); }
-    t.registered = true;
-    t.url = String(msg.url || t.url);
-    t.title = String(msg.title || t.title);
-    log(`page registered: ${label} tabId=${t.tabId} ${t.url.slice(0, 80)}`);
-    return;
-  }
-  const p = pagePending.get(String(msg.id));
-  if (p) {
-    pagePending.delete(String(msg.id));
-    clearTimeout(p.timer);
-    if (msg.error) p.reject(new Error(String(msg.error)));
-    else p.resolve(msg.result);
-  }
-}
-
 // Debug HTTP endpoint (curl a raw rust op / read page beacons)
 Bun.serve({
   hostname: '127.0.0.1',
@@ -135,152 +96,6 @@ Bun.serve({
   },
 });
 
-function pageExec(t: TabEntry, action: Record<string, unknown>, timeoutMs = 30000): Promise<unknown> {
-  const id = `p${++reqCounter}`;
-  const dispatch = `window.__bridgeDispatch && window.__bridgeDispatch(${JSON.stringify({ id, ...action })})`;
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => { pagePending.delete(id); reject(new Error(`exec ${action.action} timed out on tab ${t.tabId} (page not bridged?)`)); }, timeoutMs);
-    pagePending.set(id, { resolve, reject, timer });
-    rustRequest('evalJs', { label: t.label, js: dispatch }).catch(e => {
-      if (pagePending.delete(id)) { clearTimeout(timer); reject(e as Error); }
-    });
-  });
-}
-
-/** Wait until the tab's page socket is (re)connected — used after newTab/navigate. */
-async function waitForPage(label: string, timeoutMs = 15000): Promise<TabEntry> {
-  const start = Date.now();
-  for (;;) {
-    const t = tabs.get(label);
-    if (t?.registered) return t;
-    if (Date.now() - start > timeoutMs) throw new Error(`page for ${label} did not connect within ${timeoutMs}ms`);
-    await new Promise(r => setTimeout(r, 100));
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Command handling (the extension-background analogue)
-// ---------------------------------------------------------------------------
-async function handleCommand(msg: { id: string; cmd: string; params?: Record<string, unknown> }): Promise<unknown> {
-  const params = (msg.params || {}) as Record<string, unknown> & { tabId?: number; url?: string };
-  switch (msg.cmd) {
-    case 'ping': return { pong: true };
-    case 'getTabs': return [...tabs.values()].map(t => tabShape(t));
-    case 'getActiveTab': return tabShape(byTabId(undefined));
-    case 'newTab': {
-      const url = params.url || 'https://example.com';
-      // Optional profileId → the shell creates a manual window bound to that profile's persistent,
-      // isolated WKWebsiteDataStore (see bridge_mac.rs). Absent → a plain tauri window.
-      const profileId = (params as { profileId?: string }).profileId;
-      // Unique across shim restarts — the app may still hold windows from a previous shim run.
-      const label = `bridge-${Date.now().toString(36)}-${++tabCounter}`;
-      const t: TabEntry = { tabId: tabCounter, label, url: String(url), title: '', registered: false, profileId };
-      tabs.set(label, t);
-      activeLabel = label;
-      await rustRequest('createWindow', { label, url, ...(profileId ? { profileId } : {}) });
-      await waitForPage(label).catch(e => log(`newTab: ${e.message}`)); // tab exists even if slow to load
-      return tabShape(t);
-    }
-    case 'closeTab': {
-      const t = byTabId(params.tabId);
-      await rustRequest('closeWindow', { label: t.label });
-      tabs.delete(t.label);
-      if (activeLabel === t.label) activeLabel = [...tabs.keys()].pop() ?? null;
-      return { success: true };
-    }
-    case 'navigate': {
-      const t = byTabId(params.tabId);
-      t.registered = false; // old document is going away
-      t.url = String(params.url);
-      activeLabel = t.label;
-      await rustRequest('navigate', { label: t.label, url: params.url });
-      await waitForPage(t.label).catch(e => log(`navigate: ${e.message}`));
-      return tabShape(t);
-    }
-    case 'screenshot': {
-      const t = byTabId(params.tabId);
-      const r = await rustRequest('screenshot', { label: t.label }, 20000) as { png: string };
-      return { dataUrl: `data:image/png;base64,${r.png}` };
-    }
-    case 'exec': {
-      const { tabId, frameId: _f, ...action } = params as Record<string, unknown> & { tabId?: number };
-      const t = byTabId(tabId);
-      const timeout = action.action === 'waitFor' ? Number(action.timeout || 5000) + 5000 : 30000;
-      return pageExec(t, action, timeout);
-    }
-    case 'setInput': {
-      // Extension does this via chrome.scripting in MAIN world; our bundle already runs in the
-      // page world, so route through the content eval with a native-setter script.
-      const t = byTabId(params.tabId);
-      const script = `(() => { const el = document.querySelector(${JSON.stringify(params.selector)});
-        if (!el) return { error: 'not found: ' + ${JSON.stringify(params.selector)} };
-        const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
-        const setter = Object.getOwnPropertyDescriptor(proto, 'value')?.set;
-        if (setter) setter.call(el, ${JSON.stringify(params.value)}); else el.value = ${JSON.stringify(params.value)};
-        el.dispatchEvent(new Event('input', { bubbles: true }));
-        el.dispatchEvent(new Event('change', { bubbles: true }));
-        return { ok: true, value: el.value }; })()`;
-      const r = await rustRequest('evalAsync', { label: t.label, js: `return JSON.stringify(${script});` }) as { json: string };
-      const inner = JSON.parse(r.json || 'null') as { error?: string; ok?: boolean } | null;
-      if (inner?.error) throw new Error(inner.error);
-      return inner;
-    }
-    case 'cdpEval': {
-      // CSP-immune eval — WKWebView callAsyncJavaScript (native compilation, awaits promises).
-      // The bridge server falls back to this when a page's CSP blocks the content-layer eval().
-      const t = byTabId(params.tabId);
-      const expression = String(params.expression || '');
-      const body = `const __r = await (${expression}); return JSON.stringify(__r === undefined ? null : __r);`;
-      const timeoutMs = Number((params as { timeoutMs?: number }).timeoutMs || 30000);
-      try {
-        const r = await rustRequest('evalAsync', { label: t.label, js: body }, timeoutMs) as { json: string };
-        return { result: JSON.parse(r.json || 'null') };
-      } catch (e) {
-        return { result: null, error: (e as Error).message };
-      }
-    }
-    case 'cdpInsertText': {
-      // Controlled text insertion into a contenteditable / input WITHOUT ever submitting.
-      // The extension's real path is CDP Input.insertText (we have no CDP); this replicates it
-      // via focus + beforeinput/insertText/input events. It deliberately dispatches NO Enter/
-      // keydown and never clicks a submit control — a spike delegation auto-submitted a comment
-      // because the earlier execCommand workaround let a stray Enter through; this closes that.
-      const t = byTabId(params.tabId);
-      const selector = (params as { selector?: string }).selector;
-      const text = String((params as { text?: string }).text ?? '');
-      const clear = !!(params as { clear?: boolean }).clear;
-      const body = `
-        const el = ${selector ? `document.querySelector(${JSON.stringify(selector)})` : 'document.activeElement'};
-        if (!el) return JSON.stringify({ error: 'insert target not found' });
-        el.focus();
-        const editable = el.isContentEditable;
-        if (${clear}) {
-          if (editable) { const r = document.createRange(); r.selectNodeContents(el); const s = getSelection(); s.removeAllRanges(); s.addRange(r); document.execCommand('delete'); }
-          else { const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype; const set = Object.getOwnPropertyDescriptor(proto,'value')?.set; set ? set.call(el,'') : (el.value=''); }
-        }
-        el.dispatchEvent(new InputEvent('beforeinput', { bubbles: true, cancelable: true, inputType: 'insertText', data: ${JSON.stringify(text)} }));
-        if (editable) {
-          if (!document.execCommand('insertText', false, ${JSON.stringify(text)})) el.textContent += ${JSON.stringify(text)};
-        } else {
-          const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
-          const set = Object.getOwnPropertyDescriptor(proto,'value')?.set; const nv = (el.value||'') + ${JSON.stringify(text)};
-          set ? set.call(el, nv) : (el.value = nv);
-        }
-        el.dispatchEvent(new InputEvent('input', { bubbles: true, inputType: 'insertText', data: ${JSON.stringify(text)} }));
-        return JSON.stringify({ ok: true, value: editable ? el.innerText : el.value, submitted: false });`;
-      const r = await rustRequest('evalAsync', { label: t.label, js: body }) as { json: string };
-      const out = JSON.parse(r.json || 'null') as { error?: string };
-      if (out?.error) throw new Error(out.error);
-      return out;
-    }
-    case 'getGroup': return { groupId: null };
-    case 'closeGroup': return { success: true };
-    case 'listExtensions': return [];
-    default:
-      throw new Error(`unsupported on appwrap-desktop: ${msg.cmd}`);
-  }
-}
-
 // ---------------------------------------------------------------------------
 // Bridge server WS client (the extension background's ws.ts analogue)
 // ---------------------------------------------------------------------------
@@ -298,7 +113,7 @@ function connectServer() {
       const parsed = JSON.parse(String(ev.data));
       if (parsed.type === 'pong' || parsed.type === 'reload' || parsed.type === 'recording_saved') return;
       msg = parsed;
-      const result = await handleCommand(msg!);
+      const result = await driver.handleCommand(msg!);
       log(`cmd=${msg!.cmd} ok`);
       serverWs!.send(JSON.stringify({ id: msg!.id, result }));
     } catch (e) {

package/runtime-desktop/chrome/appwrap-browser-chrome.html

@@ -0,0 +1,120 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8" />
+<meta name="viewport" content="width=device-width, initial-scale=1" />
+<title>Browser</title>
+<style>
+  :root {
+    --bar-h: 44px;
+    --bg: #f2f2f4; --fg: #1c1c1e; --border: #d0d0d5;
+    --field-bg: #ffffff; --field-border: #c4c4cc; --btn-hover: #e2e2e6;
+  }
+  @media (prefers-color-scheme: dark) {
+    :root {
+      --bg: #2a2a2e; --fg: #f2f2f4; --border: #444;
+      --field-bg: #1c1c1e; --field-border: #555; --btn-hover: #3a3a40;
+    }
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; height: 100%; overflow: hidden;
+    font: 13px -apple-system, system-ui, sans-serif; color: var(--fg); }
+  /* The controlled WKWebView is a native subview covering everything below the bar; the body below
+     the bar is never seen — only this top strip renders. */
+  #bar {
+    display: flex; align-items: center; gap: 6px;
+    height: var(--bar-h); padding: 0 8px;
+    background: var(--bg); border-bottom: 1px solid var(--border);
+    -webkit-user-select: none; user-select: none;
+  }
+  button.nav {
+    width: 30px; height: 28px; flex: none;
+    border: none; border-radius: 6px; background: transparent; color: var(--fg);
+    font-size: 16px; line-height: 1; cursor: default;
+  }
+  button.nav:hover { background: var(--btn-hover); }
+  button.nav:active { background: var(--field-border); }
+  #addr {
+    flex: 1 1 auto; height: 28px; padding: 0 10px;
+    border: 1px solid var(--field-border); border-radius: 7px;
+    background: var(--field-bg); color: var(--fg); font-size: 13px; outline: none;
+  }
+  #addr:focus { border-color: #4c8bf5; }
+  #profile {
+    flex: none; height: 28px; max-width: 160px;
+    border: 1px solid var(--field-border); border-radius: 7px;
+    background: var(--field-bg); color: var(--fg); font-size: 12px; padding: 0 4px;
+  }
+</style>
+</head>
+<body>
+  <div id="bar">
+    <button class="nav" id="back" title="Back">&#8249;</button>
+    <button class="nav" id="fwd" title="Forward">&#8250;</button>
+    <button class="nav" id="reload" title="Reload">&#8635;</button>
+    <input id="addr" type="text" spellcheck="false" autocomplete="off"
+           placeholder="Enter address (e.g. 127.0.0.1:3000)" />
+    <select id="profile" title="Profile"></select>
+  </div>
+<script>
+(function () {
+  var id = new URLSearchParams(location.search).get('id') || '';
+  function invoke(cmd, args) {
+    var core = window.__TAURI__ && window.__TAURI__.core;
+    if (!core) return Promise.reject(new Error('Tauri core unavailable'));
+    return core.invoke(cmd, args || {});
+  }
+
+  var addr = document.getElementById('addr');
+  var profileSel = document.getElementById('profile');
+
+  function normalizeUrl(raw) {
+    var s = (raw || '').trim();
+    if (!s) return '';
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(s) || /^about:/i.test(s)) return s;
+    return 'https://' + s;
+  }
+
+  document.getElementById('back').addEventListener('click', function () { invoke('browser_tab_back', { id: id }); });
+  document.getElementById('fwd').addEventListener('click', function () { invoke('browser_tab_forward', { id: id }); });
+  document.getElementById('reload').addEventListener('click', function () { invoke('browser_tab_reload', { id: id }); });
+
+  addr.addEventListener('keydown', function (e) {
+    if (e.key !== 'Enter') return;
+    var url = normalizeUrl(addr.value);
+    if (url) invoke('browser_tab_navigate', { id: id, url: url });
+  });
+
+  profileSel.addEventListener('change', function () {
+    invoke('browser_subwindow_switch_profile', { id: id, profileId: profileSel.value });
+  });
+
+  // Populate the profile dropdown.
+  invoke('browser_list_profiles').then(function (profiles) {
+    (profiles || ['default']).forEach(function (p) {
+      var opt = document.createElement('option');
+      opt.value = p; opt.textContent = p;
+      profileSel.appendChild(opt);
+    });
+  }).catch(function (e) { console.error('list profiles failed', e); });
+
+  // Keep the address bar in sync with the controlled webview (skip while the user is editing it).
+  var focused = false;
+  addr.addEventListener('focus', function () { focused = true; });
+  addr.addEventListener('blur', function () { focused = false; });
+  function poll() {
+    invoke('browser_tab_current_url', { id: id }).then(function (json) {
+      if (focused) return;
+      try {
+        var o = JSON.parse(json);
+        var href = o && o.href ? o.href : '';
+        if (href && href !== 'about:blank') addr.value = href;
+      } catch (_) {}
+    }).catch(function () {});
+  }
+  setInterval(poll, 1000);
+  poll();
+})();
+</script>
+</body>
+</html>