Channel-Based Communication

if (data.type === "join") {
  const channelName = data.channel;
  
  // Create channel if it doesn't exist
  if (!channels.has(channelName)) {
    channels.set(channelName, new Set());
  }
  
  // Add client to channel
  const channelClients = channels.get(channelName)!;
  channelClients.add(ws);
  
  console.log(`✓ Client joined channel "${channelName}" (${channelClients.size} total clients)`);
  
  // Notify client of successful join
  ws.send(JSON.stringify({
    type: "system",
    message: `Joined channel: ${channelName}`,
    channel: channelName
  }));
}

// Store clients by channel
const channels = new Map<string, Set<ServerWebSocket<any>>>();

// Example state after clients join:
// channels = {
//   "my-project": Set { ws1, ws2 },
//   "design-team": Set { ws3, ws4, ws5 },
//   "prototype": Set { ws6 }
// }

if (data.type === "message") {
  const channelName = data.channel;
  const channelClients = channels.get(channelName);
  
  if (!channelClients || !channelClients.has(ws)) {
    ws.send(JSON.stringify({
      type: "error",
      message: "You must join the channel first"
    }));
    return;
  }
  
  // Broadcast to all OTHER clients in the channel (not the sender)
  let broadcastCount = 0;
  channelClients.forEach((client) => {
    if (client !== ws && client.readyState === WebSocket.OPEN) {
      broadcastCount++;
      client.send(JSON.stringify({
        type: "broadcast",
        message: data.message,
        sender: "peer",
        channel: channelName
      }));
    }
  });
  
  console.log(`✓ Broadcast to ${broadcastCount} peer(s) in channel "${channelName}"`);
}

ws.close = () => {
  console.log("Client disconnected");
  
  // Remove client from their channel
  channels.forEach((clients, channelName) => {
    if (clients.has(ws)) {
      clients.delete(ws);
      
      // Notify other clients in the channel
      clients.forEach((client) => {
        if (client.readyState === WebSocket.OPEN) {
          client.send(JSON.stringify({
            type: "system",
            message: "A user has left the channel",
            channel: channelName
          }));
        }
      });
    }
  });
};

// Track current channel
let currentChannel: string | null = null;

// Function to join a channel
async function joinChannel(channelName: string): Promise<void> {
  if (!ws || ws.readyState !== WebSocket.OPEN) {
    throw new Error("Not connected to Figma");
  }
  
  await sendCommandToFigma("join", { channel: channelName });
  currentChannel = channelName;
  logger.info(`Joined channel: ${channelName}`);
}

// Validate channel before sending commands
function sendCommandToFigma(
  command: FigmaCommand,
  params: unknown = {}
): Promise<unknown> {
  return new Promise((resolve, reject) => {
    // Check if we need a channel for this command
    const requiresChannel = command !== "join";
    if (requiresChannel && !currentChannel) {
      reject(new Error("Must join a channel before sending commands"));
      return;
    }
    
    const request = {
      id: uuidv4(),
      type: command === "join" ? "join" : "message",
      channel: command === "join" ? params.channel : currentChannel,
      message: { /* ... */ }
    };
    
    ws.send(JSON.stringify(request));
  });
}

// When a client disconnects
websocket: {
  close(ws: ServerWebSocket<any>) {
    // Remove client from all channels
    channels.forEach((clients) => {
      clients.delete(ws);
    });
    
    // Empty channels are kept in the Map
    // They'll be reused when new clients join
  }
}