Migrate from 100ms

import jwt from 'jsonwebtoken';
import { randomUUID } from 'node:crypto';
 
const now = Math.floor(Date.now() / 1000);
const token = jwt.sign(
  {
    access_key: process.env.HMS_ACCESS_KEY,
    room_id: roomId,
    user_id: user.id,
    role: 'host',
    type: 'app',
    version: 2,
    iat: now,
    nbf: now,
  },
  process.env.HMS_APP_SECRET,
  { algorithm: 'HS256', expiresIn: '24h', jwtid: randomUUID() },
);

import time, uuid
import jwt  # PyJWT
 
now = int(time.time())
token = jwt.encode(
    {
        "access_key": hms_access_key, "room_id": room_id, "user_id": user_id,
        "role": "host", "type": "app", "version": 2,
        "iat": now, "nbf": now, "exp": now + 86400, "jti": str(uuid.uuid4()),
    },
    hms_app_secret,
    algorithm="HS256",
)

import { Livqeno } from '@livqeno/server';
 
const livqeno = new Livqeno({ apiKey: process.env.LIVQENO_API_KEY, baseUrl: process.env.LIVQENO_API_URL });
 
// What a 100ms role allowed now lives in the token.
const ROLES = {
  host: { join: true, subscribe: true, publish: true, publishData: true },
  guest: { join: true, subscribe: true, publish: true, publishAudio: true, publishVideo: false },
  viewer: { join: true, subscribe: true },
};
 
const room = await livqeno.rooms.create({ name: roomName, getOrCreate: true });
const grant = await livqeno.tokens.create({
  room: room.id,
  identity: user.id,
  permissions: ROLES.host,
  expiresIn: 3600,
});
res.json(grant); // forward the whole grant: token, endpoint, iceServers

import os
from livqeno import Livqeno, CreateTokenParams, TokenPermissions
 
livqeno = Livqeno(api_key=os.environ["LIVQENO_API_KEY"], base_url=os.environ["LIVQENO_API_URL"])
 
room = livqeno.rooms.create(room_name, get_or_create=True)
grant = livqeno.tokens.create(
    CreateTokenParams(
        room=room["id"],
        identity=user_id,
        permissions=TokenPermissions(join=True, subscribe=True, publish=True, publish_data=True),
        expires_in=3600,
    )
)

client := livqeno.New(os.Getenv("LIVQENO_API_KEY"), livqeno.WithBaseURL(os.Getenv("LIVQENO_API_URL")))
 
room, err := client.Rooms.Create(ctx, livqeno.CreateRoomParams{Name: roomName, GetOrCreate: true})
if err != nil {
	return err
}
grant, err := client.Tokens.Create(ctx, livqeno.CreateTokenParams{
	Room:     room.ID,
	Identity: userID,
	Permissions: &livqeno.TokenPermissions{
		Join: livqeno.Bool(true), Subscribe: livqeno.Bool(true),
		Publish: livqeno.Bool(true), PublishData: livqeno.Bool(true),
	},
	ExpiresIn: 3600,
})

import com.livqeno.server.model.*;
 
Room room = livqeno.rooms().create(CreateRoomParams.builder().name(roomName).getOrCreate(true).build());
 
IssuedToken grant = livqeno.tokens().create(CreateTokenParams.builder()
        .room(room.id())
        .identity(userId)
        .permissions(TokenPermissions.builder().join(true).subscribe(true).publish(true).publishData(true).build())
        .expiresIn(3600)
        .build());

$room = $client->rooms->create(['name' => $roomName, 'getOrCreate' => true]);
 
$grant = $client->tokens->create([
    'room' => $room->id,
    'identity' => $userId,
    'permissions' => ['join' => true, 'subscribe' => true, 'publish' => true, 'publishData' => true],
    'expiresIn' => 3600,
]);

import { HMSReactiveStore, selectPeers } from '@100mslive/hms-video-store';
 
const hms = new HMSReactiveStore();
hms.triggerOnSubscribe();
const hmsActions = hms.getActions();
const hmsStore = hms.getStore();
 
await hmsActions.join({ userName: 'Alice', authToken: token });
 
hmsStore.subscribe((peers) => {
  for (const peer of peers) {
    if (peer.videoTrack) hmsActions.attachVideo(peer.videoTrack, videoElementFor(peer.id));
  }
}, selectPeers);

import { createRTCClient } from '@livqeno/rtc';
 
const grant = await fetch('/join-room', { method: 'POST' }).then((r) => r.json());
const client = createRTCClient(grant); // reads token, endpoint and iceServers
const room = await client.join(); // the room comes from the token
 
// Audio and video both arrive here; attach() returns an autoplaying element.
room.on('trackSubscribed', (track, participant) => {
  const el = track.attach();
  el.dataset.identity = participant.identity;
  grid.appendChild(el);
});
room.on('trackUnsubscribed', (track) => track.detach().forEach((el) => el.remove()));
 
await room.enableCamera();
await room.enableMicrophone();

await hmsActions.setLocalAudioEnabled(false);
await hmsActions.setLocalAudioEnabled(true);

