Skip to main content

Origin by Corvus - Developer & Build Handbook

Platform: Origin by Corvus
Provider: Quantum Tiger (Morning Bay Technology Pvt. Ltd.)
Official Website: https://quantumtiger.in
Authoring Engineering Team: Quantum Tiger Core Engineering


Overview​

Origin by Corvus is a secure, 100% self-hosted enterprise collaboration platform engineered for data sovereignty, private cloud deployment, and air-gapped corporate networks. This handbook is the comprehensive technical reference for any software engineer, DevOps engineer, or system architect building, testing, packaging, or extending the Origin codebase.


Codebase Architecture​

The repository is organized as a unified monorepo containing the Go backend, the React/TypeScript frontend, production installers, container specifications, and CI/CD pipelines:

Origin-by-Corvus/
├── server/ # Go Backend Server & mmctl CLI
│ ├── cmd/
│ │ ├── origin/ # Server entrypoint binary (main.go)
│ │ └── mmctl/ # Command-line administrative tool
│ ├── channels/ # Core application logic
│ │ ├── api4/ # REST API v4 endpoint handlers
│ │ ├── app/ # Business logic, plugins, sessions, webhooks
│ │ └── store/ # Database access layer (PostgreSQL / MySQL)
│ ├── public/ # Public Go module (model, plugin interfaces)
│ │ └── model/ # Domain models, configuration, constants
│ └── scripts/
│ └── config_generator/ # Generates default_config.json from code defaults
│
├── webapp/ # React & TypeScript Frontend (Monorepo)
│ ├── channels/ # Primary collaboration client web application
│ │ ├── src/
│ │ │ ├── components/ # React UI components (signup, chat, admin)
│ │ │ ├── actions/ # Redux action dispatchers
│ │ │ └── utils/
│ │ │ └── plugins/ # Whitelabeling & Origin module naming logic
│ │ └── package.json # Channels package manifest
│ ├── platform/ # Shared workspace libraries
│ │ ├── client/ # REST API v4 JavaScript/TypeScript client
│ │ ├── components/ # Shared design system components
│ │ └── core-redux/ # Core Redux store and state selectors
│ └── patches/ # patch-package npm patches applied during build
│
├── docs/ # Technical Documentation Hub & Sitemap
│ ├── User GUIDE.md # Master platform requirements & pre-flight checklist
│ ├── README.md # Documentation portal, architecture diagram & sitemap
│ ├── deployment/ # Installation, backup/restore, and updating guides
│ ├── security/ # Defense-in-depth security architecture
│ └── development/ # Engineering, contributing, and build handbooks
│
├── .gitea/ # Gitea Actions CI/CD & Repository Management
│ ├── workflows/ # Automated build, multi-arch publication & release
│ ├── ISSUE_TEMPLATE/ # Gitea issue forms (bug report, deployment help)
│ ├── PULL_REQUEST_TEMPLATE.md# Structured review checklist
│ └── labels.yaml # Standardized label taxonomy
│
├── Dockerfile # Multi-stage production container build (Debian Bookworm)
├── entrypoint.sh # Container startup script (storage & config init)
├── install.sh # Single-command Linux / macOS production installer
├── install.ps1 # Single-command Windows PowerShell installer
└── README.md # Root repository overview & quick start

Prerequisites & Toolchains​

To compile all components from source, install the following tools:

ToolRecommended VersionPurpose
Go1.22+ (or 1.24+)Compiling backend server and CLI
Node.js20.x or 22.x (or 24.x)Compiling React webapp client
npm10.x+Package manager for webapp
Docker & Docker Compose24.x+ (Compose v2)Container execution and local stack
GNU Make & g++Standard build-essentialNative addon compilation for Node
Git & curlLatestSource control & package fetching

Building from Source​

1. Build the Web Application (Frontend)​

The frontend is compiled into static production bundles served directly by the Go backend or an Nginx reverse proxy:

cd webapp

# 1. Install dependencies without triggering pre-compile scripts
npm install --ignore-scripts --engine-strict=false

