OpenVidu Meet is a fully featured video conferencing application built with Angular, Node.js, and LiveKit. This repository provides both a Community Edition (CE) and a Professional Edition (PRO) with advanced features.

1. Architecture Overview
2. Prerequisites
3. Getting Started
4. Development
   • Development Mode
   • Manual Development Setup
5. Building
6. Testing
7. Documentation
8. Production Deployment
9. Project Structure
10. Using the meet.sh Script

The OpenVidu Meet application is a monorepo managed with pnpm workspaces and consists of multiple interconnected packages:

• Frontend (frontend/): Angular 20 application providing the user interface

  • shared-meet-components: Reusable Angular library with shared components for administration and preferences
  • Integrates openvidu-components-angular for core video conferencing functionality

• Backend (backend/): Node.js/TypeScript REST API server

  • Manages rooms, participants, recordings, and authentication
  • Serves the compiled frontend in production

• Typings (typings/): Shared TypeScript type definitions used across frontend and backend

• Webcomponent (frontend/webcomponent/): Standalone web component version of OpenVidu Meet

• TestApp (testapp/): Testing application for development and validation

Before starting, ensure you have the following installed:

• Node.js: Version 22 or higher
• pnpm: Package manager (will be installed automatically by meet.sh if missing)
• LiveKit: For local testing (optional)

  curl -sSL https://get.livekit.io/cli | bash

Set up your local development environment by cloning the necessary repositories into a shared folder. This ensures the openvidu-components-angular library is available for development and linking.

your-dev-folder/
├── openvidu/
│   └── openvidu-components-angular/  # Core Angular components library
└── openvidu-meet/                     # This repository

Note: Clone the openvidu repository alongside openvidu-meet to enable proper linking. If you haven't done so yet:

git clone https://github.com/OpenVidu/openvidu.git

# Clone the repository
git clone https://github.com/OpenVidu/openvidu-meet.git
cd openvidu-meet

# Start development mode with hot-reload
./meet.sh dev

Then, the application will be available at http://localhost:6080.

Note: Livereload is also available at http://localhost:6081.

The recommended way to develop is using the integrated development mode that watches all components:

./meet.sh dev

This command starts concurrent watchers for:

• openvidu-components-angular: Core Angular components library
• Typings: Shared type definitions with automatic sync
• Backend: Node.js server with nodemon auto-restart
• Frontend: Angular application with live reload
• REST API Docs: OpenAPI documentation generation

LIVEKIT_URL=ws://localhost:7880
LIVEKIT_API_KEY=your-api-key
LIVEKIT_API_SECRET=your-api-secret

If you prefer more granular control:

# Install dependencies
./meet.sh install

# Build shared typings (required first)
./meet.sh build-typings

# In separate terminals:
# Terminal 1 - Backend
cd backend
pnpm run start:dev

# Terminal 2 - Frontend
cd frontend
pnpm run dev

# Terminal 3 - Typings watcher (optional)
cd typings
pnpm run dev

Build all components in the correct order:

# Build everything (typings → frontend → backend → webcomponent)
./meet.sh build

# Or build individual components:
./meet.sh build-typings          # Build shared types
./meet.sh build-webcomponent     # Build web component only
./meet.sh build-testapp          # Build test application

The meet.sh script supports flags to optimize CI/CD pipelines:

# Install dependencies once
./meet.sh install

# Build typings once
./meet.sh build-typings

# Build webcomponent (skip already completed steps)
./meet.sh build-webcomponent --skip-install --skip-typings

# Run tests without reinstalling
./meet.sh test-unit-webcomponent --skip-install

Available flags:

• --skip-install: Skip dependency installation
• --skip-build: Skip build steps
• --skip-typings: Skip typings build (use when already built)

OpenVidu Meet includes comprehensive testing capabilities:

# Backend unit tests
./meet.sh test-unit-backend

# Webcomponent unit tests
./meet.sh test-unit-webcomponent

# Run E2E tests for webcomponent (installs Playwright automatically)
./meet.sh test-e2e-webcomponent

# Force reinstall Playwright browsers
./meet.sh test-e2e-webcomponent --force-install

The repository includes a dedicated testing application for manual testing:

# Build and start the test application
./meet.sh start-testapp

The test app will be available at http://localhost:5080

# Generate webcomponent documentation
./meet.sh build-webcomponent-doc [output_dir]

# Generate REST API documentation
./meet.sh build-rest-api-doc [output_dir]

Documentation files will be generated in:

• Webcomponent: docs/webcomponent-*.md (events, commands, attributes)
• REST API: meet-ce/backend/public/openapi/public.html

If you specify an output directory, the documentation will be copied there.

Build and run the production container:

# Build the Docker image (using meet.sh)
./meet.sh build-docker openvidu-meet-ce

# Build Docker image for demos (different BASE_HREF)
./meet.sh build-docker openvidu-meet-ce --demos

