codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/apps/macos-overlay/Sources/Views/AutostartView.swift

@@ -0,0 +1,293 @@
+import SwiftUI
+import Foundation
+import Darwin
+
+public struct FlowPilotAutostartStatus: Equatable {
+    public let enabled: Bool
+    public let plistExists: Bool
+    public let launchdLoaded: Bool
+    public let executablePath: String
+}
+
+public enum FlowPilotAutostartService {
+    public static let label = "com.parsifalc.codex-flow.flowpilot"
+
+    private static var environment: [String: String] { ProcessInfo.processInfo.environment }
+    private static var home: URL { FileManager.default.homeDirectoryForCurrentUser }
+    private static var codexHome: URL {
+        environment["CODEX_HOME"].map(URL.init(fileURLWithPath:))
+            ?? home.appendingPathComponent(".codex")
+    }
+    private static var stateDirectory: URL { codexHome.appendingPathComponent("codex-flow") }
+    private static var preferenceURL: URL { stateDirectory.appendingPathComponent("autostart-preference") }
+    private static var launchAgentsDirectory: URL { home.appendingPathComponent("Library/LaunchAgents") }
+    private static var plistURL: URL { launchAgentsDirectory.appendingPathComponent("\(label).plist") }
+
+    private static let userDefaultsKey = "FlowPilot.Autostart.Enabled"
+
+    public static func status() -> FlowPilotAutostartStatus {
+        // Status is intentionally read-only.  Re-registering a missing plist
+        // here can bootstrap a RunAtLoad LaunchAgent while the app is merely
+        // constructing its UI, which races the singleton owner.
+        let pref = configuredPreference()
+        let exists = FileManager.default.fileExists(atPath: plistURL.path)
+        // A stored preference alone is not an active login registration.  A
+        // missing plist is reported as disabled so toggling the control back
+        // on explicitly recreates and bootstraps the LaunchAgent.
+        let isEnabled = (pref ?? exists) && exists
+        return FlowPilotAutostartStatus(
+            enabled: isEnabled,
+            plistExists: exists,
+            launchdLoaded: launchdIsLoaded(),
+            executablePath: resolvedExecutable().path
+        )
+    }
+
+    @discardableResult
+    public static func enable() throws -> FlowPilotAutostartStatus {
+        try writePreference(enabled: true)
+        try writeRegistration()
+        return status()
+    }
+
+    @discardableResult
+    public static func disable() throws -> FlowPilotAutostartStatus {
+        try writePreference(enabled: false)
+        // Deliberately do not `bootout` the current job here. If FlowPilot was
+        // launched by launchd, booting it out would kill the app as the user
+        // toggles the setting. Removing the plist is sufficient to prevent the
+        // next login from launching it; uninstall performs a full bootout.
+        try removeRegistration()
+        return status()
+    }
+
+    private static func configuredPreference() -> Bool? {
+        if let raw = try? String(contentsOf: preferenceURL, encoding: .utf8)
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased() {
+            switch raw {
+            case "enabled", "true", "1", "yes": return true
+            case "disabled", "false", "0", "no": return false
+            default: break
+            }
+        }
+        if UserDefaults.standard.object(forKey: userDefaultsKey) != nil {
+            return UserDefaults.standard.bool(forKey: userDefaultsKey)
+        }
+        return nil
+    }
+
+    private static func writePreference(enabled: Bool) throws {
+        try FileManager.default.createDirectory(at: stateDirectory, withIntermediateDirectories: true)
+        try (enabled ? "enabled\n" : "disabled\n").write(to: preferenceURL, atomically: true, encoding: .utf8)
+        UserDefaults.standard.set(enabled, forKey: userDefaultsKey)
+    }
+
+    private static func writeRegistration() throws {
+        let executable = resolvedExecutable()
+        guard FileManager.default.isExecutableFile(atPath: executable.path) else {
+            throw serviceError(L(
+                "FlowPilot executable is not available for login launch.",
+                "用于登录启动的 FlowPilot 可执行文件不存在。"
+            ))
+        }
+
+        let logs = stateDirectory.appendingPathComponent("logs")
+        try FileManager.default.createDirectory(at: launchAgentsDirectory, withIntermediateDirectories: true)
+        try FileManager.default.createDirectory(at: logs, withIntermediateDirectories: true)
+
+        let path = [
+            home.appendingPathComponent(".local/bin").path,
+            "/opt/homebrew/bin",
+            "/usr/local/bin",
+            "/usr/bin",
+            "/bin",
+            "/usr/sbin",
+            "/sbin"
+        ].joined(separator: ":")
+
+        var launchEnvironment: [String: String] = ["PATH": path]
+        // A RunAtLoad launch is best-effort reconciliation.  The app must not
+        // preempt a manual/restart owner when launchd notices the plist.
+        launchEnvironment[FlowPilotInstanceLock.launchAgentEnvironmentKey] = "1"
+        if let configuredCodexHome = environment["CODEX_HOME"], !configuredCodexHome.isEmpty {
+            launchEnvironment["CODEX_HOME"] = configuredCodexHome
+        }
+        if let configuredBinDir = environment["CODEX_FLOW_BIN_DIR"], !configuredBinDir.isEmpty {
+            launchEnvironment["CODEX_FLOW_BIN_DIR"] = configuredBinDir
+        }
+
+        let plist: [String: Any] = [
+            "Label": label,
+            "ProgramArguments": [executable.path, "start"],
+            "RunAtLoad": true,
+            "KeepAlive": false,
+            "ProcessType": "Interactive",
+            "LimitLoadToSessionType": "Aqua",
+            "EnvironmentVariables": launchEnvironment,
+            "StandardOutPath": logs.appendingPathComponent("flowpilot-launchd.out.log").path,
+            "StandardErrorPath": logs.appendingPathComponent("flowpilot-launchd.err.log").path
+        ]
+
+        let data = try PropertyListSerialization.data(fromPropertyList: plist, format: .xml, options: 0)
+        try data.write(to: plistURL, options: .atomic)
+        _ = chmod(plistURL.path, mode_t(S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))
+
+        // Ensure launchd is aware of the LaunchAgent in the current GUI session
+        if !launchdIsLoaded() {
+            _ = runLaunchctl(["bootstrap", "gui/\(getuid())", plistURL.path])
+        }
+    }
+
+    private static func removeRegistration() throws {
+        guard FileManager.default.fileExists(atPath: plistURL.path) else { return }
+        try FileManager.default.removeItem(at: plistURL)
+    }
+
+    private static func resolvedExecutable() -> URL {
+        // Prefer the stable installer-managed location so a source checkout can
+        // move without breaking login launch. Dev builds fall back to themselves.
+        let installed = stateDirectory.appendingPathComponent("bin/FlowPilot")
+        if FileManager.default.isExecutableFile(atPath: installed.path) {
+            return installed
+        }
+        let legacy = stateDirectory.appendingPathComponent("bin/codex-flow-overlay")
+        if FileManager.default.isExecutableFile(atPath: legacy.path) {
+            return legacy
+        }
+        if let current = CommandLine.arguments.first, !current.isEmpty {
+            let currentURL = URL(fileURLWithPath: current).standardizedFileURL
+            if FileManager.default.isExecutableFile(atPath: currentURL.path) {
+                return currentURL
+            }
+        }
+        return installed
+    }
+
+    private static func launchdIsLoaded() -> Bool {
+        runLaunchctl(["print", "gui/\(getuid())/\(label)"]) == 0
+    }
+
+    private static func runLaunchctl(_ arguments: [String]) -> Int32 {
+        let process = Process()
+        process.executableURL = URL(fileURLWithPath: "/bin/launchctl")
+        process.arguments = arguments
+        process.standardOutput = FileHandle.nullDevice
+        process.standardError = FileHandle.nullDevice
+        do {
+            try process.run()
+            process.waitUntilExit()
+            return process.terminationStatus
+        } catch {
+            return -1
+        }
+    }
+
+    private static func serviceError(_ message: String) -> NSError {
+        NSError(domain: "FlowPilot.Autostart", code: 1, userInfo: [NSLocalizedDescriptionKey: message])
+    }
+}
+
+public struct AutostartCard: View {
+    @ObservedObject private var localization = AppLocalization.shared
+    @State private var status = FlowPilotAutostartService.status()
+    @State private var isChanging = false
+    @State private var message: String?
+    @State private var isError = false
+
+    public init() {}
+
+    public var body: some View {
+        VStack(alignment: .leading, spacing: 7) {
+            HStack(spacing: 7) {
+                Image(systemName: "power.circle.fill")
+                    .font(.system(size: 11, weight: .semibold))
+                    .foregroundColor(status.enabled ? .green : .orange.opacity(0.72))
+
+                VStack(alignment: .leading, spacing: 2) {
+                    Text(L("Launch at Login", "登录时启动"))
+                        .font(.system(size: 9.5, weight: .bold, design: .rounded))
+                        .foregroundColor(.white.opacity(0.84))
+                    Text(statusText)
+                        .font(.system(size: 7.6))
+                        .foregroundColor(.white.opacity(0.42))
+                }
+
+                Spacer()
+
+                if isChanging {
+                    ProgressView().controlSize(.mini)
+                }
+
+                Toggle("", isOn: Binding(
+                    get: { status.enabled },
+                    set: { setEnabled($0) }
+                ))
+                .labelsHidden()
+                .toggleStyle(SleekSwitchToggleStyle(tint: .green))
+                .disabled(isChanging)
+            }
+
+            if let message {
+                Text(message)
+                    .font(.system(size: 7.6, weight: .medium))
+                    .foregroundColor(isError ? .orange : .green)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+            }
+
+            HStack(spacing: 4) {
+                Image(systemName: "info.circle")
+                    .font(.system(size: 7.2))
+                Text(L(
+                    "Registered as a user LaunchAgent; enabling it affects the next login and does not restart the current widget.",
+                    "使用用户级 LaunchAgent 注册；开启后从下次登录生效，不会重启当前悬浮窗。"
+                ))
+                    .font(.system(size: 7.2))
+            }
+            .foregroundColor(.white.opacity(0.3))
+        }
+        .padding(9)
+        .background(
+            RoundedRectangle(cornerRadius: 10)
+                .fill(Color.white.opacity(0.04))
+                .overlay(RoundedRectangle(cornerRadius: 10).stroke(Color.white.opacity(0.08), lineWidth: 0.8))
+        )
+        .onAppear { status = FlowPilotAutostartService.status() }
+    }
+
+    private var statusText: String {
+        guard status.enabled else { return L("Disabled", "已关闭") }
+        if status.launchdLoaded {
+            return L("Enabled · managed by launchd in this login session", "已开启 · 当前登录会话由 launchd 托管")
+        }
+        return L("Enabled · starts automatically on next login", "已开启 · 下次登录自动启动")
+    }
+
+    private func setEnabled(_ enabled: Bool) {
+        guard !isChanging else { return }
+        isChanging = true
+        message = nil
+        DispatchQueue.global(qos: .userInitiated).async {
+            do {
+                let next = try enabled
+                    ? FlowPilotAutostartService.enable()
+                    : FlowPilotAutostartService.disable()
+                DispatchQueue.main.async {
+                    status = next
+                    isChanging = false
+                    isError = false
+                    message = enabled
+                        ? L("FlowPilot will launch automatically when you next log in.", "FlowPilot 将在下次登录时自动启动。")
+                        : L("Login launch disabled; FlowPilot remains running now.", "已关闭登录启动；当前 FlowPilot 继续运行。")
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    status = FlowPilotAutostartService.status()
+                    isChanging = false
+                    isError = true
+                    message = error.localizedDescription
+                }
+            }
+        }
+    }
+}

