CloudForge: A Cloud-Native Collaborative Development Workspace

Executive Summary & Vision
Problem Statement & Motivation
Key Capabilities & Feature Matrix
System Architecture
- Architectural Topology
- Subsystem Decomposition
Literature Review & Theoretical Foundation
- Reviewed Papers (RP_1 to RP_10)
- State-of-the-Art Research Gap Matrix
Deep-Dive Feature Specifications
Repository Layout & Directory Tree
Comprehensive REST API Reference
WebSocket Protocol Specifications
Localhost Installation & Quickstart Guide
Environment Variables Reference
Automated Verification & Test Suites
Security Architecture & Threat Mitigation
Cloud Computing Conceptual Framework
AWS Cloud Deployment Architecture & Runbook
Presentation & Seminar Speech Guide
Future Cloud-Native Scalability Roadmap
License & Acknowledgments

1. Executive Summary & Vision

CloudForge is an open-source, cloud-native, browser-based collaborative development platform designed to deliver an end-to-end software engineering environment directly within any modern web browser. It completely eliminates local machine configuration overhead, cross-platform dependency drift, and the notorious "works on my machine" syndrome.

By uniting an industrial-grade code editor (Monaco Editor), multi-user synchronous editing powered by Conflict-Free Replicated Data Types (CRDTs), containerized sandboxes (Dockerode), a real-time WebSocket Cloud Shell, visual Git source control & commit timeline graphs, an integrated Live Web App Preview reverse proxy, and dynamic starter templates, CloudForge brings the power of full-stack desktop IDEs to an instant-boot, zero-install web interface.

2. Problem Statement & Motivation

Traditional software engineering workflows impose substantial friction on developers, educational institutions, and distributed teams:

Dependency Hell & Machine Configuration Drift: Developers spend hours configuring SDKs, runtimes (Python, Node.js, C++, Java), system paths, compilers, and database daemons. Inevitable differences across Windows, macOS, and Linux cause subtle runtime failures.
Fragmented Developer Toolchains: Developers must constantly toggle between disparate applications: a local text editor, an operating system terminal, a separate Git GUI client (or CLI commands), browser windows for web app previews, and third-party tools for pair programming.
Heavyweight Commercial Cloud IDEs: Existing commercial solutions (such as GitHub Codespaces, Gitpod, or CodeSandbox) often impose heavy cloud credit costs, proprietary devcontainer configurations, vendor lock-in, and significant boot latency (>30 seconds) on cold starts.
Shallow Collaborative Editors: Web-based collaborative tools typically focus on single-file transient buffers (like Google Docs or interview whiteboard pads) without true project directory trees, persistent document schemas, visual staging areas, branch switching, or bidirectional GitHub remote synchronization.

CloudForge solves this by delivering a lightweight, zero-configuration, fully self-hostable cloud development workspace accessible from any browser.

3. Key Capabilities & Feature Matrix

Feature	CloudForge Implementation	Benefit to Developers
Browser-Based IDE	Monaco Editor, multi-tabs, line gutter, minimap, find/replace, custom themes	Rich, VS Code-familiar editing environment without local installs
Hierarchical File Explorer	Expandable/collapsible tree, syntax icons, multi-file upload, recursive delete/rename	Full multi-file project structure and directory management
Real-Time Collaboration	Yjs CRDTs, WebSocket gateway (`/ws/collaboration`), live cursor tracking, activity feed	Sub-millisecond synchronous pair-programming with mathematical convergence
Container Sandboxing	Dockerode container isolation with automatic local workspace sandbox fallback	Safe, reproducible code execution environments for every project
Interactive Cloud Shell	Xterm.js + WebSocket gateway (`/ws/terminal`), jailed to `/workspace`, disk-to-DB sync	Full bash/sh shell execution, CLI compilation, and package management
Visual Git & Source Control	Staged vs. unstaged tracking, status pills (A, M, D), commit timeline graph, branch switcher	Intuitive Git management without memorizing complex CLI commands
Side-by-Side & Unified Diff	Dual-mode diff viewer with colored inline character/line additions and deletions	Comprehensive pre-commit inspection and review of commit history
Bidirectional GitHub Sync	GitHub REST API v3 integration for remote linking, repo publishing, and tree pulls	Seamless interoperability with existing GitHub repositories
Live Web App Preview	Dynamic port detection, reverse proxy streaming (`/api/projects/:id/preview/:port`), split view	Real-time visual feedback for web applications directly in the IDE
Interactive Execution Kernel	Jupyter Notebook (`.ipynb`) viewer, stateful cell execution for Python and JavaScript	Data science and rapid algorithmic experimentation in-browser
Dynamic Starter Templates	React+TS, Node Express, Python, Go, Rust, C++, Java, Web, and Blank presets	Instant one-click project bootstrap and in-place stack re-seeding
Zero-Config Database	Dual-mode Mongoose: auto-boots `mongodb-memory-server` if local MongoDB is absent	Runs instantly on any developer machine without pre-installed databases
Workspace Portability	Client-side ZIP bundling via `JSZip`	Full local backup and export of project code at any time

4. System Architecture

4.1 Architectural Topology

flowchart TD
  subgraph Client ["Client Tier (Browser - React 19 + TypeScript + Vite)"]
    UI["CloudForge Workspace Interface"]
    Monaco["Monaco Multi-Tab Editor"]
    Xterm["Xterm.js Cloud Shell"]
    CollabClient["Yjs CRDT Collaboration Client"]
    PreviewIframe["Live Web App Preview (Split / Tab)"]
    VCSUI["Source Control & Commit Graph UI"]
  end

  subgraph Gateway ["Application Gateway Tier (Node.js + Express 5.2)"]
    AuthMW["JWT & Cookie Authentication Middleware"]
    ProjectCtrl["Project & Workspace Controllers"]
    VCSCtrl["Git & Version Control Controllers"]
    PreviewProxy["Preview Reverse Proxy & Port Scanner"]
    TermWS["Terminal WebSocket Gateway (/ws/terminal)"]
    CollabWS["Collaboration WebSocket Gateway (/ws/collaboration)"]
  end

  subgraph Compute ["Compute & Execution Tier (Docker & Host Sandbox)"]
    DockerDaemon["Dockerode Dev Container (Node/Python/C++/Rust)"]
    HostSandbox["Host Sandbox Fallback (Isolated Storage Subdir)"]
    DiskWatcher["Real-Time Disk-to-DB File Watcher"]
  end

  subgraph Storage ["Persistence & State Tier"]
    MongoMemory[("MongoDB Memory Server (Zero-Config Fallback)")]
    MongoAtlas[("MongoDB Atlas / Local MongoDB (Persistent URI)")]
    LocalFS[("Workspace Storage Directory (/Backend/storage/)")]
  end

  subgraph External ["External Services"]
    GitHubAPI["GitHub REST API v3"]
  end

  UI --> Monaco
  UI --> Xterm
  UI --> VCSUI
  UI --> PreviewIframe

  Monaco <-->|CRDT Binary Updates| CollabWS
  Xterm <-->|Bidirectional PTY Stream| TermWS
  PreviewIframe <-->|HTTP Reverse Proxy| PreviewProxy
  VCSUI -->|REST API Requests| VCSCtrl
  UI -->|File CRUD & Project API| ProjectCtrl

  ProjectCtrl --> AuthMW
  VCSCtrl --> AuthMW
  PreviewProxy --> AuthMW

  ProjectCtrl --> DockerDaemon
  ProjectCtrl -.-> HostSandbox
  TermWS <--> DockerDaemon
  TermWS -.-> HostSandbox
  DiskWatcher <--> LocalFS
  DiskWatcher -.-> ProjectCtrl

  ProjectCtrl --> MongoMemory
  ProjectCtrl -.-> MongoAtlas
  VCSCtrl <--> GitHubAPI

