'use strict';

const internalUtil = require('internal/util');

const util = require('util');

const path = require('path');

const net = require('net');

const vm = require('vm');

const Module = require('module');

const repl = require('repl');

const inherits = util.inherits;

const assert = require('assert');

const spawn = require('child_process').spawn;

const Buffer = require('buffer').Buffer;

const errors = require('internal/errors');

exports.start = function(argv, stdin, stdout) {

argv || (argv = process.argv.slice(2));

if (argv.length < 1) {

console.error('Usage: node debug script.js');

console.error(' node debug <host>:<port>');

console.error(' node debug -p <pid>');

process.exit(1);

}

// Setup input/output streams

stdin = stdin || process.stdin;

stdout = stdout || process.stdout;

const args = [`--debug-brk=${exports.port}`].concat(argv);

const interface_ = new Interface(stdin, stdout, args);

stdin.resume();

process.on('uncaughtException', function(e) {

internalUtil.error('There was an internal error in Node\'s debugger. ' +

'Please report this bug.');

console.error(e.message);

console.error(e.stack);

if (interface_.child) interface_.child.kill();

process.exit(1);

});

};

exports.port = process.debugPort;

//

// Parser/Serializer for V8 debugger protocol

// https://github.com/v8/v8/wiki/Debugging-Protocol

//

// Usage:

// p = new Protocol();

//

// p.onResponse = function(res) {

// // do stuff with response from V8

// };

//

// socket.setEncoding('utf8');

// socket.on('data', function(s) {

// // Pass strings into the protocol

// p.execute(s);

// });

//

//

function Protocol() {

this._newRes();

}

exports.Protocol = Protocol;

Protocol.prototype._newRes = function(raw) {

this.res = { raw: raw || '', headers: {} };

this.state = 'headers';

this.reqSeq = 1;

this.execute('');

};

Protocol.prototype.execute = function(d) {

var res = this.res;

res.raw += d;

switch (this.state) {

case 'headers':

var endHeaderIndex = res.raw.indexOf('\r\n\r\n');

if (endHeaderIndex < 0) break;

var rawHeader = res.raw.slice(0, endHeaderIndex);

var endHeaderByteIndex = Buffer.byteLength(rawHeader, 'utf8');

var lines = rawHeader.split('\r\n');

for (var i = 0; i < lines.length; i++) {

var kv = lines[i].split(/: +/);

res.headers[kv[0]] = kv[1];

}

this.contentLength = +res.headers['Content-Length'];

this.bodyStartByteIndex = endHeaderByteIndex + 4;

this.state = 'body';

var len = Buffer.byteLength(res.raw, 'utf8');

if (len - this.bodyStartByteIndex < this.contentLength) {

break;

}

// falls through

case 'body':

var resRawByteLength = Buffer.byteLength(res.raw, 'utf8');

if (resRawByteLength - this.bodyStartByteIndex >= this.contentLength) {

var buf = Buffer.allocUnsafe(resRawByteLength);

buf.write(res.raw, 0, resRawByteLength, 'utf8');

res.body =

buf.slice(this.bodyStartByteIndex,

this.bodyStartByteIndex +

this.contentLength).toString('utf8');

// JSON parse body?

res.body = res.body.length ? JSON.parse(res.body) : {};

// Done!

this.onResponse(res);

this._newRes(buf.slice(this.bodyStartByteIndex +

this.contentLength).toString('utf8'));

}

break;

default:

throw new errors.Error('ERR_UNKNOWN_DEBUGGER_STATE');

}

};

Protocol.prototype.serialize = function(req) {

req.type = 'request';

req.seq = this.reqSeq++;

var json = JSON.stringify(req);

return 'Content-Length: ' + Buffer.byteLength(json, 'utf8') +

'\r\n\r\n' + json;

};

const NO_FRAME = -1;

function Client() {

net.Socket.call(this);

var protocol = this.protocol = new Protocol(this);

this._reqCallbacks = [];

var socket = this;

this.currentFrame = NO_FRAME;

this.currentSourceLine = -1;

this.handles = {};

this.scripts = {};

this.breakpoints = [];

// Note that 'Protocol' requires strings instead of Buffers.

socket.setEncoding('utf8');

socket.on('data', function(d) {

protocol.execute(d);

});

protocol.onResponse = (res) => this._onResponse(res);

}

inherits(Client, net.Socket);

exports.Client = Client;

Client.prototype._addHandle = function(desc) {

if (desc === null || typeof desc !== 'object' ||

typeof desc.handle !== 'number') {

return;

}

this.handles[desc.handle] = desc;

if (desc.type === 'script') {

this._addScript(desc);

}

};

