Fix KeeShare code issues and add KeePassXC format support

This commit addresses reviewer feedback from PR PhilippC#3106:

**Error Handling**
- Fix Import method to rethrow exceptions instead of silently swallowing them
- Allows proper error propagation and user notification via outer exception handlers

**Path Resolution**
- Refactor ResolvePath to use IFileStorage methods consistently for both local and remote files
- Removes System.IO.Path usage in favor of abstraction layer
- Ensures all file operations go through proper storage backends

**LoadDB Handler Logic**
- Add clarifying comment to WrapHandlerForKeeShare explaining that OnLoadCompleteKeeShareCheck
  runs in both null and non-null handler cases
- Addresses maintainer question about intentionality of the null check

**KeePassXC Interoperability**
- Add HasKeePassXCFormat() to detect groups created in KeePassXC
- Add TryImportKeePassXCConfig() to import KeePassXC's KeeShare configuration
- Support multiple KeePassXC CustomData formats:
  * KeeShareReference.Path/Type/Password
  * KPXC_KeeShare_Path/Type/Password
  * Legacy KeeShare XML format
- Integrate detection into HasKeeShareGroups() for automatic import
- Maintains backward compatibility with KP2A format
- Allows device-specific path overrides using existing KP2A mechanism

**Notes**
- Status logging already implemented (line 482: "Exporting KeeShare database group")
- Build workflow already includes dotnet workload restore (lines 312-314, 322)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: beveradb

src/Kp2aBusinessLogic/database/edit/LoadDB.cs

