Merge pull request #4 from sqlrsync/matt

Key mgmt refactor, pull implementation, -sqlrsync improvements

Author: pnwmatt

.gitignore

@@ -10,4 +10,9 @@
 **/.claude/
 
 CLAUDE.md
-**/CLAUDE.md
+**/CLAUDE.md
+
+tmp/
+client/sqlrsync
+client/sqlrsync
+client/sqlrsync_simple

bridge/cgo_bridge.go

@@ -174,7 +174,9 @@ func go_local_read_callback(userData unsafe.Pointer, buffer *C.uint8_t, size C.i
 		if err.Error() != "connection lost" && err.Error() != "sync completed" {
 			client.Logger.Error("Connection to server had a failure.  Are you online?  Read callback error", zap.Error(err))
 		}
-		return -1
+		// For sync completion errors, return 0 to signal EOF gracefully
+		// This allows sqlite_rsync to finish processing any buffered data
+		return 0
 	}
 
 	client.Logger.Debug("Read callback", zap.Int("bytesRead", bytesRead))

bridge/sqlite_rsync_wrapper.c

@@ -277,12 +277,13 @@ static void *websocket_read_thread(void *arg)
     }
     else if (bytes_read == 0)
     {
-      // No more data, close write end to signal EOF
+      // 0 bytes indicates EOF from the Go callback (sync completed)
+      // Close write end to signal EOF to sqlite_rsync
       break;
     }
     else
     {
-      // Error occurred
+      // Negative value indicates a real error
       break;
     }
   }

client/auth/config.go

