code-squad-cli 1.2.17 → 1.2.20

package/dist/flip/routes/session.js

@@ -47,7 +47,6 @@ export function createSessionRouter(sessionManager) {
         res.json({
             session_id: session.id,
             cwd: session.cwd,
-            lastActivity: session.lastActivity,
         });
     });
     return router;

package/dist/flip/session/SessionManager.d.ts

@@ -6,10 +6,10 @@ export interface Session {
     cwd: string;
     /** FileWatcher instance for this session */
     watcher: FileWatcher;
-    /** Last activity timestamp (ms since epoch) */
-    lastActivity: number;
     /** Changed files since last poll (for polling-based sync) */
     pendingChanges: PendingChanges;
+    /** Timeout timer for session expiration */
+    timeoutTimer: ReturnType<typeof setTimeout> | null;
 }
 export interface PendingChanges {
     filesChanged: boolean;
@@ -25,10 +25,9 @@ export interface SessionManagerOptions {
 export declare class SessionManager {
     private sessions;
     private options;
-    private cleanupInterval;
     constructor(options: SessionManagerOptions);
     /**
-     * Start the session cleanup timer
+     * Start the session manager (no-op, kept for API compatibility)
      */
     start(): void;
     /**
@@ -40,15 +39,15 @@ export declare class SessionManager {
      */
     registerSession(sessionId: string, cwd: string): Session;
     /**
-     * Get a session by ID and update activity
+     * Get a session by ID and reset timeout
      */
     getSession(sessionId: string): Session | undefined;
     /**
-     * Touch session to update activity timestamp (called on every API request)
+     * Touch session to reset timeout (called on every API request)
      */
     touchSession(sessionId: string): void;
     /**
-     * Unregister a session (e.g., on cancel/submit)
+     * Unregister a session (e.g., on cancel/submit/timeout)
      */
     unregisterSession(sessionId: string): Promise<void>;
     /**
@@ -65,5 +64,9 @@ export declare class SessionManager {
     get hasSessions(): boolean;
     private createWatcher;
     private createEmptyPendingChanges;
-    private cleanupTimedOutSessions;
+    /**
+     * Reset the timeout timer for a session.
+     * Called on every activity (register, poll, etc.)
+     */
+    private resetSessionTimeout;
 }

package/dist/flip/session/SessionManager.js

@@ -3,29 +3,26 @@ const log = (...args) => console.error(...args);
 export class SessionManager {
     sessions = new Map();
     options;
-    cleanupInterval = null;
     constructor(options) {
         this.options = options;
     }
     /**
-     * Start the session cleanup timer
+     * Start the session manager (no-op, kept for API compatibility)
      */
     start() {
-        // Check for timed out sessions every 5 seconds
-        this.cleanupInterval = setInterval(() => {
-            this.cleanupTimedOutSessions();
-        }, 5000);
+        // No longer uses periodic cleanup - each session has its own timeout
     }
     /**
      * Stop the session manager and clean up all sessions
      */
     async stop() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = null;
-        }
-        // Stop all watchers
-        const stopPromises = Array.from(this.sessions.values()).map(session => session.watcher.stop());
+        // Clear all session timeouts and stop watchers
+        const stopPromises = Array.from(this.sessions.values()).map(session => {
+            if (session.timeoutTimer) {
+                clearTimeout(session.timeoutTimer);
+            }
+            return session.watcher.stop();
+        });
         await Promise.all(stopPromises);
         this.sessions.clear();
     }
@@ -35,8 +32,8 @@ export class SessionManager {
     registerSession(sessionId, cwd) {
         const existing = this.sessions.get(sessionId);
         if (existing) {
-            // Update activity timestamp
-            existing.lastActivity = Date.now();
+            // Reset timeout on activity
+            this.resetSessionTimeout(sessionId);
             // If cwd changed, need to restart watcher
             if (existing.cwd !== cwd) {
                 existing.watcher.stop();
@@ -52,38 +49,40 @@ export class SessionManager {
             id: sessionId,
             cwd,
             watcher,
-            lastActivity: Date.now(),
             pendingChanges: this.createEmptyPendingChanges(),
+            timeoutTimer: null,
         };
         this.sessions.set(sessionId, session);
+        this.resetSessionTimeout(sessionId);
         log(`[SessionManager] Session registered: ${sessionId} (cwd: ${cwd})`);
         return session;
     }
     /**
-     * Get a session by ID and update activity
+     * Get a session by ID and reset timeout
      */
     getSession(sessionId) {
         const session = this.sessions.get(sessionId);
         if (session) {
-            session.lastActivity = Date.now();
+            this.resetSessionTimeout(sessionId);
         }
         return session;
     }
     /**
-     * Touch session to update activity timestamp (called on every API request)
+     * Touch session to reset timeout (called on every API request)
      */
     touchSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.lastActivity = Date.now();
-        }
+        this.resetSessionTimeout(sessionId);
     }
     /**
-     * Unregister a session (e.g., on cancel/submit)
+     * Unregister a session (e.g., on cancel/submit/timeout)
      */
     async unregisterSession(sessionId) {
         const session = this.sessions.get(sessionId);
         if (session) {
+            // Clear timeout timer
+            if (session.timeoutTimer) {
+                clearTimeout(session.timeoutTimer);
+            }
             await session.watcher.stop();
             this.sessions.delete(sessionId);
             log(`[SessionManager] Session unregistered: ${sessionId}`);
@@ -147,17 +146,24 @@ export class SessionManager {
             changedFiles: new Set(),
         };
     }
-    cleanupTimedOutSessions() {
-        const now = Date.now();
-        const timedOut = [];
-        for (const [sessionId, session] of this.sessions) {
-            if (now - session.lastActivity > this.options.sessionTimeoutMs) {
-                timedOut.push(sessionId);
-            }
+    /**
+     * Reset the timeout timer for a session.
+     * Called on every activity (register, poll, etc.)
+     */
+    resetSessionTimeout(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return;
+        // Clear existing timeout
+        if (session.timeoutTimer) {
+            clearTimeout(session.timeoutTimer);
         }
-        for (const sessionId of timedOut) {
+        // Set new timeout
+        session.timeoutTimer = setTimeout(() => {
             log(`[SessionManager] Session timed out: ${sessionId}`);
-            this.unregisterSession(sessionId);
-        }
+            this.unregisterSession(sessionId).catch(error => {
+                log(`[SessionManager] Error during session unregister for ${sessionId}:`, error);
+            });
+        }, this.options.sessionTimeoutMs);
     }
 }

package/dist/index.js

@@ -1265,8 +1265,7 @@ function createSessionRouter(sessionManager) {
     }
     res.json({
       session_id: session.id,
-      cwd: session.cwd,
-      lastActivity: session.lastActivity
+      cwd: session.cwd
     });
   });
   return router6;
@@ -1426,27 +1425,24 @@ var log = (...args) => console.error(...args);
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
   options;
-  cleanupInterval = null;
   constructor(options) {
     this.options = options;
   }
   /**
-   * Start the session cleanup timer
+   * Start the session manager (no-op, kept for API compatibility)
    */
   start() {
-    this.cleanupInterval = setInterval(() => {
-      this.cleanupTimedOutSessions();
-    }, 5e3);
   }
   /**
    * Stop the session manager and clean up all sessions
    */
   async stop() {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-    const stopPromises = Array.from(this.sessions.values()).map((session) => session.watcher.stop());
+    const stopPromises = Array.from(this.sessions.values()).map((session) => {
+      if (session.timeoutTimer) {
+        clearTimeout(session.timeoutTimer);
+      }
+      return session.watcher.stop();
+    });
     await Promise.all(stopPromises);
     this.sessions.clear();
   }
@@ -1456,7 +1452,7 @@ var SessionManager = class {
   registerSession(sessionId, cwd) {
     const existing = this.sessions.get(sessionId);
     if (existing) {
-      existing.lastActivity = Date.now();
+      this.resetSessionTimeout(sessionId);
       if (existing.cwd !== cwd) {
         existing.watcher.stop();
         existing.cwd = cwd;
@@ -1470,38 +1466,39 @@ var SessionManager = class {
       id: sessionId,
       cwd,
       watcher,
-      lastActivity: Date.now(),
-      pendingChanges: this.createEmptyPendingChanges()
+      pendingChanges: this.createEmptyPendingChanges(),
+      timeoutTimer: null
     };
     this.sessions.set(sessionId, session);
+    this.resetSessionTimeout(sessionId);
     log(`[SessionManager] Session registered: ${sessionId} (cwd: ${cwd})`);
     return session;
   }
   /**
-   * Get a session by ID and update activity
+   * Get a session by ID and reset timeout
    */
   getSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (session) {
-      session.lastActivity = Date.now();
+      this.resetSessionTimeout(sessionId);
     }
     return session;
   }
   /**
-   * Touch session to update activity timestamp (called on every API request)
+   * Touch session to reset timeout (called on every API request)
    */
   touchSession(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (session) {
-      session.lastActivity = Date.now();
-    }
+    this.resetSessionTimeout(sessionId);
   }
   /**
-   * Unregister a session (e.g., on cancel/submit)
+   * Unregister a session (e.g., on cancel/submit/timeout)
    */
   async unregisterSession(sessionId) {
     const session = this.sessions.get(sessionId);
     if (session) {
+      if (session.timeoutTimer) {
+        clearTimeout(session.timeoutTimer);
+      }
       await session.watcher.stop();
       this.sessions.delete(sessionId);
       log(`[SessionManager] Session unregistered: ${sessionId}`);
@@ -1564,18 +1561,23 @@ var SessionManager = class {
       changedFiles: /* @__PURE__ */ new Set()
     };
   }
-  cleanupTimedOutSessions() {
-    const now = Date.now();
-    const timedOut = [];
-    for (const [sessionId, session] of this.sessions) {
-      if (now - session.lastActivity > this.options.sessionTimeoutMs) {
-        timedOut.push(sessionId);
-      }
+  /**
+   * Reset the timeout timer for a session.
+   * Called on every activity (register, poll, etc.)
+   */
+  resetSessionTimeout(sessionId) {
+    const session = this.sessions.get(sessionId);
+    if (!session)
+      return;
+    if (session.timeoutTimer) {
+      clearTimeout(session.timeoutTimer);
     }
-    for (const sessionId of timedOut) {
+    session.timeoutTimer = setTimeout(() => {
       log(`[SessionManager] Session timed out: ${sessionId}`);
-      this.unregisterSession(sessionId);
-    }
+      this.unregisterSession(sessionId).catch((error) => {
+        log(`[SessionManager] Error during session unregister for ${sessionId}:`, error);
+      });
+    }, this.options.sessionTimeoutMs);
   }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-squad-cli",
-  "version": "1.2.17",
+  "version": "1.2.20",
   "type": "module",
   "bin": {
     "csq": "./dist/index.js"