feat: server-side move

Author: jon4hz

README.md

@@ -100,9 +100,15 @@ You can now manage your Google Drive mounts directly from the terminal using the
   ```
   This command allows you to copy files or folders from one Google Drive to another, or within the same drive, using rclone's server-side copy. This avoids any file format conversion and is the recommended way to copy Google Docs, Sheets, and Slides natively.
 
-  > **Why not use normal copy?**
+- **Move files or folders between Google Drives (server-side, no conversion):**
+  ```bash
+  adfinis-rclone-mgr mv <source>... <destination>
+  ```
+  This command allows you to move files or folders from one Google Drive to another, or within the same drive, using rclone's server-side move. This avoids any file format conversion and is the recommended way to move Google Docs, Sheets, and Slides natively.
+
+  > **Why not use normal copy or move?**
   >
-  > If you use the standard copy methods (Ctrl+C, right-click + Copy, or drag & drop) in your file manager, rclone mounts will convert Google Docs, Sheets, and Slides to Microsoft Office formats (e.g., gdocs to .docx) during the copy. This can cause formatting issues. The `cp` command and the "Copy on Google Drive" Nautilus context menu entry ensure that all copy actions are performed server-side, preserving the native Google format and avoiding unwanted conversions.
+  > If you use the standard copy or move methods (ctrl+c/ctrl+x, right-click + Copy/Move, or drag & drop) in your file manager or `cp`, `rsync`, `mv`, etc. in the terminal, rclone mountes will convert Google Docs, Sheets, and Slides to Microsoft Office formats (e.g., gdocs to .docx) during the operation. This can cause formatting issues. The `cp` and `mv` commands and the "Copy on Google Drive"/"Move on Google Drive" Nautilus context menu entries ensure that all copy and move actions are performed server-side, preserving the native Google format and avoiding unwanted conversions.
 
 ### Daemon Mode
 

assets/google_drive_opener.py

@@ -3,7 +3,6 @@
 import subprocess
 import webbrowser
 import json
-import threading
 
 """
 This extension adds a context menu item to Nautilus for opening files in Google Drive.
@@ -45,11 +44,19 @@ def get_file_items(self, *args):
         copy_file_item = Nautilus.MenuItem(
             name="GoogleDriveOpener::CopyFile",
             label="Copy on Google Drive",
-            tip="Copy Files or Folders on Google Drive",
+            tip="Copy on Google Drive",
         )
-        copy_file_item.connect("activate", self._copy_file, file_paths)
+        copy_file_item.connect("activate", self.copy_file, file_paths)
         items.append(copy_file_item)
 
+        move_file_item = Nautilus.MenuItem(
+            name="GoogleDriveOpener::MoveFile",
+            label="Move on Google Drive",
+            tip="Move on Google Drive",
+        )
+        move_file_item.connect("activate", self.move_file, file_paths)
+        items.append(move_file_item)
+
         # add copy button if only one file is selected
         if len(file_paths) == 1:
             copy_file_link_item = Nautilus.MenuItem(
@@ -139,10 +146,9 @@ def copy_file_link(self, menu, file_paths):
                 ["zenity", "--error", "--text", f"Unexpected error:\n{str(e)}"]
             )
 
-    def _copy_file(self, menu, file_paths):
+    def _send_file_op(self, file_paths, op):
         try:
             import httpx
-            # Determine the drive name from the first file path
             if not file_paths:
                 return
             relative_path = os.path.relpath(file_paths[0], self.RCLONE_MOUNT_PATH)
@@ -152,19 +158,19 @@ def _copy_file(self, menu, file_paths):
                 "adfinis-rclone-mgr",
                 f"{drive_name}.sock",
             )
-            # httpx expects the socket path as a str, and the URL as http://localhost/...
-            url = "http://localhost/gdrive/copy"
+            url = f"http://localhost/gdrive/{op}"
             transport = httpx.HTTPTransport(uds=sock_path)
             with httpx.Client(transport=transport) as client:
                 resp = client.post(url, json={"sources": file_paths}, timeout=600)
                 if resp.status_code != 200:
                     raise Exception(f"Server error: {resp.text}")
         except Exception as e:
             subprocess.Popen([
-                "zenity", "--error", "--text", f"Failed to copy file(s) via daemon: {str(e)}"
+                "zenity", "--error", "--text", f"Failed to {op} file(s) via daemon: {str(e)}"
             ])
 
     def copy_file(self, menu, file_paths):
-        threading.Thread(
-            target=self._copy_file, args=(menu, file_paths), daemon=True
-        ).start()
+        self._send_file_op(file_paths, "copy")
+
+    def move_file(self, menu, file_paths):
+        self._send_file_op(file_paths, "move")

daemon.go

@@ -71,34 +71,38 @@ func ipcServer(driveName string) {
 	}
 }
 
-type copyRequest struct {
+type gdriveOPRequest struct {
 	Sources []string `json:"sources"`
 }
 
-func newHTTPHandler() http.Handler {
-	mux := http.NewServeMux()
-	mux.HandleFunc("/gdrive/copy", func(w http.ResponseWriter, r *http.Request) {
+func handleGDriveOp(op string) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
 		if r.Method != http.MethodPost {
 			w.WriteHeader(http.StatusMethodNotAllowed)
 			w.Write([]byte("Method not allowed")) // nolint:errcheck
 			return
 		}
-		var req copyRequest
+		var req gdriveOPRequest
 		err := json.NewDecoder(r.Body).Decode(&req)
 		if err != nil || len(req.Sources) == 0 {
 			w.WriteHeader(http.StatusBadRequest)
 			w.Write([]byte("Invalid request: must provide sources")) // nolint:errcheck
 			return
 		}
 
-		log.Println("Received copy request for sources:", req.Sources)
+		log.Printf("Received %s request for sources: %v", op, req.Sources)
 
-		// copy files in background
-		go selectDestAndCopy(req.Sources)
+		// run files in background
+		go selectDestAndRunOP(req.Sources, op)
 
 		w.WriteHeader(http.StatusOK)
 		w.Write([]byte("OK")) // nolint:errcheck
-	})
+	}
+}
 
+func newHTTPHandler() http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/gdrive/copy", handleGDriveOp("copy"))
+	mux.HandleFunc("/gdrive/move", handleGDriveOp("move"))
 	return mux
 }

filehandler.go

@@ -15,7 +15,13 @@ import (
 func copy(cmd *cobra.Command, args []string) {
 	// last arg is the destination directory
 	dest := args[len(args)-1]
-	copyFile(args[:len(args)-1], dest)
+	runRcloneOp("copy", args[:len(args)-1], dest)
+}
+
+func move(cmd *cobra.Command, args []string) {
+	// last arg is the destination directory
+	dest := args[len(args)-1]
+	runRcloneOp("move", args[:len(args)-1], dest)
 }
 
 // isSubdir checks if sub is a subdirectory (or the same) as root.
@@ -85,7 +91,7 @@ func selectDestination() (string, error) {
 	return destDir, nil
 }
 
-func selectDestAndCopy(srcPaths []string) {
+func selectDestAndRunOP(srcPaths []string, op string) {
 	destDir, err := selectDestination()
 	if err != nil {
 		log.Println("Failed to select destination:", err)
@@ -97,10 +103,11 @@ func selectDestAndCopy(srcPaths []string) {
 		return
 	}
 
-	copyFile(srcPaths, destDir)
+	runRcloneOp(op, srcPaths, destDir)
 }
 
-func copyFile(srcPaths []string, destDir string) {
+// runRcloneOp runs rclone with the given operation ("copy" or "move")
+func runRcloneOp(op string, srcPaths []string, destDir string) {
 	absGoogleRoot, err := filepath.Abs(getGooglePath())
 	if err != nil {
 		showZenityError("Failed to resolve Google Drive root")
@@ -140,18 +147,33 @@ func copyFile(srcPaths []string, destDir string) {
 		if isDir(src) {
 			destRclone = patchDestPath(srcPath, destRclone)
 		}
-		log.Printf("Copying from %s to %s", srcRclone, destRclone)
+		// ahhh yes
+		verb := op
+		switch op {
+		case "copy":
+			verb = "copy"
+		case "move":
+			verb = "mov"
+		}
+		log.Printf("%sing from %s to %s", verb, srcRclone, destRclone)
 
-		cmd := exec.Command("rclone", "copy", "--drive-server-side-across-configs", srcRclone, destRclone, "-v")
+		cmd := exec.Command("rclone", op, "--drive-server-side-across-configs", srcRclone, destRclone, "-v")
 		cmd.Stdout = os.Stdout
 		cmd.Stderr = os.Stderr
 		err = cmd.Run()
 		if err != nil {
-			showZenityError("rclone copy failed: " + err.Error())
+			showZenityError(fmt.Sprintf("rclone %s failed: %v", op, err))
 			return
 		}
 	}
-	if err := exec.Command("zenity", "--info", "--text", "File(s) copied successfully").Run(); err != nil {
+	var msg string
+	switch op {
+	case "copy":
+		msg = "File(s) copied successfully"
+	case "move":
+		msg = "File(s) moved successfully"
+	}
+	if err := exec.Command("zenity", "--info", "--text", msg).Run(); err != nil {
 		log.Println("Failed to show success dialog:", err)
 	}
 }

main.go

@@ -46,6 +46,7 @@ func init() {
 		listCmd,
 		daemonCmd,
 		copyCmd,
+		moveCmd,
 		versionCmd,
 		manCmd,
 	)
@@ -144,6 +145,16 @@ var copyCmd = &cobra.Command{
 	Run:  copy,
 }
 
+var moveCmd = &cobra.Command{
+	Use:   "mv",
+	Short: "Move files or folders from one drive to another",
+	Long: "The mv command allows you to move files or folders from one Google Drive to another.\n" +
+		"It supports moving single files, multiple files, or entire folders.\n" +
+		"You can use it as a drop-in replacement for the linux mv command, but with the added benefit of working across Google Drives.\n",
+	Args: cobra.MinimumNArgs(2),
+	Run:  move,
+}
+
 var versionCmd = &cobra.Command{
 	Use:   "version",
 	Short: "Print the version details",

main_test.go

@@ -26,6 +26,7 @@ func TestRootCmd_HasSubcommands(t *testing.T) {
 		"ls",
 		"daemon",
 		"cp",
+		"mv",
 		"version",
 		"man",
 	}