@@ -0,0 +1,336 @@
+package auth
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/BurntSushi/toml"
+)
+
+// DefaultsConfig represents ~/.config/sqlrsync/defaults.toml
+type DefaultsConfig struct {
+	Defaults struct {
+		Server string `toml:"server"`
+	} `toml:"defaults"`
+}
+
+// LocalSecretsConfig represents ~/.config/sqlrsync/local-secrets.toml
+type LocalSecretsConfig struct {
+	SQLRsyncDatabases []SQLRsyncDatabase `toml:"sqlrsync-databases"`
+}
+
+// SQLRsyncDatabase represents a configured database with auth info
+type SQLRsyncDatabase struct {
+	LocalPath                     string    `toml:"path,omitempty"`
+	Server                        string    `toml:"server"`
+	CustomerSuppliedEncryptionKey string    `toml:"customerSuppliedEncryptionKey,omitempty"`
+	ReplicaID                     string    `toml:"replicaID"`
+	RemotePath                    string    `toml:"remotePath,omitempty"`
+	PushKey                       string    `toml:"pushKey,omitempty"`
+	LastPush                      time.Time `toml:"lastPush,omitempty"`
+}
+
+// DashSQLRsync manages the -sqlrsync file for a database
+type DashSQLRsync struct {
+	DatabasePath string
+	RemotePath   string
+	PullKey      string
+	Server       string
+	ReplicaID    string
+}
+
+// GetConfigDir returns the sqlrsync config directory path
+func GetConfigDir() (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", fmt.Errorf("failed to get user home directory: %w", err)
+	}
+	return filepath.Join(homeDir, ".config", "sqlrsync"), nil
+}
+
+// GetDefaultsPath returns the path to defaults.toml
+func GetDefaultsPath() (string, error) {
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(configDir, "defaults.toml"), nil
+}
+
+// GetLocalSecretsPath returns the path to local-secrets.toml
+func GetLocalSecretsPath() (string, error) {
+	configDir, err := GetConfigDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(configDir, "local-secrets.toml"), nil
+}
+
+// LoadDefaultsConfig loads the defaults configuration
+func LoadDefaultsConfig() (*DefaultsConfig, error) {
+	path, err := GetDefaultsPath()
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			// Return default config if file doesn't exist
+			config := &DefaultsConfig{}
+			config.Defaults.Server = "wss://sqlrsync.com"
+			return config, nil
+		}
+		return nil, fmt.Errorf("failed to read defaults config file %s: %w", path, err)
+	}
+
+	var config DefaultsConfig
+	if _, err := toml.Decode(string(data), &config); err != nil {
+		return nil, fmt.Errorf("failed to parse TOML defaults config: %w", err)
+	}
+
+	// Set default server if not specified
+	if config.Defaults.Server == "" {
+		config.Defaults.Server = "wss://sqlrsync.com"
+	}
+
+	return &config, nil
+}
+
+// SaveDefaultsConfig saves the defaults configuration
+func SaveDefaultsConfig(config *DefaultsConfig) error {
+	path, err := GetDefaultsPath()
+	if err != nil {
+		return err
+	}
+
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", dir, err)
+	}
+
+	file, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to create defaults config file %s: %w", path, err)
+	}
+	defer file.Close()
+
+	encoder := toml.NewEncoder(file)
+	if err := encoder.Encode(config); err != nil {
+		return fmt.Errorf("failed to write defaults config: %w", err)
+	}
+
+	return nil
+}
+
+// LoadLocalSecretsConfig loads the local secrets configuration
+func LoadLocalSecretsConfig() (*LocalSecretsConfig, error) {
+	path, err := GetLocalSecretsPath()
+	if err != nil {
+		return nil, err
+	}
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			// Return empty config if file doesn't exist
+			return &LocalSecretsConfig{
+				SQLRsyncDatabases: []SQLRsyncDatabase{},
+			}, nil
+		}
+		return nil, fmt.Errorf("failed to read local-secrets config file %s: %w", path, err)
+	}
+
+	var config LocalSecretsConfig
+	if _, err := toml.Decode(string(data), &config); err != nil {
+		return nil, fmt.Errorf("failed to parse TOML local-secrets config: %w", err)
+	}
+
+	return &config, nil
+}
+
+// SaveLocalSecretsConfig saves the local secrets configuration
+func SaveLocalSecretsConfig(config *LocalSecretsConfig) error {
+	path, err := GetLocalSecretsPath()
+	if err != nil {
+		return err
+	}
+
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return fmt.Errorf("failed to create directory %s: %w", dir, err)
+	}
+
+	file, err := os.Create(path)
+	if err != nil {
+		return fmt.Errorf("failed to create local-secrets config file %s: %w", path, err)
+	}
+	defer file.Close()
+
+	// Set file permissions to 0600 (read/write for owner only)
+	if err := file.Chmod(0600); err != nil {
+		return fmt.Errorf("failed to set permissions on local-secrets config file: %w", err)
+	}
+
+	encoder := toml.NewEncoder(file)
+	if err := encoder.Encode(config); err != nil {
+		return fmt.Errorf("failed to write local-secrets config: %w", err)
+	}
+
+	return nil
+}
+
+// FindDatabaseByPath finds a database configuration by local path
+func (c *LocalSecretsConfig) FindDatabaseByPath(path string) *SQLRsyncDatabase {
+	// Normalize the search path to absolute path
+	searchPath, err := filepath.Abs(path)
+	if err != nil {
+		// If we can't get absolute path, fall back to original comparison
+		for i := range c.SQLRsyncDatabases {
+			if c.SQLRsyncDatabases[i].LocalPath == path {
+				return &c.SQLRsyncDatabases[i]
+			}
+		}
+		return nil
+	}
+
+	for i := range c.SQLRsyncDatabases {
+		// Normalize the stored path to absolute path for comparison
+		storedPath, err := filepath.Abs(c.SQLRsyncDatabases[i].LocalPath)
+		if err != nil {
+			// If we can't normalize stored path, compare as-is
+			if c.SQLRsyncDatabases[i].LocalPath == path || c.SQLRsyncDatabases[i].LocalPath == searchPath {
+				return &c.SQLRsyncDatabases[i]
+			}
+		} else {
+			// Compare normalized absolute paths
+			if storedPath == searchPath {
+				return &c.SQLRsyncDatabases[i]
+			}
+		}
+	}
+	return nil
+}
+
+// UpdateOrAddDatabase updates an existing database or adds a new one
+func (c *LocalSecretsConfig) UpdateOrAddDatabase(db SQLRsyncDatabase) {
+	for i := range c.SQLRsyncDatabases {
+		if c.SQLRsyncDatabases[i].LocalPath == db.LocalPath {
+			// Update existing database
+			c.SQLRsyncDatabases[i] = db
+			return
+		}
+	}
+	// Add new database
+	c.SQLRsyncDatabases = append(c.SQLRsyncDatabases, db)
+}
+
+// RemoveDatabase removes a database configuration by local path
+func (c *LocalSecretsConfig) RemoveDatabase(path string) {
+	for i, db := range c.SQLRsyncDatabases {
+		if db.LocalPath == path {
+			// Remove database from slice
+			c.SQLRsyncDatabases = append(c.SQLRsyncDatabases[:i], c.SQLRsyncDatabases[i+1:]...)
+			return
+		}
+	}
+}
+
+// NewDashSQLRsync creates a new DashSQLRsync instance for the given database path
+func NewDashSQLRsync(databasePath string) *DashSQLRsync {
+	if strings.Contains(databasePath, "@") {
+		databasePath = strings.Split(databasePath, "@")[0]
+	}
+
+	return &DashSQLRsync{
+		DatabasePath: databasePath,
+	}
+}
+
+// FilePath returns the path to the -sqlrsync file
+func (d *DashSQLRsync) FilePath() string {
+	return d.DatabasePath + "-sqlrsync"
+}
+
+// Exists checks if the -sqlrsync file exists
+func (d *DashSQLRsync) Exists() bool {
+	_, err := os.Stat(d.FilePath())
+	return err == nil
+}
+
+// Read reads the -sqlrsync file and populates the struct fields
+func (d *DashSQLRsync) Read() error {
+	if !d.Exists() {
+		return fmt.Errorf("file does not exist: %s", d.FilePath())
+	}
+
+	file, err := os.Open(d.FilePath())
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+
+		if strings.HasPrefix(line, "#") || line == "" {
+			continue
+		}
+
+		if strings.HasPrefix(line, "sqlrsync ") {
+			parts := strings.Fields(line)
+			if len(parts) >= 2 {
+				d.RemotePath = parts[1]
+			}
+
+			for _, part := range parts {
+				if strings.HasPrefix(part, "--pullKey=") {
+					d.PullKey = strings.TrimPrefix(part, "--pullKey=")
+				}
+				if strings.HasPrefix(part, "--replicaID=") {
+					d.ReplicaID = strings.TrimPrefix(part, "--replicaID=")
+				}
+				if strings.HasPrefix(part, "--server=") {
+					d.Server = strings.TrimPrefix(part, "--server=")
+				}
+			}
+			break
+		}
+	}
+
+	return scanner.Err()
+}
+
+// Write writes the -sqlrsync file with the given remote path and pull key
+func (d *DashSQLRsync) Write(remotePath string, localName string, replicaID string, pullKey string, serverURL string) error {
+	d.RemotePath = remotePath
+	d.PullKey = pullKey
+
+	localNameTree := strings.Split(localName, "/")
+	localName = localNameTree[len(localNameTree)-1]
+
+	content := fmt.Sprintf(`#!/bin/bash
+# https://sqlrsync.com/help/dash-sqlrsync
+sqlrsync %s %s --replicaID=%s --pullKey=%s --server=%s "$@"
+
+`, remotePath, localName, replicaID, pullKey, serverURL)
+
+	if err := os.WriteFile(d.FilePath(), []byte(content), 0755); err != nil {
+		return fmt.Errorf("failed to write -sqlrsync file: %w", err)
+	}
+
+	return nil
+}
+
+// Remove removes the -sqlrsync file if it exists
+func (d *DashSQLRsync) Remove() error {
+	if !d.Exists() {
+		return nil
+	}
+	return os.Remove(d.FilePath())
+}