claude-ps 0.2.4 → 0.2.6

package/dist/chunk-JYWGOPVM.js

@@ -0,0 +1,460 @@
+#!/usr/bin/env node
+
+// src/utils/session.ts
+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(/^-/, "-");
+}
+async function getSessionPath(cwd, startTime) {
+  const projectDir = cwdToProjectDir(cwd);
+  const sessionsDir = join(homedir(), ".claude", "projects", projectDir);
+  try {
+    const files = await readdir(sessionsDir);
+    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+    if (process.env.DEBUG_SESSION) {
+      console.error(`[DEBUG] cwd: ${cwd}`);
+      console.error(`[DEBUG] projectDir: ${projectDir}`);
+      console.error(`[DEBUG] sessionsDir: ${sessionsDir}`);
+      console.error(`[DEBUG] found ${jsonlFiles.length} jsonl files`);
+    }
+    if (jsonlFiles.length === 0) return "";
+    const fileStats = await Promise.all(
+      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}`);
+      for (const f of fileStats) {
+        console.error(
+          `[DEBUG]   ${f.path.split("/").pop()}: ${f.size} bytes, birth: ${f.birthtime.toISOString()}, mtime: ${new Date(f.mtimeMs).toISOString()}`
+        );
+      }
+      if (startTime) {
+        console.error(`[DEBUG] startTime: ${startTime.toISOString()}`);
+      }
+    }
+    if (startTime && fileStats.length > 0) {
+      const startMs = startTime.getTime();
+      const birthtimeThreshold = 3e5;
+      const birthtimeMatched = fileStats.filter(
+        (f) => Math.abs(f.birthtime.getTime() - startMs) < birthtimeThreshold
+      ).sort((a, b) => b.mtimeMs - a.mtimeMs);
+      if (birthtimeMatched.length > 0) {
+        if (process.env.DEBUG_SESSION) {
+          console.error(
+            `[DEBUG] matched by birthtime: ${birthtimeMatched[0].path}`
+          );
+        }
+        return birthtimeMatched[0].path;
+      }
+      const mtimeThreshold = 6e5;
+      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)
+      );
+      if (mtimeMatched.length > 0) {
+        if (process.env.DEBUG_SESSION) {
+          console.error(`[DEBUG] matched by mtime: ${mtimeMatched[0].path}`);
+        }
+        return mtimeMatched[0].path;
+      }
+    }
+    fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    if (process.env.DEBUG_SESSION && fileStats[0]) {
+      console.error(`[DEBUG] fallback to latest: ${fileStats[0].path}`);
+    }
+    return fileStats[0]?.path || "";
+  } catch {
+    return "";
+  }
+}
+async function getRecentMessages(sessionPath, limit = 5) {
+  if (!sessionPath) return [];
+  try {
+    const content = await readFile2(sessionPath, "utf-8");
+    const lines = content.trim().split("\n");
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" && entry.message?.content) {
+          const text = extractUserText(entry.message.content);
+          if (text && !isMetaMessage(text)) {
+            messages.push({
+              role: "user",
+              content: truncate(text, 100),
+              timestamp: entry.timestamp || ""
+            });
+          }
+        } else if (entry.type === "assistant" && entry.message?.content) {
+          const text = extractAssistantText(entry.message.content);
+          if (text) {
+            messages.push({
+              role: "assistant",
+              content: truncate(text, 100),
+              timestamp: entry.timestamp || ""
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return messages.slice(-limit);
+  } catch {
+    return [];
+  }
+}
+async function getNewMessages(sessionPath, fromLine) {
+  if (!sessionPath) return { messages: [], totalLines: 0 };
+  try {
+    const content = await sessionContentCache.get(sessionPath);
+    const lines = content.trim().split("\n");
+    const totalLines = lines.length;
+    const newLines = lines.slice(fromLine);
+    const messages = [];
+    for (const line of newLines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" && entry.message?.content) {
+          const text = extractUserText(entry.message.content);
+          if (text && !isMetaMessage(text)) {
+            messages.push({
+              role: "user",
+              content: truncate(text, 100),
+              timestamp: entry.timestamp || ""
+            });
+          }
+        } else if (entry.type === "assistant" && entry.message?.content) {
+          const text = extractAssistantText(entry.message.content);
+          if (text) {
+            messages.push({
+              role: "assistant",
+              content: truncate(text, 100),
+              timestamp: entry.timestamp || ""
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return { messages, totalLines };
+  } catch {
+    return { messages: [], totalLines: 0 };
+  }
+}
+async function getAllMessages(sessionPath) {
+  if (!sessionPath) return { messages: [], lineCount: 0 };
+  try {
+    const content = await sessionContentCache.get(sessionPath);
+    const lines = content.trim().split("\n");
+    const messages = [];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.type === "user" && entry.message?.content) {
+          const text = extractUserText(entry.message.content);
+          if (text && !isMetaMessage(text)) {
+            messages.push({
+              role: "user",
+              content: truncate(text, 100),
+              timestamp: entry.timestamp || ""
+            });
+          }
+        } else if (entry.type === "assistant" && entry.message?.content) {
+          const text = extractAssistantText(entry.message.content);
+          if (text) {
+            messages.push({
+              role: "assistant",
+              content: truncate(text, 100),
+              timestamp: entry.timestamp || ""
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    const limitedMessages = messages.length > MAX_MESSAGES ? messages.slice(-MAX_MESSAGES) : messages;
+    return { messages: limitedMessages, lineCount: lines.length };
+  } catch {
+    return { messages: [], lineCount: 0 };
+  }
+}
+function extractUserText(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  return "";
+}
+function extractAssistantText(content) {
+  if (!Array.isArray(content)) return "";
+  const textParts = content.filter((item) => item.type === "text" && item.text).map((item) => item.text);
+  return textParts.join("\n");
+}
+function isMetaMessage(text) {
+  return text.startsWith("<local-command") || text.startsWith("<command-name>") || text.startsWith("<command-message>");
+}
+function truncate(text, maxLen) {
+  const clean = text.replace(/\s+/g, " ").trim();
+  if (clean.length <= maxLen) return clean;
+  return `${clean.slice(0, maxLen - 3)}...`;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatTimeDiff(date, referenceDate) {
+  const diffMs = date.getTime() - referenceDate.getTime();
+  const diffSec = Math.abs(diffMs / 1e3);
+  if (diffSec < 60) {
+    return diffMs >= 0 ? `\u542F\u52A8\u540E ${diffSec.toFixed(0)} \u79D2` : `\u542F\u52A8\u524D ${diffSec.toFixed(0)} \u79D2`;
+  }
+  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");
+  if (processes.length === 0) {
+    output.push("\u672A\u627E\u5230\u8FD0\u884C\u4E2D\u7684 Claude Code \u8FDB\u7A0B\n");
+    return output.join("\n");
+  }
+  let successCount = 0;
+  for (let i = 0; i < processes.length; i++) {
+    const proc = processes[i];
+    output.push(`\u8FDB\u7A0B #${i + 1} (PID: ${proc.pid})`);
+    output.push(`  \u5DE5\u4F5C\u76EE\u5F55: ${proc.cwd}`);
+    output.push(`  \u542F\u52A8\u65F6\u95F4: ${proc.startTime.toISOString()}`);
+    const projectDir = cwdToProjectDir(proc.cwd);
+    const sessionsDir = join(homedir(), ".claude", "projects", projectDir);
+    output.push(`  \u9879\u76EE\u76EE\u5F55: ${projectDir}`);
+    output.push(`  \u4F1A\u8BDD\u76EE\u5F55: ${sessionsDir}`);
+    output.push("");
+    try {
+      const files = await readdir(sessionsDir);
+      const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
+      if (jsonlFiles.length === 0) {
+        output.push("  \u26A0\uFE0F  \u672A\u627E\u5230\u4F1A\u8BDD\u6587\u4EF6");
+        output.push("");
+        continue;
+      }
+      output.push("  \u627E\u5230\u7684\u4F1A\u8BDD\u6587\u4EF6:");
+      const fileStats = await Promise.all(
+        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;
+        const prefix = ignored ? "    \u2717" : "    \u2713";
+        output.push(`${prefix} ${file.name}`);
+        output.push(`      \u5927\u5C0F: ${formatSize(file.size)}`);
+        if (ignored) {
+          output.push("      (< 1KB, \u5DF2\u5FFD\u7565)");
+        }
+        output.push(
+          `      \u521B\u5EFA: ${file.birthtime.toISOString()} (${formatTimeDiff(file.birthtime, proc.startTime)})`
+        );
+        output.push(
+          `      \u4FEE\u6539: ${file.mtime.toISOString()} (${formatTimeDiff(file.mtime, proc.startTime)})`
+        );
+        output.push("");
+      }
+      const startMs = proc.startTime.getTime();
+      const validFiles = fileStats.filter((f) => f.size >= 1024);
+      let matchedFile = null;
+      let matchStrategy = "";
+      const birthtimeThreshold = 3e5;
+      const birthtimeMatched = validFiles.filter(
+        (f) => Math.abs(f.birthtime.getTime() - startMs) < birthtimeThreshold
+      ).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+      if (birthtimeMatched.length > 0) {
+        matchedFile = birthtimeMatched[0];
+        matchStrategy = "\u521B\u5EFA\u65F6\u95F4\u5339\u914D \u2713";
+      } else {
+        const mtimeThreshold = 6e5;
+        const mtimeMatched = validFiles.filter((f) => {
+          const mtimeDiff = f.mtime.getTime() - startMs;
+          return Math.abs(mtimeDiff) < mtimeThreshold;
+        }).sort(
+          (a, b) => Math.abs(a.mtime.getTime() - startMs) - Math.abs(b.mtime.getTime() - startMs)
+        );
+        if (mtimeMatched.length > 0) {
+          matchedFile = mtimeMatched[0];
+          matchStrategy = "\u4FEE\u6539\u65F6\u95F4\u5339\u914D \u2713";
+        } else {
+          const sorted = [...validFiles].sort(
+            (a, b) => b.mtime.getTime() - a.mtime.getTime()
+          );
+          if (sorted.length > 0) {
+            matchedFile = sorted[0];
+            matchStrategy = "\u56DE\u9000\u5230\u6700\u65B0\u6587\u4EF6";
+          }
+        }
+      }
+      output.push("  \u5339\u914D\u7ED3\u679C:");
+      output.push(`    \u7B56\u7565: ${matchStrategy}`);
+      if (matchedFile) {
+        output.push(`    \u9009\u62E9: ${matchedFile.name}`);
+        try {
+          const { messages } = await getAllMessages(matchedFile.path);
+          output.push(`    \u6D88\u606F\u6570: ${messages.length} \u6761`);
+          successCount++;
+        } catch {
+          output.push("    \u6D88\u606F\u6570: \u8BFB\u53D6\u5931\u8D25");
+        }
+      } else {
+        output.push("    \u9009\u62E9: \u65E0");
+      }
+      output.push("");
+      output.push("---");
+      output.push("");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      output.push(`  \u274C \u9519\u8BEF: ${errorMsg}`);
+      output.push("");
+      output.push("---");
+      output.push("");
+    }
+  }
+  output.push(
+    `\u603B\u8BA1: ${processes.length} \u4E2A\u8FDB\u7A0B, ${successCount} \u4E2A\u6210\u529F\u5339\u914D\u4F1A\u8BDD`
+  );
+  return output.join("\n");
+}
+
+export {
+  getSessionPath,
+  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,7 +2,13 @@
 import {
   getClaudeProcesses,
   killProcess
-} from "./chunk-EZHIVMX4.js";
+} from "./chunk-KF2FBZRQ.js";
+import {
+  clearSessionCache,
+  getAllMessages,
+  getNewMessages,
+  getSessionPath
+} from "./chunk-JYWGOPVM.js";
 
 // src/index.tsx
 import { withFullScreen } from "fullscreen-ink";
