@theia/process 1.47.1 → 1.48.1

package/lib/node/raw-process.js

@@ -1,105 +1,105 @@
-"use strict";
-// *****************************************************************************
-// Copyright (C) 2017 Ericsson and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RawProcess = exports.RawProcessFactory = exports.RawProcessOptions = exports.DevNullStream = void 0;
-const tslib_1 = require("tslib");
-const inversify_1 = require("@theia/core/shared/inversify");
-const process_manager_1 = require("./process-manager");
-const common_1 = require("@theia/core/lib/common");
-const process_1 = require("./process");
-const child_process_1 = require("child_process");
-// The class was here before, exporting to not break anything.
-var dev_null_stream_1 = require("./dev-null-stream");
-Object.defineProperty(exports, "DevNullStream", { enumerable: true, get: function () { return dev_null_stream_1.DevNullStream; } });
-const dev_null_stream_2 = require("./dev-null-stream");
-exports.RawProcessOptions = Symbol('RawProcessOptions');
-exports.RawProcessFactory = Symbol('RawProcessFactory');
-let RawProcess = class RawProcess extends process_1.Process {
-    constructor(// eslint-disable-next-line @typescript-eslint/indent
-    options, processManager, logger) {
-        super(processManager, logger, process_1.ProcessType.Raw, options);
-        const executable = this.isForkOptions(options) ? options.modulePath : options.command;
-        this.logger.debug(`Starting raw process: ${executable},`
-            + ` with args: ${options.args ? options.args.join(' ') : ''}, `
-            + ` with options: ${JSON.stringify(options.options)}`);
-        // About catching errors: spawn will sometimes throw directly
-        // (EACCES on Linux), sometimes return a Process object with the pid
-        // property undefined (ENOENT on Linux) and then emit an 'error' event.
-        // For now, we try to normalize that into always emitting an 'error'
-        // event.
-        try {
-            if (this.isForkOptions(options)) {
-                this.process = (0, child_process_1.fork)(options.modulePath, options.args || [], options.options || {});
-            }
-            else {
-                this.process = (0, child_process_1.spawn)(options.command, options.args || [], options.options || {});
-            }
-            this.process.on('error', (error) => {
-                error.code = error.code || 'Unknown error';
-                this.emitOnError(error);
-            });
-            // When no stdio option is passed, it is null by default.
-            this.outputStream = this.process.stdout || new dev_null_stream_2.DevNullStream({ autoDestroy: true });
-            this.inputStream = this.process.stdin || new dev_null_stream_2.DevNullStream({ autoDestroy: true });
-            this.errorStream = this.process.stderr || new dev_null_stream_2.DevNullStream({ autoDestroy: true });
-            this.process.on('exit', (exitCode, signal) => {
-                // node's child_process exit sets the unused parameter to null,
-                // but we want it to be undefined instead.
-                this.emitOnExit(typeof exitCode === 'number' ? exitCode : undefined, typeof signal === 'string' ? signal : undefined);
-                this.processManager.unregister(this);
-            });
-            this.process.on('close', (exitCode, signal) => {
-                // node's child_process exit sets the unused parameter to null,
-                // but we want it to be undefined instead.
-                this.emitOnClose(typeof exitCode === 'number' ? exitCode : undefined, typeof signal === 'string' ? signal : undefined);
-            });
-            if (this.process.pid !== undefined) {
-                process.nextTick(this.emitOnStarted.bind(this));
-            }
-        }
-        catch (error) {
-            /* When an error is thrown, set up some fake streams, so the client
-               code doesn't break because these field are undefined.  */
-            this.outputStream = new dev_null_stream_2.DevNullStream({ autoDestroy: true });
-            this.inputStream = new dev_null_stream_2.DevNullStream({ autoDestroy: true });
-            this.errorStream = new dev_null_stream_2.DevNullStream({ autoDestroy: true });
-            /* Call the client error handler, but first give them a chance to register it.  */
-            this.emitOnErrorAsync(error);
-        }
-    }
-    get pid() {
-        if (!this.process || !this.process.pid) {
-            throw new Error('process did not start correctly');
-        }
-        return this.process.pid;
-    }
-    kill(signal) {
-        if (this.process && this.killed === false) {
-            this.process.kill(signal);
-        }
-    }
-};
-RawProcess = (0, tslib_1.__decorate)([
-    (0, inversify_1.injectable)(),
-    (0, tslib_1.__param)(0, (0, inversify_1.inject)(exports.RawProcessOptions)),
-    (0, tslib_1.__param)(1, (0, inversify_1.inject)(process_manager_1.ProcessManager)),
-    (0, tslib_1.__param)(2, (0, inversify_1.inject)(common_1.ILogger)),
-    (0, tslib_1.__param)(2, (0, inversify_1.named)('process')),
-    (0, tslib_1.__metadata)("design:paramtypes", [Object, process_manager_1.ProcessManager, Object])
-], RawProcess);
-exports.RawProcess = RawProcess;
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2017 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawProcess = exports.RawProcessFactory = exports.RawProcessOptions = exports.DevNullStream = void 0;
+const tslib_1 = require("tslib");
+const inversify_1 = require("@theia/core/shared/inversify");
+const process_manager_1 = require("./process-manager");
+const common_1 = require("@theia/core/lib/common");
+const process_1 = require("./process");
+const child_process_1 = require("child_process");
+// The class was here before, exporting to not break anything.
+var dev_null_stream_1 = require("./dev-null-stream");
+Object.defineProperty(exports, "DevNullStream", { enumerable: true, get: function () { return dev_null_stream_1.DevNullStream; } });
+const dev_null_stream_2 = require("./dev-null-stream");
+exports.RawProcessOptions = Symbol('RawProcessOptions');
+exports.RawProcessFactory = Symbol('RawProcessFactory');
+let RawProcess = class RawProcess extends process_1.Process {
+    constructor(// eslint-disable-next-line @typescript-eslint/indent
+    options, processManager, logger) {
+        super(processManager, logger, process_1.ProcessType.Raw, options);
+        const executable = this.isForkOptions(options) ? options.modulePath : options.command;
+        this.logger.debug(`Starting raw process: ${executable},`
+            + ` with args: ${options.args ? options.args.join(' ') : ''}, `
+            + ` with options: ${JSON.stringify(options.options)}`);
+        // About catching errors: spawn will sometimes throw directly
+        // (EACCES on Linux), sometimes return a Process object with the pid
+        // property undefined (ENOENT on Linux) and then emit an 'error' event.
+        // For now, we try to normalize that into always emitting an 'error'
+        // event.
+        try {
+            if (this.isForkOptions(options)) {
+                this.process = (0, child_process_1.fork)(options.modulePath, options.args || [], options.options || {});
+            }
+            else {
+                this.process = (0, child_process_1.spawn)(options.command, options.args || [], options.options || {});
+            }
+            this.process.on('error', (error) => {
+                error.code = error.code || 'Unknown error';
+                this.emitOnError(error);
+            });
+            // When no stdio option is passed, it is null by default.
+            this.outputStream = this.process.stdout || new dev_null_stream_2.DevNullStream({ autoDestroy: true });
+            this.inputStream = this.process.stdin || new dev_null_stream_2.DevNullStream({ autoDestroy: true });
+            this.errorStream = this.process.stderr || new dev_null_stream_2.DevNullStream({ autoDestroy: true });
+            this.process.on('exit', (exitCode, signal) => {
+                // node's child_process exit sets the unused parameter to null,
+                // but we want it to be undefined instead.
+                this.emitOnExit(typeof exitCode === 'number' ? exitCode : undefined, typeof signal === 'string' ? signal : undefined);
+                this.processManager.unregister(this);
+            });
+            this.process.on('close', (exitCode, signal) => {
+                // node's child_process exit sets the unused parameter to null,
+                // but we want it to be undefined instead.
+                this.emitOnClose(typeof exitCode === 'number' ? exitCode : undefined, typeof signal === 'string' ? signal : undefined);
+            });
+            if (this.process.pid !== undefined) {
+                process.nextTick(this.emitOnStarted.bind(this));
+            }
+        }
+        catch (error) {
+            /* When an error is thrown, set up some fake streams, so the client
+               code doesn't break because these field are undefined.  */
+            this.outputStream = new dev_null_stream_2.DevNullStream({ autoDestroy: true });
+            this.inputStream = new dev_null_stream_2.DevNullStream({ autoDestroy: true });
+            this.errorStream = new dev_null_stream_2.DevNullStream({ autoDestroy: true });
+            /* Call the client error handler, but first give them a chance to register it.  */
+            this.emitOnErrorAsync(error);
+        }
+    }
+    get pid() {
+        if (!this.process || !this.process.pid) {
+            throw new Error('process did not start correctly');
+        }
+        return this.process.pid;
+    }
+    kill(signal) {
+        if (this.process && this.killed === false) {
+            this.process.kill(signal);
+        }
+    }
+};
+RawProcess = (0, tslib_1.__decorate)([
+    (0, inversify_1.injectable)(),
+    (0, tslib_1.__param)(0, (0, inversify_1.inject)(exports.RawProcessOptions)),
+    (0, tslib_1.__param)(1, (0, inversify_1.inject)(process_manager_1.ProcessManager)),
+    (0, tslib_1.__param)(2, (0, inversify_1.inject)(common_1.ILogger)),
+    (0, tslib_1.__param)(2, (0, inversify_1.named)('process')),
+    (0, tslib_1.__metadata)("design:paramtypes", [Object, process_manager_1.ProcessManager, Object])
+], RawProcess);
+exports.RawProcess = RawProcess;
 //# sourceMappingURL=raw-process.js.map

