Initial Commit

2026-09-08 14:12:59 +01:00
commit 3b95f53a25
46 changed files with 4334 additions and 0 deletions
@@ -0,0 +1,119 @@
+import SwiftUI
+import SwiftData
+
+struct RunHistoryView: View {
+    @Environment(\.modelContext) private var modelContext
+    @Query(sort: \SyncRun.startedAt, order: .reverse) private var runs: [SyncRun]
+    @State private var selection: SyncRun?
+    let onBack: () -> Void
+
+    var body: some View {
+        HSplitView {
+            VStack(spacing: 0) {
+                HStack(spacing: 10) {
+                    VStack(alignment: .leading, spacing: 2) {
+                        Text("Recent Runs")
+                            .font(.headline)
+                        Text("\(runs.count) recorded")
+                            .font(.caption)
+                            .foregroundStyle(.secondary)
+                    }
+
+                    Spacer()
+
+                    Button("Clear", role: .destructive) {
+                        runs.forEach(modelContext.delete)
+                        selection = nil
+                        try? modelContext.save()
+                    }
+                    .buttonStyle(.bordered)
+                    .controlSize(.small)
+                    .disabled(runs.isEmpty)
+                }
+                .padding(14)
+
+                Divider()
+
+                if runs.isEmpty {
+                    ContentUnavailableView(
+                        "No Run History",
+                        systemImage: "clock.arrow.circlepath",
+                        description: Text("Completed, failed and background synchronisations will appear here.")
+                    )
+                    .frame(maxWidth: .infinity, maxHeight: .infinity)
+                } else {
+                    List(selection: $selection) {
+                        ForEach(runs) { run in
+                            HStack(spacing: 11) {
+                                Image(systemName: statusIcon(run))
+                                    .foregroundStyle(statusColour(run))
+
+                                VStack(alignment: .leading, spacing: 4) {
+                                    HStack {
+                                        Text(run.jobName)
+                                            .fontWeight(.semibold)
+                                            .lineLimit(1)
+                                        Spacer()
+                                        StatusBadge(run: run)
+                                    }
+
+                                    Text(run.startedAt, format: .dateTime.day().month(.abbreviated).year().hour().minute())
+                                        .font(.caption)
+                                        .foregroundStyle(.secondary)
+
+                                    HStack(spacing: 6) {
+                                        Label(run.trigger.title, systemImage: run.trigger.systemImage)
+                                            .font(.caption2.weight(.semibold))
+                                            .foregroundStyle(run.trigger == .watched ? Color.purple : Color.blue)
+                                        if run.wasDryRun {
+                                            Text("Dry run")
+                                                .font(.caption2.weight(.semibold))
+                                                .foregroundStyle(.blue)
+                                        }
+                                    }
+                                }
+                            }
+                            .padding(.vertical, 3)
+                            .tag(run)
+                            .contextMenu {
+                                Button("Delete Log", role: .destructive) {
+                                    if selection?.id == run.id { selection = nil }
+                                    modelContext.delete(run)
+                                    try? modelContext.save()
+                                }
+                            }
+                        }
+                    }
+                    .listStyle(.sidebar)
+                }
+            }
+            .frame(minWidth: 300, idealWidth: 340, maxWidth: 390)
+
+            Group {
+                if let selection {
+                    RunLogView(run: selection)
+                } else {
+                    ContentUnavailableView(
+                        "Select a Run",
+                        systemImage: "clock.arrow.circlepath",
+                        description: Text("Select a completed or failed run to inspect its summary and full log.")
+                    )
+                }
+            }
+            .frame(minWidth: 620, maxWidth: .infinity, maxHeight: .infinity)
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+    }
+
+    private func statusIcon(_ run: SyncRun) -> String {
+        if run.isRunning { return "arrow.triangle.2.circlepath" }
+        if run.wasCancelled { return "xmark.circle.fill" }
+        return run.succeeded ? "checkmark.circle.fill" : "exclamationmark.triangle.fill"
+    }
+
+    private func statusColour(_ run: SyncRun) -> Color {
+        if run.isRunning { return .blue }
+        if run.wasCancelled { return .secondary }
+        return run.succeeded ? .green : .orange
+    }
+}
@@ -0,0 +1,47 @@
+import SwiftUI
+
+struct RunLogView: View {
+    let run: SyncRun
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 20) {
+                HStack {
+                    VStack(alignment: .leading) {
+                        Text(run.jobName).font(.title.bold())
+                        Text(run.startedAt.formatted(date: .abbreviated, time: .standard))
+                            .foregroundStyle(.secondary)
+                    }
+                    Spacer()
+                    StatusBadge(run: run)
+                }
+
+                if let duration = run.duration {
+                    LabeledContent("Duration", value: Duration.seconds(duration).formatted(.units(allowed: [.minutes, .seconds], width: .abbreviated)))
+                }
+                if let exitCode = run.exitCode {
+                    LabeledContent("Exit code", value: String(exitCode))
+                }
+                LabeledContent("Mode", value: run.wasDryRun ? "Dry Run" : "Live Run")
+
+                console(title: "Command", text: run.command)
+                if !run.output.isEmpty { console(title: "Output", text: run.output) }
+                if !run.errorOutput.isEmpty { console(title: "Errors", text: run.errorOutput) }
+            }
+            .padding(28)
+        }
+        .navigationTitle("Run Log")
+    }
+
+    private func console(title: String, text: String) -> some View {
+        GroupBox(title) {
+            ScrollView(.horizontal) {
+                Text(text)
+                    .font(.system(.caption, design: .monospaced))
+                    .textSelection(.enabled)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+}