@sriinnu/runic 2.0.0 → 2.11.1

package/Sources/RunicClaudeWatchdog/main.swift

@@ -1,122 +0,0 @@
-import Darwin
-import Foundation
-
-private enum WatchdogExitCode {
-    static let usage: Int32 = 64
-    static let spawnFailed: Int32 = 70
-}
-
-private nonisolated(unsafe) var globalChildPID: pid_t = 0
-private nonisolated(unsafe) var globalShouldTerminate: Int32 = 0
-
-private func usageAndExit() -> Never {
-    fputs("Usage: RunicClaudeWatchdog -- <binary> [args...]\n", stderr)
-    Darwin.exit(WatchdogExitCode.usage)
-}
-
-private func killProcessTree(childPID: pid_t, graceSeconds: TimeInterval = 0.5) {
-    let pgid = getpgid(childPID)
-    if pgid > 0 {
-        kill(-pgid, SIGTERM)
-    } else {
-        kill(childPID, SIGTERM)
-    }
-
-    let deadline = Date().addingTimeInterval(graceSeconds)
-    var status: Int32 = 0
-    while Date() < deadline {
-        let rc = waitpid(childPID, &status, WNOHANG)
-        if rc == childPID { return }
-        usleep(50000)
-    }
-
-    if pgid > 0 {
-        kill(-pgid, SIGKILL)
-    } else {
-        kill(childPID, SIGKILL)
-    }
-}
-
-private func exitCode(fromWaitStatus status: Int32) -> Int32 {
-    // Swift can't import wait(2) macros (function-like macros). Use the classic encoding:
-    // - low 7 bits: signal number (0 means exited)
-    // - high byte: exit status (when exited)
-    let low = status & 0x7F
-    if low == 0 {
-        return (status >> 8) & 0xFF
-    }
-    if low != 0x7F {
-        return 128 + low
-    }
-    return 1
-}
-
-let argv = CommandLine.arguments
-guard let sep = argv.firstIndex(of: "--") else { usageAndExit() }
-let childArgs = Array(argv[(sep + 1)...])
-guard !childArgs.isEmpty else { usageAndExit() }
-
-let childBinary = childArgs[0]
-let childArgv = childArgs
-
-let spawnResult: Int32 = childArgv.withUnsafeBufferPointer { buffer in
-    var cStrings: [UnsafeMutablePointer<CChar>?] = buffer
-        .map { strdup($0) }
-    cStrings.append(nil)
-    defer { cStrings.forEach { if let p = $0 { free(p) } } }
-
-    return cStrings.withUnsafeMutableBufferPointer { cBuffer in
-        var pid: pid_t = 0
-        let rc: Int32 = childBinary.withCString { childPath in
-            posix_spawnp(&pid, childPath, nil, nil, cBuffer.baseAddress, environ)
-        }
-        if rc == 0, pid > 0 {
-            globalChildPID = pid
-        }
-        return rc
-    }
-}
-
-guard spawnResult == 0, globalChildPID > 0 else {
-    fputs("RunicClaudeWatchdog: failed to spawn child: \(childBinary) (rc=\(spawnResult))\n", stderr)
-    Darwin.exit(WatchdogExitCode.spawnFailed)
-}
-
-_ = setpgid(globalChildPID, globalChildPID)
-
-private func terminateChild() {
-    if globalChildPID > 0 {
-        killProcessTree(childPID: globalChildPID)
-    }
-}
-
-private func handleTerminationSignal(_ sig: Int32) {
-    globalShouldTerminate = sig
-}
-
-signal(SIGTERM, handleTerminationSignal)
-signal(SIGINT, handleTerminationSignal)
-signal(SIGHUP, handleTerminationSignal)
-
-var status: Int32 = 0
-while true {
-    let rc = waitpid(globalChildPID, &status, WNOHANG)
-    if rc == globalChildPID {
-        Darwin.exit(exitCode(fromWaitStatus: status))
-    }
-
-    if globalShouldTerminate != 0 {
-        let sig = globalShouldTerminate
-        terminateChild()
-        _ = waitpid(globalChildPID, &status, 0)
-        Darwin.exit(128 + sig)
-    }
-
-    if getppid() == 1 {
-        terminateChild()
-        _ = waitpid(globalChildPID, &status, 0)
-        Darwin.exit(exitCode(fromWaitStatus: status))
-    }
-
-    usleep(200_000)
-}

