codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/apps/macos-overlay/Tests/TelemetryQueryEngineConcurrencyTests.swift

@@ -0,0 +1,221 @@
+import Foundation
+
+// TelemetryData.swift references the app localization helper in an unrelated
+// display-only property. Keep this regression test isolated from UI/Combine.
+func L(_ english: String, _ chinese: String) -> String { english }
+
+@main
+struct TelemetryQueryEngineConcurrencyTests {
+    private struct QuerySnapshot: Equatable {
+        let runStems: [String]
+        let chatSignatures: [String]
+        let filteredRunStems: [String]
+        let totalRuns: Int
+        let delegatedRuns: Int
+        let directRuns: Int
+        let totalDurationMs: Double
+        let totalTokens: Int
+        let parentTokens: Int
+        let workerTokens: Int
+        let modelSignatures: [String]
+        let projectSignatures: [String]
+    }
+
+    private final class FailureRecorder: @unchecked Sendable {
+        private let lock = NSLock()
+        private var messages: [String] = []
+
+        func append(_ message: String) {
+            lock.lock()
+            messages.append(message)
+            lock.unlock()
+        }
+
+        var firstMessage: String? {
+            lock.lock()
+            defer { lock.unlock() }
+            return messages.first
+        }
+    }
+
+    // DispatchQueue's @Sendable closure cannot prove that this intentionally
+    // synchronized reference is safe, so keep the test's crossing explicit.
+    private final class EngineBox: @unchecked Sendable {
+        let engine: TelemetryQueryEngine
+
+        init(_ engine: TelemetryQueryEngine) {
+            self.engine = engine
+        }
+    }
+
+    static func main() {
+        testConcurrentQueriesRemainStable()
+        print("Telemetry query engine concurrency regression tests passed")
+    }
+
+    private static func testConcurrentQueriesRemainStable() {
+        let fileManager = FileManager.default
+        let root = fileManager.temporaryDirectory
+            .appendingPathComponent("telemetry-query-engine-\(UUID().uuidString)", isDirectory: true)
+        let runsDirectory = root.appendingPathComponent("runs", isDirectory: true)
+
+        do {
+            try fileManager.createDirectory(at: runsDirectory, withIntermediateDirectories: true)
+            try writeTelemetryRuns(to: runsDirectory)
+        } catch {
+            preconditionFailure("unable to create telemetry fixtures: \(error)")
+        }
+        defer { try? fileManager.removeItem(at: root) }
+
+        let engine = TelemetryQueryEngine(customRoot: root)
+        let expected = makeSnapshot(engine: engine, project: "telemetry-alpha")
+
+        precondition(expected.runStems.count == 12, "fixture should contain 12 runs")
+        precondition(expected.chatSignatures.count == 4, "fixture should contain 4 chat sessions")
+        precondition(expected.filteredRunStems.count == 6, "project filter should select 6 runs")
+        precondition(expected.totalRuns == 12)
+        precondition(expected.delegatedRuns == 4)
+        precondition(expected.directRuns == 8)
+        precondition(expected.totalDurationMs == 12_000)
+        precondition(expected.totalTokens == 1_484)
+        precondition(expected.parentTokens == 1_266)
+        precondition(expected.workerTokens == 218)
+        precondition(expected.modelSignatures == [
+            "model-parent:12:1266:parent",
+            "model-worker:4:218:worker",
+        ])
+        precondition(expected.projectSignatures == [
+            "telemetry-beta:6:748:2",
+            "telemetry-alpha:6:736:2",
+        ])
+
+        let engineBox = EngineBox(engine)
+        let failures = FailureRecorder()
+        let startGate = DispatchGroup()
+        let workers = DispatchGroup()
+        let workerCount = 8
+        let iterations = 30
+
+        startGate.enter()
+        for workerIndex in 0..<workerCount {
+            workers.enter()
+            DispatchQueue.global(qos: .userInitiated).async {
+                defer { workers.leave() }
+                startGate.wait()
+
+                for iteration in 0..<iterations {
+                    let snapshot = makeSnapshot(
+                        engine: engineBox.engine,
+                        project: "telemetry-alpha"
+                    )
+                    if snapshot != expected {
+                        failures.append(
+                            "worker \(workerIndex), iteration \(iteration) returned an unstable result"
+                        )
+                        return
+                    }
+                }
+            }
+        }
+        startGate.leave()
+        workers.wait()
+
+        precondition(
+            failures.firstMessage == nil,
+            failures.firstMessage ?? "concurrent telemetry query failed"
+        )
+    }
+
+    private static func writeTelemetryRuns(to runsDirectory: URL) throws {
+        let nowMs = Date().timeIntervalSince1970 * 1000
+        let encoder = JSONEncoder()
+
+        for index in 0..<12 {
+            let parentTokens = 100 + index
+            let workerTokens = 50 + index
+            let sessionIndex = index / 3
+            let project = index.isMultiple(of: 2) ? "telemetry-alpha" : "telemetry-beta"
+            let workers: [ParticipantInfo]?
+            if index.isMultiple(of: 3) {
+                workers = [
+                    ParticipantInfo(
+                        agentId: "worker-\(index)",
+                        name: "Worker \(index)",
+                        agentType: "worker",
+                        model: "model-worker",
+                        status: "completed",
+                        usage: TokenUsage(
+                            totalTokens: workerTokens,
+                            promptTokens: 30 + index,
+                            completionTokens: 20
+                        )
+                    )
+                ]
+            } else {
+                workers = nil
+            }
+
+            let run = TaskRun(
+                sessionId: "session-\(sessionIndex)",
+                turnId: "turn-\(index)",
+                startedAtMs: nowMs - Double(12 - index) * 1000,
+                finishedAtMs: nowMs - Double(11 - index) * 1000,
+                status: "completed",
+                thread: ThreadInfo(
+                    name: "session-\(sessionIndex)",
+                    preview: "stable telemetry run \(index)",
+                    cwd: "/tmp/\(project)",
+                    gitInfo: GitInfo(branch: "main")
+                ),
+                cwd: "/tmp/\(project)",
+                summary: "stable telemetry run \(index)",
+                parent: ParticipantInfo(
+                    name: "Parent",
+                    agentType: "orchestrator",
+                    model: "model-parent",
+                    status: "completed",
+                    usage: TokenUsage(
+                        totalTokens: parentTokens,
+                        promptTokens: parentTokens - 20,
+                        completionTokens: 20
+                    )
+                ),
+                workers: workers
+            )
+            let data = try encoder.encode(run)
+            let fileURL = runsDirectory.appendingPathComponent("run-\(index).json")
+            try data.write(to: fileURL, options: .atomic)
+        }
+    }
+
+    private static func makeSnapshot(
+        engine: TelemetryQueryEngine,
+        project: String
+    ) -> QuerySnapshot {
+        let runs = engine.loadAllRuns()
+        let chats = engine.fetchChatHistory(limit: 0)
+        let filteredRuns = engine.fetchHistory(limit: 0, project: project)
+        let stats = engine.computeStats(days: 30)
+
+        return QuerySnapshot(
+            runStems: runs.map { $0.fileStem ?? "" },
+            chatSignatures: chats.map { chat in
+                "\(chat.sessionId):\(chat.runs.count):\(chat.latestRun?.fileStem ?? "")"
+            },
+            filteredRunStems: filteredRuns.map { $0.fileStem ?? "" },
+            totalRuns: stats.totalRuns,
+            delegatedRuns: stats.delegatedRuns,
+            directRuns: stats.directRuns,
+            totalDurationMs: stats.totalDurationMs,
+            totalTokens: stats.totalTokens,
+            parentTokens: stats.parentTokens,
+            workerTokens: stats.workerTokens,
+            modelSignatures: stats.models.map {
+                "\($0.name):\($0.calls):\($0.tokens):\($0.roles.joined(separator: ","))"
+            },
+            projectSignatures: stats.projects.map {
+                "\($0.name):\($0.runs):\($0.tokens):\($0.delegated)"
+            }
+        )
+    }
+}

