chore: remove error logging for errors that are propagated

Replace dual string check with single unique identifier for more precise error handling

BUILDING.md

@@ -617,7 +617,8 @@ The Electron build process follows a multi-stage approach:
 #### **Stage 2: Capacitor Sync**
 
 - Copies web assets to Electron app directory
-- Syncs Capacitor configuration and plugins
+- Uses Electron-specific Capacitor configuration (not copied from main config)
+- Syncs Capacitor plugins for Electron platform
 - Prepares native module bindings
 
 #### **Stage 3: TypeScript Compile**

electron/capacitor.config.ts

@@ -0,0 +1,116 @@
+import { CapacitorConfig } from '@capacitor/cli';
+
+const config: CapacitorConfig = {
+  appId: 'app.timesafari',
+  appName: 'TimeSafari',
+  webDir: 'dist',
+  server: {
+    cleartext: true
+  },
+  plugins: {
+    App: {
+      appUrlOpen: {
+        handlers: [
+          {
+            url: 'timesafari://*',
+            autoVerify: true
+          }
+        ]
+      }
+    },
+    SplashScreen: {
+      launchShowDuration: 3000,
+      launchAutoHide: true,
+      backgroundColor: '#ffffff',
+      androidSplashResourceName: 'splash',
+      androidScaleType: 'CENTER_CROP',
+      showSpinner: false,
+      androidSpinnerStyle: 'large',
+      iosSpinnerStyle: 'small',
+      spinnerColor: '#999999',
+      splashFullScreen: true,
+      splashImmersive: true
+    },
+    CapSQLite: {
+      iosDatabaseLocation: 'Library/CapacitorDatabase',
+      iosIsEncryption: false,
+      iosBiometric: {
+        biometricAuth: false,
+        biometricTitle: 'Biometric login for TimeSafari'
+      },
+      androidIsEncryption: false,
+      androidBiometric: {
+        biometricAuth: false,
+        biometricTitle: 'Biometric login for TimeSafari'
+      },
+      electronIsEncryption: false
+    }
+  },
+  ios: {
+    contentInset: 'never',
+    allowsLinkPreview: true,
+    scrollEnabled: true,
+    limitsNavigationsToAppBoundDomains: true,
+    backgroundColor: '#ffffff',
+    allowNavigation: [
+      '*.timesafari.app',
+      '*.jsdelivr.net',
+      'api.endorser.ch'
+    ]
+  },
+  android: {
+    allowMixedContent: true,
+    captureInput: true,
+    webContentsDebuggingEnabled: false,
+    allowNavigation: [
+      '*.timesafari.app',
+      '*.jsdelivr.net',
+      'api.endorser.ch',
+      '10.0.2.2:3000'
+    ]
+  },
+  electron: {
+    deepLinking: {
+      schemes: ['timesafari']
+    },
+    buildOptions: {
+      appId: 'app.timesafari',
+      productName: 'TimeSafari',
+      directories: {
+        output: 'dist-electron-packages'
+      },
+      files: [
+        'dist/**/*',
+        'electron/**/*'
+      ],
+      mac: {
+        category: 'public.app-category.productivity',
+        target: [
+          {
+            target: 'dmg',
+            arch: ['x64', 'arm64']
+          }
+        ]
+      },
+      win: {
+        target: [
+          {
+            target: 'nsis',
+            arch: ['x64']
+          }
+        ]
+      },
+      linux: {
+        target: [
+          {
+            target: 'AppImage',
+            arch: ['x64']
+          }
+        ],
+        category: 'Utility'
+      }
+    }
+  }
+};
+
+export default config;

electron/package-lock.json

@@ -56,7 +56,6 @@
       "version": "6.0.2",
       "resolved": "https://registry.npmjs.org/@capacitor-community/sqlite/-/sqlite-6.0.2.tgz",
       "integrity": "sha512-sj+2SPLu7E/3dM3xxcWwfNomG+aQHuN96/EFGrOtp4Dv30/2y5oIPyi6hZGjQGjPc5GDNoTQwW7vxWNzybjuMg==",
-      "license": "MIT",
       "dependencies": {
         "jeep-sqlite": "^2.7.2"
       },

