getgloss 0.8.4 → 0.8.5

package/README.md

@@ -100,8 +100,11 @@ compares only against the requested ref and does not switch to a branch diff.
 Use `gloss open --review <reviewId> --json` after applying feedback to capture
 the next diff as another turn in the same browser review.
 The background server exits automatically after a short idle window with no
-pending reviews. `gloss doctor` reports unmanaged daemon processes, and
-`gloss stop --all` cleans them up.
+live review clients. Pending review artifacts stay on disk and can be resumed,
+but they do not keep the daemon alive by themselves. `gloss doctor` reports
+unmanaged daemon processes, and normal startup/status commands also clean up
+clearly stale daemons. `gloss stop --all` cleans up every Gloss daemon for the
+current user.
 
 You do not need to unlock `~/.gloss/server.json` after finishing a review.
 That file is only the background daemon pointer, not a review lock. If a

package/dist/cli/index.js

@@ -3,8 +3,8 @@
 // src/cli/index.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { constants } from "fs";
-import { access, rm as rm4, writeFile as writeFile3 } from "fs/promises";
-import path6 from "path";
+import { access, rm as rm5, writeFile as writeFile4 } from "fs/promises";
+import path7 from "path";
 import { Command } from "commander";
 import openBrowser from "open";
 
@@ -30,7 +30,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.8.4",
+  version: "0.8.5",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -126,6 +126,9 @@ function globalStateDir() {
 function globalServerFile() {
   return path.join(globalStateDir(), "server.json");
 }
+function globalServerLockDir() {
+  return path.join(globalStateDir(), "server.lock");
+}
 function globalLogDir() {
   return path.join(globalStateDir(), "logs");
 }
@@ -205,10 +208,10 @@ function parseJsonValue(value, guard, label) {
   return value;
 }
 function isServerInfo(value) {
-  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir);
+  return isRecord(value) && isNumber(value.pid) && isNumber(value.port) && isString(value.version) && isString(value.startedAt) && isString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
 }
 function isHealthResponse(value) {
-  return isRecord(value) && isBoolean(value.ok) && isString(value.version) && isNumber(value.activeReviews);
+  return isRecord(value) && isBoolean(value.ok) && isString(value.version) && isNumber(value.activeReviews) && isOptionalNumber(value.connections) && isOptionalString(value.stateDir) && isOptionalString(value.cwd) && isOptionalString(value.daemonPath);
 }
 function isClearReviewsResult(value) {
   return isRecord(value) && isString(value.reviewsDir) && isString(value.cutoff) && isNumber(value.olderThanDays) && isBoolean(value.dryRun) && isArrayOf(value.candidates, isClearReviewEntry) && isArrayOf(value.deleted, isClearReviewEntry) && isArrayOf(value.skipped, isClearReviewSkipped) && isRecord(value.counts) && isNumber(value.counts.candidates) && isNumber(value.counts.deleted) && isNumber(value.counts.skipped);
@@ -1107,12 +1110,15 @@ async function assertGitAvailable() {
 // src/cli/lifecycle.ts
 import { execFile, spawn } from "child_process";
 import { closeSync, existsSync, openSync } from "fs";
+import { mkdir as mkdir2, readFile as readFile3, rm as rm4, stat, writeFile as writeFile3 } from "fs/promises";
 import { userInfo } from "os";
+import path5 from "path";
 import { fileURLToPath } from "url";
 import { promisify } from "util";
 import getPort from "get-port";
 
 // src/cli/server-client.ts
+var timedWatchAttemptMs = 1e3;
 var ServerClient = class {
   constructor(baseUrl) {
     this.baseUrl = baseUrl;
@@ -1191,11 +1197,15 @@ var ServerClient = class {
         throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
       }
       const controller = new AbortController();
-      const timeout = remainingMs ? setTimeout(() => controller.abort(), remainingMs) : null;
+      const timeoutMs = remainingMs === null ? null : Math.min(remainingMs, timedWatchAttemptMs);
+      const timeout = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : null;
       try {
         return await this.readReviewEvents(reviewId, controller.signal);
       } catch (error) {
         if (isAbortError(error)) {
+          if (deadline && Date.now() < deadline) {
+            throw new Error("watch stream ended before completion");
+          }
           throw new Error(`watch timed out after ${timeoutSeconds} seconds`);
         }
         if (!isPrematureWatchEnd(error)) {
@@ -1240,20 +1250,20 @@ var ServerClient = class {
       }
     }
   }
-  async get(path7, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path7}`);
+  async get(path8, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path8}`);
     return parseResponse(response, guard, label);
   }
-  async post(path7, body, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path7}`, {
+  async post(path8, body, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path8}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body)
     });
     return parseResponse(response, guard, label);
   }
-  async delete(path7, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path7}`, { method: "DELETE" });
+  async delete(path8, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path8}`, { method: "DELETE" });
     return parseResponse(response, guard, label);
   }
 };
@@ -1278,6 +1288,8 @@ async function sleep(milliseconds) {
 var execFileAsync = promisify(execFile);
 var gracefulShutdownTimeoutMs = 2e3;
 var forceShutdownTimeoutMs = 1e3;
+var serverLockTimeoutMs = 8e3;
+var staleServerLockMs = 3e4;
 function serverUrl(info) {
   return `http://localhost:${info.port}`;
 }
