getgloss 0.8.3 → 0.8.4

package/README.md

@@ -103,6 +103,14 @@ 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.
 
+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
+command reports a permission error while cleaning it up, run `gloss doctor`,
+then try `gloss stop --all` from a normal terminal. If macOS flags made the
+file immutable, inspect with `ls -lOe ~/.gloss ~/.gloss/server.json` and clear
+the flag with `chflags nouchg ~/.gloss/server.json`. For sandboxed agents, set
+`GLOSS_STATE_DIR` to a writable directory.
+
 `gloss clear` deletes completed review artifacts older than 30 days from
 `~/.gloss/reviews` while always preserving pending reviews. Use
 `gloss clear --dry-run` to preview candidates, or `--older-than <days>` to

package/dist/cli/index.js

@@ -1,6 +1,10 @@
 #!/usr/bin/env node
 
 // 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 { Command } from "commander";
 import openBrowser from "open";
 
@@ -14,6 +18,9 @@ function formatError(error) {
 function isFileNotFound(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
+function isPermissionError(error) {
+  return error instanceof Error && "code" in error && (error.code === "EACCES" || error.code === "EPERM");
+}
 
 // src/shared/paths.ts
 import { mkdir } from "fs/promises";
@@ -23,7 +30,7 @@ import path from "path";
 // package.json
 var package_default = {
   name: "getgloss",
-  version: "0.8.3",
+  version: "0.8.4",
   description: "Local browser-based diff review for coding-agent loops.",
   type: "module",
   packageManager: "pnpm@10.33.2",
@@ -592,11 +599,127 @@ function cleanupResult({
   };
 }
 
+// src/shared/server-info.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { readFile as readFile2, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import path3 from "path";
+
+// src/shared/json.ts
+import { randomUUID } from "crypto";
+import { rename, rm as rm2, writeFile } from "fs/promises";
+import path2 from "path";
+function serializeJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+async function writeJsonFile(filePath, value) {
+  await writeTextFile(filePath, serializeJson(value));
+}
+async function writeTextFile(filePath, value) {
+  const tempPath = path2.join(
+    path2.dirname(filePath),
+    `.${path2.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  try {
+    await writeFile(tempPath, value);
+    await rename(tempPath, filePath);
+  } catch (error) {
+    await rm2(tempPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/shared/server-info.ts
+async function readServerInfo() {
+  let raw;
+  try {
+    raw = await readFile2(globalServerFile(), "utf8");
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return null;
+    }
+    if (isPermissionError(error)) {
+      throw new Error(serverInfoPermissionMessage("read", error), { cause: error });
+    }
+    throw new Error(`Could not read server info at ${globalServerFile()}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+  try {
+    return parseJson(raw, isServerInfo, "server info");
+  } catch (error) {
+    throw new Error(`Invalid server info at ${globalServerFile()}: ${formatError(error)}`, {
+      cause: error
+    });
+  }
+}
+async function writeServerInfo(info) {
+  try {
+    await ensureDir(globalStateDir());
+  } catch (error) {
+    if (isPermissionError(error)) {
+      throw new Error(serverInfoPermissionMessage("create", error), { cause: error });
+    }
+    throw error;
+  }
+  try {
+    await writeJsonFile(globalServerFile(), info);
+  } catch (error) {
+    if (!isPermissionError(error)) {
+      throw error;
+    }
+    await assertStateDirWritable();
+    try {
+      await writeFile2(globalServerFile(), serializeServerInfo(info));
+    } catch (directWriteError) {
+      throw new Error(serverInfoPermissionMessage("write", directWriteError), {
+        cause: directWriteError
+      });
+    }
+  }
+}
+async function removeServerInfoFile() {
+  try {
+    await rm3(globalServerFile(), { force: true });
+    return null;
+  } catch (error) {
+    return serverInfoPermissionMessage("remove", error);
+  }
+}
+function serverInfoPermissionMessage(action, error) {
+  const stateDir = globalStateDir();
+  const source = process.env.GLOSS_STATE_DIR ? `GLOSS_STATE_DIR=${stateDir}` : "GLOSS_STATE_DIR is not set; defaulting to ~/.gloss";
+  return [
+    `Could not ${action} Gloss server state at ${globalServerFile()}: ${formatError(error)}.`,
+    "`server.json` is not a review lock, so there is nothing to unlock after a review.",
+    `Check that ${stateDir} and ${globalServerFile()} are owned and writable by your user.`,
+    `On macOS, if the file is immutable, run \`chflags nouchg "${globalServerFile()}"\`.`,
+    `For sandboxed agents, set GLOSS_STATE_DIR to a writable directory. ${source}.`
+  ].join(" ");
+}
+function serializeServerInfo(info) {
+  return `${JSON.stringify(info, null, 2)}
+`;
+}
+async function assertStateDirWritable() {
+  const probePath = path3.join(
+    globalStateDir(),
+    `.server.json.${process.pid}.${randomUUID2()}.probe`
+  );
+  try {
+    await writeFile2(probePath, "");
+    await rm3(probePath, { force: true });
+  } catch (error) {
+    await rm3(probePath, { force: true }).catch(() => void 0);
+    throw new Error(serverInfoPermissionMessage("write", error), { cause: error });
+  }
+}
+
 // src/cli/git.ts
 import { execa } from "execa";
 
 // src/shared/language.ts
-import path2 from "path";
+import path4 from "path";
 var languageByExtension = {
   cjs: "js",
   css: "css",
@@ -618,7 +741,7 @@ var languageByExtension = {
   yml: "yaml"
 };
 function languageForPath(filePath) {
-  const ext = path2.extname(filePath).slice(1).toLowerCase();
+  const ext = path4.extname(filePath).slice(1).toLowerCase();
   if (!ext) {
     return null;
   }
@@ -984,66 +1107,11 @@ async function assertGitAvailable() {
 // src/cli/lifecycle.ts
 import { execFile, spawn } from "child_process";
 import { closeSync, existsSync, openSync } from "fs";
-import { rm as rm3 } from "fs/promises";
 import { userInfo } from "os";
 import { fileURLToPath } from "url";
 import { promisify } from "util";
 import getPort from "get-port";
 
-// src/shared/server-info.ts
-import { readFile as readFile2 } from "fs/promises";
-
-// src/shared/json.ts
-import { randomUUID } from "crypto";
-import { rename, rm as rm2, writeFile } from "fs/promises";
-import path3 from "path";
-function serializeJson(value) {
-  return `${JSON.stringify(value, null, 2)}
-`;
-}
-async function writeJsonFile(filePath, value) {
-  await writeTextFile(filePath, serializeJson(value));
-}
-async function writeTextFile(filePath, value) {
-  const tempPath = path3.join(
-    path3.dirname(filePath),
-    `.${path3.basename(filePath)}.${process.pid}.${randomUUID()}.tmp`
-  );
-  try {
-    await writeFile(tempPath, value);
-    await rename(tempPath, filePath);
-  } catch (error) {
-    await rm2(tempPath, { force: true }).catch(() => void 0);
-    throw error;
-  }
-}
-
-// src/shared/server-info.ts
-async function readServerInfo() {
-  let raw;
-  try {
-    raw = await readFile2(globalServerFile(), "utf8");
-  } catch (error) {
-    if (isFileNotFound(error)) {
-      return null;
-    }
-    throw new Error(`Could not read server info at ${globalServerFile()}: ${formatError(error)}`, {
-      cause: error
-    });
-  }
-  try {
-    return parseJson(raw, isServerInfo, "server info");
-  } catch (error) {
-    throw new Error(`Invalid server info at ${globalServerFile()}: ${formatError(error)}`, {
-      cause: error
-    });
-  }
-}
-async function writeServerInfo(info) {
-  await ensureDir(globalStateDir());
-  await writeJsonFile(globalServerFile(), info);
-}
-
 // src/cli/server-client.ts
 var ServerClient = class {
   constructor(baseUrl) {
@@ -1172,20 +1240,20 @@ var ServerClient = class {
       }
     }
   }
-  async get(path5, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path5}`);
+  async get(path7, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path7}`);
     return parseResponse(response, guard, label);
   }
-  async post(path5, body, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path5}`, {
+  async post(path7, body, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path7}`, {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify(body)
     });
     return parseResponse(response, guard, label);
   }
-  async delete(path5, guard, label) {
-    const response = await fetch(`${this.baseUrl}${path5}`, { method: "DELETE" });
+  async delete(path7, guard, label) {
+    const response = await fetch(`${this.baseUrl}${path7}`, { method: "DELETE" });
     return parseResponse(response, guard, label);
   }
 };
@@ -1276,7 +1344,12 @@ async function launchServer(port) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString(),
     stateDir: globalStateDir()
   };
-  await writeServerInfo(info);
+  try {
+    await writeServerInfo(info);
+  } catch (error) {
+    await terminatePid(info.pid);
+    throw error;
+  }
   const deadline = Date.now() + 8e3;
   while (Date.now() < deadline) {
     if (await isServerResponsive(info)) {
@@ -1290,7 +1363,7 @@ async function launchServer(port) {
 }
 async function stopServer(options = {}) {
   if (options.all) {
-    const info2 = await readServerInfo();
+    const { info: info2, warning: readWarning2 } = await readServerInfoForStop();
     const daemonPids = await listGlossDaemonPids();
     const stoppedPids = [];
     for (const pid of daemonPids) {
@@ -1298,26 +1371,27 @@ async function stopServer(options = {}) {
         stoppedPids.push(pid);
       }
     }
-    await rm3(globalServerFile(), { force: true });
-    return { stopped: stoppedPids.length > 0, info: info2, stoppedPids };
+    return withWarning(
+      { stopped: stoppedPids.length > 0, info: info2, stoppedPids },
+      combineWarnings(readWarning2, await removeServerInfoFile())
+    );
   }
-  const info = await readServerInfo();
+  const { info, warning: readWarning } = await readServerInfoForStop();
   if (!info) {
-    return { stopped: false, info: null };
+    return withWarning({ stopped: false, info: null }, readWarning);
   }
   if (!isPidAlive(info.pid)) {
-    await removeServerInfoForPid(info.pid);
-    return { stopped: false, info };
+    return withWarning({ stopped: false, info }, await removeServerInfoForPid(info.pid));
   }
   if (!await isGlossDaemonPid(info.pid)) {
-    await removeServerInfoForPid(info.pid);
-    return { stopped: false, info };
+    return withWarning({ stopped: false, info }, await removeServerInfoForPid(info.pid));
   }
   const stopped = await terminatePid(info.pid);
+  let warning = null;
   if (stopped) {
-    await removeServerInfoForPid(info.pid);
+    warning = await removeServerInfoForPid(info.pid);
   }
-  return { stopped, info };
+  return withWarning({ stopped, info }, warning);
 }
 function isPidAlive(pid) {
   if (pid <= 0) {
@@ -1368,8 +1442,23 @@ async function waitForPidExit(pid, timeoutMs) {
 async function removeServerInfoForPid(pid) {
   const current = await readServerInfo().catch(() => null);
   if (!current || current.pid === pid) {
-    await rm3(globalServerFile(), { force: true });
+    return removeServerInfoFile();
   }
+  return null;
+}
+function withWarning(result, warning) {
+  return warning ? { ...result, warning } : result;
+}
+async function readServerInfoForStop() {
+  try {
+    return { info: await readServerInfo(), warning: null };
+  } catch (error) {
+    return { info: null, warning: error instanceof Error ? error.message : String(error) };
+  }
+}
+function combineWarnings(...warnings) {
+  const present = warnings.filter((warning) => Boolean(warning));
+  return present.length > 0 ? present.join(" ") : null;
 }
 async function isGlossDaemonPid(pid) {
   const command = await readProcessCommand(pid);
@@ -1409,7 +1498,7 @@ function isGlossDaemonCommand(command) {
 // src/server/store.ts
 import { createHash } from "crypto";
 import { readdir as readdir2, readFile as readFile3 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 import { ulid } from "ulid";
 
 // src/shared/comments.ts
@@ -2182,9 +2271,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 ?? path4.join(meta.artifactDir, "feedback.json") : void 0,
-    markdownPath: feedback ? meta.markdownPath ?? path4.join(meta.artifactDir, "feedback.md") : void 0,
-    resolvedPath: resolution ? meta.resolvedPath ?? path4.join(meta.artifactDir, "resolved.json") : 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,
     diff,
     ...feedback ? { feedback } : {},
     ...resolution ? { resolution } : {}
@@ -2378,9 +2467,7 @@ program.command("status").description("Show server and active reviews").action(a
 program.command("stop").description("Stop the managed background server").option("--all", "stop all Gloss daemon processes for the current user").action(async (options) => {
   const globals = program.opts();
   const result = await stopServer({ all: options.all });
-  globals.json ? printJson(result) : printPlain(
-    options.all && result.stoppedPids ? `Stopped ${result.stoppedPids.length} Gloss daemon(s)` : result.stopped ? "Gloss server stopped" : "Gloss server was not running"
-  );
+  globals.json ? printJson(result) : printPlain(formatStopResult(result, options.all === true));
 });
 program.command("clear").description("Delete old completed review artifacts").option(
   "--older-than <days>",
@@ -2438,11 +2525,19 @@ program.command("doctor").description("Diagnose setup and validate git/state").a
       detail: error instanceof Error ? error.message : String(error)
     });
   }
-  const info = await readServerInfo();
+  checks.push(await checkStateDirAccess());
+  checks.push(await checkServerInfoAccess());
+  let info = null;
+  let serverStateError = null;
+  try {
+    info = await readServerInfo();
+  } catch (error) {
+    serverStateError = error;
+  }
   checks.push({
     name: "server",
     ok: info ? await isServerResponsive(info) : false,
-    detail: info ? serverUrl(info) : "not started"
+    detail: info ? serverUrl(info) : serverStateError ? formatError(serverStateError) : "not started"
   });
   try {
     const daemonPids = await listGlossDaemonPids();
@@ -2496,6 +2591,46 @@ async function watchReviewWithReconnect(reviewId, initialInfo, timeoutSeconds, o
     }
   }
 }
+function formatStopResult(result, all) {
+  const status = all && result.stoppedPids ? `Stopped ${result.stoppedPids.length} Gloss daemon(s)` : result.stopped ? "Gloss server stopped" : "Gloss server was not running";
+  return result.warning ? `${status}
+Warning: ${result.warning}` : status;
+}
+async function checkStateDirAccess() {
+  const probePath = path6.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 });
+    return { name: "state-dir", ok: true, detail: stateDirDetail() };
+  } catch (error) {
+    await rm4(probePath, { force: true }).catch(() => void 0);
+    return {
+      name: "state-dir",
+      ok: false,
+      detail: `${stateDirDetail()}: ${formatError(error)}. Set GLOSS_STATE_DIR to a writable directory for sandboxed agents.`
+    };
+  }
+}
+async function checkServerInfoAccess() {
+  try {
+    await access(globalServerFile(), constants.R_OK | constants.W_OK);
+    return { name: "server-json", ok: true, detail: globalServerFile() };
+  } catch (error) {
+    if (isFileNotFound(error)) {
+      return { name: "server-json", ok: true, detail: "not present" };
+    }
+    return {
+      name: "server-json",
+      ok: false,
+      detail: serverInfoPermissionMessage("access", error)
+    };
+  }
+}
+function stateDirDetail() {
+  return process.env.GLOSS_STATE_DIR ? `${globalStateDir()} (from GLOSS_STATE_DIR)` : `${globalStateDir()} (default; set GLOSS_STATE_DIR for a writable sandbox state dir)`;
+}
 async function baseForExistingReview(client, reviewId) {
   const record = await client.getReview(reviewId);
   return record.diff.scope.mode === "explicit" ? record.diff.scope.requestedBase ?? record.diff.base.ref : null;