CodeTogether (codetogether-inc/codetogether)

CodeTogether

https://github.com/codetogether-inc/codetogether
Admin
CodeTogether is a collaborative IDE live sharing platform that enables real-time code editing and...

Tokens:33,631
Snippets:503
Trust Score:5.5
Update:2 weeks ago
Show doc for...
Context Summary (auto-generated)
Raw
# CodeTogether Live

CodeTogether Live is a real-time collaborative coding platform that enables developers to live share their IDE and coding sessions across multiple development environments. Supporting Eclipse, IntelliJ, VS Code, and browser-based access, it provides a seamless collaborative experience similar to Google Docs but designed specifically for code. The platform features end-to-end encryption, host-based language intelligence, and cross-IDE compatibility, making it ideal for pair programming, mob programming, code reviews, and remote development scenarios.

CodeTogether Live offers both SaaS and On-Premises deployment options with enterprise features including SSO integration, multi-server deployments for scalability, and comprehensive metrics dashboards. Free plans with anonymous usage are available for basic collaboration needs, while paid plans unlock advanced features such as team sessions, terminal write access, audio/video communication, and higher participant limits.

## Starting a Hosting Session

Hosts can start collaborative coding sessions directly from their IDE, controlling access permissions, cursor behavior, and editing rights for participants.

```bash
# VS Code: Start hosting via Command Palette
# Press Ctrl+Shift+P (or Cmd+Shift+P on Mac), then type:
CodeTogether: Start Hosting Session

# IntelliJ: Start hosting via menu
# Navigate to: Tools > CodeTogether: Start Hosting Session

# Eclipse: Start hosting via menu
# Navigate to: Help > CodeTogether > Start Hosting Session
```

## Joining a Remote Session

Participants can join sessions from any supported IDE or directly from a web browser using an invite URL.

```bash
# VS Code: Join session via Command Palette
# Press Ctrl+Shift+P, then type:
CodeTogether: Join Remote Session
# Paste the invite URL when prompted

# IntelliJ: Join session via menu
# Navigate to: Tools > CodeTogether: Join Remote Session
# Paste the invite URL in the dialog

# Browser: Simply open the invite URL directly
# Example URL format:
https://codetogether.com/join/AbCdEfGhIjKl

# Eclipse: Join via menu
# Navigate to: Help > CodeTogether > Join Remote Session
```

## Configuring Session Access Controls

When starting a session, hosts can configure cursor behavior, editing permissions, and access restrictions.

```javascript
// Session configuration options available when starting:

// Cursor Owner Options:
// - "Dynamic driver based on activity" - Default, auto-assigns driver
// - "Explicitly assigned driver (strong-style pairing)" - Manual driver assignment
// - "Only host has a cursor (presentation mode)" - Read-only for guests

// Guest Initial Cursor Behavior:
// - "Guests decide cursor behavior"
// - "Guests follow your cursor"
// - "Guests have their own cursor"

// Editing Permissions:
// - Everyone (all guests can edit)
// - Team members only (CodeTogether Teams plan)

// Run/Unit Test Access:
// - All guests (default)
// - Team members only (Teams plan)

// Session Restriction (Teams only):
// - Restrict session to team members checkbox
```

## Hiding Files and Folders from Sessions

Hosts can exclude sensitive files and folders from being shared in CodeTogether sessions using ignore patterns.

```bash
# Create a .codetogether.ignore file in the project root
# Use Glob patterns to match resources to exclude

# Example .codetogether.ignore file content:
.env
*.secret
credentials.json
config/secrets/
node_modules/
.git/
*.pem
*.key

# Alternatively, right-click a file/folder in IDE and select:
# "Add to CodeTogether Ignore"
```

## Docker Installation for On-Premises

Deploy CodeTogether Live on-premises using Docker for complete control over your collaboration infrastructure.

