@sriinnu/runic 1.0.0

package/Sources/RunicClaudeWatchdog/main.swift

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

@@ -0,0 +1,62 @@
+import RunicCore
+import Foundation
+
+@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

@@ -0,0 +1,187 @@
+import Foundation
+import RunicCore
+
+/// Storage for alert rules, alert history, and webhook configurations
+public struct 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: 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: storageURL, options: .atomic)
+    }
+
+    public static func addRule(_ rule: AlertRule) throws {
+        var data = load()
+        data.rules.append(rule)
+        try save(data)
+    }
+
+    public static func removeRule(id: String) throws {
+        var data = load()
+        data.rules.removeAll { $0.id == id }
+        try save(data)
+    }
+
+    public static func updateRule(_ rule: AlertRule) throws {
+        var data = load()
+        if let index = data.rules.firstIndex(where: { $0.id == rule.id }) {
+            data.rules[index] = rule
+            try save(data)
+        }
+    }
+
+    public static func getEnabledRules() -> [AlertRule] {
+        load().rules.filter { $0.enabled }
+    }
+
+    public static func addHistoryEntry(_ entry: AlertHistoryEntry) throws {
+        var data = load()
+        data.history.append(entry)
+
+        // Keep last 100 history entries
+        if data.history.count > 100 {
+            data.history = Array(data.history.suffix(100))
+        }
+
+        try save(data)
+    }
+
+    public static func acknowledgeAlert(id: String) throws {
+        var data = load()
+        if let index = data.history.firstIndex(where: { $0.id == id }) {
+            data.history[index].acknowledged = true
+            data.history[index].acknowledgedAt = Date()
+            try save(data)
+        }
+    }
+
+    public static func getRecentHistory(limit: Int = 20) -> [AlertHistoryEntry] {
+        let history = load().history.sorted { $0.triggeredAt > $1.triggeredAt }
+        return Array(history.prefix(limit))
+    }
+
+    public static func getUnacknowledgedAlerts() -> [AlertHistoryEntry] {
+        load().history.filter { !$0.acknowledged }
+    }
+}

package/Sources/RunicCore/BrowserCookieImportOrder.swift

@@ -0,0 +1,25 @@
+#if os(macOS)
+import Silo
+
+public typealias BrowserCookieImportOrder = [Browser]
+
+public extension Collection where Element == Browser {
+    /// Returns a user-friendly hint about which browsers to log in to.
+    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 { $0.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

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

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