server/

Discobot Server

The Discobot Server is a Go backend that provides REST APIs for workspace management, session orchestration, and sandbox lifecycle management.

Overview

The server handles:

• Workspace creation and git operations
• Session lifecycle and sandbox management
• Agent configuration and credential storage
• Real-time events via Server-Sent Events
• Chat message routing to sandboxes

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                       Go Server                                  │
│                                                                  │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                    HTTP Handlers                          │  │
│  │  /api/projects/{id}/workspaces, sessions, agents, etc.   │  │
│  └──────────────────────────────────────────────────────────┘  │
│                           │                                      │
│                           ▼                                      │
│  ┌──────────────────────────────────────────────────────────┐  │
│  │                    Service Layer                          │  │
│  │  Business logic, validation, orchestration               │  │
│  └──────────────────────────────────────────────────────────┘  │
│                           │                                      │
│         ┌─────────────────┼─────────────────┐                   │
│         ▼                 ▼                 ▼                   │
│  ┌────────────┐   ┌────────────┐   ┌────────────────────┐      │
│  │   Store    │   │  Sandbox   │   │   Git Provider     │      │
│  │   (GORM)   │   │  Provider  │   │   (local git)      │      │
│  └────────────┘   └────────────┘   └────────────────────┘      │
│         │                 │                 │                   │
│         ▼                 ▼                 ▼                   │
│    PostgreSQL/       Docker API       File System               │
│     SQLite                                                      │
└─────────────────────────────────────────────────────────────────┘

Documentation

• Architecture Overview - System design and data flow
• Handler Module - HTTP request handlers
• Service Module - Business logic layer
• Store Module - Data access layer
• Sandbox Module - Docker integration
• Cache System - Project-scoped cache volumes
• Events Module - SSE and event system
• Jobs Module - Background job processing

Getting Started

Prerequisites

• Go 1.23+
• Docker (for sandbox runtime)
• PostgreSQL or SQLite

Development

# Run with auto-reload
cd server
air

# Or run directly
go run cmd/server/main.go

# Run tests
go test ./...

# Run linter
golangci-lint run

Environment Variables

When HTTPS_PORT is enabled, the server starts both HTTP and HTTPS listeners. In ephemeral mode it generates an in-memory self-signed certificate at startup. In static mode it loads the configured PEM cert/key pair. In acme mode it uses Go's autocert support and stores cached ACME state in the database encrypted with ENCRYPTION_KEY.

For trusted HTTPS modes (static and acme), the HTTP listener redirects normal traffic to the HTTPS listener. In acme mode, Go's autocert HTTP challenge paths are still served on the HTTP listener so certificate issuance and renewal continue to work.

By default, CORS origins are generated from the configured API listener ports. That includes the active HTTP API origin (http://localhost:{PORT} and http://*.localhost:{PORT}), the active HTTPS API origin when enabled (https://localhost:{HTTPS_PORT} and https://*.localhost:{HTTPS_PORT}), plus the local frontend dev origins on ports 3000 and 3100. If you set CORS_ORIGINS explicitly, you can still use {HTTP_PORT} and {HTTPS_PORT} placeholders in the value.

On startup, the server first waits until each configured listener port can be bound. It probes PORT and HTTPS_PORT every 10 seconds for up to 2 minutes, immediately releases the probe listener on success, and only then continues with the normal startup sequence. This avoids restart races with a previous process that is still shutting down.

After startup seeding, the server also imports known credential environment variables into the default local project when possible. This is additive only: if the project already has a credential for that env var or provider, the server leaves it unchanged and does not create a duplicate.

Building

For a standalone server binary with the embedded Svelte SPA, build from the repository root:

pnpm build:server

This builds ui/build, copies it into server/static/ui/dist, and then compiles the Go server.

If you only run go build directly inside server/, the binary will not include the freshly built SPA assets.

Authservice container image

Use the dedicated authservice Dockerfile when you want to package the standalone authservice executable:

docker build -f authservice/Dockerfile -t discobot-authservice .

The local rolling deployment setup under authservice/docker-compose.rolling.yml builds this image from the repository root with context: ...

API Endpoints

Projects

Workspaces

Sessions

Chat

Agents

User Preferences

User preferences are scoped to the authenticated user (not project-scoped).

Examples:

# Set a preference
curl -X PUT http://localhost:3001/api/preferences/theme \
  -H "Content-Type: application/json" \
  -d '{"value": "dark"}'

# Get a preference
curl http://localhost:3001/api/preferences/theme

# Set multiple preferences
curl -X PUT http://localhost:3001/api/preferences \
  -H "Content-Type: application/json" \
  -d '{"preferences": {"theme": "dark", "editor": "vim"}}'

# List all preferences
curl http://localhost:3001/api/preferences

# Delete a preference
curl -X DELETE http://localhost:3001/api/preferences/theme

Events

Project Structure

server/
├── cmd/server/
│   └── main.go              # Application entry point
├── internal/
│   ├── config/              # Configuration loading
│   ├── database/            # Database connection
│   ├── model/               # GORM models (User, Project, Session, UserPreference, etc.)
│   ├── store/               # Data access layer
│   ├── handler/             # HTTP handlers
│   │   ├── handler.go       # Base handler setup
│   │   ├── preferences.go   # User preferences handlers
│   │   └── ...
│   ├── service/             # Business logic
│   │   ├── preference.go    # User preferences service
│   │   └── ...
│   ├── sandbox/             # Sandbox runtime
│   │   ├── docker/          # Docker implementation
│   │   └── mock/            # Mock for testing
│   ├── git/                 # Git operations
│   ├── dispatcher/          # Job dispatcher
│   ├── jobs/                # Background jobs
│   ├── events/              # Event system
│   ├── middleware/          # HTTP middleware
│   ├── encryption/          # Credential encryption
│   └── integration/         # Integration tests
├── go.mod
└── go.sum

Dependencies

Testing

# Run all tests
go test ./...

# Run with verbose output
go test -v ./...

# Run specific package
go test ./internal/service/...

# Run integration tests
go test ./internal/integration/...

License

MIT