```bash
# Step 1: Login to CodeTogether Docker Registry
docker login -u "<username>" hub.edge.codetogether.com

# Step 2: Pull the latest CodeTogether image
docker pull hub.edge.codetogether.com/latest/codetogether

# Step 3: Pull a specific version (optional)
docker pull hub.edge.codetogether.com/releases/codetogether:<version>

# Step 4: Verify the image
docker image ls

# Step 5: Create a Dockerfile with license configuration
cat > Dockerfile << 'EOF'
FROM hub.edge.codetogether.com/latest/codetogether

# Uncomment if using a self-signed certificate
#ENV CT_TRUST_ALL_CERTS true

ENV CT_LICENSEE "Your Company Name"
ENV CT_MAXCONNECTIONS 250
ENV CT_EXPIRATION 2025/12/30
ENV CT_LOCATOR none
ENV CT_SIGNATURE your-signature-from-sales

# Provide the externally accessible HTTPS URL for this server
ENV CT_SERVER_URL https://codetogether.yourcompany.com

# A/V configuration
ENV CT_AV_ENABLED "true"
ENV CT_AV_LAN_IP "auto"
EOF

# Step 6: Build the container
docker build -t "codetogether:local" .

# Step 7: Start the container
docker run \
  --name codetogether \
  -v ctlogs:/var/log/codetogether \
  -p 80:1080 -p 443:1443 -p 10000:10000/udp -p 4443:4443 \
  -d codetogether:local

# Step 8: Verify container is running
docker ps | grep codetogether
```

## Docker Installation with SSL Certificates

Configure SSL certificates directly within the CodeTogether container for secure HTTPS connections.

```bash
# Create SSL settings configuration file
cat > codetogether-ssl-settings.conf << 'EOF'
# enable SSL
listen 1443 ssl;
# add your certificates
ssl_certificate /etc/nginx/ssl/codetogether.company.com.crt;
ssl_certificate_key /etc/nginx/ssl/codetogether.company.com.key;
# add your TLS and/or ciphering settings
ssl_protocols TLSv1.3 TLSv1.2;
EOF

# Create Dockerfile with SSL configuration
cat > Dockerfile << 'EOF'
FROM hub.edge.codetogether.com/latest/codetogether

COPY --chown=codetogether:0 codetogether.company.com.crt /etc/nginx/ssl
COPY --chown=codetogether:0 codetogether.company.com.key /etc/nginx/ssl
COPY --chown=codetogether:0 codetogether-ssl-settings.conf /etc/nginx/includes
RUN chmod -R g+r /etc/nginx/ssl

# Uncomment if using a self-signed certificate
#ENV CT_TRUST_ALL_CERTS true

ENV CT_LICENSEE "Your Company Name"
ENV CT_MAXCONNECTIONS 250
ENV CT_EXPIRATION 2025/12/30
ENV CT_LOCATOR none
ENV CT_SIGNATURE your-signature

ENV CT_SERVER_URL https://codetogether.company.com

ENV CT_AV_ENABLED "true"
ENV CT_AV_LAN_IP "auto"
EOF

# Build and run with SSL
docker build -t "codetogether:local" .
docker run \
  --name codetogether \
  -v ctlogs:/var/log/codetogether \
  -p 443:1443 -p 10000:10000/udp -p 4443:4443 \
  -d codetogether:local
```

## External License Configuration

Store license details outside the Dockerfile for enhanced security in production deployments.

```bash
# Create a secure license configuration file
cat > /secure/path/codetogether.config << 'EOF'
export CT_LICENSEE="Your Company Name"
export CT_MAXCONNECTIONS=250
export CT_EXPIRATION=2025/12/30
export CT_LOCATOR=none
export CT_SIGNATURE=your-signature-from-sales
export CT_SERVER_URL=https://codetogether.company.com
export CT_AV_ENABLED=true
export CT_AV_LAN_IP=auto
EOF

# Set appropriate permissions
chmod 600 /secure/path/codetogether.config

# Create minimal Dockerfile
cat > Dockerfile << 'EOF'
FROM hub.edge.codetogether.com/latest/codetogether

# Uncomment if using a self-signed certificate
#ENV CT_TRUST_ALL_CERTS true

ENV CT_SERVER_URL https://codetogether.company.com
ENV CT_AV_ENABLED "true"
ENV CT_AV_LAN_IP "auto"
EOF

# Build and run with mounted config
docker build -t "codetogether:local" .
docker run \
  --name codetogether \
  --mount type=bind,source=/secure/path/codetogether.config,target=/opt/codetogether/.bashrc \
  -v ctlogs:/var/log/codetogether \
  -p 80:1080 -p 443:1443 -p 10000:10000/udp -p 4443:4443 \
  -d codetogether:local
```

