@sriinnu/runic 2.0.0 → 2.11.1

package/Sources/RunicCore/Providers/Bedrock/BedrockUsageFetcher.swift

@@ -1,164 +0,0 @@
-import Foundation
-
-struct BedrockModelsResponse: Decodable {
-    struct ModelSummary: Decodable {
-        let modelID: String?
-        let modelName: String?
-        let providerName: String?
-
-        enum CodingKeys: String, CodingKey {
-            case modelID = "modelId"
-            case modelName
-            case providerName
-        }
-    }
-
-    let modelSummaries: [ModelSummary]?
-}
-
-struct BedrockUsageFetcher {
-    private static let commandTimeout: TimeInterval = 20
-
-    static func fetchModels(
-        region: String,
-        profile: String?,
-        modelFilter: String?) async throws -> BedrockModelsResponse
-    {
-        let output = try await self.runAWSCLI(
-            arguments: ["bedrock", "list-foundation-models", "--region", region, "--output", "json"],
-            profile: profile)
-
-        let decoder = JSONDecoder()
-        let decoded: BedrockModelsResponse
-        do {
-            decoded = try decoder.decode(BedrockModelsResponse.self, from: output)
-        } catch {
-            throw BedrockCLIError.decodeFailed(error.localizedDescription)
-        }
-
-        guard let modelFilter = self.cleaned(modelFilter) else {
-            return decoded
-        }
-        let loweredFilter = modelFilter.lowercased()
-        let filtered = (decoded.modelSummaries ?? []).filter { model in
-            let id = model.modelID?.lowercased() ?? ""
-            let name = model.modelName?.lowercased() ?? ""
-            let provider = model.providerName?.lowercased() ?? ""
-            return id.contains(loweredFilter) || name.contains(loweredFilter) || provider.contains(loweredFilter)
-        }
-        return BedrockModelsResponse(modelSummaries: filtered)
-    }
-
-    private static func runAWSCLI(arguments: [String], profile: String?) async throws -> Data {
-        var environment = ProcessInfo.processInfo.environment
-        environment["PATH"] = self.effectivePATH(existing: environment["PATH"])
-        if let profile = self.cleaned(profile) {
-            environment["AWS_PROFILE"] = profile
-        }
-
-        do {
-            let result = try await SubprocessRunner.run(
-                binary: "/usr/bin/env",
-                arguments: ["aws"] + arguments,
-                environment: environment,
-                timeout: Self.commandTimeout,
-                label: "bedrock.cli")
-            let output = Data(result.stdout.utf8)
-            guard !output.isEmpty else {
-                throw BedrockCLIError.emptyResponse
-            }
-            return output
-        } catch let error as SubprocessRunnerError {
-            switch error {
-            case .binaryNotFound:
-                throw BedrockCLIError.awsCLINotFound
-            case let .launchFailed(details):
-                throw BedrockCLIError.commandFailed(statusCode: -1, detail: details)
-            case .timedOut:
-                throw BedrockCLIError.commandTimedOut
-            case let .nonZeroExit(code, stderr):
-                throw BedrockCLIError.commandFailed(statusCode: Int(code), detail: stderr)
-            }
-        }
-    }
-
-    private static func effectivePATH(existing: String?) -> String {
-        let defaults = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]
-        var parts = (existing ?? "")
-            .split(separator: ":")
-            .map(String.init)
-            .filter { !$0.isEmpty }
-        for path in defaults where !parts.contains(path) {
-            parts.append(path)
-        }
-        return parts.joined(separator: ":")
-    }
-
-    private static func cleaned(_ raw: String?) -> String? {
-        let trimmed = raw?.trimmingCharacters(in: .whitespacesAndNewlines)
-        guard let trimmed, !trimmed.isEmpty else { return nil }
-        return trimmed
-    }
-}
-
-extension BedrockModelsResponse {
-    func toUsageSnapshot(region: String, profile: String?, modelFilter: String?) -> UsageSnapshot {
-        let models = self.modelSummaries ?? []
-        let count = models.count
-        let preview = models
-            .compactMap(\.modelID)
-            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
-            .filter { !$0.isEmpty }
-            .prefix(3)
-            .joined(separator: ", ")
-
-        var summaryParts: [String] = ["Models available: \(count)", "region \(region)"]
-        if let profile = profile?.trimmingCharacters(in: .whitespacesAndNewlines), !profile.isEmpty {
-            summaryParts.append("profile \(profile)")
-        }
-        if let modelFilter = modelFilter?.trimmingCharacters(in: .whitespacesAndNewlines), !modelFilter.isEmpty {
-            summaryParts.append("filter \(modelFilter)")
-        }
-        if !preview.isEmpty {
-            summaryParts.append(preview)
-        }
-
-        return UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 0,
-                windowMinutes: nil,
-                resetsAt: nil,
-                resetDescription: summaryParts.joined(separator: " • "),
-                label: "Foundation models"),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
-    }
-}
-
-enum BedrockCLIError: LocalizedError {
-    case awsCLINotFound
-    case commandFailed(statusCode: Int, detail: String?)
-    case commandTimedOut
-    case decodeFailed(String)
-    case emptyResponse
-
-    var errorDescription: String? {
-        switch self {
-        case .awsCLINotFound:
-            return "AWS CLI is not available. Install awscli and ensure `aws` is on PATH."
-        case let .commandFailed(statusCode, detail):
-            if let detail, !detail.isEmpty {
-                return "AWS Bedrock CLI request failed (\(statusCode)): \(detail)"
-            }
-            return "AWS Bedrock CLI request failed with exit code \(statusCode)."
-        case .commandTimedOut:
-            return "AWS Bedrock CLI request timed out."
-        case let .decodeFailed(detail):
-            return "Could not decode Bedrock response: \(detail)"
-        case .emptyResponse:
-            return "AWS Bedrock returned an empty response."
-        }
-    }
-}