const natives = process.binding('natives');

Client.prototype._addScript = function(desc) {

this.scripts[desc.id] = desc;

if (desc.name) {

desc.isNative = (desc.name.replace('.js', '') in natives) ||

desc.name === 'node.js';

}

};

Client.prototype._removeScript = function(desc) {

this.scripts[desc.id] = undefined;

};

Client.prototype._onResponse = function(res) {

var cb;

var index = -1;

this._reqCallbacks.some(function(fn, i) {

if (fn.request_seq === res.body.request_seq) {

cb = fn;

index = i;

return true;

}

});

var self = this;

var handled = false;

if (res.headers.Type === 'connect') {

// Request a list of scripts for our own storage.

self.reqScripts();

self.emit('ready');

handled = true;

} else if (res.body && res.body.event === 'break') {

this.emit('break', res.body);

handled = true;

} else if (res.body && res.body.event === 'exception') {

this.emit('exception', res.body);

handled = true;

} else if (res.body && res.body.event === 'afterCompile') {

this._addHandle(res.body.body.script);

handled = true;

} else if (res.body && res.body.event === 'scriptCollected') {

// ???

this._removeScript(res.body.body.script);

handled = true;

} else if (res.body && res.body.event === 'compileError') {

// This event is not used anywhere right now, perhaps somewhere in the

// future?

handled = true;

}

if (cb) {

this._reqCallbacks.splice(index, 1);

handled = true;

var err = res.success === false && (res.message || true) ||

res.body.success === false && (res.body.message || true);

cb(err, res.body && res.body.body || res.body, res);

}

if (!handled) this.emit('unhandledResponse', res.body);

};

Client.prototype.req = function(req, cb) {

this.write(this.protocol.serialize(req));

cb.request_seq = req.seq;

this._reqCallbacks.push(cb);

};

Client.prototype.reqVersion = function(cb) {

cb = cb || function() {};

this.req({ command: 'version' }, function(err, body, res) {

if (err) return cb(err);

cb(null, res.body.body.V8Version, res.body.running);

});

};

Client.prototype.reqLookup = function(refs, cb) {

var self = this;

// TODO: We have a cache of handle's we've already seen in this.handles

// This can be used if we're careful.

var req = {

command: 'lookup',

arguments: {

handles: refs

}

};

cb = cb || function() {};

this.req(req, function(err, res) {

if (err) return cb(err);

for (var ref in res) {

if (res[ref] !== null && typeof res[ref] === 'object') {

self._addHandle(res[ref]);

}

}

cb(null, res);

});

};

Client.prototype.reqScopes = function(cb) {

const self = this;

const req = {

command: 'scopes',

arguments: {}

};

cb = cb || function() {};

this.req(req, function(err, res) {

if (err) return cb(err);

var refs = res.scopes.map(function(scope) {

return scope.object.ref;

});

self.reqLookup(refs, function(err, res) {

if (err) return cb(err);

var globals = Object.keys(res).map(function(key) {

return res[key].properties.map(function(prop) {

return prop.name;

});

});

cb(null, globals.reverse());

});

});

};

// This is like reqEval, except it will look up the expression in each of the

// scopes associated with the current frame.

Client.prototype.reqEval = function(expression, cb) {

var self = this;

if (this.currentFrame === NO_FRAME) {

// Only need to eval in global scope.

this.reqFrameEval(expression, NO_FRAME, cb);

return;

}

cb = cb || function() {};

// Otherwise we need to get the current frame to see which scopes it has.

this.reqBacktrace(function(err, bt) {

if (err || !bt.frames) {

// ??

return cb(null, {});

}

var frame = bt.frames[self.currentFrame];

var evalFrames = frame.scopes.map(function(s) {

if (!s) return;

var x = bt.frames[s.index];

if (!x) return;

return x.index;

});

self._reqFramesEval(expression, evalFrames, cb);

});

};

// Finds the first scope in the array in which the expression evals.

Client.prototype._reqFramesEval = function(expression, evalFrames, cb) {

if (evalFrames.length === 0) {

// Just eval in global scope.

this.reqFrameEval(expression, NO_FRAME, cb);

return;

}

var self = this;

var i = evalFrames.shift();

cb = cb || function() {};

this.reqFrameEval(expression, i, function(err, res) {

if (!err) return cb(null, res);

self._reqFramesEval(expression, evalFrames, cb);

});

};

