Capture the error if the gateway CLI client executable is not found

web/packages/teleterm/src/services/pty/fixtures/mocks.ts

@@ -29,16 +29,30 @@ export class MockPtyProcess implements IPtyProcess {
 
   dispose() {}
 
-  onData() {}
+  onData() {
+    return () => {};
+  }
 
-  onExit() {}
+  onExit() {
+    return () => {};
+  }
 
-  onOpen() {}
+  onOpen() {
+    return () => {};
+  }
+
+  onStartError() {
+    return () => {};
+  }
 
   getPid() {
     return 0;
   }
 
+  getPtyId() {
+    return '1234';
+  }
+
   async getCwd() {
     return '';
   }

web/packages/teleterm/src/services/pty/ptyHost/ptyEventsStreamHandler.ts

@@ -16,6 +16,8 @@
 
 import { ClientDuplexStream } from '@grpc/grpc-js';
 
+import Logger from 'teleterm/logger';
+
 import {
   PtyClientEvent,
   PtyEventData,
@@ -25,15 +27,22 @@ import {
 } from 'teleterm/sharedProcess/ptyHost';
 
 export class PtyEventsStreamHandler {
+  private logger: Logger;
+
   constructor(
-    private readonly stream: ClientDuplexStream<PtyClientEvent, PtyServerEvent>
-  ) {}
+    private readonly stream: ClientDuplexStream<PtyClientEvent, PtyServerEvent>,
+    ptyId: string
+  ) {
+    this.logger = new Logger(`PtyEventsStreamHandler ${ptyId}`);
+  }
 
   /**
    * Client -> Server stream events
    */
 
   start(columns: number, rows: number): void {
+    this.logger.info('Start');
+
     this.writeOrThrow(
       new PtyClientEvent().setStart(
         new PtyEventStart().setColumns(columns).setRows(rows)
@@ -56,6 +65,8 @@ export class PtyEventsStreamHandler {
   }
 
   dispose(): void {
+    this.logger.info('Dispose');
+
     this.stream.end();
     this.stream.removeAllListeners();
   }
@@ -64,30 +75,51 @@ export class PtyEventsStreamHandler {
    * Stream -> Client stream events
    */
 
-  onOpen(callback: () => void): void {
-    this.stream.addListener('data', (event: PtyServerEvent) => {
-      if (event.hasOpen()) {
-        callback();
+  onOpen(callback: () => void): RemoveListenerFunction {
+    return this.addDataListenerAndReturnRemovalFunction(
+      (event: PtyServerEvent) => {
+        if (event.hasOpen()) {
+          callback();
+        }
       }
-    });
+    );
   }
 
-  onData(callback: (data: string) => void): void {
-    this.stream.addListener('data', (event: PtyServerEvent) => {
-      if (event.hasData()) {
-        callback(event.getData().getMessage());
+  onData(callback: (data: string) => void): RemoveListenerFunction {
+    return this.addDataListenerAndReturnRemovalFunction(
+      (event: PtyServerEvent) => {
+        if (event.hasData()) {
+          callback(event.getData().getMessage());
+        }
       }
-    });
+    );
   }
 
   onExit(
     callback: (reason: { exitCode: number; signal?: number }) => void
-  ): void {
-    this.stream.addListener('data', (event: PtyServerEvent) => {
-      if (event.hasExit()) {
-        callback(event.getExit().toObject());
+  ): RemoveListenerFunction {
+    return this.addDataListenerAndReturnRemovalFunction(
+      (event: PtyServerEvent) => {
+        if (event.hasExit()) {
+          this.logger.info('On exit', event.getExit().toObject());
+          callback(event.getExit().toObject());
+        }
       }
-    });
+    );
+  }
+
+  onStartError(callback: (message: string) => void): RemoveListenerFunction {
+    return this.addDataListenerAndReturnRemovalFunction(
+      (event: PtyServerEvent) => {
+        if (event.hasStartError()) {
+          this.logger.info(
+            'On start error',
+            event.getStartError().toObject().message
+          );
+          callback(event.getStartError().toObject().message);
+        }
+      }
+    );
   }
 
   private writeOrThrow(event: PtyClientEvent) {
@@ -97,4 +129,16 @@ export class PtyEventsStreamHandler {
       }
     });
   }
+
+  private addDataListenerAndReturnRemovalFunction(
+    callback: (event: PtyServerEvent) => void
+  ) {
+    this.stream.addListener('data', callback);
+
+    return () => {
+      this.stream.removeListener('data', callback);
+    };
+  }
 }
+
+type RemoveListenerFunction = () => void;

web/packages/teleterm/src/services/pty/ptyHost/ptyHostClient.ts

@@ -72,7 +72,7 @@ export function createPtyHostClient(
       const metadata = new Metadata();
       metadata.set('ptyId', ptyId);
       const stream = client.exchangeEvents(metadata);
-      return new PtyEventsStreamHandler(stream);
+      return new PtyEventsStreamHandler(stream, ptyId);
     },
   };
 }

web/packages/teleterm/src/services/pty/ptyHost/ptyProcess.ts

@@ -25,6 +25,10 @@ export function createPtyProcess(
   const exchangeEventsStream = ptyHostClient.exchangeEvents(ptyId);
 
   return {
+    getPtyId() {
+      return ptyId;
+    },
+
     /**
      * Client -> Server stream events
      */
@@ -49,18 +53,20 @@ export function createPtyProcess(
      * Server -> Client stream events
      */
 
-    onData(callback: (data: string) => void): void {
-      exchangeEventsStream.onData(callback);
+    onData(callback: (data: string) => void) {
+      return exchangeEventsStream.onData(callback);
+    },
+
+    onOpen(callback: () => void) {
+      return exchangeEventsStream.onOpen(callback);
     },
 
-    onOpen(callback: () => void): void {
-      exchangeEventsStream.onOpen(callback);
+    onExit(callback: (reason: { exitCode: number; signal?: number }) => void) {
+      return exchangeEventsStream.onExit(callback);
     },
 
-    onExit(
-      callback: (reason: { exitCode: number; signal?: number }) => void
-    ): void {
-      exchangeEventsStream.onExit(callback);
+    onStartError(callback: (message: string) => void) {
+      return exchangeEventsStream.onStartError(callback);
     },
 
     /**

web/packages/teleterm/src/sharedProcess/api/proto/ptyHostService.proto

@@ -51,6 +51,7 @@ message PtyServerEvent {
     PtyEventData data = 2;
     PtyEventOpen open = 3;
     PtyEventExit exit = 4;
+    PtyEventStartError start_error = 5;
   }
 }
 
@@ -75,6 +76,10 @@ message PtyEventExit {
   optional uint32 signal = 2;
 }
 
+message PtyEventStartError {
+  string message = 1;
+}
+
 message PtyCwd {
   string cwd = 1;
 }