npm - session-steward - Versions diffs - 0.9.0 → 0.10.1 - Mend

session-steward 0.9.0 → 0.10.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/CHANGELOG.md +14 -0
package/README.md +37 -49
package/bin/session-steward-mcp.mjs +4 -4
package/bin/session-steward-scheduler.mjs +61 -0
package/dist/assets/{index-C94A1O5c.js → index-BDiEQG6G.js} +1 -1
package/dist/index.html +1 -1
package/lib/cleanup-scheduler-service.mjs +205 -0
package/lib/cleanup-schedules.mjs +439 -0
package/lib/cli.mjs +145 -117
package/lib/installed-products.mjs +44 -0
package/lib/mcp.mjs +426 -416
package/lib/providers/claude-code/events.mjs +2 -0
package/lib/providers/claude-code/store.mjs +12 -3
package/lib/providers/codex/database-families.mjs +4 -2
package/lib/providers/codex/store.mjs +171 -25
package/lib/server.mjs +49 -115
package/lib/session-cleanup.mjs +540 -0
package/lib/settings.mjs +1 -0
package/package.json +3 -2

package/dist/index.html CHANGED Viewed

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width,initial-scale=1.0"/>
     <link href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Crect width='32' height='32' rx='8' fill='%23171717'/%3E%3Cpath d='M16 4 26 8v7c0 6-4 11-10 13C10 26 6 21 6 15V8Z' fill='%23f5f5f5'/%3E%3Cpath d='m9.5 16 2.2-2.2 3 3 6.5-6.5 2.2 2.2-8.7 8.7Z' fill='%23171717'/%3E%3C/svg%3E" rel="icon"/>
     <title>Session Steward</title>
-    <script type="module" crossorigin src="/assets/index-C94A1O5c.js"></script>
+    <script type="module" crossorigin src="/assets/index-BDiEQG6G.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CXq8Tw8T.css">
   </head>
   <body>

package/lib/cleanup-scheduler-service.mjs ADDED Viewed

