It took me some time and a couple of different approaches, but I managed to work up something I think solves your problem and allows to develop tests in a rather nice way.

Because it does not directly answer the question of how to re-use a browser session in Selenium (using their JavaScript API), I will first present my proposed solution and then briefly discuss the other approaches I tried. It may give someone else an idea and help them to solve this problem in a nicer/better way. Who knows. At least my attempts will be documented.

Proposed solution (tested and works)

Because I did not manage to actually reuse a browser session (see below), I figured I could try something else. The approach will be the following.

Idea

1. Have a main loop in one file (say init.js) and tests in a separate file (test.js).
2. The main loop opens a browser instance and keeps it open. It also exposes some sort of CLI that allows one to run tests (from test.js), inspect errors as they occur and to close the browser instance and stop the main loop.
3. The test in test.js exports a test function that is being executed by the main loop. It is passed a driver instance to work with. Any errors that occur here are being caught by the main loop.

Because the browser instance is opened only once, we have to do the manual process of authenticating with WhatsApp (scanning a QR code) only once. After that, running a test will reload web.whatsapp.com, but it will have remembered that we authenticated and thus immediately be able to run whatever tests we define in test.js.

In order to keep the main loop alive, it is vital that we catch each and every error that might occur in our tests. I unfortunately had to resort to uncaughtException for that.

Implementation

This is the implementation of the above idea I came up with. It is possible to make this much fancier if you would want to do so. I went for simplicity here (hope I managed).

init.js
This is the main loop from the above idea.

var webdriver = require('selenium-webdriver'),
    by = webdriver.By,
    until = webdriver.until,
    driver = null,
    prompt = '> ',
    testPath = 'test.js',
    lastError = null;

function initDriver() {
    return new Promise((resolve, reject) => {
        // already opened a browser? done
        if (driver !== null) {
            resolve();
            return;
        }
        // open a new browser, let user scan QR code
        driver = new webdriver.Builder().forBrowser('chrome').build();
        driver.get('https://web.whatsapp.com');
        process.stdout.write("Please scan the QR code within 30 seconds...\n");
        driver.wait(until.elementLocated(by.className('chat')), 30000)
            .then(() => resolve())
            .catch((timeout) => {
                process.stdout.write("\b\bTimed out waiting for code to" +
                    " be scanned.\n");
                driver.quit();
                reject();
            });
    });
}

function recordError(err) {
    process.stderr.write(err.name + ': ' + err.message + "\n");
    lastError = err;
    // let user know that test failed
    process.stdout.write("Test failed!\n");
    // indicate we are ready to read the next command
    process.stdout.write(prompt);
}

process.stdout.write(prompt);
process.stdin.setEncoding('utf8');
process.stdin.on('readable', () => {
    var chunk = process.stdin.read();
    if (chunk === null) {
        // happens on initialization, ignore
        return;
    }
    // do various different things for different commands
    var line = chunk.trim(),
        cmds = line.split(/\s+/);
    switch (cmds[0]) {
        case 'error':
            // print last error, when applicable
            if (lastError !== null) {
                console.log(lastError);
            }
            // indicate we are ready to read the next command
            process.stdout.write(prompt);
            break;
        case 'run':
            // open a browser if we didn't yet, execute tests
            initDriver().then(() => {
                // carefully load test code, report SyntaxError when applicable
                var file = (cmds.length === 1 ? testPath : cmds[1] + '.js');
                try {
                    var test = require('./' + file);
                } catch (err) {
                    recordError(err);
                    return;
                } finally {
                    // force node to read the test code again when we
                    // require it in the future
                    delete require.cache[__dirname + '/' + file];
                }
                // carefully execute tests, report errors when applicable
                test.execute(driver, by, until)
                    .then(() => {
                        // indicate we are ready to read the next command
                        process.stdout.write(prompt);
                    })
                    .catch(recordError);
            }).catch(() => process.stdin.destroy());
            break;
        case 'quit':
            // close browser if it was opened and stop this process
            if (driver !== null) {
                driver.quit();
            }
            process.stdin.destroy();
            return;
    }
});