4.2 Subsystem Decomposition

Client Tier (/Frontend): Built with React 19, TypeScript, and Vite. Utilizes @monaco-editor/react for high-performance syntax-highlighted code editing, @xterm/xterm for terminal rendering, marked and katex for technical documentation rendering, and jszip for client-side workspace packaging.
Application Gateway Tier (/Backend): Built on Express 5.2 with modular controllers and middleware. It hosts two dedicated WebSocket gateways (/ws/terminal and /ws/collaboration), enforces JWT-based authentication guards, and proxies HTTP traffic to dynamically running ports inside workspaces.
Compute & Execution Tier: Integrates dockerode to spin up isolated container runtimes with strict CPU/memory limits. When Docker is not available on the host, CloudForge seamlessly activates an isolated local workspace directory jail (/Backend/storage/<projectId>/).
Persistence Tier: Utilizes Mongoose 9.9 with dual-mode connectivity: connects to an existing MongoDB URI or automatically spawns an in-memory database daemon via mongodb-memory-server.

5. Literature Review & Theoretical Foundation

CloudForge is grounded in empirical research and peer-reviewed literature across container orchestration, cloud-based collaborative editing, and developer productivity environments.

5.1 Reviewed Papers (RP_1 to RP_10)

ID	Title & Authors	Year & Venue	Core Contribution	Limitations & Research Gaps
RP 1	Leveraging Container Orchestration with Docker and Kubernetes for Web-Based IDEs Y. Tayyebi et al.	2025 PIEMR	Microservices web IDE using Docker containers and Kubernetes HPA for multi-tenant isolation.	Lacks visual Git staging, interactive diff inspection, and zero-install client workspace persistence.
RP 2	Real Time Code Collaborator: A Cloud-Based Platform for Seamless Multi-User Programming S. T. Shruthi et al.	2025 IJARCCE	Full-stack collaborator using WebSockets for sub-second editing and Docker sandboxes.	Designed for transient interview pair sessions; lacks persistent directory trees, commit graphs, and GitHub sync.
RP 3	Cloud vs. Local Development Stacks: Leveraging CDE and PaaS Platforms for Academic Labs R. I. Zuhairnawan et al.	2026 e-Proc. Eng.	Benchmarked CDEs (Codespaces, DevZero) and PaaS for boot time, latency, and resource footprint.	Evaluates existing commercial platforms without offering an open-source, lightweight standalone architecture.
RP 4	Creating a Standardized Environment for Learning Management using GitHub Codespaces A. D. Snowberger & K. You	2024 JPEE	Containerized devcontainer workflows in computer science labs to eliminate setup friction.	Heavy dependency on proprietary Microsoft quotas; high cloud credit costs and VM boot delays.
RP 5	CoVSCode: A Novel Real-Time Collaborative Programming Environment for Lightweight IDE H. Fan et al.	2019 MDPI Appl. Sci.	Operational Transformation (OT) extension for VS Code enabling multi-cursor tracking.	Confined strictly to desktop VS Code installations; lacks zero-install browser access and containerized runtimes.
RP 6	The Impact of Docker, DevOps, and GitHub on Collaborative Open Source Software Development P. S. Emmanni	2023 EJAET	Empirical study on how Docker, CI/CD, and GitHub version control accelerate developer velocity.	Qualitative analysis without proposing an integrated architecture or embedding visual Git workflows in a browser IDE.
RP 7	ATCoPE: Any-Time Collaborative Programming Environment for Synchronous & Asynchronous Teamwork H. Fan et al.	2012 ACM GROUP	Theoretical unification of synchronous pair programming with asynchronous branch version control.	Focuses on buffer concurrency algorithms; lacks modern web containers, GitHub API, diff UI, and cloud terminals.
RP 8	Building Temporary Isolated Workspace in Real-Time Collaborative Programming Environment J. Jiang et al.	2023 IEEE SMC	RECON model isolating broken intermediate code into sandbox buffers during joint editing.	Restricted to buffer-level syntactic isolation; does not address multi-file project persistence or cloud terminals.
RP 9	DoCloud: An Elastic Cloud Platform for Web Applications Based on Docker C. Kan	2016 IEEE ICACT	Elastic cloud hosting platform using Docker containers with predictive (ARMA) and reactive auto-scaling.	Tailored exclusively for server deployment; lacks developer IDE interface, file explorer, or source control tooling.
RP 10	ChainIDE: A Cloud-Based Integrated Development Environment for Smart Contracts H. Qiu et al.	2020 IEEE/ACM Blockchain	Multi-ecosystem cloud IDE with cloud compilation, asynchronous compiler microservices, and templates.	Domain-specific for blockchain smart contracts; lacks generic full-stack developer tooling, visual Git, and terminal access.

5.2 State-of-the-Art Research Gap Matrix

+---------------------------------------------------------------------------------------------------------+
|                                    RESEARCH GAP TAXONOMY MATRIX                                         |
+------------------------------------+---------------------------------------+----------------------------+
| Research Dimension                 | State-of-the-Art Literature           | CloudForge Unified Solution|
+------------------------------------+---------------------------------------+----------------------------+
| 1. Version Control Integration     | CLI-only commands (RP 1, RP 6)        | Visual Git DAG & Diff UI   |
| 2. Development Setup Overhead      | Heavy VMs & Subscription Quotas (RP 4)| Zero-Install Browser IDE   |
| 3. Buffer vs. Workspace Lifecycle  | Transient In-Memory Buffers (RP 2, 8) | MongoDB Hierarchical Tree  |
| 4. Diff & Change Inspection        | Basic Raw Text Differences (RP 7)     | Split & Unified Diff Engine|
| 5. Project Starter & Re-seeding    | Static Single Repositories (RP 10)    | In-Place Template Engine   |
| 6. Remote Repository Interop       | Manual Local Clones / Pulls (RP 6)    | Bidirectional GitHub REST  |
| 7. Execution & Sandboxing          | Heavy Cloud Infrastructure (RP 3, 9)  | Dual-Mode Docker/Local Jail|
| 8. In-Workspace Web App Preview    | External Browsers / Port Forwarding   | Integrated Reverse Proxy   |
+------------------------------------+---------------------------------------+----------------------------+

6. Deep-Dive Feature Specifications

6.1 Browser-Based Multi-Tab IDE & Monaco Editor

