@sriinnu/runic 1.2.0 → 2.11.1

package/Tests/RunicTests/StatusProbeTests.swift

@@ -1,377 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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)")
-        }
-    }
-}