Only the delta.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Build output and local SDK state
**/bin/
**/obj/
/Admin/Build/
/.dotnet/

# Machine-specific IDE settings
.vs/
.idea/
*.user
*.suo

# Generated checks, downloads, and media
/Admin/TestResults/
/Admin/GuiState/
/Admin/Downloads/
/Admin/Videos/
*.onnx
*.onnx.data

# Local credentials and tooling state
.env
.env.*
!.env.example
/.aws/
/.codex/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Build output and local SDK state
**/bin/
**/obj/
/Admin/Build/
/.dotnet/

# Machine-specific IDE settings
.vs/
.idea/
*.user
*.suo

# Generated checks, downloads, and media
/Admin/TestResults/
/Admin/Downloads/
/Admin/Videos/
*.onnx
*.onnx.data

# Local credentials and tooling state
.env
.env.*
!.env.example
/.aws/
/.codex/

1
2
3
4

<Project>
  <!-- V16 scenario-driven project planning and execution boards. -->
  <PropertyGroup><VersionPrefix>16.0.0</VersionPrefix><VersionSuffix>alpha.1</VersionSuffix></PropertyGroup>
</Project>

1
2
3
4

<Project>
  <!-- V15 configured home devices controlled by task-specific scenarios. -->
  <PropertyGroup><VersionPrefix>15.0.0</VersionPrefix><VersionSuffix>alpha.1</VersionSuffix></PropertyGroup>
</Project>

1
2
3
4
5
6
7
8
9
10
11

param([switch]$NoBrowser)
$ErrorActionPreference = 'Stop'
$guiRoot = [IO.Path]::GetFullPath((Join-Path $PSScriptRoot '../..'))
Push-Location -LiteralPath $guiRoot
try {
    dotnet build Interfaces/Gui/LilithDesktop/LilithDesktop.csproj -c Release -p:NuGetAudit=false
    if ($LASTEXITCODE -ne 0) { throw 'GUI build failed.' }
    $guiAssembly = Join-Path $guiRoot 'Admin/Build/bin/Interfaces/Gui/LilithDesktop/LilithDesktop/Release/net10.0-windows/LilithDesktop.dll'
    dotnet $guiAssembly
    if ($LASTEXITCODE -ne 0) { throw 'Lilith desktop did not finish normally. Read the launch error above; no Windows security policy is modified by this script.' }
} finally { Pop-Location }

1
2

namespace Lilith.Desktop;
public partial class App : System.Windows.Application { }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

using System.Text.Json;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;

namespace Lilith.Desktop;

internal sealed class ApprovalWindow : Window
{
    internal ApprovalWindow(Window owner,JsonElement proposal,Func<bool,Task> decide)
    {
        Owner=owner;Title="Lilith — Review approval";Width=720;Height=640;MinWidth=420;MinHeight=350;
        WindowStartupLocation=WindowStartupLocation.CenterOwner;Background=new SolidColorBrush(Color.FromRgb(11,16,14));Foreground=Brushes.White;
        var layout=new DockPanel{Margin=new Thickness(24)};Content=layout;
        var heading=new TextBlock{Text=proposal.GetProperty("Title").GetString(),FontSize=23,Foreground=new SolidColorBrush(Color.FromRgb(214,246,117)),Margin=new Thickness(0,0,0,16)};
        DockPanel.SetDock(heading,Dock.Top);layout.Children.Add(heading);
        var footer=new StackPanel{Margin=new Thickness(0,16,0,0)};DockPanel.SetDock(footer,Dock.Bottom);layout.Children.Add(footer);
        var status=new TextBlock{Text="Review the exact prepared change before deciding. Closing this window leaves it pending.",TextWrapping=TextWrapping.Wrap,Margin=new Thickness(0,0,0,12)};footer.Children.Add(status);
        var actions=new StackPanel{Orientation=Orientation.Horizontal};footer.Children.Add(actions);
        var approve=new Button{Content="Approve this change",Padding=new Thickness(18,10,18,10),Background=heading.Foreground,Foreground=Brushes.Black};
        var reject=new Button{Content="Reject",Padding=new Thickness(18,10,18,10),Margin=new Thickness(12,0,0,0)};actions.Children.Add(approve);actions.Children.Add(reject);
        var review=new TextBox{Text=JsonSerializer.Serialize(proposal.GetProperty("Review"),new JsonSerializerOptions{WriteIndented=true}),IsReadOnly=true,TextWrapping=TextWrapping.Wrap,VerticalScrollBarVisibility=ScrollBarVisibility.Auto,Background=new SolidColorBrush(Color.FromRgb(17,24,20)),Foreground=Brushes.White,FontFamily=new FontFamily("Consolas"),Padding=new Thickness(14)};layout.Children.Add(review);
        bool working=false;
        async Task Decide(bool yes)
        {
            if(working)return;working=true;approve.IsEnabled=reject.IsEnabled=false;status.Text="Applying your decision…";
            try{await decide(yes);working=false;Close();}
            catch(Exception ex){status.Text=ex.Message;working=false;approve.IsEnabled=reject.IsEnabled=true;}
        }
        approve.Click+=async(_,_)=>await Decide(true);reject.Click+=async(_,_)=>await Decide(false);
        Closing+=(_,e)=>{if(working)e.Cancel=true;};
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

using System.IO.Compression;
using System.Runtime.InteropServices;

namespace Lilith.Desktop;

internal static class EdgeDriverLocator
{
    internal static async Task<string> ResolveAsync(string repo,string version)
    {
        if(!System.Text.RegularExpressions.Regex.IsMatch(version,@"^\d+\.\d+\.\d+\.\d+$"))throw new InvalidDataException("Invalid WebView2 runtime version.");
        string platform=RuntimeInformation.OSArchitecture==Architecture.Arm64?"arm64":"win64";
        string cache=Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile),".cache","selenium","msedgedriver",platform,version,"msedgedriver.exe");
        if(File.Exists(cache))return cache;
        string folder=Path.Combine(repo,"Admin","Build","DesktopDriver",version);
        string target=Path.Combine(folder,"msedgedriver.exe");if(File.Exists(target))return target;
        using var http=new HttpClient{Timeout=TimeSpan.FromSeconds(60)};
        // Microsoft distributes a version-matched driver separately from WebView2.
        using var response=await http.GetAsync($"https://msedgedriver.microsoft.com/{version}/edgedriver_{platform}.zip",HttpCompletionOption.ResponseHeadersRead);
        response.EnsureSuccessStatusCode();
        if(response.Content.Headers.ContentLength>50000000)throw new IOException("Unexpected driver archive size.");
        var bytes=await response.Content.ReadAsByteArrayAsync();if(bytes.Length>50000000)throw new IOException("Unexpected driver archive size.");
        using var zip=new ZipArchive(new MemoryStream(bytes));
        var executable=zip.GetEntry("msedgedriver.exe")??throw new IOException("Microsoft archive did not contain Edge WebDriver.");
        if(executable.Length>100000000)throw new IOException("Unexpected driver size.");
        Directory.CreateDirectory(folder);string pending=target+".pending";
        executable.ExtractToFile(pending,true);File.Move(pending,target,true);return target;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168

using OpenQA.Selenium;
using OpenQA.Selenium.Edge;

namespace Lilith.Core.WebResearch;

internal sealed class EmbeddedResearchBrowser(BrowserResearchOptions? options = null, Action<string, string>? captureSearchPage = null, Action<string>? reportLifecycle = null,
    Action<ResearchBrowserFrame>? captureFrame = null, Func<PublicWebProxy, EdgeDriver>? createEmbedded = null) : IResearchBrowser, IDisposable
{
    private readonly object _sync = new();
    private EdgeDriver? _driver;
    private PublicWebProxy? _proxy;
    private bool _disposed;
    private Timer? _captureTimer;
    private int _capturedFrames;
    private void Capture()
    {
        if (captureFrame is null || !Monitor.TryEnter(_sync)) return;
        try
        {
            if (_disposed || _driver is null || _capturedFrames >= 1200) return;
            var png = _driver.GetScreenshot().AsByteArray;
            captureFrame(new(DateTimeOffset.UtcNow, _driver.Url, png));
            _capturedFrames++;
        }
        catch (Exception ex) { Report("Browser capture unavailable: " + ex.GetType().Name); }
        finally { Monitor.Exit(_sync); }
    }
    private BrowserResearchOptions Options => options ?? BrowserResearchOptions.Load();
    private Task<T> UseAsync<T>(Func<EdgeDriver, T> action, CancellationToken ct) => Task.Run(() =>
    {
        lock (_sync)
        {
            ObjectDisposedException.ThrowIf(_disposed, this);
            ct.ThrowIfCancellationRequested();
            if (_driver is null)
            {
                _proxy = new PublicWebProxy();
                try
                {
                    _driver = Create(_proxy); Report("Selenium session opened: " + _driver.SessionId);
                    if (captureFrame is not null)
                    {
                        Capture();
                        _captureTimer = new Timer(_ => Capture(), null, 1000, 1000);
                    }
                }
                catch { _proxy.Dispose(); _proxy = null; throw; }
            }
            try { return action(_driver); }
            finally { Capture(); }
        }
    }, ct);

    public void Dispose()
    {
        lock (_sync)
        {
            if (_disposed) return;
            _disposed = true;
            _captureTimer?.Dispose();
            string? session = _driver?.SessionId?.ToString();
            try { _driver?.Dispose(); }
            finally
            {
                _driver = null; _proxy?.Dispose(); _proxy = null;
                if (session is not null) Report("Selenium session closed: " + session);
                if (session is not null && captureFrame is not null)
                    try { captureFrame(new(DateTimeOffset.UtcNow, "", null, Closed: true)); } catch { /* Capture cannot own disposal. */ }
            }
        }
    }
    private void Report(string message) { try { reportLifecycle?.Invoke(message); } catch { /* Diagnostics never own execution. */ } }
    private EdgeDriver Create(PublicWebProxy proxy)
    {
        return createEmbedded?.Invoke(proxy) ?? throw new InvalidOperationException("Embedded browser factory missing.");
    }
    public Task<SearchBatch> SearchAsync(string question, int candidateLimit, CancellationToken ct) => UseAsync(driver =>
    {
        var found = new Dictionary<string, SearchSource>(StringComparer.Ordinal); var outcomes = new List<EngineOutcome>();
        foreach (var engine in Options.Engines)
        {
            ct.ThrowIfCancellationRequested();
            try
            {
                driver.Navigate().GoToUrl(engine.QueryUrl.Replace("{query}", Uri.EscapeDataString(question)));
                WaitFor(driver, engine.ResultSelector, ct);
                Capture();
                captureSearchPage?.Invoke(engine.Name, driver.PageSource);
                int count = 0;
                foreach (var anchor in driver.FindElements(By.CssSelector(engine.ResultSelector)).Take(60))
                {
                    string? href = anchor.GetAttribute("href");
                    if (href is null) continue;
                    string url;
                    try { url = PublicWeb.ValidateUri(Unwrap(href)).AbsoluteUri; } catch (ArgumentException) { continue; }
                    if (new Uri(url).Host == new Uri(engine.QueryUrl.Replace("{query}", "test")).Host) continue;
                    // Public result markup can arrive before the engine reveals
                    // its styled result panel. WebDriver's visible Text is empty
                    // then, although the actual link/title is already in the DOM.
                    string title = anchor.Text.Trim();
                    if (title.Length == 0) title = (anchor.GetDomProperty("textContent") ?? "").Trim();
                    if (title.Length == 0) continue;
                    count++; found.TryAdd(url, new(url, title[..Math.Min(title.Length, 200)], engine.Name));
                }
                string diagnostic = count > 0 ? "Public result links extracted." : DescribeUnavailable(driver);
                outcomes.Add(new(engine.Name, count > 0 ? "completed" : "unavailable", diagnostic));
            }
            catch (WebDriverException) { outcomes.Add(new(engine.Name, "unavailable", "Navigation failed or the engine blocked automated access.")); }
        }
        // Interleave engine results so a first engine cannot fill every selected slot.
        var queues = Options.Engines.Select(e => new Queue<SearchSource>(found.Values.Where(s => s.Engine == e.Name))).ToArray();
        var ordered = new List<SearchSource>();
        while (queues.Any(q => q.Count > 0)) foreach (var queue in queues) if (queue.TryDequeue(out var source)) ordered.Add(source);
        return new SearchBatch(ordered.Take(candidateLimit).ToArray(), outcomes.ToArray());
    }, ct);
    public Task<WebPage> ReadAsync(string url, CancellationToken ct) => UseAsync<WebPage>(driver =>
    {
        var uri = PublicWeb.ValidateUri(url); ct.ThrowIfCancellationRequested();
        try
        {
            driver.Navigate().GoToUrl(uri.AbsoluteUri); WaitFor(driver, "body", ct);
            Capture();
            string text = "";
            var readyUntil = DateTime.UtcNow.AddSeconds(8);
            do
            {
                ct.ThrowIfCancellationRequested();
                text = ((IJavaScriptExecutor)driver).ExecuteScript("return (document.querySelector('article,main,[role=main]') || document.body)?.innerText || '';")?.ToString() ?? "";
                if (text.Trim().Length >= 160) break;
                ct.WaitHandle.WaitOne(200);
            } while (DateTime.UtcNow < readyUntil);
            string final = PublicWeb.ValidateUri(driver.Url).AbsoluteUri;
            string lower = text[..Math.Min(text.Length, 1500)].ToLowerInvariant();
            bool blocked = new[] { "verify you are human", "unusual traffic", "access denied", "enable javascript and cookies", "checking your browser", "complete the captcha" }.Any(lower.Contains);
            if (blocked || text.Trim().Length < 160) return new(final, driver.Title, false, "", "Blocked, unreadable or too little public text.", DateTimeOffset.UtcNow);
            ct.ThrowIfCancellationRequested();
            return new(final, driver.Title[..Math.Min(driver.Title.Length, 200)], true, text[..Math.Min(text.Length, 16000)], "", DateTimeOffset.UtcNow);
        }
        catch (WebDriverException) { return new(uri.AbsoluteUri, "", false, "", "Page navigation failed or timed out.", DateTimeOffset.UtcNow); }
    }, ct);
    private static void WaitFor(EdgeDriver driver, string selector, CancellationToken ct)
    {
        var until = DateTime.UtcNow.AddSeconds(8);
        do { ct.ThrowIfCancellationRequested(); if (driver.FindElements(By.CssSelector(selector)).Count > 0) return; ct.WaitHandle.WaitOne(200); } while (DateTime.UtcNow < until);
    }
    private static string DescribeUnavailable(EdgeDriver driver)
    {
        string text = ((IJavaScriptExecutor)driver).ExecuteScript("return document.body?.innerText || '';")?.ToString() ?? "";
        string markupText = driver.FindElement(By.TagName("body")).GetDomProperty("textContent") ?? text;
        if (new[] { "unusual traffic", "verify you are human", "captcha", "checking your browser", "complete the following challenge", "bots use DuckDuckGo too" }.Any(s => markupText.Contains(s, StringComparison.OrdinalIgnoreCase)))
            return "The engine displayed an automated-access challenge; no results were extracted.";
        text = string.Join(" ", text.Split((char[]?)null, StringSplitOptions.RemoveEmptyEntries));
        return $"No result links. Page: {driver.Title}; host: {new Uri(driver.Url).Host}; excerpt: {text[..Math.Min(text.Length, 600)]}";
    }
    private static string Unwrap(string href)
    {
        if (!Uri.TryCreate(href, UriKind.Absolute, out var uri)) return href;
        var query = uri.Query.TrimStart('?').Split('&').Select(p => p.Split('=', 2)).Where(p => p.Length == 2).GroupBy(p => p[0], StringComparer.OrdinalIgnoreCase).ToDictionary(g => g.Key, g => Uri.UnescapeDataString(g.First()[1]), StringComparer.OrdinalIgnoreCase);
        bool Host(string domain) => uri.Host.Equals(domain, StringComparison.OrdinalIgnoreCase) || uri.Host.EndsWith("." + domain, StringComparison.OrdinalIgnoreCase);
        if (Host("duckduckgo.com") && query.TryGetValue("uddg", out var target)) return target;
        if (Host("google.com") && uri.AbsolutePath == "/url" && query.TryGetValue("q", out target)) return target;
        if (Host("bing.com") && query.TryGetValue("u", out target) && target.StartsWith("a1"))
        {
            try { string encoded = target[2..].Replace('-', '+').Replace('_', '/'); return System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encoded.PadRight((encoded.Length + 3) / 4 * 4, '='))); } catch (FormatException) { }
        }
        return href;
    }
}

