Add flow-launcher:// deep link protocol, .flowplugin file association, and --query command line argument

Flow.Launcher.Core/Plugin/PluginInstaller.cs

@@ -148,6 +148,51 @@ public static async Task InstallPluginAndCheckRestartAsync(string filePath)
         await InstallPluginAndCheckRestartAsync(plugin);
     }
 
+    /// <summary>
+    /// Installs a plugin from a direct zip download URL and restarts the application if required by settings.
+    /// Applies the unknown source warning and prompts user for confirmation before installing.
+    /// </summary>
+    /// <param name="url">The https URL of the plugin zip file.</param>
+    /// <returns>A Task representing the asynchronous install operation.</returns>
+    public static async Task InstallPluginFromWebAndCheckRestartAsync(string url)
+    {
+        // Derive the filename from the URI path so query strings (e.g. plugin.zip?token=x) don't end up
+        // as part of a temp filename, which is invalid on Windows. Fall back to the naive split if the
+        // URL somehow fails to parse as a URI (callers already validate https, this is defense in depth).
+        // uri.LocalPath is percent-decoded, so it can still contain characters that are invalid in
+        // Windows filenames (e.g. a literal "?" from an encoded "%3F"); strip those out.
+        var filename = Uri.TryCreate(url, UriKind.Absolute, out var uri)
+            ? Path.GetFileName(uri.LocalPath)
+            : url.Split('/').Last();
+        foreach (var c in Path.GetInvalidFileNameChars())
+        {
+            filename = filename.Replace(c.ToString(), string.Empty);
+        }
+        var name = filename.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)
+            ? filename[..^".zip".Length]
+            : filename;
+
+        var plugin = new UserPlugin
+        {
+            ID = string.Empty,
+            Name = name,
+            Version = string.Empty,
+            Author = Localize.UnknownPluginAuthor(),
+            UrlDownload = url
+        };
+
+        if (Settings.ShowUnknownSourceWarning)
+        {
+            if (!InstallSourceKnown(url)
+                && PublicApi.Instance.ShowMsgBox(Localize.InstallFromUnknownSourceSubtitle(Environment.NewLine),
+                    Localize.InstallFromUnknownSourceTitle(),
+                    MessageBoxButton.YesNo) == MessageBoxResult.No)
+                return;
+        }
+
+        await InstallPluginAndCheckRestartAsync(plugin);
+    }
+
     /// <summary>
     /// Uninstalls a plugin and restarts the application if required by settings. Prompts user for confirmation and whether to keep plugin settings.
     /// </summary>

Flow.Launcher.Infrastructure/UserSettings/Settings.cs

@@ -266,6 +266,7 @@ public bool ShowHistoryResultsForHomePage
 
         public bool AutoRestartAfterChanging { get; set; } = false;
         public bool ShowUnknownSourceWarning { get; set; } = true;
+        public bool EnableDeepLinkProtocol { get; set; } = true;
         public bool AutoUpdatePlugins { get; set; } = true;
 
         public int CustomExplorerIndex { get; set; } = 0;

Flow.Launcher.Test/DeepLinkTest.cs

