Add browser best match option

browser/extension/background.js

@@ -4,9 +4,7 @@ const isNodeTestEnv = typeof module !== "undefined" && module.exports;
 const usePromiseAPI = typeof globalThis.browser !== "undefined";
 const defaultSettings = {
   bearerToken: "",
-  bestMatchOnly: false,
-  requireSchemeMatch: false,
-  sortResults: "quality"
+  bestMatchOnly: false
 };
 const pageStatePrefix = "keepassgo-page-state:";
 const matchCacheTTL = 30 * 1000;
@@ -176,20 +174,13 @@ function connectNative(message) {
 }
 
 async function loadSettings() {
-  const stored = await storageGet(["bearerToken", "bestMatchOnly", "requireSchemeMatch", "sortResults"]);
-  const sortResults = normalizeSortResults(stored.sortResults);
+  const stored = await storageGet(["bearerToken", "bestMatchOnly"]);
   return {
     bearerToken: (stored.bearerToken || defaultSettings.bearerToken).trim(),
-    bestMatchOnly: Boolean(stored.bestMatchOnly ?? defaultSettings.bestMatchOnly),
-    requireSchemeMatch: Boolean(stored.requireSchemeMatch ?? defaultSettings.requireSchemeMatch),
-    sortResults
+    bestMatchOnly: Boolean(stored.bestMatchOnly ?? defaultSettings.bestMatchOnly)
   };
 }
 
-function normalizeSortResults(value) {
-  return ["quality", "title", "path"].includes(value) ? value : defaultSettings.sortResults;
-}
-
 function supportsPageStateURL(rawURL) {
   return typeof rawURL === "string" && /^https?:\/\//i.test(rawURL);
 }
@@ -249,21 +240,6 @@ function matchHost(rawURL) {
   }
 }
 
