claudia-orchestrator 0.1.0

package/dist/routes/conversation.routes.js

@@ -0,0 +1,870 @@
+import { Router } from 'express';
+import { CUIError } from '../types/index.js';
+import { createLogger } from '../services/logger.js';
+import { SessionInsightsService } from '../services/session-insights-service.js';
+import { getInsightsService } from '../services/insights-service.js';
+export function createConversationRoutes(processManager, historyReader, statusTracker, sessionInfoService, conversationStatusManager, toolMetricsService) {
+    const router = Router();
+    const logger = createLogger('ConversationRoutes');
+    const insightsService = new SessionInsightsService(historyReader, sessionInfoService);
+    // Track sessions currently being started to enforce limits accurately
+    const sessionsBeingStarted = new Set();
+    // Start new conversation (also handles resume if resumedSessionId is provided)
+    router.post('/start', async (req, res, next) => {
+        const requestId = req.requestId;
+        const isResume = !!req.body.resumedSessionId;
+        // DEBUG TRACE - prominent logging
+        logger.info('[TRACE] POST /start received', {
+            requestId,
+            isResume,
+            resumedSessionId: req.body.resumedSessionId,
+            workingDirectory: req.body.workingDirectory,
+            promptPreview: req.body.initialPrompt?.substring(0, 80)
+        });
+        logger.debug('Start conversation request', {
+            requestId,
+            isResume,
+            resumedSessionId: req.body.resumedSessionId,
+            body: {
+                ...req.body,
+                initialPrompt: req.body.initialPrompt ? `${req.body.initialPrompt.substring(0, 50)}...` : undefined
+            }
+        });
+        try {
+            // Validate required fields
+            // For resume, workingDirectory can be fetched from the original session
+            if (!req.body.workingDirectory && !req.body.resumedSessionId) {
+                throw new CUIError('MISSING_WORKING_DIRECTORY', 'workingDirectory is required for new conversations', 400);
+            }
+            if (!req.body.initialPrompt) {
+                throw new CUIError('MISSING_INITIAL_PROMPT', 'initialPrompt is required', 400);
+            }
+            // Check license limits - enforce on ALL sessions (new and resumed)
+            // This prevents the workaround of starting multiple quick sessions then resuming them all
+            // TEMPORARILY DISABLED FOR DEVELOPMENT
+            /*
+            const limits = await licenseService.getLimits();
+      
+            if (limits.maxSessions !== null) {
+              // Count both active sessions AND sessions currently being started
+              const activeSessions = conversationStatusManager.getActiveSessionIds();
+              const totalSessions = activeSessions.length + sessionsBeingStarted.size;
+      
+              // Check if we're at the session limit
+              if (totalSessions >= limits.maxSessions) {
+                logger.info('Session limit reached', {
+                  requestId,
+                  activeCount: activeSessions.length,
+                  startingCount: sessionsBeingStarted.size,
+                  totalCount: totalSessions,
+                  limit: limits.maxSessions,
+                  tier: (await licenseService.validate()).tier,
+                  isResume: !!req.body.resumedSessionId
+                });
+      
+                throw new CUIError(
+                  'SESSION_LIMIT_REACHED',
+                  `Session limit reached. Free tier allows ${limits.maxSessions} concurrent session${limits.maxSessions === 1 ? '' : 's'}. Upgrade to Pro for unlimited sessions.`,
+                  403
+                );
+              }
+      
+              // Mark this request as starting a session (for both new and resumed)
+              if (requestId) {
+                sessionsBeingStarted.add(requestId);
+              }
+            }
+            */
+            // Validate permissionMode if provided
+            if (req.body.permissionMode) {
+                const validModes = ['acceptEdits', 'bypassPermissions', 'default', 'plan'];
+                if (!validModes.includes(req.body.permissionMode)) {
+                    throw new CUIError('INVALID_PERMISSION_MODE', `permissionMode must be one of: ${validModes.join(', ')}`, 400);
+                }
+            }
+            // For resume operations, fetch working directory and permission mode in parallel
+            // (messages are fetched after process spawn to avoid blocking startup)
+            let effectiveWorkingDirectory = req.body.workingDirectory;
+            let inheritedPermissionMode;
+            if (req.body.resumedSessionId) {
+                // Parallel fetch of working directory and session info
+                const [fetchedDir, sessionInfo] = await Promise.all([
+                    !effectiveWorkingDirectory
+                        ? historyReader.getConversationWorkingDirectory(req.body.resumedSessionId)
+                        : Promise.resolve(effectiveWorkingDirectory),
+                    !req.body.permissionMode
+                        ? sessionInfoService.getSessionInfo(req.body.resumedSessionId).catch(() => null)
+                        : Promise.resolve(null)
+                ]);
+                if (!effectiveWorkingDirectory) {
+                    if (!fetchedDir) {
+                        throw new CUIError('CONVERSATION_NOT_FOUND', `Could not find working directory for session ${req.body.resumedSessionId}`, 404);
+                    }
+                    effectiveWorkingDirectory = fetchedDir;
+                    logger.debug('Fetched working directory for resume', {
+                        requestId,
+                        resumedSessionId: req.body.resumedSessionId,
+                        workingDirectory: effectiveWorkingDirectory
+                    });
+                }
+                if (sessionInfo && !req.body.permissionMode) {
+                    inheritedPermissionMode = sessionInfo.permission_mode;
+                    logger.debug('Retrieved permission mode from session info', {
+                        requestId,
+                        originalSessionId: req.body.resumedSessionId,
+                        permissionMode: inheritedPermissionMode
+                    });
+                }
+            }
+            // Start process immediately - don't wait for message fetch
+            const conversationConfig = {
+                ...req.body,
+                workingDirectory: effectiveWorkingDirectory,
+                permissionMode: req.body.permissionMode || inheritedPermissionMode
+            };
+            // Start the process and fetch previous messages in parallel
+            // Messages are only needed for optimistic UI, not for Claude CLI (which uses --resume)
+            const [spawnResult, previousMessages] = await Promise.all([
+                processManager.startConversation(conversationConfig),
+                req.body.resumedSessionId
+                    ? historyReader.fetchConversationDirect(req.body.resumedSessionId)
+                        .then(({ messages }) => messages)
+                        .catch((error) => {
+                        logger.warn('Failed to fetch previous session messages', {
+                            requestId,
+                            originalSessionId: req.body.resumedSessionId,
+                            error: error instanceof Error ? error.message : String(error)
+                        });
+                        return [];
+                    })
+                    : Promise.resolve([])
+            ]);
+            const { streamingId, systemInit } = spawnResult;
+            // DEBUG TRACE - after process started
+            logger.info('[TRACE] Claude process started', {
+                streamingId,
+                newSessionId: systemInit.session_id,
+                model: systemInit.model,
+                cwd: systemInit.cwd
+            });
+            // Register the session with conversation status manager immediately (optimistic UI)
+            try {
+                conversationStatusManager.registerActiveSession(streamingId, systemInit.session_id, {
+                    initialPrompt: req.body.initialPrompt,
+                    workingDirectory: systemInit.cwd,
+                    model: systemInit.model,
+                    inheritedMessages: previousMessages.length > 0 ? previousMessages : undefined
+                });
+                logger.debug('Registered active session with status manager', {
+                    requestId,
+                    newSessionId: systemInit.session_id,
+                    streamingId,
+                    isResumed: !!req.body.resumedSessionId,
+                    inheritedMessageCount: previousMessages.length
+                });
+            }
+            catch (error) {
+                logger.warn('Failed to register session with status manager', {
+                    requestId,
+                    error: error instanceof Error ? error.message : String(error)
+                });
+            }
+            // Note: continuation_session_id tracking removed
+            // Resume operations continue in the same session (no forking), so there's no
+            // continuation to track. This prevents self-referential continuation_session_id
+            // entries that were caused by the UI expecting new session IDs (commit aa64a4b bug)
+            // Store permission mode in session info if provided
+            if (conversationConfig.permissionMode) {
+                try {
+                    await sessionInfoService.updateSessionInfo(systemInit.session_id, {
+                        permission_mode: conversationConfig.permissionMode
+                    });
+                    logger.debug('Stored permission mode in session info', {
+                        sessionId: systemInit.session_id,
+                        permissionMode: conversationConfig.permissionMode
+                    });
+                }
+                catch (error) {
+                    logger.warn('Failed to store permission mode in session info', {
+                        sessionId: systemInit.session_id,
+                        permissionMode: conversationConfig.permissionMode,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            logger.debug('Conversation started successfully', {
+                requestId,
+                isResume,
+                resumedSessionId: req.body.resumedSessionId,
+                streamingId,
+                sessionId: systemInit.session_id,
+                model: systemInit.model,
+                cwd: systemInit.cwd,
+                previousMessageCount: previousMessages.length
+            });
+            // Clean up session tracking
+            if (requestId) {
+                sessionsBeingStarted.delete(requestId);
+            }
+            res.json({
+                streamingId,
+                streamUrl: `/api/stream/${streamingId}`,
+                // System init fields
+                sessionId: systemInit.session_id,
+                cwd: systemInit.cwd,
+                tools: systemInit.tools,
+                mcpServers: systemInit.mcp_servers,
+                model: systemInit.model,
+                permissionMode: systemInit.permissionMode,
+                apiKeySource: systemInit.apiKeySource
+            });
+        }
+        catch (error) {
+            // Clean up session tracking on error
+            if (requestId) {
+                sessionsBeingStarted.delete(requestId);
+            }
+            logger.debug('Start conversation failed', {
+                requestId,
+                isResume,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // List conversations
+    router.get('/', async (req, res, next) => {
+        const requestId = req.requestId;
+        logger.debug('List conversations request', {
+            requestId,
+            query: req.query
+        });
+        try {
+            const result = await historyReader.listConversations(req.query);
+            // Update status for each conversation based on active streams
+            const conversationsWithStatus = result.conversations.map(conversation => {
+                const status = statusTracker.getConversationStatus(conversation.sessionId);
+                const baseConversation = {
+                    ...conversation,
+                    status
+                };
+                // Add toolMetrics if available
+                const metrics = toolMetricsService.getMetrics(conversation.sessionId);
+                if (metrics) {
+                    baseConversation.toolMetrics = metrics;
+                }
+                // Add streamingId if conversation is ongoing
+                if (status === 'ongoing') {
+                    const streamingId = statusTracker.getStreamingId(conversation.sessionId);
+                    if (streamingId) {
+                        return { ...baseConversation, streamingId };
+                    }
+                }
+                return baseConversation;
+            });
+            // Get all active sessions and add optimistic conversations for those not in history
+            // But only when NOT viewing archive (active sessions shouldn't appear in archive view)
+            const existingSessionIds = new Set(conversationsWithStatus.map(c => c.sessionId));
+            const isArchiveView = req.query.archived === true;
+            const conversationsNotInHistory = isArchiveView
+                ? []
+                : conversationStatusManager.getConversationsNotInHistory(existingSessionIds);
+            // Combine history conversations with active ones not in history
+            const allConversations = [...conversationsWithStatus, ...conversationsNotInHistory];
+            // Ensure session info entries exist for all conversations
+            try {
+                await sessionInfoService.syncMissingSessions(allConversations.map(c => c.sessionId));
+            }
+            catch (syncError) {
+                logger.debug('Failed to sync session info', {
+                    requestId,
+                    error: syncError instanceof Error ? syncError.message : String(syncError)
+                });
+            }
+            // Fetch cached insights for all sessions in one DB call
+            const sessionIds = allConversations.map(c => c.sessionId);
+            let cachedInsights = new Map();
+            try {
+                cachedInsights = await insightsService.getCachedInsightsForSessions(sessionIds);
+                // If we have sessions without cached insights, compute them in background
+                const missingSessions = sessionIds.filter(id => !cachedInsights.has(id));
+                if (missingSessions.length > 0) {
+                    logger.debug('Computing missing insights in background', { count: missingSessions.length });
+                    // Fire and forget - don't block the response
+                    insightsService.computeMissingInsights(missingSessions, 3).catch(err => logger.debug('Background insights computation failed', { error: err }));
+                }
+            }
+            catch (insightsError) {
+                logger.debug('Failed to fetch cached insights', {
+                    requestId,
+                    error: insightsError instanceof Error ? insightsError.message : String(insightsError)
+                });
+            }
+            // Attach insights to each conversation
+            const conversationsWithInsights = allConversations.map(conv => ({
+                ...conv,
+                insights: cachedInsights.get(conv.sessionId) || undefined
+            }));
+            logger.debug('Conversations listed successfully', {
+                requestId,
+                conversationCount: conversationsWithInsights.length,
+                historyConversations: conversationsWithStatus.length,
+                conversationsNotInHistory: conversationsNotInHistory.length,
+                totalFound: result.total,
+                activeConversations: conversationsWithInsights.filter(c => c.status === 'ongoing').length,
+                withInsights: cachedInsights.size
+            });
+            res.json({
+                conversations: conversationsWithInsights,
+                total: result.total + conversationsNotInHistory.length // Update total to include conversations not in history
+            });
+        }
+        catch (error) {
+            logger.debug('List conversations failed', {
+                requestId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // SSE endpoint for real-time activity updates
+    // Clients subscribe to receive instant updates when files change
+    // IMPORTANT: This must be defined BEFORE /:sessionId or Express will match "activity-stream" as a sessionId
+    router.get('/activity-stream', (req, res) => {
+        const requestId = req.requestId;
+        logger.debug('Activity stream client connected', { requestId });
+        // Configure SSE headers
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('X-Accel-Buffering', 'no');
+        res.setHeader('Connection', 'keep-alive');
+        // Flush headers immediately so client knows connection is established
+        res.flushHeaders();
+        // Import and get the watcher
+        import('../services/session-activity-watcher.js').then(async ({ getSessionActivityWatcher }) => {
+            const watcher = getSessionActivityWatcher();
+            // Start the watcher if not already running
+            watcher.start();
+            // Send initial connection confirmation
+            res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: Date.now() })}\n\n`);
+            // Seed initial state: send action history for all recent sessions
+            try {
+                const { conversations } = await historyReader.listConversations({ limit: 50, sortBy: 'updated', order: 'desc', archived: false });
+                const recentSessions = conversations.map(c => c.sessionId);
+                for (const sessionId of recentSessions) {
+                    try {
+                        const { messages } = await historyReader.fetchConversationDirect(sessionId);
+                        if (messages.length === 0)
+                            continue;
+                        const recentActions = insightsService.extractRecentActions(messages, 14);
+                        if (recentActions.length > 0) {
+                            const initialUpdate = {
+                                type: 'activity',
+                                sessionId,
+                                recentActions,
+                                timestamp: Date.now()
+                            };
+                            res.write(`data: ${JSON.stringify(initialUpdate)}\n\n`);
+                        }
+                    }
+                    catch (err) {
+                        // Skip sessions with errors
+                        logger.debug('Failed to seed initial state for session', { sessionId: sessionId.slice(0, 8), err });
+                    }
+                }
+            }
+            catch (err) {
+                logger.warn('Failed to seed initial activity state', { err });
+            }
+            // Seed insights timestamps so reconnecting clients can detect missed updates
+            try {
+                const sessionIds = (await historyReader.listConversations({ limit: 50, sortBy: 'updated', order: 'desc', archived: false })).conversations.map(c => c.sessionId);
+                const cachedInsights = await insightsService.getCachedInsightsForSessions(sessionIds);
+                const insightsTimestamps = {};
+                for (const [sessionId, insights] of cachedInsights.entries()) {
+                    if (insights.computedAt) {
+                        insightsTimestamps[sessionId] = insights.computedAt;
+                    }
+                }
+                if (Object.keys(insightsTimestamps).length > 0) {
+                    res.write(`data: ${JSON.stringify({ type: 'insights-status', timestamps: insightsTimestamps })}\n\n`);
+                }
+            }
+            catch (err) {
+                logger.warn('Failed to seed insights timestamps', { err });
+            }
+            // Forward activity updates to this client
+            const onActivity = (update) => {
+                res.write(`data: ${JSON.stringify({ type: 'activity', ...update })}\n\n`);
+            };
+            // Forward insights updates to this client
+            const onInsights = (update) => {
+                // Rename 'type' to 'insightType' to avoid collision with SSE event type
+                const { type: insightType, ...rest } = update;
+                res.write(`data: ${JSON.stringify({ type: 'insights', insightType, ...rest })}\n\n`);
+            };
+            watcher.on('activity', onActivity);
+            watcher.on('insights', onInsights);
+            // Clean up on disconnect
+            req.on('close', () => {
+                logger.debug('Activity stream client disconnected', { requestId });
+                watcher.off('activity', onActivity);
+                watcher.off('insights', onInsights);
+            });
+            // Keep-alive ping every 30 seconds
+            const keepAlive = setInterval(() => {
+                res.write(`data: ${JSON.stringify({ type: 'ping', timestamp: Date.now() })}\n\n`);
+            }, 30000);
+            req.on('close', () => {
+                clearInterval(keepAlive);
+            });
+        }).catch((error) => {
+            logger.error('Activity stream failed to initialize watcher', { requestId, error });
+            res.write(`data: ${JSON.stringify({ type: 'error', error: 'Failed to initialize activity watcher' })}\n\n`);
+        });
+    });
+    // Get conversation details
+    // Supports pagination via query params:
+    //   ?limit=N - return only the last N messages (default: all)
+    //   ?before=messageId - return messages before this message ID (for loading older messages)
+    router.get('/:sessionId', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { sessionId } = req.params;
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : undefined;
+        const before = req.query.before;
+        const startTime = Date.now();
+        logger.debug('Get conversation details request', {
+            requestId,
+            sessionId,
+            limit,
+            before
+        });
+        try {
+            // First try to fetch from history using fast direct lookup
+            try {
+                const { messages: allMessages, metadata } = await historyReader.fetchConversationDirect(req.params.sessionId);
+                const fetchTime = Date.now() - startTime;
+                logger.debug('Conversation fetch timing (direct)', {
+                    requestId,
+                    sessionId,
+                    fetchMs: fetchTime,
+                    messageCount: allMessages.length
+                });
+                // Apply pagination if requested
+                let messages = allMessages;
+                let hasMore = false;
+                let oldestMessageId;
+                const totalMessages = allMessages.length;
+                if (limit || before) {
+                    // If 'before' is specified, find that message and take messages before it
+                    let endIndex = allMessages.length;
+                    if (before) {
+                        const beforeIndex = allMessages.findIndex(m => m.uuid === before);
+                        if (beforeIndex > 0) {
+                            endIndex = beforeIndex;
+                        }
+                    }
+                    // Apply limit - take the last N messages up to endIndex
+                    const effectiveLimit = limit || 50;
+                    const startIndex = Math.max(0, endIndex - effectiveLimit);
+                    messages = allMessages.slice(startIndex, endIndex);
+                    hasMore = startIndex > 0;
+                    oldestMessageId = messages.length > 0 ? messages[0].uuid : undefined;
+                }
+                const response = {
+                    messages,
+                    summary: metadata.summary,
+                    projectPath: metadata.projectPath,
+                    metadata: {
+                        totalDuration: metadata.totalDuration,
+                        model: metadata.model
+                    },
+                    totalMessages,
+                    hasMore,
+                    oldestMessageId
+                };
+                // Add toolMetrics if available
+                const metrics = toolMetricsService.getMetrics(req.params.sessionId);
+                if (metrics) {
+                    response.toolMetrics = metrics;
+                }
+                // Check if this historical session is also currently active
+                // First check CUI-spawned sessions (have streamingId)
+                const activeStreamingId = conversationStatusManager.getStreamingId(sessionId);
+                if (activeStreamingId) {
+                    response.status = 'ongoing';
+                    response.streamingId = activeStreamingId;
+                }
+                else {
+                    // Also check for CLI sessions via process detection
+                    const hasActiveProcess = await historyReader.isSessionFileInUse(sessionId);
+                    response.status = hasActiveProcess ? 'ongoing' : 'completed';
+                }
+                logger.debug('Conversation details retrieved from history', {
+                    requestId,
+                    sessionId,
+                    messageCount: response.messages.length,
+                    totalMessages,
+                    hasMore,
+                    hasSummary: !!response.summary,
+                    projectPath: response.projectPath
+                });
+                res.json(response);
+            }
+            catch (historyError) {
+                // If not found in history, check if it's an active session
+                if (historyError instanceof CUIError && historyError.code === 'CONVERSATION_NOT_FOUND') {
+                    const activeDetails = conversationStatusManager.getActiveConversationDetails(sessionId);
+                    if (activeDetails) {
+                        logger.debug('Conversation details created for active session', {
+                            requestId,
+                            sessionId,
+                            projectPath: activeDetails.projectPath
+                        });
+                        res.json(activeDetails);
+                    }
+                    else {
+                        // Not found in history and not active
+                        throw historyError;
+                    }
+                }
+                else {
+                    // Other errors, re-throw
+                    throw historyError;
+                }
+            }
+        }
+        catch (error) {
+            logger.debug('Get conversation details failed', {
+                requestId,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Stop conversation
+    router.post('/:streamingId/stop', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { streamingId } = req.params;
+        logger.debug('Stop conversation request', {
+            requestId,
+            streamingId
+        });
+        try {
+            const success = await processManager.stopConversation(streamingId);
+            logger.debug('Stop conversation result', {
+                requestId,
+                streamingId,
+                success
+            });
+            res.json({ success });
+        }
+        catch (error) {
+            logger.debug('Stop conversation failed', {
+                requestId,
+                streamingId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Stop session by sessionId (looks up streamingId internally)
+    router.post('/session/:sessionId/stop', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { sessionId } = req.params;
+        logger.debug('Stop session by sessionId request', {
+            requestId,
+            sessionId
+        });
+        try {
+            // Look up the streamingId for this session
+            const streamingId = statusTracker.getStreamingId(sessionId);
+            if (!streamingId) {
+                logger.debug('No active streamingId found for session', {
+                    requestId,
+                    sessionId
+                });
+                res.json({ success: false, error: 'Session not active or streamingId not found' });
+                return;
+            }
+            const success = await processManager.stopConversation(streamingId);
+            logger.debug('Stop session result', {
+                requestId,
+                sessionId,
+                streamingId,
+                success
+            });
+            res.json({ success });
+        }
+        catch (error) {
+            logger.debug('Stop session failed', {
+                requestId,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Force kill session by sessionId (immediate SIGKILL)
+    router.post('/session/:sessionId/force-kill', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { sessionId } = req.params;
+        logger.info('Force kill session request', {
+            requestId,
+            sessionId
+        });
+        try {
+            const streamingId = statusTracker.getStreamingId(sessionId);
+            if (!streamingId) {
+                logger.debug('No active streamingId found for session', {
+                    requestId,
+                    sessionId
+                });
+                res.json({ success: false, error: 'Session not active or streamingId not found' });
+                return;
+            }
+            const success = processManager.forceKillConversation(streamingId);
+            logger.info('Force kill session result', {
+                requestId,
+                sessionId,
+                streamingId,
+                success
+            });
+            res.json({ success });
+        }
+        catch (error) {
+            logger.error('Force kill session failed', {
+                requestId,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Inject message into running session (send to stdin)
+    router.post('/session/:sessionId/inject', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { sessionId } = req.params;
+        const { message } = req.body;
+        logger.info('Inject message request', {
+            requestId,
+            sessionId,
+            messageLength: message?.length
+        });
+        try {
+            if (!message) {
+                res.status(400).json({ success: false, error: 'message is required' });
+                return;
+            }
+            const streamingId = statusTracker.getStreamingId(sessionId);
+            if (!streamingId) {
+                logger.debug('No active streamingId found for session', {
+                    requestId,
+                    sessionId
+                });
+                res.json({ success: false, error: 'Session not active or streamingId not found' });
+                return;
+            }
+            // Format as a user message for Claude's stdin protocol
+            const stdinMessage = JSON.stringify({
+                type: 'user',
+                message: {
+                    role: 'user',
+                    content: message
+                }
+            });
+            const success = processManager.sendStdinMessage(streamingId, stdinMessage);
+            logger.info('Inject message result', {
+                requestId,
+                sessionId,
+                streamingId,
+                success
+            });
+            res.json({ success });
+        }
+        catch (error) {
+            logger.error('Inject message failed', {
+                requestId,
+                sessionId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Rename session (update custom name)
+    router.put('/:sessionId/rename', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { sessionId } = req.params;
+        const { customName } = req.body;
+        logger.debug('Rename session request', {
+            requestId,
+            sessionId,
+            customName
+        });
+        try {
+            // Validate required fields
+            if (!sessionId || !sessionId.trim()) {
+                throw new CUIError('MISSING_SESSION_ID', 'sessionId is required', 400);
+            }
+            if (customName === undefined || customName === null) {
+                throw new CUIError('MISSING_CUSTOM_NAME', 'customName is required', 400);
+            }
+            // Validate custom name length (reasonable limit)
+            if (customName.length > 200) {
+                throw new CUIError('CUSTOM_NAME_TOO_LONG', 'customName must be 200 characters or less', 400);
+            }
+            // Check if session exists by trying to fetch it
+            try {
+                await historyReader.fetchConversationDirect(sessionId);
+            }
+            catch {
+                throw new CUIError('CONVERSATION_NOT_FOUND', 'Conversation not found', 404);
+            }
+            // Update custom name
+            await sessionInfoService.updateCustomName(sessionId, customName.trim());
+            logger.info('Session renamed successfully', {
+                requestId,
+                sessionId,
+                customName: customName.trim()
+            });
+            res.json({
+                success: true,
+                sessionId,
+                customName: customName.trim()
+            });
+        }
+        catch (error) {
+            logger.debug('Rename session failed', {
+                requestId,
+                sessionId,
+                customName,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Update session info (replaces rename endpoint)
+    router.put('/:sessionId/update', async (req, res, next) => {
+        const requestId = req.requestId;
+        const { sessionId } = req.params;
+        const updates = req.body;
+        logger.debug('Update session request', {
+            requestId,
+            sessionId,
+            updates
+        });
+        try {
+            // Validate sessionId
+            if (!sessionId || sessionId.trim() === '') {
+                logger.debug('Invalid session ID', { requestId, sessionId });
+                return res.status(400).json({
+                    success: false,
+                    sessionId: '',
+                    updatedFields: {},
+                    error: 'Session ID is required'
+                });
+            }
+            // Validate fields if provided
+            if (updates.customName !== undefined && updates.customName.length > 200) {
+                logger.debug('Custom name too long', { requestId, length: updates.customName.length });
+                return res.status(400).json({
+                    success: false,
+                    sessionId,
+                    updatedFields: {},
+                    error: 'Custom name must be 200 characters or less'
+                });
+            }
+            // Prepare updates object - map camelCase to snake_case
+            const sessionUpdates = {};
+            if (updates.customName !== undefined)
+                sessionUpdates.custom_name = updates.customName.trim();
+            if (updates.pinned !== undefined)
+                sessionUpdates.pinned = updates.pinned;
+            if (updates.archived !== undefined)
+                sessionUpdates.archived = updates.archived;
+            if (updates.continuationSessionId !== undefined)
+                sessionUpdates.continuation_session_id = updates.continuationSessionId;
+            if (updates.initialCommitHead !== undefined)
+                sessionUpdates.initial_commit_head = updates.initialCommitHead;
+            if (updates.permissionMode !== undefined) {
+                // Validate permission mode
+                const validModes = ['acceptEdits', 'bypassPermissions', 'default', 'plan'];
+                if (!validModes.includes(updates.permissionMode)) {
+                    logger.debug('Invalid permission mode', { requestId, permissionMode: updates.permissionMode });
+                    return res.status(400).json({
+                        success: false,
+                        sessionId,
+                        updatedFields: {},
+                        error: `Permission mode must be one of: ${validModes.join(', ')}`
+                    });
+                }
+                sessionUpdates.permission_mode = updates.permissionMode;
+            }
+            // Update session info
+            const updatedFields = await sessionInfoService.updateSessionInfo(sessionId, sessionUpdates);
+            // If session was archived, clean up insights service tracking
+            if (updates.archived === true) {
+                const insightsService = getInsightsService();
+                insightsService.cleanupSession(sessionId);
+                logger.debug('Cleaned up insights tracking for archived session', {
+                    requestId,
+                    sessionId
+                });
+            }
+            // Log without huge base64 image data
+            const logFields = { ...updatedFields };
+            if (logFields.identity_image && logFields.identity_image.length > 100) {
+                logFields.identity_image = `[base64 ${logFields.identity_image.length} chars]`;
+            }
+            logger.info('Session updated successfully', {
+                requestId,
+                sessionId,
+                updatedFields: logFields
+            });
+            res.json({
+                success: true,
+                sessionId,
+                updatedFields
+            });
+        }
+        catch (error) {
+            logger.debug('Update session failed', {
+                requestId,
+                sessionId,
+                updates,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    // Archive all sessions
+    router.post('/archive-all', async (req, res, next) => {
+        const requestId = req.requestId;
+        logger.debug('Archive all sessions request', {
+            requestId
+        });
+        try {
+            // Archive all sessions
+            const archivedCount = await sessionInfoService.archiveAllSessions();
+            logger.info('All sessions archived successfully', {
+                requestId,
+                archivedCount
+            });
+            res.json({
+                success: true,
+                archivedCount,
+                message: `Successfully archived ${archivedCount} session${archivedCount !== 1 ? 's' : ''}`
+            });
+        }
+        catch (error) {
+            logger.debug('Archive all sessions failed', {
+                requestId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            next(error);
+        }
+    });
+    return router;
+}
+//# sourceMappingURL=conversation.routes.js.map