Fix startup task enabled detection (#326)

Co-authored-by: Owen McGirr <o.a.mcgirr@gmail.com>

Author: enaboapps

src/SwitchifyPc.Tests/SystemStartupServiceTests.cs

@@ -59,6 +59,22 @@ public async Task ReportsEnabledOnlyForHealthyScheduledTask()
         Assert.Equal(["--start-hidden"], settings.TaskRegistration?.RegisteredArguments);
     }
 
+    [Fact]
+    public async Task ReportsEnabledForHealthyTaskWhenWindowsXmlOmitsEnabled()
+    {
+        StartupTaskSnapshot taskParsedFromWindowsXml = new(
+            Exists: true,
+            Enabled: true,
+            ExecutablePath: ExecutablePath,
+            Arguments: ["--start-hidden"],
+            LastRunResult: "0");
+
+        SystemStartupSettings settings = await CreateService(new FakeStartupTask(taskParsedFromWindowsXml), new FakeStartupRegistry()).GetSettingsAsync();
+
+        Assert.True(settings.StartWithSystem);
+        Assert.True(settings.TaskRegistration?.Enabled);
+    }
+
     [Fact]
     public async Task ReportsDisabledForMissingDisabledStalePathOrStaleArguments()
     {

src/SwitchifyPc.Tests/WindowsStartupTaskTests.cs

@@ -74,6 +74,81 @@ public void ParsesEnabledScheduledTaskXml()
         Assert.Equal("0", snapshot.LastRunResult);
     }
 
