Implement LmxOpcUa server — all 6 phases complete

Full OPC UA server on .NET Framework 4.8 (x86) exposing AVEVA System
Platform Galaxy tags via MXAccess. Mirrors Galaxy object hierarchy as
OPC UA address space, translating contained-name browse paths to
tag-name runtime references.

Components implemented:
- Configuration: AppConfiguration with 4 sections, validator
- Domain: ConnectionState, Quality, Vtq, MxDataTypeMapper, error codes
- MxAccess: StaComThread, MxAccessClient (partial classes), MxProxyAdapter
  using strongly-typed ArchestrA.MxAccess COM interop
- Galaxy Repository: SQL queries (hierarchy, attributes, change detection),
  ChangeDetectionService with auto-rebuild on deploy
- OPC UA Server: LmxNodeManager (CustomNodeManager2), LmxOpcUaServer,
  OpcUaServerHost with programmatic config, SecurityPolicy None
- Status Dashboard: HTTP server with HTML/JSON/health endpoints
- Integration: Full 14-step startup, graceful shutdown, component wiring

175 tests (174 unit + 1 integration), all passing.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

tools/opcuacli-dotnet/Commands/BrowseCommand.cs

@@ -0,0 +1,92 @@
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+using Opc.Ua;
+using Opc.Ua.Client;
+
+namespace OpcUaCli.Commands;
+
+[Command("browse", Description = "Browse the OPC UA address space")]
+public class BrowseCommand : ICommand
+{
+    [CommandOption("url", 'u', Description = "OPC UA server endpoint URL", IsRequired = true)]
+    public string Url { get; init; } = default!;
+
+    [CommandOption("node", 'n', Description = "Node ID to browse (default: Objects folder)")]
+    public string? NodeId { get; init; }
+
+    [CommandOption("depth", 'd', Description = "Maximum browse depth")]
+    public int Depth { get; init; } = 1;
+
+    [CommandOption("recursive", 'r', Description = "Browse recursively (uses --depth as max depth)")]
+    public bool Recursive { get; init; }
+
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        using var session = await OpcUaHelper.ConnectAsync(Url);
+
+        var startNode = string.IsNullOrEmpty(NodeId)
+            ? ObjectIds.ObjectsFolder
+            : new NodeId(NodeId);
+
+        var maxDepth = Recursive ? Depth : 1;
+        await BrowseNodeAsync(session, console, startNode, maxDepth, 0);
+    }
+
+    private static async Task BrowseNodeAsync(
+        ISession session, IConsole console, NodeId nodeId, int maxDepth, int currentDepth)
+    {
+        var indent = new string(' ', currentDepth * 2);
+
+        var (_, continuationPoint, references) = await session.BrowseAsync(
+            null,
+            null,
+            nodeId,
+            0u,
+            BrowseDirection.Forward,
+            ReferenceTypeIds.HierarchicalReferences,
+            true,
+            (uint)NodeClass.Object | (uint)NodeClass.Variable | (uint)NodeClass.Method);
+
+        if (references == null) return;
+
+        // Handle continuation points for large result sets
+        while (references.Count > 0)
+        {
+            foreach (var reference in references)
+            {
+                var nodeClass = reference.NodeClass;
+                var marker = nodeClass switch
+                {
+                    NodeClass.Object => "[Object]",
+                    NodeClass.Variable => "[Variable]",
+                    NodeClass.Method => "[Method]",
+                    _ => $"[{nodeClass}]"
+                };
+
+                await console.Output.WriteLineAsync(
+                    $"{indent}{marker} {reference.DisplayName} (NodeId: {reference.NodeId})");
+
+                if (currentDepth + 1 < maxDepth && nodeClass == NodeClass.Object)
+                {
+                    var childNodeId = ExpandedNodeId.ToNodeId(
+                        reference.NodeId, session.NamespaceUris);
+                    await BrowseNodeAsync(session, console, childNodeId, maxDepth, currentDepth + 1);
+                }
+            }
+
+            // Follow continuation point if present
+            if (continuationPoint != null && continuationPoint.Length > 0)
+            {
+                var (_, nextCp, nextRefs) = await session.BrowseNextAsync(
+                    null, false, continuationPoint);
+                continuationPoint = nextCp;
+                references = nextRefs;
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+}

tools/opcuacli-dotnet/Commands/ConnectCommand.cs

@@ -0,0 +1,22 @@
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+
+namespace OpcUaCli.Commands;
+
+[Command("connect", Description = "Test connection to an OPC UA server")]
+public class ConnectCommand : ICommand
+{
+    [CommandOption("url", 'u', Description = "OPC UA server endpoint URL", IsRequired = true)]
+    public string Url { get; init; } = default!;
+
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        using var session = await OpcUaHelper.ConnectAsync(Url);
+        await console.Output.WriteLineAsync($"Connected to: {session.Endpoint.EndpointUrl}");
+        await console.Output.WriteLineAsync($"Server: {session.Endpoint.Server!.ApplicationName}");
+        await console.Output.WriteLineAsync($"Security Mode: {session.Endpoint.SecurityMode}");
+        await console.Output.WriteLineAsync($"Security Policy: {session.Endpoint.SecurityPolicyUri}");
+        await console.Output.WriteLineAsync("Connection successful.");
+    }
+}

tools/opcuacli-dotnet/Commands/ReadCommand.cs

@@ -0,0 +1,31 @@
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+using Opc.Ua;
+using Opc.Ua.Client;
+
+namespace OpcUaCli.Commands;
+
+[Command("read", Description = "Read a value from a node")]
+public class ReadCommand : ICommand
+{
+    [CommandOption("url", 'u', Description = "OPC UA server endpoint URL", IsRequired = true)]
+    public string Url { get; init; } = default!;
+
+    [CommandOption("node", 'n', Description = "Node ID (e.g. ns=2;s=MyNode)", IsRequired = true)]
+    public string NodeId { get; init; } = default!;
+
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        using var session = await OpcUaHelper.ConnectAsync(Url);
+
+        var node = new NodeId(NodeId);
+        var value = await session.ReadValueAsync(node);
+
+        await console.Output.WriteLineAsync($"Node:        {NodeId}");
+        await console.Output.WriteLineAsync($"Value:       {value.Value}");
+        await console.Output.WriteLineAsync($"Status:      {value.StatusCode}");
+        await console.Output.WriteLineAsync($"Source Time: {value.SourceTimestamp:O}");
+        await console.Output.WriteLineAsync($"Server Time: {value.ServerTimestamp:O}");
+    }
+}