package/Sources/RunicCore/Providers/Cerebras/CerebrasProviderDescriptor.swift

@@ -1,84 +0,0 @@
-import Foundation
-import RunicMacroSupport
-
-@ProviderDescriptorRegistration
-@ProviderDescriptorDefinition
-public enum CerebrasProviderDescriptor {
-    static func makeDescriptor() -> ProviderDescriptor {
-        ProviderDescriptor(
-            id: .cerebras,
-            metadata: ProviderMetadata(
-                id: .cerebras,
-                displayName: "Cerebras",
-                sessionLabel: "Models",
-                weeklyLabel: "",
-                opusLabel: nil,
-                supportsOpus: false,
-                supportsCredits: false,
-                creditsHint: "Shows model availability from Cerebras API.",
-                toggleTitle: "Show Cerebras usage",
-                cliName: "cerebras",
-                defaultEnabled: false,
-                isPrimaryProvider: false,
-                usesAccountFallback: false,
-                dashboardURL: "https://cloud.cerebras.ai",
-                statusPageURL: nil,
-                usageCoverage: ProviderUsageCoverage(
-                    supportsModelBreakdown: true,
-                    supportsTokenMetrics: false,
-                    supportsProjectAttribution: false)),
-            branding: ProviderBranding(
-                iconStyle: .cerebras,
-                iconResourceName: "ProviderIcon-cerebras",
-                color: ProviderColor(red: 14 / 255, green: 122 / 255, blue: 161 / 255)),
-            tokenCost: ProviderTokenCostConfig(
-                supportsTokenCost: false,
-                noDataMessage: { "Cerebras cost summary is not supported." }),
-            fetchPlan: ProviderFetchPlan(
-                sourceModes: [.auto, .cli],
-                pipeline: ProviderFetchPipeline(resolveStrategies: { _ in [CerebrasAPIFetchStrategy()] })),
-            cli: ProviderCLIConfig(
-                name: "cerebras",
-                aliases: [],
-                versionDetector: nil))
-    }
-}
-
-struct CerebrasAPIFetchStrategy: ProviderFetchStrategy {
-    let id: String = "cerebras.api"
-    let kind: ProviderFetchKind = .apiToken
-
-    func isAvailable(_ context: ProviderFetchContext) async -> Bool {
-        Self.resolveTokenResolution(environment: context.env) != nil
-    }
-
-    func fetch(_ context: ProviderFetchContext) async throws -> ProviderFetchResult {
-        guard let tokenRes = Self.resolveTokenResolution(environment: context.env) else {
-            throw CerebrasSettingsError.missingToken
-        }
-        let usage = try await CerebrasUsageFetcher.fetchModels(apiKey: tokenRes.token)
-        return self.makeResult(
-            usage: usage.toUsageSnapshot(),
-            sourceLabel: tokenRes.source.rawValue)
-    }
-
-    func shouldFallback(on _: Error, context _: ProviderFetchContext) -> Bool {
-        false
-    }
-
-    private static func resolveTokenResolution(environment: [String: String]) -> ProviderTokenResolution? {
-        ProviderTokenResolver.cerebrasResolution(environment: environment)
-    }
-}
-
-enum CerebrasSettingsError: LocalizedError {
-    case missingToken
-
-    var errorDescription: String? {
-        switch self {
-        case .missingToken:
-            "Cerebras API key not found. Set it in Preferences → Providers → Cerebras or " +
-                "export CEREBRAS_API_KEY."
-        }
-    }
-}

