Make everything use active evals (#30)

* Add trace log level

* Use active eval to implement spdlog

* Split server/client active eval interfaces

Since all properties are *not* valid on both sides

* +200% fire resistance

* Implement exec using active evaluations

* Fully implement child process streams

* Watch impl, move child_process back to explicitly adding events

Automatically forwarding all events might be the right move, but wanna
think/discuss it a bit more because it didn't come out very cleanly.

* Would you like some args with that callback?

* Implement the rest of child_process using active evals

* Rampant memory leaks

Emit "kill" to active evaluations when client disconnects in order to
kill processes. Most likely won't be the final solution.

* Resolve some minor issues with output panel

* Implement node-pty with active evals

* Provide clearTimeout to vm sandbox

* Implement socket with active evals

* Extract some callback logic

Also remove some eval interfaces, need to re-think those.

* Implement net.Server and remainder of net.Socket using active evals

* Implement dispose for active evaluations

* Use trace for express requests

* Handle sending buffers through evaluation events

* Make event logging a bit more clear

* Fix some errors due to us not actually instantiating until connect/listen

* is this a commit message?

* We can just create the evaluator in the ctor

Not sure what I was thinking.

* memory leak for you, memory leak for everyone

* it's a ternary now

* Don't dispose automatically on close or error

The code may or may not be disposable at that point.

* Handle parsing buffers on the client side as well

* Remove unused protobuf

* Remove TypedValue

* Remove unused forkProvider and test

* Improve dispose pattern for active evals

* Socket calls close after error; no need to bind both

* Improve comment

* Comment is no longer wishy washy due to explicit boolean

* Simplify check for sendHandle and options

* Replace _require with __non_webpack_require__

Webpack will then replace this with `require` which we then provide to
the vm sandbox.

* Provide path.parse

* Prevent original-fs from loading

* Start with a pid of -1

vscode immediately checks the PID to see if the debug process launch
correctly, but of course we don't get the pid synchronously.

* Pass arguments to bootstrap-fork

* Fully implement streams

Was causing errors because internally the stream would set this.writing
to true and it would never become false, so subsequent messages would
never send.

* Fix serializing errors and streams emitting errors multiple times

* Was emitting close to data

* Fix missing path for spawned processes

* Move evaluation onDispose call

Now it's accurate and runs when the active evaluation has actually
disposed.

* Fix promisifying fs.exists

* Fix some active eval callback issues

* Patch existsSync in debug adapter

packages/protocol/src/common/util.ts

@@ -1,3 +1,5 @@
+import { IDisposable } from "@coder/disposable";
+
 /**
  * Return true if we're in a browser environment (including web workers).
  */
@@ -25,10 +27,54 @@ export type IEncodingOptions = {
 export type IEncodingOptionsCallback = IEncodingOptions | ((err: NodeJS.ErrnoException, ...args: any[]) => void);
 
 /**
- * Return true if the options specify to use a Buffer instead of string.
+ * Stringify an event argument.
  */
-export const useBuffer = (options: IEncodingOptionsCallback): boolean => {
-	return options === "buffer"
-		|| (!!options && typeof options !== "string" && typeof options !== "function"
-				&& (options.encoding === "buffer" || options.encoding === null));
+export const stringify = (arg: any): string => { // tslint:disable-line no-any
+	if (arg instanceof Error) {
+		return JSON.stringify({
+			type: "Error",
+			data: {
+				message: arg.message,
+				name: arg.name,
+				stack: arg.stack,
+			},
+		});
+	}
+
+	return JSON.stringify(arg);
 };
+/**
+ * Parse an event argument.
+ */
+export const parse = (arg: string): any => { // tslint:disable-line no-any
+	if (!arg) {
+		return arg;
+	}
+
+	const result = JSON.parse(arg);
+
+	if (result && result.data && result.type) {
+		switch (result.type) {
+			// JSON.stringify turns a Buffer into an object but JSON.parse doesn't
+			// turn it back, it just remains an object.
+			case "Buffer":
+				if (Array.isArray(result.data)) {
+					return Buffer.from(result);
+				}
+				break;
+			// Errors apparently can't be stringified, so we do something similar to
+			// what happens to buffers and stringify them as regular objects.
+			case "Error":
+				if (result.data.message) {
+					return new Error(result.data.message);
+				}
+				break;
+		}
+	}
+
+	return result;
+};
+
+export interface Disposer extends IDisposable {
+	onDidDispose: (cb: () => void) => void;
+}