LogonTaskRegistration: per-user scheduled task that auto-mounts at logon

Adds IScheduledTaskInvoker, SchTasksScheduledTaskInvoker, and
LogonTaskRegistration. Manages a per-user logon task that runs
gvfs.exe service --mount-all via conhost.exe --headless to prevent
console window flash. Drift detection via full SHA-256 hash marker.

21 new unit tests. 857/857 pass.

Assisted-by: Claude Opus 4.8
Signed-off-by: Tyrie Vella <tyrielv@gmail.com>

Author: tyrielv

GVFS/GVFS.Common/IScheduledTaskInvoker.cs

@@ -0,0 +1,37 @@
+using System.Collections.Generic;
+
+namespace GVFS.Common
+{
+    /// <summary>
+    /// Abstracts the Windows Task Scheduler operations needed by
+    /// <see cref="LogonTaskRegistration"/>. Production callers use
+    /// <see cref="SchTasksScheduledTaskInvoker"/>; tests pass a mock so
+    /// they can exercise <see cref="LogonTaskRegistration"/>'s logic
+    /// without actually touching the Task Scheduler on the test machine.
+    /// </summary>
+    public interface IScheduledTaskInvoker
+    {
+        /// <summary>
+        /// Register the task at <paramref name="taskPath"/> from the given
+        /// XML, overwriting any existing task at that path. Returns
+        /// <c>true</c> on success.
+        /// </summary>
+        bool TryRegisterFromXml(string taskPath, string xml, out string errorMessage);
+
+        /// <summary>
+        /// Read back the registered XML for the task at
+        /// <paramref name="taskPath"/>. Returns <c>true</c> with the XML
+        /// when the task exists; returns <c>false</c> with a populated
+        /// <paramref name="errorMessage"/> when it does not.
+        /// </summary>
+        bool TryQueryXml(string taskPath, out string xml, out string errorMessage);
+
+        /// <summary>
+        /// Unregister the task at <paramref name="taskPath"/>. Returns
+        /// <c>true</c> if the task was unregistered OR was not registered
+        /// to begin with (idempotent). Returns <c>false</c> only on a hard
+        /// failure (e.g., permission denied).
+        /// </summary>
+        bool TryUnregister(string taskPath, out string errorMessage);
+    }
+}

GVFS/GVFS.Common/LogonTaskRegistration.cs