## Kubernetes Deployment with Helm

Deploy CodeTogether Live on Kubernetes using the official Helm chart for production-grade deployments.

```bash
# Step 1: Add the CodeTogether Helm repository
helm repo add genuitec https://genuitec.github.io/CodeTogether/helm/
helm repo list

# Step 2: Update and pull the chart
helm repo update
helm pull genuitec/codetogether --untar
ls codetogether/

# Step 3: Create custom values file (my-values.yaml)
cat > my-values.yaml << 'EOF'
image:
  tag: latest
  pullPolicy: Always

license:
  licensee: "Your Company"
  maxConnections: "250"
  expiration: "2025/12/30"
  signature: "your-license-signature"

codetogether:
  mode: "direct"
  url: https://codetogether.company.com
  trustAllCerts: "false"

ingress:
  enabled: true
  tls:
    - secretName: codetogether-tls

dashboard:
  enabled: true
  username: "admin"
  password: "secure-password"

av:
  enabled: true
  serverIP: "auto"

service:
  type: ClusterIP
  port: 443
EOF

# Step 4: Install the chart
helm install codetogether -f my-values.yaml ./codetogether

# Step 5: Upgrade an existing deployment
helm upgrade codetogether -f my-values.yaml ./codetogether

# Step 6: Verify deployment
kubectl get pods | grep codetogether
kubectl get ingress | grep codetogether
```

## Multi-Server Helm Deployment

Configure CodeTogether for multi-server deployment with locator and edge servers for scalability.

```yaml
# locator-values.yaml - Central Locator Configuration
image:
  tag: latest

license:
  licensee: "Your Company"
  maxConnections: "500"
  expiration: "2025/12/30"
  signature: "your-license-signature"

codetogether:
  mode: "locator-central"
  url: https://codetogether-locator.company.com
  trustAllCerts: "false"

locatorCentral:
  database:
    host: "10.10.0.2"
    port: 3306
    schema: "codetogether"
    dialect: "mysql"
    user: "ct_user"
    password: "secure-db-password"
    sslEnabled: false

dashboard:
  enabled: true
  username: "admin"
  password: "dashboard-password"

---
# edge-values.yaml - Edge Server Configuration
image:
  tag: latest

license:
  licensee: "Your Company"
  maxConnections: "250"
  expiration: "2025/12/30"
  signature: "your-license-signature"

codetogether:
  mode: "locator-edge"
  url: https://codetogether-edge1.company.com
  trustAllCerts: "false"

locatorEdge:
  locator: "https://codetogether-locator.company.com"
  region: "us-east"

av:
  enabled: true
  serverIP: "auto"
```

```bash
# Deploy locator and edge servers
helm install ct-locator -f locator-values.yaml ./codetogether
helm install ct-edge1 -f edge-values.yaml ./codetogether

# Check edge server connection status
kubectl logs -f deployment/ct-edge1
# Expected output: "Edge Server ready; connected to Locator for assignments"
```

## SSO Configuration with Okta

Configure Single Sign-On integration with Okta for enterprise authentication.

