agenttop 0.9.2 → 0.9.4

package/dist/index.js

@@ -8,6 +8,8 @@ import {
   discoverSessions,
   getArchived,
   getNicknames,
+  getProjectsDirs,
+  getTaskDirs,
   isFirstRun,
   loadConfig,
   purgeExpiredArchives,
@@ -17,11 +19,11 @@ import {
   setNickname,
   startMcpServer,
   unarchiveSession
-} from "./chunk-6D2UXDV4.js";
+} from "./chunk-3LEBAMTZ.js";
 
 // src/index.tsx
-import { readFileSync as readFileSync4 } from "fs";
-import { join as join4, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join5, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import React16 from "react";
 import { render } from "ink";
@@ -348,33 +350,36 @@ var deriveSeverityColors = (c) => ({
 });
 
 // src/updates.ts
-import { execSync, exec } from "child_process";
-import { readFileSync } from "fs";
+import { execFile, exec } from "child_process";
+import { readFile } from "fs/promises";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
-var getPackageVersion = () => {
+var getPackageVersion = async () => {
   try {
     const thisFile = fileURLToPath(import.meta.url);
     const pkgPath = join(dirname(thisFile), "..", "package.json");
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";
   }
 };
-var checkForUpdate = () => {
-  const current = getPackageVersion();
-  try {
-    const latest = execSync("npm view agenttop version", { encoding: "utf-8", timeout: 5e3 }).trim();
-    return {
-      current,
-      latest,
-      available: latest !== current && compareVersions(latest, current) > 0
-    };
-  } catch {
-    return { current, latest: current, available: false };
-  }
-};
+var checkForUpdate = () => new Promise((resolve) => {
+  getPackageVersion().then((current) => {
+    execFile("npm", ["view", "agenttop", "version"], { encoding: "utf-8", timeout: 5e3 }, (err, stdout) => {
+      if (err || !stdout) {
+        resolve({ current, latest: current, available: false });
+        return;
+      }
+      const latest = stdout.trim();
+      resolve({
+        current,
+        latest,
+        available: latest !== current && compareVersions(latest, current) > 0
+      });
+    });
+  });
+});
 var installUpdate = () => {
   return new Promise((resolve, reject) => {
     exec("npm install -g agenttop@latest", { timeout: 6e4 }, (err, stdout) => {
@@ -490,11 +495,24 @@ var formatTokens = (n) => {
   return String(n);
 };
 var truncate = (s, max) => s.length > max ? s.slice(0, max - 1) + "\u2026" : s;
-var SIDEBAR_WIDTH = 30;
-var INNER_WIDTH = SIDEBAR_WIDTH - 4;
+var getDisplayName = (s) => {
+  if (s.nickname) return s.nickname;
+  if (s.cwd) {
+    const parts = s.cwd.replace(/\/+$/, "").split("/");
+    return parts[parts.length - 1] || s.slug;
+  }
+  if (s.project) {
+    const parts = s.project.replace(/\/+$/, "").split("/");
+    return parts[parts.length - 1] || s.slug;
+  }
+  return s.slug;
+};
+var DEFAULT_SIDEBAR_WIDTH = 30;
 var LINES_PER_ITEM = 3;
 var SessionList = React2.memo(
-  ({ visibleItems, selectedIndex, focused, height, filter, viewingArchive, totalSessions }) => {
+  ({ visibleItems, selectedIndex, focused, height, filter, viewingArchive, totalSessions, sidebarWidth }) => {
+    const SIDEBAR_WIDTH = sidebarWidth ?? DEFAULT_SIDEBAR_WIDTH;
+    const INNER_WIDTH = SIDEBAR_WIDTH - 4;
     const availableRows = height - 2;
     const maxVisible = Math.max(1, Math.floor((availableRows + 1) / LINES_PER_ITEM));
     const halfView = Math.floor(maxVisible / 2);
@@ -546,14 +564,14 @@ var SessionList = React2.memo(
                   paddingX: 1,
                   backgroundColor: isSelected ? colors.selected : void 0,
                   children: [
-                    /* @__PURE__ */ jsxs2(Text2, { color: nameColor2, bold: isSelected, wrap: "truncate", children: [
+                    /* @__PURE__ */ jsxs2(Text2, { color: nameColor2, bold: isSelected, underline: isSelected, wrap: "truncate", children: [
                       arrow,
                       " ",
                       /* @__PURE__ */ jsx2(Text2, { color: dotColor2, children: statusDot2 }),
                       " ",
                       label2
                     ] }),
-                    /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, wrap: "truncate", children: [
+                    /* @__PURE__ */ jsxs2(Text2, { color: isSelected ? colors.text : colors.muted, wrap: "truncate", children: [
                       "    ",
                       model2,
                       " ",
@@ -576,7 +594,7 @@ var SessionList = React2.memo(
             const model = formatModel(session.model);
             if (item.type === "session") {
               const nameColor2 = isSelected ? colors.bright : isActive ? colors.secondary : colors.muted;
-              const displayName2 = truncate(session.slug, INNER_WIDTH - 6);
+              const displayName2 = truncate(session.nickname || session.slug, INNER_WIDTH - 6);
               return /* @__PURE__ */ jsxs2(
                 Box2,
                 {
@@ -584,14 +602,14 @@ var SessionList = React2.memo(
                   paddingX: 1,
                   backgroundColor: isSelected ? colors.selected : void 0,
                   children: [
-                    /* @__PURE__ */ jsxs2(Text2, { color: nameColor2, bold: isSelected, wrap: "truncate", children: [
+                    /* @__PURE__ */ jsxs2(Text2, { color: nameColor2, bold: isSelected, underline: isSelected, wrap: "truncate", children: [
                       "  ",
                       " ",
                       /* @__PURE__ */ jsx2(Text2, { color: dotColor, children: statusDot }),
                       " ",
                       displayName2
                     ] }),
-                    /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, wrap: "truncate", children: [
+                    /* @__PURE__ */ jsxs2(Text2, { color: isSelected ? colors.text : colors.muted, wrap: "truncate", children: [
                       "      ",
                       model,
                       " ",
@@ -608,19 +626,7 @@ var SessionList = React2.memo(
             }
             const indicator = isSelected ? "\u25B8" : " ";
             const nameColor = isSelected ? colors.bright : isActive ? colors.secondary : colors.text;
-            const getDisplayName2 = (s) => {
-              if (s.nickname) return s.nickname;
-              if (s.cwd) {
-                const parts = s.cwd.replace(/\/+$/, "").split("/");
-                return parts[parts.length - 1] || s.slug;
-              }
-              if (s.project) {
-                const parts = s.project.replace(/\/+$/, "").split("/");
-                return parts[parts.length - 1] || s.slug;
-              }
-              return s.slug;
-            };
-            const displayName = truncate(getDisplayName2(session), INNER_WIDTH - 4);
+            const displayName = truncate(getDisplayName(session), INNER_WIDTH - 4);
             return /* @__PURE__ */ jsxs2(
               Box2,
               {
@@ -628,14 +634,14 @@ var SessionList = React2.memo(
                 paddingX: 1,
                 backgroundColor: isSelected ? colors.selected : void 0,
                 children: [
-                  /* @__PURE__ */ jsxs2(Text2, { color: nameColor, bold: isSelected, wrap: "truncate", children: [
+                  /* @__PURE__ */ jsxs2(Text2, { color: nameColor, bold: isSelected, underline: isSelected, wrap: "truncate", children: [
                     indicator,
                     " ",
                     /* @__PURE__ */ jsx2(Text2, { color: dotColor, children: statusDot }),
                     " ",
                     displayName
                   ] }),
-                  /* @__PURE__ */ jsxs2(Text2, { color: colors.muted, wrap: "truncate", children: [
+                  /* @__PURE__ */ jsxs2(Text2, { color: isSelected ? colors.text : colors.muted, wrap: "truncate", children: [
                     "    ",
                     model,
                     " ",
@@ -1099,7 +1105,9 @@ var KEYBIND_LABELS = {
   pinLeft: "Pin to left panel",
   pinRight: "Pin to right panel",
   swapPanels: "Swap panels",
-  closePanel: "Close panel"
+  closePanel: "Close panel",
+  sidebarNarrower: "Sidebar narrower",
+  sidebarWider: "Sidebar wider"
 };
 var RULE_LABELS = {
   network: "Network detection",
@@ -1129,7 +1137,9 @@ var DEFAULT_KEYBINDINGS = {
   pinLeft: "1",
   pinRight: "2",
   swapPanels: "S",
-  closePanel: "X"
+  closePanel: "X",
+  sidebarNarrower: "<",
+  sidebarWider: ">"
 };
 var SEVERITY_OPTIONS = ["info", "warn", "high", "critical"];
 var ARCHIVE_EXPIRY_OPTIONS = [0, 7, 14, 30, 60, 90];
@@ -1930,20 +1940,402 @@ var SplitPanel = React14.memo(
 
 // src/ui/hooks/useSessions.ts
 import { useState as useState8, useEffect as useEffect5, useCallback as useCallback2, useRef as useRef3, useMemo as useMemo2 } from "react";
-var ACTIVE_POLL_MS = 1e4;
-var IDLE_POLL_MS = 3e4;
-var getDisplayName = (session) => {
-  if (session.nickname) return session.nickname;
-  if (session.cwd) {
-    const parts = session.cwd.replace(/\/+$/, "").split("/");
-    return parts[parts.length - 1] || session.slug;
+
+// src/discovery/sessionsAsync.ts
+import { readdir, stat as stat2 } from "fs/promises";
+import { join as join2, basename } from "path";
+
+// src/discovery/cache.ts
+var sessions = [];
+var refreshInFlight = false;
+var listeners = /* @__PURE__ */ new Set();
+var getCachedSessions = () => sessions;
+var setCachedSessions = (next) => {
+  sessions = next;
+  for (const fn of listeners) fn(next);
+};
+var subscribe = (fn) => {
+  listeners.add(fn);
+  return () => {
+    listeners.delete(fn);
+  };
+};
+var isRefreshInFlight = () => refreshInFlight;
+var setRefreshInFlight = (v) => {
+  refreshInFlight = v;
+};
+var MAX_CACHE_ENTRIES = 500;
+var fileMetaCache = /* @__PURE__ */ new Map();
+var pruneFileMetaCache = (validPaths) => {
+  for (const key of fileMetaCache.keys()) {
+    if (!validPaths.has(key)) fileMetaCache.delete(key);
   }
-  if (session.project) {
-    const parts = session.project.replace(/\/+$/, "").split("/");
-    return parts[parts.length - 1] || session.slug;
+  if (fileMetaCache.size > MAX_CACHE_ENTRIES) {
+    const excess = fileMetaCache.size - MAX_CACHE_ENTRIES;
+    const iter = fileMetaCache.keys();
+    for (let i = 0; i < excess; i++) {
+      const next = iter.next();
+      if (!next.done) fileMetaCache.delete(next.value);
+    }
   }
-  return session.slug;
 };
+
+// src/discovery/asyncHelpers.ts
+import { execFile as execFile2 } from "child_process";
+import { open, stat, readlink } from "fs/promises";
+var normalisePath = (p) => p.replace(/\/+$/, "");
+var getClaudeProcessesAsync = async () => {
+  const stdout = await new Promise((resolve) => {
+    execFile2("ps", ["aux"], { encoding: "utf-8", timeout: 5e3, maxBuffer: 4 * 1024 * 1024 }, (err, out) => {
+      resolve(err || !out ? "" : out);
+    });
+  });
+  if (!stdout) return [];
+  const procs = [];
+  for (const line of stdout.split("\n")) {
+    if (!line.includes("/claude") || line.includes("grep") || line.includes("agenttop")) continue;
+    const parts = line.trim().split(/\s+/);
+    const pid = parseInt(parts[1], 10);
+    if (isNaN(pid)) continue;
+    const command = parts.slice(10).join(" ");
+    if (command.startsWith("sudo")) continue;
+    procs.push({
+      pid,
+      cpu: parseFloat(parts[2]) || 0,
+      mem: parseFloat(parts[3]) || 0,
+      memKB: parseInt(parts[5], 10) || 0,
+      startTime: parts[8] || "",
+      command,
+      cwd: ""
+    });
+  }
+  await Promise.all(
+    procs.map(async (p) => {
+      try {
+        p.cwd = await readlink(`/proc/${p.pid}/cwd`);
+      } catch {
+      }
+    })
+  );
+  return procs;
+};
+var readFirstLinesAsync = async (filePath, bytes) => {
+  let fh;
+  try {
+    fh = await open(filePath, "r");
+    const buf = Buffer.alloc(bytes);
+    const { bytesRead } = await fh.read(buf, 0, bytes, 0);
+    return buf.subarray(0, bytesRead).toString("utf-8").split("\n").filter(Boolean);
+  } catch {
+    return [];
+  } finally {
+    await fh?.close();
+  }
+};
+var extractSessionMetaCached = async (filePath) => {
+  let fstat;
+  try {
+    fstat = await stat(filePath);
+    if (!fstat.isFile() || fstat.size === 0) return null;
+  } catch {
+    return null;
+  }
+  const cached = fileMetaCache.get(filePath);
+  if (cached && cached.mtimeMs === fstat.mtimeMs && cached.size === fstat.size) {
+    return {
+      sessionId: cached.sessionId,
+      cwd: cached.cwd,
+      version: cached.version,
+      gitBranch: cached.gitBranch,
+      model: cached.model,
+      usage: cached.usage
+    };
+  }
+  const lines = await readFirstLinesAsync(filePath, 65536);
+  let sessionId = "";
+  let cwd = "";
+  let version = "";
+  let gitBranch = "";
+  let model = "";
+  const usage = { inputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, outputTokens: 0 };
+  for (const line of lines) {
+    try {
+      const evt = JSON.parse(line);
+      if (!sessionId && evt.sessionId) sessionId = String(evt.sessionId);
+      if (!cwd && evt.cwd) cwd = String(evt.cwd);
+      if (!version && evt.version) version = String(evt.version);
+      if (!gitBranch && evt.gitBranch) gitBranch = String(evt.gitBranch);
+      if (evt.type === "assistant") {
+        if (!model && evt.message?.model) model = String(evt.message.model);
+        const u = evt.message?.usage;
+        if (u) {
+          usage.inputTokens += u.input_tokens ?? 0;
+          usage.cacheCreationTokens += u.cache_creation_input_tokens ?? 0;
+          usage.cacheReadTokens += u.cache_read_input_tokens ?? 0;
+          usage.outputTokens += u.output_tokens ?? 0;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  if (!sessionId) return null;
+  fileMetaCache.set(filePath, {
+    mtimeMs: fstat.mtimeMs,
+    size: fstat.size,
+    sessionId,
+    cwd,
+    version,
+    gitBranch,
+    model,
+    usage
+  });
+  return { sessionId, cwd, version, gitBranch, model, usage };
+};
+var readFirstEventAsync = async (filePath) => {
+  const lines = await readFirstLinesAsync(filePath, 16384);
+  if (lines.length === 0) return null;
+  try {
+    return JSON.parse(lines[0]);
+  } catch {
+    return null;
+  }
+};
+var findModelAndUsageAsync = async (filePath) => {
+  let fstat;
+  try {
+    fstat = await stat(filePath);
+  } catch {
+    return { model: "", usage: { inputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, outputTokens: 0 } };
+  }
+  const cached = fileMetaCache.get(filePath);
+  if (cached && cached.mtimeMs === fstat.mtimeMs && cached.size === fstat.size) {
+    return { model: cached.model, usage: cached.usage };
+  }
+  const usage = { inputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0, outputTokens: 0 };
+  let model = "";
+  const lines = await readFirstLinesAsync(filePath, 65536);
+  for (const line of lines) {
+    try {
+      const evt = JSON.parse(line);
+      if (evt.type === "assistant") {
+        if (!model && evt.message?.model) model = String(evt.message.model);
+        const u = evt.message?.usage;
+        if (u) {
+          usage.inputTokens += u.input_tokens ?? 0;
+          usage.cacheCreationTokens += u.cache_creation_input_tokens ?? 0;
+          usage.cacheReadTokens += u.cache_read_input_tokens ?? 0;
+          usage.outputTokens += u.output_tokens ?? 0;
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { model, usage };
+};
+
+// src/discovery/sessionsAsync.ts
+var discoverFromProjectsAsync = async (allUsers, processes, sessionMap, seenFiles) => {
+  const projectsDirs = getProjectsDirs(allUsers);
+  for (const projectsDir of projectsDirs) {
+    let projectNames;
+    try {
+      projectNames = await readdir(projectsDir);
+    } catch {
+      continue;
+    }
+    for (const projectName of projectNames) {
+      const projectPath = join2(projectsDir, projectName);
+      try {
+        const s = await stat2(projectPath);
+        if (!s.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      let files;
+      try {
+        files = (await readdir(projectPath)).filter((f) => f.endsWith(".jsonl"));
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        const filePath = join2(projectPath, file);
+        seenFiles.add(filePath);
+        let fstat;
+        try {
+          fstat = await stat2(filePath);
+          if (!fstat.isFile() || fstat.size === 0) continue;
+        } catch {
+          continue;
+        }
+        const meta = await extractSessionMetaCached(filePath);
+        if (!meta) continue;
+        if (sessionMap.has(meta.sessionId)) continue;
+        const normCwd = normalisePath(meta.cwd);
+        const matchingProcess = processes.find((p) => p.cwd && normalisePath(p.cwd) === normCwd);
+        const session = {
+          sessionId: meta.sessionId,
+          slug: meta.sessionId.slice(0, 12),
+          project: projectName.replace(/-/g, "/"),
+          cwd: meta.cwd,
+          model: meta.model || "unknown",
+          version: meta.version,
+          gitBranch: meta.gitBranch,
+          pid: matchingProcess?.pid ?? null,
+          cpu: matchingProcess?.cpu ?? 0,
+          mem: matchingProcess?.mem ?? 0,
+          memMB: matchingProcess ? Math.round(matchingProcess.memKB / 1024) : 0,
+          agentCount: 1,
+          agentIds: [basename(file, ".jsonl")],
+          outputFiles: [filePath],
+          startTime: fstat.birthtimeMs || fstat.ctimeMs,
+          lastActivity: fstat.mtimeMs,
+          usage: meta.usage
+        };
+        sessionMap.set(meta.sessionId, session);
+      }
+    }
+  }
+};
+var discoverFromTmpAsync = async (allUsers, processes, sessionMap, seenFiles) => {
+  const taskDirs = getTaskDirs(allUsers);
+  for (const taskDir of taskDirs) {
+    let projectDirs;
+    try {
+      projectDirs = await readdir(taskDir);
+    } catch {
+      continue;
+    }
+    for (const projectName of projectDirs) {
+      const projectPath = join2(taskDir, projectName);
+      try {
+        const s = await stat2(projectPath);
+        if (!s.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      const tasksPaths = [];
+      const tasksDir = join2(projectPath, "tasks");
+      try {
+        await readdir(tasksDir);
+        tasksPaths.push(tasksDir);
+      } catch {
+        try {
+          for (const sub of await readdir(projectPath)) {
+            const subTasks = join2(projectPath, sub, "tasks");
+            try {
+              await readdir(subTasks);
+              tasksPaths.push(subTasks);
+            } catch {
+              continue;
+            }
+          }
+        } catch {
+          continue;
+        }
+      }
+      for (const tDir of tasksPaths) {
+        let outputFiles;
+        try {
+          outputFiles = (await readdir(tDir)).filter((f) => f.endsWith(".output")).map((f) => join2(tDir, f));
+        } catch {
+          continue;
+        }
+        if (outputFiles.length === 0) continue;
+        const agentIds = [];
+        let sessionId = "";
+        let slug = "";
+        let cwd = "";
+        let model = "";
+        let version = "";
+        let gitBranch = "";
+        let startTime = Infinity;
+        let lastActivity = 0;
+        const totalUsage = {
+          inputTokens: 0,
+          cacheCreationTokens: 0,
+          cacheReadTokens: 0,
+          outputTokens: 0
+        };
+        for (const outputFile of outputFiles) {
+          seenFiles.add(outputFile);
+          const agentId = basename(outputFile, ".output");
+          agentIds.push(agentId);
+          const firstEvent = await readFirstEventAsync(outputFile);
+          if (firstEvent) {
+            if (!sessionId) sessionId = String(firstEvent.sessionId || "");
+            if (!slug) slug = String(firstEvent.slug || "");
+            if (!cwd) cwd = String(firstEvent.cwd || "");
+            if (!version) version = String(firstEvent.version || "");
+            if (!gitBranch) gitBranch = String(firstEvent.gitBranch || "");
+          }
+          try {
+            const fstat = await stat2(outputFile);
+            const created = fstat.birthtimeMs || fstat.ctimeMs;
+            if (created < startTime) startTime = created;
+            if (fstat.mtimeMs > lastActivity) lastActivity = fstat.mtimeMs;
+          } catch {
+          }
+          const result = await findModelAndUsageAsync(outputFile);
+          if (!model && result.model) model = result.model;
+          totalUsage.inputTokens += result.usage.inputTokens;
+          totalUsage.cacheCreationTokens += result.usage.cacheCreationTokens;
+          totalUsage.cacheReadTokens += result.usage.cacheReadTokens;
+          totalUsage.outputTokens += result.usage.outputTokens;
+        }
+        if (!sessionId && !slug) continue;
+        if (sessionMap.has(sessionId || projectName)) continue;
+        const normCwd = normalisePath(cwd);
+        const matchingProcess = processes.find((p) => p.cwd && normalisePath(p.cwd) === normCwd);
+        const session = {
+          sessionId,
+          slug: slug || sessionId.slice(0, 12),
+          project: projectName.replace(/-/g, "/"),
+          cwd,
+          model: model || "unknown",
+          version,
+          gitBranch,
+          pid: matchingProcess?.pid ?? null,
+          cpu: matchingProcess?.cpu ?? 0,
+          mem: matchingProcess?.mem ?? 0,
+          memMB: matchingProcess ? Math.round(matchingProcess.memKB / 1024) : 0,
+          agentCount: agentIds.length,
+          agentIds,
+          outputFiles,
+          startTime: startTime === Infinity ? Date.now() : startTime,
+          lastActivity,
+          usage: totalUsage
+        };
+        sessionMap.set(sessionId || projectName, session);
+      }
+    }
+  }
+};
+var discoverSessionsAsync = async (allUsers) => {
+  const processes = await getClaudeProcessesAsync();
+  const sessionMap = /* @__PURE__ */ new Map();
+  const seenFiles = /* @__PURE__ */ new Set();
+  await discoverFromProjectsAsync(allUsers, processes, sessionMap, seenFiles);
+  await discoverFromTmpAsync(allUsers, processes, sessionMap, seenFiles);
+  pruneFileMetaCache(seenFiles);
+  return Array.from(sessionMap.values()).sort((a, b) => {
+    const aActive = a.pid !== null ? 1 : 0;
+    const bActive = b.pid !== null ? 1 : 0;
+    if (aActive !== bActive) return bActive - aActive;
+    return b.lastActivity - a.lastActivity;
+  });
+};
+var triggerRefresh = (allUsers) => {
+  if (isRefreshInFlight()) return;
+  setRefreshInFlight(true);
+  discoverSessionsAsync(allUsers).then((result) => setCachedSessions(result)).catch(() => {
+  }).finally(() => setRefreshInFlight(false));
+};
+
+// src/ui/hooks/useSessions.ts
+var ACTIVE_POLL_MS = 1e4;
+var IDLE_POLL_MS = 3e4;
 var getGroupKey = (session) => {
   if (session.cwd) {
     const parts = session.cwd.replace(/\/+$/, "").split("/");
@@ -1955,19 +2347,16 @@ var getGroupKey = (session) => {
   }
   return session.slug;
 };
-var buildGroups = (sessions, expandedKeys) => {
+var buildGroups = (sessions2, expandedKeys) => {
   const byKey = /* @__PURE__ */ new Map();
-  for (const s of sessions) {
+  for (const s of sessions2) {
     const key = getGroupKey(s);
     const existing = byKey.get(key);
-    if (existing) {
-      existing.sessions.push(s);
-    } else {
-      byKey.set(key, { displayName: getDisplayName(s), sessions: [s] });
-    }
+    if (existing) existing.push(s);
+    else byKey.set(key, [s]);
   }
   const groups = [];
-  for (const [key, { displayName, sessions: list }] of byKey) {
+  for (const [key, list] of byKey) {
     list.sort((a, b) => b.lastActivity - a.lastActivity);
     const totalIn = list.reduce((sum, s) => sum + s.usage.inputTokens + s.usage.cacheReadTokens, 0);
     const totalOut = list.reduce((sum, s) => sum + s.usage.outputTokens, 0);
@@ -2002,52 +2391,64 @@ var buildVisibleItems = (groups) => {
   }
   return items;
 };
+var enrichAndFilter = (found, usageOverrides, filter, archivedIds, viewingArchive) => {
+  const nicknames = getNicknames();
+  let enriched = found.map((s) => {
+    const override = usageOverrides.get(s.sessionId);
+    return {
+      ...s,
+      nickname: nicknames[s.sessionId],
+      usage: override ? {
+        inputTokens: s.usage.inputTokens + override.inputTokens,
+        cacheCreationTokens: s.usage.cacheCreationTokens + override.cacheCreationTokens,
+        cacheReadTokens: s.usage.cacheReadTokens + override.cacheReadTokens,
+        outputTokens: s.usage.outputTokens + override.outputTokens
+      } : s.usage
+    };
+  });
+  if (archivedIds && archivedIds.size > 0) {
+    if (viewingArchive) {
+      enriched = enriched.filter((s) => archivedIds.has(s.sessionId));
+    } else {
+      enriched = enriched.filter((s) => !archivedIds.has(s.sessionId));
+    }
+  } else if (viewingArchive) {
+    enriched = [];
+  }
+  if (filter) {
+    const lower = filter.toLowerCase();
+    enriched = enriched.filter(
+      (s) => s.slug.toLowerCase().includes(lower) || s.nickname?.toLowerCase().includes(lower) || s.project.toLowerCase().includes(lower) || s.model.toLowerCase().includes(lower)
+    );
+  }
+  return enriched;
+};
 var useSessions = (allUsers, filter, archivedIds, viewingArchive) => {
-  const [sessions, setSessions] = useState8([]);
+  const [sessions2, setSessions] = useState8([]);
   const [selectedIndex, setSelectedIndex] = useState8(0);
   const [expandedKeys, setExpandedKeys] = useState8(/* @__PURE__ */ new Set());
   const usageOverrides = useRef3(/* @__PURE__ */ new Map());
   const refresh = useCallback2(() => {
-    const found = discoverSessions(allUsers);
-    const nicknames = getNicknames();
-    const enriched = found.map((s) => {
-      const override = usageOverrides.current.get(s.sessionId);
-      return {
-        ...s,
-        nickname: nicknames[s.sessionId],
-        usage: override ? {
-          inputTokens: s.usage.inputTokens + override.inputTokens,
-          cacheCreationTokens: s.usage.cacheCreationTokens + override.cacheCreationTokens,
-          cacheReadTokens: s.usage.cacheReadTokens + override.cacheReadTokens,
-          outputTokens: s.usage.outputTokens + override.outputTokens
-        } : s.usage
-      };
-    });
-    let filtered = enriched;
-    if (archivedIds && archivedIds.size > 0) {
-      if (viewingArchive) {
-        filtered = filtered.filter((s) => archivedIds.has(s.sessionId));
-      } else {
-        filtered = filtered.filter((s) => !archivedIds.has(s.sessionId));
-      }
-    } else if (viewingArchive) {
-      filtered = [];
-    }
-    if (filter) {
-      const lower = filter.toLowerCase();
-      filtered = filtered.filter(
-        (s) => s.slug.toLowerCase().includes(lower) || s.nickname?.toLowerCase().includes(lower) || s.project.toLowerCase().includes(lower) || s.model.toLowerCase().includes(lower)
-      );
-    }
+    const found = getCachedSessions();
+    const filtered = enrichAndFilter(found, usageOverrides.current, filter, archivedIds, viewingArchive);
     setSessions(filtered);
+    triggerRefresh(allUsers);
   }, [allUsers, filter, archivedIds, viewingArchive]);
+  useEffect5(() => {
+    const unsubscribe = subscribe(() => {
+      const found = getCachedSessions();
+      const filtered = enrichAndFilter(found, usageOverrides.current, filter, archivedIds, viewingArchive);
+      setSessions(filtered);
+    });
+    return unsubscribe;
+  }, [filter, archivedIds, viewingArchive]);
   useEffect5(() => {
     refresh();
-    const pollMs = sessions.length > 0 ? ACTIVE_POLL_MS : IDLE_POLL_MS;
-    const interval = setInterval(refresh, pollMs);
+    const pollMs = sessions2.length > 0 ? ACTIVE_POLL_MS : IDLE_POLL_MS;
+    const interval = setInterval(() => triggerRefresh(allUsers), pollMs);
     return () => clearInterval(interval);
-  }, [refresh, sessions.length > 0]);
-  const groups = useMemo2(() => buildGroups(sessions, expandedKeys), [sessions, expandedKeys]);
+  }, [refresh, sessions2.length > 0]);
+  const groups = useMemo2(() => buildGroups(sessions2, expandedKeys), [sessions2, expandedKeys]);
   const visibleItems = useMemo2(() => buildVisibleItems(groups), [groups]);
   const itemCountRef = useRef3(visibleItems.length);
   itemCountRef.current = visibleItems.length;
@@ -2085,7 +2486,7 @@ var useSessions = (allUsers, filter, archivedIds, viewingArchive) => {
     }
   }, []);
   return {
-    sessions,
+    sessions: sessions2,
     groups,
     visibleItems,
     selectedSession,
@@ -2106,24 +2507,32 @@ var MAX_EVENTS = 200;
 var useActivityStream = (session, allUsers) => {
   const [events, setEvents] = useState9([]);
   const watcherRef = useRef4(null);
-  const sessions = session === null ? [] : Array.isArray(session) ? session : [session];
-  const sessionKey = sessions.map((s) => s.sessionId).sort().join(",");
-  const sessionIdSet = new Set(sessions.map((s) => s.sessionId));
+  const sessions2 = session === null ? [] : Array.isArray(session) ? session : [session];
+  const sessionKey = sessions2.map((s) => s.sessionId).sort().join(",");
+  const sessionIdSet = new Set(sessions2.map((s) => s.sessionId));
   useEffect6(() => {
     setEvents([]);
-    if (sessions.length === 0) return;
-    const existingCalls = [];
-    const tempWatcher = new Watcher(() => {
-    }, allUsers);
-    const allFiles = sessions.flatMap((s) => s.outputFiles);
-    const seen = /* @__PURE__ */ new Set();
-    for (const file of allFiles) {
-      if (seen.has(file)) continue;
-      seen.add(file);
-      existingCalls.push(...tempWatcher.readExisting(file));
-    }
-    existingCalls.sort((a, b) => a.timestamp - b.timestamp);
-    setEvents(existingCalls.slice(-MAX_EVENTS));
+    if (sessions2.length === 0) return;
+    let cancelled = false;
+    const loadExisting = async () => {
+      const tempWatcher = new Watcher(() => {
+      }, allUsers);
+      const allFiles = sessions2.flatMap((s) => s.outputFiles);
+      const seen = /* @__PURE__ */ new Set();
+      const existingCalls = [];
+      for (const file of allFiles) {
+        if (cancelled) return;
+        if (seen.has(file)) continue;
+        seen.add(file);
+        if (cancelled) return;
+        const calls = await tempWatcher.readExistingAsync(file);
+        existingCalls.push(...calls);
+      }
+      if (cancelled) return;
+      existingCalls.sort((a, b) => a.timestamp - b.timestamp);
+      setEvents(existingCalls.slice(-MAX_EVENTS));
+    };
+    loadExisting();
     const handler = (calls) => {
       const matched = calls.filter((c) => sessionIdSet.has(c.sessionId));
       if (matched.length === 0) return;
@@ -2133,6 +2542,7 @@ var useActivityStream = (session, allUsers) => {
     watcherRef.current = watcher;
     watcher.start();
     return () => {
+      cancelled = true;
       watcher.stop();
       watcherRef.current = null;
     };
@@ -2507,6 +2917,14 @@ var useKeyHandler = (deps) => {
       return;
     }
     if (d.activePanel === "sessions") {
+      if (matchKey(d.kb.sidebarWider, input, key)) {
+        d.setSidebarWidth((w) => Math.min(w + 5, 60));
+        return;
+      }
+      if (matchKey(d.kb.sidebarNarrower, input, key)) {
+        d.setSidebarWidth((w) => Math.max(w - 5, 20));
+        return;
+      }
       if (matchKey(d.kb.navDown, input, key) || key.downArrow) d.selectNext();
       if (matchKey(d.kb.navUp, input, key) || key.upArrow) d.selectPrev();
     }
@@ -2537,19 +2955,19 @@ var useUpdateChecker = (disabled, checkOnLaunch, checkInterval) => {
   const [updateInfo, setUpdateInfo] = useState12(null);
   useEffect8(() => {
     if (disabled || !checkOnLaunch) return;
-    try {
-      const i = checkForUpdate();
-      if (i.available) setUpdateInfo(i);
-    } catch {
-    }
-    const iv = setInterval(() => {
-      try {
-        const i = checkForUpdate();
-        if (i.available) setUpdateInfo(i);
-      } catch {
-      }
-    }, checkInterval);
-    return () => clearInterval(iv);
+    let cancelled = false;
+    const check = () => {
+      checkForUpdate().then((i) => {
+        if (!cancelled && i.available) setUpdateInfo(i);
+      }).catch(() => {
+      });
+    };
+    check();
+    const iv = setInterval(check, checkInterval);
+    return () => {
+      cancelled = true;
+      clearInterval(iv);
+    };
   }, []);
   return updateInfo;
 };
@@ -2558,35 +2976,35 @@ var useUpdateChecker = (disabled, checkOnLaunch, checkInterval) => {
 import { useState as useState13, useCallback as useCallback4 } from "react";
 
 // src/hooks/installer.ts
-import { existsSync, readFileSync as readFileSync2, writeFileSync, copyFileSync, mkdirSync as mkdirSync2, chmodSync } from "fs";
-import { join as join2, dirname as dirname3 } from "path";
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync as mkdirSync2, chmodSync } from "fs";
+import { join as join3, dirname as dirname3 } from "path";
 import { homedir } from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var HOOK_FILENAME = "agenttop-guard.py";
-var SETTINGS_PATH = join2(homedir(), ".claude", "settings.json");
+var SETTINGS_PATH = join3(homedir(), ".claude", "settings.json");
 var getHookSource = () => {
   const thisFile = fileURLToPath2(import.meta.url);
-  const srcHooksDir = join2(dirname3(thisFile), "..", "src", "hooks");
-  const distHooksDir = join2(dirname3(thisFile), "hooks");
+  const srcHooksDir = join3(dirname3(thisFile), "..", "src", "hooks");
+  const distHooksDir = join3(dirname3(thisFile), "hooks");
   for (const dir of [distHooksDir, srcHooksDir]) {
-    const path = join2(dir, HOOK_FILENAME);
+    const path = join3(dir, HOOK_FILENAME);
     if (existsSync(path)) return path;
   }
-  const npmGlobalPath = join2(dirname3(thisFile), "..", "hooks", HOOK_FILENAME);
+  const npmGlobalPath = join3(dirname3(thisFile), "..", "hooks", HOOK_FILENAME);
   if (existsSync(npmGlobalPath)) return npmGlobalPath;
   throw new Error(`cannot find ${HOOK_FILENAME} \u2014 is agenttop installed correctly?`);
 };
 var getHookTarget = () => {
-  const claudeHooksDir = join2(homedir(), ".claude", "hooks");
+  const claudeHooksDir = join3(homedir(), ".claude", "hooks");
   mkdirSync2(claudeHooksDir, { recursive: true });
-  return join2(claudeHooksDir, HOOK_FILENAME);
+  return join3(claudeHooksDir, HOOK_FILENAME);
 };
 var readSettings = () => {
   if (!existsSync(SETTINGS_PATH)) {
     return {};
   }
   try {
-    return JSON.parse(readFileSync2(SETTINGS_PATH, "utf-8"));
+    return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -2653,20 +3071,20 @@ var uninstallHooks = () => {
 };
 
 // src/install-mcp.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
-import { join as join3 } from "path";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3 } from "fs";
+import { join as join4 } from "path";
 import { homedir as homedir2 } from "os";
 var installMcpConfig = () => {
-  const settingsPath = join3(homedir2(), ".claude", "settings.json");
+  const settingsPath = join4(homedir2(), ".claude", "settings.json");
   let settings = {};
   try {
-    settings = JSON.parse(readFileSync3(settingsPath, "utf-8"));
+    settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
   } catch {
   }
   const mcpServers = settings.mcpServers ?? {};
   mcpServers.agenttop = { command: "agenttop", args: ["--mcp"] };
   settings.mcpServers = mcpServers;
-  mkdirSync3(join3(homedir2(), ".claude"), { recursive: true });
+  mkdirSync3(join4(homedir2(), ".claude"), { recursive: true });
   writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   process.stdout.write("agenttop MCP server registered in Claude Code settings\n");
   process.stdout.write(`  settings: ${settingsPath}
@@ -2867,7 +3285,19 @@ var App = ({ options, config: initialConfig, version, firstRun }) => {
     null
   );
   const [archivedIds, setArchivedIds] = useState15(() => new Set(Object.keys(getArchived())));
+  const [sidebarWidth, setSidebarWidth] = useState15(() => initialConfig.sidebarWidth ?? 30);
   const refreshArchived = useCallback6(() => setArchivedIds(new Set(Object.keys(getArchived()))), []);
+  const persistSidebarWidth = useCallback6((v) => {
+    setSidebarWidth((prev) => {
+      const next = typeof v === "function" ? v(prev) : v;
+      if (next !== prev) {
+        const cfg = loadConfig();
+        cfg.sidebarWidth = next;
+        saveConfig(cfg);
+      }
+      return next;
+    });
+  }, []);
   const updateInfo = useUpdateChecker(
     options.noUpdates,
     setup.liveConfig.updates.checkOnLaunch,
@@ -2877,7 +3307,7 @@ var App = ({ options, config: initialConfig, version, firstRun }) => {
     applyTheme(resolveTheme(setup.liveConfig.theme, setup.liveConfig.customThemes));
   }, [setup.liveConfig.theme, setup.liveConfig.customThemes]);
   const {
-    sessions,
+    sessions: sessions2,
     visibleItems,
     selectedSession,
     selectedGroup,
@@ -3000,6 +3430,7 @@ var App = ({ options, config: initialConfig, version, firstRun }) => {
     setActivityScroll,
     setConfirmAction,
     setUpdateStatus,
+    setSidebarWidth: persistSidebarWidth,
     nicknameInput,
     filterInput,
     onNickname: (id) => {
@@ -3125,7 +3556,7 @@ var App = ({ options, config: initialConfig, version, firstRun }) => {
     }
   );
   return /* @__PURE__ */ jsxs15(Box15, { flexDirection: "column", height: termHeight, children: [
-    /* @__PURE__ */ jsx15(StatusBar, { sessionCount: sessions.length, alertCount: alerts.length, version, updateInfo }),
+    /* @__PURE__ */ jsx15(StatusBar, { sessionCount: sessions2.length, alertCount: alerts.length, version, updateInfo }),
     /* @__PURE__ */ jsxs15(Box15, { flexGrow: 1, height: mainHeight, children: [
       /* @__PURE__ */ jsx15(
         SessionList,
@@ -3136,7 +3567,8 @@ var App = ({ options, config: initialConfig, version, firstRun }) => {
           height: mainHeight,
           filter: filter || void 0,
           viewingArchive,
-          totalSessions: sessions.length
+          totalSessions: sessions2.length,
+          sidebarWidth
         }
       ),
       rightPanel
@@ -3176,11 +3608,11 @@ var formatTokens3 = (n) => {
 };
 var runStreamMode = (options, isJson) => {
   const engine = options.noSecurity ? null : new SecurityEngine(options.alertLevel);
-  const sessions = discoverSessions(options.allUsers);
+  const sessions2 = discoverSessions(options.allUsers);
   if (isJson) {
-    write(JSON.stringify({ type: "sessions", data: sessions }));
+    write(JSON.stringify({ type: "sessions", data: sessions2 }));
   } else {
-    for (const s of sessions) {
+    for (const s of sessions2) {
       write(
         `SESSION ${s.slug} | ${s.model} | ${s.cwd} | CPU ${s.cpu}% | ${s.memMB}MB | ${formatTokens3(s.usage.inputTokens)} in / ${formatTokens3(s.usage.outputTokens)} out`
       );
@@ -3236,8 +3668,8 @@ process.title = "agenttop";
 var getVersion = () => {
   try {
     const thisFile = fileURLToPath3(import.meta.url);
-    const pkgPath = join4(dirname4(thisFile), "..", "package.json");
-    const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+    const pkgPath = join5(dirname4(thisFile), "..", "package.json");
+    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
     return pkg.version || "0.0.0";
   } catch {
     return "0.0.0";