make opencode persiting sessions (#5)

Signed-off-by: Ettore Di Giacinto <mudler@localai.io>

Author: mudler

opencode/Dockerfile

@@ -29,16 +29,26 @@ COPY --from=builder /app/opencode-mcp-server /usr/local/bin/opencode-mcp-server
 ENV OPENCODE_SESSION_DIR=/root
 ENV OPENCODE_BINARY=/usr/local/bin/opencode
 ENV OPENCODE_MAX_SESSIONS=10
-ENV OPENCODE_LOG_RETENTION_HOURS=24
-ENV OPENCODE_FORMAT=json
 ENV OPENCODE_SHARE=false
 
+# Persistence and retention settings
+ENV OPENCODE_PERSISTENCE_ENABLED=true
+ENV OPENCODE_AUTO_SAVE_INTERVAL=30s
+ENV OPENCODE_DEFAULT_RETENTION_HOURS=168
+ENV OPENCODE_COMPLETED_RETENTION_HOURS=168
+ENV OPENCODE_FAILED_RETENTION_HOURS=24
+ENV OPENCODE_STOPPED_RETENTION_HOURS=48
+
+# Logging
+ENV OPENCODE_LOG_LEVEL=INFO
+
 # Optional environment variables (uncomment to use):
 # ENV OPENCODE_MODEL=openai/gpt-4
 # ENV OPENCODE_AGENT=
 # ENV OPENCODE_VARIANT=
 # ENV OPENCODE_ATTACH=
 # ENV OPENCODE_PORT=0
+# ENV OPENCODE_LOG_FILE=/var/log/opencode/opencode-mcp.log
 
 # Run the MCP server
 ENTRYPOINT ["opencode-mcp-server"]

opencode/logging.go

@@ -0,0 +1,213 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"runtime/debug"
+	"time"
+)
+
+// Logger provides structured logging with different levels
+type Logger struct {
+	logger   *log.Logger
+	logLevel LogLevel
+	logFile  *os.File
+}
+
+// LogLevel represents the logging level
+type LogLevel int
+
+const (
+	DEBUG LogLevel = iota
+	INFO
+	WARN
+	ERROR
+	FATAL
+)
+
+func (l LogLevel) String() string {
+	switch l {
+	case DEBUG:
+		return "DEBUG"
+	case INFO:
+		return "INFO"
+	case WARN:
+		return "WARN"
+	case ERROR:
+		return "ERROR"
+	case FATAL:
+		return "FATAL"
+	default:
+		return "UNKNOWN"
+	}
+}
+
+var defaultLogger *Logger
+
+// InitLogger initializes the default logger
+func InitLogger() {
+	logLevel := getEnvLogLevel("OPENCODE_LOG_LEVEL", INFO)
+	logFile := getEnv("OPENCODE_LOG_FILE", "")
+
+	var writer *os.File
+	if logFile != "" {
+		// Ensure log directory exists
+		logDir := filepath.Dir(logFile)
+		if err := os.MkdirAll(logDir, 0755); err != nil {
+			fmt.Fprintf(os.Stderr, "Failed to create log directory: %v\n", err)
+			writer = os.Stderr
+		} else {
+			var err error
+			writer, err = os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
+			if err != nil {
+				fmt.Fprintf(os.Stderr, "Failed to open log file: %v\n", err)
+				writer = os.Stderr
+			}
+		}
+	} else {
+		writer = os.Stderr
+	}
+
+	defaultLogger = &Logger{
+		logger:   log.New(writer, "", log.LstdFlags),
+		logLevel: logLevel,
+		logFile:  writer,
+	}
+}
+
+// GetLogger returns the default logger
+func GetLogger() *Logger {
+	if defaultLogger == nil {
+		InitLogger()
+	}
+	return defaultLogger
+}
+
+// log logs a message at the specified level
+func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
+	if level < l.logLevel {
+		return
+	}
+
+	msg := fmt.Sprintf(format, args...)
+	l.logger.Printf("[%s] %s", level.String(), msg)
+}
+
+// Debug logs a debug message
+func (l *Logger) Debug(format string, args ...interface{}) {
+	l.log(DEBUG, format, args...)
+}
+
+// Info logs an info message
+func (l *Logger) Info(format string, args ...interface{}) {
+	l.log(INFO, format, args...)
+}
+
+// Warn logs a warning message
+func (l *Logger) Warn(format string, args ...interface{}) {
+	l.log(WARN, format, args...)
+}
+
+// Error logs an error message
+func (l *Logger) Error(format string, args ...interface{}) {
+	l.log(ERROR, format, args...)
+}
+
+// Fatal logs a fatal message and exits
+func (l *Logger) Fatal(format string, args ...interface{}) {
+	l.log(FATAL, format, args...)
+	os.Exit(1)
+}
+
+// Close closes the log file if opened
+func (l *Logger) Close() {
+	if l.logFile != os.Stderr && l.logFile != nil {
+		l.logFile.Close()
+	}
+}
+
+// WithRecovery wraps a function with panic recovery
+func WithRecovery(operation string, fn func()) {
+	defer func() {
+		if r := recover(); r != nil {
+			logger := GetLogger()
+			logger.Error("Panic in %s: %v\nStack trace:\n%s", operation, r, debug.Stack())
+		}
+	}()
+	fn()
+}
+
+// getEnvLogLevel parses log level from environment
+func getEnvLogLevel(key string, defaultValue LogLevel) LogLevel {
+	value := os.Getenv(key)
+	switch value {
+	case "DEBUG":
+		return DEBUG
+	case "INFO":
+		return INFO
+	case "WARN", "WARNING":
+		return WARN
+	case "ERROR":
+		return ERROR
+	case "FATAL":
+		return FATAL
+	default:
+		return defaultValue
+	}
+}
+
+// SessionMetrics tracks session-related metrics
+type SessionMetrics struct {
+	TotalSessionsCreated   int
+	TotalSessionsCompleted int
+	TotalSessionsFailed    int
+	ActiveSessions         int
+	StartTime              time.Time
+}
+
+var metrics = &SessionMetrics{
+	StartTime: time.Now(),
+}
+
+// RecordSessionCreated records a new session creation
+func RecordSessionCreated() {
+	metrics.TotalSessionsCreated++
+	metrics.ActiveSessions++
+}
+
+// RecordSessionCompleted records a session completion
+func RecordSessionCompleted() {
+	metrics.TotalSessionsCompleted++
+	metrics.ActiveSessions--
+	if metrics.ActiveSessions < 0 {
+		metrics.ActiveSessions = 0
+	}
+}
+
+// RecordSessionFailed records a session failure
+func RecordSessionFailed() {
+	metrics.TotalSessionsFailed++
+	metrics.ActiveSessions--
+	if metrics.ActiveSessions < 0 {
+		metrics.ActiveSessions = 0
+	}
+}
+
+// GetMetrics returns current metrics
+func GetMetrics() SessionMetrics {
+	return *metrics
+}
+
+// LogMetrics logs current metrics
+func LogMetrics() {
+	logger := GetLogger()
+	logger.Info("Session metrics - Created: %d, Completed: %d, Failed: %d, Active: %d, Uptime: %s",
+		metrics.TotalSessionsCreated,
+		metrics.TotalSessionsCompleted,
+		metrics.TotalSessionsFailed,
+		metrics.ActiveSessions,
+		time.Since(metrics.StartTime).Round(time.Second),
+	)
+}

