Janus and Jitsi

FROM debian:trixie-slim AS build
RUN apt-get update && apt-get install -y --no-install-recommends \
    build-essential autoconf automake libtool pkg-config git ca-certificates gengetopt \
    libmicrohttpd-dev libjansson-dev libssl-dev libsrtp2-dev libsofia-sip-ua-dev \
    libglib2.0-dev libopus-dev libogg-dev libcurl4-openssl-dev liblua5.3-dev \
    libconfig-dev libnice-dev libwebsockets-dev libusrsctp-dev \
 && rm -rf /var/lib/apt/lists/*
RUN git clone --depth 1 --branch v1.4.3 https://github.com/meetecho/janus-gateway.git /src
WORKDIR /src
RUN sh autogen.sh \
 && ./configure --prefix=/opt/janus --enable-websockets --enable-data-channels \
 && make -j4 && make install && make configs

FROM debian:trixie-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
    libmicrohttpd12t64 libjansson4 libssl3t64 libsrtp2-1 libsofia-sip-ua0t64 \
    libglib2.0-0t64 libopus0 libogg0 libcurl4t64 liblua5.3-0 libconfig11 \
    libnice10 libwebsockets19t64 libusrsctp2 curl ca-certificates \
 && rm -rf /var/lib/apt/lists/*
COPY --from=build /opt/janus /opt/janus
EXPOSE 8088 8188
CMD ["/opt/janus/bin/janus", "-F", "/opt/janus/etc/janus"]

docker build -t huddle-janus:1.4.3 .
docker run -d --name huddle-janus -p 8088:8088 -p 8188:8188 huddle-janus:1.4.3
curl -s http://localhost:8088/janus/info

// Huddle: drive Janus's VideoRoom over the plain HTTP REST transport.
const BASE = process.env.JANUS_URL ?? 'http://localhost:8088/janus';
let n = 0;
const tx = () => `huddle-${++n}`;

async function post(path, body) {
  const res = await fetch(BASE + path, {
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify({ transaction: tx(), ...body }),
  });
  const json = await res.json();
  if (json.janus === 'error') throw new Error(`${json.error.code}: ${json.error.reason}`);
  return json;
}

// Asynchronous plugin events arrive through a long poll on the session.
async function nextEvent(session) {
  const res = await fetch(`${BASE}/${session}?maxev=1`);
  const events = await res.json();
  return Array.isArray(events) ? events[0] : events;
}

const info = await (await fetch(`${BASE}/info`)).json();
console.log('server', info.version_string, Object.keys(info.plugins).length, 'plugins');

const session = (await post('', { janus: 'create' })).data.id;
const handle = (await post(`/${session}`, { janus: 'attach', plugin: 'janus.plugin.videoroom' })).data.id;

// Synchronous request: the answer is in the HTTP response itself.
const created = await post(`/${session}/${handle}`, {
  janus: 'message',
  body: { request: 'create', description: 'Huddle standup', publishers: 8, is_private: false },
});
const room = created.plugindata.data.room;
console.log('created room', room);

const list = await post(`/${session}/${handle}`, { janus: 'message', body: { request: 'list' } });
console.log('rooms', list.plugindata.data.list.map((r) => `${r.room}:${r.description}`).join(', '));

// Asynchronous request: HTTP answers "ack", the result comes from the long poll.
const ack = await post(`/${session}/${handle}`, {
  janus: 'message',
  body: { request: 'join', ptype: 'publisher', room, display: 'Ada' },
});
console.log('join ack:', ack.janus);
let ev;
do { ev = await nextEvent(session); } while (ev.janus === 'keepalive');
console.log('event:', ev.janus, ev.plugindata.data.videoroom, 'publisher id', ev.plugindata.data.id);

await post(`/${session}`, { janus: 'keepalive' });
await post(`/${session}/${handle}`, { janus: 'detach' });
await post(`/${session}`, { janus: 'destroy' });
console.log('session destroyed');

// Pixel Arena lobby: the same Janus API over the WebSocket transport (subprotocol janus-protocol).
const ws = new WebSocket(process.env.JANUS_WS ?? 'ws://localhost:8188', 'janus-protocol');
const pending = new Map();
ws.onmessage = (m) => {
  const msg = JSON.parse(m.data);
  const resolve = pending.get(msg.transaction);
  if (resolve && msg.janus !== 'ack') { pending.delete(msg.transaction); resolve(msg); }
  else if (!msg.transaction) console.log('async:', msg.janus);
};
let n = 0;
const send = (obj) => new Promise((resolve) => {
  const transaction = `arena-${++n}`;
  pending.set(transaction, resolve);
  ws.send(JSON.stringify({ transaction, ...obj }));
});
await new Promise((r) => (ws.onopen = r));
console.log('subprotocol:', ws.protocol);
const session = (await send({ janus: 'create' })).data.id;
const handle = (await send({ janus: 'attach', session_id: session, plugin: 'janus.plugin.textroom' })).data.id;
const reply = await send({ janus: 'message', session_id: session, handle_id: handle, body: { request: 'list' } });
console.log('textroom list:', JSON.stringify(reply.plugindata.data));
await send({ janus: 'destroy', session_id: session });
ws.close();

import Janus from 'janus-gateway';
import adapter from 'webrtc-adapter';

let pub; // the publisher handle
const localVideo = document.querySelector('#local');

Janus.init({
  debug: 'warn',
  dependencies: Janus.useDefaultDependencies({ adapter }),
  callback: () => {
    const janus = new Janus({
      server: ['wss://janus.example.test/ws', 'https://janus.example.test/janus'], // try WebSocket, then HTTP
      success: () => janus.attach({
        plugin: 'janus.plugin.videoroom',
        success: (h) => {
          pub = h;
          pub.send({ message: { request: 'join', ptype: 'publisher', room: 1234, display: 'Ada' } });
        },
        onmessage: (msg, jsep) => {
          if (msg.videoroom === 'joined') {
            // Publish the camera and microphone as soon as we are in the room.
            pub.createOffer({
              tracks: [{ type: 'audio', capture: true }, { type: 'video', capture: true }],
              success: (offer) => pub.send({ message: { request: 'configure', audio: true, video: true }, jsep: offer }),
            });
          }
          if (jsep) pub.handleRemoteJsep({ jsep });
        },
        onlocaltrack: (track, on) => { if (on && track.kind === 'video') localVideo.srcObject = new MediaStream([track]); },
      }),
      error: (err) => console.error('janus', err),
    });
  },
});

wget $(wget -q -O - https://api.github.com/repos/jitsi/docker-jitsi-meet/releases/latest | grep zip | cut -d\" -f4)
unzip stable-11248-2.zip && cd docker-jitsi-meet-stable-11248-2   # use the file name you downloaded
cp env.example .env
./gen-passwords.sh                                                 # fills the internal component passwords

mkdir -p ~/.jitsi-meet-cfg/{web,prosody/config,prosody/prosody-plugins-custom,jicofo,jvb,jigasi,jibri,transcriber}
mkdir -p ~/.jitsi-meet-cfg/storage/{jibri,prosody,transcripts,web}
mkdir -p ~/.jitsi-meet-cfg/tmp/{web-crontabs,web-load-test}
chmod 777 ~/.jitsi-meet-cfg/storage/{jibri,prosody,transcripts,web}
chmod 777 ~/.jitsi-meet-cfg/tmp/{web-crontabs,web-load-test}

docker compose up -d
# open https://localhost:8443

# docker-compose.override.yml, next to the downloaded docker-compose.yml
services:
    prosody:
        volumes:
            - prosody-data:/var/lib/prosody
volumes:
    prosody-data:

<!doctype html>
<meta charset="utf-8">
<title>Huddle embedded in Jitsi</title>
<div id="meet" style="height:480px"></div>
<script src="https://localhost:8443/external_api.js"></script>
<script>
  const api = new JitsiMeetExternalAPI('localhost:8443', {
    roomName: 'huddle-standup-42',
    parentNode: document.querySelector('#meet'),
    userInfo: { displayName: 'Ada' },
    configOverwrite: { prejoinConfig: { enabled: false }, startWithAudioMuted: false },
    interfaceConfigOverwrite: { TOOLBAR_BUTTONS: ['microphone', 'camera', 'hangup', 'chat'] }
  });
  for (const name of ['videoConferenceJoined', 'participantJoined', 'audioMuteStatusChanged', 'readyToClose']) {
    api.addListener(name, (e) => console.log(name, e));
  }
  // Later: api.executeCommand('toggleAudio'); api.executeCommand('hangup');
</script>

<!doctype html>
<meta charset="utf-8">
<title>Huddle with lib-jitsi-meet</title>
<script src="https://localhost:8443/libs/lib-jitsi-meet.min.js"></script>
<script>
  async function main() {
    JitsiMeetJS.init({});
    const E = JitsiMeetJS.events;
    const connection = new JitsiMeetJS.JitsiConnection(null, null, {
      hosts: { domain: 'meet.jitsi', muc: 'muc.meet.jitsi' },
      serviceUrl: 'wss://localhost:8443/xmpp-websocket?room=huddle-ljm-7',
    });

    connection.addEventListener(E.connection.CONNECTION_ESTABLISHED, async () => {
      const room = connection.initJitsiConference('huddle-ljm-7', {});
      room.on(E.conference.CONFERENCE_JOINED, () => console.log('joined'));
      room.on(E.conference.TRACK_ADDED, (t) => console.log('track', t.getType(), t.isLocal() ? 'local' : 'remote'));
      room.on(E.conference.USER_JOINED, (id) => console.log('user', id));
      room.setDisplayName('Grace');
      const tracks = await JitsiMeetJS.createLocalTracks({ devices: ['audio', 'video'] });
      for (const t of tracks) room.addTrack(t);
      room.join();
    });
    connection.addEventListener(E.connection.CONNECTION_FAILED, () => console.log('failed'));
    connection.connect();
  }
  main();
</script>