Add idle timeout to kill inactive sessions after 15 minutes

Author: charlesvien

apps/code/src/main/services/agent/schemas.ts

@@ -183,11 +183,17 @@ export const subscribeSessionInput = z.object({
   taskRunId: z.string(),
 });
 
+// Report activity input — keeps the idle timeout debounce alive for the given task
+export const reportActivityInput = z.object({
+  taskId: z.string().nullable(),
+});
+
 // Agent events
 export const AgentServiceEvent = {
   SessionEvent: "session-event",
   PermissionRequest: "permission-request",
   SessionsIdle: "sessions-idle",
+  SessionIdleKilled: "session-idle-killed",
 } as const;
 
 export interface AgentSessionEventPayload {
@@ -203,10 +209,16 @@ export type PermissionRequestPayload = Omit<
   taskRunId: string;
 };
 
+export interface SessionIdleKilledPayload {
+  taskRunId: string;
+  taskId: string;
+}
+
 export interface AgentServiceEvents {
   [AgentServiceEvent.SessionEvent]: AgentSessionEventPayload;
   [AgentServiceEvent.PermissionRequest]: PermissionRequestPayload;
   [AgentServiceEvent.SessionsIdle]: undefined;
+  [AgentServiceEvent.SessionIdleKilled]: SessionIdleKilledPayload;
 }
 
 // Permission response input for tRPC

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

@@ -252,10 +252,13 @@ interface PendingPermission {
 
 @injectable()
 export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
+  private static readonly IDLE_TIMEOUT_MS = 15 * 60 * 1000;
+
   private sessions = new Map<string, ManagedSession>();
   private currentToken: string | null = null;
   private pendingPermissions = new Map<string, PendingPermission>();
   private mockNodeReady = false;
+  private idleTimeoutHandles = new Map<string, ReturnType<typeof setTimeout>>();
   private processTracking: ProcessTrackingService;
   private sleepService: SleepService;
   private fsService: FsService;
@@ -349,6 +352,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     });
 
     this.pendingPermissions.delete(key);