Client.prototype.reqFrameEval = function(expression, frame, cb) {

var self = this;

var req = {

command: 'evaluate',

arguments: { expression: expression }

};

if (frame === NO_FRAME) {

req.arguments.global = true;

} else {

req.arguments.frame = frame;

}

cb = cb || function() {};

this.req(req, function(err, res) {

if (!err) self._addHandle(res);

cb(err, res);

});

};

// reqBacktrace(cb)

// TODO: from, to, bottom

Client.prototype.reqBacktrace = function(cb) {

this.req({ command: 'backtrace', arguments: { inlineRefs: true } }, cb);

};

// reqSetExceptionBreak(type, cb)

// TODO: from, to, bottom

Client.prototype.reqSetExceptionBreak = function(type, cb) {

this.req({

command: 'setexceptionbreak',

arguments: { type: type, enabled: true }

}, cb);

};

// Returns an array of objects like this:

//

// { handle: 11,

// type: 'script',

// name: 'node.js',

// id: 14,

// lineOffset: 0,

// columnOffset: 0,

// lineCount: 562,

// sourceStart: '(function(process) {\n\n ',

// sourceLength: 15939,

// scriptType: 2,

// compilationType: 0,

// context: { ref: 10 },

// text: 'node.js (lines: 562)' }

//

Client.prototype.reqScripts = function(cb) {

var self = this;

cb = cb || function() {};

this.req({ command: 'scripts' }, function(err, res) {

if (err) return cb(err);

for (var i = 0; i < res.length; i++) {

self._addHandle(res[i]);

}

cb(null);

});

};

Client.prototype.reqContinue = function(cb) {

this.currentFrame = NO_FRAME;

this.req({ command: 'continue' }, cb);

};

Client.prototype.listbreakpoints = function(cb) {

this.req({ command: 'listbreakpoints' }, cb);

};

Client.prototype.setBreakpoint = function(req, cb) {

req = {

command: 'setbreakpoint',

arguments: req

};

this.req(req, cb);

};

Client.prototype.clearBreakpoint = function(req, cb) {

req = {

command: 'clearbreakpoint',

arguments: req

};

this.req(req, cb);

};

Client.prototype.reqSource = function(from, to, cb) {

var req = {

command: 'source',

fromLine: from,

toLine: to

};

this.req(req, cb);

};

// client.next(1, cb);

Client.prototype.step = function(action, count, cb) {

var req = {

command: 'continue',

arguments: { stepaction: action, stepcount: count }

};

this.currentFrame = NO_FRAME;

this.req(req, cb);

};

Client.prototype.mirrorObject = function(handle, depth, cb) {

var self = this;

var val;

if (handle.type === 'object') {

// The handle looks something like this:

// { handle: 8,

// type: 'object',

// className: 'Object',

// constructorFunction: { ref: 9 },

// protoObject: { ref: 4 },

// prototypeObject: { ref: 2 },

// properties: [ { name: 'hello', propertyType: 1, ref: 10 } ],

// text: '#<an Object>' }

// For now ignore the className and constructor and prototype.

// TJ's method of object inspection would probably be good for this:

// https://groups.google.com/forum/?pli=1#!topic/nodejs-dev/4gkWBOimiOg

var propertyRefs = handle.properties.map(function(p) {

return p.ref;

});

cb = cb || function() {};

this.reqLookup(propertyRefs, function(err, res) {

if (err) {

internalUtil.error('problem with reqLookup');

cb(null, handle);

return;

}

var mirror;

var waiting = 1;

if (handle.className === 'Array') {

mirror = [];

} else if (handle.className === 'Date') {

mirror = new Date(handle.value);

} else {

mirror = {};

}

var keyValues = [];

handle.properties.forEach(function(prop, i) {

var value = res[prop.ref];

var mirrorValue;

if (value) {

mirrorValue = value.value ? value.value : value.text;

} else {

mirrorValue = '[?]';

}

// Skip the 'length' property.

if (Array.isArray(mirror) && prop.name === 'length') {

return;

}

keyValues[i] = {

name: prop.name,

value: mirrorValue

};

if (value && value.handle && depth > 0) {

waiting++;

self.mirrorObject(value, depth - 1, function(err, result) {

if (!err) keyValues[i].value = result;

waitForOthers();

});

}

});

waitForOthers();

function waitForOthers() {

if (--waiting === 0) {

keyValues.forEach(function(kv) {

mirror[kv.name] = kv.value;

});

cb(null, mirror);

}

}

});

return;

} else if (handle.type === 'function') {

val = function() {};

} else if (handle.type === 'null') {

val = null;

} else if (handle.value !== undefined) {

val = handle.value;

} else if (handle.type === 'undefined') {

val = undefined;

} else {

val = handle;

}

process.nextTick(cb, null, val);

};