@@ -1293,17 +1305,26 @@ async function isServerResponsive(info) {
   }
 }
 async function ensureServer(options = {}) {
-  const existing = await readServerInfo();
-  if (existing && await isServerResponsive(existing)) {
-    return existing;
-  }
-  return startServer(options);
+  return withServerLock(async () => {
+    const existing = await readServerInfo();
+    await reapStaleDaemons(existing);
+    if (existing && await isServerResponsive(existing)) {
+      return existing;
+    }
+    return startServerUnlocked(existing, options);
+  });
 }
 async function startServer(options = {}) {
-  const existing = await readServerInfo();
-  if (existing && await isServerResponsive(existing)) {
-    return existing;
-  }
+  return withServerLock(async () => {
+    const existing = await readServerInfo();
+    await reapStaleDaemons(existing);
+    if (existing && await isServerResponsive(existing)) {
+      return existing;
+    }
+    return startServerUnlocked(existing, options);
+  });
+}
+async function startServerUnlocked(existing, options = {}) {
   if (existing) {
     await retireServer(existing);
   }
@@ -1342,7 +1363,9 @@ async function launchServer(port) {
     port,
     version: packageVersion,
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    stateDir: globalStateDir()
+    stateDir: globalStateDir(),
+    cwd: process.cwd(),
+    daemonPath
   };
   try {
     await writeServerInfo(info);
@@ -1361,10 +1384,86 @@ async function launchServer(port) {
   await removeServerInfoForPid(info.pid);
   throw new Error(`Server did not become responsive. See ${globalServerLogFile()}`);
 }
+async function withServerLock(fn) {
+  const release = await acquireServerLock();
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+async function acquireServerLock() {
+  await ensureDir(globalStateDir());
+  const lockDir = globalServerLockDir();
+  const ownerFile = serverLockOwnerFile();
+  const deadline = Date.now() + serverLockTimeoutMs;
+  while (true) {
+    try {
+      await mkdir2(lockDir);
+      try {
+        await writeFile3(
+          ownerFile,
+          `${JSON.stringify({ pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2)}
+`
+        );
+      } catch (error) {
+        await rm4(lockDir, { recursive: true, force: true }).catch(() => void 0);
+        throw error;
+      }
+      return () => rm4(lockDir, { recursive: true, force: true });
+    } catch (error) {
+      if (!isAlreadyExistsError(error)) {
+        throw error;
+      }
+      if (await removeStaleServerLock(lockDir, ownerFile)) {
+        continue;
+      }
+      if (Date.now() >= deadline) {
+        throw new Error(`Timed out waiting for Gloss server lock at ${lockDir}`);
+      }
+      await sleep2(50);
+    }
+  }
+}
+async function removeStaleServerLock(lockDir, ownerFile) {
+  const owner = await readServerLockOwner(ownerFile);
+  if (owner?.pid && !isPidAlive(owner.pid)) {
+    await rm4(lockDir, { recursive: true, force: true });
+    return true;
+  }
+  if (!owner && await isOldLockDir(lockDir)) {
+    await rm4(lockDir, { recursive: true, force: true });
+    return true;
+  }
+  return false;
+}
+async function readServerLockOwner(ownerFile) {
+  try {
+    const raw = await readFile3(ownerFile, "utf8");
+    const parsed = JSON.parse(raw);
+    return typeof parsed.pid === "number" && Number.isFinite(parsed.pid) ? { pid: parsed.pid } : null;
+  } catch {
+    return null;
+  }
+}
+async function isOldLockDir(lockDir) {
+  try {
+    const info = await stat(lockDir);
+    return Date.now() - info.mtimeMs > staleServerLockMs;
+  } catch {
+    return false;
+  }
+}
+function serverLockOwnerFile() {
+  return path5.join(globalServerLockDir(), "owner.json");
+}
+function isAlreadyExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
 async function stopServer(options = {}) {
   if (options.all) {
     const { info: info2, warning: readWarning2 } = await readServerInfoForStop();
-    const daemonPids = await listGlossDaemonPids();
+    const daemonPids = (await listGlossDaemonProcesses()).map((processInfo) => processInfo.pid);
     const stoppedPids = [];
     for (const pid of daemonPids) {
       if (await terminatePid(pid)) {
@@ -1393,6 +1492,28 @@ async function stopServer(options = {}) {
   }
   return withWarning({ stopped, info }, warning);
 }
+async function reapStaleDaemons(managed) {
+  if (process.env.GLOSS_SKIP_STALE_DAEMON_REAP === "1") {
+    return [];
+  }
+  const processes = await listGlossDaemonProcesses();
+  const managedProcess = managed ? processes.find((processInfo) => processInfo.pid === managed.pid) : null;
+  const managedSource = managedProcess ? daemonSourceKey(managedProcess) : managed?.daemonPath ? daemonPathSourceKey(managed.daemonPath) : null;
+  const reapedPids = [];
+  for (const processInfo of processes) {
+    const shouldReap = isMissingDaemonSource(processInfo) || isStaleHomebrewDaemon(processInfo) || managedSource !== null && processInfo.pid !== managed?.pid && daemonSourceKey(processInfo) === managedSource;
+    if (!shouldReap) {
+      continue;
+    }
+    if (await terminatePid(processInfo.pid)) {
+      reapedPids.push(processInfo.pid);
+      if (processInfo.pid === managed?.pid) {
+        await removeServerInfoForPid(processInfo.pid);
+      }
+    }
+  }
+  return reapedPids;
+}
 function isPidAlive(pid) {
   if (pid <= 0) {
     return false;
@@ -1435,7 +1556,7 @@ async function waitForPidExit(pid, timeoutMs) {
     if (!isPidAlive(pid)) {
       return true;
     }
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await sleep2(50);
   }
   return !isPidAlive(pid);
 }
@@ -1462,7 +1583,7 @@ function combineWarnings(...warnings) {
 }
 async function isGlossDaemonPid(pid) {
   const command = await readProcessCommand(pid);
-  return command ? isGlossDaemonCommand(command) : false;
+  return command ? parseGlossDaemonCommand(command) !== null : false;
 }
 async function readProcessCommand(pid) {
   try {
@@ -1473,6 +1594,9 @@ async function readProcessCommand(pid) {
   }
 }
 async function listGlossDaemonPids() {
+  return (await listGlossDaemonProcesses()).map((processInfo) => processInfo.pid);
+}
+async function listGlossDaemonProcesses() {
   let stdout;
   try {
     ({ stdout } = await execFileAsync("ps", ["-axo", "pid=,user=,command=", "-ww"]));
@@ -1480,25 +1604,60 @@ async function listGlossDaemonPids() {
     return [];
   }
   const currentUser = userInfo().username;
-  return parseGlossDaemonPids(stdout, currentUser, process.pid);
+  return parseGlossDaemonProcesses(stdout, currentUser, process.pid);
 }
-function parseGlossDaemonPids(stdout, currentUser, currentPid = process.pid) {
+function parseGlossDaemonProcesses(stdout, currentUser, currentPid = process.pid) {
   return stdout.split("\n").map((line) => /^\s*(\d+)\s+(\S+)\s+(.+)$/.exec(line)).filter((match) => Boolean(match)).map((match) => ({
     pid: Number(match[1]),
     user: match[2],
     command: match[3]
+  })).map((processInfo) => ({
+    ...processInfo,
+    parsed: parseGlossDaemonCommand(processInfo.command)
   })).filter(
-    ({ pid, user, command }) => pid !== currentPid && user === currentUser && isGlossDaemonCommand(command)
-  ).map(({ pid }) => pid);
+    (processInfo) => processInfo.pid !== currentPid && processInfo.user === currentUser && processInfo.parsed !== null
+  ).map(({ pid, user, command, parsed }) => ({
+    pid,
+    user,
+    command,
+    daemonPath: parsed.daemonPath,
+    ...parsed.homebrewVersion ? { homebrewVersion: parsed.homebrewVersion } : {}
+  }));
+}
+function parseGlossDaemonCommand(command) {
+  const match = /(?:^|\s)(?:\S*\/)?node\s+(\S*dist\/server\/daemon\.js)(?:\s|$)/.exec(command);
+  if (!match) {
+    return null;
+  }
+  const daemonPath = match[1];
+  const homebrewVersion = /\/Cellar\/gloss\/([^/]+)\/libexec\/lib\/node_modules\/getgloss\/dist\/server\/daemon\.js$/.exec(
+    daemonPath
+  )?.[1];
+  return {
+    daemonPath,
+    ...homebrewVersion ? { homebrewVersion } : {}
+  };
+}
+function isMissingDaemonSource(processInfo) {
+  return !existsSync(processInfo.daemonPath);
+}
+function isStaleHomebrewDaemon(processInfo) {
+  return Boolean(processInfo.homebrewVersion && processInfo.homebrewVersion !== packageVersion);
 }
-function isGlossDaemonCommand(command) {
-  return /(?:^|\s)(?:\S*\/)?node\s+\S*dist\/server\/daemon\.js(?:\s|$)/.test(command);
+function daemonSourceKey(processInfo) {
+  return daemonPathSourceKey(processInfo.daemonPath);
+}
+function daemonPathSourceKey(daemonPath) {
+  return path5.normalize(daemonPath);
+}
+async function sleep2(milliseconds) {
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 
 // src/server/store.ts
 import { createHash } from "crypto";
-import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import path5 from "path";
+import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import path6 from "path";
 import { ulid } from "ulid";
 
 // src/shared/comments.ts
@@ -1969,16 +2128,25 @@ var ReviewStore = class {
     const reviewLoads = [];
     for (const entry of entries) {
       if (entry.isDirectory()) {
-        reviewLoads.push(this.loadReview(entry.name));
+        reviewLoads.push(this.loadReviewForList(entry.name));
       }
     }
     await Promise.all(reviewLoads);
   }
+  async loadReviewForList(id) {
+    try {
+      return await this.loadReview(id);
+    } catch (error) {
+      process.stderr.write(`Warning: Skipping corrupt review ${id}: ${formatError(error)}
+`);
+      return null;
+    }
+  }
   async loadReview(id) {
     const metaPath = globalReviewMetaFile(id);
     let metaRaw;
     try {
-      metaRaw = await readFile3(metaPath, "utf8");
+      metaRaw = await readFile4(metaPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return this.loadReviewFromTurnsOnly(id);
@@ -2060,8 +2228,8 @@ var ReviewStore = class {
     let diffRaw;
     try {
       [metaRaw, diffRaw] = await Promise.all([
-        readFile3(metaPath, "utf8"),
-        readFile3(diffPath, "utf8")
+        readFile4(metaPath, "utf8"),
+        readFile4(diffPath, "utf8")
       ]);
     } catch (error) {
       if (isFileNotFound(error)) {
@@ -2091,7 +2259,7 @@ var ReviewStore = class {
     const diffPath = globalReviewDiffFile(id);
     let diffRaw;
     try {
-      diffRaw = await readFile3(diffPath, "utf8");
+      diffRaw = await readFile4(diffPath, "utf8");
     } catch (error) {
       if (isFileNotFound(error)) {
         return null;
@@ -2271,9 +2439,9 @@ function reconcileTurn(meta, diff, feedback, resolution) {
     status,
     submittedAt: feedback?.timestamp ?? meta.submittedAt,
     resolvedAt: status === "resolved" ? resolution?.resolvedAt ?? meta.resolvedAt : void 0,
-    feedbackPath: feedback ? meta.feedbackPath ?? path5.join(meta.artifactDir, "feedback.json") : void 0,
-    markdownPath: feedback ? meta.markdownPath ?? path5.join(meta.artifactDir, "feedback.md") : void 0,
-    resolvedPath: resolution ? meta.resolvedPath ?? path5.join(meta.artifactDir, "resolved.json") : void 0,
+    feedbackPath: feedback ? meta.feedbackPath ?? path6.join(meta.artifactDir, "feedback.json") : void 0,
+    markdownPath: feedback ? meta.markdownPath ?? path6.join(meta.artifactDir, "feedback.md") : void 0,
+    resolvedPath: resolution ? meta.resolvedPath ?? path6.join(meta.artifactDir, "resolved.json") : void 0,
     diff,
     ...feedback ? { feedback } : {},
     ...resolution ? { resolution } : {}
@@ -2306,7 +2474,7 @@ function requiredPath(value, label) {
 async function readOptionalJsonFile(filePath, guard, label) {
   let raw;
   try {
-    raw = await readFile3(filePath, "utf8");
+    raw = await readFile4(filePath, "utf8");
   } catch (error) {
     if (isFileNotFound(error)) {
       return void 0;
@@ -2456,7 +2624,9 @@ program.command("start").description("Start or reuse the background server").opt
 });
 program.command("status").description("Show server and active reviews").action(async () => {
   const globals = program.opts();
-  const info = await readServerInfo();
+  let info = await readServerInfo();
+  await reapStaleDaemons(info);
+  info = await readServerInfo();
   const responsive = info ? await isServerResponsive(info) : false;
   const reviews = await listReviewsForStatus({ responsive, server: info });
   const status = { running: responsive, server: info, reviews };
@@ -2582,7 +2752,7 @@ async function watchReviewWithReconnect(reviewId, initialInfo, timeoutSeconds, o
       if (!isReconnectableWatchError(error)) {
         throw error;
       }
-      await sleep2(500);
+      await sleep3(500);
       const nextInfo = await ensureServer();
       if (nextInfo.port !== info.port) {
         await onServerChanged(nextInfo);
@@ -2597,15 +2767,15 @@ function formatStopResult(result, all) {
 Warning: ${result.warning}` : status;
 }
 async function checkStateDirAccess() {
-  const probePath = path6.join(globalStateDir(), `.doctor-${process.pid}-${randomUUID3()}.tmp`);
+  const probePath = path7.join(globalStateDir(), `.doctor-${process.pid}-${randomUUID3()}.tmp`);
   try {
     await ensureDir(globalStateDir());
     await access(globalStateDir(), constants.R_OK | constants.W_OK | constants.X_OK);
-    await writeFile3(probePath, "");
-    await rm4(probePath, { force: true });
+    await writeFile4(probePath, "");
+    await rm5(probePath, { force: true });
     return { name: "state-dir", ok: true, detail: stateDirDetail() };
   } catch (error) {
-    await rm4(probePath, { force: true }).catch(() => void 0);
+    await rm5(probePath, { force: true }).catch(() => void 0);
     return {
       name: "state-dir",
       ok: false,
@@ -2661,7 +2831,7 @@ function isWatchTimeout(error) {
 function isReconnectableWatchError(error) {
   return error instanceof Error && !/^watch failed: [45]\d\d /.test(error.message);
 }
-async function sleep2(milliseconds) {
+async function sleep3(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 program.parseAsync(process.argv).catch((error) => {