Function ProcessManager

src/components/ProcessManager.tsx:142–263

()

}

export default function ProcessManager() {
  const [processes, setProcesses] = useState<ProcessInfo[]>([]);
  const [search, setSearch] = useState("");
  const [icons, setIcons] = useState<Record<number, string>>({});
  const [speedMap, setSpeedMap] = useState<Map<number, SpeedState>>(new Map());
  const [selectedPid, setSelectedPid] = useState<number | null>(null);
  const { settings } = useSettings();
  const { speed, setSpeed, commitSpeed } = useSpeed();
  const { notify } = useSnackbar();
  const { t } = useTranslation();

  const gears = useMemo(() => settings
    ? [1, 2, 3, 4, 5].map(i => (settings[`gear${i}Speed` as keyof typeof settings] as number) || 1)
    : [1, 2, 5, 10, 100],
  [settings]);

  // Derive enabled set for UI
  const enabled = useMemo(() => {
    const s = new Set<number>();
    for (const [pid, st] of speedMap) { if (st.enabled) s.add(pid); }
    return s;
  }, [speedMap]);

  // Toggle — optimistic update with rollback on failure
  async function toggle(pid: number, arch: string) {
    const cur = speedMap.get(pid);
    const wasOn = cur?.enabled ?? false;
    const wasInjected = cur?.injected ?? false;

    if (!wasOn) {
      // Turning ON
      if (!wasInjected) {
        // First time inject
        setSpeedMap(prev => { const n = new Map(prev); n.set(pid, { injected: true, enabled: true, arch }); return n; });
        const ok = await invoke<boolean>("bridge_inject", { pid, arch }).catch((e) => { console.error("[toggle] bridge_inject error:", e); return false; });
        console.log("[toggle] bridge_inject result:", ok);
        if (!ok) {
          setSpeedMap(prev => { const n = new Map(prev); n.delete(pid); return n; });
          notify(t("process.injectFail"), "error");
        }
      } else {
        // Already injected — re-enable
        setSpeedMap(prev => { const n = new Map(prev); n.set(pid, { ...cur!, enabled: true }); return n; });
        const ok = await invoke<boolean>("bridge_enable", { pid, arch }).catch(() => false);
        if (!ok) {
          setSpeedMap(prev => { const n = new Map(prev); n.set(pid, cur!); return n; });
          notify(t("process.enableFail"), "error");
        }
      }
    } else {
      // Turning OFF
      setSpeedMap(prev => { const n = new Map(prev); n.set(pid, { ...cur!, enabled: false }); return n; });
      const ok = await invoke<boolean>("bridge_disable", { pid, arch }).catch(() => false);
      if (!ok) {
        setSpeedMap(prev => { const n = new Map(prev); n.set(pid, cur!); return n; });
        notify(t("process.disableFail"), "error");
      }
    }