@teddysc/claude-run 0.11.0 → 0.13.0

package/README.md

@@ -30,8 +30,22 @@ bun install -g @teddysc/claude-run@latest
 
 The browser will open automatically at http://localhost:12001.
 
+## Specifications
+
+See [spec.md](spec.md)
+
 ## Changelog
 
+### 0.13.0
+- Display message count, duration, and JSONL size in conversation header
+- Sidebar shows compact message count, duration, and JSONL size per session
+- Add sorting options for sessions (by duration or JSONL size, asc/desc)
+
+### 0.12.0
+- Rename sessions directly from the web UI
+- Searchable project dropdown with fuzzy matching on name and path
+- Session summary caching for improved performance
+
 ### 0.11.0
 - Display session metadata (model, start/end times) in conversation header
 - Show full project path with ~ shorthand in header and sidebar tooltips
@@ -87,10 +101,13 @@ The browser will open automatically at http://localhost:12001.
 - **Truncation options** - Limit long tool outputs by line count or character count
 - **Batch export** - Export multiple conversations at once
 - **Real-time streaming** - Watch conversations update live as Claude responds
-- **Filter by project** - Focus on specific projects
+- **Filter by project** - Searchable dropdown with fuzzy matching on project name and path
 - **Resume sessions** - Copy the resume command to continue any conversation in your terminal
 - **Copy messages** - Click the copy button on any message to copy its text content
-- **Session metadata** - See model and start/end times in the conversation header
+- **Session metadata** - See model, message count, duration, and JSONL size in the conversation header
+- **Sidebar stats** - Compact message count, duration, and JSONL size per session
+- **Sidebar sorting** - Sort sessions by duration or JSONL size (asc/desc)
+- **Rename sessions** - Click the conversation title to rename a session
 - **Collapsible sidebar** - Maximize your viewing area
 - **Dark mode** - Easy on the eyes
 - **Clean UI** - Familiar chat interface with collapsible tool calls

package/dist/index.js