1
2

global using System.IO;
global using System.Net.Http;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup><OutputType>WinExe</OutputType><TargetFramework>net10.0-windows</TargetFramework><UseWPF>true</UseWPF><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup>
  <PropertyGroup><ApplicationIcon>Assets/Lilith.ico</ApplicationIcon></PropertyGroup>
  <ItemGroup>
    <Resource Include="Assets/Lilith.ico" />
    <PackageReference Include="Microsoft.Web.WebView2" Version="1.0.4258.31" />
    <PackageReference Include="Selenium.WebDriver" Version="4.51.0" />
    <Compile Include="../LilithGui/GuiSession.cs" Link="Backend/GuiSession.cs" />
    <Compile Include="../LilithGui/VersionCatalog.cs" Link="Backend/VersionCatalog.cs" />
    <Compile Include="../LilithGui/GuiTray.cs" Link="GuiTray.cs" />
    <Compile Include="../../../Lilith/Core/WebResearch/PublicWeb.cs" Link="Research/PublicWeb.cs" />
    <Compile Include="../../../Lilith/Core/WebResearch/PublicWebProxy.cs" Link="Research/PublicWebProxy.cs" />
    <Compile Include="../../../Lilith/Core/WebResearch/ResearchModels.cs" Link="Research/ResearchModels.cs" />
  </ItemGroup>
</Project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302

using System.ComponentModel;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text.Json;
using System.Windows;
using System.Windows.Input;
using System.Windows.Threading;
using System.Windows.Interop;
using Lilith.Core.WebResearch;
using Lilith.Gui;
using Microsoft.Web.WebView2.Core;
using OpenQA.Selenium.Edge;

namespace Lilith.Desktop;

