@sriinnu/runic 1.0.0

package/Tests/RunicTests/StatusProbeTests.swift

@@ -0,0 +1,377 @@
+import RunicCore
+import Foundation
+import Testing
+@testable import Runic
+
+@Suite
+struct StatusProbeTests {
+    @Test
+    func parseCodexStatus() throws {
+        let sample = """
+        Model: gpt
+        Credits: 980 credits
+        5h limit: [#####] 75% left
+        Weekly limit: [##] 25% left
+        """
+        let snap = try CodexStatusProbe.parse(text: sample)
+        #expect(snap.credits == 980)
+        #expect(snap.fiveHourPercentLeft == 75)
+        #expect(snap.weeklyPercentLeft == 25)
+    }
+
+    @Test
+    func parseCodexStatusWithAnsiAndResets() throws {
+        let sample = """
+        \u{001B}[38;5;245mCredits:\u{001B}[0m 557 credits
+        5h limit: [█████     ] 50% left (resets 09:01)
+        Weekly limit: [███████   ] 85% left (resets 04:01 on 27 Nov)
+        """
+        let snap = try CodexStatusProbe.parse(text: sample)
+        #expect(snap.credits == 557)
+        #expect(snap.fiveHourPercentLeft == 50)
+        #expect(snap.weeklyPercentLeft == 85)
+    }
+
+    @Test
+    func parseClaudeStatus() throws {
+        let sample = """
+        Settings: Status   Config   Usage (tab to cycle)
+
+        Current session
+        1% used  (Resets 5am (Europe/Vienna))
+        Current week (all models)
+        1% used  (Resets Dec 2 at 12am (Europe/Vienna))
+        Current week (Sonnet only)
+        1% used (Resets Dec 2 at 12am (Europe/Vienna))
+
+        Nov 24, 2025 update:
+        We've increased your limits and removed the Opus cap,
+        so you can use Opus 4.5 up to your overall limit.
+        Sonnet now has its own limit—it's set to match your previous overall limit,
+        so you can use just as much as before.
+        Account: user@example.com
+        Org: Example Org
+        """
+        let snap = try ClaudeStatusProbe.parse(text: sample)
+        #expect(snap.sessionPercentLeft == 99)
+        #expect(snap.weeklyPercentLeft == 99)
+        #expect(snap.opusPercentLeft == 99)
+        #expect(snap.accountEmail == "user@example.com")
+        #expect(snap.accountOrganization == "Example Org")
+        #expect(snap.primaryResetDescription == "Resets 5am (Europe/Vienna)")
+        #expect(snap.secondaryResetDescription == "Resets Dec 2 at 12am (Europe/Vienna)")
+        #expect(snap.opusResetDescription == "Resets Dec 2 at 12am (Europe/Vienna)")
+    }
+
+    @Test
+    func parseClaudeStatusWithANSI() throws {
+        let sample = """
+        \u{001B}[35mCurrent session\u{001B}[0m
+        40% used  (Resets 11am)
+        Current week (all models)
+        10% used  (Resets Nov 27)
+        Current week (Sonnet only)
+        0% used (Resets Nov 27)
+        Account: user@example.com
+        Org: ACME
+        \u{001B}[0m
+        """
+        let snap = try ClaudeStatusProbe.parse(text: sample)
+        #expect(snap.sessionPercentLeft == 60)
+        #expect(snap.weeklyPercentLeft == 90)
+        #expect(snap.opusPercentLeft == 100)
+        #expect(snap.primaryResetDescription == "Resets 11am")
+        #expect(snap.secondaryResetDescription == "Resets Nov 27")
+        #expect(snap.opusResetDescription == "Resets Nov 27")
+    }
+
+    @Test
+    func parseClaudeStatusLegacyOpusLabel() throws {
+        let sample = """
+        Current session
+        12% used  (Resets 11am)
+        Current week (all models)
+        55% used  (Resets Nov 21)
+        Current week (Opus)
+        5% used (Resets Nov 21)
+        Account: user@example.com
+        Org: Example Org
+        """
+        let snap = try ClaudeStatusProbe.parse(text: sample)
+        #expect(snap.sessionPercentLeft == 88)
+        #expect(snap.weeklyPercentLeft == 45)
+        #expect(snap.opusPercentLeft == 95)
+        #expect(snap.primaryResetDescription == "Resets 11am")
+        #expect(snap.secondaryResetDescription == "Resets Nov 21")
+        #expect(snap.opusResetDescription == "Resets Nov 21")
+    }
+
+    @Test
+    func parseClaudeStatusEnterpriseSessionOnly() throws {
+        let sample = """
+        Current session
+        █                                                  2% used
+        Resets 3pm (Europe/Vienna)
+        """
+        let snap = try ClaudeStatusProbe.parse(text: sample)
+        #expect(snap.sessionPercentLeft == 98)
+        #expect(snap.weeklyPercentLeft == nil)
+        #expect(snap.primaryResetDescription == "Resets 3pm (Europe/Vienna)")
+        #expect(snap.secondaryResetDescription == nil)
+    }
+
+    @Test
+    func parseClaudeStatusResetMappings_withCRLineEndings() throws {
+        let sample =
+            "Current  session\r" +
+            "██████████████████████████████████████████████████  17% used\r" +
+            "Resets 12:59pm (Europe/Paris)\r" +
+            "Current week (all models)\r" +
+            "██████████████████████████████████████████████████   4% used\r" +
+            "Resets Dec 24 at 3:59pm (Europe/Paris)\r" +
+            "Current week (Sonnet only)\r" +
+            "██████████████████████████████████████████████████   3% used\r" +
+            "Resets Dec 23 at 3:59am (Europe/Paris)\r"
+
+        let snap = try ClaudeStatusProbe.parse(text: sample)
+        #expect(snap.sessionPercentLeft == 83)
+        #expect(snap.weeklyPercentLeft == 96)
+        #expect(snap.opusPercentLeft == 97)
+        #expect(snap.primaryResetDescription == "Resets 12:59pm (Europe/Paris)")
+        #expect(snap.secondaryResetDescription == "Resets Dec 24 at 3:59pm (Europe/Paris)")
+        #expect(snap.opusResetDescription == "Resets Dec 23 at 3:59am (Europe/Paris)")
+    }
+
+    @Test
+    func parseClaudeStatusResetMappings_doesNotPromoteWeeklyResetToSession() throws {
+        let sample = """
+        Current session
+        ██████████████████████████████████████████████████  17% used
+        Current week (all models)
+        ██████████████████████████████████████████████████   4% used
+        Resets Dec 24 at 3:59pm (Europe/Paris)
+        """
+        let snap = try ClaudeStatusProbe.parse(text: sample)
+        #expect(snap.sessionPercentLeft == 83)
+        #expect(snap.weeklyPercentLeft == 96)
+        #expect(snap.primaryResetDescription == nil)
+        #expect(snap.secondaryResetDescription == "Resets Dec 24 at 3:59pm (Europe/Paris)")
+    }
+
+    @Test
+    func parseClaudeStatusWithPlanAndAnsiNoise() throws {
+        let sample = """
+        Settings: Status   Config   Usage
+
+        Login method: \u{001B}[22mClaude Max Account\u{001B}[0m
+        Account: user@example.com
+        Org: ACME
+        """
+        // Only care about login/identity; include minimal usage lines to satisfy parser.
+        let text = """
+        Current session
+        10% used
+        Current week (all models)
+        20% used
+        Current week (Opus)
+        30% used
+        \(sample)
+        """
+        let snap = try ClaudeStatusProbe.parse(text: text)
+        #expect(snap.loginMethod == "Max")
+        #expect(snap.accountEmail == "user@example.com")
+        #expect(snap.accountOrganization == "ACME")
+    }
+
+    @Test
+    func parseClaudeStatusWithBracketPlanNoiseNoEsc() throws {
+        let sample = """
+        Login method: [22m Claude Max Account
+        Account: user@example.com
+        """
+        let text = """
+        Current session
+        10% used
+        Current week (all models)
+        20% used
+        Current week (Opus)
+        30% used
+        \(sample)
+        """
+        let snap = try ClaudeStatusProbe.parse(text: text)
+        #expect(snap.loginMethod == "Max")
+    }
+
+    @Test
+    func surfacesClaudeTokenExpired() {
+        let sample = """
+        Settings:  Status   Config   Usage
+
+        Error: Failed to load usage data: {"type":"error","error":{"type":"authentication_error",
+        "message":"OAuth token has expired. Please obtain a new token or refresh your existing token.",
+        "details":{"error_visibility":"user_facing","error_code":"token_expired"}},\
+        "request_id":"req_123"}
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: sample)
+            #expect(Bool(false), "Parsing should fail for auth error")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            let lower = message.lowercased()
+            #expect(lower.contains("token"))
+            #expect(lower.contains("login"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func surfacesClaudeFolderTrustPrompt() {
+        let sample = """
+        Do you trust the files in this folder?
+
+        /Users/example/project
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: sample)
+            #expect(Bool(false), "Parsing should fail for folder trust prompt")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            #expect(message.lowercased().contains("trust"))
+            #expect(message.contains("/Users/example/project"))
+            #expect(message.contains("cd \"/Users/example/project\" && claude"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func surfacesClaudeFolderTrustPrompt_withCRLFAndSpaces() {
+        let sample = "Do you trust the files in this folder?\r\n\r\n/Users/example/My Project\r\n"
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: sample)
+            #expect(Bool(false), "Parsing should fail for folder trust prompt")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            #expect(message.contains("/Users/example/My Project"))
+            #expect(message.contains("cd \"/Users/example/My Project\" && claude"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func surfacesClaudeFolderTrustPrompt_withoutFolderPath() {
+        let sample = """
+        Do you trust the files in this folder?
+        """
+
+        do {
+            _ = try ClaudeStatusProbe.parse(text: sample)
+            #expect(Bool(false), "Parsing should fail for folder trust prompt")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            let lower = message.lowercased()
+            #expect(lower.contains("trust"))
+            #expect(lower.contains("auto-accept"))
+        } catch {
+            #expect(Bool(false), "Unexpected error: \(error)")
+        }
+    }
+
+    @Test
+    func parsesClaudeResetTimeOnly() {
+        let now = Date(timeIntervalSince1970: 1_733_690_000)
+        let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets 12:59pm (Europe/Helsinki)", now: now)
+        let tz = TimeZone(identifier: "Europe/Helsinki")!
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = tz
+        var expected = calendar.date(bySettingHour: 12, minute: 59, second: 0, of: now)!
+        if expected < now {
+            expected = calendar.date(byAdding: .day, value: 1, to: expected)!
+        }
+        #expect(parsed == expected)
+    }
+
+    @Test
+    func parsesClaudeResetDateAndTime() {
+        let now = Date(timeIntervalSince1970: 1_733_690_000)
+        let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9, 8:59am (Europe/Helsinki)", now: now)
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(identifier: "Europe/Helsinki")!
+        let expected = calendar.date(from: DateComponents(
+            year: calendar.component(.year, from: now),
+            month: 12,
+            day: 9,
+            hour: 8,
+            minute: 59,
+            second: 0))
+        #expect(parsed == expected)
+    }
+
+    @Test
+    func parsesClaudeResetWithDotSeparatedTime() {
+        let now = Date(timeIntervalSince1970: 1_733_690_000)
+        let parsed = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9 at 5.27am (UTC)", now: now)
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(identifier: "UTC")!
+        let expected = calendar.date(from: DateComponents(year: 2024, month: 12, day: 9, hour: 5, minute: 27))
+        #expect(parsed == expected)
+    }
+
+    @Test
+    func parsesClaudeResetWithCompactTimes() {
+        let now = Date(timeIntervalSince1970: 1_733_690_000)
+        let parsedTimeOnly = ClaudeStatusProbe.parseResetDate(from: "Resets 1pm (UTC)", now: now)
+        var calendar = Calendar(identifier: .gregorian)
+        calendar.timeZone = TimeZone(identifier: "UTC")!
+        var expected = calendar.date(bySettingHour: 13, minute: 0, second: 0, of: now)!
+        if expected < now {
+            expected = calendar.date(byAdding: .day, value: 1, to: expected)!
+        }
+        #expect(parsedTimeOnly == expected)
+
+        let parsedDateTime = ClaudeStatusProbe.parseResetDate(from: "Resets Dec 9, 9am", now: now)
+        calendar.timeZone = TimeZone.current
+        let dateExpected = calendar.date(from: DateComponents(
+            year: calendar.component(.year, from: now),
+            month: 12,
+            day: 9,
+            hour: 9,
+            minute: 0,
+            second: 0))
+        #expect(parsedDateTime == dateExpected)
+    }
+
+    @Test
+    func liveCodexStatus() async throws {
+        guard ProcessInfo.processInfo.environment["LIVE_CODEX_STATUS"] == "1" else { return }
+
+        let probe = CodexStatusProbe()
+        do {
+            let snap = try await probe.fetch()
+            let summary = """
+            Live Codex status:
+            \(snap.rawText)
+            values: 5h \(snap.fiveHourPercentLeft ?? -1)% left,
+            weekly \(snap.weeklyPercentLeft ?? -1)% left,
+            credits \(snap.credits ?? -1)
+            """
+            print(summary)
+        } catch {
+            // Dump raw PTY text to help debug.
+            let runner = TTYCommandRunner()
+            let res = try runner.run(
+                binary: "codex",
+                send: "/status\n",
+                options: .init(rows: 60, cols: 200, timeout: 12))
+            print("RAW CODEX PTY OUTPUT BEGIN\n\(res.text)\nRAW CODEX PTY OUTPUT END")
+            let clean = TextParsing.stripANSICodes(res.text)
+            print("CLEAN CODEX OUTPUT BEGIN\n\(clean)\nCLEAN CODEX OUTPUT END")
+            let five = TextParsing.firstInt(pattern: #"5h limit[^\n]*?([0-9]{1,3})%\s+left"#, text: clean) ?? -1
+            let week = TextParsing.firstInt(pattern: #"Weekly limit[^\n]*?([0-9]{1,3})%\s+left"#, text: clean) ?? -1
+            let credits = TextParsing.firstNumber(pattern: #"Credits:\s*([0-9][0-9.,]*)"#, text: clean) ?? -1
+            print("Parsed probes => 5h \(five)% weekly \(week)% credits \(credits)")
+            throw error
+        }
+    }
+}

package/Tests/RunicTests/SubprocessRunnerTests.swift

@@ -0,0 +1,20 @@
+import Foundation
+import Testing
+
+@testable import RunicCore
+
+@Suite
+struct SubprocessRunnerTests {
+    @Test
+    func readsLargeStdoutWithoutDeadlock() async throws {
+        let result = try await SubprocessRunner.run(
+            binary: "/usr/bin/python3",
+            arguments: ["-c", "print('x' * 1_000_000)"],
+            environment: ProcessInfo.processInfo.environment,
+            timeout: 5,
+            label: "python large stdout")
+
+        #expect(result.stdout.count >= 1_000_000)
+        #expect(result.stderr.isEmpty)
+    }
+}

package/Tests/RunicTests/SubscriptionDetectionTests.swift

@@ -0,0 +1,65 @@
+import Foundation
+import Testing
+@testable import Runic
+
+@Suite
+struct SubscriptionDetectionTests {
+    // MARK: - Subscription plans should be detected
+
+    @Test
+    func detectsMaxPlan() {
+        #expect(UsageStore.isSubscriptionPlan("Claude Max") == true)
+        #expect(UsageStore.isSubscriptionPlan("Max") == true)
+        #expect(UsageStore.isSubscriptionPlan("claude max") == true)
+        #expect(UsageStore.isSubscriptionPlan("MAX") == true)
+    }
+
+    @Test
+    func detectsProPlan() {
+        #expect(UsageStore.isSubscriptionPlan("Claude Pro") == true)
+        #expect(UsageStore.isSubscriptionPlan("Pro") == true)
+        #expect(UsageStore.isSubscriptionPlan("pro") == true)
+    }
+
+    @Test
+    func detectsUltraPlan() {
+        #expect(UsageStore.isSubscriptionPlan("Claude Ultra") == true)
+        #expect(UsageStore.isSubscriptionPlan("Ultra") == true)
+        #expect(UsageStore.isSubscriptionPlan("ultra") == true)
+    }
+
+    @Test
+    func detectsTeamPlan() {
+        #expect(UsageStore.isSubscriptionPlan("Claude Team") == true)
+        #expect(UsageStore.isSubscriptionPlan("Team") == true)
+        #expect(UsageStore.isSubscriptionPlan("team") == true)
+    }
+
+    // MARK: - Non-subscription plans should return false
+
+    @Test
+    func nilLoginMethodReturnsFalse() {
+        #expect(UsageStore.isSubscriptionPlan(nil) == false)
+    }
+
+    @Test
+    func emptyLoginMethodReturnsFalse() {
+        #expect(UsageStore.isSubscriptionPlan("") == false)
+        #expect(UsageStore.isSubscriptionPlan("   ") == false)
+    }
+
+    @Test
+    func unknownPlanReturnsFalse() {
+        #expect(UsageStore.isSubscriptionPlan("API") == false)
+        #expect(UsageStore.isSubscriptionPlan("Free") == false)
+        #expect(UsageStore.isSubscriptionPlan("Unknown") == false)
+        #expect(UsageStore.isSubscriptionPlan("Claude") == false)
+    }
+
+    @Test
+    func apiKeyUsersReturnFalse() {
+        // API users typically don't have a login method or have non-subscription identifiers
+        #expect(UsageStore.isSubscriptionPlan("api_key") == false)
+        #expect(UsageStore.isSubscriptionPlan("console") == false)
+    }
+}

package/Tests/RunicTests/TTYCommandRunnerTests.swift

@@ -0,0 +1,148 @@
+import Foundation
+import Testing
+@testable import RunicCore
+
+@Suite
+struct TTYCommandRunnerEnvTests {
+    @Test
+    func preservesEnvironmentAndSetsTerm() {
+        let baseEnv: [String: String] = [
+            "PATH": "/custom/bin",
+            "HOME": "/Users/tester",
+            "LANG": "en_US.UTF-8",
+        ]
+
+        let merged = TTYCommandRunner.enrichedEnvironment(
+            baseEnv: baseEnv,
+            loginPATH: nil,
+            home: "/Users/tester")
+
+        #expect(merged["HOME"] == "/Users/tester")
+        #expect(merged["LANG"] == "en_US.UTF-8")
+        #expect(merged["TERM"] == "xterm-256color")
+
+        #expect(merged["PATH"] == "/custom/bin")
+    }
+
+    @Test
+    func backfillsHomeWhenMissing() {
+        let merged = TTYCommandRunner.enrichedEnvironment(
+            baseEnv: ["PATH": "/custom/bin"],
+            loginPATH: nil,
+            home: "/Users/fallback")
+        #expect(merged["HOME"] == "/Users/fallback")
+        #expect(merged["TERM"] == "xterm-256color")
+    }
+
+    @Test
+    func preservesExistingTermAndCustomVars() {
+        let merged = TTYCommandRunner.enrichedEnvironment(
+            baseEnv: [
+                "PATH": "/custom/bin",
+                "TERM": "vt100",
+                "BUN_INSTALL": "/Users/tester/.bun",
+                "SHELL": "/bin/zsh",
+            ],
+            loginPATH: nil,
+            home: "/Users/tester")
+
+        #expect(merged["TERM"] == "vt100")
+        #expect(merged["BUN_INSTALL"] == "/Users/tester/.bun")
+        #expect(merged["SHELL"] == "/bin/zsh")
+        #expect((merged["PATH"] ?? "").contains("/custom/bin"))
+    }
+
+    @Test
+    func setsWorkingDirectoryWhenProvided() throws {
+        let fm = FileManager.default
+        let dir = fm.temporaryDirectory.appendingPathComponent("runic-tty-\(UUID().uuidString)", isDirectory: true)
+        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
+
+        let runner = TTYCommandRunner()
+        let result = try runner.run(binary: "/bin/pwd", send: "", options: .init(timeout: 3, workingDirectory: dir))
+        let clean = result.text.replacingOccurrences(of: "\r", with: "")
+        #expect(clean.contains(dir.path))
+    }
+
+    @Test
+    func autoRespondsToTrustPrompt() throws {
+        let fm = FileManager.default
+        let dir = fm.temporaryDirectory.appendingPathComponent("runic-tty-\(UUID().uuidString)", isDirectory: true)
+        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? fm.removeItem(at: dir) }
+
+        let scriptURL = dir.appendingPathComponent("trust.sh")
+        let script = """
+        #!/bin/sh
+        echo \"Do you trust the files in this folder?\"
+        echo \"\"
+        echo \"/Users/example/project\"
+        IFS= read -r ans
+        if [ \"$ans\" = \"y\" ] || [ \"$ans\" = \"Y\" ]; then
+          echo \"accepted\"
+        else
+          echo \"rejected:$ans\"
+        fi
+        """
+        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
+        try fm.setAttributes([.posixPermissions: 0o755], ofItemAtPath: scriptURL.path)
+
+        let runner = TTYCommandRunner()
+        let result = try runner.run(
+            binary: scriptURL.path,
+            send: "",
+            options: .init(
+                timeout: 3,
+                // Use LF for portability: some PTY/termios setups do not translate CR → NL for shell reads.
+                sendOnSubstrings: ["Do you trust the files in this folder?": "y\n"],
+                stopOnSubstrings: ["accepted", "rejected"],
+                settleAfterStop: 0.1))
+
+        #expect(result.text.contains("accepted"))
+    }
+
+    @Test
+    func stopsWhenOutputIsIdle() throws {
+        let fm = FileManager.default
+        let dir = fm.temporaryDirectory.appendingPathComponent("runic-tty-\(UUID().uuidString)", isDirectory: true)
+        try fm.createDirectory(at: dir, withIntermediateDirectories: true)
+        defer { try? fm.removeItem(at: dir) }
+
+        let scriptURL = dir.appendingPathComponent("idle.sh")
+        let script = """
+        #!/bin/sh
+        echo "hello"
+        sleep 10
+        """
+        try script.write(to: scriptURL, atomically: true, encoding: .utf8)
+        try fm.setAttributes([.posixPermissions: 0o755], ofItemAtPath: scriptURL.path)
+
+        let runner = TTYCommandRunner()
+        let startedAt = Date()
+        let result = try runner.run(
+            binary: scriptURL.path,
+            send: "",
+            options: .init(timeout: 6, idleTimeout: 0.2))
+        let elapsed = Date().timeIntervalSince(startedAt)
+
+        #expect(result.text.contains("hello"))
+        #expect(elapsed < 3.0)
+    }
+
+    @Test
+    func rollingBufferDetectsNeedleAcrossBoundary() {
+        var scanner = TTYCommandRunner.RollingBuffer(maxNeedle: 6)
+        let needle = Data("hello".utf8)
+        let first = scanner.append(Data("he".utf8))
+        #expect(first.range(of: needle) == nil)
+        let second = scanner.append(Data("llo!".utf8))
+        #expect(second.range(of: needle) != nil)
+    }
+
+    @Test
+    func lowercasedASCIIOnlyTouchesAscii() {
+        let data = Data("UpDaTe".utf8)
+        let lowered = TTYCommandRunner.lowercasedASCII(data)
+        #expect(String(data: lowered, encoding: .utf8) == "update")
+    }
+}

package/Tests/RunicTests/TTYIntegrationTests.swift

@@ -0,0 +1,41 @@
+import RunicCore
+import XCTest
+@testable import Runic
+
+final class TTYIntegrationTests: XCTestCase {
+    func testCodexRPCUsageLive() async throws {
+        let fetcher = UsageFetcher()
+        do {
+            let snapshot = try await fetcher.loadLatestUsage()
+            let hasData = snapshot.primary.usedPercent >= 0 && (snapshot.secondary?.usedPercent ?? 0) >= 0
+            XCTAssertTrue(hasData, "Codex RPC probe returned no usage data.")
+        } catch UsageError.noRateLimitsFound {
+            throw XCTSkip("Codex RPC returned no rate limits yet (likely warming up).")
+        } catch {
+            throw XCTSkip("Codex RPC probe failed: \(error)")
+        }
+    }
+
+    func testClaudeTTYUsageProbeLive() async throws {
+        guard TTYCommandRunner.which("claude") != nil else {
+            throw XCTSkip("Claude CLI not installed; skipping live PTY probe.")
+        }
+
+        let fetcher = ClaudeUsageFetcher(dataSource: .cli)
+        do {
+            let snapshot = try await fetcher.loadLatestUsage()
+            XCTAssertNotNil(snapshot.primary.remainingPercent, "Claude session percent missing")
+            // Weekly is absent for some enterprise accounts.
+        } catch let ClaudeUsageError.parseFailed(message) {
+            throw XCTSkip("Claude PTY parse failed (likely not logged in or usage unavailable): \(message)")
+        } catch let ClaudeStatusProbeError.parseFailed(message) {
+            throw XCTSkip("Claude status parse failed (likely not logged in or usage unavailable): \(message)")
+        } catch ClaudeUsageError.claudeNotInstalled {
+            throw XCTSkip("Claude CLI not installed; skipping live PTY probe.")
+        } catch ClaudeStatusProbeError.timedOut {
+            throw XCTSkip("Claude PTY probe timed out; skipping.")
+        } catch let TTYCommandRunner.Error.launchFailed(message) where message.contains("login") {
+            throw XCTSkip("Claude CLI not logged in: \(message)")
+        }
+    }
+}