feat: add ftp root path setting

internal/application/capture_ftp.go

@@ -40,9 +40,9 @@ type CaptureAndFTPService struct {
 	Cfg       domain.FTPConfig
 }
 
-// ExecuteWithBytes uploads previously captured PNG bytes and copies the exact
-// remote path semantics shown in Settings: FTP paths are rooted at "/", while
-// SFTP paths are relative to the authenticated user's home directory.
+// ExecuteWithBytes uploads previously captured PNG bytes and copies a display
+// path built from the configured root directory plus the uploaded relative
+// path. RootDirectory deliberately does not affect the upload destination.
 func (s *CaptureAndFTPService) ExecuteWithBytes(ctx context.Context, pngBytes []byte) error {
 	if s.Uploader == nil {
 		s.notifyFailure("FTP/SFTP not configured")
@@ -80,7 +80,7 @@ func (s *CaptureAndFTPService) ExecuteWithBytes(ctx context.Context, pngBytes []
 		return err
 	}
 
-	clipText := ftpShareText(protocol, relPath)
+	clipText := ftpShareText(protocol, s.Cfg.RootDirectory, relPath)
 	if s.Clipboard != nil {
 		if err := s.Clipboard.WriteText(clipText); err != nil {
 			s.notifyFailure("clipboard write failed: " + err.Error())
@@ -131,11 +131,16 @@ func normalizedFTPProtocol(protocol string) string {
 	return domain.FTPProtocolFTP
 }
 
-func ftpShareText(protocol, relPath string) string {
-	if protocol == domain.FTPProtocolSFTP {
-		return "~/" + relPath
+func ftpShareText(protocol, rootDirectory, relPath string) string {
+	rootDirectory = strings.TrimSpace(rootDirectory)
+	if rootDirectory == "" {
+		if protocol == domain.FTPProtocolSFTP {
+			rootDirectory = "~/"
+		} else {
+			rootDirectory = "/"
+		}
 	}
-	return "/" + relPath
+	return strings.TrimRight(rootDirectory, "/") + "/" + strings.TrimLeft(relPath, "/")
 }
 
 func (s *CaptureAndFTPService) notifyFailure(reason string) {

internal/application/capture_ftp_test.go

@@ -52,23 +52,52 @@ func TestCaptureAndFTPServiceUploadsAndCopiesFTPPath(t *testing.T) {
 	}
 }
 
-func TestCaptureAndFTPServiceCopiesSFTPHomePath(t *testing.T) {
+func TestCaptureAndFTPServiceCopiesConfiguredRootPath(t *testing.T) {
 	uploader := &fakeFTPUploader{}
 	clip := &fakeClipboard{}
 	svc := &CaptureAndFTPService{
 		Uploader:  uploader,
 		Clipboard: clip,
 		Cfg: domain.FTPConfig{
-			Protocol:   domain.FTPProtocolSFTP,
-			PathPrefix: "images",
+			Protocol:      domain.FTPProtocolSFTP,
+			RootDirectory: "~/ftp/",
+			PathPrefix:    "images",
 		},
 	}
 
 	if err := svc.ExecuteWithBytes(context.Background(), []byte("png")); err != nil {
 		t.Fatalf("upload SFTP screenshot: %v", err)
 	}
-	if clip.text != "~/"+uploader.path {
-		t.Fatalf("expected SFTP home path copied, got %q", clip.text)
+	if clip.text != "~/ftp/"+uploader.path {
+		t.Fatalf("expected configured SFTP root path copied, got %q", clip.text)
+	}
+}
+
+func TestFTPShareTextJoinsConfiguredRootAndRemoteDirectory(t *testing.T) {
+	const relPath = "snapgo/2026/07/20260713-110413-18lnbx.png"
+	const want = "~/ftp/snapgo/2026/07/20260713-110413-18lnbx.png"
+	if got := ftpShareText(domain.FTPProtocolSFTP, "~/ftp/", relPath); got != want {
+		t.Fatalf("ftpShareText() = %q, want %q", got, want)
+	}
+}
+
+func TestFTPShareTextUsesProtocolDefaultWhenRootDirectoryIsEmpty(t *testing.T) {
+	const relPath = "snapgo/2026/07/image.png"
+	tests := []struct {
+		name     string
+		protocol string
+		want     string
+	}{
+		{name: "FTP", protocol: domain.FTPProtocolFTP, want: "/" + relPath},
+		{name: "SFTP", protocol: domain.FTPProtocolSFTP, want: "~/" + relPath},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := ftpShareText(tt.protocol, "", relPath); got != tt.want {
+				t.Fatalf("ftpShareText() = %q, want %q", got, tt.want)
+			}
+		})
 	}
 }
 

internal/domain/config.go

@@ -83,6 +83,10 @@ type SSHConfig struct {
 //     reuses the local ssh-agent and ~/.ssh/id_* discovery used by SSH/SCP.
 //   - PathPrefix is relative to the account's login root. The application
 //     rejects absolute paths and traversal segments before uploading.
+//   - RootDirectory is only used to build the path copied to the clipboard.
+//     Keeping it separate from PathPrefix lets the server expose a login root
+//     such as "~/ftp/" while uploads still target a relative directory such
+//     as "snapgo/".
 //   - StrictHostKey and KnownHostsPath apply only to SFTP. Plain FTP has no
 //     host-key mechanism and sends credentials and data without encryption.
 type FTPConfig struct {
@@ -92,6 +96,7 @@ type FTPConfig struct {
 	User               string `json:"user"`
 	AuthMethod         string `json:"authMethod"`
 	Password           string `json:"password"`
+	RootDirectory      string `json:"rootDirectory"`
 	PathPrefix         string `json:"pathPrefix"`
 	StrictHostKey      bool   `json:"strictHostKey"`
 	KnownHostsPath     string `json:"knownHostsPath"`
@@ -260,6 +265,7 @@ func DefaultAppConfig() AppConfig {
 			Protocol:           FTPProtocolFTP,
 			Port:               21,
 			AuthMethod:         SSHAuthPassword,
+			RootDirectory:      "/",
 			PathPrefix:         "snapgo/",
 			ConnectTimeoutSecs: 10,
 			StrictHostKey:      false,
@@ -371,6 +377,13 @@ func (c *AppConfig) Normalize() {
 	if c.FTP.AuthMethod != SSHAuthPassword && c.FTP.AuthMethod != SSHAuthKey {
 		c.FTP.AuthMethod = SSHAuthPassword
 	}
+	if c.FTP.RootDirectory == "" {
+		if c.FTP.Protocol == FTPProtocolSFTP {
+			c.FTP.RootDirectory = "~/"
+		} else {
+			c.FTP.RootDirectory = "/"
+		}
+	}
 	if c.FTP.PathPrefix == "" {
 		c.FTP.PathPrefix = "snapgo/"
 	}

internal/domain/config_ftp_test.go

@@ -13,6 +13,9 @@ func TestDefaultAppConfigIncludesFTPDefaults(t *testing.T) {
 	if cfg.FTP.PathPrefix != "snapgo/" {
 		t.Fatalf("expected default path prefix, got %q", cfg.FTP.PathPrefix)
 	}
+	if cfg.FTP.RootDirectory != "/" {
+		t.Fatalf("expected default root directory, got %q", cfg.FTP.RootDirectory)
+	}
 	if cfg.FTP.ConnectTimeoutSecs != 10 {
 		t.Fatalf("expected 10 second timeout, got %d", cfg.FTP.ConnectTimeoutSecs)
 	}
@@ -31,6 +34,9 @@ func TestNormalizeUsesSFTPDefaultPort(t *testing.T) {
 	if cfg.FTP.AuthMethod != SSHAuthPassword {
 		t.Fatalf("expected password auth default, got %q", cfg.FTP.AuthMethod)
 	}
+	if cfg.FTP.RootDirectory != "~/" {
+		t.Fatalf("expected SFTP home root directory, got %q", cfg.FTP.RootDirectory)
+	}
 }
 
 func TestIsFTPConfiguredRequiresProtocolHostAndUser(t *testing.T) {