feat(gui): ensure graceful shutdown on interrupt signals

commit: 6588389fd967ac197fdcc69aac2bf98f224c6d72
author: brice · 10mo ago · 2025-12-21 17:14 UTC
committer: brice · 10mo ago · 2025-12-21 19:35 UTC
parent: 6fa0e3d
signature: unsigned

2 files · +77 -63

M cmd/dumber/main.go +43 -40


@@ -5,8 +5,10 @@ import (
5	5		"database/sql"
6	6		"fmt"
7	7		"os"
	8	+	"os/signal"
8	9		"path/filepath"
9	10		"runtime"
	11	+	"syscall"
10	12
11	13		"github.com/bnema/dumber/internal/application/port"
12	14		"github.com/bnema/dumber/internal/application/usecase"

@@ -72,34 +74,39 @@ func runGUI() int {
72	74		// Apply optional /opt-style runtime prefix overrides (if configured)
73	75		deps.ApplyPrefixEnv(cfg.Runtime.Prefix)
74	76
75		-	// Generate session ID for this browser run
76		-	sessionID := logging.GenerateSessionID()
77		-
78		-	logger, logCleanup := initLogger(cfg, sessionID)
79		-	if logCleanup != nil {
80		-	defer logCleanup()
81		-	}
82		-
83		-	logger.Info().
	77	+	bootstrapLogger := logging.NewFromConfigValues(cfg.Logging.Level, cfg.Logging.Format)
	78	+	bootstrapLogger.Info().
84	79		Str("version", version).
85	80		Str("commit", commit).
86	81		Str("build_date", buildDate).
87	82		Msg("starting dumber")
88	83
89		-	// Create root context with logger
90		-	ctx := logging.WithContext(context.Background(), logger)
91		-
92		-	checkRuntimeRequirements(ctx, cfg, logger)
93		-
94		-	checkMediaRequirements(ctx, cfg, logger)
	84	+	ctx := logging.WithContext(context.Background(), bootstrapLogger)
95	85
96		-	dataDir, cacheDir := resolveWebKitDirs(logger)
	86	+	dataDir, cacheDir := resolveWebKitDirs(bootstrapLogger)
97	87
98		-	db, dbCleanup := openDatabase(ctx, logger, dataDir)
	88	+	db, dbCleanup := openDatabase(ctx, bootstrapLogger, dataDir)
99	89		if dbCleanup != nil {
100	90		defer dbCleanup()
101	91		}
102	92
	93	+	browserSession, sessionCtx, err := bootstrap.StartBrowserSession(ctx, cfg, db)
	94	+	if err != nil {
	95	+	bootstrapLogger.Fatal().Err(err).Msg("failed to start session")
	96	+	}
	97	+	if browserSession.LogCleanup != nil {
	98	+	defer browserSession.LogCleanup()
	99	+	}
	100	+	defer func() {
	101	+	_ = browserSession.End(sessionCtx)
	102	+	}()
	103	+
	104	+	logger := browserSession.Logger
	105	+	ctx = sessionCtx
	106	+
	107	+	checkRuntimeRequirements(ctx, cfg, logger)
	108	+	checkMediaRequirements(ctx, cfg, logger)
	109	+
103	110		// Create repositories
104	111		historyRepo := sqlite.NewHistoryRepository(db)
105	112		favoriteRepo := sqlite.NewFavoriteRepository(db)

@@ -156,8 +163,26 @@ func runGUI() int {
156	163		faviconService,
157	164		)
158	165
	166	+	app, err := ui.New(uiDeps)
	167	+	if err != nil {
	168	+	logger.Error().Err(err).Msg("failed to create application")
	169	+	return 1
	170	+	}
	171	+
	172	+	// Ensure sessions are closed on Ctrl+C / SIGTERM.
	173	+	// Without this, the process may exit immediately and skip defers,
	174	+	// leaving the DB session stuck in "active" state.
	175	+	sigCh := make(chan os.Signal, 1)
	176	+	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
	177	+	defer signal.Stop(sigCh)
	178	+	go func() {
	179	+	<-sigCh
	180	+	logger.Info().Msg("received interrupt, quitting")
	181	+	app.Quit()
	182	+	}()
	183	+
159	184		// Run the application
160		-	exitCode := ui.RunWithArgs(ctx, uiDeps)
	185	+	exitCode := app.Run(ctx, os.Args)
161	186		return exitCode
162	187		}
163	188

@@ -169,28 +194,6 @@ func initConfig() *config.Config {
169	194		return config.Get()
170	195		}
171	196
172		-	func initLogger(cfg *config.Config, sessionID string) (zerolog.Logger, func()) {
173		-	logger, logCleanup, err := logging.NewWithFile(
174		-	logging.Config{
175		-	Level: logging.ParseLevel(cfg.Logging.Level),
176		-	Format: cfg.Logging.Format,
177		-	TimeFormat: "15:04:05",
178		-	},
179		-	logging.FileConfig{
180		-	Enabled: cfg.Logging.EnableFileLog,
181		-	LogDir: cfg.Logging.LogDir,
182		-	SessionID: sessionID,
183		-	WriteToStderr: true, // GUI: keep stderr output for debugging
184		-	},
185		-	)
186		-	if err != nil {
187		-	logger = logging.NewFromConfigValues(cfg.Logging.Level, cfg.Logging.Format)
188		-	fmt.Fprintf(os.Stderr, "Warning: failed to create session log file: %v\n", err)
189		-	return logger, nil
190		-	}
191		-	return logger, logCleanup
192		-	}
193		-
194	197		func checkRuntimeRequirements(ctx context.Context, cfg *config.Config, logger zerolog.Logger) {
195	198		probe := deps.NewPkgConfigProbe()
196	199		checkRuntimeUC := usecase.NewCheckRuntimeDependenciesUseCase(probe)

 	"database/sql"
 	"fmt"
 	"os"
+	"os/signal"
 	"path/filepath"
 	"runtime"
+	"syscall"
 	"github.com/bnema/dumber/internal/application/port"
 	"github.com/bnema/dumber/internal/application/usecase"
 	// Apply optional /opt-style runtime prefix overrides (if configured)
 	deps.ApplyPrefixEnv(cfg.Runtime.Prefix)
-	// Generate session ID for this browser run
+	bootstrapLogger := logging.NewFromConfigValues(cfg.Logging.Level, cfg.Logging.Format)
-	sessionID := logging.GenerateSessionID()
+	bootstrapLogger.Info().
-	logger, logCleanup := initLogger(cfg, sessionID)
-	if logCleanup != nil {
-		defer logCleanup()
-	}
-	logger.Info().
 		Str("version", version).
 		Str("commit", commit).
 		Str("build_date", buildDate).
 		Msg("starting dumber")
-	// Create root context with logger
+	ctx := logging.WithContext(context.Background(), bootstrapLogger)
-	ctx := logging.WithContext(context.Background(), logger)
-	checkRuntimeRequirements(ctx, cfg, logger)
-	checkMediaRequirements(ctx, cfg, logger)
-	dataDir, cacheDir := resolveWebKitDirs(logger)
+	dataDir, cacheDir := resolveWebKitDirs(bootstrapLogger)
-	db, dbCleanup := openDatabase(ctx, logger, dataDir)
+	db, dbCleanup := openDatabase(ctx, bootstrapLogger, dataDir)
 	if dbCleanup != nil {
 		defer dbCleanup()
 	}
+	browserSession, sessionCtx, err := bootstrap.StartBrowserSession(ctx, cfg, db)
+	if err != nil {
+		bootstrapLogger.Fatal().Err(err).Msg("failed to start session")
+	}
+	if browserSession.LogCleanup != nil {
+		defer browserSession.LogCleanup()
+	}
+	defer func() {
+		_ = browserSession.End(sessionCtx)
+	}()
+	logger := browserSession.Logger
+	ctx = sessionCtx
+	checkRuntimeRequirements(ctx, cfg, logger)
+	checkMediaRequirements(ctx, cfg, logger)
 	// Create repositories
 	historyRepo := sqlite.NewHistoryRepository(db)
 	favoriteRepo := sqlite.NewFavoriteRepository(db)
 		faviconService,
 	)
+	app, err := ui.New(uiDeps)
+	if err != nil {
+		logger.Error().Err(err).Msg("failed to create application")
+		return 1
+	}
+	// Ensure sessions are closed on Ctrl+C / SIGTERM.
+	// Without this, the process may exit immediately and skip defers,
+	// leaving the DB session stuck in "active" state.
+	sigCh := make(chan os.Signal, 1)
+	signal.Notify(sigCh, os.Interrupt, syscall.SIGTERM)
+	defer signal.Stop(sigCh)
+	go func() {
+		<-sigCh
+		logger.Info().Msg("received interrupt, quitting")
+		app.Quit()
+	}()
 	// Run the application
-	exitCode := ui.RunWithArgs(ctx, uiDeps)
+	exitCode := app.Run(ctx, os.Args)
 	return exitCode
 }
 	return config.Get()
 }