```bash
# Docker environment variables for Okta SSO
cat > Dockerfile << 'EOF'
FROM hub.edge.codetogether.com/latest/codetogether

ENV CT_LICENSEE "Your Company"
ENV CT_MAXCONNECTIONS 250
ENV CT_EXPIRATION 2025/12/30
ENV CT_LOCATOR none
ENV CT_SIGNATURE your-signature
ENV CT_SERVER_URL https://codetogether.company.com

# Okta SSO Configuration
ENV CT_SSO_PROVIDER "OKTA"
ENV CT_SSO_CLIENT_ID "0oa5vFs2yPWSiqABC123"
ENV CT_SSO_CLIENT_SECRET "bI96uXez4QBb3ZxIY7eO4GCr..."
ENV CT_SSO_SYSTEM_BASE_URL "https://yourcompany.okta.com/oauth2/default"

ENV CT_AV_ENABLED "true"
ENV CT_AV_LAN_IP "auto"
EOF
```

## SSO Configuration with Azure AD

Configure Single Sign-On integration with Microsoft Azure Active Directory.

```bash
# Docker environment variables for Azure AD SSO
cat > Dockerfile << 'EOF'
FROM hub.edge.codetogether.com/latest/codetogether

ENV CT_LICENSEE "Your Company"
ENV CT_MAXCONNECTIONS 250
ENV CT_EXPIRATION 2025/12/30
ENV CT_LOCATOR none
ENV CT_SIGNATURE your-signature
ENV CT_SERVER_URL https://codetogether.company.com

# Azure AD SSO Configuration
ENV CT_SSO_PROVIDER "MICROSOFT"
ENV CT_SSO_CLIENT_ID "ab55a5a3-498b-479b-..."
ENV CT_SSO_CLIENT_SECRET "_ZcjuPg_TNh_g~hld..."
ENV CT_SSO_SYSTEM_BASE_URL "https://login.microsoftonline.com/your-tenant-id/v2.0"

ENV CT_AV_ENABLED "true"
ENV CT_AV_LAN_IP "auto"
EOF
```

## SSO Provider Setup Requirements

Configure your SSO provider application with the required OAuth2/OIDC settings.

```javascript
// SSO Provider Application Configuration
// Required settings when creating a new application in your SSO provider:

// Login redirect URI:
`${CT_SERVER_URL}/sso/authorization-code/callback`
// Example: https://codetogether.company.com/sso/authorization-code/callback

// Logout redirect URI:
`${CT_SERVER_URL}/sso/logout`
// Example: https://codetogether.company.com/sso/logout

// Required Grant Types:
// - Client Credentials: enabled
// - Authorization Code: enabled
// - Refresh Token: enabled

// Required OIDC Scopes:
// - openid
// - profile
// - offline_access

// Environment Variables Summary:
// CT_SSO_PROVIDER: "OKTA" | "MICROSOFT" | "IDCS" | "KEYCLOAK" | "ONELOGIN"
// CT_SSO_CLIENT_ID: Unique ID from SSO provider
// CT_SSO_CLIENT_SECRET: Private key from SSO provider
// CT_SSO_SYSTEM_BASE_URL: Base URL for identity system (Domain/Realm)
// CT_SSO_TOKEN_ENDPT: Optional, for non-standard OIDC systems
// CT_SSO_SECURE_JWKS_ENDPT_ENABLE: "true" for Oracle IDCS
```

## Nginx Reverse Proxy Configuration

Configure Nginx as a reverse proxy for CodeTogether with WebSocket support.

```nginx
# /etc/nginx/conf.d/codetogether.conf

# Backend server running CodeTogether container
upstream codetogether {
    server codetogether-backend.internal:1080;
}

# HTTPS frontend configuration
server {
    listen 443 ssl http2;
    server_name codetogether.company.com;

    ssl_protocols TLSv1.3 TLSv1.2;
    ssl_certificate /etc/nginx/ssl/codetogether.company.com.crt;
    ssl_certificate_key /etc/nginx/ssl/codetogether.company.com.key;

    # Proxy headers at server context
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header Host $http_host;

    location / {
        proxy_redirect off;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header Host $http_host;
        proxy_set_header X-NginX-Proxy true;
        proxy_http_version 1.1;

        # Required for WebSocket support
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";

        proxy_pass http://codetogether;
    }
}
```