public partial class MainWindow : Window
{
    private readonly string _repo;
    private readonly GuiSession _session;
    private readonly DispatcherTimer _events = new() { Interval=TimeSpan.FromMilliseconds(100) };
    private long _sequence;
    private bool _closing,_closed,_fullscreen;
    private WindowState _previousState;
    private GuiTray? _tray;
    private EmbeddedResearchBrowser? _browser;
    private CoreWebView2Environment? _researchEnvironment;
    private EdgeDriverService? _researchService;
    private readonly SemaphoreSlim _researchGate=new(1,1);
    private readonly CancellationTokenSource _shutdown=new();
    private ApprovalWindow? _approvalWindow;
    private const string UiHost="lilith.example";
    public MainWindow()
    {
        InitializeComponent();
        _repo=Directory.GetCurrentDirectory();
        while(!File.Exists(Path.Combine(_repo,"Version.props")))
            _repo=Directory.GetParent(_repo)?.FullName??throw new DirectoryNotFoundException("Start inside the Lilith repository.");
        string? testState=Environment.GetCommandLineArgs().Any(a=>a.EndsWith("-check"))?Path.Combine(_repo,"Admin","TestResults","Latest","Desktop","State"):null;
        _session=new(_repo,testState){BrowserRequest=BrowserRequest};
        _events.Tick+=PumpEvents;
        ComponentDispatcher.ThreadPreprocessMessage+=DesktopKey;
    }
    private async void OnLoaded(object sender,RoutedEventArgs e)
    {
        try
        {
            CheckLog("Window loaded; initializing WebView2.");
            var environment=await CoreWebView2Environment.CreateAsync(userDataFolder:Path.Combine(_repo,"Admin","GuiState","Desktop","Interface"));
            CheckLog("WebView2 runtime: "+environment.BrowserVersionString);
            await Interface.EnsureCoreWebView2Async(environment);
            CheckLog("Interface initialized.");
            // Serve an explicit asset allowlist from native code. WebView's sandbox
            // never needs filesystem access to the user's source checkout.
            Interface.CoreWebView2.AddWebResourceRequestedFilter("https://"+UiHost+"/*",CoreWebView2WebResourceContext.All);
            Interface.CoreWebView2.WebResourceRequested+=(_,args)=>
            {
                string path=new Uri(args.Request.Uri).AbsolutePath;
                string? file=path switch{"/"=>"index.html","/app.js"=>"app.js","/app.css"=>"app.css","/favicon.svg"=>"favicon.svg",_=>null};
                string mime=path switch{"/app.js"=>"text/javascript","/app.css"=>"text/css","/favicon.svg"=>"image/svg+xml",_=>"text/html"};
                var stream=new MemoryStream(file is null?[]:File.ReadAllBytes(Path.Combine(_repo,"Interfaces","Gui","LilithGui","wwwroot",file)));
                args.Response=environment.CreateWebResourceResponse(stream,file is null?404:200,file is null?"Not Found":"OK","Content-Type: "+mime+"; charset=utf-8\r\nCache-Control: no-store\r\nX-Content-Type-Options: nosniff");
            };
            Interface.CoreWebView2.Settings.AreDevToolsEnabled=false;
            Interface.CoreWebView2.NavigationStarting+=(_,args)=>{if(!args.Uri.StartsWith("https://"+UiHost+"/",StringComparison.Ordinal))args.Cancel=true;};
            Interface.CoreWebView2.NewWindowRequested+=(_,args)=>args.Handled=true;
            Interface.CoreWebView2.WebMessageReceived+=OnWebMessage;
            Interface.CoreWebView2.NavigationCompleted+=(_,args)=>CheckLog("Navigation: "+args.IsSuccess+" "+args.WebErrorStatus);
            await Interface.CoreWebView2.AddScriptToExecuteOnDocumentCreatedAsync("""
                (()=>{const pending=new Map();let sequence=0;window.addEventListener("keydown",e=>{if(e.key==="F11"){e.preventDefault();chrome.webview.postMessage({id:"fullscreen",path:"/native/fullscreen",body:null});}},true);
                chrome.webview.addEventListener('message',e=>{const p=pending.get(e.data.id);if(!p)return;pending.delete(e.data.id);const r=e.data.result;p.resolve(r?.image?new Response(Uint8Array.from(atob(r.image),c=>c.charCodeAt(0)),{headers:{'Content-Type':'image/png'}}):new Response(JSON.stringify(e.data.error?{error:e.data.error}:r),{status:e.data.error?409:200,headers:{'Content-Type':'application/json'}}));});
                window.fetch=(path,options={})=>{const id=String(++sequence);return new Promise((resolve,reject)=>{pending.set(id,{resolve,reject});chrome.webview.postMessage({id,path:String(path),body:options.body?JSON.parse(options.body):null});});};
                })();
                """);
            Interface.Source=new Uri("https://"+UiHost+"/");
            _events.Start();
            try{_tray=new GuiTray(()=>Dispatcher.BeginInvoke(()=>{Show();WindowState=WindowState.Normal;Activate();}));}
            catch(Exception ex){Title="Lilith — tray unavailable: "+ex.Message;}
            if(Environment.GetCommandLineArgs().Any(a=>a is "--desktop-check" or "--browser-check" or "--live-v8-check"))_=RunChecks();
        }
        catch(Exception ex){CheckLog(ex.ToString());if(Environment.GetCommandLineArgs().Any(a=>a.EndsWith("-check")))Close();else MessageBox.Show(this,ex.Message,"Lilith desktop could not start");}
    }
    private void CheckLog(string text)
    {
        if(!Environment.GetCommandLineArgs().Any(a=>a.EndsWith("-check")))return;
        string folder=Path.Combine(_repo,"Admin","TestResults","Latest","Desktop");Directory.CreateDirectory(folder);
        File.AppendAllText(Path.Combine(folder,"startup.log"),DateTimeOffset.Now+" "+text+Environment.NewLine);
    }
    private void DesktopKey(ref MSG message,ref bool handled)
    {
        if(!handled&&message.message==0x100&&message.wParam.ToInt32()==122&&(message.lParam.ToInt64()&(1L<<30))==0)
        {handled=true;ToggleFullscreen();}
    }
    private async void OnWebMessage(object? sender,CoreWebView2WebMessageReceivedEventArgs e)
    {
        string? id=null;
        try
        {
            if(!e.Source.StartsWith("https://"+UiHost+"/",StringComparison.Ordinal))return;
            var request=JsonDocument.Parse(e.WebMessageAsJson).RootElement.Clone();
            id=request.GetProperty("id").GetString();string path=request.GetProperty("path").GetString()!;
            var body=request.GetProperty("body");object? result;
            if(path=="/native/fullscreen"){ToggleFullscreen();result=new{};}
            else if(path=="/native/approval")
            {
                if(_approvalWindow is not null){_approvalWindow.Activate();result=new{pending=true};}
                else
                {
                    var pending=await _session.SendAsync("approvals",JsonSerializer.SerializeToElement(new{}));
                    var proposal=pending.EnumerateArray().SingleOrDefault(p=>p.GetProperty("Id").GetString()==body.GetProperty("id").GetString()&&p.GetProperty("Service").GetString()==body.GetProperty("service").GetString());
                    if(proposal.ValueKind==JsonValueKind.Undefined)throw new InvalidOperationException("This approval is no longer pending.");
                    bool decided=false;
                    _approvalWindow=new ApprovalWindow(this,proposal,async approve=>
                    {
                        await _session.SendAsync("approval_decide",JsonSerializer.SerializeToElement(new{id=proposal.GetProperty("Id").GetString(),service=proposal.GetProperty("Service").GetString(),fingerprint=proposal.GetProperty("Fingerprint").GetString(),approve}));decided=true;
                    });
                    try{_approvalWindow.ShowDialog();}finally{_approvalWindow=null;}
                    result=new{decided};
                }
            }
            else if(path=="/api/versions")result=await new VersionCatalog(_repo).ListAsync();
            else if(path=="/api/session")result=_session.Summary();
            else if(path.StartsWith("/api/image/"))result=new{image=Convert.ToBase64String(_session.ReadImage(path[11..]))};
            else if(path.StartsWith("/api/events?after="))result=Array.Empty<object>(); // Native event push owns delivery.
            else if(path=="/api/boot")
            {
                await CloseResearch();result=await _session.BootAsync(body.GetProperty("major").GetInt32(),body);await CloseResearch();
            }
            else if(path=="/api/action")
            {
                string action=body.GetProperty("action").GetString()!;
                if(action is not("chat" or "command" or "panel" or "scenario" or "history" or "cancel" or "approvals" or "approval_decide"))throw new ArgumentException("Unknown action.");
                try{result=await _session.SendAsync(action,body);}
                finally{if(action is "chat" or "scenario" or "command")await CloseResearch();}
            }
            else throw new NotSupportedException("Unknown desktop request.");
            Interface.CoreWebView2.PostWebMessageAsJson(JsonSerializer.Serialize(new{id,result}));
        }
        catch(Exception ex){if(id is not null&&!_closed)Interface.CoreWebView2.PostWebMessageAsJson(JsonSerializer.Serialize(new{id,error=ex.Message}));}
    }
    private async void PumpEvents(object? sender,EventArgs e)
    {
        if(_closed||Interface.CoreWebView2 is null)return;
        _events.Stop();
        try
        {
            foreach(var item in _session.Events(_sequence))
            {
                await Interface.ExecuteScriptAsync("consumeEvent(normalize("+JsonSerializer.Serialize(item,new JsonSerializerOptions{PropertyNamingPolicy=JsonNamingPolicy.CamelCase})+"));");
                _sequence=item.Sequence;
            }
        }
        catch(Exception ex){Title="Lilith — "+ex.Message;}
        finally{if(!_closing)_events.Start();}
    }
    private async Task<object> BrowserRequest(JsonElement data)
    {
        await _researchGate.WaitAsync();
        try
        {
            if(_browser is null)
            {
                var options=data.GetProperty("options").Deserialize<BrowserResearchOptions>(new JsonSerializerOptions{PropertyNameCaseInsensitive=true})!;
                _browser=new EmbeddedResearchBrowser(options,reportLifecycle:s=>_session.Emit("trace",new{sender="Embedded Selenium",text=s}),createEmbedded:proxy=>Dispatcher.InvokeAsync(()=>AttachBrowser(proxy)).Task.Unwrap().GetAwaiter().GetResult());
            }
            string value=data.GetProperty("value").GetString()!;
            using var timeout=CancellationTokenSource.CreateLinkedTokenSource(_shutdown.Token);timeout.CancelAfter(TimeSpan.FromMinutes(3));
            return data.GetProperty("operation").GetString() switch
            {
                "SearchAsync"=>await _browser.SearchAsync(value,data.GetProperty("limit").GetInt32(),timeout.Token),
                "ReadAsync"=>await _browser.ReadAsync(value,timeout.Token),
                _=>throw new NotSupportedException("Unknown embedded browser operation.")
            };
        }
        finally{_researchGate.Release();}
    }
    private async Task<EdgeDriver> AttachBrowser(PublicWebProxy proxy)
    {
        BrowserPanel.Visibility=Visibility.Visible;ArrangeBrowser();BrowserStatus.Text="Starting embedded browser…";
        using var listener=new TcpListener(IPAddress.Loopback,0);listener.Start();int port=((IPEndPoint)listener.LocalEndpoint).Port;listener.Stop();
        var settings=new CoreWebView2EnvironmentOptions($"--remote-debugging-port={port} --disable-quic --disable-background-networking --force-webrtc-ip-handling-policy=disable_non_proxied_udp --proxy-server=http://127.0.0.1:{proxy.Port} --proxy-bypass-list=<-loopback>");
        _researchEnvironment=await CoreWebView2Environment.CreateAsync(userDataFolder:Path.Combine(_repo,"Admin","GuiState","Desktop","Research"),options:settings);
        await Research.EnsureCoreWebView2Async(_researchEnvironment);
        await Research.CoreWebView2.Profile.ClearBrowsingDataAsync();
        Research.CoreWebView2.Settings.AreDevToolsEnabled=false;
        Research.CoreWebView2.NewWindowRequested+=(_,e)=>e.Handled=true;
        Research.CoreWebView2.DownloadStarting+=(_,e)=>e.Cancel=true;
        Research.CoreWebView2.PermissionRequested+=(_,e)=>e.State=CoreWebView2PermissionState.Deny;
        Research.CoreWebView2.SourceChanged+=(_,_)=>BrowserStatus.Text=Research.Source?.ToString()??"Research";
        var options=new EdgeOptions{UseWebView=true,DebuggerAddress="127.0.0.1:"+port,PageLoadStrategy=OpenQA.Selenium.PageLoadStrategy.Eager};
        string executable=await EdgeDriverLocator.ResolveAsync(_repo,_researchEnvironment.BrowserVersionString.Split(' ')[0]);
        var service=EdgeDriverService.CreateDefaultService(Path.GetDirectoryName(executable));service.HideCommandPromptWindow=true;
        EdgeDriver driver;
        try{driver=await Task.Run(()=>new EdgeDriver(service,options,TimeSpan.FromSeconds(40)));}
        catch{service.Dispose();throw;}
        _researchService=service;
        driver.Manage().Timeouts().PageLoad=TimeSpan.FromSeconds(25);
        return driver;
    }
    private async Task CloseResearch()
    {
        await _researchGate.WaitAsync();
        try
        {
            if(_browser is null)return;
            CheckLog("Disconnecting research automation.");
            await Task.Run(()=>{_researchService?.Dispose();_browser.Dispose();});_researchService=null;_browser=null;
            CheckLog("Disposing research control.");
            await Dispatcher.InvokeAsync(()=>{Research.Dispose();var old=Research;Research=new Microsoft.Web.WebView2.Wpf.WebView2();var panel=(System.Windows.Controls.DockPanel)BrowserPanel.Child;panel.Children.Remove(old);panel.Children.Add(Research);_researchEnvironment=null;BrowserStatus.Text="Research finished";BrowserPanel.Visibility=Visibility.Collapsed;ArrangeBrowser();});
        }
        finally{_researchGate.Release();}
    }
    private void OnSizeChanged(object sender,SizeChangedEventArgs e)=>ArrangeBrowser();
    private void ArrangeBrowser()
    {
        if(BrowserColumn is null)return;
        bool shown=BrowserPanel.Visibility==Visibility.Visible,stacked=ActualWidth<1050;
        BrowserColumn.Width=shown&&!stacked?new GridLength(1,GridUnitType.Star):new GridLength(0);
        Layout.ColumnDefinitions[0].Width=shown&&!stacked?new GridLength(2,GridUnitType.Star):new GridLength(1,GridUnitType.Star);
        BrowserRow.Height=shown&&stacked?new GridLength(1,GridUnitType.Star):new GridLength(0);
        System.Windows.Controls.Grid.SetColumn(BrowserPanel,stacked?0:1);System.Windows.Controls.Grid.SetRow(BrowserPanel,stacked?1:0);
    }
    private void OnKeyDown(object sender,KeyEventArgs e)
    {
        if(e.Key!=Key.F11)return;e.Handled=true;ToggleFullscreen();
    }
    private void ToggleFullscreen()
    {
        if(!_fullscreen){_previousState=WindowState;WindowState=WindowState.Normal;WindowStyle=WindowStyle.None;ResizeMode=ResizeMode.NoResize;WindowState=WindowState.Maximized;}
        else{WindowState=WindowState.Normal;WindowStyle=WindowStyle.SingleBorderWindow;ResizeMode=ResizeMode.CanResize;WindowState=_previousState;}
        _fullscreen=!_fullscreen;
    }
    private async Task RunChecks()
    {
        string output=Path.Combine(_repo,"Admin","TestResults","Latest","Desktop");Directory.CreateDirectory(output);
        try
        {
            for(int i=0;i<100;i++){await Task.Delay(200);if(await Interface.ExecuteScriptAsync("typeof state !== 'undefined' && state.versions.length > 0")=="true")break;}
            if(await Interface.ExecuteScriptAsync("typeof state !== 'undefined' && !!document.getElementById('composer')")!="true")
                throw new Exception("Desktop interface did not load: "+await Interface.ExecuteScriptAsync("document.body.innerText"));
            await Interface.ExecuteScriptAsync("""
                activityPreference(true);
                addActivity({sequence:900001,kind:'scenario',data:{runId:'layout-fixture',scenarioId:'Layout fixture',kind:'Started',step:1,totalSteps:2,text:'Fixture only; no scenario executed.'}});
                addActivity({sequence:900002,kind:'tool',data:{id:'layout-tool',name:'Fixture tool',kind:'Result',text:'<img src=x onerror=alert(1)>'}});
                document.querySelector('.activity-notice').dispatchEvent(new Event('mouseenter'));
                """);
            if(await Interface.ExecuteScriptAsync("document.querySelectorAll('.activity-card').length===2 && !!document.querySelector('.activity-card.activity-highlight') && !document.querySelector('.activity-card img')")!="true")throw new Exception("Activity cards, safe content or hover highlighting failed.");
            await Interface.ExecuteScriptAsync("activityPreference(false)");
            if(await Interface.ExecuteScriptAsync("$('activity-sidebar').hidden && getComputedStyle(document.querySelector('.activity-notice')).display==='none' && localStorage.getItem('lilith-show-activity')==='false'")!="true")throw new Exception("GUI activity setting did not hide or persist.");
            await Interface.ExecuteScriptAsync("activityPreference(true)");
            await Interface.ExecuteScriptAsync("""
                state.ready=true;state.busy=false;state.booting=true;updateComposer();
                """);
            if(await Interface.ExecuteScriptAsync("$('prompt').disabled && $('cancel').disabled && $('cancel').textContent==='Booting'")!="true")throw new Exception("Boot controls are not disabled and labelled Booting.");
            await Interface.ExecuteScriptAsync("""
                state.booting=false;
                applyApprovals([{id:'fixture-proposal',service:'workspace',title:'Fixture approval — no operation',review:{request:{operation:'save',path:'fixture.txt',content:'Fixture only'}},fingerprint:'fixture'}]);
                """);
            if(await Interface.ExecuteScriptAsync("$('prompt').disabled && $('send').disabled && !!document.querySelector('.approval-card')")!="true")throw new Exception("Pending approval did not lock chat or create a clickable receipt.");
            var fixture=JsonSerializer.SerializeToElement(new{Id="fixture-proposal",Service="workspace",Title="Fixture approval — no operation",Review=new{Request=new{Operation="save",Path="fixture.txt",Content="Fixture only"}}});
            var approvalCheck=new ApprovalWindow(this,fixture,_=>throw new Exception("Layout checks cannot approve actions."));
            approvalCheck.Show();await Task.Delay(100);if(!approvalCheck.IsVisible)throw new Exception("Native approval window did not open.");approvalCheck.Close();
            await Interface.ExecuteScriptAsync("applyApprovals([]);state.ready=false;$('gui-settings').close();updateComposer();");
            foreach(var size in new[]{(1360d,900d),(800d,700d),(520d,600d)})
            {
                Width=size.Item1;Height=size.Item2;await Task.Delay(300);
                if(await Interface.ExecuteScriptAsync("document.documentElement.scrollWidth <= innerWidth")!="true")throw new Exception("Horizontal overflow at "+size+": "+await Interface.ExecuteScriptAsync("JSON.stringify([...document.querySelectorAll(\"*\")].filter(e=>e.getBoundingClientRect().right>innerWidth+1).map(e=>e.tagName+\".\"+e.className).slice(0,15))"));
            }
            ToggleFullscreen();if(WindowStyle!=WindowStyle.None)throw new Exception("F11 did not enter fullscreen.");ToggleFullscreen();
            if(WindowStyle!=WindowStyle.SingleBorderWindow)throw new Exception("F11 did not restore window chrome.");
            Width=1360;Height=900;
            using(var screenshot=File.Create(Path.Combine(output,"desktop.png")))await Interface.CoreWebView2.CapturePreviewAsync(CoreWebView2CapturePreviewImageFormat.Png,screenshot).WaitAsync(TimeSpan.FromSeconds(15));
            if(Environment.GetCommandLineArgs().Contains("--browser-check"))
            {
                var request=JsonSerializer.SerializeToElement(new{operation="ReadAsync",value="https://www.selenium.dev/documentation/webdriver/",options=BrowserResearchOptions.Default});
                var page=(WebPage)await BrowserRequest(request);
                if(!page.Readable||!page.Text.Contains("WebDriver",StringComparison.OrdinalIgnoreCase))throw new Exception("Embedded Selenium could not read public documentation: "+page.Error);
                File.WriteAllText(Path.Combine(output,"browser.json"),JsonSerializer.Serialize(page));
                using(var screenshot=File.Create(Path.Combine(output,"browser.png")))await Research.CoreWebView2.CapturePreviewAsync(CoreWebView2CapturePreviewImageFormat.Png,screenshot).WaitAsync(TimeSpan.FromSeconds(15));
                await CloseResearch();
            }
            if(Environment.GetCommandLineArgs().Contains("--live-v8-check"))
            {
                await _session.BootAsync(8,JsonSerializer.SerializeToElement(new{major=8,model="gemma4",provider="Ollama",name="Lilith",speech=false,mode="Ask"}));
                var result=await _session.SendAsync("chat",JsonSerializer.SerializeToElement(new{text="When does GTA 6 come out? Use 5 sources. Call run_scenario with {\"scenario_name\":\"web_research\",\"inputs\":{\"question\":\"When does GTA 6 come out?\",\"source_count\":\"5\"}}.",clientId="desktop-check"}));
                File.WriteAllText(Path.Combine(output,"live-events.json"),JsonSerializer.Serialize(_session.Events(0)));
                string events=File.ReadAllText(Path.Combine(output,"live-events.json"));
                if(!events.Contains("Sources read: 5 of 5")||events.Contains("Web research failed."))throw new Exception("Live V8 research did not qualify; inspect live-events.json.");
                await CloseResearch();
            }
            File.WriteAllText(Path.Combine(output,"result.txt"),"PASS: "+string.Join(' ',Environment.GetCommandLineArgs().Skip(1)));
        }
        catch(Exception ex){File.WriteAllText(Path.Combine(output,"result.txt"),"FAIL: "+ex);}
        finally{Close();}
    }
    private async void OnClosing(object? sender,CancelEventArgs e)
    {
        if(_closed)return;e.Cancel=true;if(_closing)return;_closing=true;_events.Stop();_shutdown.Cancel();
        try{await _session.DisposeAsync();await CloseResearch();}
        finally{ComponentDispatcher.ThreadPreprocessMessage-=DesktopKey;_tray?.Dispose();Interface.Dispose();Research.Dispose();_closed=true;_ = Dispatcher.BeginInvoke(Close);}
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

using System.Diagnostics;
using System.Text.Json;

namespace Lilith.Gui;

internal sealed record GuiEvent(long Sequence,string Kind,JsonElement Data);
internal sealed class GuiSession(string repo,string? stateRoot=null) : IAsyncDisposable
{
    private readonly object _sync=new();
    private readonly List<GuiEvent> _events=[];
    private readonly Dictionary<string,TaskCompletionSource<JsonElement>> _pending=[];
    private readonly Dictionary<string,string> _images=new(StringComparer.Ordinal);
    private readonly SemaphoreSlim _lifecycle=new(1,1);
    private readonly SemaphoreSlim _writes=new(1,1);
    private Process? _worker;
    private long _sequence;
    private JsonElement? _ready,_status;
    internal Func<JsonElement,Task<object>>? BrowserRequest {get;set;}
    internal GuiVersion? Version {get;private set;}
    internal void Emit(string kind,object data)
    {
        var element=JsonSerializer.SerializeToElement(data);
        lock(_sync)
        {
            if(kind=="reset"){_ready=null;_images.Clear();}
            if(kind=="ready")_ready=element;
            if(kind=="status")_status=element;
            if(kind=="images"&&element.ValueKind==JsonValueKind.Array)
                foreach(var image in element.EnumerateArray())
                {
                    string? hash=image.EnumerateObject().FirstOrDefault(p=>p.Name.Equals("sha256",StringComparison.OrdinalIgnoreCase)).Value.GetString();
                    string? file=image.EnumerateObject().FirstOrDefault(p=>p.Name.Equals("file",StringComparison.OrdinalIgnoreCase)).Value.GetString();
                    if(hash is not null&&file is not null)_images[hash]=file;
                }
            while(_images.Count>100)_images.Remove(_images.Keys.First());
            _events.Add(new(++_sequence,kind,element));if(_events.Count>2000)_events.RemoveRange(0,_events.Count-2000);
        }
    }
    internal byte[] ReadImage(string hash)
    {
        string file;lock(_sync)file=_images.GetValueOrDefault(hash)??throw new FileNotFoundException("Unknown image artifact.");
        string path=Path.GetFullPath(file),root=Path.GetFullPath(Path.Combine(repo,"Admin","GuiState"))+Path.DirectorySeparatorChar;
        if(!path.StartsWith(root,StringComparison.OrdinalIgnoreCase))throw new IOException("Image is outside GUI-owned state.");
        string? check=path;
        while(check is not null&&check.StartsWith(root,StringComparison.OrdinalIgnoreCase))
        {if((File.GetAttributes(check)&FileAttributes.ReparsePoint)!=0)throw new IOException("Linked artifacts are not served.");check=Path.GetDirectoryName(check);}
        if(new FileInfo(path).Length>16000000)throw new IOException("Oversized image.");byte[] bytes=File.ReadAllBytes(path);
        if(Convert.ToHexString(System.Security.Cryptography.SHA256.HashData(bytes))!=hash)throw new IOException("Image changed since capture.");
        return bytes;
    }
    internal GuiEvent[] Events(long after){lock(_sync)return _events.Where(e=>e.Sequence>after).Take(500).ToArray();}
    internal object Summary(){lock(_sync)return new{version=Version,ready=_ready,status=_status,sequence=_sequence};}
    internal async Task<JsonElement> BootAsync(int major,JsonElement settings)
    {
        await _lifecycle.WaitAsync();
        try
        {
            await StopAsync();
            var catalog=new VersionCatalog(repo);var version=(await catalog.ListAsync()).Single(v=>v.Major==major);
            Version=version;
            Emit("reset",new{version});
            string backend=await catalog.PrepareAsync(version,text=>Emit("status",new{state="starting",text}));
            string workerProject=Path.Combine(repo,"Interfaces","Gui","LilithGui.Worker","LilithGui.Worker.csproj");
            await VersionCatalog.Run("dotnet",["build",workerProject,"-c","Release","-p:NuGetAudit=false"],repo);
            string worker=Path.Combine(repo,"Admin","Build","bin","Interfaces","Gui","LilithGui.Worker","LilithGui.Worker","Release","net10.0","LilithGui.Worker.dll");
            var start=new ProcessStartInfo("dotnet"){WorkingDirectory=backend,RedirectStandardInput=true,RedirectStandardOutput=true,RedirectStandardError=true,UseShellExecute=false,CreateNoWindow=true};
            start.ArgumentList.Add(worker);start.ArgumentList.Add(backend);
            string state=Path.Combine(stateRoot??Path.Combine(repo,"Admin","GuiState"),"v"+major);Directory.CreateDirectory(state);
            start.ArgumentList.Add(state);start.Environment["AGENT_CORE_CHAT_HISTORY_ROOT"]=Path.Combine(state,"History");
            if(BrowserRequest is not null)start.Environment["LILITH_DESKTOP_BROWSER"]="1";
            start.Environment["LILITH_SCENARIOS_ROOT"]=Path.Combine(backend,"Scenarios");
            // Historical localhost probes have a two-second IPv6 fallback timeout.
            // This affects only the isolated worker, not the user's/global network settings.
            start.Environment["DOTNET_SYSTEM_NET_DISABLEIPV6"]="1";
            _worker=Process.Start(start)??throw new IOException("Backend worker failed to start.");Version=version;
            _=ReadAsync(_worker);_=ReadErrors(_worker);
            return await SendAsync("boot",settings);
        }
        finally{_lifecycle.Release();}
    }
    private async Task ReadAsync(Process process)
    {
        while(await process.StandardOutput.ReadLineAsync() is {} line)
        {
            if(!line.StartsWith("@lilith-gui ",StringComparison.Ordinal))continue;
            try
            {
                using var doc=JsonDocument.Parse(line[12..]);var root=doc.RootElement;string kind=root.GetProperty("kind").GetString()!;var data=root.GetProperty("data").Clone();
                if(kind=="browser_request"&&BrowserRequest is not null){_=HandleBrowserAsync(process,data);continue;}
                if(kind=="reply")
                {
                    string id=data.GetProperty("id").GetString()!;TaskCompletionSource<JsonElement>? completion;
                    lock(_sync){_pending.Remove(id,out completion);}
                    if(data.TryGetProperty("error",out var error))completion?.TrySetException(new InvalidOperationException(error.GetString()));else completion?.TrySetResult(data.GetProperty("result").Clone());
                }
                else Emit(kind,data);
            }
            catch(JsonException){Emit("trace",new{sender="GUI",text="Invalid backend event was ignored."});}
        }
        if(ReferenceEquals(_worker,process))
            lock(_sync){_ready=null;foreach(var pending in _pending.Values)pending.TrySetException(new IOException("Backend process closed."));_pending.Clear();}
    }
    private async Task ReadErrors(Process process){while(await process.StandardError.ReadLineAsync() is {} line)Emit("trace",new{sender="Backend",text=line[..Math.Min(2000,line.Length)]});}
    private async Task HandleBrowserAsync(Process owner,JsonElement data)
    {
        object payload;
        try{payload=new{requestId=data.GetProperty("requestId").GetString(),result=await BrowserRequest!(data)};}
        catch(Exception ex){payload=new{requestId=data.GetProperty("requestId").GetString(),error=ex.Message};}
        await _writes.WaitAsync();
        try{if(ReferenceEquals(_worker,owner)&&!owner.HasExited){await owner.StandardInput.WriteLineAsync(JsonSerializer.Serialize(new{id="browser",action="browser_result",payload}));await owner.StandardInput.FlushAsync();}}
        finally{_writes.Release();}
    }
    internal async Task<JsonElement> SendAsync(string action,JsonElement payload)
    {
        if(_worker is null||_worker.HasExited)throw new InvalidOperationException("Start a version first.");
        string id=Guid.NewGuid().ToString("N");var completion=new TaskCompletionSource<JsonElement>(TaskCreationOptions.RunContinuationsAsynchronously);
        lock(_sync)_pending[id]=completion;
        await _writes.WaitAsync();
        try{await _worker.StandardInput.WriteLineAsync(JsonSerializer.Serialize(new{id,action,payload}));await _worker.StandardInput.FlushAsync();}
        finally{_writes.Release();}
        return await completion.Task.WaitAsync(TimeSpan.FromMinutes(45));
    }
    private async Task StopAsync()
    {
        if(_worker is null)return;
        if(!_worker.HasExited)
        {
            try{await SendAsync("stop",JsonSerializer.SerializeToElement(new{})).WaitAsync(TimeSpan.FromSeconds(15));await _worker.WaitForExitAsync().WaitAsync(TimeSpan.FromSeconds(5));}
            catch(Exception){if(!_worker.HasExited)_worker.Kill(true);}
        }
        _worker.Dispose();_worker=null;Version=null;
    }
    public async ValueTask DisposeAsync()=>await StopAsync();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

using System.Diagnostics;
using System.Runtime.InteropServices;

namespace Lilith.Gui;

// A small native message loop keeps the tray independent of the web-host threads.
internal sealed class GuiTray : IDisposable
{
    private const uint Callback = 0x8001;
    private readonly Action _open;
    private readonly Thread _thread;
    private readonly WindowProc _procedure;
    private readonly ManualResetEventSlim _started = new();
    private IntPtr _window, _icon;
    private Exception? _error;
    private readonly string _className = "LilithTray" + Guid.NewGuid().ToString("N");

    internal GuiTray(string url):this(()=>Process.Start(new ProcessStartInfo(url){UseShellExecute=true})) { }
    internal GuiTray(Action open)
    {
        _open = open;
        _procedure = OnMessage;
        _thread = new Thread(Run) { IsBackground = true, Name = "Lilith tray" };
        _thread.Start();
        _started.Wait();
        if (_error is not null) { _thread.Join(); _started.Dispose(); throw new InvalidOperationException("Tray could not start.", _error); }
    }

    private void Run()
    {
        var instance = GetModuleHandle(null);
        try
        {
            var cls = new WindowClass { procedure = _procedure, instance = instance, className = _className };
            if (RegisterClass(ref cls) == 0) throw new System.ComponentModel.Win32Exception();
            _window = CreateWindowEx(0, _className, "Lilith", 0, 0, 0, 0, 0, IntPtr.Zero, IntPtr.Zero, instance, IntPtr.Zero);
            if (_window == IntPtr.Zero) throw new System.ComponentModel.Win32Exception();
            _icon = CreateLogo(instance);
            var data = Data();
            data.flags = 1 | 2 | 4; data.callback = Callback; data.icon = _icon; data.tip = "Lilith — Local Intelligence";
            if (!Shell_NotifyIcon(0, ref data)) throw new InvalidOperationException("Windows Shell rejected notification-icon registration.");
            _started.Set();
            while (GetMessage(out var message, IntPtr.Zero, 0, 0) > 0) { TranslateMessage(ref message); DispatchMessage(ref message); }
        }
        catch (Exception ex) { _error = ex; }
        finally
        {
            _started.Set();
            if (_window != IntPtr.Zero) { var data = Data(); Shell_NotifyIcon(2, ref data); DestroyWindow(_window); }
            if (_icon != IntPtr.Zero) DestroyIcon(_icon);
            UnregisterClass(_className, instance);
        }
    }

    private NotifyData Data() => new() { size = (uint)Marshal.SizeOf<NotifyData>(), window = _window, id = 1 };
    private IntPtr OnMessage(IntPtr window, uint message, IntPtr wParam, IntPtr lParam)
    {
        if (message == Callback && ((int)lParam == 0x202 || (int)lParam == 0x205))
        {
            var menu = CreatePopupMenu();
            try
            {
                AppendMenu(menu, 0, 1, "Open Lilith");
                GetCursorPos(out var point); SetForegroundWindow(window);
                if (TrackPopupMenu(menu, 0x100 | 2, point.x, point.y, 0, window, IntPtr.Zero) == 1)
                    try { _open(); }
                    catch (Exception ex) { Console.WriteLine("Could not open GUI: " + ex.Message); }
                PostMessage(window, 0, IntPtr.Zero, IntPtr.Zero);
            }
            finally { DestroyMenu(menu); }
            return IntPtr.Zero;
        }
        if (message == 0x10) { PostQuitMessage(0); return IntPtr.Zero; }
        return DefWindowProc(window, message, wParam, lParam);
    }

    private static IntPtr CreateLogo(IntPtr instance)
    {
        // Match wwwroot/favicon.svg, including its dark rounded background.
        var mask = Enumerable.Repeat((byte)255, 128).ToArray();
        var pixels = new byte[32 * 32 * 4];
        for (int y = 0; y < 32; y++) for (int x = 0; x < 32; x++)
        {
            double sx = (x + .5) * 1.5, sy = (y + .5) * 1.5;
            double cornerX = Math.Clamp(sx, 8, 40), cornerY = Math.Clamp(sy, 8, 40);
            bool background = (sx - cornerX) * (sx - cornerX) + (sy - cornerY) * (sy - cornerY) <= 64;
            bool ink = (sx >= 7 && sx < 15 && sy >= 12 && sy < 45)
                || (sx >= 7 && sx < 40 && sy >= 37 && sy < 45)
                || ((sx - 34) * (sx - 34) + (sy - 12) * (sy - 12) <= 64);
            if (!background) continue;
            // CreateIcon consumes these device-dependent mask rows top to bottom.
            mask[y * 4 + x / 8] &= (byte)~(128 >> (x % 8));
            int offset = (y * 32 + x) * 4;
            pixels[offset] = ink ? (byte)117 : (byte)14;
            pixels[offset + 1] = ink ? (byte)246 : (byte)16;
            pixels[offset + 2] = ink ? (byte)214 : (byte)11;
            pixels[offset + 3] = 255;
        }
        var icon = CreateIcon(instance, 32, 32, 1, 32, mask, pixels);
        return icon != IntPtr.Zero ? icon : throw new System.ComponentModel.Win32Exception();
    }

    public void Dispose() { if (_thread.IsAlive) { PostMessage(_window, 0x10, IntPtr.Zero, IntPtr.Zero); _thread.Join(); } _started.Dispose(); }
    private delegate IntPtr WindowProc(IntPtr window, uint message, IntPtr wParam, IntPtr lParam);
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct WindowClass { public uint style; public WindowProc procedure; public int classExtra, windowExtra; public IntPtr instance, icon, cursor, background; public string? menu; public string className; }
    [StructLayout(LayoutKind.Sequential)] private struct Point { public int x, y; }
    [StructLayout(LayoutKind.Sequential)] private struct Message { public IntPtr window; public uint message; public UIntPtr wParam; public IntPtr lParam; public uint time; public Point point; public uint privateData; }
    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
    private struct NotifyData
    {
        public uint size; public IntPtr window; public uint id, flags, callback; public IntPtr icon;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] public string? tip;
        public uint state, stateMask;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)] public string? info;
        public uint timeout;
        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 64)] public string? title;
        public uint infoFlags; public Guid guid; public IntPtr balloon;
    }
    [DllImport("kernel32", CharSet = CharSet.Unicode)] private static extern IntPtr GetModuleHandle(string? name);
    [DllImport("user32", CharSet = CharSet.Unicode)] private static extern ushort RegisterClass(ref WindowClass cls);
    [DllImport("user32", CharSet = CharSet.Unicode)] private static extern bool UnregisterClass(string name, IntPtr instance);
    [DllImport("user32", CharSet = CharSet.Unicode)] private static extern IntPtr CreateWindowEx(uint ex, string cls, string title, uint style, int x, int y, int w, int h, IntPtr parent, IntPtr menu, IntPtr instance, IntPtr param);
    [DllImport("user32", CharSet = CharSet.Unicode)] private static extern IntPtr DefWindowProc(IntPtr window, uint message, IntPtr w, IntPtr l);
    [DllImport("user32")] private static extern int GetMessage(out Message message, IntPtr window, uint min, uint max);
    [DllImport("user32")] private static extern bool TranslateMessage(ref Message message);
    [DllImport("user32", CharSet = CharSet.Unicode)] private static extern IntPtr DispatchMessage(ref Message message);
    [DllImport("user32")] private static extern bool PostMessage(IntPtr window, uint message, IntPtr w, IntPtr l);
    [DllImport("user32")] private static extern void PostQuitMessage(int code);
    [DllImport("user32")] private static extern bool DestroyWindow(IntPtr window);
    [DllImport("shell32", CharSet = CharSet.Unicode)] private static extern bool Shell_NotifyIcon(uint action, ref NotifyData data);
    [DllImport("user32")] private static extern IntPtr CreateIcon(IntPtr instance, int width, int height, byte planes, byte bits, byte[] andMask, byte[] xorMask);
    [DllImport("user32")] private static extern bool DestroyIcon(IntPtr icon);
    [DllImport("user32")] private static extern IntPtr CreatePopupMenu();
    [DllImport("user32", CharSet = CharSet.Unicode)] private static extern bool AppendMenu(IntPtr menu, uint flags, uint id, string text);
    [DllImport("user32")] private static extern uint TrackPopupMenu(IntPtr menu, uint flags, int x, int y, int reserved, IntPtr window, IntPtr rect);
    [DllImport("user32")] private static extern bool DestroyMenu(IntPtr menu);
    [DllImport("user32")] private static extern bool GetCursorPos(out Point point);
    [DllImport("user32")] private static extern bool SetForegroundWindow(IntPtr window);
}

