feat: prune stale session files after one week

Delete session persistence files when lastActivityAt is older than seven days and add coverage for stale/recent retention behavior.

Author: LIU9293

packages/config/local/sessions.ts

@@ -15,6 +15,7 @@ const homedir = typeof os.homedir === "function" ? os.homedir : () => "";
 const ODE_CONFIG_DIR = join(homedir(), ".config", "ode");
 const SESSIONS_DIR = join(ODE_CONFIG_DIR, "sessions");
 const SESSION_SAVE_DEBOUNCE_MS = 5000;
+const SESSION_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
 
 export interface TrackedTool {
   id: string;
@@ -101,6 +102,21 @@ function getSessionFilePath(sessionKey: string): string {
   return join(SESSIONS_DIR, `${safeKey}.json`);
 }
 
+function getSessionLastActiveAt(session: PersistedSession): number {
+  if (Number.isFinite(session.lastActivityAt)) {
+    return session.lastActivityAt;
+  }
+  if (Number.isFinite(session.createdAt)) {
+    return session.createdAt;
+  }
+  return 0;
+}
+
+function isSessionExpired(session: PersistedSession, now = Date.now()): boolean {
+  const lastActiveAt = getSessionLastActiveAt(session);
+  return now - lastActiveAt >= SESSION_RETENTION_MS;
+}
+
 function sanitizeSessionForStorage(session: PersistedSession): PersistedSession {
   const snapshot = structuredClone(session);
   if (snapshot.activeRequest) {
@@ -158,7 +174,12 @@ export function loadSession(channelId: string, threadId: string): PersistedSessi
 
   // Check cache first
   if (activeSessions.has(sessionKey)) {
-    return activeSessions.get(sessionKey)!;
+    const cached = activeSessions.get(sessionKey)!;
+    if (isSessionExpired(cached)) {
+      deleteSession(channelId, threadId);
+      return null;
+    }
+    return cached;
   }
 
   const filePath = getSessionFilePath(sessionKey);
@@ -169,6 +190,10 @@ export function loadSession(channelId: string, threadId: string): PersistedSessi
   try {
     const data = readFileSync(filePath, "utf-8");
     const session = JSON.parse(data) as PersistedSession;
+    if (isSessionExpired(session)) {
+      deleteSession(channelId, threadId);
+      return null;
+    }
     if (session.activeRequest) {
       const active = session.activeRequest as ActiveRequest & {
         settingsChannelId?: string;
@@ -340,7 +365,11 @@ export function loadAllSessions(): PersistedSession[] {
   ensureSessionsDir();
   const sessionsByKey = new Map<string, PersistedSession>();
 
-  for (const [sessionKey, session] of activeSessions.entries()) {
+  for (const [sessionKey, session] of Array.from(activeSessions.entries())) {
+    if (isSessionExpired(session)) {
+      deleteSession(session.channelId, session.threadId);
+      continue;
+    }
     sessionsByKey.set(sessionKey, session);
   }
 
@@ -351,6 +380,10 @@ export function loadAllSessions(): PersistedSession[] {
       try {
         const data = readFileSync(filePath, "utf-8");
         const session = JSON.parse(data) as PersistedSession;
+        if (isSessionExpired(session)) {
+          deleteSession(session.channelId, session.threadId);
+          continue;
+        }
         const sessionKey = getSessionKey(session.channelId, session.threadId);
         if (!sessionsByKey.has(sessionKey)) {
           sessionsByKey.set(sessionKey, session);

packages/core/test/session-retention.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "bun:test";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { deleteSession, loadSession } from "@/config/local/sessions";
+
+const SESSIONS_DIR = path.join(os.homedir(), ".config", "ode", "sessions");
+
+function getSessionFilePath(channelId: string, threadId: string): string {
+  const sessionKey = `${channelId}-${threadId}`;
+  const safeKey = sessionKey.replace(/[^a-zA-Z0-9-]/g, "_");
+  return path.join(SESSIONS_DIR, `${safeKey}.json`);
+}
+
+function writeSessionFixture(params: {
+  channelId: string;
+  threadId: string;
+  createdAt: number;
+  lastActivityAt: number;
+}): string {
+  const { channelId, threadId, createdAt, lastActivityAt } = params;
+  const filePath = getSessionFilePath(channelId, threadId);
+  fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify({
+    sessionId: `session-${threadId}`,
+    channelId,
+    threadId,
+    workingDirectory: "/tmp",
+    createdAt,
+    lastActivityAt,
+  }, null, 2));
+  return filePath;
+}
+
+describe("session retention", () => {
+  it("deletes session file when lastActivityAt is older than one week", () => {
+    const channelId = "RETENTION-C1";
+    const threadId = "RETENTION-T1";
+    const now = Date.now();
+    const staleAt = now - 8 * 24 * 60 * 60 * 1000;
+    const filePath = writeSessionFixture({
+      channelId,
+      threadId,
+      createdAt: staleAt,
+      lastActivityAt: staleAt,
+    });
+
+    expect(fs.existsSync(filePath)).toBeTrue();
+    expect(loadSession(channelId, threadId)).toBeNull();
+    expect(fs.existsSync(filePath)).toBeFalse();
+
+    deleteSession(channelId, threadId);
+  });
+
+  it("keeps session file when lastActivityAt is within one week", () => {
+    const channelId = "RETENTION-C2";
+    const threadId = "RETENTION-T2";
+    const now = Date.now();
+    const recentAt = now - 2 * 24 * 60 * 60 * 1000;
+    const filePath = writeSessionFixture({
+      channelId,
+      threadId,
+      createdAt: recentAt,
+      lastActivityAt: recentAt,
+    });
+
+    const loaded = loadSession(channelId, threadId);
+    expect(loaded).not.toBeNull();
+    expect(fs.existsSync(filePath)).toBeTrue();
+
+    deleteSession(channelId, threadId);
+  });
+});