```bash
# Validate and apply Nginx configuration
nginx -t
# Expected output:
# nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
# nginx: configuration file /etc/nginx/nginx.conf test is successful

# Reload Nginx
service nginx reload
```

## Kubernetes Deployment YAML

Deploy CodeTogether directly on Kubernetes without Helm using a deployment manifest.

```yaml
# codetogether.yaml - Complete Kubernetes deployment

# Secret: License Configuration
apiVersion: v1
kind: Secret
metadata:
  name: codetogether-license
  namespace: default
type: Opaque
stringData:
  CT_SERVER_URL: "https://codetogether.company.com"
  CT_TRUST_ALL_CERTS: "false"
  CT_LICENSEE: "Your Company"
  CT_MAXCONNECTIONS: "250"
  CT_EXPIRATION: "2025/12/30"
  CT_SIGNATURE: "your-license-signature"
---
# Secret: SSL Certificates
apiVersion: v1
kind: Secret
metadata:
  name: codetogether-tls
  namespace: default
type: kubernetes.io/tls
data:
  tls.crt: "BASE64_ENCODED_CERTIFICATE"
  tls.key: "BASE64_ENCODED_KEY"
---
# Ingress: HTTPS routing
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: codetogether
  annotations:
    nginx.ingress.kubernetes.io/proxy-read-timeout: "3600"
    nginx.ingress.kubernetes.io/proxy-send-timeout: "3600"
spec:
  tls:
  - hosts:
    - codetogether.company.com
    secretName: codetogether-tls
  rules:
  - host: codetogether.company.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: codetogether
            port:
              number: 80
---
# Service: Internal routing
apiVersion: v1
kind: Service
metadata:
  name: codetogether
  labels:
    app: codetogether
spec:
  ports:
  - port: 80
    name: http
    targetPort: 1080
    protocol: TCP
  selector:
    app: codetogether
---
# Deployment: Container configuration
apiVersion: apps/v1
kind: Deployment
metadata:
  name: codetogether
  namespace: default
spec:
  selector:
    matchLabels:
      app: codetogether
  replicas: 1
  template:
    metadata:
      labels:
        app: codetogether
    spec:
      containers:
      - name: codetogether
        image: hub.edge.codetogether.com/latest/codetogether:latest
        imagePullPolicy: Always
        ports:
        - containerPort: 1080
        env:
        - name: CT_LOCATOR
          value: "none"
        - name: CT_SERVER_URL
          valueFrom:
            secretKeyRef:
              name: codetogether-license
              key: CT_SERVER_URL
        - name: CT_LICENSEE
          valueFrom:
            secretKeyRef:
              name: codetogether-license
              key: CT_LICENSEE
        - name: CT_MAXCONNECTIONS
          valueFrom:
            secretKeyRef:
              name: codetogether-license
              key: CT_MAXCONNECTIONS
        - name: CT_EXPIRATION
          valueFrom:
            secretKeyRef:
              name: codetogether-license
              key: CT_EXPIRATION
        - name: CT_SIGNATURE
          valueFrom:
            secretKeyRef:
              name: codetogether-license
              key: CT_SIGNATURE
      imagePullSecrets:
      - name: ctcreds
```

```bash
# Create registry credentials
kubectl create secret docker-registry ctcreds \
    --docker-server=hub.edge.codetogether.com \
    --docker-username=<your-username> \
    --docker-password=<your-password>

# Apply the deployment
kubectl apply -f codetogether.yaml

# Verify deployment
kubectl get pods -l app=codetogether
kubectl get ingress codetogether
```

## Remote Test Execution

Guests can run tests on the host IDE and view results in real-time across all connected clients.