codex_flow/data/apps/macos-overlay/Sources/Views/BubbleView.swift

@@ -0,0 +1,317 @@
+import SwiftUI
+import AppKit
+
+public struct BubbleView: View {
+    @ObservedObject var state: OverlayState
+    @ObservedObject private var localization = AppLocalization.shared
+    @ObservedObject private var updateService = FlowPilotUpdateService.shared
+    @State private var isHovered: Bool = false
+    @State private var breathePhase: CGFloat = 0.0
+    @State private var shimmerAngle: Double = 0.0
+
+    public init(state: OverlayState) {
+        self.state = state
+    }
+
+    public var body: some View {
+        ZStack {
+            if state.isDocked {
+                dockTabView
+                    .transition(.opacity.combined(with: .scale(scale: 0.95)))
+            } else {
+                fullBubbleView
+                    .transition(.opacity.combined(with: .scale(scale: 0.95)))
+            }
+
+            if updateService.hasUpdateBadge {
+                residentUpdateBadge
+                    .offset(x: updateBadgeOffsetX, y: -22)
+                    .transition(.scale(scale: 0.7).combined(with: .opacity))
+                    .allowsHitTesting(false)
+            }
+        }
+        .frame(width: 76, height: 76)
+        .animation(.spring(response: 0.16, dampingFraction: 0.82), value: state.isDocked)
+        .animation(.spring(response: 0.22, dampingFraction: 0.78), value: updateService.hasUpdateBadge)
+        .onAppear {
+            withAnimation(.easeInOut(duration: 1.2).repeatForever(autoreverses: true)) {
+                breathePhase = 1.0
+            }
+        }
+    }
+
+    private func handleHover(_ hovered: Bool) {
+        withAnimation(.easeInOut(duration: 0.25)) {
+            isHovered = hovered
+        }
+        if hovered {
+            withAnimation(.linear(duration: 2.0).repeatForever(autoreverses: false)) {
+                shimmerAngle = 360.0
+            }
+        } else {
+            shimmerAngle = 0.0
+        }
+    }
+
+    private var updateBadgeOffsetX: CGFloat {
+        if !state.isDocked { return -20 }
+        return state.dockEdge == .right ? 27 : -27
+    }
+
+    private var residentUpdateBadge: some View {
+        ZStack {
+            Circle()
+                .fill(updateService.isRestartRequired ? Color.orange : Color.red)
+                .frame(width: 12, height: 12)
+                .overlay(Circle().stroke(Color.black.opacity(0.78), lineWidth: 1.2))
+                .shadow(
+                    color: (updateService.isRestartRequired ? Color.orange : Color.red).opacity(0.7),
+                    radius: 3
+                )
+
+            Image(systemName: updateService.isRestartRequired ? "arrow.clockwise" : "arrow.down")
+                .font(.system(size: 6, weight: .black))
+                .foregroundColor(.white)
+        }
+        .accessibilityLabel(updateService.isRestartRequired ? L("Restart required", "需要重启") : L("Update available", "发现新版本"))
+    }
+
+    // MARK: - Dedicated Edge Dock Tab View
+    private var dockTabView: some View {
+        HStack(spacing: 0) {
+            if state.dockEdge == .right {
+                Spacer(minLength: 0)
+                dockPillContent(isRight: true)
+            } else {
+                dockPillContent(isRight: false)
+                Spacer(minLength: 0)
+            }
+        }
+        .frame(width: 76, height: 76)
+    }
+
+    private func dockPillContent(isRight: Bool) -> some View {
+        VStack(spacing: 2.5) {
+            HStack(spacing: 3) {
+                Circle()
+                    .fill(statusColor)
+                    .frame(width: 6.5, height: 6.5)
+                    .shadow(color: statusColor.opacity(0.9), radius: 2)
+
+                Image(systemName: "sparkles")
+                    .font(.system(size: 9.5, weight: .bold))
+                    .foregroundStyle(
+                        LinearGradient(
+                            colors: [.cyan, .purple],
+                            startPoint: .topLeading,
+                            endPoint: .bottomTrailing
+                        )
+                    )
+            }
+
+            Text(state.latestRun?.formattedCompactTokens ?? L("Ready", "就绪"))
+                .font(.system(size: 9.0, weight: .bold, design: .rounded))
+                .foregroundColor(.white)
+                .lineLimit(1)
+                .minimumScaleFactor(0.7)
+
+            HStack(spacing: 2) {
+                if isRight {
+                    Image(systemName: "chevron.left")
+                        .font(.system(size: 7, weight: .bold))
+                        .foregroundColor(.cyan.opacity(0.9))
+                }
+
+                Text(state.isTaskRunning ? L("RUN", "运行") : L("OK", "正常"))
+                    .font(.system(size: 7.5, weight: .black, design: .rounded))
+                    .foregroundColor(statusColor)
+
+                if !isRight {
+                    Image(systemName: "chevron.right")
+                        .font(.system(size: 7, weight: .bold))
+                        .foregroundColor(.cyan.opacity(0.9))
+                }
+            }
+        }
+        .padding(.vertical, 7)
+        .padding(.horizontal, 5)
+        .frame(width: 44, height: 56)
+        .background(
+            RoundedRectangle(cornerRadius: 13, style: .continuous)
+                .fill(
+                    LinearGradient(
+                        colors: [
+                            Color(red: 0.14, green: 0.16, blue: 0.22).opacity(0.96),
+                            Color(red: 0.08, green: 0.09, blue: 0.13).opacity(0.98)
+                        ],
+                        startPoint: isRight ? .leading : .trailing,
+                        endPoint: isRight ? .trailing : .leading
+                    )
+                )
+        )
+        .overlay(
+            RoundedRectangle(cornerRadius: 13, style: .continuous)
+                .stroke(
+                    LinearGradient(
+                        colors: [
+                            Color.cyan.opacity(0.7),
+                            Color.purple.opacity(0.5),
+                            Color.white.opacity(0.15)
+                        ],
+                        startPoint: isRight ? .leading : .trailing,
+                        endPoint: isRight ? .trailing : .leading
+                    ),
+                    lineWidth: 1.2
+                )
+        )
+        .shadow(color: statusGlowColor.opacity(0.45), radius: 4)
+        .contentShape(RoundedRectangle(cornerRadius: 13, style: .continuous))
+        .onHover { handleHover($0) }
+    }
+
+    // MARK: - Full Circular Bubble View
+    private var fullBubbleView: some View {
+        ZStack {
+            Circle()
+                .fill(
+                    RadialGradient(
+                        colors: [
+                            Color(red: 0.14, green: 0.16, blue: 0.22).opacity(0.92),
+                            Color(red: 0.06, green: 0.07, blue: 0.10).opacity(0.97)
+                        ],
+                        center: .center,
+                        startRadius: 4,
+                        endRadius: 29
+                    )
+                )
+                .overlay(
+                    Circle()
+                        .stroke(Color.white.opacity(isHovered ? 0.25 : 0.12), lineWidth: 0.8)
+                )
+                .frame(width: 58, height: 58)
+
+            Circle()
+                .strokeBorder(
+                    borderGradient,
+                    lineWidth: isHovered ? 2.0 : 1.6
+                )
+                .rotationEffect(.degrees(isHovered ? shimmerAngle : 0))
+                .shadow(
+                    color: statusGlowColor.opacity(isHovered ? 0.85 : (state.isTaskRunning ? 0.7 : 0.3)),
+                    radius: isHovered ? 4 : 2
+                )
+                .frame(width: 58, height: 58)
+
+            VStack(spacing: 2) {
+                ZStack {
+                    if state.isTaskRunning || isHovered {
+                        Circle()
+                            .stroke(statusColor.opacity(isHovered ? 0.6 : 0.4), lineWidth: 1.2)
+                            .frame(width: 28, height: 28)
+                            .scaleEffect(1.0 + breathePhase * (isHovered ? 0.25 : 0.35))
+                            .opacity(1.0 - breathePhase)
+                    }
+
+                    Image(systemName: "sparkles")
+                        .font(.system(size: 18, weight: .semibold))
+                        .foregroundStyle(
+                            LinearGradient(
+                                colors: isHovered ? [.white, .cyan, .purple] : [.cyan, .indigo, .purple],
+                                startPoint: .topLeading,
+                                endPoint: .bottomTrailing
+                            )
+                        )
+                        .shadow(color: .cyan.opacity(isHovered ? 0.7 : 0.3), radius: isHovered ? 3 : 1.5)
+                }
+                .frame(height: 22)
+
+                HStack(spacing: 2) {
+                    Image(systemName: "bolt.fill")
+                        .font(.system(size: 6.5, weight: .bold))
+                        .foregroundColor(statusColor)
+
+                    Text(state.latestRun?.formattedCompactTokens ?? L("Ready", "就绪"))
+                        .font(.system(size: 8, weight: .bold, design: .rounded))
+                        .foregroundColor(.white.opacity(0.95))
+                        .lineLimit(1)
+                        .minimumScaleFactor(0.75)
+                }
+                .padding(.horizontal, 5)
+                .padding(.vertical, 1.5)
+                .background(
+                    Capsule()
+                        .fill(Color.black.opacity(0.65))
+                        .overlay(
+                            Capsule()
+                                .stroke(Color.white.opacity(isHovered ? 0.3 : 0.15), lineWidth: 0.5)
+                        )
+                )
+            }
+
+            Circle()
+                .fill(statusColor)
+                .frame(width: 8, height: 8)
+                .overlay(
+                    Circle()
+                        .stroke(Color.black.opacity(0.7), lineWidth: 1.2)
+                )
+                .shadow(color: statusColor.opacity(isHovered ? 0.9 : 0.7), radius: isHovered ? 3 : 1.5)
+                .offset(x: 20, y: -20)
+        }
+        .frame(width: 58, height: 58)
+        .contentShape(Circle())
+        .onHover { handleHover($0) }
+    }
+
+    private var borderGradient: AnyShapeStyle {
+        if state.isTaskRunning {
+            return AnyShapeStyle(
+                AngularGradient(
+                    colors: [.cyan, .blue, .teal, .cyan],
+                    center: .center
+                )
+            )
+        } else if let run = state.latestRun, run.isError {
+            return AnyShapeStyle(
+                LinearGradient(
+                    colors: [.orange, .red],
+                    startPoint: .topLeading,
+                    endPoint: .bottomTrailing
+                )
+            )
+        } else {
+            return AnyShapeStyle(
+                AngularGradient(
+                    colors: [
+                        Color.cyan.opacity(0.8),
+                        Color.purple.opacity(0.8),
+                        Color.pink.opacity(0.8),
+                        Color.cyan.opacity(0.8)
+                    ],
+                    center: .center
+                )
+            )
+        }
+    }
+
+    private var statusColor: Color {
+        if state.isTaskRunning {
+            return .cyan
+        } else if let run = state.latestRun {
+            if run.isError {
+                return .orange
+            }
+            return Color(red: 0.2, green: 0.85, blue: 0.45)
+        }
+        return Color(red: 0.2, green: 0.85, blue: 0.45)
+    }
+
+    private var statusGlowColor: Color {
+        if state.isTaskRunning {
+            return .cyan
+        } else if let run = state.latestRun, run.isError {
+            return .red
+        }
+        return Color(red: 0.2, green: 0.85, blue: 0.45)
+    }
+}