Files
Unified_Dashboard_Suite_Go/cmd/image-hoster/main.go
T

480 lines
14 KiB
Go

package main
import (
"encoding/json"
"fmt"
"io"
"log/slog"
"net/http"
"os"
"os/exec"
"path/filepath"
"strings"
"sync"
"time"
"github.com/go-chi/chi/v5"
"github.com/go-chi/chi/v5/middleware"
"unified-dashboard/internal/common"
mymiddleware "unified-dashboard/internal/middleware"
)
var (
sessionPaths = make(map[string]string)
sessionStats = make(map[string]map[string]int)
relaySessions = make(map[string]chan map[string]interface{})
requestEvents = make(map[string]chan []byte)
tunnelProcess *exec.Cmd
tunnelURL string
tunnelLock sync.Mutex
globalLock sync.Mutex
)
func writeJSON(w http.ResponseWriter, status int, data any) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(status)
json.NewEncoder(w).Encode(data)
}
func main() {
common.InitLogger("image-hoster")
port := common.EnvOr("PORT", "5005")
scriptName := os.Getenv("SCRIPT_NAME")
r := chi.NewRouter()
r.Use(middleware.RealIP)
r.Use(middleware.RequestID)
r.Use(mymiddleware.RequestLogger)
r.Use(middleware.Recoverer)
if scriptName != "" {
r.Use(common.PrefixMiddleware(scriptName))
}
workDir, _ := os.Getwd()
webDir := filepath.Join(workDir, "web", "image-hoster")
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, filepath.Join(webDir, "index.html"))
})
r.Get("/styles.css", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/css; charset=utf-8")
http.ServeFile(w, r, filepath.Join(webDir, "styles.css"))
})
r.Get("/app.js", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/javascript; charset=utf-8")
http.ServeFile(w, r, filepath.Join(webDir, "app.js"))
})
r.Get("/radheradhe", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, filepath.Join(webDir, "admin.html"))
})
r.Get("/radheradhe/", func(w http.ResponseWriter, r *http.Request) {
http.ServeFile(w, r, filepath.Join(webDir, "admin.html"))
})
r.Get("/admin.css", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "text/css; charset=utf-8")
http.ServeFile(w, r, filepath.Join(webDir, "admin.css"))
})
r.Get("/admin.js", func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/javascript; charset=utf-8")
http.ServeFile(w, r, filepath.Join(webDir, "admin.js"))
})
r.Post("/create_session", func(w http.ResponseWriter, r *http.Request) {
var req struct {
Mode string `json:"mode"`
}
// Body might be empty
json.NewDecoder(r.Body).Decode(&req)
sessionID := fmt.Sprintf("%d", time.Now().UnixNano())
globalLock.Lock()
if req.Mode == "relay" {
relaySessions[sessionID] = make(chan map[string]interface{}, 100)
}
sessionStats[sessionID] = map[string]int{"requests": 0, "bytes": 0}
globalLock.Unlock()
writeJSON(w, 200, map[string]any{"success": true, "session_id": sessionID})
})
r.Post("/admin_login", func(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, map[string]bool{"success": true})
})
r.Post("/set_session_path", func(w http.ResponseWriter, r *http.Request) {
var req struct {
SessionID string `json:"session_id"`
Path string `json:"path"`
}
json.NewDecoder(r.Body).Decode(&req)
globalLock.Lock()
if req.Path == "(Relay Mode)" {
// Relay mode: serve files from browser via SSE, NOT from disk
if _, exists := relaySessions[req.SessionID]; !exists {
relaySessions[req.SessionID] = make(chan map[string]interface{}, 100)
}
// Remove from sessionPaths so the /files handler uses the relay path
delete(sessionPaths, req.SessionID)
if _, exists := sessionStats[req.SessionID]; !exists {
sessionStats[req.SessionID] = map[string]int{"requests": 0, "bytes": 0}
}
globalLock.Unlock()
writeJSON(w, 200, map[string]any{"success": true, "mode": "relay"})
return
}
// Server-side path mapping
if req.Path == "" {
globalLock.Unlock()
writeJSON(w, 400, map[string]string{"error": "Path required"})
return
}
sessionPaths[req.SessionID] = req.Path
// If previously in relay mode, remove it
delete(relaySessions, req.SessionID)
if _, exists := sessionStats[req.SessionID]; !exists {
sessionStats[req.SessionID] = map[string]int{"requests": 0, "bytes": 0}
}
globalLock.Unlock()
writeJSON(w, 200, map[string]bool{"success": true})
})
r.Post("/delete_session", func(w http.ResponseWriter, r *http.Request) {
var req struct {
SessionID string `json:"session_id"`
}
json.NewDecoder(r.Body).Decode(&req)
globalLock.Lock()
delete(sessionPaths, req.SessionID)
delete(relaySessions, req.SessionID)
delete(sessionStats, req.SessionID)
globalLock.Unlock()
writeJSON(w, 200, map[string]bool{"success": true})
})
r.Get("/stream_events/{session_id}", func(w http.ResponseWriter, r *http.Request) {
sid := chi.URLParam(r, "session_id")
w.Header().Set("Content-Type", "text/event-stream")
w.Header().Set("Cache-Control", "no-cache")
w.Header().Set("Connection", "keep-alive")
flusher, ok := w.(http.Flusher)
if !ok { return }
globalLock.Lock()
ch, exists := relaySessions[sid]
globalLock.Unlock()
if !exists { return }
for msg := range ch {
b, _ := json.Marshal(msg)
fmt.Fprintf(w, "data: %s\n\n", b)
flusher.Flush()
}
})
r.Post("/fulfill_request", func(w http.ResponseWriter, r *http.Request) {
reqID := r.FormValue("req_id")
globalLock.Lock()
ch, exists := requestEvents[reqID]
globalLock.Unlock()
if !exists {
writeJSON(w, 404, map[string]string{"error": "Invalid ID"})
return
}
file, _, err := r.FormFile("file")
if err == nil {
data, _ := io.ReadAll(file)
ch <- data
file.Close()
} else {
ch <- nil
}
writeJSON(w, 200, map[string]bool{"success": true})
})
r.Get("/files/{session_id}/*", func(w http.ResponseWriter, r *http.Request) {
sid := chi.URLParam(r, "session_id")
filename := chi.URLParam(r, "*")
globalLock.Lock()
basePath, localExists := sessionPaths[sid]
ch, relayExists := relaySessions[sid]
stats := sessionStats[sid]
globalLock.Unlock()
if stats != nil {
stats["requests"]++
}
if localExists {
fullPath := filepath.Join(basePath, filename)
stat, err := os.Stat(fullPath)
if err == nil {
if stats != nil {
stats["bytes"] += int(stat.Size())
}
if stat.IsDir() {
// Return beautiful HTML listing for directories instead of 404
w.Header().Set("Content-Type", "text/html")
html := `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Hosted Files</title>
<link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
<style>
:root {
--bg-deep: #050505;
--bg-surface: #101015;
--primary: #7b2cbf;
--secondary: #4cc9f0;
--text-main: #ffffff;
--text-muted: #a0a0a0;
}
body {
font-family: 'Segoe UI', -apple-system, sans-serif;
background: var(--bg-deep);
color: var(--text-main);
margin: 0;
padding: 40px 20px;
display: flex;
flex-direction: column;
align-items: center;
}
.container {
width: 100%;
max-width: 800px;
background: var(--bg-surface);
border-radius: 12px;
padding: 30px;
box-shadow: 0 10px 30px rgba(0,0,0,0.5);
border: 1px solid rgba(255,255,255,0.05);
}
h2 {
margin-top: 0;
color: var(--secondary);
border-bottom: 2px solid rgba(255,255,255,0.1);
padding-bottom: 15px;
display: flex;
align-items: center;
gap: 10px;
}
.file-list {
list-style: none;
padding: 0;
margin: 0;
display: flex;
flex-direction: column;
gap: 8px;
}
.file-list li a {
display: flex;
align-items: center;
gap: 12px;
color: var(--text-main);
text-decoration: none;
padding: 12px 15px;
border-radius: 8px;
background: rgba(255,255,255,0.02);
transition: all 0.2s;
border: 1px solid transparent;
}
.file-list li a:hover {
background: rgba(76, 201, 240, 0.1);
border-color: rgba(76, 201, 240, 0.3);
color: var(--secondary);
transform: translateX(5px);
}
.icon {
color: var(--primary);
font-size: 1.2rem;
}
</style>
</head>
<body>
<div class="container">
<h2><i class="fas fa-folder-open"></i> Hosted Files</h2>
<ul class="file-list">`
w.Write([]byte(html))
entries, _ := os.ReadDir(fullPath)
if len(entries) == 0 {
w.Write([]byte(`<div style="color:var(--text-muted); padding:20px; text-align:center;">This folder is empty.</div>`))
} else {
for _, e := range entries {
icon := "fa-file"
if e.IsDir() { icon = "fa-folder" }
ext := strings.ToLower(filepath.Ext(e.Name()))
if ext == ".jpg" || ext == ".png" || ext == ".gif" || ext == ".webp" { icon = "fa-image" }
link := fmt.Sprintf("%s/%s", strings.TrimRight(r.URL.Path, "/"), e.Name())
w.Write([]byte(fmt.Sprintf(`<li><a href="%s"><i class="fas %s icon"></i> %s</a></li>`, link, icon, e.Name())))
}
}
w.Write([]byte("</ul></div></body></html>"))
return
}
http.ServeFile(w, r, fullPath)
return
}
} else if relayExists {
reqID := fmt.Sprintf("%d", time.Now().UnixNano())
resCh := make(chan []byte, 1)
globalLock.Lock()
requestEvents[reqID] = resCh
globalLock.Unlock()
ch <- map[string]interface{}{
"type": "request_file",
"req_id": reqID,
"filename": filename,
}
select {
case data := <-resCh:
globalLock.Lock()
delete(requestEvents, reqID)
globalLock.Unlock()
if data != nil {
if stats != nil {
stats["bytes"] += len(data)
}
w.Write(data)
return
}
case <-time.After(30 * time.Second):
globalLock.Lock()
delete(requestEvents, reqID)
globalLock.Unlock()
}
}
http.Error(w, "Not found", 404)
})
r.Get("/get_session_files/{session_id}", func(w http.ResponseWriter, r *http.Request) {
sid := chi.URLParam(r, "session_id")
globalLock.Lock()
_, relayExists := relaySessions[sid]
basePath, localExists := sessionPaths[sid]
globalLock.Unlock()
if relayExists {
writeJSON(w, 200, map[string]any{"success": true, "mode": "relay", "path_set": true, "current_path": "(Hosted from Browser)"})
return
}
if !localExists {
writeJSON(w, 200, map[string]any{"success": true, "files": []any{}, "path_set": false})
return
}
var filesList []map[string]any
filepath.Walk(basePath, func(path string, info os.FileInfo, err error) error {
if err != nil || info.IsDir() {
return nil
}
relPath, err := filepath.Rel(basePath, path)
if err != nil {
return nil
}
relPath = filepath.ToSlash(relPath)
folder := filepath.Dir(relPath)
if folder == "." {
folder = "(Root)"
}
ext := strings.ToLower(filepath.Ext(path))
isCode := ext == ".json" || ext == ".html" || ext == ".htm" || ext == ".css" || ext == ".js"
filesList = append(filesList, map[string]any{
"path": relPath,
"folder": folder,
"name": info.Name(),
"url": fmt.Sprintf("/files/%s/%s", sid, relPath),
"is_code": isCode,
})
return nil
})
writeJSON(w, 200, map[string]any{
"success": true,
"files": filesList,
"path_set": true,
"current_path": basePath,
})
})
r.Post("/browse_folder", func(w http.ResponseWriter, r *http.Request) {
cmd := exec.Command("zenity", "--file-selection", "--directory", "--title=Select Image Folder")
out, err := cmd.Output()
path := strings.TrimSpace(string(out))
if err == nil && path != "" {
writeJSON(w, 200, map[string]any{"success": true, "path": path})
return
}
pyCode := `import tkinter as tk; from tkinter import filedialog; root = tk.Tk(); root.withdraw(); root.attributes("-topmost", True); print(filedialog.askdirectory()); root.destroy()`
cmd = exec.Command("python3", "-c", pyCode)
out, err = cmd.Output()
path = strings.TrimSpace(string(out))
if err == nil && path != "" {
writeJSON(w, 200, map[string]any{"success": true, "path": path})
return
}
writeJSON(w, 200, map[string]any{"success": false, "error": "No folder selected"})
})
r.Post("/get_tunnel", func(w http.ResponseWriter, r *http.Request) {
var req struct {
SessionID string `json:"session_id"`
}
json.NewDecoder(r.Body).Decode(&req)
if req.SessionID == "" {
writeJSON(w, 400, map[string]string{"error": "No session ID"})
return
}
tunnelURL := fmt.Sprintf("https://nexus.linuxguy.space/hoster/%s", req.SessionID)
writeJSON(w, 200, map[string]any{"success": true, "url": tunnelURL})
})
r.Post("/stop_tunnel", func(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, map[string]bool{"success": true})
})
r.Post("/regenerate_tunnel", func(w http.ResponseWriter, r *http.Request) {
writeJSON(w, 200, map[string]bool{"success": true})
})
r.Post("/get_tunnel_status", func(w http.ResponseWriter, r *http.Request) {
var req struct {
SessionID string `json:"session_id"`
}
json.NewDecoder(r.Body).Decode(&req)
tunnelURL := fmt.Sprintf("https://nexus.linuxguy.space/hoster/%s", req.SessionID)
writeJSON(w, 200, map[string]any{"active": true, "url": tunnelURL})
})
slog.Info("starting image-hoster", "port", port, "pid", os.Getpid())
if err := http.ListenAndServe(":"+port, r); err != nil {
slog.Error("server failed", "error", err)
}
}