/*---------------------------------------------------------------------------------------------

* Copyright (c) Microsoft Corporation. All rights reserved.

* Licensed under the MIT License. See License.txt in the project root for license information.

*--------------------------------------------------------------------------------------------*/

import {

DebugSession, Thread, Source, StackFrame, Scope, Variable, Breakpoint,

TerminatedEvent, InitializedEvent, StoppedEvent, OutputEvent,

Handles, ErrorDestination

} from 'vscode-debugadapter';

import {DebugProtocol} from 'vscode-debugprotocol';

import {

NodeV8Protocol, NodeV8Event, NodeV8Response,

V8SetBreakpointArgs, V8SetExceptionBreakArgs,

V8BacktraceResponse, V8ScopeResponse, V8EvaluateResponse, V8FrameResponse,

V8EventBody,

V8Ref, V8Handle, V8Property, V8Object, V8Simple, V8Function, V8Frame, V8Scope, V8Script

} from './nodeV8Protocol';

import {ISourceMaps, SourceMaps, Bias} from './sourceMaps';

import {Terminal, TerminalError} from './terminal';

import * as PathUtils from './pathUtilities';

import * as CP from 'child_process';

import * as Net from 'net';

import * as Path from 'path';

import * as FS from 'fs';

import * as nls from 'vscode-nls';

const localize = nls.config(process.env.VSCODE_NLS_CONFIG)();

export interface VariableContainer {

Expand(session: NodeDebugSession): Promise<Variable[]>;

SetValue(session: NodeDebugSession, name: string, value: string): Promise<string>;

}

export class Expander implements VariableContainer {

public static SET_VALUE_ERROR = localize('setVariable.error', "Setting value not supported");

private _expanderFunction : () => Promise<Variable[]>;

public constructor(func: () => Promise<Variable[]>) {

this._expanderFunction = func;

}

public Expand(session: NodeDebugSession) : Promise<Variable[]> {

return this._expanderFunction();

}

public SetValue(session: NodeDebugSession, name: string, value: string) : Promise<string> {

return Promise.reject(new Error(Expander.SET_VALUE_ERROR));

}

}

export class ArrayContainer implements VariableContainer {

private _array: V8Object;

private _length: number;

private _chunkSize: number;

public constructor(array: V8Object, length: number, chunkSize: number) {

this._array = array;

this._length = length;

this._chunkSize = chunkSize;

}

public Expand(session: NodeDebugSession) : Promise<Variable[]> {

// first add named properties then add ranges

return session._createProperties(this._array, 'named').then(variables => {

for (let start = 0; start < this._length; start += this._chunkSize) {

const end = Math.min(start + this._chunkSize, this._length)-1;

const count = end-start+1;

variables.push(new Variable(`[${start}..${end}]`, ' ', session._variableHandles.create(new RangeContainer(this._array, start, count))));

}

return variables;

});

}

public SetValue(session: NodeDebugSession, name: string, value: string) : Promise<string> {

return session._setPropertyValue(this._array.handle, name, value);

}

}

export class RangeContainer implements VariableContainer {

private _array: V8Object;

private _start: number;

private _count: number;

public constructor(array, start: number, count: number) {

this._array = array;

this._start = start;

this._count = count;

}

public Expand(session: NodeDebugSession) : Promise<Variable[]> {

// experimental support for long arrays not relying on code injection

//return session._createLargeArrayElements(this._array, this._start, this._count);

return session._createProperties(this._array, 'range', this._start, this._count);

}

public SetValue(session: NodeDebugSession, name: string, value: string) : Promise<string> {

return session._setPropertyValue(this._array.handle, name, value);

}

}

