Initial commit

Author: Exortions

.gitignore

@@ -0,0 +1,4 @@
+.env
+node_modules
+dist
+.vscode

.prettierignore

@@ -0,0 +1 @@
+node_modules

.prettierrc

@@ -0,0 +1,8 @@
+{
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "all",
+    "printWidth": 120,
+    "tabWidth": 4,
+    "useTabs": false
+}

jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+    testEnvironment: 'node',
+    transform: {
+        "^.+\\.ts$": "ts-jest"
+    },
+};

package.json

@@ -0,0 +1,47 @@
+{
+  "name": "rvsc-server",
+  "version": "1.0.0",
+  "description": "Server for Remote Visual Studio Code.",
+  "scripts": {
+    "build": "webpack",
+    "test": "jest",
+    "start": "yarn build && node dist/server.js"
+  },
+  "main": "dist/server.js",
+  "author": "Exortions",
+  "license": "MIT",
+  "private": true,
+  "dependencies": {
+    "axios": "^0.27.2",
+    "body-parser": "^1.20.0",
+    "chalk": "^5.0.1",
+    "cors": "^2.8.5",
+    "express": "^4.18.1",
+    "fs-extra": "^10.1.0",
+    "jsonwebtoken": "^8.5.1",
+    "lodash": "^4.17.21",
+    "mongoose": "^6.6.3",
+    "socket.io": "^4.5.2",
+    "socket.io-client": "^4.5.2",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.14",
+    "@types/jest": "^29.1.1",
+    "@types/jsonwebtoken": "^8.5.9",
+    "@types/node": "^18.7.23",
+    "@types/socket.io": "^3.0.2",
+    "@types/socket.io-client": "^3.0.0",
+    "@types/supertest": "^2.0.12",
+    "@types/uuid": "^8.3.4",
+    "dotenv-webpack": "^8.0.1",
+    "jest": "^29.1.2",
+    "supertest": "^6.2.4",
+    "ts-jest": "^29.0.3",
+    "ts-loader": "^9.4.1",
+    "typescript": "^4.8.4",
+    "webpack": "^5.74.0",
+    "webpack-cli": "^4.10.0",
+    "webpack-node-externals": "^3.0.0"
+  }
+}

src/database/database.ts

@@ -0,0 +1,15 @@
+import mongoose from 'mongoose';
+
+export async function connect(): Promise<boolean> {
+    const uri: string | undefined = process.env.MONGO_URI;
+
+    if (!uri) throw new Error('MONGO_URI is not defined');
+
+    try {
+        await mongoose.connect(uri);
+
+        return true;
+    } catch (err) {
+        return false;
+    }
+}

src/models/Session.ts

@@ -0,0 +1,123 @@
+import mongoose, { Schema } from 'mongoose';
+
+const SessionSchema = new Schema({
+    sid: {
+        type: String,
+        required: true,
+        unique: true,
+    },
+    password: {
+        type: String,
+        required: true,
+    },
+    expires: {
+        type: Date,
+        required: true,
+    },
+    users_connected: [
+        {
+            user: {
+                type: String,
+                required: true,
+            },
+            permission: {
+                type: String,
+                required: true,
+                validate: {
+                    validator: (v: string) => {
+                        return v === 'admin' || v === 'editor' || v === 'viewer';
+                    },
+                },
+            },
+        },
+    ],
+});
+
+export type UserPermission = 'viewer' | 'editor' | 'admin';
+
+export type SessionLike = mongoose.Document & {
+    sid: string;
+    password: string;
+    expires: Date;
+    users_connected: { user: string; permission: UserPermission }[];
+};
+
+export type SessionAuth = {
+    sid: string;
+    password: string;
+};
+
+const Session = mongoose.model<SessionLike>('Session', SessionSchema);
+
+export async function validate(session: SessionAuth): Promise<boolean> {
+    const found = Session.findOne({ sid: session.sid, password: session.password });
+
+    return found !== null && found !== undefined;
+}
+
+export async function find(session: SessionAuth): Promise<SessionLike | null> {
+    if (!(await validate(session))) return null;
+
+    const found = await Session.findOne({ sid: session.sid, password: session.password });
+
+    return found;
+}
+
+export async function create(session: SessionAuth & { expires: Date }): Promise<SessionLike> {
+    const created = new Session(session);
+
+    await created.save();
+
+    return created;
+}
+
+export async function remove(session: SessionAuth): Promise<boolean> {
+    if (!(await validate(session))) return false;
+
+    await Session.deleteOne({ sid: session.sid, password: session.password });
+
+    return true;
+}
+
+export async function add_user(
+    session: SessionAuth,
+    user: { user: string; permission: UserPermission },
+): Promise<boolean> {
+    if (!(await validate(session))) return false;
+
+    const found = await Session.findOne({ sid: session.sid, password: session.password });
+
+    if (found === null || !found) return false;
+
+    found.users_connected.push(user);
+
+    await found.save();
+
+    return true;
+}
+
+export async function remove_user(session: SessionAuth, user: string): Promise<boolean> {
+    if (!(await validate(session))) return false;
+
+    const found = await Session.findOne({ sid: session.sid, password: session.password });
+
+    if (found === null || !found) return false;
+
+    found.users_connected = found.users_connected.filter((u) => u.user !== user);
+
+    await found.save();
+
+    return true;
+}
+
+export async function get_users(session: SessionAuth): Promise<{ user: string; permission: UserPermission }[] | null> {
+    if (!(await validate(session))) return null;
+
+    const found = await Session.findOne({ sid: session.sid, password: session.password });
+
+    if (found === null || !found || !found.users_connected) return null;
+
+    return found.users_connected;
+}
+
+export default Session;