package/Sources/RunicClaudeWebProbe/main.swift

@@ -1,62 +0,0 @@
-import Foundation
-import RunicCore
-
-@main
-enum RunicClaudeWebProbe {
-    private static let defaultEndpoints: [String] = [
-        "https://claude.ai/api/organizations",
-        "https://claude.ai/api/organizations/{orgId}/usage",
-        "https://claude.ai/api/organizations/{orgId}/overage_spend_limit",
-        "https://claude.ai/api/organizations/{orgId}/members",
-        "https://claude.ai/api/organizations/{orgId}/me",
-        "https://claude.ai/api/organizations/{orgId}/billing",
-        "https://claude.ai/api/me",
-        "https://claude.ai/api/user",
-        "https://claude.ai/api/session",
-        "https://claude.ai/api/account",
-        "https://claude.ai/settings/billing",
-        "https://claude.ai/settings/account",
-        "https://claude.ai/settings/usage",
-    ]
-
-    static func main() async {
-        let args = CommandLine.arguments.dropFirst()
-        let endpoints = args.isEmpty ? Self.defaultEndpoints : Array(args)
-        let includePreview = ProcessInfo.processInfo.environment["CLAUDE_WEB_PROBE_PREVIEW"] == "1"
-
-        do {
-            let results = try await ClaudeWebAPIFetcher.probeEndpoints(
-                endpoints,
-                includePreview: includePreview)
-            for result in results {
-                Self.printResult(result)
-            }
-        } catch {
-            fputs("Probe failed: \(error.localizedDescription)\n", stderr)
-            Darwin.exit(1)
-        }
-    }
-
-    private static func printResult(_ result: ClaudeWebAPIFetcher.ProbeResult) {
-        let status = result.statusCode.map(String.init) ?? "error"
-        print("==> \(result.url)")
-        print("status: \(status)")
-        if let contentType = result.contentType { print("content-type: \(contentType)") }
-        if !result.topLevelKeys.isEmpty {
-            print("keys: \(result.topLevelKeys.joined(separator: ", "))")
-        }
-        if !result.emails.isEmpty {
-            print("emails: \(result.emails.joined(separator: ", "))")
-        }
-        if !result.planHints.isEmpty {
-            print("plan-hints: \(result.planHints.joined(separator: ", "))")
-        }
-        if !result.notableFields.isEmpty {
-            print("fields: \(result.notableFields.joined(separator: ", "))")
-        }
-        if let preview = result.bodyPreview, !preview.isEmpty {
-            print("preview: \(preview)")
-        }
-        print("")
-    }
-}

package/Sources/RunicCore/AlertRuleStore.swift

