@teddysc/claude-run 0.9.1 → 0.11.0

package/README.md

@@ -32,6 +32,20 @@ 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
+- Merge sidechain text in getConversation functions
+
 ### 0.9.1
 - Fix favicon response handling
 - Enhance server response handling for static assets
@@ -76,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,10 +11,80 @@ 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";
+function normalizeContentBlocks(content) {
+  if (!content || typeof content === "string") {
+    return [];
+  }
+  return Array.isArray(content) ? content : [content];
+}
+function extractTextBlocks(content) {
+  return normalizeContentBlocks(content).filter(
+    (block) => block.type === "text" && typeof block.text === "string" && block.text.trim().length > 0
+  );
+}
+async function loadSidechainTextByMessageId(filePath) {
+  const map = /* @__PURE__ */ new Map();
+  const sessionDir = filePath.replace(/\.jsonl$/, "");
+  const subagentsDir = join(sessionDir, "subagents");
+  try {
+    const files = await readdir(subagentsDir);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    await Promise.all(
+      jsonlFiles.map(async (file) => {
+        try {
+          const content = await readFile(join(subagentsDir, file), "utf-8");
+          const lines = content.trim().split("\n").filter(Boolean);
+          for (const line of lines) {
+            try {
+              const msg = JSON.parse(line);
+              if (msg.type !== "assistant" || !msg.isSidechain) {
+                continue;
+              }
+              const messageId = msg.message?.id;
+              if (!messageId) {
+                continue;
+              }
+              const textBlocks = extractTextBlocks(msg.message?.content);
+              if (textBlocks.length > 0) {
+                map.set(messageId, textBlocks);
+              }
+            } catch {
+            }
+          }
+        } catch {
+        }
+      })
+    );
+  } catch {
+  }
+  return map;
+}
+function mergeSidechainText(messages, sidechainMap) {
+  if (sidechainMap.size === 0) {
+    return messages;
+  }
+  return messages.map((message) => {
+    if (message.type !== "assistant" || !message.message?.id) {
+      return message;
+    }
+    const sidechainBlocks = sidechainMap.get(message.message.id);
+    if (!sidechainBlocks || sidechainBlocks.length === 0) {
+      return message;
+    }
+    const existingText = extractTextBlocks(message.message.content);
+    if (existingText.length > 0) {
+      return message;
+    }
+    const existingBlocks = normalizeContentBlocks(message.message.content);
+    message.message.content = existingBlocks.length > 0 ? [...existingBlocks, ...sidechainBlocks] : sidechainBlocks;
+    return message;
+  });
+}
 var claudeDir = join(homedir(), ".claude");
 var projectsDir = join(claudeDir, "projects");
 var fileIndex = /* @__PURE__ */ new Map();
@@ -151,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 () => {
@@ -190,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);
@@ -197,6 +412,7 @@ async function getConversation(sessionId) {
       return [];
     }
     const messages = [];
+    const sidechainMap = await loadSidechainTextByMessageId(filePath);
     try {
       const content = await readFile(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
@@ -214,7 +430,7 @@ async function getConversation(sessionId) {
     } catch (err) {
       console.error("Error reading conversation:", err);
     }
-    return messages;
+    return mergeSidechainText(messages, sidechainMap);
   });
 }
 async function getConversationStream(sessionId, fromOffset = 0) {
@@ -223,6 +439,7 @@ async function getConversationStream(sessionId, fromOffset = 0) {
     return { messages: [], nextOffset: 0 };
   }
   const messages = [];
+  const sidechainMap = await loadSidechainTextByMessageId(filePath);
   let fileHandle;
   try {
     const fileStat = await stat(filePath);
@@ -258,7 +475,7 @@ async function getConversationStream(sessionId, fromOffset = 0) {
     }
     const actualOffset = fromOffset + bytesConsumed;
     const nextOffset = actualOffset > fileSize ? fileSize : actualOffset;
-    return { messages, nextOffset };
+    return { messages: mergeSidechainText(messages, sidechainMap), nextOffset };
   } catch (err) {
     console.error("Error reading conversation stream:", err);
     return { messages: [], nextOffset: fromOffset };
@@ -511,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 {