From b4dcb61301feb867c490faef3183304ea42fd6e7 Mon Sep 17 00:00:00 2001
From: jerl <valley.forge@live.com>
Date: Sat, 7 Sep 2024 20:55:03 -0500
Subject: [PATCH] call

---
 README.md               |  15 ++--
 client/call.js          | 139 +++++++++++++++++++++++++++++++++++++
 client/index.html       |   5 +-
 client/stream.js        |   3 +-
 client/thread.js        |  16 ++---
 package.json            |   1 +
 server.js               |  13 +++-
 src/check_permission.js |  25 ++++---
 src/db.js               |   3 +-
 src/events/call.js      | 147 ++++++++++++++++++++++++++++++++++++++++
 src/events/stream.js    |   9 +--
 src/events/thread.js    |  86 ++++++++++++++---------
 12 files changed, 389 insertions(+), 73 deletions(-)
 create mode 100644 client/call.js
 create mode 100644 src/events/call.js

diff --git a/README.md b/README.md
index 673943b..68f73fd 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@ a vybe instance (server) features user accounts and **threads**.
 
 user accounts are owned by PGP keys stored in users' clients.
 
-each thread features a chatroom, a **space**, and audio streams.
+each thread features a chatroom, a call, a **space**, and audio streams.
 
 a space is like a text blackboard, basically. you can write text and move it around and resize it with your mouse.
 
@@ -21,21 +21,24 @@ then
 
 > `node .`
 
-it will run on port 1312 by default; you can change this by setting PORT on first-run:
+it will run on port 1312 by default; on first run, you can change this by setting PORT:
 
 > `PORT=1234 node .`
 
-after first-run, the port is configured in instance.json.
+after first run, the port is configured in instance.json.
 
 **currently, you'll need to proxy it through a webserver like nginx or Caddy, which needs to have https enabled** for things to work correctly. if you want the easy option, i recommend Caddy. example Caddy config:
 
 > ```
-> vybe.my.domain {
+> vybe.example.domain {
 > 	reverse_proxy localhost:1312
+> 	header Access-Control-Allow-Origin "*"
 > }
-> ```  
+> ```
 
-then go to `https://vybe.my.domain` to start using vybe!
+(the allow-origin header isn't required normally unless websockets don't work for whatever reason)
+
+then go to `https://vybe.example.domain` to start using vybe!
 
 ## todo
 