@@ -0,0 +1,255 @@
+using GVFS.Common.Tracing;
+using System;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace GVFS.Common
+{
+    /// <summary>
+    /// Registers / updates / unregisters the per-user Windows scheduled task
+    /// that mounts a user's registered GVFS enlistments at logon. Replaces
+    /// the role of <c>GVFS.Service</c>'s session-change-driven AutoMount in
+    /// the user-level install model.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// The task is registered at <c>\GVFS\AutoMount</c>, scoped to a single
+    /// user (the user's SID is baked into the task's principal and trigger),
+    /// runs at user logon with the user's interactive token, and executes
+    /// <c>gvfs.exe service --mount-all</c>. The mount-all verb already
+    /// reads the user's registered repos (via <see cref="LocalRepoRegistry"/>
+    /// fallback when the service is unavailable) and mounts each one.
+    /// </para>
+    /// <para>
+    /// Drift detection works via a content-hash marker embedded in the
+    /// task's Description field
+    /// (<c>[gvfs-logon-task-hash=XXXXXXXXXXXXXXXX]</c>). The hash covers the
+    /// XML template <em>with placeholders still in place</em>, so it is
+    /// stable across re-substitutions with different user SIDs or gvfs.exe
+    /// paths -- only template content changes (a code change to the
+    /// template constant) bump the hash. <see cref="IsCurrent"/> queries
+    /// the registered task XML, extracts the marker, and compares against
+    /// <see cref="TemplateHash"/>.
+    /// </para>
+    /// <para>
+    /// Tested as a unit by passing a mock <see cref="IScheduledTaskInvoker"/>.
+    /// Production callers should use
+    /// <see cref="CreateForCurrentPlatform(ITracer)"/>, which constructs a
+    /// <see cref="SchTasksScheduledTaskInvoker"/> behind the scenes.
+    /// </para>
+    /// </remarks>
+    public class LogonTaskRegistration
+    {
+        public const string TaskName = "AutoMount";
+        public const string TaskFolder = @"\GVFS\";
+        public const string FullTaskPath = @"\GVFS\AutoMount";
+
+        public const string GvfsPathPlaceholder = "__GVFS_PATH__";
+        public const string UserIdPlaceholder = "__USER_ID__";
+        public const string TaskHashPlaceholder = "__TASK_HASH__";
+
+        public const string HashMarkerPrefix = "[gvfs-logon-task-hash=";
+        public const string HashMarkerSuffix = "]";
+
+        /// <summary>
+        /// Task XML template. Placeholders:
+        /// <list type="bullet">
+        /// <item><c>__GVFS_PATH__</c> -- absolute path to gvfs.exe</item>
+        /// <item><c>__USER_ID__</c> -- the user's SID (must be the same one
+        ///   the principal runs as, so the logon trigger fires for the
+        ///   right user)</item>
+        /// <item><c>__TASK_HASH__</c> -- content hash of this template,
+        ///   inserted into the Description for drift detection</item>
+        /// </list>
+        /// Indented as a verbatim string; the XML emitted is well-formed
+        /// and accepted by <c>schtasks /Create /XML</c>.
+        /// </summary>
+        public const string XmlTemplate =
+@"<?xml version=""1.0"" encoding=""UTF-16""?>
+<Task version=""1.4"" xmlns=""http://schemas.microsoft.com/windows/2004/02/mit/task"">
+  <RegistrationInfo>
+    <Author>GVFS</Author>
+    <Description>Mounts the user's registered GVFS enlistments at logon. Required by VFS for Git in the user-level install model. [gvfs-logon-task-hash=__TASK_HASH__]</Description>
+    <URI>\GVFS\AutoMount</URI>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>__USER_ID__</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id=""Author"">
+      <UserId>__USER_ID__</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT5M</ExecutionTimeLimit>
+    <Priority>5</Priority>
+  </Settings>
+  <Actions Context=""Author"">
+    <Exec>
+      <Command>conhost.exe</Command>
+      <Arguments>--headless __GVFS_PATH__ service --mount-all</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+";
+
+        private static readonly Lazy<string> templateHash = new Lazy<string>(ComputeTemplateHash);
+
+        private readonly ITracer tracer;
+        private readonly IScheduledTaskInvoker invoker;
+
+        public LogonTaskRegistration(ITracer tracer, IScheduledTaskInvoker invoker)
+        {
+            ArgumentNullException.ThrowIfNull(tracer);
+            ArgumentNullException.ThrowIfNull(invoker);
+            this.tracer = tracer;
+            this.invoker = invoker;
+        }
+
+        /// <summary>
+        /// Convenience factory for production callers: wires up a real
+        /// <see cref="SchTasksScheduledTaskInvoker"/>.
+        /// </summary>
+        public static LogonTaskRegistration CreateForCurrentPlatform(ITracer tracer)
+        {
+            ArgumentNullException.ThrowIfNull(tracer);
+            return new LogonTaskRegistration(tracer, new SchTasksScheduledTaskInvoker(tracer));
+        }
+
+        /// <summary>
+        /// Stable hex hash of <see cref="XmlTemplate"/> (with placeholders
+        /// intact). 64 hex chars (full SHA-256), computed once per process.
+        /// </summary>
+        public static string TemplateHash => templateHash.Value;
+
+        /// <summary>
+        /// Substitute placeholders to produce a registerable task XML.
+        /// </summary>
+        public static string BuildTaskXml(string gvfsExePath, string userSid)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(gvfsExePath);
+            ArgumentException.ThrowIfNullOrEmpty(userSid);
+
+            return XmlTemplate
+                .Replace(GvfsPathPlaceholder, gvfsExePath)
+                .Replace(UserIdPlaceholder, userSid)
+                .Replace(TaskHashPlaceholder, TemplateHash);
+        }
+
+        /// <summary>
+        /// Extract the <c>[gvfs-logon-task-hash=XXXX]</c> hash marker from
+        /// arbitrary text (usually a Task's Description). Returns
+        /// <c>false</c> when no marker is present.
+        /// </summary>
+        public static bool TryExtractHashMarker(string text, out string hash)
+        {
+            hash = null;
+            if (string.IsNullOrEmpty(text))
+            {
+                return false;
+            }
+
+            int start = text.IndexOf(HashMarkerPrefix, StringComparison.Ordinal);
+            if (start < 0)
+            {
+                return false;
+            }
+
+            int hashStart = start + HashMarkerPrefix.Length;
+            int hashEnd = text.IndexOf(HashMarkerSuffix, hashStart, StringComparison.Ordinal);
+            if (hashEnd <= hashStart)
+            {
+                return false;
+            }
+
+            hash = text.Substring(hashStart, hashEnd - hashStart);
+            return true;
+        }
+
+        /// <summary>
+        /// Returns <c>true</c> when the logon task is registered AND its
+        /// embedded hash marker matches the current template's hash.
+        /// Returns <c>false</c> if the task is missing, the query fails,
+        /// or the hash differs (drift).
+        /// </summary>
+        public bool IsCurrent()
+        {
+            if (!this.invoker.TryQueryXml(FullTaskPath, out string xml, out _))
+            {
+                return false;
+            }
+
+            if (!TryExtractHashMarker(xml, out string registeredHash))
+            {
+                return false;
+            }
+
+            return string.Equals(registeredHash, TemplateHash, StringComparison.Ordinal);
+        }
+
+        /// <summary>
+        /// Register the logon task with the given gvfs.exe path and user
+        /// SID, overwriting any existing registration. Idempotent: when
+        /// the registered task already matches the intended XML (same
+        /// hash, same args), this is a fast no-op.
+        /// </summary>
+        public bool TryRegisterOrUpdate(string gvfsExePath, string userSid, out string errorMessage)
+        {
+            ArgumentException.ThrowIfNullOrEmpty(gvfsExePath);
+            ArgumentException.ThrowIfNullOrEmpty(userSid);
+
+            if (this.IsCurrent())
+            {
+                // Still verify args are right; the hash covers the template
+                // structure but not the substituted gvfs.exe path. Re-query
+                // and check the action command.
+                if (this.invoker.TryQueryXml(FullTaskPath, out string existingXml, out _) &&
+                    existingXml.Contains(gvfsExePath, StringComparison.Ordinal) &&
+                    existingXml.Contains($"<UserId>{userSid}</UserId>", StringComparison.Ordinal))
+                {
+                    errorMessage = string.Empty;
+                    return true;
+                }
+            }
+
+            string xml = BuildTaskXml(gvfsExePath, userSid);
+            return this.invoker.TryRegisterFromXml(FullTaskPath, xml, out errorMessage);
+        }
+
+        /// <summary>
+        /// Unregister the logon task. Idempotent: returns <c>true</c> when
+        /// the task was unregistered OR was not registered to begin with.
+        /// </summary>
+        public bool TryUnregister(out string errorMessage)
+        {
+            return this.invoker.TryUnregister(FullTaskPath, out errorMessage);
+        }
+
+        private static string ComputeTemplateHash()
+        {
+            byte[] bytes = Encoding.UTF8.GetBytes(XmlTemplate);
+            byte[] hash = SHA256.HashData(bytes);
+            return Convert.ToHexString(hash);
+        }
+    }
+}