Merge pull request #3 from g4-api/development

Development

Author: gravity-api

src/ChromiumPeek.Domain/ChromiumPeek.Domain.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+	<PropertyGroup>
+		<!-- Assembly -->
+		<TargetFramework>net10.0</TargetFramework>
+		<AssemblyVersion>10.0.0.0</AssemblyVersion>
+		<FileVersion>10.0.0.0</FileVersion>
+		<IsPackable>false</IsPackable>
+		<CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
+		<SatelliteResourceLanguages>en-US</SatelliteResourceLanguages>
+		<LangVersion>latest</LangVersion>
+		<ErrorOnDuplicatePublishOutputFiles>false</ErrorOnDuplicatePublishOutputFiles>
+		<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+
+		<!-- https://learn.microsoft.com/en-us/dotnet/fundamentals/syslib-diagnostics/syslib1040-1049 -->
+		<NoWarn>$(NoWarn);SYSLIB1045;IDE0130;SYSLIB1054;CA2101;S4200;MSB3305</NoWarn>
+	</PropertyGroup>
+
+	<ItemGroup>
+		<ProjectReference Include="..\Common.Domain\Common.Domain.csproj" />
+	</ItemGroup>
+
+	<ItemGroup>
+		<Content Include="..\ChromiumPeek.Extension\**\*.*">
+			<Link>ChromiumExtension\%(RecursiveDir)%(FileName)%(Extension)</Link>
+			<CopyToOutputDirectory>Always</CopyToOutputDirectory>
+		</Content>
+	</ItemGroup>
+
+</Project>

src/ChromiumPeek.Domain/ChromiumPeekRepository.cs

@@ -0,0 +1,20 @@
+using ChromiumPeek.Domain.Models;
+
+namespace UiaPeek.Domain
+{
+    /// <summary>
+    /// Represents a repository for accessing UI Automation elements and their ancestor chains.
+    /// </summary>
+    public class ChromiumPeekRepository : IChromiumPeekRepository
+    {
+        public ChromiumChainModel Peek()
+        {
+            throw new System.NotImplementedException();
+        }
+
+        public ChromiumChainModel Peek(int x, int y)
+        {
+            throw new System.NotImplementedException();
+        }
+    }
+}

src/ChromiumPeek.Domain/Hubs/ChromiumPeekHub.cs

@@ -0,0 +1,110 @@
+using Microsoft.AspNetCore.SignalR;
+
+using System;
+using System.Collections.Concurrent;
+using System.Threading.Tasks;
+
+using Common.Domain.Models;
+using UiaPeek.Domain;
+using ChromiumPeek.Domain.Models;
+
+namespace ChromiumPeek.Domain.Hubs
+{
+    /// <summary>
+    /// SignalR hub for handling UI Automation (UIA) peek operations.
+    /// Provides real-time communication for heartbeat checks and
+    /// ancestor chain inspection at specific screen coordinates.
+    /// </summary>
+    public class ChromiumPeekHub(IChromiumPeekRepository repository) : Hub
+    {
+        // Collection of active recording sessions keyed by a unique session id.
+        private readonly static ConcurrentDictionary<string, ConcurrentBag<ChromiumChainModel>> s_sessions = new();
+
+        // Repository used for querying UIA elements at coordinates.
+        private readonly IChromiumPeekRepository _repository = repository;
+
+        // Sends a heartbeat message to the caller.
+        // This can be used by clients to verify the connection is alive.
+        [HubMethodName(name: nameof(SendHeartbeat))]
+        public Task SendHeartbeat()
+        {
+            // Notify the calling client with a heartbeat message.
+            return Clients.Caller.SendAsync(
+                method: "ReceiveHeartbeat",
+                arg1: new HubResponseModel("Heartbeat received - connection is alive"));
+        }
+
+        // Resolves the UIA element at the given screen coordinates and
+        // returns its ancestor chain back to the caller.
+        [HubMethodName(name: $"{nameof(SendPeek)}At")]
+        public Task SendPeek(RecorderPointModel point)
+        {
+            // Query the repository to get the UIA ancestor chain at the given coordinates.
+            var peekResponse = _repository.Peek(x: point.XPos, y: point.YPos);
+
+            // Send the result back to the calling client.
+            return Clients.Caller.SendAsync(
+                method: "ReceivePeek",
+                arg1: new HubResponseModel(peekResponse));
+        }
+
+        // Resolves the UIA element at the given screen coordinates and
+        // returns its ancestor chain back to the caller.
+        [HubMethodName(name: $"{nameof(SendPeek)}Focused")]
+        public Task SendPeek()
+        {
+            // Query the repository to get the UIA ancestor chain from the currently focused element.
+            var peekResponse = _repository.Peek();
+
+            // Send the result back to the calling client.
+            return Clients.Caller.SendAsync(
+                method: "ReceivePeek",
+                arg1: new HubResponseModel(peekResponse));
+        }
+
+        // Starts a new recording session for the current SignalR caller.
+        [HubMethodName(name: $"{nameof(StartRecordingSession)}")]
+        public Task StartRecordingSession()
+        {
+            // Generate a unique identifier for this caller's recording session.
+            var session = Guid.NewGuid().ToString();
+
+            // Initialize storage for this session's recorded events/actions.
+            // Assumes `_sessions` is a (thread-safe) dictionary keyed by session id.
+            s_sessions[session] = [];
+
+            // Notify ONLY the invoking client that the session has started and
+            // return the session id as the payload. The client should listen to
+            // "RecordingSessionStarted" and extract the `Value` field.
+            return Clients.Caller.SendAsync(
+                method: "RecordingSessionStarted",
+                arg1: new HubResponseModel(session));
+        }
+
+        // Stops an existing recording session for the current SignalR caller.
+        [HubMethodName(name: $"{nameof(StopRecordingSession)}")]
+        public Task StopRecordingSession(string session)
+        {
+            // Remove the session from the active sessions collection.
+            s_sessions.TryRemove(session, out var chains);
+
+            // Notify ONLY the invoking client that the session has stopped.
+            return Clients.Caller.SendAsync(
+                method: "RecordingSessionStopped",
+                arg1: new HubResponseModel(chains));
+        }
+
+        /// <summary>
+        /// Lightweight envelope for hub-to-client messages that carry a single value.
+        /// </summary>
+        /// <param name="value">The payload to send to the client.</param>
+        private sealed class HubResponseModel(object value)
+        {
+            /// <summary>
+            /// The payload carried by this response. Using <see cref="object"/> allows
+            /// any serializable value (string, number, DTO, etc.).
+            /// </summary>
+            public object Value { get; init; } = value;
+        }
+    }
+}

