@teddysc/claude-run 0.10.1 → 0.12.0

package/README.md

@@ -30,8 +30,26 @@ bun install -g @teddysc/claude-run@latest
 
 The browser will open automatically at http://localhost:12001.
 
+## Specifications
+
+See [spec.md](spec.md)
+
 ## Changelog
 
+### 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
+- Add "Hide Unknown model" filter to hide sessions without detected models
+- Add "Delete Unknown" button to remove blank/orphaned sessions from disk
+- Automatic cleanup of orphaned history entries on startup
+- Add comprehensive logging for delete operations
+- Fix URL state sync when unchecking checkboxes
+
 ### 0.10.0
 - Enhance message handling: add message ID to ConversationMessage
 - Normalize content blocks in message processing
@@ -78,12 +96,15 @@ 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
+- **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
+- **Filter & cleanup** - Hide Unknown-model sessions and delete blank sessions from disk
 
 ## Usage
 

package/dist/index.js

@@ -11,7 +11,8 @@ import { streamSSE } from "hono/streaming";
 import { serve } from "@hono/node-server";
 
 // api/storage.ts
-import { readdir, readFile, stat, open } from "fs/promises";
+import { readdir, readFile, stat, open, unlink, writeFile } from "fs/promises";
+import { createReadStream } from "fs";
 import { join, basename } from "path";
 import { homedir } from "os";
 import { createInterface } from "readline";
@@ -87,6 +88,7 @@ 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 historyCache = null;
 var pendingRequests = /* @__PURE__ */ new Map();
 function initStorage(dir) {
@@ -101,6 +103,58 @@ function invalidateHistoryCache() {
 }
 function addToFileIndex(sessionId, filePath) {
   fileIndex.set(sessionId, filePath);
+  summaryCache.delete(sessionId);
+}
+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, "-");
@@ -220,8 +274,85 @@ async function findSessionFile(sessionId) {
   }
   return null;
 }