Powered by @monaco-editor/react, supporting over 50 programming languages.
Full multi-tab bar with dirty-state indicators (unsaved circles), close actions, and active tab switching.
Keyboard shortcuts: Ctrl+S (Save file), Ctrl+F (Find), Ctrl+H (Find & Replace), Ctrl+P (Quick file navigation).
Rich custom viewers:
- Markdown Viewer: Interactive preview with GitHub-style callouts ([!NOTE], [!TIP], [!IMPORTANT]) and copyable code blocks.
- LaTeX Viewer: Mathematical formulas rendered via KaTeX with live equation formatting.
- IPYNB Viewer: Interactive Jupyter Notebook layout showing cells, markdown explanations, and execution outputs.

6.2 Real-Time Collaboration & CRDT Document Sync

Protocol: Operates over a dedicated WebSocket gateway at ws://localhost:5000/ws/collaboration.
CRDT Engine: Integrates Yjs for conflict-free mathematical convergence across multiple concurrent typists.
State Vector Handshake: When a user opens a file, the client transmits document_sync_step_1 containing its local state vector. The server replies with document_sync_step_2 containing the missing binary updates.
Incremental Binary Updates: Subsequent edits transmit compact delta frames (document_update), slashing bandwidth consumption compared to sending full document text.
Debounced Storage Flush: In-memory CRDT mutations are automatically saved to MongoDB every 8 seconds, or immediately upon user departure.
Presence & Remote Cursors: Transmits cursor positions (line, column) and selections, rendering colored remote user cursors and name flags in real time.
Activity Feed: Broadcasts throttled, user-friendly activity events ("Alice edited main.py", "Bob committed changes").

6.3 Container Sandboxing & Execution Isolation

Built upon dockerode, providing isolated Linux container environments for each project.
Resource Quotas: Standard defaults enforce 1536 MB RAM and 1.5 CPU Cores per workspace to prevent resource exhaustion.
Zero-Config Host Sandbox Fallback: If Docker is not running or unavailable on the host system, CloudForge automatically falls back to an isolated workspace sandbox under /Backend/storage/<projectId>/workspace/.
Terminal navigation within the sandbox is strictly jailed to /workspace using custom shell initialization flags, preventing traversal into the host's root operating system.

6.4 Jailed Cloud Terminal & WebSocket PTY Gateway

Terminal emulator powered by @xterm/xterm with the @xterm/addon-fit and @xterm/addon-web-links plugins.
Connects to ws://localhost:5000/ws/terminal?projectId=<id>&token=<jwt>.
Supports bidirectional interactive input/output, ANSI color codes, text selection, and command execution (e.g., npm install, python app.py, git status).
Disk-to-DB Real-Time Synchronization: A file watcher automatically detects files created, modified, or deleted inside the terminal shell and synchronizes them to MongoDB and the frontend File Explorer in real time.

6.5 Visual Git Engine, Diff Viewer & Commit Graph

Working Tree Tracking: Distinguishes between Staged and Unstaged changes with modification badges: A (Added), M (Modified), and D (Deleted).
Staging Controls: One-click Stage All, Unstage All, or per-file staging and change discarding.
Interactive Commit Diff Viewer:
- Side-by-Side (Split) Mode: Displays original and revised code in adjacent panes with aligned line numbering.
- Unified Mode: Standard line-by-line diff with inline green additions and red deletions.
Commit History Graph: Chronological DAG timeline displaying commit messages, author names, relative timestamps, and short SHA hashes.
Branch Management: Switch between active branches (main, dev, feature) or create new branches on the fly.
GitHub Integration: Link an existing GitHub repository URL, publish a new public/private repository, and synchronize commits bidirectionally using personal access tokens.

6.6 Live Web Application Preview & Reverse Proxy

