claude-ps 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ziheng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# claude-ps
+
+TUI application for viewing and managing Claude Code processes.
+
+## Installation
+
+```bash
+npm install -g claude-ps
+```
+
+## Usage
+
+```bash
+claude-ps              # 启动交互界面
+claude-ps --list       # 列出进程（非交互）
+claude-ps --json       # JSON 格式输出
+claude-ps --interval 5 # 设置刷新间隔（秒）
+```
+
+## Keybindings
+
+- `↑/↓` or `j/k` - 移动选择
+- `s` - 切换排序方式
+- `r` - 刷新
+- `d` - 终止进程 (SIGTERM)
+- `D` - 强制终止 (SIGKILL)
+- `q/ESC` - 退出
+
+## License
+
+MIT

package/dist/chunk-TPK4XYR3.js

@@ -0,0 +1,106 @@
+#!/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 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
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/index.js

@@ -0,0 +1,609 @@
+#!/usr/bin/env node
+import {
+  getClaudeProcesses,
+  killProcess
+} from "./chunk-TPK4XYR3.js";
+
+// src/index.tsx
+import { withFullScreen } from "fullscreen-ink";
+import meow from "meow";
+
+// src/App.tsx
+import { Box as Box5, Text as Text5, useApp, useInput, useStdout } from "ink";
+
+// src/components/DetailPanel.tsx
+import { Box, Text } from "ink";
+
+// src/constants/theme.ts
+var USAGE_THRESHOLD = {
+  LOW: 30,
+  HIGH: 70
+};
+var COLORS = {
+  /** 使用率颜色 */
+  usage: {
+    low: "green",
+    medium: "yellow",
+    high: "red"
+  },
+  /** 标签颜色 */
+  label: "gray",
+  /** 数值颜色 */
+  value: "cyan",
+  /** 当前终端进程 */
+  current: "green",
+  /** 孤儿进程 */
+  orphan: "red",
+  /** 选中项 */
+  selected: "yellow",
+  /** 标题 */
+  title: "cyan"
+};
+var COLUMN_WIDTH = {
+  prefix: 2,
+  pid: 6,
+  cpu: 6,
+  memory: 6,
+  elapsed: 9
+};
+var ESTIMATED_TOTAL_MEMORY_MB = 16 * 1024;
+function getUsageColor(percent) {
+  if (percent < USAGE_THRESHOLD.LOW) return COLORS.usage.low;
+  if (percent < USAGE_THRESHOLD.HIGH) return COLORS.usage.medium;
+  return COLORS.usage.high;
+}
+
+// src/utils/format.ts
+function formatMemory(memPercent) {
+  const usedMB = memPercent / 100 * ESTIMATED_TOTAL_MEMORY_MB;
+  if (usedMB < 1024) return `${Math.round(usedMB)}MB`;
+  return `${(usedMB / 1024).toFixed(1)}GB`;
+}
+function formatElapsed(elapsed) {
+  if (!elapsed) return "\u672A\u77E5";
+  const parts = elapsed.split(/[-:]/);
+  if (parts.length === 2) {
+    return `${parts[0]}\u5206${parts[1]}\u79D2`;
+  }
+  if (parts.length === 3) {
+    return `${parts[0]}\u65F6${parts[1]}\u5206`;
+  }
+  if (parts.length === 4) {
+    return `${parts[0]}\u5929${parts[1]}\u65F6`;
+  }
+  return elapsed;
+}
+function shortenPath(inputPath, maxLen = 25) {
+  let path = inputPath;
+  const home = process.env.HOME || "";
+  if (home && path.startsWith(home)) {
+    path = `~${path.slice(home.length)}`;
+  }
+  if (path.length <= maxLen) return path;
+  const half = Math.floor((maxLen - 3) / 2);
+  return `${path.slice(0, half)}...${path.slice(-half)}`;
+}
+
+// src/components/DetailPanel.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function DetailPanel({ process: proc }) {
+  if (!proc) {
+    return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingLeft: 1, children: /* @__PURE__ */ jsx(Text, { color: COLORS.label, children: "\u9009\u62E9\u4E00\u4E2A\u8FDB\u7A0B\u67E5\u770B\u8BE6\u60C5" }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingLeft: 1, children: [
+    /* @__PURE__ */ jsxs(Box, { children: [
+      /* @__PURE__ */ jsx(Text, { color: COLORS.title, children: "CPU: " }),
+      /* @__PURE__ */ jsxs(Text, { children: [
+        proc.cpu.toFixed(1),
+        "%"
+      ] }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: COLORS.title, children: "\u5185\u5B58: " }),
+      /* @__PURE__ */ jsx(Text, { children: formatMemory(proc.memory) }),
+      /* @__PURE__ */ jsx(Text, { children: " " }),
+      /* @__PURE__ */ jsx(Text, { color: COLORS.title, children: "\u65F6\u957F: " }),
+      /* @__PURE__ */ jsx(Text, { children: formatElapsed(proc.elapsed) })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Text, { color: COLORS.title, children: "Session:" }),
+      /* @__PURE__ */ jsx(Text, { color: COLORS.label, wrap: "truncate", children: proc.sessionPath || "\u65E0\u4F1A\u8BDD\u6587\u4EF6" })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { children: " " }),
+    /* @__PURE__ */ jsx(Text, { color: COLORS.title, bold: true, children: "\u2500 \u6700\u8FD1\u5BF9\u8BDD \u2500" }),
+    proc.messages.length === 0 ? /* @__PURE__ */ jsx(Text, { color: COLORS.label, children: "\u65E0\u5BF9\u8BDD\u8BB0\u5F55" }) : proc.messages.map((msg) => /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsxs(Text, { color: msg.role === "user" ? COLORS.current : "blue", children: [
+        "[",
+        msg.role === "user" ? "User" : "Claude",
+        "]",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: msg.content })
+    ] }, msg.timestamp))
+  ] });
+}
+
+// src/components/HelpBar.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import React from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var hints = [
+  { key: "\u2191/\u2193", desc: "\u79FB\u52A8" },
+  { key: "d", desc: "\u7EC8\u6B62" },
+  { key: "D", desc: "\u5F3A\u6740" },
+  { key: "s", desc: "\u6392\u5E8F" },
+  { key: "r", desc: "\u5237\u65B0" },
+  { key: "q", desc: "\u9000\u51FA" }
+];
+var sortFieldLabels = {
+  cpu: "CPU",
+  memory: "\u5185\u5B58",
+  elapsed: "\u65F6\u957F",
+  default: "PID"
+};
+function HelpBar({ processCount, interval: interval2, sortField }) {
+  return /* @__PURE__ */ jsxs2(Box2, { justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx2(Box2, { children: hints.map((hint, i) => /* @__PURE__ */ jsxs2(React.Fragment, { children: [
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.selected, children: hint.key }),
+      /* @__PURE__ */ jsxs2(Text2, { color: COLORS.label, children: [
+        " ",
+        hint.desc
+      ] }),
+      i < hints.length - 1 && /* @__PURE__ */ jsx2(Text2, { children: " " })
+    ] }, hint.key)) }),
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { color: COLORS.value, children: [
+        processCount,
+        " \u8FDB\u7A0B"
+      ] }),
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.label, children: " | " }),
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.label, children: "\u6392\u5E8F: " }),
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.value, children: sortFieldLabels[sortField] }),
+      /* @__PURE__ */ jsx2(Text2, { color: COLORS.label, children: " | " }),
+      /* @__PURE__ */ jsxs2(Text2, { color: COLORS.label, children: [
+        "\u5237\u65B0: ",
+        interval2,
+        "s"
+      ] })
+    ] })
+  ] });
+}
+
+// src/components/ProcessList.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatPercent(value, width) {
+  const str = `${value.toFixed(1)}%`;
+  return str.padStart(width);
+}
+function ProcessList({
+  processes,
+  selectedIndex,
+  loading
+}) {
+  if (loading) {
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "\u52A0\u8F7D\u4E2D..." }) });
+  }
+  if (processes.length === 0) {
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", children: /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "\u65E0\u8FD0\u884C\u4E2D\u7684 Claude \u8FDB\u7A0B" }) });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLORS.title, children: "  " }),
+      /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.pid, children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLORS.title, children: "PID" }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.cpu, children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLORS.title, children: "CPU" }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.memory, children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLORS.title, children: "MEM" }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.elapsed, children: /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLORS.title, children: "\u65F6\u957F" }) }),
+      /* @__PURE__ */ jsx3(Text3, { bold: true, color: COLORS.title, children: "\u5DE5\u4F5C\u76EE\u5F55" })
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "\u2500".repeat(60) }),
+    processes.map((proc, index) => {
+      const isSelected = index === selectedIndex;
+      const prefix = isSelected ? "\u25B6 " : "   ";
+      let cwdColor = void 0;
+      if (proc.isOrphan) cwdColor = COLORS.orphan;
+      else if (proc.isCurrent) cwdColor = COLORS.current;
+      return /* @__PURE__ */ jsxs3(Box3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: isSelected ? COLORS.selected : void 0, children: prefix }),
+        /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.pid, children: /* @__PURE__ */ jsx3(Text3, { color: isSelected ? COLORS.selected : void 0, children: proc.pid }) }),
+        /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.cpu, children: /* @__PURE__ */ jsx3(Text3, { color: getUsageColor(proc.cpu), children: formatPercent(proc.cpu, COLUMN_WIDTH.cpu - 1) }) }),
+        /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.memory, children: /* @__PURE__ */ jsx3(Text3, { color: getUsageColor(proc.memory), children: formatPercent(proc.memory, COLUMN_WIDTH.memory - 1) }) }),
+        /* @__PURE__ */ jsx3(Box3, { width: COLUMN_WIDTH.elapsed, children: /* @__PURE__ */ jsx3(Text3, { color: isSelected ? COLORS.selected : "gray", children: formatElapsed(proc.elapsed).slice(0, COLUMN_WIDTH.elapsed - 1) }) }),
+        /* @__PURE__ */ jsxs3(Text3, { color: cwdColor, children: [
+          shortenPath(proc.cwd, 30),
+          proc.isCurrent ? " \u25CF" : ""
+        ] })
+      ] }, proc.pid);
+    })
+  ] });
+}
+
+// src/components/StatusBar.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function calculateStats(processes) {
+  const totalCpu = processes.reduce((sum, p) => sum + p.cpu, 0);
+  const totalMemoryPercent = processes.reduce((sum, p) => sum + p.memory, 0);
+  const totalMemoryMB = totalMemoryPercent / 100 * ESTIMATED_TOTAL_MEMORY_MB;
+  const orphanCount = processes.filter((p) => p.isOrphan).length;
+  const currentCount = processes.filter((p) => p.isCurrent).length;
+  return {
+    count: processes.length,
+    totalCpu,
+    totalMemory: totalMemoryMB < 1024 ? `${Math.round(totalMemoryMB)}MB` : `${(totalMemoryMB / 1024).toFixed(1)}GB`,
+    orphanCount,
+    currentCount
+  };
+}
+function StatusBar({ processes }) {
+  const stats = calculateStats(processes);
+  return /* @__PURE__ */ jsxs4(Box4, { children: [
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.label, children: "\u8FDB\u7A0B: " }),
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.value, children: stats.count }),
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.label, children: " | CPU: " }),
+    /* @__PURE__ */ jsxs4(Text4, { color: COLORS.value, children: [
+      stats.totalCpu.toFixed(1),
+      "%"
+    ] }),
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.label, children: " | \u5185\u5B58: " }),
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.value, children: stats.totalMemory }),
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.label, children: " | \u5B64\u513F: " }),
+    /* @__PURE__ */ jsx4(Text4, { color: stats.orphanCount > 0 ? COLORS.orphan : COLORS.value, children: stats.orphanCount }),
+    /* @__PURE__ */ jsx4(Text4, { color: COLORS.label, children: " | \u5F53\u524D: " }),
+    /* @__PURE__ */ jsx4(Text4, { color: stats.currentCount > 0 ? COLORS.current : COLORS.value, children: stats.currentCount })
+  ] });
+}
+
+// src/hooks/useProcesses.ts
+import { useCallback, useEffect, useMemo, 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 getRecentMessages(sessionPath, limit = 5) {
+  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.slice(-limit);
+  } 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/useProcesses.ts
+function sortProcesses(processes, sortField) {
+  const sorted = [...processes];
+  switch (sortField) {
+    case "cpu":
+      sorted.sort((a, b) => b.cpu - a.cpu);
+      break;
+    case "memory":
+      sorted.sort((a, b) => b.memory - a.memory);
+      break;
+    case "elapsed":
+      sorted.sort((a, b) => a.startTime.getTime() - b.startTime.getTime());
+      break;
+    default:
+      sorted.sort((a, b) => a.pid - b.pid);
+  }
+  return sorted;
+}
+function useProcesses(interval2) {
+  const [rawProcesses, setRawProcesses] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const [sortField, setSortField] = useState("default");
+  const refresh = useCallback(async () => {
+    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 getRecentMessages(sessionPath);
+          return {
+            ...proc,
+            sessionPath,
+            messages
+          };
+        })
+      );
+      setRawProcesses(enriched);
+      setError(null);
+      setSelectedIndex(
+        (prev) => Math.min(prev, Math.max(0, enriched.length - 1))
+      );
+    } catch (e) {
+      setError(e instanceof Error ? e.message : "\u672A\u77E5\u9519\u8BEF");
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  useEffect(() => {
+    refresh();
+    const timer = setInterval(refresh, interval2 * 1e3);
+    return () => clearInterval(timer);
+  }, [refresh, interval2]);
+  const processes = useMemo(
+    () => sortProcesses(rawProcesses, sortField),
+    [rawProcesses, sortField]
+  );
+  const selectNext = useCallback(() => {
+    setSelectedIndex((prev) => Math.min(prev + 1, processes.length - 1));
+  }, [processes.length]);
+  const selectPrev = useCallback(() => {
+    setSelectedIndex((prev) => Math.max(prev - 1, 0));
+  }, []);
+  const cycleSortField = useCallback(() => {
+    setSortField((prev) => {
+      const order = ["cpu", "memory", "elapsed", "default"];
+      const idx = order.indexOf(prev);
+      return order[(idx + 1) % order.length];
+    });
+  }, []);
+  const killSelected = useCallback(
+    async (force = false) => {
+      const proc = processes[selectedIndex];
+      if (!proc) return false;
+      const success = await killProcess(proc.pid, force);
+      if (success) {
+        await refresh();
+      }
+      return success;
+    },
+    [processes, selectedIndex, refresh]
+  );
+  const selectedProcess = processes[selectedIndex] || null;
+  return {
+    processes,
+    loading,
+    error,
+    selectedIndex,
+    selectedProcess,
+    sortField,
+    refresh,
+    selectNext,
+    selectPrev,
+    cycleSortField,
+    killSelected
+  };
+}
+
+// src/App.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function App({ interval: interval2 }) {
+  const { exit } = useApp();
+  const { stdout } = useStdout();
+  const termWidth = stdout?.columns || 80;
+  const termHeight = stdout?.rows || 24;
+  const {
+    processes,
+    loading,
+    error,
+    selectedIndex,
+    selectedProcess,
+    sortField,
+    refresh,
+    selectNext,
+    selectPrev,
+    cycleSortField,
+    killSelected
+  } = useProcesses(interval2);
+  useInput((input, key) => {
+    if (input === "q" || key.escape) {
+      exit();
+    } else if (key.downArrow || input === "j") {
+      selectNext();
+    } else if (key.upArrow || input === "k") {
+      selectPrev();
+    } else if (input === "r") {
+      refresh();
+    } else if (input === "s") {
+      cycleSortField();
+    } else if (input === "d") {
+      killSelected(false);
+    } else if (input === "D") {
+      killSelected(true);
+    }
+  });
+  const leftWidth = Math.floor(termWidth * 0.45);
+  const rightWidth = termWidth - leftWidth - 1;
+  const contentHeight = termHeight - 4;
+  if (error) {
+    return /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", width: termWidth, height: termHeight, children: /* @__PURE__ */ jsxs5(Text5, { color: COLORS.orphan, children: [
+      "\u9519\u8BEF: ",
+      error
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", width: termWidth, height: termHeight, children: [
+    /* @__PURE__ */ jsxs5(Box5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, color: COLORS.title, children: "claude-ps" }),
+      /* @__PURE__ */ jsx5(Text5, { color: COLORS.label, children: " - Claude Code \u8FDB\u7A0B\u7BA1\u7406\u5668" })
+    ] }),
+    /* @__PURE__ */ jsx5(StatusBar, { processes }),
+    /* @__PURE__ */ jsxs5(Box5, { height: contentHeight, children: [
+      /* @__PURE__ */ jsx5(Box5, { width: leftWidth, flexDirection: "column", height: contentHeight, children: /* @__PURE__ */ jsx5(
+        ProcessList,
+        {
+          processes,
+          selectedIndex,
+          loading
+        }
+      ) }),
+      /* @__PURE__ */ jsx5(Box5, { width: 1, flexDirection: "column", height: contentHeight, children: /* @__PURE__ */ jsx5(Text5, { color: COLORS.label, children: "\u2502\n".repeat(contentHeight).trim() }) }),
+      /* @__PURE__ */ jsx5(Box5, { width: rightWidth, flexDirection: "column", height: contentHeight, children: /* @__PURE__ */ jsx5(DetailPanel, { process: selectedProcess }) })
+    ] }),
+    /* @__PURE__ */ jsx5(
+      Box5,
+      {
+        borderStyle: "single",
+        borderTop: true,
+        borderBottom: false,
+        borderLeft: false,
+        borderRight: false,
+        children: /* @__PURE__ */ jsx5(
+          HelpBar,
+          {
+            processCount: processes.length,
+            interval: interval2,
+            sortField
+          }
+        )
+      }
+    )
+  ] });
+}
+
+// src/index.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var cli = meow(
+  `
+  Usage
+    $ claude-ps [options]
+
+  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
+    -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
+
+  Examples
+    $ 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 -i 5         \u8BBE\u7F6E\u5237\u65B0\u95F4\u9694\u4E3A 5 \u79D2
+`,
+  {
+    importMeta: import.meta,
+    flags: {
+      list: {
+        type: "boolean",
+        shortFlag: "l",
+        default: false
+      },
+      json: {
+        type: "boolean",
+        shortFlag: "j",
+        default: false
+      },
+      interval: {
+        type: "number",
+        shortFlag: "i",
+        default: 2
+      }
+    }
+  }
+);
+var { list, json, interval } = cli.flags;
+if (list || json) {
+  const { getClaudeProcesses: getClaudeProcesses2 } = await import("./process-2SZ7S64S.js");
+  const processes = await getClaudeProcesses2();
+  if (json) {
+    console.log(JSON.stringify(processes, null, 2));
+  } else {
+    console.log("PID	TTY	CWD");
+    for (const proc of processes) {
+      console.log(`${proc.pid}	${proc.tty}	${proc.cwd}`);
+    }
+  }
+  process.exit(0);
+}
+withFullScreen(/* @__PURE__ */ jsx6(App, { interval })).start();

