├── .env
├── .gitignore
├── LICENSE.md
├── api
    ├── sessions
    │   └── sessions.go
    └── system
    │   ├── ping.go
    │   └── version.go
├── config
    └── constants.go
├── database
    └── redis.go
├── debug
    └── debug.go
├── deploy.sh
├── docker-compose.yml
├── go.mod
├── go.sum
├── handlers
    ├── cursor_websocket_handler.go
    ├── index_handler.go
    ├── screenshot_handler.go
    ├── session_handler.go
    ├── templates
    │   ├── index.html
    │   ├── session_not_found.html
    │   ├── template_fs.go
    │   └── x.html
    └── upload_handler.go
├── repository
    └── sessions.go
├── server.go
└── util
    └── sessions.go


/.env:
--------------------------------------------------------------------------------
1 | REDIS_HOST=localhost
2 | REDIS_PORT=8877
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | uploads/*
2 | server
3 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
  1 | # Functional Source License, Version 1.1, Apache 2.0 Future License
  2 | 
  3 | ## Abbreviation
  4 | 
  5 | FSL-1.1-Apache-2.0
  6 | 
  7 | ## Notice
  8 | 
  9 | Copyright 2024 Roman Pushkin
 10 | 
 11 | ## Terms and Conditions
 12 | 
 13 | ### Licensor ("We")
 14 | 
 15 | The party offering the Software under these Terms and Conditions.
 16 | 
 17 | ### The Software
 18 | 
 19 | The "Software" is each version of the software that we make available under
 20 | these Terms and Conditions, as indicated by our inclusion of these Terms and
 21 | Conditions with the Software.
 22 | 
 23 | ### License Grant
 24 | 
 25 | Subject to your compliance with this License Grant and the Patents,
 26 | Redistribution and Trademark clauses below, we hereby grant you the right to
 27 | use, copy, modify, create derivative works, publicly perform, publicly display
 28 | and redistribute the Software for any Permitted Purpose identified below.
 29 | 
 30 | ### Permitted Purpose
 31 | 
 32 | A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
 33 | means making the Software available to others in a commercial product or
 34 | service that:
 35 | 
 36 | 1. substitutes for the Software;
 37 | 
 38 | 2. substitutes for any other product or service we offer using the Software
 39 |    that exists as of the date we make the Software available; or
 40 | 
 41 | 3. offers the same or substantially similar functionality as the Software.
 42 | 
 43 | Permitted Purposes specifically include using the Software:
 44 | 
 45 | 1. for your internal use and access;
 46 | 
 47 | 2. for non-commercial education;
 48 | 
 49 | 3. for non-commercial research; and
 50 | 
 51 | 4. in connection with professional services that you provide to a licensee
 52 |    using the Software in accordance with these Terms and Conditions.
 53 | 
 54 | ### Patents
 55 | 
 56 | To the extent your use for a Permitted Purpose would necessarily infringe our
 57 | patents, the license grant above includes a license under our patents. If you
 58 | make a claim against any party that the Software infringes or contributes to
 59 | the infringement of any patent, then your patent license to the Software ends
 60 | immediately.
 61 | 
 62 | ### Redistribution
 63 | 
 64 | The Terms and Conditions apply to all copies, modifications and derivatives of
 65 | the Software.
 66 | 
 67 | If you redistribute any copies, modifications or derivatives of the Software,
 68 | you must include a copy of or a link to these Terms and Conditions and not
 69 | remove any copyright notices provided in or with the Software.
 70 | 
 71 | ### Disclaimer
 72 | 
 73 | THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
 74 | IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
 75 | PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
 76 | 
 77 | IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
 78 | SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
 79 | EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
 80 | 
 81 | ### Trademarks
 82 | 
 83 | Except for displaying the License Details and identifying us as the origin of
 84 | the Software, you have no right under these Terms and Conditions to use our
 85 | trademarks, trade names, service marks or product names.
 86 | 
 87 | ## Grant of Future License
 88 | 
 89 | We hereby irrevocably grant you an additional license to use the Software under
 90 | the Apache License, Version 2.0 that is effective on the second anniversary of
 91 | the date we make the Software available. On or after that date, you may use the
 92 | Software under the Apache License, Version 2.0, in which case the following
 93 | will apply:
 94 | 
 95 | Licensed under the Apache License, Version 2.0 (the "License"); you may not use
 96 | this file except in compliance with the License.
 97 | 
 98 | You may obtain a copy of the License at
 99 | 
100 | http://www.apache.org/licenses/LICENSE-2.0
101 | 
102 | Unless required by applicable law or agreed to in writing, software distributed
103 | under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
104 | CONDITIONS OF ANY KIND, either express or implied. See the License for the
105 | specific language governing permissions and limitations under the License.
106 | 
107 | 


--------------------------------------------------------------------------------
/api/sessions/sessions.go:
--------------------------------------------------------------------------------
 1 | package sessions
 2 | 
 3 | import (
 4 | 	"crypto/rand"
 5 | 	"encoding/json"
 6 | 	"math/big"
 7 | 	"net/http"
 8 | 	"time"
 9 | 
10 | 	"server/database"
11 | 	"server/repository"
12 | )
13 | 
14 | const (
15 | 	SESSION_ID_LENGTH = 10
16 | 	SESSION_EXPIRY    = 48 * time.Hour
17 | )
18 | 
19 | type ApiSessions struct {
20 | 	repoSessions *repository.RepoSessions
21 | }
22 | 
23 | func NewApiSessions() *ApiSessions {
24 | 	return &ApiSessions{
25 | 		repoSessions: repository.NewRepoSessions(database.GetRedisClient()),
26 | 	}
27 | }
28 | 
29 | func (api *ApiSessions) CreateSession(w http.ResponseWriter, r *http.Request) {
30 | 	sessionID := generateRandomID(SESSION_ID_LENGTH)
31 | 
32 | 	err := api.repoSessions.Create(sessionID, SESSION_EXPIRY)
33 | 	if err != nil {
34 | 		http.Error(w, "Failed to create session", http.StatusInternalServerError)
35 | 		return
36 | 	}
37 | 
38 | 	w.Header().Set("Content-Type", "application/json")
39 | 	json.NewEncoder(w).Encode(map[string]string{
40 | 		"status":     "ok",
41 | 		"session_id": sessionID,
42 | 	})
43 | }
44 | 
45 | func generateRandomID(length int) string {
46 | 	const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
47 | 	b := make([]byte, length)
48 | 	for i := range b {
49 | 		n, _ := rand.Int(rand.Reader, big.NewInt(int64(len(charset))))
50 | 		b[i] = charset[n.Int64()]
51 | 	}
52 | 	return string(b)
53 | }
54 | 


--------------------------------------------------------------------------------
/api/system/ping.go:
--------------------------------------------------------------------------------
 1 | package system
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | func PingHandler(w http.ResponseWriter, r *http.Request) {
 9 | 	w.Header().Set("Content-Type", "application/json")
10 | 	json.NewEncoder(w).Encode(map[string]string{"status": "pong"})
11 | }
12 | 


--------------------------------------------------------------------------------
/api/system/version.go:
--------------------------------------------------------------------------------
 1 | package system
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"net/http"
 6 | )
 7 | 
 8 | func VersionHandler(w http.ResponseWriter, r *http.Request) {
 9 | 	w.Header().Set("Content-Type", "application/json")
10 | 	json.NewEncoder(w).Encode(map[string]string{"version": "0.1"})
11 | }
12 | 


--------------------------------------------------------------------------------
/config/constants.go:
--------------------------------------------------------------------------------
 1 | package config
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | const (
 8 | 	UPLOAD_DIR           = "uploads"
 9 | 	SCREENSHOT_FILE      = "screenshot.jpeg"
10 | 	SCREENSHOT_HASH_FILE = "screenshot_hash.txt"
11 | )
12 | 
13 | func PrintDebug(message string) {
14 | 	// Implement the printDebug function here or import it from the appropriate package
15 | 	fmt.Println(message)
16 | }
17 | 


--------------------------------------------------------------------------------
/database/redis.go:
--------------------------------------------------------------------------------
 1 | package database
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"os"
 6 | 	"sync"
 7 | 
 8 | 	"github.com/go-redis/redis"
 9 | 	"github.com/joho/godotenv"
10 | )
11 | 
12 | var (
13 | 	redisClient *redis.Client
14 | 	once        sync.Once
15 | )
16 | 
17 | func GetRedisClient() *redis.Client {
18 | 	once.Do(func() {
19 | 		// Load .env file
20 | 		err := godotenv.Load()
21 | 		if err != nil {
22 | 			fmt.Println("Error loading .env file")
23 | 		}
24 | 
25 | 		// Read Redis host and port from environment variables
26 | 		redisHost := os.Getenv("REDIS_HOST")
27 | 		redisPort := os.Getenv("REDIS_PORT")
28 | 
29 | 		if redisHost == "" {
30 | 			redisHost = "localhost"
31 | 		}
32 | 		if redisPort == "" {
33 | 			redisPort = "6379"
34 | 		}
35 | 
36 | 		redisAddr := fmt.Sprintf("%s:%s", redisHost, redisPort)
37 | 
38 | 		redisClient = redis.NewClient(&redis.Options{
39 | 			Addr: redisAddr,
40 | 		})
41 | 	})
42 | 	return redisClient
43 | }
44 | 


--------------------------------------------------------------------------------
/debug/debug.go:
--------------------------------------------------------------------------------
 1 | package debug
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | )
 6 | 
 7 | func PrintDebug(message string) {
 8 | 	// Implement the printDebug function here or import it from the appropriate package
 9 | 	fmt.Println(message)
10 | }
11 | 


--------------------------------------------------------------------------------
/deploy.sh:
--------------------------------------------------------------------------------
 1 | #!/bin/bash
 2 | # 1fps Deployment Script
 3 | 
 4 | # This script deploys the 1fps server to the remote machine.
 5 | # It builds the server locally, stops the service on the remote machine,
 6 | # updates Docker components if necessary, copies the binary, and restarts the service.
 7 | 
 8 | # To set up the Ubuntu service (do this manually, once):
 9 | # 1. Create a systemd service file: sudo nano /etc/systemd/system/1fps.service
10 | # 2. Add the following content:
11 | #    [Unit]
12 | #    Description=1fps Server
13 | #    After=network.target
14 | #
15 | #    [Service]
16 | #    ExecStart=/home/ubuntu/work/1fps/server
17 | #    WorkingDirectory=/home/ubuntu/work/1fps
18 | #    User=ubuntu
19 | #    Restart=always
20 | #
21 | #    [Install]
22 | #    WantedBy=multi-user.target
23 | #
24 | # 3. Save the file and exit
25 | # 4. Reload systemd: sudo systemctl daemon-reload
26 | # 5. Enable the service: sudo systemctl enable 1fps.service
27 | 
28 | # Remote server details
29 | REMOTE_HOST="51.81.245.182"
30 | REMOTE_DIR="/home/ubuntu/work/1fps"
31 | 
32 | # Build the server locally for Linux
33 | echo "Building server locally for Linux..."
34 | GOOS=linux GOARCH=amd64 go build -o server.linux server.go
35 | if [ $? -ne 0 ]; then
36 |     echo "Build failed. Aborting deployment."
37 |     exit 1
38 | fi
39 | 
40 | # Stop the service on the remote machine
41 | echo "Stopping 1fps service on remote machine..."
42 | ssh $REMOTE_HOST "sudo systemctl stop 1fps.service && sudo systemctl status 1fps.service"
43 | 
44 | # Check if docker-compose.yml needs to be updated
45 | echo "Checking if docker-compose.yml needs to be updated..."
46 | if ! ssh $REMOTE_HOST "test -e $REMOTE_DIR/docker-compose.yml && diff <(cat $REMOTE_DIR/docker-compose.yml) <(cat -)" < docker-compose.yml; then
47 |     echo "docker-compose.yml needs updating. Copying file and restarting containers..."
48 |     scp docker-compose.yml $REMOTE_HOST:$REMOTE_DIR/
49 |     ssh $REMOTE_HOST "cd $REMOTE_DIR && docker-compose down && docker-compose up -d"
50 | else
51 |     echo "docker-compose.yml is up to date."
52 | fi
53 | 
54 | # Copy .env file to remote host
55 | echo "Copying .env file to remote machine..."
56 | scp .env $REMOTE_HOST:$REMOTE_DIR/
57 | 
58 | # Parse .env file and test Redis connection on remote server
59 | REDIS_HOST=$(grep REDIS_HOST .env | cut -d '=' -f2)
60 | REDIS_PORT=$(grep REDIS_PORT .env | cut -d '=' -f2)
61 | echo "Testing Redis connection on remote server (${REDIS_HOST}:${REDIS_PORT})..."
62 | ssh $REMOTE_HOST "
63 |     while ! nc -z ${REDIS_HOST} ${REDIS_PORT}; do
64 |         echo 'Redis is unavailable - sleeping for 5 seconds'
65 |         sleep 5
66 |     done
67 |     echo 'Redis is available'
68 | "
69 | 
70 | # Copy the server binary
71 | echo "Copying server binary to remote machine..."
72 | scp server.linux $REMOTE_HOST:$REMOTE_DIR/server
73 | 
74 | # Remove the local Linux binary
75 | echo "Removing local Linux binary..."
76 | rm server.linux
77 | 
78 | # Start the service on the remote machine
79 | echo "Starting 1fps service on remote machine..."
80 | ssh $REMOTE_HOST "sudo systemctl start 1fps.service && sudo systemctl status 1fps.service"
81 | 
82 | echo "Deployment completed successfully."
83 | 


--------------------------------------------------------------------------------
/docker-compose.yml:
--------------------------------------------------------------------------------
 1 | version: '3'
 2 | 
 3 | services:
 4 |   redis:
 5 |     container_name: 1fps_redis
 6 |     image: redis:latest
 7 |     command: redis-server --protected-mode no
 8 |     ports:
 9 |       - "127.0.0.1:8877:6379"
10 |     volumes:
11 |       - redis_data:/data
12 | 
13 | volumes:
14 |   redis_data:
15 | 


--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
 1 | module server
 2 | 
 3 | go 1.22
 4 | 
 5 | require (
 6 | 	github.com/gorilla/mux v1.8.1
 7 | 	github.com/gorilla/websocket v1.5.1
 8 | )
 9 | 
10 | require (
11 | 	github.com/go-redis/redis v6.15.9+incompatible // indirect
12 | 	github.com/joho/godotenv v1.5.1 // indirect
13 | 	golang.org/x/net v0.21.0 // indirect
14 | )
15 | 


--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
 1 | github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg=
 2 | github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
 3 | github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 4 | github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
 5 | github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY=
 6 | github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY=
 7 | github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
 8 | github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
 9 | golang.org/x/net v0.21.0 h1:AQyQV4dYCvJ7vGmJyKki9+PBdyvhkSd8EIx/qb0AYv4=
10 | golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
11 | 


--------------------------------------------------------------------------------
/handlers/cursor_websocket_handler.go:
--------------------------------------------------------------------------------
 1 | package handlers
 2 | 
 3 | import (
 4 | 	"encoding/json"
 5 | 	"fmt"
 6 | 	"net/http"
 7 | 	"server/debug"
 8 | 
 9 | 	"github.com/gorilla/mux"
10 | 	"github.com/gorilla/websocket"
11 | )
12 | 
13 | var (
14 | 	upgrader = websocket.Upgrader{
15 | 		ReadBufferSize:  1024,
16 | 		WriteBufferSize: 1024,
17 | 	}
18 | 
19 | 	// clients is a nested map that stores WebSocket connections for each session.
20 | 	// The outer map uses session IDs as keys, and the inner map uses WebSocket connections as keys.
21 | 	// This structure allows for efficient management of multiple clients across different sessions.
22 | 	//
23 | 	// Ruby equivalent:
24 | 	// clients = {
25 | 	//   "session1" => {
26 | 	//     websocket_conn1 => true,
27 | 	//     websocket_conn2 => true
28 | 	//   },
29 | 	//   "session2" => {
30 | 	//     websocket_conn3 => true
31 | 	//   }
32 | 	// }
33 | 	clients = make(map[string]map[*websocket.Conn]bool)
34 | )
35 | 
36 | func CursorWebSocketHandler(w http.ResponseWriter, r *http.Request) {
37 | 	vars := mux.Vars(r)
38 | 	sessionID := vars["sessionID"]
39 | 
40 | 	conn, err := upgrader.Upgrade(w, r, nil)
41 | 	if err != nil {
42 | 		debug.PrintDebug(fmt.Sprintf("WebSocket upgrade failed: %v", err))
43 | 		return
44 | 	}
45 | 	defer conn.Close()
46 | 
47 | 	if clients[sessionID] == nil {
48 | 		clients[sessionID] = make(map[*websocket.Conn]bool)
49 | 	}
50 | 	clients[sessionID][conn] = true
51 | 
52 | 	for {
53 | 		_, message, err := conn.ReadMessage()
54 | 		if err != nil {
55 | 			debug.PrintDebug(fmt.Sprintf("WebSocket read failed: %v", err))
56 | 			delete(clients[sessionID], conn)
57 | 			if len(clients[sessionID]) == 0 {
58 | 				delete(clients, sessionID)
59 | 			}
60 | 			break
61 | 		}
62 | 
63 | 		var data struct {
64 | 			X  int  `json:"x"`
65 | 			Y  int  `json:"y"`
66 | 			RW *int `json:"rw"` // must be nil if not specified
67 | 			RH *int `json:"rh"` // because of fallbacks in client code
68 | 		}
69 | 		err = json.Unmarshal(message, &data)
70 | 		if err != nil {
71 | 			debug.PrintDebug(fmt.Sprintf("JSON unmarshal failed: %v", err))
72 | 			continue
73 | 		}
74 | 
75 | 		// Broadcast the cursor position to all connected clients in the same session
76 | 		for client := range clients[sessionID] {
77 | 			err := client.WriteJSON(data)
78 | 			if err != nil {
79 | 				debug.PrintDebug(fmt.Sprintf("WebSocket write failed: %v", err))
80 | 				client.Close()
81 | 				delete(clients[sessionID], client)
82 | 				if len(clients[sessionID]) == 0 {
83 | 					delete(clients, sessionID)
84 | 				}
85 | 			}
86 | 		}
87 | 	}
88 | }
89 | 


--------------------------------------------------------------------------------
/handlers/index_handler.go:
--------------------------------------------------------------------------------
 1 | package handlers
 2 | 
 3 | import (
 4 | 	"html/template"
 5 | 	"net/http"
 6 | 	"server/debug"
 7 | 	"server/handlers/templates"
 8 | )
 9 | 
10 | func IndexHandler(w http.ResponseWriter, r *http.Request) {
11 | 	debug.PrintDebug("Received index request")
12 | 
13 | 	// Parse the index template
14 | 	tmpl, err := template.ParseFS(templates.TemplateFS, "index.html")
15 | 	if err != nil {
16 | 		debug.PrintDebug("Error parsing index template: " + err.Error())
17 | 		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
18 | 		return
19 | 	}
20 | 
21 | 	// Execute the template
22 | 	err = tmpl.Execute(w, nil)
23 | 	if err != nil {
24 | 		debug.PrintDebug("Error executing index template: " + err.Error())
25 | 		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
26 | 		return
27 | 	}
28 | }
29 | 


--------------------------------------------------------------------------------
/handlers/screenshot_handler.go:
--------------------------------------------------------------------------------
 1 | package handlers
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"net/http"
 6 | 	"os"
 7 | 	"path/filepath"
 8 | 	"server/config"
 9 | 	"server/debug"
10 | 	"server/util"
11 | 
12 | 	"github.com/gorilla/mux"
13 | )
14 | 
15 | func ScreenshotHandler(w http.ResponseWriter, r *http.Request) {
16 | 	debug.PrintDebug("Received screenshot request")
17 | 
18 | 	// Extract sessionID from the URL parameters
19 | 	vars := mux.Vars(r)
20 | 	sessionID := vars["sessionID"]
21 | 
22 | 	if !util.IsValidSessionID(sessionID) {
23 | 		debug.PrintDebug("Invalid session ID format")
24 | 		http.Error(w, "Invalid session ID format", http.StatusBadRequest)
25 | 		return
26 | 	}
27 | 
28 | 	screenshotPath := filepath.Join(config.UPLOAD_DIR, sessionID, config.SCREENSHOT_FILE)
29 | 	if _, err := os.Stat(screenshotPath); os.IsNotExist(err) {
30 | 		http.NotFound(w, r)
31 | 		return
32 | 	}
33 | 
34 | 	hashPath := filepath.Join(config.UPLOAD_DIR, sessionID, config.SCREENSHOT_HASH_FILE)
35 | 	hash, err := os.ReadFile(hashPath)
36 | 	if err != nil {
37 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
38 | 		return
39 | 	}
40 | 
41 | 	w.Header().Set("ETag", string(hash))
42 | 	w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
43 | 	w.Header().Set("Pragma", "no-cache")
44 | 	w.Header().Set("Expires", "0")
45 | 	http.ServeFile(w, r, screenshotPath)
46 | 
47 | 	debug.PrintDebug(fmt.Sprintf("Served screenshot file %s", screenshotPath))
48 | }
49 | 


--------------------------------------------------------------------------------
/handlers/session_handler.go:
--------------------------------------------------------------------------------
 1 | package handlers
 2 | 
 3 | import (
 4 | 	"fmt"
 5 | 	"html/template"
 6 | 	"net/http"
 7 | 	"server/debug"
 8 | 
 9 | 	"server/database"
10 | 	"server/handlers/templates"
11 | 	"server/repository"
12 | 
13 | 	"github.com/gorilla/mux"
14 | )
15 | 
16 | func SessionHandler(w http.ResponseWriter, r *http.Request) {
17 | 	debug.PrintDebug("Received index request")
18 | 
19 | 	// Get the session ID from the URL parameters
20 | 	vars := mux.Vars(r)
21 | 	sessionID := vars["sessionID"]
22 | 
23 | 	debug.PrintDebug(fmt.Sprintf("Session ID: %s", sessionID))
24 | 
25 | 	// Create a new RepoSessions instance
26 | 	repoSessions := repository.NewRepoSessions(database.GetRedisClient())
27 | 
28 | 	// Check if the session exists in Redis
29 | 	sessionValue, err := repoSessions.Get(sessionID)
30 | 	if err != nil {
31 | 		debug.PrintDebug(fmt.Sprintf("Error getting session: %v", err))
32 | 		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
33 | 		return
34 | 	}
35 | 
36 | 	if sessionValue == nil {
37 | 		// Session not found, render the session_not_found template
38 | 		tmpl, err := template.ParseFS(templates.TemplateFS, "session_not_found.html")
39 | 		if err != nil {
40 | 			debug.PrintDebug(fmt.Sprintf("Error parsing template: %v", err))
41 | 			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
42 | 			return
43 | 		}
44 | 
45 | 		err = tmpl.Execute(w, nil)
46 | 		if err != nil {
47 | 			debug.PrintDebug(fmt.Sprintf("Error executing template: %v", err))
48 | 			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
49 | 		}
50 | 		return
51 | 	}
52 | 
53 | 	// Session exists, render the share template
54 | 	tmpl, err := template.ParseFS(templates.TemplateFS, "x.html")
55 | 	if err != nil {
56 | 		debug.PrintDebug(fmt.Sprintf("Error parsing template: %v", err))
57 | 		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
58 | 		return
59 | 	}
60 | 
61 | 	// Pass the session ID to the template
62 | 	data := struct {
63 | 		SessionID string
64 | 	}{
65 | 		SessionID: sessionID,
66 | 	}
67 | 
68 | 	err = tmpl.Execute(w, data)
69 | 	if err != nil {
70 | 		debug.PrintDebug(fmt.Sprintf("Error executing template: %v", err))
71 | 		http.Error(w, "Internal Server Error", http.StatusInternalServerError)
72 | 		return
73 | 	}
74 | }
75 | 


--------------------------------------------------------------------------------
/handlers/templates/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | <head>
  4 |     <meta charset="UTF-8">
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <title>1fps.video - Hassle-free Screen Sharing</title>
  7 |     <style>
  8 |         body {
  9 |             font-family: Arial, sans-serif;
 10 |             line-height: 1.6;
 11 |             color: #333;
 12 |             max-width: 800px;
 13 |             margin: 0 auto;
 14 |             padding: 20px;
 15 |         }
 16 |         h1, h2 {
 17 |             color: #2c3e50;
 18 |         }
 19 |         .highlight {
 20 |             background-color: #f1c40f;
 21 |             padding: 2px 5px;
 22 |             border-radius: 3px;
 23 |         }
 24 |         .feature-list {
 25 |             list-style-type: none;
 26 |             padding: 0;
 27 |         }
 28 |         .feature-list li {
 29 |             margin-bottom: 10px;
 30 |             padding-left: 20px;
 31 |             position: relative;
 32 |         }
 33 |         .feature-list li::before {
 34 |             content: "•";
 35 |             position: absolute;
 36 |             left: 0;
 37 |             color: #3498db;
 38 |         }
 39 |         .command-box {
 40 |             background-color: #f0f0f0;
 41 |             border: 1px solid #ddd;
 42 |             border-radius: 5px;
 43 |             padding: 10px;
 44 |             margin: 20px 0;
 45 |             position: relative;
 46 |         }
 47 |         .copy-btn {
 48 |             position: absolute;
 49 |             right: 10px;
 50 |             top: 50%;
 51 |             transform: translateY(-50%);
 52 |             background-color: #3498db;
 53 |             color: white;
 54 |             border: none;
 55 |             padding: 5px 10px;
 56 |             border-radius: 3px;
 57 |             cursor: pointer;
 58 |         }
 59 |         .copy-btn:hover {
 60 |             background-color: #2980b9;
 61 |         }
 62 |         .source-link {
 63 |             display: inline-block;
 64 |             margin-top: 10px;
 65 |             color: #3498db;
 66 |             text-decoration: none;
 67 |         }
 68 |         .source-link:hover {
 69 |             text-decoration: underline;
 70 |         }
 71 |         .footer {
 72 |             font-size: 10px;
 73 |             text-align: center;
 74 |             margin-top: 20px;
 75 |             color: #777;
 76 |         }
 77 |     </style>
 78 | </head>
 79 | <body>
 80 |     <h1>1fps.video - Encrypted Screen Sharing</h1>
 81 |     
 82 |     <h2>Quick Start</h2>
 83 |     <p>You need Golang installed for this command to work. If you don't have Golang, you can install it using one of these methods:</p>
 84 |     <ul>
 85 |         <li>For Mac, Linux, or Windows (<a href="https://github.com/1fpsvideo/1fps?tab=readme-ov-file#windows-users" target="_blank">see Windows notes</a>), use this one-line command to install Go Runtime: <a href="https://webinstall.dev/golang/" target="_blank">https://webinstall.dev/golang/</a></li>
 86 |         <li>Or visit the official Go website for installation instructions: <a href="https://go.dev/doc/install" target="_blank">https://go.dev/doc/install</a></li>
 87 |     </ul>
 88 |     <div class="command-box">
 89 |         <code id="commandText">go run github.com/1fpsvideo/1fps@v0.1.11</code>
 90 |         <button id="copyBtn" class="copy-btn" onclick="copyToClipboard()">Copy</button>
 91 |     </div>
 92 |     <p>
 93 |         <a href="https://github.com/1fpsvideo/1fps" target="_blank" class="source-link">
 94 |             🔒 Check out our secure, open-source client app
 95 |         </a>
 96 |     </p>
 97 | 
 98 |     <h2>Hassle-free video sharing for:</h2>
 99 |     <ul class="feature-list">
100 |         <li>Developers</li>
101 |         <li>IT teams</li>
102 |         <li>Security professionals</li>
103 |         <li>Meeting-free collaboration enthusiasts and more</li>
104 |     </ul>
105 | 
106 |     <h2>Why 1 FPS?</h2>
107 |     <p>We've discovered that low FPS video sharing is often sufficient for most collaborative tasks, especially for developers who spend most of their time writing code. Our approach offers several benefits:</p>
108 |     <ul>
109 |         <li>Promotes a <span class="highlight">meeting-free culture</span> by eliminating the need for audio</li>
110 |         <li>Significantly reduces CPU, memory, and network consumption</li>
111 |         <li>Allows older laptops to perform better during screen sharing</li>
112 |         <li>More environmentally friendly due to lower resource usage</li>
113 |         <li>Supports multiple monitors for comprehensive sharing</li>
114 |         <li>Adjustable image quality to optimize traffic consumption</li>
115 |         <li>Resizable screen capture for large displays, further reducing traffic</li>
116 |         <li>Intelligent screen comparison to avoid unnecessary data transmission when the screen hasn't changed</li>
117 |     </ul>
118 | 
119 |     <h2>Is 1 FPS enough?</h2>
120 |     <p>For most coding and development work, absolutely! Plus, we use WebSocket-based cursor tracking, providing smooth, near 30 FPS pointer movement for precise demonstrations.</p>
121 | 
122 |     <h2>Why choose our service?</h2>
123 |     <p>1fps.video is perfect for introverts and remote workers who prefer sharing their screen without the pressure of audio or video calls. It's a versatile solution that works alongside any team chat application you're already using. Our multi-monitor support, adjustable image quality, and screen resizing options allow you to tailor the sharing experience to your specific needs and network conditions.</p>
124 | 
125 |     <h2>Privacy and Security</h2>
126 |     <p>We take your privacy seriously:</p>
127 |     <ul>
128 |         <li>All data is <span class="highlight">end-to-end encrypted</span></li>
129 |         <li>Encryption keys are generated client-side and never sent to our servers</li>
130 |         <li>The key is part of the URL (after the # symbol), which is never transmitted to the backend</li>
131 |         <li>Only those with the full link can access your shared screen</li>
132 |         <li>Intelligent screen comparison ensures minimal data transmission, enhancing privacy</li>
133 |     </ul>
134 |     <p><strong>Note:</strong> We're currently working on encrypting cursor coordinates for even greater privacy.</p>
135 | 
136 |     <h2>About idea</h2>
137 |     <p>1fps.video addresses the growing need for secure, easy screen sharing and monitoring across various sectors. It's designed for
138 |     long-running sessions, offering a simple link-sharing solution without software installation requirements.</p>
139 | 
140 |     <p>Unlike current options that often need specialized software or lack simple URL sharing, 1fps.video aims to streamline screen
141 |     sharing globally. Our goal is to provide a secure, efficient solution for long-term streaming needs, making screen
142 |     sharing as easy as sharing a link, while offering advanced features like multi-monitor support and traffic optimization.</p>
143 | 
144 |     <p>Start sharing your screen effortlessly and securely with 1fps.video today!</p>
145 | 
146 |     <script>
147 |         function copyToClipboard() {
148 |             const el = document.createElement('textarea');
149 |             el.value = document.getElementById('commandText').textContent;
150 |             document.body.appendChild(el);
151 |             el.select();
152 |             document.execCommand('copy');
153 |             document.body.removeChild(el);
154 |             const copyBtn = document.getElementById('copyBtn');
155 |             copyBtn.textContent = 'Copied';
156 |             setTimeout(() => {
157 |                 copyBtn.textContent = 'Copy';
158 |             }, 2000);
159 |         }
160 |     </script>
161 |     <footer class="footer">
162 |         For contacts, you can reach out to: <span id="email"></span>
163 |     </footer>
164 |     <script>
165 |         const encryptedEmail = "ebzna.chfuxva@tznvy.pbz";
166 |         const decryptedEmail = encryptedEmail.replace(/[a-zA-Z]/g, function(c) {
167 |             return String.fromCharCode((c <= "Z" ? 90 : 122) >= (c = c.charCodeAt(0) + 13) ? c : c - 26);
168 |         });
169 |         document.getElementById('email').textContent = decryptedEmail;
170 |     </script>
171 | </body>
172 | </html>
173 | 


--------------------------------------------------------------------------------
/handlers/templates/session_not_found.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html lang="en">
 3 | <head>
 4 |     <meta charset="UTF-8">
 5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
 6 |     <title>Session Not Found</title>
 7 |     <style>
 8 |         body {
 9 |             font-family: Arial, sans-serif;
10 |             display: flex;
11 |             justify-content: center;
12 |             align-items: center;
13 |             height: 100vh;
14 |             margin: 0;
15 |             background-color: #f0f0f0;
16 |         }
17 |         .container {
18 |             text-align: center;
19 |             padding: 2rem;
20 |             background-color: white;
21 |             border-radius: 8px;
22 |             box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
23 |         }
24 |         h1 {
25 |             color: #333;
26 |         }
27 |         p {
28 |             color: #666;
29 |         }
30 |     </style>
31 | </head>
32 | <body>
33 |     <div class="container">
34 |         <h1>Session Not Found</h1>
35 |         <p>The requested session does not exist or has expired.</p>
36 |         <p>Please check the URL and try again, or create a new session.</p>
37 |     </div>
38 | </body>
39 | </html>
40 | 


--------------------------------------------------------------------------------
/handlers/templates/template_fs.go:
--------------------------------------------------------------------------------
1 | package templates
2 | 
3 | import (
4 | 	"embed"
5 | )
6 | 
7 | //go:embed *.html
8 | var TemplateFS embed.FS
9 | 


--------------------------------------------------------------------------------
/handlers/templates/x.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | 
  4 | <head>
  5 |     <meta charset="UTF-8">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |     <title>Screen Share</title>
  8 |     <style>
  9 |         body {
 10 |             margin: 0;
 11 |             overflow: hidden;
 12 |             display: flex;
 13 |             justify-content: center;
 14 |             align-items: center;
 15 |             height: 100vh;
 16 |         }
 17 | 
 18 |         img {
 19 |             max-width: 100%;
 20 |             max-height: 100%;
 21 |             object-fit: contain;
 22 |         }
 23 | 
 24 |         #cursor {
 25 |             position: absolute;
 26 |             width: 32px;
 27 |             height: 32px;
 28 |             pointer-events: none;
 29 |             transition: left 0.1s linear, top 0.1s linear;
 30 |         }
 31 | 
 32 |         #error-message {
 33 |             position: fixed;
 34 |             top: 0;
 35 |             left: 0;
 36 |             right: 0;
 37 |             background-color: #812e2e;
 38 |             color: white;
 39 |             text-align: center;
 40 |             padding: 10px;
 41 |             z-index: 1000;
 42 |             display: none;
 43 |         }
 44 |     </style>
 45 | </head>
 46 | 
 47 | <body>
 48 |     <div id="error-message"></div>
 49 |     <img id="screenshot" alt="Screenshot">
 50 |     <svg id="cursor" version="1.1" id="Layer_1" xmlns="http://www.w3.org/2000/svg"
 51 |         xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px" viewBox="0 0 28 28" enable-background="new 0 0 28 28"
 52 |         xml:space="preserve" style="transform: translate(-10px, -4px);">
 53 |         <polygon fill="#FFFFFF" points="8.2,20.9 8.2,4.9 19.8,16.5 13,16.5 12.6,16.6 " />
 54 |         <polygon fill="#FFFFFF" points="17.3,21.6 13.7,23.1 9,12 12.7,10.5 " />
 55 |         <rect x="12.5" y="13.6" transform="matrix(0.9221 -0.3871 0.3871 0.9221 -5.7605 6.5909)" width="2" height="8" />
 56 |         <polygon points="9.2,7.3 9.2,18.5 12.2,15.6 12.6,15.5 17.4,15.5 " />
 57 |     </svg>
 58 | 
 59 |     <script>
 60 |         const img = document.getElementById('screenshot');
 61 |         const cursorElement = document.getElementById('cursor');
 62 |         const errorMessageElement = document.getElementById('error-message');
 63 |         let socket = null;
 64 | 
 65 |         function getDecryptionKey() {
 66 |             return window.location.hash.substring(1);
 67 |         }
 68 | 
 69 |         function getSessionID() {
 70 |             const pathParts = window.location.pathname.split('/');
 71 |             return pathParts[pathParts.length - 1];
 72 |         }
 73 | 
 74 |         function showError(message) {
 75 |             errorMessageElement.textContent = message;
 76 |             errorMessageElement.style.display = 'block';
 77 |         }
 78 | 
 79 |         function hideError() {
 80 |             errorMessageElement.style.display = 'none';
 81 |         }
 82 | 
 83 |         async function decryptImage(encryptedData, key) {
 84 |             const keyMaterial = await window.crypto.subtle.importKey(
 85 |                 "raw",
 86 |                 new TextEncoder().encode(key),
 87 |                 { name: "PBKDF2" },
 88 |                 false,
 89 |                 ["deriveBits", "deriveKey"]
 90 |             );
 91 | 
 92 |             const salt = encryptedData.slice(0, 16);
 93 |             const iv = encryptedData.slice(16, 28);
 94 |             const data = encryptedData.slice(28);
 95 | 
 96 |             const derivedKey = await window.crypto.subtle.deriveKey(
 97 |                 {
 98 |                     name: "PBKDF2",
 99 |                     salt: salt,
100 |                     iterations: 100000,
101 |                     hash: "SHA-256"
102 |                 },
103 |                 keyMaterial,
104 |                 { name: "AES-GCM", length: 256 },
105 |                 false,
106 |                 ["decrypt"]
107 |             );
108 | 
109 |             const decrypted = await window.crypto.subtle.decrypt(
110 |                 {
111 |                     name: "AES-GCM",
112 |                     iv: iv
113 |                 },
114 |                 derivedKey,
115 |                 data
116 |             );
117 | 
118 |             return new Blob([decrypted], { type: "image/jpeg" });
119 |         }
120 | 
121 |         async function refreshImage() {
122 |             const key = getDecryptionKey();
123 |             if (!key) {
124 |                 alert("Decryption key is required. Please provide it in the URL after the # symbol.");
125 |                 return;
126 |             }
127 | 
128 |             const sessionID = getSessionID();
129 | 
130 |             try {
131 |                 const response = await fetch(`/x/${sessionID}/screenshot?` + new Date().getTime());
132 |                 const encryptedData = await response.arrayBuffer();
133 |                 const decryptedBlob = await decryptImage(encryptedData, key);
134 |                 const imageUrl = URL.createObjectURL(decryptedBlob);
135 |                 img.src = imageUrl;
136 |                 hideError();
137 |             } catch (error) {
138 |                 console.error("Error decrypting image:", error);
139 |                 showError("Failed to decrypt the image. The decryption key might be invalid.");
140 |             }
141 |         }
142 | 
143 |         setInterval(refreshImage, 1000); // Refresh every 1 second
144 | 
145 |         function setupWebSocket() {
146 |             const sessionID = getSessionID();
147 |             const host = window.location.host;
148 |             const isLocalhost = host === 'localhost' || host.startsWith('localhost:') || host.startsWith('127.0.0.1');
149 |             const protocol = isLocalhost ? 'ws://' : 'wss://';
150 |             socket = new WebSocket(`${protocol}${host}/x/${sessionID}/ws`);
151 | 
152 |             socket.onopen = function (event) {
153 |                 console.log('WebSocket connection established');
154 |             };
155 | 
156 |             socket.onclose = function (event) {
157 |                 console.log('WebSocket connection closed. Retrying in 5 seconds...');
158 |                 setTimeout(setupWebSocket, 5000);
159 |             };
160 | 
161 |             socket.onmessage = function (event) {
162 |                 // Parse the incoming WebSocket message
163 |                 const data = JSON.parse(event.data);
164 |                 const x = data.x;
165 |                 const y = data.y;
166 | 
167 |                 // Get the resized width and height from the data
168 |                 // If not provided, fallback to default values for backwards compatibility
169 |                 const rw = data.rw || 1280;
170 |                 const rh = data.rh || 720;
171 | 
172 |                 // Get the screenshot image element and its dimensions
173 |                 const img = document.getElementById('screenshot');
174 |                 const imgRect = img.getBoundingClientRect();
175 |                 const imgWidth = imgRect.width;
176 |                 const imgHeight = imgRect.height;
177 | 
178 |                 // Calculate the scaling factors
179 |                 const scaleX = imgWidth / rw;
180 |                 const scaleY = imgHeight / rh;
181 | 
182 |                 // Scale the cursor coordinates to match the displayed image size
183 |                 const scaledX = x * scaleX;
184 |                 const scaledY = y * scaleY;
185 | 
186 |                 // Position the cursor element
187 |                 const cursorLeft = imgRect.left + scaledX;
188 |                 const cursorTop = imgRect.top + scaledY;
189 |                 cursorElement.style.left = cursorLeft + 'px';
190 |                 cursorElement.style.top = cursorTop + 'px';
191 | 
192 |                 // Output verbose debugging information
193 |                 // console.log('WebSocket data received:', data);
194 |                 // console.log('Image dimensions:', { width: imgWidth, height: imgHeight });
195 |                 // console.log('Resized dimensions:', { rw, rh });
196 |                 // console.log('Scaling factors:', { scaleX, scaleY });
197 |                 // console.log('Cursor coordinates:', { x, y });
198 |                 // console.log('Scaled cursor coordinates:', { scaledX, scaledY });
199 |                 // console.log('Cursor position:', { left: cursorLeft, top: cursorTop });
200 |                 // console.log('Image rectangle:', imgRect);
201 |                 // console.log('===')
202 |             };
203 |         }
204 | 
205 |         setupWebSocket();
206 |         refreshImage(); // Initial image load
207 |     </script>
208 | </body>
209 | 
210 | </html>


--------------------------------------------------------------------------------
/handlers/upload_handler.go:
--------------------------------------------------------------------------------
  1 | package handlers
  2 | 
  3 | import (
  4 | 	"crypto/sha256"
  5 | 	"fmt"
  6 | 	"io"
  7 | 	"net/http"
  8 | 	"os"
  9 | 	"path/filepath"
 10 | 	"server/config"
 11 | 	"server/database"
 12 | 	"server/debug"
 13 | 	"server/repository"
 14 | 	"server/util"
 15 | )
 16 | 
 17 | func UploadHandler(w http.ResponseWriter, r *http.Request) {
 18 | 	debug.PrintDebug("Received upload request")
 19 | 
 20 | 	sessionID := r.FormValue("session_id")
 21 | 	if !util.IsValidSessionID(sessionID) {
 22 | 		debug.PrintDebug("Invalid session ID format")
 23 | 		http.Error(w, "Invalid session ID format", http.StatusBadRequest)
 24 | 		return
 25 | 	}
 26 | 
 27 | 	repoSessions := repository.NewRepoSessions(database.GetRedisClient())
 28 | 	session, err := repoSessions.Get(sessionID)
 29 | 	if err != nil || session == nil {
 30 | 		debug.PrintDebug("Session not found or expired")
 31 | 		http.Error(w, "Session not found or expired. Please initiate a new session.", http.StatusNotFound)
 32 | 		return
 33 | 	}
 34 | 
 35 | 	file, _, err := r.FormFile("file")
 36 | 	if err != nil {
 37 | 		debug.PrintDebug(fmt.Sprintf("Error retrieving file from form: %v", err))
 38 | 		http.Error(w, err.Error(), http.StatusBadRequest)
 39 | 		return
 40 | 	}
 41 | 	defer file.Close()
 42 | 
 43 | 	// Create session-specific directory
 44 | 	sessionDir := filepath.Join(config.UPLOAD_DIR, sessionID)
 45 | 	err = os.MkdirAll(sessionDir, os.ModePerm)
 46 | 	if err != nil && !os.IsExist(err) {
 47 | 		debug.PrintDebug(fmt.Sprintf("Error creating session directory %s: %v", sessionDir, err))
 48 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 49 | 		return
 50 | 	}
 51 | 
 52 | 	// Save the uploaded file
 53 | 	screenshotPath := filepath.Join(sessionDir, config.SCREENSHOT_FILE)
 54 | 	out, err := os.Create(screenshotPath)
 55 | 	if err != nil {
 56 | 		debug.PrintDebug(fmt.Sprintf("Error creating file %s: %v", screenshotPath, err))
 57 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 58 | 		return
 59 | 	}
 60 | 	defer out.Close()
 61 | 
 62 | 	_, err = io.Copy(out, file)
 63 | 	if err != nil {
 64 | 		debug.PrintDebug(fmt.Sprintf("Error writing file %s: %v", screenshotPath, err))
 65 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 66 | 		return
 67 | 	}
 68 | 
 69 | 	debug.PrintDebug(fmt.Sprintf("Saved uploaded file to %s", screenshotPath))
 70 | 
 71 | 	// Save the hash of the uploaded screenshot
 72 | 	hash := calculateFileHash(screenshotPath)
 73 | 	hashPath := filepath.Join(sessionDir, config.SCREENSHOT_HASH_FILE)
 74 | 	err = os.WriteFile(hashPath, []byte(hash), 0644)
 75 | 	if err != nil {
 76 | 		debug.PrintDebug(fmt.Sprintf("Error writing hash file %s: %v", hashPath, err))
 77 | 		http.Error(w, err.Error(), http.StatusInternalServerError)
 78 | 		return
 79 | 	}
 80 | 
 81 | 	debug.PrintDebug(fmt.Sprintf("Saved screenshot hash to %s", hashPath))
 82 | 
 83 | 	w.WriteHeader(http.StatusOK)
 84 | }
 85 | 
 86 | func calculateFileHash(filePath string) string {
 87 | 	file, err := os.Open(filePath)
 88 | 	if err != nil {
 89 | 		panic(err)
 90 | 	}
 91 | 	defer file.Close()
 92 | 
 93 | 	hash := sha256.New()
 94 | 	if _, err := io.Copy(hash, file); err != nil {
 95 | 		panic(err)
 96 | 	}
 97 | 
 98 | 	return fmt.Sprintf("%x", hash.Sum(nil))
 99 | }
100 | 


--------------------------------------------------------------------------------
/repository/sessions.go:
--------------------------------------------------------------------------------
 1 | package repository
 2 | 
 3 | import (
 4 | 	"time"
 5 | 
 6 | 	"github.com/go-redis/redis"
 7 | )
 8 | 
 9 | type RepoSessions struct {
10 | 	client *redis.Client
11 | }
12 | 
13 | func NewRepoSessions(client *redis.Client) *RepoSessions {
14 | 	return &RepoSessions{client: client}
15 | }
16 | 
17 | func (r *RepoSessions) Create(id string, duration time.Duration) error {
18 | 	return r.client.Set(id, 0, duration).Err()
19 | }
20 | 
21 | func (r *RepoSessions) Get(id string) (*int64, error) {
22 | 	val, err := r.client.Get(id).Int64()
23 | 	if err == redis.Nil {
24 | 		return nil, nil
25 | 	} else if err != nil {
26 | 		return nil, err
27 | 	}
28 | 	return &val, nil
29 | }
30 | 
31 | func (r *RepoSessions) Delete(id string) error {
32 | 	return r.client.Del(id).Err()
33 | }
34 | 


--------------------------------------------------------------------------------
/server.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import (
 4 | 	"net/http"
 5 | 	"os"
 6 | 	"server/api/sessions"
 7 | 	"server/api/system"
 8 | 	"server/config"
 9 | 	"server/debug"
10 | 	"server/handlers"
11 | 
12 | 	"github.com/gorilla/mux"
13 | )
14 | 
15 | func main() {
16 | 	router := mux.NewRouter()
17 | 
18 | 	// Create the upload directory if it doesn't exist
19 | 	if err := os.MkdirAll(config.UPLOAD_DIR, os.ModePerm); err != nil {
20 | 		panic(err)
21 | 	}
22 | 
23 | 	// Route for the index page
24 | 	router.HandleFunc("/", handlers.IndexHandler).Methods("GET")
25 | 
26 | 	// Route for uploading the screenshot without authentication
27 | 	router.HandleFunc("/upload", handlers.UploadHandler).Methods("POST")
28 | 	router.HandleFunc("/x/{sessionID}/ws", handlers.CursorWebSocketHandler)
29 | 
30 | 	// Previously protected routes, now accessible without authentication
31 | 	router.HandleFunc("/x/{sessionID}/screenshot", handlers.ScreenshotHandler).Methods("GET")
32 | 	router.HandleFunc("/x/{sessionID}", handlers.SessionHandler).Methods("GET")
33 | 
34 | 	// New API endpoints
35 | 	router.HandleFunc("/v1/api/system/version", system.VersionHandler).Methods("GET")
36 | 	router.HandleFunc("/v1/api/system/ping", system.PingHandler).Methods("GET")
37 | 
38 | 	// Initialize ApiSessions
39 | 	apiSessions := sessions.NewApiSessions()
40 | 	router.HandleFunc("/v1/api/sessions", apiSessions.CreateSession).Methods("POST")
41 | 
42 | 	debug.PrintDebug("Server is running on http://127.0.0.1:8899")
43 | 	http.ListenAndServe("127.0.0.1:8899", router)
44 | }
45 | 


--------------------------------------------------------------------------------
/util/sessions.go:
--------------------------------------------------------------------------------
 1 | package util
 2 | 
 3 | import "regexp"
 4 | 
 5 | // IsValidSessionID checks if the given sessionID is valid.
 6 | // It returns true if the sessionID consists of 1 to 15 alphanumeric characters.
 7 | func IsValidSessionID(sessionID string) bool {
 8 | 	match, _ := regexp.MatchString("^[a-zA-Z0-9]{1,15}$", sessionID)
 9 | 	return match
10 | }
11 | 


--------------------------------------------------------------------------------