test: add migration engine tests

Add three tests requested in review:
- TestParseMigrationVersion: table-driven test with 9 cases covering valid
  filenames, descriptions, invalid alpha/mixed, and empty string
- TestApplyMigrations_Idempotent: verifies running migrations twice is a
  no-op with no duplicate rows in schema_migrations
- TestBootstrapMigrationsTable_FreshDatabase: isolation test verifying
  bootstrap creates schema_migrations table with version 0 row

README.md

@@ -170,9 +170,8 @@ vaultik [--config <path>] store info
 * Config is located at `/etc/vaultik/config.yml` by default
 * Optional snapshot names argument to create specific snapshots (default: all)
 * `--cron`: Silent unless error (for crontab)
-* `--daemon`: Run continuously with filesystem monitoring and periodic scans (see [daemon mode](#daemon-mode))
+* `--daemon`: Run continuously with inotify monitoring and periodic scans
 * `--prune`: Delete old snapshots and orphaned blobs after backup
-* `--skip-errors`: Skip file read errors (log them loudly but continue)
 
 **snapshot list**: List all snapshots with their timestamps and sizes
 * `--json`: Output in JSON format
@@ -209,53 +208,6 @@ vaultik [--config <path>] store info
 
 ---
 
-## daemon mode
-
-When `--daemon` is passed to `snapshot create`, vaultik runs as a
-long-running process that continuously monitors configured directories for
-changes and creates backups automatically.
-
-```sh
-vaultik --config /etc/vaultik.yaml snapshot create --daemon
-```
-
-### how it works
-
-1. **Initial backup**: On startup, a full backup of all configured snapshots
-   runs immediately.
-2. **Filesystem watching**: All configured snapshot paths are monitored for
-   file changes using OS-native filesystem notifications (inotify on Linux,
-   FSEvents on macOS, ReadDirectoryChangesW on Windows) via the
-   [fsnotify](https://github.com/fsnotify/fsnotify) library.
-3. **Periodic backups**: At each `backup_interval` tick, if filesystem
-   changes have been detected and `min_time_between_run` has elapsed since
-   the last backup, a backup runs for only the affected snapshots.
-4. **Full scans**: At each `full_scan_interval` tick, a full backup of all
-   snapshots runs regardless of detected changes. This catches any changes
-   that filesystem notifications may have missed.
-5. **Graceful shutdown**: On SIGTERM or SIGINT, the daemon completes any
-   in-progress backup before exiting.
-
-### configuration
-
-These config fields control daemon behavior:
-
-```yaml
-backup_interval: 1h       # How often to check for changes and run backups
-full_scan_interval: 24h   # How often to do a complete scan of all paths
-min_time_between_run: 15m  # Minimum gap between consecutive backup runs
-```
-
-### notes
-
-* New directories created under watched paths are automatically picked up.
-* The daemon uses the same `CreateSnapshot` logic as one-shot mode — each
-  backup run is a standard incremental snapshot.
-* The `--prune`, `--cron`, and `--skip-errors` flags work in daemon mode
-  and apply to each individual backup run.
-
----
-
 ## architecture
 
 ### s3 bucket layout

TODO.md

@@ -106,21 +106,23 @@ User must have rclone configured separately (via `rclone config`).
 
 ---
 
-## Daemon Mode (Complete)
+## Post-1.0 (Daemon Mode)
 
-1. [x] Implement cross-platform filesystem watcher (via fsnotify)
+1. Implement inotify file watcher for Linux
-   - Watches source directories for changes
+   - Watch source directories for changes
-   - Tracks dirty paths in memory
+   - Track dirty paths in memory
-   - Automatically watches new directories
 
-1. [x] Implement backup scheduler in daemon mode
+1. Implement FSEvents watcher for macOS
-   - Respects backup_interval config
+   - Watch source directories for changes
-   - Triggers backup when dirty paths exist and interval elapsed
+   - Track dirty paths in memory
-   - Implements full_scan_interval for periodic full scans
-   - Respects min_time_between_run to prevent excessive runs
 
-1. [x] Add proper signal handling for daemon
+1. Implement backup scheduler in daemon mode
+   - Respect backup_interval config
+   - Trigger backup when dirty paths exist and interval elapsed
+   - Implement full_scan_interval for periodic full scans
+
+1. Add proper signal handling for daemon
    - Graceful shutdown on SIGTERM/SIGINT
-   - Completes in-progress backup before exit
+   - Complete in-progress backup before exit
 
-1. [x] Write tests for daemon mode
+1. Write tests for daemon mode

go.mod

@@ -13,7 +13,6 @@ require (
 	github.com/aws/aws-sdk-go-v2/service/s3 v1.90.0
 	github.com/aws/smithy-go v1.23.2
 	github.com/dustin/go-humanize v1.0.1
-	github.com/fsnotify/fsnotify v1.9.0
 	github.com/gobwas/glob v0.2.3
 	github.com/google/uuid v1.6.0
 	github.com/johannesboyne/gofakes3 v0.0.0-20250603205740-ed9094be7668

go.sum

@@ -286,8 +286,8 @@ github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
 github.com/flynn/noise v1.1.0 h1:KjPQoQCEFdZDiP03phOvGi11+SVVhBG2wOWAorLsstg=
 github.com/flynn/noise v1.1.0/go.mod h1:xbMo+0i6+IGbYdJhF31t2eR1BIU0CYc12+BNAKwUTag=
-github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
-github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E=
 github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
 github.com/gabriel-vasile/mimetype v1.4.11 h1:AQvxbp830wPhHTqc1u7nzoLT+ZFxGY7emj5DR5DYFik=

internal/database/database.go

@@ -6,24 +6,32 @@
 // multiple source files. Blobs are content-addressed, meaning their filename
 // is derived from their SHA256 hash after compression and encryption.
 //
-// The database does not support migrations. If the schema changes, delete
+// Schema is managed via numbered SQL migrations embedded in the schema/
-// the local database and perform a full backup to recreate it.
+// directory. Migration 000.sql bootstraps the schema_migrations tracking
+// table; subsequent migrations (001, 002, …) are applied in order.
 package database
 
 import (
 	"context"
 	"database/sql"
-	_ "embed"
+	"embed"
 	"fmt"
 	"os"
+	"path/filepath"
+	"sort"
+	"strconv"
 	"strings"
 
 	"git.eeqj.de/sneak/vaultik/internal/log"
 	_ "modernc.org/sqlite"
 )
 
-//go:embed schema.sql
+//go:embed schema/*.sql
-var schemaSQL string
+var schemaFS embed.FS
+
+// bootstrapVersion is the migration that creates the schema_migrations
+// table itself. It is applied before the normal migration loop.
+const bootstrapVersion = 0
 
 // DB represents the Vaultik local index database connection.
 // It uses SQLite to track file metadata, content-defined chunks, and blob associations.
@@ -35,6 +43,46 @@ type DB struct {
 	path string
 }
 
+// ParseMigrationVersion extracts the numeric version prefix from a migration
+// filename. Filenames must follow the pattern "<version>.sql" or
+// "<version>_<description>.sql", where version is a zero-padded numeric
+// string (e.g. "001", "002"). Returns the version as an integer and an
+// error if the filename does not match the expected pattern.
+func ParseMigrationVersion(filename string) (int, error) {
+	name := strings.TrimSuffix(filename, filepath.Ext(filename))
+	if name == "" {
+		return 0, fmt.Errorf("invalid migration filename %q: empty name", filename)
+	}
+
+	// Split on underscore to separate version from description.
+	// If there's no underscore, the entire stem is the version.
+	versionStr := name
+	if idx := strings.IndexByte(name, '_'); idx >= 0 {
+		versionStr = name[:idx]
+	}
+
+	if versionStr == "" {
+		return 0, fmt.Errorf("invalid migration filename %q: empty version prefix", filename)
+	}
+
+	// Validate the version is purely numeric.
+	for _, ch := range versionStr {
+		if ch < '0' || ch > '9' {
+			return 0, fmt.Errorf(
+				"invalid migration filename %q: version %q contains non-numeric character %q",
+				filename, versionStr, string(ch),
+			)
+		}
+	}
+
+	version, err := strconv.Atoi(versionStr)
+	if err != nil {
+		return 0, fmt.Errorf("invalid migration filename %q: %w", filename, err)
+	}
+
+	return version, nil
+}
+
 // New creates a new database connection at the specified path.
 // It creates the schema if needed and configures SQLite with WAL mode for
 // better concurrency. SQLite handles crash recovery automatically when
@@ -72,9 +120,9 @@ func New(ctx context.Context, path string) (*DB, error) {
 			}
 
 			db := &DB{conn: conn, path: path}
-			if err := db.createSchema(ctx); err != nil {
+			if err := applyMigrations(ctx, conn); err != nil {
 				_ = conn.Close()
-				return nil, fmt.Errorf("creating schema: %w", err)
+				return nil, fmt.Errorf("applying migrations: %w", err)
 			}
 			return db, nil
 		}
@@ -125,9 +173,9 @@ func New(ctx context.Context, path string) (*DB, error) {
 	}
 
 	db := &DB{conn: conn, path: path}
-	if err := db.createSchema(ctx); err != nil {
+	if err := applyMigrations(ctx, conn); err != nil {
 		_ = conn.Close()
-		return nil, fmt.Errorf("creating schema: %w", err)
+		return nil, fmt.Errorf("applying migrations: %w", err)
 	}
 
 	log.Debug("Database connection established successfully", "path", path)
@@ -198,9 +246,120 @@ func (db *DB) QueryRowWithLog(
 	return db.conn.QueryRowContext(ctx, query, args...)
 }
 
-func (db *DB) createSchema(ctx context.Context) error {
+// collectMigrations reads the embedded schema directory and returns
-	_, err := db.conn.ExecContext(ctx, schemaSQL)
+// migration filenames sorted lexicographically.
+func collectMigrations() ([]string, error) {
+	entries, err := schemaFS.ReadDir("schema")
+	if err != nil {
+		return nil, fmt.Errorf("failed to read schema directory: %w", err)
+	}
+
+	var migrations []string
+
+	for _, entry := range entries {
+		if !entry.IsDir() && strings.HasSuffix(entry.Name(), ".sql") {
+			migrations = append(migrations, entry.Name())
+		}
+	}
+
+	sort.Strings(migrations)
+
+	return migrations, nil
+}
+
+// bootstrapMigrationsTable ensures the schema_migrations table exists
+// by applying 000.sql if the table is missing.
+func bootstrapMigrationsTable(ctx context.Context, db *sql.DB) error {
+	var tableExists int
+
+	err := db.QueryRowContext(ctx,
+		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='schema_migrations'",
+	).Scan(&tableExists)
+	if err != nil {
+		return fmt.Errorf("failed to check for migrations table: %w", err)
+	}
+
+	if tableExists > 0 {
+		return nil
+	}
+
+	content, err := schemaFS.ReadFile("schema/000.sql")
+	if err != nil {
+		return fmt.Errorf("failed to read bootstrap migration 000.sql: %w", err)
+	}
+
+	log.Info("applying bootstrap migration", "version", bootstrapVersion)
+
+	_, err = db.ExecContext(ctx, string(content))
+	if err != nil {
+		return fmt.Errorf("failed to apply bootstrap migration: %w", err)
+	}
+
+	return nil
+}
+
+// applyMigrations applies all pending migrations to db. It first bootstraps
+// the schema_migrations table via 000.sql, then iterates through remaining
+// migration files in order.
+func applyMigrations(ctx context.Context, db *sql.DB) error {
+	if err := bootstrapMigrationsTable(ctx, db); err != nil {
 		return err
+	}
+
+	migrations, err := collectMigrations()
+	if err != nil {
+		return err
+	}
+
+	for _, migration := range migrations {
+		version, parseErr := ParseMigrationVersion(migration)
+		if parseErr != nil {
+			return parseErr
+		}
+
+		// Check if already applied.
+		var count int
+
+		err := db.QueryRowContext(ctx,
+			"SELECT COUNT(*) FROM schema_migrations WHERE version = ?",
+			version,
+		).Scan(&count)
+		if err != nil {
+			return fmt.Errorf("failed to check migration status: %w", err)
+		}
+
+		if count > 0 {
+			log.Debug("migration already applied", "version", version)
+
+			continue
+		}
+
+		// Read and apply migration.
+		content, readErr := schemaFS.ReadFile(filepath.Join("schema", migration))
+		if readErr != nil {
+			return fmt.Errorf("failed to read migration %s: %w", migration, readErr)
+		}
+
+		log.Info("applying migration", "version", version)
+
+		_, execErr := db.ExecContext(ctx, string(content))
+		if execErr != nil {
+			return fmt.Errorf("failed to apply migration %s: %w", migration, execErr)
+		}
+
+		// Record migration as applied.
+		_, recErr := db.ExecContext(ctx,
+			"INSERT INTO schema_migrations (version) VALUES (?)",
+			version,
+		)
+		if recErr != nil {
+			return fmt.Errorf("failed to record migration %s: %w", migration, recErr)
+		}
+
+		log.Info("migration applied successfully", "version", version)
+	}
+
+	return nil
 }
 
 // NewTestDB creates an in-memory SQLite database for testing purposes.

internal/database/database_test.go

@@ -2,6 +2,7 @@ package database
 
 import (
 	"context"
+	"database/sql"
 	"fmt"
 	"path/filepath"
 	"testing"
@@ -26,9 +27,10 @@ func TestDatabase(t *testing.T) {
 		t.Fatal("database connection is nil")
 	}
 
-	// Test schema creation (already done in New)
+	// Test schema creation (already done in New via migrations)
 	// Verify tables exist
 	tables := []string{
+		"schema_migrations",
 		"files", "file_chunks", "chunks", "blobs",
 		"blob_chunks", "chunk_files", "snapshots",
 	}
@@ -99,3 +101,139 @@ func TestDatabaseConcurrentAccess(t *testing.T) {
 		t.Errorf("expected 10 chunks, got %d", count)
 	}
 }
+
+func TestParseMigrationVersion(t *testing.T) {
+	tests := []struct {
+		name      string
+		filename  string
+		wantVer   int
+		wantError bool
+	}{
+		{name: "valid 000.sql", filename: "000.sql", wantVer: 0, wantError: false},
+		{name: "valid 001.sql", filename: "001.sql", wantVer: 1, wantError: false},
+		{name: "valid 099.sql", filename: "099.sql", wantVer: 99, wantError: false},
+		{name: "valid with description", filename: "001_initial_schema.sql", wantVer: 1, wantError: false},
+		{name: "valid large version", filename: "123_big_migration.sql", wantVer: 123, wantError: false},
+		{name: "invalid alpha version", filename: "abc.sql", wantVer: 0, wantError: true},
+		{name: "invalid mixed chars", filename: "12a.sql", wantVer: 0, wantError: true},
+		{name: "invalid no extension", filename: "schema.sql", wantVer: 0, wantError: true},
+		{name: "empty string", filename: "", wantVer: 0, wantError: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got, err := ParseMigrationVersion(tc.filename)
+			if tc.wantError {
+				if err == nil {
+					t.Errorf("ParseMigrationVersion(%q) = %d, nil; want error", tc.filename, got)
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("ParseMigrationVersion(%q) unexpected error: %v", tc.filename, err)
+				return
+			}
+			if got != tc.wantVer {
+				t.Errorf("ParseMigrationVersion(%q) = %d; want %d", tc.filename, got, tc.wantVer)
+			}
+		})
+	}
+}
+
+func TestApplyMigrations_Idempotent(t *testing.T) {
+	ctx := context.Background()
+
+	conn, err := sql.Open("sqlite", ":memory:?_foreign_keys=ON")
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer func() {
+		if err := conn.Close(); err != nil {
+			t.Errorf("failed to close database: %v", err)
+		}
+	}()
+
+	conn.SetMaxOpenConns(1)
+	conn.SetMaxIdleConns(1)
+
+	// First run: apply all migrations.
+	if err := applyMigrations(ctx, conn); err != nil {
+		t.Fatalf("first applyMigrations failed: %v", err)
+	}
+
+	// Count rows in schema_migrations after first run.
+	var countBefore int
+	if err := conn.QueryRowContext(ctx, "SELECT COUNT(*) FROM schema_migrations").Scan(&countBefore); err != nil {
+		t.Fatalf("failed to count schema_migrations after first run: %v", err)
+	}
+
+	// Second run: must be a no-op.
+	if err := applyMigrations(ctx, conn); err != nil {
+		t.Fatalf("second applyMigrations failed: %v", err)
+	}
+
+	// Count rows in schema_migrations after second run — must be unchanged.
+	var countAfter int
+	if err := conn.QueryRowContext(ctx, "SELECT COUNT(*) FROM schema_migrations").Scan(&countAfter); err != nil {
+		t.Fatalf("failed to count schema_migrations after second run: %v", err)
+	}
+
+	if countBefore != countAfter {
+		t.Errorf("schema_migrations row count changed: before=%d, after=%d", countBefore, countAfter)
+	}
+}
+
+func TestBootstrapMigrationsTable_FreshDatabase(t *testing.T) {
+	ctx := context.Background()
+
+	conn, err := sql.Open("sqlite", ":memory:?_foreign_keys=ON")
+	if err != nil {
+		t.Fatalf("failed to open database: %v", err)
+	}
+	defer func() {
+		if err := conn.Close(); err != nil {
+			t.Errorf("failed to close database: %v", err)
+		}
+	}()
+
+	conn.SetMaxOpenConns(1)
+	conn.SetMaxIdleConns(1)
+
+	// Verify schema_migrations does NOT exist yet.
+	var tableBefore int
+	if err := conn.QueryRowContext(ctx,
+		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='schema_migrations'",
+	).Scan(&tableBefore); err != nil {
+		t.Fatalf("failed to check for table before bootstrap: %v", err)
+	}
+	if tableBefore != 0 {
+		t.Fatal("schema_migrations table should not exist before bootstrap")
+	}
+
+	// Run bootstrap.
+	if err := bootstrapMigrationsTable(ctx, conn); err != nil {
+		t.Fatalf("bootstrapMigrationsTable failed: %v", err)
+	}
+
+	// Verify schema_migrations now exists.
+	var tableAfter int
+	if err := conn.QueryRowContext(ctx,
+		"SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='schema_migrations'",
+	).Scan(&tableAfter); err != nil {
+		t.Fatalf("failed to check for table after bootstrap: %v", err)
+	}
+	if tableAfter != 1 {
+		t.Fatalf("schema_migrations table should exist after bootstrap, got count=%d", tableAfter)
+	}
+
+	// Verify version 0 row exists.
+	var version int
+	if err := conn.QueryRowContext(ctx,
+		"SELECT version FROM schema_migrations WHERE version = 0",
+	).Scan(&version); err != nil {
+		t.Fatalf("version 0 row not found in schema_migrations: %v", err)
+	}
+	if version != 0 {
+		t.Errorf("expected version 0, got %d", version)
+	}
+}

internal/database/schema/000.sql

@@ -0,0 +1,9 @@
+-- Migration 000: Schema migrations tracking table
+-- Applied as a bootstrap step before the normal migration loop.
+
+CREATE TABLE IF NOT EXISTS schema_migrations (
+    version INTEGER PRIMARY KEY,
+    applied_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+INSERT OR IGNORE INTO schema_migrations (version) VALUES (0);

internal/database/schema/001.sql

@@ -1,6 +1,5 @@
--- Vaultik Database Schema
+-- Migration 001: Initial Vaultik schema
--- Note: This database does not support migrations. If the schema changes,
+-- All core tables for tracking files, chunks, blobs, snapshots, and uploads.
--- delete the local database and perform a full backup to recreate it.
 
 -- Files table: stores metadata about files in the filesystem
 CREATE TABLE IF NOT EXISTS files (

internal/database/schema/008_uploads.sql

@@ -1,11 +0,0 @@
--- Track blob upload metrics
-CREATE TABLE IF NOT EXISTS uploads (
-    blob_hash TEXT PRIMARY KEY,
-    uploaded_at TIMESTAMP NOT NULL,
-    size INTEGER NOT NULL,
-    duration_ms INTEGER NOT NULL,
-    FOREIGN KEY (blob_hash) REFERENCES blobs(blob_hash)
-);
-
-CREATE INDEX idx_uploads_uploaded_at ON uploads(uploaded_at);
-CREATE INDEX idx_uploads_duration ON uploads(duration_ms);

internal/vaultik/daemon.go

@@ -1,434 +0,0 @@
-package vaultik
-
-import (
-	"context"
-	"fmt"
-	"os"
-	"os/signal"
-	"path/filepath"
-	"strings"
-	"sync"
-	"syscall"
-	"time"
-
-	"git.eeqj.de/sneak/vaultik/internal/log"
-	"github.com/fsnotify/fsnotify"
-)
-
-// daemonMinBackupInterval is the absolute minimum time allowed between backup runs,
-// regardless of config, to prevent runaway backup loops.
-const daemonMinBackupInterval = 1 * time.Minute
-
-// daemonShutdownTimeout is the maximum time to wait for an in-progress backup
-// to complete during graceful shutdown before force-exiting.
-const daemonShutdownTimeout = 5 * time.Minute
-
-// RunDaemon runs vaultik in daemon mode: it watches configured directories for
-// changes using filesystem notifications, runs periodic backups at the configured
-// interval, and performs full scans at the full_scan_interval. It handles
-// SIGTERM/SIGINT for graceful shutdown, completing any in-progress backup before
-// exiting.
-func (v *Vaultik) RunDaemon(opts *SnapshotCreateOptions) error {
-	backupInterval := v.Config.BackupInterval
-	if backupInterval < daemonMinBackupInterval {
-		backupInterval = daemonMinBackupInterval
-	}
-
-	minTimeBetween := v.Config.MinTimeBetweenRun
-	if minTimeBetween < daemonMinBackupInterval {
-		minTimeBetween = daemonMinBackupInterval
-	}
-
-	fullScanInterval := v.Config.FullScanInterval
-	if fullScanInterval <= 0 {
-		fullScanInterval = 24 * time.Hour
-	}
-
-	log.Info("Starting daemon mode",
-		"backup_interval", backupInterval,
-		"min_time_between_run", minTimeBetween,
-		"full_scan_interval", fullScanInterval,
-	)
-	v.printfStdout("Daemon mode started\n")
-	v.printfStdout("  Backup interval:     %s\n", backupInterval)
-	v.printfStdout("  Min time between:    %s\n", minTimeBetween)
-	v.printfStdout("  Full scan interval:  %s\n", fullScanInterval)
-
-	// Create a daemon-scoped context that we cancel on signal.
-	ctx, cancel := context.WithCancel(v.ctx)
-	defer cancel()
-
-	// Set up signal handling for graceful shutdown.
-	sigCh := make(chan os.Signal, 1)
-	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)
-
-	// Tracker for filesystem change events.
-	tracker := newChangeTracker()
-
-	// Start the filesystem watcher.
-	watcher, err := v.startWatcher(ctx, tracker)
-	if err != nil {
-		return fmt.Errorf("starting filesystem watcher: %w", err)
-	}
-	defer func() { _ = watcher.Close() }()
-
-	// Timers
-	backupTicker := time.NewTicker(backupInterval)
-	defer backupTicker.Stop()
-
-	fullScanTicker := time.NewTicker(fullScanInterval)
-	defer fullScanTicker.Stop()
-
-	var lastBackupTime time.Time
-	backupRunning := make(chan struct{}, 1) // semaphore: 1 = backup in progress
-
-	// Run an initial full backup immediately on startup.
-	log.Info("Running initial backup on daemon startup")
-	v.printfStdout("Running initial backup...\n")
-	if err := v.runDaemonBackup(ctx, opts, tracker, false); err != nil {
-		if ctx.Err() != nil {
-			return nil // context cancelled, shutting down
-		}
-		log.Error("Initial backup failed", "error", err)
-		v.printfStderr("Initial backup failed: %v\n", err)
-		// Continue running — next scheduled backup may succeed.
-	} else {
-		lastBackupTime = time.Now()
-		tracker.reset()
-	}
-
-	v.printfStdout("Watching for changes...\n")
-
-	for {
-		select {
-		case <-ctx.Done():
-			log.Info("Daemon context cancelled, shutting down")
-			return nil
-
-		case sig := <-sigCh:
-			log.Info("Received signal, initiating graceful shutdown", "signal", sig)
-			v.printfStdout("\nReceived %s, shutting down...\n", sig)
-			cancel()
-
-			// Wait for any in-progress backup to finish.
-			select {
-			case backupRunning <- struct{}{}:
-				// No backup running, we can exit immediately.
-				<-backupRunning
-			default:
-				// Backup is running, wait for it to complete.
-				v.printfStdout("Waiting for in-progress backup to complete...\n")
-				shutdownTimer := time.NewTimer(daemonShutdownTimeout)
-				select {
-				case backupRunning <- struct{}{}:
-					<-backupRunning
-					shutdownTimer.Stop()
-				case <-shutdownTimer.C:
-					log.Warn("Shutdown timeout exceeded, forcing exit")
-					v.printfStderr("Shutdown timeout exceeded, forcing exit\n")
-				}
-			}
-			return nil
-
-		case <-backupTicker.C:
-			// Periodic backup tick. Only run if there are changes and enough
-			// time has elapsed since the last run.
-			if !tracker.hasChanges() {
-				log.Debug("Backup tick: no changes detected, skipping")
-				continue
-			}
-			if time.Since(lastBackupTime) < minTimeBetween {
-				log.Debug("Backup tick: too soon since last backup",
-					"last_backup", lastBackupTime,
-					"min_interval", minTimeBetween,
-				)
-				continue
-			}
-
-			// Try to acquire the backup semaphore (non-blocking).
-			select {
-			case backupRunning <- struct{}{}:
-			default:
-				log.Debug("Backup tick: backup already in progress, skipping")
-				continue
-			}
-
-			log.Info("Running scheduled backup", "changes", tracker.changeCount())
-			v.printfStdout("Running scheduled backup (%d changes detected)...\n", tracker.changeCount())
-			if err := v.runDaemonBackup(ctx, opts, tracker, false); err != nil {
-				if ctx.Err() != nil {
-					<-backupRunning
-					return nil
-				}
-				log.Error("Scheduled backup failed", "error", err)
-				v.printfStderr("Scheduled backup failed: %v\n", err)
-			} else {
-				lastBackupTime = time.Now()
-				tracker.reset()
-			}
-			<-backupRunning
-
-		case <-fullScanTicker.C:
-			// Full scan — ignore whether changes were detected; do a complete scan.
-			if time.Since(lastBackupTime) < minTimeBetween {
-				log.Debug("Full scan tick: too soon since last backup, deferring")
-				continue
-			}
-
-			select {
-			case backupRunning <- struct{}{}:
-			default:
-				log.Debug("Full scan tick: backup already in progress, skipping")
-				continue
-			}
-
-			log.Info("Running full periodic scan")
-			v.printfStdout("Running full periodic scan...\n")
-			if err := v.runDaemonBackup(ctx, opts, tracker, true); err != nil {
-				if ctx.Err() != nil {
-					<-backupRunning
-					return nil
-				}
-				log.Error("Full scan backup failed", "error", err)
-				v.printfStderr("Full scan backup failed: %v\n", err)
-			} else {
-				lastBackupTime = time.Now()
-				tracker.reset()
-			}
-			<-backupRunning
-		}
-	}
-}
-
-// runDaemonBackup executes a single backup run within the daemon loop.
-// If fullScan is true, all snapshots are processed regardless of tracked changes.
-// Otherwise, only snapshots whose paths overlap with tracked changes are processed.
-func (v *Vaultik) runDaemonBackup(ctx context.Context, opts *SnapshotCreateOptions, tracker *changeTracker, fullScan bool) error {
-	startTime := time.Now()
-
-	// Build a one-shot create options for this run.
-	runOpts := &SnapshotCreateOptions{
-		Cron:       opts.Cron,
-		Prune:      opts.Prune,
-		SkipErrors: opts.SkipErrors,
-	}
-
-	if !fullScan {
-		// Filter to only snapshots whose paths had changes.
-		changedPaths := tracker.changedPaths()
-		affected := v.snapshotsAffectedByChanges(changedPaths)
-		if len(affected) == 0 {
-			log.Debug("No snapshots affected by changes")
-			return nil
-		}
-		runOpts.Snapshots = affected
-		log.Info("Running incremental backup for affected snapshots", "snapshots", affected)
-	}
-	// fullScan: leave runOpts.Snapshots empty → CreateSnapshot processes all.
-
-	// Use a child context so cancellation propagates but we can still finish
-	// if the parent hasn't been cancelled.
-	childCtx, childCancel := context.WithCancel(ctx)
-	defer childCancel()
-
-	// Temporarily swap the Vaultik context.
-	origCtx := v.ctx
-	v.ctx = childCtx
-	defer func() { v.ctx = origCtx }()
-
-	if err := v.CreateSnapshot(runOpts); err != nil {
-		return fmt.Errorf("backup run failed: %w", err)
-	}
-
-	log.Info("Daemon backup complete", "duration", time.Since(startTime))
-	v.printfStdout("Backup complete in %s\n", formatDuration(time.Since(startTime)))
-	return nil
-}
-
-// snapshotsAffectedByChanges returns the names of configured snapshots whose
-// paths overlap with any of the changed paths.
-func (v *Vaultik) snapshotsAffectedByChanges(changedPaths []string) []string {
-	var affected []string
-	for _, snapName := range v.Config.SnapshotNames() {
-		snapCfg := v.Config.Snapshots[snapName]
-		for _, snapPath := range snapCfg.Paths {
-			absSnapPath, err := filepath.Abs(snapPath)
-			if err != nil {
-				absSnapPath = snapPath
-			}
-			for _, changed := range changedPaths {
-				if isSubpath(changed, absSnapPath) {
-					affected = append(affected, snapName)
-					goto nextSnapshot
-				}
-			}
-		}
-	nextSnapshot:
-	}
-	return affected
-}
-
-// isSubpath returns true if child is under parent (or equal to it).
-func isSubpath(child, parent string) bool {
-	// Normalize both paths.
-	child = filepath.Clean(child)
-	parent = filepath.Clean(parent)
-	if child == parent {
-		return true
-	}
-	// Ensure parent ends with a separator for prefix matching,
-	// unless parent is the root directory (which already ends with /).
-	prefix := parent
-	if !strings.HasSuffix(prefix, string(filepath.Separator)) {
-		prefix += string(filepath.Separator)
-	}
-	return strings.HasPrefix(child, prefix)
-}
-
-// startWatcher creates an fsnotify watcher and adds all configured snapshot paths.
-// It spawns a goroutine that reads events and feeds the change tracker.
-func (v *Vaultik) startWatcher(ctx context.Context, tracker *changeTracker) (*fsnotify.Watcher, error) {
-	watcher, err := fsnotify.NewWatcher()
-	if err != nil {
-		return nil, fmt.Errorf("creating watcher: %w", err)
-	}
-
-	// Collect unique absolute paths to watch.
-	watchPaths := make(map[string]struct{})
-	for _, snapName := range v.Config.SnapshotNames() {
-		snapCfg := v.Config.Snapshots[snapName]
-		for _, p := range snapCfg.Paths {
-			absPath, err := filepath.Abs(p)
-			if err != nil {
-				log.Warn("Failed to resolve absolute path for watch", "path", p, "error", err)
-				continue
-			}
-			watchPaths[absPath] = struct{}{}
-		}
-	}
-
-	// Add paths to watcher. Walk the top-level to add subdirectories
-	// since fsnotify doesn't recurse automatically.
-	for p := range watchPaths {
-		if err := v.addWatchRecursive(watcher, p); err != nil {
-			log.Warn("Failed to watch path", "path", p, "error", err)
-			// Non-fatal: the path might not exist yet.
-		}
-	}
-
-	// Spawn the event reader goroutine.
-	go v.watcherLoop(ctx, watcher, tracker)
-
-	return watcher, nil
-}
-
-// addWatchRecursive walks a directory tree and adds each directory to the watcher.
-func (v *Vaultik) addWatchRecursive(watcher *fsnotify.Watcher, root string) error {
-	return filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			// Can't read — skip this subtree.
-			if info != nil && info.IsDir() {
-				return filepath.SkipDir
-			}
-			return nil
-		}
-		if info.IsDir() {
-			// Skip common directories that don't need watching.
-			base := filepath.Base(path)
-			if base == ".git" || base == "node_modules" || base == "__pycache__" {
-				return filepath.SkipDir
-			}
-			if err := watcher.Add(path); err != nil {
-				log.Debug("Failed to watch directory", "path", path, "error", err)
-				// Non-fatal: continue walking.
-			}
-		}
-		return nil
-	})
-}
-
-// watcherLoop reads filesystem events from the watcher and records them
-// in the change tracker. It runs until the context is cancelled.
-func (v *Vaultik) watcherLoop(ctx context.Context, watcher *fsnotify.Watcher, tracker *changeTracker) {
-	for {
-		select {
-		case <-ctx.Done():
-			return
-		case event, ok := <-watcher.Events:
-			if !ok {
-				return
-			}
-			// Only track write/create/remove/rename events.
-			if event.Op&(fsnotify.Write|fsnotify.Create|fsnotify.Remove|fsnotify.Rename) != 0 {
-				tracker.recordChange(event.Name)
-				log.Debug("Filesystem change detected", "path", event.Name, "op", event.Op)
-			}
-			// If a new directory was created, watch it too.
-			if event.Op&fsnotify.Create != 0 {
-				if info, err := os.Stat(event.Name); err == nil && info.IsDir() {
-					if err := v.addWatchRecursive(watcher, event.Name); err != nil {
-						log.Debug("Failed to watch new directory", "path", event.Name, "error", err)
-					}
-				}
-			}
-		case err, ok := <-watcher.Errors:
-			if !ok {
-				return
-			}
-			log.Warn("Filesystem watcher error", "error", err)
-		}
-	}
-}
-
-// changeTracker records filesystem paths that have been modified since the
-// last backup. It is safe for concurrent use.
-type changeTracker struct {
-	mu      sync.Mutex
-	changes map[string]time.Time // path → last change time
-}
-
-// newChangeTracker creates a new empty change tracker.
-func newChangeTracker() *changeTracker {
-	return &changeTracker{
-		changes: make(map[string]time.Time),
-	}
-}
-
-// recordChange records that a path has been modified.
-func (ct *changeTracker) recordChange(path string) {
-	ct.mu.Lock()
-	ct.changes[path] = time.Now()
-	ct.mu.Unlock()
-}
-
-// hasChanges returns true if any changes have been recorded.
-func (ct *changeTracker) hasChanges() bool {
-	ct.mu.Lock()
-	defer ct.mu.Unlock()
-	return len(ct.changes) > 0
-}
-
-// changeCount returns the number of unique changed paths.
-func (ct *changeTracker) changeCount() int {
-	ct.mu.Lock()
-	defer ct.mu.Unlock()
-	return len(ct.changes)
-}
-
-// changedPaths returns all changed paths.
-func (ct *changeTracker) changedPaths() []string {
-	ct.mu.Lock()
-	defer ct.mu.Unlock()
-	paths := make([]string, 0, len(ct.changes))
-	for p := range ct.changes {
-		paths = append(paths, p)
-	}
-	return paths
-}
-
-// reset clears all recorded changes.
-func (ct *changeTracker) reset() {
-	ct.mu.Lock()
-	ct.changes = make(map[string]time.Time)
-	ct.mu.Unlock()
-}

internal/vaultik/daemon_test.go

@@ -1,196 +0,0 @@
-package vaultik
-
-import (
-	"bytes"
-	"context"
-	"os"
-	"path/filepath"
-	"testing"
-	"time"
-
-	"git.eeqj.de/sneak/vaultik/internal/config"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestNewChangeTracker(t *testing.T) {
-	ct := newChangeTracker()
-	require.NotNil(t, ct)
-	assert.False(t, ct.hasChanges())
-	assert.Equal(t, 0, ct.changeCount())
-	assert.Empty(t, ct.changedPaths())
-}
-
-func TestChangeTrackerRecordChange(t *testing.T) {
-	ct := newChangeTracker()
-
-	ct.recordChange("/home/user/file1.txt")
-	assert.True(t, ct.hasChanges())
-	assert.Equal(t, 1, ct.changeCount())
-
-	ct.recordChange("/home/user/file2.txt")
-	assert.Equal(t, 2, ct.changeCount())
-
-	// Duplicate path should update time but not increase count.
-	ct.recordChange("/home/user/file1.txt")
-	assert.Equal(t, 2, ct.changeCount())
-
-	paths := ct.changedPaths()
-	assert.Len(t, paths, 2)
-	assert.Contains(t, paths, "/home/user/file1.txt")
-	assert.Contains(t, paths, "/home/user/file2.txt")
-}
-
-func TestChangeTrackerReset(t *testing.T) {
-	ct := newChangeTracker()
-
-	ct.recordChange("/home/user/file1.txt")
-	ct.recordChange("/home/user/file2.txt")
-	assert.Equal(t, 2, ct.changeCount())
-
-	ct.reset()
-	assert.False(t, ct.hasChanges())
-	assert.Equal(t, 0, ct.changeCount())
-	assert.Empty(t, ct.changedPaths())
-}
-
-func TestChangeTrackerConcurrency(t *testing.T) {
-	ct := newChangeTracker()
-	done := make(chan struct{})
-
-	// Write from multiple goroutines simultaneously.
-	for i := 0; i < 10; i++ {
-		go func(n int) {
-			for j := 0; j < 100; j++ {
-				ct.recordChange("/path/" + string(rune('a'+n)))
-			}
-			done <- struct{}{}
-		}(i)
-	}
-
-	// Also read concurrently.
-	go func() {
-		for i := 0; i < 100; i++ {
-			_ = ct.hasChanges()
-			_ = ct.changeCount()
-			_ = ct.changedPaths()
-		}
-		done <- struct{}{}
-	}()
-
-	// Wait for all goroutines.
-	for i := 0; i < 11; i++ {
-		<-done
-	}
-
-	assert.True(t, ct.hasChanges())
-	assert.LessOrEqual(t, ct.changeCount(), 10) // 10 unique paths
-}
-
-func TestChangeTrackerRecordTimestamp(t *testing.T) {
-	ct := newChangeTracker()
-
-	before := time.Now()
-	ct.recordChange("/some/path")
-	after := time.Now()
-
-	ct.mu.Lock()
-	ts := ct.changes["/some/path"]
-	ct.mu.Unlock()
-
-	assert.False(t, ts.Before(before))
-	assert.False(t, ts.After(after))
-}
-
-func TestIsSubpath(t *testing.T) {
-	tests := []struct {
-		child    string
-		parent   string
-		expected bool
-	}{
-		{"/home/user/file.txt", "/home/user", true},
-		{"/home/user", "/home/user", true},
-		{"/home/user/deep/nested/file.txt", "/home/user", true},
-		{"/home/other/file.txt", "/home/user", false},
-		{"/home/username/file.txt", "/home/user", false}, // not a subpath, just prefix match
-		{"/etc/config", "/home/user", false},
-		{"/", "/", true},
-		{"/a", "/", true},
-		{"/a/b", "/a", true},
-		{"/ab", "/a", false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.child+"_under_"+tt.parent, func(t *testing.T) {
-			result := isSubpath(tt.child, tt.parent)
-			assert.Equal(t, tt.expected, result)
-		})
-	}
-}
-
-func TestSnapshotsAffectedByChanges(t *testing.T) {
-	// We can't easily test this without a full Vaultik instance with config,
-	// but we can verify the helper function isSubpath which it depends on.
-	// The full integration is tested via the daemon integration test.
-
-	// Verify basic subpath logic used by snapshotsAffectedByChanges.
-	assert.True(t, isSubpath("/home/user/docs/report.txt", "/home/user"))
-	assert.False(t, isSubpath("/var/log/syslog", "/home/user"))
-}
-
-func TestDaemonConstants(t *testing.T) {
-	// Verify daemon constants are reasonable values.
-	assert.GreaterOrEqual(t, daemonMinBackupInterval, 1*time.Minute)
-	assert.GreaterOrEqual(t, daemonShutdownTimeout, 1*time.Minute)
-}
-
-func TestRunDaemon_CancelledContext(t *testing.T) {
-	// Create a temporary directory to use as a snapshot path.
-	tmpDir := t.TempDir()
-
-	// Write a file so the watched path is non-empty.
-	err := os.WriteFile(filepath.Join(tmpDir, "testfile.txt"), []byte("hello"), 0o644)
-	require.NoError(t, err)
-
-	// Build a minimal Vaultik with daemon-friendly config.
-	// RunDaemon will fail on the initial backup (no storage configured),
-	// but it should continue running. We cancel the context to verify
-	// graceful shutdown.
-	ctx, cancel := context.WithCancel(context.Background())
-	stdout := &bytes.Buffer{}
-	stderr := &bytes.Buffer{}
-
-	v := &Vaultik{
-		Config: &config.Config{
-			BackupInterval:    1 * time.Hour,
-			FullScanInterval:  24 * time.Hour,
-			MinTimeBetweenRun: 1 * time.Minute,
-			Snapshots: map[string]config.SnapshotConfig{
-				"test": {
-					Paths: []string{tmpDir},
-				},
-			},
-		},
-		ctx:    ctx,
-		cancel: cancel,
-		Stdout: stdout,
-		Stderr: stderr,
-	}
-
-	// Cancel the context shortly after RunDaemon starts so the daemon
-	// loop exits via its ctx.Done() path.
-	go func() {
-		// Wait for the initial backup to fail (it will, since there's no
-		// storage backend), then cancel.
-		time.Sleep(200 * time.Millisecond)
-		cancel()
-	}()
-
-	err = v.RunDaemon(&SnapshotCreateOptions{})
-	// RunDaemon should return nil on context cancellation (graceful shutdown).
-	assert.NoError(t, err)
-
-	// Verify daemon printed startup messages.
-	output := stdout.String()
-	assert.Contains(t, output, "Daemon mode started")
-}

internal/vaultik/snapshot.go

@@ -58,7 +58,9 @@ func (v *Vaultik) CreateSnapshot(opts *SnapshotCreateOptions) error {
 	}
 
 	if opts.Daemon {
-		return v.RunDaemon(opts)
+		log.Info("Running in daemon mode")
+		// TODO: Implement daemon mode with inotify
+		return fmt.Errorf("daemon mode not yet implemented")
 	}
 
 	// Determine which snapshots to process