session-steward 0.1.1 → 0.2.0

package/lib/providers/codex/store.mjs

@@ -139,6 +139,12 @@ async function pathExists(targetPath) {
   }
 }
 
+function isContainedPath(rootDirectory, candidatePath) {
+  if (!candidatePath) return false;
+  const relativePath = path.relative(path.resolve(rootDirectory), path.resolve(candidatePath));
+  return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+
 async function readFirstLine(filePath) {
   const stream = createReadStream(filePath, {
     encoding: "utf8",
@@ -414,8 +420,11 @@ function deriveDisplayName({
 
 function getCodexPaths(codexHomeInput) {
   const codexHome = path.resolve(expandHome(codexHomeInput || "~/.codex"));
+  const archivedSessionsDirectory = path.join(codexHome, "archived_sessions");
+  const sessionsDirectory = path.join(codexHome, "sessions");
 
   return {
+    archivedSessionsDirectory,
     codexHome,
     desktopStateBackupPath: path.join(codexHome, ".codex-global-state.json.bak"),
     desktopStatePath: path.join(codexHome, ".codex-global-state.json"),
@@ -424,8 +433,9 @@ function getCodexPaths(codexHomeInput) {
     logsDatabasePath: path.join(codexHome, "logs_2.sqlite"),
     memoryDatabasePath: path.join(codexHome, "memories_1.sqlite"),
     sessionIndexPath: path.join(codexHome, "session_index.jsonl"),
-    sessionsDirectory: path.join(codexHome, "sessions"),
+    sessionsDirectory,
     stateDatabasePath: path.join(codexHome, "state_5.sqlite"),
+    transcriptDirectories: [sessionsDirectory, archivedSessionsDirectory],
   };
 }
 
@@ -584,21 +594,7 @@ export async function loadSessionStore({ codexHome }) {
       from thread_spawn_edges
     `,
   );
-  const transcriptHeaders = new Map();
-
-  for await (const transcriptFile of findTranscriptFiles(paths.sessionsDirectory)) {
-    try {
-      const header = await parseTranscriptHeader(transcriptFile);
-
-      const current = header?.id ? transcriptHeaders.get(header.id) : null;
-
-      if (header?.id && (!current || header.filePath > current.filePath)) {
-        transcriptHeaders.set(header.id, header);
-      }
-    } catch {
-      continue;
-    }
-  }
+  const transcriptHeaders = await indexTranscriptHeaders(paths.transcriptDirectories);
 
   const discoveryIds = new Set(threadRows.map((threadRow) => String(threadRow.id)));
 
@@ -698,7 +694,7 @@ export async function loadSessionStore({ codexHome }) {
     const record = {
       agentNickname: transcriptHeader.agentNickname,
       agentRole: transcriptHeader.agentRole,
-      archived: false,
+      archived: isContainedPath(paths.archivedSessionsDirectory, transcriptHeader.filePath),
       childThreadIds: childIdsByParentId.get(transcriptId) ?? [],
       createdAtMs: transcriptHeader.timestampMs,
       cwd: transcriptHeader.cwd,
@@ -898,25 +894,40 @@ export async function assertDeepCleanupSupported({ codexHome }) {
 
 const DEFAULT_PAGE_SIZE = 25;
 const MAX_PAGE_SIZE = 100;
+const OVERVIEW_STAT_BATCH_SIZE = 24;
 const SUPPORTING_THREAD_PREFIX = "The following is the Codex agent history whose request action you are assessing";
+const SESSION_CREATED_SQL = "coalesce(nullif(t.created_at_ms, 0), nullif(t.created_at, 0) * 1000, 0)";
+const SESSION_UPDATED_SQL = "coalesce(nullif(t.updated_at_ms, 0), nullif(t.updated_at, 0) * 1000, 0)";
+const SESSION_ACTIVITY_SQL = `coalesce(nullif(${SESSION_UPDATED_SQL}, 0), nullif(${SESSION_CREATED_SQL}, 0), 0)`;
 
 function getSessionOrder(sort) {
-  const updated = "coalesce(t.updated_at_ms, t.updated_at * 1000, 0)";
-  const created = "coalesce(t.created_at_ms, t.created_at * 1000, 0)";
   const name = "lower(coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), t.id))";
 
   return {
-    created: `${created} desc, t.id asc`,
-    cwd: `lower(coalesce(t.cwd, '')) asc, ${updated} desc, t.id asc`,
-    name: `${name} asc, ${updated} desc, t.id asc`,
-    updated: `${updated} desc, t.id asc`,
-  }[sort] ?? `${updated} desc, t.id asc`;
+    created: `${SESSION_CREATED_SQL} desc, t.id asc`,
+    cwd: `lower(coalesce(t.cwd, '')) asc, ${SESSION_ACTIVITY_SQL} desc, t.id asc`,
+    name: `${name} asc, ${SESSION_ACTIVITY_SQL} desc, t.id asc`,
+    updated: `${SESSION_ACTIVITY_SQL} desc, t.id asc`,
+  }[sort] ?? `${SESSION_ACTIVITY_SQL} desc, t.id asc`;
 }
 
-function getSessionConditions({ includeInternals, includeSupporting, search }) {
+function getSessionConditions({
+  archiveStatus,
+  inactiveBeforeMs,
+  includeInternals,
+  includeSupporting,
+  search,
+  workspace,
+}) {
   const conditions = [];
   const parameters = [];
 
+  if (archiveStatus === "active") {
+    conditions.push("coalesce(t.archived, 0) = 0");
+  } else if (archiveStatus === "archived") {
+    conditions.push("coalesce(t.archived, 0) <> 0");
+  }
+
   if (!includeInternals) {
     conditions.push(`not exists (
       select 1 from thread_spawn_edges edge where edge.child_thread_id = t.id
@@ -928,6 +939,16 @@ function getSessionConditions({ includeInternals, includeSupporting, search }) {
     parameters.push(`${SUPPORTING_THREAD_PREFIX}%`);
   }
 
+  if (Number.isFinite(inactiveBeforeMs) && inactiveBeforeMs > 0) {
+    conditions.push(`${SESSION_ACTIVITY_SQL} > 0 and ${SESSION_ACTIVITY_SQL} <= ?`);
+    parameters.push(Math.trunc(inactiveBeforeMs));
+  }
+
+  if (typeof workspace === "string") {
+    conditions.push("coalesce(t.cwd, '') = ?");
+    parameters.push(workspace);
+  }
+
   const normalizedSearch = normalizeText(search).toLowerCase();
 
   if (normalizedSearch) {
@@ -957,8 +978,8 @@ const SESSION_COLUMNS = `
   t.agent_role,
   t.archived,
   t.is_pinned,
-  coalesce(t.created_at_ms, t.created_at * 1000, 0) as created_at_ms,
-  coalesce(t.updated_at_ms, t.updated_at * 1000, 0) as updated_at_ms,
+  ${SESSION_CREATED_SQL} as created_at_ms,
+  ${SESSION_ACTIVITY_SQL} as updated_at_ms,
   (
     select edge.parent_thread_id
     from thread_spawn_edges edge
@@ -1061,19 +1082,21 @@ async function getStoreAvailability(paths) {
   };
 }
 
-async function indexTranscriptHeaders(sessionsDirectory) {
+async function indexTranscriptHeaders(transcriptDirectories) {
   const headersById = new Map();
 
-  for await (const transcriptFile of findTranscriptFiles(sessionsDirectory)) {
-    try {
-      const header = await parseTranscriptHeader(transcriptFile);
-      const current = header?.id ? headersById.get(String(header.id)) : null;
+  for (const transcriptDirectory of transcriptDirectories) {
+    for await (const transcriptFile of findTranscriptFiles(transcriptDirectory)) {
+      try {
+        const header = await parseTranscriptHeader(transcriptFile);
+        const current = header?.id ? headersById.get(String(header.id)) : null;
 
-      if (header?.id && (!current || header.filePath > current.filePath)) {
-        headersById.set(String(header.id), { ...header, id: String(header.id) });
+        if (header?.id && (!current || header.filePath > current.filePath)) {
+          headersById.set(String(header.id), { ...header, id: String(header.id) });
+        }
+      } catch {
+        continue;
       }
-    } catch {
-      continue;
     }
   }
 
@@ -1126,7 +1149,7 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
 
   const [availability, transcriptHeaders] = await Promise.all([
     getStoreAvailability(paths),
-    indexTranscriptHeaders(paths.sessionsDirectory),
+    indexTranscriptHeaders(paths.transcriptDirectories),
   ]);
   const transcriptChildrenByParentId = getTranscriptChildrenByParentId(transcriptHeaders);
   const pendingIds = [...selectedIds];
@@ -1218,7 +1241,7 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     recordsById.set(id, {
       agentNickname: header.agentNickname,
       agentRole: header.agentRole,
-      archived: false,
+      archived: isContainedPath(paths.archivedSessionsDirectory, header.filePath),
       childThreadIds: [...(childIdsByParentId.get(id) ?? [])].sort(),
       createdAtMs: header.timestampMs,
       cwd: header.cwd,
@@ -1306,20 +1329,30 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
 }
 
 export async function listSessions({
+  archiveStatus = "all",
   codexHome,
+  inactiveBeforeMs = null,
   includeInternals = false,
   includeSupporting = false,
   page = 1,
   pageSize = DEFAULT_PAGE_SIZE,
   search = "",
   sort = "updated",
+  workspace,
 }) {
   const paths = getCodexPaths(codexHome);
   const boundedPageSize = Number.isFinite(pageSize)
     ? Math.min(MAX_PAGE_SIZE, Math.max(1, Math.trunc(pageSize)))
     : DEFAULT_PAGE_SIZE;
   const requestedPage = Number.isFinite(page) ? Math.max(1, Math.trunc(page)) : 1;
-  const conditions = getSessionConditions({ includeInternals, includeSupporting, search });
+  const conditions = getSessionConditions({
+    archiveStatus,
+    inactiveBeforeMs,
+    includeInternals,
+    includeSupporting,
+    search,
+    workspace,
+  });
   const countRow = queryRows(
     paths.stateDatabasePath,
     `select count(*) as count from threads t ${conditions.sql}`,
@@ -1347,6 +1380,115 @@ export async function listSessions({
   };
 }
 
+async function measureTranscriptStorage(transcriptDirectories) {
+  let transcriptBytes = 0;
+  let transcriptFileCount = 0;
+  let unreadableFileCount = 0;
+  let pendingPaths = [];
+
+  const measurePendingPaths = async () => {
+    const pathsToMeasure = pendingPaths;
+    pendingPaths = [];
+    const results = await Promise.all(pathsToMeasure.map(async (filePath) => {
+      try {
+        return await fs.stat(filePath);
+      } catch {
+        return null;
+      }
+    }));
+
+    for (const stats of results) {
+      if (!stats?.isFile()) {
+        unreadableFileCount += 1;
+        continue;
+      }
+
+      transcriptBytes += stats.size;
+      transcriptFileCount += 1;
+    }
+  };
+
+  for (const transcriptDirectory of transcriptDirectories) {
+    for await (const transcriptPath of findTranscriptFiles(transcriptDirectory)) {
+      pendingPaths.push(transcriptPath);
+
+      if (pendingPaths.length >= OVERVIEW_STAT_BATCH_SIZE) {
+        await measurePendingPaths();
+      }
+    }
+  }
+
+  if (pendingPaths.length > 0) {
+    await measurePendingPaths();
+  }
+
+  return {
+    transcriptBytes,
+    transcriptFileCount,
+    unreadableFileCount,
+  };
+}
+
+export async function getSessionOverview({ codexHome }) {
+  const paths = getCodexPaths(codexHome);
+  const supportingPattern = `${SUPPORTING_THREAD_PREFIX}%`;
+  const overviewRow = queryRows(
+    paths.stateDatabasePath,
+    `select
+       count(*) as total,
+       coalesce(sum(case when coalesce(t.archived, 0) <> 0 then 1 else 0 end), 0) as archived_count,
+       coalesce(sum(case when coalesce(t.archived, 0) = 0 then 1 else 0 end), 0) as active_count,
+       count(children.child_thread_id) as subagent_count,
+       coalesce(sum(case
+         when children.child_thread_id is null
+           and not (coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), '') like ?)
+         then 1
+         else 0
+       end), 0) as primary_session_count,
+       coalesce(sum(case
+         when coalesce(nullif(trim(t.title), ''), nullif(trim(t.first_user_message), ''), '') like ? then 1
+         else 0
+       end), 0) as supporting_count,
+       coalesce(sum(case when ${SESSION_ACTIVITY_SQL} = 0 then 1 else 0 end), 0) as unknown_activity_count
+     from threads t
+     left join (
+       select distinct child_thread_id from thread_spawn_edges
+     ) children on children.child_thread_id = t.id`,
+    [supportingPattern, supportingPattern],
+  )[0] ?? {};
+  const workspaceRows = queryRows(
+    paths.stateDatabasePath,
+    `select
+       coalesce(t.cwd, '') as path,
+       count(*) as session_count,
+       max(${SESSION_ACTIVITY_SQL}) as last_activity_at_ms
+     from threads t
+     group by coalesce(t.cwd, '')
+     order by
+       case when coalesce(t.cwd, '') = '' then 1 else 0 end,
+       last_activity_at_ms desc,
+       lower(coalesce(t.cwd, '')) asc`,
+  );
+  const storage = await measureTranscriptStorage(paths.transcriptDirectories);
+
+  return {
+    activeSessionCount: Number(overviewRow.active_count ?? 0),
+    archivedSessionCount: Number(overviewRow.archived_count ?? 0),
+    calculatedAtMs: Date.now(),
+    primarySessionCount: Number(overviewRow.primary_session_count ?? 0),
+    sessionCount: Number(overviewRow.total ?? 0),
+    subagentCount: Number(overviewRow.subagent_count ?? 0),
+    supportingCount: Number(overviewRow.supporting_count ?? 0),
+    unknownActivityCount: Number(overviewRow.unknown_activity_count ?? 0),
+    workspaces: workspaceRows.map((row) => ({
+      lastActivityAtMs: toTimestampMs(row.last_activity_at_ms),
+      path: row.path ?? "",
+      sessionCount: Number(row.session_count ?? 0),
+    })),
+    ...storage,
+  };
+}
+
 export async function getSessionRecord({ codexHome, id }) {
   const paths = getCodexPaths(codexHome);
   const rows = queryRows(
@@ -1359,6 +1501,7 @@ export async function getSessionRecord({ codexHome, id }) {
 }
 
 export function filterAndSortSessions({
+  archiveStatus = "all",
   includeInternals,
   records,
   search,
@@ -1366,6 +1509,14 @@ export function filterAndSortSessions({
 }) {
   const normalizedSearch = normalizeText(search).toLowerCase();
   const filteredRecords = records.filter((record) => {
+    if (archiveStatus === "active" && record.archived) {
+      return false;
+    }
+
+    if (archiveStatus === "archived" && !record.archived) {
+      return false;
+    }
+
     if (!includeInternals && record.isSubagent) {
       return false;
     }
@@ -1477,6 +1628,33 @@ export async function planSessionDeletion({ recordIds, store }) {
     .map((record) => record.rolloutPath)
     .filter(Boolean);
   const deletionIdSet = new Set(deletionIds);
+  const requestedIdSet = new Set(recordIds);
+  const newestLinkedActivityAtMs = selectedRecords.reduce((newest, record) => {
+    if (requestedIdSet.has(record.id)) {
+      return newest;
+    }
+
+    return Math.max(newest, record.updatedAtMs ?? 0);
+  }, 0);
+  let transcriptBytes = 0;
+  let transcriptFileCount = 0;
+
+  for (const transcriptBatch of batches([...new Set(transcriptPaths)], OVERVIEW_STAT_BATCH_SIZE)) {
+    const results = await Promise.all(transcriptBatch.map(async (transcriptPath) => {
+      try {
+        return await fs.stat(transcriptPath);
+      } catch (error) {
+        if (error?.code === "ENOENT") return null;
+        throw error;
+      }
+    }));
+
+    for (const stats of results) {
+      if (!stats?.isFile()) continue;
+      transcriptBytes += stats.size;
+      transcriptFileCount += 1;
+    }
+  }
   const [historyMatches, sessionIndexMatches] = await Promise.all([
     inspectJsonlMatches(
       store.historyPath,
@@ -1522,9 +1700,12 @@ export async function planSessionDeletion({ recordIds, store }) {
     logRowCount,
     memoryRowCount,
     missingTranscriptPaths,
+    newestLinkedActivityAtMs,
     records: selectedRecords,
     sessionIndexMatchCount: sessionIndexMatches.count,
     spawnEdgeCount,
+    transcriptBytes,
+    transcriptFileCount,
     transcriptPaths,
   };
 }
@@ -2043,6 +2224,23 @@ function resolveContainedPath(rootDirectory, candidatePath) {
   return resolved;
 }
 
+export async function deleteSessionDeletionBackup({ backupDirectory, codexHome }) {
+  const backupRoot = path.join(codexHome, "session-steward-backups");
+  const resolvedBackupDirectory = resolveContainedPath(backupRoot, backupDirectory);
+
+  if (resolvedBackupDirectory === path.resolve(backupRoot)) {
+    throw new Error("Choose one recovery backup to delete.");
+  }
+
+  await fs.rm(resolvedBackupDirectory, {
+    force: true,
+    maxRetries: 3,
+    recursive: true,
+    retryDelay: 25,
+  });
+  return { backupDirectory: resolvedBackupDirectory };
+}
+
 async function atomicCopyFile(sourcePath, destinationPath) {
   await fs.mkdir(path.dirname(destinationPath), { recursive: true });
   const temporaryPath = `${destinationPath}.session-steward-${process.pid}-${Date.now()}.tmp`;