src/ChromiumPeek.Domain/IChromiumPeekRepository.cs

@@ -0,0 +1,25 @@
+using ChromiumPeek.Domain.Models;
+
+namespace UiaPeek.Domain
+{
+    /// <summary>
+    /// Represents a repository for accessing UI Automation elements and their ancestor chains.
+    /// </summary>
+    public interface IChromiumPeekRepository
+    {
+        /// <summary>
+        /// Retrieves the ancestor chain of the UI Automation element located at the given screen coordinates.
+        /// </summary>
+        /// <param name="x">The X-coordinate on the screen.</param>
+        /// <param name="y">The Y-coordinate on the screen.</param>
+        /// <returns>A <see cref="ChromiumChainModel"/> representing the ancestor chain of the element at the specified point, or <c>null</c> if no element is found.</returns>
+        ChromiumChainModel Peek();
+
+        /// <summary>
+        /// Retrieves the currently focused UI Automation element and constructs
+        /// its ancestor chain representation, including an absolute XPath locator.
+        /// </summary>
+        /// <returns>A <see cref="ChromiumChainModel"/> representing the focused element and its ancestors,or an empty model if no element is currently focused.</returns>
+        ChromiumChainModel Peek(int x, int y);
+    }
+}

src/ChromiumPeek.Domain/Models/ChromiumChainModel.cs

@@ -0,0 +1,18 @@
+using Common.Domain.Models;
+
+namespace ChromiumPeek.Domain.Models
+{
+    /// <summary>
+    /// Represents a chain of UIA (UI Automation) nodes recorded by UiaPeek.
+    /// Uses <see cref="ChromiumNodeModel"/> as the node type.
+    ///
+    /// This class acts as a strongly-typed alias for <see cref="ChainModel{TNode}"/>,
+    /// providing clearer intent within the UIA domain. Extend this class when
+    /// UIA-specific chain metadata or behavior is required.
+    /// </summary>
+    public class ChromiumChainModel : ChainModel<ChromiumNodeModel>
+    {
+        // Intentionally empty — provides a domain-specific type for UIA chains.
+        // Add members here if UIA chains require additional metadata or logic.
+    }
+}

src/ChromiumPeek.Domain/Models/ChromiumEventModel.cs

@@ -0,0 +1,24 @@
+using Common.Domain.Models;
+
+namespace ChromiumPeek.Domain.Models
+{
+    /// <summary>
+    /// Represents a UI Automation (UIA) event captured by the UiaPeek tool.
+    /// Inherits from <see cref="RecorderEventModel{TChain}"/> using <see cref="ChromiumChainModel"/> 
+    /// as the event chain type.
+    /// 
+    /// This model serves as the strongly-typed event payload used throughout the 
+    /// recorder pipeline. It provides structure, metadata, and a chain of actions 
+    /// that describe the recorded UI interaction sequence.
+    /// 
+    /// The class does not add new members — all functionality is inherited — 
+    /// but it allows the domain layer to work with UIA-specific event chains
+    /// without needing to reference the generic base everywhere.
+    /// </summary>
+    public class ChromiumEventModel : RecorderEventModel<ChromiumChainModel>
+    {
+        // Intentionally empty — this class acts as a domain-specific alias 
+        // so consumers can work with a UiaEventModel rather than a generic type.
+        // Extend here in the future if UIA events require custom fields or behavior.
+    }
+}

