Toak/Core/DaemonService.cs

using System;
using System.Diagnostics;
using System.IO;
using System.Net.Sockets;
using System.Threading;
using System.Threading.Tasks;
using Toak.Audio;
using Toak.Configuration;
using Toak.Api;
using Toak.IO;

namespace Toak.Core;

public static class DaemonService
{
    private static GroqApiClient? _groqClient;

    public static string GetSocketPath()
    {
        var runtimeDir = Environment.GetEnvironmentVariable("XDG_RUNTIME_DIR");
        if (string.IsNullOrEmpty(runtimeDir))
        {
            runtimeDir = Path.GetTempPath();
        }
        return Path.Combine(runtimeDir, "toak.sock");
    }

    public static async Task StartAsync(bool verbose)
    {
        Logger.Verbose = verbose;
        var socketPath = GetSocketPath();

        if (File.Exists(socketPath))
        {
            try { File.Delete(socketPath); } catch { }
        }

        var config = ConfigManager.LoadConfig();
        if (string.IsNullOrWhiteSpace(config.GroqApiKey))
        {
            Console.WriteLine("Groq API Key is not configured. Run 'toak onboard'.");
            return;
        }

        _groqClient = new GroqApiClient(config.GroqApiKey);

        using var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified);
        var endPoint = new UnixDomainSocketEndPoint(socketPath);
        
        try
        {
            socket.Bind(endPoint);
            socket.Listen(10);
            Logger.LogDebug($"Daemon listening on {socketPath}");
            Console.WriteLine($"Toak daemon started, listening on {socketPath}");

            while (true)
            {
                var client = await socket.AcceptAsync();
                _ = Task.Run(() => HandleClientAsync(client));
            }
        }
        catch (Exception ex)
        {
            Logger.LogDebug($"Daemon error: {ex.Message}");
        }
        finally
        {
            if (File.Exists(socketPath))
            {
                File.Delete(socketPath);
            }
        }
    }

    private static async Task HandleClientAsync(Socket client)
    {
        try
        {
            var buffer = new byte[3];
            int bytesRead = await client.ReceiveAsync(buffer, SocketFlags.None);
            if (bytesRead > 0)
            {
                byte cmd = buffer[0];
                bool pipeToStdout = bytesRead > 1 && buffer[1] == 1;
                bool copyToClipboard = bytesRead > 2 && buffer[2] == 1;

                if (cmd == 1) // START
                {
                    await ProcessStartRecordingAsync();
                }
                else if (cmd == 2) // STOP
                {
                    await ProcessStopRecordingAsync(client, pipeToStdout, copyToClipboard);
                }
                else if (cmd == 3) // ABORT
                {
                    ProcessAbortAsync();
                }
                else if (cmd == 4) // TOGGLE
                {
                    if (StateTracker.IsRecording())
                        await ProcessStopRecordingAsync(client, pipeToStdout, copyToClipboard);
                    else
                        await ProcessStartRecordingAsync();
                }
            }
        }
        catch (Exception ex)
        {
            Logger.LogDebug($"HandleClient error: {ex.Message}");
        }
        finally
        {
            client.Close();
        }
    }

    private static async Task ProcessStartRecordingAsync()
    {
        if (StateTracker.IsRecording()) return;

        Logger.LogDebug("Received START command");
        var config = ConfigManager.LoadConfig();
        Notifications.PlaySound(config.StartSoundPath);
        AudioRecorder.StartRecording();
    }

    private static async Task ProcessStopRecordingAsync(Socket client, bool pipeToStdout, bool copyToClipboard)
    {
        if (!StateTracker.IsRecording()) return;

        Logger.LogDebug("Received STOP command");
        var config = ConfigManager.LoadConfig();
        Notifications.PlaySound(config.StopSoundPath);
        Notifications.Notify("Toak", "Transcribing...");
        
        AudioRecorder.StopRecording();

        var wavPath = AudioRecorder.GetWavPath();
        if (!File.Exists(wavPath) || new FileInfo(wavPath).Length == 0)
        {
            Notifications.Notify("Toak", "No audio recorded.");
            return;
        }

        try
        {
            var stopWatch = Stopwatch.StartNew();
            
            Logger.LogDebug($"Starting STT via Whisper for {wavPath}...");
            var transcript = await _groqClient!.TranscribeAsync(wavPath, config.WhisperLanguage, config.WhisperModel);
            
            if (string.IsNullOrWhiteSpace(transcript))
            {
                Notifications.Notify("Toak", "No speech detected.");
                return;
            }

            // LLM Refinement
            var detectedSkill = Toak.Core.Skills.SkillRegistry.DetectSkill(transcript, config.ActiveSkills);
            string systemPrompt = detectedSkill != null ? detectedSkill.GetSystemPrompt(transcript) : PromptBuilder.BuildPrompt(config);
            bool isExecutionSkill = detectedSkill != null && detectedSkill.HandlesExecution;

            if (isExecutionSkill)
            {
                var finalText = await _groqClient.RefineTextAsync(transcript, systemPrompt, config.LlmModel);
                if (!string.IsNullOrWhiteSpace(finalText))
                {
                    detectedSkill!.Execute(finalText);
                    stopWatch.Stop();
                    Notifications.Notify("Toak", $"Skill executed in {stopWatch.ElapsedMilliseconds}ms");
                }
            }
            else
            {
                Logger.LogDebug("Starting LLM text refinement (streaming)...");
                var tokenStream = _groqClient.RefineTextStreamAsync(transcript, systemPrompt, config.LlmModel);
                
                if (pipeToStdout || copyToClipboard)
                {
                    string fullText = "";
                    await foreach (var token in tokenStream)
                    {
                        fullText += token;
                        if (pipeToStdout)
                        {
                            await client.SendAsync(System.Text.Encoding.UTF8.GetBytes(token), SocketFlags.None);
                        }
                    }
                    stopWatch.Stop();
                    if (copyToClipboard)
                    {
                        ClipboardManager.Copy(fullText);
                        Notifications.Notify("Toak", $"Copied to clipboard in {stopWatch.ElapsedMilliseconds}ms");
                    }
                }
                else
                {
                    await TextInjector.InjectStreamAsync(tokenStream, config.TypingBackend);
                    stopWatch.Stop();
                    Notifications.Notify("Toak", $"Done in {stopWatch.ElapsedMilliseconds}ms");
                }
            }
        }
        catch (Exception ex)
        {
            Notifications.Notify("Toak Error", ex.Message);
            Logger.LogDebug($"Error during processing: {ex.Message}");
        }
        finally
        {
            if (File.Exists(wavPath)) File.Delete(wavPath);
        }
    }

    private static void ProcessAbortAsync()
    {
        Logger.LogDebug("Received ABORT command");
        AudioRecorder.StopRecording();
        var wavPath = AudioRecorder.GetWavPath();
        if (File.Exists(wavPath)) File.Delete(wavPath);
        Notifications.Notify("Toak", "Recording Aborted.");
    }
}