feat: prevent scroll/state loss during pane drags and refactor sleep inhibitor

- fix(dnd): preserve chat scroll position across pane swaps via stable pane sort, scroller data attribute, drag overlay, and AutoScroller opt-out
- fix(scroll): memoize useScrollFade setter to keep virtualizer scroll element stable
- refactor(main): extract powerSaveBlocker logic into testable createSleepInhibitor module
- test: add coverage for sleepInhibitor and useScrollFade

Author: SDSLeon

src/main/main.ts

@@ -1,11 +1,12 @@
 import { watch } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { app, BrowserWindow, powerSaveBlocker } from "electron";
+import { app, BrowserWindow } from "electron";
 import { closeDatabase, dbGetThreads, initDatabase } from "./db";
 import { cleanupOrphanedAttachments, prepareLightcodeDataRoot } from "./lightcodeData";
 import { createLocalIpcHandlers } from "./ipc/localHandlers";
 import { registerIpcHandlers } from "./ipc/registerHandlers";
+import { createSleepInhibitor } from "./sleepInhibitor";
 import {
   installLocalFileProtocolHandler,
   registerLocalFileProtocolScheme,
@@ -44,7 +45,7 @@ let lightcodePaths: LightcodePaths | null = null;
 let windowsJobObjectManager: WindowsJobObjectManager | null = null;
 
 const workingThreads = new Set<string>();
-let powerSaveBlockerId: number | null = null;
+const sleepInhibitor = createSleepInhibitor();
 
 function requireLightcodePaths(): LightcodePaths {
   if (!lightcodePaths) {
@@ -55,17 +56,9 @@ function requireLightcodePaths(): LightcodePaths {
 
 function updatePowerSaveBlocker(): void {
   const enabled = lightcodePaths
-    ? (readSharedSettingsFile(lightcodePaths.settingsPath).preventSleepWhileWorking ?? true)
+    ? readSharedSettingsFile(lightcodePaths.settingsPath).preventSleepWhileWorking
     : true;
-  const shouldBlock = enabled && workingThreads.size > 0;
-  if (shouldBlock && powerSaveBlockerId === null) {
-    powerSaveBlockerId = powerSaveBlocker.start("prevent-app-suspension");
-  } else if (!shouldBlock && powerSaveBlockerId !== null) {
-    if (powerSaveBlocker.isStarted(powerSaveBlockerId)) {
-      powerSaveBlocker.stop(powerSaveBlockerId);
-    }
-    powerSaveBlockerId = null;
-  }
+  sleepInhibitor.setActive(enabled && workingThreads.size > 0);
 }
 
 function handleSupervisorEventForSleep(event: SupervisorEvent): void {
@@ -270,6 +263,7 @@ if (!hasSingleInstanceLock) {
       supervisorClient.dispose();
       windowsJobObjectManager?.dispose();
       windowsJobObjectManager = null;
+      sleepInhibitor.dispose();
     });
   });
 }

src/main/sleepInhibitor.test.ts

@@ -0,0 +1,217 @@
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("electron", () => ({
+  powerSaveBlocker: {
+    start: vi.fn<(type: string) => number>(() => -1),
+    stop: vi.fn<(id: number) => void>(),
+    isStarted: vi.fn<(id: number) => boolean>(() => false),
+  },
+}));
+
+import { createSleepInhibitor } from "./sleepInhibitor";
+
+interface FakeChildProcess extends EventEmitter {
+  stdin: { end: ReturnType<typeof vi.fn<() => void>> } | null;
+  kill: ReturnType<typeof vi.fn<(signal?: string) => boolean>>;
+}
+
+function createFakeChild(): FakeChildProcess {
+  const emitter = new EventEmitter() as FakeChildProcess;
+  emitter.stdin = { end: vi.fn<() => void>() };
+  emitter.kill = vi.fn<(signal?: string) => boolean>(() => true);
+  return emitter;
+}
+
+function createBlocker() {
+  let nextId = 1;
+  const started = new Set<number>();
+  return {
+    start: vi.fn<(type: string) => number>(() => {
+      const id = nextId++;
+      started.add(id);
+      return id;
+    }),
+    stop: vi.fn<(id: number) => void>((id: number) => {
+      started.delete(id);
+    }),
+    isStarted: vi.fn<(id: number) => boolean>((id: number) => started.has(id)),
+    _started: started,
+  };
+}
+
+let logs: string[] = [];
+const logger = (message: string) => {
+  logs.push(message);
+};
+
+beforeEach(() => {
+  logs = [];
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("createSleepInhibitor", () => {
+  it("starts and stops the electron blocker on non-linux platforms", () => {
+    const blocker = createBlocker();
+    const spawnFn = vi.fn<() => ChildProcess>();
+    const inhibitor = createSleepInhibitor({
+      platform: "darwin",
+      electronBlocker: blocker,
+      spawnFn: spawnFn as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+    expect(blocker.start).toHaveBeenCalledWith("prevent-app-suspension");
+    expect(blocker._started.size).toBe(1);
+    expect(spawnFn).not.toHaveBeenCalled();
+
+    inhibitor.setActive(false);
+    expect(blocker.stop).toHaveBeenCalledTimes(1);
+    expect(blocker._started.size).toBe(0);
+  });
+
+  it("is idempotent on repeated setActive(true)", () => {
+    const blocker = createBlocker();
+    const inhibitor = createSleepInhibitor({
+      platform: "win32",
+      electronBlocker: blocker,
+      spawnFn: vi.fn<() => ChildProcess>() as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+    inhibitor.setActive(true);
+    inhibitor.setActive(true);
+
+    expect(blocker.start).toHaveBeenCalledTimes(1);
+  });
+
+  it("logs when powerSaveBlocker.start fails to activate", () => {
+    const blocker = createBlocker();
+    blocker.isStarted = vi.fn<(id: number) => boolean>(() => false);
+    const inhibitor = createSleepInhibitor({
+      platform: "darwin",
+      electronBlocker: blocker,
+      spawnFn: vi.fn<() => ChildProcess>() as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+
+    expect(logs.some((l) => l.includes("powerSaveBlocker.start did not activate"))).toBe(true);
+
+    inhibitor.setActive(false);
+    expect(blocker.stop).not.toHaveBeenCalled();
+  });
+
+  it("spawns systemd-inhibit on linux alongside the electron blocker", () => {
+    const blocker = createBlocker();
+    const child = createFakeChild();
+    const spawnFn = vi.fn<() => ChildProcess>(() => child as unknown as ChildProcess);
+    const inhibitor = createSleepInhibitor({
+      platform: "linux",
+      electronBlocker: blocker,
+      spawnFn: spawnFn as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+
+    expect(blocker.start).toHaveBeenCalled();
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+    expect(spawnFn).toHaveBeenCalledWith(
+      "systemd-inhibit",
+      [
+        "--what=sleep:idle",
+        "--who=Lightcode",
+        "--why=Agent thread is working",
+        "--mode=block",
+        "cat",
+      ],
+      expect.objectContaining({ detached: false }),
+    );
+  });
+
+  it("releases the systemd-inhibit child on setActive(false)", () => {
+    const blocker = createBlocker();
+    const child = createFakeChild();
+    const spawnFn = vi.fn<() => ChildProcess>(() => child as unknown as ChildProcess);
+    const inhibitor = createSleepInhibitor({
+      platform: "linux",
+      electronBlocker: blocker,
+      spawnFn: spawnFn as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+    inhibitor.setActive(false);
+
+    expect(child.stdin!.end).toHaveBeenCalled();
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+  });
+
+  it("disables systemd-inhibit after a spawn throw and does not retry", () => {
+    const blocker = createBlocker();
+    const spawnFn = vi.fn<() => ChildProcess>(() => {
+      throw new Error("ENOENT systemd-inhibit");
+    });
+    const inhibitor = createSleepInhibitor({
+      platform: "linux",
+      electronBlocker: blocker,
+      spawnFn: spawnFn as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+    inhibitor.setActive(false);
+    inhibitor.setActive(true);
+
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+    expect(logs.some((l) => l.includes("systemd-inhibit unavailable"))).toBe(true);
+    expect(blocker.start).toHaveBeenCalledTimes(2);
+  });
+
+  it("disables systemd-inhibit after a runtime error event", () => {
+    const blocker = createBlocker();
+    const child = createFakeChild();
+    const spawnFn = vi.fn<() => ChildProcess>(() => child as unknown as ChildProcess);
+    const inhibitor = createSleepInhibitor({
+      platform: "linux",
+      electronBlocker: blocker,
+      spawnFn: spawnFn as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+    child.emit("error", new Error("spawn failed"));
+
+    inhibitor.setActive(false);
+    inhibitor.setActive(true);
+
+    expect(spawnFn).toHaveBeenCalledTimes(1);
+    expect(logs.some((l) => l.includes("systemd-inhibit failed"))).toBe(true);
+  });
+
+  it("dispose() releases all inhibitors", () => {
+    const blocker = createBlocker();
+    const child = createFakeChild();
+    const spawnFn = vi.fn<() => ChildProcess>(() => child as unknown as ChildProcess);
+    const inhibitor = createSleepInhibitor({
+      platform: "linux",
+      electronBlocker: blocker,
+      spawnFn: spawnFn as never,
+      logger,
+    });
+
+    inhibitor.setActive(true);
+    inhibitor.dispose();
+
+    expect(blocker.stop).toHaveBeenCalled();
+    expect(child.kill).toHaveBeenCalledWith("SIGTERM");
+  });
+});