export class PropertyContainer implements VariableContainer {

private _object: V8Object;

private _this: V8Object;

public constructor(obj: V8Object, ths?: V8Object) {

this._object = obj;

this._this = ths;

}

public Expand(session: NodeDebugSession) : Promise<Variable[]> {

return session._createProperties(this._object, 'all').then(variables => {

if (this._this) {

return session._createVariable('this', this._this).then(variable => {

variables.push(variable);

return variables;

});

} else {

return variables;

}

});

}

public SetValue(session: NodeDebugSession, name: string, value: string) : Promise<string> {

return session._setPropertyValue(this._object.handle, name, value);

}

}

export class ScopeContainer implements VariableContainer {

private _frame: number;

private _scope: number;

private _object: V8Object;

private _this: V8Object;

public constructor(scope: V8Scope, obj: V8Object, ths?: V8Object) {

this._frame = scope.frameIndex;

this._scope = scope.index;

this._object = obj;

this._this = ths;

}

public Expand(session: NodeDebugSession) : Promise<Variable[]> {

return session._createProperties(this._object, 'all').then(variables => {

if (this._this) {

return session._createVariable('this', this._this).then(variable => {

variables.push(variable);

return variables;

});

} else {

return variables;

}

});

}

public SetValue(session: NodeDebugSession, name: string, value: string) : Promise<string> {

return session._setVariableValue(this._frame, this._scope, name, value);

}

}

class Script {

contents: string;

constructor(script: V8Script) {

this.contents = script.source;

}

}

class InternalSourceBreakpoint {

line: number;

orgLine: number;

column: number;

orgColumn: number;

condition: string;

constructor(line: number, column: number = 0, condition?: string) {

this.line = this.orgLine = line;

this.column = this.orgColumn = column;

this.condition = condition;

}

}

/**

* A SourceSource represents the source contents of an internal module or of a source map with inlined contents.

*/

class SourceSource {

scriptId: number; // if 0 then source contains the file contents of a source map, otherwise a scriptID.

source: string;

constructor(sid: number, content?: string) {

this.scriptId = sid;

this.source = content;

}

}

/**

* Arguments shared between Launch and Attach requests.

*/

interface CommonArguments {

/** comma separated list of trace selectors. Supported:

* 'all': all

* 'la': launch/attach

* 'ls': load scripts

* 'bp': breakpoints

* 'sm': source maps

* 'va': data structure access

* 'ss': smart steps

* 'rc': ref caching

* */

trace?: string;

/** The debug port to attach to. */

port: number;

/** The TCP/IP address of the port (remote addresses only supported for node >= 5.0). */

address?: string;

/** Retry for this number of milliseconds to connect to the node runtime. */

timeout?: number;

/** Automatically stop target after launch. If not specified, target does not stop. */

stopOnEntry?: boolean;

/** Configure source maps. By default source maps are disabled. */

sourceMaps?: boolean;

/** Where to look for the generated code. Only used if sourceMaps is true. */

outDir?: string;

/** Try to automatically step over uninteresting source. */

smartStep?: boolean;

/** Step back supported. */

stepBack?: boolean;

}

/**

* This interface should always match the schema found in the node-debug extension manifest.

*/

interface LaunchRequestArguments extends DebugProtocol.LaunchRequestArguments, CommonArguments {

/** An absolute path to the program to debug. */

program: string;

/** Optional arguments passed to the debuggee. */

args?: string[];

/** Launch the debuggee in this working directory (specified as an absolute path). If omitted the debuggee is lauched in its own directory. */

cwd?: string;

/** Absolute path to the runtime executable to be used. Default is the runtime executable on the PATH. */

runtimeExecutable?: string;

/** Optional arguments passed to the runtime executable. */

runtimeArgs?: string[];

/** Optional environment variables to pass to the debuggee. The string valued properties of the 'environmentVariables' are used as key/value pairs. */

env?: { [key: string]: string; };

/** If true launch the target in an external console. */

externalConsole?: boolean;

}

/**

* This interface should always match the schema found in the node-debug extension manifest.

*/

