init commit

This commit is contained in:
ysandler
2026-01-27 22:01:30 -06:00
commit ee23a4f39c
22 changed files with 1605 additions and 0 deletions

211
cmd/service.go Normal file
View File

@@ -0,0 +1,211 @@
package cmd
import (
"fmt"
"os"
"os/exec"
"path/filepath"
"strconv"
"syscall"
"github.com/spf13/cobra"
"github.com/yeho/klp/internal/database"
"github.com/yeho/klp/internal/service"
)
var (
foregroundFlag bool
)
var serviceCmd = &cobra.Command{
Use: "service",
Short: "Service management commands",
Long: `Commands for managing the clipboard monitoring service.`,
}
var serviceStartCmd = &cobra.Command{
Use: "start",
Short: "Start the clipboard monitor",
Long: `Start the clipboard monitoring service as a background daemon.
The service monitors clipboard changes and stores them in the database.
Use --foreground to run in foreground instead of daemonizing.
Use 'klp service stop' to stop the daemon.`,
Run: func(cmd *cobra.Command, args []string) {
if !foregroundFlag && os.Getenv("KLP_DAEMON") != "1" {
// Daemonize: re-exec ourselves in background
daemonize()
return
}
// Running as daemon or in foreground mode
runMonitor()
},
}
var serviceStopCmd = &cobra.Command{
Use: "stop",
Short: "Stop the clipboard monitor daemon",
Run: func(cmd *cobra.Command, args []string) {
pidFile := getPidFile()
data, err := os.ReadFile(pidFile)
if err != nil {
fmt.Println("No running daemon found")
return
}
pid, err := strconv.Atoi(string(data))
if err != nil {
fmt.Fprintf(os.Stderr, "Invalid PID file: %v\n", err)
os.Exit(1)
}
process, err := os.FindProcess(pid)
if err != nil {
fmt.Println("No running daemon found")
os.Remove(pidFile)
return
}
if err := process.Signal(syscall.SIGTERM); err != nil {
fmt.Printf("Daemon not running (PID %d)\n", pid)
os.Remove(pidFile)
return
}
fmt.Printf("Stopped daemon (PID %d)\n", pid)
os.Remove(pidFile)
},
}
var serviceStatusCmd = &cobra.Command{
Use: "status",
Short: "Check if the clipboard monitor is running",
Run: func(cmd *cobra.Command, args []string) {
pidFile := getPidFile()
data, err := os.ReadFile(pidFile)
if err != nil {
fmt.Println("Daemon is not running")
return
}
pid, err := strconv.Atoi(string(data))
if err != nil {
fmt.Println("Daemon is not running (invalid PID file)")
return
}
// Check if process exists
process, err := os.FindProcess(pid)
if err != nil {
fmt.Println("Daemon is not running")
os.Remove(pidFile)
return
}
// On Unix, FindProcess always succeeds, so we need to send signal 0 to check
if err := process.Signal(syscall.Signal(0)); err != nil {
fmt.Println("Daemon is not running")
os.Remove(pidFile)
return
}
fmt.Printf("Daemon is running (PID %d)\n", pid)
},
}
func init() {
rootCmd.AddCommand(serviceCmd)
serviceCmd.AddCommand(serviceStartCmd)
serviceCmd.AddCommand(serviceStopCmd)
serviceCmd.AddCommand(serviceStatusCmd)
serviceStartCmd.Flags().BoolVarP(&foregroundFlag, "foreground", "f", false, "Run in foreground instead of daemonizing")
}
func getPidFile() string {
homeDir, _ := os.UserHomeDir()
return filepath.Join(homeDir, ".config", "klp", "klp.pid")
}
func getLogFile() string {
homeDir, _ := os.UserHomeDir()
return filepath.Join(homeDir, ".config", "klp", "klp.log")
}
func daemonize() {
// Check if already running
pidFile := getPidFile()
if data, err := os.ReadFile(pidFile); err == nil {
if pid, err := strconv.Atoi(string(data)); err == nil {
if process, err := os.FindProcess(pid); err == nil {
if err := process.Signal(syscall.Signal(0)); err == nil {
fmt.Printf("Daemon already running (PID %d)\n", pid)
return
}
}
}
}
// Get executable path
executable, err := os.Executable()
if err != nil {
fmt.Fprintf(os.Stderr, "Error getting executable path: %v\n", err)
os.Exit(1)
}
// Ensure config directory exists
os.MkdirAll(filepath.Dir(pidFile), 0755)
// Open log file
logFile, err := os.OpenFile(getLogFile(), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
fmt.Fprintf(os.Stderr, "Error opening log file: %v\n", err)
os.Exit(1)
}
// Start daemon process
cmd := exec.Command(executable, "service", "start", "--foreground")
cmd.Env = append(os.Environ(), "KLP_DAEMON=1")
cmd.Stdout = logFile
cmd.Stderr = logFile
cmd.SysProcAttr = &syscall.SysProcAttr{
Setsid: true, // Create new session
}
if err := cmd.Start(); err != nil {
fmt.Fprintf(os.Stderr, "Error starting daemon: %v\n", err)
os.Exit(1)
}
// Write PID file
if err := os.WriteFile(pidFile, []byte(strconv.Itoa(cmd.Process.Pid)), 0644); err != nil {
fmt.Fprintf(os.Stderr, "Error writing PID file: %v\n", err)
}
fmt.Printf("Daemon started (PID %d)\n", cmd.Process.Pid)
fmt.Printf("Log file: %s\n", getLogFile())
}
func runMonitor() {
db, err := database.Load(cfg.DBPath())
if err != nil {
fmt.Fprintf(os.Stderr, "Error loading database: %v\n", err)
os.Exit(1)
}
monitor, err := service.NewMonitor(cfg, db)
if err != nil {
fmt.Fprintf(os.Stderr, "Error creating monitor: %v\n", err)
os.Exit(1)
}
// Clean up PID file on exit
pidFile := getPidFile()
defer os.Remove(pidFile)
if err := monitor.Run(); err != nil {
fmt.Fprintf(os.Stderr, "Error running monitor: %v\n", err)
os.Exit(1)
}
}