Recovery Coremod

src/renderer/coremods/recovery/index.tsx

@@ -0,0 +1,155 @@
+import { fluxDispatcher, parser, toast } from "@common";
+import { Button } from "@components";
+import { Injector, Logger } from "@replugged";
+import { filters, getByProps, waitForModule } from "@webpack";
+import "./styles.css";
+import { AnyFunction } from "../../../types";
+import { Messages } from "@common/i18n";
+
+import { generalSettings } from "../settings/pages";
+import { disable } from "../../managers/plugins";
+import { Tree, findInTree } from "../../util";
+const injector = new Injector();
+
+// const URL_REGEX_FIND = /https:\/\/\S+/g;
+const PLUGIN_ID_FIND_REGEX = /plugin\/(.*?)\.asar/;
+const FIND_ERROR_NUMBER = /invariant=(\d+)&/;
+const ReactErrorList =
+  "https://raw.githubusercontent.com/facebook/react/v18.2.0/scripts/error-codes/codes.json";
+const ReactErrorListFallback =
+  "https://raw.githubusercontent.com/facebook/react/v17.0.0/scripts/error-codes/codes.json";
+const logger = Logger.coremod("recovery");
+let ReactErrors: Record<string, string> | undefined;
+
+interface ErrorComponentState {
+  error: {
+    message: string;
+    stack: string;
+  } | null;
+  info: null;
+}
+interface ErrorScreenClass {
+  prototype: {
+    render: AnyFunction;
+  };
+}
+interface ErrorScreenInstance {
+  state?: ErrorComponentState;
+  setState: (state: ErrorComponentState) => void;
+}
+
+interface Modals {
+  closeAllModals: AnyFunction;
+}
+
+interface RouteInstance {
+  transitionTo: (location: string) => void;
+}
+
+const ModalModule: Modals | undefined = getByProps("openModalLazy");
+const RouteModule: RouteInstance | undefined = getByProps("transitionTo");
+
+function startMainRecovery(): void {
+  const log = (reason: string): void => logger.log(reason),
+    err = (reason: string): void => logger.error(reason);
+  log("Starting main recovery methods.");
+  if (!ModalModule) {
+    err("Could not find `openModalLazy` Module.");
+    return;
+  }
+
+  try {
+    // I think trying to transition first is a better move.
+    // Considering most errors come from patching.
+    RouteModule?.transitionTo("/channels/@me");
+  } catch {
+    err("Failed to transition to '/channels/@me'.");
+  }
+
+  try {
+    fluxDispatcher.dispatch({ type: "CONTEXT_MENU_CLOSE" });
+  } catch {
+    err("ContextMenu's could not be closed.");
+  }
+
+  try {
+    ModalModule.closeAllModals();
+  } catch {
+    err("Could not close (most) modals.");
+  }
+
+  log("Ended main recovery.");
+}
+interface TreeNode {
+  children: React.ReactElement[];
+}
+export async function start(): Promise<void> {
+  const ErrorScreen = await waitForModule<ErrorScreenClass>(
+    filters.bySource(".AnalyticEvents.APP_CRASHED"),
+  );
+  void startErrors();
+  injector.after(
+    ErrorScreen.prototype,
+    "render",
+    (_args, res: React.ReactElement, instance: ErrorScreenInstance): void => {
+      if (generalSettings.get("automaticRecover")) {
+        startMainRecovery();
+        instance.setState({ error: null, info: null });
+      }
+      if (!instance.state?.error) return;
+      const {
+        props: { children },
+      }: { props: TreeNode } = findInTree(res as unknown as Tree, (x) => Boolean(x?.action))
+        ?.action as {
+        props: TreeNode;
+      };
+      if (!instance.state.error) return;
+      const stackError = instance.state.error.stack;
+      const pluginId = stackError.match(PLUGIN_ID_FIND_REGEX);
+      if (pluginId) {
+        void disable(pluginId[1]);
+        toast.toast(
+          Messages.REPLUGGED_TOAST_ADDON_DISABLE_SUCCESS.format({
+            name: pluginId[1],
+          }),
+          toast.Kind.SUCCESS,
+        );
+      }
+
+      const invar = stackError.match(FIND_ERROR_NUMBER);
+
+      children.push(
+        <>
+          <Button
+            className={`replugged-recovery-button`}
+            onClick={() => {
+              startMainRecovery();
+              instance.setState({ error: null, info: null });
+            }}>
+            Recover Discord
+          </Button>
+          <div className={"recovery-parse"}>
+            {parser.parse(`\`\`\`${invar ? ReactErrors?.[invar[1]] : ""}\n\n${stackError}\`\`\``)}
+          </div>
+        </>,
+      );
+    },
+  );
+}
+
+export function stop(): void {
+  injector.uninjectAll();
+}
+
+export async function startErrors(): Promise<void> {
+  ReactErrors = await fetch(ReactErrorList)
+    .then((response) => response.json())
+    .catch(async (error) => {
+      logger.error("ReactErrorList Fail:", error);
+      return await fetch(ReactErrorListFallback).then((response) => response.json());
+    })
+    .catch((error) => {
+      logger.error("ReactErrorListFallback Fail:", error, "\nFalling back to {}");
+      return {};
+    });
+}