opencode/main.go

@@ -29,10 +29,12 @@ type Session struct {
 
 // SessionManager manages all opencode sessions
 type SessionManager struct {
-	sessions    map[string]*Session
-	mutex       sync.RWMutex
-	sessionDir  string
-	maxSessions int
+	sessions       map[string]*Session
+	mutex          sync.RWMutex
+	sessionDir     string
+	maxSessions    int
+	store          *JSONSessionStore
+	retentionHours map[string]int // retention hours by status
 }
 
 // Global session manager
@@ -57,10 +59,19 @@ func getEnvInt(key string, defaultValue int) int {
 }
 
 func main() {
+	// Initialize logger first
+	InitLogger()
+	logger := GetLogger()
+
+	logger.Info("Starting OpenCode MCP server")
+
 	// Initialize session manager
 	sessionDir := getEnv("OPENCODE_SESSION_DIR", "/tmp/opencode-sessions")
 	maxSessions := getEnvInt("OPENCODE_MAX_SESSIONS", 10)
 
+	logger.Info("Session directory: %s", sessionDir)
+	logger.Info("Max sessions: %d", maxSessions)
+
 	// Ensure session directory exists
 	if err := os.MkdirAll(sessionDir, 0755); err != nil {
 		log.Fatalf("Failed to create session directory: %v", err)
@@ -70,6 +81,28 @@ func main() {
 		sessions:    make(map[string]*Session),
 		sessionDir:  sessionDir,
 		maxSessions: maxSessions,
+		retentionHours: map[string]int{
+			"completed": getEnvInt("OPENCODE_COMPLETED_RETENTION_HOURS", getEnvInt("OPENCODE_DEFAULT_RETENTION_HOURS", 168)), // 7 days default
+			"failed":    getEnvInt("OPENCODE_FAILED_RETENTION_HOURS", 24),
+			"stopped":   getEnvInt("OPENCODE_STOPPED_RETENTION_HOURS", 48),
+			"running":   0, // Never clean up running sessions
+			"starting":  0, // Never clean up starting sessions
+		},
+	}
+
+	// Initialize persistence store
+	globalSessionManager.store = NewJSONSessionStore(sessionDir, globalSessionManager)
+
+	// Start auto-save
+	autoSaveInterval := getEnvDuration("OPENCODE_AUTO_SAVE_INTERVAL", 30*time.Second)
+	globalSessionManager.store.StartAutoSave(autoSaveInterval)
+	defer globalSessionManager.store.StopAutoSave()
+
+	// Load existing sessions on startup
+	if err := globalSessionManager.LoadSessions(); err != nil {
+		log.Printf("Warning: Failed to load existing sessions: %v", err)
+	} else {
+		log.Printf("Loaded %d existing sessions", len(globalSessionManager.sessions))
 	}
 
 	// Create MCP server