Merge pull request #458 from nblumhardt-ro/feature/mcp

Kick off `seqcli skills install` and `seqcli mcp run`

Author: nblumhardt

.gitignore

@@ -292,3 +292,7 @@ __pycache__/
 global.json
 
 .DS_Store/
+
+.claude/
+.qwen/
+.agents/

src/SeqCli/Cli/Commands/Mcp/InstallCommand.cs

@@ -0,0 +1,52 @@
+// Copyright © Datalust and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Threading.Tasks;
+using SeqCli.Mcp;
+using SeqCli.Util;
+
+namespace SeqCli.Cli.Commands.Mcp;
+
+[Command("mcp", "install", "Install or update the Seq MCP server for an agent",
+    Example = "seqcli mcp install --global --agent claude")]
+class InstallCommand : Command
+{
+    bool _global;
+    string? _agent;
+    string? _profile;
+
+    public InstallCommand()
+    {
+        Options.Add(
+            "g|global",
+            "Install for the current user globally; the default is to install into the current project directory",
+            _ => _global = true);
+
+        Options.Add(
+            "a=|agent=",
+            "The agent name to install the MCP server for; the default is the generic name `agents`",
+            t => _agent = ArgumentString.Normalize(t));
+
+        Options.Add(
+            "profile=",
+            "A connection profile to use; by default the `connection.serverUrl` and `connection.apiKey` config values will be used",
+            v => _profile = ArgumentString.Normalize(v));
+    }
+
+    protected override Task<int> Run()
+    {
+        McpServerInstaller.Install(_agent?.ToLowerInvariant(), _global, _profile);
+        return Task.FromResult(0);
+    }
+}

src/SeqCli/Cli/Commands/Mcp/RunCommand.cs

@@ -0,0 +1,85 @@
+// Copyright © Datalust and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Threading.Tasks;
+using Autofac.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using SeqCli.Api;
+using SeqCli.Cli.Features;
+using SeqCli.Config;
+using SeqCli.Mcp;
+using SeqCli.Mcp.Tools.Search;
+using Serilog;
+
+namespace SeqCli.Cli.Commands.Mcp;
+
+[Command("mcp", "run", "Run an MCP (Model Context Protocol) server on STDIO")]
+class RunCommand: Command
+{
+    readonly ConnectionFeature _connection;
+    readonly StoragePathFeature _storagePath;
+    bool _debug;
+
+    public RunCommand()
+    {
+        _connection = Enable<ConnectionFeature>();
+        _storagePath = Enable<StoragePathFeature>();
+        Options.Add("debug", "Write diagnostic messages from the MCP server back through the connection",
+            _ => _debug = true);
+    }
+
+    protected override async Task<int> Run()
+    {
+        var config = RuntimeConfigurationLoader.Load(_storagePath);
+
+        if (_debug)
+        {
+            Log.Logger = new LoggerConfiguration()
+                .Enrich.WithProperty("Application", "seqcli mcp run")
+                .WriteTo.Seq(config.Connection.ServerUrl, apiKey: config.Connection.DecodeApiKey(config.Encryption.DataProtector()))
+                .CreateLogger();
+            
+            Log.Information("Seq MCP server starting up");
+        }
+
+        try
+        {
+            var builder = Host.CreateApplicationBuilder();
+            builder.ConfigureContainer(new AutofacServiceProviderFactory());
+            builder.Services.AddSerilog();
+            builder.Services.AddSingleton(_ => SeqConnectionFactory.Connect(_connection, config));
+            builder.Services.AddSingleton<McpSession>();
+            builder.Services
+                .AddMcpServer()
+                .WithStdioServerTransport()
+                .WithTools([
+                    typeof(SearchAndQueryToolType)
+                ]);
+
+            await builder.Build().RunAsync();
+        }
+        catch (Exception ex)
+        {
+            Log.Fatal(ex, "Unhandled exception");
+            return 1;
+        }
+        finally
+        {
+            await Log.CloseAndFlushAsync();
+        }
+        return 0;
+    }
+}

src/SeqCli/Cli/Commands/SearchCommand.cs

@@ -128,7 +128,7 @@ protected override async Task<int> Run()
         }
     }
 
