@teddysc/claude-run 0.10.1 → 0.11.0

package/README.md

@@ -32,6 +32,15 @@ The browser will open automatically at http://localhost:12001.
 
 ## Changelog
 
+### 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
@@ -81,9 +90,11 @@ The browser will open automatically at http://localhost:12001.
 - **Filter by project** - Focus on specific projects
 - **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
 - **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";
@@ -220,8 +221,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 () => {
@@ -259,6 +337,74 @@ 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);
+  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 getConversation(sessionId) {
   return dedupe(`getConversation:${sessionId}`, async () => {
     const filePath = await findSessionFile(sessionId);
@@ -582,6 +728,49 @@ 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/search", async (c) => {
     let body;
     try {