diff --git a/client/call.js b/client/call.js
new file mode 100644
index 0000000..d9576ef
--- /dev/null
+++ b/client/call.js
@@ -0,0 +1,139 @@
+import { render, html } from '/uhtml.js';
+import loadStreams from '/stream.js';
+
+let instance;
+let thread;
+let connection;
+let mediaStream;
+
+function loadCall() {
+	let div = document.getElementById('call');
+	render(div, html`
+		<div id='users'></div>
+		<p id='noone'>no one is in call</p>
+		<button id='join' onclick=${async function(event) {
+			if (instance) {
+				connection.close();
+				instance.emit('leave', { thread }, msg => {
+					if (!msg.success)
+						console.log('leave error:', msg.message);
+				});
+				instance = null;
+				if (thread === currentThread.id) {
+					this.innerText = 'join';
+					return;
+				}
+			}
+			mediaStream = await navigator.mediaDevices.getUserMedia({
+				audio: {
+					autoGainControl: true,
+					echoCancellation: true,
+					noiseSuppression: true,
+					sampleRate: 48000,
+					sampleSize: 16
+				}
+			});
+			if (!mediaStream) {
+				console.log("couldn't get media stream");
+				return;
+			}
+			this.innerText = 'leave';
+			instance = currentInstance;
+			thread = currentThread.id;
+			connection = new RTCPeerConnection();
+			connection.addTrack(mediaStream.getTracks()[0]);
+			instance.emit('join', {
+				thread
+			}, async msg => {
+				if (!msg.success)
+					console.log('join error:', msg.message);
+			});
+			connection.onnegotiationneeded = async e => {
+				await connection.setLocalDescription(await connection.createOffer());
+				instance.emit('offer', {
+					thread,
+					sdp: connection.localDescription
+				}, async msg => {
+					if (!msg.success) {
+						console.log('offer error:', msg.message);
+						return;
+					}
+					await connection.setRemoteDescription(msg.sdp);
+				});
+			};
+			connection.ontrack = track => {
+				let audioctx = new AudioContext();
+				console.log(audioctx);
+				let source = audioctx.createMediaStreamSource(new MediaStream([track.track]));
+				source.connect(audioctx.destination);
+			};
+			connection.onicecandidate = event => {
+				if (!instance || !event.candidate)
+					return;
+				let candidate = event.candidate.toJSON();
+				console.log(candidate);
+				if (!candidate.candidate)
+					return;
+				instance.emit('ice', {
+					thread,
+					candidate
+				}, msg => {
+					if (!msg.success)
+						console.log('ice error:', msg.message);
+				});
+			};
+			connection.onconnectionstatechange = e => {
+				console.log(connection.connectionState);
+				if (connection.connectionState === 'disconnected' && instance) {
+					connection.close();
+					instance = null;
+					if (thread === currentThread.id)
+						this.innerText = 'join';
+				}
+			};
+		}}>join</button>
+		<hr color='#505050'>
+		<div id='stream'></div>`);
+	if (Object.keys(currentThread.call).length)
+		div.children['noone'].classList.add('hidden');
+	for (let id in currentThread.call) {
+		let p = document.createElement('p');
+		p.append(window.makeUser(currentThread.call[id], id.split?.('@')[1] || currentInstance.url));
+		div.children['users'].append(p);
+	}
+	if (!currentInstance.called) {
+		currentInstance.socket.on('call', msg => {
+			if (msg.thread !== currentThread.id)
+				return;
+			if (Object.keys(msg.call).length)
+				div.children['noone'].classList.add('hidden');
+			else
+				div.children['noone'].classList.remove('hidden');
+			currentThread.call = msg.call;
+			div.children['users'].replaceChildren(...Object.values(msg.call).map(user => {
+				let p = document.createElement('p');
+				p.append(window.makeUser(user, user.id.split?.('@')[1] || currentInstance.url));
+				return p;
+			}));
+		});
+		currentInstance.socket.on('offer', async (msg, respond) => {
+			if (!connection)
+				return;
+			await connection.setRemoteDescription(msg.sdp);
+			await connection.setLocalDescription(await connection.createAnswer());
+			respond({
+				success: true,
+				sdp: connection.localDescription
+			});
+		});
+		currentInstance.socket.on('ice', msg => {
+			if (!connection)
+				return;
+			connection.addIceCandidate(new RTCIceCandidate(msg.candidate));
+		});
+		currentInstance.called = true;
+	}
+	loadStreams();
+}
+
+export default loadCall;
diff --git a/client/index.html b/client/index.html
index 61f2147..63d93ff 100644
--- a/client/index.html
+++ b/client/index.html
@@ -272,9 +272,9 @@
 			}
 			.tabcontent {
 				flex: 1;
+				margin: 0 2px;
 			}
 			#message {
-				margin: 2px;
 				display: flex;
 				flex-direction: column;
 				min-height: 0; /* flex makes this auto so it can't shrink */
@@ -323,9 +323,6 @@
 				position: absolute;
 				white-space: nowrap;
 			}
-			#stream {
-				margin: 4px 2px;
-			}
 			#play {
 				line-height: 1.4;
 				font-family: 'Segoe UI Symbol', math;
