session-steward 0.8.0 → 0.10.0

package/lib/providers/codex/store.mjs

@@ -1515,6 +1515,7 @@ export async function loadDeletionStore({ codexHome, recordIds }) {
     stateDatabasePath: paths.stateDatabasePath,
     stateDatabasePaths: paths.stateDatabasePaths,
     stateDatabases: paths.stateDatabases,
+    threadWriterLocksDirectory: paths.threadWriterLocksDirectory,
     resolvedDatabases: paths.resolvedDatabases,
     logsDatabasePaths: paths.logsDatabasePaths,
     memoryDatabasePaths: paths.memoryDatabasePaths,
@@ -1534,6 +1535,7 @@ export async function listSessions({
   inactiveBeforeMs = null,
   includeInternals = false,
   includeSupporting = false,
+  minimumTranscriptBytes = null,
   page = 1,
   pageSize = DEFAULT_PAGE_SIZE,
   refresh = false,
@@ -1548,7 +1550,12 @@ export async function listSessions({
     : DEFAULT_PAGE_SIZE;
   const requestedPage = Number.isFinite(page) ? Math.max(1, Math.trunc(page)) : 1;
   const resolvedSort = SESSION_SORTS.has(sort) ? sort : "updated";
-  if (paths.stateDatabases.length === 1 && resolvedSort !== "size" && !forceUnion) {
+  const resolvedMinimumTranscriptBytes = Number.isFinite(minimumTranscriptBytes)
+    && minimumTranscriptBytes > 0
+    ? Math.trunc(minimumTranscriptBytes)
+    : null;
+  const needsSizeIndex = resolvedSort === "size" || resolvedMinimumTranscriptBytes !== null;
+  if (paths.stateDatabases.length === 1 && !needsSizeIndex && !forceUnion) {
     const database = paths.stateDatabases[0];
     const conditions = getSessionConditions(database, {
       archiveStatus, inactiveBeforeMs, includeInternals, includeSupporting, search, workspace,
@@ -1583,6 +1590,7 @@ export async function listSessions({
   const ordered = [];
   const seenIds = paths.stateDatabases.length > 1 ? new Set() : null;
   const compactSizeIds = resolvedSort === "size" && paths.stateDatabases.length === 1;
+  const sizes = needsSizeIndex ? await getSessionSizeIndex(paths, { refresh }) : null;
   let compareSortRows = null;
   for (const database of paths.stateDatabases) {
     const conditions = getSessionConditions(database, {
@@ -1599,6 +1607,12 @@ export async function listSessions({
       const id = String(row.id);
       if (seenIds?.has(id)) continue;
       seenIds?.add(id);
+      if (resolvedMinimumTranscriptBytes !== null) {
+        const transcriptBytes = sizes.get(id);
+        if (!Number.isFinite(transcriptBytes) || transcriptBytes < resolvedMinimumTranscriptBytes) {
+          continue;
+        }
+      }
       if (compactSizeIds) {
         ordered.push(id);
         continue;
@@ -1609,7 +1623,6 @@ export async function listSessions({
     }
   }
   if (resolvedSort === "size") {
-    const sizes = await getSessionSizeIndex(paths, { refresh });
     ordered.sort((left, right) => compareSessionIdsBySize(
       compactSizeIds ? left : left.id,
       compactSizeIds ? right : right.id,
@@ -2445,13 +2458,14 @@ async function createOperationBackup({ onProgress, plan, scope, store }) {
   return backupDirectory;
 }
 
-function cleanupErrorWithBackup(error, backupDirectory) {
+function cleanupErrorWithBackup(error, backupDirectory, { mutationStarted = false } = {}) {
   const detail = error instanceof Error ? error.message : "The cleanup could not be completed.";
   const wrappedError = new Error(
     `Cleanup stopped after the backup was created. Backup: ${backupDirectory}. ${detail}`,
     { cause: error },
   );
   wrappedError.backupDirectory = backupDirectory;
+  wrappedError.mutationStarted = mutationStarted;
   return wrappedError;
 }
 
@@ -2643,7 +2657,7 @@ export async function executeSessionDeletion({
       skippedTranscriptPaths,
     };
   } catch (error) {
-    throw cleanupErrorWithBackup(error, backupDirectory);
+    throw cleanupErrorWithBackup(error, backupDirectory, { mutationStarted: true });
   }
 }
 

package/lib/server.mjs

@@ -1,18 +1,23 @@
 import { createServer } from "node:http";
 import { randomBytes } from "node:crypto";
-import { execFileSync } from "node:child_process";
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { getProvider, listProviders } from "./providers/index.mjs";
+import { getInstalledProductVersions } from "./installed-products.mjs";
 import {
   DEFAULT_SESSION_EVENT_LIMIT,
   MAX_SESSION_EVENT_LIMIT,
 } from "./session-event-reader.mjs";
 import { createProviderSettings } from "./settings.mjs";
 import { classifyInstalledVersion } from "./version-support.mjs";
-import { getCommandInvocation } from "./platform.mjs";
+import {
+  acquireSessionMutationLock,
+  executePreparedSessionCleanup,
+  prepareSessionCleanup,
+  SESSION_CLEANUP_REVIEW_REQUIRED,
+} from "./session-cleanup.mjs";
 
 const MAX_BODY_BYTES = 64 * 1024;
 const ALLOWED_SCOPES = new Set(["core", "deep"]);
@@ -21,9 +26,9 @@ const OPERATION_TTL_MS = 60 * 60 * 1000;
 const MAX_SAVED_PLANS = 20;
 const MAX_SAVED_OPERATIONS = 50;
 const PLAN_RECORD_SAMPLE_LIMIT = 20;
-const PLAN_REVIEW_REQUIRED = "DELETION_PLAN_REVIEW_REQUIRED";
+const PLAN_REVIEW_REQUIRED = SESSION_CLEANUP_REVIEW_REQUIRED;
 const SESSION_OVERVIEW_TTL_MS = 45 * 1000;
-const ALLOWED_INACTIVE_DAYS = new Set([30, 60, 90]);
+const MAX_INACTIVE_DAYS = 3_650;
 const ALLOWED_ARCHIVE_STATUSES = new Set(["all", "active", "archived"]);
 const ALLOWED_SORTS = new Set(["created", "cwd", "name", "size", "updated"]);
 const publicDirectory = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "dist");
@@ -31,47 +36,6 @@ const staticAssets = new Map([
   ["/", { fileName: "index.html", contentType: "text/html; charset=utf-8" }],
 ]);
 
-function readCommandVersion(command, args) {
-  try {
-    const invocation = getCommandInvocation(command, args);
-    return execFileSync(invocation.command, invocation.args, {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"],
-      windowsHide: invocation.windowsHide,
-    }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-
-async function getInstalledProductVersions() {
-  const versions = {
-    chatgptDesktop: null,
-    claudeCli: readCommandVersion("claude", ["--version"]),
-    claudeDesktop: null,
-    codexCli: readCommandVersion("codex", ["--version"]),
-  };
-
-  if (process.platform !== "darwin") {
-    return versions;
-  }
-
-  const chatGptInfoPath = "/Applications/ChatGPT.app/Contents/Info.plist";
-  const claudeInfoPath = "/Applications/Claude.app/Contents/Info.plist";
-  try {
-    await fs.access(chatGptInfoPath);
-    versions.chatgptDesktop = readCommandVersion("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleShortVersionString", chatGptInfoPath]);
-  } catch {
-  }
-  try {
-    await fs.access(claudeInfoPath);
-    versions.claudeDesktop = readCommandVersion("/usr/libexec/PlistBuddy", ["-c", "Print :CFBundleShortVersionString", claudeInfoPath]);
-  } catch {
-  }
-
-  return versions;
-}
-
 function providerOptions(providerId, home) {
   return providerId === "codex" ? { codexHome: home } : { claudeHome: home };
 }
@@ -220,8 +184,8 @@ function getInactiveBeforeMs(value) {
 
   const days = Number(value);
 
-  if (!ALLOWED_INACTIVE_DAYS.has(days)) {
-    throw new Error("Last activity must be 30, 60, or 90 days.");
+  if (!Number.isSafeInteger(days) || days < 1 || days > MAX_INACTIVE_DAYS) {
+    throw new Error(`Last activity must be a whole number between 1 and ${MAX_INACTIVE_DAYS} days.`);
   }
 
   return Date.now() - days * 24 * 60 * 60 * 1000;
@@ -490,72 +454,26 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
     operation.phase = "preflight";
     operation.progress = 2;
 
+    let releaseMutationLock;
     try {
       const provider = getProvider(savedPlan.providerId);
       const options = providerOptions(savedPlan.providerId, savedPlan.home);
-      let currentStore;
-
-      try {
-        currentStore = await provider.loadDeletionStore({
-          ...options,
-          recordIds: savedPlan.requestedIds,
-        });
-      } catch (error) {
-        if (error?.message === "One or more selected sessions are no longer available.") {
-          throw codedError(
-            "The selected sessions changed after this preview. Review the selection again.",
-            PLAN_REVIEW_REQUIRED,
-          );
-        }
-        throw error;
-      }
-
-      const currentPlan = await provider.planSessionDeletion({
-        recordIds: savedPlan.requestedIds,
-        store: currentStore,
-      });
-      const currentFingerprint = await provider.fingerprintSessionDeletion({
-        plan: currentPlan,
-        scope: savedPlan.scope,
-        store: currentStore,
-      });
-
-      if (currentFingerprint !== savedPlan.fingerprint) {
-        throw codedError(
-          "Session data changed after this preview. Review the selection again.",
-          PLAN_REVIEW_REQUIRED,
-        );
-      }
-
-      await provider.preflightSessionDeletion({
-        plan: currentPlan,
-        scope: savedPlan.scope,
-        store: currentStore,
-      });
-
-      if (savedPlan.scope === "deep") {
-        await provider.assertDeepCleanupSupported(options);
-      }
-
-      const result = await provider.executeSessionDeletion({
+      releaseMutationLock = await acquireSessionMutationLock({ options, provider });
+      const execution = await executePreparedSessionCleanup({
+        expectedFingerprint: savedPlan.fingerprint,
         onProgress: (update) => Object.assign(operation, update),
-        plan: currentPlan,
+        options,
+        provider,
+        recordIds: savedPlan.requestedIds,
         scope: savedPlan.scope,
         shouldCancel: () => operation.cancelRequested,
-        store: currentStore,
       });
+      const result = execution.deletion;
       operation.backupDirectory = result.backupDirectory;
       operation.backupDirectories = [result.backupDirectory];
       operation.result = summarizeDeletionResult(result);
       operation.canCancel = false;
-      operation.message = "Checking that cleanup completed";
-      operation.phase = "verification";
-      operation.progress = 94;
-      const verification = await provider.verifySessionDeletion({
-        plan: currentPlan,
-        scope: savedPlan.scope,
-        store: currentStore,
-      });
+      const verification = execution.verification;
       operation.verification = summarizeVerification(verification);
       operation.progress = 100;
 
@@ -596,6 +514,9 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
         operation.status = "failed";
       }
     } finally {
+      const terminalStatus = operation.status;
+      operation.status = "running";
+      await releaseMutationLock?.().catch(() => {});
       getProvider(savedPlan.providerId).invalidateSessionCache?.(
         providerOptions(savedPlan.providerId, savedPlan.home),
       );
@@ -604,6 +525,7 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
       deletionPlans.delete(savedPlan.id);
       operation.finishedAtMs = Date.now();
       if (activeOperationId === operation.id) activeOperationId = null;
+      operation.status = terminalStatus;
     }
   }
 
@@ -653,10 +575,14 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
     operation.status = "restoring";
     activeOperationId = operation.id;
     const task = (async () => {
+      let releaseMutationLock;
       try {
-        const restoreResult = await getProvider(operation.providerId).restoreSessionDeletionBackup({
+        const provider = getProvider(operation.providerId);
+        const options = providerOptions(operation.providerId, operation.home);
+        releaseMutationLock = await acquireSessionMutationLock({ options, provider });
+        const restoreResult = await provider.restoreSessionDeletionBackup({
           backupDirectory: operation.backupDirectory,
-          ...providerOptions(operation.providerId, operation.home),
+          ...options,
           onProgress: (update) => Object.assign(operation, update),
         });
         operation.restoreResult = restoreResult;
@@ -685,12 +611,16 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
         operation.message = "Restore could not be completed";
         operation.status = "restore-failed";
       } finally {
+        const terminalStatus = operation.status;
+        operation.status = "restoring";
+        await releaseMutationLock?.().catch(() => {});
         getProvider(operation.providerId).invalidateSessionCache?.(
           providerOptions(operation.providerId, operation.home),
         );
         invalidateSessionOverview();
         operation.finishedAtMs = Date.now();
         if (activeOperationId === operation.id) activeOperationId = null;
+        operation.status = terminalStatus;
       }
     })();
     activeTasks.add(task);
@@ -935,26 +865,23 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
         const home = settings.getHome(providerId);
         const options = providerOptions(providerId, home);
 
-        if (scope === "deep") {
-          await provider.assertDeepCleanupSupported(options);
-        }
-
-        const store = await provider.loadDeletionStore({
-          ...options,
+        const prepared = await prepareSessionCleanup({
+          options,
+          provider,
           recordIds: ids,
+          scope,
         });
-        const plan = await provider.planSessionDeletion({ recordIds: ids, store });
-        const preflight = await provider.preflightSessionDeletion({ plan, scope, store });
+        const { plan, preflight } = prepared;
         const id = randomBytes(18).toString("base64url");
         const expiresAtMs = Date.now() + PLAN_TTL_MS;
         const savedPlan = {
           home,
           consumed: false,
           expiresAtMs,
-          fingerprint: await provider.fingerprintSessionDeletion({ plan, scope, store }),
+          fingerprint: prepared.fingerprint,
           id,
           providerId,
-          requestedIds: ids,
+          requestedIds: prepared.requestedIds,
           scope,
         };
         removeExpiredEntries(deletionPlans, PLAN_TTL_MS, MAX_SAVED_PLANS);
@@ -1043,17 +970,24 @@ export async function startLocalServer({ claudeHome, codexHome, configDirectory,
           }
 
           mutationInProgress = true;
+          let releaseMutationLock;
+          let responsePayload;
           try {
+            const provider = getProvider(operation.providerId);
+            const options = providerOptions(operation.providerId, operation.home);
+            releaseMutationLock = await acquireSessionMutationLock({ options, provider });
             if (!(await removeOperationBackups(operation))) {
               throw new Error("The recovery backup could not be deleted.");
             }
             operation.backupDeleteError = null;
             operation.canRestore = false;
             if (operation.result) operation.result.recoveryBackupDeleted = true;
-            sendJson(response, 200, { operation: publicOperation(operation) });
+            responsePayload = { operation: publicOperation(operation) };
           } finally {
+            await releaseMutationLock?.().catch(() => {});
             mutationInProgress = false;
           }
+          sendJson(response, 200, responsePayload);
           return;
         }