tools/opcuacli-dotnet/Commands/SubscribeCommand.cs

@@ -0,0 +1,61 @@
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+using Opc.Ua;
+using Opc.Ua.Client;
+
+namespace OpcUaCli.Commands;
+
+[Command("subscribe", Description = "Monitor a node for value changes")]
+public class SubscribeCommand : ICommand
+{
+    [CommandOption("url", 'u', Description = "OPC UA server endpoint URL", IsRequired = true)]
+    public string Url { get; init; } = default!;
+
+    [CommandOption("node", 'n', Description = "Node ID to monitor", IsRequired = true)]
+    public string NodeId { get; init; } = default!;
+
+    [CommandOption("interval", 'i', Description = "Polling interval in milliseconds")]
+    public int Interval { get; init; } = 1000;
+
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        using var session = await OpcUaHelper.ConnectAsync(Url);
+
+        var subscription = new Subscription(session.DefaultSubscription)
+        {
+            PublishingInterval = Interval,
+            DisplayName = "CLI Subscription"
+        };
+
+        var item = new MonitoredItem(subscription.DefaultItem)
+        {
+            StartNodeId = new NodeId(NodeId),
+            DisplayName = NodeId,
+            SamplingInterval = Interval
+        };
+
+        item.Notification += (_, e) =>
+        {
+            if (e.NotificationValue is MonitoredItemNotification notification)
+            {
+                console.Output.WriteLine(
+                    $"[{notification.Value.SourceTimestamp:O}] {NodeId} = {notification.Value.Value} ({notification.Value.StatusCode})");
+            }
+        };
+
+        subscription.AddItem(item);
+        session.AddSubscription(subscription);
+        await subscription.CreateAsync();
+
+        await console.Output.WriteLineAsync(
+            $"Subscribed to {NodeId} (interval: {Interval}ms). Press Ctrl+C to stop.");
+
+        var ct = console.RegisterCancellationHandler();
+
+        try { await Task.Delay(Timeout.Infinite, ct); }
+        catch (OperationCanceledException) { }
+
+        await console.Output.WriteLineAsync("Unsubscribed.");
+    }
+}

tools/opcuacli-dotnet/Commands/WriteCommand.cs

@@ -0,0 +1,44 @@
+using CliFx;
+using CliFx.Attributes;
+using CliFx.Infrastructure;
+using Opc.Ua;
+using Opc.Ua.Client;
+
+namespace OpcUaCli.Commands;
+
+[Command("write", Description = "Write a value to a node")]
+public class WriteCommand : ICommand
+{
+    [CommandOption("url", 'u', Description = "OPC UA server endpoint URL", IsRequired = true)]
+    public string Url { get; init; } = default!;
+
+    [CommandOption("node", 'n', Description = "Node ID (e.g. ns=2;s=MyNode)", IsRequired = true)]
+    public string NodeId { get; init; } = default!;
+
+    [CommandOption("value", 'v', Description = "Value to write", IsRequired = true)]
+    public string Value { get; init; } = default!;
+
+    public async ValueTask ExecuteAsync(IConsole console)
+    {
+        using var session = await OpcUaHelper.ConnectAsync(Url);
+
+        var node = new NodeId(NodeId);
+        var current = await session.ReadValueAsync(node);
+        var typedValue = OpcUaHelper.ConvertValue(Value, current.Value);
+
+        var writeValue = new WriteValue
+        {
+            NodeId = node,
+            AttributeId = Attributes.Value,
+            Value = new DataValue(new Variant(typedValue))
+        };
+
+        var request = new WriteValueCollection { writeValue };
+        var response = await session.WriteAsync(null, request, CancellationToken.None);
+
+        if (StatusCode.IsGood(response.Results[0]))
+            await console.Output.WriteLineAsync($"Write successful: {NodeId} = {typedValue}");
+        else
+            await console.Output.WriteLineAsync($"Write failed: {response.Results[0]}");
+    }
+}