Refactor evaluations (#285)

* Replace evaluations with proxies and messages

* Return proxies synchronously

Otherwise events can be lost.

* Ensure events cannot be missed

* Refactor remaining fills

* Use more up-to-date version of util

For callbackify.

* Wait for dispose to come back before removing

This prevents issues with the "done" event not always being the last
event fired. For example a socket might close and then end, but only
if the caller called end.

* Remove old node-pty tests

* Fix emitting events twice on duplex streams

* Preserve environment when spawning processes

* Throw a better error if the proxy doesn't exist

* Remove rimraf dependency from ide

* Update net.Server.listening

* Use exit event instead of killed

Doesn't look like killed is even a thing.

* Add response timeout to server

* Fix trash

* Require node-pty & spdlog after they get unpackaged

This fixes an error when running in the binary.

* Fix errors in down emitter preventing reconnecting

* Fix disposing proxies when nothing listens to "error" event

* Refactor event tests to use jest.fn()

* Reject proxy call when disconnected

Otherwise it'll wait for the timeout which is a waste of time since we
already know the connection is dead.

* Use nbin for binary packaging

* Remove additional module requires

* Attempt to remove require for local bootstrap-fork

* Externalize fsevents

packages/vscode/src/fill/spdlog.ts

@@ -1,63 +1,4 @@
-import { RotatingLogger as NodeRotatingLogger } from "spdlog";
-import { logger } from "@coder/logger";
+import { Module } from "@coder/protocol";
 import { client } from "@coder/ide/src/fill/client";
 
-const ae = client.run((ae) => {
-	const loggers = new Map<number, NodeRotatingLogger>();
-
-	ae.on("new", (id: number, name: string, filePath: string, fileSize: number, fileCount: number) => {
-		const logger = new ae.modules.spdlog.RotatingLogger(name, filePath, fileSize, fileCount);
-		loggers.set(id, logger);
-	});
-
-	ae.on("clearFormatters", (id: number) => loggers.get(id)!.clearFormatters());
-	ae.on("critical", (id: number, message: string) => loggers.get(id)!.critical(message));
-	ae.on("debug", (id: number, message: string) => loggers.get(id)!.debug(message));
-	ae.on("drop", (id: number) => loggers.get(id)!.drop());
-	ae.on("errorLog", (id: number, message: string) => loggers.get(id)!.error(message));
-	ae.on("flush", (id: number) => loggers.get(id)!.flush());
-	ae.on("info", (id: number, message: string) => loggers.get(id)!.info(message));
-	ae.on("setAsyncMode", (bufferSize: number, flushInterval: number) => ae.modules.spdlog.setAsyncMode(bufferSize, flushInterval));
-	ae.on("setLevel", (id: number, level: number) => loggers.get(id)!.setLevel(level));
-	ae.on("trace", (id: number, message: string) => loggers.get(id)!.trace(message));
-	ae.on("warn", (id: number, message: string) => loggers.get(id)!.warn(message));
-
-	const disposeCallbacks = <Array<() => void>>[];
-
-	return {
-		onDidDispose: (cb): number => disposeCallbacks.push(cb),
-		dispose: (): void => {
-			loggers.forEach((logger) => logger.flush());
-			loggers.clear();
-			disposeCallbacks.forEach((cb) => cb());
-		},
-	};
-});
-
-const spdLogger = logger.named("spdlog");
-ae.on("close", () => spdLogger.error("session closed prematurely"));
-ae.on("error", (error: Error) => spdLogger.error(error.message));
-
-let id = 0;
-export class RotatingLogger implements NodeRotatingLogger {
-	private readonly id = id++;
-
-	public constructor(name: string, filePath: string, fileSize: number, fileCount: number) {
-		ae.emit("new", this.id, name, filePath, fileSize, fileCount);
-	}
-
-	public trace(message: string): void { ae.emit("trace", this.id, message); }
-	public debug(message: string): void { ae.emit("debug", this.id, message); }
-	public info(message: string): void { ae.emit("info", this.id, message); }
-	public warn(message: string): void { ae.emit("warn", this.id, message); }
-	public error(message: string): void { ae.emit("errorLog", this.id, message); }
-	public critical(message: string): void { ae.emit("critical", this.id, message); }
-	public setLevel(level: number): void { ae.emit("setLevel", this.id, level); }
-	public clearFormatters(): void { ae.emit("clearFormatters", this.id); }
-	public flush(): void { ae.emit("flush", this.id); }
-	public drop(): void { ae.emit("drop", this.id); }
-}
-
-export const setAsyncMode = (bufferSize: number, flushInterval: number): void => {
-	ae.emit("setAsyncMode", bufferSize, flushInterval);
-};
+export = client.modules[Module.Spdlog];