1 files changed, 10 insertions, 75 deletions

diff --git a/src/hooks/usePerAppWorkarounds.ts b/src/hooks/usePerAppWorkarounds.ts
index e9e44e1..ab33bb2 100644
--- a/src/hooks/usePerAppWorkarounds.ts
+++ b/src/hooks/usePerAppWorkarounds.ts
@@ -3,14 +3,12 @@ import {
   getWorkaroundState,
   removeWorkaroundState,
   setWorkaroundState,
-  type TargetTransport,
   type WorkaroundState,
 } from "../api/lsfgApi";
 import {
   getDefaultWrapperPath,
-  hasWrapperLaunchIntegration,
   installWrapperIntegration,
-  isLegacyWrapperToken,
+  isWrapperIntegrationInstalled,
   readSteamLaunchOptions,
   removeWrapperIntegration,
   subscribeSteamLaunchOptions,
@@ -45,8 +43,6 @@ export interface WorkaroundSnapshot {
   wrapperOwned: boolean;
   integrationInstalled: boolean;
   commandTokenAdded: boolean;
-  shortcutExe?: string | null;
-  transport: TargetTransport;
 }
 
 interface PerAppWorkarounds {
@@ -61,26 +57,6 @@ function asError(error: unknown): Error {
   return error instanceof Error ? error : new Error(String(error));
 }
 
-function selectShortcutExecutable(
-  transport: TargetTransport,
-  ...candidates: Array<string | null | undefined>
-): string | undefined {
-  const absolute = candidates
-    .map((candidate) => candidate?.trim())
-    .find((candidate) => candidate && candidate.startsWith("/"));
-  if (absolute) return absolute;
-  if (transport.kind === "flatpak") return "/usr/bin/flatpak";
-  return candidates.map((candidate) => candidate?.trim()).find(Boolean);
-}
-
-function integrationIsInstalled(
-  steam: SteamLaunchOptionsSnapshot,
-  nonSteam: boolean,
-  wrapperPath: string,
-): boolean {
-  return nonSteam ? steam.target === wrapperPath : hasWrapperLaunchIntegration(steam.options, wrapperPath);
-}
-
 function makeSnapshot(
   steam: SteamLaunchOptionsSnapshot,
   result: Awaited<ReturnType<typeof getWorkaroundState>>,
@@ -88,75 +64,43 @@ function makeSnapshot(
 ): WorkaroundSnapshot {
   if (!result.state) throw new Error("Workaround state is not initialized for this profile");
   const wrapperPath = result.wrapper_path || getDefaultWrapperPath();
-  if (nonSteam && steam.target === wrapperPath && !result.shortcut_exe) {
-    throw new Error("Managed shortcut Target has no saved original executable");
-  }
   return {
     steam,
     state: result.state,
     wrapperPath,
     wrapperOwned: result.wrapper_owned === true,
-    integrationInstalled: integrationIsInstalled(steam, nonSteam, wrapperPath),
+    integrationInstalled: isWrapperIntegrationInstalled(steam, nonSteam, wrapperPath),
     commandTokenAdded: result.command_token_added === true,
-    shortcutExe: result.shortcut_exe,
-    transport: result.transport || { kind: "host" },
   };
 }
 
 async function adoptWorkaroundState(
   appId: string,
   nonSteam: boolean,
-  transport: TargetTransport,
-  steam: SteamLaunchOptionsSnapshot,
   wrapperPath: string,
 ): Promise<WorkaroundSnapshot> {
-  if (nonSteam && (!steam.target || steam.target === wrapperPath || isLegacyWrapperToken(steam.target))) {
-    throw new Error("Shortcut Target is a wrapper but its original Target is unknown");
-  }
-  const originalExecutable = nonSteam
-    ? selectShortcutExecutable(transport, steam.target)
-    : null;
-  const initial = await setWorkaroundState(
-    appId,
-    DEFAULT_WORKAROUND_STATE,
-    originalExecutable,
-    false,
-    transport,
-  );
-  if (!initial.success) throw new Error(initial.error || "Could not create workaround state");
   let integration: Awaited<ReturnType<typeof installWrapperIntegration>> | null = null;
   try {
-    integration = await installWrapperIntegration(
-      Number(appId),
-      nonSteam,
-      wrapperPath,
-    );
+    integration = await installWrapperIntegration(Number(appId), nonSteam, wrapperPath, false);
     const finalized = await setWorkaroundState(
       appId,
       DEFAULT_WORKAROUND_STATE,
-      nonSteam
-        ? (selectShortcutExecutable(transport, integration.originalExecutable, originalExecutable) || null)
-        : null,
       integration.commandTokenAdded,
-      transport,
+      nonSteam,
     );
     if (!finalized.success) throw new Error(finalized.error || "Could not finalize workaround state");
     return makeSnapshot(integration.snapshot, finalized, nonSteam);
   } catch (error) {
     let rollbackSucceeded = true;
-    if (integration) {
+    if (integration?.changed) {
       try {
         await removeWrapperIntegration(
           Number(appId),
           nonSteam,
           wrapperPath,
-          nonSteam
-            ? (selectShortcutExecutable(transport, integration?.originalExecutable, originalExecutable) || undefined)
-            : undefined,
-          integration?.commandTokenAdded ?? false,
+          integration.commandTokenAdded,
         );
       } catch {
-        // Leave the owned integration in place rather than guessing at cleanup.
         rollbackSucceeded = false;
       }
     }
@@ -168,11 +112,7 @@ async function adoptWorkaroundState(
   }
 }
 
-export function usePerAppWorkarounds(
-  appId: string,
-  nonSteam: boolean,
-  transport: TargetTransport = { kind: "host" },
-): PerAppWorkarounds {
+export function usePerAppWorkarounds(appId: string, nonSteam: boolean): PerAppWorkarounds {
   const [status, setStatus] = useState<WorkaroundLoadStatus>("loading");
   const [snapshot, setSnapshot] = useState<WorkaroundSnapshot | null>(null);
   const [error, setError] = useState<string | null>(null);
@@ -189,13 +129,11 @@ export function usePerAppWorkarounds(
       return adoptWorkaroundState(
         appId,
         nonSteam,
-        transport,
-        steam,
         result.wrapper_path || getDefaultWrapperPath(),
       );
     }
     return makeSnapshot(steam, result, nonSteam);
-  }, [appId, nonSteam, numericAppId, transport]);
+  }, [appId, nonSteam, numericAppId]);
 
   const applySnapshot = useCallback((next: WorkaroundSnapshot) => {
     setSnapshot(next);
@@ -230,7 +168,7 @@ export function usePerAppWorkarounds(
           setSnapshot((current) => current ? {
             ...current,
             steam,
-            integrationInstalled: integrationIsInstalled(steam, nonSteam, current.wrapperPath),
+            integrationInstalled: isWrapperIntegrationInstalled(steam, nonSteam, current.wrapperPath),
           } : current);
         },
         (subscriptionError) => {
@@ -268,9 +206,8 @@ export function usePerAppWorkarounds(
       const result = await setWorkaroundState(
         appId,
         nextState,
-        current.shortcutExe ?? null,
         current.commandTokenAdded,
-        current.transport,
+        nonSteam,
       );
       if (!result.success || !result.state) throw new Error(result.error || "Could not save workaround state");
       applySnapshot({
@@ -278,9 +215,7 @@ export function usePerAppWorkarounds(
         state: result.state,
         wrapperPath: result.wrapper_path || current.wrapperPath,
         wrapperOwned: result.wrapper_owned === true,
-        shortcutExe: result.shortcut_exe,
         commandTokenAdded: result.command_token_added === true,
-        transport: result.transport || current.transport,
       });
       return true;
     } catch (updateError) {