@teddysc/claude-run 0.11.0 → 0.12.0

package/README.md

@@ -30,8 +30,17 @@ 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
@@ -87,10 +96,11 @@ 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

package/dist/index.js

@@ -88,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) {
@@ -102,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, "-");
@@ -316,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)
@@ -369,6 +423,7 @@ async function deleteSession(sessionId) {
     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 {
@@ -405,6 +460,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 +907,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 {