claude-ps 0.2.5 → 0.2.6

package/dist/{chunk-RZG4BATR.js → chunk-JYWGOPVM.js}

@@ -1,9 +1,105 @@
 #!/usr/bin/env node
 
 // src/utils/session.ts
-import { readFile, readdir } from "fs/promises";
+import { readFile as readFile2, readdir, stat as stat2 } from "fs/promises";
 import { homedir } from "os";
 import { join } from "path";
+import pLimit from "p-limit";
+
+// src/utils/cache.ts
+import { readFile, stat } from "fs/promises";
+var FileCache = class {
+  cache = /* @__PURE__ */ new Map();
+  maxSize;
+  ttl;
+  loader;
+  constructor(options) {
+    this.maxSize = options.maxSize ?? 50;
+    this.ttl = options.ttl ?? 5 * 60 * 1e3;
+    this.loader = options.loader;
+  }
+  /**
+   * 获取文件内容（优先从缓存读取）
+   * @param path 文件路径
+   * @returns 文件内容
+   */
+  async get(path) {
+    try {
+      const stats = await stat(path);
+      const currentMtime = stats.mtimeMs;
+      const cached = this.cache.get(path);
+      const now = Date.now();
+      if (cached && cached.mtimeMs === currentMtime && now - cached.cachedAt < this.ttl) {
+        this.cache.delete(path);
+        this.cache.set(path, cached);
+        return cached.data;
+      }
+      const data = await this.loader(path);
+      this.cache.set(path, {
+        data,
+        mtimeMs: currentMtime,
+        cachedAt: now
+      });
+      this.cleanup();
+      return data;
+    } catch {
+      return this.loader(path).catch(() => {
+        throw new Error(`Failed to load file: ${path}`);
+      });
+    }
+  }
+  /**
+   * 清理过期和超出大小限制的缓存
+   */
+  cleanup() {
+    const now = Date.now();
+    const entries = Array.from(this.cache.entries());
+    for (const [key, entry] of entries) {
+      if (now - entry.cachedAt >= this.ttl) {
+        this.cache.delete(key);
+      }
+    }
+    while (this.cache.size > this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * 清除指定文件的缓存
+   * @param path 文件路径
+   */
+  clear(path) {
+    this.cache.delete(path);
+  }
+  /**
+   * 清除所有缓存
+   */
+  clearAll() {
+    this.cache.clear();
+  }
+  /**
+   * 获取缓存大小
+   */
+  get size() {
+    return this.cache.size;
+  }
+};
+
+// src/utils/session.ts
+var statLimit = pLimit(10);
+var sessionContentCache = new FileCache({
+  maxSize: 50,
+  ttl: 5 * 60 * 1e3,
+  // 5 分钟
+  loader: async (path) => {
+    return readFile2(path, "utf-8");
+  }
+});
+var MAX_MESSAGES = 100;
 function cwdToProjectDir(cwd) {
   return cwd.replace(/\//g, "-").replace(/^-/, "-");
 }
@@ -20,18 +116,19 @@ async function getSessionPath(cwd, startTime) {
       console.error(`[DEBUG] found ${jsonlFiles.length} jsonl files`);
     }
     if (jsonlFiles.length === 0) return "";
-    const { stat } = await import("fs/promises");
     const fileStats = await Promise.all(
-      jsonlFiles.map(async (f) => {
-        const path = join(sessionsDir, f);
-        const s = await stat(path);
-        return {
-          path,
-          birthtime: s.birthtime,
-          mtimeMs: s.mtimeMs,
-          size: s.size
-        };
-      })
+      jsonlFiles.map(
+        (f) => statLimit(async () => {
+          const path = join(sessionsDir, f);
+          const s = await stat2(path);
+          return {
+            path,
+            birthtime: s.birthtime,
+            mtimeMs: s.mtimeMs,
+            size: s.size
+          };
+        })
+      )
     );
     if (process.env.DEBUG_SESSION) {
       console.error(`[DEBUG] total files: ${fileStats.length}`);
@@ -62,7 +159,9 @@ async function getSessionPath(cwd, startTime) {
       const mtimeMatched = fileStats.filter((f) => {
         const mtimeDiff = f.mtimeMs - startMs;
         return Math.abs(mtimeDiff) < mtimeThreshold;
-      }).sort((a, b) => Math.abs(a.mtimeMs - startMs) - Math.abs(b.mtimeMs - startMs));
+      }).sort(
+        (a, b) => Math.abs(a.mtimeMs - startMs) - Math.abs(b.mtimeMs - startMs)
+      );
       if (mtimeMatched.length > 0) {
         if (process.env.DEBUG_SESSION) {
           console.error(`[DEBUG] matched by mtime: ${mtimeMatched[0].path}`);
@@ -82,7 +181,7 @@ async function getSessionPath(cwd, startTime) {
 async function getRecentMessages(sessionPath, limit = 5) {
   if (!sessionPath) return [];
   try {
-    const content = await readFile(sessionPath, "utf-8");
+    const content = await readFile2(sessionPath, "utf-8");
     const lines = content.trim().split("\n");
     const messages = [];
     for (const line of lines) {
@@ -118,7 +217,7 @@ async function getRecentMessages(sessionPath, limit = 5) {
 async function getNewMessages(sessionPath, fromLine) {
   if (!sessionPath) return { messages: [], totalLines: 0 };
   try {
-    const content = await readFile(sessionPath, "utf-8");
+    const content = await sessionContentCache.get(sessionPath);
     const lines = content.trim().split("\n");
     const totalLines = lines.length;
     const newLines = lines.slice(fromLine);
@@ -154,9 +253,9 @@ async function getNewMessages(sessionPath, fromLine) {
   }
 }
 async function getAllMessages(sessionPath) {
-  if (!sessionPath) return [];
+  if (!sessionPath) return { messages: [], lineCount: 0 };
   try {
-    const content = await readFile(sessionPath, "utf-8");
+    const content = await sessionContentCache.get(sessionPath);
     const lines = content.trim().split("\n");
     const messages = [];
     for (const line of lines) {
@@ -184,9 +283,10 @@ async function getAllMessages(sessionPath) {
       } catch {
       }
     }
-    return messages;
+    const limitedMessages = messages.length > MAX_MESSAGES ? messages.slice(-MAX_MESSAGES) : messages;
+    return { messages: limitedMessages, lineCount: lines.length };
   } catch {
-    return [];
+    return { messages: [], lineCount: 0 };
   }
 }
 function extractUserText(content) {
@@ -222,6 +322,12 @@ function formatTimeDiff(date, referenceDate) {
   const diffMin = diffSec / 60;
   return diffMs >= 0 ? `\u542F\u52A8\u540E ${diffMin.toFixed(1)} \u5206\u949F` : `\u542F\u52A8\u524D ${diffMin.toFixed(1)} \u5206\u949F`;
 }
+function clearSessionCache(sessionPath) {
+  sessionContentCache.clear(sessionPath);
+}
+function clearAllSessionCache() {
+  sessionContentCache.clearAll();
+}
 async function debugSessionMatching(processes) {
   const output = [];
   output.push("=== Claude Code \u4F1A\u8BDD\u8C03\u8BD5\u4FE1\u606F ===\n");
@@ -249,19 +355,20 @@ async function debugSessionMatching(processes) {
         continue;
       }
       output.push("  \u627E\u5230\u7684\u4F1A\u8BDD\u6587\u4EF6:");
-      const { stat } = await import("fs/promises");
       const fileStats = await Promise.all(
-        jsonlFiles.map(async (f) => {
-          const path = join(sessionsDir, f);
-          const s = await stat(path);
-          return {
-            name: f,
-            path,
-            birthtime: s.birthtime,
-            mtime: new Date(s.mtimeMs),
-            size: s.size
-          };
-        })
+        jsonlFiles.map(
+          (f) => statLimit(async () => {
+            const path = join(sessionsDir, f);
+            const s = await stat2(path);
+            return {
+              name: f,
+              path,
+              birthtime: s.birthtime,
+              mtime: new Date(s.mtimeMs),
+              size: s.size
+            };
+          })
+        )
       );
       for (const file of fileStats) {
         const ignored = file.size < 1024;
@@ -316,7 +423,7 @@ async function debugSessionMatching(processes) {
       if (matchedFile) {
         output.push(`    \u9009\u62E9: ${matchedFile.name}`);
         try {
-          const messages = await getAllMessages(matchedFile.path);
+          const { messages } = await getAllMessages(matchedFile.path);
           output.push(`    \u6D88\u606F\u6570: ${messages.length} \u6761`);
           successCount++;
         } catch {
@@ -347,5 +454,7 @@ export {
   getRecentMessages,
   getNewMessages,
   getAllMessages,
+  clearSessionCache,
+  clearAllSessionCache,
   debugSessionMatching
 };

package/dist/chunk-KF2FBZRQ.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+// src/utils/process.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import pLimit from "p-limit";
+var execAsync = promisify(exec);
+var processLimit = pLimit(8);
+async function getCurrentTty() {
+  try {
+    const { stdout } = await execAsync("tty");
+    return stdout.trim().replace("/dev/", "");
+  } catch {
+    return "";
+  }
+}
+async function batchGetProcessCwd(pids) {
+  if (pids.length === 0) return /* @__PURE__ */ new Map();
+  return processLimit(async () => {
+    try {
+      const pidList = pids.join(",");
+      const { stdout } = await execAsync(
+        `lsof -p ${pidList} 2>/dev/null | grep cwd`
+      );
+      const result = /* @__PURE__ */ new Map();
+      const lines = stdout.trim().split("\n");
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 9) {
+          const pid = Number.parseInt(parts[1], 10);
+          const cwd = parts[8];
+          if (cwd.startsWith("/")) {
+            result.set(pid, cwd);
+          }
+        }
+      }
+      return result;
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  });
+}
+async function batchGetProcessStats(pids) {
+  if (pids.length === 0) return /* @__PURE__ */ new Map();
+  return processLimit(async () => {
+    try {
+      const pidList = pids.join(",");
+      const { stdout } = await execAsync(
+        `ps -p ${pidList} -o pid,%cpu,%mem,etime 2>/dev/null`
+      );
+      const result = /* @__PURE__ */ new Map();
+      const lines = stdout.trim().split("\n");
+      for (let i = 1; i < lines.length; i++) {
+        const parts = lines[i].trim().split(/\s+/);
+        if (parts.length >= 4) {
+          const pid = Number.parseInt(parts[0], 10);
+          result.set(pid, {
+            cpu: Number.parseFloat(parts[1]) || 0,
+            memory: Number.parseFloat(parts[2]) || 0,
+            elapsed: parts[3] || ""
+          });
+        }
+      }
+      return result;
+    } catch {
+      return /* @__PURE__ */ new Map();
+    }
+  });
+}
+function parseElapsedToDate(elapsed) {
+  const now = /* @__PURE__ */ new Date();
+  const parts = elapsed.split(/[-:]/);
+  let seconds = 0;
+  if (parts.length === 2) {
+    seconds = Number.parseInt(parts[0]) * 60 + Number.parseInt(parts[1]);
+  } else if (parts.length === 3) {
+    seconds = Number.parseInt(parts[0]) * 3600 + Number.parseInt(parts[1]) * 60 + Number.parseInt(parts[2]);
+  } else if (parts.length === 4) {
+    seconds = Number.parseInt(parts[0]) * 86400 + Number.parseInt(parts[1]) * 3600 + Number.parseInt(parts[2]) * 60 + Number.parseInt(parts[3]);
+  }
+  return new Date(now.getTime() - seconds * 1e3);
+}
+async function getClaudeProcesses() {
+  const currentTty = await getCurrentTty();
+  let stdout;
+  try {
+    const result = await execAsync(
+      `ps -eo pid,tty,command | grep -E '^\\s*[0-9]+\\s+\\S+\\s+claude(\\s|$)' | grep -v 'chrome-native-host' | grep -v grep`
+    );
+    stdout = result.stdout;
+  } catch {
+    return [];
+  }
+  const lines = stdout.trim().split("\n").filter(Boolean);
+  if (lines.length === 0) return [];
+  const basicInfo = [];
+  for (const line of lines) {
+    const match = line.trim().match(/^(\d+)\s+(\S+)\s+(.+)$/);
+    if (match) {
+      basicInfo.push({
+        pid: Number.parseInt(match[1]),
+        tty: match[2]
+      });
+    }
+  }
+  if (basicInfo.length === 0) return [];
+  const pids = basicInfo.map((p) => p.pid);
+  const [cwdMap, statsMap] = await Promise.all([
+    batchGetProcessCwd(pids),
+    batchGetProcessStats(pids)
+  ]);
+  const processes = [];
+  for (const info of basicInfo) {
+    const cwd = cwdMap.get(info.pid) || "\u672A\u77E5";
+    const stats = statsMap.get(info.pid) || {
+      cpu: 0,
+      memory: 0,
+      elapsed: ""
+    };
+    const isOrphan = info.tty === "??" || info.tty === "?";
+    const isCurrent = currentTty !== "" && info.tty === currentTty;
+    processes.push({
+      pid: info.pid,
+      tty: info.tty,
+      cwd,
+      isCurrent,
+      isOrphan,
+      cpu: stats.cpu,
+      memory: stats.memory,
+      elapsed: stats.elapsed,
+      startTime: parseElapsedToDate(stats.elapsed),
+      sessionPath: ""
+    });
+  }
+  return processes;
+}
+async function killProcess(pid, force = false) {
+  try {
+    const signal = force ? "KILL" : "TERM";
+    await execAsync(`kill -${signal} ${pid}`);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  getClaudeProcesses,
+  killProcess
+};

package/dist/index.js

@@ -2,12 +2,13 @@
 import {
   getClaudeProcesses,
   killProcess
-} from "./chunk-EZHIVMX4.js";
+} from "./chunk-KF2FBZRQ.js";
 import {
+  clearSessionCache,
   getAllMessages,
   getNewMessages,
   getSessionPath
-} from "./chunk-RZG4BATR.js";
+} from "./chunk-JYWGOPVM.js";
 
 // src/index.tsx
 import { withFullScreen } from "fullscreen-ink";
@@ -308,6 +309,7 @@ function ProcessList({
 }
 
 // src/hooks/useProcesses.ts
+import pLimit from "p-limit";
 import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState } from "react";
 
 // src/hooks/useSessionWatcher.ts
@@ -330,6 +332,7 @@ function useSessionWatcher(sessionPaths, onFileChange) {
       }
     });
     watcher.on("change", (path) => {
+      clearSessionCache(path);
       const existingTimer = debounceTimersRef.current.get(path);
       if (existingTimer) {
         clearTimeout(existingTimer);
@@ -355,6 +358,7 @@ function useSessionWatcher(sessionPaths, onFileChange) {
 }
 
 // src/hooks/useProcesses.ts
+var sessionLimit = pLimit(5);
 function sortProcesses(processes, sortField) {
   const sorted = [...processes];
   switch (sortField) {
@@ -383,22 +387,20 @@ function useProcesses(interval2) {
     try {
       const procs = await getClaudeProcesses();
       const enriched = await Promise.all(
-        procs.map(async (proc) => {
-          const sessionPath = await getSessionPath(proc.cwd, proc.startTime);
-          const messages = await getAllMessages(sessionPath);
-          if (sessionPath && !sessionLineNumbers.current.has(sessionPath)) {
-            const content = await import("fs/promises").then(
-              (m) => m.readFile(sessionPath, "utf-8").catch(() => "")
-            );
-            const lines = content.trim().split("\n");
-            sessionLineNumbers.current.set(sessionPath, lines.length);
-          }
-          return {
-            ...proc,
-            sessionPath,
-            messages
-          };
-        })
+        procs.map(
+          (proc) => sessionLimit(async () => {
+            const sessionPath = await getSessionPath(proc.cwd, proc.startTime);
+            const { messages, lineCount } = await getAllMessages(sessionPath);
+            if (sessionPath && !sessionLineNumbers.current.has(sessionPath)) {
+              sessionLineNumbers.current.set(sessionPath, lineCount);
+            }
+            return {
+              ...proc,
+              sessionPath,
+              messages
+            };
+          })
+        )
       );
       setRawProcesses(enriched);
       setError(null);
@@ -660,10 +662,10 @@ var cli = meow(
 );
 var { list, json, debug, interval } = cli.flags;
 if (list || json || debug) {
-  const { getClaudeProcesses: getClaudeProcesses2 } = await import("./process-AUO5UVTV.js");
+  const { getClaudeProcesses: getClaudeProcesses2 } = await import("./process-XJGJPUAG.js");
   const processes = await getClaudeProcesses2();
   if (debug) {
-    const { debugSessionMatching } = await import("./session-TGVDWUTY.js");
+    const { debugSessionMatching } = await import("./session-FTYMYOIH.js");
     const debugInfo = await debugSessionMatching(processes);
     console.log(debugInfo);
   } else if (json) {

package/dist/{process-AUO5UVTV.js → process-XJGJPUAG.js}

@@ -2,7 +2,7 @@
 import {
   getClaudeProcesses,
   killProcess
-} from "./chunk-EZHIVMX4.js";
+} from "./chunk-KF2FBZRQ.js";
 export {
   getClaudeProcesses,
   killProcess

package/dist/{session-TGVDWUTY.js → session-FTYMYOIH.js}

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
 import {
+  clearAllSessionCache,
+  clearSessionCache,
   debugSessionMatching,
   getAllMessages,
   getNewMessages,
   getRecentMessages,
   getSessionPath
-} from "./chunk-RZG4BATR.js";
+} from "./chunk-JYWGOPVM.js";
 export {
+  clearAllSessionCache,
+  clearSessionCache,
   debugSessionMatching,
   getAllMessages,
   getNewMessages,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-ps",
-	"version": "0.2.5",
+	"version": "0.2.6",
 	"description": "TUI application for viewing and managing Claude Code processes",
 	"type": "module",
 	"main": "dist/index.js",
@@ -33,6 +33,7 @@
 		"fullscreen-ink": "^0.1.0",
 		"ink": "^5.0.1",
 		"meow": "^13.2.0",
+		"p-limit": "^7.3.0",
 		"react": "^18.3.1"
 	},
 	"devDependencies": {

package/dist/chunk-EZHIVMX4.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-
-// src/utils/process.ts
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-async function getCurrentTty() {
-  try {
-    const { stdout } = await execAsync("tty");
-    return stdout.trim().replace("/dev/", "");
-  } catch {
-    return "";
-  }
-}
-async function getProcessCwd(pid) {
-  try {
-    const { stdout } = await execAsync(`lsof -p ${pid} 2>/dev/null | grep cwd`);
-    const match = stdout.trim().match(/\s(\/.+)$/);
-    return match ? match[1] : "";
-  } catch {
-    return "";
-  }
-}
-async function getProcessStats(pid) {
-  try {
-    const { stdout } = await execAsync(
-      `ps -p ${pid} -o %cpu,%mem,etime 2>/dev/null`
-    );
-    const lines = stdout.trim().split("\n");
-    if (lines.length < 2) return { cpu: 0, memory: 0, elapsed: "" };
-    const parts = lines[1].trim().split(/\s+/);
-    return {
-      cpu: Number.parseFloat(parts[0]) || 0,
-      memory: Number.parseFloat(parts[1]) || 0,
-      elapsed: parts[2] || ""
-    };
-  } catch {
-    return { cpu: 0, memory: 0, elapsed: "" };
-  }
-}
-function parseElapsedToDate(elapsed) {
-  const now = /* @__PURE__ */ new Date();
-  const parts = elapsed.split(/[-:]/);
-  let seconds = 0;
-  if (parts.length === 2) {
-    seconds = Number.parseInt(parts[0]) * 60 + Number.parseInt(parts[1]);
-  } else if (parts.length === 3) {
-    seconds = Number.parseInt(parts[0]) * 3600 + Number.parseInt(parts[1]) * 60 + Number.parseInt(parts[2]);
-  } else if (parts.length === 4) {
-    seconds = Number.parseInt(parts[0]) * 86400 + Number.parseInt(parts[1]) * 3600 + Number.parseInt(parts[2]) * 60 + Number.parseInt(parts[3]);
-  }
-  return new Date(now.getTime() - seconds * 1e3);
-}
-async function getClaudeProcesses() {
-  const currentTty = await getCurrentTty();
-  let stdout;
-  try {
-    const result = await execAsync(
-      `ps -eo pid,tty,command | grep -E '^\\s*[0-9]+\\s+\\S+\\s+claude(\\s|$)' | grep -v 'chrome-native-host' | grep -v grep`
-    );
-    stdout = result.stdout;
-  } catch {
-    return [];
-  }
-  const lines = stdout.trim().split("\n").filter(Boolean);
-  const processes = [];
-  for (const line of lines) {
-    const match = line.trim().match(/^(\d+)\s+(\S+)\s+(.+)$/);
-    if (!match) continue;
-    const pid = Number.parseInt(match[1]);
-    const tty = match[2];
-    const [cwd, stats] = await Promise.all([
-      getProcessCwd(pid),
-      getProcessStats(pid)
-    ]);
-    const isOrphan = tty === "??" || tty === "?";
-    const isCurrent = currentTty !== "" && tty === currentTty;
-    processes.push({
-      pid,
-      tty,
-      cwd: cwd || "\u672A\u77E5",
-      isCurrent,
-      isOrphan,
-      cpu: stats.cpu,
-      memory: stats.memory,
-      elapsed: stats.elapsed,
-      startTime: parseElapsedToDate(stats.elapsed),
-      sessionPath: ""
-    });
-  }
-  return processes;
-}
-async function killProcess(pid, force = false) {
-  try {
-    const signal = force ? "KILL" : "TERM";
-    await execAsync(`kill -${signal} ${pid}`);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export {
-  getClaudeProcesses,
-  killProcess
-};