+async function getSessionModel(sessionId) {
+  const filePath = await findSessionFile(sessionId);
+  if (!filePath) {
+    return 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;
+        }
+        const model = msg.message?.model;
+        if (model) {
+          return model;
+        }
+      } catch {
+        continue;
+      }
+    }
+  } finally {
+    rl.close();
+    stream.close();
+  }
+  return null;
+}
 async function loadStorage() {
   await Promise.all([buildFileIndex(), loadHistoryCache()]);
+  await cleanupOrphanedHistoryEntries();
+}
+async function cleanupOrphanedHistoryEntries() {
+  const history = historyCache ?? await loadHistoryCache();
+  const orphanedIds = [];
+  for (const entry of history) {
+    if (entry.sessionId && !await findSessionFile(entry.sessionId)) {
+      orphanedIds.push(entry.sessionId);
+    }
+  }
+  if (orphanedIds.length === 0) {
+    return;
+  }
+  console.log(
+    `[cleanup] Found ${orphanedIds.length} orphaned history entries, cleaning up...`
+  );
+  const historyPath = join(claudeDir, "history.jsonl");
+  const orphanedSet = new Set(orphanedIds);
+  try {
+    const content = await readFile(historyPath, "utf-8");
+    const lines = content.split("\n");
+    const filtered = [];
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.sessionId && orphanedSet.has(entry.sessionId)) {
+          continue;
+        }
+      } catch {
+      }
+      filtered.push(line);
+    }
+    await writeFile(historyPath, filtered.join("\n") + "\n", "utf-8");
+    if (historyCache) {
+      historyCache = historyCache.filter(
+        (entry) => !(entry.sessionId && orphanedSet.has(entry.sessionId))
+      );
+    }
+    for (const id of orphanedIds) {
+      fileIndex.delete(id);
+    }
+    console.log(`[cleanup] Removed ${orphanedIds.length} orphaned entries`);
+  } catch (err) {
+    console.error("[cleanup] Failed to clean up orphaned entries:", err);
+  }
 }
 async function getSessions() {
   return dedupe("getSessions", async () => {
@@ -238,9 +369,10 @@ async function getSessions() {
         continue;
       }
       seenIds.add(sessionId);
+      const summary = await getSessionSummary(sessionId);
       sessions.push({
         id: sessionId,
-        display: entry.display,
+        display: summary ?? entry.display,
         timestamp: entry.timestamp,
         project: entry.project,
         projectName: getProjectName(entry.project)
@@ -259,6 +391,156 @@ async function getProjects() {
   }
   return [...projects].sort();
 }
+async function getSessionsMetadata(ids) {
+  const unique = Array.from(new Set(ids.filter(Boolean)));
+  return Promise.all(
+    unique.map(async (id) => ({
+      id,
+      model: await getSessionModel(id)
+    }))
+  );
+}
+async function deleteSession(sessionId) {
+  console.log(`[deleteSession] Attempting to delete: ${sessionId}`);
+  const filePath = await findSessionFile(sessionId);
+  let fileDeleted = false;
+  if (filePath) {
+    console.log(`[deleteSession] Found file: ${filePath}`);
+    try {
+      await unlink(filePath);
+      console.log(`[deleteSession] Successfully deleted: ${filePath}`);
+      fileDeleted = true;
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        console.log(`[deleteSession] File already deleted: ${filePath}`);
+        fileDeleted = true;
+      } else {
+        console.error(`[deleteSession] Failed to delete ${filePath}:`, err);
+        return false;
+      }
+    }
+  } else {
+    console.log(`[deleteSession] No file found for session: ${sessionId}`);
+  }
+  fileIndex.delete(sessionId);
+  summaryCache.delete(sessionId);
+  const historyPath = join(claudeDir, "history.jsonl");
+  let historyChanged = false;
+  try {
+    const content = await readFile(historyPath, "utf-8");
+    const lines = content.split("\n");
+    const filtered = [];
+    let changed = false;
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const entry = JSON.parse(line);
+        if (entry.sessionId && entry.sessionId === sessionId) {
+          changed = true;
+          continue;
+        }
+      } catch {
+      }
+      filtered.push(line);
+    }
+    if (changed) {
+      await writeFile(historyPath, filtered.join("\n") + "\n", "utf-8");
+      console.log(`[deleteSession] Removed from history.jsonl: ${sessionId}`);
+      if (historyCache) {
+        historyCache = historyCache.filter(
+          (entry) => entry.sessionId !== sessionId
+        );
+      }
+      historyChanged = true;
+    }
+  } catch (err) {
+    console.error(`[deleteSession] Failed to update history.jsonl for ${sessionId}:`, err);
+  }
+  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);
@@ -582,6 +864,80 @@ function createServer(options) {
     const projects = await getProjects();
     return c.json(projects);
   });
+  app.post("/api/sessions/metadata", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (!body || !Array.isArray(body.ids)) {
+      return c.json({ error: "Missing ids" }, 400);
+    }
+    const sessions = await getSessionsMetadata(body.ids);
+    return c.json({ sessions });
+  });
+  app.post("/api/sessions/delete", async (c) => {
+    let body;
+    try {
+      body = await c.req.json();
+    } catch {
+      return c.json({ error: "Invalid JSON body" }, 400);
+    }
+    if (!body || !Array.isArray(body.ids)) {
+      return c.json({ error: "Missing ids" }, 400);
+    }
+    console.log(`[/api/sessions/delete] Received request to delete ${body.ids.length} sessions:`, body.ids);
+    const deleted = [];
+    const failed = [];
+    for (const id of body.ids) {
+      if (typeof id !== "string" || !id) {
+        console.log(`[/api/sessions/delete] Skipping invalid id:`, id);
+        continue;
+      }
+      const ok = await deleteSession(id);
+      if (ok) {
+        deleted.push(id);
+      } else {
+        failed.push(id);
+      }
+    }
+    console.log(`[/api/sessions/delete] Result: ${deleted.length} deleted, ${failed.length} failed`);
+    console.log(`[/api/sessions/delete] Deleted:`, deleted);
+    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 {