@@ -0,0 +1,90 @@
+using System;
+using Flow.Launcher.Helper;
+using NUnit.Framework;
+
+namespace Flow.Launcher.Test
+{
+    [TestFixture]
+    public class DeepLinkTest
+    {
+        [Test]
+        public void FromCommandLineArgs_QueryFlag_NormalizesToQueryUri()
+        {
+            var result = DeepLink.FromCommandLineArgs(new[] { "--query", "foo bar" }, true);
+            Assert.That(result, Is.EqualTo("flow-launcher://query?q=foo%20bar"));
+        }
+
+        [Test]
+        public void FromCommandLineArgs_SingleDashQueryFlag_NormalizesToQueryUri()
+        {
+            var result = DeepLink.FromCommandLineArgs(new[] { "-q", "foo" }, true);
+            Assert.That(result, Is.EqualTo("flow-launcher://query?q=foo"));
+        }
+
+        [Test]
+        public void FromCommandLineArgs_FlowPluginPath_NormalizesToInstallUri()
+        {
+            var path = OperatingSystem.IsWindows() ? @"C:\tmp\My Plugin.flowplugin" : "/tmp/My Plugin.flowplugin";
+            var result = DeepLink.FromCommandLineArgs(new[] { path }, true);
+            Assert.That(result, Does.StartWith("flow-launcher://plugin/install?path="));
+            Assert.That(Uri.UnescapeDataString(result.Split("path=")[1]), Does.EndWith("My Plugin.flowplugin"));
+        }
+
+        [Test]
+        public void FromCommandLineArgs_RawSchemeUri_PassedThroughWhenAllowed()
+        {
+            var result = DeepLink.FromCommandLineArgs(new[] { "flow-launcher://settings" }, true);
+            Assert.That(result, Is.EqualTo("flow-launcher://settings"));
+        }
+
+        [Test]
+        public void FromCommandLineArgs_RawSchemeUri_DroppedWhenDisallowed()
+        {
+            var result = DeepLink.FromCommandLineArgs(new[] { "flow-launcher://settings" }, false);
+            Assert.That(result, Is.Null);
+        }
+
+        [Test]
+        public void FromCommandLineArgs_FlowPluginPath_StillWorksWhenSchemeDisallowed()
+        {
+            var result = DeepLink.FromCommandLineArgs(new[] { "plugin.flowplugin" }, false);
+            Assert.That(result, Does.StartWith("flow-launcher://plugin/install?path="));
+        }
+
+        [Test]
+        public void FromCommandLineArgs_NoRelevantArgs_ReturnsNull()
+        {
+            Assert.That(DeepLink.FromCommandLineArgs(Array.Empty<string>(), true), Is.Null);
+            Assert.That(DeepLink.FromCommandLineArgs(new[] { "--unrelated" }, true), Is.Null);
+            Assert.That(DeepLink.FromCommandLineArgs(new[] { "--query" }, true), Is.Null); // flag without value
+        }
+
+        [Test]
+        public void FromCommandLineArgs_QueryFlagWithEmptyValue_ReturnsNull()
+        {
+            Assert.That(DeepLink.FromCommandLineArgs(new[] { "--query", "" }, true), Is.Null);
+            Assert.That(DeepLink.FromCommandLineArgs(new[] { "-q", "" }, true), Is.Null);
+        }
+
+        [TestCase("flow-launcher://query?q=hello%20world", "query", "q", "hello world")]
+        [TestCase("flow-launcher://plugin/install?id=abc123", "plugin/install", "id", "abc123")]
+        [TestCase("FLOW-LAUNCHER://SETTINGS", "settings", null, null)]
+        public void TryParse_ValidUris_ExtractsVerbAndParameters(string payload, string expectedVerb, string paramKey, string paramValue)
+        {
+            var ok = DeepLink.TryParse(payload, out var verb, out var parameters);
+            Assert.That(ok, Is.True);
+            Assert.That(verb, Is.EqualTo(expectedVerb));
+            if (paramKey != null)
+                Assert.That(parameters[paramKey], Is.EqualTo(paramValue));
+        }
+
+        [TestCase(null)]
+        [TestCase("")]
+        [TestCase("just a plain query string")]
+        [TestCase("https://example.com/notourscheme")]
+        public void TryParse_InvalidPayloads_ReturnsFalse(string payload)
+        {
+            Assert.That(DeepLink.TryParse(payload, out _, out _), Is.False);
+        }
+    }
+}

Flow.Launcher/App.xaml.cs

@@ -44,6 +44,7 @@ public partial class App : IDisposable, ISingleInstanceApp
 
         private static bool _disposed;
         private static Settings _settings;
+        private static string _pendingDeepLink;
         private static MainWindow _mainWindow;
         private readonly MainViewModel _mainVM;
         private readonly Internationalization _internationalization;
@@ -126,7 +127,7 @@ public App()
         #region Main
 
         [STAThread]
-        public static void Main()
+        public static void Main(string[] args)
         {
             // Initialize settings so that we can get language code
             try
@@ -151,8 +152,10 @@ public static void Main()
             }
 
             // Start the application as a single instance
-            if (SingleInstance<App>.InitializeAsFirstInstance())
+            var deepLink = DeepLink.FromCommandLineArgs(args, _settings.EnableDeepLinkProtocol);
+            if (SingleInstance<App>.InitializeAsFirstInstance(deepLink))
             {
+                _pendingDeepLink = deepLink;
                 using var application = new App();
                 application.InitializeComponent();
                 application.Run();
@@ -243,6 +246,8 @@ await API.StopwatchLogInfoAsync(ClassName, "Startup cost", async () =>
 
                 RegisterExitEvents();
 
+                DeepLinkRegistration.EnsureRegistered(_settings.EnableDeepLinkProtocol);
+
                 AutoStartup();
                 AutoUpdates();
 
@@ -262,6 +267,13 @@ await API.StopwatchLogInfoAsync(ClassName, "Startup cost", async () =>
                     // Refresh the history results after plugins are initialized so that we can parse the absolute icon paths
                     _mainVM.RefreshLastOpenedHistoryResults();
 
+                    // Dispatch the deep link passed on the command line now that plugins can answer it
+                    if (!string.IsNullOrEmpty(_pendingDeepLink))
+                    {
+                        DeepLink.Dispatch(_pendingDeepLink);
+                        _pendingDeepLink = null;
+                    }
+
                     // Refresh home page after plugins are initialized because users may open main window during plugin initialization
                     // And home page is created without full plugin list
                     if (_settings.ShowHomePage && _mainVM.QueryResultsSelected() && string.IsNullOrEmpty(_mainVM.QueryText))
@@ -465,9 +477,15 @@ public void Dispose()
 
         #region ISingleInstanceApp
 
-        public void OnSecondAppStarted()
+        public void OnSecondAppStarted(string payload)
         {
-            API.ShowMainWindow();
+            if (string.IsNullOrEmpty(payload))
+            {
+                API.ShowMainWindow();
+                return;
+            }
+
+            DeepLink.Dispatch(payload);
         }
 
         #endregion