Create initial server layout (#11)

* Create initial server layout

* Adjust command name to entry

* Add @oclif/config as dependency

* Implement build process for outputting single binary

* Add init message

* Remove unused import, add tsconfig.json to .gitignore

* Accidently pushed wacky change to output host FS files

* Add options to createApp

Author: kylecarbs

package.json

@@ -41,5 +41,9 @@
     "webpack-cli": "^3.2.1",
     "webpack-dev-server": "^3.1.14",
     "write-file-webpack-plugin": "^4.5.0"
+  },
+  "dependencies": {
+    "node-loader": "^0.6.0",
+    "webpack-merge": "^4.2.1"
   }
 }

packages/logger/src/logger.ts

@@ -117,6 +117,8 @@ export abstract class Formatter {
 	public abstract push(arg: string, color?: string, weight?: string): void;
 	public abstract push(arg: any): void; // tslint:disable-line no-any
 
+	public abstract fields(fields: Array<Field<any>>): void;
+
 	/**
 	 * Flush out the built arguments.
 	 */
@@ -149,12 +151,12 @@ export abstract class Formatter {
  */
 export class BrowserFormatter extends Formatter {
 
-	public tag(name: string, color:string): void {
+	public tag(name: string, color: string): void {
 		this.format += `%c ${name} `;
 		this.args.push(
 			`border: 1px solid #222; background-color: ${color}; padding-top: 1px;`
-				+ " padding-bottom: 1px; font-size: 12px; font-weight: bold; color: white;"
-				+ (name.length === 4 ? "padding-left: 3px; padding-right: 4px;" : ""),
+			+ " padding-bottom: 1px; font-size: 12px; font-weight: bold; color: white;"
+			+ (name.length === 4 ? "padding-left: 3px; padding-right: 4px;" : ""),
 		);
 	}
 
@@ -170,6 +172,20 @@ export class BrowserFormatter extends Formatter {
 		this.args.push(arg);
 	}
 
+	public fields(fields: Array<Field<any>>): void {
+		console.groupCollapsed(...this.flush());
+		fields.forEach((field) => {
+			this.push(field.identifier, "#3794ff", "bold");
+			if (typeof field.value !== "undefined" && field.value.constructor && field.value.constructor.name) {
+				this.push(` (${field.value.constructor.name})`);
+			}
+			this.push(": ");
+			this.push(field.value);
+			console.log(...this.flush());
+		});
+		console.groupEnd();
+	}
+
 }
 
 /**
@@ -179,8 +195,11 @@ export class ServerFormatter extends Formatter {
 
 	public tag(name: string, color: string): void {
 		const [r, g, b] = hexToRgb(color);
+		while (name.length < 5) {
+			name += " ";
+		}
 		this.format += "\u001B[1m";
-		this.format += `\u001B[48;2;${r};${g};${b}m ${name} \u001B[0m`;
+		this.format += `\u001B[38;2;${r};${g};${b}m ${name} \u001B[0m`;
 	}
 
 	public push(arg: any, color?: string, weight?: string): void { // tslint:disable-line no-any
@@ -198,6 +217,16 @@ export class ServerFormatter extends Formatter {
 		this.args.push(arg);
 	}
 
+	public fields(fields: Array<Field<any>>): void {
+		const obj = {} as any;
+		this.format += "\u001B[38;2;140;140;140m"
+		fields.forEach((field) => {
+			obj[field.identifier] = field.value;
+		});
+		this.args.push(JSON.stringify(obj));
+		console.log(...this.flush());
+	}
+
 }
 
 /**
@@ -250,7 +279,7 @@ export class Logger {
 			type: "warn",
 			message: msg,
 			fields,
-			tagColor: "#919E00",
+			tagColor: "#FF9D00",
 		});
 	}
 
@@ -325,7 +354,7 @@ export class Logger {
 			this._formatter.push(" ");
 			this._formatter.tag(this.name.toUpperCase(), this.nameColor);
 		}
-		this._formatter.push(" " + options.message);
+		this._formatter.push(options.message);
 		if (times.length > 0) {
 			times.forEach((time) => {
 				const diff = now - time.value.ms;
@@ -341,17 +370,7 @@ export class Logger {
 
 		// tslint:disable no-console
 		if (hasFields) {
-			console.groupCollapsed(...this._formatter.flush());
-			fields.forEach((field) => {
-				this._formatter.push(field.identifier, "#3794ff", "bold");
-				if (typeof field.value !== "undefined" && field.value.constructor && field.value.constructor.name) {
-					this._formatter.push(` (${field.value.constructor.name})`);
-				}
-				this._formatter.push(": ");
-				this._formatter.push(field.value);
-				console.log(...this._formatter.flush());
-			});
-			console.groupEnd();
+			this._formatter.fields(fields);
 		} else {
 			console.log(...this._formatter.flush());
 		}

packages/protocol/package.json

@@ -3,13 +3,13 @@
     "main": "src/index.ts",
     "dependencies": {
         "express": "^4.16.4",
+        "google-protobuf": "^3.6.1",
         "node-pty": "^0.8.0",
         "ws": "^6.1.2"
     },
     "devDependencies": {
-        "@types/express": "^4.16.0",
+        "@types/google-protobuf": "^3.2.7",
         "@types/text-encoding": "^0.0.35",
-        "@types/ws": "^6.0.1",
         "text-encoding": "^0.7.0",
         "ts-protoc-gen": "^0.8.0"
     }

packages/protocol/src/browser/client.ts

@@ -1,6 +1,6 @@
-import { ReadWriteConnection } from "../common/connection";
-import { NewEvalMessage, ServerMessage, EvalDoneMessage, EvalFailedMessage, TypedValue, ClientMessage, NewSessionMessage, TTYDimensions, SessionOutputMessage, CloseSessionInputMessage } from "../proto";
-import { Emitter } from "@coder/events";
+import { ReadWriteConnection, InitData, OperatingSystem } from "../common/connection";
+import { NewEvalMessage, ServerMessage, EvalDoneMessage, EvalFailedMessage, TypedValue, ClientMessage, NewSessionMessage, TTYDimensions, SessionOutputMessage, CloseSessionInputMessage, InitMessage } from "../proto";
+import { Emitter, Event } from "@coder/events";
 import { logger, field } from "@coder/logger";
 import { ChildProcess, SpawnOptions, ServerProcess } from "./command";
 
@@ -15,12 +15,17 @@ export class Client {
 	private sessionId: number = 0;
 	private sessions: Map<number, ServerProcess> = new Map();
 
+	private _initData: InitData | undefined;
+	private initDataEmitter: Emitter<InitData> = new Emitter();
+
 	/**
 	 * @param connection Established connection to the server
 	 */
 	public constructor(
 		private readonly connection: ReadWriteConnection,
 	) {
+		this.initDataEmitter = new Emitter();
+
 		connection.onMessage((data) => {
 			try {
 				this.handleMessage(ServerMessage.deserializeBinary(data));
@@ -30,6 +35,14 @@ export class Client {
 		});
 	}
 
+	public get onInitData(): Event<InitData> {
+		return this.initDataEmitter.event;
+	}
+
+	public get initData(): InitData | undefined {
+		return this._initData;
+	}
+
 	public evaluate<R>(func: () => R | Promise<R>): Promise<R>;
 	public evaluate<R, T1>(func: (a1: T1) => R | Promise<R>, a1: T1): Promise<R>;
 	public evaluate<R, T1, T2>(func: (a1: T1, a2: T2) => R | Promise<R>, a1: T1, a2: T2): Promise<R>;
@@ -47,7 +60,7 @@ export class Client {
 	 * console.log(returned);
 	 * // output: "hi"
 	 * @param func Function to evaluate
-	 * @returns {Promise} Promise rejected or resolved from the evaluated function
+	 * @returns Promise rejected or resolved from the evaluated function
 	 */
 		public evaluate<R, T1, T2, T3, T4, T5, T6>(func: (a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6) => R | Promise<R>, a1?: T1, a2?: T2, a3?: T3, a4?: T4, a5?: T5, a6?: T6): Promise<R> {
 		const newEval = new NewEvalMessage();
@@ -61,8 +74,8 @@ export class Client {
 		this.connection.send(clientMsg.serializeBinary());
 
 		let res: (value?: R) => void;
-		let rej: (err?: any) => void;
-		const prom = new Promise<R>((r, e) => {
+		let rej: (err?: Error) => void;
+		const prom = new Promise<R>((r, e): void => {
 			res = r;
 			rej = e;
 		});
@@ -80,6 +93,7 @@ export class Client {
 				}
 
 				const rt = resp.getType();
+				// tslint:disable-next-line
 				let val: any;
 				switch (rt) {
 					case TypedValue.Type.BOOLEAN:
@@ -107,7 +121,7 @@ export class Client {
 				d1.dispose();
 				d2.dispose();
 
-				rej(failedMsg.getMessage());
+				rej(new Error(failedMsg.getMessage()));
 			}
 		});
 
@@ -120,7 +134,6 @@ export class Client {
 	 * const cp = this.client.spawn("echo", ["test"]);
 	 * cp.stdout.on("data", (data) => console.log(data.toString()));
 	 * cp.on("exit", (code) => console.log("exited with", code));
-	 * @param command
 	 * @param args Arguments
 	 * @param options Options to execute for the command
 	 */
@@ -167,14 +180,14 @@ export class Client {
 
 		const serverProc = new ServerProcess(this.connection, id, options ? options.tty !== undefined : false);
 		serverProc.stdin.on("close", () => {
-			console.log("stdin closed");
 			const c = new CloseSessionInputMessage();
 			c.setId(id);
 			const cm = new ClientMessage();
 			cm.setCloseSessionInput(c);
 			this.connection.send(cm.serializeBinary());
 		});
 		this.sessions.set(id, serverProc);
+
 		return serverProc;
 	}
 
@@ -183,7 +196,31 @@ export class Client {
 	 * routed through here.
 	 */
 	private handleMessage(message: ServerMessage): void {
-		if (message.hasEvalDone()) {
+		if (message.hasInit()) {
+			const init = message.getInit()!;
+			let opSys: OperatingSystem;
+			switch (init.getOperatingSystem()) {
+				case InitMessage.OperatingSystem.WINDOWS:
+					opSys = OperatingSystem.Windows;
+					break;
+				case InitMessage.OperatingSystem.LINUX:
+					opSys = OperatingSystem.Linux;
+					break;
+				case InitMessage.OperatingSystem.MAC:
+					opSys = OperatingSystem.Mac;
+					break;
+				default:
+					throw new Error(`unsupported operating system ${init.getOperatingSystem()}`);
+			}
+			this._initData = {
+				dataDirectory: init.getDataDirectory(),
+				homeDirectory: init.getHomeDirectory(),
+				tmpDirectory: init.getTmpDirectory(),
+				workingDirectory: init.getWorkingDirectory(),
+				os: opSys,
+			};
+			this.initDataEmitter.emit(this._initData);
+		} else if (message.hasEvalDone()) {
 			this.evalDoneEmitter.emit(message.getEvalDone()!);
 		} else if (message.hasEvalFailed()) {
 			this.evalFailedEmitter.emit(message.getEvalFailed()!);

packages/protocol/src/browser/modules/child_process.ts

@@ -38,14 +38,18 @@ export class CP {
 			);
 		});
 
+		// @ts-ignore
 		return process;
 	}
 
-	public fork = (modulePath: string): cp.ChildProcess => {
+	public fork(modulePath: string): cp.ChildProcess {
+		//@ts-ignore
 		return this.client.fork(modulePath);
 	}
 
-	public spawn = (command: string, args?: ReadonlyArray<string> | cp.SpawnOptions, _options?: cp.SpawnOptions): cp.ChildProcess => {
+	public spawn(command: string, args?: ReadonlyArray<string> | cp.SpawnOptions, _options?: cp.SpawnOptions): cp.ChildProcess {
+		// TODO: fix this ignore. Should check for args or options here
+		//@ts-ignore
 		return this.client.spawn(command, args, options);
 	}
 

packages/protocol/src/common/connection.ts

@@ -7,3 +7,17 @@ export interface ReadWriteConnection extends SendableConnection {
 	onClose(cb: () => void): void;
 	close(): void;
 }
+
+export enum OperatingSystem {
+	Windows,
+	Linux,
+	Mac,
+}
+
+export interface InitData {
+	readonly os: OperatingSystem;
+	readonly dataDirectory: string;
+	readonly workingDirectory: string;
+	readonly homeDirectory: string;
+	readonly tmpDirectory: string;
+}

packages/protocol/src/node/evaluate.ts

@@ -2,6 +2,7 @@ import * as vm from "vm";
 import { NewEvalMessage, TypedValue, EvalFailedMessage, EvalDoneMessage, ServerMessage } from "../proto";
 import { SendableConnection } from "../common/connection";
 
+declare var __non_webpack_require__: typeof require;
 export const evaluate = async (connection: SendableConnection, message: NewEvalMessage): Promise<void> => {
 	const argStr: string[] = [];
 	message.getArgsList().forEach((value) => {
@@ -51,7 +52,7 @@ export const evaluate = async (connection: SendableConnection, message: NewEvalM
 		connection.send(serverMsg.serializeBinary());
 	};
 	try {
-		const value = vm.runInNewContext(`(${message.getFunction()})(${argStr.join(",")})`, { Buffer, require, setTimeout }, {
+		const value = vm.runInNewContext(`(${message.getFunction()})(${argStr.join(",")})`, { Buffer, require: typeof __non_webpack_require__ !== "undefined" ? __non_webpack_require__ : require, setTimeout }, {
 			timeout: message.getTimeout() || 30000,
 		});
 		sendResp(await value);

packages/protocol/src/node/server.ts

@@ -1,16 +1,23 @@
 import { logger, field } from "@coder/logger";
+import * as os from "os";
 import { TextDecoder } from "text-encoding";
-import { ClientMessage } from "../proto";
+import { ClientMessage, InitMessage, ServerMessage } from "../proto";
 import { evaluate } from "./evaluate";
 import { ReadWriteConnection } from "../common/connection";
 import { Process, handleNewSession } from "./command";
 
+export interface ServerOptions {
+	readonly workingDirectory: string;
+	readonly dataDirectory: string;
+}
+
 export class Server {
 
 	private readonly sessions: Map<number, Process>;
 
 	public constructor(
 		private readonly connection: ReadWriteConnection,
+		options?: ServerOptions,
 	) {
 		this.sessions = new Map();
 
@@ -21,6 +28,37 @@ export class Server {
 				logger.error("Failed to handle client message", field("length", data.byteLength), field("exception", ex));
 			}
 		});
+
+		if (!options) {
+			logger.warn("No server options provided. InitMessage will not be sent.");
+
+			return;
+		}
+
+		const initMsg = new InitMessage();
+		initMsg.setDataDirectory(options.dataDirectory);
+		initMsg.setWorkingDirectory(options.workingDirectory);
+		initMsg.setHomeDirectory(os.homedir());
+		initMsg.setTmpDirectory(os.tmpdir());
+		const platform = os.platform();
+		let operatingSystem: InitMessage.OperatingSystem;
+		switch (platform) {
+			case "win32":
+				operatingSystem = InitMessage.OperatingSystem.WINDOWS;
+				break;
+			case "linux":
+				operatingSystem = InitMessage.OperatingSystem.LINUX;
+				break;
+			case "darwin":
+				operatingSystem = InitMessage.OperatingSystem.MAC;
+				break;
+			default:
+				throw new Error(`unrecognized platform "${platform}"`);
+		}
+		initMsg.setOperatingSystem(operatingSystem);
+		const srvMsg = new ServerMessage();
+		srvMsg.setInit(initMsg);
+		connection.send(srvMsg.serializeBinary());
 	}
 
 	private handleMessage(message: ClientMessage): void {