Add Raven capture mux daemon

This commit is contained in:
Meta Vens 2026-06-07 17:24:55 +01:00
commit 9642a4d205
9 changed files with 946 additions and 4 deletions

View file

@ -7,6 +7,7 @@
<Project Path="src/Mimir.EveDashboard/Mimir.EveDashboard.csproj" />
<Project Path="src/Mimir.EveSensorReceiver/Mimir.EveSensorReceiver.csproj" />
<Project Path="src/Mimir.FensalirDaemon/Mimir.FensalirDaemon.csproj" />
<Project Path="src/Mimir.RavenDaemon/Mimir.RavenDaemon.csproj" />
<Project Path="src/Mimir.Well/Mimir.Well.csproj" />
<Project Path="src/Mimir.WellObsDaemon/Mimir.WellObsDaemon.csproj" />
<Project Path="src/Mimir.VerseRecorder/Mimir.VerseRecorder.csproj" />

View file

@ -0,0 +1,57 @@
# Raven Capture Mux Daemon
Raven owns local display capture and Realtek render-loopback capture. Mimir receives the muxed stream and decides what it means inside the synchronized program model.
## Authority Map
- Owner: `Mimir.RavenDaemon` owns process supervision and typed status for Raven's capture mux.
- Inputs: local display capture parameters, WASAPI render-loopback selection, FFmpeg path, SRT target, log root, and operator flags.
- Outputs: `mimir.raven_capture_mux_state.v1`, an Eve dashboard surface, health JSON, and the FFmpeg SRT MPEG-TS stream.
- Derived state: PID, restart count, log paths, and dashboard nodes are derived from the supervised process and daemon options.
- Forbidden writers: capture scripts may still launch diagnostics, but they do not own daemon status or the canonical Raven mux state.
- Shared paths: service launch, dry run, health checks, and Eve dashboard projection all read the same `MimirRavenCaptureMuxStateDocument`.
- Cut line: no OBS plugin, custom media daemon, or alternate transport owns media in this pass. FFmpeg/WASAPI own capture and mux; CultMesh owns status and operator surface.
## Run On Raven
From a Mimir checkout on Raven:
```powershell
.\scripts\start-raven-daemon.ps1
```
Defaults:
- Target: `srt://10.77.0.2:5200`
- Eve/CultMesh dashboard: `ws://0.0.0.0:8801/eve/deck`
- Binary CultMesh dashboard stream: `ws://0.0.0.0:8801/eve/deck/cultmesh`
- Health: `http://127.0.0.1:8801/health`
- State cache: `C:\Meta\Mimir\state\raven-capture-mux.ccmp`
- Logs: `C:\Meta\Mimir\logs`
Use a dry run to inspect the exact FFmpeg pipeline without starting capture:
```powershell
.\scripts\start-raven-daemon.ps1 -DryRun
```
Use a specific Realtek render endpoint when Windows exposes more than one:
```powershell
.\scripts\start-raven-daemon.ps1 -AudioDevice "Realtek"
```
If Raven already has a host-level CultMesh server bound, keep this daemon as a local typed-state publisher and Eve endpoint:
```powershell
.\scripts\start-raven-daemon.ps1 -NoCultNetServer
```
## Receiver Shape
The daemon sends one MPEG-TS SRT stream containing:
- `raven-display`: Raven desktop via `ddagrab` or `gdigrab`, encoded with `h264_nvenc`
- `raven-realtk-loopback`: Raven render loopback via `Mimir.WasapiLoopback` or the PowerShell WASAPI fallback, encoded as AAC
Existing demux/receiver tooling can split that stream back into the video and audio source lanes. The typo in the existing source id, `raven-realtk-loopback`, is preserved until the receiver config is migrated.

View file

@ -17,8 +17,8 @@ Get-Content .\state\evidence.jsonl -Tail 8
## Current Shape
- Public brand/Face is Mimir.
- Mimir's Face doctrine lives in [[docs/mimir-face|Mimir Face]].
- Public brand/Persona is Mimir.
- Mimir's Persona doctrine lives in [[docs/mimir-face|Mimir Persona]].
- VoidBot persona/state live under `.voidbot/voice/` and `.voidbot/state/`.
Commit `.voidbot` dirt in a separate state commit whenever it appears.
- V1 still has FFmpeg/SRT/OBS bridge utilities for LAN ingest.
@ -164,6 +164,13 @@ Get-Content .\state\evidence.jsonl -Tail 8
Raven desktop capture with `gdigrab` plus NVENC. EveCanvas owns Eve camera/mic
capture directly through AVFoundation/AVAudioEngine; no external iOS camera
app owns that path.
- `src/Mimir.RavenDaemon` is the Raven-local capture mux owner for the
stream-proof path. It supervises display capture plus Realtek render loopback
through the existing FFmpeg/WASAPI pipeline, publishes
`mimir.raven_capture_mux_state.v1` through CultMesh/CultCache, and exposes
Eve dashboard state on port `8801`. `scripts/start-raven-daemon.ps1` defaults
to Starfire over WireGuard at `10.77.0.2:5200`. The older Raven sender scripts
remain diagnostics, not canonical long-running status owners.
- Faust/native DSP owns hot audio alignment, separation, spatialization, and
synchronized stems.
- The current listenable dual-mic receipt is the Faust-chain bridge, not the

