Add Terminal History via OSC Sequence Shell Injection

NOTICE.md

@@ -208,6 +208,12 @@ b73945c70f1117c4e65939dd3e10bdd623cb4ef3 (n/a)
 
 * License: CC-BY-4.0
 
+intellij-community (2025.2.4)
+
+* License: Apache-2.0
+* Project: <https://github.com/JetBrains/intellij-community>
+* Source: <https://github.com/JetBrains/intellij-community>
+
 inversify (5.0.1)
 
 * License: MIT

dev-packages/application-manager/src/generator/webpack-generator.ts

@@ -95,6 +95,12 @@ const plugins = [
                 from: path.join(resolvePackagePath('@theia/plugin-ext-vscode', __dirname), '..', 'lib', 'node', 'context', 'plugin-vscode-init-fe.js'),
                 to: path.resolve(__dirname, 'lib', 'frontend', 'context', 'plugin-vscode-init-fe.js')
             }`)}
+            ${this.ifPackage('@theia/terminal', `,
+            {
+                // copy shell integration scripts
+                from: path.join(resolvePackagePath('@theia/terminal', __dirname), '..', 'src', 'node', 'shell-integrations'),
+                to: path.resolve(__dirname, 'lib', 'backend', 'shell-integrations')
+            }`)}
         ]
     }),
     new webpack.ProvidePlugin({

packages/ai-terminal/src/browser/ai-terminal-contribution.ts

@@ -21,10 +21,12 @@ import { inject, injectable } from '@theia/core/shared/inversify';
 import { TerminalService } from '@theia/terminal/lib/browser/base/terminal-service';
 import { TerminalMenus } from '@theia/terminal/lib/browser/terminal-frontend-contribution';
 import { TerminalWidgetImpl } from '@theia/terminal/lib/browser/terminal-widget-impl';
+import { TerminalPreferences } from '@theia/terminal/lib/common/terminal-preferences';
 import { AiTerminalAgent } from './ai-terminal-agent';
 import { AICommandHandlerFactory } from '@theia/ai-core/lib/browser/ai-command-handler-factory';
 import { AgentService } from '@theia/ai-core';
 import { nls } from '@theia/core/lib/common/nls';
+import { TerminalBlock } from '@theia/terminal/lib/browser/base/terminal-widget';
 
 const AI_TERMINAL_COMMAND = Command.toLocalizedCommand({
     id: 'ai-terminal:open',
@@ -50,6 +52,9 @@ export class AiTerminalCommandContribution implements CommandContribution, MenuC
     @inject(ApplicationShell)
     protected readonly shell: ApplicationShell;
 
+    @inject(TerminalPreferences)
+    protected readonly terminalPreferences: TerminalPreferences;
+
     registerKeybindings(keybindings: KeybindingRegistry): void {
         keybindings.registerKeybinding({
             command: AI_TERMINAL_COMMAND.id,
@@ -71,7 +76,8 @@ export class AiTerminalCommandContribution implements CommandContribution, MenuC
                 if (currentTerminal instanceof TerminalWidgetImpl && currentTerminal.kind === 'user') {
                     new AiTerminalChatWidget(
                         currentTerminal,
-                        this.terminalAgent
+                        this.terminalAgent,
+                        () => this.terminalPreferences['terminal.integrated.enableCommandHistory'] ?? false
                     );
                 }
             },
@@ -96,7 +102,8 @@ class AiTerminalChatWidget {
 
     constructor(
         protected terminalWidget: TerminalWidgetImpl,
-        protected terminalAgent: AiTerminalAgent
+        protected terminalAgent: AiTerminalAgent,
+        protected getEnableCommandHistory: () => boolean
     ) {
         this.chatContainer = document.createElement('div');
         this.chatContainer.className = 'ai-terminal-chat-container';
@@ -185,12 +192,47 @@ class AiTerminalChatWidget {
     }
 
     protected getRecentTerminalCommands(): string[] {
+        // Character count for recent context when one line is 120 characters long.
+        const characterLimit = 1200;
+        if (this.getEnableCommandHistory()) {
+            const commandHistory = this.terminalWidget.commandHistoryState.commandHistory;
+            return this.extractContextFromTerminalOutput(commandHistory, characterLimit);
+        }
+
         const maxLines = 100;
         return this.terminalWidget.buffer.getLines(0,
             this.terminalWidget.buffer.length > maxLines ? maxLines : this.terminalWidget.buffer.length
         );
     }
 
+    protected extractContextFromTerminalOutput(commandBlocks: TerminalBlock[], characterLimit: number): string[] {
+        const context: string[] = [];
+        let currentCharacters = 0;
+
+        for (let i = commandBlocks.length - 1; i >= 0; i--) {
+            const block = commandBlocks[i];
+            const blockCharacters = block.command.length + block.output.length;
+
+            if (currentCharacters + blockCharacters <= characterLimit) {
+                context.unshift(`${block.command}\n${block.output}`);
+                currentCharacters += blockCharacters;
+            } else {
+                const remainingCharacters = characterLimit - currentCharacters;
+                if (block.command.length <= remainingCharacters) {
+                    const outputLimit = remainingCharacters - block.command.length;
+                    const trimmedOutput = block.output.substring(0, outputLimit);
+                    context.unshift(`${block.command}\n${trimmedOutput}`);
+                } else {
+                    const trimmedCommand = block.command.substring(0, remainingCharacters);
+                    context.unshift(trimmedCommand);
+                }
+                break;
+            }
+        }
+
+        return context;
+    }
+
     protected getNextCommandIndex(step: number): number {
         const currentIndex = this.commands.indexOf(this.chatResultParagraph.innerText);
         const nextIndex = (currentIndex + step + this.commands.length) % this.commands.length;

packages/debug/src/browser/debug-session.tsx

@@ -522,6 +522,12 @@ export class DebugSession implements CompositeTreeElement {
         if (!terminal) {
             terminal = await this.terminalServer.newTerminal(options);
             await terminal.start();
+            try {
+                // delay opening of the terminal until the terminal prompt appears to prevent duplicate commands in the terminal buffer
+                await waitForEvent(terminal.commandHistoryState.onTerminalPromptShown, 3000);
+            } catch (error) {
+                console.warn(`Terminal did not emit prompt in time, using it anyway: ${error}`);
+            }
         }
         this.terminalServer.open(terminal);
         return terminal;

packages/process/src/node/task-terminal-process.ts

@@ -27,8 +27,29 @@ export class TaskTerminalProcess extends TerminalProcess {
 
     public exited = false;
     public attachmentAttempted = false;
+    /**
+     * Controls whether OSC (Operating System Command) sequences are injected
+     * into the terminal stream for command history tracking.
+     */
+    protected _enableCommandHistory = false;
+
+    setEnableCommandHistory(enable: boolean): void {
+        this._enableCommandHistory = enable;
+    }
+
+    /**
+     * injects the command to be tracked into the terminal output stream
+     * only if command history tracking is enabled
+     */
+    injectCommandStartOsc(command: string): void {
+        if (this._enableCommandHistory) {
+            const encoded = Buffer.from(command).toString('hex');
+            this.ringBuffer.enq(`\x1b]133;command_started;${encoded}\x07`);
+        }
+    }
 
     protected override onTerminalExit(code: number | undefined, signal: string | undefined): void {
+        this.injectCommandEndOsc();
         this.emitOnExit(code, signal);
         this.exited = true;
         // Unregister process only if task terminal already attached (or failed attach),
@@ -38,4 +59,17 @@ export class TaskTerminalProcess extends TerminalProcess {
         }
     }
 
+    override kill(signal?: string): void {
+        this.injectCommandEndOsc();
+        super.kill(signal);
+    }
+
+    protected injectCommandEndOsc(): void {
+        if (this._enableCommandHistory) {
+            // Mark the task command as finished in command history tracking.
+            // OSC 133 'prompt_started' signals the end of command execution.
+            this.ringBuffer.enq('\x1b]133;prompt_started\x07');
+        }
+    }
+
 }

packages/task/src/browser/task-service.ts

@@ -68,6 +68,7 @@ import { TaskTerminalWidgetManager } from './task-terminal-widget-manager';
 import { ShellTerminalServerProxy } from '@theia/terminal/lib/common/shell-terminal-protocol';
 import { Mutex } from 'async-mutex';
 import { TaskContextKeyService } from './task-context-key-service';
+import { TerminalPreferences } from '@theia/terminal/lib/common/terminal-preferences';
 
 export interface QuickPickProblemMatcherItem {
     problemMatchers: NamedProblemMatcher[] | undefined;
@@ -197,6 +198,9 @@ export class TaskService implements TaskConfigurationClient {
     @inject(TaskContextKeyService)
     protected readonly taskContextKeyService: TaskContextKeyService;
 
+    @inject(TerminalPreferences)
+    protected readonly terminalPreferences: TerminalPreferences;
+
     @postConstruct()
     protected init(): void {
         this.getRunningTasks().then(tasks =>
@@ -999,6 +1003,7 @@ export class TaskService implements TaskConfigurationClient {
         const taskLabel = resolvedTask.label;
         let taskInfo: TaskInfo | undefined;
         try {
+            resolvedTask.enableCommandHistory = this.terminalPreferences['terminal.integrated.enableCommandHistory'] ?? false;
             taskInfo = await this.taskServer.run(resolvedTask, this.getContext(), option);
             this.lastTask = { resolvedTask, option };
             this.logger.debug(`Task created. Task id: ${taskInfo.taskId}`);

packages/task/src/common/task-protocol.ts

@@ -179,6 +179,12 @@ export interface TaskConfiguration extends TaskCustomization {
     readonly label: string;
     readonly _scope: TaskConfigurationScope;
     readonly executionType?: 'shell' | 'process' | 'customExecution';
+    /**
+     * Whether to enable command history tracking for this task's terminal.
+     * When enabled, OSC sequences are injected to mark command boundaries.
+     * Defaults to false if not specified.
+     */
+    enableCommandHistory?: boolean;
 }
 
 export interface ContributedTaskConfiguration extends TaskConfiguration {

packages/task/src/node/process/process-task-runner.ts

@@ -28,6 +28,7 @@ import {
     Process,
     TerminalProcessOptions,
     TaskTerminalProcessFactory,
+    TaskTerminalProcess,
 } from '@theia/process/lib/node';
 import {
     ShellQuotedString, ShellQuotingFunctions, BashQuotingFunctions, CmdQuotingFunctions, PowershellQuotingFunctions, createShellCommandLine, ShellQuoting,
@@ -86,6 +87,9 @@ export class ProcessTaskRunner implements TaskRunner {
             // - shell: defer the spawning to a shell that will evaluate a command line with our executable.
             const terminalProcessOptions = this.getResolvedCommand(taskConfig);
             const terminal: Process = this.taskTerminalProcessFactory(terminalProcessOptions);
+            const processType = (taskConfig.executionType || taskConfig.type) as 'process' | 'shell';
+            const command = this.getCommand(processType, terminalProcessOptions);
+            this.setupTaskTerminalCommandHistory(terminal, taskConfig.enableCommandHistory ?? false, command);
 
             // Wait for the confirmation that the process is successfully started, or has failed to start.
             await new Promise((resolve, reject) => {
@@ -95,21 +99,34 @@ export class ProcessTaskRunner implements TaskRunner {
                 });
             });
 
-            const processType = (taskConfig.executionType || taskConfig.type) as 'process' | 'shell';
             return this.taskFactory({
                 label: taskConfig.label,
                 process: terminal,
                 processType,
                 context: ctx,
                 config: taskConfig,
-                command: this.getCommand(processType, terminalProcessOptions)
+                command: command,
             });
         } catch (error) {
             this.logger.error(`Error occurred while creating task: ${error}`);
             throw error;
         }
     }
 
+    /**
+     * Enables or disables command history tracking for the task terminal.
+     * When enabled, OSC sequences are injected into the terminal output stream
+     * to mark command boundaries for history tracking.
+     */
+    protected setupTaskTerminalCommandHistory(terminal: Process, enable: boolean, command?: string): void {
+        if (terminal instanceof TaskTerminalProcess) {
+            terminal.setEnableCommandHistory(enable);
+        }
+        if (terminal instanceof TaskTerminalProcess && command) {
+            terminal.injectCommandStartOsc(command);
+        }
+    }
+
     protected getResolvedCommand(taskConfig: TaskConfiguration): TerminalProcessOptions {
         const osSpecificCommand = this.getOsSpecificCommand(taskConfig);