electron/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compileOnSave": true,
-  "include": ["./src/**/*", "./capacitor.config.ts", "./capacitor.config.js"],
+  "include": ["./src/**/*"],
   "compilerOptions": {
     "outDir": "./build",
     "importHelpers": true,

scripts/build-electron.sh

@@ -181,7 +181,7 @@ sync_capacitor() {
 copy_web_assets() {
     log_info "Copying web assets to Electron"
     safe_execute "Copying assets" "cp -r dist/* electron/app/"
-    safe_execute "Copying config" "cp capacitor.config.json electron/capacitor.config.json"
+    # Note: Electron has its own capacitor.config.ts file, so we don't copy the main config
 }
 
 # Compile TypeScript

src/constants/notifications.ts

@@ -1689,3 +1689,11 @@ export const NOTIFY_CONTACTS_ADDED_CONFIRM = {
   title: "They're Added To Your List",
   message: "Would you like to go to the main page now?",
 };
+
+// ImportAccountView.vue specific constants
+// Used in: ImportAccountView.vue (onImportClick method - duplicate account warning)
+export const NOTIFY_DUPLICATE_ACCOUNT_IMPORT = {
+  title: "Account Already Imported",
+  message:
+    "This account has already been imported. Please use a different seed phrase or check your existing accounts.",
+};

src/libs/util.ts

@@ -614,57 +614,64 @@ export const retrieveAllAccountsMetadata = async (): Promise<
   return result;
 };
 
+export const DUPLICATE_ACCOUNT_ERROR = "Cannot import duplicate account.";
+
 /**
- * Saves a new identity to both SQL and Dexie databases
+ * Saves a new identity to SQL database
  */
 export async function saveNewIdentity(
   identity: IIdentifier,
   mnemonic: string,
   derivationPath: string,
 ): Promise<void> {
-  try {
-    // add to the new sql db
-    const platformService = await getPlatformService();
+  // add to the new sql db
+  const platformService = await getPlatformService();
 
-    const secrets = await platformService.dbQuery(
-      `SELECT secretBase64 FROM secret`,
-    );
-    if (!secrets?.values?.length || !secrets.values[0]?.length) {
-      throw new Error(
-        "No initial encryption supported. We recommend you clear your data and start over.",
-      );
-    }
+  // Check if account already exists before attempting to save
+  const existingAccount = await platformService.dbQuery(
+    "SELECT did FROM accounts WHERE did = ?",
+    [identity.did],
+  );
 
-    const secretBase64 = secrets.values[0][0] as string;
-
-    const secret = base64ToArrayBuffer(secretBase64);
-    const identityStr = JSON.stringify(identity);
-    const encryptedIdentity = await simpleEncrypt(identityStr, secret);
-    const encryptedMnemonic = await simpleEncrypt(mnemonic, secret);
-    const encryptedIdentityBase64 = arrayBufferToBase64(encryptedIdentity);
-    const encryptedMnemonicBase64 = arrayBufferToBase64(encryptedMnemonic);
-
-    const sql = `INSERT INTO accounts (dateCreated, derivationPath, did, identityEncrBase64, mnemonicEncrBase64, publicKeyHex)
-       VALUES (?, ?, ?, ?, ?, ?)`;
-    const params = [
-      new Date().toISOString(),
-      derivationPath,
-      identity.did,
-      encryptedIdentityBase64,
-      encryptedMnemonicBase64,
-      identity.keys[0].publicKeyHex,
-    ];
-    await platformService.dbExec(sql, params);
-
-    await platformService.updateDefaultSettings({ activeDid: identity.did });
-
-    await platformService.insertNewDidIntoSettings(identity.did);
-  } catch (error) {
-    logger.error("Failed to update default settings:", error);
+  if (existingAccount?.values?.length) {
     throw new Error(
-      "Failed to set default settings. Please try again or restart the app.",
+      `Account with DID ${identity.did} already exists. ${DUPLICATE_ACCOUNT_ERROR}`,
     );
   }
+
+  const secrets = await platformService.dbQuery(
+    `SELECT secretBase64 FROM secret`,
+  );
+  if (!secrets?.values?.length || !secrets.values[0]?.length) {
+    throw new Error(
+      "No initial encryption supported. We recommend you clear your data and start over.",
+    );
+  }
+
+  const secretBase64 = secrets.values[0][0] as string;
+
+  const secret = base64ToArrayBuffer(secretBase64);
+  const identityStr = JSON.stringify(identity);
+  const encryptedIdentity = await simpleEncrypt(identityStr, secret);
+  const encryptedMnemonic = await simpleEncrypt(mnemonic, secret);
+  const encryptedIdentityBase64 = arrayBufferToBase64(encryptedIdentity);
+  const encryptedMnemonicBase64 = arrayBufferToBase64(encryptedMnemonic);
+
+  const sql = `INSERT INTO accounts (dateCreated, derivationPath, did, identityEncrBase64, mnemonicEncrBase64, publicKeyHex)
+      VALUES (?, ?, ?, ?, ?, ?)`;
+  const params = [
+    new Date().toISOString(),
+    derivationPath,
+    identity.did,
+    encryptedIdentityBase64,
+    encryptedMnemonicBase64,
+    identity.keys[0].publicKeyHex,
+  ];
+  await platformService.dbExec(sql, params);
+
+  await platformService.updateDefaultSettings({ activeDid: identity.did });
+
+  await platformService.insertNewDidIntoSettings(identity.did);
 }
 
 /**
@@ -1032,3 +1039,58 @@ export async function importFromMnemonic(
     }
   }
 }
+
+/**
+ * Checks if an account with the given DID already exists in the database
+ *
+ * @param did - The DID to check for duplicates
+ * @returns Promise<boolean> - True if account already exists, false otherwise
+ * @throws Error if database query fails
+ */
+export async function checkForDuplicateAccount(did: string): Promise<boolean>;
+
+/**
+ * Checks if an account with the given DID already exists in the database
+ *
+ * @param mnemonic - The mnemonic phrase to derive DID from
+ * @param derivationPath - The derivation path to use
+ * @returns Promise<boolean> - True if account already exists, false otherwise
+ * @throws Error if database query fails
+ */
+export async function checkForDuplicateAccount(
+  mnemonic: string,
+  derivationPath: string,
+): Promise<boolean>;
+
+/**
+ * Implementation of checkForDuplicateAccount with overloaded signatures
+ */
+export async function checkForDuplicateAccount(
+  didOrMnemonic: string,
+  derivationPath?: string,
+): Promise<boolean> {
+  let didToCheck: string;
+
+  if (derivationPath) {
+    // Derive the DID from mnemonic and derivation path
+    const [address, privateHex, publicHex] = deriveAddress(
+      didOrMnemonic.trim().toLowerCase(),
+      derivationPath,
+    );
+
+    const newId = newIdentifier(address, privateHex, publicHex, derivationPath);
+    didToCheck = newId.did;
+  } else {
+    // Use the provided DID directly
+    didToCheck = didOrMnemonic;
+  }
+
+  // Check if an account with this DID already exists
+  const platformService = await getPlatformService();
+  const existingAccount = await platformService.dbQuery(
+    "SELECT did FROM accounts WHERE did = ?",
+    [didToCheck],
+  );
+
+  return (existingAccount?.values?.length ?? 0) > 0;
+}

src/views/ImportAccountView.vue

@@ -88,9 +88,15 @@ import { Router } from "vue-router";
 
 import { AppString, NotificationIface } from "../constants/app";
 import { DEFAULT_ROOT_DERIVATION_PATH } from "../libs/crypto";
-import { retrieveAccountCount, importFromMnemonic } from "../libs/util";
+import {
+  retrieveAccountCount,
+  importFromMnemonic,
+  checkForDuplicateAccount,
+  DUPLICATE_ACCOUNT_ERROR,
+} from "../libs/util";
 import { PlatformServiceMixin } from "@/utils/PlatformServiceMixin";
 import { createNotifyHelpers, TIMEOUTS } from "@/utils/notify";
+import { NOTIFY_DUPLICATE_ACCOUNT_IMPORT } from "@/constants/notifications";
 
 /**
  * Import Account View Component
@@ -198,6 +204,19 @@ export default class ImportAccountView extends Vue {
     }
 
     try {
+      // Check for duplicate account before importing
+      const isDuplicate = await checkForDuplicateAccount(
+        this.mnemonic,
+        this.derivationPath,
+      );
+      if (isDuplicate) {
+        this.notify.warning(
+          NOTIFY_DUPLICATE_ACCOUNT_IMPORT.message,
+          TIMEOUTS.LONG,
+        );
+        return;
+      }
+
       await importFromMnemonic(
         this.mnemonic,
         this.derivationPath,
@@ -223,9 +242,20 @@ export default class ImportAccountView extends Vue {
       this.$router.push({ name: "account" });
     } catch (error: unknown) {
       this.$logError("Import failed: " + error);
+
+      // Check if this is a duplicate account error from saveNewIdentity
+      const errorMessage =
+        error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes(DUPLICATE_ACCOUNT_ERROR)) {
+        this.notify.warning(
+          NOTIFY_DUPLICATE_ACCOUNT_IMPORT.message,
+          TIMEOUTS.LONG,
+        );
+        return;
+      }
+
       this.notify.error(
-        (error instanceof Error ? error.message : String(error)) ||
-          "Failed to import account.",
+        errorMessage || "Failed to import account.",
         TIMEOUTS.LONG,
       );
     }

src/views/ImportDerivedAccountView.vue

@@ -83,6 +83,7 @@ import {
   retrieveAllAccountsMetadata,
   retrieveFullyDecryptedAccount,
   saveNewIdentity,
+  checkForDuplicateAccount,
 } from "../libs/util";
 import { logger } from "../utils/logger";
 import { Account, AccountEncrypted } from "../db/tables/accounts";
@@ -171,6 +172,16 @@ export default class ImportAccountView extends Vue {
     const newId = newIdentifier(address, publicHex, privateHex, newDerivPath);
 
     try {
+      // Check for duplicate account before creating
+      const isDuplicate = await checkForDuplicateAccount(newId.did);
+      if (isDuplicate) {
+        this.notify.warning(
+          "This derived account already exists. Please try a different derivation path.",
+          TIMEOUTS.LONG,
+        );
+        return;
+      }
+
       await saveNewIdentity(newId, mne, newDerivPath);
 
       // record that as the active DID

test-playwright/03-duplicate-import-test.spec.ts

@@ -0,0 +1,63 @@
+import { test, expect } from '@playwright/test';
+import { importUserFromAccount, getTestUserData } from './testUtils';
+import { NOTIFY_DUPLICATE_ACCOUNT_IMPORT } from '../src/constants/notifications';
+
+/**
+ * Test duplicate account import functionality
+ * 
+ * This test verifies that:
+ * 1. A user can successfully import an account the first time
+ * 2. Attempting to import the same account again shows a warning message
+ * 3. The duplicate import is prevented
+ */
+test.describe('Duplicate Account Import', () => {
+  test('should prevent importing the same account twice', async ({ page }) => {
+    const userData = getTestUserData("00");
+    
+    // First import - should succeed
+    await page.goto("./start");
+    await page.getByText("You have a seed").click();
+    await page.getByPlaceholder("Seed Phrase").fill(userData.seedPhrase);
+    await page.getByRole("button", { name: "Import" }).click();
+    
+    // Verify first import was successful
+    await expect(page.getByRole("code")).toContainText(userData.did);
+    
+    // Navigate back to start page for second import attempt
+    await page.goto("./start");
+    await page.getByText("You have a seed").click();
+    await page.getByPlaceholder("Seed Phrase").fill(userData.seedPhrase);
+    await page.getByRole("button", { name: "Import" }).click();
+    
+    // Verify duplicate import shows warning message
+    // The warning can appear either from the pre-check or from the saveNewIdentity error handling
+    await expect(page.getByText(NOTIFY_DUPLICATE_ACCOUNT_IMPORT.message)).toBeVisible();
+    
+    // Verify we're still on the import page (not redirected to account)
+    await expect(page.getByPlaceholder("Seed Phrase")).toBeVisible();
+  });
+
+  test('should allow importing different accounts', async ({ page }) => {
+    const userZeroData = getTestUserData("00");
+    const userOneData = getTestUserData("01");
+    
+    // Import first user
+    await page.goto("./start");
+    await page.getByText("You have a seed").click();
+    await page.getByPlaceholder("Seed Phrase").fill(userZeroData.seedPhrase);
+    await page.getByRole("button", { name: "Import" }).click();
+    
+    // Verify first import was successful
+    await expect(page.getByRole("code")).toContainText(userZeroData.did);
+    
+    // Navigate back to start page for second user import
+    await page.goto("./start");
+    await page.getByText("You have a seed").click();
+    await page.getByPlaceholder("Seed Phrase").fill(userOneData.seedPhrase);
+    await page.getByRole("button", { name: "Import" }).click();
+    
+    // Verify second import was successful (should not show duplicate warning)
+    await expect(page.getByRole("code")).toContainText(userOneData.did);
+    await expect(page.getByText(NOTIFY_DUPLICATE_ACCOUNT_IMPORT.message)).not.toBeVisible();
+  });
+});