[PM-5560] Implement Autofill Settings state provider (#7767)

* Begin migration of autofill settings Co-authored-by: Cesar Gonzalez <cagonzalezcs@users.noreply.github.com> Co-authored-by: Thomas Avery <Thomas-Avery@users.noreply.github.com> Co-authored-by: Jonathan Prusik <jprusik@users.noreply.github.com> Co-authored-by: Colton Hurst <coltonhurst@users.noreply.github.com> * add browser dependency for AutofillSettingsService Co-authored-by: Matt Gibson <mgibson@bitwarden.com> * update autofill settings service * replace usages of stateService get/set autofillOnPageLoad with autofillSettingsService * replace usages of stateService get/set autofillOnPageLoadDefault with autofillSettingsService * replace usages of stateService get/set autoCopyTotp with autofillSettingsService * replace usages of stateService get/set autoFillOnPageLoadCalloutIsDismissed with autofillSettingsService * replace usages of stateService get/set activateAutoFillOnPageLoadFromPolicy with autofillSettingsService * replace usages of get/set autoFillOverlayVisibility with autofillSettingsService * inlineMenuVisibility should use global state * add the AutofillSettingsService to background scripts * fix typing * replace additional usages of get/set autoFillOverlayVisibility and disableAutoTotpCopy with autofillSettingsService equivalents * replace additional usages of get/set autofillOnPageLoadDefault with autofillSettingsService equivalent * replace additional usages of get/set activateAutoFillOnPageLoadFromPolicy with autofillSettingsService equivalent * remove additional deprecated and unused state service calls * improve naming conventions and consistency * fix missing mock for policy service test * replace missing overlay background tests * cleanup * fix double inversion * fix reference to wrong setter * move handleActivateAutofillPolicy out of BrowserPolicyService * create state migration script * resolve linting issues * remove migrated setting properties * add AutofillSettingsSErvice to jslib-services * handle conditional content script loading via autofillOnPageLoad check * add deprecated note to getFromLocalStorage * add jsdoc decorators to new autofill service methods * handle undefined globalState * move autofill settings out of BrowserPolicyService * Move autofill settings code out of policyService * fix tests * fix typo in state definition --------- Co-authored-by: Matt Gibson <mgibson@bitwarden.com> Co-authored-by: Cesar Gonzalez <cagonzalezcs@users.noreply.github.com> Co-authored-by: Thomas Avery <Thomas-Avery@users.noreply.github.com> Co-authored-by: Colton Hurst <coltonhurst@users.noreply.github.com> Co-authored-by: Thomas Rittson <trittson@bitwarden.com>
2025-12-15 07:43:35 +00:00 · 2024-02-12 17:11:04 -05:00
parent bf16682f42
commit c65e92f769
34 changed files with 975 additions and 306 deletions
--- a/libs/common/src/abstractions/settings.service.ts
+++ b/libs/common/src/abstractions/settings.service.ts
@@ -10,7 +10,5 @@ export abstract class SettingsService {
  getEquivalentDomains: (url: string) => Set<string>;
  setDisableFavicon: (value: boolean) => Promise<any>;
  getDisableFavicon: () => boolean;
-  setAutoFillOverlayVisibility: (value: number) => Promise<void>;
-  getAutoFillOverlayVisibility: () => Promise<number>;
  clear: (userId?: string) => Promise<void>;
 }
--- a/libs/common/src/admin-console/services/policy/policy.service.spec.ts
+++ b/libs/common/src/admin-console/services/policy/policy.service.spec.ts
@@ -1,22 +1,22 @@
 import { mock, MockProxy } from "jest-mock-extended";
 import { BehaviorSubject, firstValueFrom } from "rxjs";

-import { OrganizationService } from "../admin-console/abstractions/organization/organization.service.abstraction";
-import { OrganizationUserStatusType, PolicyType } from "../admin-console/enums";
-import { PermissionsApi } from "../admin-console/models/api/permissions.api";
-import { OrganizationData } from "../admin-console/models/data/organization.data";
-import { PolicyData } from "../admin-console/models/data/policy.data";
-import { MasterPasswordPolicyOptions } from "../admin-console/models/domain/master-password-policy-options";
-import { Organization } from "../admin-console/models/domain/organization";
-import { Policy } from "../admin-console/models/domain/policy";
-import { ResetPasswordPolicyOptions } from "../admin-console/models/domain/reset-password-policy-options";
-import { PolicyResponse } from "../admin-console/models/response/policy.response";
-import { PolicyService } from "../admin-console/services/policy/policy.service";
-import { ListResponse } from "../models/response/list.response";
-import { CryptoService } from "../platform/abstractions/crypto.service";
-import { EncryptService } from "../platform/abstractions/encrypt.service";
-import { ContainerService } from "../platform/services/container.service";
-import { StateService } from "../platform/services/state.service";
+import { OrganizationService } from "../../../admin-console/abstractions/organization/organization.service.abstraction";
+import { OrganizationUserStatusType, PolicyType } from "../../../admin-console/enums";
+import { PermissionsApi } from "../../../admin-console/models/api/permissions.api";
+import { OrganizationData } from "../../../admin-console/models/data/organization.data";
+import { PolicyData } from "../../../admin-console/models/data/policy.data";
+import { MasterPasswordPolicyOptions } from "../../../admin-console/models/domain/master-password-policy-options";
+import { Organization } from "../../../admin-console/models/domain/organization";
+import { Policy } from "../../../admin-console/models/domain/policy";
+import { ResetPasswordPolicyOptions } from "../../../admin-console/models/domain/reset-password-policy-options";
+import { PolicyResponse } from "../../../admin-console/models/response/policy.response";
+import { PolicyService } from "../../../admin-console/services/policy/policy.service";
+import { ListResponse } from "../../../models/response/list.response";
+import { CryptoService } from "../../../platform/abstractions/crypto.service";
+import { EncryptService } from "../../../platform/abstractions/encrypt.service";
+import { ContainerService } from "../../../platform/services/container.service";
+import { StateService } from "../../../platform/services/state.service";

 describe("PolicyService", () => {
  let policyService: PolicyService;
--- a/libs/common/src/autofill/services/autofill-settings.service.ts
+++ b/libs/common/src/autofill/services/autofill-settings.service.ts
@@ -0,0 +1,174 @@
+import { filter, switchMap, tap, firstValueFrom, map, Observable } from "rxjs";
+
+import {
+  AutofillOverlayVisibility,
+  InlineMenuVisibilitySetting,
+} from "../../../../../apps/browser/src/autofill/utils/autofill-overlay.enum";
+import { PolicyService } from "../../admin-console/abstractions/policy/policy.service.abstraction";
+import { PolicyType } from "../../admin-console/enums/index";
+import { Policy } from "../../admin-console/models/domain/policy";
+import {
+  AUTOFILL_SETTINGS_DISK,
+  AUTOFILL_SETTINGS_DISK_LOCAL,
+  ActiveUserState,
+  GlobalState,
+  KeyDefinition,
+  StateProvider,
+} from "../../platform/state";
+
+const AUTOFILL_ON_PAGE_LOAD = new KeyDefinition(AUTOFILL_SETTINGS_DISK, "autofillOnPageLoad", {
+  deserializer: (value: boolean) => value ?? false,
+});
+
+const AUTOFILL_ON_PAGE_LOAD_DEFAULT = new KeyDefinition(
+  AUTOFILL_SETTINGS_DISK,
+  "autofillOnPageLoadDefault",
+  {
+    deserializer: (value: boolean) => value ?? false,
+  },
+);
+
+const AUTO_COPY_TOTP = new KeyDefinition(AUTOFILL_SETTINGS_DISK, "autoCopyTotp", {
+  deserializer: (value: boolean) => value ?? false,
+});
+
+const AUTOFILL_ON_PAGE_LOAD_CALLOUT_DISMISSED = new KeyDefinition(
+  AUTOFILL_SETTINGS_DISK,
+  "autofillOnPageLoadCalloutIsDismissed",
+  {
+    deserializer: (value: boolean) => value ?? false,
+  },
+);
+
+const ACTIVATE_AUTOFILL_ON_PAGE_LOAD_FROM_POLICY = new KeyDefinition(
+  AUTOFILL_SETTINGS_DISK_LOCAL,
+  "activateAutofillOnPageLoadFromPolicy",
+  {
+    deserializer: (value: boolean) => value ?? false,
+  },
+);
+
+const INLINE_MENU_VISIBILITY = new KeyDefinition(
+  AUTOFILL_SETTINGS_DISK_LOCAL,
+  "inlineMenuVisibility",
+  {
+    deserializer: (value: InlineMenuVisibilitySetting) => value ?? AutofillOverlayVisibility.Off,
+  },
+);
+
+export abstract class AutofillSettingsServiceAbstraction {
+  autofillOnPageLoad$: Observable<boolean>;
+  setAutofillOnPageLoad: (newValue: boolean) => Promise<void>;
+  autofillOnPageLoadDefault$: Observable<boolean>;
+  setAutofillOnPageLoadDefault: (newValue: boolean) => Promise<void>;
+  autoCopyTotp$: Observable<boolean>;
+  setAutoCopyTotp: (newValue: boolean) => Promise<void>;
+  autofillOnPageLoadCalloutIsDismissed$: Observable<boolean>;
+  setAutofillOnPageLoadCalloutIsDismissed: (newValue: boolean) => Promise<void>;
+  activateAutofillOnPageLoadFromPolicy$: Observable<boolean>;
+  setActivateAutofillOnPageLoadFromPolicy: (newValue: boolean) => Promise<void>;
+  inlineMenuVisibility$: Observable<InlineMenuVisibilitySetting>;
+  setInlineMenuVisibility: (newValue: InlineMenuVisibilitySetting) => Promise<void>;
+  handleActivateAutofillPolicy: (policies: Observable<Policy[]>) => Observable<boolean[]>;
+}
+
+export class AutofillSettingsService implements AutofillSettingsServiceAbstraction {
+  private autofillOnPageLoadState: ActiveUserState<boolean>;
+  readonly autofillOnPageLoad$: Observable<boolean>;
+
+  private autofillOnPageLoadDefaultState: ActiveUserState<boolean>;
+  readonly autofillOnPageLoadDefault$: Observable<boolean>;
+
+  private autoCopyTotpState: ActiveUserState<boolean>;
+  readonly autoCopyTotp$: Observable<boolean>;
+
+  private autofillOnPageLoadCalloutIsDismissedState: ActiveUserState<boolean>;
+  readonly autofillOnPageLoadCalloutIsDismissed$: Observable<boolean>;
+
+  private activateAutofillOnPageLoadFromPolicyState: ActiveUserState<boolean>;
+  readonly activateAutofillOnPageLoadFromPolicy$: Observable<boolean>;
+
+  private inlineMenuVisibilityState: GlobalState<InlineMenuVisibilitySetting>;
+  readonly inlineMenuVisibility$: Observable<InlineMenuVisibilitySetting>;
+
+  constructor(
+    private stateProvider: StateProvider,
+    policyService: PolicyService,
+  ) {
+    this.autofillOnPageLoadState = this.stateProvider.getActive(AUTOFILL_ON_PAGE_LOAD);
+    this.autofillOnPageLoad$ = this.autofillOnPageLoadState.state$.pipe(map((x) => x ?? false));
+
+    this.autofillOnPageLoadDefaultState = this.stateProvider.getActive(
+      AUTOFILL_ON_PAGE_LOAD_DEFAULT,
+    );
+    this.autofillOnPageLoadDefault$ = this.autofillOnPageLoadDefaultState.state$.pipe(
+      map((x) => x ?? true),
+    );
+
+    this.autoCopyTotpState = this.stateProvider.getActive(AUTO_COPY_TOTP);
+    this.autoCopyTotp$ = this.autoCopyTotpState.state$.pipe(map((x) => x ?? false));
+
+    this.autofillOnPageLoadCalloutIsDismissedState = this.stateProvider.getActive(
+      AUTOFILL_ON_PAGE_LOAD_CALLOUT_DISMISSED,
+    );
+    this.autofillOnPageLoadCalloutIsDismissed$ =
+      this.autofillOnPageLoadCalloutIsDismissedState.state$.pipe(map((x) => x ?? false));
+
+    this.activateAutofillOnPageLoadFromPolicyState = this.stateProvider.getActive(
+      ACTIVATE_AUTOFILL_ON_PAGE_LOAD_FROM_POLICY,
+    );
+    this.activateAutofillOnPageLoadFromPolicy$ =
+      this.activateAutofillOnPageLoadFromPolicyState.state$.pipe(map((x) => x ?? false));
+
+    this.inlineMenuVisibilityState = this.stateProvider.getGlobal(INLINE_MENU_VISIBILITY);
+    this.inlineMenuVisibility$ = this.inlineMenuVisibilityState.state$.pipe(
+      map((x) => x ?? AutofillOverlayVisibility.Off),
+    );
+
+    policyService.policies$.pipe(this.handleActivateAutofillPolicy.bind(this)).subscribe();
+  }
+
+  async setAutofillOnPageLoad(newValue: boolean): Promise<void> {
+    await this.autofillOnPageLoadState.update(() => newValue);
+  }
+
+  async setAutofillOnPageLoadDefault(newValue: boolean): Promise<void> {
+    await this.autofillOnPageLoadDefaultState.update(() => newValue);
+  }
+
+  async setAutoCopyTotp(newValue: boolean): Promise<void> {
+    await this.autoCopyTotpState.update(() => newValue);
+  }
+
+  async setAutofillOnPageLoadCalloutIsDismissed(newValue: boolean): Promise<void> {
+    await this.autofillOnPageLoadCalloutIsDismissedState.update(() => newValue);
+  }
+
+  async setActivateAutofillOnPageLoadFromPolicy(newValue: boolean): Promise<void> {
+    await this.activateAutofillOnPageLoadFromPolicyState.update(() => newValue);
+  }
+
+  async setInlineMenuVisibility(newValue: InlineMenuVisibilitySetting): Promise<void> {
+    await this.inlineMenuVisibilityState.update(() => newValue);
+  }
+
+  /**
+   * If the ActivateAutofill policy is enabled, save a flag indicating if we need to
+   * enable Autofill on page load.
+   */
+  handleActivateAutofillPolicy(policies$: Observable<Policy[]>): Observable<boolean[]> {
+    return policies$.pipe(
+      map((policies) => policies.find((p) => p.type == PolicyType.ActivateAutofill && p.enabled)),
+      filter((p) => p != null),
+      switchMap(async (_) => [
+        await firstValueFrom(this.activateAutofillOnPageLoadFromPolicy$),
+        await firstValueFrom(this.autofillOnPageLoad$),
+      ]),
+      tap(([activated, autofillEnabled]) => {
+        if (activated === undefined) {
+          void this.setActivateAutofillOnPageLoadFromPolicy(!autofillEnabled);
+        }
+      }),
+    );
+  }
+}
--- a/libs/common/src/platform/abstractions/state.service.ts
+++ b/libs/common/src/platform/abstractions/state.service.ts
@@ -71,8 +71,6 @@ export abstract class StateService<T extends Account = Account> {
  setApiKeyClientSecret: (value: string, options?: StorageOptions) => Promise<void>;
  getAutoConfirmFingerPrints: (options?: StorageOptions) => Promise<boolean>;
  setAutoConfirmFingerprints: (value: boolean, options?: StorageOptions) => Promise<void>;
-  getAutoFillOnPageLoadDefault: (options?: StorageOptions) => Promise<boolean>;
-  setAutoFillOnPageLoadDefault: (value: boolean, options?: StorageOptions) => Promise<void>;
  getBiometricAwaitingAcceptance: (options?: StorageOptions) => Promise<boolean>;
  setBiometricAwaitingAcceptance: (value: boolean, options?: StorageOptions) => Promise<void>;
  getBiometricFingerprintValidated: (options?: StorageOptions) => Promise<boolean>;
@@ -243,8 +241,6 @@ export abstract class StateService<T extends Account = Account> {
  setDisableAddLoginNotification: (value: boolean, options?: StorageOptions) => Promise<void>;
  getDisableAutoBiometricsPrompt: (options?: StorageOptions) => Promise<boolean>;
  setDisableAutoBiometricsPrompt: (value: boolean, options?: StorageOptions) => Promise<void>;
-  getDisableAutoTotpCopy: (options?: StorageOptions) => Promise<boolean>;
-  setDisableAutoTotpCopy: (value: boolean, options?: StorageOptions) => Promise<void>;
  getDisableBadgeCounter: (options?: StorageOptions) => Promise<boolean>;
  setDisableBadgeCounter: (value: boolean, options?: StorageOptions) => Promise<void>;
  getDisableChangedPasswordNotification: (options?: StorageOptions) => Promise<boolean>;
@@ -264,8 +260,6 @@ export abstract class StateService<T extends Account = Account> {
  setDisableFavicon: (value: boolean, options?: StorageOptions) => Promise<void>;
  getDisableGa: (options?: StorageOptions) => Promise<boolean>;
  setDisableGa: (value: boolean, options?: StorageOptions) => Promise<void>;
-  getDismissedAutofillCallout: (options?: StorageOptions) => Promise<boolean>;
-  setDismissedAutofillCallout: (value: boolean, options?: StorageOptions) => Promise<void>;
  getDontShowCardsCurrentTab: (options?: StorageOptions) => Promise<boolean>;
  setDontShowCardsCurrentTab: (value: boolean, options?: StorageOptions) => Promise<void>;
  getDontShowIdentitiesCurrentTab: (options?: StorageOptions) => Promise<boolean>;
@@ -294,10 +288,6 @@ export abstract class StateService<T extends Account = Account> {
  setEmailVerified: (value: boolean, options?: StorageOptions) => Promise<void>;
  getEnableAlwaysOnTop: (options?: StorageOptions) => Promise<boolean>;
  setEnableAlwaysOnTop: (value: boolean, options?: StorageOptions) => Promise<void>;
-  getAutoFillOverlayVisibility: (options?: StorageOptions) => Promise<number>;
-  setAutoFillOverlayVisibility: (value: number, options?: StorageOptions) => Promise<void>;
-  getEnableAutoFillOnPageLoad: (options?: StorageOptions) => Promise<boolean>;
-  setEnableAutoFillOnPageLoad: (value: boolean, options?: StorageOptions) => Promise<void>;
  getEnableBrowserIntegration: (options?: StorageOptions) => Promise<boolean>;
  setEnableBrowserIntegration: (value: boolean, options?: StorageOptions) => Promise<void>;
  getEnableBrowserIntegrationFingerprint: (options?: StorageOptions) => Promise<boolean>;
@@ -486,13 +476,6 @@ export abstract class StateService<T extends Account = Account> {

  getAvatarColor: (options?: StorageOptions) => Promise<string | null | undefined>;
  setAvatarColor: (value: string, options?: StorageOptions) => Promise<void>;
-  getActivateAutoFillOnPageLoadFromPolicy: (
-    options?: StorageOptions,
-  ) => Promise<boolean | undefined>;
-  setActivateAutoFillOnPageLoadFromPolicy: (
-    value: boolean,
-    options?: StorageOptions,
-  ) => Promise<void>;
  getSMOnboardingTasks: (
    options?: StorageOptions,
  ) => Promise<Record<string, Record<string, boolean>>>;
--- a/libs/common/src/platform/models/domain/account.ts
+++ b/libs/common/src/platform/models/domain/account.ts
@@ -216,20 +216,16 @@ export class AccountProfile {

 export class AccountSettings {
  autoConfirmFingerPrints?: boolean;
-  autoFillOnPageLoadDefault?: boolean;
  biometricUnlock?: boolean;
  clearClipboard?: number;
  collapsedGroupings?: string[];
  defaultUriMatch?: UriMatchType;
  disableAutoBiometricsPrompt?: boolean;
-  disableAutoTotpCopy?: boolean;
  disableBadgeCounter?: boolean;
  disableGa?: boolean;
-  dismissedAutoFillOnPageLoadCallout?: boolean;
  dontShowCardsCurrentTab?: boolean;
  dontShowIdentitiesCurrentTab?: boolean;
  enableAlwaysOnTop?: boolean;
-  enableAutoFillOnPageLoad?: boolean;
  enableBiometric?: boolean;
  enableFullWidth?: boolean;
  equivalentDomains?: any;
@@ -246,7 +242,6 @@ export class AccountSettings {
  serverConfig?: ServerConfigData;
  approveLoginRequests?: boolean;
  avatarColor?: string;
-  activateAutoFillOnPageLoadFromPolicy?: boolean;
  smOnboardingTasks?: Record<string, Record<string, boolean>>;
  trustDeviceChoiceForDecryption?: boolean;
  biometricPromptCancelled?: boolean;
--- a/libs/common/src/platform/models/domain/global-state.ts
+++ b/libs/common/src/platform/models/domain/global-state.ts
@@ -34,6 +34,5 @@ export class GlobalState {
  disableAddLoginNotification?: boolean;
  disableChangedPasswordNotification?: boolean;
  disableContextMenuItem?: boolean;
-  autoFillOverlayVisibility?: number;
  deepLinkRedirectUrl?: string;
 }
--- a/libs/common/src/platform/services/state.service.ts
+++ b/libs/common/src/platform/services/state.service.ts
@@ -1,7 +1,6 @@
 import { BehaviorSubject, concatMap } from "rxjs";
 import { Jsonify, JsonValue } from "type-fest";

-import { AutofillOverlayVisibility } from "../../../../../apps/browser/src/autofill/utils/autofill-overlay.enum";
 import { OrganizationData } from "../../admin-console/models/data/organization.data";
 import { PolicyData } from "../../admin-console/models/data/policy.data";
 import { ProviderData } from "../../admin-console/models/data/provider.data";
@@ -374,24 +373,6 @@ export class StateService<
    );
  }

-  async getAutoFillOnPageLoadDefault(options?: StorageOptions): Promise<boolean> {
-    return (
-      (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
-        ?.settings?.autoFillOnPageLoadDefault ?? true
-    );
-  }
-
-  async setAutoFillOnPageLoadDefault(value: boolean, options?: StorageOptions): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-    account.settings.autoFillOnPageLoadDefault = value;
-    await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-  }
-
  async getBiometricAwaitingAcceptance(options?: StorageOptions): Promise<boolean> {
    return (
      (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
@@ -1154,24 +1135,6 @@ export class StateService<
    );
  }

-  async getDisableAutoTotpCopy(options?: StorageOptions): Promise<boolean> {
-    return (
-      (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
-        ?.settings?.disableAutoTotpCopy ?? false
-    );
-  }
-
-  async setDisableAutoTotpCopy(value: boolean, options?: StorageOptions): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-    account.settings.disableAutoTotpCopy = value;
-    await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-  }
-
  async getDisableBadgeCounter(options?: StorageOptions): Promise<boolean> {
    return (
      (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
@@ -1268,24 +1231,6 @@ export class StateService<
    );
  }

-  async getDismissedAutofillCallout(options?: StorageOptions): Promise<boolean> {
-    return (
-      (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
-        ?.settings?.dismissedAutoFillOnPageLoadCallout ?? false
-    );
-  }
-
-  async setDismissedAutofillCallout(value: boolean, options?: StorageOptions): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-    account.settings.dismissedAutoFillOnPageLoadCallout = value;
-    await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-  }
-
  async getDontShowCardsCurrentTab(options?: StorageOptions): Promise<boolean> {
    return (
      (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
@@ -1525,43 +1470,6 @@ export class StateService<
    );
  }

-  async getAutoFillOverlayVisibility(options?: StorageOptions): Promise<number> {
-    const locallyStoredOptions = await this.defaultOnDiskLocalOptions();
-    const reconciledOptions = this.reconcileOptions(options, locallyStoredOptions);
-    const globals = await this.getGlobals(reconciledOptions);
-
-    return globals?.autoFillOverlayVisibility ?? AutofillOverlayVisibility.Off;
-  }
-
-  async setAutoFillOverlayVisibility(value: number, options?: StorageOptions): Promise<void> {
-    const globals = await this.getGlobals(
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-    globals.autoFillOverlayVisibility = value;
-    await this.saveGlobals(
-      globals,
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-  }
-
-  async getEnableAutoFillOnPageLoad(options?: StorageOptions): Promise<boolean> {
-    return (
-      (await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
-        ?.settings?.enableAutoFillOnPageLoad ?? false
-    );
-  }
-
-  async setEnableAutoFillOnPageLoad(value: boolean, options?: StorageOptions): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-    account.settings.enableAutoFillOnPageLoad = value;
-    await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskOptions()),
-    );
-  }
-
  async getEnableBrowserIntegration(options?: StorageOptions): Promise<boolean> {
    return (
      (await this.getGlobals(this.reconcileOptions(options, await this.defaultOnDiskOptions())))
@@ -2612,26 +2520,6 @@ export class StateService<
    );
  }

-  async getActivateAutoFillOnPageLoadFromPolicy(options?: StorageOptions): Promise<boolean> {
-    return (
-      await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()))
-    )?.settings?.activateAutoFillOnPageLoadFromPolicy;
-  }
-
-  async setActivateAutoFillOnPageLoadFromPolicy(
-    value: boolean,
-    options?: StorageOptions,
-  ): Promise<void> {
-    const account = await this.getAccount(
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-    account.settings.activateAutoFillOnPageLoadFromPolicy = value;
-    return await this.saveAccount(
-      account,
-      this.reconcileOptions(options, await this.defaultOnDiskLocalOptions()),
-    );
-  }
-
  async getSMOnboardingTasks(
    options?: StorageOptions,
  ): Promise<Record<string, Record<string, boolean>>> {
--- a/libs/common/src/platform/state/state-definitions.ts
+++ b/libs/common/src/platform/state/state-definitions.ts
@@ -49,3 +49,8 @@ export const SYNC_STATE = new StateDefinition("sync", "disk", { web: "memory" })
 export const VAULT_SETTINGS_DISK = new StateDefinition("vaultSettings", "disk", {
  web: "disk-local",
 });
+
+export const AUTOFILL_SETTINGS_DISK = new StateDefinition("autofillSettings", "disk");
+export const AUTOFILL_SETTINGS_DISK_LOCAL = new StateDefinition("autofillSettingsLocal", "disk", {
+  web: "disk-local",
+});
--- a/libs/common/src/services/settings.service.ts
+++ b/libs/common/src/services/settings.service.ts
@@ -74,14 +74,6 @@ export class SettingsService implements SettingsServiceAbstraction {
    return this._disableFavicon.getValue();
  }

-  async setAutoFillOverlayVisibility(value: number): Promise<void> {
-    return await this.stateService.setAutoFillOverlayVisibility(value);
-  }
-
-  async getAutoFillOverlayVisibility(): Promise<number> {
-    return await this.stateService.getAutoFillOverlayVisibility();
-  }
-
  async clear(userId?: string): Promise<void> {
    if (userId == null || userId == (await this.stateService.getUserId())) {
      this._settings.next({});
--- a/libs/common/src/state-migrations/migrate.ts
+++ b/libs/common/src/state-migrations/migrate.ts
@@ -13,6 +13,7 @@ import { MoveBiometricClientKeyHalfToStateProviders } from "./migrations/14-move
 import { FolderMigrator } from "./migrations/15-move-folder-state-to-state-provider";
 import { LastSyncMigrator } from "./migrations/16-move-last-sync-to-state-provider";
 import { EnablePasskeysMigrator } from "./migrations/17-move-enable-passkeys-to-state-providers";
+import { AutofillSettingsKeyMigrator } from "./migrations/18-move-autofill-settings-to-state-providers";
 import { FixPremiumMigrator } from "./migrations/3-fix-premium";
 import { RemoveEverBeenUnlockedMigrator } from "./migrations/4-remove-ever-been-unlocked";
 import { AddKeyTypeToOrgKeysMigrator } from "./migrations/5-add-key-type-to-org-keys";
@@ -23,7 +24,7 @@ import { MoveBrowserSettingsToGlobal } from "./migrations/9-move-browser-setting
 import { MinVersionMigrator } from "./migrations/min-version";

 export const MIN_VERSION = 2;
-export const CURRENT_VERSION = 17;
+export const CURRENT_VERSION = 18;
 export type MinVersion = typeof MIN_VERSION;

 export async function migrate(
@@ -56,7 +57,8 @@ export async function migrate(
    .with(MoveBiometricClientKeyHalfToStateProviders, 13, 14)
    .with(FolderMigrator, 14, 15)
    .with(LastSyncMigrator, 15, 16)
-    .with(EnablePasskeysMigrator, 16, CURRENT_VERSION)
+    .with(EnablePasskeysMigrator, 16, 17)
+    .with(AutofillSettingsKeyMigrator, 17, CURRENT_VERSION)

    .migrate(migrationHelper);
 }
--- a/libs/common/src/state-migrations/migrations/18-move-autofill-settings-to-state-providers.spec.ts
+++ b/libs/common/src/state-migrations/migrations/18-move-autofill-settings-to-state-providers.spec.ts
@@ -0,0 +1,223 @@
+import { any, MockProxy } from "jest-mock-extended";
+
+import { AutofillOverlayVisibility } from "../../../../../apps/browser/src/autofill/utils/autofill-overlay.enum";
+import { StateDefinitionLike, MigrationHelper } from "../migration-helper";
+import { mockMigrationHelper } from "../migration-helper.spec";
+
+import { AutofillSettingsKeyMigrator } from "./18-move-autofill-settings-to-state-providers";
+
+function exampleJSON() {
+  return {
+    global: {
+      autoFillOverlayVisibility: AutofillOverlayVisibility.OnButtonClick,
+      otherStuff: "otherStuff1",
+    },
+    authenticatedAccounts: ["user-1", "user-2", "user-3"],
+    "user-1": {
+      settings: {
+        autoFillOnPageLoadDefault: true,
+        enableAutoFillOnPageLoad: true,
+        dismissedAutoFillOnPageLoadCallout: true,
+        disableAutoTotpCopy: false,
+        activateAutoFillOnPageLoadFromPolicy: true,
+        otherStuff: "otherStuff2",
+      },
+      otherStuff: "otherStuff3",
+    },
+    "user-2": {
+      settings: {
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+  };
+}
+
+function rollbackJSON() {
+  return {
+    global_autofillSettingsLocal_inlineMenuVisibility: AutofillOverlayVisibility.OnButtonClick,
+    "user_user-1_autofillSettings_autoCopyTotp": true,
+    "user_user-1_autofillSettings_autofillOnPageLoad": true,
+    "user_user-1_autofillSettings_autofillOnPageLoadCalloutIsDismissed": true,
+    "user_user-1_autofillSettings_autofillOnPageLoadDefault": true,
+    "user_user-1_autofillSettingsLocal_activateAutofillOnPageLoadFromPolicy": true,
+    global: {
+      otherStuff: "otherStuff1",
+    },
+    authenticatedAccounts: ["user-1", "user-2", "user-3"],
+    "user-1": {
+      settings: {
+        otherStuff: "otherStuff2",
+      },
+      otherStuff: "otherStuff3",
+    },
+    "user-2": {
+      settings: {
+        otherStuff: "otherStuff4",
+      },
+      otherStuff: "otherStuff5",
+    },
+  };
+}
+
+const autofillSettingsStateDefinition: {
+  stateDefinition: StateDefinitionLike;
+} = {
+  stateDefinition: {
+    name: "autofillSettings",
+  },
+};
+
+describe("ProviderKeysMigrator", () => {
+  let helper: MockProxy<MigrationHelper>;
+  let sut: AutofillSettingsKeyMigrator;
+
+  describe("migrate", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(exampleJSON(), 17);
+      sut = new AutofillSettingsKeyMigrator(17, 18);
+    });
+
+    it("should remove autofill settings from all accounts", async () => {
+      await sut.migrate(helper);
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("global", {
+        otherStuff: "otherStuff1",
+      });
+      expect(helper.set).toHaveBeenCalledWith("user-1", {
+        settings: {
+          otherStuff: "otherStuff2",
+        },
+        otherStuff: "otherStuff3",
+      });
+    });
+
+    it("should set autofill setting values for each account", async () => {
+      await sut.migrate(helper);
+
+      expect(helper.setToGlobal).toHaveBeenCalledTimes(1);
+      expect(helper.setToGlobal).toHaveBeenCalledWith(
+        {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "inlineMenuVisibility",
+        },
+        1,
+      );
+
+      expect(helper.setToUser).toHaveBeenCalledTimes(5);
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadDefault" },
+        true,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autofillOnPageLoad" },
+        true,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadCalloutIsDismissed" },
+        true,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autoCopyTotp" },
+        true,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "activateAutofillOnPageLoadFromPolicy",
+        },
+        true,
+      );
+    });
+  });
+
+  describe("rollback", () => {
+    beforeEach(() => {
+      helper = mockMigrationHelper(rollbackJSON(), 16);
+      sut = new AutofillSettingsKeyMigrator(17, 18);
+    });
+
+    it("should null out new values for each account", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.setToGlobal).toHaveBeenCalledTimes(1);
+      expect(helper.setToGlobal).toHaveBeenCalledWith(
+        {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "inlineMenuVisibility",
+        },
+        null,
+      );
+
+      expect(helper.setToUser).toHaveBeenCalledTimes(5);
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadDefault" },
+        null,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autofillOnPageLoad" },
+        null,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadCalloutIsDismissed" },
+        null,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        { ...autofillSettingsStateDefinition, key: "autoCopyTotp" },
+        null,
+      );
+      expect(helper.setToUser).toHaveBeenCalledWith(
+        "user-1",
+        {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "activateAutofillOnPageLoadFromPolicy",
+        },
+        null,
+      );
+    });
+
+    it("should add explicit value back to accounts", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).toHaveBeenCalledTimes(2);
+      expect(helper.set).toHaveBeenCalledWith("global", {
+        autoFillOverlayVisibility: 1,
+        otherStuff: "otherStuff1",
+      });
+      expect(helper.set).toHaveBeenCalledWith("user-1", {
+        settings: {
+          otherStuff: "otherStuff2",
+          autoFillOnPageLoadDefault: true,
+          enableAutoFillOnPageLoad: true,
+          dismissedAutoFillOnPageLoadCallout: true,
+          disableAutoTotpCopy: false,
+          activateAutoFillOnPageLoadFromPolicy: true,
+        },
+        otherStuff: "otherStuff3",
+      });
+    });
+
+    it("should not try to restore values to missing accounts", async () => {
+      await sut.rollback(helper);
+
+      expect(helper.set).not.toHaveBeenCalledWith("user-3", any());
+    });
+  });
+});
--- a/libs/common/src/state-migrations/migrations/18-move-autofill-settings-to-state-providers.ts
+++ b/libs/common/src/state-migrations/migrations/18-move-autofill-settings-to-state-providers.ts
@@ -0,0 +1,262 @@
+import { InlineMenuVisibilitySetting } from "../../../../../apps/browser/src/autofill/utils/autofill-overlay.enum";
+import { StateDefinitionLike, MigrationHelper } from "../migration-helper";
+import { Migrator } from "../migrator";
+
+type ExpectedAccountState = {
+  settings?: {
+    autoFillOnPageLoadDefault?: boolean;
+    enableAutoFillOnPageLoad?: boolean;
+    dismissedAutoFillOnPageLoadCallout?: boolean;
+    disableAutoTotpCopy?: boolean;
+    activateAutoFillOnPageLoadFromPolicy?: InlineMenuVisibilitySetting;
+  };
+};
+
+type ExpectedGlobalState = { autoFillOverlayVisibility?: InlineMenuVisibilitySetting };
+
+const autofillSettingsStateDefinition: {
+  stateDefinition: StateDefinitionLike;
+} = {
+  stateDefinition: {
+    name: "autofillSettings",
+  },
+};
+
+export class AutofillSettingsKeyMigrator extends Migrator<17, 18> {
+  async migrate(helper: MigrationHelper): Promise<void> {
+    // global state (e.g. "autoFillOverlayVisibility -> inlineMenuVisibility")
+    const globalState = await helper.get<ExpectedGlobalState>("global");
+
+    if (globalState?.autoFillOverlayVisibility != null) {
+      await helper.setToGlobal(
+        {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "inlineMenuVisibility",
+        },
+        globalState.autoFillOverlayVisibility,
+      );
+
+      // delete `autoFillOverlayVisibility` from state global
+      delete globalState.autoFillOverlayVisibility;
+
+      await helper.set<ExpectedGlobalState>("global", globalState);
+    }
+
+    // account state (e.g. account settings -> state provider framework keys)
+    const accounts = await helper.getAccounts<ExpectedAccountState>();
+
+    await Promise.all([...accounts.map(({ userId, account }) => migrateAccount(userId, account))]);
+
+    // migrate account state
+    async function migrateAccount(userId: string, account: ExpectedAccountState): Promise<void> {
+      let updateAccount = false;
+      const accountSettings = account?.settings;
+
+      if (accountSettings?.autoFillOnPageLoadDefault != null) {
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadDefault" },
+          accountSettings.autoFillOnPageLoadDefault,
+        );
+        delete account.settings.autoFillOnPageLoadDefault;
+        updateAccount = true;
+      }
+
+      if (accountSettings?.enableAutoFillOnPageLoad != null) {
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autofillOnPageLoad" },
+          accountSettings?.enableAutoFillOnPageLoad,
+        );
+        delete account.settings.enableAutoFillOnPageLoad;
+        updateAccount = true;
+      }
+
+      if (accountSettings?.dismissedAutoFillOnPageLoadCallout != null) {
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadCalloutIsDismissed" },
+          accountSettings?.dismissedAutoFillOnPageLoadCallout,
+        );
+        delete account.settings.dismissedAutoFillOnPageLoadCallout;
+        updateAccount = true;
+      }
+
+      if (accountSettings?.disableAutoTotpCopy != null) {
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autoCopyTotp" },
+          // invert the value to match the new naming convention
+          !accountSettings?.disableAutoTotpCopy,
+        );
+        delete account.settings.disableAutoTotpCopy;
+        updateAccount = true;
+      }
+
+      if (accountSettings?.activateAutoFillOnPageLoadFromPolicy != null) {
+        await helper.setToUser(
+          userId,
+          {
+            stateDefinition: {
+              name: "autofillSettingsLocal",
+            },
+            key: "activateAutofillOnPageLoadFromPolicy",
+          },
+          accountSettings?.activateAutoFillOnPageLoadFromPolicy,
+        );
+        delete account.settings.activateAutoFillOnPageLoadFromPolicy;
+        updateAccount = true;
+      }
+
+      if (updateAccount) {
+        // update the state account settings with the migrated values deleted
+        await helper.set(userId, account);
+      }
+    }
+  }
+
+  async rollback(helper: MigrationHelper): Promise<void> {
+    // global state (e.g. "inlineMenuVisibility -> autoFillOverlayVisibility")
+    const globalState = (await helper.get<ExpectedGlobalState>("global")) || {};
+    const inlineMenuVisibility: InlineMenuVisibilitySetting = await helper.getFromGlobal({
+      stateDefinition: {
+        name: "autofillSettingsLocal",
+      },
+      key: "inlineMenuVisibility",
+    });
+
+    if (inlineMenuVisibility) {
+      await helper.set<ExpectedGlobalState>("global", {
+        ...globalState,
+        autoFillOverlayVisibility: inlineMenuVisibility,
+      });
+
+      // remove the global state provider framework key for `inlineMenuVisibility`
+      await helper.setToGlobal(
+        {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "inlineMenuVisibility",
+        },
+        null,
+      );
+    }
+
+    // account state (e.g. state provider framework keys -> account settings)
+    const accounts = await helper.getAccounts<ExpectedAccountState>();
+
+    await Promise.all([...accounts.map(({ userId, account }) => rollbackAccount(userId, account))]);
+
+    // rollback account state
+    async function rollbackAccount(userId: string, account: ExpectedAccountState): Promise<void> {
+      let updateAccount = false;
+      let settings = account?.settings || {};
+
+      const autoFillOnPageLoadDefault: boolean = await helper.getFromUser(userId, {
+        ...autofillSettingsStateDefinition,
+        key: "autofillOnPageLoadDefault",
+      });
+
+      const enableAutoFillOnPageLoad: boolean = await helper.getFromUser(userId, {
+        ...autofillSettingsStateDefinition,
+        key: "autofillOnPageLoad",
+      });
+
+      const dismissedAutoFillOnPageLoadCallout: boolean = await helper.getFromUser(userId, {
+        ...autofillSettingsStateDefinition,
+        key: "autofillOnPageLoadCalloutIsDismissed",
+      });
+
+      const autoCopyTotp: boolean = await helper.getFromUser(userId, {
+        ...autofillSettingsStateDefinition,
+        key: "autoCopyTotp",
+      });
+
+      const activateAutoFillOnPageLoadFromPolicy: InlineMenuVisibilitySetting =
+        await helper.getFromUser(userId, {
+          stateDefinition: {
+            name: "autofillSettingsLocal",
+          },
+          key: "activateAutofillOnPageLoadFromPolicy",
+        });
+
+      // update new settings and remove the account state provider framework keys for the rolled back values
+      if (autoFillOnPageLoadDefault != null) {
+        settings = { ...settings, autoFillOnPageLoadDefault };
+
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadDefault" },
+          null,
+        );
+
+        updateAccount = true;
+      }
+
+      if (enableAutoFillOnPageLoad != null) {
+        settings = { ...settings, enableAutoFillOnPageLoad };
+
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autofillOnPageLoad" },
+          null,
+        );
+
+        updateAccount = true;
+      }
+
+      if (dismissedAutoFillOnPageLoadCallout != null) {
+        settings = { ...settings, dismissedAutoFillOnPageLoadCallout };
+
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autofillOnPageLoadCalloutIsDismissed" },
+          null,
+        );
+
+        updateAccount = true;
+      }
+
+      if (autoCopyTotp != null) {
+        // invert the value to match the new naming convention
+        settings = { ...settings, disableAutoTotpCopy: !autoCopyTotp };
+
+        await helper.setToUser(
+          userId,
+          { ...autofillSettingsStateDefinition, key: "autoCopyTotp" },
+          null,
+        );
+
+        updateAccount = true;
+      }
+
+      if (activateAutoFillOnPageLoadFromPolicy != null) {
+        settings = { ...settings, activateAutoFillOnPageLoadFromPolicy };
+
+        await helper.setToUser(
+          userId,
+          {
+            stateDefinition: {
+              name: "autofillSettingsLocal",
+            },
+            key: "activateAutofillOnPageLoadFromPolicy",
+          },
+          null,
+        );
+
+        updateAccount = true;
+      }
+
+      if (updateAccount) {
+        // commit updated settings to state
+        await helper.set(userId, {
+          ...account,
+          settings,
+        });
+      }
+    }
+  }
+}
--- a/libs/common/src/vault/services/cipher.service.spec.ts
+++ b/libs/common/src/vault/services/cipher.service.spec.ts
@@ -5,6 +5,7 @@ import { makeStaticByteArray } from "../../../spec/utils";
 import { ApiService } from "../../abstractions/api.service";
 import { SearchService } from "../../abstractions/search.service";
 import { SettingsService } from "../../abstractions/settings.service";
