у меня есть программа на js 


//Глобальный флаг, чтобы можно было остановить обновление
let isUpdating = true;

document.getElementById('fetchButton').addEventListener('click', () => {
  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {

    // Устанавливаем флаг обновления в false и отправляем его в chrome.runtime
    isUpdating = false;
    chrome.runtime.sendMessage({ action: 'updateFlag', isUpdating });

    chrome.scripting.executeScript({
      target: { tabId: tabs[0].id },
      func: async () => {

        console.log('Скрипт начал выполняться');

        // Основная функция
        const processPositionsScript = async () => {

          // Получаем строки таблицы и пропускаем первые две
          const rows = Array.from(document.querySelectorAll('.by-table-row')).slice(2); // Пропускаем первые две строки
          let positions = rows.map((row, index) => {
            const cells = row.querySelectorAll('.by-table-cell');
            const position = {
              index,
              orderPriceIV: cells[8]?.innerText.trim() || '',
              direction: cells[5]?.innerText.trim() || '',
              quantity: parseFloat(cells[9]?.innerText.trim()) || 0,
              orderPriceCell: cells[8],
              quantityCell: cells[9],
              askSize: parseFloat(cells[10]?.innerText.trim()) || 0,
              bidSize: parseFloat(cells[6]?.innerText.trim()) || 0,
            };
            return position;
          }).filter(pos => pos.orderPriceIV && pos.direction); // Исключаем пустые записи

          console.log("Recycle position");
          // Записываем информацию о позициях в sessionStorage
          positions.forEach((pos) => {
            if(sessionStorage.getItem(`quantity_${pos.index}`) === null) {
              const keyOrderPriceIV = `orderPriceIV_${pos.index}`;
              const keyQuantity = `quantity_${pos.index}`;

              console.log(`Записываю в sessionStorage:  ${keyOrderPriceIV} = ${pos.orderPriceIV}`);
              console.log(`Записываю в sessionStorage:  ${keyQuantity} = ${pos.quantity}`);

              sessionStorage.setItem(keyOrderPriceIV, pos.orderPriceIV);
              sessionStorage.setItem(keyQuantity, pos.quantity);
            }
            else console.log("Data has even")
        });

          // Функция масштабирования количеств
          const scaleAllQuantities = () => {
            const groupedByOrderPrice = positions.reduce((acc, pos) => {
              if (!acc[pos.orderPriceIV]) acc[pos.orderPriceIV] = [];
              acc[pos.orderPriceIV].push(pos);
              return acc;
            }, {});

            let scaleFactors = Object.values(groupedByOrderPrice).flatMap(group => {
              const buyGroup = group.filter(pos => pos.direction === 'Купить');
              const sellGroup = group.filter(pos => pos.direction === 'Продать');
              const calculateScale = (group, sizeKey) => {
                if (group.length === 0) return 1;
                const totalSize = group[0][sizeKey];
                const totalQuantity = group.reduce((sum, pos) => sum + pos.quantity, 0);
                return totalQuantity > totalSize ? totalSize / totalQuantity : 1;
              };
              return [
                calculateScale(buyGroup, 'askSize'),
                calculateScale(sellGroup, 'bidSize'),
              ];
            });

            const minScaleFactor = Math.min(...scaleFactors, 1);
            console.log(`Минимальный коэффициент масштабирования: ${minScaleFactor * 100}%`);
            positions.forEach(pos => {
              pos.quantity *= minScaleFactor
              console.log("ORIGINAL: " + pos.quantity)
              pos.quantityCell.innerText = pos.quantity.toFixed(2);
            });
            return minScaleFactor < 1;
          };

          // Функция для обновления позиций
          const updatePositions = () => {
            positions.forEach(pos => {
              const cells = pos.quantityCell.parentElement.querySelectorAll('.by-table-cell');
              Object.assign(pos, {
                orderPriceIV: cells[8]?.innerText.trim() || '',
                direction: cells[5]?.innerText.trim() || '',
                quantity: parseFloat(pos.quantityCell.innerText.trim()) || 0,
                askSize: parseFloat(cells[10]?.innerText.trim()) || 0,
                bidSize: parseFloat(cells[6]?.innerText.trim()) || 0,
              });
            });
          };

          // Функция обработки позиций и нажатия кнопок
          const processAndClickButtons = async () => {

            // Пока есть позиции с количеством больше 0.001
            while (positions.some(pos => pos.quantity >= 0.001)) {
              console.log('Обрабатываем позиции...');
              positions.forEach(pos => {

                // Рассчитываем разницу между сохраненным и текущим количеством
                const diff = Math.abs(sessionStorage.getItem(`quantity_${pos.index}`) - pos.quantity);

                console.log("Index: " + pos.index
                    + " Diff: " + diff
                    + " SavedQuantity: " + sessionStorage.getItem(`quantity_${pos.index}`)
                    + " NowQuantity: " + pos.quantity
                    + " SavedOrderPrice " + sessionStorage.getItem(`orderPriceIV_${pos.index}`)
                    + " OrderPrice " + pos.orderPriceIV
                    + " askSIZE: " + pos.askSize
                    + " bidSIZE: " + pos.bidSize
                )

                // Проверяем, если разница между сохраненным количеством и текущим количеством меньше или равна размеру заявки
                if (diff <= (pos.direction === 'Купить' ? pos.askSize : pos.bidSize)) {
                  // Если разница мала, позиция выполнена и количество становится 0
                  pos.quantity = 0;
                  sessionStorage.setItem(`quantity_${pos.index}`, pos.quantity.toString());
                } else {
                  // Если разница велика, вычисляем новое количество, вычитая размер заявки
                  const newQuantity = diff - (pos.direction === 'Купить' ? pos.askSize : pos.bidSize);
                  // Обновляем количество на размер заявки (askSize для покупки, bidSize для продажи) 5% от текущей
                  pos.quantity = (pos.direction === 'Купить' ? pos.askSize : pos.bidSize) * 0.95;
                  sessionStorage.setItem(`quantity_${pos.index}`, newQuantity.toString());
                }

                // Расчет новой цены с фактором случайной вариации
                const priceFactor = 1 + (Math.random() * 0.1 - 0.05);
                const getPrice = sessionStorage.getItem(`orderPriceIV_${pos.index}`)
                pos.orderPriceIV = (parseFloat(getPrice) * priceFactor).toFixed(2);

                // Обновляем цену и количество на странице
                pos.orderPriceCell.innerText = pos.orderPriceIV;
                pos.quantityCell.innerText = pos.quantity.toFixed(2);


                console.log("ASK: " + pos.askSize + " BID: " + pos.bidSize + " getQuantity: " + pos.quantity + " orderPrice " + pos.orderPriceIV)
              });
              updatePositions();
              await clickButtons();
            }
            console.log('Все позиции обработаны.');
          };

          // Функция нажатия кнопок
          const clickButtons = async () => {
            const firstButton = document.querySelector('.by-button.by-builder-opr-btn.by-button--contained.by-button--xx-large.by-button--brand');
            if (firstButton) firstButton.click();
            await new Promise(resolve => setTimeout(resolve, 1000));
            const secondButton = document.querySelector('.by-button.by-dialog__btn.by-button--contained.by-button--xx-large.by-button--brand');
            if (secondButton) secondButton.click();
            console.log("Все кнопки прожаты")
          };


          // Запускаем обработку
          const requiresScaling = scaleAllQuantities();
          if (requiresScaling) {
            await clickButtons();
            await processAndClickButtons();
          } else {
            await clickButtons();
            console.log('Скрипт завершен без необходимости масштабирования.');
          }

          
          // Меняем информацию о позициях в sessionStorage на null
          positions.forEach((pos) => {
            if(sessionStorage.getItem(`quantity_${pos.index}`) !== null) {
              const keyOrderPriceIV = `orderPriceIV_${pos.index}`;
              const keyQuantity = `quantity_${pos.index}`;

              console.log(`Записываю в sessionStorage:  ${keyOrderPriceIV} = null`);
              console.log(`Записываю в sessionStorage:  ${keyQuantity} = null`);

              sessionStorage.setItem(keyOrderPriceIV, null);
              sessionStorage.setItem(keyQuantity, null);
            }
            else console.log("Data has not recycle")
          });

        };

        await processPositionsScript();


      },
    });

    // Устанавливаем флаг завершения обновления в true
    isUpdating = true;
    chrome.runtime.sendMessage({ action: 'updateFlag', isUpdating });

  });
});