+    this.recordActivity(taskRunId);
   }
 
   /**
@@ -376,6 +380,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     });
 
     this.pendingPermissions.delete(key);
+    this.recordActivity(taskRunId);
   }
 
   /**
@@ -392,6 +397,36 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
     return false;
   }
 
+  public reportActivity(taskId: string | null): void {
+    if (!taskId) return;
+    for (const session of this.sessions.values()) {
+      if (session.taskId === taskId) {
+        this.recordActivity(session.taskRunId);
+      }
+    }
+  }
+
+  private recordActivity(taskRunId: string): void {
+    const existing = this.idleTimeoutHandles.get(taskRunId);
+    if (existing) clearTimeout(existing);
+
+    const handle = setTimeout(() => {
+      this.idleTimeoutHandles.delete(taskRunId);
+      const session = this.sessions.get(taskRunId);
+      if (!session || session.promptPending) return;
+      log.info("Killing idle session", { taskRunId, taskId: session.taskId });
+      this.emit(AgentServiceEvent.SessionIdleKilled, {
+        taskRunId,
+        taskId: session.taskId,
+      });
+      this.cleanupSession(taskRunId).catch((err) => {
+        log.error("Failed to cleanup idle session", { taskRunId, err });
+      });
+    }, AgentService.IDLE_TIMEOUT_MS);
+
+    this.idleTimeoutHandles.set(taskRunId, handle);
+  }
+
   private getToken(fallback: string): string {
     return this.currentToken || fallback;
   }
@@ -912,6 +947,7 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
 
     session.lastActivityAt = Date.now();
     session.promptPending = true;
+    this.recordActivity(sessionId);
     this.sleepService.acquire(sessionId);
 
     const promptJson = JSON.stringify(finalPrompt);
@@ -947,6 +983,8 @@ export class AgentService extends TypedEventEmitter<AgentServiceEvents> {
       throw err;
     } finally {
       session.promptPending = false;
+      session.lastActivityAt = Date.now();
+      this.recordActivity(sessionId);
       this.sleepService.release(sessionId);
 
       if (!this.hasActiveSessions()) {
@@ -1138,6 +1176,8 @@ For git operations while detached:
 
   @preDestroy()
   async cleanupAll(): Promise<void> {
+    for (const handle of this.idleTimeoutHandles.values()) clearTimeout(handle);
+    this.idleTimeoutHandles.clear();
     const sessionIds = Array.from(this.sessions.keys());
     log.info("Cleaning up all agent sessions", {
       sessionCount: sessionIds.length,
@@ -1224,6 +1264,12 @@ For git operations while detached:
       }
 
       this.sessions.delete(taskRunId);
+
+      const handle = this.idleTimeoutHandles.get(taskRunId);
+      if (handle) {
+        clearTimeout(handle);
+        this.idleTimeoutHandles.delete(taskRunId);
+      }
     }
   }
 

apps/code/src/main/trpc/routers/agent.ts

@@ -14,6 +14,7 @@ import {
   promptInput,
   promptOutput,
   reconnectSessionInput,
+  reportActivityInput,
   respondToPermissionInput,
   sessionResponseSchema,
   setConfigOptionInput,
@@ -183,6 +184,20 @@ export const agentRouter = router({
     log.info("All sessions reset successfully");
   }),
 
+  reportActivity: publicProcedure
+    .input(reportActivityInput)
+    .mutation(({ input }) => getService().reportActivity(input.taskId)),
+
+  onSessionIdleKilled: publicProcedure.subscription(async function* (opts) {
+    const service = getService();
+    for await (const event of service.toIterable(
+      AgentServiceEvent.SessionIdleKilled,
+      { signal: opts.signal },
+    )) {
+      yield event;
+    }
+  }),
+
   getGatewayModels: publicProcedure
     .input(getGatewayModelsInput)
     .output(getGatewayModelsOutput)

apps/code/src/renderer/features/sessions/service/service.test.ts

@@ -15,6 +15,7 @@ const mockTrpcAgent = vi.hoisted(() => ({
   cancelPermission: { mutate: vi.fn() },
   onSessionEvent: { subscribe: vi.fn() },
   onPermissionRequest: { subscribe: vi.fn() },
+  onSessionIdleKilled: { subscribe: vi.fn(() => ({ unsubscribe: vi.fn() })) },
   resetAll: { mutate: vi.fn().mockResolvedValue(undefined) },
 }));
 

apps/code/src/renderer/features/sessions/service/service.ts

@@ -121,6 +121,23 @@ export class SessionService {
       onStatusChange?: () => void;
     }
   >();
+  private idleKilledSubscription: { unsubscribe: () => void } | null = null;
+
+  constructor() {
+    this.idleKilledSubscription =
+      trpcVanilla.agent.onSessionIdleKilled.subscribe(undefined, {
+        onData: (event) => {
+          const { taskRunId } = event as { taskRunId: string; taskId: string };
+          log.info("Session idle-killed by main process", { taskRunId });
+          this.unsubscribeFromChannel(taskRunId);
+          sessionStoreSetters.removeSession(taskRunId);
+          removePersistedConfigOptions(taskRunId);
+        },
+        onError: (err) => {
+          log.debug("Idle-killed subscription error", { error: err });
+        },
+      });
+  }
 
   /**
    * Connect to a task session.
@@ -767,6 +784,8 @@ export class SessionService {
     this.connectingTasks.clear();
     this.previewAbort?.abort();
     this.previewAbort = null;
+    this.idleKilledSubscription?.unsubscribe();
+    this.idleKilledSubscription = null;
   }
 
   private updatePromptStateFromEvents(

apps/code/src/renderer/features/task-detail/components/TaskLogsPanel.tsx

@@ -132,6 +132,17 @@ export function TaskLogsPanel({ taskId, task }: TaskLogsPanelProps) {
     requestFocus(taskId);
   }, [taskId, requestFocus]);
 
+  useEffect(() => {
+    trpcVanilla.agent.reportActivity.mutate({ taskId }).catch(() => {});
+    const heartbeat = setInterval(
+      () => {
+        trpcVanilla.agent.reportActivity.mutate({ taskId }).catch(() => {});
+      },
+      5 * 60 * 1000,
+    );
+    return () => clearInterval(heartbeat);
+  }, [taskId]);
+
   // Keep cloud session title aligned with latest task metadata.
   useEffect(() => {
     if (!isCloud) return;