@bobfrankston/mailx 1.0.74 → 1.0.82

package/client/lib/local-store.js

@@ -0,0 +1,214 @@
+/**
+ * Local storage layer for Android/WebView — uses IndexedDB instead of SQLite.
+ * Implements the subset of MailxDB that the client needs.
+ */
+const DB_NAME = "mailx";
+const DB_VERSION = 1;
+let db = null;
+async function openDB() {
+    if (db)
+        return db;
+    return new Promise((resolve, reject) => {
+        const req = indexedDB.open(DB_NAME, DB_VERSION);
+        req.onupgradeneeded = () => {
+            const d = req.result;
+            if (!d.objectStoreNames.contains("accounts")) {
+                d.createObjectStore("accounts", { keyPath: "id" });
+            }
+            if (!d.objectStoreNames.contains("folders")) {
+                const fs = d.createObjectStore("folders", { keyPath: "id", autoIncrement: true });
+                fs.createIndex("accountId", "accountId");
+            }
+            if (!d.objectStoreNames.contains("messages")) {
+                const ms = d.createObjectStore("messages", { keyPath: "key" });
+                ms.createIndex("accountId", "accountId");
+                ms.createIndex("folderId", "folderId");
+                ms.createIndex("folder", ["accountId", "folderId"]);
+                ms.createIndex("date", "date");
+            }
+            if (!d.objectStoreNames.contains("bodies")) {
+                d.createObjectStore("bodies", { keyPath: "key" });
+            }
+            if (!d.objectStoreNames.contains("contacts")) {
+                const cs = d.createObjectStore("contacts", { keyPath: "email" });
+                cs.createIndex("name", "name");
+            }
+            if (!d.objectStoreNames.contains("meta")) {
+                d.createObjectStore("meta", { keyPath: "key" });
+            }
+        };
+        req.onsuccess = () => { db = req.result; resolve(db); };
+        req.onerror = () => reject(req.error);
+    });
+}
+function tx(stores, mode = "readonly") {
+    const names = Array.isArray(stores) ? stores : [stores];
+    return db.transaction(names, mode);
+}
+function getAll(store, index, key) {
+    return new Promise((resolve, reject) => {
+        const t = tx(store);
+        const s = t.objectStore(store);
+        const target = index ? s.index(index) : s;
+        const req = key ? target.getAll(key) : target.getAll();
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+}
+function put(store, value) {
+    return new Promise((resolve, reject) => {
+        const t = tx(store, "readwrite");
+        t.objectStore(store).put(value);
+        t.oncomplete = () => resolve();
+        t.onerror = () => reject(t.error);
+    });
+}
+function del(store, key) {
+    return new Promise((resolve, reject) => {
+        const t = tx(store, "readwrite");
+        t.objectStore(store).delete(key);
+        t.oncomplete = () => resolve();
+        t.onerror = () => reject(t.error);
+    });
+}
+// ── Public API (mirrors MailxDB methods used by the client service) ──
+export async function init() {
+    await openDB();
+}
+export async function getAccounts() {
+    return getAll("accounts");
+}
+export async function upsertAccount(id, name, email, config) {
+    await put("accounts", { id, name, email, config, lastSync: 0 });
+}
+export async function getFolders(accountId) {
+    return getAll("folders", "accountId", accountId);
+}
+export async function upsertFolder(folder) {
+    await put("folders", folder);
+}
+export async function getMessages(accountId, folderId, page = 1, pageSize = 50) {
+    const all = await getAll("messages", "folder", [accountId, folderId]);
+    // Sort by date descending
+    all.sort((a, b) => b.date - a.date);
+    const total = all.length;
+    const start = (page - 1) * pageSize;
+    const items = all.slice(start, start + pageSize).map(toEnvelope);
+    return { items, total, page, pageSize };
+}
+export async function getUnifiedInbox(page = 1, pageSize = 50) {
+    const folders = await getAll("folders");
+    const inboxFolders = folders.filter(f => f.specialUse === "inbox");
+    const allMsgs = [];
+    for (const f of inboxFolders) {
+        const msgs = await getAll("messages", "folder", [f.accountId, f.id]);
+        allMsgs.push(...msgs);
+    }
+    allMsgs.sort((a, b) => b.date - a.date);
+    const total = allMsgs.length;
+    const start = (page - 1) * pageSize;
+    const items = allMsgs.slice(start, start + pageSize).map(toEnvelope);
+    return { items, total, page, pageSize };
+}
+export async function getMessageByUid(accountId, uid, folderId) {
+    if (folderId != null) {
+        const key = `${accountId}:${folderId}:${uid}`;
+        return new Promise((resolve, reject) => {
+            const t = tx("messages");
+            const req = t.objectStore("messages").get(key);
+            req.onsuccess = () => resolve(req.result ? toEnvelope(req.result) : null);
+            req.onerror = () => reject(req.error);
+        });
+    }
+    // Search all folders
+    const all = await getAll("messages", "accountId", accountId);
+    const msg = all.find(m => m.uid === uid);
+    return msg ? toEnvelope(msg) : null;
+}
+export async function upsertMessage(msg) {
+    await put("messages", msg);
+}
+export async function deleteMessage(accountId, uid) {
+    const all = await getAll("messages", "accountId", accountId);
+    const msg = all.find(m => m.uid === uid);
+    if (msg)
+        await del("messages", msg.key);
+}
+export async function getHighestUid(accountId, folderId) {
+    const msgs = await getAll("messages", "folder", [accountId, folderId]);
+    return msgs.reduce((max, m) => Math.max(max, m.uid), 0);
+}
+export async function storeBody(accountId, folderId, uid, body) {
+    await put("bodies", { key: `${accountId}:${folderId}:${uid}`, body });
+}
+export async function getBody(accountId, folderId, uid) {
+    return new Promise((resolve, reject) => {
+        const t = tx("bodies");
+        const req = t.objectStore("bodies").get(`${accountId}:${folderId}:${uid}`);
+        req.onsuccess = () => resolve(req.result?.body || null);
+        req.onerror = () => reject(req.error);
+    });
+}
+export async function updateFolderCounts(folderId, total, unread) {
+    const folders = await getAll("folders");
+    const f = folders.find(f => f.id === folderId);
+    if (f) {
+        f.totalCount = total;
+        f.unreadCount = unread;
+        await put("folders", f);
+    }
+}
+export async function searchContacts(query) {
+    const q = query.toLowerCase();
+    const all = await getAll("contacts");
+    return all.filter(c => c.name.toLowerCase().includes(q) || c.email.toLowerCase().includes(q)).slice(0, 10);
+}
+export async function upsertContact(email, name, source) {
+    const existing = await new Promise((resolve, reject) => {
+        const t = tx("contacts");
+        const req = t.objectStore("contacts").get(email);
+        req.onsuccess = () => resolve(req.result);
+        req.onerror = () => reject(req.error);
+    });
+    if (existing) {
+        existing.useCount++;
+        existing.lastUsed = Date.now();
+        if (name && !existing.name)
+            existing.name = name;
+        await put("contacts", existing);
+    }
+    else {
+        await put("contacts", { email, name, source, useCount: 1, lastUsed: Date.now() });
+    }
+}
+export async function getMeta(key) {
+    return new Promise((resolve, reject) => {
+        const t = tx("meta");
+        const req = t.objectStore("meta").get(key);
+        req.onsuccess = () => resolve(req.result?.value);
+        req.onerror = () => reject(req.error);
+    });
+}
+export async function setMeta(key, value) {
+    await put("meta", { key, value });
+}
+// ── Helpers ──
+function toEnvelope(m) {
+    return {
+        accountId: m.accountId,
+        folderId: m.folderId,
+        uid: m.uid,
+        messageId: m.messageId,
+        date: m.date,
+        subject: m.subject,
+        from: { name: m.fromName, address: m.fromAddress },
+        to: JSON.parse(m.toJson || "[]"),
+        cc: JSON.parse(m.ccJson || "[]"),
+        flags: m.flags ? m.flags.split(",").filter(Boolean) : [],
+        size: m.size,
+        hasAttachments: m.hasAttachments,
+        preview: m.preview,
+        bodyPath: m.bodyPath,
+    };
+}
+//# sourceMappingURL=local-store.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/mailx",
-  "version": "1.0.74",
+  "version": "1.0.82",
   "description": "Local-first email client with IMAP sync and standalone native app",
   "type": "module",
   "main": "bin/mailx.js",
@@ -20,7 +20,7 @@
     "postinstall": "node launcher/builder/postinstall.js"
   },
   "dependencies": {
-    "@bobfrankston/iflow": "^1.0.34",
+    "@bobfrankston/iflow": "^1.0.37",
     "@bobfrankston/miscinfo": "^1.0.6",
     "@bobfrankston/oauthsupport": "^1.0.19",
     "@bobfrankston/rust-builder": "^0.1.2",

package/packages/mailx-imap/index.d.ts

@@ -25,8 +25,12 @@ export declare class ImapManager extends EventEmitter {
     private db;
     private bodyStore;
     private syncIntervals;
+    /** Track which accounts have already shown an error banner — only emit once per session */
+    private accountErrorShown;
     private syncing;
     private inboxSyncing;
+    /** Use native IMAP client instead of imapflow. Set to true to enable. */
+    useNativeClient: boolean;
     constructor(db: MailxDB);
     /** Get OAuth access token for an account (for SMTP auth) */
     getOAuthToken(accountId: string): Promise<string | null>;
@@ -38,9 +42,10 @@ export declare class ImapManager extends EventEmitter {
     deleteOnServer(accountId: string, folderPath: string, uid: number): Promise<void>;
     /** Search messages on the IMAP server — returns matching UIDs */
     searchOnServer(accountId: string, mailboxPath: string, criteria: any): Promise<number[]>;
-    /** Create a fresh ImapClient for an account (public access for API endpoints) */
-    createPublicClient(accountId: string): ImapClient;
-    /** Create a fresh ImapClient for an account (disposable, single-use) */
+    /** Create a fresh IMAP client for an account (public access for API endpoints) */
+    createPublicClient(accountId: string): any;
+    /** Create a fresh IMAP client for an account (disposable, single-use).
+     *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag. */
     private createClient;
     /** Register an account */
     addAccount(account: AccountConfig): Promise<void>;
@@ -56,6 +61,7 @@ export declare class ImapManager extends EventEmitter {
     /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
      *  If message count changed, triggers a full inbox sync. */
     private lastInboxCounts;
+    private quickCheckRunning;
     quickInboxCheck(): Promise<void>;
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes: number): void;

package/packages/mailx-imap/index.js

@@ -3,7 +3,7 @@
  * Multi-account IMAP management wrapping iflow.
  * Syncs messages to local store, emits events for new mail.
  */
-import { ImapClient, createAutoImapConfig } from "@bobfrankston/iflow";
+import { ImapClient, createAutoImapConfig, CompatImapClient, NodeTransport } from "@bobfrankston/iflow";
 import { FileMessageStore } from "@bobfrankston/mailx-store";
 import { loadSettings, getStorePath, getConfigDir } from "@bobfrankston/mailx-settings";
 import { EventEmitter } from "node:events";
@@ -65,8 +65,12 @@ export class ImapManager extends EventEmitter {
     db;
     bodyStore;
     syncIntervals = new Map();
+    /** Track which accounts have already shown an error banner — only emit once per session */
+    accountErrorShown = new Set();
     syncing = false;
     inboxSyncing = false;
+    /** Use native IMAP client instead of imapflow. Set to true to enable. */
+    useNativeClient = false;
     constructor(db) {
         super();
         this.db = db;
@@ -116,6 +120,7 @@ export class ImapManager extends EventEmitter {
             const config = this.configs.get(accountId);
             if (config?.tokenProvider) {
                 console.log(`  [reauth] ${accountId}: success`);
+                this.accountErrorShown.delete(accountId);
                 this.syncInbox().catch(() => { });
                 return true;
             }
@@ -155,17 +160,21 @@ export class ImapManager extends EventEmitter {
             catch { /* ignore */ }
         }
     }
-    /** Create a fresh ImapClient for an account (public access for API endpoints) */
+    /** Create a fresh IMAP client for an account (public access for API endpoints) */
     createPublicClient(accountId) {
         return this.createClient(accountId);
     }
-    /** Create a fresh ImapClient for an account (disposable, single-use) */
+    /** Create a fresh IMAP client for an account (disposable, single-use).
+     *  Returns CompatImapClient (native) or ImapClient (imapflow) based on useNativeClient flag. */
     createClient(accountId) {
         if (this.reauthenticating.has(accountId))
             throw new Error(`Account ${accountId} is re-authenticating`);
         const config = this.configs.get(accountId);
         if (!config)
             throw new Error(`No config for account ${accountId}`);
+        if (this.useNativeClient) {
+            return new CompatImapClient(config, () => new NodeTransport({ rejectUnauthorized: config.rejectUnauthorized !== false }));
+        }
         return new ImapClient(config);
     }
     /** Register an account */
@@ -192,7 +201,10 @@ export class ImapManager extends EventEmitter {
             }
             catch (e) {
                 console.error(`  [auth] ${account.id}: ${imapError(e)}`);
-                this.emit("accountError", account.id, imapError(e), "Re-authenticate: click the button below or run mailx -setup");
+                if (!this.accountErrorShown.has(account.id)) {
+                    this.accountErrorShown.add(account.id);
+                    this.emit("accountError", account.id, imapError(e), "Re-authenticate: click the button below or run mailx -setup");
+                }
             }
         }
     }
@@ -447,11 +459,14 @@ export class ImapManager extends EventEmitter {
             catch (e) {
                 this.emit("syncError", accountId, imapError(e));
                 console.error(`Sync error for ${accountId}: ${imapError(e)}`);
-                // Emit user-facing error — always offer re-auth for OAuth accounts
-                const config = this.configs.get(accountId);
-                const isOAuth = !!config?.tokenProvider;
-                const hint = isOAuth ? "Authentication may have expired" : "Check server connectivity";
-                this.emit("accountError", accountId, imapError(e), hint);
+                // Emit user-facing error once per account per session
+                if (!this.accountErrorShown.has(accountId)) {
+                    this.accountErrorShown.add(accountId);
+                    const config = this.configs.get(accountId);
+                    const isOAuth = !!config?.tokenProvider;
+                    const hint = isOAuth ? "Authentication may have expired" : "Check server connectivity";
+                    this.emit("accountError", accountId, imapError(e), hint);
+                }
             }
             finally {
                 if (client)
@@ -563,49 +578,58 @@ export class ImapManager extends EventEmitter {
     /** Quick inbox check — uses IMAP STATUS (single command, no mailbox open).
      *  If message count changed, triggers a full inbox sync. */
     lastInboxCounts = new Map();
+    quickCheckRunning = false;
     async quickInboxCheck() {
-        for (const [accountId] of this.configs) {
-            if (this.reauthenticating.has(accountId))
-                continue;
-            let client = null;
-            try {
-                const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
-                if (!inbox)
+        if (this.quickCheckRunning || this.syncing || this.inboxSyncing)
+            return;
+        this.quickCheckRunning = true;
+        try {
+            for (const [accountId] of this.configs) {
+                if (this.reauthenticating.has(accountId))
                     continue;
-                client = this.createClient(accountId);
-                const count = await client.getMessagesCount("INBOX");
-                await client.logout();
-                client = null;
-                const prev = this.lastInboxCounts.get(accountId) ?? count;
-                this.lastInboxCounts.set(accountId, count);
-                if (count !== prev) {
-                    console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
-                    // New mail detected — do a full inbox sync
+                let client = null;
+                try {
+                    const inbox = this.db.getFolders(accountId).find(f => f.specialUse === "inbox");
+                    if (!inbox)
+                        continue;
                     client = this.createClient(accountId);
-                    await this.syncFolder(accountId, inbox.id, client);
+                    const count = await client.getMessagesCount("INBOX");
                     await client.logout();
                     client = null;
-                }
-            }
-            catch {
-                // Lightweight check — silently ignore errors (full sync will catch up)
-            }
-            finally {
-                if (client)
-                    try {
+                    const prev = this.lastInboxCounts.get(accountId) ?? count;
+                    this.lastInboxCounts.set(accountId, count);
+                    if (count !== prev) {
+                        console.log(`  [check] ${accountId} INBOX: ${prev} → ${count}`);
+                        client = this.createClient(accountId);
+                        await this.syncFolder(accountId, inbox.id, client);
                         await client.logout();
+                        client = null;
                     }
-                    catch { /* ignore */ }
+                }
+                catch {
+                    // Lightweight check — silently ignore errors
+                }
+                finally {
+                    if (client)
+                        try {
+                            await client.logout();
+                        }
+                        catch { /* ignore */ }
+                }
             }
         }
+        finally {
+            this.quickCheckRunning = false;
+        }
     }
     /** Start periodic sync */
     startPeriodicSync(intervalMinutes) {
         this.stopPeriodicSync();
-        // Quick inbox check every 3 seconds — lightweight STATUS command
+        // Quick inbox check every 10 seconds — STATUS command is cheap but TCP setup isn't
+        // Guards prevent overlapping with full sync or inbox sync
         const quickCheck = setInterval(() => {
             this.quickInboxCheck().catch(() => { });
-        }, 3000);
+        }, 10000);
         this.syncIntervals.set("quick", quickCheck);
         // Sync actions (sends + flags/deletes/moves) every 30 seconds
         const actionsInterval = setInterval(async () => {
@@ -1064,7 +1088,7 @@ export class ImapManager extends EventEmitter {
             for (const uid of uids) {
                 // Check flags — skip if already being sent or permanently failed
                 const flags = await client.getFlags(outboxFolder.path, uid);
-                if (flags.some(f => f.startsWith("$Sending")))
+                if (flags.some((f) => f.startsWith("$Sending")))
                     continue;
                 if (flags.includes("$PermanentFailure"))
                     continue;
@@ -1076,7 +1100,7 @@ export class ImapManager extends EventEmitter {
                 await client.addFlags(outboxFolder.path, uid, [sendingFlag]);
                 // Re-check — did we win the race?
                 const flagsAfter = await client.getFlags(outboxFolder.path, uid);
-                const sendingFlags = flagsAfter.filter(f => f.startsWith("$Sending"));
+                const sendingFlags = flagsAfter.filter((f) => f.startsWith("$Sending"));
                 if (sendingFlags.length > 1 || (sendingFlags.length === 1 && sendingFlags[0] !== sendingFlag)) {
                     // Another machine claimed it — back off
                     await client.removeFlags(outboxFolder.path, uid, [sendingFlag]);

package/packages/mailx-server/index.js

@@ -57,6 +57,10 @@ if (settings.accounts.length === 0) {
 const dbDir = getConfigDir();
 const db = new MailxDB(dbDir);
 const imapManager = new ImapManager(db);
+if (process.argv.includes("--native-imap") || process.argv.includes("-native-imap")) {
+    imapManager.useNativeClient = true;
+    console.log("  Using native IMAP client (transport-agnostic)");
+}
 // ── Express App ──
 const app = express();
 app.use(express.json({ limit: "Infinity" }));

package/packages/mailx-service/index.js

@@ -342,9 +342,14 @@ export class MailxService {
         const newPath = parts.join(folder.delimiter || ".");
         const client = this.imapManager.createPublicClient(accountId);
         try {
-            await client.withConnection(async () => {
-                await client.client.mailboxRename(folder.path, newPath);
-            });
+            if (client.renameMailbox) {
+                await client.renameMailbox(folder.path, newPath);
+            }
+            else {
+                await client.withConnection(async () => {
+                    await client.client.mailboxRename(folder.path, newPath);
+                });
+            }
             await this.imapManager.syncFolders(accountId, client);
             await client.logout();
         }
@@ -361,9 +366,14 @@ export class MailxService {
             throw new Error("Folder not found");
         const client = this.imapManager.createPublicClient(accountId);
         try {
-            await client.withConnection(async () => {
-                await client.client.mailboxDelete(folder.path);
-            });
+            if (client.deleteMailbox) {
+                await client.deleteMailbox(folder.path);
+            }
+            else {
+                await client.withConnection(async () => {
+                    await client.client.mailboxDelete(folder.path);
+                });
+            }
             this.db.deleteFolder(folderId);
             await client.logout();
         }

package/android/app/build.gradle

@@ -1,54 +0,0 @@
-apply plugin: 'com.android.application'
-
-android {
-    namespace = "com.frankston.mailx"
-    compileSdk = rootProject.ext.compileSdkVersion
-    defaultConfig {
-        applicationId "com.frankston.mailx"
-        minSdkVersion rootProject.ext.minSdkVersion
-        targetSdkVersion rootProject.ext.targetSdkVersion
-        versionCode 1
-        versionName "1.0"
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
-        aaptOptions {
-             // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.
-             // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61
-            ignoreAssetsPattern = '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~'
-        }
-    }
-    buildTypes {
-        release {
-            minifyEnabled false
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-        }
-    }
-}
-
-repositories {
-    flatDir{
-        dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs'
-    }
-}
-
-dependencies {
-    implementation fileTree(include: ['*.jar'], dir: 'libs')
-    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
-    implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion"
-    implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion"
-    implementation project(':capacitor-android')
-    testImplementation "junit:junit:$junitVersion"
-    androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
-    androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
-    implementation project(':capacitor-cordova-android-plugins')
-}
-
-apply from: 'capacitor.build.gradle'
-
-try {
-    def servicesJSON = file('google-services.json')
-    if (servicesJSON.text) {
-        apply plugin: 'com.google.gms.google-services'
-    }
-} catch(Exception e) {
-    logger.info("google-services.json not found, google-services plugin not applied. Push Notifications won't work")
-}

package/android/app/capacitor.build.gradle

@@ -1,19 +0,0 @@
-// DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN
-
-android {
-  compileOptions {
-      sourceCompatibility JavaVersion.VERSION_21
-      targetCompatibility JavaVersion.VERSION_21
-  }
-}
-
-apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle"
-dependencies {
-
-
-}
-
-
-if (hasProperty('postBuildExtras')) {
-  postBuildExtras()
-}

package/android/app/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

package/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java

@@ -1,26 +0,0 @@
-package com.getcapacitor.myapp;
-
-import static org.junit.Assert.*;
-
-import android.content.Context;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-import androidx.test.platform.app.InstrumentationRegistry;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * @see <a href="http://d.android.com/tools/testing">Testing documentation</a>
- */
-@RunWith(AndroidJUnit4.class)
-public class ExampleInstrumentedTest {
-
-    @Test
-    public void useAppContext() throws Exception {
-        // Context of the app under test.
-        Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext();
-
-        assertEquals("com.getcapacitor.app", appContext.getPackageName());
-    }
-}