@@ -193,7 +199,10 @@ function formatElapsed(elapsed) {
 
 // src/components/ui/DetailPanel.tsx
 import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
-function DetailPanel({ process: proc, isLive = true }) {
+function DetailPanel({
+  process: proc,
+  isLive = true
+}) {
   if (!proc) {
     return /* @__PURE__ */ jsx4(EmptyPrompt, { message: "\u9009\u62E9\u4E00\u4E2A\u8FDB\u7A0B\u67E5\u770B\u8BE6\u60C5" });
   }
@@ -300,159 +309,12 @@ function ProcessList({
 }
 
 // src/hooks/useProcesses.ts
+import pLimit from "p-limit";
 import { useCallback, useEffect as useEffect2, useMemo, useRef as useRef2, useState } from "react";
 
-// src/utils/session.ts
-import { readFile, readdir } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-function cwdToProjectDir(cwd) {
-  return cwd.replace(/\//g, "-").replace(/^-/, "-");
-}
-async function getSessionPath(cwd, startTime) {
-  const projectDir = cwdToProjectDir(cwd);
-  const sessionsDir = join(homedir(), ".claude", "projects", projectDir);
-  try {
-    const files = await readdir(sessionsDir);
-    const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-    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
-        };
-      })
-    );
-    const minSize = 1024;
-    const validFiles = fileStats.filter((f) => f.size >= minSize);
-    if (startTime && validFiles.length > 0) {
-      const startMs = startTime.getTime();
-      const birthtimeThreshold = 1e4;
-      const birthtimeMatched = validFiles.filter(
-        (f) => Math.abs(f.birthtime.getTime() - startMs) < birthtimeThreshold
-      ).sort((a, b) => b.mtimeMs - a.mtimeMs);
-      if (birthtimeMatched.length > 0) {
-        return birthtimeMatched[0].path;
-      }
-      const mtimeThreshold = 6e4;
-      const mtimeMatched = validFiles.filter((f) => {
-        const mtimeDiff = f.mtimeMs - startMs;
-        return mtimeDiff >= 0 && mtimeDiff < mtimeThreshold;
-      }).sort((a, b) => a.mtimeMs - b.mtimeMs);
-      if (mtimeMatched.length > 0) {
-        return mtimeMatched[0].path;
-      }
-    }
-    const fallbackFiles = validFiles.length > 0 ? validFiles : fileStats;
-    fallbackFiles.sort((a, b) => b.mtimeMs - a.mtimeMs);
-    return fallbackFiles[0]?.path || "";
-  } catch {
-    return "";
-  }
-}
-async function getNewMessages(sessionPath, fromLine) {
-  if (!sessionPath) return { messages: [], totalLines: 0 };
-  try {
-    const content = await readFile(sessionPath, "utf-8");
-    const lines = content.trim().split("\n");
-    const totalLines = lines.length;
-    const newLines = lines.slice(fromLine);
-    const messages = [];
-    for (const line of newLines) {
-      try {
-        const entry = JSON.parse(line);
-        if (entry.type === "user" && entry.message?.content) {
-          const text = extractUserText(entry.message.content);
-          if (text && !isMetaMessage(text)) {
-            messages.push({
-              role: "user",
-              content: truncate(text, 100),
-              timestamp: entry.timestamp || ""
-            });
-          }
-        } else if (entry.type === "assistant" && entry.message?.content) {
-          const text = extractAssistantText(entry.message.content);
-          if (text) {
-            messages.push({
-              role: "assistant",
-              content: truncate(text, 100),
-              timestamp: entry.timestamp || ""
-            });
-          }
-        }
-      } catch {
-      }
-    }
-    return { messages, totalLines };
-  } catch {
-    return { messages: [], totalLines: 0 };
-  }
-}
-async function getAllMessages(sessionPath) {
-  if (!sessionPath) return [];
-  try {
-    const content = await readFile(sessionPath, "utf-8");
-    const lines = content.trim().split("\n");
-    const messages = [];
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line);
-        if (entry.type === "user" && entry.message?.content) {
-          const text = extractUserText(entry.message.content);
-          if (text && !isMetaMessage(text)) {
-            messages.push({
-              role: "user",
-              content: truncate(text, 100),
-              timestamp: entry.timestamp || ""
-            });
-          }
-        } else if (entry.type === "assistant" && entry.message?.content) {
-          const text = extractAssistantText(entry.message.content);
-          if (text) {
-            messages.push({
-              role: "assistant",
-              content: truncate(text, 100),
-              timestamp: entry.timestamp || ""
-            });
-          }
-        }
-      } catch {
-      }
-    }
-    return messages;
-  } catch {
-    return [];
-  }
-}
-function extractUserText(content) {
-  if (typeof content === "string") {
-    return content;
-  }
-  return "";
-}
-function extractAssistantText(content) {
-  if (!Array.isArray(content)) return "";
-  const textParts = content.filter((item) => item.type === "text" && item.text).map((item) => item.text);
-  return textParts.join("\n");
-}
-function isMetaMessage(text) {
-  return text.startsWith("<local-command") || text.startsWith("<command-name>") || text.startsWith("<command-message>");
-}
-function truncate(text, maxLen) {
-  const clean = text.replace(/\s+/g, " ").trim();
-  if (clean.length <= maxLen) return clean;
-  return `${clean.slice(0, maxLen - 3)}...`;
-}
-
 // src/hooks/useSessionWatcher.ts