package/Sources/RunicCore/Providers/Cerebras/CerebrasUsageFetcher.swift

@@ -1,75 +0,0 @@
-import Foundation
-
-struct CerebrasModelsResponse: Decodable {
-    let data: [Model]?
-
-    struct Model: Decodable {
-        let id: String?
-    }
-}
-
-enum CerebrasUsageFetcher {
-    static let apiURL = URL(string: "https://api.cerebras.ai/v1/models")!
-
-    static func fetchModels(apiKey: String) async throws -> CerebrasModelsResponse {
-        var request = URLRequest(url: apiURL)
-        request.addValue("Bearer \(apiKey)", forHTTPHeaderField: "Authorization")
-        request.addValue("application/json", forHTTPHeaderField: "Content-Type")
-
-        let (data, response) = try await URLSession.shared.data(for: request)
-
-        guard let httpResponse = response as? HTTPURLResponse else {
-            throw CerebrasAPIError.invalidResponse
-        }
-
-        guard httpResponse.statusCode == 200 else {
-            let body = String(data: data, encoding: .utf8)?
-                .trimmingCharacters(in: .whitespacesAndNewlines)
-            throw CerebrasAPIError.httpError(
-                statusCode: httpResponse.statusCode,
-                body: body?.isEmpty == false ? body : nil)
-        }
-
-        let decoder = JSONDecoder()
-        return try decoder.decode(CerebrasModelsResponse.self, from: data)
-    }
-}
-
-extension CerebrasModelsResponse {
-    func toUsageSnapshot() -> UsageSnapshot {
-        let models = (self.data ?? []).compactMap(\.id)
-        var summary = "Models available: \(models.count)"
-        let preview = models.prefix(3).joined(separator: ", ")
-        if !preview.isEmpty {
-            summary += " (\(preview))"
-        }
-
-        return UsageSnapshot(
-            primary: RateWindow(
-                usedPercent: 0,
-                windowMinutes: nil,
-                resetsAt: nil,
-                resetDescription: summary),
-            secondary: nil,
-            tertiary: nil,
-            updatedAt: Date(),
-            identity: nil)
-    }
-}
-
-enum CerebrasAPIError: LocalizedError {
-    case invalidResponse
-    case httpError(statusCode: Int, body: String?)
-
-    var errorDescription: String? {
-        switch self {
-        case .invalidResponse:
-            return "Invalid response from Cerebras API"
-        case let .httpError(statusCode, body):
-            if let body, !body.isEmpty {
-                return "Cerebras API returned status code \(statusCode): \(body)"
-            }
-            return "Cerebras API returned status code \(statusCode)"
-        }
-    }
-}

