dry run and visibility

Author: pnwmatt

bridge/client.go

@@ -73,14 +73,15 @@ func (c *Client) GetDatabaseInfo() (*DatabaseInfo, error) {
 func (c *Client) RunPushSync(readFunc ReadFunc, writeFunc WriteFunc) error {
 	c.Logger.Info("Starting origin sync", zap.String("database", c.Config.DatabasePath))
 
+	if c.Config.DryRun {
+		fmt.Println("Running in dry-run mode")
+		return nil
+	}
+
 	// Store I/O functions for callbacks
 	c.ReadFunc = readFunc
 	c.WriteFunc = writeFunc
 
-	if c.Config.DryRun {
-		c.Logger.Info("Running in dry-run mode")
-	}
-
 	c.Logger.Debug("Calling C sqlite_rsync_run_origin")
 
 	// Run the origin synchronization via CGO bridge
@@ -102,7 +103,8 @@ func (c *Client) RunPullSync(readFunc ReadFunc, writeFunc WriteFunc) error {
 	c.WriteFunc = writeFunc
 
 	if c.Config.DryRun {
-		c.Logger.Info("Running in dry-run mode")
+		fmt.Println("Running in dry-run mode. We should not have gotten here.")
+		return nil
 	}
 
 	c.Logger.Debug("Calling C sqlite_rsync_run_replica")
@@ -120,12 +122,13 @@ func (c *Client) RunPullSync(readFunc ReadFunc, writeFunc WriteFunc) error {
 
 // RunDirectSync runs direct local synchronization between two SQLite files
 func (c *Client) RunDirectSync(replicaPath string) error {
-	c.Logger.Info("Starting direct local sync", 
+	c.Logger.Info("Starting direct local sync",
 		zap.String("origin", c.Config.DatabasePath),
 		zap.String("replica", replicaPath))
 
 	if c.Config.DryRun {
-		c.Logger.Info("Running in dry-run mode")
+		fmt.Println("Running in dry-run mode. We should not have gotten here.")
+		return nil
 	}
 
 	verboseLevel := 0

client/main.go

@@ -21,6 +21,7 @@ var (
 	verbose     bool
 	dryRun      bool
 	SetPublic   bool
+	SetUnlisted bool
 	subscribing bool
 	pullKey     string
 	pushKey     string
@@ -30,19 +31,30 @@ var (
 )
 
 var rootCmd = &cobra.Command{
-	Use:   "sqlrsync " + VERSION + " [ORIGIN] [REPLICA] or [LOCAL] or [REMOTE]",
-	Short: "SQLite Rsync - Simplified Version",
-	Long: `A web-enabled rsync-like utility for SQLite databases with subscription support.
+	Use:   "sqlrsync [ORIGIN] [REPLICA] or [LOCAL] or [REMOTE]",
+	Short: "SQLRsync v" + VERSION,
+	Long: `SQLRsync v` + VERSION + `
+A web-enabled rsync-like utility for SQLite databases with subscription support.
 
 Usage modes:
-1. Pull from server:       sqlrsync REMOTE [LOCAL] [OPTIONS]
-2. Pull with subscription: sqlrsync REMOTE [LOCAL] --subscribe [OPTIONS]
-3. Push to server:         sqlrsync LOCAL [REMOTE] [OPTIONS]
+1. Push to server:         sqlrsync LOCAL [REMOTE] [OPTIONS]
+2. Pull from server:       sqlrsync REMOTE [LOCAL] [OPTIONS]
+3. Pull with subscription: sqlrsync REMOTE [LOCAL] --subscribe [OPTIONS]
+4. Local to local sync:    sqlrsync LOCAL1 LOCAL2 [OPTIONS]
+
+Where:
+- REMOTE is a path like namespace/db.sqlite (remote server)
+- LOCAL is a local file path like ./db.sqlite or db.sqlite (local file)
+
+Limitations:
+- Pushing to the server requires page size of 4096 (default for SQLite).
+  Check by querying "PRAGMA page_size;".
 
 Examples:
-  sqlrsync namespace/db.sqlite                    # Pull to local db.sqlite
-  sqlrsync namespace/db.sqlite --subscribe       # Pull and watch for updates
-  sqlrsync mydb.sqlite namespace/db.sqlite       # Push local to remote
+  sqlrsync mydb.sqlite                        # Push local to remote
+  sqlrsync namespace/db.sqlite                # Pull to local db.sqlite
+  sqlrsync namespace/db.sqlite --subscribe    # Pull and watch for updates
+  sqlrsync mydb.sqlite mydb2.sqlite           # Local to local sync
 `,
 	Version: VERSION,
 	PreRun: func(cmd *cobra.Command, args []string) {
@@ -78,6 +90,15 @@ func runSync(cmd *cobra.Command, args []string) error {
 		}
 	}
 
+	visibility := 0
+	if SetPublic && SetUnlisted {
+		return fmt.Errorf("cannot set both public and unlisted visibility")
+	} else if SetPublic {
+		visibility = 2
+	} else if SetUnlisted {
+		visibility = 1
+	}
+
 	// Create sync coordinator
 	coordinator := sync.NewCoordinator(&sync.Config{
 		ServerURL:         serverURL,
@@ -90,7 +111,7 @@ func runSync(cmd *cobra.Command, args []string) error {
 		ReplicaPath:       remotePath, // For LOCAL TO LOCAL, remotePath is actually the replica path
 		Version:           version,    // Could be extended to parse @version syntax
 		Operation:         operation,
-		SetPublic:         SetPublic,
+		SetVisibility:     visibility,
 		DryRun:            dryRun,
 		Logger:            logger,
 		Verbose:           verbose,
@@ -203,7 +224,8 @@ func init() {
 	rootCmd.Flags().StringVarP(&serverURL, "server", "s", "wss://sqlrsync.com", "Server URL for operations")
 	rootCmd.Flags().BoolVar(&subscribing, "subscribe", false, "Enable subscription to PULL changes")
 	rootCmd.Flags().BoolVar(&verbose, "verbose", false, "Enable verbose logging")
-	rootCmd.Flags().BoolVar(&SetPublic, "public", false, "Enable public access to the replica (PUSH only)")
+	rootCmd.Flags().BoolVar(&SetUnlisted, "unlisted", false, "Enable unlisted access to the replica (initial PUSH only)")
+	rootCmd.Flags().BoolVar(&SetPublic, "public", false, "Enable public access to the replica (initial PUSH only)")
 	rootCmd.Flags().BoolVar(&dryRun, "dry", false, "Perform a dry run without making changes")
 	rootCmd.Flags().BoolVarP(&showVersion, "version", "v", false, "Show version information")
 

client/remote/client.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -392,7 +393,7 @@ type Config struct {
 	Version                 string
 	ReplicaID               string
 	Subscribe               bool
-	SetPublic               bool // for PUSH
+	SetVisibility           int // for PUSH
 	Timeout                 int  // in milliseconds
 	Logger                  *zap.Logger
 	EnableTrafficInspection bool // Enable detailed traffic logging
@@ -448,7 +449,7 @@ type Client struct {
 	ReplicaID      string
 	Version        string
 	ReplicaPath    string
-	SetPublic      bool
+	SetVisibility  int
 	newVersionChan chan struct{}
 
 	// Progress tracking
@@ -697,8 +698,8 @@ func (c *Client) Connect() error {
 	if c.config.ReplicaID != "" {
 		headers.Set("X-ReplicaID", c.config.ReplicaID)
 	}
-	if c.config.SetPublic {
-		headers.Set("X-SetPublic", fmt.Sprintf("%t", c.config.SetPublic))
+	if c.config.SetVisibility != 0 {
+		headers.Set("X-Visibility", strconv.Itoa(c.config.SetVisibility))
 	}
 
 	conn, response, err := dialer.DialContext(connectCtx, u.String(), headers)

client/sync/coordinator.go

@@ -12,6 +12,7 @@ import (
 
 	"go.uber.org/zap"
 
+	"github.com/fatih/color"
 	"github.com/sqlrsync/sqlrsync.com/auth"
 	"github.com/sqlrsync/sqlrsync.com/bridge"
 	"github.com/sqlrsync/sqlrsync.com/remote"
@@ -40,7 +41,7 @@ type Config struct {
 	ReplicaPath       string // For LOCAL TO LOCAL sync
 	Version           string
 	Operation         Operation
-	SetPublic         bool
+	SetVisibility     int
 	DryRun            bool
 	Logger            *zap.Logger
 	Verbose           bool
@@ -101,6 +102,64 @@ func (c *Coordinator) Execute() error {
 	}
 }
 
+// displayDryRunInfo displays dry run information for different operations
+func (c *Coordinator) displayDryRunInfo(operation string, authResult *auth.ResolveResult, absLocalPath, serverURL, remotePath, localHostname string) {
+	fmt.Println("SQLRsync Dry Run:")
+
+	switch operation {
+	case "push":
+		fmt.Printf(" - Mode:           %s the LOCAL ORIGIN file up to the REMOTE REPLICA\n", color.YellowString("PUSHing"))
+		fmt.Printf(" - LOCAL ORIGIN:   %s\n", color.GreenString(absLocalPath))
+		if remotePath == "" {
+			fmt.Println(" - REMOTE REPLICA: " + color.YellowString("(None - the server will assign a path using this hostname)"))
+			fmt.Printf("   - Hostname:     %s\n", color.GreenString(localHostname))
+		} else {
+			fmt.Printf(" - REMOTE REPLICA: %s\n", color.GreenString(remotePath))
+		}
+	case "pull":
+		fmt.Printf(" - Mode:           %s the REMOTE ORIGIN file down to LOCAL REPLICA\n", color.YellowString("PULLing"))
+		fmt.Printf(" - REMOTE ORIGIN:  %s\n", color.GreenString(remotePath))
+		fmt.Printf(" - LOCAL REPLICA:  %s\n", color.GreenString(absLocalPath))
+	case "subscribe":
+		fmt.Printf(" - Mode:           %s to REMOTE ORIGIN to PULL down current and future updates\n", color.YellowString("SUBSCRIBing"))
+		fmt.Printf(" - REMOTE ORIGIN:  %s\n", color.GreenString(remotePath))
+		fmt.Printf(" - LOCAL REPLICA:  %s\n", color.GreenString(absLocalPath))
+	case "local":
+		fmt.Printf(" - Mode:           %s between two databases\n", color.YellowString("LOCAL ONLY"))
+	}
+
+	if operation != "local" {
+		fmt.Printf(" - Server:         %s\n", color.GreenString(serverURL))
+
+		fmt.Printf(" - Auth Token:     %s\n", color.GreenString(authResult.AuthToken))
+
+		if operation == "push" {
+			switch c.config.SetVisibility {
+			case 0:
+				fmt.Println(" - Visibility:     " + color.YellowString("PRIVATE") + " (only accessible with access key)")
+			case 1:
+				fmt.Println(" - Visibility:     " + color.YellowString("UNLISTED") + " (anyone with the link can access)")
+			case 2:
+				fmt.Println(" - Visibility:     " + color.GreenString("PUBLIC") + " (anyone can access)")
+			}
+		}
+
+		if c.authResolver.CheckNeedsDashFile(c.config.LocalPath, remotePath) {
+			fmt.Println(" - A shareable config (the -sqlrsync file) " + color.GreenString("WILL BE") + " created for future PULLs and SUBSCRIBEs")
+		} else {
+			fmt.Println(" - A shareable config (the -sqlrsync file) will " + color.RedString("NOT") + " be created")
+		}
+	} else {
+		// For local sync, show the replica path
+		if c.config.ReplicaPath != "" {
+			absReplicaPath, _ := filepath.Abs(c.config.ReplicaPath)
+			fmt.Printf(" - LOCAL ORIGIN:   %s\n", color.GreenString(absLocalPath))
+			fmt.Printf(" - LOCAL REPLICA:  %s\n", color.GreenString(absReplicaPath))
+		}
+	}
+	fmt.Println("\nAfter running this command, REPLICA will become a copy of ORIGIN at the moment the command begins.")
+}
+
 // resolveAuth resolves authentication for the given operation
 func (c *Coordinator) resolveAuth(operation string) (*auth.ResolveResult, error) {
 	req := &auth.ResolveRequest{
@@ -154,6 +213,28 @@ func (c *Coordinator) executeSubscribe() error {
 		return fmt.Errorf("authentication failed: %w", err)
 	}
 
+	// Check for dry run mode
+	if c.config.DryRun {
+		absLocalPath, err := filepath.Abs(c.config.LocalPath)
+		if err != nil {
+			return fmt.Errorf("failed to get absolute path: %w", err)
+		}
+		localHostname, _ := os.Hostname()
+
+		serverURL := authResult.ServerURL
+		if c.config.ServerURL != "" && c.config.ServerURL != "wss://sqlrsync.com" {
+			serverURL = c.config.ServerURL
+		}
+
+		remotePath := authResult.RemotePath
+		if c.config.RemotePath != "" {
+			remotePath = c.config.RemotePath
+		}
+
+		c.displayDryRunInfo("subscribe", authResult, absLocalPath, serverURL, remotePath, localHostname)
+		return nil
+	}
+
 	// Create subscription manager with reconnection configuration
 	c.subManager = subscription.NewManager(&subscription.Config{
 		ServerURL:             authResult.ServerURL,
@@ -196,7 +277,7 @@ func (c *Coordinator) executeSubscribe() error {
 		}
 
 		// Wait for new version notification
-		var version string;
+		var version string
 		for {
 			version, err = c.subManager.WaitForNewVersionMsg()
 			if err != nil {
@@ -258,6 +339,18 @@ func (c *Coordinator) executePull(isSubscription bool) error {
 		remotePath = c.config.RemotePath
 	}
 
+	// Get absolute path and hostname for dry run display
+	absLocalPath, err := filepath.Abs(c.config.LocalPath)
+	if err != nil {
+		return fmt.Errorf("failed to get absolute path: %w", err)
+	}
+	localHostname, _ := os.Hostname()
+
+	if c.config.DryRun {
+		c.displayDryRunInfo("pull", authResult, absLocalPath, serverURL, remotePath, localHostname)
+		return nil
+	}
+
 	if !isSubscription {
 		fmt.Printf("PULLing down from %s/%s@%s ...\n", serverURL, remotePath, version)
 	}
@@ -275,7 +368,7 @@ func (c *Coordinator) executePull(isSubscription bool) error {
 		InspectionDepth:         5,
 		Version:                 version,
 		SendConfigCmd:           true,
-		SendKeyRequest:        c.authResolver.CheckNeedsDashFile(c.config.LocalPath, remotePath),
+		SendKeyRequest:          c.authResolver.CheckNeedsDashFile(c.config.LocalPath, remotePath),
 		//ProgressCallback:        remote.DefaultProgressCallback(remote.FormatSimple),
 		ProgressCallback: nil,
 		ProgressConfig: &remote.ProgressConfig{
@@ -359,8 +452,6 @@ func (c *Coordinator) executePush() error {
 		remotePath = c.config.RemotePath
 	}
 
-	fmt.Printf("PUSHing up to %s/%s ...\n", serverURL, remotePath)
-
 	// Create local client for SQLite operations
 	localClient, err := bridge.New(&bridge.Config{
 		DatabasePath: c.config.LocalPath,
@@ -380,6 +471,13 @@ func (c *Coordinator) executePush() error {
 
 	localHostname, _ := os.Hostname()
 
+	if c.config.DryRun {
+		c.displayDryRunInfo("push", authResult, absLocalPath, serverURL, remotePath, localHostname)
+		return nil
+	}
+
+	fmt.Printf("PUSHing up to %s/%s ...\n", serverURL, remotePath)
+
 	// Create remote client for WebSocket transport
 	remoteClient, err := remote.New(&remote.Config{
 		ServerURL:               serverURL + "/sapi/push/" + remotePath,
@@ -393,7 +491,7 @@ func (c *Coordinator) executePush() error {
 		InspectionDepth:         5,
 		SendKeyRequest:          c.authResolver.CheckNeedsDashFile(c.config.LocalPath, remotePath),
 		SendConfigCmd:           true,
-		SetPublic:               c.config.SetPublic,
+		SetVisibility:           c.config.SetVisibility,
 		ProgressCallback:        nil, //remote.DefaultProgressCallback(remote.FormatSimple),
 		ProgressConfig: &remote.ProgressConfig{
 			Enabled:        true,
@@ -454,10 +552,6 @@ func (c *Coordinator) executePush() error {
 		}
 	}
 
-	if c.config.SetPublic {
-		fmt.Printf("🌐 This replica is now publicly accessible at sqlrsync.com/%s\n", remoteClient.GetReplicaPath())
-	}
-
 	c.logger.Info("Push synchronization completed successfully")
 	return nil
 }
@@ -523,6 +617,11 @@ func (c *Coordinator) executeLocalSync() error {
 		return fmt.Errorf("failed to get absolute path for replica: %w", err)
 	}
 
+	if c.config.DryRun {
+		c.displayDryRunInfo("local", nil, absOriginPath, "", "", "")
+		return nil
+	}
+
 	fmt.Printf("Syncing LOCAL to LOCAL: %s → %s\n", absOriginPath, absReplicaPath)
 
 	// Create local client for SQLite operations