src/renderer/coremods/recovery/styles.css

@@ -0,0 +1,21 @@
+[class*="errorPage"] [class*="buttons_"] {
+  flex-direction: column;
+  align-items: center;
+}
+[class*="errorPage"] [class*="buttons_"] [class*="button__"] {
+  width: 400px;
+  margin: 5px;
+}
+.replugged-recovery-button {
+  width: var(--custom-button-button-lg-width);
+  height: var(--custom-button-button-lg-height);
+  min-width: var(--custom-button-button-lg-width);
+  min-height: var(--custom-button-button-lg-height);
+
+  background-color: var(--button-danger-background) !important;
+}
+[class*="errorPage"] [class*="scrollbarGhostHairline"] {
+  white-space: break-spaces;
+  width: 80vw;
+  text-align: center;
+}

src/renderer/coremods/settings/pages/General.tsx

@@ -97,6 +97,12 @@ export const General = (): React.ReactElement => {
         {Messages.REPLUGGED_SETTINGS_BADGES}
       </SwitchItem>
 
+      <SwitchItem
+        {...util.useSetting(generalSettings, "automaticRecover")}
+        note={"Allows Discord to try to automatically recover from a crash."}>
+        {"Automatic Recovery"}
+      </SwitchItem>
+
       <SwitchItem
         {...util.useSetting(generalSettings, "addonEmbeds")}
         note={Messages.REPLUGGED_SETTINGS_ADDON_EMBEDS_DESC}>

src/renderer/managers/coremods.ts

@@ -35,6 +35,7 @@ export namespace coremods {
   export let watcher: Coremod;
   export let commands: Coremod;
   export let welcome: Coremod;
+  export let recovery: Coremod;
 }
 
 export async function start(name: keyof typeof coremods): Promise<void> {
@@ -60,6 +61,7 @@ export async function startAll(): Promise<void> {
   coremods.watcher = await import("../coremods/watcher");
   coremods.commands = await import("../coremods/commands");
   coremods.welcome = await import("../coremods/welcome");
+  coremods.recovery = await import("../coremods/recovery");
   coremods.notrack = await import("../coremods/notrack");
 
   await Promise.all(

src/renderer/modules/injector.ts

@@ -20,9 +20,9 @@ enum InjectionTypes {
  * @param self The module the injected function is on
  * @returns New arguments to pass to the original function, or undefined to leave them unchanged
  */
-export type BeforeCallback<A extends unknown[] = unknown[]> = (
+export type BeforeCallback<A extends unknown[] = unknown[], I = ObjectExports> = (
   args: A,
-  self: ObjectExports,
+  self: I,
 ) => A | undefined | void;
 
 /**
@@ -32,10 +32,10 @@ export type BeforeCallback<A extends unknown[] = unknown[]> = (
  * @param self The module the injected function is on
  * @returns New result to return
  */
-export type InsteadCallback<A extends unknown[] = unknown[], R = unknown> = (
+export type InsteadCallback<A extends unknown[] = unknown[], R = unknown, I = ObjectExports> = (
   args: A,
   orig: (...args: A) => R,
-  self: ObjectExports,
+  self: I,
 ) => R | void;
 
 /**
@@ -45,10 +45,10 @@ export type InsteadCallback<A extends unknown[] = unknown[], R = unknown> = (
  * @param self The module the injected function is on
  * @returns New result to return, or undefined to leave it unchanged
  */
-export type AfterCallback<A extends unknown[] = unknown[], R = unknown> = (
+export type AfterCallback<A extends unknown[] = unknown[], R = unknown, I = ObjectExports> = (
   args: A,
   res: R,
-  self: ObjectExports,
+  self: I,
 ) => R | undefined | void;
 
 interface ObjectInjections {
@@ -167,7 +167,8 @@ function before<
   T extends Record<U, AnyFunction>,
   U extends keyof T & string,
   A extends unknown[] = Parameters<T[U]>,
->(obj: T, funcName: U, cb: BeforeCallback<A>): () => void {
+  I = T[U],
+>(obj: T, funcName: U, cb: BeforeCallback<A, I>): () => void {
   // @ts-expect-error 'unknown[]' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype of constraint 'unknown[]'.
   return inject(obj, funcName, cb as BeforeCallback, InjectionTypes.Before);
 }
@@ -177,7 +178,8 @@ function instead<
   U extends keyof T & string,
   A extends unknown[] = Parameters<T[U]>,
   R = ReturnType<T[U]>,
->(obj: T, funcName: U, cb: InsteadCallback<A, R>): () => void {
+  I = T[U],
+>(obj: T, funcName: U, cb: InsteadCallback<A, R, I>): () => void {
   // @ts-expect-error 'unknown[]' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype of constraint 'unknown[]'.
   return inject(obj, funcName, cb, InjectionTypes.Instead);
 }
@@ -187,7 +189,8 @@ function after<
   U extends keyof T & string,
   A extends unknown[] = Parameters<T[U]>,
   R = ReturnType<T[U]>,
->(obj: T, funcName: U, cb: AfterCallback<A, R>): () => void {
+  I = T[U],
+>(obj: T, funcName: U, cb: AfterCallback<A, R, I>): () => void {
   // @ts-expect-error 'unknown[]' is assignable to the constraint of type 'A', but 'A' could be instantiated with a different subtype of constraint 'unknown[]'.
   return inject(obj, funcName, cb, InjectionTypes.After);
 }
@@ -250,7 +253,8 @@ export class Injector {
     U extends keyof T & string,
     A extends unknown[] = Parameters<T[U]>,
     R = ReturnType<T[U]>,
-  >(obj: T, funcName: U, cb: InsteadCallback<A, R>): () => void {
+    I = T[U],
+  >(obj: T, funcName: U, cb: InsteadCallback<A, R, I>): () => void {
     const uninjector = instead(obj, funcName, cb);
     this.#uninjectors.add(uninjector);
     return uninjector;
@@ -268,7 +272,8 @@ export class Injector {
     U extends keyof T & string,
     A extends unknown[] = Parameters<T[U]>,
     R = ReturnType<T[U]>,
-  >(obj: T, funcName: U, cb: AfterCallback<A, R>): () => void {
+    I = T[U],
+  >(obj: T, funcName: U, cb: AfterCallback<A, R, I>): () => void {
     const uninjector = after(obj, funcName, cb);
     this.#uninjectors.add(uninjector);
     return uninjector;

src/types/settings.ts

@@ -14,6 +14,7 @@ export type GeneralSettings = {
   showWelcomeNoticeOnOpen?: boolean;
   addonEmbeds?: boolean;
   reactDevTools?: boolean;
+  automaticRecover?: boolean;
 };
 
 export const defaultSettings = {
@@ -24,4 +25,5 @@ export const defaultSettings = {
   showWelcomeNoticeOnOpen: true,
   reactDevTools: false,
   addonEmbeds: true,
+  automaticRecover: false,
 } satisfies Partial<GeneralSettings>;