@@ -88,6 +88,8 @@ function mergeSidechainText(messages, sidechainMap) {
 var claudeDir = join(homedir(), ".claude");
 var projectsDir = join(claudeDir, "projects");
 var fileIndex = /* @__PURE__ */ new Map();
+var summaryCache = /* @__PURE__ */ new Map();
+var sessionStatsCache = /* @__PURE__ */ new Map();
 var historyCache = null;
 var pendingRequests = /* @__PURE__ */ new Map();
 function initStorage(dir) {
@@ -102,6 +104,132 @@ function invalidateHistoryCache() {
 }
 function addToFileIndex(sessionId, filePath) {
   fileIndex.set(sessionId, filePath);
+  summaryCache.delete(sessionId);
+  sessionStatsCache.delete(sessionId);
+}
+function invalidateSessionStats(sessionId) {
+  sessionStatsCache.delete(sessionId);
+}
+function parseMessageTimestamp(rawTimestamp) {
+  if (typeof rawTimestamp === "string") {
+    const parsed = Date.parse(rawTimestamp);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  if (typeof rawTimestamp === "number" && Number.isFinite(rawTimestamp)) {
+    return rawTimestamp;
+  }
+  return null;
+}
+async function getSessionStats(sessionId) {
+  if (sessionStatsCache.has(sessionId)) {
+    return sessionStatsCache.get(sessionId);
+  }
+  const filePath = await findSessionFile(sessionId);
+  if (!filePath) {
+    const empty = {
+      messageCount: 0,
+      startTime: null,
+      endTime: null,
+      fileSizeBytes: null
+    };
+    sessionStatsCache.set(sessionId, empty);
+    return empty;
+  }
+  let fileSizeBytes = null;
+  try {
+    const fileStat = await stat(filePath);
+    fileSizeBytes = fileStat.size;
+  } catch {
+    fileSizeBytes = null;
+  }
+  let messageCount = 0;
+  let startTime = null;
+  let endTime = null;
+  const stream = createReadStream(filePath, { encoding: "utf-8" });
+  const rl = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const msg = JSON.parse(line);
+        if (msg.type !== "user" && msg.type !== "assistant") {
+          continue;
+        }
+        messageCount += 1;
+        const parsed = parseMessageTimestamp(msg.timestamp);
+        if (parsed !== null) {
+          startTime = startTime === null ? parsed : Math.min(startTime, parsed);
+          endTime = endTime === null ? parsed : Math.max(endTime, parsed);
+        }
+      } catch {
+        continue;
+      }
+    }
+  } finally {
+    rl.close();
+    stream.close();
+  }
+  const stats = {
+    messageCount,
+    startTime,
+    endTime,
+    fileSizeBytes
+  };
+  sessionStatsCache.set(sessionId, stats);
+  return stats;
+}
+async function readLastNonEmptyLine(filePath) {
+  try {
+    const fileStat = await stat(filePath);
+    const fileSize = fileStat.size;
+    if (fileSize === 0) {
+      return null;
+    }
+    const chunkSize = Math.min(8192, fileSize);
+    const start = Math.max(0, fileSize - chunkSize);
+    const fileHandle = await open(filePath, "r");
+    try {
+      const buffer = Buffer.alloc(chunkSize);
+      await fileHandle.read(buffer, 0, chunkSize, start);
+      const text = buffer.toString("utf-8");
+      const lines = text.split("\n").filter((line) => line.trim().length > 0);
+      if (lines.length === 0) {
+        return null;
+      }
+      return lines[lines.length - 1] ?? null;
+    } finally {
+      await fileHandle.close();
+    }
+  } catch {
+    return null;
+  }
+}
+async function getSessionSummary(sessionId) {
+  if (summaryCache.has(sessionId)) {
+    return summaryCache.get(sessionId) ?? null;
+  }
+  const filePath = await findSessionFile(sessionId);
+  if (!filePath) {
+    summaryCache.set(sessionId, null);
+    return null;
+  }
+  const lastLine = await readLastNonEmptyLine(filePath);
+  if (!lastLine) {
+    summaryCache.set(sessionId, null);
+    return null;
+  }
+  try {
+    const msg = JSON.parse(lastLine);
+    if (msg.type === "summary" && typeof msg.summary === "string" && msg.summary.trim().length > 0) {
+      summaryCache.set(sessionId, msg.summary);
+      return msg.summary;
+    }
+  } catch {
+  }
+  summaryCache.set(sessionId, null);
+  return null;
 }
 function encodeProjectPath(path) {
   return path.replace(/[/.]/g, "-");
@@ -316,12 +444,18 @@ async function getSessions() {
         continue;
       }
       seenIds.add(sessionId);
+      const summary = await getSessionSummary(sessionId);
+      const stats = await getSessionStats(sessionId);
       sessions.push({
         id: sessionId,
-        display: entry.display,
+        display: summary ?? entry.display,
         timestamp: entry.timestamp,
         project: entry.project,
-        projectName: getProjectName(entry.project)
+        projectName: getProjectName(entry.project),
+        messageCount: stats.messageCount,
+        startTime: stats.startTime,
+        endTime: stats.endTime,
+        fileSizeBytes: stats.fileSizeBytes
       });
     }
     return sessions.sort((a, b) => b.timestamp - a.timestamp);
@@ -369,6 +503,8 @@ async function deleteSession(sessionId) {
     console.log(`[deleteSession] No file found for session: ${sessionId}`);
   }
   fileIndex.delete(sessionId);
+  summaryCache.delete(sessionId);
+  sessionStatsCache.delete(sessionId);
   const historyPath = join(claudeDir, "history.jsonl");
   let historyChanged = false;
   try {
@@ -405,6 +541,87 @@ async function deleteSession(sessionId) {
   }
   return fileDeleted || historyChanged;
 }
