.githooks/pre-push

@@ -8,7 +8,7 @@ NOCOLOR='\033[0m'
 
 # Run tests before push
 echo -e "\n${CYAN}Running tests...${NOCOLOR}"
-cd "$(git rev-parse --show-toplevel)/core" && go test ./...
+go test ./...   # Runs all tests in your repo
 status=$?
 if [ $status -ne 0 ]; then
   echo -e "${RED}Push aborted: some tests failed.${NOCOLOR}"

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,91 +0,0 @@
-name: Bug Report
-description: Report a bug in Orama Network
-labels: ["bug"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for reporting a bug! Please fill out the sections below.
-
-        **Security issues:** If this is a security vulnerability, do NOT open an issue. Email security@orama.io instead.
-
-  - type: input
-    id: version
-    attributes:
-      label: Orama version
-      description: "Run `orama version` to find this"
-      placeholder: "v0.18.0-beta"
-    validations:
-      required: true
-
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      options:
-        - Gateway / API
-        - CLI (orama command)
-        - WireGuard / Networking
-        - RQLite / Storage
-        - Olric / Caching
-        - IPFS / Pinning
-        - CoreDNS
-        - OramaOS
-        - Other
-    validations:
-      required: true
-
-  - type: textarea
-    id: description
-    attributes:
-      label: Description
-      description: A clear description of the bug
-    validations:
-      required: true
-
-  - type: textarea
-    id: steps
-    attributes:
-      label: Steps to reproduce
-      description: Minimal steps to reproduce the behavior
-      placeholder: |
-        1. Run `orama ...`
-        2. See error
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected
-    attributes:
-      label: Expected behavior
-      description: What you expected to happen
-    validations:
-      required: true
-
-  - type: textarea
-    id: actual
-    attributes:
-      label: Actual behavior
-      description: What actually happened (include error messages and logs if any)
-    validations:
-      required: true
-
-  - type: textarea
-    id: environment
-    attributes:
-      label: Environment
-      description: OS, Go version, deployment environment, etc.
-      placeholder: |
-        - OS: Ubuntu 22.04
-        - Go: 1.23
-        - Environment: sandbox
-    validations:
-      required: false
-
-  - type: textarea
-    id: context
-    attributes:
-      label: Additional context
-      description: Logs, screenshots, monitor reports, or anything else that might help
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,49 +0,0 @@
-name: Feature Request
-description: Suggest a new feature or improvement
-labels: ["enhancement"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for the suggestion! Please describe what you'd like to see.
-
-  - type: dropdown
-    id: component
-    attributes:
-      label: Component
-      options:
-        - Gateway / API
-        - CLI (orama command)
-        - WireGuard / Networking
-        - RQLite / Storage
-        - Olric / Caching
-        - IPFS / Pinning
-        - CoreDNS
-        - OramaOS
-        - Other
-    validations:
-      required: true
-
-  - type: textarea
-    id: problem
-    attributes:
-      label: Problem
-      description: What problem does this solve? Why do you need it?
-    validations:
-      required: true
-
-  - type: textarea
-    id: solution
-    attributes:
-      label: Proposed solution
-      description: How do you think this should work?
-    validations:
-      required: true
-
-  - type: textarea
-    id: alternatives
-    attributes:
-      label: Alternatives considered
-      description: Any workarounds or alternative approaches you've thought of
-    validations:
-      required: false

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,31 +0,0 @@
-## Summary
-
-<!-- What does this PR do? Keep it to 1-3 bullet points. -->
-
-## Motivation
-
-<!-- Why is this change needed? Link to an issue if applicable. -->
-
-## Test plan
-
-<!-- How did you verify this works? -->
-
-- [ ] `make test` passes
-- [ ] Tested on sandbox/staging environment
-
-## Distributed system impact
-
-<!-- Does this change affect any of the following? If yes, explain. -->
-
-- [ ] Raft quorum / RQLite
-- [ ] WireGuard mesh / networking
-- [ ] Olric gossip / caching
-- [ ] Service startup ordering
-- [ ] Rolling upgrade compatibility
-
-## Checklist
-
-- [ ] Tests added for new functionality or bug fix
-- [ ] No debug code (`fmt.Println`, `log.Println`) left behind
-- [ ] Docs updated (if user-facing behavior changed)
-- [ ] Errors wrapped with context (`fmt.Errorf("...: %w", err)`)

.github/workflows/publish-sdk.yml

@@ -1,80 +0,0 @@
-name: Publish SDK to npm
-
-on:
-  workflow_dispatch:
-    inputs:
-      version:
-        description: "Version to publish (e.g., 1.0.0). Leave empty to use package.json version."
-        required: false
-      dry-run:
-        description: "Dry run (don't actually publish)"
-        type: boolean
-        default: false
-
-permissions:
-  contents: write
-
-jobs:
-  publish:
-    name: Build & Publish @debros/orama
-    runs-on: ubuntu-latest
-    defaults:
-      run:
-        working-directory: sdk
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Set up Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Install pnpm
-        uses: pnpm/action-setup@v4
-        with:
-          version: 9
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Bump version
-        if: inputs.version != ''
-        run: npm version ${{ inputs.version }} --no-git-tag-version
-
-      - name: Typecheck
-        run: pnpm typecheck
-
-      - name: Build
-        run: pnpm build
-
-      - name: Run unit tests
-        run: pnpm vitest run tests/unit
-
-      - name: Publish (dry run)
-        if: inputs.dry-run == true
-        run: npm publish --access public --dry-run
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Publish
-        if: inputs.dry-run == false
-        run: npm publish --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-
-      - name: Get published version
-        if: inputs.dry-run == false
-        id: version
-        run: echo "version=$(node -p "require('./package.json').version")" >> $GITHUB_OUTPUT
-
-      - name: Create git tag
-        if: inputs.dry-run == false
-        working-directory: .
-        run: |
-          git config user.name "github-actions[bot]"
-          git config user.email "github-actions[bot]@users.noreply.github.com"
-          git tag "sdk/v${{ steps.version.outputs.version }}"
-          git push origin "sdk/v${{ steps.version.outputs.version }}"

.github/workflows/release-apt.yml

@@ -28,8 +28,7 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v5
         with:
-          go-version: "1.24"
-          cache-dependency-path: core/go.sum
+          go-version: "1.23"
 
       - name: Get version
         id: version
@@ -47,7 +46,6 @@ jobs:
         uses: docker/setup-qemu-action@v3
 
       - name: Build binary
-        working-directory: core
         env:
           GOARCH: ${{ matrix.arch }}
           CGO_ENABLED: 0
@@ -73,7 +71,7 @@ jobs:
           mkdir -p ${PKG_NAME}/usr/local/bin
 
           # Copy binaries
-          cp core/build/usr/local/bin/* ${PKG_NAME}/usr/local/bin/
+          cp build/usr/local/bin/* ${PKG_NAME}/usr/local/bin/
           chmod 755 ${PKG_NAME}/usr/local/bin/*
 
           # Create control file

.github/workflows/release.yaml

@@ -23,8 +23,8 @@ jobs:
       - name: Set up Go
         uses: actions/setup-go@v4
         with:
-          go-version: '1.24'
-          cache-dependency-path: core/go.sum
+          go-version: '1.21'
+          cache: true
       
       - name: Run GoReleaser
         uses: goreleaser/goreleaser-action@v5

.gitignore

@@ -1,50 +1,4 @@
-# === Global ===
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-*.swp
-*.swo
-*~
-
-# IDE
-.vscode/
-.idea/
-.cursor/
-
-# Environment & credentials
-.env
-.env.*
-!.env.example
-.mcp.json
-.claude/
-.codex/
-
-# === Core (Go) ===
-core/phantom-auth/
-core/bin/
-core/bin-linux/
-core/dist/
-core/orama-cli-linux
-core/keys_backup/
-core/.gocache/
-core/configs/
-core/data/*
-core/tmp/
-core/temp/
-core/results/
-core/rnd/
-core/vps.txt
-core/coverage.txt
-core/coverage.html
-core/profile.out
-core/e2e/config.yaml
-core/scripts/remote-nodes.conf
-
-# Go build artifacts
+# Binaries
 *.exe
 *.exe~
 *.dll
@@ -52,39 +6,91 @@ core/scripts/remote-nodes.conf
 *.dylib
 *.test
 *.out
+bin/
+bin-linux/
+dist/
+orama-cli-linux
+
+# Build artifacts
 *.deb
 *.rpm
 *.tar.gz
 *.zip
+
+# Go
 go.work
+.gocache/
+
+# Dependencies
+# vendor/
+
+# Environment & credentials
+.env
+.env.*
+.env.local
+.env.*.local
+scripts/remote-nodes.conf
+keys_backup/
+e2e/config.yaml
+
+# Config (generated/local)
+configs/
+
+# Data & databases
+data/*
+*.db
+
+# IDE & editor files
+.vscode/
+.idea/
+.cursor/
+.claude/
+.mcp.json
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
 
 # Logs
 *.log
 
-# Databases
-*.db
+# Temporary files
+tmp/
+temp/
+*.tmp
 
-# === Website ===
-website/node_modules/
-website/dist/
-website/invest-api/invest-api
-website/invest-api/*.db
-website/invest-api/*.db-shm
-website/invest-api/*.db-wal
+# Coverage & profiling
+coverage.txt
+coverage.html
+profile.out
 
-# === SDK (TypeScript) ===
-sdk/node_modules/
-sdk/dist/
-sdk/coverage/
-
-# === Vault (Zig) ===
-vault/.zig-cache/
-vault/zig-out/
-
-# === OS ===
-os/output/
-
-# === Local development ===
+# Local development
 .dev/
 .local/
 local/
+.codex/
+results/
+rnd/
+vps.txt
+
+# Project subdirectories (managed separately)
+website/
+phantom-auth/
+
+# One-off scripts & tools
+redeploy-6.sh
+terms-agreement
+./bootstrap
+./node
+./cli
+./inspector
+docs/later_todos/
+sim/

.goreleaser.yaml

@@ -9,13 +9,11 @@ env:
 
 before:
   hooks:
-    - cmd: go mod tidy
-      dir: core
+    - go mod tidy
 
 builds:
   # orama CLI binary
   - id: orama
-    dir: core
     main: ./cmd/cli
     binary: orama
     goos:
@@ -33,7 +31,6 @@ builds:
 
   # orama-node binary (Linux only for apt)
   - id: orama-node
-    dir: core
     main: ./cmd/node
     binary: orama-node
     goos:
@@ -87,7 +84,7 @@ nfpms:
     section: utils
     priority: optional
     contents:
-      - src: ./core/README.md
+      - src: ./README.md
         dst: /usr/share/doc/orama/README.md
     deb:
       lintian_overrides:
@@ -109,7 +106,7 @@ nfpms:
     section: net
     priority: optional
     contents:
-      - src: ./core/README.md
+      - src: ./README.md
         dst: /usr/share/doc/orama-node/README.md
     deb:
       lintian_overrides:

CONTRIBUTING.md

@@ -1,78 +1,47 @@
-# Contributing to Orama Network
+# Contributing to DeBros Network
 
-Thanks for helping improve the network! This monorepo contains multiple projects — pick the one relevant to your contribution.
+Thanks for helping improve the network! This guide covers setup, local dev, tests, and PR guidelines.
 
-## Repository Structure
+## Requirements
 
-| Package | Language | Build |
-|---------|----------|-------|
-| `core/` | Go 1.24+ | `make core-build` |
-| `website/` | TypeScript (pnpm) | `make website-build` |
-| `vault/` | Zig 0.14+ | `make vault-build` |
-| `os/` | Go + Buildroot | `make os-build` |
+- Go 1.22+ (1.23 recommended)
+- RQLite (optional for local runs; the Makefile starts nodes with embedded setup)
+- Make (optional)
 
 ## Setup
 
 ```bash
 git clone https://github.com/DeBrosOfficial/network.git
 cd network
-```
-
-### Core (Go)
-
-```bash
-cd core
 make deps
-make build
-make test
 ```
 
-### Website
+## Build, Test, Lint
+
+- Build: `make build`
+- Test: `make test`
+- Format/Vet: `make fmt vet` (or `make lint`)
+
+````
+
+Useful CLI commands:
 
 ```bash
-cd website
-pnpm install
-pnpm dev
-```
+./bin/orama health
+./bin/orama peers
+./bin/orama status
+````
 
-### Vault (Zig)
+## Versioning
 
-```bash
-cd vault
-zig build
-zig build test
-```
+- The CLI reports its version via `orama version`.
+- Releases are tagged (e.g., `v0.18.0-beta`) and published via GoReleaser.
 
 ## Pull Requests
 
-1. Fork and create a topic branch from `main`.
-2. Ensure `make test` passes for affected packages.
-3. Include tests for new functionality or bug fixes.
-4. Keep PRs focused — one concern per PR.
-5. Write a clear description: motivation, approach, and how you tested it.
-6. Update docs if you're changing user-facing behavior.
-
-## Code Style
-
-### Go (core/, os/)
-
-- Follow standard Go conventions
-- Run `make lint` before submitting
-- Wrap errors with context: `fmt.Errorf("failed to X: %w", err)`
-- No magic values — use named constants
-
-### TypeScript (website/)
-
-- TypeScript strict mode
-- Follow existing patterns in the codebase
-
-### Zig (vault/)
-
-- Follow standard Zig conventions
-- Run `zig build test` before submitting
-
-## Security
-
-If you find a security vulnerability, **do not open a public issue**. Email security@debros.io instead.
+1. Fork and create a topic branch.
+2. Ensure `make build test` passes; include tests for new functionality.
+3. Keep PRs focused and well-described (motivation, approach, testing).
+4. Update README/docs for behavior changes.
 
 Thank you for contributing!

Makefile

@@ -1,66 +1,176 @@
-# Orama Monorepo
-# Delegates to sub-project Makefiles
+TEST?=./...
 
-.PHONY: help build test clean
+.PHONY: test
+test:
+	@echo Running tests...
+	go test -v $(TEST)
 
-# === Core (Go network) ===
-.PHONY: core core-build core-test core-clean core-lint
-core: core-build
+# Gateway-focused E2E tests assume gateway and nodes are already running
+# Auto-discovers configuration from ~/.orama and queries database for API key
+# No environment variables required
+.PHONY: test-e2e test-e2e-deployments test-e2e-fullstack test-e2e-https test-e2e-quick test-e2e-prod test-e2e-shared test-e2e-cluster test-e2e-integration test-e2e-production
 
-core-build:
-	$(MAKE) -C core build
+# Production E2E tests - includes production-only tests
+test-e2e-prod:
+	@if [ -z "$$ORAMA_GATEWAY_URL" ]; then \
+		echo "❌ ORAMA_GATEWAY_URL not set"; \
+		echo "Usage: ORAMA_GATEWAY_URL=https://dbrs.space make test-e2e-prod"; \
+		exit 1; \
+	fi
+	@echo "Running E2E tests (including production-only) against $$ORAMA_GATEWAY_URL..."
+	go test -v -tags "e2e production" -timeout 30m ./e2e/...
 
-core-test:
-	$(MAKE) -C core test
+# Generic e2e target
+test-e2e:
+	@echo "Running comprehensive E2E tests..."
+	@echo "Auto-discovering configuration from ~/.orama..."
+	go test -v -tags e2e -timeout 30m ./e2e/...
 
-core-lint:
-	$(MAKE) -C core lint
+test-e2e-deployments:
+	@echo "Running deployment E2E tests..."
+	go test -v -tags e2e -timeout 15m ./e2e/deployments/...
 
-core-clean:
-	$(MAKE) -C core clean
+test-e2e-fullstack:
+	@echo "Running fullstack E2E tests..."
+	go test -v -tags e2e -timeout 20m -run "TestFullStack" ./e2e/...
 
-# === Website ===
-.PHONY: website website-dev website-build
-website-dev:
-	cd website && pnpm dev
+test-e2e-https:
+	@echo "Running HTTPS/external access E2E tests..."
+	go test -v -tags e2e -timeout 10m -run "TestHTTPS" ./e2e/...
 
-website-build:
-	cd website && pnpm build
+test-e2e-shared:
+	@echo "Running shared E2E tests..."
+	go test -v -tags e2e -timeout 10m ./e2e/shared/...
 
-# === SDK (TypeScript) ===
-.PHONY: sdk sdk-build sdk-test
-sdk: sdk-build
+test-e2e-cluster:
+	@echo "Running cluster E2E tests..."
+	go test -v -tags e2e -timeout 15m ./e2e/cluster/...
 
-sdk-build:
-	cd sdk && pnpm install && pnpm build
+test-e2e-integration:
+	@echo "Running integration E2E tests..."
+	go test -v -tags e2e -timeout 20m ./e2e/integration/...
 
-sdk-test:
-	cd sdk && pnpm test
+test-e2e-production:
+	@echo "Running production-only E2E tests..."
+	go test -v -tags "e2e production" -timeout 15m ./e2e/production/...
 
-# === Vault (Zig) ===
-.PHONY: vault vault-build vault-test
-vault-build:
-	cd vault && zig build
+test-e2e-quick:
+	@echo "Running quick E2E smoke tests..."
+	go test -v -tags e2e -timeout 5m -run "TestStatic|TestHealth" ./e2e/...
 
-vault-test:
-	cd vault && zig build test
+# Network - Distributed P2P Database System
+# Makefile for development and build tasks
 
-# === OS ===
-.PHONY: os os-build
-os-build:
-	$(MAKE) -C os
+.PHONY: build clean test deps tidy fmt vet lint install-hooks push-devnet push-testnet rollout-devnet rollout-testnet release
 
-# === Aggregate ===
-build: core-build
-test: core-test
-clean: core-clean
+VERSION := 0.115.0
+COMMIT  ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
+DATE    ?= $(shell date -u +%Y-%m-%dT%H:%M:%SZ)
+LDFLAGS := -X 'main.version=$(VERSION)' -X 'main.commit=$(COMMIT)' -X 'main.date=$(DATE)'
+LDFLAGS_LINUX := -s -w $(LDFLAGS)
 
+# Build targets
+build: deps
+	@echo "Building network executables (version=$(VERSION))..."
+	@mkdir -p bin
+	go build -ldflags "$(LDFLAGS)" -o bin/identity ./cmd/identity
+	go build -ldflags "$(LDFLAGS)" -o bin/orama-node ./cmd/node
+	go build -ldflags "$(LDFLAGS)" -o bin/orama ./cmd/cli/
+	# Inject gateway build metadata via pkg path variables
+	go build -ldflags "$(LDFLAGS) -X 'github.com/DeBrosOfficial/network/pkg/gateway.BuildVersion=$(VERSION)' -X 'github.com/DeBrosOfficial/network/pkg/gateway.BuildCommit=$(COMMIT)' -X 'github.com/DeBrosOfficial/network/pkg/gateway.BuildTime=$(DATE)'" -o bin/gateway ./cmd/gateway
+	go build -ldflags "$(LDFLAGS)" -o bin/sfu ./cmd/sfu
+	go build -ldflags "$(LDFLAGS)" -o bin/turn ./cmd/turn
+	@echo "Build complete! Run ./bin/orama version"
+
+# Cross-compile CLI for Linux (only binary needed locally; VPS builds everything else from source)
+build-linux: deps
+	@echo "Cross-compiling CLI for linux/amd64 (version=$(VERSION))..."
+	@mkdir -p bin-linux
+	GOOS=linux GOARCH=amd64 go build -ldflags "$(LDFLAGS_LINUX)" -trimpath -o bin-linux/orama ./cmd/cli/
+	@echo "✓ CLI built at bin-linux/orama"
+	@echo ""
+	@echo "Prefer 'make build-archive' for full pre-built binary archive."
+
+# Build pre-compiled binary archive for deployment (all binaries + deps)
+build-archive: deps
+	@echo "Building binary archive (version=$(VERSION))..."
+	go build -ldflags "$(LDFLAGS)" -o bin/orama ./cmd/cli/
+	./bin/orama build --output /tmp/orama-$(VERSION)-linux-amd64.tar.gz
+
+# Install git hooks
+install-hooks:
+	@echo "Installing git hooks..."
+	@bash scripts/install-hooks.sh
+
+# Clean build artifacts
+clean:
+	@echo "Cleaning build artifacts..."
+	rm -rf bin/
+	rm -rf data/
+	@echo "Clean complete!"
+
+# Push binary archive to devnet nodes (fanout distribution)
+push-devnet:
+	./bin/orama node push --env devnet
+
+# Push binary archive to testnet nodes (fanout distribution)
+push-testnet:
+	./bin/orama node push --env testnet
+
+# Full rollout to devnet (build + push + rolling upgrade)
+rollout-devnet:
+	./bin/orama node rollout --env devnet --yes
+
+# Full rollout to testnet (build + push + rolling upgrade)
+rollout-testnet:
+	./bin/orama node rollout --env testnet --yes
+
+# Interactive release workflow (tag + push)
+release:
+	@bash scripts/release.sh
+
+# Check health of all nodes in an environment
+# Usage: make health ENV=devnet
+health:
+	@if [ -z "$(ENV)" ]; then \
+		echo "Usage: make health ENV=devnet|testnet"; \
+		exit 1; \
+	fi
+	./bin/orama monitor report --env $(ENV)
+
+# Help
 help:
-	@echo "Orama Monorepo"
+	@echo "Available targets:"
+	@echo "  build         - Build all executables"
+	@echo "  clean         - Clean build artifacts"
+	@echo "  test          - Run unit tests"
 	@echo ""
-	@echo "  Core (Go):     make core-build | core-test | core-lint | core-clean"
-	@echo "  Website:       make website-dev | website-build"
-	@echo "  Vault (Zig):   make vault-build | vault-test"
-	@echo "  OS:            make os-build"
+	@echo "E2E Testing:"
+	@echo "  make test-e2e-prod        - Run all E2E tests incl. production-only (needs ORAMA_GATEWAY_URL)"
+	@echo "  make test-e2e-shared      - Run shared E2E tests (cache, storage, pubsub, auth)"
+	@echo "  make test-e2e-cluster     - Run cluster E2E tests (libp2p, olric, rqlite, namespace)"
+	@echo "  make test-e2e-integration - Run integration E2E tests (fullstack, persistence, concurrency)"
+	@echo "  make test-e2e-deployments - Run deployment E2E tests"
+	@echo "  make test-e2e-production  - Run production-only E2E tests (DNS, HTTPS, cross-node)"
+	@echo "  make test-e2e-quick       - Quick smoke tests (static deploys, health checks)"
+	@echo "  make test-e2e             - Generic E2E tests (auto-discovers config)"
 	@echo ""
-	@echo "  Aggregate:     make build | test | clean  (delegates to core)"
+	@echo "  Example:"
+	@echo "    ORAMA_GATEWAY_URL=https://orama-devnet.network make test-e2e-prod"
+	@echo ""
+	@echo "Deployment:"
+	@echo "  make build-archive         - Build pre-compiled binary archive for deployment"
+	@echo "  make push-devnet           - Push binary archive to devnet nodes"
+	@echo "  make push-testnet          - Push binary archive to testnet nodes"
+	@echo "  make rollout-devnet        - Full rollout: build + push + rolling upgrade (devnet)"
+	@echo "  make rollout-testnet       - Full rollout: build + push + rolling upgrade (testnet)"
+	@echo "  make health ENV=devnet     - Check health of all nodes in an environment"
+	@echo "  make release               - Interactive release workflow (tag + push)"
+	@echo ""
+	@echo "Maintenance:"
+	@echo "  deps          - Download dependencies"
+	@echo "  tidy          - Tidy dependencies"
+	@echo "  fmt           - Format code"
+	@echo "  vet           - Vet code"
+	@echo "  lint          - Lint code (fmt + vet)"
+	@echo "  help          - Show this help"

README.md

@@ -1,50 +1,465 @@
-# Orama Network
+# Orama Network - Distributed P2P Platform
 
-A decentralized infrastructure platform combining distributed SQL, IPFS storage, caching, serverless WASM execution, and privacy relay — all managed through a unified API gateway.
+A high-performance API Gateway and distributed platform built in Go. Provides a unified HTTP/HTTPS API for distributed SQL (RQLite), distributed caching (Olric), decentralized storage (IPFS), pub/sub messaging, and serverless WebAssembly execution.
 
-## Packages
+**Architecture:** Modular Gateway / Edge Proxy following SOLID principles
 
-| Package | Language | Description |
-|---------|----------|-------------|
-| [core/](core/) | Go | API gateway, distributed node, CLI, and client SDK |
-| [sdk/](sdk/) | TypeScript | `@debros/orama` — JavaScript/TypeScript SDK ([npm](https://www.npmjs.com/package/@debros/orama)) |
-| [website/](website/) | TypeScript | Marketing website and invest portal |
-| [vault/](vault/) | Zig | Distributed secrets vault (Shamir's Secret Sharing) |
-| [os/](os/) | Go + Buildroot | OramaOS — hardened minimal Linux for network nodes |
+## Features
+
+- **🔐 Authentication** - Wallet signatures, API keys, JWT tokens
+- **💾 Storage** - IPFS-based decentralized file storage with encryption
+- **⚡ Cache** - Distributed cache with Olric (in-memory key-value)
+- **🗄️ Database** - RQLite distributed SQL with Raft consensus + Per-namespace SQLite databases
+- **📡 Pub/Sub** - Real-time messaging via LibP2P and WebSocket
+- **⚙️ Serverless** - WebAssembly function execution with host functions
+- **🌐 HTTP Gateway** - Unified REST API with automatic HTTPS (Let's Encrypt)
+- **📦 Client SDK** - Type-safe Go SDK for all services
+- **🚀 App Deployments** - Deploy React, Next.js, Go, Node.js apps with automatic domains
+- **🗄️ SQLite Databases** - Per-namespace isolated databases with IPFS backups
+
+## Application Deployments
+
+Deploy full-stack applications with automatic domain assignment and namespace isolation.
+
+### Deploy a React App
+
+```bash
+# Build your app
+cd my-react-app
+npm run build
+
+# Deploy to Orama Network
+orama deploy static ./dist --name my-app
+
+# Your app is now live at: https://my-app.orama.network
+```
+
+### Deploy Next.js with SSR
+
+```bash
+cd my-nextjs-app
+
+# Ensure next.config.js has: output: 'standalone'
+npm run build
+orama deploy nextjs . --name my-nextjs --ssr
+
+# Live at: https://my-nextjs.orama.network
+```
+
+### Deploy Go Backend
+
+```bash
+# Build for Linux (name binary 'app' for auto-detection)
+GOOS=linux GOARCH=amd64 go build -o app main.go
+
+# Deploy (must implement /health endpoint)
+orama deploy go ./app --name my-api
+
+# API live at: https://my-api.orama.network
+```
+
+### Create SQLite Database
+
+```bash
+# Create database
+orama db create my-database
+
+# Create schema
+orama db query my-database "CREATE TABLE users (id INT, name TEXT)"
+
+# Insert data
+orama db query my-database "INSERT INTO users VALUES (1, 'Alice')"
+
+# Query data
+orama db query my-database "SELECT * FROM users"
+
+# Backup to IPFS
+orama db backup my-database
+```
+
+### Full-Stack Example
+
+Deploy a complete app with React frontend, Go backend, and SQLite database:
+
+```bash
+# 1. Create database
+orama db create myapp-db
+orama db query myapp-db "CREATE TABLE users (id INT PRIMARY KEY, name TEXT)"
+
+# 2. Deploy Go backend (connects to database)
+GOOS=linux GOARCH=amd64 go build -o api main.go
+orama deploy go ./api --name myapp-api
+
+# 3. Deploy React frontend (calls backend API)
+cd frontend && npm run build
+orama deploy static ./dist --name myapp
+
+# Access:
+# Frontend: https://myapp.orama.network
+# Backend: https://myapp-api.orama.network
+```
+
+**📖 Full Guide**: See [Deployment Guide](docs/DEPLOYMENT_GUIDE.md) for complete documentation, examples, and best practices.
 
 ## Quick Start
 
+### Building
+
 ```bash
-# Build the core network binaries
-make core-build
-
-# Run tests
-make core-test
-
-# Start website dev server
-make website-dev
-
-# Build vault
-make vault-build
+# Build all binaries
+make build
 ```
 
+## CLI Commands
+
+### Authentication
+
+```bash
+orama auth login            # Authenticate with wallet
+orama auth status           # Check authentication
+orama auth logout           # Clear credentials
+```
+
+### Application Deployments
+
+```bash
+# Deploy applications
+orama deploy static <path> --name myapp       # React, Vue, static sites
+orama deploy nextjs <path> --name myapp --ssr # Next.js with SSR (requires output: 'standalone')
+orama deploy go <path> --name myapp           # Go binaries (must have /health endpoint)
+orama deploy nodejs <path> --name myapp       # Node.js apps (must have /health endpoint)
+
+# Manage deployments
+orama app list                               # List all deployments
+orama app get <name>                         # Get deployment details
+orama app logs <name> --follow               # View logs
+orama app delete <name>                      # Delete deployment
+orama app rollback <name> --version 1        # Rollback to version
+```
+
+### SQLite Databases
+
+```bash
+orama db create <name>                   # Create database
+orama db query <name> "SELECT * FROM t"  # Execute SQL query
+orama db list                            # List all databases
+orama db backup <name>                   # Backup to IPFS
+orama db backups <name>                  # List backups
+```
+
+### Environment Management
+
+```bash
+orama env list              # List available environments
+orama env current           # Show active environment
+orama env use <name>        # Switch environment
+```
+
+## Serverless Functions (WASM)
+
+Orama supports high-performance serverless function execution using WebAssembly (WASM). Functions are isolated, secure, and can interact with network services like the distributed cache.
+
+> **Full guide:** See [docs/SERVERLESS.md](docs/SERVERLESS.md) for host functions API, secrets management, PubSub triggers, and examples.
+
+### 1. Build Functions
+
+Functions must be compiled to WASM. We recommend using [TinyGo](https://tinygo.org/).
+
+```bash
+# Build example functions to examples/functions/bin/
+./examples/functions/build.sh
+```
+
+### 2. Deployment
+
+Deploy your compiled `.wasm` file to the network via the Gateway.
+
+```bash
+# Deploy a function
+curl -X POST https://your-node.example.com/v1/functions \
+  -H "Authorization: Bearer <your_api_key>" \
+  -F "name=hello-world" \
+  -F "namespace=default" \
+  -F "wasm=@./examples/functions/bin/hello.wasm"
+```
+
+### 3. Invocation
+
+Trigger your function with a JSON payload. The function receives the payload via `stdin` and returns its response via `stdout`.
+
+```bash
+# Invoke via HTTP
+curl -X POST https://your-node.example.com/v1/functions/hello-world/invoke \
+  -H "Authorization: Bearer <your_api_key>" \
+  -H "Content-Type: application/json" \
+  -d '{"name": "Developer"}'
+```
+
+### 4. Management
+
+```bash
+# List all functions in a namespace
+curl https://your-node.example.com/v1/functions?namespace=default
+
+# Delete a function
+curl -X DELETE https://your-node.example.com/v1/functions/hello-world?namespace=default
+```
+
+## Production Deployment
+
+### Prerequisites
+
+- Ubuntu 22.04+ or Debian 12+
+- `amd64` or `arm64` architecture
+- 4GB RAM, 50GB SSD, 2 CPU cores
+
+### Required Ports
+
+**External (must be open in firewall):**
+
+- **80** - HTTP (ACME/Let's Encrypt certificate challenges)
+- **443** - HTTPS (Main gateway API endpoint)
+- **4101** - IPFS Swarm (peer connections)
+- **7001** - RQLite Raft (cluster consensus)
+
+**Internal (bound to localhost, no firewall needed):**
+
+- 4501 - IPFS API
+- 5001 - RQLite HTTP API
+- 6001 - Unified Gateway
+- 8080 - IPFS Gateway
+- 9050 - Anyone SOCKS5 proxy
+- 9094 - IPFS Cluster API
+- 3320/3322 - Olric Cache
+
+**Anyone Relay Mode (optional, for earning rewards):**
+
+- 9001 - Anyone ORPort (relay traffic, must be open externally)
+
+### Anyone Network Integration
+
+Orama Network integrates with the [Anyone Protocol](https://anyone.io) for anonymous routing. By default, nodes run as **clients** (consuming the network). Optionally, you can run as a **relay operator** to earn rewards.
+
+**Client Mode (Default):**
+- Routes traffic through Anyone network for anonymity
+- SOCKS5 proxy on localhost:9050
+- No rewards, just consumes network
+
+**Relay Mode (Earn Rewards):**
+- Provide bandwidth to the Anyone network
+- Earn $ANYONE tokens as a relay operator
+- Requires 100 $ANYONE tokens in your wallet
+- Requires ORPort (9001) open to the internet
+
+```bash
+# Install as relay operator (earn rewards)
+sudo orama node install --vps-ip <IP> --domain <domain> \
+  --anyone-relay \
+  --anyone-nickname "MyRelay" \
+  --anyone-contact "operator@email.com" \
+  --anyone-wallet "0x1234...abcd"
+
+# With exit relay (legal implications apply)
+sudo orama node install --vps-ip <IP> --domain <domain> \
+  --anyone-relay \
+  --anyone-exit \
+  --anyone-nickname "MyExitRelay" \
+  --anyone-contact "operator@email.com" \
+  --anyone-wallet "0x1234...abcd"
+
+# Migrate existing Anyone installation
+sudo orama node install --vps-ip <IP> --domain <domain> \
+  --anyone-relay \
+  --anyone-migrate \
+  --anyone-nickname "MyRelay" \
+  --anyone-contact "operator@email.com" \
+  --anyone-wallet "0x1234...abcd"
+```
+
+**Important:** After installation, register your relay at [dashboard.anyone.io](https://dashboard.anyone.io) to start earning rewards.
+
+### Installation
+
+**macOS (Homebrew):**
+
+```bash
+brew install DeBrosOfficial/tap/orama
+```
+
+**Linux (Debian/Ubuntu):**
+
+```bash
+# Download and install the latest .deb package
+curl -sL https://github.com/DeBrosOfficial/network/releases/latest/download/orama_$(curl -s https://api.github.com/repos/DeBrosOfficial/network/releases/latest | grep tag_name | cut -d '"' -f 4 | tr -d 'v')_linux_amd64.deb -o orama.deb
+sudo dpkg -i orama.deb
+```
+
+**From Source:**
+
+```bash
+go install github.com/DeBrosOfficial/network/cmd/cli@latest
+```
+
+**Setup (after installation):**
+
+```bash
+sudo orama node install --interactive
+```
+
+### Service Management
+
+```bash
+# Status
+sudo orama node status
+
+# Control services
+sudo orama node start
+sudo orama node stop
+sudo orama node restart
+
+# Diagnose issues
+sudo orama node doctor
+
+# View logs
+orama node logs node --follow
+orama node logs gateway --follow
+orama node logs ipfs --follow
+```
+
+### Upgrade
+
+```bash
+# Upgrade to latest version
+sudo orama node upgrade --restart
+```
+
+## Configuration
+
+All configuration lives in `~/.orama/`:
+
+- `configs/node.yaml` - Node configuration
+- `configs/gateway.yaml` - Gateway configuration
+- `configs/olric.yaml` - Cache configuration
+- `secrets/` - Keys and certificates
+- `data/` - Service data directories
+
+## Troubleshooting
+
+### Services Not Starting
+
+```bash
+# Check status
+sudo orama node status
+
+# View logs
+orama node logs node --follow
+
+# Check log files
+sudo orama node doctor
+```
+
+### Port Conflicts
+
+```bash
+# Check what's using specific ports
+sudo lsof -i :443   # HTTPS Gateway
+sudo lsof -i :7001  # TCP/SNI Gateway
+sudo lsof -i :6001  # Internal Gateway
+```
+
+### RQLite Cluster Issues
+
+```bash
+# Connect to RQLite CLI
+rqlite -H localhost -p 5001
+
+# Check cluster status
+.nodes
+.status
+.ready
+
+# Check consistency level
+.consistency
+```
+
+### Reset Installation
+
+```bash
+# Production reset (⚠️ DESTROYS DATA)
+sudo orama node uninstall
+sudo rm -rf /opt/orama/.orama
+sudo orama node install
+```
+
+## HTTP Gateway API
+
+### Main Gateway Endpoints
+
+- `GET /health` - Health status
+- `GET /v1/status` - Full status
+- `GET /v1/version` - Version info
+- `POST /v1/rqlite/exec` - Execute SQL
+- `POST /v1/rqlite/query` - Query database
+- `GET /v1/rqlite/schema` - Get schema
+- `POST /v1/pubsub/publish` - Publish message
+- `GET /v1/pubsub/topics` - List topics
+- `GET /v1/pubsub/ws?topic=<name>` - WebSocket subscribe
+- `POST /v1/functions` - Deploy function (multipart/form-data)
+- `POST /v1/functions/{name}/invoke` - Invoke function
+- `GET /v1/functions` - List functions
+- `DELETE /v1/functions/{name}` - Delete function
+- `GET /v1/functions/{name}/logs` - Get function logs
+
+See `openapi/gateway.yaml` for complete API specification.
+
 ## Documentation
 
-| Document | Description |
-|----------|-------------|
-| [Architecture](core/docs/ARCHITECTURE.md) | System architecture and design patterns |
-| [Deployment Guide](core/docs/DEPLOYMENT_GUIDE.md) | Deploy apps, databases, and domains |
-| [Dev & Deploy](core/docs/DEV_DEPLOY.md) | Building, deploying to VPS, rolling upgrades |
-| [Security](core/docs/SECURITY.md) | Security hardening and threat model |
-| [Monitoring](core/docs/MONITORING.md) | Cluster health monitoring |
-| [Client SDK](core/docs/CLIENT_SDK.md) | Go SDK documentation |
-| [Serverless](core/docs/SERVERLESS.md) | WASM serverless functions |
-| [Common Problems](core/docs/COMMON_PROBLEMS.md) | Troubleshooting known issues |
+- **[Deployment Guide](docs/DEPLOYMENT_GUIDE.md)** - Deploy React, Next.js, Go apps and manage databases
+- **[Architecture Guide](docs/ARCHITECTURE.md)** - System architecture and design patterns
+- **[Client SDK](docs/CLIENT_SDK.md)** - Go SDK documentation and examples
+- **[Monitoring](docs/MONITORING.md)** - Cluster monitoring and health checks
+- **[Inspector](docs/INSPECTOR.md)** - Deep subsystem health inspection
+- **[Serverless Functions](docs/SERVERLESS.md)** - WASM serverless with host functions
+- **[WebRTC](docs/WEBRTC.md)** - Real-time communication setup
+- **[Common Problems](docs/COMMON_PROBLEMS.md)** - Troubleshooting known issues
+
+## Resources
+
+- [RQLite Documentation](https://rqlite.io/docs/)
+- [IPFS Documentation](https://docs.ipfs.tech/)
+- [LibP2P Documentation](https://docs.libp2p.io/)
+- [WebAssembly](https://webassembly.org/)
+- [GitHub Repository](https://github.com/DeBrosOfficial/network)
+- [Issue Tracker](https://github.com/DeBrosOfficial/network/issues)
+
+## Project Structure
+
+```
+network/
+├── cmd/              # Binary entry points
+│   ├── cli/         # CLI tool
+│   ├── gateway/     # HTTP Gateway
+│   ├── node/        # P2P Node
+├── pkg/              # Core packages
+│   ├── gateway/     # Gateway implementation
+│   │   └── handlers/ # HTTP handlers by domain
+│   ├── client/      # Go SDK
+│   ├── serverless/  # WASM engine
+│   ├── rqlite/      # Database ORM
+│   ├── contracts/   # Interface definitions
+│   ├── httputil/    # HTTP utilities
+│   └── errors/      # Error handling
+├── docs/            # Documentation
+├── e2e/             # End-to-end tests
+└── examples/        # Example code
+```
 
 ## Contributing
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for setup, development, and PR guidelines.
+Contributions are welcome! This project follows:
+- **SOLID Principles** - Single responsibility, open/closed, etc.
+- **DRY Principle** - Don't repeat yourself
+- **Clean Architecture** - Clear separation of concerns
+- **Test Coverage** - Unit and E2E tests required
 
-## License
-
-[AGPL-3.0](LICENSE)
+See our architecture docs for design patterns and guidelines.

core/.env.example

@@ -1,8 +0,0 @@
-# OpenRouter API Key for changelog generation
-# Get your API key from https://openrouter.ai/keys
-OPENROUTER_API_KEY=your-api-key-here
-
-# ZeroSSL API Key for TLS certificates (alternative to Let's Encrypt)
-# Get your free API key from https://app.zerossl.com/developer
-# If not set, Caddy will use Let's Encrypt as the default CA
-ZEROSSL_API_KEY=

core/Makefile

@@ -1,181 +0,0 @@
-TEST?=./...
-
-.PHONY: test
-test:
-	@echo Running tests...
-	go test -v $(TEST)
-
-# Gateway-focused E2E tests assume gateway and nodes are already running
-# Auto-discovers configuration from ~/.orama and queries database for API key
-# No environment variables required
-.PHONY: test-e2e test-e2e-deployments test-e2e-fullstack test-e2e-https test-e2e-quick test-e2e-prod test-e2e-shared test-e2e-cluster test-e2e-integration test-e2e-production
-
-# Production E2E tests - includes production-only tests
-test-e2e-prod:
-	@if [ -z "$$ORAMA_GATEWAY_URL" ]; then \
-		echo "❌ ORAMA_GATEWAY_URL not set"; \
-		echo "Usage: ORAMA_GATEWAY_URL=https://dbrs.space make test-e2e-prod"; \
-		exit 1; \
-	fi
-	@echo "Running E2E tests (including production-only) against $$ORAMA_GATEWAY_URL..."
-	go test -v -tags "e2e production" -timeout 30m ./e2e/...
-
-# Generic e2e target
-test-e2e:
-	@echo "Running comprehensive E2E tests..."
-	@echo "Auto-discovering configuration from ~/.orama..."
-	go test -v -tags e2e -timeout 30m ./e2e/...
-
-test-e2e-deployments:
-	@echo "Running deployment E2E tests..."
-	go test -v -tags e2e -timeout 15m ./e2e/deployments/...
-
-test-e2e-fullstack:
-	@echo "Running fullstack E2E tests..."
-	go test -v -tags e2e -timeout 20m -run "TestFullStack" ./e2e/...
-
-test-e2e-https:
-	@echo "Running HTTPS/external access E2E tests..."
-	go test -v -tags e2e -timeout 10m -run "TestHTTPS" ./e2e/...
-
-test-e2e-shared:
-	@echo "Running shared E2E tests..."
-	go test -v -tags e2e -timeout 10m ./e2e/shared/...
-
-test-e2e-cluster:
-	@echo "Running cluster E2E tests..."
-	go test -v -tags e2e -timeout 15m ./e2e/cluster/...
-
-test-e2e-integration:
-	@echo "Running integration E2E tests..."
-	go test -v -tags e2e -timeout 20m ./e2e/integration/...
-
-test-e2e-production:
-	@echo "Running production-only E2E tests..."
-	go test -v -tags "e2e production" -timeout 15m ./e2e/production/...
-
-test-e2e-quick:
-	@echo "Running quick E2E smoke tests..."
-	go test -v -tags e2e -timeout 5m -run "TestStatic|TestHealth" ./e2e/...
-
-# Network - Distributed P2P Database System
-# Makefile for development and build tasks
-
-.PHONY: build clean test deps tidy fmt vet lint install-hooks push-devnet push-testnet rollout-devnet rollout-testnet release
-
-VERSION := 0.120.0
-COMMIT  ?= $(shell git rev-parse --short HEAD 2>/dev/null || echo unknown)
-DATE    ?= $(shell date -u +%Y-%m-%dT%H:%M:%SZ)
-LDFLAGS := -X 'main.version=$(VERSION)' -X 'main.commit=$(COMMIT)' -X 'main.date=$(DATE)'
-LDFLAGS_LINUX := -s -w $(LDFLAGS)
-
-# Build targets
-build: deps
-	@echo "Building network executables (version=$(VERSION))..."
-	@mkdir -p bin
-	go build -ldflags "$(LDFLAGS)" -o bin/identity ./cmd/identity
-	go build -ldflags "$(LDFLAGS)" -o bin/orama-node ./cmd/node
-	go build -ldflags "$(LDFLAGS)" -o bin/orama ./cmd/cli/
-	# Inject gateway build metadata via pkg path variables
-	go build -ldflags "$(LDFLAGS) -X 'github.com/DeBrosOfficial/network/pkg/gateway.BuildVersion=$(VERSION)' -X 'github.com/DeBrosOfficial/network/pkg/gateway.BuildCommit=$(COMMIT)' -X 'github.com/DeBrosOfficial/network/pkg/gateway.BuildTime=$(DATE)'" -o bin/gateway ./cmd/gateway
-	go build -ldflags "$(LDFLAGS)" -o bin/sfu ./cmd/sfu
-	go build -ldflags "$(LDFLAGS)" -o bin/turn ./cmd/turn
-	@echo "Build complete! Run ./bin/orama version"
-
-# Cross-compile CLI for Linux (only binary needed locally; VPS builds everything else from source)
-build-linux: deps
-	@echo "Cross-compiling CLI for linux/amd64 (version=$(VERSION))..."
-	@mkdir -p bin-linux
-	GOOS=linux GOARCH=amd64 go build -ldflags "$(LDFLAGS_LINUX)" -trimpath -o bin-linux/orama ./cmd/cli/
-	@echo "✓ CLI built at bin-linux/orama"
-	@echo ""
-	@echo "Prefer 'make build-archive' for full pre-built binary archive."
-
-# Build pre-compiled binary archive for deployment (all binaries + deps)
-build-archive: deps
-	@echo "Building binary archive (version=$(VERSION))..."
-	go build -ldflags "$(LDFLAGS)" -o bin/orama ./cmd/cli/
-	./bin/orama build --output /tmp/orama-$(VERSION)-linux-amd64.tar.gz
-
-# Install git hooks
-install-hooks:
-	@echo "Installing git hooks..."
-	@bash scripts/install-hooks.sh
-
-# Install orama CLI to ~/.local/bin and configure PATH
-install: build
-	@bash scripts/install.sh
-
-# Clean build artifacts
-clean:
-	@echo "Cleaning build artifacts..."
-	rm -rf bin/
-	rm -rf data/
-	@echo "Clean complete!"
-
-# Push binary archive to devnet nodes (fanout distribution)
-push-devnet:
-	./bin/orama node push --env devnet
-
-# Push binary archive to testnet nodes (fanout distribution)
-push-testnet:
-	./bin/orama node push --env testnet
-
-# Full rollout to devnet (build + push + rolling upgrade)
-rollout-devnet:
-	./bin/orama node rollout --env devnet --yes
-
-# Full rollout to testnet (build + push + rolling upgrade)
-rollout-testnet:
-	./bin/orama node rollout --env testnet --yes
-
-# Interactive release workflow (tag + push)
-release:
-	@bash scripts/release.sh
-
-# Check health of all nodes in an environment
-# Usage: make health ENV=devnet
-health:
-	@if [ -z "$(ENV)" ]; then \
-		echo "Usage: make health ENV=devnet|testnet"; \
-		exit 1; \
-	fi
-	./bin/orama monitor report --env $(ENV)
-
-# Help
-help:
-	@echo "Available targets:"
-	@echo "  build         - Build all executables"
-	@echo "  install       - Build and install 'orama' CLI to ~/.local/bin"
-	@echo "  clean         - Clean build artifacts"
-	@echo "  test          - Run unit tests"
-	@echo ""
-	@echo "E2E Testing:"
-	@echo "  make test-e2e-prod        - Run all E2E tests incl. production-only (needs ORAMA_GATEWAY_URL)"
-	@echo "  make test-e2e-shared      - Run shared E2E tests (cache, storage, pubsub, auth)"
-	@echo "  make test-e2e-cluster     - Run cluster E2E tests (libp2p, olric, rqlite, namespace)"
-	@echo "  make test-e2e-integration - Run integration E2E tests (fullstack, persistence, concurrency)"
-	@echo "  make test-e2e-deployments - Run deployment E2E tests"
-	@echo "  make test-e2e-production  - Run production-only E2E tests (DNS, HTTPS, cross-node)"
-	@echo "  make test-e2e-quick       - Quick smoke tests (static deploys, health checks)"
-	@echo "  make test-e2e             - Generic E2E tests (auto-discovers config)"
-	@echo ""
-	@echo "  Example:"
-	@echo "    ORAMA_GATEWAY_URL=https://orama-devnet.network make test-e2e-prod"
-	@echo ""
-	@echo "Deployment:"
-	@echo "  make build-archive         - Build pre-compiled binary archive for deployment"
-	@echo "  make push-devnet           - Push binary archive to devnet nodes"
-	@echo "  make push-testnet          - Push binary archive to testnet nodes"
-	@echo "  make rollout-devnet        - Full rollout: build + push + rolling upgrade (devnet)"
-	@echo "  make rollout-testnet       - Full rollout: build + push + rolling upgrade (testnet)"
-	@echo "  make health ENV=devnet     - Check health of all nodes in an environment"
-	@echo "  make release               - Interactive release workflow (tag + push)"
-	@echo ""
-	@echo "Maintenance:"
-	@echo "  deps          - Download dependencies"
-	@echo "  tidy          - Tidy dependencies"
-	@echo "  fmt           - Format code"
-	@echo "  vet           - Vet code"
-	@echo "  lint          - Lint code (fmt + vet)"
-	@echo "  help          - Show this help"

core/pkg/cli/sandbox/create_test.go

@@ -1,158 +0,0 @@
-package sandbox
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/DeBrosOfficial/network/pkg/rwagent"
-)
-
-func TestFindProjectRoot_FromSubDir(t *testing.T) {
-	// Create a temp dir with go.mod (resolve symlinks for macOS /private/var)
-	root, _ := filepath.EvalSymlinks(t.TempDir())
-	if err := os.WriteFile(filepath.Join(root, "go.mod"), []byte("module test"), 0644); err != nil {
-		t.Fatal(err)
-	}
-
-	// Create a nested subdir
-	sub := filepath.Join(root, "pkg", "foo")
-	if err := os.MkdirAll(sub, 0755); err != nil {
-		t.Fatal(err)
-	}
-
-	// Change to subdir and find root
-	orig, _ := os.Getwd()
-	defer os.Chdir(orig)
-	os.Chdir(sub)
-
-	got, err := findProjectRoot()
-	if err != nil {
-		t.Fatalf("findProjectRoot() error: %v", err)
-	}
-	if got != root {
-		t.Errorf("findProjectRoot() = %q, want %q", got, root)
-	}
-}
-
-func TestFindProjectRoot_NoGoMod(t *testing.T) {
-	// Create a temp dir without go.mod
-	dir := t.TempDir()
-
-	orig, _ := os.Getwd()
-	defer os.Chdir(orig)
-	os.Chdir(dir)
-
-	_, err := findProjectRoot()
-	if err == nil {
-		t.Error("findProjectRoot() should error when no go.mod exists")
-	}
-}
-
-func TestFindNewestArchive_NoArchives(t *testing.T) {
-	// findNewestArchive scans /tmp — just verify it returns "" when
-	// no matching files exist (this is the normal case in CI).
-	// We can't fully control /tmp, but we can verify the function doesn't crash.
-	result := findNewestArchive()
-	// Result is either "" or a valid path — both are acceptable
-	if result != "" {
-		if _, err := os.Stat(result); err != nil {
-			t.Errorf("findNewestArchive() returned non-existent path: %s", result)
-		}
-	}
-}
-
-func TestIsSafeDNSName(t *testing.T) {
-	tests := []struct {
-		input string
-		want  bool
-	}{
-		{"example.com", true},
-		{"test-cluster.orama.network", true},
-		{"a", true},
-		{"", false},
-		{"test;rm -rf /", false},
-		{"test$(whoami)", false},
-		{"test space", false},
-		{"test_underscore", false},
-		{"UPPER.case.OK", true},
-		{"123.456", true},
-	}
-	for _, tt := range tests {
-		got := isSafeDNSName(tt.input)
-		if got != tt.want {
-			t.Errorf("isSafeDNSName(%q) = %v, want %v", tt.input, got, tt.want)
-		}
-	}
-}
-
-func TestIsHex(t *testing.T) {
-	tests := []struct {
-		input string
-		want  bool
-	}{
-		{"abcdef0123456789", true},
-		{"ABCDEF", true},
-		{"0", true},
-		{"", true}, // vacuous truth, but guarded by len check in caller
-		{"xyz", false},
-		{"abcg", false},
-		{"abc def", false},
-	}
-	for _, tt := range tests {
-		got := isHex(tt.input)
-		if got != tt.want {
-			t.Errorf("isHex(%q) = %v, want %v", tt.input, got, tt.want)
-		}
-	}
-}
-
-func TestValidateAgentStatus_Locked(t *testing.T) {
-	status := &rwagent.StatusResponse{Locked: true, ConnectedApps: 1}
-	err := validateAgentStatus(status)
-	if err == nil {
-		t.Fatal("expected error for locked agent")
-	}
-	if !strings.Contains(err.Error(), "locked") {
-		t.Errorf("error should mention locked, got: %v", err)
-	}
-}
-
-func TestValidateAgentStatus_NoDesktopApp(t *testing.T) {
-	status := &rwagent.StatusResponse{Locked: false, ConnectedApps: 0}
-	err := validateAgentStatus(status)
-	if err == nil {
-		t.Fatal("expected error when no desktop app connected")
-	}
-	if !strings.Contains(err.Error(), "desktop app") {
-		t.Errorf("error should mention desktop app, got: %v", err)
-	}
-}
-
-func TestValidateAgentStatus_Ready(t *testing.T) {
-	status := &rwagent.StatusResponse{Locked: false, ConnectedApps: 1}
-	if err := validateAgentStatus(status); err != nil {
-		t.Errorf("expected no error for ready agent, got: %v", err)
-	}
-}
-
-func TestFormatBytes(t *testing.T) {
-	tests := []struct {
-		input int64
-		want  string
-	}{
-		{0, "0 B"},
-		{500, "500 B"},
-		{1024, "1.0 KB"},
-		{1536, "1.5 KB"},
-		{1048576, "1.0 MB"},
-		{1073741824, "1.0 GB"},
-	}
-	for _, tt := range tests {
-		got := formatBytes(tt.input)
-		if got != tt.want {
-			t.Errorf("formatBytes(%d) = %q, want %q", tt.input, got, tt.want)
-		}
-	}
-}

core/scripts/install.sh

@@ -1,95 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Orama CLI installer
-# Builds the CLI and adds `orama` to your PATH.
-# Usage: ./scripts/install.sh [--shell fish|zsh|bash]
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
-BIN_DIR="$HOME/.local/bin"
-BIN_PATH="$BIN_DIR/orama"
-
-# --- Parse args ---
-SHELL_NAME=""
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --shell) SHELL_NAME="$2"; shift 2 ;;
-    -h|--help)
-      echo "Usage: ./scripts/install.sh [--shell fish|zsh|bash]"
-      echo ""
-      echo "Builds the Orama CLI and installs 'orama' to ~/.local/bin."
-      echo "If --shell is not provided, auto-detects from \$SHELL."
-      exit 0 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-# Auto-detect shell
-if [[ -z "$SHELL_NAME" ]]; then
-  case "$SHELL" in
-    */fish) SHELL_NAME="fish" ;;
-    */zsh)  SHELL_NAME="zsh" ;;
-    */bash) SHELL_NAME="bash" ;;
-    *)      SHELL_NAME="unknown" ;;
-  esac
-fi
-
-echo "==> Shell: $SHELL_NAME"
-
-# --- Build ---
-echo "==> Building Orama CLI..."
-(cd "$PROJECT_DIR" && make build)
-
-# --- Install binary ---
-mkdir -p "$BIN_DIR"
-cp -f "$PROJECT_DIR/bin/orama" "$BIN_PATH"
-chmod +x "$BIN_PATH"
-echo "==> Installed $BIN_PATH"
-
-# --- Ensure PATH ---
-add_to_path() {
-  local rc_file="$1"
-  local line="$2"
-
-  if [[ -f "$rc_file" ]] && grep -qF "$line" "$rc_file"; then
-    echo "==> PATH already configured in $rc_file"
-  else
-    echo "" >> "$rc_file"
-    echo "$line" >> "$rc_file"
-    echo "==> Added PATH to $rc_file"
-  fi
-}
-
-case "$SHELL_NAME" in
-  fish)
-    FISH_CONFIG="$HOME/.config/fish/config.fish"
-    mkdir -p "$(dirname "$FISH_CONFIG")"
-    add_to_path "$FISH_CONFIG" "fish_add_path $BIN_DIR"
-    ;;
-  zsh)
-    add_to_path "$HOME/.zshrc" "export PATH=\"$BIN_DIR:\$PATH\""
-    ;;
-  bash)
-    add_to_path "$HOME/.bashrc" "export PATH=\"$BIN_DIR:\$PATH\""
-    ;;
-  *)
-    echo "==> Unknown shell. Add this to your shell config manually:"
-    echo "    export PATH=\"$BIN_DIR:\$PATH\""
-    ;;
-esac
-
-# --- Verify ---
-VERSION=$("$BIN_PATH" version 2>/dev/null || echo "unknown")
-echo ""
-echo "==> Orama CLI ${VERSION} installed!"
-echo "    Run: orama --help"
-echo ""
-if [[ "$SHELL_NAME" != "unknown" ]]; then
-  echo "    Restart your terminal or run:"
-  case "$SHELL_NAME" in
-    fish) echo "      source ~/.config/fish/config.fish" ;;
-    zsh)  echo "      source ~/.zshrc" ;;
-    bash) echo "      source ~/.bashrc" ;;
-  esac
-fi