diff --git a/client/stream.js b/client/stream.js
index 35cb3a9..a6fe70a 100644
--- a/client/stream.js
+++ b/client/stream.js
@@ -78,8 +78,7 @@ function loadStreams() {
 	let div = document.getElementById('stream');
 	div.innerHTML = '';
 	if (window.currentThread?.permissions.post) {
-		// why doesn't html` work here? html.node` does
-		render(div, html.node`
+		render(div, html`
 			<button id='streaming' onclick=${stream}>
 				${window.currentThread.handle ? 'stop' : 'start'} streaming
 			</button>
diff --git a/client/thread.js b/client/thread.js
index 1220b4d..816b7ee 100644
--- a/client/thread.js
+++ b/client/thread.js
@@ -1,7 +1,7 @@
 import { render, html } from '/uhtml.js';
 import loadMessages from '/message.js';
 import loadSpace from '/space.js';
-import loadStreams from '/stream.js';
+import loadCall from '/call.js';
 
 function setVisibility() {
 	document.getElementById('visibility').innerText = `${
@@ -77,9 +77,9 @@ function chooseThread() {
 				return p;
 			}))
 		);
-		loadStreams();
+		loadCall();
 		let tab = url.searchParams.get('tab');
-		if (!['message', 'space', 'stream'].includes(tab))
+		if (!['message', 'space', 'call'].includes(tab))
 			tab = null;
 		if (tab || this.tab) {
 			if (tab)
@@ -101,11 +101,11 @@ function chooseThread() {
 							if (spans.length)
 								switchTab(document.getElementById(div.tab = 'spacetab'));
 							else if (window.currentThread.streams.length)
-								switchTab(document.getElementById(div.tab = 'streamtab'));
+								switchTab(document.getElementById(div.tab = 'calltab'));
 							else
 								switchTab(document.getElementById(
 									div.tab = spans.length ? 'spacetab' :
-										window.currentThread.streams.length ? 'streamtab' : 'messagetab'));
+										window.currentThread.streams.length ? 'calltab' : 'messagetab'));
 							resolve();
 						});
 				});
@@ -142,7 +142,7 @@ function newThread(instance) {
 	let members = [{
 		id: String(window.id),
 		name: window.name,
-		permissions: { admin: 'true' }
+		permissions: { admin: true }
 	}];
 	if (instance !== window.instancelist[0]) {
 		members[0].id += '@' + location.host;
@@ -387,7 +387,7 @@ async function loadThreads(instancediv, select) {
 					<div id='tabs'>
 						<button id='messagetab' class='tab active' onclick=${clickedTab}>messages
 						</button><button id='spacetab' class='tab' onclick=${clickedTab}>space
-						</button><button id='streamtab' class='tab' onclick=${clickedTab}>streams</button>
+						</button><button id='calltab' class='tab' onclick=${clickedTab}>call / stream</button>
 					</div>
 					<button id='showmembers' onclick=${() =>
 						document.getElementById('members').classList.toggle('hidden')
@@ -395,7 +395,7 @@ async function loadThreads(instancediv, select) {
 				</div>
 				<div id='message' class='tabcontent'></div>
 				<div id='space' class='tabcontent hidden'></div>
-				<div id='stream' class='tabcontent hidden'></div>
+				<div id='call' class='tabcontent hidden'></div>
 			</div>
 			<hr class='separator' color='#505050'>
 			<div id='members' class='column hidden'>
diff --git a/package.json b/package.json
index 9365074..15d0e6f 100644
--- a/package.json
+++ b/package.json
@@ -9,6 +9,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@roamhq/wrtc": "^0.8.0",
     "aes-js": "^3.1.2",
     "compression": "^1.7.4",
     "cors": "^2.8.5",
diff --git a/server.js b/server.js
index 0221e49..a6ff703 100644
--- a/server.js
+++ b/server.js
@@ -51,6 +51,7 @@ global.vybe = {
 	instances: {},
 	users: {},
 	threads: {},
+	calls: {},
 	streams: {},
 	connectInstance: async url => {
 		let instance = vybe.instances[url];
@@ -103,7 +104,7 @@ io.on('connection', (socket) => {
 			}
 		});
 	}
-	socket.on('disconnect', reason => {
+	socket.on('disconnect', async reason => {
 		let user = vybe.users[socket.__userid];
 		if (user)
 			user.sockets.splice(user.sockets.indexOf(socket), 1);
@@ -113,6 +114,16 @@ io.on('connection', (socket) => {
 			if (stream.socket === socket)
 				stream.stop();
 		}
+		for (let id in vybe.calls) {
+			let call = vybe.calls[id];
+			let connection = call[socket.__userid];
+			if (!connection)
+				continue;
+			connection.close();
+			delete call[socket.__userid];
+			delete vybe.threads[id].call[socket.__userid];
+			await vybe.threads[id].emitcall();
+		}
 	});
 });
 
diff --git a/src/check_permission.js b/src/check_permission.js
index 1f3f478..0ba7f74 100644
--- a/src/check_permission.js
+++ b/src/check_permission.js
@@ -1,24 +1,23 @@
 const db = require('./db');
 
-const check_permission = async (user_id, thread_id) => {
+async function check_permission(user_id, thread_id) {
 	// get all the permissions for the thread
-	const permissions = await db.query(
+	const perms = {
+		is_member: (await db.query(
+			'select * from member where thread = ? and user = ?',
+			[thread_id, user_id])
+		).rows.length > 0
+	};
+	for (let p of (await db.query(
 		'select * from permission where thread = ?',
-		[thread_id]
-	);
-	// check if the user is a member
-	const is_member = (
-			await db.query('select * from member where thread = ? and user = ?',
-				[thread_id, user_id])
-		).rows.length > 0;
-	let perms = { is_member };
-	for (let p of permissions.rows) {
+		thread_id
+	)).rows) {
 		if ((p.type === 'everyone' && p.value === 'true')
-			|| (p.type === 'members' && is_member && p.value === 'true')
+			|| (p.type === 'members' && perms.is_member && p.value === 'true')
 			|| (p.type === 'user' && p.user == user_id && p.value === 'true'))
 			perms[p.permission] = true;
 	}
 	return perms;
-};
+}
 
 module.exports = check_permission;
diff --git a/src/db.js b/src/db.js
index 5a75014..ca47617 100644
--- a/src/db.js
+++ b/src/db.js
@@ -7,9 +7,8 @@ const existed = fs.existsSync(path);
 const db = new sqlite3.Database(path);
 
 db.query = function (sql, params) {
-	let self = this;
 	return new Promise((resolve, reject) => {
-		self.all(sql, params, (error, rows) => {
+		db.all(sql, params, (error, rows) => {
 			if (error)
 				reject(error);
 			else
diff --git a/src/events/call.js b/src/events/call.js
new file mode 100644
index 0000000..8f156f9
--- /dev/null
+++ b/src/events/call.js
@@ -0,0 +1,147 @@
+const { RTCPeerConnection } = require('@roamhq/wrtc');
+const db = require('../db');
+const check_permission = require('../check_permission');
+const authwrap = require('../authwrap');
+
+async function join(msg, respond, socket) {
+	if (!msg.thread)
+		return respond({
+			success: false,
+			message: 'missing argument'
+		});
+	if (!(await check_permission(msg.auth_user.id, msg.thread)).view)
+		return respond({
+			success: false,
+			message: "user doesn't have permission"
+		});
+	const thread = vybe.threads[msg.thread];
+	const call = vybe.calls[msg.thread];
+	call[msg.auth_user.id]?.close();
+	connection = call[msg.auth_user.id] = new RTCPeerConnection();
+	connection.onnegotiationneeded = async event => {
+		await connection.setLocalDescription(await connection.createOffer());
+		socket.emit('offer', {
+			thread: msg.thread,
+			sdp: connection.localDescription
+		}, async msg => {
+			if (!msg.success) {
+				console.log('offer error:', msg.message);
+				return;
+			}
+			await connection.setRemoteDescription(msg.sdp);
+		});
+	};
+	connection.onicecandidate = event => {
+		if (event.candidate)
+			socket.emit('ice', { candidate: event.candidate.toJSON() });
+	};
+	connection.ontrack = track => {
+		connection.senders = connection.getSenders();
+		connection.track = track.track;
+		console.log('got track', track.track.id, connection.senders.length);
+		for (let id in call)
+			if (id != msg.auth_user.id)
+				call[id].addTrack(track.track);
+	};
+	connection.onconnectionstatechange = async e => {
+		switch (connection.connectionState) {
+			case 'connected':
+				thread.call[msg.auth_user.id] = {
+					id: msg.auth_user.id,
+					name: vybe.users[msg.auth_user.id].name,
+					displayname: vybe.users[msg.auth_user.id].displayname,
+					permissions: Object.fromEntries((await db.query(
+						`select permission, value from permission
+						where type = 'user' and thread = ? and user = ?`,
+						[msg.thread, msg.auth_user.id])).rows.map(p =>
+							[p.permission, ['admin', 'post', 'view'].includes(p.permission)
+								? p.value === 'true' : p.value]))
+				};
+				await thread.emitcall();
+				if (connection.connectionState === 'connected')
+					for (let id in call)
+						if (id != msg.auth_user.id)
+							connection.addTrack(call[id].track);
+				break;
+			case 'failed':
+				console.log('peer connection failed');
+			case 'disconnected':
+			case 'closed':
+				if (call[msg.auth_user.id]) {
+					if (call[msg.auth_user.id] === connection) {
+						delete call[msg.auth_user.id];
+						delete thread.call[msg.auth_user.id];
+						await thread.emitcall();
+					}
+				}
+		}
+	};
+	respond({ success: true });
+}
+
+async function offer(msg, respond) {
+	if (!msg.thread || !msg.sdp)
+		return respond({
+			success: false,
+			message: 'missing argument'
+		});
+	let connection = vybe.calls[msg.thread]?.[msg.auth_user.id];
+	if (!connection)
+		return respond({
+			success: false,
+			message: 'no connection'
+		});
+	await connection.setRemoteDescription(msg.sdp);
+	await connection.setLocalDescription(await connection.createAnswer());
+	respond({
+		success: true,
+		sdp: connection.localDescription
+	});
+}
+
+async function ice(msg, respond) {
+	if (!msg.thread || !msg.candidate)
+		return respond({
+			success: false,
+			message: 'missing argument'
+		});
+	let connection = vybe.calls[msg.thread]?.[msg.auth_user.id];
+	if (!connection)
+		return respond({
+			success: false,
+			message: 'no connection'
+		});
+	try {
+		await connection.addIceCandidate(msg.candidate);
+		respond({ success: true });
+	}
+	catch (e) {
+		respond({
+			success: false,
+			message: 'error: ' + e
+		});
+	}
+}
+
+async function leave(msg, respond) {
+	let thread = vybe.threads[msg.thread];
+	let call = vybe.calls[msg.thread];
+	let connection = call?.[msg.auth_user.id];
+	if (!connection)
+		return respond({
+			success: false,
+			message: 'user not in call'
+		});
+	connection.close();
+	delete call[msg.auth_user.id];
+	delete thread.call[msg.auth_user.id];
+	await thread.emitcall();
+	respond({ success: true });
+}
+
+module.exports = {
+	join: authwrap(join),
+	offer:authwrap(offer),
+	ice: authwrap(ice),
+	leave: authwrap(leave)
+};
diff --git a/src/events/stream.js b/src/events/stream.js
index f4b4c3a..02a6962 100644
--- a/src/events/stream.js
+++ b/src/events/stream.js
@@ -12,15 +12,11 @@ async function stream(msg, respond, socket) {
 		});
 	}
 	let stream;
-	let thread = vybe.threads[msg.thread] || (vybe.threads[msg.thread] = {
-		streams: []
-	});
 	async function send() {
-		const permissions = await db.query(
+		if ((await db.query(
 			`select * from permission
 			where thread = ? and type = 'everyone' and value = 'true' and permission = 'view'`,
-			msg.thread);
-		if (permissions.rows.length) {
+			msg.thread)).rows.length) {
 			for (let id in vybe.users)
 				for (let socket of vybe.users[id].sockets)
 					socket.emit('stream', stream);
@@ -74,6 +70,7 @@ async function stream(msg, respond, socket) {
 			},
 			name: msg.name
 		};
+		let thread = vybe.threads[msg.thread];
 		thread.streams.push(stream);
 		vybe.streams[stream.id] = {
 			stream,
diff --git a/src/events/thread.js b/src/events/thread.js
index d9113fd..c6f0242 100644
--- a/src/events/thread.js
+++ b/src/events/thread.js
@@ -2,6 +2,42 @@ const db = require('../db');
 const authwrap = require('../authwrap');
 const check_permission = require('../check_permission');
 
+(async () => {
+	for (let thread of (await db.query(
+		`select name, id from thread`
+	)).rows) {
+		vybe.threads[thread.id] = {
+			...thread,
+			streams: [],
+			call: {},
+			emitcall: async function() {
+				let msg = {
+					thread: this.id,
+					call: this.call
+				};
+				if ((await db.query(
+					`select * from permission
+					where thread = ? and type = 'everyone' and value = 'true' and permission = 'view'`,
+					this.id)).rows.length) {
+					for (let id in vybe.users)
+						for (let socket of vybe.users[id].sockets)
+							socket.emit('call', msg);
+				} else {
+					for (let member of (
+						await db.query('select user from member where member.thread = ?', this.id)
+					).rows) {
+						member = vybe.users[member.user];
+						if (member)
+							for (let socket of member.sockets)
+								socket.emit('call', msg);
+					}
+				}
+			}
+		};
+		vybe.calls[thread.id] = {};
+	}
+})();
+
 async function create_thread(msg, respond) {
 	// validate inputs
 	if (typeof msg.name !== 'string')
@@ -19,7 +55,7 @@ async function create_thread(msg, respond) {
 			success: false,
 			message: 'invalid members'
 		});
-	if (msg.members.find(m => m.id == msg.auth_user.id)?.permissions?.admin !== 'true')
+	if (msg.members.find(m => m.id == msg.auth_user.id)?.permissions?.admin !== true)
 		return respond({
 			success: false,
 			message: 'creator missing admin permission'
@@ -78,12 +114,13 @@ async function create_thread(msg, respond) {
 				await db.query(`
 					insert into permission (thread, type, user, mutable, permission, value)
 					values (?, ?, ?, ?, ?, ?)`,
-					[thread_id, 'user', id, true, permission, member.permissions[permission]]);
+					[thread_id, 'user', id, true, permission, String(member.permissions[permission])]);
 	}
-	let thread = {
+	let thread = vybe.threads[thread_id] = {
 		id: thread_id,
 		name: msg.name,
-		streams: []
+		streams: [],
+		call: {}
 	};
 	if (!msg.permissions?.view_limited) {
 		for (let id in vybe.users) {
@@ -137,7 +174,7 @@ async function list_threads(msg, respond) {
 		msg.auth_user.id
 	);
 	threads = await Promise.all(threads.rows.map(async thread => {
-		thread.streams = vybe.threads[thread.id]?.streams || [];
+		Object.assign(thread, vybe.threads[thread.id]);
 		thread.permissions = await check_permission(msg.auth_user.id, thread.id);
 		return thread;
 	}));
@@ -161,27 +198,22 @@ async function get_thread(msg, respond) {
 			message: "you can't view this thread"
 		});
 	}
-	let thread = await db.query(
-		`select thread.name, member.user, user.name as username,
+	let members = Object.fromEntries((await db.query(
+		`select member.user as id, user.name,
 			coalesce(user.displayname, user.name) as displayname
 		from thread
 		left join member on thread.id = member.thread
 		left join user on user.id = member.user
 		where thread.id = ?`,
 		msg.thread
-	);
+	)).rows.map(member =>
+		[member.id, member]
+	));
 	const permissions = await db.query(
 		`select type, user, permission, value, mutable
 		from permission where thread = ?`,
 		msg.thread
 	);
-	let members = Object.fromEntries(thread.rows.map(member =>
-		[member.user, {
-			id: member.user,
-			name: member.username,
-			displayname: member.displayname
-		}]
-	));
 	for (let permission of permissions.rows) {
 		const member = members[permission.user];
 		if (member)
@@ -210,16 +242,13 @@ async function get_thread(msg, respond) {
 	makeBool('everyone', 'post', false);
 	makeBool('members', 'view', true);
 	makeBool('members', 'post', true);
-	thread = {
-		id: msg.thread,
-		name: thread.rows[0].name,
-		permissions: perms,
-		members: Object.values(members),
-		streams: vybe.threads[msg.thread]?.streams || []
-	};
 	return respond({
 		success: true,
-		thread
+		thread: {
+			...vybe.threads[msg.thread],
+			permissions: perms,
+			members: Object.values(members)
+		}
 	});
 }
 
@@ -244,11 +273,13 @@ async function edit_thread(msg, respond) {
 			message: "user doesn't have permission"
 		});
 	}
+	let thread = vybe.threads[msg.id];
 	// update name
 	await db.query(
 		'update thread set name = ? where id = ?',
 		[msg.name, msg.id]
 	);
+	thread.name = msg.name;
 	// update permissions
 	let permissions = {};
 	for (const p of (await db.query(
@@ -333,11 +364,6 @@ async function edit_thread(msg, respond) {
 			where thread.id = ?`,
 			msg.id
 		)).rows.map(row => [row.user, true]));
-	let thread = {
-		id: msg.id,
-		name: msg.name,
-		streams: vybe.threads[msg.id]?.streams || []
-	};
 	if (!msg.permissions?.view_limited) {
 		for (let id in vybe.users)
 			for (let socket of vybe.users[id].sockets)
@@ -368,9 +394,7 @@ async function edit_thread(msg, respond) {
 				});
 		}
 	}
-	return respond({
-		success: true
-	});
+	return respond({ success: true });
 }
 
 async function add_member(msg, respond) {