438 lines
17 KiB
JavaScript
438 lines
17 KiB
JavaScript
"use strict";
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
const express_1 = __importDefault(require("express"));
|
|
const cors_1 = __importDefault(require("cors"));
|
|
const http_1 = require("http");
|
|
const ws_1 = require("ws");
|
|
const uuid_1 = require("uuid");
|
|
const app = (0, express_1.default)();
|
|
const PORT = process.env.PORT || 3001;
|
|
app.use((0, cors_1.default)());
|
|
app.use(express_1.default.json());
|
|
const connectedUsers = new Map();
|
|
// Database
|
|
const crypto_1 = __importDefault(require("crypto"));
|
|
const db_1 = require("./db");
|
|
function hashPassword(pw) { return crypto_1.default.createHash('sha256').update(pw).digest('hex'); }
|
|
// REST API Routes
|
|
// Health check endpoint
|
|
app.get('/api/health', async (req, res) => {
|
|
const allServers = await (0, db_1.getAllPublicServers)();
|
|
res.json({
|
|
status: 'ok',
|
|
timestamp: Date.now(),
|
|
serverCount: allServers.length,
|
|
connectedUsers: connectedUsers.size,
|
|
});
|
|
});
|
|
// Time endpoint for clock synchronization
|
|
app.get('/api/time', (req, res) => {
|
|
res.json({ now: Date.now() });
|
|
});
|
|
// Image proxy to allow rendering external images within CSP (img-src 'self' data: blob:)
|
|
app.get('/api/image-proxy', async (req, res) => {
|
|
try {
|
|
const url = String(req.query.url || '');
|
|
if (!/^https?:\/\//i.test(url)) {
|
|
return res.status(400).json({ error: 'Invalid URL' });
|
|
}
|
|
const controller = new AbortController();
|
|
const timeout = setTimeout(() => controller.abort(), 8000);
|
|
const response = await fetch(url, { redirect: 'follow', signal: controller.signal });
|
|
clearTimeout(timeout);
|
|
if (!response.ok) {
|
|
return res.status(response.status).end();
|
|
}
|
|
const contentType = response.headers.get('content-type') || '';
|
|
if (!contentType.toLowerCase().startsWith('image/')) {
|
|
return res.status(415).json({ error: 'Unsupported content type' });
|
|
}
|
|
const arrayBuffer = await response.arrayBuffer();
|
|
const MAX_BYTES = 8 * 1024 * 1024; // 8MB limit
|
|
if (arrayBuffer.byteLength > MAX_BYTES) {
|
|
return res.status(413).json({ error: 'Image too large' });
|
|
}
|
|
res.setHeader('Content-Type', contentType);
|
|
res.setHeader('Cache-Control', 'public, max-age=3600');
|
|
res.send(Buffer.from(arrayBuffer));
|
|
}
|
|
catch (err) {
|
|
if (err?.name === 'AbortError') {
|
|
return res.status(504).json({ error: 'Timeout fetching image' });
|
|
}
|
|
console.error('Image proxy error:', err);
|
|
res.status(502).json({ error: 'Failed to fetch image' });
|
|
}
|
|
});
|
|
// Auth
|
|
app.post('/api/users/register', async (req, res) => {
|
|
const { username, password, displayName } = req.body;
|
|
if (!username || !password)
|
|
return res.status(400).json({ error: 'Missing username/password' });
|
|
const exists = await (0, db_1.getUserByUsername)(username);
|
|
if (exists)
|
|
return res.status(409).json({ error: 'Username taken' });
|
|
const user = { id: (0, uuid_1.v4)(), username, passwordHash: hashPassword(password), displayName: displayName || username, createdAt: Date.now() };
|
|
await (0, db_1.createUser)(user);
|
|
res.status(201).json({ id: user.id, username: user.username, displayName: user.displayName });
|
|
});
|
|
app.post('/api/users/login', async (req, res) => {
|
|
const { username, password } = req.body;
|
|
const user = await (0, db_1.getUserByUsername)(username);
|
|
if (!user || user.passwordHash !== hashPassword(password))
|
|
return res.status(401).json({ error: 'Invalid credentials' });
|
|
res.json({ id: user.id, username: user.username, displayName: user.displayName });
|
|
});
|
|
// Search servers
|
|
app.get('/api/servers', async (req, res) => {
|
|
const { q, tags, limit = 20, offset = 0 } = req.query;
|
|
let results = await (0, db_1.getAllPublicServers)();
|
|
results = results
|
|
.filter(s => {
|
|
if (q) {
|
|
const query = String(q).toLowerCase();
|
|
return s.name.toLowerCase().includes(query) ||
|
|
s.description?.toLowerCase().includes(query);
|
|
}
|
|
return true;
|
|
})
|
|
.filter(s => {
|
|
if (tags) {
|
|
const tagList = String(tags).split(',');
|
|
return tagList.some(t => s.tags.includes(t));
|
|
}
|
|
return true;
|
|
});
|
|
const total = results.length;
|
|
results = results.slice(Number(offset), Number(offset) + Number(limit));
|
|
res.json({ servers: results, total, limit: Number(limit), offset: Number(offset) });
|
|
});
|
|
// Register a server
|
|
app.post('/api/servers', async (req, res) => {
|
|
const { id: clientId, name, description, ownerId, ownerPublicKey, isPrivate, maxUsers, tags } = req.body;
|
|
if (!name || !ownerId || !ownerPublicKey) {
|
|
return res.status(400).json({ error: 'Missing required fields' });
|
|
}
|
|
const id = clientId || (0, uuid_1.v4)();
|
|
const server = {
|
|
id,
|
|
name,
|
|
description,
|
|
ownerId,
|
|
ownerPublicKey,
|
|
isPrivate: isPrivate ?? false,
|
|
maxUsers: maxUsers ?? 0,
|
|
currentUsers: 0,
|
|
tags: tags ?? [],
|
|
createdAt: Date.now(),
|
|
lastSeen: Date.now(),
|
|
};
|
|
await (0, db_1.upsertServer)(server);
|
|
res.status(201).json(server);
|
|
});
|
|
// Update server
|
|
app.put('/api/servers/:id', async (req, res) => {
|
|
const { id } = req.params;
|
|
const { ownerId, ...updates } = req.body;
|
|
const server = await (0, db_1.getServerById)(id);
|
|
if (!server) {
|
|
return res.status(404).json({ error: 'Server not found' });
|
|
}
|
|
if (server.ownerId !== ownerId) {
|
|
return res.status(403).json({ error: 'Not authorized' });
|
|
}
|
|
const updated = { ...server, ...updates, lastSeen: Date.now() };
|
|
await (0, db_1.upsertServer)(updated);
|
|
res.json(updated);
|
|
});
|
|
// Heartbeat - keep server alive
|
|
app.post('/api/servers/:id/heartbeat', async (req, res) => {
|
|
const { id } = req.params;
|
|
const { currentUsers } = req.body;
|
|
const server = await (0, db_1.getServerById)(id);
|
|
if (!server) {
|
|
return res.status(404).json({ error: 'Server not found' });
|
|
}
|
|
server.lastSeen = Date.now();
|
|
if (typeof currentUsers === 'number') {
|
|
server.currentUsers = currentUsers;
|
|
}
|
|
await (0, db_1.upsertServer)(server);
|
|
res.json({ ok: true });
|
|
});
|
|
// Remove server
|
|
app.delete('/api/servers/:id', async (req, res) => {
|
|
const { id } = req.params;
|
|
const { ownerId } = req.body;
|
|
const server = await (0, db_1.getServerById)(id);
|
|
if (!server) {
|
|
return res.status(404).json({ error: 'Server not found' });
|
|
}
|
|
if (server.ownerId !== ownerId) {
|
|
return res.status(403).json({ error: 'Not authorized' });
|
|
}
|
|
await (0, db_1.deleteServer)(id);
|
|
res.json({ ok: true });
|
|
});
|
|
// Request to join a server
|
|
app.post('/api/servers/:id/join', async (req, res) => {
|
|
const { id: serverId } = req.params;
|
|
const { userId, userPublicKey, displayName } = req.body;
|
|
const server = await (0, db_1.getServerById)(serverId);
|
|
if (!server) {
|
|
return res.status(404).json({ error: 'Server not found' });
|
|
}
|
|
const requestId = (0, uuid_1.v4)();
|
|
const request = {
|
|
id: requestId,
|
|
serverId,
|
|
userId,
|
|
userPublicKey,
|
|
displayName,
|
|
status: server.isPrivate ? 'pending' : 'approved',
|
|
createdAt: Date.now(),
|
|
};
|
|
await (0, db_1.createJoinRequest)(request);
|
|
// Notify server owner via WebSocket
|
|
if (server.isPrivate) {
|
|
notifyServerOwner(server.ownerId, {
|
|
type: 'join_request',
|
|
request,
|
|
});
|
|
}
|
|
res.status(201).json(request);
|
|
});
|
|
// Get join requests for a server
|
|
app.get('/api/servers/:id/requests', async (req, res) => {
|
|
const { id: serverId } = req.params;
|
|
const { ownerId } = req.query;
|
|
const server = await (0, db_1.getServerById)(serverId);
|
|
if (!server) {
|
|
return res.status(404).json({ error: 'Server not found' });
|
|
}
|
|
if (server.ownerId !== ownerId) {
|
|
return res.status(403).json({ error: 'Not authorized' });
|
|
}
|
|
const requests = await (0, db_1.getPendingRequestsForServer)(serverId);
|
|
res.json({ requests });
|
|
});
|
|
// Approve/reject join request
|
|
app.put('/api/requests/:id', async (req, res) => {
|
|
const { id } = req.params;
|
|
const { ownerId, status } = req.body;
|
|
const request = await (0, db_1.getJoinRequestById)(id);
|
|
if (!request) {
|
|
return res.status(404).json({ error: 'Request not found' });
|
|
}
|
|
const server = await (0, db_1.getServerById)(request.serverId);
|
|
if (!server || server.ownerId !== ownerId) {
|
|
return res.status(403).json({ error: 'Not authorized' });
|
|
}
|
|
await (0, db_1.updateJoinRequestStatus)(id, status);
|
|
const updated = { ...request, status };
|
|
// Notify the requester
|
|
notifyUser(request.userId, {
|
|
type: 'request_update',
|
|
request: updated,
|
|
});
|
|
res.json(updated);
|
|
});
|
|
// WebSocket Server for real-time signaling
|
|
const server = (0, http_1.createServer)(app);
|
|
const wss = new ws_1.WebSocketServer({ server });
|
|
wss.on('connection', (ws) => {
|
|
const connectionId = (0, uuid_1.v4)();
|
|
connectedUsers.set(connectionId, { oderId: connectionId, ws, serverIds: new Set() });
|
|
ws.on('message', (data) => {
|
|
try {
|
|
const message = JSON.parse(data.toString());
|
|
handleWebSocketMessage(connectionId, message);
|
|
}
|
|
catch (err) {
|
|
console.error('Invalid WebSocket message:', err);
|
|
}
|
|
});
|
|
ws.on('close', () => {
|
|
const user = connectedUsers.get(connectionId);
|
|
if (user) {
|
|
// Notify all servers the user was a member of
|
|
user.serverIds.forEach((sid) => {
|
|
broadcastToServer(sid, {
|
|
type: 'user_left',
|
|
oderId: user.oderId,
|
|
displayName: user.displayName,
|
|
serverId: sid,
|
|
}, user.oderId);
|
|
});
|
|
}
|
|
connectedUsers.delete(connectionId);
|
|
});
|
|
// Send connection acknowledgment with the connectionId (client will identify with their actual oderId)
|
|
ws.send(JSON.stringify({ type: 'connected', connectionId, serverTime: Date.now() }));
|
|
});
|
|
function handleWebSocketMessage(connectionId, message) {
|
|
const user = connectedUsers.get(connectionId);
|
|
if (!user)
|
|
return;
|
|
switch (message.type) {
|
|
case 'identify':
|
|
// User identifies themselves with their permanent ID
|
|
// Store their actual oderId for peer-to-peer routing
|
|
user.oderId = message.oderId || connectionId;
|
|
user.displayName = message.displayName || 'Anonymous';
|
|
connectedUsers.set(connectionId, user);
|
|
console.log(`User identified: ${user.displayName} (${user.oderId})`);
|
|
break;
|
|
case 'join_server': {
|
|
const sid = message.serverId;
|
|
const isNew = !user.serverIds.has(sid);
|
|
user.serverIds.add(sid);
|
|
user.viewedServerId = sid;
|
|
connectedUsers.set(connectionId, user);
|
|
console.log(`User ${user.displayName || 'Anonymous'} (${user.oderId}) joined server ${sid} (new=${isNew})`);
|
|
// Always send the current user list for this server
|
|
const usersInServer = Array.from(connectedUsers.values())
|
|
.filter(u => u.serverIds.has(sid) && u.oderId !== user.oderId && u.displayName)
|
|
.map(u => ({ oderId: u.oderId, displayName: u.displayName || 'Anonymous' }));
|
|
console.log(`Sending server_users to ${user.displayName || 'Anonymous'}:`, usersInServer);
|
|
user.ws.send(JSON.stringify({
|
|
type: 'server_users',
|
|
serverId: sid,
|
|
users: usersInServer,
|
|
}));
|
|
// Only broadcast user_joined if this is a brand-new join (not a re-view)
|
|
if (isNew) {
|
|
broadcastToServer(sid, {
|
|
type: 'user_joined',
|
|
oderId: user.oderId,
|
|
displayName: user.displayName || 'Anonymous',
|
|
serverId: sid,
|
|
}, user.oderId);
|
|
}
|
|
break;
|
|
}
|
|
case 'view_server': {
|
|
// Just switch the viewed server without joining/leaving
|
|
const viewSid = message.serverId;
|
|
user.viewedServerId = viewSid;
|
|
connectedUsers.set(connectionId, user);
|
|
console.log(`User ${user.displayName || 'Anonymous'} (${user.oderId}) viewing server ${viewSid}`);
|
|
// Send current user list for the viewed server
|
|
const viewUsers = Array.from(connectedUsers.values())
|
|
.filter(u => u.serverIds.has(viewSid) && u.oderId !== user.oderId && u.displayName)
|
|
.map(u => ({ oderId: u.oderId, displayName: u.displayName || 'Anonymous' }));
|
|
user.ws.send(JSON.stringify({
|
|
type: 'server_users',
|
|
serverId: viewSid,
|
|
users: viewUsers,
|
|
}));
|
|
break;
|
|
}
|
|
case 'leave_server': {
|
|
const leaveSid = message.serverId || user.viewedServerId;
|
|
if (leaveSid) {
|
|
user.serverIds.delete(leaveSid);
|
|
if (user.viewedServerId === leaveSid) {
|
|
user.viewedServerId = undefined;
|
|
}
|
|
connectedUsers.set(connectionId, user);
|
|
broadcastToServer(leaveSid, {
|
|
type: 'user_left',
|
|
oderId: user.oderId,
|
|
displayName: user.displayName || 'Anonymous',
|
|
serverId: leaveSid,
|
|
}, user.oderId);
|
|
}
|
|
break;
|
|
}
|
|
case 'offer':
|
|
case 'answer':
|
|
case 'ice_candidate':
|
|
// Forward signaling messages to specific peer
|
|
console.log(`Forwarding ${message.type} from ${user.oderId} to ${message.targetUserId}`);
|
|
const targetUser = findUserByUserId(message.targetUserId);
|
|
if (targetUser) {
|
|
targetUser.ws.send(JSON.stringify({
|
|
...message,
|
|
fromUserId: user.oderId,
|
|
}));
|
|
console.log(`Successfully forwarded ${message.type} to ${message.targetUserId}`);
|
|
}
|
|
else {
|
|
console.log(`Target user ${message.targetUserId} not found. Connected users:`, Array.from(connectedUsers.values()).map(u => ({ oderId: u.oderId, displayName: u.displayName })));
|
|
}
|
|
break;
|
|
case 'chat_message': {
|
|
// Broadcast chat message to all users in the server
|
|
const chatSid = message.serverId || user.viewedServerId;
|
|
if (chatSid && user.serverIds.has(chatSid)) {
|
|
broadcastToServer(chatSid, {
|
|
type: 'chat_message',
|
|
serverId: chatSid,
|
|
message: message.message,
|
|
senderId: user.oderId,
|
|
senderName: user.displayName,
|
|
timestamp: Date.now(),
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
case 'typing': {
|
|
// Broadcast typing indicator
|
|
const typingSid = message.serverId || user.viewedServerId;
|
|
if (typingSid && user.serverIds.has(typingSid)) {
|
|
broadcastToServer(typingSid, {
|
|
type: 'user_typing',
|
|
serverId: typingSid,
|
|
oderId: user.oderId,
|
|
displayName: user.displayName,
|
|
}, user.oderId);
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
console.log('Unknown message type:', message.type);
|
|
}
|
|
}
|
|
function broadcastToServer(serverId, message, excludeOderId) {
|
|
console.log(`Broadcasting to server ${serverId}, excluding ${excludeOderId}:`, message.type);
|
|
connectedUsers.forEach((user) => {
|
|
if (user.serverIds.has(serverId) && user.oderId !== excludeOderId) {
|
|
console.log(` -> Sending to ${user.displayName} (${user.oderId})`);
|
|
user.ws.send(JSON.stringify(message));
|
|
}
|
|
});
|
|
}
|
|
function notifyServerOwner(ownerId, message) {
|
|
const owner = findUserByUserId(ownerId);
|
|
if (owner) {
|
|
owner.ws.send(JSON.stringify(message));
|
|
}
|
|
}
|
|
function notifyUser(oderId, message) {
|
|
const user = findUserByUserId(oderId);
|
|
if (user) {
|
|
user.ws.send(JSON.stringify(message));
|
|
}
|
|
}
|
|
function findUserByUserId(oderId) {
|
|
return Array.from(connectedUsers.values()).find(u => u.oderId === oderId);
|
|
}
|
|
// Cleanup stale join requests periodically (older than 24 h)
|
|
setInterval(() => {
|
|
(0, db_1.deleteStaleJoinRequests)(24 * 60 * 60 * 1000).catch(err => console.error('Failed to clean up stale join requests:', err));
|
|
}, 60 * 1000);
|
|
(0, db_1.initDB)().then(() => {
|
|
server.listen(PORT, () => {
|
|
console.log(`🚀 MetoYou signaling server running on port ${PORT}`);
|
|
console.log(` REST API: http://localhost:${PORT}/api`);
|
|
console.log(` WebSocket: ws://localhost:${PORT}`);
|
|
});
|
|
}).catch((err) => {
|
|
console.error('Failed to initialize database:', err);
|
|
process.exit(1);
|
|
});
|
|
//# sourceMappingURL=index.js.map
|