codesesh 0.1.5 → 0.2.0

package/dist/index.js

@@ -1,10 +1,14 @@
 #!/usr/bin/env node
 import {
   createRegisteredAgents,
+  filterSessions,
   getAgentInfoMap,
+  getCursorDataPath,
   perf,
-  scanSessionsAsync
-} from "./chunk-FG2FZIU5.js";
+  resolveProviderRoots,
+  saveCachedSessions,
+  scanSessions
+} from "./chunk-2UNXB2D3.js";
 
 // src/index.ts
 import { defineCommand, runMain } from "citty";
@@ -22,20 +26,62 @@ import { fileURLToPath } from "url";
 import { Hono } from "hono";
 
 // src/api/handlers.ts
-function handleGetAgents(c, scanResult) {
-  const counts = {};
-  for (const agent of scanResult.agents) {
-    counts[agent.name] = scanResult.byAgent[agent.name]?.length ?? 0;
-  }
+function getTotalTokens(stats) {
+  return stats.total_tokens ?? stats.total_input_tokens + stats.total_output_tokens;
+}
+function getSessionActivityTime(session) {
+  return session.time_updated ?? session.time_created;
+}
+function parseDateParam(value, fallback) {
+  if (value == null) return fallback;
+  const ts = new Date(value).getTime();
+  return Number.isNaN(ts) ? fallback : ts;
+}
+function filterSessionsByWindow(sessions, from, to) {
+  if (from == null && to == null) return sessions;
+  return sessions.filter((s) => {
+    if (from != null && s.time_created < from) return false;
+    if (to != null && s.time_created > to) return false;
+    return true;
+  });
+}
+function filterSessionsByActivityWindow(sessions, from, to) {
+  if (from == null && to == null) return sessions;
+  return sessions.filter((session) => {
+    const activity = getSessionActivityTime(session);
+    if (from != null && activity < from) return false;
+    if (to != null && activity > to) return false;
+    return true;
+  });
+}
+function handleGetConfig(c, defaults) {
+  return c.json({
+    window: {
+      from: defaults.from,
+      to: defaults.to,
+      days: defaults.days
+    }
+  });
+}
+function handleGetAgents(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
+  const { from, to } = defaults;
+  const counts = Object.fromEntries(
+    Object.entries(scanResult.byAgent).map(([agentName, sessions]) => [
+      agentName,
+      filterSessionsByWindow(sessions, from, to).length
+    ])
+  );
   const info = getAgentInfoMap(counts);
   return c.json(info);
 }
-function handleGetSessions(c, scanResult) {
+function handleGetSessions(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
   const agent = c.req.query("agent");
   const q = c.req.query("q")?.toLowerCase();
   const cwd = c.req.query("cwd")?.toLowerCase();
-  const from = c.req.query("from");
-  const to = c.req.query("to");
+  const from = parseDateParam(c.req.query("from"), defaults.from);
+  const to = parseDateParam(c.req.query("to"), defaults.to);
   let sessions = [];
   if (agent && scanResult.byAgent[agent]) {
     sessions = [...scanResult.byAgent[agent]];
@@ -45,24 +91,19 @@ function handleGetSessions(c, scanResult) {
   if (cwd) {
     sessions = sessions.filter((s) => s.directory.toLowerCase().includes(cwd));
   }
-  if (from) {
-    const fromTs = new Date(from).getTime();
-    if (!Number.isNaN(fromTs)) {
-      sessions = sessions.filter((s) => s.time_created >= fromTs);
-    }
+  if (from != null) {
+    sessions = sessions.filter((s) => s.time_created >= from);
   }
-  if (to) {
-    const toTs = new Date(to).getTime();
-    if (!Number.isNaN(toTs)) {
-      sessions = sessions.filter((s) => s.time_created <= toTs);
-    }
+  if (to != null) {
+    sessions = sessions.filter((s) => s.time_created <= to);
   }
   if (q) {
     sessions = sessions.filter((s) => s.title.toLowerCase().includes(q));
   }
   return c.json({ sessions });
 }
-async function handleGetSessionData(c, scanResult) {
+async function handleGetSessionData(c, scanSource) {
+  const scanResult = scanSource.getSnapshot();
   const agentName = c.req.param("agent");
   const sessionId = c.req.param("id");
   if (!sessionId) {
@@ -80,13 +121,178 @@ async function handleGetSessionData(c, scanResult) {
     return c.json({ error: message }, 500);
   }
 }
+function toLocalDateKey(ts) {
+  const d = new Date(ts);
+  const year = d.getFullYear();
+  const month = `${d.getMonth() + 1}`.padStart(2, "0");
+  const day = `${d.getDate()}`.padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function startOfLocalDay(ts) {
+  const d = new Date(ts);
+  d.setHours(0, 0, 0, 0);
+  return d.getTime();
+}
+function resolveDashboardWindow(defaults, queryDays, queryFrom, queryTo) {
+  const now = Date.now();
+  const todayStart = startOfLocalDay(now);
+  const toTs = parseDateParam(queryTo, defaults.to) ?? todayStart + 24 * 60 * 60 * 1e3 - 1;
+  const parsedDays = queryDays ? parseInt(queryDays, 10) : NaN;
+  let days = Number.isFinite(parsedDays) && parsedDays > 0 ? parsedDays : defaults.days;
+  const fromFromQuery = parseDateParam(queryFrom, void 0);
+  let fromTs;
+  if (fromFromQuery != null) {
+    fromTs = startOfLocalDay(fromFromQuery);
+    days ??= Math.max(1, Math.ceil((todayStart - fromTs) / 864e5) + 1);
+  } else if (days && days > 0) {
+    fromTs = todayStart - (days - 1) * 864e5;
+  } else if (defaults.from != null) {
+    fromTs = startOfLocalDay(defaults.from);
+    days = Math.max(1, Math.ceil((todayStart - fromTs) / 864e5) + 1);
+  } else {
+    days = 30;
+    fromTs = todayStart - (days - 1) * 864e5;
+  }
+  return { from: fromTs, to: toTs, days };
+}
+function handleGetDashboard(c, scanSource, defaults = {}) {
+  const scanResult = scanSource.getSnapshot();
+  const { from, to, days } = resolveDashboardWindow(
+    defaults,
+    c.req.query("days"),
+    c.req.query("from"),
+    c.req.query("to")
+  );
+  const windowed = filterSessionsByActivityWindow(scanResult.sessions, from, to);
+  const agentInfo = getAgentInfoMap(
+    Object.fromEntries(
+      Object.entries(scanResult.byAgent).map(([name, sessions]) => [
+        name,
+        filterSessionsByActivityWindow(sessions, from, to).length
+      ])
+    )
+  );
+  const agentInfoMap = new Map(agentInfo.map((a) => [a.name, a]));
+  let totalMessages = 0;
+  let totalTokens = 0;
+  let totalCost = 0;
+  let latestActivity = 0;
+  for (const session of windowed) {
+    totalMessages += session.stats.message_count;
+    totalTokens += getTotalTokens(session.stats);
+    totalCost += session.stats.total_cost ?? 0;
+    const activity = getSessionActivityTime(session);
+    if (activity > latestActivity) latestActivity = activity;
+  }
+  const perAgent = Object.entries(scanResult.byAgent).map(([name, sessions]) => {
+    const info = agentInfoMap.get(name);
+    const agentWindowed = filterSessionsByActivityWindow(sessions, from, to);
+    let messages = 0;
+    let tokens = 0;
+    for (const s of agentWindowed) {
+      messages += s.stats.message_count;
+      tokens += getTotalTokens(s.stats);
+    }
+    return {
+      name,
+      displayName: info?.displayName ?? name,
+      icon: info?.icon ?? "",
+      sessions: agentWindowed.length,
+      messages,
+      tokens
+    };
+  }).filter((item) => item.sessions > 0).sort((a, b) => b.sessions - a.sessions);
+  const dailyMap = /* @__PURE__ */ new Map();
+  const bucketStart = startOfLocalDay(from);
+  for (let i = 0; i < days; i += 1) {
+    const ts = bucketStart + i * 864e5;
+    const key = toLocalDateKey(ts);
+    dailyMap.set(key, { date: key, sessions: 0, messages: 0 });
+  }
+  for (const session of windowed) {
+    const key = toLocalDateKey(getSessionActivityTime(session));
+    const bucket = dailyMap.get(key);
+    if (bucket) {
+      bucket.sessions += 1;
+      bucket.messages += session.stats.message_count;
+    }
+  }
+  const dailyActivity = [...dailyMap.values()];
+  const recentSessions = [...windowed].sort((a, b) => getSessionActivityTime(b) - getSessionActivityTime(a)).slice(0, 10).map((session) => {
+    const agentKey = session.slug.split("/")[0] ?? "unknown";
+    return { ...session, agentName: agentKey };
+  });
+  const data = {
+    totals: {
+      sessions: windowed.length,
+      messages: totalMessages,
+      tokens: totalTokens,
+      cost: totalCost,
+      latestActivity: latestActivity || void 0
+    },
+    perAgent,
+    dailyActivity,
+    recentSessions,
+    window: { from, to, days }
+  };
+  return c.json(data);
+}
 
 // src/api/routes.ts
-function createApiRoutes(scanResult) {
+function createSseResponse(store, signal) {
+  const encoder = new TextEncoder();
+  return new Response(
+    new ReadableStream({
+      start(controller) {
+        const write = (event, data) => {
+          controller.enqueue(encoder.encode(`event: ${event}
+`));
+          controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+        };
+        write("connected", { timestamp: Date.now() });
+        const unsubscribe = store.subscribe((event) => {
+          write(event.type, event);
+        });
+        const heartbeat = setInterval(() => {
+          controller.enqueue(encoder.encode(": keepalive\n\n"));
+        }, 15e3);
+        const close = () => {
+          clearInterval(heartbeat);
+          unsubscribe();
+          controller.close();
+        };
+        signal.addEventListener("abort", close, { once: true });
+      },
+      cancel() {
+        return;
+      }
+    }),
+    {
+      headers: {
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        "Content-Type": "text/event-stream"
+      }
+    }
+  );
+}
+function createApiRoutes(scanSource, store, options = {}) {
   const api = new Hono();
-  api.get("/agents", (c) => handleGetAgents(c, scanResult));
-  api.get("/sessions", (c) => handleGetSessions(c, scanResult));
-  api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanResult));
+  const listDefaults = {
+    from: options.defaultSessionFrom,
+    to: options.defaultSessionTo,
+    days: options.defaultSessionDays
+  };
+  api.get("/config", (c) => handleGetConfig(c, listDefaults));
+  api.get("/agents", (c) => handleGetAgents(c, scanSource, listDefaults));
+  api.get("/sessions", (c) => handleGetSessions(c, scanSource, listDefaults));
+  api.get("/sessions/:agent/:id", (c) => handleGetSessionData(c, scanSource));
+  api.get("/dashboard", (c) => handleGetDashboard(c, scanSource, listDefaults));
+  if (store) {
+    api.get("/events", (c) => createSseResponse(store, c.req.raw.signal));
+  }
   return api;
 }
 
@@ -103,31 +309,370 @@ function findWebDistPath() {
   }
   return null;
 }
-async function createServer(port, scanResult) {
+function waitForListening(server) {
+  return new Promise((resolve3, reject) => {
+    const handleListening = () => {
+      server.off("error", handleError);
+      resolve3();
+    };
+    const handleError = (error) => {
+      server.off("listening", handleListening);
+      reject(error);
+    };
+    server.once("listening", handleListening);
+    server.once("error", handleError);
+  });
+}
+function getServerStartupErrorMessage(error, port) {
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "EADDRINUSE") {
+    return `Port ${port} \u5DF2\u88AB\u5360\u7528\uFF0C\u8BF7\u5173\u95ED\u73B0\u6709 CodeSesh \u8FDB\u7A0B\u6216\u6539\u7528 --port \u6307\u5B9A\u5176\u4ED6\u7AEF\u53E3\u3002`;
+  }
+  return error instanceof Error ? error.message : `\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25: ${String(error)}`;
+}
+async function createServer(port, store, options = {}) {
   const app = new Hono2();
   app.use("*", logger());
-  app.route("/api", createApiRoutes(scanResult));
+  const routeOptions = {
+    defaultSessionFrom: options.defaultSessionFrom,
+    defaultSessionTo: options.defaultSessionTo,
+    defaultSessionDays: options.defaultSessionDays
+  };
+  app.route(
+    "/api",
+    createApiRoutes(
+      store,
+      "subscribe" in store ? store : void 0,
+      routeOptions
+    )
+  );
   const webDistPath = findWebDistPath();
   if (webDistPath) {
     app.use("/*", serveStatic({ root: webDistPath }));
     app.get("/*", serveStatic({ root: webDistPath, path: "index.html" }));
   }
   const server = serve({ fetch: app.fetch, port });
+  try {
+    await waitForListening(server);
+  } catch (error) {
+    server.close();
+    if (store.shutdown) {
+      await store.shutdown();
+    }
+    throw new Error(getServerStartupErrorMessage(error, port));
+  }
   const url = `http://localhost:${port}`;
   return {
     url,
-    shutdown: () => server.close()
+    shutdown: () => {
+      server.close();
+      if (store.shutdown) {
+        void store.shutdown();
+      }
+    }
   };
 }
 
+// src/live-scan.ts
+import { existsSync as existsSync2 } from "fs";
+import { dirname as dirname2, isAbsolute, join } from "path";
+import chokidar from "chokidar";
+function sortSessions(sessions) {
+  return [...sessions].sort(
+    (a, b) => (b.time_updated ?? b.time_created) - (a.time_updated ?? a.time_created)
+  );
+}
+function sessionSignature(session) {
+  return JSON.stringify([
+    session.title,
+    session.directory,
+    session.time_created,
+    session.time_updated ?? session.time_created,
+    session.stats.message_count,
+    session.stats.total_input_tokens,
+    session.stats.total_output_tokens,
+    session.stats.total_cost,
+    session.stats.total_tokens ?? 0
+  ]);
+}
+function buildAgentCacheMeta(agent) {
+  const metaMap = agent.getSessionMetaMap?.();
+  const meta = {};
+  if (!metaMap) return meta;
+  for (const [id, data] of metaMap.entries()) {
+    meta[id] = { id, ...data };
+  }
+  return meta;
+}
+function buildUpdateEvent(agentName, previousSessions, nextSessions) {
+  const previousMap = new Map(previousSessions.map((session) => [session.id, session]));
+  const nextMap = new Map(nextSessions.map((session) => [session.id, session]));
+  let newSessions = 0;
+  let updatedSessions = 0;
+  let removedSessions = 0;
+  for (const [id, session] of nextMap.entries()) {
+    const previous = previousMap.get(id);
+    if (!previous) {
+      newSessions += 1;
+      continue;
+    }
+    if (sessionSignature(previous) !== sessionSignature(session)) {
+      updatedSessions += 1;
+    }
+  }
+  for (const id of previousMap.keys()) {
+    if (!nextMap.has(id)) {
+      removedSessions += 1;
+    }
+  }
+  if (newSessions === 0 && updatedSessions === 0 && removedSessions === 0) {
+    return null;
+  }
+  return {
+    type: "sessions-updated",
+    changedAgents: [agentName],
+    newSessions,
+    updatedSessions,
+    removedSessions,
+    totalSessions: nextSessions.length,
+    timestamp: Date.now()
+  };
+}
+function closestWatchablePath(targetPath) {
+  if (!isAbsolute(targetPath) && !existsSync2(targetPath)) {
+    return null;
+  }
+  let current = targetPath;
+  while (!existsSync2(current)) {
+    const parent = dirname2(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+  return current;
+}
+function resolveAgentWatchTargets(agentName) {
+  const roots = resolveProviderRoots();
+  const cursorDataPath = getCursorDataPath();
+  switch (agentName) {
+    case "claudecode":
+      return [
+        { path: join(roots.claudeRoot, "projects"), depth: 2 },
+        { path: "data/claudecode", depth: 2 }
+      ];
+    case "codex":
+      return [{ path: join(roots.codexRoot, "sessions"), depth: 4 }];
+    case "cursor":
+      return cursorDataPath ? [
+        { path: join(cursorDataPath, "globalStorage", "state.vscdb") },
+        { path: join(cursorDataPath, "workspaceStorage"), depth: 2 }
+      ] : [];
+    case "kimi":
+      return [
+        { path: join(roots.kimiRoot, "sessions"), depth: 2 },
+        { path: "data/kimi", depth: 2 }
+      ];
+    case "opencode":
+      return [
+        { path: join(roots.opencodeRoot, "opencode.db") },
+        { path: "data/opencode/opencode.db" }
+      ];
+    default:
+      return [];
+  }
+}
+var LiveScanStore = class {
+  constructor(watchEnabled = true, scanOptions = {}) {
+    this.watchEnabled = watchEnabled;
+    this.scanOptions = scanOptions;
+  }
+  watchEnabled;
+  scanOptions;
+  agents = [];
+  byAgent = {};
+  sessions = [];
+  listeners = /* @__PURE__ */ new Set();
+  refreshTimers = /* @__PURE__ */ new Map();
+  refreshTimestamps = /* @__PURE__ */ new Map();
+  refreshInFlight = /* @__PURE__ */ new Set();
+  pendingRefreshes = /* @__PURE__ */ new Set();
+  watchers = [];
+  async initialize() {
+    const initialResult = await scanSessions({
+      ...this.scanOptions,
+      useCache: true,
+      smartRefresh: false
+    });
+    const knownAgents = createRegisteredAgents();
+    const agentMap = /* @__PURE__ */ new Map();
+    const allowedAgents = this.getAllowedAgents();
+    for (const agent of initialResult.agents) {
+      agentMap.set(agent.name, agent);
+    }
+    for (const agent of knownAgents) {
+      if (!agentMap.has(agent.name)) {
+        agentMap.set(agent.name, agent);
+      }
+    }
+    this.agents = [...agentMap.values()].filter((agent) => {
+      if (!allowedAgents) {
+        return true;
+      }
+      return allowedAgents.has(agent.name.toLowerCase());
+    });
+    for (const agent of this.agents) {
+      this.byAgent[agent.name] = sortSessions(initialResult.byAgent[agent.name] ?? []);
+      this.refreshTimestamps.set(agent.name, Date.now());
+    }
+    this.rebuildSessions();
+    if (this.watchEnabled) {
+      this.startWatching();
+    }
+  }
+  getSnapshot() {
+    return {
+      sessions: this.sessions,
+      byAgent: this.byAgent,
+      agents: this.agents
+    };
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async shutdown() {
+    for (const timer of this.refreshTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.refreshTimers.clear();
+    await Promise.all(this.watchers.map((watcher) => watcher.close()));
+    this.watchers = [];
+  }
+  emit(event) {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+  rebuildSessions() {
+    this.sessions = sortSessions(Object.values(this.byAgent).flat());
+  }
+  getAllowedAgents() {
+    if (!this.scanOptions.agents?.length) {
+      return null;
+    }
+    return new Set(this.scanOptions.agents.map((agent) => agent.toLowerCase()));
+  }
+  applyFilters(sessions) {
+    return filterSessions(sessions, this.scanOptions);
+  }
+  startWatching() {
+    for (const agent of this.agents) {
+      const rawTargets = resolveAgentWatchTargets(agent.name);
+      const watchTargets = rawTargets.map((target) => {
+        const watchPath = closestWatchablePath(target.path);
+        return watchPath ? { ...target, path: watchPath } : null;
+      }).filter((target) => target !== null).filter(
+        (target, index, items) => items.findIndex((item) => item.path === target.path && item.depth === target.depth) === index
+      );
+      if (watchTargets.length === 0) {
+        continue;
+      }
+      const watcher = chokidar.watch(
+        watchTargets.map((target) => target.path),
+        {
+          ignoreInitial: true,
+          awaitWriteFinish: {
+            stabilityThreshold: 250,
+            pollInterval: 100
+          },
+          depth: watchTargets.reduce(
+            (maxDepth, target) => Math.max(maxDepth, target.depth ?? 0),
+            0
+          )
+        }
+      );
+      watcher.on("all", () => {
+        this.scheduleRefresh(agent.name);
+      });
+      watcher.on("error", (error) => {
+        console.error(`[${agent.name}] File watcher failed:`, error);
+      });
+      this.watchers.push(watcher);
+    }
+  }
+  scheduleRefresh(agentName, delayMs = 200) {
+    const existing = this.refreshTimers.get(agentName);
+    if (existing) {
+      clearTimeout(existing);
+    }
+    const timer = setTimeout(() => {
+      this.refreshTimers.delete(agentName);
+      void this.refreshAgent(agentName);
+    }, delayMs);
+    this.refreshTimers.set(agentName, timer);
+  }
+  async refreshAgent(agentName) {
+    if (this.refreshInFlight.has(agentName)) {
+      this.pendingRefreshes.add(agentName);
+      return;
+    }
+    this.refreshInFlight.add(agentName);
+    try {
+      await this.runRefresh(agentName);
+    } finally {
+      this.refreshInFlight.delete(agentName);
+      if (this.pendingRefreshes.delete(agentName)) {
+        this.scheduleRefresh(agentName, 100);
+      }
+    }
+  }
+  async runRefresh(agentName) {
+    const agent = this.agents.find((item) => item.name === agentName);
+    if (!agent) {
+      return;
+    }
+    const previousSessions = this.byAgent[agentName] ?? [];
+    let nextSessions = previousSessions;
+    if (!agent.isAvailable()) {
+      nextSessions = [];
+      this.refreshTimestamps.set(agentName, Date.now());
+    } else if (previousSessions.length > 0 && agent.checkForChanges && agent.incrementalScan) {
+      const checkResult = await Promise.resolve(
+        agent.checkForChanges(this.refreshTimestamps.get(agentName) ?? 0, previousSessions)
+      );
+      this.refreshTimestamps.set(agentName, checkResult.timestamp);
+      if (!checkResult.hasChanges) {
+        return;
+      }
+      nextSessions = await Promise.resolve(
+        agent.incrementalScan(previousSessions, checkResult.changedIds ?? [])
+      );
+    } else {
+      nextSessions = await Promise.resolve(agent.scan());
+      this.refreshTimestamps.set(agentName, Date.now());
+    }
+    nextSessions = this.applyFilters(nextSessions);
+    saveCachedSessions(agentName, nextSessions, buildAgentCacheMeta(agent));
+    const event = buildUpdateEvent(agentName, previousSessions, nextSessions);
+    this.byAgent[agentName] = sortSessions(nextSessions);
+    this.rebuildSessions();
+    if (event) {
+      event.totalSessions = this.sessions.length;
+      this.emit(event);
+    }
+  }
+};
+
 // src/output.ts
 import { consola } from "consola";
 
 // src/version.ts
 import { readFileSync } from "fs";
-import { resolve as resolve2, dirname as dirname2 } from "path";
+import { resolve as resolve2, dirname as dirname3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname = dirname2(fileURLToPath2(import.meta.url));
+var __dirname = dirname3(fileURLToPath2(import.meta.url));
 var pkg = JSON.parse(readFileSync(resolve2(__dirname, "../package.json"), "utf-8"));
 var VERSION = pkg.version;
 
@@ -262,7 +807,7 @@ var main = defineCommand({
       perf.enable();
     }
     if (clearCache) {
-      const { clearCache: clear } = await import("./dist-ZF35YB7B.js");
+      const { clearCache: clear } = await import("./dist-6EV6SS6N.js");
       clear();
       console.log("Cache cleared.");
     }
@@ -278,27 +823,35 @@ var main = defineCommand({
     if (cwdFilter === ".") {
       cwdFilter = process.cwd();
     }
-    let fromTimestamp;
+    let listDefaultFrom;
+    let listDefaultDays;
     if (args.from) {
-      fromTimestamp = parseDateToTimestamp(args.from);
+      listDefaultFrom = parseDateToTimestamp(args.from);
     } else {
       const days = parseInt(args.days, 10);
       if (!Number.isNaN(days) && days > 0) {
-        fromTimestamp = Date.now() - days * 24 * 60 * 60 * 1e3;
+        listDefaultFrom = Date.now() - days * 24 * 60 * 60 * 1e3;
+        listDefaultDays = days;
       }
     }
+    const listDefaultTo = args.to ? parseDateToTimestamp(args.to) : void 0;
     const scanOptions = {
       agents: targetSession ? [targetSession.agent] : args.agent ? args.agent.split(",").map((a) => a.trim()) : void 0,
       cwd: cwdFilter,
-      from: fromTimestamp,
-      to: args.to ? parseDateToTimestamp(args.to) : void 0,
       useCache
     };
-    const result = await scanSessionsAsync(scanOptions);
+    const store = new LiveScanStore(!jsonOnly, scanOptions);
+    await store.initialize();
+    const result = store.getSnapshot();
     if (trace) {
       console.log(perf.getReport());
     }
     if (jsonOnly) {
+      const windowed = result.sessions.filter((s) => {
+        if (listDefaultFrom != null && s.time_created < listDefaultFrom) return false;
+        if (listDefaultTo != null && s.time_created > listDefaultTo) return false;
+        return true;
+      });
       const info = getAgentInfoMap(
         Object.fromEntries(Object.entries(result.byAgent).map(([k, v]) => [k, v.length]))
       );
@@ -309,15 +862,25 @@ var main = defineCommand({
           count,
           available: count > 0
         })),
-        sessions: result.sessions
+        sessions: windowed
       };
       console.log(JSON.stringify(output, null, 2));
       return;
     }
     const agents = createRegisteredAgents();
     printScanResults(agents, result);
-    const { url } = await createServer(port, result);
-    console.log(`  http://localhost:${port}`);
+    let url;
+    try {
+      ({ url } = await createServer(port, store, {
+        defaultSessionFrom: listDefaultFrom,
+        defaultSessionTo: listDefaultTo,
+        defaultSessionDays: listDefaultDays
+      }));
+    } catch (error) {
+      console.error(getServerStartupErrorMessage(error, port));
+      process.exit(1);
+    }
+    console.log(`  ${url}`);
     console.log("");
     if (!noOpen) {
       const open = (await import("open")).default;