@sriinnu/runic 1.0.0

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

@@ -0,0 +1,168 @@
+import Foundation
+
+struct BedrockModelsResponse: Decodable, Sendable {
+    struct ModelSummary: Decodable, Sendable {
+        let modelID: String?
+        let modelName: String?
+        let providerName: String?
+
+        enum CodingKeys: String, CodingKey {
+            case modelID = "modelId"
+            case modelName
+            case providerName
+        }
+    }
+
+    let modelSummaries: [ModelSummary]?
+
+    init(modelSummaries: [ModelSummary]?) {
+        self.modelSummaries = modelSummaries
+    }
+}
+
+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, Sendable {
+    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

@@ -0,0 +1,84 @@
+import RunicMacroSupport
+import Foundation
+
+@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, Sendable {
+    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

@@ -0,0 +1,75 @@
+import Foundation
+
+struct CerebrasModelsResponse: Decodable {
+    let data: [Model]?
+
+    struct Model: Decodable {
+        let id: String?
+    }
+}
+
+struct 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, Sendable {
+    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

@@ -0,0 +1,332 @@
+#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()
+    }
+}