Wand-Enhancer-k1tbyte/web-panel/bridge/scripts/default/installed-apps-sync/index.js

import {
  BIND_CHANNEL,
  BOOTSTRAP_LOG_THROTTLE_ATTEMPTS,
  COMMAND_REQUEST_CHANNEL,
  CONTAINER_LOG_THROTTLE_ATTEMPTS,
  FOLLOW_UP_SYNC_DELAY_MS,
  GLOBAL_FLAG,
  MAX_BOOTSTRAP_ATTEMPTS,
  MAX_OPTIONAL_SERVICES_ATTEMPTS,
  OPTIONAL_SERVICES_RETRY_INTERVAL_MS,
  RETRY_DELAY_MS,
  SYNC_CHANNEL,
  SYNC_INTERVAL_MS,
} from "./constants.js"
import {
  createIdleGameSession,
  createIdleTrainerStatus,
  installGameStatusSubscriptions,
} from "./game-status.js"
import {
  buildSnapshot,
  makeInstalledAppsSignature,
  refreshUnavailableTitles,
  resolveInstalledData,
} from "./installed-data.js"
import { createLogger } from "./logger.js"
import { handleRemoteCommandRequest } from "./remote-commands.js"
import {
  formatError,
  getAppRoot,
  getAureliaContainer,
  getRequire,
  getWebpackRequire,
  hasAppRoot,
  invokeIpc,
  isRecord,
  summarizeAureliaSubtree,
} from "./runtime.js"
import {
  getInstalledAppsService,
  getStoreRef,
  hasMissingOptionalServices,
  hasUnresolvedServices,
  resolveOptionalServices,
} from "./services.js"

export function installInstalledAppsSync(WandEnhancer) {
  if (globalThis[GLOBAL_FLAG]) {
    return
  }

  globalThis[GLOBAL_FLAG] = true

  const state = createState(WandEnhancer)
  state.resolveRemoteCommandServices = () => resolveRemoteCommandServices(state)
  state.queueSync = (force = false) => queueSync(state, force)
  state.queueFollowUpSync = () => queueFollowUpSync(state)

  state.log(
    "info",
    "Script loaded.",
    `logFile=${globalThis.__wandInstalledAppsSyncLogFile || "console-only"}`
  )
  retryBootstrap(state)
}

function createState(WandEnhancer) {
  return {
    WandEnhancer,
    log: createLogger(WandEnhancer),
    lastSignature: null,
    lastGameStatusSignature: null,
    refreshTimer: null,
    followUpSyncTimer: null,
    pollTimer: null,
    optionalServicesTimer: null,
    bootstrapAttempts: 0,
    optionalServicesAttempts: 0,
    bridgeBound: false,
    bridgeBinding: false,
    refreshPatched: false,
    installedAppsService: null,
    gameLifecycleService: null,
    trainerVisibilityService: null,
    unavailableTitlesService: null,
    storeRef: null,
    ipcRenderer: null,
    lastBootstrapReason: null,
    gameLifecycleSubscriptionsInstalled: false,
    trainerVisibilitySubscriptionInstalled: false,
    trainerEndedSubscriptionInstalled: false,
    unavailableTitlesFetchKey: null,
    unavailableTitlesFetchPromise: null,
    unavailableTitlesById: {},
    trainerApiService: null,
    trainerService: null,
    trainerLaunchRequestCtor: null,
    commandListenerInstalled: false,
    missingOptionalServiceWarnings: new Set(),
    currentGameSession: createIdleGameSession(),
    currentRunningTrainer: createIdleTrainerStatus(),
    resolveRemoteCommandServices: null,
    queueSync: null,
    queueFollowUpSync: null,
  }
}

function setBootstrapReason(state, reason) {
  if (
    reason === state.lastBootstrapReason &&
    state.bootstrapAttempts % BOOTSTRAP_LOG_THROTTLE_ATTEMPTS !== 0
  ) {
    return
  }

  state.lastBootstrapReason = reason
  state.log(
    "info",
    `Bootstrap waiting: ${reason}.`,
    `attempt=${state.bootstrapAttempts + 1}/${MAX_BOOTSTRAP_ATTEMPTS}`
  )
}