@@ -1,187 +0,0 @@
-import Foundation
-import RunicCore
-
-/// Storage for alert rules, alert history, and webhook configurations
-public enum AlertRuleStore {
-    // MARK: - Types
-
-    public enum AlertType: String, Codable, Sendable {
-        case projectBudget = "project_budget"
-        case usageVelocity = "usage_velocity"
-        case costAnomaly = "cost_anomaly"
-        case quotaThreshold = "quota_threshold"
-    }
-
-    public enum AlertSeverity: String, Codable, Sendable {
-        case info
-        case warning
-        case critical
-    }
-
-    public struct AlertRule: Codable, Sendable, Identifiable {
-        public let id: String
-        public var type: AlertType
-        public var projectID: String?
-        public var provider: String? // UsageProvider rawValue
-        public var threshold: Double
-        public var severity: AlertSeverity
-        public var notifyWebhook: Bool
-        public var webhookURL: String?
-        public var enabled: Bool
-        public let createdAt: Date
-
-        public init(
-            id: String = UUID().uuidString,
-            type: AlertType,
-            projectID: String? = nil,
-            provider: String? = nil,
-            threshold: Double,
-            severity: AlertSeverity,
-            notifyWebhook: Bool = false,
-            webhookURL: String? = nil,
-            enabled: Bool = true,
-            createdAt: Date = Date())
-        {
-            self.id = id
-            self.type = type
-            self.projectID = projectID
-            self.provider = provider
-            self.threshold = threshold
-            self.severity = severity
-            self.notifyWebhook = notifyWebhook
-            self.webhookURL = webhookURL
-            self.enabled = enabled
-            self.createdAt = createdAt
-        }
-    }
-
-    public struct AlertHistoryEntry: Codable, Sendable, Identifiable {
-        public let id: String
-        public let alertID: String
-        public let triggeredAt: Date
-        public var message: String
-        public var severity: AlertSeverity
-        public var acknowledged: Bool
-        public var acknowledgedAt: Date?
-
-        public init(
-            id: String = UUID().uuidString,
-            alertID: String,
-            triggeredAt: Date = Date(),
-            message: String,
-            severity: AlertSeverity,
-            acknowledged: Bool = false,
-            acknowledgedAt: Date? = nil)
-        {
-            self.id = id
-            self.alertID = alertID
-            self.triggeredAt = triggeredAt
-            self.message = message
-            self.severity = severity
-            self.acknowledged = acknowledged
-            self.acknowledgedAt = acknowledgedAt
-        }
-    }
-
-    public struct AlertsData: Codable {
-        public let version: Int
-        public var rules: [AlertRule]
-        public var history: [AlertHistoryEntry]
-
-        public init(version: Int = 1, rules: [AlertRule] = [], history: [AlertHistoryEntry] = []) {
-            self.version = version
-            self.rules = rules
-            self.history = history
-        }
-    }
-
-    // MARK: - Storage Location
-
-    private static var storageURL: URL {
-        let appSupport = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
-        let runicDir = appSupport.appendingPathComponent("Runic", isDirectory: true)
-        try? FileManager.default.createDirectory(at: runicDir, withIntermediateDirectories: true)
-        return runicDir.appendingPathComponent("alert-rules.json")
-    }
-
-    // MARK: - Public Methods
-
-    public static func load() -> AlertsData {
-        guard FileManager.default.fileExists(atPath: self.storageURL.path) else {
-            return AlertsData()
-        }
-
-        do {
-            let data = try Data(contentsOf: storageURL)
-            let decoder = JSONDecoder()
-            decoder.dateDecodingStrategy = .iso8601
-            return try decoder.decode(AlertsData.self, from: data)
-        } catch {
-            print("[AlertRuleStore] Failed to load alerts: \(error)")
-            return AlertsData()
-        }
-    }
-
-    public static func save(_ alertsData: AlertsData) throws {
-        let encoder = JSONEncoder()
-        encoder.dateEncodingStrategy = .iso8601
-        encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
-
-        let data = try encoder.encode(alertsData)
-        try data.write(to: self.storageURL, options: .atomic)
-    }
-
-    public static func addRule(_ rule: AlertRule) throws {
-        var data = self.load()
-        data.rules.append(rule)
-        try self.save(data)
-    }
-
-    public static func removeRule(id: String) throws {
-        var data = self.load()
-        data.rules.removeAll { $0.id == id }
-        try self.save(data)
-    }
-
-    public static func updateRule(_ rule: AlertRule) throws {
-        var data = self.load()
-        if let index = data.rules.firstIndex(where: { $0.id == rule.id }) {
-            data.rules[index] = rule
-            try self.save(data)
-        }
-    }
-
-    public static func getEnabledRules() -> [AlertRule] {
-        self.load().rules.filter(\.enabled)
-    }
-
-    public static func addHistoryEntry(_ entry: AlertHistoryEntry) throws {
-        var data = self.load()
-        data.history.append(entry)
-
-        // Keep last 100 history entries
-        if data.history.count > 100 {
-            data.history = Array(data.history.suffix(100))
-        }
-
-        try self.save(data)
-    }
-
-    public static func acknowledgeAlert(id: String) throws {
-        var data = self.load()
-        if let index = data.history.firstIndex(where: { $0.id == id }) {
-            data.history[index].acknowledged = true
-            data.history[index].acknowledgedAt = Date()
-            try self.save(data)
-        }
-    }
-
-    public static func getRecentHistory(limit: Int = 20) -> [AlertHistoryEntry] {
-        let history = self.load().history.sorted { $0.triggeredAt > $1.triggeredAt }
-        return Array(history.prefix(limit))
-    }
-
-    public static func getUnacknowledgedAlerts() -> [AlertHistoryEntry] {
-        self.load().history.filter { !$0.acknowledged }
-    }
-}

package/Sources/RunicCore/BrowserCookieImportOrder.swift

