fix: fall back to getRandomValues for UUIDs on insecure origins

crypto.randomUUID() is secure-context-gated, so it's undefined on
plain-HTTP non-localhost desks (GALLEY_HOST/tailnet), and creating a
comment threw. Add a uuid() helper that uses the native call when
present and otherwise builds an RFC-4122 v4 UUID from
crypto.getRandomValues(), which has no such gate.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: ymansurozer

src/ui/main.ts

@@ -37,6 +37,7 @@ import {
 import { setBaseTitle, reviewStats } from "./progress";
 import { installKeys, helpGroups, confirmYes, confirmNo } from "./keys";
 import { cursorReset, cursorSelection, invalidateCursorRows } from "./cursor";
+import { uuid } from "./uuid";
 import type { ReviewState, FileRow, Settings, DiffStyle } from "./types";
 
 // Close the inline composer when clicking outside it (unless it has unsaved text). The
@@ -405,7 +406,7 @@ const submitComment = (intent: "question" | "action") => {
   const contents =
     cur.path === file.path ? (side === "deletions" ? cur.oldContents : cur.newContents) : undefined;
   const c = {
-    id: crypto.randomUUID(),
+    id: uuid(),
     path: file.path,
     side,
     lineNumber,

src/ui/uuid.test.ts

@@ -0,0 +1,37 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { uuid, uuidFallback } from "./uuid";
+
+// Standard v4 shape: 8-4-4-4-12 hex groups, version nibble "4", variant nibble in [89ab].
+const V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+
+test("uuidFallback returns v4-format ids", () => {
+  assert.match(uuidFallback(), V4);
+});
+
+test("uuidFallback: successive calls differ", () => {
+  assert.notEqual(uuidFallback(), uuidFallback());
+});
+
+test("uuid: falls back to v4 format when crypto.randomUUID is absent", () => {
+  const original = crypto.randomUUID;
+  // @ts-expect-error — simulating an insecure context, where randomUUID is undefined.
+  crypto.randomUUID = undefined;
+  try {
+    assert.match(uuid(), V4);
+  } finally {
+    crypto.randomUUID = original;
+  }
+});
+
+test("uuid: uses the native implementation when available", () => {
+  const original = crypto.randomUUID;
+  const sentinel =
+    "11111111-1111-4111-8111-111111111111" as `${string}-${string}-${string}-${string}-${string}`;
+  crypto.randomUUID = () => sentinel;
+  try {
+    assert.equal(uuid(), sentinel);
+  } finally {
+    crypto.randomUUID = original;
+  }
+});

src/ui/uuid.ts

@@ -0,0 +1,15 @@
+// crypto.randomUUID() is secure-context-gated: on a plain-HTTP non-localhost origin
+// (GALLEY_HOST/tailnet desks, e.g. http://devbox:41443/) it's undefined and comment creation
+// would throw. crypto.getRandomValues() has no such gate, so build an RFC-4122 v4 UUID from it
+// when the native call isn't available — same shape as native, no Math.random fallback.
+export function uuidFallback(): string {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = (bytes[6]! & 0x0f) | 0x40; // version 4
+  bytes[8] = (bytes[8]! & 0x3f) | 0x80; // variant 10xx
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
+export function uuid(): string {
+  return typeof crypto.randomUUID === "function" ? crypto.randomUUID() : uuidFallback();
+}