interface AttachRequestArguments extends DebugProtocol.AttachRequestArguments, CommonArguments {

/** Request frontend to restart session on termination. */

restart?: boolean;

/** Node's root directory. */

remoteRoot?: string;

/** VS Code's root directory. */

localRoot?: string;

/** Send a USR1 signal to this process. */

processId?: string;

}

export class NodeDebugSession extends DebugSession {

private static MAX_STRING_LENGTH = 10000; // max string size to return in 'evaluate' request

private static NODE_TERMINATION_POLL_INTERVAL = 3000;

private static ATTACH_TIMEOUT = 10000;

private static NODE = 'node';

private static DUMMY_THREAD_ID = 1;

private static DUMMY_THREAD_NAME = 'Node';

private static FIRST_LINE_OFFSET = 62;

private static PROTO = '__proto__';

private static DEBUG_INJECTION = 'debugInjection.js';

private static NODE_SHEBANG_MATCHER = new RegExp('#! */usr/bin/env +node');

private static LONG_STRING_MATCHER = /\.\.\. \(length: [0-9]+\)$/;

// tracing

private _trace: string[];

private _traceAll = false;

// options

private _tryToInjectExtension = true;

private _chunkSize = 100; // chunk size for large data structures

private _smartStep = false; // try to automatically step over uninteresting source

// session state

private _adapterID: string;

private _node: NodeV8Protocol;

private _nodeProcessId: number = -1; // pid of the node runtime

private _functionBreakpoints = new Array<number>(); // node function breakpoint ids

private _scripts = new Map<number, Script>();

// session configurations

private _noDebug = false;

private _attachMode = false;

private _localRoot: string;

private _remoteRoot: string;

private _restartMode = false;

private _sourceMaps: ISourceMaps;

private _externalConsole: boolean;

private _stopOnEntry: boolean;

private _stepBack = false;

// state valid between stop events

public _variableHandles = new Handles<VariableContainer>();

private _frameHandles = new Handles<V8Frame>();

private _sourceHandles = new Handles<SourceSource>();

private _refCache = new Map<number, V8Handle>();

// internal state

private _isTerminated: boolean;

private _inShutdown: boolean;

private _terminalProcess: CP.ChildProcess; // the terminal process or undefined

private _pollForNodeProcess = false;

private _exception: V8Object;

private _lastStoppedEvent: DebugProtocol.StoppedEvent;

private _stoppedReason: string;

private _nodeInjectionAvailable = false;

private _needContinue: boolean;

private _needBreakpointEvent: boolean;

private _gotEntryEvent: boolean;

private _entryPath: string;

private _entryLine: number; // entry line in *.js file (not in the source file)

private _entryColumn: number; // entry column in *.js file (not in the source file)

private _smartStepCount = 0;

public constructor() {

super();

// this debugger uses zero-based lines and columns which is the default

// so the following two calls are not really necessary.

this.setDebuggerLinesStartAt1(false);

this.setDebuggerColumnsStartAt1(false);

this._node = new NodeV8Protocol(response => {

// if request successful, cache alls refs

if (response.success && response.refs) {

const oldSize = this._refCache.size;

for (let r of response.refs) {

this._cache(r.handle, r);

}

if (this._refCache.size !== oldSize) {

this.log('rc', `NodeV8Protocol hook: ref cache size: ${this._refCache.size}`);

}

}

});

this._node.on('break', (event: NodeV8Event) => {

this._stopped('break');

this._handleNodeBreakEvent(event.body);

});

this._node.on('exception', (event: NodeV8Event) => {

this._stopped('exception');

this._handleNodeBreakEvent(event.body);

});

/*

this._node.on('beforeCompile', (event: NodeV8Event) => {

this.outLine(`beforeCompile ${event.body.name}`);

});

*/

this._node.on('afterCompile', (event: NodeV8Event) => {

this._handleNodeAfterCompileEvent(event.body);

});

this._node.on('close', (event: NodeV8Event) => {

this._terminated('node v8protocol close');

});

this._node.on('error', (event: NodeV8Event) => {

this._terminated('node v8protocol error');

});

/*

this._node.on('diagnostic', (event: NodeV8Event) => {

this.outLine(`diagnostic event ${event.body.reason}`);

});

*/

}

/**

* Experimental support for SystemJS module loader (https://github.com/systemjs/systemjs)

*

* Tries to figure out whether JavaScript code has been dynamically generated

* and whether it contains a source map reference.

* If this is the case try to reload breakpoints.

*/

private _handleNodeAfterCompileEvent(eventBody: V8EventBody) {

if (this._sourceMaps) { // this only applies if source maps are enabled

let path = eventBody.script.name;

if (path && Path.extname(path) === '.js!transpiled' && path.indexOf('file://') === 0) {

path = path.substring('file://'.length);

if (!FS.existsSync(path)) { // path does not exist locally.

const script_id = eventBody.script.id;

this._loadScript(script_id).then(script => {

const sources = this._sourceMaps.MapPathToSource(path, script.contents);

if (sources && sources.length >= 0) {

this.outLine(`afterCompile: ${path} maps to ${sources[0]}`);

// trigger resending breakpoints

this.sendEvent(new InitializedEvent());

}

}).catch(err => {

// ignore

});

}

}

}

}

/**

* Analyse why node has stopped and sends StoppedEvent if necessary.

*/

private _handleNodeBreakEvent(eventBody: V8EventBody) : void {

/*

// workaround: load sourcemap for this location to populate cache

if (this._sourceMaps) {

let path = body.script.name;

if (path && PathUtils.isAbsolutePath(path)) {

path = this._remoteToLocal(path);

this._sourceMaps.MapToSource(path, null, 0, 0);

}

}

*/

let isEntry = false;

let reason: string;

let exception_text: string;

// is exception?

if (eventBody.exception) {

this._exception = eventBody.exception;

exception_text = eventBody.exception.text;

reason = localize({ key: 'reason.exception', comment: ['https://github.com/Microsoft/vscode/issues/4568'] }, "exception");

}

// is breakpoint?

if (!reason) {

const breakpoints = eventBody.breakpoints;

if (isArray(breakpoints) && breakpoints.length > 0) {

const id = breakpoints[0];

if (!this._gotEntryEvent && id === 1) { // 'stop on entry point' is implemented as a breakpoint with id 1

isEntry = true;

this.log('la', '_analyzeBreak: suppressed stop-on-entry event');

reason = localize({ key: 'reason.entry', comment: ['https://github.com/Microsoft/vscode/issues/4568'] }, "entry");

this._rememberEntryLocation(eventBody.script.name, eventBody.sourceLine, eventBody.sourceColumn);

} else {

reason = localize({ key: 'reason.breakpoint', comment: ['https://github.com/Microsoft/vscode/issues/4568'] }, "breakpoint");

}

}

}

// is debugger statement?

if (!reason) {

const sourceLine = eventBody.sourceLineText;

if (sourceLine && sourceLine.indexOf('debugger') >= 0) {

reason = localize({ key: 'reason.debugger_statement', comment: ['https://github.com/Microsoft/vscode/issues/4568'] }, "debugger statement");

}

}

// no reason yet: must be the result of a 'step'

if (!reason) {

// should we continue until we find a better place to stop?

if (this._smartStep && this._skipGenerated(eventBody)) {

this._node.command('continue', { stepaction: 'in' });

this._smartStepCount++;

return null;

}

reason = localize({ key: 'reason.step', comment: ['https://github.com/Microsoft/vscode/issues/4568'] }, "step");

}

this._lastStoppedEvent = new StoppedEvent(reason, NodeDebugSession.DUMMY_THREAD_ID, exception_text);

if (!isEntry) {

if (this._smartStepCount > 0) {

this.log('ss', `_handleNodeBreakEvent: ${this._smartStepCount} steps skipped`);

this._smartStepCount = 0;

}

this.sendEvent(this._lastStoppedEvent);

}

}

/**

* Returns true if a source location should be skipped.

*/

private _skipGenerated(event: V8EventBody) : boolean {

if (!this._sourceMaps) {

// proceed as normal

return false;

}

let line = event.sourceLine;

let column = this._adjustColumn(line, event.sourceColumn);

let remotePath = event.script.name;

if (remotePath && PathUtils.isAbsolutePath(remotePath)) {

// if launch.json defines localRoot and remoteRoot try to convert remote path back to a local path

let localPath = this._remoteToLocal(remotePath);

// try to map

let mapresult = this._sourceMaps.MapToSource(localPath, null, line, column, Bias.LEAST_UPPER_BOUND);

if (!mapresult) { // try using the other bias option

mapresult = this._sourceMaps.MapToSource(localPath, null, line, column, Bias.GREATEST_LOWER_BOUND);

}

if (mapresult) {

return false;

}

}

// skip everything

return true;

}

/**

* clear everything that is no longer valid after a new stopped event.

*/

private _stopped(reason: string): void {

this._stoppedReason = reason;

this.log('la', `_stopped: got ${reason} event from node`);

this._exception = undefined;

this._variableHandles.reset();

this._frameHandles.reset();

this._refCache = new Map<number, V8Object>();

this.log('rc', `_stopped: new ref cache`);

}

/**

* The debug session has terminated.

*/

private _terminated(reason: string): void {

this.log('la', `_terminated: ${reason}`);

if (this._terminalProcess) {

// if the debug adapter owns a terminal,

// we delay the TerminatedEvent so that the user can see the result of the process in the terminal.

return;

}

if (!this._isTerminated) {

this._isTerminated = true;

if (this._restartMode && !this._inShutdown) {

this.sendEvent(new TerminatedEvent(true));

} else {

this.sendEvent(new TerminatedEvent());

}

}

}

//---- initialize request -------------------------------------------------------------------------------------------------

protected initializeRequest(response: DebugProtocol.InitializeResponse, args: DebugProtocol.InitializeRequestArguments): void {

this.log('la', `initializeRequest: adapterID: ${args.adapterID}`);

this._adapterID = args.adapterID;

//---- Send back feature and their options

// This debug adapter supports the configurationDoneRequest.

response.body.supportsConfigurationDoneRequest = true;

// This debug adapter supports function breakpoints.

response.body.supportsFunctionBreakpoints = true;

// This debug adapter supports conditional breakpoints.

response.body.supportsConditionalBreakpoints = true;

// This debug adapter does not support a side effect free evaluate request for data hovers.

response.body.supportsEvaluateForHovers = false;

// This debug adapter supports two exception breakpoint filters

response.body.exceptionBreakpointFilters = [

{

label: localize('exceptions.all', "All Exceptions"),

filter: 'all',

default: false

},

{

label: localize('exceptions.uncaught', "Uncaught Exceptions"),

filter: 'uncaught',

default: true

}

];

response.body.supportsSetVariable = true;

this.sendResponse(response);

}

//---- launch request -----------------------------------------------------------------------------------------------------

protected launchRequest(response: DebugProtocol.LaunchResponse, args: LaunchRequestArguments): void {

if (this._processCommonArgs(response, args)) {

return;

}

this._noDebug = (typeof args.noDebug === 'boolean') && args.noDebug;

this._externalConsole = (typeof args.externalConsole === 'boolean') && args.externalConsole;

const port = args.port || random(3000, 50000);

const address = args.address;

const timeout = args.timeout;

let runtimeExecutable = args.runtimeExecutable;

if (runtimeExecutable) {

if (!Path.isAbsolute(runtimeExecutable)) {

this.sendRelativePathErrorResponse(response, 'runtimeExecutable', runtimeExecutable);

return;

}

if (!FS.existsSync(runtimeExecutable)) {

this.sendNotExistErrorResponse(response, 'runtimeExecutable', runtimeExecutable);

return;

}

} else {

if (!Terminal.isOnPath(NodeDebugSession.NODE)) {

this.sendErrorResponse(response, 2001, localize('VSND2001', "Cannot find runtime '{0}' on PATH.", '{_runtime}'), { _runtime: NodeDebugSession.NODE });

return;

}

runtimeExecutable = NodeDebugSession.NODE; // use node from PATH

}

const runtimeArgs = args.runtimeArgs || [];

const programArgs = args.args || [];

// special code for 'extensionHost' debugging

if (this._adapterID === 'extensionHost') {

// we always launch in 'debug-brk' mode, but we only show the break event if 'stopOnEntry' attribute is true.

let launchArgs = [ runtimeExecutable ];

if (!this._noDebug) {

launchArgs.push(`--debugBrkPluginHost=${port}`);

}

launchArgs = launchArgs.concat(runtimeArgs, programArgs);

this._sendLaunchCommandToConsole(launchArgs);

const cmd = CP.spawn(runtimeExecutable, launchArgs.slice(1));

cmd.on('error', (err) => {

this._terminated(`failed to launch extensionHost (${err})`);

});

this._captureOutput(cmd);

// we are done!

this.sendResponse(response);

return;

}

let programPath = args.program;

if (programPath) {

if (!Path.isAbsolute(programPath)) {

this.sendRelativePathErrorResponse(response, 'program', programPath);

return;

}

if (!FS.existsSync(programPath)) {

this.sendNotExistErrorResponse(response, 'program', programPath);

return;

}

programPath = Path.normalize(programPath);

if (PathUtils.normalizeDriveLetter(programPath) !== PathUtils.realPath(programPath)) {

this.outLine(localize('program.path.case.mismatch.warning', "Program path uses differently cased character as file on disk; this might result in breakpoints not being hit."));

}

} else {

this.sendAttributeMissingErrorResponse(response, 'program');

return;

}

if (NodeDebugSession.isJavaScript(programPath)) {

if (this._sourceMaps) {

// if programPath is a JavaScript file and sourceMaps are enabled, we don't know whether

// programPath is the generated file or whether it is the source (and we need source mapping).

// Typically this happens if a tool like 'babel' or 'uglify' is used (because they both transpile js to js).

// We use the source maps to find a 'source' file for the given js file.

const generatedPath = this._sourceMaps.MapPathFromSource(programPath);

if (generatedPath && generatedPath !== programPath) {

// programPath must be source because there seems to be a generated file for it

this.log('sm', `launchRequest: program '${programPath}' seems to be the source; launch the generated file '${generatedPath}' instead`);

programPath = generatedPath;

} else {

this.log('sm', `launchRequest: program '${programPath}' seems to be the generated file`);

}

}

} else {

// node cannot execute the program directly

if (!this._sourceMaps) {

this.sendErrorResponse(response, 2002, localize('VSND2002', "Cannot launch program '{0}'; configuring source maps might help.", '{path}'), { path: programPath });

return;

}

const generatedPath = this._sourceMaps.MapPathFromSource(programPath);

if (!generatedPath) { // cannot find generated file

this.sendErrorResponse(response, 2003, localize('VSND2003', "Cannot launch program '{0}'; setting the '{1}' attribute might help.", '{path}', 'outDir'), { path: programPath });

return;

}

this.log('sm', `launchRequest: program '${programPath}' seems to be the source; launch the generated file '${generatedPath}' instead`);

programPath = generatedPath;

}

let program: string;

let workingDirectory = args.cwd;

if (workingDirectory) {

if (!Path.isAbsolute(workingDirectory)) {

this.sendRelativePathErrorResponse(response, 'cwd', workingDirectory);

return;

}

if (!FS.existsSync(workingDirectory)) {

this.sendNotExistErrorResponse(response, 'cwd', workingDirectory);

return;

}

// if working dir is given and if the executable is within that folder, we make the executable path relative to the working dir

program = Path.relative(workingDirectory, programPath);

}

else { // should not happen

// if no working dir given, we use the direct folder of the executable

workingDirectory = Path.dirname(programPath);

program = Path.basename(programPath);

}

// we always break on entry (but if user did not request this, we will not stop in the UI).

let launchArgs = [ runtimeExecutable ];

if (! this._noDebug) {

launchArgs.push(`--debug-brk=${port}`);

}

launchArgs = launchArgs.concat(runtimeArgs, [ program ], programArgs);

if (this._externalConsole) {

Terminal.launchInTerminal(workingDirectory, launchArgs, args.env).then(term => {

if (term) {

// if we got a terminal process, we will track it

this._terminalProcess = term;

term.on('exit', () => {

this._terminalProcess = null;

this._terminated('terminal exited');

});

}

// since node starts in a terminal, we cannot track it with an 'exit' handler

// plan for polling after we have gotten the process pid.

this._pollForNodeProcess = true;

if (this._noDebug) {

this.sendResponse(response);

} else {

this._attach(response, port, address, timeout);

}

}).catch((error: TerminalError) => {

this.sendErrorResponseWithInfoLink(response, 2011, localize('VSND2011', "Cannot launch debug target in terminal ({0}).", '{_error}'), { _error: error.message }, error.linkId );

this._terminated('terminal error: ' + error.message);

});

} else {

this._sendLaunchCommandToConsole(launchArgs);

// merge environment variables into a copy of the process.env

const env = extendObject(extendObject( { }, process.env), args.env);

const options = {

cwd: workingDirectory,

env: env

};

const nodeProcess = CP.spawn(runtimeExecutable, launchArgs.slice(1), options);

nodeProcess.on('error', (error) => {

this.sendErrorResponse(response, 2017, localize('VSND2017', "Cannot launch debug target ({0}).", '{_error}'), { _error: error.message }, ErrorDestination.Telemetry | ErrorDestination.User );

this._terminated(`failed to launch target (${error})`);

});

nodeProcess.on('exit', () => {

this._terminated('target exited');

});

nodeProcess.on('close', (code) => {

this._terminated('target closed');

});

this._nodeProcessId = nodeProcess.pid;

this._captureOutput(nodeProcess);

if (this._noDebug) {

this.sendResponse(response);

} else {

this._attach(response, port, address, timeout);

}

}

}

private _sendLaunchCommandToConsole(args: string[]) {

// print the command to launch the target to the debug console

let cli = '';

for (let a of args) {

if (a.indexOf(' ') >= 0) {

cli += '\'' + a + '\'';

} else {

cli += a;

}

cli += ' ';

}

this.outLine(cli);

}

private _captureOutput(process: CP.ChildProcess) {

process.stdout.on('data', (data: string) => {

this.sendEvent(new OutputEvent(data.toString(), 'stdout'));

});

process.stderr.on('data', (data: string) => {

this.sendEvent(new OutputEvent(data.toString(), 'stderr'));

});

}

/**

* returns true on error.

*/

private _processCommonArgs(response: DebugProtocol.Response, args: CommonArguments): boolean {

if (typeof args.trace === 'string') {

this._trace = args.trace.split(',');

this._traceAll = this._trace.indexOf('all') >= 0;

}

this._stepBack = (typeof args.stepBack === 'boolean') && args.stepBack;

this._smartStep = (typeof args.smartStep === 'boolean') && args.smartStep;

this._stopOnEntry = (typeof args.stopOnEntry === 'boolean') && args.stopOnEntry;

if (!this._sourceMaps) {

if (typeof args.sourceMaps === 'boolean' && args.sourceMaps) {

const generatedCodeDirectory = args.outDir;

if (generatedCodeDirectory) {

if (!Path.isAbsolute(generatedCodeDirectory)) {

this.sendRelativePathErrorResponse(response, 'outDir', generatedCodeDirectory);

return true;

}

if (!FS.existsSync(generatedCodeDirectory)) {

this.sendNotExistErrorResponse(response, 'outDir', generatedCodeDirectory);

return true;

}

}

this._sourceMaps = new SourceMaps(this, generatedCodeDirectory);

}

}

return false;

}

//---- attach request -----------------------------------------------------------------------------------------------------

protected attachRequest(response: DebugProtocol.AttachResponse, args: AttachRequestArguments): void {

if (this._processCommonArgs(response, args)) {

return;

}

if (this._adapterID === 'extensionHost') {

// in EH mode 'attach' means 'launch' mode

this._attachMode = false;

} else {

this._attachMode = true;

}

if (typeof args.restart === 'boolean') {

this._restartMode = args.restart;

}

if (args.localRoot) {

const localRoot = args.localRoot;

if (!Path.isAbsolute(localRoot)) {

this.sendRelativePathErrorResponse(response, 'localRoot', localRoot);

return;

}

if (!FS.existsSync(localRoot)) {

this.sendNotExistErrorResponse(response, 'localRoot', localRoot);

return;

}

this._localRoot = localRoot;

}

this._remoteRoot = args.remoteRoot;

// if a processId is specified, try to bring the process into debug mode.

if (typeof args.processId === 'string') {

const pid_string = args.processId.trim();

if (/^([0-9]+)$/.test(pid_string)) {

const pid = Number(pid_string);

try {

if (process.platform === 'win32') {

// regular node has an undocumented API function for forcing another node process into debug mode.

// (<any>process)._debugProcess(pid);

// But since we are running on Electron's node, process._debugProcess doesn't work (for unknown reasons).

// So we use a regular node instead:

const command = `node -e process._debugProcess(${pid})`;

CP.execSync(command);

} else {

process.kill(pid, 'SIGUSR1');

}

} catch (e) {

this.sendErrorResponse(response, 2021, localize('VSND2021', "Attach to process: cannot enable debug mode for process '{0}' ({1}).", pid, e));

return;

}

} else {

this.sendErrorResponse(response, 2006, localize('VSND2006', "Attach to process: '{0}' doesn't look like a process id.", pid_string));

return;

}

}

this._attach(response, args.port, args.address, args.timeout);

}

/*

* shared code used in launchRequest and attachRequest

*/

private _attach(response: DebugProtocol.Response, port: number, address: string, timeout: number): void {

if (!port) {

port = 5858;

}

if (!address || address === 'localhost') {

address = '127.0.0.1';

}

if (!timeout) {

timeout = NodeDebugSession.ATTACH_TIMEOUT;

}

this.log('la', `_attach: address: ${address} port: ${port}`);

let connected = false;

const socket = new Net.Socket();

socket.connect(port, address);

socket.on('connect', err => {

this.log('la', '_attach: connected');

connected = true;

this._node.startDispatch(socket, socket);

this._initialize(response);

});

const endTime = new Date().getTime() + timeout;

socket.on('error', err => {

if (connected) {

// since we are connected this error is fatal

this._terminated('socket error');

} else {

// we are not yet connected so retry a few times

if (err.code === 'ECONNREFUSED' || err.code === 'ECONNRESET') {

const now = new Date().getTime();

if (now < endTime) {

setTimeout(() => {

this.log('la', '_attach: retry socket.connect');

socket.connect(port);

}, 200); // retry after 200 ms

} else {

this.sendErrorResponse(response, 2009, localize('VSND2009', "Cannot connect to runtime process (timeout after {0} ms).", '{_timeout}'), { _timeout: timeout });

}

} else {

this.sendErrorResponse(response, 2010, localize('VSND2010', "Cannot connect to runtime process (reason: {0}).", '{_error}'), { _error: err.message });

}

}

});

socket.on('end', err => {

this._terminated('socket end');

});

}

private _initialize(response: DebugProtocol.Response, retryCount: number = 0) : void {

this._node.command('evaluate', { expression: 'process.pid', global: true }, (resp: V8EvaluateResponse) => {