Client.prototype.fullTrace = function(cb) {

var self = this;

cb = cb || function() {};

this.reqBacktrace(function(err, trace) {

if (err) return cb(err);

if (trace.totalFrames <= 0) return cb(Error('No frames'));

var refs = [];

for (var i = 0; i < trace.frames.length; i++) {

var frame = trace.frames[i];

// looks like this:

// { type: 'frame',

// index: 0,

// receiver: { ref: 1 },

// func: { ref: 0 },

// script: { ref: 7 },

// constructCall: false,

// atReturn: false,

// debuggerFrame: false,

// arguments: [],

// locals: [],

// position: 160,

// line: 7,

// column: 2,

// sourceLineText: ' debugger;',

// scopes: [ { type: 1, index: 0 }, { type: 0, index: 1 } ],

// text: '#00 blah() /home/ryan/projects/node/test-debug.js l...' }

refs.push(frame.script.ref);

refs.push(frame.func.ref);

refs.push(frame.receiver.ref);

}

self.reqLookup(refs, function(err, res) {

if (err) return cb(err);

for (var i = 0; i < trace.frames.length; i++) {

var frame = trace.frames[i];

frame.script = res[frame.script.ref];

frame.func = res[frame.func.ref];

frame.receiver = res[frame.receiver.ref];

}

cb(null, trace);

});

});

};

const commands = [

[

'run (r)',

'cont (c)',

'next (n)',

'step (s)',

'out (o)',

'backtrace (bt)',

'setBreakpoint (sb)',

'clearBreakpoint (cb)'

],

[

'watch',

'unwatch',

'watchers',

'repl',

'exec',

'restart',

'kill',

'list',

'scripts',

'breakOnException',

'breakpoints',

'version'

]

];

var helpMessage = 'Commands: ' + commands.map(function(group) {

return group.join(', ');

}).join(',\n');

// Previous command received. Initialize to empty command.

var lastCommand = '\n';

function SourceUnderline(sourceText, position, repl) {

if (!sourceText) return '';

const head = sourceText.slice(0, position);

var tail = sourceText.slice(position);

// Colourize char if stdout supports colours

if (repl.useColors) {

tail = tail.replace(/(.+?)([^\w]|$)/, '\u001b[32m$1\u001b[39m$2');

}

// Return source line with coloured char at `position`

return [

head,

tail

].join('');

}

function SourceInfo(body) {

var result = body.exception ? 'exception in ' : 'break in ';

if (body.script) {

if (body.script.name) {

var name = body.script.name;

const dir = path.resolve() + '/';

// Change path to relative, if possible

if (name.indexOf(dir) === 0) {

name = name.slice(dir.length);

}

result += name;

} else {

result += '[unnamed]';

}

}

result += ':';

result += body.sourceLine + 1;

if (body.exception) result += '\n' + body.exception.text;

return result;

}

// This class is the repl-enabled debugger interface which is invoked on

// "node debug"

function Interface(stdin, stdout, args) {

var self = this;

this.stdin = stdin;

this.stdout = stdout;

this.args = args;

// Two eval modes are available: controlEval and debugEval

// But controlEval is used by default

var opts = {

prompt: 'debug> ',

input: this.stdin,

output: this.stdout,

eval: (code, ctx, file, cb) => this.controlEval(code, ctx, file, cb),

useGlobal: false,

ignoreUndefined: true

};

if (parseInt(process.env['NODE_NO_READLINE'], 10)) {

opts.terminal = false;

} else if (parseInt(process.env['NODE_FORCE_READLINE'], 10)) {

opts.terminal = true;

// Emulate Ctrl+C if we're emulating terminal

if (!this.stdout.isTTY) {

process.on('SIGINT', function() {

self.repl.rli.emit('SIGINT');

});

}

}

if (parseInt(process.env['NODE_DISABLE_COLORS'], 10)) {

opts.useColors = false;

}

this.repl = repl.start(opts);

// Do not print useless warning

repl._builtinLibs.splice(repl._builtinLibs.indexOf('repl'), 1);

// Kill child process when main process dies

this.repl.on('exit', function() {

process.exit(0);

});

// Handle all possible exits

process.on('exit', () => this.killChild());

process.once('SIGTERM', process.exit.bind(process, 0));

process.once('SIGHUP', process.exit.bind(process, 0));

var proto = Interface.prototype;

const ignored = [

'pause',

'resume',

'exitRepl',

'handleBreak',

'requireConnection',

'killChild',

'trySpawn',

'controlEval',

'debugEval',

'print',

'childPrint',

'clearline'

];

const shortcut = {

'run': 'r',

'cont': 'c',

'next': 'n',

'step': 's',

'out': 'o',

'backtrace': 'bt',

'setBreakpoint': 'sb',

'clearBreakpoint': 'cb',

'pause_': 'pause'

};

function defineProperty(key, protoKey) {

// Check arity

var fn = proto[protoKey].bind(self);

if (proto[protoKey].length === 0) {

Object.defineProperty(self.repl.context, key, {

get: fn,

enumerable: true,

configurable: false

});

} else {

self.repl.context[key] = fn;

}

}

// Copy all prototype methods in repl context

// Setup them as getters if possible

for (var i in proto) {

if (Object.prototype.hasOwnProperty.call(proto, i) &&

ignored.indexOf(i) === -1) {

defineProperty(i, i);

if (shortcut[i]) defineProperty(shortcut[i], i);

}

}

this.killed = false;

this.waiting = null;

this.paused = 0;

this.context = this.repl.context;

this.history = {

debug: [],

control: []

};

this.breakpoints = [];

this._watchers = [];

// Run script automatically

this.pause();

setImmediate(() => { this.run(() => this.resume()); });

}

