цель-исполняемый: перетаскивание файлов запускает exe/скрипт (open with)

Если цель — исполняемый или скрипт (.exe/.com/.bat/.cmd/.ps1/.py/.pyw/.vbs/
.wsf/.js/.jar), то дроп файлов на её плитку запускает её с этими файлами как
аргументами (поведение Windows «open with»), а не копирует. Ярлык .lnk
резолвится в настоящую цель (с кешем). Скрипты, которые shell-open открыл бы в
редакторе (.ps1/.py/.jar), запускаются через интерпретатор (powershell/py/java).
Drag-over показывает бейдж ▶ и эффект-ссылку. Undo нет (это запуск). Тесты xUnit.

Author: IvanLarinDev

src/Dropwheel/Models/TargetItem.cs

@@ -27,8 +27,20 @@ public class TargetItem
     [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
     public List<SortRule>? Rules { get; set; }
 
+    /// <summary>Extensions treated as "drop files to run it with them as arguments" targets.</summary>
+    public static readonly string[] ExeExtensions =
+        { ".exe", ".com", ".bat", ".cmd", ".ps1", ".py", ".pyw", ".vbs", ".wsf", ".js", ".jar" };
+
+    public static bool IsExeExtension(string path) =>
+        ExeExtensions.Contains(System.IO.Path.GetExtension(path).ToLowerInvariant());
+
     [JsonIgnore] public bool IsGroup => Children != null;
     [JsonIgnore] public bool IsSorter => SortRules is { Count: > 0 } || Rules is { Count: > 0 };
     [JsonIgnore] public bool IsFolder => !IsGroup && Directory.Exists(Path);
+
+    /// <summary>An executable or script by its own extension. A .lnk that points at an executable
+    /// is handled by LaunchService.IsRunTarget, which resolves the shortcut first.</summary>
+    [JsonIgnore] public bool IsExecutable => !IsGroup && IsExeExtension(Path);
+
     [JsonIgnore] public bool Exists => IsGroup || IsFolder || File.Exists(Path);
 }

src/Dropwheel/Services/LaunchService.cs

@@ -1,10 +1,29 @@
 using System.Diagnostics;
+using System.IO;
 using Dropwheel.Models;
 
 namespace Dropwheel.Services;
 
 public static class LaunchService
 {
+    private static readonly Dictionary<string, string> LnkCache = new(StringComparer.OrdinalIgnoreCase);
+
+    /// <summary>The path a target really points at: a .lnk is resolved to its target (cached to
+    /// avoid repeated COM calls during drag-over), anything else is returned unchanged.</summary>
+    private static string EffectivePath(string path)
+    {
+        if (!path.EndsWith(".lnk", StringComparison.OrdinalIgnoreCase)) return path;
+        if (LnkCache.TryGetValue(path, out var cached)) return cached;
+        var resolved = ShortcutResolver.Resolve(path);
+        LnkCache[path] = resolved;
+        return resolved;
+    }
+
+    /// <summary>Whether dropping files on this target should run it with them as arguments —
+    /// true for executable/script targets, including a .lnk that points at one.</summary>
+    public static bool IsRunTarget(TargetItem t) =>
+        !t.IsGroup && TargetItem.IsExeExtension(EffectivePath(t.Path));
+
     public static void Launch(TargetItem t)
     {
         try
@@ -17,6 +36,30 @@ public static void Launch(TargetItem t)
         catch { /* target may no longer exist — ignore */ }
     }
 
+    /// <summary>Quotes each dropped path and joins them for use as command-line arguments.</summary>
+    public static string BuildArgs(IEnumerable<string> files) =>
+        string.Join(" ", files.Select(f => $"\"{f}\""));
+
+    /// <summary>Runs an executable or script target with the dropped files as arguments — the
+    /// Windows "open with" behaviour. Scripts that the shell would open in an editor (.ps1/.py/.jar)
+    /// are launched through their interpreter so they actually run. Returns whether it started.</summary>
+    public static bool LaunchWith(TargetItem t, IReadOnlyList<string> files)
+    {
+        var exe = EffectivePath(t.Path);
+        var args = BuildArgs(files);
+        var psi = Path.GetExtension(exe).ToLowerInvariant() switch
+        {
+            ".ps1" => new ProcessStartInfo("powershell.exe",
+                $"-NoProfile -ExecutionPolicy Bypass -File \"{exe}\" {args}"),
+            ".py" or ".pyw" => new ProcessStartInfo("py", $"\"{exe}\" {args}"),
+            ".jar" => new ProcessStartInfo("java", $"-jar \"{exe}\" {args}"),
+            _ => new ProcessStartInfo(exe) { Arguments = args, UseShellExecute = true },
+        };
+        psi.WorkingDirectory = Path.GetDirectoryName(exe) ?? "";
+        try { Process.Start(psi); return true; }
+        catch { return false; }
+    }
+
     public static void OpenConfigFolder() =>
         Process.Start(new ProcessStartInfo("explorer.exe", $"\"{TargetStore.Dir}\""));
 }

