Merge pull request #107 from martindurant/moer

More features for the file browser

Author: martindurant

pycharm_plugin/src/main/kotlin/com/projspec/toolwindow/ProjspecToolWindowPanel.kt

@@ -300,8 +300,14 @@ class ProjspecToolWindowPanel(
                                                     msg["name"] as? String ?: "", so) }
             "deleteEntry"  -> pool { fbDeleteEntry(msg["url"] as? String ?: "",
                                                     msg["isDir"] == true, so) }
+            "deleteEntries" -> pool { fbDeleteEntries(msg["items"] as? List<*> ?: emptyList<Any>()) }
             "renameEntry"  -> pool { fbRenameEntry(msg["url"] as? String ?: "",
                                                     msg["newName"] as? String ?: "", so) }
+            "paste"        -> pool { fbPasteEntry(msg["items"] as? List<*> ?: emptyList<Any>(),
+                                                   msg["dstDir"] as? String ?: "",
+                                                   msg["dstStorageOptions"] as? String,
+                                                   msg["mode"] as? String ?: "copy",
+                                                   msg["confirmed"] == true) }
             "mkdir"        -> pool { fbMkdir(msg["parentUrl"] as? String ?: "",
                                              msg["name"] as? String ?: "", so) }
             "addBookmark"  -> pool { fbBookmarkAdd(msg["url"] as? String ?: "",
@@ -829,6 +835,37 @@ class ProjspecToolWindowPanel(
         fbBrowse(url.trimEnd('/').substringBeforeLast('/').ifBlank { "/" }, storageOptions, false)
     }
 
+    /**
+     * Delete one or more entries (multi-select). Deletes each item
+     * individually (fire-and-forget, like [fbDeleteEntry]) and reports
+     * per-item results so partial failures are visible in the webview.
+     */
+    private fun fbDeleteEntries(items: List<*>) {
+        if (items.isEmpty()) return
+        val results = mutableListOf<Map<String, Any?>>()
+        var refreshDir: String? = null
+        var refreshSo: String? = null
+        for (raw in items) {
+            @Suppress("UNCHECKED_CAST")
+            val item = raw as? Map<String, Any?> ?: continue
+            val url = item["url"] as? String ?: continue
+            val isDir = item["isDir"] == true
+            val storageOptions = item["storageOptions"] as? String
+            val so = server.parseSo(storageOptions)
+            val error = if (server.delete(url, isDir, so) != null) {
+                null
+            } else {
+                ProjspecRunner.runFbDelete(url, isDir, storageOptions)
+                null
+            }
+            results.add(mapOf("url" to url, "error" to error))
+            refreshDir = url.trimEnd('/').substringBeforeLast('/').ifBlank { "/" }
+            refreshSo = storageOptions
+        }
+        deliverToFbWebview(mapOf("type" to "deleteEntriesResult", "results" to results))
+        if (refreshDir != null) fbBrowse(refreshDir, refreshSo, false)
+    }
+
     private fun fbRenameEntry(url: String, newName: String, storageOptions: String?) {
         val parent = url.trimEnd('/').substringBeforeLast('/').ifBlank { "/" }
         val dst = parent.trimEnd('/') + "/" + newName
@@ -837,6 +874,81 @@ class ProjspecToolWindowPanel(
         fbBrowse(parent, storageOptions, false)
     }
 
+    /**
+     * Paste one or more previously copied/cut entries into `dstDir`. `mode`
+     * is "copy" or "cut" — "cut" maps to `move()` per item (fire-and-forget,
+     * like [fbRenameEntry]); "copy" first checks the *aggregate* size of all
+     * items via a single `totalSize()` call, which reports `needsConfirm`
+     * using the same `filebrowser_copy_confirm_bytes` threshold `copy()`
+     * itself enforces per item. If confirmation is needed and `confirmed`
+     * wasn't already set, nothing is copied yet — `pasteNeedsConfirm` is
+     * delivered to the webview, which re-sends this same message with
+     * `confirmed=true` once the user accepts. Each item is then
+     * copied/moved individually (passing `confirmed=true` through so the
+     * per-item calls don't redundantly re-check a threshold already cleared
+     * for the batch) and per-item results are reported.
+     */
+    private fun fbPasteEntry(
+        items: List<*>,
+        dstDir: String,
+        dstStorageOptions: String?,
+        mode: String,
+        confirmed: Boolean,
+    ) {
+        @Suppress("UNCHECKED_CAST")
+        val parsedItems = items.mapNotNull { it as? Map<String, Any?> }
+        if (parsedItems.isEmpty()) return
+        val firstSrcSo = parsedItems[0]["srcStorageOptions"] as? String
+        val soStr = firstSrcSo ?: dstStorageOptions
+        val so = server.parseSo(soStr)
+
+        if (mode != "cut" && !confirmed) {
+            val urls = parsedItems.mapNotNull { it["src"] as? String }
+            val tsData: Map<String, Any?> = server.totalSize(urls, so) ?: run {
+                val raw = ProjspecRunner.runFbTotalSize(urls, soStr)
+                try {
+                    @Suppress("UNCHECKED_CAST")
+                    gson.fromJson(raw, Map::class.java) as Map<String, Any?>
+                } catch (_: Exception) {
+                    mapOf("total_size" to null, "error" to raw, "needs_confirm" to false)
+                }
+            }
+            if (tsData["needs_confirm"] == true) {
+                deliverToFbWebview(mapOf(
+                    "type" to "pasteNeedsConfirm",
+                    "items" to items, "dstDir" to dstDir, "dstStorageOptions" to dstStorageOptions,
+                    "mode" to mode, "totalSize" to tsData["total_size"],
+                ))
+                return
+            }
+        }
+
+        val results = mutableListOf<Map<String, Any?>>()
+        for (item in parsedItems) {
+            val src = item["src"] as? String ?: continue
+            val itemSoStr = (item["srcStorageOptions"] as? String) ?: dstStorageOptions
+            val itemSo = server.parseSo(itemSoStr) ?: so
+            val dst = dstDir.trimEnd('/') + "/" + (src.trimEnd('/').substringAfterLast('/'))
+            val error: Any? = if (mode == "cut") {
+                if (server.move(src, dst, itemSo) == null) ProjspecRunner.runFbMove(src, dst, itemSoStr)
+                null
+            } else {
+                val data: Map<String, Any?> = server.copy(src, dst, itemSo, true) ?: run {
+                    val raw = ProjspecRunner.runFbCopy(src, dst, itemSoStr, true)
+                    try {
+                        @Suppress("UNCHECKED_CAST")
+                        gson.fromJson(raw, Map::class.java) as Map<String, Any?>
+                    } catch (_: Exception) {
+                        mapOf("error" to raw)
+                    }
+                }
+                data["error"]
+            }
+            results.add(mapOf("src" to src, "dst" to dst, "error" to error))
+        }
+        deliverToFbWebview(mapOf("type" to "pasteResult", "mode" to mode, "results" to results, "error" to null))
+    }
+
     private fun fbMkdir(parentUrl: String, name: String, storageOptions: String?) {
         val newUrl = parentUrl.trimEnd('/') + "/" + name
         val so = server.parseSo(storageOptions)

pycharm_plugin/src/main/kotlin/com/projspec/util/ProjspecRunner.kt

@@ -186,6 +186,30 @@ print(json.dumps(result))
         run(args)
     }
 
+    /** `projspec filebrowser copy <src> <dst> [--confirmed] [--storage-options JSON]` → JSON result */
+    fun runFbCopy(src: String, dst: String, storageOptions: String?, confirmed: Boolean): String {
+        val args = mutableListOf(cli, "filebrowser", "copy", src, dst)
+        if (confirmed) args.add("--confirmed")
+        if (!storageOptions.isNullOrBlank()) { args.add("--storage-options"); args.add(storageOptions) }
+        return when (val r = run(args)) {
+            is CliResult.Success -> extractJson(r.stdout).ifBlank { "{}" }
+            is CliResult.Failure ->
+                """{"src":"$src","dst":"$dst","error":"${r.message.replace("\"", "'")}","needs_confirm":false,"total_size":null}"""
+        }
+    }
+
+    /** `projspec filebrowser total-size <url>... [--storage-options JSON]` → JSON result */
+    fun runFbTotalSize(urls: List<String>, storageOptions: String?): String {
+        val args = mutableListOf(cli, "filebrowser", "total-size")
+        args.addAll(urls)
+        if (!storageOptions.isNullOrBlank()) { args.add("--storage-options"); args.add(storageOptions) }
+        return when (val r = run(args)) {
+            is CliResult.Success -> extractJson(r.stdout).ifBlank { "{}" }
+            is CliResult.Failure ->
+                """{"total_size":null,"error":"${r.message.replace("\"", "'")}","needs_confirm":false}"""
+        }
+    }
+
     /** `projspec filebrowser mkdir <url> [--storage-options JSON]` */
     fun runFbMkdir(url: String, storageOptions: String?) {
         val args = mutableListOf(cli, "filebrowser", "mkdir", url)

pycharm_plugin/src/main/kotlin/com/projspec/util/ProjspecServer.kt

@@ -362,6 +362,16 @@ class ProjspecServer {
     fun move(src: String, dst: String, so: Map<String, Any?>? = null): Map<String, Any?>? =
         post("/filebrowser/move", mapOf("src" to src, "dst" to dst, "storage_options" to so)) as? Map<String, Any?>
 
+    fun copy(src: String, dst: String, so: Map<String, Any?>? = null, confirmed: Boolean = false): Map<String, Any?>? =
+        post("/filebrowser/copy", mapOf(
+            "src" to src, "dst" to dst, "storage_options" to so, "confirmed" to confirmed,
+        )) as? Map<String, Any?>
+
+    fun totalSize(urls: List<String>, so: Map<String, Any?>? = null): Map<String, Any?>? =
+        post("/filebrowser/total_size", mapOf(
+            "urls" to urls, "storage_options" to so,
+        )) as? Map<String, Any?>
+
     fun mkdir(url: String, so: Map<String, Any?>? = null): Map<String, Any?>? =
         post("/filebrowser/mkdir", mapOf("url" to url, "storage_options" to so)) as? Map<String, Any?>
 

src/projspec/__main__.py

@@ -468,6 +468,71 @@ def fb_move(src, dst, storage_options):
     print(json.dumps(move(src, dst, storage_options=so)))
 
 
+@filebrowser.command("copy")
+@click.argument("src")
+@click.argument("dst")
+@click.option("--storage-options", default="", help="fsspec storage options as JSON")
+@click.option(
+    "--no-recursive",
+    "recursive",
+    is_flag=True,
+    default=True,
+    flag_value=False,
+    help="Do not copy directory contents recursively (default: recursive)",
+)
+@click.option(
+    "--confirmed",
+    is_flag=True,
+    default=False,
+    help=(
+        "Proceed even if the total size exceeds filebrowser_copy_confirm_bytes. "
+        "Without this flag, a copy exceeding that threshold is not performed; "
+        "the command instead reports needs_confirm=true and the total size."
+    ),
+)
+def fb_copy(src, dst, storage_options, recursive, confirmed):
+    """Copy SRC to DST, recursively for directories.
+
+    Uses fsspec.generic to support copying between different filesystems.
+
+    Outputs JSON with keys: src, dst, error, needs_confirm, total_size.
+    """
+    from projspec.filebrowser import copy
+
+    so = json.loads(storage_options) if storage_options.strip() else None
+    print(
+        json.dumps(
+            copy(
+                src,
+                dst,
+                storage_options=so,
+                recursive=recursive,
+                confirmed=confirmed,
+            )
+        )
+    )
+
+
+@filebrowser.command("total-size")
+@click.argument("urls", nargs=-1, required=True)
+@click.option("--storage-options", default="", help="fsspec storage options as JSON")
+def fb_total_size(urls, storage_options):
+    """Compute the combined size (bytes) of one or more URLs (files/dirs).
+
+    Used by the multi-select copy/paste confirmation gate to check the
+    total size of a batch in a single call instead of once per item.
+
+    Outputs JSON with keys: total_size, error.
+    """
+    from projspec.filebrowser import total_size
+
+    so = json.loads(storage_options) if storage_options.strip() else None
+    # NB: do not call `list(urls)` here — this module defines a click
+    # command named `list` (see `library list`) which shadows the builtin.
+    # `urls` (a tuple from nargs=-1) is already a fine iterable for total_size().
+    print(json.dumps(total_size(urls, storage_options=so)))
+
+
 @filebrowser.command("mkdir")
 @click.argument("url")
 @click.option("--storage-options", default="", help="fsspec storage options as JSON")

src/projspec/config.py

@@ -46,6 +46,7 @@ def defaults():
         "data_min_play_size": 1,  # 64 * 1024,
         "data_consolidate_min_group": 3,
         "data_inspect_max_datasets": 50,
+        "filebrowser_copy_confirm_bytes": 256 * 1024 * 1024,  # 256 MB
         "excludes": [
             "bld",
             "build",
@@ -108,6 +109,11 @@ def defaults():
         "do not run intake inspection if more than this many distinct datasets "
         "are found in a directory (avoids huge scans)."
     ),
+    "filebrowser_copy_confirm_bytes": (
+        "in the file browser UI, ask for confirmation before copying/pasting "
+        "a file or directory tree whose total size (bytes) exceeds this "
+        "value. Default is 256 MB."
+    ),
     "excludes": (
         "directory names to skip when walking a project tree for child projects "
         "and file statistics. Directories whose names start with '.' or '_' are "