codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/apps/macos-overlay/Sources/Services/FlowPilotInstanceLock.swift

@@ -0,0 +1,153 @@
+import Foundation
+import Darwin
+
+/// Process-lifetime singleton lock for the native FlowPilot overlay.
+///
+/// The lock file is deliberately never removed.  `flock` tracks ownership by
+/// open file description, so a process crash releases the lock while keeping a
+/// stable path for future processes to open.  The descriptor is marked
+/// close-on-exec so helper processes cannot accidentally keep the overlay
+/// alive after the app exits.
+public final class FlowPilotInstanceLock {
+    public static let launchAgentEnvironmentKey = "CODEX_FLOW_LAUNCHD_START"
+    public static let manualHandoffTimeout: TimeInterval = 5.0
+
+    public static var lockPath: String {
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        let codexHome = ProcessInfo.processInfo.environment["CODEX_HOME"]
+            ?? home.appendingPathComponent(".codex").path
+        let directory = URL(fileURLWithPath: codexHome).appendingPathComponent("codex-flow")
+        try? FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+        return directory.appendingPathComponent("overlay.lock").path
+    }
+
+    public static var isLaunchAgentStart: Bool {
+        guard let raw = ProcessInfo.processInfo.environment[launchAgentEnvironmentKey]?
+            .trimmingCharacters(in: .whitespacesAndNewlines)
+            .lowercased() else {
+            return false
+        }
+        return raw == "1" || raw == "true" || raw == "yes"
+    }
+
+    public enum LockError: Error, LocalizedError {
+        case openFailed(path: String, errno: Int32)
+        case acquisitionFailed(path: String, errno: Int32)
+        case timedOut(path: String, timeout: TimeInterval)
+        case closed
+
+        public var errorDescription: String? {
+            switch self {
+            case let .openFailed(path, errorNumber):
+                return "Could not open FlowPilot instance lock at \(path): \(Self.message(for: errorNumber))"
+            case let .acquisitionFailed(path, errorNumber):
+                return "Could not acquire FlowPilot instance lock at \(path): \(Self.message(for: errorNumber))"
+            case let .timedOut(path, timeout):
+                return "Timed out after \(String(format: "%.1f", timeout))s waiting for FlowPilot instance lock at \(path)."
+            case .closed:
+                return "FlowPilot instance lock is closed."
+            }
+        }
+
+        private static func message(for errorNumber: Int32) -> String {
+            guard let message = strerror(errorNumber) else {
+                return "errno \(errorNumber)"
+            }
+            return String(cString: message)
+        }
+    }
+
+    private let path: String
+    private var fileDescriptor: Int32
+    private var ownsLock = false
+
+    public init(path: String = FlowPilotInstanceLock.lockPath) throws {
+        self.path = path
+
+        let directory = URL(fileURLWithPath: path).deletingLastPathComponent()
+        try FileManager.default.createDirectory(at: directory, withIntermediateDirectories: true)
+
+        let mode = mode_t(0o600)
+        let descriptor = open(path, O_CREAT | O_RDWR | O_CLOEXEC, mode)
+        guard descriptor >= 0 else {
+            throw LockError.openFailed(path: path, errno: errno)
+        }
+
+        self.fileDescriptor = descriptor
+        // `open(..., 0600)` only applies when the file is created.  Tighten an
+        // existing lock left by an older build as well, without replacing its
+        // inode or disturbing an active flock owner.
+        if fchmod(descriptor, mode) != 0 {
+            let errorNumber = errno
+            close(descriptor)
+            throw LockError.openFailed(path: path, errno: errorNumber)
+        }
+    }
+
+    /// Acquire the exclusive lock, retrying transient contention until the
+    /// monotonic timeout expires.  A zero timeout performs one non-blocking
+    /// attempt, which is used to decide whether a manual handoff is needed.
+    public func acquire(timeout: TimeInterval) throws {
+        guard fileDescriptor >= 0 else { throw LockError.closed }
+
+        if ownsLock { return }
+        let deadline = Self.monotonicDeadline(after: timeout)
+
+        while true {
+            if flock(fileDescriptor, LOCK_EX | LOCK_NB) == 0 {
+                ownsLock = true
+                return
+            }
+
+            let errorNumber = errno
+            guard errorNumber == EINTR || errorNumber == EWOULDBLOCK || errorNumber == EAGAIN else {
+                throw LockError.acquisitionFailed(path: path, errno: errorNumber)
+            }
+
+            let current = Self.monotonicNow()
+            if current >= deadline {
+                throw LockError.timedOut(path: path, timeout: max(0, timeout))
+            }
+
+            // A short bounded sleep avoids a busy loop while keeping handoff
+            // responsive.  If usleep is interrupted, the outer loop retries
+            // and re-checks the same monotonic deadline.
+            let remaining = deadline - current
+            let micros = min(UInt64(10_000), max(UInt64(1), remaining / 1_000))
+            _ = usleep(UInt32(min(micros, UInt64(UInt32.max))))
+        }
+    }
+
+    /// Release ownership and close the descriptor.  The lock file itself is
+    /// intentionally retained for the next process to open.
+    public func release() {
+        guard fileDescriptor >= 0 else { return }
+        if ownsLock {
+            _ = flock(fileDescriptor, LOCK_UN)
+            ownsLock = false
+        }
+        close(fileDescriptor)
+        fileDescriptor = -1
+    }
+
+    deinit {
+        release()
+    }
+
+    private static func monotonicNow() -> UInt64 {
+        DispatchTime.now().uptimeNanoseconds
+    }
+
+    private static func monotonicDeadline(after timeout: TimeInterval) -> UInt64 {
+        let now = monotonicNow()
+        guard timeout.isFinite, timeout > 0 else {
+            return timeout.isFinite ? now : UInt64.max
+        }
+
+        let requested = timeout * 1_000_000_000
+        let delta = requested >= Double(UInt64.max)
+            ? UInt64.max
+            : UInt64(max(1, requested.rounded(.up)))
+        return UInt64.max - now < delta ? UInt64.max : now + delta
+    }
+}