// some errors somehow still escape all catches we have...
process.on('uncaughtException', recordError);

test.js
This is the test from the above idea. I wrote some things just to test the main loop and some WebDriver functionality. Pretty much anything is possible here. I have used promises to make test execution work nicely with the main loop.

var driver, by, until,
    timeout = 5000;

function waitAndClickElement(selector, index = 0) {
    driver.wait(until.elementLocated(by.css(selector)), timeout)
        .then(() => {
            driver.findElements(by.css(selector)).then((els) => {
                var element = els[index];
                driver.wait(until.elementIsVisible(element), timeout);
                element.click();
            });
        });
}

exports.execute = function(d, b, u) {
    // make globally accessible for ease of use
    driver = d;
    by = b;
    until = u;
    // actual test as a promise
    return new Promise((resolve, reject) => {
        // open site
        driver.get('https://web.whatsapp.com');
        // make sure it loads fine
        driver.wait(until.elementLocated(by.className('chat')), timeout);
        driver.wait(until.elementIsVisible(
            driver.findElement(by.className('chat'))), timeout);
        // open menu
        waitAndClickElement('.icon.icon-menu');
        // click profile link
        waitAndClickElement('.menu-shortcut', 1);
        // give profile time to animate
        // this prevents an error from occurring when we try to click the close
        // button while it is still being animated (workaround/hack!)
        driver.sleep(500);
        // close profile
        waitAndClickElement('.btn-close-drawer');
        driver.sleep(500); // same for hiding profile
        // click some chat
        waitAndClickElement('.chat', 3);
        // let main script know we are done successfully
        // we do so after all other webdriver promise have resolved by creating
        // another webdriver promise and hooking into its resolve
        driver.wait(until.elementLocated(by.className('chat')), timeout)
            .then(() => resolve());
    });
};

Example output

Here is some example output. The first invocation of run test will open up an instance of Chrome. Other invocations will use that same instance. When an error occurs, it can be inspected as shown. Executing quit will close the browser instance and quit the main loop.

$ node init.js
> run test
> run test
WebDriverError: unknown error: Element <div class="chat">...</div> is not clickable at point (163, 432). Other element would receive the click: <div dir="auto" contenteditable="false" class="input input-text">...</div>
  (Session info: chrome=57.0.2987.133)
  (Driver info: chromedriver=2.29.461571 (8a88bbe0775e2a23afda0ceaf2ef7ee74e822cc5),platform=Linux 4.9.0-2-amd64 x86_64)
Test failed!
> error
<prints complete stacktrace>
> run test
> quit

You can run tests in other files by simply calling them. Say you have a file test-foo.js, then execute run test-foo in the above prompt to run it. All tests will share the same Chrome instance.

Failed attempt #1: saving and restoring storage

When inspecting the page using my development tools, I noticed that it appears to use the localStorage. It is possible to export this as JSON and write it to a file. On a next invocation, this file can be read, parsed and written to the new browser instance storage before reloading the page.

Unfortunately, WhatsApp still required me to scan the QR code. I have tried to figure out what I missed (cookies, sessionStorage, ...), but did not manage. It is possible that WhatsApp registers the browser as being disconnected after some time has passed. Or that it uses other browser properties (session ID?) to recognize the browser. This is pure speculating from my side though.

Failed attempt #2: switching session/window

Every browser instance started via WebDriver has a session ID. This ID can be retrieved, so I figured it may be possible to start a session and then connect to it from the test cases, which would then be run from a separate file (you can see this is the predecessor of the final solution). Unfortunately, I have not been able to figure out a way to set the session ID. This may actually be a security concern, I am not sure. People more expert in the usage of WebDriver might be able to clarify here.

I did find out that it is possible to retrieve a list of window handles and switch between them. Unfortunately, windows are only shared within a single session and not across sessions.