1
2
3

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup>
</Project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

using System.Security.Cryptography;
using System.Text.Json;
using Lilith.Gui;

string repo=Directory.GetCurrentDirectory();
bool openBrowser=args.Contains("--open-browser");args=args.Where(a=>a!="--open-browser").ToArray();
while(!File.Exists(Path.Combine(repo,"Version.props"))){repo=Directory.GetParent(repo)?.FullName??throw new DirectoryNotFoundException("Run the GUI inside the Lilith repository.");}
var builder=WebApplication.CreateBuilder(new WebApplicationOptions{Args=args,ContentRootPath=repo,WebRootPath=Path.Combine(repo,"Interfaces","Gui","LilithGui","wwwroot")});
builder.WebHost.UseUrls("http://127.0.0.1:4180");
builder.Logging.SetMinimumLevel(LogLevel.Warning);
builder.Services.Configure<Microsoft.AspNetCore.Server.Kestrel.Core.KestrelServerOptions>(o=>o.Limits.MaxRequestBodySize=64000);
var app=builder.Build();string token=Convert.ToHexString(RandomNumberGenerator.GetBytes(32));
await using var session=new GuiSession(repo);
app.Use(async(context,next)=>
{
    context.Response.Headers.CacheControl="no-store";context.Response.Headers["X-Content-Type-Options"]="nosniff";
    context.Response.Headers.ContentSecurityPolicy="default-src 'self'; img-src 'self' blob: data:; style-src 'self'; script-src 'self'; frame-ancestors 'none'; base-uri 'none'";
    string origin="http://127.0.0.1:4180";
    if(context.Request.Host.Value!="127.0.0.1:4180"||context.Request.Headers.Origin is {Count:>0} sent&&sent.ToString()!=origin){context.Response.StatusCode=403;return;}
    if(context.Request.Path.StartsWithSegments("/api")&&context.Request.Headers["X-Lilith-Gui"]!=token){context.Response.StatusCode=401;return;}
    try{await next();}catch(Exception ex){if(!context.Response.HasStarted){context.Response.StatusCode=409;await context.Response.WriteAsJsonAsync(new{error=ex.Message});}}
});
app.UseDefaultFiles();app.UseStaticFiles();
app.MapGet("/api/versions",()=>new VersionCatalog(repo).ListAsync());
app.MapGet("/api/session",()=>session.Summary());
app.MapGet("/api/events",(long? after)=>session.Events(after??0));
app.MapGet("/api/image/{hash}",(string hash)=>Results.File(session.ReadImage(hash),"image/png"));
app.MapPost("/api/boot",async(JsonElement body)=>await session.BootAsync(body.GetProperty("major").GetInt32(),body));
app.MapPost("/api/action",async(JsonElement body)=>
{
    string action=body.GetProperty("action").GetString()??"";
    if(action is not ("chat" or "command" or "panel" or "scenario" or "history" or "cancel" or "approvals" or "approval_decide"))throw new ArgumentException("Unknown GUI action.");
    return await session.SendAsync(action,body);
});
await app.StartAsync();
string url="http://127.0.0.1:4180/#"+token;Console.WriteLine("Lilith GUI: "+url);
GuiTray? tray=null;
if(OperatingSystem.IsWindows())
{
    try{tray=new GuiTray(url);}
    catch(Exception ex){Console.WriteLine("Windows tray unavailable in this desktop session: "+ex.Message+" Use the printed GUI URL.");}
}
using var ownedTray=tray;
if(openBrowser)
{
    try{System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo(url){UseShellExecute=true});}
    catch(Exception ex){Console.WriteLine("Open the printed local address in your browser. "+ex.Message);}
}
await app.WaitForShutdownAsync();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91