-import { useEffect, useRef } from "react";
 import chokidar from "chokidar";
+import { useEffect, useRef } from "react";
 function useSessionWatcher(sessionPaths, onFileChange) {
   const watcherRef = useRef(null);
   const debounceTimersRef = useRef(/* @__PURE__ */ new Map());
@@ -470,6 +332,7 @@ function useSessionWatcher(sessionPaths, onFileChange) {
       }
     });
     watcher.on("change", (path) => {
+      clearSessionCache(path);
       const existingTimer = debounceTimersRef.current.get(path);
       if (existingTimer) {
         clearTimeout(existingTimer);
@@ -495,6 +358,7 @@ function useSessionWatcher(sessionPaths, onFileChange) {
 }
 
 // src/hooks/useProcesses.ts
+var sessionLimit = pLimit(5);
 function sortProcesses(processes, sortField) {
   const sorted = [...processes];
   switch (sortField) {
@@ -523,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);
@@ -750,6 +612,7 @@ var cli = meow(
   Options
     -l, --list        \u975E\u4EA4\u4E92\u6A21\u5F0F\uFF0C\u4EC5\u5217\u51FA\u8FDB\u7A0B
     -j, --json        JSON \u683C\u5F0F\u8F93\u51FA\uFF08\u914D\u5408 --list\uFF09
+    -d, --debug       \u663E\u793A\u4F1A\u8BDD\u5339\u914D\u8C03\u8BD5\u4FE1\u606F
     -i, --interval    \u5237\u65B0\u95F4\u9694\u79D2\u6570\uFF08\u9ED8\u8BA4 2\uFF09
     -v, --version     \u663E\u793A\u7248\u672C
     -h, --help        \u663E\u793A\u5E2E\u52A9
@@ -758,6 +621,7 @@ var cli = meow(
     $ claude-ps              \u542F\u52A8 TUI
     $ claude-ps --list       \u5217\u51FA\u8FDB\u7A0B\u540E\u9000\u51FA
     $ claude-ps --json       JSON \u683C\u5F0F\u8F93\u51FA
+    $ claude-ps --debug      \u663E\u793A\u4F1A\u8BDD\u5339\u914D\u8BE6\u60C5
     $ claude-ps -i 5         \u8BBE\u7F6E\u5237\u65B0\u95F4\u9694\u4E3A 5 \u79D2
 `,
   {
@@ -778,6 +642,11 @@ var cli = meow(
         shortFlag: "j",
         default: false
       },
+      debug: {
+        type: "boolean",
+        shortFlag: "d",
+        default: false
+      },
       interval: {
         type: "number",
         shortFlag: "i",
@@ -791,11 +660,15 @@ var cli = meow(
     }
   }
 );
-var { list, json, interval } = cli.flags;
-if (list || json) {
-  const { getClaudeProcesses: getClaudeProcesses2 } = await import("./process-AUO5UVTV.js");
+var { list, json, debug, interval } = cli.flags;
+if (list || json || debug) {
+  const { getClaudeProcesses: getClaudeProcesses2 } = await import("./process-XJGJPUAG.js");
   const processes = await getClaudeProcesses2();
-  if (json) {
+  if (debug) {
+    const { debugSessionMatching } = await import("./session-FTYMYOIH.js");
+    const debugInfo = await debugSessionMatching(processes);
+    console.log(debugInfo);
+  } else if (json) {
     console.log(JSON.stringify(processes, null, 2));
   } else {
     console.log("PID	TTY	CWD");

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-FTYMYOIH.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "claude-ps",
-	"version": "0.2.4",
+	"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
-};