+async function getSessionFilePath(sessionId) {
+  return findSessionFile(sessionId);
+}
+async function renameSessionDisplay(params) {
+  const { sessionId, display, project, timestamp } = params;
+  const historyPath = join(claudeDir, "history.jsonl");
+  let changed = false;
+  let summaryChanged = false;
+  try {
+    const content = await readFile(historyPath, "utf-8");
+    const lines = content.split("\n");
+    const updated = [];
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const entry = JSON.parse(line);
+        const matchesId = entry.sessionId && entry.sessionId === sessionId;
+        const matchesFallback = !entry.sessionId && project && typeof timestamp === "number" && entry.project === project && entry.timestamp === timestamp;
+        if (matchesId || matchesFallback) {
+          if (entry.display !== display) {
+            entry.display = display;
+            changed = true;
+          }
+        }
+        updated.push(JSON.stringify(entry));
+      } catch {
+        updated.push(line);
+      }
+    }
+    if (changed) {
+      await writeFile(historyPath, updated.join("\n") + "\n", "utf-8");
+      if (historyCache) {
+        historyCache = historyCache.map((entry) => {
+          const matchesId = entry.sessionId && entry.sessionId === sessionId;
+          const matchesFallback = !entry.sessionId && project && typeof timestamp === "number" && entry.project === project && entry.timestamp === timestamp;
+          if (matchesId || matchesFallback) {
+            return { ...entry, display };
+          }
+          return entry;
+        });
+      }
+    }
+  } catch (err) {
+    console.error(`[renameSessionDisplay] Failed to update history.jsonl for ${sessionId}:`, err);
+    return false;
+  }
+  const sessionFile = await findSessionFile(sessionId);
+  if (sessionFile) {
+    try {
+      const content = await readFile(sessionFile, "utf-8");
+      const lines = content.split("\n");
+      let summaryUpdated = false;
+      const updatedLines = lines.map((line) => {
+        if (!line.trim()) {
+          return line;
+        }
+        try {
+          const msg = JSON.parse(line);
+          if (msg.type === "summary") {
+            msg.summary = display;
+            summaryUpdated = true;
+            return JSON.stringify(msg);
+          }
+        } catch {
+        }
+        return line;
+      });
+      if (!summaryUpdated) {
+        updatedLines.push(JSON.stringify({ type: "summary", summary: display }));
+      }
+      await writeFile(sessionFile, updatedLines.join("\n") + "\n", "utf-8");
+      summaryCache.set(sessionId, display);
+      summaryChanged = true;
+    } catch (err) {
+      console.error(`[renameSessionDisplay] Failed to update session file for ${sessionId}:`, err);
+    }
+  }
+  return changed || summaryChanged;
+}
 async function getConversation(sessionId) {
   return dedupe(`getConversation:${sessionId}`, async () => {
     const filePath = await findSessionFile(sessionId);
@@ -771,6 +988,37 @@ function createServer(options) {
     console.log(`[/api/sessions/delete] Failed:`, failed);
     return c.json({ deleted, failed });
   });
+  app.post("/api/sessions/rename", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    const id = body?.id?.trim();
+    const display = body?.display?.trim();
+    if (!id || !display) {
+      return c.json({ error: "Missing id/display" }, 400);
+    }
+    const ok = await renameSessionDisplay({
+      sessionId: id,
+      display,
+      project: body.project,
+      timestamp: body.timestamp
+    });
+    if (!ok) {
+      return c.json({ error: "Session not found" }, 404);
+    }
+    return c.json({ ok: true });
+  });
+  app.get("/api/sessions/:id/path", async (c) => {
+    const sessionId = c.req.param("id");
+    if (!sessionId) {
+      return c.json({ error: "Missing session id" }, 400);
+    }
+    const path = await getSessionFilePath(sessionId);
+    return c.json({ path });
+  });
   app.post("/api/search", async (c) => {
     let body;
     try {
@@ -929,6 +1177,7 @@ function createServer(options) {
   });
   onSessionChange((sessionId, filePath) => {
     addToFileIndex(sessionId, filePath);
+    invalidateSessionStats(sessionId);
   });
   startWatcher();
   let httpServer = null;