@@ -1,25 +0,0 @@
-#if os(macOS)
-import Silo
-
-public typealias BrowserCookieImportOrder = [Browser]
-
-extension Collection<Browser> {
-    /// Returns a user-friendly hint about which browsers to log in to.
-    public var loginHint: String {
-        if self.isEmpty {
-            return "your browser"
-        } else if self.count == 1, let first = self.first {
-            return first.displayName
-        } else {
-            let names = self.map(\.displayName)
-            return names.dropLast().joined(separator: ", ") + " or " + (names.last ?? "")
-        }
-    }
-}
-#else
-public struct Browser: Sendable, Hashable {
-    public init() {}
-}
-
-public typealias BrowserCookieImportOrder = [Browser]
-#endif

package/Sources/RunicCore/CopilotUsageModels.swift

@@ -1,84 +0,0 @@
-import Foundation
-
-public struct CopilotUsageResponse: Sendable, Decodable {
-    public struct Organization: Sendable, Decodable {
-        public let name: String?
-        public let login: String?
-    }
-
-    public struct QuotaSnapshot: Sendable, Decodable {
-        public let entitlement: Double?
-        public let remaining: Double?
-        public let quotaRemaining: Double?
-        public let percentRemaining: Double?
-        public let quotaId: String?
-        public let unlimited: Bool?
-        public let overageCount: Double?
-        public let overagePermitted: Bool?
-        public let timestampUTC: String?
-
-        private enum CodingKeys: String, CodingKey {
-            case entitlement
-            case remaining
-            case quotaRemaining = "quota_remaining"
-            case percentRemaining = "percent_remaining"
-            case quotaId = "quota_id"
-            case unlimited
-            case overageCount = "overage_count"
-            case overagePermitted = "overage_permitted"
-            case timestampUTC = "timestamp_utc"
-        }
-
-        public var normalizedRemaining: Double? {
-            self.remaining ?? self.quotaRemaining
-        }
-
-        public var normalizedPercentRemaining: Double? {
-            if let percent = self.percentRemaining {
-                return percent
-            }
-
-            guard let entitlement = self.entitlement,
-                  entitlement > 0,
-                  let remaining = self.normalizedRemaining
-            else {
-                return nil
-            }
-
-            let ratio = (remaining / entitlement) * 100
-            return max(0, min(100, ratio))
-        }
-    }
-
-    public struct QuotaSnapshots: Sendable, Decodable {
-        public let premiumInteractions: QuotaSnapshot?
-        public let chat: QuotaSnapshot?
-        public let completions: QuotaSnapshot?
-
-        private enum CodingKeys: String, CodingKey {
-            case premiumInteractions = "premium_interactions"
-            case chat
-            case completions
-        }
-    }
-
-    public let quotaSnapshots: QuotaSnapshots?
-    public let copilotPlan: String?
-    public let assignedDate: String?
-    public let quotaResetDate: String?
-    public let accessTypeSKU: String?
-    public let chatEnabled: Bool?
-    public let organizationLoginList: [String]?
-    public let organizationList: [Organization]?
-
-    private enum CodingKeys: String, CodingKey {
-        case quotaSnapshots = "quota_snapshots"
-        case copilotPlan = "copilot_plan"
-        case assignedDate = "assigned_date"
-        case quotaResetDate = "quota_reset_date"
-        case accessTypeSKU = "access_type_sku"
-        case chatEnabled = "chat_enabled"
-        case organizationLoginList = "organization_login_list"
-        case organizationList = "organization_list"
-    }
-}

package/Sources/RunicCore/CostUsageFetcher.swift