// Stream control

Interface.prototype.pause = function() {

if (this.killed || this.paused++ > 0) return this;

this.repl.rli.pause();

this.stdin.pause();

return this;

};

Interface.prototype.resume = function(silent) {

if (this.killed || this.paused === 0 || --this.paused !== 0) return this;

this.repl.rli.resume();

if (silent !== true) {

this.repl.displayPrompt();

}

this.stdin.resume();

if (this.waiting) {

this.waiting();

this.waiting = null;

}

return this;

};

// Clear current line

Interface.prototype.clearline = function() {

if (this.stdout.isTTY) {

this.stdout.cursorTo(0);

this.stdout.clearLine(1);

} else {

this.stdout.write('\b');

}

};

// Print text to output stream

Interface.prototype.print = function(text, oneline) {

if (this.killed) return;

this.clearline();

this.stdout.write(typeof text === 'string' ? text : util.inspect(text));

if (oneline !== true) {

this.stdout.write('\n');

}

};

// Format and print text from child process

Interface.prototype.childPrint = function(text) {

this.print(text.toString().split(/\r\n|\r|\n/g).filter(function(chunk) {

return chunk;

}).map(function(chunk) {

return '< ' + chunk;

}).join('\n'));

this.repl.displayPrompt(true);

};

// Errors formatting

Interface.prototype.error = function(text) {

this.print(text);

this.resume();

};

// Debugger's `break` event handler

Interface.prototype.handleBreak = function(r) {

var self = this;

this.pause();

// Save execution context's data

this.client.currentSourceLine = r.sourceLine;

this.client.currentSourceLineText = r.sourceLineText;

this.client.currentSourceColumn = r.sourceColumn;

this.client.currentFrame = 0;

this.client.currentScript = r.script && r.script.name;

// Print break data

this.print(SourceInfo(r));

// Show watchers' values

this.watchers(true, function(err) {

if (err) return self.error(err);

// And list source

self.list(2);

self.resume(true);

});

};

// Internal method for checking connection state

Interface.prototype.requireConnection = function() {

if (!this.client) {

this.error('App isn\'t running... Try `run` instead');

return false;

}

return true;

};

// Evals

// Used for debugger's commands evaluation and execution

Interface.prototype.controlEval = function(code, context, filename, callback) {

try {

// Repeat last command if empty line are going to be evaluated

if (code === '\n') {

code = lastCommand;

} else {

lastCommand = code;

}

// exec process.title => exec("process.title");

var match = code.match(/^\s*exec\s+([^\n]*)/);

if (match) {

code = 'exec(' + JSON.stringify(match[1]) + ')';

}

var result = vm.runInContext(code, context, filename);

// Repl should not ask for next command

// if current one was asynchronous.

if (this.paused === 0) return callback(null, result);

// Add a callback for asynchronous command

// (it will be automatically invoked by .resume() method

this.waiting = function() {

callback(null, result);

};

} catch (e) {

callback(e);

}

};

// Used for debugger's remote evaluation (`repl`) commands

Interface.prototype.debugEval = function(code, context, filename, callback) {

if (!this.requireConnection()) return;

const self = this;

const client = this.client;

// Repl asked for scope variables

if (code === '.scope') {

client.reqScopes(callback);

return;

}

var frame = client.currentFrame === NO_FRAME ? frame : undefined;

self.pause();