+import { AutofillSettingsService } from "../../autofill/services/autofill-settings.service";
 import { ConfigServiceAbstraction } from "../../platform/abstractions/config/config.service.abstraction";
 import { CryptoService } from "../../platform/abstractions/crypto.service";
 import { EncryptService } from "../../platform/abstractions/encrypt.service";
@@ -97,6 +98,7 @@ const cipherData: CipherData = {
 describe("Cipher Service", () => {
  const cryptoService = mock<CryptoService>();
  const stateService = mock<StateService>();
+  const autofillSettingsService = mock<AutofillSettingsService>();
  const settingsService = mock<SettingsService>();
  const apiService = mock<ApiService>();
  const cipherFileUploadService = mock<CipherFileUploadService>();
@@ -121,6 +123,7 @@ describe("Cipher Service", () => {
      i18nService,
      searchService,
      stateService,
+      autofillSettingsService,
      encryptService,
      cipherFileUploadService,
      configService,
@@ -266,6 +269,8 @@ describe("Cipher Service", () => {
        Promise.resolve(new SymmetricCryptoKey(makeStaticByteArray(64)) as CipherKey),
      );
      cryptoService.encrypt.mockImplementation(encryptText);
+
+      jest.spyOn(cipherService as any, "getAutofillOnPageLoadDefault").mockResolvedValue(true);
    });

    describe("login encryption", () => {
--- a/libs/common/src/vault/services/cipher.service.ts
+++ b/libs/common/src/vault/services/cipher.service.ts
@@ -4,6 +4,7 @@ import { SemVer } from "semver";
 import { ApiService } from "../../abstractions/api.service";
 import { SearchService } from "../../abstractions/search.service";
 import { SettingsService } from "../../abstractions/settings.service";
+import { AutofillSettingsServiceAbstraction } from "../../autofill/services/autofill-settings.service";
 import { ErrorResponse } from "../../models/response/error.response";
 import { ListResponse } from "../../models/response/list.response";
 import { View } from "../../models/view/view";
@@ -65,6 +66,7 @@ export class CipherService implements CipherServiceAbstraction {
    private i18nService: I18nService,
    private searchService: SearchService,
    private stateService: StateService,
+    private autofillSettingsService: AutofillSettingsServiceAbstraction,
    private encryptService: EncryptService,
    private cipherFileUploadService: CipherFileUploadService,
    private configService: ConfigServiceAbstraction,
@@ -1250,6 +1252,10 @@ export class CipherService implements CipherServiceAbstraction {
    }
  }

+  private async getAutofillOnPageLoadDefault() {
+    return await firstValueFrom(this.autofillSettingsService.autofillOnPageLoadDefault$);
+  }
+
  private async getCipherForUrl(
    url: string,
    lastUsed: boolean,
@@ -1265,7 +1271,8 @@ export class CipherService implements CipherServiceAbstraction {
      }

      if (autofillOnPageLoad) {
-        const autofillOnPageLoadDefault = await this.stateService.getAutoFillOnPageLoadDefault();
+        const autofillOnPageLoadDefault = await this.getAutofillOnPageLoadDefault();
+
        ciphers = ciphers.filter(
          (cipher) =>
            cipher.login.autofillOnPageLoad ||