intercube
diff --git a/‎README.md‎
Lines changed: 26 additions & 2 deletions b/‎README.md‎
Lines changed: 26 additions & 2 deletions
diff --git a/‎cmd/sync-config_test.go‎
Lines changed: 44 additions & 0 deletions b/‎cmd/sync-config_test.go‎
Lines changed: 44 additions & 0 deletions
diff --git a/‎cmd/sync-database.go‎
Lines changed: 120 additions & 10 deletions b/‎cmd/sync-database.go‎
Lines changed: 120 additions & 10 deletions
@@ -71,8 +71,32 @@ Behavior:
 - always fetches current site inventory at runtime
 - interactive target selection when no argument is passed
 - argument auto-resolves against site ID/domain/server/user when possible
-- stores only file path mappings in config (`sync.files.items`)
-- database details are requested interactively for each run (not persisted)
+- stores file path mappings in config (`sync.files.items`)
+- database connection details are requested interactively for each run (not persisted)
+- database sync uses the selected target server by default, with an optional
+  database SSH host override for clustered setups where files and MySQL live on
+  separate servers
+
+Single-server environments do not need extra sync configuration. For clustered
+targets, add the database SSH defaults to `.intercube.yaml`:
+
+```yaml
+sync:
+  files:
+    items:
+      - source: /var/www/site/
+        target: /var/www/site/
+  database:
+    target_ssh:
+      host: production-sql.example.com
+      user: deploy
+      port: 22
+```
+
+When `sync.database.target_ssh.host` is set, `intercube sync --database`
+pre-fills the database SSH prompt with that host. The `user` and `port` values
+are optional; when omitted, the selected target server's SSH user and port are
+used.
 
 ### Context-aware defaults
 
 
@@ -0,0 +1,44 @@
+package cmd
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/spf13/viper"
+)
+
+func TestLoadSyncSettingsDecodesDatabaseTargetSSH(t *testing.T) {
+	viper.Reset()
+	t.Cleanup(viper.Reset)
+
+	viper.SetConfigType("yaml")
+	err := viper.ReadConfig(strings.NewReader(`
+sync:
+  database:
+    target_ssh:
+      host: production-sql.example.com
+      user: deploy
+      port: 2200
+`))
+	if err != nil {
+		t.Fatalf("unable to read config: %v", err)
+	}
+
+	settings, err := loadSyncSettings()
+	if err != nil {
+		t.Fatalf("unable to load sync settings: %v", err)
+	}
+
+	if settings.Database.TargetSSH.Host != "production-sql.example.com" {
+		t.Fatalf("unexpected database SSH host: %q", settings.Database.TargetSSH.Host)
+	}
+	if settings.Database.TargetSSH.User != "deploy" {
+		t.Fatalf("unexpected database SSH user: %q", settings.Database.TargetSSH.User)
+	}
+	if settings.Database.TargetSSH.Port != 2200 {
+		t.Fatalf("unexpected database SSH port: %d", settings.Database.TargetSSH.Port)
+	}
+	if settings.Files.Items == nil {
+		t.Fatalf("expected file sync items to default to an empty slice")
+	}
+}
@@ -21,10 +21,17 @@ type mysqlSyncConfig struct {
 	TargetHost        string
 	TargetPort        int
 	TargetPasswordEnv string
+	DatabaseSSH       syncSSHTarget
 	DumpFlags         []string
 }
 