package/Sources/RunicCore/Providers/Claude/ClaudeCLISession.swift

@@ -1,332 +0,0 @@
-#if canImport(Darwin)
-import Darwin
-#else
-import Glibc
-#endif
-import Foundation
-
-actor ClaudeCLISession {
-    static let shared = ClaudeCLISession()
-
-    enum SessionError: LocalizedError {
-        case launchFailed(String)
-        case timedOut
-        case processExited
-
-        var errorDescription: String? {
-            switch self {
-            case let .launchFailed(msg): "Failed to launch Claude CLI session: \(msg)"
-            case .timedOut: "Claude CLI session timed out."
-            case .processExited: "Claude CLI session exited."
-            }
-        }
-    }
-
-    private var process: Process?
-    private var primaryFD: Int32 = -1
-    private var primaryHandle: FileHandle?
-    private var secondaryHandle: FileHandle?
-    private var processGroup: pid_t?
-    private var binaryPath: String?
-    private var startedAt: Date?
-    private var lastActivityAt: Date?
-    private var idleShutdownTask: Task<Void, Never>?
-    private var isCapturing = false
-    private let idleShutdownDelay: TimeInterval = 90
-
-    private let sendOnSubstrings: [String: String] = [
-        "Do you trust the files in this folder?": "y\r",
-        "Ready to code here?": "\r",
-        "Press Enter to continue": "\r",
-    ]
-
-    private struct RollingBuffer {
-        private let maxNeedle: Int
-        private var tail = Data()
-
-        init(maxNeedle: Int) {
-            self.maxNeedle = max(0, maxNeedle)
-        }
-
-        mutating func append(_ data: Data) -> Data {
-            guard !data.isEmpty else { return Data() }
-            var combined = Data()
-            combined.reserveCapacity(self.tail.count + data.count)
-            combined.append(self.tail)
-            combined.append(data)
-            if self.maxNeedle > 1 {
-                if combined.count >= self.maxNeedle - 1 {
-                    self.tail = combined.suffix(self.maxNeedle - 1)
-                } else {
-                    self.tail = combined
-                }
-            } else {
-                self.tail.removeAll(keepingCapacity: true)
-            }
-            return combined
-        }
-    }
-
-    func capture(
-        subcommand: String,
-        binary: String,
-        timeout: TimeInterval,
-        idleTimeout: TimeInterval? = 3.0,
-        stopOnSubstrings: [String] = [],
-        settleAfterStop: TimeInterval = 0.25,
-        sendEnterEvery: TimeInterval? = nil) async throws -> String
-    {
-        try self.ensureStarted(binary: binary)
-        self.isCapturing = true
-        self.lastActivityAt = Date()
-        defer {
-            self.isCapturing = false
-            self.lastActivityAt = Date()
-            self.scheduleIdleShutdown()
-        }
-        if let startedAt {
-            let sinceStart = Date().timeIntervalSince(startedAt)
-            if sinceStart < 0.4 {
-                let delay = UInt64((0.4 - sinceStart) * 1_000_000_000)
-                try await Task.sleep(nanoseconds: delay)
-            }
-        }
-        self.drainOutput()
-
-        let trimmed = subcommand.trimmingCharacters(in: .whitespacesAndNewlines)
-        if !trimmed.isEmpty {
-            try self.send(trimmed)
-            try self.send("\r")
-        }
-
-        let stopNeedles = stopOnSubstrings.map { Data($0.utf8) }
-        let sendNeedles = self.sendOnSubstrings.map { (needle: Data($0.key.utf8), keys: Data($0.value.utf8)) }
-        let cursorQuery = Data([0x1B, 0x5B, 0x36, 0x6E])
-        let needleLengths =
-            stopNeedles.map(\.count) +
-            sendNeedles.map(\.needle.count) +
-            [cursorQuery.count]
-        let maxNeedle = needleLengths.max() ?? cursorQuery.count
-        var scanBuffer = RollingBuffer(maxNeedle: maxNeedle)
-        var triggeredSends = Set<Data>()
-
-        var buffer = Data()
-        let deadline = Date().addingTimeInterval(timeout)
-        var lastOutputAt = Date()
-        var lastEnterAt = Date()
-        var nextCursorCheckAt = Date(timeIntervalSince1970: 0)
-        var stoppedEarly = false
-
-        while Date() < deadline {
-            let newData = self.readChunk()
-            if !newData.isEmpty {
-                buffer.append(newData)
-                lastOutputAt = Date()
-            }
-
-            let scanData = scanBuffer.append(newData)
-            if Date() >= nextCursorCheckAt,
-               !scanData.isEmpty,
-               scanData.range(of: cursorQuery) != nil
-            {
-                try? self.send("\u{1b}[1;1R")
-                nextCursorCheckAt = Date().addingTimeInterval(1.0)
-            }
-
-            if !sendNeedles.isEmpty {
-                for item in sendNeedles where !triggeredSends.contains(item.needle) {
-                    if scanData.range(of: item.needle) != nil {
-                        try? self.primaryHandle?.write(contentsOf: item.keys)
-                        triggeredSends.insert(item.needle)
-                    }
-                }
-            }
-
-            if !stopNeedles.isEmpty, stopNeedles.contains(where: { scanData.range(of: $0) != nil }) {
-                stoppedEarly = true
-                break
-            }
-
-            if let idleTimeout,
-               !buffer.isEmpty,
-               Date().timeIntervalSince(lastOutputAt) >= idleTimeout
-            {
-                stoppedEarly = true
-                break
-            }
-
-            if let every = sendEnterEvery, Date().timeIntervalSince(lastEnterAt) >= every {
-                try? self.send("\r")
-                lastEnterAt = Date()
-            }
-
-            if let proc = self.process, !proc.isRunning {
-                throw SessionError.processExited
-            }
-
-            try await Task.sleep(nanoseconds: 60_000_000)
-        }
-
-        if stoppedEarly {
-            let settle = max(0, min(settleAfterStop, deadline.timeIntervalSinceNow))
-            if settle > 0 {
-                let settleDeadline = Date().addingTimeInterval(settle)
-                while Date() < settleDeadline {
-                    let newData = self.readChunk()
-                    if !newData.isEmpty { buffer.append(newData) }
-                    try await Task.sleep(nanoseconds: 50_000_000)
-                }
-            }
-        }
-
-        guard !buffer.isEmpty, let text = String(data: buffer, encoding: .utf8) else {
-            throw SessionError.timedOut
-        }
-        return text
-    }
-
-    func reset() {
-        self.idleShutdownTask?.cancel()
-        self.idleShutdownTask = nil
-        self.cleanup()
-    }
-
-    private func ensureStarted(binary: String) throws {
-        if let proc = self.process, proc.isRunning, self.binaryPath == binary { return }
-        self.cleanup()
-
-        var primaryFD: Int32 = -1
-        var secondaryFD: Int32 = -1
-        var win = winsize(ws_row: 50, ws_col: 160, ws_xpixel: 0, ws_ypixel: 0)
-        guard openpty(&primaryFD, &secondaryFD, nil, nil, &win) == 0 else {
-            throw SessionError.launchFailed("openpty failed")
-        }
-        _ = fcntl(primaryFD, F_SETFL, O_NONBLOCK)
-
-        let primaryHandle = FileHandle(fileDescriptor: primaryFD, closeOnDealloc: true)
-        let secondaryHandle = FileHandle(fileDescriptor: secondaryFD, closeOnDealloc: true)
-
-        let proc = Process()
-        let resolvedURL = URL(fileURLWithPath: binary)
-        if resolvedURL.lastPathComponent == "claude",
-           let watchdog = TTYCommandRunner.locateBundledHelper("RunicClaudeWatchdog")
-        {
-            proc.executableURL = URL(fileURLWithPath: watchdog)
-            proc.arguments = ["--", binary, "--allowed-tools", ""]
-        } else {
-            proc.executableURL = resolvedURL
-            proc.arguments = ["--allowed-tools", ""]
-        }
-        proc.standardInput = secondaryHandle
-        proc.standardOutput = secondaryHandle
-        proc.standardError = secondaryHandle
-
-        let workingDirectory = ClaudeStatusProbe.probeWorkingDirectoryURL()
-        proc.currentDirectoryURL = workingDirectory
-        var env = TTYCommandRunner.enrichedEnvironment()
-        env["PWD"] = workingDirectory.path
-        proc.environment = env
-
-        do {
-            try proc.run()
-        } catch {
-            try? primaryHandle.close()
-            try? secondaryHandle.close()
-            throw SessionError.launchFailed(error.localizedDescription)
-        }
-
-        let pid = proc.processIdentifier
-        var processGroup: pid_t?
-        if setpgid(pid, pid) == 0 {
-            processGroup = pid
-        }
-
-        self.process = proc
-        self.primaryFD = primaryFD
-        self.primaryHandle = primaryHandle
-        self.secondaryHandle = secondaryHandle
-        self.processGroup = processGroup
-        self.binaryPath = binary
-        self.startedAt = Date()
-        self.lastActivityAt = self.startedAt
-    }
-
-    private func cleanup() {
-        if let proc = self.process, proc.isRunning, let handle = self.primaryHandle {
-            try? handle.write(contentsOf: Data("/exit\n".utf8))
-        }
-        try? self.primaryHandle?.close()
-        try? self.secondaryHandle?.close()
-
-        if let proc = self.process, proc.isRunning {
-            proc.terminate()
-        }
-        if let pgid = self.processGroup {
-            kill(-pgid, SIGTERM)
-        }
-        let waitDeadline = Date().addingTimeInterval(1.0)
-        if let proc = self.process {
-            while proc.isRunning, Date() < waitDeadline {
-                usleep(100_000)
-            }
-            if proc.isRunning {
-                if let pgid = self.processGroup {
-                    kill(-pgid, SIGKILL)
-                }
-                kill(proc.processIdentifier, SIGKILL)
-            }
-        }
-
-        self.process = nil
-        self.primaryHandle = nil
-        self.secondaryHandle = nil
-        self.primaryFD = -1
-        self.processGroup = nil
-        self.startedAt = nil
-        self.lastActivityAt = nil
-        self.isCapturing = false
-    }
-
-    private func readChunk() -> Data {
-        guard self.primaryFD >= 0 else { return Data() }
-        var appended = Data()
-        while true {
-            var tmp = [UInt8](repeating: 0, count: 8192)
-            let n = read(self.primaryFD, &tmp, tmp.count)
-            if n > 0 {
-                appended.append(contentsOf: tmp.prefix(n))
-                continue
-            }
-            break
-        }
-        return appended
-    }
-
-    private func drainOutput() {
-        _ = self.readChunk()
-    }
-
-    private func send(_ text: String) throws {
-        guard let data = text.data(using: .utf8) else { return }
-        guard let handle = self.primaryHandle else { throw SessionError.processExited }
-        try handle.write(contentsOf: data)
-    }
-
-    private func scheduleIdleShutdown() {
-        self.idleShutdownTask?.cancel()
-        let deadline = Date().addingTimeInterval(self.idleShutdownDelay)
-        self.idleShutdownTask = Task { [weak self] in
-            let delay = self?.idleShutdownDelay ?? 0
-            if delay > 0 {
-                try? await Task.sleep(nanoseconds: UInt64(delay * 1_000_000_000))
-            }
-            await self?.shutdownIfIdle(since: deadline)
-        }
-    }
-
-    private func shutdownIfIdle(since deadline: Date) {
-        guard !self.isCapturing else { return }
-        guard let lastActivityAt, lastActivityAt <= deadline else { return }
-        self.cleanup()
-    }
-}