-func initLogger(cfg *config.Config, sessionID string) (zerolog.Logger, func()) {
-	logger, logCleanup, err := logging.NewWithFile(
-		logging.Config{
-			Level:      logging.ParseLevel(cfg.Logging.Level),
-			Format:     cfg.Logging.Format,
-			TimeFormat: "15:04:05",
-		},
-		logging.FileConfig{
-			Enabled:       cfg.Logging.EnableFileLog,
-			LogDir:        cfg.Logging.LogDir,
-			SessionID:     sessionID,
-			WriteToStderr: true, // GUI: keep stderr output for debugging
-		},
-	)
-	if err != nil {
-		logger = logging.NewFromConfigValues(cfg.Logging.Level, cfg.Logging.Format)
-		fmt.Fprintf(os.Stderr, "Warning: failed to create session log file: %v\n", err)
-		return logger, nil
-	}
-	return logger, logCleanup
-}
 func checkRuntimeRequirements(ctx context.Context, cfg *config.Config, logger zerolog.Logger) {
 	probe := deps.NewPkgConfigProbe()
 	checkRuntimeUC := usecase.NewCheckRuntimeDependenciesUseCase(probe)

M internal/cli/app.go +34 -23


@@ -8,11 +8,13 @@ import (
8	8		"os"
9	9		"path/filepath"
10	10
	11	+	"github.com/bnema/dumber/internal/application/port"
11	12		"github.com/bnema/dumber/internal/application/usecase"
12	13		"github.com/bnema/dumber/internal/cli/styles"
13	14		"github.com/bnema/dumber/internal/domain/build"
14	15		"github.com/bnema/dumber/internal/domain/repository"
15	16		"github.com/bnema/dumber/internal/infrastructure/config"
	17	+	infralogging "github.com/bnema/dumber/internal/infrastructure/logging"
16	18		"github.com/bnema/dumber/internal/infrastructure/persistence/sqlite"
17	19		"github.com/bnema/dumber/internal/logging"
18	20		)

@@ -27,6 +29,7 @@ type App struct {
27	29
28	30		// Use cases
29	31		SearchHistoryUC *usecase.SearchHistoryUseCase
	32	+	SessionUC *usecase.ManageSessionUseCase
30	33
31	34		// Context with logger
32	35		ctx context.Context

@@ -36,40 +39,27 @@ type App struct {
36	39		// NewApp creates a new CLI application with all dependencies.
37	40		func NewApp() (*App, error) {
38	41		const dataDirPerm = 0o755
	42	+	var err error
39	43		// Load config
40	44		cfg := loadConfig()
41	45
42	46		// Create theme from config
43	47		theme := styles.NewTheme(cfg)
44	48
45		-	// Initialize logger with file output for debugging
46		-	// Logs can be viewed with: tail -f ~/.local/state/dumber/logs/session_*.log
47		-	logCfg := logging.DefaultConfig()
48		-	if level := os.Getenv("DUMBER_LOG_LEVEL"); level != "" {
49		-	logCfg.Level = logging.ParseLevel(level)
50		-	}
51		-
52		-	// Create session log file
53		-	home, _ := os.UserHomeDir()
54		-	sessionID := logging.GenerateSessionID()
55		-	logDir := filepath.Join(home, ".local", "state", "dumber", "logs")
56		-
57		-	logger, logCleanup, err := logging.NewWithFile(logCfg, logging.FileConfig{
58		-	Enabled: true,
59		-	LogDir: logDir,
60		-	SessionID: sessionID,
61		-	WriteToStderr: false, // CLI: log to file only, keep terminal clean
62		-	})
63		-	if err != nil {
64		-	// Fallback to no-file logging
65		-	logger = logging.NewFromEnv()
66		-	logCleanup = func() {}
	49	+	// Start with a quiet logger. If a browser session is active, we'll attach to it.
	50	+	logLevel := cfg.Logging.Level
	51	+	if envLevel := os.Getenv("DUMBER_LOG_LEVEL"); envLevel != "" {
	52	+	logLevel = envLevel
67	53		}
68	54
	55	+	logger, logCleanup, _ := logging.NewWithFile(
	56	+	logging.Config{Level: logging.ParseLevel(logLevel), Format: cfg.Logging.Format, TimeFormat: "15:04:05"},
	57	+	logging.FileConfig{Enabled: false, WriteToStderr: false},
	58	+	)
69	59		ctx := logging.WithContext(context.Background(), logger)
70		-	logger.Info().Str("command", "cli").Msg("CLI session started")
71	60
72	61		// Determine database path - use share directory per XDG spec (user data)
	62	+	home, _ := os.UserHomeDir()
73	63		dbFile := cfg.Database.Path
74	64		if dbFile == "" {
75	65		dbFile = filepath.Join(home, ".local", "share", "dumber", "dumber.db")

@@ -87,6 +77,26 @@ func NewApp() (*App, error) {
87	77		return nil, fmt.Errorf("open database: %w", err)
88	78		}
89	79
	80	+	// Attach CLI logs to the active browser session (if any).
	81	+	// This avoids creating extra tiny session log files for each CLI invocation.
	82	+	sessionRepo := sqlite.NewSessionRepository(db)
	83	+	sessionLoggerAdapter := infralogging.NewSessionLoggerAdapter()
	84	+	sessionUC := usecase.NewManageSessionUseCase(sessionRepo, sessionLoggerAdapter)
	85	+	if active, activeErr := sessionUC.GetActiveSession(ctx); activeErr == nil && active != nil {
	86	+	attachedLogger, attachedCleanup, _ := sessionLoggerAdapter.CreateLogger(ctx, active.ID, port.SessionLogConfig{
	87	+	Level: logLevel,
	88	+	Format: cfg.Logging.Format,
	89	+	TimeFormat: "15:04:05",
	90	+	LogDir: cfg.Logging.LogDir,
	91	+	WriteToStderr: false,
	92	+	EnableFileLog: cfg.Logging.EnableFileLog,
	93	+	})
	94	+	logger = attachedLogger
	95	+	logCleanup = attachedCleanup
	96	+	ctx = logging.WithContext(context.Background(), logger)
	97	+	logger.Info().Str("session_id", string(active.ID)).Msg("attached to active session")
	98	+	}
	99	+
90	100		logger.Debug().Str("db_path", dbFile).Msg("database connected")
91	101
92	102		// Create repositories

@@ -101,6 +111,7 @@ func NewApp() (*App, error) {
101	111		db: db,
102	112		History: historyRepo,
103	113		SearchHistoryUC: searchHistoryUC,
	114	+	SessionUC: sessionUC,
104	115		ctx: ctx,
105	116		logCleanup: logCleanup,
106	117		}, nil

 	"os"
 	"path/filepath"
+	"github.com/bnema/dumber/internal/application/port"
 	"github.com/bnema/dumber/internal/application/usecase"
 	"github.com/bnema/dumber/internal/cli/styles"
 	"github.com/bnema/dumber/internal/domain/build"
 	"github.com/bnema/dumber/internal/domain/repository"
 	"github.com/bnema/dumber/internal/infrastructure/config"
+	infralogging "github.com/bnema/dumber/internal/infrastructure/logging"
 	"github.com/bnema/dumber/internal/infrastructure/persistence/sqlite"
 	"github.com/bnema/dumber/internal/logging"
 )
 	// Use cases
 	SearchHistoryUC *usecase.SearchHistoryUseCase
+	SessionUC       *usecase.ManageSessionUseCase
 	// Context with logger
 	ctx        context.Context
 // NewApp creates a new CLI application with all dependencies.
 func NewApp() (*App, error) {
 	const dataDirPerm = 0o755
+	var err error
 	// Load config
 	cfg := loadConfig()
 	// Create theme from config
 	theme := styles.NewTheme(cfg)
-	// Initialize logger with file output for debugging
+	// Start with a quiet logger. If a browser session is active, we'll attach to it.
-	// Logs can be viewed with: tail -f ~/.local/state/dumber/logs/session_*.log
+	logLevel := cfg.Logging.Level
-	logCfg := logging.DefaultConfig()
+	if envLevel := os.Getenv("DUMBER_LOG_LEVEL"); envLevel != "" {
-	if level := os.Getenv("DUMBER_LOG_LEVEL"); level != "" {
+		logLevel = envLevel
-		logCfg.Level = logging.ParseLevel(level)
-	}
-	// Create session log file
-	home, _ := os.UserHomeDir()
-	sessionID := logging.GenerateSessionID()
-	logDir := filepath.Join(home, ".local", "state", "dumber", "logs")
-	logger, logCleanup, err := logging.NewWithFile(logCfg, logging.FileConfig{
-		Enabled:       true,
-		LogDir:        logDir,
-		SessionID:     sessionID,
-		WriteToStderr: false, // CLI: log to file only, keep terminal clean
-	})
-	if err != nil {
-		// Fallback to no-file logging
-		logger = logging.NewFromEnv()
-		logCleanup = func() {}
 	}
+	logger, logCleanup, _ := logging.NewWithFile(
+		logging.Config{Level: logging.ParseLevel(logLevel), Format: cfg.Logging.Format, TimeFormat: "15:04:05"},
+		logging.FileConfig{Enabled: false, WriteToStderr: false},
+	)
 	ctx := logging.WithContext(context.Background(), logger)
-	logger.Info().Str("command", "cli").Msg("CLI session started")
 	// Determine database path - use share directory per XDG spec (user data)
+	home, _ := os.UserHomeDir()
 	dbFile := cfg.Database.Path
 	if dbFile == "" {
 		dbFile = filepath.Join(home, ".local", "share", "dumber", "dumber.db")
 		return nil, fmt.Errorf("open database: %w", err)
 	}
+	// Attach CLI logs to the active browser session (if any).
+	// This avoids creating extra tiny session log files for each CLI invocation.
+	sessionRepo := sqlite.NewSessionRepository(db)
+	sessionLoggerAdapter := infralogging.NewSessionLoggerAdapter()
+	sessionUC := usecase.NewManageSessionUseCase(sessionRepo, sessionLoggerAdapter)
+	if active, activeErr := sessionUC.GetActiveSession(ctx); activeErr == nil && active != nil {
+		attachedLogger, attachedCleanup, _ := sessionLoggerAdapter.CreateLogger(ctx, active.ID, port.SessionLogConfig{
+			Level:         logLevel,
+			Format:        cfg.Logging.Format,
+			TimeFormat:    "15:04:05",
+			LogDir:        cfg.Logging.LogDir,
+			WriteToStderr: false,
+			EnableFileLog: cfg.Logging.EnableFileLog,
+		})
+		logger = attachedLogger
+		logCleanup = attachedCleanup
+		ctx = logging.WithContext(context.Background(), logger)
+		logger.Info().Str("session_id", string(active.ID)).Msg("attached to active session")
+	}
 	logger.Debug().Str("db_path", dbFile).Msg("database connected")
 	// Create repositories
 		db:              db,
 		History:         historyRepo,
 		SearchHistoryUC: searchHistoryUC,
+		SessionUC:       sessionUC,
 		ctx:             ctx,
 		logCleanup:      logCleanup,
 	}, nil