View file

@ -0,0 +1,80 @@
param(
[string]$TargetHost = "10.77.0.2",
[int]$Port = 5200,
[int]$EvePort = 8801,
[int]$Width = 1920,
[int]$Height = 1080,
[int]$Framerate = 30,
[int]$AudioSampleRate = 48000,
[int]$AudioChannels = 2,
[ValidateSet("ddagrab", "gdigrab")]
[string]$VideoCapture = "ddagrab",
[int]$DdagrabOutputIndex = 0,
[string]$AudioDevice = "Realtek",
[string]$FfmpegPath = "ffmpeg",
[string]$WasapiLoopbackPath = "",
[string]$CultMeshCachePath = "C:\Meta\Mimir\state\raven-capture-mux.ccmp",
[string]$LogRoot = "C:\Meta\Mimir\logs",
[switch]$NoCultNetServer,
[switch]$DryRun
)
$ErrorActionPreference = "Stop"
$repo = Split-Path -Parent $PSScriptRoot
$project = Join-Path $repo "src\Mimir.RavenDaemon\Mimir.RavenDaemon.csproj"
$runtimeArgs = @(
"run",
"--project", $project,
"--",
"--target-host", $TargetHost,
"--port", $Port,
"--eve-port", $EvePort,
"--width", $Width,
"--height", $Height,
"--framerate", $Framerate,
"--audio-sample-rate", $AudioSampleRate,
"--audio-channels", $AudioChannels,
"--video-capture", $VideoCapture,
"--ddagrab-output-index", $DdagrabOutputIndex,
"--audio-device", $AudioDevice,
"--ffmpeg", $FfmpegPath,
"--cultmesh-cache", $CultMeshCachePath,
"--log-root", $LogRoot
)
if (-not [string]::IsNullOrWhiteSpace($WasapiLoopbackPath)) {
$runtimeArgs += @("--wasapi-loopback", $WasapiLoopbackPath)
}
if ($NoCultNetServer) {
$runtimeArgs += "--no-cultnet-server"
}
if ($DryRun) {
$runtimeArgs += "--dry-run"
& dotnet @runtimeArgs
exit $LASTEXITCODE
}
New-Item -ItemType Directory -Force -Path $LogRoot | Out-Null
New-Item -ItemType Directory -Force -Path (Split-Path -Parent $CultMeshCachePath) | Out-Null
$timestamp = Get-Date -Format "yyyyMMdd-HHmmss"
$stdoutLog = Join-Path $LogRoot "mimir-raven-daemon-$timestamp.out.log"
$stderrLog = Join-Path $LogRoot "mimir-raven-daemon-$timestamp.err.log"
$process = Start-Process `
-FilePath "dotnet" `
-ArgumentList $runtimeArgs `
-WindowStyle Hidden `
-RedirectStandardOutput $stdoutLog `
-RedirectStandardError $stderrLog `
-PassThru
Write-Host "Started Mimir.RavenDaemon pid=$($process.Id)"
Write-Host " Eve/CultMesh: ws://0.0.0.0:${EvePort}/eve/deck"
Write-Host " Health: http://127.0.0.1:${EvePort}/health"
Write-Host " Target: srt://${TargetHost}:${Port}"
Write-Host " CultMesh cache: $CultMeshCachePath"
Write-Host " stdout: $stdoutLog"
Write-Host " stderr: $stderrLog"

View file

@ -0,0 +1,18 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net10.0-windows</TargetFramework>
<AssemblyName>Mimir.RavenDaemon</AssemblyName>
<RootNamespace>Mimir.RavenDaemon</RootNamespace>
<ImplicitUsings>enable</ImplicitUsings>
<Nullable>enable</Nullable>
</PropertyGroup>
<ItemGroup>
<ProjectReference Include="..\Mimir.Runtime\Mimir.Runtime.csproj" />
<ProjectReference Include="..\..\..\CultLib\src\GameCult.Caching.MessagePack\GameCult.Caching.MessagePack.csproj" />
<ProjectReference Include="..\..\..\CultLib\src\GameCult.Mesh\GameCult.Mesh.csproj" />
</ItemGroup>
</Project>

View file