const mic = await room.enableMicrophone();
await mic?.mute();
await mic?.unmute();

await hmsActions.setScreenShareEnabled(true);
await hmsActions.setScreenShareEnabled(false);

await room.enableScreenShare();
await room.disableScreenShare();

await hmsActions.sendBroadcastMessage('hello');
// Also: sendDirectMessage(message, peerId), sendGroupMessage(message, roles)

await room.sendData(JSON.stringify({ type: 'chat', text: 'hello' }));
 
room.on('dataReceived', (payload, participant) => {
  console.log(participant?.identity, new TextDecoder().decode(payload));
});

import { createChatClient } from '@livqeno/chat';
 
const chat = createChatClient(chatGrant); // from livqeno.chat.createToken() on your backend
await chat.connect({ room: conversationId });
 
chat.on('message', (message) => console.log(message.senderId, message.text));
await chat.sendMessage({ text: 'hello' });

// Browser-composite recording and/or RTMP out, started from the client
await hmsActions.startRTMPOrRecording({
  meetingURL,
  rtmpURLs: [`rtmp://a.rtmp.youtube.com/live2/${youtubeKey}`],
  record: true,
});
await hmsActions.stopRTMPAndRecording();
 
// HLS for a large audience
await hmsActions.startHLSStreaming();
await hmsActions.stopHLSStreaming();

// Backend only. A live stream owns its room; BROADCAST adds HLS for viewers
// and an HLS replay when it ends (live_stream.recording_ready webhook).
const stream = await livqeno.liveStreams.create({
  title: 'Town hall',
  hostIdentity: 'host-1',
  deliveryMode: 'BROADCAST',
});
const hostGrant = await livqeno.liveStreams.addHost(stream.id, { identity: 'host-1' });
await livqeno.liveStreams.start(stream.id);
 
await livqeno.liveStreams.restreams.create(stream.id, {
  url: 'rtmps://a.rtmp.youtube.com/live2', // URL and key are separate fields
  streamKey: process.env.YOUTUBE_STREAM_KEY!,
  label: 'YouTube',
});
 
// Viewers: livqeno.liveStreams.createViewerToken(stream.id, identity, { acceptPlayback: true })
await livqeno.liveStreams.end(stream.id);

import os
from livqeno import CreateLiveStreamParams, AddHostParams, CreateRestreamParams
 
stream = livqeno.live_streams.create(
    CreateLiveStreamParams(title="Town hall", host_identity="host-1", delivery_mode="BROADCAST")
)
host_grant = livqeno.live_streams.add_host(stream["id"], AddHostParams(identity="host-1"))
livqeno.live_streams.start(stream["id"])
 
livqeno.live_streams.restreams.create(
    stream["id"],
    CreateRestreamParams(
        url="rtmps://a.rtmp.youtube.com/live2",
        stream_key=os.environ["YOUTUBE_STREAM_KEY"],
        label="YouTube",
    ),
)

// 100ms sends the custom headers you configure in its dashboard with each
// webhook; you check them yourself (check their docs for the current options).
if (req.get('x-webhook-secret') !== process.env.HMS_WEBHOOK_SECRET) return res.sendStatus(401);
const { type, data } = req.body;
if (type === 'peer.join.success') {
  // data.room_id, data.user_id
}

import { createHmac, timingSafeEqual } from 'node:crypto';
 
// Signed with HMAC-SHA256 over `<t>.<raw body>`. Use the RAW body.
function verify(rawBody: string, header: string, secret: string): boolean {
  const parts = Object.fromEntries(header.split(',').map((p) => p.trim().split('=')));
  if (Math.abs(Date.now() / 1000 - Number(parts.t)) > 300) return false;
  const expected = createHmac('sha256', secret).update(`${parts.t}.${rawBody}`).digest('hex');
  const a = Buffer.from(parts.v1 ?? '');
  const b = Buffer.from(expected);
  return a.length === b.length && timingSafeEqual(a, b);
}
 
if (!verify(rawBody, req.get('Swalvo-Signature') ?? '', process.env.LIVQENO_WEBHOOK_SECRET!)) {
  return res.sendStatus(400);
}
const event = JSON.parse(rawBody);
if (event.type === 'room.participant_joined') {
  // event.data: { roomId, identity, connectionId, at }
}

import hashlib, hmac, time
 
def verify(raw_body: bytes, header: str, secret: str) -> bool:
    parts = dict(p.strip().split("=", 1) for p in header.split(",") if "=" in p)
    t = parts.get("t", "")
    if not t.isdigit() or abs(time.time() - int(t)) > 300:
        return False
    expected = hmac.new(secret.encode(), t.encode() + b"." + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(parts.get("v1", ""), expected)

use Livqeno\LivqenoException;
use Livqeno\Webhook;
 
$webhook = new Webhook(getenv('LIVQENO_WEBHOOK_SECRET'));
try {
    $event = $webhook->constructEvent(file_get_contents('php://input'), $_SERVER['HTTP_LIVQENO_SIGNATURE'] ?? null);
} catch (LivqenoException $e) {
    http_response_code(400);
    exit;
}