Add a setting to prevent sleep while the agent is working

Author: charlesvien

apps/twig/src/main/di/container.ts

@@ -17,6 +17,7 @@ import { NotificationService } from "../services/notification/service.js";
 import { OAuthService } from "../services/oauth/service.js";
 import { ProcessTrackingService } from "../services/process-tracking/service.js";
 import { ShellService } from "../services/shell/service.js";
+import { SleepService } from "../services/sleep/service.js";
 import { TaskLinkService } from "../services/task-link/service.js";
 import { UIService } from "../services/ui/service.js";
 import { UpdatesService } from "../services/updates/service.js";
@@ -43,6 +44,7 @@ container.bind(MAIN_TOKENS.GitService).to(GitService);
 container.bind(MAIN_TOKENS.NotificationService).to(NotificationService);
 container.bind(MAIN_TOKENS.OAuthService).to(OAuthService);
 container.bind(MAIN_TOKENS.ProcessTrackingService).to(ProcessTrackingService);
+container.bind(MAIN_TOKENS.SleepService).to(SleepService);
 container.bind(MAIN_TOKENS.ShellService).to(ShellService);
 container.bind(MAIN_TOKENS.UIService).to(UIService);
 container.bind(MAIN_TOKENS.UpdatesService).to(UpdatesService);

apps/twig/src/main/di/tokens.ts