-function matchScheme(rawURL) {
-  if (typeof rawURL !== "string") {
-    return "";
-  }
-  const trimmed = rawURL.trim();
-  if (!trimmed) {
-    return "";
-  }
-  try {
-    return new URL(trimmed).protocol.toLowerCase();
-  } catch (_error) {
-    return "";
-  }
-}
-
 function qualityRank(quality) {
   switch (String(quality || "").trim().toLowerCase()) {
     case "exact":
@@ -277,67 +253,17 @@ function qualityRank(quality) {
   }
 }
 
-function compareMatchText(left, right) {
-  return String(left || "").localeCompare(String(right || ""), undefined, { sensitivity: "base" });
-}
-
-function sortMatches(matches, sortResults) {
-  const sorted = [...matches];
-  switch (normalizeSortResults(sortResults)) {
-    case "title":
-      sorted.sort((left, right) =>
-        compareMatchText(left?.title, right?.title) ||
-        compareMatchText(left?.username, right?.username) ||
-        compareMatchText(left?.path?.join("/"), right?.path?.join("/"))
-      );
-      return sorted;
-    case "path":
-      sorted.sort((left, right) =>
-        compareMatchText(left?.path?.join("/"), right?.path?.join("/")) ||
-        compareMatchText(left?.title, right?.title) ||
-        compareMatchText(left?.username, right?.username)
-      );
-      return sorted;
-    default:
-      sorted.sort((left, right) =>
-        qualityRank(left?.quality) - qualityRank(right?.quality) ||
-        compareMatchText(left?.title, right?.title) ||
-        compareMatchText(left?.username, right?.username)
-      );
-      return sorted;
+function applyBestMatchOnly(matches, enabled) {
+  if (!Array.isArray(matches) || !enabled) {
+    return Array.isArray(matches) ? [...matches] : [];
   }
-}
-
-function filterSchemeMatches(matches, pageURL) {
-  const pageScheme = matchScheme(pageURL);
-  if (!pageScheme) {
-    return [...matches];
-  }
-  return matches.filter((match) => {
-    const entryScheme = matchScheme(match?.url);
-    return !entryScheme || entryScheme === pageScheme;
-  });
-}
-
-function filterBestQuality(matches) {
-  if (!Array.isArray(matches) || matches.length === 0) {
+  if (matches.length === 0) {
     return [];
   }
   const bestRank = Math.min(...matches.map((match) => qualityRank(match?.quality)));
   return matches.filter((match) => qualityRank(match?.quality) === bestRank);
 }
 
-function applyMatchControls(matches, settings, pageURL) {
-  let filtered = Array.isArray(matches) ? [...matches] : [];
-  if (settings?.requireSchemeMatch) {
-    filtered = filterSchemeMatches(filtered, pageURL);
-  }
-  if (settings?.bestMatchOnly) {
-    filtered = filterBestQuality(filtered);
-  }
-  return sortMatches(filtered, settings?.sortResults);
-}
-
 function defaultObservedTitle(observed) {
   if (observed?.title) {
     return observed.title;
@@ -723,11 +649,6 @@ async function refreshPageState(tabId, pageUrl, options = {}) {
       bearerToken: settings.bearerToken,
       url: resolvedURL
     });
-    const filteredMatches = applyMatchControls(
-      Array.isArray(matches?.matches) ? matches.matches : [],
-      settings,
-      resolvedURL
-    );
 
     state = {
       ...state,
@@ -737,7 +658,7 @@ async function refreshPageState(tabId, pageUrl, options = {}) {
       pendingMessage: tokenPendingApprovalCount(matches?.status ?? state.status) > 0
         ? approvalHintForState(state) || "Approve or deny the browser fill request in KeePassGO."
         : "",
-      matches: filteredMatches,
+      matches: applyBestMatchOnly(matches?.matches, settings.bestMatchOnly),
       error: matches?.error ?? "",
       updatedAt: Date.now()
     };
@@ -918,7 +839,7 @@ async function saveObservedLogin(tabId, selectedMatch = null) {
 }
 
 const backgroundTestExports = {
-  applyMatchControls,
+  applyBestMatchOnly,
   normalizePageState,
   actionPresentationForState,
   shouldReuseMatches,
@@ -960,30 +881,22 @@ if (isNodeTestEnv) {
         case "keepassgo-save-settings":
           await storageSet({
             bearerToken: String(message.settings?.bearerToken || "").trim(),
-            bestMatchOnly: Boolean(message.settings?.bestMatchOnly),
-            requireSchemeMatch: Boolean(message.settings?.requireSchemeMatch),
-            sortResults: normalizeSortResults(message.settings?.sortResults)
+            bestMatchOnly: Boolean(message.settings?.bestMatchOnly)
           });
           await refreshActivePage({ force: true }).catch(() => null);
           sendResponse({ success: true });
           return;
         case "keepassgo-search-logins": {
           const settings = await loadSettings();
-          const page = await activePageContext();
           const response = await connectNative({
             action: "search-logins",
             bearerToken: settings.bearerToken,
             query: String(message?.query || "").trim()
           });
-          const searchResults = applyMatchControls(
-            Array.isArray(response?.searchResults) ? response.searchResults : [],
-            settings,
-            page.url
-          );
           sendResponse({
             success: Boolean(response?.success),
             error: response?.error || "",
-            results: searchResults,
+            results: applyBestMatchOnly(response?.searchResults, settings.bestMatchOnly),
             status: response?.status ?? null
           });
           return;

browser/extension/background.test.cjs

@@ -70,8 +70,6 @@ test("shouldContinueWatchingState keeps polling locked login pages", () => {
 test("default settings include a blank bearer token that can be overridden by harness patching", () => {
   assert.equal(background.defaultSettings.bearerToken, "");
   assert.equal(background.defaultSettings.bestMatchOnly, false);
-  assert.equal(background.defaultSettings.requireSchemeMatch, false);
-  assert.equal(background.defaultSettings.sortResults, "quality");
 });
 
 test("savePlanForObservedLogin prefers updating an exact username match", () => {
@@ -133,44 +131,21 @@ test("savePlanForObservedLogin falls back to saving into the current page group"
   });
 });
 
-test("applyMatchControls keeps only the strongest quality band when best-match-only is enabled", () => {
-  const filtered = background.applyMatchControls([
+test("applyBestMatchOnly keeps only the strongest quality band when enabled", () => {
+  const filtered = background.applyBestMatchOnly([
     { id: "livingston", title: "Livingston Dell", quality: "exact" },
     { id: "rusty", title: "Rusty Ryan", quality: "host" },
     { id: "linus", title: "Linus Caldwell", quality: "scheme" }
-  ], {
-    bestMatchOnly: true,
-    requireSchemeMatch: false,
-    sortResults: "quality"
-  }, "https://vault.example.invalid/login");
+  ], true);
 
   assert.deepEqual(filtered.map((match) => match.id), ["livingston"]);
 });
 
-test("applyMatchControls removes explicit scheme mismatches but keeps scheme-less matches", () => {
-  const filtered = background.applyMatchControls([
-    { id: "yen", title: "The Amazing Yen", url: "https://vault.example.invalid/login", quality: "exact" },
-    { id: "saul", title: "Saul Bloom", url: "http://vault.example.invalid/login", quality: "exact" },
-    { id: "basher", title: "Basher Tarr", url: "vault.example.invalid", quality: "host" }
-  ], {
-    bestMatchOnly: false,
-    requireSchemeMatch: true,
-    sortResults: "quality"
-  }, "https://vault.example.invalid/login");
+test("applyBestMatchOnly preserves all matches when disabled", () => {
+  const filtered = background.applyBestMatchOnly([
+    { id: "livingston", title: "Livingston Dell", quality: "exact" },
+    { id: "rusty", title: "Rusty Ryan", quality: "host" }
+  ], false);
 
-  assert.deepEqual(filtered.map((match) => match.id), ["yen", "basher"]);
-});
-
-test("applyMatchControls sorts by path when requested", () => {
-  const filtered = background.applyMatchControls([
-    { id: "linus", title: "Linus Caldwell", path: ["Crew", "Inside"] },
-    { id: "rusty", title: "Rusty Ryan", path: ["Crew", "Casino"] },
-    { id: "danny", title: "Danny Ocean", path: ["Crew"] }
-  ], {
-    bestMatchOnly: false,
-    requireSchemeMatch: false,
-    sortResults: "path"
-  }, "https://vault.example.invalid/login");
-
-  assert.deepEqual(filtered.map((match) => match.id), ["danny", "rusty", "linus"]);
+  assert.deepEqual(filtered.map((match) => match.id), ["livingston", "rusty"]);
 });

browser/extension/options.html

@@ -25,18 +25,6 @@
           <input id="best-match-only" name="best-match-only" type="checkbox">
           <span>Best match only</span>
         </label>
-        <label class="checkbox-row">
-          <input id="require-scheme-match" name="require-scheme-match" type="checkbox">
-          <span>Require current scheme</span>
-        </label>
-        <label>
-          <span>Sort results</span>
-          <select id="sort-results" name="sort-results">
-            <option value="quality">KeePassGO match quality</option>
-            <option value="title">Title</option>
-            <option value="path">Path</option>
-          </select>
-        </label>
       </fieldset>
       <div class="actions">
         <button type="submit">Save</button>

browser/extension/options.js

@@ -24,8 +24,6 @@ async function loadSettings() {
   }
   document.getElementById("bearer-token").value = response.settings.bearerToken || "";
   document.getElementById("best-match-only").checked = Boolean(response.settings.bestMatchOnly);
-  document.getElementById("require-scheme-match").checked = Boolean(response.settings.requireSchemeMatch);
-  document.getElementById("sort-results").value = response.settings.sortResults || "quality";
 }
 
 async function saveSettings(event) {
@@ -37,9 +35,7 @@ async function saveSettings(event) {
       type: "keepassgo-save-settings",
       settings: {
         bearerToken: document.getElementById("bearer-token").value,
-        bestMatchOnly: document.getElementById("best-match-only").checked,
-        requireSchemeMatch: document.getElementById("require-scheme-match").checked,
-        sortResults: document.getElementById("sort-results").value
+        bestMatchOnly: document.getElementById("best-match-only").checked
       }
     });
     if (!response?.success) {

browser/extension/style.css

@@ -177,8 +177,7 @@ label {
 }
 
 input,
-textarea,
-select {
+textarea {
   width: 100%;
   padding: 10px 12px;
   border: 1px solid var(--line);

docs/browser-extension.md

@@ -103,9 +103,8 @@ User story:
   access.
 - Browser matching must treat common KeePass data conventions as real browser
   targets, not just the primary `URL` field.
-- Users need explicit control over how aggressive browser matching should be so
-  they can prefer narrow page suggestions or broader candidate lists without
-  reconfiguring KeePassGO itself.
+- Users who prefer narrow suggestions can ask the extension to show only the
+  strongest match quality returned by KeePassGO.
 
 Expected behavior:
 
@@ -117,20 +116,9 @@ Expected behavior:
   - scheme-less host values such as `gitlab.com`
   - custom URL fields such as `URL1`, `URL2`, and similar KeePass-style URL
     slots
-- The extension settings page exposes browser match controls for:
-  - `Best match only`
-  - `Require current scheme`
-  - `Sort results`
-- `Best match only` limits page suggestions to the strongest quality band
-  returned by KeePassGO instead of showing every candidate for the host.
-- `Require current scheme` hides `http` credentials on `https` pages and
-  vice versa when an entry stores an explicit scheme, while still allowing
-  scheme-less host entries to match either page.
-- `Sort results` affects both page suggestions and popup search results so the
-  user can prefer:
-  - KeePassGO match quality first
-  - title order
-  - path order
+- The extension settings page exposes `Best match only`.
+- When `Best match only` is enabled, page suggestions and popup search results
+  only show the strongest quality band returned by KeePassGO.
 
 ## Locked Vault Workflow