@@ -0,0 +1,205 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+import { getDefaultConfigDirectory } from "./platform.mjs";
+const execFile = promisify(execFileCallback);
+const LABEL = "com.mallikcheripally.session-steward.cleanup";
+const WINDOWS_TASK_NAME = "Session Steward Cleanup";
+const RUNNER_PATH = fileURLToPath(new URL("../bin/session-steward-scheduler.mjs", import.meta.url));
+function xml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&apos;");
+}
+function systemdArgument(value) {
+  return `"${String(value)
+    .replaceAll("%", "%%")
+    .replaceAll("\\", "\\\\")
+    .replaceAll('"', '\\"')
+    .replaceAll("$", "\\$")
+    .replaceAll("`", "\\`")}"`;
+}
+function windowsArgument(value) {
+  return `"${String(value).replaceAll(/(\\*)"/gu, "$1$1\\\"").replaceAll(/(\\+)$/gu, "$1$1")}"`;
+}
+async function writePrivateFile(filePath, contents) {
+  await fs.mkdir(path.dirname(filePath), { mode: 0o700, recursive: true });
+  await fs.writeFile(filePath, contents, { encoding: "utf8", mode: 0o600 });
+}
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export function createCleanupSchedulerService({
+  configDirectory = getDefaultConfigDirectory(),
+  environment = process.env,
+  execute = execFile,
+  home = os.homedir(),
+  nodePath = process.execPath,
+  platform = process.platform,
+  runnerPath = RUNNER_PATH,
+  userId = typeof process.getuid === "function" ? process.getuid() : null,
+} = {}) {
+  const launchAgentPath = path.join(home, "Library", "LaunchAgents", `${LABEL}.plist`);
+  const xdgConfigHome = path.isAbsolute(environment.XDG_CONFIG_HOME || "")
+    ? environment.XDG_CONFIG_HOME
+    : path.join(home, ".config");
+  const systemdDirectory = path.join(xdgConfigHome, "systemd", "user");
+  const systemdServicePath = path.join(systemdDirectory, "session-steward-cleanup.service");
+  const systemdTimerPath = path.join(systemdDirectory, "session-steward-cleanup.timer");
+  async function command(commandName, args, { allowFailure = false } = {}) {
+    try {
+      await execute(commandName, args, { windowsHide: true });
+      return true;
+    } catch (error) {
+      if (allowFailure) return false;
+      throw new Error("Session Steward could not update the automatic cleanup scheduler.", {
+        cause: error,
+      });
+    }
+  }
+  async function start() {
+    if (platform === "darwin") {
+      if (!Number.isSafeInteger(userId)) throw new Error("Session Steward could not identify this user.");
+      const target = `gui/${userId}`;
+      await writePrivateFile(launchAgentPath, `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+  <key>Label</key><string>${LABEL}</string>
+  <key>ProgramArguments</key><array>
+    <string>${xml(nodePath)}</string>
+    <string>${xml(runnerPath)}</string>
+    <string>--run-due</string>
+    <string>--config-directory</string>
+    <string>${xml(configDirectory)}</string>
+  </array>
+  <key>RunAtLoad</key><true/>
+  <key>StartInterval</key><integer>900</integer>
+</dict></plist>
+`);
+      await command("launchctl", ["bootout", `${target}/${LABEL}`], { allowFailure: true });
+      await command("launchctl", ["bootstrap", target, launchAgentPath]);
+      await command("launchctl", ["enable", `${target}/${LABEL}`]);
+      return status();
+    }
+    if (platform === "linux") {
+      await writePrivateFile(systemdServicePath, `[Unit]
+Description=Session Steward automatic cleanup
+[Service]
+Type=oneshot
+ExecStart=${systemdArgument(nodePath)} ${systemdArgument(runnerPath)} --run-due --config-directory ${systemdArgument(configDirectory)}
+`);
+      await writePrivateFile(systemdTimerPath, `[Unit]
+Description=Run Session Steward automatic cleanup
+[Timer]
+OnBootSec=2min
+OnUnitActiveSec=15min
+Persistent=true
+[Install]
+WantedBy=timers.target
+`);
+      await command("systemctl", ["--user", "daemon-reload"]);
+      await command("systemctl", ["--user", "enable", "--now", "session-steward-cleanup.timer"]);
+      return status();
+    }
+    if (platform === "win32") {
+      const taskCommand = [
+        nodePath,
+        runnerPath,
+        "--run-due",
+        "--config-directory",
+        configDirectory,
+      ].map(windowsArgument).join(" ");
+      await command("schtasks", [
+        "/Create", "/F", "/SC", "MINUTE", "/MO", "15",
+        "/TN", WINDOWS_TASK_NAME,
+        "/TR", taskCommand,
+      ]);
+      return status();
+    }
+    throw new Error(`Automatic cleanup is not supported on ${platform}.`);
+  }
+  async function stop() {
+    if (platform === "darwin") {
+      if (Number.isSafeInteger(userId)) {
+        await command("launchctl", ["bootout", `gui/${userId}/${LABEL}`], {
+          allowFailure: true,
+        });
+      }
+      await fs.rm(launchAgentPath, { force: true });
+      return status();
+    }
+    if (platform === "linux") {
+      await command("systemctl", ["--user", "disable", "--now", "session-steward-cleanup.timer"], {
+        allowFailure: true,
+      });
+      await Promise.all([
+        fs.rm(systemdServicePath, { force: true }),
+        fs.rm(systemdTimerPath, { force: true }),
+      ]);
+      await command("systemctl", ["--user", "daemon-reload"], { allowFailure: true });
+      return status();
+    }
+    if (platform === "win32") {
+      await command("schtasks", ["/Delete", "/F", "/TN", WINDOWS_TASK_NAME], {
+        allowFailure: true,
+      });
+      return status();
+    }
+    return { platform, running: false, supported: false };
+  }
+  async function status() {
+    if (platform === "darwin") {
+      const running = Number.isSafeInteger(userId)
+        ? await command("launchctl", ["print", `gui/${userId}/${LABEL}`], { allowFailure: true })
+        : false;
+      return { platform, running, supported: true };
+    }
+    if (platform === "linux") {
+      const configured = await exists(systemdTimerPath);
+      const running = configured
+        ? await command("systemctl", ["--user", "is-active", "--quiet", "session-steward-cleanup.timer"], {
+          allowFailure: true,
+        })
+        : false;
+      return { platform, running, supported: true };
+    }
+    if (platform === "win32") {
+      const running = await command("schtasks", ["/Query", "/TN", WINDOWS_TASK_NAME], {
+        allowFailure: true,
+      });
+      return { platform, running, supported: true };
+    }
+    return { platform, running: false, supported: false };
+  }
+  return { start, status, stop };
+}