# 2. Apply custom source patches (whitelabeling and fixes)
npx patch-package

# 3. Compile all packages and build the channels distribution
npm run build
  • Compilation Output: Static assets are output to webapp/channels/dist/.

2. Build the Server Binary (Backend)​

The server is built as a static 64-bit binary with zero external runtime C dependencies (CGO_ENABLED=0):

cd server

# 1. Initialize Go workspace across root and public module
go work init . ./public

# 2. Compile the core Origin server
CGO_ENABLED=0 go build -tags production -trimpath -ldflags="-s -w" -o ./bin/origin ./cmd/origin

# 3. Compile the administrative CLI tool (mmctl)
CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o ./bin/mmctl ./cmd/mmctl
  • Compilation Output:
    • Server binary: server/bin/origin
    • CLI binary: server/bin/mmctl

3. Generate Default Configuration Template​

Origin generates its canonical default_config.json directly from Go default structs to ensure all settings, plugin states, and security defaults are populated:

cd server
OUTPUT_CONFIG=./default_config.json go run ./scripts/config_generator

4. Build the Production Container Image​

The container uses a multi-stage Dockerfile that builds the webapp in Stage 1, builds the server in Stage 2, and bundles them into a secure, non-root Debian runtime in Stage 3:

# Build single-architecture image for current host:
docker build -t origin-corvus:latest .

# Build and test multi-architecture image (x86_64 and arm64):
docker buildx build --platform linux/amd64,linux/arm64 -t origin-corvus:latest .

Prepackaged Plugins Architecture​

Origin by Corvus includes three core platform modules pre-installed out of the box:

  1. Origin Calls (origin.calls): WebRTC audio, video, and screen sharing.
  2. Origin Boards (origin.boards): Visual Kanban boards and project tracking.
  3. Origin Workflows (playbooks): Incident runbooks and automated checklists.

How Prepackaging Works:​

  1. Dockerfile Download Stage: During docker build (in Stage 2), official signed .tar.gz and .tar.gz.sig packages matching the target architecture (linux-amd64 or linux-arm64) are bundled into /origin/prepackaged_plugins/.
  2. Default Enabled States: In server/public/model/config.go, PluginSettings.SetDefaults() sets:
    s.PluginStates[PluginIdCalls] = &PluginState{Enable: true}
    s.PluginStates[PluginIdPlaybooks] = &PluginState{Enable: true}
    s.PluginStates[PluginIdBoards] = &PluginState{Enable: true}
  3. Runtime Auto-Extraction: On container boot, the server checks prepackaged plugin bundles, verifies OpenPGP signatures against the embedded public key, extracts each bundle into /origin/plugins/, and starts them immediately.
  4. Whitelabeling: webapp/channels/src/utils/plugins/whitelabel.ts dynamically formats module names so they appear in the UI as Origin Calls, Origin Boards, and Origin Workflows.

Local Development Workflow​

To run a complete local stack with live backend and frontend:

1. Start Support Infrastructure​

# Run local PostgreSQL 15 and MinIO S3 storage:
docker run -d --name local-postgres -e POSTGRES_USER=origin_user -e POSTGRES_PASSWORD=origin_password -e POSTGRES_DB=origin_db -p 5432:5432 postgres:15
docker run -d --name local-minio -e MINIO_ROOT_USER=minioadmin -e MINIO_ROOT_PASSWORD=minioadmin -p 9000:9000 minio/minio server /data

2. Run Go Backend Locally​

cd server
export MM_SQLSETTINGS_DRIVERNAME=postgres
export MM_SQLSETTINGS_DATASOURCE="postgres://origin_user:origin_password@localhost:5432/origin_db?sslmode=disable"
export MM_SERVICESETTINGS_SITEURL="http://localhost:8065"

./bin/origin

3. Run Frontend in Development Mode (Hot Reload)​

cd webapp/channels
npm run run
# Opens development server at http://localhost:8065 with webpack hot-module replacement

[SYNC] Release & CI/CD Pipeline​