src/Dropwheel/UI/OverlayWindow.Dnd.cs

@@ -22,6 +22,16 @@ private void OnBubbleDragOver(TargetItem t, Border badge, DragEventArgs e)
         bool real = e.Data.GetDataPresent(DataFormats.FileDrop);
         bool virt = !real && VirtualFileService.HasVirtualFiles(e.Data);
         bool text = !real && !virt && TextDropService.HasText(e.Data);
+
+        if (real && LaunchService.IsRunTarget(t)) // drop files on an exe/script → run it (open with)
+        {
+            e.Effects = DragDropEffects.Link;
+            ((TextBlock)badge.Child).Text = "▶";
+            badge.Background = Brushes.CornflowerBlue;
+            badge.Visibility = Visibility.Visible;
+            e.Handled = true;
+            return;
+        }
         if ((!real && !virt && !text) || !t.IsFolder)
         { e.Effects = DragDropEffects.None; e.Handled = true; return; }
 
@@ -45,6 +55,16 @@ private void OnBubbleDrop(TargetItem t, Border badge, DragEventArgs e)
                 e.Handled = true;
                 return;
             }
+            if (LaunchService.IsRunTarget(t))
+            {
+                bool launched = LaunchService.LaunchWith(t, files);
+                ShowToast(launched
+                    ? $"▶ Opened {files.Length} item(s) with {t.Name}"
+                    : "Could not launch");
+                CloseCloud();
+                e.Handled = true;
+                return;
+            }
             var act = Resolve(t, e);
             bool ok = FileOps.Execute(files, t.Path, act);
             if (ok) RememberOp(act, files, t.Path);

tests/Dropwheel.Tests/ExecutableTargetTests.cs

@@ -0,0 +1,46 @@
+using Dropwheel.Models;
+using Dropwheel.Services;
+
+namespace Dropwheel.Tests;
+
+/// <summary>Verifies executable-target detection and the "open with" argument building.</summary>
+public sealed class ExecutableTargetTests
+{
+    [Theory]
+    [InlineData("C:\\tools\\build.exe", true)]
+    [InlineData("C:\\tools\\run.BAT", true)]
+    [InlineData("C:\\tools\\task.cmd", true)]
+    [InlineData("C:\\tools\\legacy.com", true)]
+    [InlineData("C:\\tools\\script.ps1", true)]
+    [InlineData("C:\\tools\\tool.py", true)]
+    [InlineData("C:\\tools\\app.jar", true)]
+    [InlineData("C:\\tools\\notes.txt", false)]
+    [InlineData("C:\\tools\\image.png", false)]
+    [InlineData("C:\\tools\\link.lnk", false)]
+    [InlineData("C:\\Downloads", false)]
+    public void IsExecutable_matches_only_executables(string path, bool expected)
+    {
+        var t = new TargetItem { Name = "x", Path = path };
+        Assert.Equal(expected, t.IsExecutable);
+    }
+
+    [Fact]
+    public void Group_is_never_executable()
+    {
+        var t = new TargetItem { Name = "grp", Path = "C:\\x.exe", Children = new() };
+        Assert.False(t.IsExecutable);
+    }
+
+    [Fact]
+    public void BuildArgs_quotes_and_joins_paths()
+    {
+        var args = LaunchService.BuildArgs(new[] { @"C:\a b\file 1.txt", @"C:\c\file2.txt" });
+        Assert.Equal("\"C:\\a b\\file 1.txt\" \"C:\\c\\file2.txt\"", args);
+    }
+
+    [Fact]
+    public void BuildArgs_empty_is_empty()
+    {
+        Assert.Equal("", LaunchService.BuildArgs(Array.Empty<string>()));
+    }
+}