@theia/terminal 1.73.0-next.9 → 1.73.0

package/src/node/buffering-stream.spec.ts

@@ -40,6 +40,36 @@ describe('BufferringStream', () => {
         expect(await waitForChunk(buffer)).deep.eq(Buffer.from([4, 5]));
     });
 
+    it('should flush with buffer bigger than maxChunkSize', () => {
+        const buffer = new BufferBufferingStream({ maxChunkSize: 2 });
+        const chunks: Buffer[] = [];
+        buffer.onData(c => chunks.push(c));
+        buffer.push(Buffer.from([0, 1, 2, 3, 4, 5]));
+        buffer.flush();
+        expect(chunks).deep.eq([Buffer.from([0, 1]), Buffer.from([2, 3]), Buffer.from([4, 5])]);
+    });
+
+    it('should flush with empty buffer', () => {
+        const buffer = new BufferBufferingStream({ maxChunkSize: 2 });
+        const chunks: Buffer[] = [];
+        buffer.onData(c => chunks.push(c));
+        buffer.flush();
+        expect(chunks).to.be.empty;
+    });
+
+    it('should not let push during a flush affect the result of flush', async () => {
+        const buffer = new BufferBufferingStream({ maxChunkSize: 2 });
+        const chunks: Buffer[] = [];
+        buffer.onData(c => {
+            chunks.push(c);
+            buffer.push(Buffer.from([99]));
+        });
+        buffer.push(Buffer.from([0, 1, 2, 3]));
+        buffer.flush();
+        expect(chunks).deep.eq([Buffer.from([0, 1]), Buffer.from([2, 3])]);
+        expect(await waitForChunk(buffer)).deep.eq(Buffer.from([99, 99]));
+    });
+
     function waitForChunk(buffer: BufferBufferingStream): Promise<Buffer> {
         return new Promise(resolve => buffer.onData(resolve));
     }

package/src/node/buffering-stream.ts

@@ -65,6 +65,19 @@ export class BufferingStream<T> {
         }
     }
 