// Слушаем сообщение от content скрипта и обновляем label с суммой комиссии
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.action === "updateAmount") {
    const commissionLabel = document.getElementById("info");
    if (commissionLabel) {
      commissionLabel.textContent = `Сумма комиссии: ${message.data}`;
    }
  }
});


document.getElementById('calculateButton').addEventListener('click', () => {
  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {

      chrome.scripting.executeScript({
        target: {tabId: tabs[0].id},
        func: () => {
          console.log("Script run")


          // Получаем строки таблицы и пропускаем первые две
          const rows = Array.from(document.querySelectorAll('.by-table-row')).slice(2); // Пропускаем первые две строки
          let positions = rows.map((row, index) => {
            const cells = row.querySelectorAll('.by-table-cell');
            return {
              index,
              orderPriceIV: (() => {
                const cellValue = cells[8]?.innerText.trim();

                // Заменяем запятую на точку (если она есть)
                const cleanedValue = cellValue.replace(',', '.');

                // Преобразуем строку в число
                const parsedValue = parseFloat(cleanedValue);

                console.log(`Значение ячейки: "${cellValue}", после замены: "${cleanedValue}", преобразовано в: ${parsedValue}`);

                return isNaN(parsedValue) ? 0 : parsedValue;
              })(),
              quantity: (() => {
                const cellValue = cells[9]?.innerText.trim();

                // Заменяем запятую на точку (если она есть)
                const cleanedValue = cellValue.replace(',', '.');

                // Преобразуем строку в число
                const parsedValue = parseFloat(cleanedValue);

                console.log(`Значение ячейки: "${cellValue}", после замены: "${cleanedValue}", преобразовано в: ${parsedValue}`);

                return isNaN(parsedValue) ? 0 : parsedValue;
              })(),
            };
          }).filter(pos => pos.orderPriceIV); // Исключаем пустые записи

          let amountCommission = 0;

          // Записываем информацию о позициях в sessionStorage
          positions.forEach((pos) => {
            const keyOrderPriceIV = `orderPriceIV_${pos.index}`;
            const keyQuantity = `quantity_${pos.index}`;

            console.log(`Записываю в sessionStorage:  ${keyOrderPriceIV} = ${pos.orderPriceIV}`);
            console.log(`Записываю в sessionStorage:  ${keyQuantity} = ${pos.quantity}`);

            amountCommission = amountCommission + (pos.orderPriceIV * pos.quantity)

            sessionStorage.setItem(keyOrderPriceIV, pos.orderPriceIV);
            sessionStorage.setItem(keyQuantity, pos.quantity);
          });

          const sizeCommission = 0.0200;

          amountCommission = amountCommission * sizeCommission;

          // Отправляем обновленную сумму в background или popup
          chrome.runtime.sendMessage({ action: "updateAmount", data: amountCommission.toFixed(4) });

          console.log("Sum of orders with commission = " + amountCommission)
        },
      });
  });
});