using System.Diagnostics;
using System.IO.Compression;
using System.Xml.Linq;

namespace Lilith.Gui;

public sealed record GuiVersion(int Major,string Label,string Version,string Revision,bool WorkingTree);
internal sealed class VersionCatalog(string repo)
{
    internal async Task<GuiVersion[]> ListAsync()
    {
        var versions = new List<GuiVersion>();
        string refs = await Run("git",["for-each-ref","--format=%(refname:short)","refs/heads/","refs/tags/"],repo);
        foreach (string branch in refs.Split('\n',StringSplitOptions.RemoveEmptyEntries|StringSplitOptions.TrimEntries))
        {
            try
            {
                string xml = await Run("git",["show",branch+":Version.props"],repo);
                string version = ReadVersion(xml); int major = int.Parse(version.Split('.')[0]);
                string commit = (await Run("git",["rev-parse",branch+"^{commit}"],repo)).Trim();
                versions.Add(new(major,"V"+major,version,commit,false));
            }
            catch (InvalidOperationException) { /* Not every release branch is an application release. */ }
        }
        string current = ReadVersion(await File.ReadAllTextAsync(Path.Combine(repo,"Version.props")));
        int currentMajor = int.Parse(current.Split('.')[0]);
        versions.RemoveAll(v=>v.Major==currentMajor);
        versions.Add(new(currentMajor,"V"+currentMajor,current,"working-tree",true));
        return versions.GroupBy(v=>v.Major).Select(g=>g.OrderBy(v=>v.WorkingTree).ThenBy(v=>Numeric(v.Version)).ThenBy(v=>!v.Version.Contains('-')).ThenBy(v=>Prerelease(v.Version)).Last()).OrderBy(v=>v.Major).ToArray();
    }
    private static Version Numeric(string version)=>Version.Parse(version.Split('-')[0]);
    private static int Prerelease(string version)=>int.TryParse(version.Split('.').Last(),out int number)?number:0;
    internal static string ReadVersion(string xml)
    {
        var elements = XDocument.Parse(xml).Descendants();
        string prefix = elements.First(e=>e.Name.LocalName=="VersionPrefix").Value;
        string suffix = elements.FirstOrDefault(e=>e.Name.LocalName=="VersionSuffix")?.Value??"";
        return prefix+(suffix.Length==0?"":"-"+suffix);
    }
    internal async Task<string> PrepareAsync(GuiVersion version,Action<string> progress)
    {
        string source = repo;
        if (!version.WorkingTree)
        {
            string cache = Path.Combine(repo,"Admin","Build","GuiBackend");
            string marker = Path.Combine(cache,"revision.txt");
            if (!File.Exists(marker)||File.ReadAllText(marker)!=version.Revision)
            {
                string resolved = Path.GetFullPath(cache);
                if (!resolved.StartsWith(Path.GetFullPath(Path.Combine(repo,"Admin","Build"))+Path.DirectorySeparatorChar,StringComparison.OrdinalIgnoreCase)) throw new IOException("Invalid backend cache root.");
                for(string? part=resolved;part is not null&&part.StartsWith(Path.GetFullPath(repo),StringComparison.OrdinalIgnoreCase);part=Path.GetDirectoryName(part))
                    if(Directory.Exists(part)&&(File.GetAttributes(part)&FileAttributes.ReparsePoint)!=0)throw new IOException("Linked cache paths cannot be replaced.");
                if (Directory.Exists(cache)) Directory.Delete(cache,true);
                Directory.CreateDirectory(cache); progress("Exporting pinned "+version.Label+" source");
                var start = new ProcessStartInfo("git") { WorkingDirectory=repo,RedirectStandardOutput=true,RedirectStandardError=true,UseShellExecute=false,CreateNoWindow=true };
                start.ArgumentList.Add("-c");start.ArgumentList.Add("safe.directory="+repo.Replace('\\','/'));
                foreach(string arg in new[]{"archive","--format=zip",version.Revision,"Lilith","Interfaces/ConsoleApp","Version.props","Directory.Build.props","Directory.Build.targets"})start.ArgumentList.Add(arg);
                using var process = Process.Start(start)??throw new IOException("Git did not start.");
                using var zip = new MemoryStream(); var errorTask=process.StandardError.ReadToEndAsync();
                await process.StandardOutput.BaseStream.CopyToAsync(zip); await process.WaitForExitAsync();
                if(process.ExitCode!=0)throw new IOException(await errorTask);
                zip.Position=0; using var archive = new ZipArchive(zip,ZipArchiveMode.Read);
                foreach(var entry in archive.Entries)
                {
                    string path=Path.GetFullPath(Path.Combine(cache,entry.FullName));
                    if(!path.StartsWith(resolved+Path.DirectorySeparatorChar,StringComparison.OrdinalIgnoreCase)||((entry.ExternalAttributes>>16)&0xF000)==0xA000)throw new IOException("Invalid archive path/link.");
                    if(entry.FullName.EndsWith('/')){Directory.CreateDirectory(path);continue;}
                    Directory.CreateDirectory(Path.GetDirectoryName(path)!); entry.ExtractToFile(path);
                }
                await File.WriteAllTextAsync(marker,version.Revision);
            }
            source=cache;
        }
        progress("Building "+version.Label+" backend from "+(version.WorkingTree?"working tree":version.Revision[..8]));
        await Run("dotnet",["build","Interfaces/ConsoleApp/LilithConsole/LilithConsole.csproj","-c","Release","-p:NuGetAudit=false"],source);
        string output=Path.Combine(source,"Admin","Build","bin","Interfaces","ConsoleApp","LilithConsole","LilithConsole","Release","net10.0");
        if(!File.Exists(Path.Combine(output,"Agent.dll")))throw new IOException("Pinned backend build did not produce Agent.dll.");
        return output;
    }
    internal static async Task<string> Run(string executable,IEnumerable<string> args,string directory)
    {
        var start=new ProcessStartInfo(executable){WorkingDirectory=directory,RedirectStandardOutput=true,RedirectStandardError=true,UseShellExecute=false,CreateNoWindow=true};
        if(executable=="git"){start.ArgumentList.Add("-c");start.ArgumentList.Add("safe.directory="+directory.Replace('\\','/'));}
        foreach(string arg in args)start.ArgumentList.Add(arg);
        using var process=Process.Start(start)??throw new IOException("Could not start "+executable);
        var stdout=process.StandardOutput.ReadToEndAsync();var stderr=process.StandardError.ReadToEndAsync();
        await process.WaitForExitAsync();string text=await stdout;
        if(process.ExitCode!=0)throw new InvalidOperationException(executable+" failed: "+text+await stderr);
        return text;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

using System.Collections.Concurrent;
using System.Reflection;
using System.Text.Json;

namespace Lilith.Gui.Worker;

// Implements the selected release's interface without loading a newer Core.
public class DesktopResearchBridge : DispatchProxy, IDisposable
{
    private static readonly ConcurrentDictionary<string,TaskCompletionSource<JsonElement>> Pending = new();
    internal Action<string,object?>? Emit;
    internal object? Options;
    private static readonly JsonSerializerOptions JsonOptions = new() { PropertyNameCaseInsensitive=true };
    internal static bool Complete(JsonElement payload)
    {
        if(!Pending.TryRemove(payload.GetProperty("requestId").GetString()!,out var completion))return false;
        if(payload.TryGetProperty("error",out var error))completion.TrySetException(new IOException(error.GetString()));
        else completion.TrySetResult(payload.GetProperty("result").Clone());
        return true;
    }
    protected override object? Invoke(MethodInfo? method,object?[]? args)
    {
        if(method is null)throw new MissingMethodException();
        if(method.Name=="Dispose"){Dispose();return null;}
        var returnType=method.ReturnType.GetGenericArguments().Single();
        return typeof(DesktopResearchBridge).GetMethod(nameof(Request),BindingFlags.Instance|BindingFlags.NonPublic)!
            .MakeGenericMethod(returnType).Invoke(this,[method.Name,args!]);
    }
    private async Task<T> Request<T>(string operation,object?[] args)
    {
        var ct=args.OfType<CancellationToken>().FirstOrDefault();
        string id=Guid.NewGuid().ToString("N");var completion=new TaskCompletionSource<JsonElement>(TaskCreationOptions.RunContinuationsAsynchronously);
        Pending[id]=completion;
        try
        {
            Emit!("browser_request",new{requestId=id,operation,value=args[0],limit=operation=="SearchAsync"?args[1]:null,options=Options});
            var result=await completion.Task.WaitAsync(TimeSpan.FromMinutes(4),ct);
            return result.Deserialize<T>(JsonOptions)!;
        }
        finally{Pending.TryRemove(id,out _);}
    }
    public void Dispose()=>Emit?.Invoke("browser_close",new{});
}

1
2
3

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup><OutputType>Exe</OutputType><TargetFramework>net10.0</TargetFramework><ImplicitUsings>enable</ImplicitUsings><Nullable>enable</Nullable></PropertyGroup>
</Project>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

using System.Reflection;
using System.Runtime.Loader;
using System.Runtime.InteropServices;
using System.Text.Json;
using Lilith.Gui.Worker;

if(args.Length!=2)throw new ArgumentException("Worker requires a pinned backend directory and isolated state directory.");
string backend=Path.GetFullPath(args[0]),state=Path.GetFullPath(args[1]);
// Selenium is loaded from the selected release, while AppContext.BaseDirectory
// belongs to this reflection host. Point its native helper at that same release.
if(string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable("SE_MANAGER_PATH")))
{
    string platform=OperatingSystem.IsWindows()?"win":OperatingSystem.IsMacOS()?"osx":
        RuntimeInformation.ProcessArchitecture==Architecture.Arm64?"linux-arm64":"linux-x64";
    string manager=Path.Combine(backend,"runtimes",platform,"native",OperatingSystem.IsWindows()?"selenium-manager.exe":"selenium-manager");
    if(File.Exists(manager))Environment.SetEnvironmentVariable("SE_MANAGER_PATH",manager);
}
var resolver=new AssemblyDependencyResolver(Path.Combine(backend,"LilithConsole.dll"));
AssemblyLoadContext.Default.Resolving+=(context,name)=>
{
    string? path=resolver.ResolveAssemblyToPath(name);path??=Path.Combine(backend,name.Name+".dll");
    return File.Exists(path)?context.LoadFromAssemblyPath(path):null;
};
AssemblyLoadContext.Default.ResolvingUnmanagedDll+=(assembly,name)=>
{string? path=resolver.ResolveUnmanagedDllToPath(name);return path is null?IntPtr.Zero:NativeLibrary.Load(path);};
var core=AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.Combine(backend,"Core.dll"));
var agent=AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.Combine(backend,"Agent.dll"));
var writeLock=new object();
void Emit(string kind,object? data){lock(writeLock)Console.WriteLine("@lilith-gui "+JsonSerializer.Serialize(new{kind,data}));}
await using var runtime=new ReleaseRuntime(core,agent,backend,state,Emit);
Task? active=null;CancellationTokenSource? cancel=null;
while(await Console.In.ReadLineAsync() is {} line)
{
    JsonElement request;
    try{request=JsonSerializer.Deserialize<JsonElement>(line);}catch(JsonException){continue;}
    string id=request.GetProperty("id").GetString()!,action=request.GetProperty("action").GetString()!;
    var payload=request.GetProperty("payload").Clone();
    if(action=="browser_result"){DesktopResearchBridge.Complete(payload);continue;}
    if(action=="cancel"){cancel?.Cancel();Emit("reply",new{id,result=new{message="Cancellation requested."}});continue;}
    if(action=="stop")
    {
        cancel?.Cancel();if(active is not null)try{await active;}catch(Exception){}
        Emit("reply",new{id,result=new{message="Stopped."}});break;
    }
    if(active is {IsCompleted:false}){Emit("reply",new{id,error="A conversation operation is active. Wait or cancel it."});continue;}
    cancel?.Dispose();cancel=new();var token=cancel.Token;
    active=Task.Run(async()=>
    {
        bool failed=false;
        try{var result=await runtime.DispatchAsync(action,payload,token);if(action is "boot" or "chat" or "command" or "scenario" or "approval_decide")await runtime.PublishApprovals(token);Emit("reply",new{id,result});}
        catch(Exception ex){failed=true;while(ex is TargetInvocationException {InnerException:{}} inner)ex=inner.InnerException!;Emit("error",new{text=ex.Message,detail=ex.ToString()});Emit("status",new{state="error",text="Stopped"});Emit("reply",new{id,error=ex.Message});}
        finally{if(!failed)Emit("status",new{state="idle",text="Ready"});}
    });
}
cancel?.Cancel();if(active is not null)try{await active;}catch(Exception){}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