Origin by Corvus uses Gitea Actions for automated builds, multi-arch publishing, and Coolify continuous deployment:

  • Trunk Branch (main): Primary production release trunk.
  • Release Branch (production): Stable production deployment and artifact publication branch.
    • Pushing to production or pushing a version tag (v*) triggers .gitea/workflows/docker-publish.yml.
    • Automatically builds multi-arch images (linux/amd64, linux/arm64).
    • Publishes images to git.projectdefcorp.com/quantum-tiger/origin-corvus.
    • Generates release notes from CHANGELOG.md.
    • Automatically publishes a Gitea Release with install.sh, install.ps1, and SHA256 checksums.
  • Development Branch (development): Active integration and testing branch.
  • Coolify Continuous Deployment & Live Log Streaming (deploy.yaml):
    • Automatically triggered on push to main or production, or via manual workflow_dispatch.
    • Triggers Coolify deployment API (/api/v1/deploy?uuid=...).
    • Streams real-time build and deployment logs directly into the Gitea Actions console using incremental line-tailing.
    • Fetches live container runtime logs upon deployment completion and generates a rich Gitea Actions Markdown step summary.
  • On-Demand Live Container Logs (coolify-logs.yaml):
    • Triggerable on demand from Gitea Actions UI via workflow_dispatch to stream the last N lines (e.g. 100, 250, 500) of container runtime logs directly inside Gitea without needing Coolify dashboard access.
  • Required Gitea Secrets (Settings -> Actions -> Secrets):
    • COOLIFY_URL: Base URL of Coolify server (https://server.projectdefcorp.com).
    • COOLIFY_DEPLOY_TOKEN / COOLIFY_TOKEN: API Bearer Token generated in Coolify (Keys & Tokens -> API Tokens).
    • COOLIFY_APP_UUID: Application UUID for Origin by Corvus in Coolify (bmqut3ytvlfk2yvsju2ywbr9).
    • COOLIFY_PROJECT_UUID: Project UUID in Coolify (2omxwnodfypkn2nljida2g1m).
    • COOLIFY_ENVIRONMENT_UUID: Environment UUID in Coolify (vcv3hwepjdjixasxkfq6twb0).
    • COOLIFY_FQDN: Production public URL (https://origin.projectdefcorp.com).

Prepackaged Native Subsystems & Module Reference​

Origin by Corvus includes native enterprise-grade collaboration subsystems prepackaged directly within the platform:

Core SubsystemSubsystem IdentifierCommercial Capability
Origin Audio & Video Mediaorigin.callsEnterprise voice conferencing, video meetings, and screen sharing.
Origin Kanban & Task Boardsorigin.boardsVisual project management, task tracking, and milestone boards.
Origin Incident & Workflowsorigin.workflowsStructured incident response playbooks and automated checklists.
Origin AI Copilot & Assistorigin.aiLocal on-premise Large Language Model assistance and summarization.
Origin Compliance & Exportorigin.channel-exportRegulatory compliance audit trails, message archiving, and CSV/JSON exports.
Origin Performance Telemetryorigin.metricsLocal Prometheus and Grafana systems metrics collector.
Origin User Feedback Surveyorigin.user-surveyIn-app user satisfaction surveys and Net Promoter Score analytics.

Engineering Checklist for New Features​

When writing code or adding dependencies:

  1. Zero External Cloud Telemetry: Never introduce external analytics, tracking pixels, or third-party cloud pings.
  2. Database Migrations: Database migrations must be backwards-compatible and tested against PostgreSQL 15.
  3. Multi-Arch Safety: Ensure any native CGO or dependency compiles cleanly on both amd64 and arm64.
  4. Whitelabel Integrity: Ensure all client-facing strings, headers, modals, and error messages maintain Origin by Corvus and Quantum Tiger branding.
  5. No Committed Secrets: Never commit passwords, private keys, or API tokens to the repository.

© 2025 - present Origin by Corvus - Quantum Tiger (Morning Bay Technology Pvt. Ltd.). All rights reserved.