413 lines
14 KiB
Swift
413 lines
14 KiB
Swift
import Foundation
|
|
import SwiftUI
|
|
|
|
struct SessionEntryRecord: Codable {
|
|
let sessionId: String?
|
|
let updatedAt: Double?
|
|
let systemSent: Bool?
|
|
let abortedLastRun: Bool?
|
|
let thinkingLevel: String?
|
|
let verboseLevel: String?
|
|
let inputTokens: Int?
|
|
let outputTokens: Int?
|
|
let totalTokens: Int?
|
|
let model: String?
|
|
let contextTokens: Int?
|
|
}
|
|
|
|
struct SessionTokenStats {
|
|
let input: Int
|
|
let output: Int
|
|
let total: Int
|
|
let contextTokens: Int
|
|
|
|
var contextSummaryShort: String {
|
|
"\(Self.formatKTokens(self.total))/\(Self.formatKTokens(self.contextTokens))"
|
|
}
|
|
|
|
var percentUsed: Int? {
|
|
guard self.contextTokens > 0, self.total > 0 else { return nil }
|
|
return min(100, Int(round((Double(self.total) / Double(self.contextTokens)) * 100)))
|
|
}
|
|
|
|
var summary: String {
|
|
let parts = ["in \(input)", "out \(output)", "total \(total)"]
|
|
var text = parts.joined(separator: " | ")
|
|
if let percentUsed {
|
|
text += " (\(percentUsed)% of \(self.contextTokens))"
|
|
}
|
|
return text
|
|
}
|
|
|
|
static func formatKTokens(_ value: Int) -> String {
|
|
if value < 1000 { return "\(value)" }
|
|
let thousands = Double(value) / 1000
|
|
let decimals = value >= 10_000 ? 0 : 1
|
|
return String(format: "%.\(decimals)fk", thousands)
|
|
}
|
|
}
|
|
|
|
struct SessionRow: Identifiable {
|
|
let id: String
|
|
let key: String
|
|
let kind: SessionKind
|
|
let updatedAt: Date?
|
|
let sessionId: String?
|
|
let thinkingLevel: String?
|
|
let verboseLevel: String?
|
|
let systemSent: Bool
|
|
let abortedLastRun: Bool
|
|
let tokens: SessionTokenStats
|
|
let model: String?
|
|
|
|
var ageText: String { relativeAge(from: self.updatedAt) }
|
|
|
|
var flagLabels: [String] {
|
|
var flags: [String] = []
|
|
if let thinkingLevel { flags.append("think \(thinkingLevel)") }
|
|
if let verboseLevel { flags.append("verbose \(verboseLevel)") }
|
|
if self.systemSent { flags.append("system sent") }
|
|
if self.abortedLastRun { flags.append("aborted") }
|
|
return flags
|
|
}
|
|
}
|
|
|
|
enum SessionKind {
|
|
case direct, group, global, unknown
|
|
|
|
static func from(key: String) -> SessionKind {
|
|
if key == "global" { return .global }
|
|
if key.hasPrefix("group:") { return .group }
|
|
if key == "unknown" { return .unknown }
|
|
return .direct
|
|
}
|
|
|
|
var label: String {
|
|
switch self {
|
|
case .direct: "Direct"
|
|
case .group: "Group"
|
|
case .global: "Global"
|
|
case .unknown: "Unknown"
|
|
}
|
|
}
|
|
|
|
var tint: Color {
|
|
switch self {
|
|
case .direct: .accentColor
|
|
case .group: .orange
|
|
case .global: .purple
|
|
case .unknown: .gray
|
|
}
|
|
}
|
|
}
|
|
|
|
struct SessionDefaults {
|
|
let model: String
|
|
let contextTokens: Int
|
|
}
|
|
|
|
extension SessionRow {
|
|
static var previewRows: [SessionRow] {
|
|
[
|
|
SessionRow(
|
|
id: "direct-1",
|
|
key: "user@example.com",
|
|
kind: .direct,
|
|
updatedAt: Date().addingTimeInterval(-90),
|
|
sessionId: "sess-direct-1234",
|
|
thinkingLevel: "low",
|
|
verboseLevel: "info",
|
|
systemSent: false,
|
|
abortedLastRun: false,
|
|
tokens: SessionTokenStats(input: 320, output: 680, total: 1000, contextTokens: 200_000),
|
|
model: "claude-3.5-sonnet"),
|
|
SessionRow(
|
|
id: "group-1",
|
|
key: "group:engineering",
|
|
kind: .group,
|
|
updatedAt: Date().addingTimeInterval(-3600),
|
|
sessionId: "sess-group-4321",
|
|
thinkingLevel: "medium",
|
|
verboseLevel: nil,
|
|
systemSent: true,
|
|
abortedLastRun: true,
|
|
tokens: SessionTokenStats(input: 5000, output: 1200, total: 6200, contextTokens: 200_000),
|
|
model: "claude-opus-4-5"),
|
|
SessionRow(
|
|
id: "global",
|
|
key: "global",
|
|
kind: .global,
|
|
updatedAt: Date().addingTimeInterval(-86400),
|
|
sessionId: nil,
|
|
thinkingLevel: nil,
|
|
verboseLevel: nil,
|
|
systemSent: false,
|
|
abortedLastRun: false,
|
|
tokens: SessionTokenStats(input: 150, output: 220, total: 370, contextTokens: 200_000),
|
|
model: "gpt-4.1-mini"),
|
|
]
|
|
}
|
|
}
|
|
|
|
struct ModelChoice: Identifiable, Hashable {
|
|
let id: String
|
|
let name: String
|
|
let provider: String
|
|
let contextWindow: Int?
|
|
}
|
|
|
|
extension String? {
|
|
var isNilOrEmpty: Bool {
|
|
switch self {
|
|
case .none: true
|
|
case let .some(value): value.isEmpty
|
|
}
|
|
}
|
|
}
|
|
|
|
extension [String] {
|
|
fileprivate func dedupedPreserveOrder() -> [String] {
|
|
var seen = Set<String>()
|
|
var result: [String] = []
|
|
for item in self where !seen.contains(item) {
|
|
seen.insert(item)
|
|
result.append(item)
|
|
}
|
|
return result
|
|
}
|
|
}
|
|
|
|
struct SessionConfigHints {
|
|
let storePath: String?
|
|
let model: String?
|
|
let contextTokens: Int?
|
|
}
|
|
|
|
enum SessionLoadError: LocalizedError {
|
|
case missingStore(String)
|
|
case decodeFailed(String)
|
|
|
|
var errorDescription: String? {
|
|
switch self {
|
|
case let .missingStore(path):
|
|
"No session store found at \(path) yet. Send or receive a message to create it."
|
|
|
|
case let .decodeFailed(reason):
|
|
"Could not read the session store: \(reason)"
|
|
}
|
|
}
|
|
}
|
|
|
|
enum SessionLoader {
|
|
static let fallbackModel = "claude-opus-4-5"
|
|
static let fallbackContextTokens = 200_000
|
|
|
|
static let defaultStorePath = standardize(
|
|
FileManager.default.homeDirectoryForCurrentUser
|
|
.appendingPathComponent(".clawdis/sessions/sessions.json").path)
|
|
|
|
private static let legacyStorePaths: [String] = [
|
|
standardize(FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".clawdis/sessions.json")
|
|
.path),
|
|
]
|
|
|
|
static func configHints() -> SessionConfigHints {
|
|
let configURL = FileManager.default.homeDirectoryForCurrentUser
|
|
.appendingPathComponent(".clawdis/clawdis.json")
|
|
guard let data = try? Data(contentsOf: configURL) else {
|
|
return SessionConfigHints(storePath: nil, model: nil, contextTokens: nil)
|
|
}
|
|
guard let parsed = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
|
|
return SessionConfigHints(storePath: nil, model: nil, contextTokens: nil)
|
|
}
|
|
|
|
let inbound = parsed["inbound"] as? [String: Any]
|
|
let reply = inbound?["reply"] as? [String: Any]
|
|
let session = reply?["session"] as? [String: Any]
|
|
let agent = reply?["agent"] as? [String: Any]
|
|
|
|
let store = session?["store"] as? String
|
|
let model = agent?["model"] as? String
|
|
let contextTokens = (agent?["contextTokens"] as? NSNumber)?.intValue
|
|
|
|
return SessionConfigHints(
|
|
storePath: store.map { self.standardize($0) },
|
|
model: model,
|
|
contextTokens: contextTokens)
|
|
}
|
|
|
|
static func resolveStorePath(override: String?) -> String {
|
|
let preferred = self.standardize(override ?? self.defaultStorePath)
|
|
let candidates = [preferred] + self.legacyStorePaths
|
|
if let existing = candidates.first(where: { FileManager.default.fileExists(atPath: $0) }) {
|
|
return existing
|
|
}
|
|
return preferred
|
|
}
|
|
|
|
static func availableModels(storeOverride: String?) -> [String] {
|
|
let path = self.resolveStorePath(override: storeOverride)
|
|
guard let data = try? Data(contentsOf: URL(fileURLWithPath: path)),
|
|
let decoded = try? JSONDecoder().decode([String: SessionEntryRecord].self, from: data)
|
|
else {
|
|
return [self.fallbackModel]
|
|
}
|
|
let models = decoded.values.compactMap(\.model)
|
|
return ([self.fallbackModel] + models).dedupedPreserveOrder()
|
|
}
|
|
|
|
static func loadRows(at path: String, defaults: SessionDefaults) async throws -> [SessionRow] {
|
|
try await Task.detached(priority: .utility) {
|
|
guard FileManager.default.fileExists(atPath: path) else {
|
|
throw SessionLoadError.missingStore(path)
|
|
}
|
|
|
|
let data = try Data(contentsOf: URL(fileURLWithPath: path))
|
|
let decoded: [String: SessionEntryRecord]
|
|
do {
|
|
decoded = try JSONDecoder().decode([String: SessionEntryRecord].self, from: data)
|
|
} catch {
|
|
throw SessionLoadError.decodeFailed(error.localizedDescription)
|
|
}
|
|
|
|
let storeDir = URL(fileURLWithPath: path).deletingLastPathComponent()
|
|
|
|
return decoded.map { key, entry in
|
|
let updated = entry.updatedAt.map { Date(timeIntervalSince1970: $0 / 1000) }
|
|
let input = entry.inputTokens ?? 0
|
|
let output = entry.outputTokens ?? 0
|
|
let fallbackTotal = entry.totalTokens ?? input + output
|
|
let promptTokens = entry.sessionId.flatMap { self.promptTokensFromSessionLog(sessionId: $0, storeDir: storeDir) }
|
|
let total = max(fallbackTotal, promptTokens ?? 0)
|
|
let context = entry.contextTokens ?? defaults.contextTokens
|
|
let model = entry.model ?? defaults.model
|
|
|
|
return SessionRow(
|
|
id: key,
|
|
key: key,
|
|
kind: SessionKind.from(key: key),
|
|
updatedAt: updated,
|
|
sessionId: entry.sessionId,
|
|
thinkingLevel: entry.thinkingLevel,
|
|
verboseLevel: entry.verboseLevel,
|
|
systemSent: entry.systemSent ?? false,
|
|
abortedLastRun: entry.abortedLastRun ?? false,
|
|
tokens: SessionTokenStats(
|
|
input: input,
|
|
output: output,
|
|
total: total,
|
|
contextTokens: context),
|
|
model: model)
|
|
}
|
|
.sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
|
|
}.value
|
|
}
|
|
|
|
private static func promptTokensFromSessionLog(sessionId: String, storeDir: URL) -> Int? {
|
|
let trimmed = sessionId.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
guard !trimmed.isEmpty else { return nil }
|
|
|
|
let candidates: [URL] = [
|
|
storeDir.appendingPathComponent("\(trimmed).jsonl"),
|
|
FileManager.default.homeDirectoryForCurrentUser
|
|
.appendingPathComponent(".pi/agent/sessions")
|
|
.appendingPathComponent("\(trimmed).jsonl"),
|
|
FileManager.default.homeDirectoryForCurrentUser
|
|
.appendingPathComponent(".tau/agent/sessions/clawdis")
|
|
.appendingPathComponent("\(trimmed).jsonl"),
|
|
]
|
|
|
|
guard let logURL = candidates.first(where: { FileManager.default.fileExists(atPath: $0.path) }) else {
|
|
return nil
|
|
}
|
|
|
|
guard let lastUsage = self.readLastUsageFromJsonl(logURL) else { return nil }
|
|
|
|
let input = self.number(from: lastUsage["input"]) ?? 0
|
|
let output = self.number(from: lastUsage["output"]) ?? 0
|
|
let cacheRead = self.number(from: lastUsage["cacheRead"] ?? lastUsage["cache_read"]) ?? 0
|
|
let cacheWrite = self.number(from: lastUsage["cacheWrite"] ?? lastUsage["cache_write"]) ?? 0
|
|
let totalTokens = self.number(from: lastUsage["totalTokens"] ?? lastUsage["total_tokens"] ?? lastUsage["total"])
|
|
|
|
let prompt = input + cacheRead + cacheWrite
|
|
if prompt > 0 { return prompt }
|
|
if let totalTokens, totalTokens > output { return totalTokens - output }
|
|
return nil
|
|
}
|
|
|
|
private static func readLastUsageFromJsonl(_ url: URL) -> [String: Any]? {
|
|
// Logs can contain huge toolResult payloads (base64 images). Avoid parsing the whole file:
|
|
// read a tail window and scan backwards for the last JSON line that contains a usage blob.
|
|
let handle: FileHandle
|
|
do {
|
|
handle = try FileHandle(forReadingFrom: url)
|
|
} catch {
|
|
return nil
|
|
}
|
|
defer { try? handle.close() }
|
|
|
|
let fileSize: UInt64
|
|
do {
|
|
fileSize = try handle.seekToEnd()
|
|
} catch {
|
|
return nil
|
|
}
|
|
|
|
let window: UInt64 = 512 * 1024
|
|
let start = fileSize > window ? fileSize - window : 0
|
|
do {
|
|
try handle.seek(toOffset: start)
|
|
} catch {
|
|
return nil
|
|
}
|
|
|
|
let data = (try? handle.readToEnd()) ?? Data()
|
|
guard let text = String(data: data, encoding: .utf8) else { return nil }
|
|
|
|
let lines = text.split(whereSeparator: \.isNewline)
|
|
for line in lines.reversed() {
|
|
let trimmedLine = line.trimmingCharacters(in: .whitespacesAndNewlines)
|
|
if trimmedLine.isEmpty { continue }
|
|
// Cheap prefilter before JSON parsing.
|
|
if !trimmedLine.contains("\"usage\"") { continue }
|
|
guard let lineData = trimmedLine.data(using: .utf8) else { continue }
|
|
guard let obj = try? JSONSerialization.jsonObject(with: lineData) as? [String: Any] else { continue }
|
|
|
|
if let message = obj["message"] as? [String: Any], let usage = message["usage"] as? [String: Any] {
|
|
return usage
|
|
}
|
|
if let usage = obj["usage"] as? [String: Any] {
|
|
return usage
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
private static func number(from raw: Any?) -> Int? {
|
|
switch raw {
|
|
case let v as Int: v
|
|
case let v as Double: Int(v)
|
|
case let v as NSNumber: v.intValue
|
|
case let v as String: Int(v)
|
|
default: nil
|
|
}
|
|
}
|
|
|
|
private static func standardize(_ path: String) -> String {
|
|
(path as NSString).expandingTildeInPath.replacingOccurrences(of: "//", with: "/")
|
|
}
|
|
}
|
|
|
|
func relativeAge(from date: Date?) -> String {
|
|
guard let date else { return "unknown" }
|
|
let delta = Date().timeIntervalSince(date)
|
|
if delta < 60 { return "just now" }
|
|
let minutes = Int(round(delta / 60))
|
|
if minutes < 60 { return "\(minutes)m ago" }
|
|
let hours = Int(round(Double(minutes) / 60))
|
|
if hours < 48 { return "\(hours)h ago" }
|
|
let days = Int(round(Double(hours) / 24))
|
|
return "\(days)d ago"
|
|
}
|