+    /** Immediately drains all buffered data, cancelling any pending timed flush. */
+    flush(): void {
+        if (this.buffer !== undefined) {
+            clearTimeout(this.timeout);
+            const snapshot = this.buffer;
+            this.buffer = undefined;
+            const totalLength = this.length(snapshot);
+            for (let offset = 0; offset < totalLength; offset += this.maxChunkSize) {
+                this.onDataEmitter.fire(this.slice(snapshot, offset, offset + this.maxChunkSize));
+            }
+        }
+    }
+
     dispose(): void {
         clearTimeout(this.timeout);
         this.buffer = undefined;

package/src/node/shell-terminal-server.spec.ts

@@ -14,8 +14,11 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import * as chai from 'chai';
+import * as os from 'os';
+import * as path from 'path';
+import { FileUri } from '@theia/core/lib/common/file-uri';
 import { createTerminalTestContainer } from './test/terminal-test-container';
-import { IShellTerminalServer } from '../common/shell-terminal-protocol';
+import { IShellTerminalServer, IShellTerminalServerOptions } from '../common/shell-terminal-protocol';
 
 /**
  * Globals
@@ -37,4 +40,119 @@ describe('ShellServer', function (): void {
 
         expect(await createResult).to.be.greaterThan(-1);
     });
+
+    describe('validateTerminalOptions', () => {
+
+        // Access the protected method for direct testing
+        function validate(options: IShellTerminalServerOptions): IShellTerminalServerOptions {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (shellTerminalServer as any).validateTerminalOptions(options);
+            return options;
+        }
+
+        it('should accept valid options unchanged', () => {
+            const options = validate({ cols: 80, rows: 24 });
+            expect(options.cols).to.equal(80);
+            expect(options.rows).to.equal(24);
+        });
+
+        it('should reset cols/rows outside valid range', () => {
+            const options = validate({ cols: -1, rows: 9999 });
+            expect(options.cols).to.be.undefined;
+            expect(options.rows).to.be.undefined;
+        });
+
+        it('should reset non-integer cols/rows', () => {
+            const options = validate({ cols: 80.5, rows: NaN });
+            expect(options.cols).to.be.undefined;
+            expect(options.rows).to.be.undefined;
+        });
+
+        it('should accept valid string args', () => {
+            const options = validate({ args: ['-l', '--color'] });
+            expect(options.args).to.deep.equal(['-l', '--color']);
+        });
+
+        it('should accept a single string as args', () => {
+            const options = validate({ args: '-l' });
+            expect(options.args).to.equal('-l');
+        });
+
+        it('should reset args with non-string elements', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const options = validate({ args: ['-l', 42 as any] });
+            expect(options.args).to.be.undefined;
+        });
+
+        it('should reset non-array non-string args', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const options = validate({ args: { cmd: 'evil' } as any });
+            expect(options.args).to.be.undefined;
+        });
+
+        it('should accept rootURI pointing to an existing directory', () => {
+            const uri = FileUri.create(os.tmpdir()).toString();
+            const options = validate({ rootURI: uri });
+            expect(options.rootURI).to.equal(uri);
+        });
+
+        it('should reset rootURI pointing to a non-existent path', () => {
+            const options = validate({ rootURI: 'file:///nonexistent/path/xyz123' });
+            expect(options.rootURI).to.be.undefined;
+        });
+
+        it('should reset rootURI pointing to a file instead of directory', () => {
+            const filePath = path.join(os.tmpdir(), 'theia-test-' + Date.now());
+            require('fs').writeFileSync(filePath, 'test');
+            try {
+                const options = validate({ rootURI: FileUri.create(filePath).toString() });
+                expect(options.rootURI).to.be.undefined;
+            } finally {
+                require('fs').unlinkSync(filePath);
+            }
+        });
+
+        it('should reset shell that does not exist', () => {
+            const options = validate({ shell: '/nonexistent/shell' });
+            expect(options.shell).to.be.undefined;
+        });
+
+        it('should accept a valid shell', () => {
+            // process.execPath is the Node binary used to run the tests, so it always exists
+            // and is executable on every platform - making it a reliable cross-platform shell value.
+            const options = validate({ shell: process.execPath });
+            expect(options.shell).to.equal(process.execPath);
+        });
+
+        it('should reset non-string shell type', () => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const options = validate({ shell: 42 as any });
+            expect(options.shell).to.be.undefined;
+        });
+
+        it('should reset malformed rootURI', () => {
+            const options = validate({ rootURI: 'not-a-valid-uri' });
+            expect(options.rootURI).to.be.undefined;
+        });
+
+        it('should reject cols: 0 (below minimum)', () => {
+            const options = validate({ cols: 0 });
+            expect(options.cols).to.be.undefined;
+        });
+
+        it('should accept cols: 500 (upper boundary)', () => {
+            const options = validate({ cols: 500 });
+            expect(options.cols).to.equal(500);
+        });
+
+        it('should reject cols: 501 (above maximum)', () => {
+            const options = validate({ cols: 501 });
+            expect(options.cols).to.be.undefined;
+        });
+
+        it('should accept rows: 1 (lower boundary)', () => {
+            const options = validate({ rows: 1 });
+            expect(options.rows).to.equal(1);
+        });
+    });
 });

package/src/node/shell-terminal-server.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 import { exec } from 'child_process';
+import * as fs from 'fs';
 
 import { inject, injectable, named } from '@theia/core/shared/inversify';
 import { ILogger } from '@theia/core/lib/common/logger';
@@ -58,6 +59,7 @@ export class ShellTerminalServer extends BaseTerminalServer implements IShellTer
 
     async create(options: IShellTerminalServerOptions): Promise<number> {
         try {
+            this.validateTerminalOptions(options);
             if (options.strictEnv !== true) {
                 options.env = this.environmentUtils.mergeProcessEnv(options.env);
                 this.applyToProcessEnvironment(URI.fromFilePath(getRootPath(options.rootURI)), options.env);
@@ -71,6 +73,74 @@ export class ShellTerminalServer extends BaseTerminalServer implements IShellTer
         }
     }
 
+    /**
+     * Validates and sanitizes terminal options received from the client.
+     * Invalid values are replaced with safe defaults rather than rejecting the request,
+     * so legitimate users with misconfigured preferences still get a working terminal.
+     */
+    protected validateTerminalOptions(options: IShellTerminalServerOptions): void {
+        // Validate shell: must be an existing, executable file. Fall back to default otherwise.
+        if (options.shell !== undefined) {
+            if (typeof options.shell !== 'string' || !this.isValidShell(options.shell)) {
+                this.logger.warn(`Invalid shell "${options.shell}": falling back to default shell.`);
+                options.shell = undefined;
+            }
+        }
+
+        // Validate rootURI: must resolve to an existing directory.
+        if (options.rootURI !== undefined) {
+            try {
+                const rootPath = getRootPath(options.rootURI);
+                if (!fs.existsSync(rootPath) || !fs.statSync(rootPath).isDirectory()) {
+                    this.logger.warn(`Invalid rootURI "${options.rootURI}": falling back to home directory.`);
+                    options.rootURI = undefined;
+                }
+            } catch {
+                this.logger.warn(`Invalid rootURI "${options.rootURI}": falling back to home directory.`);
+                options.rootURI = undefined;
+            }
+        }
+
+        // Validate cols/rows: must be positive integers within reasonable bounds.
+        if (options.cols !== undefined) {
+            if (typeof options.cols !== 'number' || !Number.isInteger(options.cols) || options.cols < 1 || options.cols > 500) {
+                options.cols = undefined;
+            }
+        }
+        if (options.rows !== undefined) {
+            if (typeof options.rows !== 'number' || !Number.isInteger(options.rows) || options.rows < 1 || options.rows > 500) {
+                options.rows = undefined;
+            }
+        }
+
+        // Validate args: must be a string array or a single string.
+        if (options.args !== undefined) {
+            if (typeof options.args === 'string') {
+                // single string is fine
+            } else if (Array.isArray(options.args)) {
+                if (!options.args.every(arg => typeof arg === 'string')) {
+                    options.args = undefined;
+                }
+            } else {
+                options.args = undefined;
+            }
+        }
+    }
+
+    protected isValidShell(shell: string): boolean {
+        try {
+            // On Windows, cmd.exe and powershell.exe are resolved from PATH,
+            // so we only check accessibility for absolute paths.
+            if (isWindows && !/[/\\]/.test(shell)) {
+                return true;
+            }
+            fs.accessSync(shell, fs.constants.X_OK);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
     // copied and modified from https://github.com/microsoft/vscode/blob/4636be2b71c87bfb0bfe3c94278b447a5efcc1f1/src/vs/workbench/contrib/debug/node/terminals.ts#L32-L75
     private spawnAsPromised(command: string, args: string[]): Promise<string> {
         return new Promise((resolve, reject) => {

package/src/node/terminal-backend-contribution.ts

@@ -50,7 +50,12 @@ export class TerminalBackendContribution implements MessagingService.Contributio
                 output.on('data', chunk => {
                     buffer.push(chunk);
                 });
+                const toDisposeOnProcessClose = termProcess.onClose(() => {
+                    buffer.flush();
+                    channel.close();
+                });
                 channel.onClose(() => {
+                    toDisposeOnProcessClose.dispose();
                     buffer.dispose();
                     output.dispose();
                 });