package/lib/cleanup-schedules.mjs ADDED Viewed

@@ -0,0 +1,439 @@
+import { randomBytes, randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { getProvider } from "./providers/index.mjs";
+import { runSessionCleanup } from "./session-cleanup.mjs";
+import { getDefaultConfigDirectory } from "./settings.mjs";
+const STATE_VERSION = 1;
+const MAX_SCHEDULES = 100;
+const MAX_SESSIONS_PER_RUN = 100;
+const RUN_CLAIM_TIMEOUT_MS = 6 * 60 * 60 * 1_000;
+const LOCK_TIMEOUT_MS = 5_000;
+const STALE_LOCK_MS = 60_000;
+const DAY_MS = 24 * 60 * 60 * 1_000;
+const MAX_DAY_COUNT = 3_650;
+const LEGACY_FREQUENCY_DAYS = Object.freeze({ daily: 1, weekly: 7 });
+const PROVIDERS = new Set(["codex", "claude-code"]);
+const ARCHIVE_STATUSES = new Set(["all", "active", "archived"]);
+const CLEANUP_MODES = new Set(["standard", "thorough"]);
+const SELECTION_ORDERS = new Set(["oldest", "largest"]);
+function emptyState() {
+  return { schedules: [], version: STATE_VERSION };
+}
+function requiredChoice(value, values, label) {
+  if (!values.has(value)) throw new Error(`${label} is not supported.`);
+  return value;
+}
+function optionalText(value, label, maximumLength) {
+  if (value === undefined || value === null || value === "") return null;
+  if (typeof value !== "string" || value.includes("\0") || value.length > maximumLength) {
+    throw new Error(`${label} is not valid.`);
+  }
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  return trimmed;
+}
+function requiredDayCount(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_DAY_COUNT) {
+    throw new Error(`${label} must be a whole number between 1 and ${MAX_DAY_COUNT}.`);
+  }
+  return value;
+}
+function normalizeDefinition(definition) {
+  if (!definition || typeof definition !== "object") {
+    throw new Error("Enter cleanup schedule settings.");
+  }
+  const name = optionalText(definition.name, "Schedule name", 100);
+  if (!name) throw new Error("Enter a schedule name.");
+  const provider = requiredChoice(definition.provider, PROVIDERS, "Provider");
+  const inactiveDays = requiredDayCount(definition.inactiveDays, "Inactivity period in days");
+  const runEveryDays = requiredDayCount(
+    definition.runEveryDays ?? LEGACY_FREQUENCY_DAYS[definition.frequency],
+    "Run interval in days",
+  );
+  const cleanupMode = requiredChoice(
+    definition.cleanupMode ?? "thorough",
+    CLEANUP_MODES,
+    "Cleanup mode",
+  );
+  const archiveStatus = requiredChoice(
+    definition.archiveStatus ?? "all",
+    ARCHIVE_STATUSES,
+    "Archive status",
+  );
+  const selectionOrder = requiredChoice(
+    definition.selectionOrder ?? "oldest",
+    SELECTION_ORDERS,
+    "Selection order",
+  );
+  const minimumTranscriptBytes = definition.minimumTranscriptBytes ?? null;
+  if (
+    minimumTranscriptBytes !== null
+    && (!Number.isSafeInteger(minimumTranscriptBytes) || minimumTranscriptBytes <= 0)
+  ) {
+    throw new Error("Minimum transcript bytes must be a positive whole number.");
+  }
+  const maxSessions = definition.maxSessions ?? 25;
+  if (!Number.isSafeInteger(maxSessions) || maxSessions < 1 || maxSessions > MAX_SESSIONS_PER_RUN) {
+    throw new Error(`Maximum sessions per run must be between 1 and ${MAX_SESSIONS_PER_RUN}.`);
+  }
+  const providerHomeOverride = definition.providerHomeOverride ?? null;
+  if (
+    providerHomeOverride !== null
+    && (
+      typeof providerHomeOverride !== "string"
+      || providerHomeOverride.includes("\0")
+      || !path.isAbsolute(providerHomeOverride)
+    )
+  ) {
+    throw new Error("Provider folder override is not valid.");
+  }
+  return {
+    archiveStatus,
+    cleanupMode,
+    enabled: definition.enabled !== false,
+    inactiveDays,
+    includeInternals: Boolean(definition.includeInternals),
+    includeSupporting: Boolean(definition.includeSupporting),
+    maxSessions,
+    minimumTranscriptBytes,
+    name,
+    provider,
+    providerHomeOverride,
+    runEveryDays,
+    selectionOrder,
+    workspace: optionalText(definition.workspace, "Workspace", 4_096),
+  };
+}
+function nextRunAt(schedule, now) {
+  return schedule.enabled ? now + schedule.runEveryDays * DAY_MS : null;
+}
+function normalizeStoredSchedule(schedule) {
+  if (Number.isSafeInteger(schedule?.runEveryDays)) return schedule;
+  const runEveryDays = LEGACY_FREQUENCY_DAYS[schedule?.frequency];
+  if (!runEveryDays) return schedule;
+  const { frequency: _frequency, ...rest } = schedule;
+  return { ...rest, runEveryDays };
+}
+async function readState(statePath) {
+  try {
+    const parsed = JSON.parse(await fs.readFile(statePath, "utf8"));
+    if (parsed?.version !== STATE_VERSION || !Array.isArray(parsed.schedules)) return emptyState();
+    return {
+      ...parsed,
+      schedules: parsed.schedules.map(normalizeStoredSchedule),
+    };
+  } catch (error) {
+    if (error?.code === "ENOENT" || error instanceof SyntaxError) return emptyState();
+    throw new Error("Session Steward could not read cleanup schedules.", { cause: error });
+  }
+}
+async function writeState(statePath, state) {
+  const directory = path.dirname(statePath);
+  const temporaryPath = path.join(
+    directory,
+    `.cleanup-schedules-${process.pid}-${randomBytes(8).toString("hex")}.tmp`,
+  );
+  await fs.mkdir(directory, { mode: 0o700, recursive: true });
+  let handle;
+  try {
+    handle = await fs.open(temporaryPath, "wx", 0o600);
+    await handle.writeFile(`${JSON.stringify(state, null, 2)}\n`, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = null;
+    await fs.rename(temporaryPath, statePath);
+  } catch (error) {
+    await handle?.close().catch(() => {});
+    await fs.rm(temporaryPath, { force: true }).catch(() => {});
+    throw new Error("Session Steward could not save cleanup schedules.", { cause: error });
+  }
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+async function acquireLock(lockPath) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
+    try {
+      await fs.mkdir(path.dirname(lockPath), { mode: 0o700, recursive: true });
+      return await fs.open(lockPath, "wx", 0o600);
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+      try {
+        const stats = await fs.stat(lockPath);
+        if (Date.now() - stats.mtimeMs > STALE_LOCK_MS) {
+          await fs.rm(lockPath, { force: true });
+          continue;
+        }
+      } catch (statError) {
+        if (statError?.code !== "ENOENT") throw statError;
+      }
+      await delay(25);
+    }
+  }
+  throw new Error("Cleanup schedules are busy. Try again shortly.");
+}
+function publicSchedule(schedule) {
+  const { providerHomeOverride: _providerHomeOverride, ...safe } = schedule;
+  return structuredClone(safe);
+}
+function privateSchedule(schedule) {
+  return structuredClone(schedule);
+}
+export function createCleanupScheduleStore({
+  configDirectory = getDefaultConfigDirectory(),
+  createId = randomUUID,
+  now = Date.now,
+} = {}) {
+  const statePath = path.join(configDirectory, "cleanup-schedules.json");
+  const lockPath = path.join(configDirectory, "cleanup-schedules.lock");
+  async function mutate(mutator) {
+    const lock = await acquireLock(lockPath);
+    try {
+      const state = await readState(statePath);
+      const value = await mutator(state);
+      await writeState(statePath, state);
+      return value;
+    } finally {
+      await lock.close().catch(() => {});
+      await fs.rm(lockPath, { force: true }).catch(() => {});
+    }
+  }
+  return {
+    async claim(id, { force = false } = {}) {
+      return mutate((state) => {
+        const schedule = state.schedules.find((item) => item.id === id);
+        if (!schedule) throw new Error("That cleanup schedule does not exist.");
+        const currentTime = now();
+        if (!schedule.enabled && !force) return null;
+        if (!force && schedule.nextRunAtMs > currentTime) return null;
+        if (
+          Number.isFinite(schedule.runningSinceMs)
+          && currentTime - schedule.runningSinceMs < RUN_CLAIM_TIMEOUT_MS
+        ) {
+          return null;
+        }
+        schedule.runningSinceMs = currentTime;
+        schedule.nextRunAtMs = nextRunAt(schedule, currentTime);
+        schedule.updatedAtMs = currentTime;
+        return privateSchedule(schedule);
+      });
+    },
+    async complete(id, run) {
+      return mutate((state) => {
+        const schedule = state.schedules.find((item) => item.id === id);
+        if (!schedule) return null;
+        schedule.lastRun = run;
+        schedule.runningSinceMs = null;
+        schedule.updatedAtMs = now();
+        return publicSchedule(schedule);
+      });
+    },
+    async list() {
+      const state = await readState(statePath);
+      return state.schedules.map(publicSchedule);
+    },
+    async remove(id) {
+      return mutate((state) => {
+        const index = state.schedules.findIndex((item) => item.id === id);
+        if (index < 0) throw new Error("That cleanup schedule does not exist.");
+        const [removed] = state.schedules.splice(index, 1);
+        return publicSchedule(removed);
+      });
+    },
+    async save(definition, { id } = {}) {
+      const normalized = normalizeDefinition(definition);
+      return mutate((state) => {
+        const currentTime = now();
+        if (id === undefined) {
+          if (state.schedules.length >= MAX_SCHEDULES) {
+            throw new Error(`Session Steward supports up to ${MAX_SCHEDULES} cleanup schedules.`);
+          }
+          const schedule = {
+            ...normalized,
+            createdAtMs: currentTime,
+            id: createId(),
+            lastRun: null,
+            nextRunAtMs: nextRunAt(normalized, currentTime),
+            runningSinceMs: null,
+            updatedAtMs: currentTime,
+          };
+          state.schedules.push(schedule);
+          return publicSchedule(schedule);
+        }
+        const index = state.schedules.findIndex((item) => item.id === id);
+        if (index < 0) throw new Error("That cleanup schedule does not exist.");
+        const existing = state.schedules[index];
+        const timingChanged = existing.runEveryDays !== normalized.runEveryDays
+          || existing.enabled !== normalized.enabled;
+        const schedule = {
+          ...existing,
+          ...normalized,
+          nextRunAtMs: timingChanged
+            ? nextRunAt(normalized, currentTime)
+            : existing.nextRunAtMs,
+          updatedAtMs: currentTime,
+        };
+        state.schedules[index] = schedule;
+        return publicSchedule(schedule);
+      });
+    },
+  };
+}
+function scheduleProviderOptions(schedule, settings) {
+  const home = schedule.providerHomeOverride ?? settings.getHome(schedule.provider);
+  if (schedule.provider === "codex") return { codexHome: home };
+  const options = { claudeHome: home };
+  if (typeof settings.getClaudeDesktopDataHome === "function") {
+    options.desktopDataHome = settings.getClaudeDesktopDataHome();
+  }
+  return options;
+}
+function listingOptions(schedule, settings, now) {
+  return {
+    archiveStatus: schedule.archiveStatus,
+    includeInternals: schedule.includeInternals,
+    includeSupporting: schedule.includeSupporting,
+    inactiveBeforeMs: now() - schedule.inactiveDays * DAY_MS,
+    minimumTranscriptBytes: schedule.minimumTranscriptBytes ?? undefined,
+    pageSize: schedule.maxSessions,
+    search: "",
+    sort: schedule.selectionOrder === "largest" ? "size" : "updated",
+    workspace: schedule.workspace ?? undefined,
+    ...scheduleProviderOptions(schedule, settings),
+  };
+}
+async function findCandidates(schedule, provider, settings, now) {
+  const options = listingOptions(schedule, settings, now);
+  if (options.sort === "size") {
+    const result = await provider.listSessions({ ...options, page: 1 });
+    return result.records.slice(0, schedule.maxSessions);
+  }
+  const first = await provider.listSessions({ ...options, page: 1 });
+  if (first.pageCount === 1) return [...first.records].reverse();
+  const oldest = await provider.listSessions({ ...options, page: first.pageCount });
+  const records = [...oldest.records].reverse();
+  if (records.length < schedule.maxSessions && first.pageCount > 1) {
+    const previous = await provider.listSessions({ ...options, page: first.pageCount - 1 });
+    records.push(...[...previous.records].reverse());
+  }
+  return records.slice(0, schedule.maxSessions);
+}
+function safeRunResult(result, candidateCount, atMs) {
+  return {
+    affectedSessionCount: result.affectedSessionCount,
+    atMs,
+    candidateCount,
+    cleanupFallback: result.cleanupFallback,
+    cleanupMode: result.cleanupMode,
+    deletedSessionCount: result.deletedSessionCount,
+    requestedCleanupMode: result.requestedCleanupMode,
+    status: result.status,
+    transcriptBytes: result.transcriptBytes,
+  };
+}
+export async function runCleanupSchedule({
+  cleanup = runSessionCleanup,
+  force = false,
+  id,
+  now = Date.now,
+  resolveProvider = getProvider,
+  scheduleStore,
+  settings,
+  signal,
+} = {}) {
+  const schedule = await scheduleStore.claim(id, { force });
+  if (!schedule) return { id, status: "not-due" };
+  const atMs = now();
+  let candidateCount = 0;
+  let run;
+  try {
+    const provider = resolveProvider(schedule.provider);
+    const candidates = await findCandidates(schedule, provider, settings, now);
+    candidateCount = candidates.length;
+    if (candidates.length === 0) {
+      run = {
+        affectedSessionCount: 0,
+        atMs,
+        candidateCount: 0,
+        deletedSessionCount: 0,
+        status: "no-matches",
+        transcriptBytes: 0,
+      };
+    } else {
+      const result = await cleanup({
+        options: scheduleProviderOptions(schedule, settings),
+        provider,
+        recordIds: candidates.map((record) => record.id),
+        scope: schedule.cleanupMode === "thorough" ? "deep" : "core",
+        signal,
+      });
+      run = safeRunResult(result, candidates.length, atMs);
+    }
+  } catch {
+    run = {
+      affectedSessionCount: 0,
+      atMs,
+      candidateCount,
+      deletedSessionCount: null,
+      status: "failed",
+      transcriptBytes: 0,
+    };
+  }
+  await scheduleStore.complete(schedule.id, run);
+  return { id: schedule.id, provider: schedule.provider, ...run };
+}
+export async function runDueCleanupSchedules({
+  cleanup = runSessionCleanup,
+  now = Date.now,
+  resolveProvider = getProvider,
+  scheduleStore,
+  settings,
+} = {}) {
+  const schedules = await scheduleStore.list();
+  const results = [];
+  for (const schedule of schedules) {
+    if (!schedule.enabled || schedule.nextRunAtMs > now()) continue;
+    results.push(await runCleanupSchedule({
+      cleanup,
+      id: schedule.id,
+      now,
+      resolveProvider,
+      scheduleStore,
+      settings,
+    }));
+  }
+  return results;
+}