Automatically scans and detects active HTTP listening ports within the workspace container (e.g., 3000, 5000, 5173, 8080).
Provides an integrated reverse proxy router at /api/projects/:id/preview/:port/*.
Embeds a resizable split-screen iframe or separate preview tab featuring an address bar, reload button, external window launcher, and viewport mode toggles (Desktop, Tablet, Mobile).

6.7 Interactive Multi-Language Execution & Jupyter Notebooks

Multi-language runtime detection automatically identifies project types (Node.js, Python, C++, Go, Rust, Java, Web).
Interactive code execution endpoint (/api/projects/:id/execution/run) evaluates code snippets and streams back stdout, stderr, and execution duration.
Stateful Jupyter kernel controller (/api/projects/:id/kernel/execute) manages in-memory variable scopes across consecutive notebook cell executions.

6.8 Starter Template Presets & Client-Side ZIP Packaging

Pre-configured starter templates ready for instant seeding:
1. React + TypeScript (Vite): Full modern single-page application setup.
2. Node.js + Express: REST API starter with JSON middleware and test endpoints.
3. Python Application: Modular Python script setup with environment templates.
4. Go Web Server: Lightweight Go HTTP server setup.
5. Rust CLI / App: Standard Cargo.toml and main.rs scaffolding.
6. C++ Project: Modern C++ application with Makefile and build scripts.
7. Java Application: Standard Java project structure.
8. Static Web: HTML5, CSS3, and modern JavaScript starter.
9. Blank Project: Clean slate for custom architectures.
Instant Client-Side ZIP Packaging: Generates a structured ZIP file of the entire workspace directly inside the browser using JSZip, allowing instant offline download.

7. Repository Layout & Directory Tree

CloudForge/
├── Backend/
│   ├── src/
│   │   ├── config/
│   │   │   └── db.js                        # Dual-mode Mongoose & MongoMemoryServer manager
│   │   ├── controllers/
│   │   │   ├── authController.js            # User registration, login, JWT issuance
│   │   │   ├── containerController.js       # Container lifecycle & metrics inspection
│   │   │   ├── deployController.js          # Deployment & export management
│   │   │   ├── executionController.js       # Code execution runner endpoints
│   │   │   ├── githubController.js          # GitHub OAuth & repository synchronization
│   │   │   ├── kernelController.js         # Interactive Jupyter notebook cell execution
│   │   │   ├── previewController.js         # Port discovery & reverse proxy streaming
│   │   │   ├── projectController.js         # Project CRUD & listing
│   │   │   └── workspaceController.js       # File tree CRUD, Git commits, Template re-seed
│   │   ├── middleware/
│   │   │   └── auth.js                      # JWT authentication verification middleware
│   │   ├── models/
│   │   │   ├── GitHubConnection.js          # OAuth tokens & linked remote repos
│   │   │   ├── Project.js                   # Project metadata & collaborator roles
│   │   │   ├── ProjectCommit.js             # Commit history & unified diff patches
│   │   │   ├── ProjectFile.js               # Hierarchical file tree nodes & content
│   │   │   └── User.js                      # User credentials & hashed passwords
│   │   ├── routes/                          # Express REST API routes
│   │   ├── services/
│   │   │   ├── cloudRunnerService.js        # Multi-language code execution engine
│   │   │   ├── collaborationGateway.js      # WebSocket gateway (/ws/collaboration)
│   │   │   ├── collaborationService.js      # In-memory Yjs CRDT document cache
│   │   │   ├── containerService.js          # Dockerode isolation & local jail sandbox
│   │   │   ├── portDetectorService.js       # Dynamic container port detection
│   │   │   ├── presenceService.js           # Multi-user presence & cursor tracking
│   │   │   ├── previewProxyService.js       # Live preview HTTP reverse proxy
│   │   │   ├── runtimeRegistry.js           # Language runtime detection & definitions
│   │   │   ├── terminalGateway.js           # WebSocket gateway (/ws/terminal)
│   │   │   └── vcsService.js                # Git staging, diffing, and DAG logic
│   │   ├── app.js                           # Express application configuration
│   │   └── server.js                        # HTTP & WebSocket server entry point
│   ├── storage/                             # Local workspace storage fallback
│   ├── package.json                         # Backend dependencies & scripts
│   └── .env.example                         # Environment configuration template
│
├── Frontend/
│   ├── src/
│   │   ├── collaboration/
│   │   │   ├── CollaborationProvider.tsx    # React collaboration context & event handler
│   │   │   ├── collaborationClient.ts       # Resilient WebSocket connector with reconnect
│   │   │   ├── documentSync.ts              # Yjs CRDT binding for Monaco Editor
│   │   │   └── types.ts                     # Collaboration message definitions
│   │   ├── components/
│   │   │   ├── layout/                      # Navbar, Footer, and Page shells
│   │   │   ├── projects/                    # Project cards, creation modal, template selector
│   │   │   ├── ui/                          # Button, Modal, Dropdown, Spinner primitives
│   │   │   └── workspace/
│   │   │       ├── ActivityBar.tsx          # Left activity dock with tool icons
│   │   │       ├── BottomPanel.tsx          # Terminal drawer & container specs panel
│   │   │       ├── CodeEditor.tsx           # Multi-tab Monaco editor with remote cursors
│   │   │       ├── CollaborationPanel.tsx   # Live collaborators list & activity feed
│   │   │       ├── CommitDetailsModal.tsx   # Commit metadata & patch viewer
│   │   │       ├── DiffViewer.tsx           # Side-by-side & unified diff viewer
│   │   │       ├── FileExplorer.tsx         # Hierarchical file tree with context menus
│   │   │       ├── GitHubRemoteModal.tsx    # Remote repository linking & publishing
│   │   │       ├── PreviewPanel.tsx         # Live web app preview with port switcher
│   │   │       ├── SourceControlPanel.tsx   # Git staging, commit authoring, and DAG graph
│   │   │       ├── StatusBar.tsx            # Bottom status bar with branch & sync status
│   │   │       └── WorkspaceNavbar.tsx      # Project title, avatars, and action controls
│   │   ├── pages/
│   │   │   ├── Dashboard.tsx                # User workspace dashboard
│   │   │   ├── Login.tsx                    # User authentication login page
│   │   │   ├── Register.tsx                 # New developer registration page
│   │   │   ├── Project.tsx                  # Project management overview
│   │   │   └── ProjectView.tsx              # Full-screen IDE workspace
│   │   ├── services/                        # API clients (project, file, git, preview)
│   │   ├── types/                           # TypeScript interfaces and type definitions
│   │   ├── App.tsx                          # React Router routes
│   │   └── main.tsx                         # Client application entry point
│   ├── package.json                         # Frontend dependencies & scripts
│   ├── vite.config.ts                       # Vite bundler configuration
│   └── tsconfig.json                        # TypeScript configuration
│
├── Research Papers/                         # 10 peer-reviewed research papers (RP_1 to RP_10)
├── CloudForge_IEEE_Report.tex               # IEEE-formatted conference & journal paper (.tex)
├── PROJECT_REPORT.md                        # Local execution & verification log
├── future.md                                # Enterprise roadmap & cloud architecture
└── README.md                                # Comprehensive project documentation

8. Comprehensive REST API Reference

8.1 Authentication Endpoints (`/api/auth`)

Method	Endpoint	Description	Request Payload	Response
`POST`	`/api/auth/register`	Register new developer account	`{ name, email, password }`	`{ message, user: { id, name, email }, token }`
`POST`	`/api/auth/login`	Authenticate and obtain JWT token	`{ email, password }`	`{ message, user: { id, name, email }, token }`
`GET`	`/api/auth/me`	Fetch authenticated user profile	Header: `Authorization: Bearer <token>`	`{ user: { id, name, email } }`

8.2 Projects & Workspace Endpoints (`/api/projects`)

Method	Endpoint	Description	Request Payload	Response
`GET`	`/api/projects`	List all projects belonging to user	None	`[ { id, name, template, gitRemote, updatedAt } ]`
`POST`	`/api/projects`	Create a new project with template	`{ name, description, template }`	`{ project: { id, name, template } }`
`GET`	`/api/projects/:id`	Fetch project details & metadata	None	`{ id, name, description, template, gitRemote }`
`GET`	`/api/projects/:id/workspace`	Unified fetch of files, commits, branches	None	`{ project, files: [], commits: [], branches: [] }`
`DELETE`	`/api/projects/:id`	Permanently delete project workspace	None	`{ message: "Project deleted successfully" }`

8.3 File Operations (`/api/projects/:id/files`)

Method	Endpoint	Description	Request Payload
`GET`	`/api/projects/:id/files`	Get flat list of workspace files	None
`POST`	`/api/projects/:id/files`	Create a new file or directory	`{ name, path, isDirectory, content? }`
`PUT`	`/api/projects/:id/files/:fileId`	Update file content	`{ content: "..." }`
`PUT`	`/api/projects/:id/files/:fileId/rename`	Rename file or folder (recursive child update)	`{ newName: "index.ts" }`
`DELETE`	`/api/projects/:id/files/:fileId`	Delete file or directory (recursive delete)	None
`POST`	`/api/projects/:id/workspace/reset-template`	Re-seed project files from starter preset	`{ template: "react" }`

8.4 Git & Source Control Operations (`/api/projects/:id/git`)

Method	Endpoint	Description	Request Payload
`GET`	`/api/projects/:id/git/commits`	Get commit timeline for active branch	None
`GET`	`/api/projects/:id/git/commits/:sha`	Get commit details and diff patch	None
`POST`	`/api/projects/:id/git/commit`	Create a commit and record diff patch	`{ message, files: [ { path, content } ] }`
`POST`	`/api/projects/:id/git/branches`	Switch active branch or create branch	`{ branchName, createNew? }`
`POST`	`/api/projects/:id/git/link-github`	Link project to existing GitHub repository	`{ repoUrl, accessToken }`
`POST`	`/api/projects/:id/git/publish-github`	Create new GitHub repository and push files	`{ repoName, isPrivate, accessToken }`
`POST`	`/api/projects/:id/git/sync`	Pull latest commits and tree from GitHub	`{ accessToken }`

8.5 Live Preview & Port Proxy Endpoints (`/api/projects/:id/preview`)

Method	Endpoint	Description
`GET`	`/api/projects/:id/preview/info`	Detect active listening ports and status in workspace
`ALL`	`/api/projects/:id/preview/:port/*`	Reverse proxy HTTP/HTTPS traffic to in-workspace port
`POST`	`/api/projects/:id/preview/start`	Launch preview dev server daemon inside container
`POST`	`/api/projects/:id/preview/stop`	Terminate running preview process

8.6 Code Execution & Interactive Kernel Endpoints

Method	Endpoint	Description	Request Payload
`POST`	`/api/projects/:id/execution/run`	Execute code file in isolated sandbox	`{ language, code, stdin? }`
`POST`	`/api/projects/:id/kernel/execute`	Execute stateful Jupyter notebook cell	`{ cellId, code, language }`
`POST`	`/api/projects/:id/kernel/restart`	Reset in-memory kernel variable state	None

9. WebSocket Protocol Specifications

CloudForge uses two dedicated WebSocket gateways to prevent multiplexing collisions:

9.1 Terminal Gateway (`/ws/terminal`)

Connection URI: ws://localhost:5000/ws/terminal?projectId=<id>&token=<jwt>
Frame Types:
- stdin (Client -> Server): { type: "stdin", data: "npm run dev\r" }
- resize (Client -> Server): { type: "resize", cols: 120, rows: 32 }
- stdout (Server -> Client): Raw UTF-8 string containing ANSI escape sequences.
- exit (Server -> Client): { type: "exit", exitCode: 0 }

9.2 Collaboration Gateway (`/ws/collaboration`)

Connection URI: ws://localhost:5000/ws/collaboration?projectId=<id>&token=<jwt>

Protocol Frames:

// Handshake Step 1 (Client -> Server)
{ "type": "document_sync_step_1", "fileId": "60a...", "stateVector": "<base64>" }

// Handshake Step 2 (Server -> Client)
{ "type": "document_sync_step_2", "fileId": "60a...", "update": "<base64>" }

// Incremental Edit Delta (Bidirectional)
{ "type": "document_update", "fileId": "60a...", "update": "<base64>" }

// Cursor & Selection Presence (Bidirectional)
{ "type": "presence_cursor", "fileId": "60a...", "cursor": { "line": 12, "col": 4 }, "selection": null }

// Activity Notification (Server -> Client)
{ "type": "activity_event", "id": "act_1720000000_abc", "user": "Alice", "action": "edited", "target": "main.py" }

Security Guard: If an unauthenticated user or non-member attempts to connect to a project room, the connection is instantly rejected with WebSocket close code 1008 (Policy Violation).

10. Localhost Installation & Quickstart Guide

10.1 Prerequisites

Node.js: v18.0.0 or higher (v20+ or v24+ fully supported)
npm (v9+) or yarn / pnpm
Git installed on the local system
(Optional) Docker Desktop (if absent, CloudForge automatically activates its zero-config local workspace sandbox)
(Optional) MongoDB (if absent, CloudForge automatically downloads and boots an in-memory MongoDB server)

10.2 Backend Setup (Zero-Config DB)

# 1. Navigate to the Backend directory
cd Backend

# 2. Install dependencies
npm install

# 3. Create your local environment file
cp .env.example .env

Ensure your Backend/.env contains the default values:

PORT=5000
CLIENT_URL=http://localhost:5173
JWT_SECRET=cloudforge_local_dev_secret_key_12345
NODE_ENV=development

(Leave MONGODB_URI commented out or empty to use the zero-config automatic in-memory MongoDB database.)

# 4. Start the backend development server
npm run dev

The backend API server will boot on http://localhost:5000/ and start both WebSocket endpoints (/ws/terminal and /ws/collaboration).

10.3 Frontend Setup

In a new terminal window:

# 1. Navigate to the Frontend directory
cd Frontend

# 2. Install dependencies
npm install

# 3. Create frontend environment configuration
cp .env.example .env

Ensure your Frontend/.env has:

VITE_API_URL=http://localhost:5000

# 4. Start the Vite development server
npm run dev

Open your browser and navigate to http://localhost:5173.

11. Environment Variables Reference

Backend (`Backend/.env`)

Variable	Default Value	Description
`PORT`	`5000`	HTTP and WebSocket port for Express server
`CLIENT_URL`	`http://localhost:5173`	Allowed CORS origin for frontend requests
`JWT_SECRET`	(Required string)	Secret key used for signing and verifying JWT tokens
`NODE_ENV`	`development`	Node runtime environment (`development` or `production`)
`MONGODB_URI`	Optional	MongoDB connection URI (Atlas or local). If omitted, boots `MongoMemoryServer`
`GITHUB_CLIENT_ID`	Optional	GitHub OAuth Client ID for repository operations
`GITHUB_CLIENT_SECRET`	Optional	GitHub OAuth Client Secret
`GITHUB_CALLBACK_URL`	`http://localhost:5000/api/github/callback`	OAuth redirect URI

Frontend (`Frontend/.env`)

Variable	Default Value	Description
`VITE_API_URL`	`http://localhost:5000`	Base URL for Backend REST API and WebSockets

12. Automated Verification & Test Suites

CloudForge includes comprehensive verification scripts to ensure complete system health:

12.1 Frontend Build & Type Check

Verify that all TypeScript types, React components, and Vite bundle configurations compile with zero errors:

cd Frontend
npm run build

Expected Result: All 4,200+ modules transform and compile into dist/ with 0 compiler errors.

12.2 Multi-User Collaboration End-to-End Test Suite

Tests real-time CRDT synchronization, concurrent edits, presence tracking, file system events, Git broadcasts, security guards, and terminal independence:

cd Backend
node scripts/test-collaboration-e2e.js

12.3 API Health Verification

# Health Check Endpoint
curl http://localhost:5000/health
# Response: { "status": "healthy", "environment": "development" }

# Service Info Endpoint
curl http://localhost:5000/
# Response: Service metadata with active capabilities

13. Security Architecture & Threat Mitigation

Jailed Workspace Environment:
- Terminal sessions are strictly jailed to /workspace using isolated shell flags.
- Prevents unauthorized navigation into system root or parent directories on the host operating system.
Path Traversal Sanitization:
- All file operations pass through strict path canonicalization algorithms (path.resolve with root prefix validation) to neutralize directory traversal exploits (../../etc/passwd).
Multi-Tenant Collaboration Authorization:
- The /ws/collaboration gateway intercepts all upgrade requests and validates JWT tokens against the requested projectId.
- Unauthorized attempts result in immediate connection closure with WebSocket code 1008.
Credential Hashing & Protection:
- Passwords are salted and hashed using bcryptjs with standard 10 salt rounds.
- Remote GitHub Personal Access Tokens and OAuth credentials are never stored in cleartext.
CORS & CSRF Protection:
- Strict CORS policies restrict HTTP requests and WebSocket connections to designated CLIENT_URL origins.

14. Cloud Computing Conceptual Framework

CloudForge is engineered around foundational cloud computing principles, virtualizing the entire software development lifecycle by transferring compute, memory, runtime execution, and persistent storage from physical local developer machines into scalable, isolated cloud containers.

14.1 PaaS & CaaS Service Models

Platform as a Service (PaaS): Traditional development requires engineers to manually configure SDKs, compilers, system paths, and package managers. CloudForge abstracts the underlying operating system and hardware away, provisioning complete developer stacks on-demand (Node 20, Python 3.11, Go 1.22, Rust 1.76, GCC, Java 17).
Containers as a Service (CaaS): Workspaces run inside containerized sandbox environments orchestrated dynamically via the Docker Engine API and the dedicated Cloud Runner microservice.

14.2 Containerization & Hardware Abstraction

Uses Linux namespaces, control groups (cgroups), and filesystem mounts to provide isolated execution boundaries.
Compute limits, network access, and memory allocations are isolated per tenant, ensuring that intensive builds (e.g. npm install, cargo build) cannot exhaust host resources or compromise co-located tenants.

14.3 Multi-Tenant Sandbox Isolation

Filesystem Virtualization: File access is strictly bound to /workspace utilizing path canonicalization and directory-jail algorithms to prevent directory traversal attacks.
Path Virtualization & Redaction: Host paths and internal server tokens are dynamically sanitized from terminal stdout streams before reaching the browser client, ensuring tenants perceive an authentic standalone cloud environment.

14.4 Distributed Document Synchronization & CRDTs

Real-time concurrent multi-user editing is achieved via Conflict-Free Replicated Data Types (CRDTs) powered by Yjs over full-duplex WebSocket channels.
State updates converge mathematically across all connected peers with zero merge conflicts, sub-millisecond latency, and automatic offline recovery.

14.5 Event-Driven PTY WebSocket Streaming

Instead of inefficient HTTP polling, CloudForge allocates an asynchronous Pseudo-Terminal (PTY) on the host/container that connects to the browser's Xterm.js engine via WebSockets (/ws/terminal).
Keystrokes and raw ANSI escape sequences stream bidirectionally with sub-millisecond latency, supported by an in-memory 16ms buffering streamer for high-throughput CLI output.

15. AWS Cloud Deployment Architecture & Runbook

CloudForge is deployed as a unified full-stack platform on Amazon Web Services (AWS) using an EC2 Virtual Machine (Ubuntu 24.04 LTS) paired with Nginx (reverse proxy + SSL termination), Docker Engine, and PM2 Process Manager.

15.1 Production Infrastructure Topology

                    Internet (Users & Developers)
                                 │
                                 │ HTTPS (443) / WSS (WebSockets)
                                 ▼
                    ┌────────────────────────────┐
                    │      AWS EC2 Instance      │ (Ubuntu 24.04 LTS)
                    │                            │
                    │   Nginx Reverse Proxy      │ (Port 80 / 443 + SSL)
                    │   ├── Static Web (/dist)   │ ──> Serves React/Vite UI
                    │   ├── REST Proxy (/api/*)  │ ──> http://127.0.0.1:5000
                    │   └── WS Proxy (/ws/*)     │ ──> http://127.0.0.1:5000
                    │                            │
                    │   PM2 Process Manager      │
                    │   └── CloudForge Backend   │ (Node.js API + WebSockets)
                    │                            │
                    │   Docker Engine (Daemon)   │
                    │   └── Workspace Containers │ (Polyglot Isolated Sandboxes)
                    └────────────┬───────────────┘
                                 │ TLS / SRV
                                 ▼
                    ┌────────────────────────────┐
                    │    MongoDB Atlas Cluster   │ (Cloud Database)
                    └────────────────────────────┘

15.2 Step-by-Step EC2 Deployment Guide

Step 1: Launch EC2 Instance & Configure Security Group

Launch an Ubuntu Server 24.04 LTS instance (t3.small or t3.medium, 20 GB gp3 storage).
Configure Security Group Inbound Rules:
- HTTP (80): 0.0.0.0/0 (Web traffic & ACME challenge)
- HTTPS (443): 0.0.0.0/0 (Secure web traffic)
- SSH (22): Your IP address

Step 2: Connect and Install Dependencies

# Update OS packages and install core build tools & Nginx
sudo apt-get update && sudo DEBIAN_FRONTEND=noninteractive apt-get upgrade -y
sudo apt-get install -y curl git nginx build-essential docker.io

# Install Node.js 20 LTS & PM2
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt-get install -y nodejs
sudo npm install -g pm2

# Configure Docker permissions
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
newgrp docker

Step 3: Clone Repository & Start Backend

cd ~
git clone https://github.com/Next-Gen-Coder-2007/CloudForge-A-Cloud-Native-Collaborative-Development-Workspace.git CloudForge

cd ~/CloudForge/Backend
npm install --omit=dev

# Configure production environment
cat << 'EOF' > .env
PORT=5000
MONGO_URI=mongodb+srv://<user>:<password>@cluster0.plib4zt.mongodb.net
JWT_SECRET=cf_prod_sec_jwt_981742987142987142
JWT_EXPIRES_IN=7d
CLIENT_URL=*
NODE_ENV=production
CLOUD_RUNNER_API_URL=http://localhost:5050
CLOUD_RUNNER_API_KEY=cf_live_sec_your_secret_runner_key
EOF

# Start Backend using PM2
pm2 start src/server.js --name "cloudforge-backend"
pm2 save
pm2 startup

Step 4: Build Frontend & Configure Nginx

cd ~/CloudForge/Frontend
npm install
npm install @tailwindcss/oxide-linux-x64-gnu lightningcss-linux-x64-gnu --save-optional
npm run build

# Configure Nginx reverse proxy
sudo tee /etc/nginx/sites-available/cloudforge > /dev/null << 'EOF'
server {
    listen 80;
    server_name _;

    root /home/ubuntu/CloudForge/Frontend/dist;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }

    location /api/ {
        proxy_pass http://127.0.0.1:5000;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    location /ws/ {
        proxy_pass http://127.0.0.1:5000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;
    }
}
EOF

# Enable site and set directory permissions
chmod 755 /home/ubuntu
sudo rm -f /etc/nginx/sites-enabled/default
sudo ln -sf /etc/nginx/sites-available/cloudforge /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl restart nginx

15.3 Free SSL / TLS Termination with Let's Encrypt

Point an A record from your domain to your EC2 Public IP, then run:

sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com -d www.your-domain.com

16. Presentation & Seminar Speech Guide

A comprehensive, academically rigorous guide designed for presenting CloudForge at university seminars, final-year project evaluations, and technical cloud conferences.

16.1 Cloud Positioning & Presentation Strategy

When presenting CloudForge to professors and evaluators, frame the project through the lens of Modern Cloud Computing:

Cloud Service Model Triad (IaaS + CaaS + PaaS + SaaS):
- IaaS (Infrastructure as a Service): Hosted on Amazon Web Services (AWS) Elastic Compute Cloud (EC2) running Ubuntu Linux, leveraging cloud elasticity, virtual hardware, and security groups.
- CaaS (Containers as a Service): Dynamic creation and isolation of containerized runtime environments using Docker Engine, isolating processes via Linux kernel namespaces and cgroups.
- PaaS (Platform as a Service): CloudForge operates as an intelligent cloud platform that automatically inspects project dependencies, maps network ports, provisions language runtimes (Node, Python, Go, Rust, Java, C++), and exposes an internal reverse proxy.
- SaaS (Software as a Service): The end-user developer consumes the complete IDE interface via standard web browsers over HTTPS/WSS without downloading or configuring local software.
NIST Cloud Computing Characteristics Demonstrated:
- On-Demand Self-Service: Developers provision fresh, fully configured workspaces with a single click.
- Broad Network Access: Workspaces are accessible from any device (laptop, tablet, Chromebook) through standard web protocols.
- Resource Pooling & Multi-Tenancy: Multi-tenant workspace sandboxes share compute and memory resources under strict isolation boundaries.
- Rapid Elasticity: Cloud containers spin up instantaneously and tear down when idle, minimizing compute overhead.
- Measured Service: Resource usage (CPU, RAM, container run-time) is metered and supervised.

16.2 Slide-by-Slide Presentation Script (Cloud & AWS Deployment)

Slide 1: Title & The Cloud Paradigm Shift in Software Engineering

"Good morning respected evaluators, professors, and fellow engineers. Today, I am thrilled to present CloudForge: A Cloud-Native Collaborative Development Workspace.

Over the past decade, we have witnessed nearly every computing workload migrate from on-premise hardware to the cloud: email, storage, continuous integration, and database hosting. Yet, the primary software engineering activity—the developer workstation—has remained stubbornly tied to local machines.

Every developer knows the frustration of spending hours installing runtimes, fighting PATH variables, dealing with compiler mismatches between Windows, macOS, and Linux, and uttering the infamous phrase: 'It works on my machine, why doesn't it work in production?'.

CloudForge eliminates this paradigm entirely by virtualizing the developer workstation directly into the cloud."

Slide 2: Problem Statement & Motivation

"Traditional development setups suffer from four major bottlenecks:

Hardware constraints—compiling large codebases or running containers is impossible on low-end laptops or mobile devices.

Configuration drift—team members write code on different runtime versions, causing subtle deployment bugs.

Toolchain fragmentation—developers juggle separate text editors, CLI terminals, Git clients, and preview browsers.

Heavyweight commercial solutions—platforms like GitHub Codespaces often incur high costs, proprietary lock-in, and 30-to-60-second cold-boot latencies.

CloudForge solves this by providing an instant-boot, zero-installation cloud workspace delivering code editing, terminal execution, real-time collaboration, and web previews in a single browser window."

Slide 3: Cloud Computing 3-Tier Architecture

"Architecturally, CloudForge is constructed on a cloud-native 3-tier topology:

The Client Presentation Tier: Built with React, TypeScript, and the Monaco Editor (the same core engine powering VS Code), paired with Xterm.js for high-frequency ANSI terminal emulation.

The Cloud Gateway & Microservices Tier: An Express.js and Node.js gateway managing JWT security, REST APIs, and full-duplex WebSocket connections for terminal PTY streaming and collaboration.

The Isolated Sandbox & Persistence Tier: A containerized execution engine using Docker to isolate tenant workspaces, backed by MongoDB Atlas cloud database cluster for persistent multi-user storage.

All communication between tiers is asynchronous, stateless, and event-driven."

Slide 4: Real-Time Distributed Synchronization & PTY Streaming

"Two major engineering breakthroughs power our user experience:

First, Real-Time Collaboration: We utilize Conflict-Free Replicated Data Types (CRDTs) via the Yjs framework over WebSockets. This guarantees eventual mathematical consistency across all connected users with zero merge conflicts, even under adverse network latency.

Second, Jailed Cloud Shell: We stream raw pseudo-terminal (PTY) byte streams directly from Docker containers to the browser. Keystrokes are buffered at a tuned 16ms window, decoupling terminal I/O from disk synchronization to achieve zero perceivable typing lag."

Slide 5: Production AWS Cloud Deployment

"CloudForge is not just a localhost prototype—it is a fully deployed, production-grade cloud service running on Amazon Web Services (AWS):

We provisioned an AWS EC2 Compute Instance running Ubuntu 24.04 LTS.

We implemented an Nginx High-Performance Reverse Proxy as the single public entry point on Port 80, handling HTTP/1.1 WebSocket connection upgrades (Upgrade, Connection: upgrade) with extended 24-hour timeouts.

The backend runs under the PM2 Process Supervisor, providing background daemonization, automatic crash recovery, and instant boot persistence across server reboots.

Data persistence is decoupled to a globally replicated MongoDB Atlas cloud cluster.

For deployment optimization on Linux x64, we compiled native high-performance binary bindings for LightningCSS and Tailwind Oxide, achieving sub-12-second production builds.

Anyone worldwide can access the platform at our public AWS IP right now."

Slide 6: Key Technical Differentiators

"To summarize our technical highlights:

Dual-Engine Preview: Cloud container reverse proxying plus an instant in-browser live preview engine powered by React 18 and Babel Standalone.

Polyglot Zero-Config Runtimes: Instant support for JavaScript, TypeScript, Python, Go, Rust, Java, and C++.

Deep Security: Jailed workspace sandboxes, path-traversal sanitization, and strict multi-tenant boundary isolation.

Enterprise Aesthetics: A clean, professional dark-mode design system with zero distracting artifacts."

Slide 7: Conclusion & Future Roadmap

"CloudForge embodies the core principles of Cloud Computing: resource centralization, elasticity, and ubiquitous network accessibility.

In our future roadmap, we have architected a custom Kubernetes Operator (cloudforge-operator) to dynamically scale workspace pods across multi-region Kubernetes clusters (Amazon EKS) with AWS EBS persistent storage.

CloudForge demonstrates that the future of software development is cloud-native, collaborative, and accessible from anywhere.

Thank you. We are now ready for the live demonstration and Q&A."

16.3 Live Demonstration Walkthrough Guide (AWS Cloud Demo)

Follow this exact sequential demonstration during your viva or project presentation.

Step	Action on Screen	Spoken Demonstration Script	Cloud Engineering Concept
1. Accessing Public Cloud	Open browser to `http://52.64.52.214` (AWS EC2)	"Notice that my laptop is running no local servers or Node.js processes. We are accessing CloudForge directly on our public AWS EC2 cloud instance over the internet."	IaaS / SaaS Delivery Model
2. Authentication & Dashboard	Log into an account; view workspace list	"Authentication is secured via JSON Web Tokens (JWT), verifying credentials against our MongoDB Atlas cloud cluster."	Stateless Auth & Cloud Persistence
3. One-Click Provisioning	Click Create Project, select template (e.g., React or Python)	"In one click, CloudForge provisions an isolated cloud workspace and mounts the project directory tree."	On-Demand Self-Service (PaaS)
4. Cloud Monaco Editing	Open `App.js` or `main.py`, edit code	"Monaco Editor gives us full IntelliSense, bracket matching, and syntax highlighting rendered natively in the browser."	Browser-Based Compute UI
5. Jailed Cloud Terminal	Type `uname -a`, `ls -la`, or `python --version`	"This terminal is a full-duplex WebSocket streaming directly from the AWS Linux host inside our sandbox container."	Event-Driven WebSocket PTY Streaming
6. Live Web App Preview	Click Run / `npm start`, switch to Preview	"CloudForge's Port Detector automatically discovers port 3000 and reverse-proxies the running web application into an embedded sandbox iframe."	Reverse Proxy & Dynamic Port Forwarding
7. Real-Time Collaboration	Open a secondary incognito window side-by-side	"Watch as I type in the left window: the right window updates instantly with remote cursor awareness using Yjs CRDTs without merge conflicts."	Decentralized Data Synchronization
8. Visual Git Engine	Stage a file, view visual diff, commit	"Developers can stage changes, review colored side-by-side diffs, and inspect commit timeline graphs without memorizing Git CLI syntax."	Integrated Developer Toolchain

16.4 Viva & Defense Q&A Preparation (Cloud & Deployment Deep-Dive)

Be prepared to answer these specific technical questions regarding Cloud Computing and AWS Deployment:

Q1: Which Cloud Service Model (IaaS, PaaS, SaaS) does CloudForge belong to?

Model Answer: *"CloudForge spans multiple cloud layers:

At the Infrastructure layer (IaaS): It is deployed on AWS EC2, consuming virtual compute, RAM, and elastic networking.

At the Platform layer (PaaS / CaaS): CloudForge itself acts as a development platform. It manages Docker containers, isolates workspaces, detects ports, compiles polyglot code, and proxies services automatically.

At the Application layer (SaaS): For end-user software engineers, CloudForge is delivered as a zero-install software service accessible via standard web browsers."*

Q2: How does CloudForge satisfy the 5 Essential Characteristics of Cloud Computing defined by NIST?

Model Answer:

*"On-demand self-service: Users spin up new language runtime workspaces independently with one click.

Broad network access: Any device with a modern browser (Windows, macOS, Linux, iPadOS, ChromeOS) can access the full IDE over standard HTTP/WebSocket protocols.

Resource pooling: Compute and memory resources of the AWS host are dynamically pooled and shared across tenant containers.

Rapid elasticity: Sandboxes scale from zero footprint to running state in milliseconds, conserving cloud resources.

Measured service: System load, container processes, and storage quotas are monitored per workspace."*

Q3: Describe the production AWS deployment architecture in detail.

Model Answer: *"Our AWS production architecture consists of:

AWS EC2 Instance: Running Ubuntu 24.04 LTS in an AWS VPC with Security Groups permitting inbound HTTP (Port 80), HTTPS (Port 443), and SSH (Port 22).

Nginx Reverse Proxy: Listening on Port 80, serving optimized static frontend bundles directly from disk with gzip compression, while reverse-proxying /api/ traffic to Express.js on port 5000 and upgrading /ws/ to WebSocket connections.

PM2 Process Manager: Supervised Node.js clustering for zero-downtime execution, automatic memory restart triggers, and systemd boot hooks.

MongoDB Atlas: Multi-region cloud replica set connected via encrypted TLS connection strings for transactional metadata and file persistence."*

Q4: Why did you use an Nginx reverse proxy instead of exposing Express.js directly to the internet?

Model Answer: *"Exposing Express.js directly to port 80/443 in production is an anti-pattern for four key reasons:

Security: Nginx protects the Node.js runtime from slowloris attacks, malformed request floods, and buffer overflows.

WebSocket Upgrade Handling: Nginx manages HTTP/1.1 Upgrade and Connection headers with persistent keep-alive timeouts (proxy_read_timeout 86400s), preventing cloud proxy disconnects.

Static File Performance: Nginx uses the Linux kernel sendfile syscall to serve static assets directly from disk without touching the Node.js event loop.

Port Binding Privileges: Node.js runs safely as the unprivileged ubuntu user rather than requiring root privileges to bind to privileged ports 80/443."*

Q5: How is multi-tenancy and sandbox security enforced between concurrent users?

Model Answer: *"Multi-tenancy is enforced through defense-in-depth:

Authentication: All HTTP requests and WebSocket handshakes require valid JWT tokens; users can only access projects they own or are invited to.

Filesystem Chroot: Workspace roots are strictly bounded. Relative paths like ../../ are intercepted by path-sanitization guards before file operations execute.

Container Isolation: In containerized mode, Docker utilizes Linux kernel namespaces (PID, Mount, Net, IPC) and cgroups to cap CPU and RAM allocation, preventing noisy-neighbor starvation or host kernel compromises."*

Q6: How does CloudForge solve the problem of terminal lag over cloud networks?

Model Answer: *"Terminal latency in web IDEs is typically caused by event-loop blocking and excessive disk I/O. We resolved this through three architectural optimizations:

16ms Output Buffering: Instead of sending a WebSocket frame for every single character output by CLI tools, we aggregate output in a 16ms window (matching 60fps monitor refreshes).

Fast-Path Echo: Keystroke echoes bypass full disk sweeps and return immediately to Xterm.js.

Asynchronous Mutex-Locked Disk Syncing: Disk-to-database synchronization runs asynchronously with debouncing and skips giant lockfiles (like package-lock.json >256KB), ensuring the terminal remains silky-smooth."*

Q7: What deployment challenges did you encounter on AWS Linux and how were they solved?

Model Answer: *"When building modern frontends on Linux (Ubuntu), packages like Tailwind CSS v4 and LightningCSS rely on platform-specific C++ native binaries (.linux-x64-gnu.node). Because npm lockfiles generated on Windows default to Windows architectures, building on Linux initially failed with missing native bindings.

We resolved this by explicitly targeting Linux dependencies (@tailwindcss/oxide-linux-x64-gnu and lightningcss-linux-x64-gnu), allowing Vite and TypeScript to produce a production-ready, minified bundle in under 12 seconds on the EC2 instance."*

Q8: How would you scale CloudForge to 10,000 concurrent developers in the future?

Model Answer: *"To scale CloudForge to enterprise scale:

Stateless API Gateway: Deploy Express API instances behind an AWS Application Load Balancer (ALB) with Auto-Scaling Groups.

Distributed WebSockets: Integrate a Redis Pub/Sub backplane so WebSocket sessions can communicate across multiple API server instances.

Kubernetes CDE Orchestration: Migrate single-host Docker containers to Amazon EKS (Elastic Kubernetes Service) using our proposed cloudforge-operator, provisioning ephemeral WorkspacePod instances with Amazon EBS/EFS persistent storage volumes."*

17. Future Cloud-Native Scalability Roadmap

As detailed in future.md, CloudForge provides an architectural blueprint for enterprise hyperscaling:

Phase 4: Kubernetes Custom Operator (cloudforge-operator): Dynamic provisioning of Custom Resource Definitions (WorkspacePod, WorkspaceVolume) across multi-node clusters.
Phase 5: Distributed Storage & Snapshots: Shared Ceph / AWS EBS dynamic persistent volume claims with sub-second volume snapshotting.
Phase 7: Cloud CI/CD Pipelines: In-workspace daemonless container builds via Kaniko and BuildKit.
Phase 8: Enterprise RBAC & Audit Trails: Granular workspace permissions (Viewer, Editor, Admin) with immutable audit logging.

18. License & Acknowledgments

This project is open-source software licensed under the MIT License.

Academic Research Basis

CloudForge is developed with theoretical and architectural reference to ten landmark research publications in container orchestration, cloud-based IDEs, and collaborative computing (RP_1 through RP_10), available in the Research Papers/ directory.

Name		Name	Last commit message	Last commit date
Backend		Backend
Frontend		Frontend
Research Papers		Research Papers
api		api
.gitignore		.gitignore
CloudForge_IEEE_Report.tex		CloudForge_IEEE_Report.tex
Initial Report.pdf		Initial Report.pdf
PROJECT_REPORT.md		PROJECT_REPORT.md
README.md		README.md
cloud-forge-a-cloud-native-collabor.vercel.app.har		cloud-forge-a-cloud-native-collabor.vercel.app.har
future.md		future.md
methodology.png		methodology.png
package-lock.json		package-lock.json
package.json		package.json
vercel.json		vercel.json

Latest commit

History

Folders and files

Repository files navigation