async function bindBridge(state) {
  if (state.bridgeBound || state.bridgeBinding || !state.ipcRenderer) {
    return
  }

  if (!state.commandListenerInstalled) {
    state.ipcRenderer.on(COMMAND_REQUEST_CHANNEL, (event, request) =>
      handleRemoteCommandRequest(state, event, request)
    )
    state.commandListenerInstalled = true
    state.log("info", "Bridge remote command handler installed.")
  }

  // Await the bind: invoke rejects asynchronously, so marking the bridge bound up
  // front left set-value permanently dead whenever the main-process handler was not
  // registered yet - and the log still claimed success.
  state.bridgeBinding = true
  try {
    await state.ipcRenderer.invoke(BIND_CHANNEL)
    state.bridgeBound = true
    state.log("info", "Bridge set-value handler bound.")
  } catch (error) {
    state.log("warn", "Bridge bind failed; will retry on the next sync.", formatError(error))
  } finally {
    state.bridgeBinding = false
  }
}

async function syncInstalledApps(state, force = false) {
  if (!state.ipcRenderer || (!state.installedAppsService && !state.storeRef)) {
    return false
  }

  const data = resolveInstalledData(state)
  if (!data) {
    if (state.installedAppsService) {
      state.log(
        "warn",
        "Service resolved but installedApps is empty/undefined. Store fallback also unavailable."
      )
    }
    return false
  }

  if (Object.keys(data.rawInstalledApps).length > 0) {
    await refreshUnavailableTitles(state, data.rawInstalledApps, force)
  }

  const snapshot = buildSnapshot(state)
  if (!snapshot) {
    state.log("warn", "Snapshot build returned nothing.")
    return false
  }

  const signature = makeInstalledAppsSignature(snapshot)
  if (!force && signature === state.lastSignature) {
    return false
  }

  state.lastSignature = signature

  const sent = await invokeIpc(
    state,
    SYNC_CHANNEL,
    snapshot,
    "Installed apps snapshot",
    "error"
  )
  if (sent) {
    state.log(
      "info",
      "Installed apps snapshot sent.",
      `apps=${snapshot.apps.length}, catalogGames=${snapshot.diagnostics.catalogGames}, rawInstalledApps=${snapshot.diagnostics.rawInstalledApps}`
    )
  }
  return sent
}

function queueSync(state, force = false) {
  if (state.refreshTimer) {
    clearTimeout(state.refreshTimer)
  }

  state.refreshTimer = setTimeout(() => {
    state.refreshTimer = null
    void syncInstalledApps(state, force)
  }, 0)
}

function queueFollowUpSync(state) {
  if (state.followUpSyncTimer) {
    clearTimeout(state.followUpSyncTimer)
  }

  state.followUpSyncTimer = setTimeout(() => {
    state.followUpSyncTimer = null
    void syncInstalledApps(state, true)
  }, FOLLOW_UP_SYNC_DELAY_MS)
}

function patchRefreshApps(state) {
  if (
    !state.installedAppsService ||
    state.refreshPatched ||
    typeof state.installedAppsService.refreshApps !== "function"
  ) {
    return
  }

  const originalRefreshApps = state.installedAppsService.refreshApps.bind(
    state.installedAppsService
  )
  state.refreshPatched = true
  state.log("info", "refreshApps hook installed.")

  state.installedAppsService.refreshApps = async (...args) => {
    const result = await originalRefreshApps(...args)
    state.log("info", "refreshApps completed; queueing installed apps sync.")
    queueSync(state, true)
    queueFollowUpSync(state)
    return result
  }
}

function resolveRemoteCommandServices(state) {
  const container = getAureliaContainer()
  const webpackRequire = getWebpackRequire()
  if (!container || !webpackRequire) {
    return false
  }

  resolveRuntimeServices(state, container, webpackRequire)
  return true
}

function resolveRuntimeServices(state, container, webpackRequire) {
  resolveOptionalServices(state, container, webpackRequire)
  installGameStatusSubscriptions(state)

  if (!hasMissingOptionalServices(state)) {
    stopOptionalServicesRetry(state)
  }
}

function stopOptionalServicesRetry(state) {
  if (!state.optionalServicesTimer) {
    return
  }

  clearInterval(state.optionalServicesTimer)
  state.optionalServicesTimer = null
}