using System.Reflection;
using System.Text.Json;

namespace Lilith.Gui.Worker;

internal static class ReflectionApi
{
    internal static object? Get(object? value,string property)=>value?.GetType().GetProperty(property,BindingFlags.Public|BindingFlags.Instance)?.GetValue(value);
    internal static object Create(Type type,IReadOnlyDictionary<string,object?> values)
    {
        var constructor=type.GetConstructors().OrderByDescending(c=>c.GetParameters().Length).First();
        return constructor.Invoke(Arguments(constructor.GetParameters(),values));
    }
    private static object?[] Arguments(ParameterInfo[] parameters,IReadOnlyDictionary<string,object?> values)=>parameters.Select(p=>
    {
        var match=values.FirstOrDefault(v=>string.Equals(v.Key,p.Name,StringComparison.OrdinalIgnoreCase));
        if(match.Key is not null)return ConvertValue(match.Value,p.ParameterType);
        return p.HasDefaultValue?p.DefaultValue:p.ParameterType==typeof(CancellationToken)?CancellationToken.None:throw new ArgumentException("Missing "+p.Name);
    }).ToArray();
    private static object? ConvertValue(object? value,Type type)
    {
        if(value is null||type.IsInstanceOfType(value))return value;
        if(type.IsEnum)return Enum.Parse(type,value.ToString()!,true);
        if(value is JsonElement json)return JsonSerializer.Deserialize(json.GetRawText(),type,new JsonSerializerOptions{PropertyNameCaseInsensitive=true});
        return Convert.ChangeType(value,Nullable.GetUnderlyingType(type)??type,System.Globalization.CultureInfo.InvariantCulture);
    }
    internal static async Task<object?> Call(object target,string method,IReadOnlyDictionary<string,object?>? values=null)
    {
        var candidates=target.GetType().GetMethods(BindingFlags.Public|BindingFlags.Instance).Where(m=>m.Name==method).OrderByDescending(m=>m.GetParameters().Length).ToArray();
        if(candidates.Length==0)throw new NotSupportedException("This release does not expose "+method+".");
        object? result=candidates[0].Invoke(target,Arguments(candidates[0].GetParameters(),values??new Dictionary<string,object?>()));
        if(result is Task task){await task;return task.GetType().GetProperty("Result")?.GetValue(task);}
        return result;
    }
    internal static void Attach(object target,string name,Action<object> callback)
    {
        var info=target.GetType().GetEvent(name);if(info?.EventHandlerType is null)return;
        info.AddEventHandler(target,new EventForwarder(callback).Create(info.EventHandlerType));
    }
    internal sealed class EventForwarder(Action<object> callback)
    {
        public void Forward<T>(T value)=>callback(value!);
        internal Delegate Create(Type delegateType)=>GetType().GetMethod(nameof(Forward))!.MakeGenericMethod(delegateType.GenericTypeArguments[0]).CreateDelegate(delegateType,this);
    }
}