feat: Add --resume functionality for non-interactive sessions

This commit implements comprehensive session resumption capabilities:

- Add --resume flag to CLI arguments with support for:
  * Index numbers (--resume 1)
  * UUID identifiers (--resume <full-uuid>)
  * Latest session (--resume latest)

- Add --list-sessions flag to display available sessions

- Add --delete-session flag to clean up sessions

- Automatic session recording in non-interactive mode via ChatRecordingService

- Session cleanup functionality with configurable retention policies

- Full integration with existing chat recording infrastructure

The implementation enables users to seamlessly continue conversations across multiple CLI invocations, maintaining context and history.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: BlocksOrg

packages/cli/src/config/config.ts

@@ -81,6 +81,9 @@ export interface CliArgs {
   useSmartEdit: boolean | undefined;
   sessionSummary: string | undefined;
   promptWords: string[] | undefined;
+  resume: string | undefined;
+  listSessions: boolean | undefined;
+  deleteSession: string | undefined;
 }
 
 export async function parseArguments(settings: Settings): Promise<CliArgs> {
@@ -234,6 +237,19 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
           type: 'string',
           description: 'File to write session summary to.',
         })
+        .option('resume', {
+          alias: 'r',
+          type: 'string',
+          description: 'Resume a previous session. Use "latest" for most recent or index number (e.g. --resume 5)',
+        })
+        .option('list-sessions', {
+          type: 'boolean',
+          description: 'List available sessions for the current project and exit.',
+        })
+        .option('delete-session', {
+          type: 'string',
+          description: 'Delete a session by index number (use --list-sessions to see available sessions).',
+        })
         .deprecateOption(
           'telemetry',
           'Use settings.json instead. This flag will be removed in a future version.',
@@ -299,6 +315,16 @@ export async function parseArguments(settings: Settings): Promise<CliArgs> {
               'Cannot use both --yolo (-y) and --approval-mode together. Use --approval-mode=yolo instead.',
             );
           }
+          if (argv.resume && (argv['listSessions'] || argv['deleteSession'])) {
+            throw new Error(
+              'Cannot use --resume with --list-sessions or --delete-session',
+            );
+          }
+          if (argv.resume && !argv.prompt && !promptWords?.length && !process.stdin.isTTY) {
+            throw new Error(
+              'When resuming a session, you must provide a message via --prompt (-p) or stdin',
+            );
+          }
           return true;
         }),
     )

packages/cli/src/config/settings.ts

@@ -46,6 +46,7 @@ function getMergeStrategyForPath(path: string[]): MergeStrategy | undefined {
 }
 
 export type { Settings, MemoryImportFormat };
+export type { SessionRetentionSettings } from './settingsSchema.js';
 
 export const SETTINGS_DIRECTORY_NAME = '.gemini';
 

packages/cli/src/config/settingsSchema.ts

@@ -152,6 +152,48 @@ export const SETTINGS_SCHEMA = {
         description: 'Enable debug logging of keystrokes to the console.',
         showInDialog: true,
       },
+      sessionRetention: {
+        type: 'object',
+        label: 'Session Retention',
+        category: 'General',
+        requiresRestart: false,
+        default: {
+          enabled: false,
+          maxAge: '30d',
+          maxCount: 100,
+        },
+        description: 'Automatic cleanup of old session files.',
+        showInDialog: false,
+        properties: {
+          enabled: {
+            type: 'boolean',
+            label: 'Enable Session Cleanup',
+            category: 'General',
+            requiresRestart: false,
+            default: false,
+            description: 'Enable automatic cleanup of old session files',
+            showInDialog: true,
+          },
+          maxAge: {
+            type: 'string',
+            label: 'Maximum Age',
+            category: 'General',
+            requiresRestart: false,
+            default: '30d',
+            description: 'Maximum age of sessions to keep (e.g., "30d", "7d", "24h")',
+            showInDialog: true,
+          },
+          maxCount: {
+            type: 'number',
+            label: 'Maximum Count',
+            category: 'General',
+            requiresRestart: false,
+            default: 100,
+            description: 'Maximum number of sessions to keep (most recent)',
+            showInDialog: true,
+          },
+        },
+      },
     },
   },
 
@@ -917,3 +959,9 @@ export interface FooterSettings {
   hideSandboxStatus?: boolean;
   hideModelInfo?: boolean;
 }
+
+export interface SessionRetentionSettings {
+  enabled?: boolean;
+  maxAge?: string;
+  maxCount?: number;
+}

packages/cli/src/gemini.test.tsx

@@ -235,6 +235,9 @@ describe('gemini.tsx main function kitty protocol', () => {
       useSmartEdit: undefined,
       sessionSummary: undefined,
       promptWords: undefined,
+      resume: undefined,
+      listSessions: undefined,
+      deleteSession: undefined,
     });
 
     await main();

packages/cli/src/gemini.tsx

@@ -55,6 +55,10 @@ import { SessionStatsProvider } from './ui/contexts/SessionContext.js';
 import { VimModeProvider } from './ui/contexts/VimModeContext.js';
 import { KeypressProvider } from './ui/contexts/KeypressContext.js';
 import { useKittyKeyboardProtocol } from './ui/hooks/useKittyKeyboardProtocol.js';
