600 lines
20 KiB
Swift
600 lines
20 KiB
Swift
import AppKit
|
|
import Foundation
|
|
import ServiceManagement
|
|
import SwiftUI
|
|
|
|
private let workspaceRoot = URL(fileURLWithPath: "/Users/david/Developer/fidelity-ai-workspace", isDirectory: true)
|
|
|
|
struct ProfileConfig {
|
|
let id: String
|
|
let displayName: String
|
|
let knowledgeDir: String
|
|
|
|
static func discoverDefault() -> ProfileConfig {
|
|
let profilesRoot = workspaceRoot.appendingPathComponent("profiles", isDirectory: true)
|
|
let candidates = (try? FileManager.default.contentsOfDirectory(at: profilesRoot, includingPropertiesForKeys: nil)) ?? []
|
|
let configs = candidates.compactMap { directory -> ProfileConfig? in
|
|
let configURL = directory.appendingPathComponent("workspace.json")
|
|
guard let data = try? Data(contentsOf: configURL),
|
|
let decoded = try? JSONDecoder().decode(ProfileWorkspaceConfig.self, from: data)
|
|
else { return nil }
|
|
return ProfileConfig(
|
|
id: decoded.profile ?? directory.lastPathComponent,
|
|
displayName: decoded.displayName ?? decoded.profile ?? directory.lastPathComponent,
|
|
knowledgeDir: decoded.knowledgeDir ?? "workspaces/\(decoded.profile ?? directory.lastPathComponent)/project-knowledge"
|
|
)
|
|
}
|
|
if let fidelity = configs.first(where: { $0.id == "fidelity" }) {
|
|
return fidelity
|
|
}
|
|
if let first = configs.sorted(by: { $0.id < $1.id }).first {
|
|
return first
|
|
}
|
|
return ProfileConfig(id: "fidelity", displayName: "Fidelity", knowledgeDir: "workspaces/fidelity/project-knowledge")
|
|
}
|
|
}
|
|
|
|
private struct ProfileWorkspaceConfig: Decodable {
|
|
let profile: String?
|
|
let displayName: String?
|
|
let knowledgeDir: String?
|
|
|
|
enum CodingKeys: String, CodingKey {
|
|
case profile
|
|
case displayName = "display_name"
|
|
case knowledgeDir = "knowledge_dir"
|
|
}
|
|
}
|
|
|
|
@main
|
|
struct AIWorkspaceApp: App {
|
|
@StateObject private var model = ServiceStatusModel()
|
|
|
|
var body: some Scene {
|
|
MenuBarExtra {
|
|
ServiceMenuView(model: model)
|
|
.task {
|
|
await model.refresh()
|
|
}
|
|
} label: {
|
|
Label("AI Workspace", systemImage: model.menuBarSymbol)
|
|
}
|
|
.menuBarExtraStyle(.window)
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
final class ServiceStatusModel: ObservableObject {
|
|
@Published private(set) var report: StatusReport?
|
|
@Published private(set) var lastError: String?
|
|
@Published private(set) var lanIP: String?
|
|
@Published private(set) var loginItemStatus: SMAppService.Status = .notRegistered
|
|
@Published private(set) var isRefreshing = false
|
|
@Published private(set) var activeAction: String?
|
|
|
|
let profile: ProfileConfig
|
|
|
|
init() {
|
|
self.profile = ProfileConfig.discoverDefault()
|
|
}
|
|
|
|
var menuBarSymbol: String {
|
|
guard let report else { return "circle.dashed" }
|
|
if report.services.contains(where: { $0.status == "unhealthy" || ($0.enabled && $0.status == "stopped") }) {
|
|
return "exclamationmark.triangle"
|
|
}
|
|
if report.services.contains(where: { $0.status == "running" }) {
|
|
return "checkmark.circle"
|
|
}
|
|
return "circle"
|
|
}
|
|
|
|
func refresh() async {
|
|
isRefreshing = true
|
|
defer { isRefreshing = false }
|
|
do {
|
|
let data = try await ServiceManager.run(["status", "--profile", profile.id, "--json"])
|
|
report = try JSONDecoder().decode(StatusReport.self, from: data)
|
|
lanIP = await NetworkInfo.primaryLANIP()
|
|
loginItemStatus = SMAppService.mainApp.status
|
|
lastError = nil
|
|
} catch {
|
|
lastError = String(describing: error)
|
|
}
|
|
}
|
|
|
|
var startAtLoginEnabled: Bool {
|
|
loginItemStatus == .enabled
|
|
}
|
|
|
|
var startAtLoginStatusText: String {
|
|
switch loginItemStatus {
|
|
case .enabled: "enabled"
|
|
case .notRegistered: "off"
|
|
case .notFound: "not found"
|
|
case .requiresApproval: "requires approval"
|
|
@unknown default: "unknown"
|
|
}
|
|
}
|
|
|
|
func setStartAtLogin(_ enabled: Bool) {
|
|
do {
|
|
if enabled {
|
|
try SMAppService.mainApp.register()
|
|
} else {
|
|
try SMAppService.mainApp.unregister()
|
|
}
|
|
loginItemStatus = SMAppService.mainApp.status
|
|
lastError = nil
|
|
} catch {
|
|
loginItemStatus = SMAppService.mainApp.status
|
|
lastError = "Start at Login: \(error.localizedDescription)"
|
|
}
|
|
}
|
|
|
|
func startProfile() {
|
|
runAction("Starting services…", ["start", "--profile", profile.id])
|
|
}
|
|
|
|
func stopProfile() {
|
|
runAction("Stopping services…", ["stop", "--profile", profile.id])
|
|
}
|
|
|
|
func primaryServiceAction() {
|
|
if allManagedServicesRunning {
|
|
stopProfile()
|
|
} else {
|
|
startProfile()
|
|
}
|
|
}
|
|
|
|
func restartMCP() {
|
|
runAction("Restarting MCP…", ["restart", "aiw-context-mcp", "--profile", profile.id])
|
|
}
|
|
|
|
func runDoctor() {
|
|
runAction("Running doctor…", ["doctor", "--profile", profile.id])
|
|
}
|
|
|
|
func copyDoctorJSON() {
|
|
Task {
|
|
do {
|
|
let data = try await ServiceManager.run(["doctor", "--profile", profile.id, "--json"])
|
|
copyToPasteboard(String(data: data, encoding: .utf8) ?? "")
|
|
} catch {
|
|
lastError = String(describing: error)
|
|
}
|
|
}
|
|
}
|
|
|
|
func copyPhotoInboxURL() {
|
|
let host = lanIP ?? "127.0.0.1"
|
|
copyToPasteboard("http://\(host):8787/upload")
|
|
}
|
|
|
|
func copyRecentLogs() {
|
|
Task {
|
|
do {
|
|
var chunks: [String] = []
|
|
for service in report?.services ?? [] {
|
|
let data = try await ServiceManager.run(["logs", service.name, "--profile", profile.id, "--lines", "30"])
|
|
if let text = String(data: data, encoding: .utf8), !text.isEmpty {
|
|
chunks.append(text)
|
|
}
|
|
}
|
|
copyToPasteboard(chunks.joined(separator: "\n\n"))
|
|
} catch {
|
|
lastError = String(describing: error)
|
|
}
|
|
}
|
|
}
|
|
|
|
func openMCPHealth() {
|
|
if let url = URL(string: "http://127.0.0.1:8765/health") {
|
|
NSWorkspace.shared.open(url)
|
|
}
|
|
}
|
|
|
|
func openLogsFolder() {
|
|
NSWorkspace.shared.open(workspaceRoot.appendingPathComponent(".aiw/runtime/logs/\(profile.id)", isDirectory: true))
|
|
}
|
|
|
|
func openProjectKnowledge() {
|
|
NSWorkspace.shared.open(workspaceRoot.appendingPathComponent(profile.knowledgeDir, isDirectory: true))
|
|
}
|
|
|
|
func openMattermost() {
|
|
runAction("Launching Mattermost…", ["start", "mattermost-desktop", "--profile", profile.id])
|
|
}
|
|
|
|
var allManagedServicesRunning: Bool {
|
|
guard let services = report?.services else { return false }
|
|
let managed = services.filter { $0.enabled && $0.kind != "app-launcher" }
|
|
return !managed.isEmpty && managed.allSatisfy { $0.status == "running" || $0.status == "externally running" }
|
|
}
|
|
|
|
var primaryActionTitle: String {
|
|
allManagedServicesRunning ? "Stop Services" : "Start Services"
|
|
}
|
|
|
|
var primaryActionSymbol: String {
|
|
allManagedServicesRunning ? "stop.fill" : "play.fill"
|
|
}
|
|
|
|
var isBusy: Bool {
|
|
isRefreshing || activeAction != nil
|
|
}
|
|
|
|
private func copyToPasteboard(_ value: String) {
|
|
NSPasteboard.general.clearContents()
|
|
NSPasteboard.general.setString(value, forType: .string)
|
|
}
|
|
|
|
private func runAction(_ label: String, _ arguments: [String]) {
|
|
Task {
|
|
activeAction = label
|
|
defer { activeAction = nil }
|
|
do {
|
|
_ = try await ServiceManager.run(arguments)
|
|
await refresh()
|
|
} catch {
|
|
lastError = String(describing: error)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
struct ServiceMenuView: View {
|
|
@ObservedObject var model: ServiceStatusModel
|
|
|
|
var body: some View {
|
|
VStack(alignment: .leading, spacing: 14) {
|
|
HStack(alignment: .firstTextBaseline) {
|
|
VStack(alignment: .leading, spacing: 3) {
|
|
Text("AI Workspace")
|
|
.font(.title3.bold())
|
|
Text("Profile: \(model.profile.displayName)")
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
Spacer()
|
|
if model.isBusy {
|
|
ProgressView()
|
|
.controlSize(.small)
|
|
}
|
|
Button {
|
|
Task { await model.refresh() }
|
|
} label: {
|
|
Image(systemName: "arrow.clockwise")
|
|
}
|
|
.buttonStyle(.borderless)
|
|
.disabled(model.isBusy)
|
|
.help("Refresh")
|
|
}
|
|
|
|
if let activeAction = model.activeAction {
|
|
Label(activeAction, systemImage: "hourglass")
|
|
.font(.caption)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
Divider()
|
|
|
|
if let report = model.report {
|
|
VStack(spacing: 8) {
|
|
ForEach(report.services) { service in
|
|
ServiceRow(service: service)
|
|
}
|
|
}
|
|
} else if let error = model.lastError {
|
|
Label("Status unavailable", systemImage: "exclamationmark.triangle")
|
|
Text(error)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
.lineLimit(3)
|
|
} else {
|
|
Label("Loading status...", systemImage: "hourglass")
|
|
}
|
|
|
|
if let lanIP = model.lanIP {
|
|
HStack(spacing: 8) {
|
|
Image(systemName: "wifi")
|
|
.foregroundStyle(.secondary)
|
|
Text("Photo Inbox LAN")
|
|
Spacer()
|
|
Text("http://\(lanIP):8787/upload")
|
|
.font(.caption.monospaced())
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
.textSelection(.enabled)
|
|
}
|
|
|
|
Divider()
|
|
|
|
Button(role: model.allManagedServicesRunning ? .destructive : nil, action: model.primaryServiceAction) {
|
|
Label(model.primaryActionTitle, systemImage: model.primaryActionSymbol)
|
|
.frame(maxWidth: .infinity)
|
|
}
|
|
.buttonStyle(.borderedProminent)
|
|
.controlSize(.large)
|
|
.disabled(model.isBusy)
|
|
|
|
LazyVGrid(columns: [GridItem(.flexible()), GridItem(.flexible())], spacing: 8) {
|
|
ActionButton(title: "Restart MCP", systemImage: "arrow.triangle.2.circlepath", disabled: model.isBusy, action: model.restartMCP)
|
|
ActionButton(title: "Mattermost via Proxy", systemImage: "message.badge", disabled: model.isBusy, action: model.openMattermost)
|
|
}
|
|
|
|
Divider()
|
|
|
|
LazyVGrid(columns: [GridItem(.flexible()), GridItem(.flexible())], spacing: 8) {
|
|
ActionButton(title: "Run Doctor", systemImage: "stethoscope", disabled: model.isBusy, action: model.runDoctor)
|
|
ActionButton(title: "Copy Doctor JSON", systemImage: "doc.on.doc", disabled: model.isBusy, action: model.copyDoctorJSON)
|
|
ActionButton(title: "Copy Photo URL", systemImage: "link", action: model.copyPhotoInboxURL)
|
|
ActionButton(title: "Copy Logs", systemImage: "doc.text", disabled: model.isBusy, action: model.copyRecentLogs)
|
|
ActionButton(title: "MCP Health", systemImage: "heart.text.square", action: model.openMCPHealth)
|
|
ActionButton(title: "Logs Folder", systemImage: "folder", action: model.openLogsFolder)
|
|
}
|
|
|
|
ActionButton(title: "Open Project Knowledge", systemImage: "books.vertical", action: model.openProjectKnowledge)
|
|
|
|
Divider()
|
|
VStack(alignment: .leading, spacing: 6) {
|
|
Toggle(isOn: Binding(
|
|
get: { model.startAtLoginEnabled },
|
|
set: { model.setStartAtLogin($0) }
|
|
)) {
|
|
Label("Start at Login", systemImage: "poweron")
|
|
}
|
|
.toggleStyle(.switch)
|
|
|
|
Text("Login item: \(model.startAtLoginStatusText)")
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
}
|
|
|
|
Divider()
|
|
HStack {
|
|
if let error = model.lastError {
|
|
Label(error, systemImage: "exclamationmark.triangle")
|
|
.font(.caption)
|
|
.foregroundStyle(.orange)
|
|
.lineLimit(2)
|
|
}
|
|
Spacer()
|
|
Button("Quit") {
|
|
NSApplication.shared.terminate(nil)
|
|
}
|
|
.keyboardShortcut("q")
|
|
}
|
|
}
|
|
.padding(18)
|
|
.frame(width: 430)
|
|
}
|
|
}
|
|
|
|
struct ActionButton: View {
|
|
let title: String
|
|
let systemImage: String
|
|
var role: ButtonRole?
|
|
var disabled = false
|
|
let action: () -> Void
|
|
|
|
var body: some View {
|
|
Button(role: role, action: action) {
|
|
Label(title, systemImage: systemImage)
|
|
.frame(maxWidth: .infinity, alignment: .leading)
|
|
}
|
|
.buttonStyle(.bordered)
|
|
.controlSize(.small)
|
|
.disabled(disabled)
|
|
}
|
|
}
|
|
|
|
struct ServiceRow: View {
|
|
let service: ServiceStatus
|
|
|
|
var body: some View {
|
|
HStack(spacing: 10) {
|
|
Image(systemName: symbol)
|
|
.foregroundStyle(color)
|
|
.frame(width: 16, alignment: .center)
|
|
VStack(alignment: .leading, spacing: 2) {
|
|
Text(service.displayName)
|
|
.font(.body.weight(.medium))
|
|
Text(service.detail)
|
|
.font(.caption2)
|
|
.foregroundStyle(.secondary)
|
|
.lineLimit(1)
|
|
}
|
|
Spacer(minLength: 12)
|
|
StatusBadge(text: service.compactStatus, color: color)
|
|
}
|
|
.padding(.vertical, 7)
|
|
.padding(.horizontal, 10)
|
|
.background(.quaternary.opacity(0.6), in: RoundedRectangle(cornerRadius: 10, style: .continuous))
|
|
.help(service.detail)
|
|
}
|
|
|
|
private var symbol: String {
|
|
switch service.status {
|
|
case "running": "checkmark.circle"
|
|
case "launcher": "arrow.up.forward.app"
|
|
case "externally running": "link.circle"
|
|
case "unhealthy": "exclamationmark.triangle"
|
|
case "disabled": "minus.circle"
|
|
default: "xmark.circle"
|
|
}
|
|
}
|
|
|
|
private var color: Color {
|
|
switch service.status {
|
|
case "running", "launcher", "externally running": .green
|
|
case "unhealthy": .orange
|
|
case "disabled": .secondary
|
|
default: .red
|
|
}
|
|
}
|
|
}
|
|
|
|
struct StatusBadge: View {
|
|
let text: String
|
|
let color: Color
|
|
|
|
var body: some View {
|
|
Text(text)
|
|
.font(.caption.weight(.semibold))
|
|
.foregroundStyle(color)
|
|
.padding(.horizontal, 8)
|
|
.padding(.vertical, 4)
|
|
.background(color.opacity(0.14), in: Capsule())
|
|
}
|
|
}
|
|
|
|
enum ServiceManager {
|
|
static func run(_ arguments: [String]) async throws -> Data {
|
|
try await Task.detached(priority: .userInitiated) {
|
|
let process = Process()
|
|
process.currentDirectoryURL = workspaceRoot
|
|
process.executableURL = URL(fileURLWithPath: "/usr/bin/env")
|
|
process.arguments = ["python3", "scripts/aiw/services.py"] + arguments
|
|
var environment = ProcessInfo.processInfo.environment
|
|
let guiSafePATH = "/opt/homebrew/bin:/opt/homebrew/sbin:/usr/local/bin:/usr/local/sbin:/usr/bin:/bin:/usr/sbin:/sbin"
|
|
if let existingPATH = environment["PATH"], !existingPATH.isEmpty {
|
|
environment["PATH"] = "\(guiSafePATH):\(existingPATH)"
|
|
} else {
|
|
environment["PATH"] = guiSafePATH
|
|
}
|
|
environment["AIW_WORKSPACE_ROOT"] = workspaceRoot.path
|
|
process.environment = environment
|
|
|
|
let output = Pipe()
|
|
let error = Pipe()
|
|
process.standardOutput = output
|
|
process.standardError = error
|
|
|
|
try process.run()
|
|
process.waitUntilExit()
|
|
|
|
let data = output.fileHandleForReading.readDataToEndOfFile()
|
|
let errorData = error.fileHandleForReading.readDataToEndOfFile()
|
|
guard process.terminationStatus == 0 else {
|
|
let message = String(data: errorData.isEmpty ? data : errorData, encoding: .utf8) ?? "service command failed"
|
|
throw ServiceManagerError.commandFailed(message.trimmingCharacters(in: .whitespacesAndNewlines))
|
|
}
|
|
return data
|
|
}.value
|
|
}
|
|
}
|
|
|
|
enum NetworkInfo {
|
|
static func primaryLANIP() async -> String? {
|
|
for interface in ["en0", "en1"] {
|
|
if let value = try? await runIPConfig(interface), !value.isEmpty {
|
|
return value
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
private static func runIPConfig(_ interface: String) async throws -> String {
|
|
try await Task.detached(priority: .utility) {
|
|
let process = Process()
|
|
process.executableURL = URL(fileURLWithPath: "/usr/sbin/ipconfig")
|
|
process.arguments = ["getifaddr", interface]
|
|
let output = Pipe()
|
|
process.standardOutput = output
|
|
process.standardError = Pipe()
|
|
try process.run()
|
|
process.waitUntilExit()
|
|
let data = output.fileHandleForReading.readDataToEndOfFile()
|
|
guard process.terminationStatus == 0 else { return "" }
|
|
return String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) ?? ""
|
|
}.value
|
|
}
|
|
}
|
|
|
|
enum ServiceManagerError: LocalizedError {
|
|
case commandFailed(String)
|
|
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case .commandFailed(let message): message
|
|
}
|
|
}
|
|
}
|
|
|
|
struct StatusReport: Decodable {
|
|
let profile: String
|
|
let workspace: String
|
|
let runtime: String
|
|
let services: [ServiceStatus]
|
|
}
|
|
|
|
struct ServiceStatus: Decodable, Identifiable {
|
|
var id: String { name }
|
|
|
|
let name: String
|
|
let enabled: Bool
|
|
let kind: String
|
|
let status: String
|
|
let pid: Int?
|
|
let command: [String]
|
|
let health: Health
|
|
let state: [String: JSONValue]
|
|
|
|
var displayName: String {
|
|
switch name {
|
|
case "aiw-context-mcp": "Context MCP"
|
|
case "mattermost-proxy": "Mattermost Proxy"
|
|
case "mattermost-desktop": "Mattermost Desktop via Proxy"
|
|
case "photo-inbox": "Photo Inbox"
|
|
default: name
|
|
}
|
|
}
|
|
|
|
var detail: String {
|
|
if name == "mattermost-desktop" {
|
|
return "Launches Mattermost through local proxy 127.0.0.1:8080"
|
|
}
|
|
return health.detail
|
|
}
|
|
|
|
var compactStatus: String {
|
|
switch status {
|
|
case "externally running": "external"
|
|
default: status
|
|
}
|
|
}
|
|
}
|
|
|
|
struct Health: Decodable {
|
|
let ok: Bool?
|
|
let detail: String
|
|
}
|
|
|
|
enum JSONValue: Decodable {
|
|
case string(String)
|
|
case number(Double)
|
|
case bool(Bool)
|
|
case object([String: JSONValue])
|
|
case array([JSONValue])
|
|
case null
|
|
|
|
init(from decoder: Decoder) throws {
|
|
let container = try decoder.singleValueContainer()
|
|
if container.decodeNil() {
|
|
self = .null
|
|
} else if let value = try? container.decode(Bool.self) {
|
|
self = .bool(value)
|
|
} else if let value = try? container.decode(Double.self) {
|
|
self = .number(value)
|
|
} else if let value = try? container.decode(String.self) {
|
|
self = .string(value)
|
|
} else if let value = try? container.decode([String: JSONValue].self) {
|
|
self = .object(value)
|
|
} else {
|
|
self = .array(try container.decode([JSONValue].self))
|
|
}
|
|
}
|
|
}
|