codex_flow/data/apps/macos-overlay/Tests/TelemetryQuotaSelectionTests.swift

@@ -0,0 +1,158 @@
+import Foundation
+
+// TelemetryData.swift references the app localization helper in an unrelated
+// display-only property. Keep this regression test isolated from UI/Combine.
+func L(_ english: String, _ chinese: String) -> String { english }
+
+@main
+struct TelemetryQuotaSelectionTests {
+    static func main() {
+        testCanonicalDeltaUsesWeeklyWindow()
+        testWindowOrderDoesNotChangeSemantics()
+        testMissingWeeklyWindowDoesNotFallBackToFiveHour()
+        testRemainingMetricsStayExplicit()
+        testFallbackDeltaComputedFromBeforeAndAfter()
+        print("Telemetry quota selection regression tests passed")
+    }
+
+    private static func testFallbackDeltaComputedFromBeforeAndAfter() {
+        let before = [
+            QuotaWindow(slot: "primary", usedPercent: 20.0, windowDurationMins: 300),
+            QuotaWindow(slot: "secondary", usedPercent: 40.0, windowDurationMins: 10_080)
+        ]
+        let after = [
+            QuotaWindow(slot: "primary", usedPercent: 25.0, windowDurationMins: 300),
+            QuotaWindow(slot: "secondary", usedPercent: 46.0, windowDurationMins: 10_080)
+        ]
+        let run = TaskRun(
+            sessionId: "quota-test-fallback",
+            turnId: UUID().uuidString,
+            status: "completed",
+            quotaBefore: before,
+            quotaAfter: after
+        )
+
+        precondition(run.shortWindowQuotaDelta == 5.0)
+        precondition(run.weeklyQuotaDelta == 6.0)
+        precondition(run.observedAccountDelta == 6.0)
+        // Contract 1: canonicalQuotaDelta strictly returns allocatedQuotaDelta; nil when missing
+        precondition(run.canonicalQuotaDelta == nil)
+        let weeklyWindow = run.effectiveQuotaWindows.first { $0.windowDurationMins == 10_080 }
+        precondition(weeklyWindow?.deltaPercentagePoints == 6.0)
+
+        // When allocation is provided, canonicalQuotaDelta returns it
+        let runWithAlloc = TaskRun(
+            sessionId: "quota-test-alloc",
+            turnId: UUID().uuidString,
+            status: "completed",
+            quotaBefore: before,
+            quotaAfter: after,
+            allocatedQuotaDelta: 6.0
+        )
+        precondition(runWithAlloc.canonicalQuotaDelta == 6.0)
+    }
+
+    private static func makeRun(_ windows: [QuotaWindow], allocated: Double? = nil) -> TaskRun {
+        TaskRun(
+            sessionId: "quota-test",
+            turnId: UUID().uuidString,
+            status: "completed",
+            quotaChangeDuringRun: windows,
+            allocatedQuotaDelta: allocated
+        )
+    }
+
+    private static func testCanonicalDeltaUsesWeeklyWindow() {
+        let runWithoutAlloc = makeRun([
+            QuotaWindow(
+                slot: "primary",
+                usedPercent: 24.0,
+                windowDurationMins: 300,
+                deltaPercentagePoints: 4.0
+            ),
+            QuotaWindow(
+                slot: "secondary",
+                usedPercent: 40.8,
+                windowDurationMins: 10_080,
+                deltaPercentagePoints: 0.8
+            ),
+        ])
+
+        precondition(runWithoutAlloc.shortWindowQuotaDelta == 4.0)
+        precondition(runWithoutAlloc.weeklyQuotaDelta == 0.8)
+        precondition(runWithoutAlloc.observedAccountDelta == 0.8)
+        // Missing allocation strictly returns nil, never falls back to 0.8
+        precondition(runWithoutAlloc.canonicalQuotaDelta == nil)
+
+        // With allocation
+        let runWithAlloc = makeRun([
+            QuotaWindow(
+                slot: "secondary",
+                usedPercent: 40.8,
+                windowDurationMins: 10_080,
+                deltaPercentagePoints: 0.8
+            ),
+        ], allocated: 0.8)
+        precondition(runWithAlloc.canonicalQuotaDelta == 0.8)
+    }
+
+    private static func testWindowOrderDoesNotChangeSemantics() {
+        let run = makeRun([
+            QuotaWindow(
+                slot: "secondary",
+                usedPercent: 40.8,
+                windowDurationMins: 10_080,
+                deltaPercentagePoints: 0.8
+            ),
+            QuotaWindow(
+                slot: "primary",
+                usedPercent: 24.0,
+                windowDurationMins: 300,
+                deltaPercentagePoints: 4.0
+            ),
+        ], allocated: 0.8)
+
+        precondition(run.shortWindowQuotaDelta == 4.0)
+        precondition(run.weeklyQuotaDelta == 0.8)
+        precondition(run.observedAccountDelta == 0.8)
+        precondition(run.canonicalQuotaDelta == 0.8)
+    }
+
+    private static func testMissingWeeklyWindowDoesNotFallBackToFiveHour() {
+        let run = makeRun([
+            QuotaWindow(
+                slot: "primary",
+                usedPercent: 24.0,
+                windowDurationMins: 300,
+                deltaPercentagePoints: 4.0
+            ),
+        ])
+
+        precondition(run.shortWindowQuotaDelta == 4.0)
+        precondition(run.weeklyQuotaDelta == nil)
+        precondition(run.canonicalQuotaDelta == nil)
+        precondition(run.primaryQuotaDelta == nil)
+    }
+
+    private static func testRemainingMetricsStayExplicit() {
+        let run = makeRun([
+            QuotaWindow(
+                slot: "primary",
+                usedPercent: 24.0,
+                windowDurationMins: 300,
+                deltaPercentagePoints: 4.0
+            ),
+            QuotaWindow(
+                slot: "secondary",
+                usedPercent: 40.8,
+                windowDurationMins: 10_080,
+                deltaPercentagePoints: 0.8
+            ),
+        ])
+
+        precondition(run.shortWindowQuotaRemaining == 76.0)
+        precondition(run.weeklyQuotaRemaining == 59.2)
+        // Preserve the legacy UI meaning of primary remaining as the short window.
+        precondition(run.primaryQuotaRemaining == 76.0)
+    }
+}