-func runDatabaseSync(cmd *cobra.Command, target ResolvedSyncTarget, _ *SyncSettings, dryRun bool, autoApprove bool) error {
+type syncSSHTarget struct {
+	Host     string
+	Username string
+	Port     int
+}
+
+func runDatabaseSync(cmd *cobra.Command, target ResolvedSyncTarget, settings *SyncSettings, dryRun bool, autoApprove bool) error {
 	if isNonInteractiveMode() {
 		return fmt.Errorf("database sync requires interactive prompts in current implementation; run with an interactive terminal")
 	}
@@ -36,18 +43,18 @@ func runDatabaseSync(cmd *cobra.Command, target ResolvedSyncTarget, _ *SyncSetti
 		return err
 	}
 
-	databaseConfig, err := promptMySQLSyncConfig(target)
+	databaseConfig, err := promptMySQLSyncConfig(target, settings)
 	if err != nil {
 		return err
 	}
 
-	if isSameDatabaseTarget(target, databaseConfig) {
+	if isSameDatabaseTarget(databaseConfig) {
 		return fmt.Errorf("source and target resolve to the same database destination")
 	}
 
 	fmt.Println("Database sync plan:")
 	fmt.Printf("  Source: %s@%s:%d/%s\n", databaseConfig.SourceUser, databaseConfig.SourceHost, databaseConfig.SourcePort, databaseConfig.SourceDatabase)
-	fmt.Printf("  Target: %s@%s:%d/%s (via %s@%s:%d)\n", databaseConfig.TargetUser, databaseConfig.TargetHost, databaseConfig.TargetPort, databaseConfig.TargetDatabase, target.Username, target.Host, target.Port)
+	fmt.Printf("  Target: %s@%s:%d/%s (via %s@%s:%d)\n", databaseConfig.TargetUser, databaseConfig.TargetHost, databaseConfig.TargetPort, databaseConfig.TargetDatabase, databaseConfig.DatabaseSSH.Username, databaseConfig.DatabaseSSH.Host, databaseConfig.DatabaseSSH.Port)
 
 	if !autoApprove {
 		confirmed, confirmErr := promptYesNo("Continue with MySQL import into target?")
@@ -73,7 +80,7 @@ func runDatabaseSync(cmd *cobra.Command, target ResolvedSyncTarget, _ *SyncSetti
 
 	dumpArgs := buildMySQLDumpArgs(databaseConfig)
 	remoteCommand := buildRemoteMySQLImportCommand(databaseConfig, targetPassword)
-	sshArgs := []string{"-p", strconv.Itoa(target.Port), fmt.Sprintf("%s@%s", target.Username, target.Host), remoteCommand}
+	sshArgs := buildDatabaseSSHArgs(databaseConfig.DatabaseSSH, remoteCommand)
 
 	fmt.Printf("Running: MYSQL_PWD=<hidden> mysqldump %s | ssh %s\n", strings.Join(dumpArgs, " "), strings.Join(sshArgs, " "))
 
@@ -122,7 +129,7 @@ func ensureCommandAvailable(name string) error {
 	return nil
 }
 
-func promptMySQLSyncConfig(target ResolvedSyncTarget) (mysqlSyncConfig, error) {
+func promptMySQLSyncConfig(target ResolvedSyncTarget, settings *SyncSettings) (mysqlSyncConfig, error) {
 	sourceDatabase, err := promptText("Source MySQL database", "", requiredValue, 0)
 	if err != nil {
 		return mysqlSyncConfig{}, err
@@ -173,6 +180,11 @@ func promptMySQLSyncConfig(target ResolvedSyncTarget) (mysqlSyncConfig, error) {
 		return mysqlSyncConfig{}, err
 	}
 
+	databaseSSH, err := promptDatabaseSSHTarget(target, settings)
+	if err != nil {
+		return mysqlSyncConfig{}, err
+	}
+
 	flagsRaw, err := promptText("Extra mysqldump flags (space-separated, optional)", "--single-transaction --quick", optionalValue, 0)
 	if err != nil {
 		return mysqlSyncConfig{}, err
@@ -189,10 +201,89 @@ func promptMySQLSyncConfig(target ResolvedSyncTarget) (mysqlSyncConfig, error) {
 		TargetHost:        strings.TrimSpace(targetHost),
 		TargetPort:        targetPort,
 		TargetPasswordEnv: strings.TrimSpace(targetPasswordEnv),
+		DatabaseSSH:       databaseSSH,
 		DumpFlags:         strings.Fields(strings.TrimSpace(flagsRaw)),
 	}, nil
 }
 
+func promptDatabaseSSHTarget(target ResolvedSyncTarget, settings *SyncSettings) (syncSSHTarget, error) {
+	defaultTarget := defaultDatabaseSSHTarget(target)
+	configuredTarget, hasConfiguredTarget := configuredDatabaseSSHTarget(target, settings)
+
+	hostDefault := ""
+	if hasConfiguredTarget {
+		hostDefault = configuredTarget.Host
+	}
+
+	host, err := promptText("Database SSH host override (blank = selected target)", hostDefault, optionalValue, 0)
+	if err != nil {
+		return syncSSHTarget{}, err
+	}
+	if strings.TrimSpace(host) == "" {
+		return defaultTarget, nil
+	}
+
+	usernameDefault := defaultTarget.Username
+	portDefault := defaultTarget.Port
+	if hasConfiguredTarget {
+		usernameDefault = configuredTarget.Username
+		portDefault = configuredTarget.Port
+	}
+
+	username, err := promptText("Database SSH user", usernameDefault, requiredValue, 0)
+	if err != nil {
+		return syncSSHTarget{}, err
+	}
+
+	port, err := promptPort("Database SSH port", strconv.Itoa(portDefault))
+	if err != nil {
+		return syncSSHTarget{}, err
+	}
+
+	return syncSSHTarget{
+		Host:     strings.TrimSpace(host),
+		Username: strings.TrimSpace(username),
+		Port:     port,
+	}, nil
+}
+
+func configuredDatabaseSSHTarget(target ResolvedSyncTarget, settings *SyncSettings) (syncSSHTarget, bool) {
+	defaultTarget := defaultDatabaseSSHTarget(target)
+	if settings == nil {
+		return defaultTarget, false
+	}
+
+	configured := settings.Database.TargetSSH
+	host := strings.TrimSpace(configured.Host)
+	if host == "" {
+		return defaultTarget, false
+	}
+
+	username := strings.TrimSpace(configured.User)
+	if username == "" {
+		username = defaultTarget.Username
+	}
+
+	port := configured.Port
+	if port <= 0 {
+		port = defaultTarget.Port
+	}
+
+	return syncSSHTarget{
+		Host:     host,
+		Username: username,
+		Port:     port,
+	}, true
+}
+
+func defaultDatabaseSSHTarget(target ResolvedSyncTarget) syncSSHTarget {
+	return syncSSHTarget{
+		Host:     strings.TrimSpace(target.Host),
+		Username: strings.TrimSpace(target.Username),
+		Port:     target.Port,
+	}
+}
+
 func promptPort(label, defaultValue string) (int, error) {
 	value, err := promptText(label, defaultValue, requiredValue, 0)
 	if err != nil {
@@ -230,23 +321,42 @@ func buildRemoteMySQLImportCommand(config mysqlSyncConfig, targetPassword string
 	)
 }
 
+func buildDatabaseSSHArgs(target syncSSHTarget, remoteCommand string) []string {
+	return []string{"-p", strconv.Itoa(target.Port), fmt.Sprintf("%s@%s", target.Username, target.Host), remoteCommand}
+}
+
 func shellQuote(value string) string {
 	escaped := strings.ReplaceAll(value, "'", "'\\''")
 	return "'" + escaped + "'"
 }
 
-func isSameDatabaseTarget(target ResolvedSyncTarget, config mysqlSyncConfig) bool {
-	if !strings.EqualFold(strings.TrimSpace(target.Host), strings.TrimSpace(config.SourceHost)) {
+func isSameDatabaseTarget(config mysqlSyncConfig) bool {
+	if !isSameDatabaseHost(config.SourceHost, config.TargetHost, config.DatabaseSSH.Host) {
 		return false
 	}
 
 	if config.TargetPort != config.SourcePort {
 		return false
 	}
 
-	if !strings.EqualFold(strings.TrimSpace(config.TargetHost), strings.TrimSpace(config.SourceHost)) {
+	return strings.EqualFold(strings.TrimSpace(config.SourceDatabase), strings.TrimSpace(config.TargetDatabase))
+}
+
+func isSameDatabaseHost(sourceHost string, targetHost string, targetSSHHost string) bool {
+	source := strings.TrimSpace(sourceHost)
+	target := strings.TrimSpace(targetHost)
+	if source == "" || target == "" {
 		return false
 	}
 
-	return strings.EqualFold(strings.TrimSpace(config.SourceDatabase), strings.TrimSpace(config.TargetDatabase))
+	if !isLoopbackHost(target) {
+		return strings.EqualFold(source, target)
+	}
+
+	return strings.EqualFold(source, strings.TrimSpace(targetSSHHost))
+}
+
+func isLoopbackHost(host string) bool {
+	normalized := strings.ToLower(strings.TrimSpace(host))
+	return normalized == "localhost" || normalized == "127.0.0.1" || normalized == "::1"
 }