refactor: process lock file storage path

- On Windows
  - Portable mode: it stores in `data/process.lock`
  - Non-portable mode: it stores in `%APPDATA%/SourceGit/process.lock`
- On macOS, it stores in `~/Library/Application Support/SourceGit/process.lock`
- On Linux
  - Portable mode: it stores in `data/process.lock`
  - Non-portable mode: it stores in `$XDG_RUNTIME_DIR/sourcegit.instance.lock`

Signed-off-by: leo <longshuang@msn.cn>

Author: love-linger

src/Models/IpcChannel.cs

@@ -10,16 +10,52 @@ namespace SourceGit.Models
 {
     public class IpcChannel : IDisposable
     {
-        public bool IsFirstInstance { get; }
+        public bool IsFirstInstance { get; private set; }
 
         public event Action<string> MessageReceived;
 
         public IpcChannel()
         {
-            try
+            IsFirstInstance = false;
+
+            var lockFile = GetLockFilePath();
+            if (OperatingSystem.IsLinux() && lockFile.NeedChangePermissions)
+            {
+                // On Linux, if the lock file is created in the XDG_RUNTIME_DIR, we need to set the permissions to 700 (rwx------) to ensure that only the current user can access it.
+                try
+                {
+                    _singletonLock = new FileStream(lockFile.Path, FileMode.CreateNew, FileAccess.ReadWrite, FileShare.None);
+                    File.SetUnixFileMode(lockFile.Path, File.GetUnixFileMode(lockFile.Path) | UnixFileMode.StickyBit);
+                    IsFirstInstance = true;
+                }
+                catch
+                {
+                    try
+                    {
+                        _singletonLock = new FileStream(lockFile.Path, FileMode.Open, FileAccess.ReadWrite, FileShare.None);
+                        IsFirstInstance = true;
+                    }
+                    catch
+                    {
+                        // Just ignore the exception and assume that another instance is running.
+                    }
+                }
+            }
+            else
+            {
+                try
+                {
+                    _singletonLock = File.Open(lockFile.Path, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
+                    IsFirstInstance = true;
+                }
+                catch
+                {
+                    // Just ignore the exception and assume that another instance is running.
+                }
+            }
+
+            if (IsFirstInstance)
             {
-                _singletonLock = File.Open(Path.Combine(Native.OS.BasicDirectories.CacheDir, "process.lock"), FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None);
-                IsFirstInstance = true;
                 _server = new NamedPipeServerStream(
                     GetPipeName(),
                     PipeDirection.In,
@@ -29,10 +65,6 @@ public IpcChannel()
                 _cancellationTokenSource = new CancellationTokenSource();
                 Task.Run(StartServer);
             }
-            catch
-            {
-                IsFirstInstance = false;
-            }
         }
 
         public void SendToFirstInstance(string cmd)
@@ -69,7 +101,30 @@ public void Dispose()
             _singletonLock?.Dispose();
         }
 
-        private static string GetPipeName()
+        private LockFile GetLockFilePath()
+        {
+            // On Windows and macOS, we can use the cache directory for the lock file.
+            if (!OperatingSystem.IsLinux())
+                return new LockFile(Path.Combine(Native.OS.BasicDirectories.CacheDir, "process.lock"), false);
+
+            // On Linux, we should first check if the app is running in portable mode.
+            var appImage = Environment.GetEnvironmentVariable("APPIMAGE");
+            if (!string.IsNullOrEmpty(appImage) && File.Exists(appImage))
+            {
+                var portableDir = Path.Combine(Path.GetDirectoryName(appImage)!, "data");
+                if (Directory.Exists(portableDir))
+                    return new LockFile(Path.Combine(portableDir, "process.lock"), false);
+            }
+
+            // If not in portable mode, we should use the XDG_RUNTIME_DIR environment variable for the lock file.
+            var runtimeDir = Environment.GetEnvironmentVariable("XDG_RUNTIME_DIR");
+            if (string.IsNullOrEmpty(runtimeDir) || !Directory.Exists(runtimeDir))
+                return new LockFile(Path.Combine(Native.OS.BasicDirectories.CacheDir, "process.lock"), false);
+
+            return new LockFile(Path.Combine(runtimeDir, "sourcegit.instance.lock"), true);
+        }
+
+        private string GetPipeName()
         {
             // SourceGit does not support multiple instances on macOS, so we can use a fixed pipe name for macOS.
             if (OperatingSystem.IsMacOS())
@@ -108,6 +163,8 @@ private async void StartServer()
             }
         }
 
+        private record LockFile(string Path, bool NeedChangePermissions);
+
         private FileStream _singletonLock = null;
         private NamedPipeServerStream _server = null;
         private CancellationTokenSource _cancellationTokenSource = null;