@cryptiklemur/lattice 4.0.1 → 5.0.0

package/dist/server/project/session.js

@@ -0,0 +1,696 @@
+import { listSessions as sdkListSessions, getSessionInfo, getSessionMessages, renameSession as sdkRenameSession, } from "@anthropic-ai/claude-agent-sdk";
+import { existsSync, unlinkSync, readFileSync, statSync } from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { homedir } from "node:os";
+import { loadConfig } from "../config.js";
+import { log } from "../logger.js";
+function getProjectPath(projectSlug) {
+    var config = loadConfig();
+    var project = config.projects.find(function (p) { return p.slug === projectSlug; });
+    return project ? project.path : null;
+}
+export function projectPathToHash(projectPath) {
+    return projectPath.replace(/\//g, "-");
+}
+function mapSDKSession(info, projectSlug) {
+    return {
+        id: info.sessionId,
+        projectSlug,
+        title: info.customTitle || info.summary || info.firstPrompt || "Untitled",
+        createdAt: info.createdAt || info.lastModified,
+        updatedAt: info.lastModified,
+    };
+}
+var LITELLM_PRICING_URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json";
+var pricingCache = {};
+var pricingLoaded = false;
+var FALLBACK_PRICING = {
+    "claude-opus-4-6": { input: 15, output: 75 },
+    "claude-sonnet-4-6": { input: 3, output: 15 },
+    "claude-haiku-4-5": { input: 0.80, output: 4 },
+};
+export function loadPricing() {
+    if (pricingLoaded)
+        return;
+    pricingLoaded = true;
+    fetch(LITELLM_PRICING_URL).then(function (res) {
+        return res.json();
+    }).then(function (data) {
+        for (var key in data) {
+            if (!key.includes("claude"))
+                continue;
+            var entry = data[key];
+            var inputCost = entry.input_cost_per_token;
+            var outputCost = entry.output_cost_per_token;
+            if (inputCost == null || outputCost == null)
+                continue;
+            var modelId = key.replace("anthropic/", "").replace("claude-", "claude-");
+            pricingCache[modelId] = {
+                input: inputCost * 1000000,
+                output: outputCost * 1000000,
+                cacheRead: entry.cache_read_input_token_cost != null ? entry.cache_read_input_token_cost * 1000000 : undefined,
+                cacheCreation: entry.cache_creation_input_token_cost != null ? entry.cache_creation_input_token_cost * 1000000 : undefined,
+            };
+            pricingCache[key] = pricingCache[modelId];
+        }
+    }).catch(function () { });
+}
+loadPricing();
+export function getPricing(model) {
+    if (pricingCache[model])
+        return pricingCache[model];
+    for (var key in pricingCache) {
+        if (key.includes(model) || model.includes(key))
+            return pricingCache[key];
+    }
+    var shortModel = model.replace("claude-", "").split("-")[0];
+    for (var key2 in pricingCache) {
+        if (key2.includes(shortModel))
+            return pricingCache[key2];
+    }
+    if (FALLBACK_PRICING[model]) {
+        return FALLBACK_PRICING[model];
+    }
+    return FALLBACK_PRICING["claude-sonnet-4-6"];
+}
+export function estimateCost(model, inputTokens, outputTokens, cacheRead, cacheCreation) {
+    var pricing = getPricing(model);
+    var normalInput = inputTokens - cacheRead - cacheCreation;
+    var inputCost = (normalInput * pricing.input) / 1000000;
+    var cacheCost = pricing.cacheRead != null
+        ? (cacheRead * pricing.cacheRead) / 1000000
+        : (cacheRead * pricing.input * 0.1) / 1000000;
+    var cacheCreateCost = pricing.cacheCreation != null
+        ? (cacheCreation * pricing.cacheCreation) / 1000000
+        : (cacheCreation * pricing.input * 1.25) / 1000000;
+    var outputCost = (outputTokens * pricing.output) / 1000000;
+    return Math.max(0, inputCost + cacheCost + cacheCreateCost + outputCost);
+}
+function parseTimestamp(msg) {
+    var raw = msg.timestamp;
+    if (raw) {
+        var parsed = new Date(raw).getTime();
+        if (!isNaN(parsed))
+            return parsed;
+    }
+    return 0;
+}
+function stripXmlTags(text) {
+    return text.replace(/<[^>]+>/g, "").trim();
+}
+function isSystemContent(text) {
+    return text.startsWith("<local-command-caveat>")
+        || text.startsWith("<system-reminder>")
+        || text.startsWith("<local-command-stdout>")
+        || text.startsWith("<command-name>")
+        || text.startsWith("<command-message>");
+}
+function extractUserText(content) {
+    if (typeof content === "string") {
+        if (isSystemContent(content))
+            return "";
+        return stripXmlTags(content);
+    }
+    if (Array.isArray(content)) {
+        for (var i = 0; i < content.length; i++) {
+            var block = content[i];
+            if (block.type === "text" && typeof block.text === "string") {
+                if (isSystemContent(block.text))
+                    continue;
+                var cleaned = stripXmlTags(block.text);
+                if (cleaned)
+                    return cleaned;
+            }
+        }
+    }
+    return "";
+}
+var HIDDEN_TOOLS = new Set([
+    "TaskUpdate", "TaskCreate", "TaskGet", "TaskList", "TaskOutput", "TaskStop",
+    "TodoWrite", "TodoRead",
+    "EnterPlanMode", "ExitPlanMode",
+    "ToolSearch",
+]);
+function convertSessionMessages(messages) {
+    var result = [];
+    var hiddenToolIds = new Set();
+    for (var i = 0; i < messages.length; i++) {
+        var msg = messages[i];
+        var ts = parseTimestamp(msg);
+        var apiMsg = msg.message;
+        if (msg.type === "user") {
+            if (msg.isCompactSummary === true) {
+                var summaryText = typeof apiMsg.content === "string" ? apiMsg.content : "";
+                if (summaryText) {
+                    result.push({
+                        type: "compact_summary",
+                        uuid: msg.uuid,
+                        text: summaryText,
+                        timestamp: ts,
+                    });
+                }
+                continue;
+            }
+            if (Array.isArray(apiMsg.content)) {
+                var hadToolResult = false;
+                for (var j = 0; j < apiMsg.content.length; j++) {
+                    var block = apiMsg.content[j];
+                    if (block.type === "tool_result" && block.tool_use_id) {
+                        if (hiddenToolIds.has(block.tool_use_id))
+                            continue;
+                        hadToolResult = true;
+                        var resultContent = "";
+                        if (typeof block.content === "string") {
+                            resultContent = block.content;
+                        }
+                        else if (Array.isArray(block.content)) {
+                            var texts = [];
+                            for (var ri = 0; ri < block.content.length; ri++) {
+                                var rb = block.content[ri];
+                                if (rb.type === "text" && rb.text)
+                                    texts.push(rb.text);
+                            }
+                            resultContent = texts.join("\n");
+                        }
+                        else {
+                            resultContent = JSON.stringify(block.content ?? "");
+                        }
+                        result.push({
+                            type: "tool_result",
+                            toolId: block.tool_use_id,
+                            content: resultContent,
+                            timestamp: ts,
+                        });
+                    }
+                    else if (block.type === "text" && block.text) {
+                        if (isSystemContent(block.text))
+                            continue;
+                        var cleaned = stripXmlTags(block.text);
+                        if (cleaned) {
+                            result.push({
+                                type: "user",
+                                uuid: msg.uuid,
+                                text: cleaned,
+                                timestamp: ts,
+                            });
+                        }
+                    }
+                }
+            }
+            else {
+                var text = extractUserText(apiMsg.content);
+                if (text) {
+                    result.push({
+                        type: "user",
+                        uuid: msg.uuid,
+                        text,
+                        timestamp: ts,
+                    });
+                }
+            }
+        }
+        else if (msg.type === "assistant") {
+            var msgUsage = apiMsg.usage;
+            var msgModel = apiMsg.model || "";
+            var lastAssistantIdx = -1;
+            if (Array.isArray(apiMsg.content)) {
+                for (var k = 0; k < apiMsg.content.length; k++) {
+                    var aBlock = apiMsg.content[k];
+                    if (aBlock.type === "text" && aBlock.text) {
+                        lastAssistantIdx = result.length;
+                        result.push({
+                            type: "assistant",
+                            uuid: msg.uuid + "-text-" + k,
+                            text: aBlock.text,
+                            timestamp: ts,
+                        });
+                    }
+                    else if (aBlock.type === "tool_use" && aBlock.id && aBlock.name) {
+                        if (HIDDEN_TOOLS.has(aBlock.name)) {
+                            hiddenToolIds.add(aBlock.id);
+                        }
+                        else {
+                            result.push({
+                                type: "tool_start",
+                                toolId: aBlock.id,
+                                name: aBlock.name,
+                                args: JSON.stringify(aBlock.input ?? {}),
+                                timestamp: ts,
+                            });
+                        }
+                    }
+                }
+                if (msgUsage && lastAssistantIdx >= 0) {
+                    var inTok = msgUsage.input_tokens || 0;
+                    var outTok = msgUsage.output_tokens || 0;
+                    var cacheRead = msgUsage.cache_read_input_tokens || 0;
+                    var cacheCreate = msgUsage.cache_creation_input_tokens || 0;
+                    result[lastAssistantIdx].inputTokens = inTok;
+                    result[lastAssistantIdx].outputTokens = outTok;
+                    result[lastAssistantIdx].model = msgModel;
+                    result[lastAssistantIdx].costEstimate = estimateCost(msgModel, inTok, outTok, cacheRead, cacheCreate);
+                }
+            }
+            else {
+                var aText = typeof apiMsg.content === "string" ? apiMsg.content : "";
+                if (aText) {
+                    lastAssistantIdx = result.length;
+                    result.push({
+                        type: "assistant",
+                        uuid: msg.uuid,
+                        text: aText,
+                        timestamp: ts,
+                    });
+                    if (msgUsage) {
+                        var inTok2 = msgUsage.input_tokens || 0;
+                        var outTok2 = msgUsage.output_tokens || 0;
+                        var cacheRead2 = msgUsage.cache_read_input_tokens || 0;
+                        var cacheCreate2 = msgUsage.cache_creation_input_tokens || 0;
+                        result[lastAssistantIdx].inputTokens = inTok2;
+                        result[lastAssistantIdx].outputTokens = outTok2;
+                        result[lastAssistantIdx].model = msgModel;
+                        result[lastAssistantIdx].costEstimate = estimateCost(msgModel, inTok2, outTok2, cacheRead2, cacheCreate2);
+                    }
+                }
+            }
+        }
+    }
+    return result;
+}
+var MODEL_CONTEXT_WINDOWS = {
+    "claude-opus-4-6": 1048576,
+    "claude-sonnet-4-6": 1048576,
+    "claude-sonnet-4-5-20250514": 1048576,
+    "claude-haiku-4-5-20251001": 1048576,
+    "claude-sonnet-4-20250514": 200000,
+    "claude-3-5-sonnet-20241022": 200000,
+    "claude-3-5-haiku-20241022": 200000,
+    "claude-3-opus-20240229": 200000,
+};
+export function guessContextWindow(model) {
+    if (MODEL_CONTEXT_WINDOWS[model])
+        return MODEL_CONTEXT_WINDOWS[model];
+    if (model.includes("opus-4") || model.includes("sonnet-4"))
+        return 1048576;
+    if (model.includes("haiku-4"))
+        return 1048576;
+    return 200000;
+}
+export async function getSessionUsage(projectSlug, sessionId) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath)
+        return null;
+    var hash = projectPathToHash(projectPath);
+    var sessionFile = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+    if (!existsSync(sessionFile))
+        return null;
+    try {
+        var fhUsage = await fsPromises.open(sessionFile, "r");
+        var statUsage = await fhUsage.stat();
+        var tailSize = Math.min(statUsage.size, 512 * 1024);
+        var bufUsage = Buffer.alloc(tailSize);
+        await fhUsage.read(bufUsage, 0, tailSize, statUsage.size - tailSize);
+        await fhUsage.close();
+        var text = bufUsage.toString("utf-8");
+        var lines = text.split("\n");
+        for (var i = lines.length - 1; i >= 0; i--) {
+            var line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                var parsed = JSON.parse(line);
+                if (parsed.type === "assistant" && parsed.message && parsed.message.usage) {
+                    var usage = parsed.message.usage;
+                    var model = parsed.message.model || "";
+                    return {
+                        inputTokens: usage.input_tokens || 0,
+                        outputTokens: usage.output_tokens || 0,
+                        cacheReadTokens: usage.cache_read_input_tokens || 0,
+                        cacheCreationTokens: usage.cache_creation_input_tokens || 0,
+                        contextWindow: guessContextWindow(model),
+                    };
+                }
+            }
+            catch { }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getSessionPreview(projectSlug, sessionId) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath)
+        return null;
+    var hash = projectPathToHash(projectPath);
+    var sessionFile = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+    if (!existsSync(sessionFile))
+        return null;
+    try {
+        var content = readFileSync(sessionFile, "utf-8");
+        var lines = content.trim().split("\n");
+        var totalCost = 0;
+        var messageCount = 0;
+        var model = "";
+        var lastMessage = "";
+        var firstTimestamp = 0;
+        var lastTimestamp = 0;
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i].trim();
+            if (!line)
+                continue;
+            try {
+                var parsed = JSON.parse(line);
+                var ts = 0;
+                var rawTs = parsed.timestamp;
+                if (rawTs) {
+                    var parsedTs = new Date(rawTs).getTime();
+                    if (!isNaN(parsedTs))
+                        ts = parsedTs;
+                }
+                if (ts > 0 && firstTimestamp === 0)
+                    firstTimestamp = ts;
+                if (ts > lastTimestamp)
+                    lastTimestamp = ts;
+                if (parsed.type === "user") {
+                    messageCount++;
+                    var userText = extractUserText(parsed.message?.content);
+                    if (userText)
+                        lastMessage = userText;
+                }
+                else if (parsed.type === "assistant" && parsed.message) {
+                    messageCount++;
+                    var usage = parsed.message.usage;
+                    var msgModel = parsed.message.model || "";
+                    if (msgModel)
+                        model = msgModel;
+                    if (usage) {
+                        var inTok = usage.input_tokens || 0;
+                        var outTok = usage.output_tokens || 0;
+                        var cacheRead = usage.cache_read_input_tokens || 0;
+                        var cacheCreate = usage.cache_creation_input_tokens || 0;
+                        totalCost += estimateCost(msgModel || model, inTok, outTok, cacheRead, cacheCreate);
+                    }
+                    var aContent = parsed.message.content;
+                    if (Array.isArray(aContent)) {
+                        for (var j = aContent.length - 1; j >= 0; j--) {
+                            if (aContent[j].type === "text" && aContent[j].text) {
+                                lastMessage = aContent[j].text;
+                                break;
+                            }
+                        }
+                    }
+                    else if (typeof aContent === "string" && aContent) {
+                        lastMessage = aContent;
+                    }
+                }
+            }
+            catch { }
+        }
+        var maxSnippet = 120;
+        if (lastMessage.length > maxSnippet) {
+            lastMessage = lastMessage.slice(0, maxSnippet) + "...";
+        }
+        return {
+            sessionId,
+            cost: Math.round(totalCost * 100) / 100,
+            durationMs: lastTimestamp > firstTimestamp ? lastTimestamp - firstTimestamp : 0,
+            messageCount,
+            model: model.replace("claude-", "").split("-20")[0],
+            lastMessage,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+var sessionListCache = new Map();
+var SESSION_CACHE_TTL = 5000;
+export async function listSessions(projectSlug, options) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath) {
+        return { sessions: [], totalCount: 0 };
+    }
+    var cached = sessionListCache.get(projectSlug);
+    if (cached && !options?.noCache && Date.now() - cached.time < SESSION_CACHE_TTL) {
+        var offset = options?.offset ?? 0;
+        var limit = options?.limit ?? 0;
+        var sliced = limit > 0 ? cached.sessions.slice(offset, offset + limit) : cached.sessions;
+        return { sessions: sliced, totalCount: cached.sessions.length };
+    }
+    try {
+        var sdkT0 = Date.now();
+        var sdkSessions = await sdkListSessions({ dir: projectPath });
+        log.session("sdkListSessions for %s: %dms (%d sessions)", projectSlug, Date.now() - sdkT0, sdkSessions.length);
+        var summaries = sdkSessions.map(function (s) {
+            return mapSDKSession(s, projectSlug);
+        });
+        summaries.sort(function (a, b) { return b.updatedAt - a.updatedAt; });
+        sessionListCache.set(projectSlug, { sessions: summaries, time: Date.now() });
+        var offset2 = options?.offset ?? 0;
+        var limit2 = options?.limit ?? 0;
+        var sliced2 = limit2 > 0 ? summaries.slice(offset2, offset2 + limit2) : summaries;
+        return { sessions: sliced2, totalCount: summaries.length };
+    }
+    catch (err) {
+        log.session("Failed to list SDK sessions: %O", err);
+        return { sessions: [], totalCount: 0 };
+    }
+}
+export function invalidateSessionCache(projectSlug) {
+    sessionListCache.delete(projectSlug);
+}
+export function invalidateHistoryCache(sessionId) {
+    historyCache.delete(sessionId);
+    var idx = historyCacheOrder.indexOf(sessionId);
+    if (idx >= 0)
+        historyCacheOrder.splice(idx, 1);
+}
+export async function getSessionTitle(projectSlug, sessionId) {
+    var projectPath = getProjectPath(projectSlug);
+    var options = projectPath ? { dir: projectPath } : undefined;
+    try {
+        var info = await getSessionInfo(sessionId, options);
+        if (info) {
+            return info.customTitle || info.summary || info.firstPrompt || "Untitled";
+        }
+    }
+    catch { }
+    return "Untitled";
+}
+var historyCache = new Map();
+var historyCacheOrder = [];
+var MAX_HISTORY_CACHE = 50;
+function touchCache(sessionId) {
+    var idx = historyCacheOrder.indexOf(sessionId);
+    if (idx >= 0)
+        historyCacheOrder.splice(idx, 1);
+    historyCacheOrder.push(sessionId);
+}
+function evictOldest() {
+    while (historyCacheOrder.length > MAX_HISTORY_CACHE) {
+        var oldest = historyCacheOrder.shift();
+        if (oldest)
+            historyCache.delete(oldest);
+    }
+}
+export function appendToHistoryCache(sessionId, message) {
+    var cached = historyCache.get(sessionId);
+    if (!cached)
+        return;
+    cached.messages.push(message);
+    touchCache(sessionId);
+}
+var INITIAL_MESSAGE_COUNT = 300;
+var TAIL_READ_BYTES = 512 * 1024;
+function getSessionFilePath(projectSlug, sessionId) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath)
+        return null;
+    var hash = projectPathToHash(projectPath);
+    var filePath = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+    return existsSync(filePath) ? filePath : null;
+}
+export function getSessionFileSizeBytes(projectSlug, sessionId) {
+    var filePath = getSessionFilePath(projectSlug, sessionId);
+    if (!filePath)
+        return null;
+    try {
+        return statSync(filePath).size;
+    }
+    catch {
+        return null;
+    }
+}
+async function readTailLines(filePath, maxBytes) {
+    var fh = await fsPromises.open(filePath, "r");
+    try {
+        var stat = await fh.stat();
+        var readStart = Math.max(0, stat.size - maxBytes);
+        var length = stat.size - readStart;
+        var buf = Buffer.alloc(length);
+        await fh.read(buf, 0, length, readStart);
+        var text = buf.toString("utf-8");
+        if (readStart > 0) {
+            var firstNewline = text.indexOf("\n");
+            if (firstNewline >= 0)
+                text = text.slice(firstNewline + 1);
+        }
+        var lines = text.split("\n").filter(function (l) { return l.length > 0; });
+        return { lines, isPartial: readStart > 0, fileSize: stat.size };
+    }
+    finally {
+        await fh.close();
+    }
+}
+function parseJsonlLines(lines) {
+    var results = [];
+    for (var i = 0; i < lines.length; i++) {
+        try {
+            var parsed = JSON.parse(lines[i]);
+            if (parsed.type === "user" || parsed.type === "assistant" || parsed.type === "system") {
+                results.push(parsed);
+            }
+        }
+        catch { }
+    }
+    return results;
+}
+export async function loadSessionHistory(projectSlug, sessionId) {
+    try {
+        var t0 = Date.now();
+        var cached = historyCache.get(sessionId);
+        if (cached) {
+            touchCache(sessionId);
+            var tail = cached.messages.length > INITIAL_MESSAGE_COUNT
+                ? cached.messages.slice(cached.messages.length - INITIAL_MESSAGE_COUNT)
+                : cached.messages;
+            log.session("loadSessionHistory %s: %dms (cached, %d total)", sessionId.slice(0, 8), Date.now() - t0, cached.messages.length);
+            return { messages: tail, totalMessages: cached.messages.length, hasMore: cached.messages.length > INITIAL_MESSAGE_COUNT };
+        }
+        var filePath = getSessionFilePath(projectSlug, sessionId);
+        if (filePath) {
+            var tailData = await readTailLines(filePath, TAIL_READ_BYTES);
+            var tailRaw = parseJsonlLines(tailData.lines);
+            var tailMessages = convertSessionMessages(tailRaw);
+            var hasMore = tailData.isPartial;
+            log.session("loadSessionHistory %s: %dms (tail read, %d msgs, partial=%s)", sessionId.slice(0, 8), Date.now() - t0, tailMessages.length, hasMore);
+            if (!hasMore && tailMessages.length > 0) {
+                historyCache.set(sessionId, { messages: tailMessages, title: null });
+                touchCache(sessionId);
+                evictOldest();
+            }
+            var initialSlice = tailMessages.length > INITIAL_MESSAGE_COUNT
+                ? tailMessages.slice(tailMessages.length - INITIAL_MESSAGE_COUNT)
+                : tailMessages;
+            return { messages: initialSlice, totalMessages: tailMessages.length, hasMore: hasMore };
+        }
+        var projectPath = getProjectPath(projectSlug);
+        var options = projectPath ? { dir: projectPath } : undefined;
+        var rawMessages = await getSessionMessages(sessionId, options);
+        var allMessages = convertSessionMessages(rawMessages);
+        if (allMessages.length > 0) {
+            historyCache.set(sessionId, { messages: allMessages, title: null });
+            touchCache(sessionId);
+            evictOldest();
+        }
+        log.session("loadSessionHistory %s: %dms (full SDK, %d msgs)", sessionId.slice(0, 8), Date.now() - t0, allMessages.length);
+        var tailSlice = allMessages.length > INITIAL_MESSAGE_COUNT
+            ? allMessages.slice(allMessages.length - INITIAL_MESSAGE_COUNT)
+            : allMessages;
+        return { messages: tailSlice, totalMessages: allMessages.length, hasMore: allMessages.length > INITIAL_MESSAGE_COUNT };
+    }
+    catch (err) {
+        log.session("Failed to load session history: %O", err);
+        return { messages: [], totalMessages: 0, hasMore: false };
+    }
+}
+export async function getSessionHistoryPage(sessionId, beforeIndex, limit, projectSlug) {
+    var cached = historyCache.get(sessionId);
+    if (!cached && projectSlug) {
+        var projectPath = getProjectPath(projectSlug);
+        var options = projectPath ? { dir: projectPath } : undefined;
+        try {
+            var rawMessages = await getSessionMessages(sessionId, options);
+            var allMessages = convertSessionMessages(rawMessages);
+            historyCache.set(sessionId, { messages: allMessages, title: null });
+            touchCache(sessionId);
+            evictOldest();
+            cached = historyCache.get(sessionId);
+            log.session("getSessionHistoryPage: full load for %s, %d messages", sessionId.slice(0, 8), allMessages.length);
+        }
+        catch {
+            return { messages: [], hasMore: false, totalMessages: 0 };
+        }
+    }
+    if (!cached)
+        return { messages: [], hasMore: false, totalMessages: 0 };
+    var total = cached.messages.length;
+    var endIdx = Math.min(Math.max(0, beforeIndex), total);
+    var startIdx = Math.max(0, endIdx - limit);
+    var page = cached.messages.slice(startIdx, endIdx);
+    return { messages: page, hasMore: startIdx > 0, totalMessages: total };
+}
+export function createSession(projectSlug) {
+    var sessionId = randomUUID();
+    var now = Date.now();
+    return {
+        id: sessionId,
+        projectSlug,
+        title: "Session " + new Date(now).toLocaleString(),
+        createdAt: now,
+        updatedAt: now,
+    };
+}
+export async function renameSession(projectSlug, sessionId, title) {
+    var projectPath = getProjectPath(projectSlug);
+    var options = projectPath ? { dir: projectPath } : undefined;
+    try {
+        await sdkRenameSession(sessionId, title, options);
+        return true;
+    }
+    catch (err) {
+        log.session("Failed to rename session: %O", err);
+        return false;
+    }
+}
+export async function deleteSession(projectSlug, sessionId) {
+    var projectPath = getProjectPath(projectSlug);
+    if (!projectPath) {
+        return false;
+    }
+    var hash = projectPathToHash(projectPath);
+    var sessionFile = join(homedir(), ".claude", "projects", hash, sessionId + ".jsonl");
+    if (!existsSync(sessionFile)) {
+        return false;
+    }
+    try {
+        unlinkSync(sessionFile);
+        return true;
+    }
+    catch (err) {
+        log.session("Failed to delete session: %O", err);
+        return false;
+    }
+}
+export async function findProjectSlugForSession(sessionId) {
+    try {
+        var info = await getSessionInfo(sessionId);
+        if (!info || !info.cwd) {
+            return null;
+        }
+        var config = loadConfig();
+        for (var i = 0; i < config.projects.length; i++) {
+            if (info.cwd.startsWith(config.projects[i].path)) {
+                return config.projects[i].slug;
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}