src/ChromiumPeek.Domain/Models/ChromiumNodeModel.cs

@@ -0,0 +1,19 @@
+using Common.Domain.Models;
+
+namespace ChromiumPeek.Domain.Models
+{
+    /// <summary>
+    /// Represents a single UI Automation (UIA) node within a recorded chain.
+    /// Wraps an <see cref="IUIAutomationElement"/> as the underlying UI element.
+    /// 
+    /// This class is a strongly-typed alias for <see cref="RecorderNodeModel{TElement}"/>,
+    /// allowing the recorder pipeline to work specifically with UIA elements.
+    /// Extend this class when UIA nodes require additional metadata, properties,
+    /// or domain-specific behavior.
+    /// </remarks>
+    public class ChromiumNodeModel : RecorderNodeModel<object>
+    {
+        // Intentionally empty — provides a domain-specific node type for UIA recordings.
+        // Add UIA-specific fields or logic here if needed in future.
+    }
+}

src/ChromiumPeek.Extension/js/background.js

@@ -0,0 +1,13 @@
+// background.js (MV3 service worker)
+
+// Simple startup log so we know the extension is alive.
+chrome.runtime.onInstalled.addListener(() => {
+    console.log("[ChromiumPeek] Extension installed.");
+});
+
+// ONLY if you really want to handle clicks directly (and NOT just use the popup)
+if (chrome.action && chrome.action.onClicked && chrome.action.onClicked.addListener) {
+    chrome.action.onClicked.addListener((tab) => {
+        console.log("[ChromiumPeek] Action icon clicked on tab:", tab.id);
+    });
+}

src/ChromiumPeek.Extension/js/content-script.js

@@ -0,0 +1,27 @@
+// content-script.js
+
+console.log("[ChromiumPeek] Hello from content script on:", window.location.href);
+
+// As a visible smoke test, mark the page once:
+if (!window.__chromiumPeekHelloInjected) {
+    window.__chromiumPeekHelloInjected = true;
+
+    const banner = document.createElement("div");
+    banner.textContent = "ChromiumPeek: Hello World!";
+    banner.style.position = "fixed";
+    banner.style.zIndex = 999999;
+    banner.style.bottom = "10px";
+    banner.style.right = "10px";
+    banner.style.padding = "6px 10px";
+    banner.style.borderRadius = "4px";
+    banner.style.fontFamily = "system-ui, sans-serif";
+    banner.style.fontSize = "12px";
+    banner.style.background = "rgba(0, 0, 0, 0.8)";
+    banner.style.color = "#fff";
+    banner.style.pointerEvents = "none";
+
+    document.body.appendChild(banner);
+
+    // Auto-remove after a few seconds
+    setTimeout(() => banner.remove(), 3000);
+}

src/ChromiumPeek.Extension/js/popup.js

@@ -0,0 +1,56 @@
+// popup.js
+
+let connection = null;
+
+document.addEventListener("DOMContentLoaded", () => {
+    const button = document.getElementById("hello-btn");
+    const status = document.getElementById("status");
+
+    button.addEventListener("click", async () => {
+        // Already connected? Don't reconnect.
+        if (connection && connection.state === "Connected") {
+            status.textContent = "Already connected to Peek hub.";
+            return;
+        }
+
+        status.textContent = "Connecting to Peek hub...";
+
+        try {
+            // Create the connection if we don't have one yet
+            if (!connection) {
+                connection = new signalR.HubConnectionBuilder()
+                    .withUrl("http://localhost:9956/hub/v4/g4/peek")
+                    .withAutomaticReconnect()
+                    .build();
+
+                // Optional: basic logging
+                connection.onreconnecting((error) => {
+                    console.warn("[ChromiumPeek] Reconnecting to hub...", error);
+                    status.textContent = "Reconnecting to Peek hub...";
+                });
+
+                connection.onreconnected((connectionId) => {
+                    console.log("[ChromiumPeek] Reconnected to hub:", connectionId);
+                    status.textContent = "Reconnected to Peek hub.";
+                });
+
+                connection.onclose((error) => {
+                    console.warn("[ChromiumPeek] Connection closed:", error);
+                    status.textContent = "Connection closed.";
+                });
+
+                // Later you'll add handlers like:
+                // connection.on("SomeServerEvent", data => { ... });
+            }
+
+            // Start the connection
+            await connection.start();
+            console.log("[ChromiumPeek] Connected to hub.");
+            status.textContent = "Connected to Peek hub.";
+
+        } catch (err) {
+            console.error("[ChromiumPeek] Failed to connect to hub:", err);
+            status.textContent = "Failed to connect – see console.";
+        }
+    });
+});