+    [Fact]
+    public void ParsesEnabledStateFromVerboseTaskOutput()
+    {
+        string output = """
+        TaskName: \Switchify PC
+        Scheduled Task State: Enabled
+        Last Result: 0
+        """;
+
+        StartupTaskQueryDetails details = WindowsStartupTask.ParseTaskDetails(output);
+
+        Assert.True(details.Enabled);
+        Assert.Equal("0", details.LastRunResult);
+    }
+
+    [Fact]
+    public void ParsesDisabledStateFromVerboseTaskOutput()
+    {
+        string output = """
+        TaskName: \Switchify PC
+        Scheduled Task State: Disabled
+        Last Result: 1
+        """;
+
+        StartupTaskQueryDetails details = WindowsStartupTask.ParseTaskDetails(output);
+
+        Assert.False(details.Enabled);
+        Assert.Equal("1", details.LastRunResult);
+    }
+
+    [Fact]
+    public void TreatsMissingXmlEnabledAsEnabled()
+    {
+        StartupTaskSnapshot snapshot = WindowsStartupTask.ParseTaskXml(TaskXmlWithoutEnabled());
+
+        Assert.True(snapshot.Enabled);
+        Assert.Equal("C:\\Program Files\\Switchify PC\\Switchify PC.exe", snapshot.ExecutablePath);
+        Assert.Equal(["--start-hidden"], snapshot.Arguments);
+    }
+
+    [Fact]
+    public void VerboseDisabledStateOverridesMissingXmlEnabled()
+    {
+        StartupTaskSnapshot snapshot = WindowsStartupTask.ParseTaskXml(TaskXmlWithoutEnabled(), enabledOverride: false);
+
+        Assert.False(snapshot.Enabled);
+    }
+
+    [Fact]
+    public async Task GetAsyncUsesVerboseEnabledStateWhenXmlOmitsEnabled()
+    {
+        WindowsStartupTask task = new((_, args) =>
+        {
+            if (args.Contains("/XML"))
+            {
+                return Task.FromResult(new CommandResult(TaskXmlWithoutEnabled(), ""));
+            }
+
+            return Task.FromResult(new CommandResult(
+                """
+                TaskName: \Switchify PC
+                Scheduled Task State: Enabled
+                Last Result: 0
+                """,
+                ""));
+        });
+
+        StartupTaskSnapshot snapshot = await task.GetAsync("Switchify PC");
+
+        Assert.True(snapshot.Enabled);
+        Assert.Equal("C:\\Program Files\\Switchify PC\\Switchify PC.exe", snapshot.ExecutablePath);
+        Assert.Equal(["--start-hidden"], snapshot.Arguments);
+        Assert.Equal("0", snapshot.LastRunResult);
+    }
+
     [Fact]
     public void ParsesDisabledScheduledTaskXml()
     {
@@ -146,4 +221,21 @@ private static string TaskXml(bool enabled)
         </Task>
         """;
     }
+
+    private static string TaskXmlWithoutEnabled()
+    {
+        return """
+        <Task xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+          <Settings>
+            <DisallowStartIfOnBatteries>true</DisallowStartIfOnBatteries>
+          </Settings>
+          <Actions>
+            <Exec>
+              <Command>"C:\Program Files\Switchify PC\Switchify PC.exe"</Command>
+              <Arguments>--start-hidden</Arguments>
+            </Exec>
+          </Actions>
+        </Task>
+        """;
+    }
 }

src/SwitchifyPc.Windows/Startup/WindowsStartupTask.cs

@@ -3,6 +3,10 @@
 
 namespace SwitchifyPc.Windows.Startup;
 
+public sealed record StartupTaskQueryDetails(
+    string? LastRunResult,
+    bool? Enabled);
+
 public sealed class WindowsStartupTask : IStartupTask
 {
     public const string StartupTaskName = "Switchify PC";
@@ -19,22 +23,21 @@ public WindowsStartupTask(CommandRunner? commandRunner = null, Action<string>? w
 
     public async Task<StartupTaskSnapshot> GetAsync(string taskName)
     {
-        string? lastRunResult = await QueryLastRunResultAsync(taskName);
+        StartupTaskQueryDetails details = await QueryTaskDetailsAsync(taskName);
 
         try
         {
             CommandResult result = await commandRunner("schtasks.exe", ["/Query", "/TN", taskName, "/XML"]);
-            StartupTaskSnapshot snapshot = ParseTaskXml(result.Stdout, lastRunResult);
-            return snapshot with { LastRunResult = lastRunResult };
+            return ParseTaskXml(result.Stdout, details.LastRunResult, details.Enabled);
         }
         catch (Exception error) when (IsMissingTaskError(error))
         {
-            return new StartupTaskSnapshot(false, false, null, [], lastRunResult);
+            return new StartupTaskSnapshot(false, false, null, [], details.LastRunResult);
         }
         catch (Exception error) when (error is System.Xml.XmlException or InvalidOperationException)
         {
             warn("Switchify startup task could not be read.");
-            return new StartupTaskSnapshot(true, false, null, [], lastRunResult);
+            return new StartupTaskSnapshot(true, false, null, [], details.LastRunResult);
         }
     }
 
@@ -81,7 +84,7 @@ public static string StartupCommandFor(string executablePath, IReadOnlyList<stri
         return string.Join(" ", new[] { $"\"{executablePath}\"" }.Concat(args));
     }
 
-    public static StartupTaskSnapshot ParseTaskXml(string xml, string? lastRunResult = null)
+    public static StartupTaskSnapshot ParseTaskXml(string xml, string? lastRunResult = null, bool? enabledOverride = null)
     {
         XDocument document = XDocument.Parse(xml);
         XElement root = document.Root ?? throw new InvalidOperationException("Task XML is empty.");
@@ -95,41 +98,64 @@ public static StartupTaskSnapshot ParseTaskXml(string xml, string? lastRunResult
             command = splitCommand;
             arguments = splitArguments;
         }
+        else
+        {
+            command = UnquoteCommand(command);
+        }
 
         return new StartupTaskSnapshot(
             Exists: true,
-            Enabled: string.Equals(enabledText, "true", StringComparison.OrdinalIgnoreCase),
+            Enabled: enabledOverride ?? (enabledText is null || string.Equals(enabledText, "true", StringComparison.OrdinalIgnoreCase)),
             ExecutablePath: string.IsNullOrWhiteSpace(command) ? null : command,
             Arguments: arguments,
             LastRunResult: lastRunResult);
     }
 
     public static string? ParseLastRunResult(string output)
     {
+        return ParseTaskDetails(output).LastRunResult;
+    }
+
+    public static StartupTaskQueryDetails ParseTaskDetails(string output)
+    {
+        string? lastRunResult = null;
+        bool? enabled = null;
+
         foreach (string line in output.Split(["\r\n", "\n"], StringSplitOptions.RemoveEmptyEntries))
         {
             int separator = line.IndexOf(':', StringComparison.Ordinal);
             if (separator <= 0) continue;
 
             string key = line[..separator].Trim();
-            if (!key.Equals("Last Result", StringComparison.OrdinalIgnoreCase)) continue;
-
-            return line[(separator + 1)..].Trim();
+            string value = line[(separator + 1)..].Trim();
+            if (key.Equals("Last Result", StringComparison.OrdinalIgnoreCase))
+            {
+                lastRunResult = value;
+            }
+            else if (key.Equals("Scheduled Task State", StringComparison.OrdinalIgnoreCase))
+            {
+                enabled = value switch
+                {
+                    _ when value.Equals("Enabled", StringComparison.OrdinalIgnoreCase) => true,
+                    _ when value.Equals("Disabled", StringComparison.OrdinalIgnoreCase) => false,
+                    _ => enabled
+                };
+            }
         }
 
-        return null;
+        return new StartupTaskQueryDetails(lastRunResult, enabled);
     }
 
-    private async Task<string?> QueryLastRunResultAsync(string taskName)
+    private async Task<StartupTaskQueryDetails> QueryTaskDetailsAsync(string taskName)
     {
         try
         {
             CommandResult result = await commandRunner("schtasks.exe", ["/Query", "/TN", taskName, "/FO", "LIST", "/V"]);
-            return ParseLastRunResult(result.Stdout);
+            return ParseTaskDetails(result.Stdout);
         }
         catch
         {
-            return null;
+            return new StartupTaskQueryDetails(null, null);
         }
     }
 
@@ -169,6 +195,14 @@ private static bool TrySplitCombinedCommand(string? command, out string? executa
         return true;
     }
 
+    private static string? UnquoteCommand(string? command)
+    {
+        if (string.IsNullOrWhiteSpace(command)) return command;
+        return command.Length >= 2 && command.StartsWith('"') && command.EndsWith('"')
+            ? command[1..^1]
+            : command;
+    }
+
     private static bool IsMissingTaskError(Exception error)
     {
         string output = error.Message.ToLowerInvariant();