```bash
# VS Code: Run tests from Testing view
# 1. Open Testing view (View > Testing)
# 2. Click run button on discovered tests
# 3. Results appear in Testing view with pass/fail status

# IntelliJ: Run tests via Run menu
# 1. Navigate to: Run > Run
# 2. Select from "Remote Test (CodeTogether)" configurations
# 3. Results appear in Run tool window

# Eclipse: Run tests via configuration
# 1. Navigate to: Run > Run Configurations
# 2. Select "Remote Test" node
# 3. Create or select test configuration
# 4. Results appear in CodeTogether Tests view

# Browser: Run tests from Remote Tests view
# 1. Open View > Remote Tests
# 2. Click run button on test nodes
# 3. Results displayed inline with pass/fail indicators

# Keyboard shortcuts for rerunning tests:
# Eclipse: Ctrl+F11
# IntelliJ: Shift+F10
```

## Shared Terminal Access

Hosts can share terminal sessions with participants, optionally granting write access to team members.

```bash
# Host: Terminals are automatically shared when opened
# Participants see terminals in the Terminals node of CodeTogether view

# Participant: Access shared terminal
# 1. Open CodeTogether view in IDE
# 2. Expand Terminals node
# 3. Double-click (Eclipse/IntelliJ) or click (VS Code) to open

# Request write access (Teams plan required):
# 1. Click "Request Write Access" button on terminal node
# 2. Or simply start typing in the terminal
# 3. Host receives prompt to grant access

# Host: Stop sharing a terminal
# 1. In CodeTogether view, find the terminal under Terminals
# 2. Click "Stop Sharing" button
# Note: Once stopped, terminal cannot be re-shared in same session
```

## Shared Server Configuration

Share local development servers, databases, and remote debug sessions with session participants.

```bash
# Host: Servers running on localhost are auto-detected
# Manually add servers via CodeTogether view:
# 1. Right-click "Shared Servers" node
# 2. Select "Add Server"
# 3. Enter port number

# Participant: Connect to shared server
# 1. In CodeTogether view, expand "Shared Servers"
# 2. Double-click server or click "Connect Server" button
# 3. Server becomes available at local port
#    (same port as host, or next available)

# Example: Sharing a web application running on port 3000
# Host runs: npm start (app on localhost:3000)
# Host shares port 3000 via CodeTogether
# Guest connects and accesses app at localhost:3000 (or next available)

# Example: Sharing a database connection
# Host has PostgreSQL on localhost:5432
# Host shares port 5432
# Guest connects and can use localhost:5432 for DB access

# Disconnect from shared server:
# Click "Disconnect Server" to free local port
```

## Dashboard Access and Metrics

Access the on-premises dashboard for real-time metrics and configuration management.

```bash
# Access dashboard at:
https://your-codetogether-server.com/dashboard

# Dashboard credentials (from Helm values or Docker config):
# Default: Dynamically generated, check server logs
# Custom: Set via dashboard.username and dashboard.password

# Dashboard features:
# - Real-time session monitoring
# - Historical usage trends
# - Edge server health (multi-server deployments)
# - Regional IP range configuration
# - StatsD/Prometheus integration settings

# Enable custom dashboard credentials in Helm:
dashboard:
  enabled: true
  username: "admin"
  password: "secure-dashboard-password"

# Enable metrics export:
direct:
  metrics:
    statsdEnabled: true
    statsdHost: "https://graphite.company.com"
    statsdPort: "8125"
    statsdProtocol: "UDP"
    prometheusEnabled: true
```

CodeTogether Live serves as a comprehensive solution for distributed development teams needing real-time collaboration capabilities. Its cross-IDE support makes it particularly valuable for organizations with diverse development environments, allowing Eclipse, IntelliJ, and VS Code users to collaborate seamlessly. The platform's host-based intelligence ensures all participants receive consistent code navigation, content assist, and validation regardless of their client IDE or browser.

For enterprise deployments, the on-premises option provides complete control over infrastructure and data, with support for SSO integration, multi-server scalability, and comprehensive audit logging. The combination of Docker and Kubernetes deployment options, along with the official Helm chart, enables organizations to integrate CodeTogether into their existing container orchestration workflows while maintaining security compliance through TLS encryption and configurable access controls.