function startOptionalServicesRetry(state) {
  if (state.optionalServicesTimer || !hasMissingOptionalServices(state)) {
    return
  }

  state.optionalServicesTimer = setInterval(() => {
    state.optionalServicesAttempts += 1

    const container = getAureliaContainer()
    const webpackRequire = getWebpackRequire()
    if (container && webpackRequire) {
      resolveRuntimeServices(state, container, webpackRequire)
    }

    if (
      state.optionalServicesTimer &&
      state.optionalServicesAttempts >= MAX_OPTIONAL_SERVICES_ATTEMPTS
    ) {
      stopOptionalServicesRetry(state)
      state.log(
        "warn",
        "Optional service retry exhausted.",
        `attempts=${state.optionalServicesAttempts}`
      )
    }
  }, OPTIONAL_SERVICES_RETRY_INTERVAL_MS)

  state.log(
    "info",
    "Optional service retry timer started.",
    `${OPTIONAL_SERVICES_RETRY_INTERVAL_MS}ms`
  )
}

function bootstrap(state) {
  if (!hasAppRoot()) {
    setBootstrapReason(state, "app root not ready")
    return false
  }

  if (!state.ipcRenderer && !resolveIpcRenderer(state)) {
    return false
  }

  const webpackRequire = getWebpackRequire()
  if (!webpackRequire) {
    setBootstrapReason(state, "webpack runtime not ready")
    return false
  }

  const container = getAureliaContainer()
  if (!container) {
    logMissingContainer(state)
    setBootstrapReason(state, "Aurelia container not ready")
    return false
  }

  state.log("info", "Aurelia container resolved.")

  if (!state.storeRef) {
    state.storeRef = getStoreRef(state, container, webpackRequire)
    if (!state.storeRef) {
      state.log(
        "warn",
        "Store reference unavailable; unsupported installed titles will be missing."
      )
    }
  }

  state.installedAppsService = getInstalledAppsService(
    state,
    container,
    webpackRequire
  )
  if (!state.installedAppsService) {
    setBootstrapReason(state, "installed apps service not ready")
    return false
  }

  resolveRuntimeServices(state, container, webpackRequire)
  startOptionalServicesRetry(state)

  if (!isRecord(state.installedAppsService.installedApps)) {
    state.log(
      "info",
      "Service instance has no installedApps data yet; reading from store until refreshApps populates it."
    )
    if (!state.storeRef) {
      state.log("warn", "Store fallback also unavailable; will retry on poll.")
    }
  }

  void bindBridge(state)
  patchRefreshApps(state)
  queueSync(state, true)
  queueFollowUpSync(state)
  startPollTimer(state)

  state.log("info", "Installed apps sync ready.")
  return true
}

function resolveIpcRenderer(state) {
  const electron = getRequire()?.("electron")
  if (!electron?.ipcRenderer) {
    setBootstrapReason(state, "electron ipcRenderer not ready")
    return false
  }

  state.ipcRenderer = electron.ipcRenderer
  state.log("info", "Electron ipcRenderer resolved.")
  return true
}

function startPollTimer(state) {
  if (state.pollTimer) {
    return
  }

  state.pollTimer = setInterval(() => {
    if (hasUnresolvedServices(state)) {
      const container = getAureliaContainer()
      const webpackRequire = getWebpackRequire()
      if (container && webpackRequire) {
        resolveRuntimeServices(state, container, webpackRequire)
      }
    }

    void bindBridge(state)
    void syncInstalledApps(state)
  }, SYNC_INTERVAL_MS)

  state.log(
    "info",
    "Installed apps poll timer started.",
    `${SYNC_INTERVAL_MS}ms`
  )
}

function logMissingContainer(state) {
  if (state.bootstrapAttempts % CONTAINER_LOG_THROTTLE_ATTEMPTS !== 0) {
    return
  }

  const root = getAppRoot()
  const aureliaKeys = root
    ? Object.getOwnPropertyNames(root)
        .filter((key) => key.startsWith("__") || key === "au")
        .join(", ")
    : "root=null"
  state.log(
    "warn",
    "Aurelia container not found.",
    `rootProps=${aureliaKeys || "(none)"}, subtree=${summarizeAureliaSubtree(root)}`
  )
}

function retryBootstrap(state) {
  if (bootstrap(state)) {
    return
  }

  state.bootstrapAttempts += 1
  if (state.bootstrapAttempts < MAX_BOOTSTRAP_ATTEMPTS) {
    setTimeout(() => retryBootstrap(state), RETRY_DELAY_MS)
    return
  }

  state.log(
    "error",
    "Installed apps sync bootstrap exhausted.",
    state.lastBootstrapReason || "unknown reason"
  )
}