getgloss 0.8.0 → 0.8.2

package/dist/server/daemon.js

@@ -1,5 +1,5 @@
 // src/server/daemon.ts
-import { rm as rm2 } from "fs/promises";
+import { rm as rm3 } from "fs/promises";
 import { serve } from "@hono/node-server";
 
 // src/shared/paths.ts
@@ -10,7 +10,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.8.0",
+  version: "0.8.2",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -211,6 +211,9 @@ function parseJsonValue(value, guard, label) {
 function isServerInfo(value) {
   return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir);
 }
+function isClearReviewsRequest(value) {
+  return isRecord(value) && isOptionalNonNegativeInteger(value.olderThanDays) && isOptionalBoolean(value.dryRun);
+}
 function isOpenFileRequest(value) {
   return isRecord(value) && isString(value.filePath) && isOptionalString(value.turnId);
 }
@@ -329,6 +332,12 @@ function isNumber(value) {
 function isOptionalNumber(value) {
   return value === void 0 || isNumber(value);
 }
+function isOptionalNonNegativeInteger(value) {
+  return value === void 0 || isNumber(value) && Number.isInteger(value) && value >= 0;
+}
+function isOptionalBoolean(value) {
+  return value === void 0 || isBoolean(value);
+}
 function isNullableNumber(value) {
   return value === null || isNumber(value);
 }
@@ -366,7 +375,7 @@ async function writeServerInfo(info) {
 }
 
 // src/server/index.ts
-import { readFile as readFile3, realpath, stat } from "fs/promises";
+import { readFile as readFile4, realpath, stat } from "fs/promises";
 import path5 from "path";
 import { fileURLToPath } from "url";
 import { Hono } from "hono";
@@ -601,10 +610,224 @@ async function openLocalPath(filePath) {
 
 // src/server/store.ts
 import { createHash } from "crypto";
-import { readdir, readFile as readFile2 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
 import path4 from "path";
 import { ulid } from "ulid";
 
+// src/shared/cleanup.ts
+import { readdir, readFile as readFile2, rm as rm2 } from "fs/promises";
+var DEFAULT_REVIEW_RETENTION_DAYS = 30;
+var clearableStatuses = /* @__PURE__ */ new Set(["submitted", "resolved", "cancelled"]);
+var millisecondsPerDay = 24 * 60 * 60 * 1e3;
+async function clearReviewArtifacts(options = {}) {
+  const olderThanDays = normalizeRetentionDays(options.olderThanDays);
+  const dryRun = options.dryRun === true;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const cutoff = new Date(now.getTime() - olderThanDays * millisecondsPerDay);
+  const reviewsDir = globalReviewsDir();
+  const candidates = [];
+  const deleted = [];
+  const skipped = [];
+  let entries;
+  try {
+    entries = await readdir(reviewsDir, { withFileTypes: true });
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return cleanupResult({
+        reviewsDir,
+        cutoff,
+        olderThanDays,
+        dryRun,
+        candidates,
+        deleted,
+        skipped
+      });
+    }
+    throw new Error(`Could not read reviews directory at ${reviewsDir}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const reviewId = entry.name;
+    const artifactDir = globalReviewDir(reviewId);
+    const candidate = await cleanupCandidate(reviewId, artifactDir, cutoff, skipped);
+    if (!candidate) {
+      continue;
+    }
+    candidates.push(candidate);
+    if (!dryRun) {
+      await rm2(artifactDir, { recursive: true, force: true });
+      deleted.push(candidate);
+    }
+  }
+  return cleanupResult({ reviewsDir, cutoff, olderThanDays, dryRun, candidates, deleted, skipped });
+}
+function normalizeRetentionDays(value) {
+  const days = value ?? DEFAULT_REVIEW_RETENTION_DAYS;
+  if (!Number.isInteger(days) || days < 0) {
+    throw new Error("olderThanDays must be a non-negative integer");
+  }
+  return days;
+}
+async function cleanupCandidate(reviewId, artifactDir, cutoff, skipped) {
+  let raw;
+  try {
+    raw = await readFile2(globalReviewMetaFile(reviewId), "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      skipped.push({ reviewId, artifactDir, reason: "missing metadata" });
+      return null;
+    }
+    skipped.push({ reviewId, artifactDir, reason: `unreadable metadata: ${formatError(error)}` });
+    return null;
+  }
+  let meta;
+  try {
+    meta = parseJson(raw, isStoredReviewMeta, "review metadata");
+  } catch (error) {
+    skipped.push({ reviewId, artifactDir, reason: `invalid metadata: ${formatError(error)}` });
+    return null;
+  }
+  if (meta.id !== reviewId) {
+    skipped.push({ reviewId, artifactDir, reason: `metadata id mismatch: ${meta.id}` });
+    return null;
+  }
+  if (!clearableStatuses.has(meta.status)) {
+    return null;
+  }
+  const turnState = await persistedTurnCleanupState(reviewId, artifactDir, skipped);
+  if (turnState === "preserve") {
+    return null;
+  }
+  const lastActivityAt = latestTimestamp([
+    ...metadataTimestamps(meta),
+    ...turnState === "none" ? [] : turnState.timestamps
+  ]);
+  if (!lastActivityAt) {
+    skipped.push({ reviewId, artifactDir, reason: "missing valid activity timestamp" });
+    return null;
+  }
+  if (Date.parse(lastActivityAt) >= cutoff.getTime()) {
+    return null;
+  }
+  return {
+    reviewId,
+    status: meta.status,
+    artifactDir,
+    lastActivityAt
+  };
+}
+async function persistedTurnCleanupState(reviewId, artifactDir, skipped) {
+  let entries;
+  try {
+    entries = await readdir(globalReviewTurnsDir(reviewId), { withFileTypes: true });
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return "none";
+    }
+    skipped.push({
+      reviewId,
+      artifactDir,
+      reason: `unreadable turns directory: ${formatError(error)}`
+    });
+    return "preserve";
+  }
+  const turnDirs = entries.filter((entry) => entry.isDirectory());
+  if (turnDirs.length === 0) {
+    return "none";
+  }
+  const timestamps = [];
+  for (const entry of turnDirs) {
+    const turn = await readPersistedTurnMeta(reviewId, entry.name, artifactDir, skipped);
+    if (!turn) {
+      return "preserve";
+    }
+    if (turn.status === "pending" || !clearableStatuses.has(turn.status)) {
+      return "preserve";
+    }
+    timestamps.push(turn.createdAt, turn.submittedAt, turn.resolvedAt);
+  }
+  return { timestamps };
+}
+async function readPersistedTurnMeta(reviewId, turnDirName, artifactDir, skipped) {
+  let raw;
+  try {
+    raw = await readFile2(globalReviewTurnMetaFile(reviewId, turnDirName), "utf8");
+  } catch (error) {
+    skipped.push({
+      reviewId,
+      artifactDir,
+      reason: `${isFileNotFound(error) ? "missing" : "unreadable"} turn metadata for ${turnDirName}${isFileNotFound(error) ? "" : `: ${formatError(error)}`}`
+    });
+    return null;
+  }
+  try {
+    const turn = parseJson(raw, isReviewTurnMeta, "review turn metadata");
+    if (turn.id !== turnDirName) {
+      skipped.push({
+        reviewId,
+        artifactDir,
+        reason: `turn metadata id mismatch for ${turnDirName}: ${turn.id}`
+      });
+      return null;
+    }
+    return turn;
+  } catch (error) {
+    skipped.push({
+      reviewId,
+      artifactDir,
+      reason: `invalid turn metadata for ${turnDirName}: ${formatError(error)}`
+    });
+    return null;
+  }
+}
+function metadataTimestamps(meta) {
+  return [
+    meta.createdAt,
+    meta.submittedAt,
+    meta.resolvedAt,
+    ...(meta.turns ?? []).flatMap((turn) => [
+      turn.createdAt,
+      turn.capturedAt,
+      turn.submittedAt,
+      turn.resolvedAt
+    ])
+  ];
+}
+function latestTimestamp(timestamps) {
+  const latest = Math.max(
+    ...timestamps.map((timestamp) => timestamp ? Date.parse(timestamp) : Number.NaN).filter((timestamp) => Number.isFinite(timestamp))
+  );
+  return Number.isFinite(latest) ? new Date(latest).toISOString() : null;
+}
+function cleanupResult({
+  reviewsDir,
+  cutoff,
+  olderThanDays,
+  dryRun,
+  candidates,
+  deleted,
+  skipped
+}) {
+  return {
+    reviewsDir,
+    cutoff: cutoff.toISOString(),
+    olderThanDays,
+    dryRun,
+    candidates,
+    deleted,
+    skipped,
+    counts: {
+      candidates: candidates.length,
+      deleted: deleted.length,
+      skipped: skipped.length
+    }
+  };
+}
+
 // src/shared/review-scope.ts
 var ALL_REVIEW_SCOPE = { mode: "all" };
 function normalizeReviewScope(diff, scope = ALL_REVIEW_SCOPE) {
@@ -789,6 +1012,15 @@ var ReviewStore = class {
     await this.loadAllReviews();
     return Array.from(this.reviews.values()).map((record) => record.meta).toSorted((a, b) => a.createdAt.localeCompare(b.createdAt));
   }
+  async clearReviewArtifacts(options = {}) {
+    const result = await clearReviewArtifacts(options);
+    if (!result.dryRun) {
+      for (const review of result.deleted) {
+        this.reviews.delete(review.reviewId);
+      }
+    }
+    return result;
+  }
   async get(id) {
     return this.reviews.get(id) ?? await this.loadKnownReview(id);
   }
@@ -1017,7 +1249,7 @@ var ReviewStore = class {
   async loadAllReviews() {
     let entries;
     try {
-      entries = await readdir(globalReviewsDir(), { withFileTypes: true });
+      entries = await readdir2(globalReviewsDir(), { withFileTypes: true });
     } catch (error) {
       if (isFileNotFound(error)) {
         return;
@@ -1041,7 +1273,7 @@ var ReviewStore = class {
     const metaPath = globalReviewMetaFile(id);
     let metaRaw;
     try {
-      metaRaw = await readFile2(metaPath, "utf8");
+      metaRaw = await readFile3(metaPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return this.loadReviewFromTurnsOnly(id);
@@ -1095,7 +1327,7 @@ var ReviewStore = class {
   async loadPersistedTurns(id) {
     let entries;
     try {
-      entries = await readdir(globalReviewTurnsDir(id), { withFileTypes: true });
+      entries = await readdir2(globalReviewTurnsDir(id), { withFileTypes: true });
     } catch (error) {
       if (isFileNotFound(error)) {
         return [];
@@ -1123,8 +1355,8 @@ var ReviewStore = class {
     let diffRaw;
     try {
       [metaRaw, diffRaw] = await Promise.all([
-        readFile2(metaPath, "utf8"),
-        readFile2(diffPath, "utf8")
+        readFile3(metaPath, "utf8"),
+        readFile3(diffPath, "utf8")
       ]);
     } catch (error) {
       if (isFileNotFound(error)) {
@@ -1154,7 +1386,7 @@ var ReviewStore = class {
     const diffPath = globalReviewDiffFile(id);
     let diffRaw;
     try {
-      diffRaw = await readFile2(diffPath, "utf8");
+      diffRaw = await readFile3(diffPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return null;
@@ -1369,7 +1601,7 @@ function requiredPath(value, label) {
 async function readOptionalJsonFile(filePath, guard, label) {
   let raw;
   try {
-    raw = await readFile2(filePath, "utf8");
+    raw = await readFile3(filePath, "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       return void 0;
@@ -1417,6 +1649,15 @@ function createApp(origin2, options = {}) {
     const response = { reviews: await reviewStore.list() };
     return c.json(response);
   });
+  app.post("/api/maintenance/clear-reviews", async (c) => {
+    const parsed = await readJsonBody(c, isClearReviewsRequest, "clear reviews request");
+    if (!parsed.ok) {
+      return parsed.response;
+    }
+    const body = parsed.body;
+    const result = await reviewStore.clearReviewArtifacts(body);
+    return c.json(result);
+  });
   app.post("/api/reviews", async (c) => {
     const parsed = await readJsonBody(c, isDiffPayload, "review diff");
     if (!parsed.ok) {
@@ -1745,7 +1986,7 @@ async function serveAsset(c) {
   const normalized = path5.normalize(requestPath).replace(/^(\.\.(\/|\\|$))+/, "");
   const assetPath = path5.join(webRoot, "assets", normalized);
   try {
-    const body = await readFile3(assetPath);
+    const body = await readFile4(assetPath);
     return new Response(body, {
       headers: {
         "content-type": mimeTypes[path5.extname(assetPath)] ?? "application/octet-stream"
@@ -1760,7 +2001,7 @@ async function serveAsset(c) {
 }
 async function serveIndex() {
   try {
-    const body = await readFile3(path5.join(webRoot, "index.html"));
+    const body = await readFile4(path5.join(webRoot, "index.html"));
     return new Response(body, {
       headers: { "content-type": "text/html; charset=utf-8" }
     });
@@ -1774,7 +2015,7 @@ async function serveIndex() {
 function serveRootFile(fileName, contentType) {
   return async () => {
     try {
-      const body = await readFile3(path5.join(webRoot, fileName));
+      const body = await readFile4(path5.join(webRoot, fileName));
       return new Response(body, {
         headers: { "content-type": contentType }
       });
@@ -1826,6 +2067,30 @@ function statusForStoreError(error) {
   return /not found/i.test(formatError(error)) ? 404 : 409;
 }
 
+// src/server/maintenance.ts
+var defaultLogger = {
+  info: (message) => {
+    process.stdout.write(`${message}
+`);
+  },
+  error: (message) => {
+    process.stderr.write(`${message}
+`);
+  }
+};
+async function runStartupCleanup(logger = defaultLogger) {
+  try {
+    const result = await reviewStore.clearReviewArtifacts({
+      olderThanDays: DEFAULT_REVIEW_RETENTION_DAYS
+    });
+    logger.info(
+      `Gloss cleanup deleted ${result.counts.deleted} review artifact(s); skipped ${result.counts.skipped}`
+    );
+  } catch (error) {
+    logger.error(`Gloss cleanup failed: ${formatError(error)}`);
+  }
+}
+
 // src/server/daemon.ts
 var port = Number(process.env.GLOSS_PORT ?? "0");
 var idleTimeoutMs = Number(process.env.GLOSS_IDLE_TIMEOUT_MS ?? "120000");
@@ -1857,6 +2122,7 @@ await writeServerInfo({
   startedAt: (/* @__PURE__ */ new Date()).toISOString(),
   stateDir: globalStateDir()
 });
+await runStartupCleanup();
 await scheduleIdleShutdown();
 for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
   process.on(signal, () => {
@@ -1914,7 +2180,7 @@ async function shutdown(exitCode) {
 async function removeCurrentServerInfo() {
   const info = await readServerInfo().catch(() => null);
   if (!info || info.pid === process.pid) {
-    await rm2(globalServerFile(), { force: true });
+    await rm3(globalServerFile(), { force: true });
   }
 }
 //# sourceMappingURL=daemon.js.map