@@ -22,6 +22,7 @@ export const MAIN_TOKENS = Object.freeze({
   NotificationService: Symbol.for("Main.NotificationService"),
   OAuthService: Symbol.for("Main.OAuthService"),
   ProcessTrackingService: Symbol.for("Main.ProcessTrackingService"),
+  SleepService: Symbol.for("Main.SleepService"),
   ShellService: Symbol.for("Main.ShellService"),
   UIService: Symbol.for("Main.UIService"),
   UpdatesService: Symbol.for("Main.UpdatesService"),

apps/twig/src/main/services/agent/service.ts

@@ -22,10 +22,12 @@ import { app } from "electron";
 import { inject, injectable, preDestroy } from "inversify";
 import type { ExecutionMode } from "@/shared/types.js";
 import type { AcpMessage } from "../../../shared/types/session-events.js";
+import { container } from "../../di/container.js";
 import { MAIN_TOKENS } from "../../di/tokens.js";
 import { logger } from "../../lib/logger.js";
 import { TypedEventEmitter } from "../../lib/typed-event-emitter.js";
 import type { ProcessTrackingService } from "../process-tracking/service.js";
+import type { SleepService } from "../sleep/service.js";
 import {
   AgentServiceEvent,
   type AgentServiceEvents,
@@ -227,6 +229,10 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     this.processTracking = processTracking;
   }
 
+  private get sleepService() {
+    return container.get<SleepService>(MAIN_TOKENS.SleepService);
+  }
+
   public updateToken(newToken: string): void {
     this.currentToken = newToken;
 
@@ -637,6 +643,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
 
     session.lastActivityAt = Date.now();
     session.promptPending = true;
+    this.sleepService.acquire(sessionId);
 
     try {
       const result = await session.clientSideConnection.prompt({
@@ -663,6 +670,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
       throw err;
     } finally {
       session.promptPending = false;
+      this.sleepService.release(sessionId);
     }
   }
 
@@ -917,6 +925,7 @@ For git operations while detached:
   private async cleanupSession(taskRunId: string): Promise<void> {
     const session = this.sessions.get(taskRunId);
     if (session) {
+      this.sleepService.release(taskRunId);
       try {
         await session.agent.cleanup();
       } catch {
@@ -986,21 +995,28 @@ For git operations while detached:
         // The claude.ts adapter only calls requestPermission when user input is needed.
         // (It handles auto-approve internally for acceptEdits/bypassPermissions modes)
         if (toolCallId) {
-          return new Promise((resolve, reject) => {
-            const key = `${taskRunId}:${toolCallId}`;
-            service.pendingPermissions.set(key, {
-              resolve,
-              reject,
-              sessionId: taskRunId,
-              toolCallId,
-            });
-
-            log.info("Emitting permission request to renderer", {
-              sessionId: taskRunId,
-              toolCallId,
-            });
-            service.emit(AgentServiceEvent.PermissionRequest, params);
-          });
+          service.sleepService.release(taskRunId);
+          try {
+            return await new Promise<RequestPermissionResponse>(
+              (resolve, reject) => {
+                const key = `${taskRunId}:${toolCallId}`;
+                service.pendingPermissions.set(key, {
+                  resolve,
+                  reject,
+                  sessionId: taskRunId,
+                  toolCallId,
+                });
+
+                log.info("Emitting permission request to renderer", {
+                  sessionId: taskRunId,
+                  toolCallId,
+                });
+                service.emit(AgentServiceEvent.PermissionRequest, params);
+              },
+            );
+          } finally {
+            service.sleepService.acquire(taskRunId);
+          }
         }
 
         // Fallback: no toolCallId means we can't track the response, auto-approve

apps/twig/src/main/services/settingsStore.ts

@@ -7,6 +7,7 @@ import Store from "electron-store";
 
 interface SettingsSchema {
   worktreeLocation: string;
+  preventSleepWhileRunning: boolean;
 }
 
 function getDefaultWorktreeLocation(): string {
@@ -50,6 +51,10 @@ const schema = {
     type: "string" as const,
     default: getDefaultWorktreeLocation(),
   },
+  preventSleepWhileRunning: {
+    type: "boolean" as const,
+    default: false,
+  },
 };
 
 export const settingsStore = new Store<SettingsSchema>({
@@ -58,6 +63,7 @@ export const settingsStore = new Store<SettingsSchema>({
   cwd: app.getPath("userData"),
   defaults: {
     worktreeLocation: getDefaultWorktreeLocation(),
+    preventSleepWhileRunning: false,
   },
 });
 

apps/twig/src/main/services/sleep/service.ts

@@ -0,0 +1,64 @@
+import { powerSaveBlocker } from "electron";
+import { injectable, preDestroy } from "inversify";
+import { logger } from "../../lib/logger.js";
+import { settingsStore } from "../settingsStore.js";
+
+const log = logger.scope("sleep");
+
+@injectable()
+export class SleepService {
+  private enabled: boolean;
+  private blockerId: number | null = null;
+  private activeActivities = new Set<string>();
+
+  constructor() {
+    this.enabled = settingsStore.get("preventSleepWhileRunning", false);
+  }
+
+  setEnabled(enabled: boolean): void {
+    log.info("setEnabled", { enabled });
+    this.enabled = enabled;
+    settingsStore.set("preventSleepWhileRunning", enabled);
+    this.updateBlocker();
+  }
+
+  getEnabled(): boolean {
+    return this.enabled;
+  }
+
+  acquire(activityId: string): void {
+    this.activeActivities.add(activityId);
+    this.updateBlocker();
+  }
+
+  release(activityId: string): void {
+    this.activeActivities.delete(activityId);
+    this.updateBlocker();
+  }
+
+  @preDestroy()
+  cleanup(): void {
+    this.stopBlocker();
+  }
+
+  private updateBlocker(): void {
+    if (this.enabled && this.activeActivities.size > 0) {
+      this.startBlocker();
+    } else {
+      this.stopBlocker();
+    }
+  }
+
+  private startBlocker(): void {
+    if (this.blockerId !== null) return;
+    this.blockerId = powerSaveBlocker.start("prevent-app-suspension");
+    log.info("Started power save blocker", { blockerId: this.blockerId });
+  }
+
+  private stopBlocker(): void {
+    if (this.blockerId === null) return;
+    log.info("Stopping power save blocker", { blockerId: this.blockerId });
+    powerSaveBlocker.stop(this.blockerId);
+    this.blockerId = null;
+  }
+}

apps/twig/src/main/trpc/router.ts

@@ -18,6 +18,7 @@ import { osRouter } from "./routers/os.js";
 import { processTrackingRouter } from "./routers/process-tracking.js";
 import { secureStoreRouter } from "./routers/secure-store.js";
 import { shellRouter } from "./routers/shell.js";
+import { sleepRouter } from "./routers/sleep.js";
 import { uiRouter } from "./routers/ui.js";
 import { updatesRouter } from "./routers/updates.js";
 import { workspaceRouter } from "./routers/workspace.js";
@@ -41,6 +42,7 @@ export const trpcRouter = router({
   logs: logsRouter,
   os: osRouter,
   processTracking: processTrackingRouter,
+  sleep: sleepRouter,
   secureStore: secureStoreRouter,
   shell: shellRouter,
   ui: uiRouter,

apps/twig/src/main/trpc/routers/sleep.ts

@@ -0,0 +1,19 @@
+import { z } from "zod";
+import { container } from "../../di/container.js";
+import { MAIN_TOKENS } from "../../di/tokens.js";
+import type { SleepService } from "../../services/sleep/service.js";
+import { publicProcedure, router } from "../trpc.js";
+
+const getService = () => container.get<SleepService>(MAIN_TOKENS.SleepService);
+
+export const sleepRouter = router({
+  getEnabled: publicProcedure
+    .output(z.boolean())
+    .query(() => getService().getEnabled()),
+
+  setEnabled: publicProcedure
+    .input(z.object({ enabled: z.boolean() }))
+    .mutation(({ input }) => {
+      getService().setEnabled(input.enabled);
+    }),
+});

apps/twig/src/renderer/features/settings/components/SettingsView.tsx

@@ -86,6 +86,7 @@ export function SettingsView() {
     autoConvertLongText,
     sendMessagesWith,
     allowBypassPermissions,
+    preventSleepWhileRunning,
     setCursorGlow,
     setDesktopNotifications,
     setDockBadgeNotifications,
@@ -94,6 +95,7 @@ export function SettingsView() {
     setAutoConvertLongText,
     setSendMessagesWith,
     setAllowBypassPermissions,
+    setPreventSleepWhileRunning,
   } = useSettingsStore();
   const terminalFontFamily = useTerminalSettingsStore(
     (state) => state.terminalFontFamily,
@@ -124,6 +126,8 @@ export function SettingsView() {
 
   const { data: appVersion } = trpcReact.os.getAppVersion.useQuery();
 
+  const preventSleepMutation = trpcReact.sleep.setEnabled.useMutation();
+
   const [localWorktreeLocation, setLocalWorktreeLocation] =
     useState<string>("");
   const [checkingForUpdates, setCheckingForUpdates] = useState(false);
@@ -318,6 +322,19 @@ export function SettingsView() {
     [sendMessagesWith, setSendMessagesWith],
   );
 
+  const handlePreventSleepChange = useCallback(
+    (checked: boolean) => {
+      track(ANALYTICS_EVENTS.SETTING_CHANGED, {
+        setting_name: "prevent_sleep_while_running",
+        new_value: checked,
+        old_value: !checked,
+      });
+      setPreventSleepWhileRunning(checked);
+      preventSleepMutation.mutate({ enabled: checked });
+    },
+    [setPreventSleepWhileRunning, preventSleepMutation],
+  );
+
   const handleBypassPermissionsChange = useCallback(
     (checked: boolean) => {
       if (checked) {
@@ -704,6 +721,22 @@ export function SettingsView() {
             <Heading size="3">Task Execution</Heading>
             <Card>
               <Flex direction="column" gap="4">
+                <Flex align="center" justify="between" gap="4">
+                  <Flex direction="column" gap="1">
+                    <Text size="1" weight="medium">
+                      Prevent sleep while running
+                    </Text>
+                    <Text size="1" color="gray">
+                      Keep your computer awake while the agent is running a
+                      task.
+                    </Text>
+                  </Flex>
+                  <Switch
+                    checked={preventSleepWhileRunning}
+                    onCheckedChange={handlePreventSleepChange}
+                    size="1"
+                  />
+                </Flex>
                 <Flex align="start" justify="between" gap="4">
                   <Flex direction="column" gap="1">
                     <Flex align="center" gap="2">

apps/twig/src/renderer/features/settings/stores/settingsStore.ts

@@ -20,6 +20,7 @@ interface SettingsStore {
   completionVolume: number;
   sendMessagesWith: SendMessagesWith;
   allowBypassPermissions: boolean;
+  preventSleepWhileRunning: boolean;
 
   setCompletionSound: (sound: CompletionSound) => void;
   setCompletionVolume: (volume: number) => void;
@@ -33,6 +34,7 @@ interface SettingsStore {
   setAutoConvertLongText: (enabled: boolean) => void;
   setSendMessagesWith: (mode: SendMessagesWith) => void;
   setAllowBypassPermissions: (enabled: boolean) => void;
+  setPreventSleepWhileRunning: (enabled: boolean) => void;
 }
 
 export const useSettingsStore = create<SettingsStore>()(
@@ -50,6 +52,7 @@ export const useSettingsStore = create<SettingsStore>()(
       autoConvertLongText: true,
       sendMessagesWith: "enter",
       allowBypassPermissions: false,
+      preventSleepWhileRunning: false,
 
       setCompletionSound: (sound) => set({ completionSound: sound }),
       setCompletionVolume: (volume) => set({ completionVolume: volume }),
@@ -68,6 +71,8 @@ export const useSettingsStore = create<SettingsStore>()(
       setSendMessagesWith: (mode) => set({ sendMessagesWith: mode }),
       setAllowBypassPermissions: (enabled) =>
         set({ allowBypassPermissions: enabled }),
+      setPreventSleepWhileRunning: (enabled) =>
+        set({ preventSleepWhileRunning: enabled }),
     }),
     {
       name: "settings-storage",