# Run the container
docker run \
  -e LIVEKIT_URL=<your-livekit-url> \
  -e LIVEKIT_API_KEY=<your-livekit-api-key> \
  -e LIVEKIT_API_SECRET=<your-livekit-api-secret> \
  -p 6080:6080 \
  openvidu-meet-ce

# Build all components
./meet.sh build

# Start in production mode
./meet.sh start --prod

# Or start in CI mode
./meet.sh start --ci

Configure your production environment using these key variables:

• LIVEKIT_URL: WebSocket URL for LiveKit server
• LIVEKIT_API_KEY: LiveKit API key
• LIVEKIT_API_SECRET: LiveKit API secret
• SERVER_PORT: Backend server port (default: 6080)
• NODE_ENV: Environment mode (development, production, ci)

For a complete list of environment variables, see backend/src/environment.ts.

openvidu-meet/
├── meet.sh                          # Main build and development script
├── pnpm-workspace.yaml              # pnpm workspace configuration
├── package.json                     # Root package with scripts
│
├── typings/                         # Shared TypeScript definitions
│   ├── src/
│   │   ├── api-key.ts
│   │   ├── auth-config.ts
│   │   ├── room.ts
│   │   └── ...
│   └── package.json
│
├── frontend/                       # Angular frontend application
│   ├── src/                        # Main application source
│   ├── projects/
│   │   └── shared-meet-components/ # Reusable Angular library
│   └── webcomponent/               # Web component build
│
├── backend/                        # Node.js/Express backend
│   ├── src/
│   │   ├── config/                 # Configuration files
│   │   ├── controllers/            # REST API controllers
│   │   ├── helpers/                # Helper functions
│   │   ├── middleware/             # Express middleware
│   │   ├── migrations/             # Database migration scripts
│   │   ├── models/                 # Domain models
│   │   ├── repositories/           # Database interaction
│   │   ├── routes/                 # API route definitions
│   │   ├── services/               # Business logic
│   │   ├── utils/                  # Utility functions
│   │   └── environment.ts          # Environment configuration
│   ├── openapi/                    # OpenAPI specifications
│   └── public/                     # Static files (includes built frontend)
│
├── testapp/                        # Testing application
│   ├── src/
│   └── public/
│
├── docker/                         # Docker build files
│   └── create_image.sh
│
├── docs/                           # Generated documentation
├── scripts/                        # Build and utility scripts
└── openvidu-meet-pro/              # Professional Edition (separate license)

The meet.sh script is the main entry point for all development and build tasks:

# Help
./meet.sh help

# Installation
./meet.sh install                    # Install all dependencies

# Building
./meet.sh build                      # Build all components
./meet.sh build-typings              # Build shared types only
./meet.sh build-webcomponent         # Build webcomponent only
./meet.sh build-testapp              # Build test application

# Development
./meet.sh dev                        # Start development mode with watchers

# Testing
./meet.sh test-unit-backend          # Run backend unit tests
./meet.sh test-unit-webcomponent     # Run webcomponent unit tests
./meet.sh test-e2e-webcomponent      # Run webcomponent E2E tests

# Running
./meet.sh start --prod               # Start in production mode
./meet.sh start --ci                 # Start in CI mode
./meet.sh start-testapp              # Start test application

# Documentation
./meet.sh build-webcomponent-doc [dir]  # Generate webcomponent docs
./meet.sh build-rest-api-doc [dir]      # Generate REST API docs

# Docker
./meet.sh build-docker <image-name> [--demos]  # Build Docker image

# Full development workflow
./meet.sh install
./meet.sh dev

# CI/CD optimized workflow
./meet.sh install
./meet.sh build-typings
./meet.sh build-webcomponent --skip-install --skip-typings
./meet.sh test-unit-webcomponent --skip-install

# Production build and deploy
./meet.sh build
./meet.sh start --prod

# Build Docker image
./meet.sh build-docker openvidu-meet-ce

# Build Docker image for demos
./meet.sh build-docker openvidu-meet-ce --demos

• Frontend: Angular 20, Material Design, TypeScript
• Backend: Node.js, Express, TypeScript
• WebRTC Infrastructure: LiveKit
• Package Manager: pnpm (workspaces)
• Build Tools: Angular CLI, TypeScript Compiler, Rollup (webcomponent)
• Testing: Jest (unit), Playwright (E2E), Mocha
• Documentation: OpenAPI/Swagger, Custom generators

Contributions are welcome! Please ensure that:

1. All tests pass: ./meet.sh test-unit-backend && ./meet.sh test-unit-webcomponent
2. Code is properly formatted
3. TypeScript types are correctly defined in typings/
4. Documentation is updated as needed

Licensed under the Apache License, Version 2.0. See LICENSE for details.

• OpenVidu Website
• OpenVidu Meet

For questions and support, visit our community forum.