+import { SessionSelector, formatRelativeTime } from './utils/sessionUtils.js';
+import { cleanupExpiredSessions } from './utils/sessionCleanup.js';
+import fs from 'node:fs/promises';
+import path from 'node:path';
 
 export function validateDnsResolutionOrder(
   order: string | undefined,
@@ -248,6 +252,15 @@ export async function main() {
     argv,
   );
 
+  // Clean up expired sessions on startup
+  try {
+    await cleanupExpiredSessions(config, settings.merged);
+  } catch (error) {
+    if (config.getDebugMode()) {
+      console.debug('Session cleanup error:', error);
+    }
+  }
+
   const wasRaw = process.stdin.isRaw;
   let kittyProtocolDetectionComplete: Promise<boolean> | undefined;
   if (config.isInteractive() && !wasRaw) {
@@ -302,6 +315,58 @@ export async function main() {
     process.exit(0);
   }
 
+  // Handle session management commands
+  if (argv.listSessions) {
+    try {
+      const sessionSelector = new SessionSelector(config);
+      const sessions = await sessionSelector.listSessions();
+      
+      if (sessions.length === 0) {
+        console.log('No previous sessions found for this project.');
+      } else {
+        console.log(`Available sessions for this project (${sessions.length}):\n`);
+        
+        for (const session of sessions) {
+          const timeAgo = formatRelativeTime(session.lastUpdated);
+          console.log(`  ${session.index}. ${session.firstUserMessage} (${timeAgo}) [${session.id}]`);
+        }
+      }
+    } catch (error) {
+      console.error('Error listing sessions:', error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  if (argv.deleteSession) {
+    try {
+      const sessionSelector = new SessionSelector(config);
+      const sessions = await sessionSelector.listSessions();
+      
+      if (sessions.length === 0) {
+        console.error('No sessions found for this project.');
+        process.exit(1);
+      }
+      
+      const index = parseInt(argv.deleteSession, 10);
+      if (isNaN(index) || index < 1 || index > sessions.length) {
+        console.error(`Invalid session index "${argv.deleteSession}". Use --list-sessions to see available sessions.`);
+        process.exit(1);
+      }
+      
+      const session = sessions[index - 1];
+      const chatsDir = path.join(config.storage.getProjectTempDir(), 'chats');
+      const sessionPath = path.join(chatsDir, session.fileName);
+      
+      await fs.unlink(sessionPath);
+      console.log(`Deleted session ${index}: ${session.firstUserMessage}`);
+    } catch (error) {
+      console.error('Error deleting session:', error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
   // Set a default auth type if one isn't set.
   if (!settings.merged.security?.auth?.selectedType) {
     if (process.env['CLOUD_SHELL'] === 'true') {
@@ -482,7 +547,24 @@ export async function main() {
     console.log('Session ID: %s', sessionId);
   }
 
-  await runNonInteractive(nonInteractiveConfig, input, prompt_id);
+  // Handle resume functionality
+  let resumedSessionData: any = undefined;
+  if (argv.resume) {
+    try {
+      const sessionSelector = new SessionSelector(nonInteractiveConfig);
+      const { sessionData, displayInfo } = await sessionSelector.resolveSession(argv.resume);
+      resumedSessionData = { conversation: sessionData, filePath: '' };
+      
+      if (nonInteractiveConfig.getDebugMode()) {
+        console.debug(`Resuming ${displayInfo}`);
+      }
+    } catch (error) {
+      console.error('Error resuming session:', error instanceof Error ? error.message : 'Unknown error');
+      process.exit(1);
+    }
+  }
+
+  await runNonInteractive(nonInteractiveConfig, input, prompt_id, resumedSessionData);
   // Call cleanup before process.exit, which causes cleanup to not run
   await runExitCleanup();
   process.exit(0);

packages/cli/src/nonInteractiveCli.ts

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import type { Config, ToolCallRequestInfo } from '@google/gemini-cli-core';
+import type { Config, ToolCallRequestInfo, ResumedSessionData } from '@google/gemini-cli-core';
 import {
   executeToolCall,
   shutdownTelemetry,
@@ -23,6 +23,7 @@ export async function runNonInteractive(
   config: Config,
   input: string,
   prompt_id: string,
+  resumedSessionData?: ResumedSessionData,
 ): Promise<void> {
   const consolePatcher = new ConsolePatcher({
     stderr: true,
@@ -40,6 +41,29 @@ export async function runNonInteractive(
     });
 
     const geminiClient = config.getGeminiClient();
+    
+    // Initialize chat recording service and handle resumed session
+    if (resumedSessionData) {
+      const chatRecordingService = geminiClient.getChatRecordingService();
+      if (chatRecordingService) {
+        chatRecordingService.initialize(resumedSessionData);
+        
+        // Convert resumed session messages to chat history
+        const geminiChat = await geminiClient.getChat();
+        if (geminiChat && resumedSessionData.conversation.messages.length > 0) {
+          // Load the conversation history into the chat
+          const historyContent: Content[] = resumedSessionData.conversation.messages.map(msg => ({
+            role: msg.type === 'user' ? 'user' : 'model' as const,
+            parts: Array.isArray(msg.content) 
+              ? msg.content.map(part => typeof part === 'string' ? { text: part } : part)
+              : [{ text: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content) }]
+          }));
+          
+          // Set the chat history
+          geminiChat.setHistory(historyContent);
+        }
+      }
+    }
 
     const abortController = new AbortController();