codex_flow/data/apps/macos-overlay/Tests/TelemetryWorkerTokenTests.swift

@@ -0,0 +1,122 @@
+import Foundation
+
+func L(_ english: String, _ chinese: String) -> String { english }
+
+@main
+struct TelemetryWorkerTokenTests {
+    static func main() {
+        testSingleRunWithWorkers()
+        testRunWithZeroWorkers()
+        testChatSessionWorkerAggregation()
+        print("Telemetry worker token regression tests passed")
+    }
+
+    private static func testSingleRunWithWorkers() {
+        let parentUsage = TokenUsage(
+            totalTokens: 1_500_000,
+            promptTokens: 1_490_000,
+            completionTokens: 10_000,
+            cachedPromptTokens: 1_400_000,
+            reasoningOutputTokens: 5_000
+        )
+        let parent = ParticipantInfo(
+            agentId: "p-1",
+            agentType: "parent",
+            model: "gpt-5.6-sol",
+            usageDelta: parentUsage
+        )
+
+        let workerUsage = TokenUsage(
+            totalTokens: 500_000,
+            promptTokens: 495_000,
+            completionTokens: 5_000,
+            cachedPromptTokens: 450_000,
+            reasoningOutputTokens: 2_000
+        )
+        let worker1 = ParticipantInfo(
+            agentId: "w-1",
+            agentType: "worker-implementer",
+            model: "gpt-5.6-luna",
+            usage: workerUsage
+        )
+
+        let run = TaskRun(
+            sessionId: "sess-1",
+            turnId: "turn-1",
+            status: "completed",
+            parent: parent,
+            workers: [worker1]
+        )
+
+        precondition(run.totalTokens == 2_000_000, "Total tokens should be 2.0M, got \(run.totalTokens)")
+        precondition(run.workerTotalTokens == 500_000, "Worker tokens should be 500k, got \(run.workerTotalTokens)")
+        precondition(run.parentTotalTokens == 1_500_000, "Parent tokens should be 1.5M, got \(run.parentTotalTokens)")
+        precondition(run.formattedWorkerTokens == "500.0k", "Formatted worker tokens: \(run.formattedWorkerTokens)")
+        precondition(abs(run.workerTokenShare - 0.25) < 0.001, "Worker share should be 25%")
+        precondition(run.formattedWorkerSharePercent == "25.0%", "Worker share formatted should be 25.0%")
+    }
+
+    private static func testRunWithZeroWorkers() {
+        let parentUsage = TokenUsage(
+            totalTokens: 676_000,
+            promptTokens: 670_000,
+            completionTokens: 6_000
+        )
+        let parent = ParticipantInfo(
+            agentId: "p-2",
+            agentType: "parent",
+            model: "gpt-5.6-sol",
+            usageDelta: parentUsage
+        )
+
+        let run = TaskRun(
+            sessionId: "sess-2",
+            turnId: "turn-2",
+            status: "completed",
+            parent: parent,
+            workers: []
+        )
+
+        precondition(run.totalTokens == 676_000)
+        precondition(run.workerTotalTokens == 0)
+        precondition(run.parentTotalTokens == 676_000)
+        precondition(run.formattedWorkerTokens == "0")
+        precondition(run.workerTokenShare == 0.0)
+        precondition(run.formattedWorkerSharePercent == "0.0%")
+    }
+
+    private static func testChatSessionWorkerAggregation() {
+        let parentUsage1 = TokenUsage(totalTokens: 8_000_000, promptTokens: 7_900_000, completionTokens: 100_000)
+        let workerUsage1 = TokenUsage(totalTokens: 2_000_000, promptTokens: 1_950_000, completionTokens: 50_000)
+        let run1 = TaskRun(
+            sessionId: "sess-chat",
+            turnId: "turn-c1",
+            status: "completed",
+            parent: ParticipantInfo(agentId: "p1", model: "gpt-5.6-sol", usageDelta: parentUsage1),
+            workers: [ParticipantInfo(agentId: "w1", model: "gpt-5.6-luna", usage: workerUsage1)]
+        )
+
+        let parentUsage2 = TokenUsage(totalTokens: 10_000_000, promptTokens: 9_900_000, completionTokens: 100_000)
+        let run2 = TaskRun(
+            sessionId: "sess-chat",
+            turnId: "turn-c2",
+            status: "completed",
+            parent: ParticipantInfo(agentId: "p2", model: "gpt-5.6-sol", usageDelta: parentUsage2),
+            workers: []
+        )
+
+        let chat = ChatSession(
+            sessionId: "sess-chat",
+            projectName: "codex-flow",
+            title: "Test Chat",
+            runs: [run2, run1]
+        )
+
+        precondition(chat.totalTokens == 20_000_000, "Chat total tokens should be 20M, got \(chat.totalTokens)")
+        precondition(chat.workerTotalTokens == 2_000_000, "Chat worker tokens should be 2M, got \(chat.workerTotalTokens)")
+        precondition(chat.parentTotalTokens == 18_000_000, "Chat parent tokens should be 18M, got \(chat.parentTotalTokens)")
+        precondition(chat.formattedWorkerTokens == "2.0M", "Chat formatted worker tokens should be 2.0M, got \(chat.formattedWorkerTokens)")
+        precondition(abs(chat.workerTokenShare - 0.10) < 0.001, "Chat worker share should be 10%")
+        precondition(chat.formattedWorkerSharePercent == "10.0%")
+    }
+}

