code-squad-cli 1.2.16 → 1.2.17

package/dist/flip/server/Server.d.ts

@@ -1,11 +1,45 @@
-export interface AppState {
-    cwd: string;
-    resolve: ((output: string | null) => void | Promise<void>) | null;
+import { SessionManager } from '../session/SessionManager.js';
+/** Server identification string for ping endpoint */
+export declare const SERVER_ID = "csq-flip";
+export interface ServerOptions {
+    /** Session timeout in ms. Default: 30000 (30 seconds) */
+    sessionTimeoutMs?: number;
+    /** Idle timeout in ms. Server shuts down if no session is registered within this time. 0 = no timeout. */
+    idleTimeout?: number;
 }
+/**
+ * Singleton flip server that manages multiple sessions
+ */
 export declare class Server {
-    private cwd;
     private port;
-    constructor(cwd: string, port: number);
-    run(): Promise<string | null>;
+    private options;
+    private app;
+    private server;
+    private sessionManager;
+    private resolveShutdown;
+    constructor(port: number, options?: ServerOptions);
+    /**
+     * Start the server and return a promise that resolves when server shuts down
+     */
+    run(): Promise<void>;
+    /**
+     * Shutdown the server gracefully
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Get the session manager
+     */
+    getSessionManager(): SessionManager | null;
 }
+/**
+ * Find an available port starting from the preferred port
+ */
 export declare function findFreePort(preferred: number, maxPort?: number): Promise<number>;
+/**
+ * Check if a csq-flip server is running on the given port
+ */
+export declare function isFlipServerRunning(port: number, timeoutMs?: number): Promise<boolean>;
+/**
+ * Find an existing csq-flip server in the port range
+ */
+export declare function findExistingServer(startPort: number, endPort: number): Promise<number | null>;

package/dist/flip/server/Server.js

@@ -8,67 +8,129 @@ import { gitRouter } from '../routes/git.js';
 import { submitRouter } from '../routes/submit.js';
 import { cancelRouter } from '../routes/cancel.js';
 import { createStaticRouter } from '../routes/static.js';
-import { createEventsRouter } from '../routes/events.js';
-import { FileWatcher } from '../watcher/FileWatcher.js';
-import { SSEManager } from '../events/SSEManager.js';
+import { createPingRouter } from '../routes/ping.js';
+import { createSessionRouter } from '../routes/session.js';
+import { createChangesRouter } from '../routes/changes.js';
+import { SessionManager } from '../session/SessionManager.js';
+const log = (...args) => console.error(...args);
+/** Server identification string for ping endpoint */
+export const SERVER_ID = 'csq-flip';
+/**
+ * Singleton flip server that manages multiple sessions
+ */
 export class Server {
-    cwd;
     port;
-    constructor(cwd, port) {
-        this.cwd = cwd;
+    options;
+    app = null;
+    server = null;
+    sessionManager = null;
+    resolveShutdown = null;
+    constructor(port, options = {}) {
         this.port = port;
+        this.options = {
+            sessionTimeoutMs: options.sessionTimeoutMs ?? 30000,
+            idleTimeout: options.idleTimeout ?? 0,
+        };
     }
+    /**
+     * Start the server and return a promise that resolves when server shuts down
+     */
     async run() {
         return new Promise((resolve) => {
-            const state = {
-                cwd: this.cwd,
-                resolve: null,
-            };
-            const app = express();
+            this.resolveShutdown = resolve;
+            this.app = express();
             // Middleware
-            app.use(cors());
-            app.use(express.json());
-            // Store state in app locals
-            app.locals.state = state;
-            // Initialize SSE manager and file watcher
-            const sseManager = new SSEManager();
-            const fileWatcher = new FileWatcher({ cwd: this.cwd });
-            // Set up watcher event handlers
-            fileWatcher.onFilesChanged(() => {
-                sseManager.broadcast({ type: 'files-changed' });
-            });
-            fileWatcher.onFileChanged((path) => {
-                sseManager.broadcast({ type: 'file-changed', path });
-            });
-            fileWatcher.onGitChanged(() => {
-                sseManager.broadcast({ type: 'git-changed' });
+            this.app.use(cors());
+            this.app.use(express.json());
+            // Initialize session manager
+            this.sessionManager = new SessionManager({
+                sessionTimeoutMs: this.options.sessionTimeoutMs,
+                onAllSessionsGone: () => {
+                    log('[Server] All sessions gone, shutting down...');
+                    this.shutdown();
+                },
             });
-            // Start watching
-            fileWatcher.start();
+            this.sessionManager.start();
+            // Store session manager in app locals
+            this.app.locals.sessionManager = this.sessionManager;
             // API routes
-            app.use('/api/files', filesRouter);
-            app.use('/api/file', fileRouter);
-            app.use('/api/git', gitRouter);
-            app.use('/api/submit', submitRouter);
-            app.use('/api/cancel', cancelRouter);
-            app.use('/api/events', createEventsRouter(sseManager));
+            this.app.use('/api/ping', createPingRouter());
+            this.app.use('/api/session', createSessionRouter(this.sessionManager));
+            this.app.use('/api/changes', createChangesRouter(this.sessionManager));
+            this.app.use('/api/files', filesRouter);
+            this.app.use('/api/file', fileRouter);
+            this.app.use('/api/git', gitRouter);
+            this.app.use('/api/submit', submitRouter);
+            this.app.use('/api/cancel', cancelRouter);
             // Static files (fallback to web-ui dist)
-            app.use(createStaticRouter());
-            const server = http.createServer(app);
-            // Set up the shutdown mechanism
-            state.resolve = async (output) => {
-                // Cleanup watcher and SSE connections
-                await fileWatcher.stop();
-                sseManager.closeAll();
-                await new Promise(res => server.close(() => res()));
-                resolve(output);
+            this.app.use(createStaticRouter());
+            this.server = http.createServer(this.app);
+            // Handle SIGINT/SIGTERM for graceful shutdown
+            const signalHandler = () => {
+                log('\nShutting down...');
+                this.shutdown();
             };
-            server.listen(this.port, '127.0.0.1', () => {
-                console.error(`Server running at http://localhost:${this.port}`);
+            process.on('SIGINT', signalHandler);
+            process.on('SIGTERM', signalHandler);
+            // Idle timeout - shutdown if no session is registered
+            let idleTimer = null;
+            if (this.options.idleTimeout && this.options.idleTimeout > 0) {
+                idleTimer = setTimeout(() => {
+                    if (!this.sessionManager?.hasSessions) {
+                        log('\nNo session registered, shutting down...');
+                        this.shutdown();
+                    }
+                }, this.options.idleTimeout);
+                // Clear timeout when first session is registered
+                // This is handled in session registration
+            }
+            // Store idle timer for cleanup
+            this.app.locals.idleTimer = idleTimer;
+            this.app.locals.clearIdleTimer = () => {
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    idleTimer = null;
+                    this.app.locals.idleTimer = null;
+                }
+            };
+            this.server.listen(this.port, '127.0.0.1', () => {
+                log(`[Server] Running at http://localhost:${this.port}`);
             });
         });
     }
+    /**
+     * Shutdown the server gracefully
+     */
+    async shutdown() {
+        if (!this.server)
+            return;
+        // Clear idle timer if exists
+        if (this.app?.locals.idleTimer) {
+            clearTimeout(this.app.locals.idleTimer);
+        }
+        // Stop session manager (stops all watchers)
+        if (this.sessionManager) {
+            await this.sessionManager.stop();
+        }
+        // Close HTTP server
+        await new Promise(res => {
+            this.server.close(() => res());
+        });
+        log('[Server] Shutdown complete');
+        if (this.resolveShutdown) {
+            this.resolveShutdown();
+        }
+    }
+    /**
+     * Get the session manager
+     */
+    getSessionManager() {
+        return this.sessionManager;
+    }
 }
+/**
+ * Find an available port starting from the preferred port
+ */
 export async function findFreePort(preferred, maxPort = 65535) {
     return new Promise((resolve, reject) => {
         if (preferred > maxPort) {
@@ -88,3 +150,46 @@ export async function findFreePort(preferred, maxPort = 65535) {
         });
     });
 }
+/**
+ * Check if a csq-flip server is running on the given port
+ */
+export async function isFlipServerRunning(port, timeoutMs = 1000) {
+    return new Promise((resolve) => {
+        const req = http.request({
+            hostname: '127.0.0.1',
+            port,
+            path: '/api/ping',
+            method: 'GET',
+            timeout: timeoutMs,
+        }, (res) => {
+            let data = '';
+            res.on('data', chunk => data += chunk);
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.id === SERVER_ID);
+                }
+                catch {
+                    resolve(false);
+                }
+            });
+        });
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => {
+            req.destroy();
+            resolve(false);
+        });
+        req.end();
+    });
+}
+/**
+ * Find an existing csq-flip server in the port range
+ */
+export async function findExistingServer(startPort, endPort) {
+    for (let port = startPort; port <= endPort; port++) {
+        if (await isFlipServerRunning(port)) {
+            return port;
+        }
+    }
+    return null;
+}

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

@@ -0,0 +1,69 @@
+import { FileWatcher } from '../watcher/FileWatcher.js';
+export interface Session {
+    /** Session ID (tty path, e.g., /dev/ttys001) */
+    id: string;
+    /** Working directory for this 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;
+}
+export interface PendingChanges {
+    filesChanged: boolean;
+    gitChanged: boolean;
+    changedFiles: Set<string>;
+}
+export interface SessionManagerOptions {
+    /** Session timeout in ms. Sessions are cleaned up after this period of inactivity. */
+    sessionTimeoutMs: number;
+    /** Callback when all sessions are gone */
+    onAllSessionsGone?: () => void;
+}
+export declare class SessionManager {
+    private sessions;
+    private options;
+    private cleanupInterval;
+    constructor(options: SessionManagerOptions);
+    /**
+     * Start the session cleanup timer
+     */
+    start(): void;
+    /**
+     * Stop the session manager and clean up all sessions
+     */
+    stop(): Promise<void>;
+    /**
+     * Register a new session or update existing one
+     */
+    registerSession(sessionId: string, cwd: string): Session;
+    /**
+     * Get a session by ID and update activity
+     */
+    getSession(sessionId: string): Session | undefined;
+    /**
+     * Touch session to update activity timestamp (called on every API request)
+     */
+    touchSession(sessionId: string): void;
+    /**
+     * Unregister a session (e.g., on cancel/submit)
+     */
+    unregisterSession(sessionId: string): Promise<void>;
+    /**
+     * Get pending changes for a session and clear them
+     */
+    consumePendingChanges(sessionId: string): PendingChanges | null;
+    /**
+     * Get number of active sessions
+     */
+    get sessionCount(): number;
+    /**
+     * Check if any sessions exist
+     */
+    get hasSessions(): boolean;
+    private createWatcher;
+    private createEmptyPendingChanges;
+    private cleanupTimedOutSessions;
+}

package/dist/flip/session/SessionManager.js

@@ -0,0 +1,163 @@
+import { FileWatcher } from '../watcher/FileWatcher.js';
+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() {
+        // Check for timed out sessions every 5 seconds
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupTimedOutSessions();
+        }, 5000);
+    }
+    /**
+     * 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());
+        await Promise.all(stopPromises);
+        this.sessions.clear();
+    }
+    /**
+     * Register a new session or update existing one
+     */
+    registerSession(sessionId, cwd) {
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            // Update activity timestamp
+            existing.lastActivity = Date.now();
+            // If cwd changed, need to restart watcher
+            if (existing.cwd !== cwd) {
+                existing.watcher.stop();
+                existing.cwd = cwd;
+                existing.watcher = this.createWatcher(sessionId, cwd);
+                existing.pendingChanges = this.createEmptyPendingChanges();
+            }
+            return existing;
+        }
+        // Create new session
+        const watcher = this.createWatcher(sessionId, cwd);
+        const session = {
+            id: sessionId,
+            cwd,
+            watcher,
+            lastActivity: Date.now(),
+            pendingChanges: this.createEmptyPendingChanges(),
+        };
+        this.sessions.set(sessionId, session);
+        log(`[SessionManager] Session registered: ${sessionId} (cwd: ${cwd})`);
+        return session;
+    }
+    /**
+     * Get a session by ID and update activity
+     */
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastActivity = Date.now();
+        }
+        return session;
+    }
+    /**
+     * Touch session to update activity timestamp (called on every API request)
+     */
+    touchSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            session.lastActivity = Date.now();
+        }
+    }
+    /**
+     * Unregister a session (e.g., on cancel/submit)
+     */
+    async unregisterSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session) {
+            await session.watcher.stop();
+            this.sessions.delete(sessionId);
+            log(`[SessionManager] Session unregistered: ${sessionId}`);
+            if (this.sessions.size === 0 && this.options.onAllSessionsGone) {
+                this.options.onAllSessionsGone();
+            }
+        }
+    }
+    /**
+     * Get pending changes for a session and clear them
+     */
+    consumePendingChanges(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return null;
+        const changes = { ...session.pendingChanges };
+        changes.changedFiles = new Set(session.pendingChanges.changedFiles);
+        // Reset pending changes
+        session.pendingChanges = this.createEmptyPendingChanges();
+        return changes;
+    }
+    /**
+     * Get number of active sessions
+     */
+    get sessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * Check if any sessions exist
+     */
+    get hasSessions() {
+        return this.sessions.size > 0;
+    }
+    createWatcher(sessionId, cwd) {
+        const watcher = new FileWatcher({ cwd });
+        watcher.onFilesChanged(() => {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                session.pendingChanges.filesChanged = true;
+            }
+        });
+        watcher.onFileChanged((filePath) => {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                session.pendingChanges.changedFiles.add(filePath);
+            }
+        });
+        watcher.onGitChanged(() => {
+            const session = this.sessions.get(sessionId);
+            if (session) {
+                session.pendingChanges.gitChanged = true;
+            }
+        });
+        watcher.start();
+        return watcher;
+    }
+    createEmptyPendingChanges() {
+        return {
+            filesChanged: false,
+            gitChanged: false,
+            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);
+            }
+        }
+        for (const sessionId of timedOut) {
+            log(`[SessionManager] Session timed out: ${sessionId}`);
+            this.unregisterSession(sessionId);
+        }
+    }
+}