-    LogEvent ToSerilogEvent(EventEntity evt)
+    internal static LogEvent ToSerilogEvent(EventEntity evt)
     {
         return new LogEvent(
             DateTimeOffset.ParseExact(evt.Timestamp, "o", CultureInfo.InvariantCulture).ToLocalTime(),
@@ -149,12 +149,12 @@ static MessageTemplateToken ToMessageTemplateToken(MessageTemplateTokenPart toke
         return new PropertyToken(token.PropertyName, token.RawText ?? $"{{{token.PropertyName}}}");
     }
 
-    LogEventProperty CreateProperty(string name, object value)
+    static LogEventProperty CreateProperty(string name, object value)
     {
         return LogEventPropertyFactory.SafeCreate(name, CreatePropertyValue(value));
     }
 
-    LogEventPropertyValue CreatePropertyValue(object value)
+    static LogEventPropertyValue CreatePropertyValue(object value)
     {
         switch (value)
         {

src/SeqCli/Cli/Commands/Skills/InstallCommand.cs

@@ -0,0 +1,46 @@
+// Copyright © Datalust and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System.Threading.Tasks;
+using SeqCli.Skills;
+using SeqCli.Util;
+
+namespace SeqCli.Cli.Commands.Skills;
+
+[Command("skills", "install", "Install or update Seq agent skills",
+    Example = "seqcli skills install --global --agent claude")]
+class InstallCommand : Command
+{
+    bool _global;
+    string? _agent;
+    
+    public InstallCommand()
+    {
+        Options.Add(
+            "g|global",
+            "Install skills globally, to `~/.{agent}/skills`; the default is to install locally, in `./{agent}/skills`",
+            _ => _global = true);
+        
+        Options.Add(
+            "a=|agent=",
+            "The agent name to install skills for; the default is the generic name `agents`",
+            t => _agent = ArgumentString.Normalize(t));
+    }
+
+    protected override Task<int> Run()
+    {
+        SkillInstaller.Install(_agent?.ToLowerInvariant(), _global);
+        return Task.FromResult(0);
+    }
+}

src/SeqCli/Ingestion/LogShipper.cs

@@ -181,7 +181,7 @@ static async Task<BatchResult> ReadBatchAsync(
                         if (isLast || batch.Count != 0 || totalWaitMS > maxWaitMS)
                             break;
 
-                        // Nothing to to ship; wait to try to fill a batch.
+                        // Nothing to ship; wait to try to fill a batch.
                         await Task.Delay(idleWaitMS);
                         totalWaitMS += idleWaitMS;
                         continue;

src/SeqCli/Mcp/Data/DataResourceGroupHelper.cs

@@ -0,0 +1,50 @@
+// Copyright © Datalust and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Globalization;
+using System.IO;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Seq.Api;
+using Seq.Api.Model.Data;
+
+namespace SeqCli.Mcp.Data;
+
+public static class DataResourceGroupHelper
+{
+    static readonly JsonSerializer Serializer = JsonSerializer.Create(new JsonSerializerSettings
+    {
+        DateParseHandling = DateParseHandling.None,
+        Culture = CultureInfo.InvariantCulture,
+        FloatParseHandling = FloatParseHandling.Decimal,
+    });
+
+    public static async Task<QueryResultPart> QueryPreserveErrorResponsesAsync(SeqConnection connection, string query, CancellationToken cancellationToken = default)
+    {
+        // Unfortunately, the `Data.QueryAsync()` API throws when the server 400s, making this case tricky. Suggests
+        // we should make some API client improvements...
+        var request = new HttpRequestMessage
+        {
+            RequestUri = new Uri("api/data?q=" + Uri.EscapeDataString(query), UriKind.Relative),
+            Method = HttpMethod.Post, Content = new StringContent("{}", new UTF8Encoding(false), "application/json")
+        };
+        var response = await connection.Client.HttpClient.SendAsync(request, cancellationToken);
+        return Serializer.Deserialize<QueryResultPart>(
+            new JsonTextReader(new StreamReader(await response.Content.ReadAsStreamAsync(cancellationToken))))!;
+    }
+}

src/SeqCli/Mcp/Data/QueryResultHelper.cs

@@ -0,0 +1,105 @@
+// Copyright © Datalust and contributors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Seq.Api.Model.Data;
+
+namespace SeqCli.Mcp.Data;
+
+public static class QueryResultHelper
+{
+    /// <summary>
+    /// Convert <paramref name="result"/> into a flat table. Seq reduces browser-side processing and optimizes
+    /// response sizes by constructing result trees for some grouped/time-sliced query results.
+    /// </summary>
+    public static void Flatten(QueryResultPart result, Action<IEnumerable<object?>> writeRow)
+    {
+        if (result.Error != null)
+            return;
+                
+        if (result.Rows != null)
+        {
+            writeRow(result.Columns!);
+            foreach (var row in result.Rows)
+            {
+                writeRow(row);
+            }
+        }
+        else if (result.Slices != null)
+        {
+            writeRow(new object[] {"time"}.Concat(result.Columns!));
+
+            var empty = result.Columns!.Select(_ => "").ToArray();
+            foreach (var slice in result.Slices)
+            {
+                var any = false;
+                foreach (var row in slice.Rows)
+                {
+                    any = true;
+                    writeRow(new object[] { DateTimeOffset.Parse(slice.Time).UtcDateTime }.Concat(row));
+                }
+                if (!any)
+                {
+                    writeRow(new object[] { DateTimeOffset.Parse(slice.Time).UtcDateTime }.Concat(empty));
+                }
+            }
+        }
+        else if (result.Series != null)
+        {
+            writeRow(MergeColumns(result.Columns!, result.Series.FirstOrDefault()));
+            foreach (var series in result.Series)
+            {
+                foreach (var slice in series.Slices)
+                {
+                    var empty = result.Columns!.Take(series.Key.Length).Select(_ => (object?)null).ToArray();
+                    var any = false;
+                    foreach (var row in slice.Rows)
+                    {
+                        any = true;
+                        writeRow(series.Key.Concat([DateTimeOffset.Parse(slice.Time).UtcDateTime]).Concat(row));
+                    }
+                    if (!any)
+                    {
+                        writeRow(series.Key.Concat([DateTimeOffset.Parse(slice.Time).UtcDateTime]).Concat(empty));
+                    }
+                }
+            }
+        }
+        else
+        {
+            throw new NotImplementedException("Query result set does not conform to any expected pattern.");
+        }            
+    }
+    
+    static IEnumerable<object> MergeColumns(string[] columns, TimeseriesPart? firstSeries)
+    {
+        if (firstSeries == null)
+            yield break;
+
+        var i = 0;
+        for (; i < firstSeries.Key.Length; ++i)
+        {
+            yield return columns[i];
+        }
+
+        yield return "time";
+
+        for (; i < columns.Length; ++i)
+        {
+            yield return columns[i];
+        }
+    }
+}