@ -0,0 +1,742 @@
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;
using GameCult.Caching;
using GameCult.Mesh;
using GameCult.Networking;
using MessagePack;
using Mimir.Runtime.Synchronization;
var options = RavenDaemonOptions.Parse(args);
Directory.CreateDirectory(options.LogRoot);
Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(options.CultMeshCachePath)) ?? ".");
using var stopping = new CancellationTokenSource();
Console.CancelKeyPress += (_, eventArgs) =>
{
eventArgs.Cancel = true;
stopping.Cancel();
};
var command = RavenMuxCommand.Build(options);
await using var state = await RavenCaptureMuxState.OpenAsync(options, command.CommandLine).ConfigureAwait(false);
using var server = new RavenDaemonEveServer(options, state);
if (options.DryRun)
{
await state.PublishAsync(state.Document with
{
Status = "dry-run",
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
CommandLine = command.CommandLine,
Notes =
[
"Dry run only; no capture process was started.",
"FFmpeg owns display capture, Realtek loopback capture, mux, encode, and SRT transport.",
"Mimir.RavenDaemon owns supervision and CultMesh/Eve status only.",
],
}, stopping.Token).ConfigureAwait(false);
Console.WriteLine(command.CommandLine);
return;
}
Console.Error.WriteLine($"Mimir Raven daemon state cache {options.CultMeshCachePath}");
Console.Error.WriteLine($"Mimir Raven daemon speaking Eve/CultMesh on ws://0.0.0.0:{options.EvePort}/eve/deck");
Console.Error.WriteLine($"Mimir Raven mux target {command.Endpoint}");
var serverTask = server.RunAsync(stopping.Token);
var supervisorTask = RavenMuxSupervisor.RunAsync(options, command, state, stopping.Token);
await Task.WhenAll(serverTask, supervisorTask).ConfigureAwait(false);
internal sealed record RavenDaemonOptions(
string DaemonId,
string HostId,
string TargetHost,
int Port,
int EvePort,
string CultMeshCachePath,
string LogRoot,
int Width,
int Height,
int Framerate,
int AudioSampleRate,
int AudioChannels,
string VideoCapture,
int DdagrabOutputIndex,
string Transport,
string SrtMode,
string FfmpegPath,
string Source,
string VideoBitrate,
string AudioBitrate,
string WasapiLoopbackPath,
string AudioDevice,
bool StartCultNetServer,
bool Once,
bool DryRun)
{
public static RavenDaemonOptions Parse(string[] args)
{
return new RavenDaemonOptions(
DaemonId: Text(args, "--daemon-id", "mimir.raven.capture-mux"),
HostId: Text(args, "--host-id", "raven"),
TargetHost: Text(args, "--target-host", "10.77.0.2"),
Port: Int(args, "--port", 5200),
EvePort: Int(args, "--eve-port", 8801),
CultMeshCachePath: Text(args, "--cultmesh-cache", @"C:\Meta\Mimir\state\raven-capture-mux.ccmp"),
LogRoot: Text(args, "--log-root", @"C:\Meta\Mimir\logs"),
Width: Int(args, "--width", 1920),
Height: Int(args, "--height", 1080),
Framerate: Int(args, "--framerate", 30),
AudioSampleRate: Int(args, "--audio-sample-rate", 48000),
AudioChannels: Int(args, "--audio-channels", 2),
VideoCapture: Choice(args, "--video-capture", "ddagrab", ["ddagrab", "gdigrab"]),
DdagrabOutputIndex: Int(args, "--ddagrab-output-index", 0),
Transport: Choice(args, "--transport", "srt", ["srt", "tcp-listener"]),
SrtMode: Choice(args, "--srt-mode", "caller", ["caller", "listener"]),
FfmpegPath: Text(args, "--ffmpeg", "ffmpeg"),
Source: Text(args, "--source", "desktop"),
VideoBitrate: Text(args, "--video-bitrate", "12000k"),
AudioBitrate: Text(args, "--audio-bitrate", "192k"),
WasapiLoopbackPath: Text(args, "--wasapi-loopback", ""),
AudioDevice: Text(args, "--audio-device", "Realtek"),
StartCultNetServer: !Flag(args, "--no-cultnet-server"),
Once: Flag(args, "--once"),
DryRun: Flag(args, "--dry-run"));
}
private static bool Flag(string[] args, string name) => args.Any(arg => string.Equals(arg, name, StringComparison.OrdinalIgnoreCase));
private static string Text(string[] args, string name, string fallback)
{
var index = Array.FindIndex(args, arg => string.Equals(arg, name, StringComparison.OrdinalIgnoreCase));
return index >= 0 && index + 1 < args.Length ? args[index + 1] : fallback;
}
private static int Int(string[] args, string name, int fallback) =>
int.TryParse(Text(args, name, ""), out var value) ? value : fallback;
private static string Choice(string[] args, string name, string fallback, string[] allowed)
{
var value = Text(args, name, fallback);
if (!allowed.Contains(value, StringComparer.OrdinalIgnoreCase))
{
throw new ArgumentOutOfRangeException(name, value, $"Expected one of: {string.Join(", ", allowed)}");
}
return value.ToLowerInvariant();
}
}
internal sealed record RavenMuxCommand(string CommandLine, string Endpoint, string StdoutLog, string StderrLog)
{
public static RavenMuxCommand Build(RavenDaemonOptions options)
{
var timestamp = DateTimeOffset.UtcNow.ToString("yyyyMMdd-HHmmss");
var stdoutLog = Path.Combine(options.LogRoot, $"raven-av-srt-{timestamp}.out.log");
var stderrLog = Path.Combine(options.LogRoot, $"raven-av-srt-{timestamp}.err.log");
var endpoint = options.Transport == "tcp-listener"
? $"tcp://{options.TargetHost}:{options.Port}?listen=1"
: $"srt://{options.TargetHost}:{options.Port}?mode={options.SrtMode}&latency=120000&timeout=30000000";
var repoRoot = FindRepoRoot();
var loopback = ResolveLoopbackCommand(options, repoRoot);
var ffmpeg = new List<string>
{
"-hide_banner",
"-loglevel",
"warning",
};
if (options.VideoCapture == "ddagrab")
{
ffmpeg.AddRange([
"-thread_queue_size",
"1024",
"-f",
"lavfi",
"-i",
$"ddagrab=framerate={options.Framerate}:output_idx={options.DdagrabOutputIndex}:draw_mouse=1",
]);
}
else
{
ffmpeg.AddRange([
"-thread_queue_size",
"1024",
"-f",
"gdigrab",
"-framerate",
options.Framerate.ToString(),
"-video_size",
$"{options.Width}x{options.Height}",
"-i",
options.Source,
]);
}
var gop = Math.Max(1, options.Framerate * 2);
ffmpeg.AddRange([
"-thread_queue_size",
"1024",
"-f",
"f32le",
"-ar",
options.AudioSampleRate.ToString(),
"-ac",
options.AudioChannels.ToString(),
"-i",
"pipe:0",
"-map",
"0:v:0",
"-map",
"1:a:0",
"-c:v",
"h264_nvenc",
"-preset",
"p4",
"-tune",
"ll",
"-b:v",
options.VideoBitrate,
"-maxrate",
options.VideoBitrate,
"-bufsize",
"24000k",
"-g",
gop.ToString(),
]);
if (options.VideoCapture == "gdigrab")
{
ffmpeg.AddRange(["-pix_fmt", "yuv420p"]);
}
ffmpeg.AddRange([
"-c:a",
"aac",
"-b:a",
options.AudioBitrate,
"-ar",
options.AudioSampleRate.ToString(),
"-ac",
options.AudioChannels.ToString(),
"-f",
"mpegts",
endpoint,
]);
var command = loopback + " | " + Quote(options.FfmpegPath) + " " + string.Join(" ", ffmpeg.Select(Quote));
return new RavenMuxCommand(command, endpoint, stdoutLog, stderrLog);
}
private static string ResolveLoopbackCommand(RavenDaemonOptions options, string repoRoot)
{
if (!string.IsNullOrWhiteSpace(options.WasapiLoopbackPath))
{
return LoopbackExeCommand(options.WasapiLoopbackPath, options);
}
var exe = Path.Combine(repoRoot, "tools", "Mimir.WasapiLoopback", "Mimir.WasapiLoopback.exe");
if (File.Exists(exe))
{
return LoopbackExeCommand(exe, options);
}
var script = Path.Combine(repoRoot, "scripts", "wasapi-loopback-capture.ps1");
return string.Join(" ", [
"powershell.exe",
"-NoProfile",
"-ExecutionPolicy",
"Bypass",
"-File",
Quote(script),
"-Output",
Quote("stdout"),
"-SampleRate",
options.AudioSampleRate.ToString(),
"-Channels",
options.AudioChannels.ToString(),
]);
}
private static string LoopbackExeCommand(string exe, RavenDaemonOptions options)
{
var parts = new List<string>
{
Quote(exe),
"--output",
"stdout",
"--sample-rate",
options.AudioSampleRate.ToString(),
"--channels",
options.AudioChannels.ToString(),
};
if (!string.IsNullOrWhiteSpace(options.AudioDevice))
{
parts.Add("--device");
parts.Add(Quote(options.AudioDevice));
}
return string.Join(" ", parts);
}
private static string FindRepoRoot()
{
var directory = new DirectoryInfo(AppContext.BaseDirectory);
while (directory != null)
{
if (File.Exists(Path.Combine(directory.FullName, "Mimir.slnx")))
{
return directory.FullName;
}
directory = directory.Parent;
}
return Directory.GetCurrentDirectory();
}
private static string Quote(string value) => "\"" + value.Replace("\"", "\\\"") + "\"";
}
internal sealed class RavenCaptureMuxState : IAsyncDisposable
{
private readonly CultMeshNode node;
private readonly CultRecordKey key;
private readonly SemaphoreSlim gate = new(1, 1);
private RavenCaptureMuxState(CultMeshNode node, CultRecordKey key, MimirRavenCaptureMuxStateDocument document)
{
this.node = node;
this.key = key;
Document = document;
}
public MimirRavenCaptureMuxStateDocument Document { get; private set; }
public static async Task<RavenCaptureMuxState> OpenAsync(RavenDaemonOptions options, string commandLine)
{
var registry = new CultNetDocumentRegistry()
.Register(CultNetDocumentBinding.ForDocument<MimirRavenCaptureMuxStateDocument>())
.Register(CultNetDocumentBinding.ForDocument<MimirEveDashboardStateDocument>());
var node = await CultMesh.CreateNodeAsync(options.CultMeshCachePath, new CultMeshNodeOptions
{
StartServer = options.StartCultNetServer,
DatabaseOptions = new CultNetDatabaseOptions
{
RuntimeId = options.DaemonId,
DocumentRegistry = registry,
},
}).ConfigureAwait(false);
var key = new CultRecordKey(options.DaemonId);
var document = InitialDocument(options, commandLine);
var state = new RavenCaptureMuxState(node, key, document);
await state.PublishAsync(document, CancellationToken.None).ConfigureAwait(false);
return state;
}
public async Task PublishAsync(MimirRavenCaptureMuxStateDocument document, CancellationToken stopping)
{
await gate.WaitAsync(stopping).ConfigureAwait(false);
try
{
Document = document;
await node.Database.PutAsync(key, document).ConfigureAwait(false);
await node.Database.PutAsync(new CultRecordKey(optionsKey(document.DaemonId, "dashboard")), RavenDaemonEveServer.ToCultMeshState(document)).ConfigureAwait(false);
await node.FlushAsync(soft: true).ConfigureAwait(false);
}
finally
{
gate.Release();
}
static string optionsKey(string daemonId, string suffix) => daemonId + "." + suffix;
}
public async ValueTask DisposeAsync()
{
gate.Dispose();
await Task.CompletedTask.ConfigureAwait(false);
node.Dispose();
}
private static MimirRavenCaptureMuxStateDocument InitialDocument(RavenDaemonOptions options, string commandLine) =>
new(
options.DaemonId,
DateTimeOffset.UtcNow.ToString("O"),
options.HostId,
"starting",
$"{options.Transport}://{options.TargetHost}:{options.Port}",
options.Transport,
"raven-display",
"raven-realtk-loopback",
options.VideoCapture,
options.Width,
options.Height,
options.Framerate,
options.AudioSampleRate,
options.AudioChannels,
null,
null,
0,
null,
"",
"",
commandLine,
[
"display-capture",
"wasapi-render-loopback",
"ffmpeg-mux",
"srt-mpegts",
"cultmesh-eve-status",
],
[
"Raven daemon supervises the capture process and publishes typed state.",
"FFmpeg owns media capture, mux, encode, and transport.",
]);
}
internal static class RavenMuxSupervisor
{
public static async Task RunAsync(RavenDaemonOptions options, RavenMuxCommand command, RavenCaptureMuxState state, CancellationToken stopping)
{
var restartCount = state.Document.RestartCount;
while (!stopping.IsCancellationRequested)
{
Directory.CreateDirectory(Path.GetDirectoryName(command.StdoutLog) ?? ".");
await using var stdout = new StreamWriter(new FileStream(command.StdoutLog, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) { AutoFlush = true };
await using var stderr = new StreamWriter(new FileStream(command.StderrLog, FileMode.Append, FileAccess.Write, FileShare.ReadWrite)) { AutoFlush = true };
using var process = StartMuxProcess(command, stdout, stderr);
var started = DateTimeOffset.UtcNow;
await state.PublishAsync(state.Document with
{
Status = "running",
UpdatedAtUtc = started.ToString("O"),
FfmpegPid = process.Id,
StartedAtUtc = started.ToString("O"),
RestartCount = restartCount,
LastExitCode = null,
StdoutLog = command.StdoutLog,
StderrLog = command.StderrLog,
CommandLine = command.CommandLine,
}, stopping).ConfigureAwait(false);
while (!process.HasExited && !stopping.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromSeconds(2), stopping).ConfigureAwait(false);
await state.PublishAsync(state.Document with
{
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
Status = "running",
FfmpegPid = process.Id,
}, stopping).ConfigureAwait(false);
}
if (!process.HasExited)
{
process.Kill(entireProcessTree: true);
await process.WaitForExitAsync(CancellationToken.None).ConfigureAwait(false);
}
var exitCode = process.ExitCode;
await state.PublishAsync(state.Document with
{
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
Status = stopping.IsCancellationRequested ? "stopped" : "exited",
FfmpegPid = null,
LastExitCode = exitCode,
}, CancellationToken.None).ConfigureAwait(false);
if (options.Once || stopping.IsCancellationRequested)
{
return;
}
restartCount++;
await state.PublishAsync(state.Document with
{
UpdatedAtUtc = DateTimeOffset.UtcNow.ToString("O"),
Status = "restarting",
RestartCount = restartCount,
}, CancellationToken.None).ConfigureAwait(false);
await Task.Delay(TimeSpan.FromSeconds(Math.Min(30, 2 + restartCount)), stopping).ConfigureAwait(false);
}
}
private static Process StartMuxProcess(RavenMuxCommand command, StreamWriter stdout, StreamWriter stderr)
{
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = "cmd.exe",
ArgumentList = { "/d", "/s", "/c", command.CommandLine },
UseShellExecute = false,
CreateNoWindow = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
},
EnableRaisingEvents = true,
};
process.OutputDataReceived += (_, eventArgs) =>
{
if (eventArgs.Data != null)
{
lock (stdout)
{
stdout.WriteLine(eventArgs.Data);
}
}
};
process.ErrorDataReceived += (_, eventArgs) =>
{
if (eventArgs.Data != null)
{
lock (stderr)
{
stderr.WriteLine(eventArgs.Data);
}
}
};
process.Start();
process.BeginOutputReadLine();
process.BeginErrorReadLine();
return process;
}
}
internal sealed class RavenDaemonEveServer(RavenDaemonOptions options, RavenCaptureMuxState state) : IDisposable
{
private static readonly JsonSerializerOptions JsonOptions = new()
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
};
private readonly TcpListener listener = new(IPAddress.Any, options.EvePort);
private readonly CancellationTokenSource stopping = new();
public async Task RunAsync(CancellationToken outerStopping)
{
using var linked = CancellationTokenSource.CreateLinkedTokenSource(outerStopping, stopping.Token);
listener.Start();
while (!linked.IsCancellationRequested)
{
try
{
var client = await listener.AcceptTcpClientAsync(linked.Token).ConfigureAwait(false);
_ = Task.Run(() => HandleAsync(client, linked.Token), linked.Token);
}
catch (OperationCanceledException)
{
break;
}
}
}
private async Task HandleAsync(TcpClient client, CancellationToken token)
{
await using var stream = client.GetStream();
var request = await HttpWire.ReadRequestAsync(stream).ConfigureAwait(false);
if (request.Path == "/health")
{
var document = state.Document;
var health = JsonSerializer.Serialize(new
{
ok = document.Status is "running" or "dry-run",
providerId = options.DaemonId,
host = document.HostId,
status = document.Status,
target = document.TargetEndpoint,
video = document.VideoSourceId,
audio = document.AudioSourceId,
ffmpegPid = document.FfmpegPid,
restartCount = document.RestartCount,
cultCache = options.CultMeshCachePath,
cultMeshDocument = "mimir.raven_capture_mux_state",
}, JsonOptions);
await HttpWire.WriteResponseAsync(stream, "200 OK", "application/json", Encoding.UTF8.GetBytes(health)).ConfigureAwait(false);
return;
}
if (request.Path == "/eve/deck/manifest")
{
await HttpWire.WriteResponseAsync(stream, "200 OK", "application/json", Encoding.UTF8.GetBytes(JsonSerializer.Serialize(Manifest(), JsonOptions))).ConfigureAwait(false);
return;
}
if (request.Path == "/eve/deck/providers")
{
await HttpWire.WriteResponseAsync(stream, "200 OK", "application/json", Encoding.UTF8.GetBytes(JsonSerializer.Serialize(new { providers = new[] { Manifest() } }, JsonOptions))).ConfigureAwait(false);
return;
}
if (!IsDashboardPath(request.Path, out var binary) || !request.Headers.TryGetValue("Sec-WebSocket-Key", out var key))
{
await HttpWire.WriteResponseAsync(stream, "404 Not Found", "text/plain", Encoding.UTF8.GetBytes("not found")).ConfigureAwait(false);
return;
}
await HttpWire.WriteWebSocketHandshakeAsync(stream, key).ConfigureAwait(false);
while (!token.IsCancellationRequested)
{
var dashboard = ToCultMeshState(state.Document);
if (binary)
{
await HttpWire.SendBinaryFrameAsync(stream, MessagePackSerializer.Serialize(dashboard)).ConfigureAwait(false);
}
else
{
await HttpWire.SendTextFrameAsync(stream, JsonSerializer.Serialize(dashboard, JsonOptions)).ConfigureAwait(false);
}
await Task.Delay(1000, token).ConfigureAwait(false);
}
}
public static MimirEveDashboardStateDocument ToCultMeshState(MimirRavenCaptureMuxStateDocument doc)
{
var statusTone = doc.Status == "running" ? "live" : doc.Status == "dry-run" ? "diagnostic" : "waiting";
return new MimirEveDashboardStateDocument(
doc.DaemonId + ".dashboard",
"Mimir Raven Capture Mux",
DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
doc.UpdatedAtUtc,
"raven-daemon",
"terminal",
[
new("raven-daemon", $"Raven Daemon\n{doc.Status}", "daemon", true, 0.0, -0.36, 0.0, 0.0, 1.0, 0.54, 0.18, statusTone, doc.DaemonId, null, "/health"),
new("raven-display", $"Display\n{doc.Width}x{doc.Height}@{doc.Framerate}", "video", true, -0.34, 0.02, 0.0, 0.0, 1.0, 0.42, 0.18, doc.VideoCapture, doc.DaemonId, null, null),
new("raven-loopback", $"Realtek Loopback\n{doc.AudioChannels}ch {doc.AudioSampleRate}Hz", "audio", true, 0.34, 0.02, 0.0, 0.0, 1.0, 0.42, 0.18, "wasapi-loopback", doc.DaemonId, null, null),
new("raven-target", $"Mux Target\n{doc.TargetEndpoint}", "transport", true, 0.0, 0.38, 0.0, 0.0, 1.0, 0.72, 0.18, doc.Transport, doc.DaemonId, null, null),
],
new MimirEveDashboardSurfaceSnapshot(
"mimir.eve_surface.v1",
"mimir.raven-capture-mux.surface",
"Raven Capture Mux",
Pane("raven-root", "Raven Capture Mux",
[
Text("raven-status", $"status {doc.Status}\nffmpeg pid {doc.FfmpegPid?.ToString() ?? "none"}\nrestarts {doc.RestartCount}"),
Text("raven-media", $"video {doc.VideoSourceId} {doc.VideoCapture} {doc.Width}x{doc.Height}@{doc.Framerate}\naudio {doc.AudioSourceId} {doc.AudioChannels}ch {doc.AudioSampleRate}Hz"),
Text("raven-target-text", $"target {doc.TargetEndpoint}\nstdout {doc.StdoutLog}\nstderr {doc.StderrLog}"),
]),
[]));
}
public void Dispose()
{
stopping.Cancel();
listener.Stop();
stopping.Dispose();
}
private DashboardProviderManifest Manifest() =>
new(
options.DaemonId,
"Mimir Raven Capture Mux",
"Raven-local supervisor for display capture plus Realtek render loopback muxed through FFmpeg and exposed as typed CultMesh/Eve state.",
"0.1.0",
$"ws://raven:{options.EvePort}/eve/deck",
["health", "eve-deck", "cultmesh-state", "raven-display", "raven-realtk-loopback"],
UsesCultMesh: true,
Transport: "CultMesh typed state + Eve WebSocket; FFmpeg/SRT owns media transport.");
private static bool IsDashboardPath(string path, out bool binary)
{
binary = path == "/eve/deck/cultmesh";
return path == "/eve/deck" || binary;
}
private static MimirEveDashboardUiElementSnapshot Pane(string id, string text, MimirEveDashboardUiElementSnapshot[] children) =>
new(id, "pane", null, text, null, null, null, null, new("column", null, null, 1.0, 1.0, 1.0, "clip", Density: "compact"), new("panel", "neutral"), null, children);
private static MimirEveDashboardUiElementSnapshot Text(string id, string text) =>
new(id, "text", null, text, null, null, null, null, new("column", null, null, 0.0, 0.0, 0.0, "clip", Density: "compact"), new("label", "neutral"), null, []);
}
internal sealed record DashboardProviderManifest(
string Id,
string Title,
string Description,
string Version,
string Endpoint,
string[] Capabilities,
bool UsesCultMesh,
string Transport);
internal static class HttpWire
{
public static async Task<HttpRequest> ReadRequestAsync(NetworkStream stream)
{
var buffer = new byte[8192];
var read = await stream.ReadAsync(buffer).ConfigureAwait(false);
var text = Encoding.ASCII.GetString(buffer, 0, read);
var lines = text.Split(["\r\n"], StringSplitOptions.None);
var first = lines.FirstOrDefault() ?? "";
var parts = first.Split(' ', StringSplitOptions.RemoveEmptyEntries);
var headers = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
foreach (var line in lines.Skip(1))
{
var colon = line.IndexOf(':');
if (colon > 0)
{
headers[line[..colon].Trim()] = line[(colon + 1)..].Trim();
}
}
return new HttpRequest(parts.Length >= 2 ? parts[1] : "/", headers);
}
public static async Task WriteResponseAsync(NetworkStream stream, string status, string contentType, byte[] body)
{
var header = Encoding.ASCII.GetBytes(
$"HTTP/1.1 {status}\r\nContent-Type: {contentType}\r\nContent-Length: {body.Length}\r\nConnection: close\r\n\r\n");
await stream.WriteAsync(header).ConfigureAwait(false);
await stream.WriteAsync(body).ConfigureAwait(false);
}
public static async Task WriteWebSocketHandshakeAsync(NetworkStream stream, string key)
{
var accept = Convert.ToBase64String(SHA1.HashData(Encoding.ASCII.GetBytes(key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11")));
var response = Encoding.ASCII.GetBytes(
"HTTP/1.1 101 Switching Protocols\r\n" +
"Upgrade: websocket\r\n" +
"Connection: Upgrade\r\n" +
$"Sec-WebSocket-Accept: {accept}\r\n\r\n");
await stream.WriteAsync(response).ConfigureAwait(false);
}
public static Task SendTextFrameAsync(NetworkStream stream, string text) =>
SendFrameAsync(stream, 0x1, Encoding.UTF8.GetBytes(text));
public static Task SendBinaryFrameAsync(NetworkStream stream, byte[] payload) =>
SendFrameAsync(stream, 0x2, payload);
private static async Task SendFrameAsync(NetworkStream stream, byte opcode, byte[] payload)
{
var header = new List<byte> { (byte)(0x80 | opcode) };
if (payload.Length <= 125)
{
header.Add((byte)payload.Length);
}
else if (payload.Length <= ushort.MaxValue)
{
header.Add(126);
header.Add((byte)(payload.Length >> 8));
header.Add((byte)payload.Length);
}
else
{
header.Add(127);
var length = BitConverter.GetBytes(IPAddress.HostToNetworkOrder((long)payload.Length));
header.AddRange(length);
}
await stream.WriteAsync(header.ToArray()).ConfigureAwait(false);
await stream.WriteAsync(payload).ConfigureAwait(false);
}
}
internal sealed record HttpRequest(string Path, IReadOnlyDictionary<string, string> Headers);

View file

@ -189,6 +189,35 @@ public sealed record MimirFensalirReservoirPressureDocument(
[property: Key(13)] long DroppedBecauseTimingDegraded,
[property: Key(14)] string PressureReason);
[CultDocument("mimir.raven_capture_mux_state", "mimir.raven_capture_mux_state.v1")]
[MessagePackObject]
public sealed record MimirRavenCaptureMuxStateDocument(
[property: Key(0)]
[property: CultName]
string DaemonId,
[property: Key(1)] string UpdatedAtUtc,
[property: Key(2)] string HostId,
[property: Key(3)] string Status,
[property: Key(4)] string TargetEndpoint,
[property: Key(5)] string Transport,
[property: Key(6)] string VideoSourceId,
[property: Key(7)] string AudioSourceId,
[property: Key(8)] string VideoCapture,
[property: Key(9)] int Width,
[property: Key(10)] int Height,
[property: Key(11)] int Framerate,
[property: Key(12)] int AudioSampleRate,
[property: Key(13)] int AudioChannels,
[property: Key(14)] int? FfmpegPid,
[property: Key(15)] string? StartedAtUtc,
[property: Key(16)] long RestartCount,
[property: Key(17)] int? LastExitCode,
[property: Key(18)] string StdoutLog,
[property: Key(19)] string StderrLog,
[property: Key(20)] string CommandLine,
[property: Key(21)] string[] Capabilities,
[property: Key(22)] string[] Notes);
[CultDocument("mimir.eve_dashboard_manifest", "mimir.eve_dashboard_manifest.v1")]
[MessagePackObject]
public sealed record MimirEveDashboardManifestDocument(

View file

@ -376,3 +376,4 @@
{"ts": "2026-06-03T05:33:56+01:00", "type": "implementation", "status": "ok", "note": "Daemon-status cut: Fensalir now validates pid-file process identity before reporting local daemons online, so reused PIDs surface as stale-pid instead of false health. Move sync remote receiver imports errno, degrades on HID write failures, and bioacoustic render preflight has a timeout. Live supervisor now has relay, recorder, Fensalir, Well, and Move sync resolving to dotnet/exe/python identities; Well remains 6/6 Ready at 40 ms. Current Move sync is online but waiting on Realtek loopback frames, not crashed."}
{"ts": "2026-06-03T05:36:16+01:00", "type": "implementation", "status": "ok", "note": "Fensalir daemon status now marks Move sync as waiting when the process identity is valid but move-sync/online-sync.jsonl is missing or empty. Hot-restarted Fensalir; Eve dashboard reported Online Daemons 5/6 while health stayed caught-up, matching the live state: relay, recorder, Fensalir, Well, and Move worker are alive, but Move score has no Realtek loopback frames yet."}
{"ts": "2026-06-04T11:07:48+01:00", "type": "decision", "status": "ok", "note": "Existing Well captures are synchronization evidence, not continuous media bodies: future recording/streaming daemons must drink typed stream-frame/body refs from the Well, while the Well owns ingest, clock mapping, source heartbeat/reacquire, and operator-alert publication only."}
{"ts": "2026-06-07T17:23:25+01:00", "type": "implementation", "status": "ok", "note": "Added Mimir.RavenDaemon as Raven-local capture mux supervisor: publishes mimir.raven_capture_mux_state.v1 via CultMesh/CultCache, exposes Eve dashboard state on 8801, and reuses FFmpeg/WASAPI for display plus Realtek loopback mux to Starfire over WireGuard."}

View file

@ -396,7 +396,14 @@ invariants:
alone. Raven's local `ddagrab + Mimir.WasapiLoopback + AAC + h264_nvenc`
proof recorded 568 frames in ten seconds at 1080p60; sparse-frame direct
TCP/SSH proof captures are therefore transport/proof-path evidence, not
Raven GPU/capture evidence. `scripts/start-raven-av-demux.ps1`
Raven GPU/capture evidence. `src/Mimir.RavenDaemon` is now the Raven-local
long-running owner for that mux path: it supervises the same
`ddagrab/gdigrab + Mimir.WasapiLoopback + FFmpeg` command, publishes
`mimir.raven_capture_mux_state.v1` through CultMesh/CultCache, and exposes
Eve dashboard state on port 8801. `scripts/start-raven-av-sender.ps1`
remains a direct diagnostic launch path; it does not own canonical Raven
capture status. `scripts/start-raven-daemon.ps1` defaults to Starfire over
WireGuard at `10.77.0.2:5200`. `scripts/start-raven-av-demux.ps1`
is the Starfire local demux edge, copying video to local SRT port 5210 and
decoding audio to f32 PCM on local SRT port 5212 for Mimir's current raw
ingest adapters. `MimirFfmpegPcmAudioStreamSource` owns the post-demux PCM
@ -765,7 +772,7 @@ accepted_design:
`open-provider`. `voidbot.swarm` reads VoidBot's existing
`.voidbot/status/swarm-state.json` projection, publishes avatar URLs on
identity nodes, and Eve renders a native VoidBot-style cockpit: CTB rail,
selected Face/status pane, state tree, and detail panel.
selected Persona/status pane, state tree, and detail panel.
Dashboard manifests and states now have typed CultMesh-compatible document
shapes `mimir.eve_dashboard_manifest.v1` and
`mimir.eve_dashboard_state.v1`, while the live iPad lane stays