package/lib/node/raw-process.spec.d.ts

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=raw-process.spec.d.ts.map

package/lib/node/raw-process.spec.js

@@ -1,165 +1,165 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// *****************************************************************************
-// Copyright (C) 2017 Ericsson and others.
-//
-// This program and the accompanying materials are made available under the
-// terms of the Eclipse Public License v. 2.0 which is available at
-// http://www.eclipse.org/legal/epl-2.0.
-//
-// This Source Code may also be made available under the following Secondary
-// Licenses when the conditions for such availability set forth in the Eclipse
-// Public License v. 2.0 are satisfied: GNU General Public License, version 2
-// with the GNU Classpath Exception which is available at
-// https://www.gnu.org/software/classpath/license.html.
-//
-// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
-// *****************************************************************************
-const chai = require("chai");
-const process = require("process");
-const stream = require("stream");
-const process_test_container_1 = require("./test/process-test-container");
-const raw_process_1 = require("./raw-process");
-const temp = require("temp");
-const fs = require("fs");
-const path = require("path");
-const core_1 = require("@theia/core");
-/* Allow to create temporary files, but delete them when we're done.  */
-const track = temp.track();
-/**
- * Globals
- */
-const expect = chai.expect;
-const FORK_TEST_FILE = path.join(__dirname, '../../src/node/test/process-fork-test.js');
-describe('RawProcess', function () {
-    this.timeout(20000);
-    let rawProcessFactory;
-    beforeEach(() => {
-        rawProcessFactory = (0, process_test_container_1.createProcessTestContainer)().get(raw_process_1.RawProcessFactory);
-    });
-    after(() => {
-        track.cleanupSync();
-    });
-    it('test error on non-existent path', async function () {
-        const error = await new Promise((resolve, reject) => {
-            const proc = rawProcessFactory({ command: '/non-existent' });
-            proc.onStart(reject);
-            proc.onError(resolve);
-            proc.onExit(reject);
-        });
-        expect(error.code).eq('ENOENT');
-    });
-    it('test error on non-executable path', async function () {
-        // Create a non-executable file.
-        const f = track.openSync('non-executable');
-        fs.writeSync(f.fd, 'echo bob');
-        // Make really sure it's non-executable.
-        let mode = fs.fstatSync(f.fd).mode;
-        mode &= ~fs.constants.S_IXUSR;
-        mode &= ~fs.constants.S_IXGRP;
-        mode &= ~fs.constants.S_IXOTH;
-        fs.fchmodSync(f.fd, mode);
-        fs.closeSync(f.fd);
-        const error = await new Promise((resolve, reject) => {
-            const proc = rawProcessFactory({ command: f.path });
-            proc.onStart(reject);
-            proc.onError(resolve);
-            proc.onExit(reject);
-        });
-        // On Windows, we get 'UNKNOWN'.
-        const expectedCode = core_1.isWindows ? 'UNKNOWN' : 'EACCES';
-        expect(error.code).eq(expectedCode);
-    });
-    it('test start event', function () {
-        return new Promise(async (resolve, reject) => {
-            const args = ['-e', 'process.exit(3)'];
-            const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
-            rawProcess.onStart(resolve);
-            rawProcess.onError(reject);
-            rawProcess.onExit(reject);
-        });
-    });
-    it('test exit', async function () {
-        const args = ['--version'];
-        const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
-        const p = new Promise((resolve, reject) => {
-            rawProcess.onError(reject);
-            rawProcess.onExit(event => {
-                if (event.code === undefined) {
-                    reject(new Error('event.code is undefined'));
-                }
-                else {
-                    resolve(event.code);
-                }
-            });
-        });
-        const exitCode = await p;
-        expect(exitCode).equal(0);
-    });
-    it('test pipe stdout stream', async function () {
-        const output = await new Promise(async (resolve, reject) => {
-            const args = ['-e', 'console.log("text to stdout")'];
-            const outStream = new stream.PassThrough();
-            const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
-            rawProcess.onError(reject);
-            rawProcess.outputStream.pipe(outStream);
-            let buf = '';
-            outStream.on('data', data => {
-                buf += data.toString();
-            });
-            outStream.on('end', () => {
-                resolve(buf.trim());
-            });
-        });
-        expect(output).to.be.equal('text to stdout');
-    });
-    it('test pipe stderr stream', async function () {
-        const output = await new Promise(async (resolve, reject) => {
-            const args = ['-e', 'console.error("text to stderr")'];
-            const outStream = new stream.PassThrough();
-            const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
-            rawProcess.onError(reject);
-            rawProcess.errorStream.pipe(outStream);
-            let buf = '';
-            outStream.on('data', data => {
-                buf += data.toString();
-            });
-            outStream.on('end', () => {
-                resolve(buf.trim());
-            });
-        });
-        expect(output).to.be.equal('text to stderr');
-    });
-    it('test forked pipe stdout stream', async function () {
-        const args = ['version'];
-        const rawProcess = rawProcessFactory({ modulePath: FORK_TEST_FILE, args, options: { stdio: 'pipe' } });
-        const outStream = new stream.PassThrough();
-        const p = new Promise((resolve, reject) => {
-            let version = '';
-            outStream.on('data', data => {
-                version += data.toString();
-            });
-            outStream.on('end', () => {
-                resolve(version.trim());
-            });
-        });
-        rawProcess.outputStream.pipe(outStream);
-        expect(await p).to.be.equal('1.0.0');
-    });
-    it('test forked pipe stderr stream', async function () {
-        const rawProcess = rawProcessFactory({ modulePath: FORK_TEST_FILE, args: [], options: { stdio: 'pipe' } });
-        const outStream = new stream.PassThrough();
-        const p = new Promise((resolve, reject) => {
-            let version = '';
-            outStream.on('data', data => {
-                version += data.toString();
-            });
-            outStream.on('end', () => {
-                resolve(version.trim());
-            });
-        });
-        rawProcess.errorStream.pipe(outStream);
-        expect(await p).to.have.string('Error');
-    });
-});
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// *****************************************************************************
+// Copyright (C) 2017 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+const chai = require("chai");
+const process = require("process");
+const stream = require("stream");
+const process_test_container_1 = require("./test/process-test-container");
+const raw_process_1 = require("./raw-process");
+const temp = require("temp");
+const fs = require("fs");
+const path = require("path");
+const core_1 = require("@theia/core");
+/* Allow to create temporary files, but delete them when we're done.  */
+const track = temp.track();
+/**
+ * Globals
+ */
+const expect = chai.expect;
+const FORK_TEST_FILE = path.join(__dirname, '../../src/node/test/process-fork-test.js');
+describe('RawProcess', function () {
+    this.timeout(20000);
+    let rawProcessFactory;
+    beforeEach(() => {
+        rawProcessFactory = (0, process_test_container_1.createProcessTestContainer)().get(raw_process_1.RawProcessFactory);
+    });
+    after(() => {
+        track.cleanupSync();
+    });
+    it('test error on non-existent path', async function () {
+        const error = await new Promise((resolve, reject) => {
+            const proc = rawProcessFactory({ command: '/non-existent' });
+            proc.onStart(reject);
+            proc.onError(resolve);
+            proc.onExit(reject);
+        });
+        expect(error.code).eq('ENOENT');
+    });
+    it('test error on non-executable path', async function () {
+        // Create a non-executable file.
+        const f = track.openSync('non-executable');
+        fs.writeSync(f.fd, 'echo bob');
+        // Make really sure it's non-executable.
+        let mode = fs.fstatSync(f.fd).mode;
+        mode &= ~fs.constants.S_IXUSR;
+        mode &= ~fs.constants.S_IXGRP;
+        mode &= ~fs.constants.S_IXOTH;
+        fs.fchmodSync(f.fd, mode);
+        fs.closeSync(f.fd);
+        const error = await new Promise((resolve, reject) => {
+            const proc = rawProcessFactory({ command: f.path });
+            proc.onStart(reject);
+            proc.onError(resolve);
+            proc.onExit(reject);
+        });
+        // On Windows, we get 'UNKNOWN'.
+        const expectedCode = core_1.isWindows ? 'UNKNOWN' : 'EACCES';
+        expect(error.code).eq(expectedCode);
+    });
+    it('test start event', function () {
+        return new Promise(async (resolve, reject) => {
+            const args = ['-e', 'process.exit(3)'];
+            const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
+            rawProcess.onStart(resolve);
+            rawProcess.onError(reject);
+            rawProcess.onExit(reject);
+        });
+    });
+    it('test exit', async function () {
+        const args = ['--version'];
+        const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
+        const p = new Promise((resolve, reject) => {
+            rawProcess.onError(reject);
+            rawProcess.onExit(event => {
+                if (event.code === undefined) {
+                    reject(new Error('event.code is undefined'));
+                }
+                else {
+                    resolve(event.code);
+                }
+            });
+        });
+        const exitCode = await p;
+        expect(exitCode).equal(0);
+    });
+    it('test pipe stdout stream', async function () {
+        const output = await new Promise(async (resolve, reject) => {
+            const args = ['-e', 'console.log("text to stdout")'];
+            const outStream = new stream.PassThrough();
+            const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
+            rawProcess.onError(reject);
+            rawProcess.outputStream.pipe(outStream);
+            let buf = '';
+            outStream.on('data', data => {
+                buf += data.toString();
+            });
+            outStream.on('end', () => {
+                resolve(buf.trim());
+            });
+        });
+        expect(output).to.be.equal('text to stdout');
+    });
+    it('test pipe stderr stream', async function () {
+        const output = await new Promise(async (resolve, reject) => {
+            const args = ['-e', 'console.error("text to stderr")'];
+            const outStream = new stream.PassThrough();
+            const rawProcess = rawProcessFactory({ command: process.execPath, 'args': args });
+            rawProcess.onError(reject);
+            rawProcess.errorStream.pipe(outStream);
+            let buf = '';
+            outStream.on('data', data => {
+                buf += data.toString();
+            });
+            outStream.on('end', () => {
+                resolve(buf.trim());
+            });
+        });
+        expect(output).to.be.equal('text to stderr');
+    });
+    it('test forked pipe stdout stream', async function () {
+        const args = ['version'];
+        const rawProcess = rawProcessFactory({ modulePath: FORK_TEST_FILE, args, options: { stdio: 'pipe' } });
+        const outStream = new stream.PassThrough();
+        const p = new Promise((resolve, reject) => {
+            let version = '';
+            outStream.on('data', data => {
+                version += data.toString();
+            });
+            outStream.on('end', () => {
+                resolve(version.trim());
+            });
+        });
+        rawProcess.outputStream.pipe(outStream);
+        expect(await p).to.be.equal('1.0.0');
+    });
+    it('test forked pipe stderr stream', async function () {
+        const rawProcess = rawProcessFactory({ modulePath: FORK_TEST_FILE, args: [], options: { stdio: 'pipe' } });
+        const outStream = new stream.PassThrough();
+        const p = new Promise((resolve, reject) => {
+            let version = '';
+            outStream.on('data', data => {
+                version += data.toString();
+            });
+            outStream.on('end', () => {
+                resolve(version.trim());
+            });
+        });
+        rawProcess.errorStream.pipe(outStream);
+        expect(await p).to.have.string('Error');
+    });
+});
 //# sourceMappingURL=raw-process.spec.js.map

package/lib/node/task-terminal-process.d.ts

@@ -1,11 +1,11 @@
-import { TerminalProcess, TerminalProcessOptions } from './terminal-process';
-export declare const TaskTerminalProcessFactory: unique symbol;
-export interface TaskTerminalProcessFactory {
-    (options: TerminalProcessOptions): TaskTerminalProcess;
-}
-export declare class TaskTerminalProcess extends TerminalProcess {
-    exited: boolean;
-    attachmentAttempted: boolean;
-    protected onTerminalExit(code: number | undefined, signal: string | undefined): void;
-}
+import { TerminalProcess, TerminalProcessOptions } from './terminal-process';
+export declare const TaskTerminalProcessFactory: unique symbol;
+export interface TaskTerminalProcessFactory {
+    (options: TerminalProcessOptions): TaskTerminalProcess;
+}
+export declare class TaskTerminalProcess extends TerminalProcess {
+    exited: boolean;
+    attachmentAttempted: boolean;
+    protected onTerminalExit(code: number | undefined, signal: string | undefined): void;
+}
 //# sourceMappingURL=task-terminal-process.d.ts.map