Changeset 0.12.0 (#63)

server/main.go

@@ -1,7 +1,11 @@
 package main
 
 import (
+	"fmt"
 	"log"
+	"os"
+	"strings"
+	"time"
 
 	"github.com/gin-gonic/gin"
 
@@ -9,16 +13,30 @@ import (
 	"git.gobha.me/xcaliber/chat-switchboard/crypto"
 	"git.gobha.me/xcaliber/chat-switchboard/database"
 	"git.gobha.me/xcaliber/chat-switchboard/events"
+	"git.gobha.me/xcaliber/chat-switchboard/extraction"
 	"git.gobha.me/xcaliber/chat-switchboard/handlers"
 	"git.gobha.me/xcaliber/chat-switchboard/middleware"
 	"git.gobha.me/xcaliber/chat-switchboard/providers"
 	"git.gobha.me/xcaliber/chat-switchboard/roles"
+	"git.gobha.me/xcaliber/chat-switchboard/storage"
 	"git.gobha.me/xcaliber/chat-switchboard/store"
 	postgres "git.gobha.me/xcaliber/chat-switchboard/store/postgres"
 	_ "git.gobha.me/xcaliber/chat-switchboard/tools" // registers built-in tools via init()
 )
 
 func main() {
+	// ── Subcommand dispatch ──────────────────
+	// Usage: switchboard vault rekey
+	if len(os.Args) > 2 && os.Args[1] == "vault" {
+		runVaultCommand(os.Args[2])
+		return
+	}
+	if len(os.Args) > 1 && os.Args[1] == "version" {
+		fmt.Println("switchboard", Version)
+		return
+	}
+
+	// ── Server startup ──────────────────────
 	cfg := config.Load()
 
 	// Register LLM providers
@@ -27,6 +45,7 @@ func main() {
 	var stores store.Stores
 	uekCache := crypto.NewUEKCache()
 	var keyResolver *crypto.KeyResolver
+	var objStore storage.ObjectStore
 
 	if err := database.Connect(cfg); err != nil {
 		log.Printf("⚠ Database unavailable: %v", err)
@@ -73,6 +92,51 @@ func main() {
 	}
 	defer database.Close()
 
+	// ── File Storage ─────────────────────────
+	// Auto-detects PVC if STORAGE_PATH is writable. Explicit STORAGE_BACKEND
+	// overrides auto-detection. nil objStore = storage features disabled.
+	var s3Cfg *storage.S3Config
+	if cfg.S3Bucket != "" {
+		s3Cfg = &storage.S3Config{
+			Endpoint:       cfg.S3Endpoint,
+			Bucket:         cfg.S3Bucket,
+			Region:         cfg.S3Region,
+			AccessKey:      cfg.S3AccessKey,
+			SecretKey:      cfg.S3SecretKey,
+			Prefix:         cfg.S3Prefix,
+			ForcePathStyle: cfg.S3ForcePathStyle,
+		}
+	}
+	if s, err := storage.Init(cfg.StorageBackend, cfg.StoragePath, s3Cfg); err != nil {
+		if cfg.StorageBackend != "" {
+			// Explicit backend requested but failed — fatal
+			log.Fatalf("❌ Storage init failed: %v", err)
+		}
+		log.Printf("⚠ Storage init failed: %v", err)
+	} else {
+		objStore = s
+	}
+	handlers.SetStorageConfigured(objStore != nil)
+
+	// ── Extraction Queue ────────────────────
+	// Filesystem-based queue for document text extraction (PDF, DOCX, etc.)
+	// Nil if storage is disabled.
+	var extQueue *extraction.Queue
+	if objStore != nil && cfg.StoragePath != "" {
+		q, err := extraction.NewQueue(cfg.StoragePath, cfg.ExtractionConcurrency)
+		if err != nil {
+			log.Printf("⚠ Extraction queue init failed: %v", err)
+		} else {
+			extQueue = q
+			// Recover items stuck in "processing" from previous crash
+			if recovered, err := extQueue.RecoverStale(30 * time.Minute); err != nil {
+				log.Printf("⚠ Extraction recovery failed: %v", err)
+			} else if recovered > 0 {
+				log.Printf("  📋 Recovered %d stale extraction items", recovered)
+			}
+		}
+	}
+
 	// Role resolver for model role dispatch (needs stores + vault)
 	roleResolver := roles.NewResolver(stores, keyResolver)
 
@@ -148,7 +212,7 @@ func main() {
 			protected.DELETE("/channels/:id", channels.DeleteChannel)
 
 			// Messages
-			msgs := handlers.NewMessageHandler(keyResolver, stores, hub)
+			msgs := handlers.NewMessageHandler(keyResolver, stores, hub, objStore)
 			protected.GET("/channels/:id/messages", msgs.ListMessages)
 			protected.POST("/channels/:id/messages", msgs.CreateMessage)
 
@@ -160,7 +224,7 @@ func main() {
 			protected.GET("/channels/:id/messages/:msgId/siblings", msgs.ListSiblings)
 
 			// Chat Completions
-			comp := handlers.NewCompletionHandler(keyResolver, stores, hub)
+			comp := handlers.NewCompletionHandler(keyResolver, stores, hub, objStore)
 			protected.POST("/chat/completions", comp.Complete)
 
 			// Summarize & Continue
@@ -222,6 +286,17 @@ func main() {
 			protected.PUT("/notes/:id", notes.Update)
 			protected.DELETE("/notes/:id", notes.Delete)
 
+			// Attachments (file upload/download)
+			attachH := handlers.NewAttachmentHandler(stores, objStore, extQueue)
+			protected.POST("/channels/:id/attachments", attachH.Upload)
+			protected.GET("/channels/:id/attachments", attachH.ListByChannel)
+			protected.GET("/attachments/:id", attachH.GetMetadata)
+			protected.GET("/attachments/:id/download", attachH.Download)
+			protected.DELETE("/attachments/:id", attachH.DeleteAttachment)
+
+			// Hook: clean up storage files when channels are deleted
+			handlers.SetChannelDeleteHook(attachH.CleanupChannelStorage)
+
 			// Teams (user: my teams)
 			teams := handlers.NewTeamHandler(keyResolver)
 			protected.GET("/teams/mine", teams.MyTeams)
@@ -352,6 +427,19 @@ func main() {
 			admin.PUT("/pricing", usageH.UpsertPricing)
 			admin.DELETE("/pricing/:provider/:model", usageH.DeletePricing)
 
+			// Storage status
+			storageH := handlers.NewStorageHandler(objStore)
+			admin.GET("/storage/status", storageH.Status)
+
+			// Vault
+			admin.GET("/vault/status", adm.VaultStatus)
+
+			// Storage management (orphan cleanup)
+			attachAdm := handlers.NewAttachmentHandler(stores, objStore, extQueue)
+			admin.GET("/storage/orphans", attachAdm.OrphanCount)
+			admin.POST("/storage/cleanup", attachAdm.CleanupOrphans)
+			admin.GET("/storage/extraction", attachAdm.ExtractionStatus)
+
 			// Extensions (admin)
 			extAdm := handlers.NewExtensionHandler(stores)
 			admin.GET("/extensions", extAdm.AdminListExtensions)
@@ -369,8 +457,64 @@ func main() {
 	log.Printf("   Base path: %s", bp)
 	log.Printf("   Schema: %s", database.SchemaVersion())
 	log.Printf("   Providers: %v", providers.List())
+	if objStore != nil {
+		log.Printf("   Storage: %s", objStore.Backend())
+		if extQueue != nil {
+			log.Printf("   Extraction: enabled (concurrency=%d)", cfg.ExtractionConcurrency)
+		} else {
+			log.Printf("   Extraction: disabled")
+		}
+	} else {
+		log.Printf("   Storage: disabled")
+	}
 	log.Printf("   EventBus: ready, WebSocket on %s/ws", cfg.BasePath)
 	if err := r.Run(":" + cfg.Port); err != nil {
 		log.Fatalf("Failed to start server: %v", err)
 	}
 }
+
+// ── Vault CLI Commands ──────────────────────
+
+func runVaultCommand(subcmd string) {
+	cfg := config.Load()
+
+	switch strings.ToLower(subcmd) {
+	case "rekey":
+		if cfg.DatabaseURL == "" {
+			log.Fatal("DATABASE_URL is required for vault operations")
+		}
+		if err := database.Connect(cfg); err != nil {
+			log.Fatalf("❌ Database connection failed: %v", err)
+		}
+		defer database.Close()
+
+		oldKey := os.Getenv("ENCRYPTION_KEY")
+		newKey := os.Getenv("NEW_ENCRYPTION_KEY")
+
+		if err := crypto.Rekey(database.DB, oldKey, newKey); err != nil {
+			log.Fatalf("❌ Vault rekey failed: %v", err)
+		}
+
+	case "status":
+		if cfg.DatabaseURL == "" {
+			log.Fatal("DATABASE_URL is required for vault operations")
+		}
+		if err := database.Connect(cfg); err != nil {
+			log.Fatalf("❌ Database connection failed: %v", err)
+		}
+		defer database.Close()
+
+		status, err := crypto.VaultStatus(database.DB, cfg.EncryptionKey)
+		if err != nil {
+			log.Fatalf("❌ Failed to get vault status: %v", err)
+		}
+		fmt.Printf("Encryption key set:   %v\n", status.EncryptionKeySet)
+		fmt.Printf("Encrypted keys:       %d\n", status.EncryptedKeys)
+		fmt.Printf("Vault users (active): %d\n", status.VaultUsers)
+
+	default:
+		fmt.Fprintf(os.Stderr, "Unknown vault command: %s\n", subcmd)
+		fmt.Fprintf(os.Stderr, "Usage: switchboard vault <rekey|status>\n")
+		os.Exit(1)
+	}
+}