package/dist/process-2SZ7S64S.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import {
+  getClaudeProcesses,
+  killProcess
+} from "./chunk-TPK4XYR3.js";
+export {
+  getClaudeProcesses,
+  killProcess
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+	"name": "claude-ps",
+	"version": "0.1.0",
+	"description": "TUI application for viewing and managing Claude Code processes",
+	"type": "module",
+	"main": "dist/index.js",
+	"bin": {
+		"claude-ps": "dist/index.js"
+	},
+	"files": ["dist"],
+	"scripts": {
+		"dev": "tsx src/index.tsx",
+		"build": "tsup",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"format": "biome format --write .",
+		"typecheck": "tsc --noEmit",
+		"all": "pnpm format && pnpm typecheck && pnpm lint"
+	},
+	"keywords": ["claude", "tui", "terminal", "process-manager"],
+	"author": "ziheng",
+	"license": "MIT",
+	"dependencies": {
+		"chalk": "^5.3.0",
+		"fullscreen-ink": "^0.1.0",
+		"ink": "^5.0.1",
+		"meow": "^13.2.0",
+		"react": "^18.3.1"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^1.9.0",
+		"@types/react": "^18.3.0",
+		"tsup": "^8.3.0",
+		"tsx": "^4.19.0",
+		"typescript": "^5.6.0"
+	},
+	"engines": {
+		"node": ">=18"
+	}
+}