Add "interactiveTerminal" debugger option

This adds a new option to the debugger configuration to run the program using brickrun -r in an interactive terminal.

Issue #90

Author: dlech

CHANGELOG.md

@@ -4,6 +4,9 @@ All notable changes to the "ev3dev-browser" extension will be documented in this
 Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
 
 ## Unreleased
+### Added
+- New "interactiveTerminal" debugger option to run remote programs in
+  interactive terminal instead of output pane
 ### Changed
 - SSH shell no longer requires native executable on Windows
 

package.json

@@ -195,6 +195,11 @@
                                 "type": "string",
                                 "description": "Absolute path to an executable file on the remote device.",
                                 "default": "/home/robot/myproject/myprogram"
+                            },
+                            "interactiveTerminal": {
+                                "type": "boolean",
+                                "description": "When true, program will be run in a new interactive terminal, when false the output pane will be used instead.",
+                                "default": false
                             }
                         }
                     }

src/debugServer.ts

@@ -2,13 +2,15 @@ import { DebugSession, Event, TerminatedEvent } from 'vscode-debugadapter';
 import { DebugProtocol } from 'vscode-debugprotocol';
 
 /**
- * This interface should always match the schema found in the mock-debug extension manifest.
+ * This interface should always match the schema found in the extension manifest.
  */
 export interface LaunchRequestArguments extends DebugProtocol.LaunchRequestArguments {
     /** An absolute path to the program to debug. */
     program: string;
     /** Download files before running. Default is true. */
     download?: boolean;
+    /** Run in terminal instead of output pane. */
+    interactiveTerminal: boolean;
 }
 
 

src/device.ts

@@ -223,10 +223,11 @@ export class Device extends vscode.Disposable {
      * Executes a command on the remote device.
      * @param command The absolute path of the command.
      */
-    public exec(command: string): Promise<ssh2.Channel> {
+    public exec(command: string, pty?: ssh2.PseudoTtyOptions): Promise<ssh2.ClientChannel> {
         return new Promise((resolve, reject) => {
             const options = {
-                env: vscode.workspace.getConfiguration('ev3devBrowser').get('env')
+                env: vscode.workspace.getConfiguration('ev3devBrowser').get('env'),
+                pty: pty,
             };
             this.client.exec(command, options, (err, channel) => {
                 if (err) {

src/extension.ts

@@ -85,6 +85,7 @@ async function pickDevice(): Promise<void> {
 }
 
 const activeDebugSessions = new Set<string>();
+let debugTerminal: vscode.Terminal;
 
 async function handleCustomDebugEvent(event: vscode.DebugSessionCustomEvent): Promise<void> {
     let device: Device | undefined;
@@ -116,35 +117,93 @@ async function handleCustomDebugEvent(event: vscode.DebugSessionCustomEvent): Pr
             // run the program
             try {
                 const dirname = path.posix.dirname(args.program);
-                const command = `brickrun --directory="${dirname}" "${args.program}"`;
-                output.show(true);
-                output.clear();
-                output.appendLine(`Starting: ${command}`);
-                const channel = await device.exec(command);
-                channel.on('close', () => {
-                    event.session.customRequest('ev3devBrowser.debugger.terminate');
-                });
-                channel.on('exit', (code, signal, coreDump, desc) => {
-                    output.appendLine('----------');
-                    if (code === 0) {
-                        output.appendLine('Completed successfully.');
-                    }
-                    else if (code) {
-                        output.appendLine(`Exited with error code ${code}.`);
-                    }
-                    else {
-                        output.appendLine(`Exited with signal ${signal}.`);
+                const command = `brickrun -r --directory="${dirname}" "${args.program}"`;
+                if (args.interactiveTerminal) {
+                    const config = vscode.workspace.getConfiguration(`terminal.integrated.env.${getPlatform()}`);
+                    const termEnv = config.get<string>('TERM');
+                    const ch = await device.exec(command, { term: termEnv || process.env['TERM'] || 'xterm-256color' });
+                    const writeEmitter = new vscode.EventEmitter<string>();
+                    ch.stdout.on('data', (data: string | Buffer) => writeEmitter.fire(String(data)));
+                    ch.stderr.on('data', (data: string | Buffer) => writeEmitter.fire(String(data)));
+                    if (debugTerminal) {
+                        debugTerminal.dispose();
                     }
-                    activeDebugSessions.delete(event.session.id);
-                });
-                channel.on('data', (chunk) => {
-                    output.append(chunk.toString());
-                });
-                channel.stderr.on('data', (chunk) => {
-                    output.append(chunk.toString());
-                });
-                output.appendLine('Started.');
-                output.appendLine('----------');
+                    debugTerminal = vscode.window.createTerminal({
+                        name: `SSH: ${device.name}`,
+                        pty: {
+                            onDidWrite: writeEmitter.event,
+                            open: (dim: vscode.TerminalDimensions | undefined) => {
+                                if (dim !== undefined) {
+                                    ch.setWindow(dim.rows, dim.columns, 0, 0);
+                                }
+                                writeEmitter.fire(`Starting: ${command}\r\n`);
+                                writeEmitter.fire('----------\r\n');
+                            },
+                            close: () => {
+                                ch.close();
+                                activeDebugSessions.delete(event.session.id);
+                            },
+                            handleInput: (data: string) => {
+                                ch.stdin.write(data);
+                            },
+                            setDimensions: (dim: vscode.TerminalDimensions) => {
+                                ch.setWindow(dim.rows, dim.columns, 0, 0);
+                            },
+                        },
+                    });
+                    ch.on('close', () => {
+                        event.session.customRequest('ev3devBrowser.debugger.terminate');
+                        ch.destroy();
+                    });
+                    ch.on('exit', (code, signal, coreDump, desc) => {
+                        writeEmitter.fire('----------\r\n');
+                        if (code === 0) {
+                            writeEmitter.fire('Completed successfully.\r\n');
+                        }
+                        else if (code) {
+                            writeEmitter.fire(`Exited with error code ${code}.\r\n`);
+                        }
+                        else {
+                            writeEmitter.fire(`Exited with signal ${signal}.\r\n`);
+                        }
+                        activeDebugSessions.delete(event.session.id);
+                    });
+                    ch.on('error', (err: any) => {
+                        vscode.window.showErrorMessage(`Connection error: ${err || err.message}`);
+                        debugTerminal.dispose();
+                        ch.destroy();
+                    });
+                    debugTerminal.show();
+                }
+                else {
+                    output.show(true);
+                    output.clear();
+                    output.appendLine(`Starting: ${command}`);
+                    const channel = await device.exec(command);
+                    channel.on('close', () => {
+                        event.session.customRequest('ev3devBrowser.debugger.terminate');
+                    });
+                    channel.on('exit', (code, signal, coreDump, desc) => {
+                        output.appendLine('----------');
+                        if (code === 0) {
+                            output.appendLine('Completed successfully.');
+                        }
+                        else if (code) {
+                            output.appendLine(`Exited with error code ${code}.`);
+                        }
+                        else {
+                            output.appendLine(`Exited with signal ${signal}.`);
+                        }
+                        activeDebugSessions.delete(event.session.id);
+                    });
+                    channel.on('data', (chunk: string | Buffer) => {
+                        output.append(chunk.toString());
+                    });
+                    channel.stderr.on('data', (chunk) => {
+                        output.append(chunk.toString());
+                    });
+                    output.appendLine('----------');
+                }
                 activeDebugSessions.add(event.session.id);
             }
             catch (err) {