src/server.ts

@@ -0,0 +1,73 @@
+import { Request, Response } from 'express';
+// @ts-ignore - weird error, not recognizing socket.io types
+import { Server } from 'socket.io';
+import parser from 'body-parser';
+import express from 'express';
+import cors from 'cors';
+
+// modules
+import { connect } from './database/database';
+import loadTokens from './token/tokens';
+import socket from './socket/socket';
+import SocketEvent from './socket/SocketEvent';
+
+// events
+import DeleteSessionEvent from './socket/events/session/delete-session';
+import CreateSessionEvent from './socket/events/session/create-session';
+import UserConnectEvent from './socket/events/user/user-connect';
+import GenerateTokenEvent from './socket/events/token/generate';
+import UserKickEvent from './socket/events/user/kick-user';
+import DisconnectEvent from './socket/events/disconnect';
+
+const app: express.Application = express();
+const port: number = Number(process.env.PORT) || 3000;
+
+app.use(parser.urlencoded({ extended: true }));
+app.use(parser.json());
+app.use(cors({ origin: '*' }));
+
+loadTokens(app);
+
+app.get('/', (_req: Request, res: Response) => {
+    res.json({
+        hello: 'world',
+    });
+});
+
+let connected: boolean = false;
+let io: Server;
+let serv: any;
+
+(async () => {
+    const events: SocketEvent<any>[] = [];
+
+    events.push(new DeleteSessionEvent());
+    events.push(new CreateSessionEvent());
+    events.push(new UserConnectEvent());
+    events.push(new GenerateTokenEvent());
+    events.push(new UserKickEvent());
+    events.push(new DisconnectEvent());
+
+    io = await socket(events);
+
+    connected = await connect();
+
+    if (!connected) {
+        console.error('Could not connect to database');
+        process.exit(1);
+    } else {
+        console.log('Connected to database');
+    }
+
+    if (require.main === module) {
+        serv = app.listen(port, () => {
+            console.log(`Started server on port ${port}`);
+        });
+    }
+})();
+
+export default app;
+export { io };
+export function stopExpress(): void {
+    if (serv) serv.close();
+}

src/socket/SocketEvent.ts

@@ -0,0 +1,48 @@
+// @ts-ignore - weird error, not recognizing socket.io types
+import { Socket, Server } from 'socket.io';
+
+export default class SocketEvent<T> {
+    private _name: string;
+    private _callback: (data: T) => void;
+    private _socket: Socket | null;
+    private _server: Server | null;
+
+    constructor(name: string, callback: (data: T) => void, socket?: Socket) {
+        this._name = name;
+        this._callback = callback;
+        this._socket = socket || null;
+    }
+
+    public fire(socket: Socket, server: Server): (data: T) => void {
+        this._socket = socket;
+        this._server = server;
+
+        return this._callback;
+    }
+
+    get name(): string {
+        return this._name;
+    }
+
+    get callback(): (data: string) => void {
+        return (d: string) => {
+            this._callback(JSON.parse(d));
+        };
+    }
+
+    set socket(socket: Socket | null) {
+        this._socket = socket;
+    }
+
+    get socket(): Socket | null {
+        return this._socket;
+    }
+
+    set server(server: Server | null) {
+        this._server = server;
+    }
+
+    get server(): Server | null {
+        return this._server;
+    }
+}

src/socket/events/disconnect.ts

@@ -0,0 +1,13 @@
+import SocketEvent from '../SocketEvent';
+
+export default class DisconnectEvent extends SocketEvent<{}> {
+    constructor() {
+        super('disconnect', (_data: {}) => {
+            if (!this.socket) return;
+
+            console.log(`Socket disconnected: ${this.socket.id}`);
+
+            this.socket.removeAllListeners();
+        });
+    }
+}