codex_flow/data/apps/macos-overlay/Sources/Services/IPCServer.swift

@@ -0,0 +1,298 @@
+import Foundation
+import Cocoa
+import Darwin
+
+public class IPCService {
+    public static var socketPath: String {
+        let home = FileManager.default.homeDirectoryForCurrentUser
+        let codexHome = ProcessInfo.processInfo.environment["CODEX_HOME"] ?? home.appendingPathComponent(".codex").path
+        let dir = URL(fileURLWithPath: codexHome).appendingPathComponent("codex-flow")
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+        return dir.appendingPathComponent("overlay.sock").path
+    }
+
+    // MARK: - Server Implementation
+    public class Server {
+        public let state: OverlayState
+        private var serverSource: DispatchSourceRead?
+        private var serverSocket: Int32 = -1
+        private let path: String
+        private var boundSocketFileNumber: UInt64?
+        public private(set) var isRunning = false
+
+        public init(state: OverlayState, socketPath: String = IPCService.socketPath) {
+            self.state = state
+            self.path = socketPath
+            start()
+        }
+
+        public func start() {
+            guard serverSource == nil, serverSocket < 0 else { return }
+            unlink(path)
+
+            serverSocket = socket(AF_UNIX, SOCK_STREAM, 0)
+            guard serverSocket >= 0 else { return }
+
+            var addr = sockaddr_un()
+            addr.sun_family = sa_family_t(AF_UNIX)
+            let pathMax = MemoryLayout.size(ofValue: addr.sun_path)
+
+            withUnsafeMutablePointer(to: &addr.sun_path) { ptr in
+                let rawPtr = UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: CChar.self)
+                _ = path.withCString { cstr in
+                    strncpy(rawPtr, cstr, pathMax - 1)
+                }
+            }
+
+            let addrLen = socklen_t(MemoryLayout<sockaddr_un>.size)
+            let bindResult = withUnsafePointer(to: &addr) { ptr in
+                ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
+                    bind(serverSocket, sa, addrLen)
+                }
+            }
+
+            guard bindResult == 0 else {
+                close(serverSocket)
+                serverSocket = -1
+                return
+            }
+
+            // Remember the filesystem socket node we actually bound. During a
+            // restart an older process can finish after a newer process has
+            // rebound the same path; only the owner of the current node may
+            // unlink it during shutdown.
+            boundSocketFileNumber = socketFileNumber(at: path)
+
+            guard listen(serverSocket, 5) == 0 else {
+                let expected = boundSocketFileNumber
+                close(serverSocket)
+                serverSocket = -1
+                if let expected,
+                   self.socketFileNumber(at: path) == expected {
+                    unlink(path)
+                }
+                boundSocketFileNumber = nil
+                return
+            }
+
+            let source = DispatchSource.makeReadSource(fileDescriptor: serverSocket, queue: .main)
+            source.setEventHandler { [weak self] in
+                self?.acceptConnection()
+            }
+            source.setCancelHandler { [weak self] in
+                guard let self else { return }
+                self.isRunning = false
+                if self.serverSocket >= 0 {
+                    close(self.serverSocket)
+                    self.serverSocket = -1
+                }
+                if let expected = self.boundSocketFileNumber,
+                   self.socketFileNumber(at: self.path) == expected {
+                    unlink(self.path)
+                }
+            }
+            source.resume()
+            self.serverSource = source
+            self.isRunning = true
+        }
+
+        private func socketFileNumber(at path: String) -> UInt64? {
+            guard let attributes = try? FileManager.default.attributesOfItem(atPath: path),
+                  let number = attributes[.systemFileNumber] as? NSNumber else {
+                return nil
+            }
+            return number.uint64Value
+        }
+
+        private func acceptConnection() {
+            var clientAddr = sockaddr_un()
+            var clientAddrLen = socklen_t(MemoryLayout<sockaddr_un>.size)
+            let clientSocket = withUnsafeMutablePointer(to: &clientAddr) { ptr in
+                ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
+                    accept(serverSocket, sa, &clientAddrLen)
+                }
+            }
+
+            guard clientSocket >= 0 else { return }
+            var noSigPipe: Int32 = 1
+            _ = setsockopt(
+                clientSocket,
+                SOL_SOCKET,
+                SO_NOSIGPIPE,
+                &noSigPipe,
+                socklen_t(MemoryLayout<Int32>.size)
+            )
+
+            var buffer = [UInt8](repeating: 0, count: 4096)
+            let bytesRead = read(clientSocket, &buffer, buffer.count)
+            if bytesRead > 0 {
+                let data = Data(buffer[0..<bytesRead])
+                if let command = String(data: data, encoding: .utf8)?.trimmingCharacters(in: .whitespacesAndNewlines) {
+                    let response = handleCommand(command)
+                    if let resData = response.data(using: .utf8) {
+                        _ = resData.withUnsafeBytes { raw in
+                            write(clientSocket, raw.baseAddress, resData.count)
+                        }
+                    }
+                }
+            }
+            close(clientSocket)
+        }
+
+        private func handleCommand(_ cmd: String) -> String {
+            if cmd == "status" {
+                return "{\"running\": true, \"pid\": \(getpid()), \"isExpanded\": \(state.isExpanded), \"isPinned\": \(state.isPinned), \"activeTab\": \"\(state.activeTab.rawValue)\"}\n"
+            } else if cmd == "toggle" {
+                state.toggle()
+                return "{\"ok\": true, \"action\": \"toggle\", \"isExpanded\": \(state.isExpanded)}\n"
+            } else if cmd == "expand" {
+                state.expand()
+                return "{\"ok\": true, \"action\": \"expand\"}\n"
+            } else if cmd == "collapse" {
+                state.collapse()
+                return "{\"ok\": true, \"action\": \"collapse\"}\n"
+            } else if cmd.hasPrefix("tab") {
+                let target = cmd.dropFirst("tab".count).trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+                if target.contains("hist") {
+                    state.selectTab(.history)
+                    state.expand()
+                    return "{\"ok\": true, \"tab\": \"History\"}\n"
+                } else if target.contains("stat") || target.contains("analyt") {
+                    state.selectTab(.analytics)
+                    state.expand()
+                    return "{\"ok\": true, \"tab\": \"Analytics\"}\n"
+                } else {
+                    state.selectTab(.inspector)
+                    state.expand()
+                    return "{\"ok\": true, \"tab\": \"Inspector\"}\n"
+                }
+            } else if cmd.hasPrefix("show") {
+                let target = cmd.dropFirst("show".count).trimmingCharacters(in: .whitespacesAndNewlines)
+                if let run = TelemetryQueryEngine.shared.fetchRun(identifier: target) {
+                    state.inspect(run: run)
+                    state.expand()
+                    return "{\"ok\": true, \"inspected\": \"\(run.sessionTitle)\"}\n"
+                }
+                return "{\"ok\": false, \"error\": \"run not found for '\(target)'\"}\n"
+            } else if cmd.hasPrefix("stats") {
+                let parts = cmd.dropFirst("stats".count).trimmingCharacters(in: .whitespacesAndNewlines)
+                if let d = Int(parts), d > 0 {
+                    state.statsDays = d
+                }
+                state.selectTab(.analytics)
+                state.expand()
+                return "{\"ok\": true, \"action\": \"showing_stats\", \"days\": \(state.statsDays)}\n"
+            } else if cmd.hasPrefix("history") || cmd.hasPrefix("list") {
+                state.selectTab(.history)
+                state.expand()
+                return "{\"ok\": true, \"action\": \"showing_history\"}\n"
+            } else if cmd.hasPrefix("update") {
+                let payload = cmd.dropFirst("update".count).trimmingCharacters(in: .whitespacesAndNewlines)
+                if payload.isEmpty {
+                    let home = FileManager.default.homeDirectoryForCurrentUser
+                    let codexHome = ProcessInfo.processInfo.environment["CODEX_HOME"] ?? home.appendingPathComponent(".codex").path
+                    let lastUrl = URL(fileURLWithPath: codexHome).appendingPathComponent("codex-flow").appendingPathComponent("telemetry").appendingPathComponent("last.json")
+                    if let data = try? Data(contentsOf: lastUrl),
+                       var run = try? JSONDecoder().decode(TaskRun.self, from: data) {
+                        TelemetryQueryEngine.shared.enrichRunIfNeeded(&run)
+                        state.update(run: run)
+                        state.expand()
+                        return "{\"ok\": true, \"updatedFrom\": \"last.json\"}\n"
+                    }
+                    state.expand()
+                    return "{\"ok\": true, \"action\": \"expanded\"}\n"
+                } else {
+                    if let fileData = try? Data(contentsOf: URL(fileURLWithPath: payload)),
+                       var run = try? JSONDecoder().decode(TaskRun.self, from: fileData) {
+                        TelemetryQueryEngine.shared.enrichRunIfNeeded(&run)
+                        state.update(run: run)
+                        state.expand()
+                        return "{\"ok\": true, \"updatedFrom\": \"file\"}\n"
+                    } else if let json = payload.data(using: .utf8),
+                              var run = try? JSONDecoder().decode(TaskRun.self, from: json) {
+                        TelemetryQueryEngine.shared.enrichRunIfNeeded(&run)
+                        state.update(run: run)
+                        state.expand()
+                        return "{\"ok\": true, \"updatedFrom\": \"json\"}\n"
+                    }
+                }
+                return "{\"ok\": false, \"error\": \"invalid payload\"}\n"
+            } else if cmd == "quit" || cmd == "stop" {
+                DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) {
+                    NSApplication.shared.terminate(nil)
+                }
+                return "{\"ok\": true, \"action\": \"quitting\"}\n"
+            }
+            return "{\"ok\": false, \"error\": \"unknown command\"}\n"
+        }
+
+        public func stop() {
+            serverSource?.cancel()
+            serverSource = nil
+            // The dispatch source owns final socket teardown.  Mark the
+            // service stopped immediately so AppDelegate can release the
+            // singleton lock only after this cancellation has been issued.
+            isRunning = false
+        }
+    }
+
+    // MARK: - Client Implementation
+    public static func sendCommand(_ cmd: String, socketPath: String = IPCService.socketPath) -> (success: Bool, response: String) {
+        guard FileManager.default.fileExists(atPath: socketPath) else {
+            return (false, L("Overlay is not running (socket not found).", "悬浮窗未运行（未找到 socket）。"))
+        }
+
+        let clientSocket = socket(AF_UNIX, SOCK_STREAM, 0)
+        guard clientSocket >= 0 else {
+            return (false, L("Failed to create client socket.", "创建客户端 socket 失败。"))
+        }
+        defer { close(clientSocket) }
+        var noSigPipe: Int32 = 1
+        _ = setsockopt(
+            clientSocket,
+            SOL_SOCKET,
+            SO_NOSIGPIPE,
+            &noSigPipe,
+            socklen_t(MemoryLayout<Int32>.size)
+        )
+
+        var addr = sockaddr_un()
+        addr.sun_family = sa_family_t(AF_UNIX)
+        let pathMax = MemoryLayout.size(ofValue: addr.sun_path)
+
+        withUnsafeMutablePointer(to: &addr.sun_path) { ptr in
+            let rawPtr = UnsafeMutableRawPointer(ptr).assumingMemoryBound(to: CChar.self)
+            _ = socketPath.withCString { cstr in
+                strncpy(rawPtr, cstr, pathMax - 1)
+            }
+        }
+
+        let addrLen = socklen_t(MemoryLayout<sockaddr_un>.size)
+        let connectResult = withUnsafePointer(to: &addr) { ptr in
+            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) { sa in
+                connect(clientSocket, sa, addrLen)
+            }
+        }
+
+        guard connectResult == 0 else {
+            return (false, L("Failed to connect to overlay socket.", "连接悬浮窗 socket 失败。"))
+        }
+
+        guard let data = cmd.data(using: .utf8) else {
+            return (false, L("Encoding error.", "编码错误。"))
+        }
+
+        _ = data.withUnsafeBytes { raw in
+            write(clientSocket, raw.baseAddress, data.count)
+        }
+
+        var buffer = [UInt8](repeating: 0, count: 4096)
+        let bytesRead = read(clientSocket, &buffer, buffer.count)
+        if bytesRead > 0 {
+            let response = String(data: Data(buffer[0..<bytesRead]), encoding: .utf8) ?? ""
+            return (true, response.trimmingCharacters(in: .whitespacesAndNewlines))
+        }
+
+        return (true, "OK")
+    }
+}