@@ -1,119 +0,0 @@
-import Foundation
-
-public enum CostUsageError: LocalizedError, Sendable {
-    case unsupportedProvider(UsageProvider)
-    case timedOut(seconds: Int)
-
-    public var errorDescription: String? {
-        switch self {
-        case let .unsupportedProvider(provider):
-            return "Cost summary is not supported for \(provider.rawValue)."
-        case let .timedOut(seconds):
-            if seconds >= 60, seconds % 60 == 0 {
-                return "Cost refresh timed out after \(seconds / 60)m."
-            }
-            return "Cost refresh timed out after \(seconds)s."
-        }
-    }
-}
-
-public struct CostUsageFetcher: Sendable {
-    public init() {}
-
-    public func loadTokenSnapshot(
-        provider: UsageProvider,
-        now: Date = Date(),
-        forceRefresh: Bool = false) async throws -> CostUsageTokenSnapshot
-    {
-        guard provider == .codex || provider == .claude else {
-            throw CostUsageError.unsupportedProvider(provider)
-        }
-
-        let until = now
-        // Rolling window: last 30 days (inclusive). Use -29 for inclusive boundaries.
-        let since = Calendar.current.date(byAdding: .day, value: -29, to: now) ?? now
-
-        var options = CostUsageScanner.Options()
-        if forceRefresh {
-            options.refreshMinIntervalSeconds = 0
-            options.forceRescan = true
-        }
-        let daily = await Task.detached(priority: .utility) {
-            CostUsageScanner.loadDailyReport(
-                provider: provider,
-                since: since,
-                until: until,
-                now: now,
-                options: options)
-        }.value
-
-        return Self.tokenSnapshot(from: daily, now: now)
-    }
-
-    static func tokenSnapshot(from daily: CostUsageDailyReport, now: Date) -> CostUsageTokenSnapshot {
-        // Pick the most recent day; break ties by cost/tokens to keep a stable "session" row.
-        let currentDay = daily.data.max { lhs, rhs in
-            let lDate = CostUsageDateParser.parse(lhs.date) ?? .distantPast
-            let rDate = CostUsageDateParser.parse(rhs.date) ?? .distantPast
-            if lDate != rDate { return lDate < rDate }
-            let lCost = lhs.costUSD ?? -1
-            let rCost = rhs.costUSD ?? -1
-            if lCost != rCost { return lCost < rCost }
-            let lTokens = lhs.totalTokens ?? -1
-            let rTokens = rhs.totalTokens ?? -1
-            if lTokens != rTokens { return lTokens < rTokens }
-            return lhs.date < rhs.date
-        }
-        // Prefer summary totals when present; fall back to summing daily entries.
-        let totalFromSummary = daily.summary?.totalCostUSD
-        let totalFromEntries = daily.data.compactMap(\.costUSD).reduce(0, +)
-        let last30DaysCostUSD = totalFromSummary ?? (totalFromEntries > 0 ? totalFromEntries : nil)
-        let totalTokensFromSummary = daily.summary?.totalTokens
-        let totalTokensFromEntries = daily.data.compactMap(\.totalTokens).reduce(0, +)
-        let last30DaysTokens = totalTokensFromSummary ?? (totalTokensFromEntries > 0 ? totalTokensFromEntries : nil)
-
-        return CostUsageTokenSnapshot(
-            sessionTokens: currentDay?.totalTokens,
-            sessionCostUSD: currentDay?.costUSD,
-            last30DaysTokens: last30DaysTokens,
-            last30DaysCostUSD: last30DaysCostUSD,
-            daily: daily.data,
-            updatedAt: now)
-    }
-
-    static func selectCurrentSession(from sessions: [CostUsageSessionReport.Entry])
-        -> CostUsageSessionReport.Entry?
-    {
-        if sessions.isEmpty { return nil }
-        return sessions.max { lhs, rhs in
-            let lDate = CostUsageDateParser.parse(lhs.lastActivity) ?? .distantPast
-            let rDate = CostUsageDateParser.parse(rhs.lastActivity) ?? .distantPast
-            if lDate != rDate { return lDate < rDate }
-            let lCost = lhs.costUSD ?? -1
-            let rCost = rhs.costUSD ?? -1
-            if lCost != rCost { return lCost < rCost }
-            let lTokens = lhs.totalTokens ?? -1
-            let rTokens = rhs.totalTokens ?? -1
-            if lTokens != rTokens { return lTokens < rTokens }
-            return lhs.session < rhs.session
-        }
-    }
-
-    static func selectMostRecentMonth(from months: [CostUsageMonthlyReport.Entry])
-        -> CostUsageMonthlyReport.Entry?
-    {
-        if months.isEmpty { return nil }
-        return months.max { lhs, rhs in
-            let lDate = CostUsageDateParser.parseMonth(lhs.month) ?? .distantPast
-            let rDate = CostUsageDateParser.parseMonth(rhs.month) ?? .distantPast
-            if lDate != rDate { return lDate < rDate }
-            let lCost = lhs.costUSD ?? -1
-            let rCost = rhs.costUSD ?? -1
-            if lCost != rCost { return lCost < rCost }
-            let lTokens = lhs.totalTokens ?? -1
-            let rTokens = rhs.totalTokens ?? -1
-            if lTokens != rTokens { return lTokens < rTokens }
-            return lhs.month < rhs.month
-        }
-    }
-}