codex_flow/data/apps/macos-overlay/build.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+BIN_DIR="$SCRIPT_DIR/bin"
+OUTPUT="$BIN_DIR/codex-flow-overlay"
+FLOWPILOT_OUTPUT="$BIN_DIR/FlowPilot"
+TMP_OUTPUT="$BIN_DIR/.codex-flow-overlay.$$"
+TMP_FLOWPILOT="$BIN_DIR/.FlowPilot.$$"
+CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
+state_tmp_flowpilot=""
+state_tmp_overlay=""
+
+cleanup() {
+    rm -f "$TMP_OUTPUT" "$TMP_FLOWPILOT"
+    [[ -z "$state_tmp_flowpilot" ]] || rm -f "$state_tmp_flowpilot"
+    [[ -z "$state_tmp_overlay" ]] || rm -f "$state_tmp_overlay"
+}
+trap cleanup EXIT
+
+mkdir -p "$BIN_DIR"
+
+echo "🔨 Building FlowPilot native macOS widget (this usually takes ~40-50s on macOS)..."
+
+SWIFT_FILES=()
+while IFS= read -r -d '' file; do
+    SWIFT_FILES+=("$file")
+done < <(find "$SCRIPT_DIR/Sources" -name "*.swift" -print0)
+
+CORES="$(sysctl -n hw.ncpu 2>/dev/null || echo 2)"
+if [ "$CORES" -gt 4 ]; then
+    CORES=4
+fi
+
+# Build to a fresh inode first. Replacing a currently executing macOS binary in
+# place can invalidate mapped executable pages and SIGKILL the running process.
+# Atomic rename keeps the old inode alive for the current process while new
+# launches immediately see the freshly built binary.
+swiftc \
+    -num-threads "$CORES" \
+    -j "$CORES" \
+    -framework Cocoa \
+    -framework SwiftUI \
+    -framework Combine \
+    "${SWIFT_FILES[@]}" \
+    -o "$TMP_OUTPUT"
+
+chmod +x "$TMP_OUTPUT"
+mv -f "$TMP_OUTPUT" "$OUTPUT"
+cp "$OUTPUT" "$TMP_FLOWPILOT"
+chmod +x "$TMP_FLOWPILOT"
+mv -f "$TMP_FLOWPILOT" "$FLOWPILOT_OUTPUT"
+ln -sf "codex-flow-overlay" "$BIN_DIR/flow-pilot"
+
+# Sync to installed state dir if it exists. Use the same atomic replacement so
+# rebuilding from the console never corrupts a currently running installed copy.
+STATE_BIN="$CODEX_HOME/codex-flow/bin"
+if [[ -d "$STATE_BIN" ]]; then
+    state_tmp_flowpilot="$STATE_BIN/.FlowPilot.$$"
+    state_tmp_overlay="$STATE_BIN/.codex-flow-overlay.$$"
+    cp "$FLOWPILOT_OUTPUT" "$state_tmp_flowpilot"
+    cp "$OUTPUT" "$state_tmp_overlay"
+    chmod +x "$state_tmp_flowpilot" "$state_tmp_overlay"
+    mv -f "$state_tmp_flowpilot" "$STATE_BIN/FlowPilot"
+    state_tmp_flowpilot=""
+    mv -f "$state_tmp_overlay" "$STATE_BIN/codex-flow-overlay"
+    state_tmp_overlay=""
+fi
+
+echo "✨ Build succeeded: $FLOWPILOT_OUTPUT"
+echo ""
+echo "🚀 Quick Start:"
+echo "   • 启动悬浮窗:  codex-flow overlay start"
+echo "   • 或独立运行:  $FLOWPILOT_OUTPUT start &"
+echo ""