function updateData() {

  chrome.tabs.query({ active: true, currentWindow: true }, (tabs) => {
    if (!isUpdating) return;

    chrome.scripting.executeScript({
      target: { tabId: tabs[0].id },
      func: () => {
        let data = [];
        document.querySelectorAll('.by-table-row').forEach((row) => {
          const cells = row.querySelectorAll('.by-table-cell');

          // Проверяем, что строка содержит достаточное количество ячеек
          if (cells.length < 18) {
            console.warn('Некоторые ячейки отсутствуют в строке:', row);
            return; // Пропускаем обработку этой строки
          }

          let rowData = {
            modeledPositions: cells[0] ? cells[0].innerText : '--',
            leverage: cells[1] ? cells[1].innerText : '--',
            expiration: cells[2] ? cells[2].innerText : '--',
            strikePrice: cells[3] ? cells[3].innerText : '--',
            type: cells[4] ? cells[4].innerText : '--',
            direction: cells[5] ? cells[5].innerText : '--',
            bidSize: cells[6] ? cells[6].innerText : '--',
            bidPriceIV: cells[7] ? cells[7].innerText : '--',
            orderPriceIV: cells[8] ? cells[8].innerText : '--',
            quantity: cells[9] ? cells[9].innerText : '--',
            askSize: cells[10] ? cells[10].innerText : '--',
            askPriceIV: cells[11] ? cells[11].innerText : '--',
            pnl: cells[12] ? cells[12].innerText : '--',
            delta: cells[13] ? cells[13].innerText : '--',
            gamma: cells[14] ? cells[14].innerText : '--',
            vega: cells[15] ? cells[15].innerText : '--',
            theta: cells[16] ? cells[16].innerText : '--',
            action: cells[17] ? cells[17].innerText : '--'
          };

          // Логика для обновления "Цены ордера" в зависимости от "Направления"
          const orderPriceCell = cells[8];
          const direction = cells[5]?.innerText?.trim();

          if (direction === 'Купить' && cells[11]?.innerText) {
            orderPriceCell.innerText = cells[11].innerText; // Ставим "Цену предложения"
          } else if (direction === 'Продать' && cells[7]?.innerText) {
            orderPriceCell.innerText = cells[7].innerText; // Ставим "Цену спроса"
          }

          data.push(rowData);
        });
        return data;
      },
    }, (results) => {
      if (results && results[0]) {
        let data = results[0].result;
        let dataDiv = document.getElementById('data');

        // Очистить предыдущие данные
        dataDiv.innerHTML = '';

        // Создаем таблицу
        let table = document.createElement('table');
        data.forEach(rowData => {
          let row = document.createElement('tr');

          let columns = [
            'modeledPositions',
            'leverage',
            'expiration',
            'strikePrice',
            'type',
            'direction',
            'bidSize',
            'bidPriceIV',
            'orderPriceIV',
            'quantity',
            'askSize',
            'askPriceIV',
            'pnl',
            'delta',
            'gamma',
            'vega',
            'theta',
            'action'
          ];

          columns.forEach(key => {
            let cell = document.createElement('td');
            cell.innerText = rowData[key];
            row.appendChild(cell);
          });

          table.appendChild(row);
        });

        dataDiv.appendChild(table);
      }
    });
  });
}

setInterval(updateData, 500); 

мне нужно что бы комиссия считалась постоянно а не по нажатию кнопки