@@ -68,6 +68,10 @@ public LoadDb(IKp2aApp app, IOConnectionInfo ioc, Task<MemoryStream> databaseDat
 
     private static OnOperationFinishedHandler WrapHandlerForKeeShare(IKp2aApp app, OnOperationFinishedHandler originalHandler)
     {
+      // Note: OnLoadCompleteKeeShareCheck runs in BOTH cases below (null or not null)
+      // The null check is just to handle the two scenarios differently:
+      // - If null: create a simple handler that only runs KeeShare check
+      // - If not null: wrap the existing handler to run KeeShare check before it
       if (originalHandler == null)
       {
         return new ActionOnOperationFinished(app, (success, message, importantMessage, exception, context) =>

src/keepass2android-app/KeeShare.cs

@@ -187,13 +187,126 @@ public static void DisableKeeShare(PwGroup group)
             group.CustomData.Remove(FilePathKey);
             group.CustomData.Remove(PasswordKey);
             group.CustomData.Remove("KeeShare.TrustedCertificate");
-            
+
             string deviceKey = GetDeviceFilePathKey();
             group.CustomData.Remove(deviceKey);
-            
+
             group.Touch(true, false);
         }
 
+        /// <summary>
+        /// Checks if a group has KeePassXC-style KeeShare configuration.
+        /// KeePassXC stores share info in CustomData with keys like "KeeShareReference.Path", etc.
+        /// </summary>
+        public static bool HasKeePassXCFormat(PwGroup group)
+        {
+            if (group == null) return false;
+
+            // Check for KeePassXC's CustomData keys
+            return group.CustomData.Exists("KeeShareReference.Path") ||
+                   group.CustomData.Exists("KPXC_KeeShare_Path") ||
+                   (group.CustomData.Exists("KeeShare") &&
+                    !group.CustomData.Exists(ActiveKey)); // Has old KeeShare key but not our format
+        }
+
+        /// <summary>
+        /// Attempts to import KeePassXC KeeShare configuration into KP2A format.
+        /// This allows groups created in KeePassXC to work in KP2A.
+        /// Does NOT overwrite existing KP2A configuration.
+        /// </summary>
+        public static bool TryImportKeePassXCConfig(PwGroup group)
+        {
+            if (group == null || !HasKeePassXCFormat(group)) return false;
+
+            // Don't overwrite existing KP2A configuration
+            if (group.CustomData.Exists(ActiveKey)) return false;
+
+            try
+            {
+                string path = null;
+                string type = "Synchronize"; // KeePassXC default
+                string password = null;
+
+                // Try to extract path from various KeePassXC formats
+                if (group.CustomData.Exists("KeeShareReference.Path"))
+                {
+                    path = group.CustomData.Get("KeeShareReference.Path");
+                }
+                else if (group.CustomData.Exists("KPXC_KeeShare_Path"))
+                {
+                    path = group.CustomData.Get("KPXC_KeeShare_Path");
+                }
+                else if (group.CustomData.Exists("KeeShare"))
+                {
+                    // Try to parse XML or structured format
+                    string data = group.CustomData.Get("KeeShare");
+                    // Simple heuristic: look for path= pattern
+                    int pathIdx = data.IndexOf("path=", StringComparison.OrdinalIgnoreCase);
+                    if (pathIdx >= 0)
+                    {
+                        pathIdx += 5; // skip "path="
+                        if (pathIdx < data.Length)
+                        {
+                            char quote = data[pathIdx];
+                            if (quote == '"' || quote == '\'')
+                            {
+                                pathIdx++;
+                                int endIdx = data.IndexOf(quote, pathIdx);
+                                if (endIdx > pathIdx)
+                                {
+                                    path = data.Substring(pathIdx, endIdx - pathIdx);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Try to extract type
+                if (group.CustomData.Exists("KeeShareReference.Type"))
+                {
+                    string xtype = group.CustomData.Get("KeeShareReference.Type");
+                    // Map KeePassXC types to KP2A types
+                    if (xtype.Equals("Export", StringComparison.OrdinalIgnoreCase))
+                        type = "Export";
+                    else if (xtype.Equals("Import", StringComparison.OrdinalIgnoreCase))
+                        type = "Import";
+                    else if (xtype.Equals("Sync", StringComparison.OrdinalIgnoreCase) ||
+                             xtype.Equals("Synchronize", StringComparison.OrdinalIgnoreCase))
+                        type = "Synchronize";
+                }
+                else if (group.CustomData.Exists("KPXC_KeeShare_Type"))
+                {
+                    string xtype = group.CustomData.Get("KPXC_KeeShare_Type");
+                    if (xtype.Equals("0")) type = "Export";
+                    else if (xtype.Equals("1")) type = "Import";
+                    else if (xtype.Equals("2")) type = "Synchronize";
+                }
+
+                // Try to extract password
+                if (group.CustomData.Exists("KeeShareReference.Password"))
+                {
+                    password = group.CustomData.Get("KeeShareReference.Password");
+                }
+                else if (group.CustomData.Exists("KPXC_KeeShare_Password"))
+                {
+                    password = group.CustomData.Get("KPXC_KeeShare_Password");
+                }
+
+                if (!string.IsNullOrEmpty(path))
+                {
+                    EnableKeeShare(group, type, path, password);
+                    Kp2aLog.Log("KeeShare: Successfully imported KeePassXC configuration for group " + group.Name);
+                    return true;
+                }
+            }
+            catch (Exception ex)
+            {
+                Kp2aLog.Log("KeeShare: Failed to import KeePassXC configuration: " + ex.Message);
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// Resolves a file path, handling relative paths for local files.
         /// Relative paths are resolved relative to the current database's directory.
@@ -228,30 +341,17 @@ internal static IOConnectionInfo ResolvePath(IKp2aApp app, string path)
                 return IOConnectionInfo.FromPath(path);
             }
 
-            if (currentIoc.IsLocalFile())
+            // Use IFileStorage methods for all paths (local and remote) for consistency
+            try
             {
-                string dir = Path.GetDirectoryName(currentIoc.Path);
-                if (string.IsNullOrEmpty(dir))
-                {
-                    Kp2aLog.Log("KeeShare: Cannot resolve relative path - database directory is empty. Using path as-is: " + path);
-                    return IOConnectionInfo.FromPath(path);
-                }
-                string fullPath = Path.Combine(dir, path);
-                return IOConnectionInfo.FromPath(fullPath);
+                var fileStorage = app.GetFileStorage(currentIoc);
+                IOConnectionInfo parentPath = fileStorage.GetParentPath(currentIoc);
+                return fileStorage.GetFilePath(parentPath, path);
             }
-            else
+            catch (Exception ex)
             {
-                try
-                {
-                    var fileStorage = app.GetFileStorage(currentIoc);
-                    IOConnectionInfo parentPath = fileStorage.GetParentPath(currentIoc);
-                    return fileStorage.GetFilePath(parentPath, path);
-                }
-                catch (Exception ex)
-                {
-                    Kp2aLog.Log("KeeShare: Failed to resolve relative path using IFileStorage methods: " + ex.Message + ". Using path as-is: " + path);
-                    return IOConnectionInfo.FromPath(path);
-                }
+                Kp2aLog.Log("KeeShare: Failed to resolve relative path using IFileStorage methods: " + ex.Message + ". Using path as-is: " + path);
+                return IOConnectionInfo.FromPath(path);
             }
         }
 
@@ -363,7 +463,16 @@ internal static bool HasKeeShareGroups(PwGroup group)
         {
             if (group.CustomData.Get(ActiveKey) == "true")
                 return true;
-            
+
+            // Check for KeePassXC format and try to import it
+            if (HasKeePassXCFormat(group))
+            {
+                TryImportKeePassXCConfig(group);
+                // After import attempt, check if we now have active KeeShare
+                if (group.CustomData.Get(ActiveKey) == "true")
+                    return true;
+            }
+
             foreach (var sub in group.Groups)
             {
                 if (HasKeeShareGroups(sub)) return true;
@@ -881,6 +990,7 @@ private void Import(PwGroup targetGroup, string path, string password, string ty
             catch (Exception ex)
             {
                 Kp2aLog.Log("KeeShare import failed for group " + targetGroup.Name + ": " + ex.Message);
+                throw;
             }
         }