@adhdev/daemon-standalone 0.9.77-rc.50 → 0.9.77-rc.57

package/dist/index.js

@@ -177,7 +177,6 @@ var require_dist = __commonJS({
         }
       }
     };
-    var import_crypto3 = require("crypto");
     var DEFAULT_SESSION_HOST_COLS = 80;
     var DEFAULT_SESSION_HOST_ROWS = 32;
     function normalizeSessionHostDimension(value, fallback) {
@@ -303,10 +302,20 @@ var require_dist = __commonJS({
       if (!record2.writeOwner) return "none";
       return `${record2.writeOwner.ownerType}:${record2.writeOwner.clientId}`;
     }
+    function generateUUID() {
+      if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return crypto.randomUUID();
+      }
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    }
     var SessionHostRegistry = class {
       sessions = /* @__PURE__ */ new Map();
       createSession(payload) {
-        const sessionId = payload.sessionId || (0, import_crypto3.randomUUID)();
+        const sessionId = payload.sessionId || generateUUID();
         if (this.sessions.has(sessionId)) {
           throw new Error(`Session already exists: ${sessionId}`);
         }
@@ -521,7 +530,16 @@ var require_dist = __commonJS({
     var os6 = __toESM2(require("os"));
     var path23 = __toESM2(require("path"));
     var net3 = __toESM2(require("net"));
-    var import_crypto22 = require("crypto");
+    function generateUUID22() {
+      if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return crypto.randomUUID();
+      }
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0;
+        const v = c === "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    }
     function getDefaultSessionHostEndpoint2(appName = "adhdev") {
       if (process.platform === "win32") {
         return {
@@ -612,7 +630,7 @@ var require_dist = __commonJS({
       async request(request) {
         await this.connect();
         if (!this.socket) throw new Error("Session host socket unavailable");
-        const requestId = (0, import_crypto22.randomUUID)();
+        const requestId = generateUUID22();
         const envelope = {
           kind: "request",
           requestId,
@@ -22398,7 +22416,7 @@ ${error48.message || ""}`;
       };
     }
     function generateMachineId() {
-      return `${MACHINE_ID_PREFIX}${(0, import_crypto3.randomUUID)().replace(/-/g, "")}`;
+      return `${MACHINE_ID_PREFIX}${(0, import_crypto2.randomUUID)().replace(/-/g, "")}`;
     }
     function isStableMachineId(machineId) {
       return typeof machineId === "string" && machineId.startsWith(MACHINE_ID_PREFIX);
@@ -22518,7 +22536,7 @@ ${error48.message || ""}`;
     var import_os2;
     var import_path2;
     var import_fs;
-    var import_crypto3;
+    var import_crypto2;
     var DEFAULT_CONFIG;
     var MACHINE_ID_PREFIX;
     var init_config = __esm2({
@@ -22527,7 +22545,7 @@ ${error48.message || ""}`;
         import_os2 = require("os");
         import_path2 = require("path");
         import_fs = require("fs");
-        import_crypto3 = require("crypto");
+        import_crypto2 = require("crypto");
         DEFAULT_CONFIG = {
           serverUrl: "https://api.adhf.dev",
           allowServerApiProxy: false,
@@ -22633,7 +22651,7 @@ ${error48.message || ""}`;
       if (!repoIdentity) throw new Error("Either repoRemoteUrl or repoIdentity is required");
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const mesh = {
-        id: `mesh_${(0, import_crypto32.randomUUID)().replace(/-/g, "")}`,
+        id: `mesh_${(0, import_crypto3.randomUUID)().replace(/-/g, "")}`,
         name: opts.name.trim().slice(0, 100),
         repoIdentity,
         repoRemoteUrl: opts.repoRemoteUrl,
@@ -22679,7 +22697,7 @@ ${error48.message || ""}`;
         throw new Error("This workspace is already in the mesh");
       }
       const node = {
-        id: `node_${(0, import_crypto32.randomUUID)().replace(/-/g, "")}`,
+        id: `node_${(0, import_crypto3.randomUUID)().replace(/-/g, "")}`,
         workspace: opts.workspace.trim(),
         repoRoot: opts.repoRoot,
         daemonId: opts.daemonId,
@@ -22720,7 +22738,7 @@ ${error48.message || ""}`;
     }
     var import_fs2;
     var import_path22;
-    var import_crypto32;
+    var import_crypto3;
     var SESSION_CLEANUP_MODES;
     var SPAWNED_SESSION_VISIBILITY_MODES;
     var init_mesh_config = __esm2({
@@ -22728,7 +22746,7 @@ ${error48.message || ""}`;
         "use strict";
         import_fs2 = require("fs");
         import_path22 = require("path");
-        import_crypto32 = require("crypto");
+        import_crypto3 = require("crypto");
         init_config();
         init_repo_mesh_types();
         SESSION_CLEANUP_MODES = /* @__PURE__ */ new Set(["preserve", "stop", "delete_stopped", "stop_and_delete"]);
@@ -23315,6 +23333,7 @@ Follow these recovery rules:
       entry.status = "assigned";
       entry.assignedNodeId = nodeId;
       entry.assignedSessionId = sessionId;
+      entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
       entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
       writeQueue(meshId, queue);
       return entry;
@@ -23377,15 +23396,22 @@ Follow these recovery rules:
     }
     function updateSessionTaskStatus(meshId, sessionId, status) {
       const queue = readQueue(meshId);
+      let bestIdx = -1;
+      let bestTime = 0;
       for (let i = queue.length - 1; i >= 0; i--) {
         if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
-          queue[i].status = status;
-          queue[i].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeQueue(meshId, queue);
-          return queue[i];
+          const time3 = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+          if (time3 > bestTime) {
+            bestTime = time3;
+            bestIdx = i;
+          }
         }
       }
-      return null;
+      if (bestIdx === -1) return null;
+      queue[bestIdx].status = status;
+      queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      writeQueue(meshId, queue);
+      return queue[bestIdx];
     }
     function getMeshQueueStats(meshId) {
       const queue = readQueue(meshId);
@@ -23805,7 +23831,9 @@ Follow these recovery rules:
     });
     var mesh_events_exports = {};
     __export2(mesh_events_exports, {
+      clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
       drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+      getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
       handleMeshForwardEvent: () => handleMeshForwardEvent,
       setupMeshEventForwarding: () => setupMeshEventForwarding,
       triggerMeshQueue: () => triggerMeshQueue,
@@ -23814,6 +23842,12 @@ Follow these recovery rules:
     function drainPendingMeshCoordinatorEvents() {
       return pendingMeshCoordinatorEvents.splice(0);
     }
+    function getPendingMeshCoordinatorEvents() {
+      return pendingMeshCoordinatorEvents.slice();
+    }
+    function clearPendingMeshCoordinatorEvents() {
+      pendingMeshCoordinatorEvents.splice(0);
+    }
     function readNonEmptyString(value) {
       return typeof value === "string" && value.trim() ? value.trim() : "";
     }
@@ -27643,6 +27677,7 @@ ${lastSnapshot}`;
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildMachineInfo: () => buildMachineInfo2,
+      buildMeshGraph: () => buildMeshGraph,
       buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
       buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
@@ -27662,6 +27697,7 @@ ${lastSnapshot}`;
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       classifyP2pRelayFailure: () => classifyP2pRelayFailure,
       clearDebugTrace: () => clearDebugTrace,
+      clearPendingMeshCoordinatorEvents: () => clearPendingMeshCoordinatorEvents,
       compareGitSnapshots: () => compareGitSnapshots,
       configureDebugTraceStore: () => configureDebugTraceStore,
       connectCdpManager: () => connectCdpManager,
@@ -27677,6 +27713,7 @@ ${lastSnapshot}`;
       detectAllVersions: () => detectAllVersions,
       detectCLIs: () => detectCLIs,
       detectIDEs: () => detectIDEs,
+      drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
       enqueueTask: () => enqueueTask,
       ensureSessionHostReady: () => ensureSessionHostReady2,
       execNpmCommandSync: () => execNpmCommandSync,
@@ -27703,6 +27740,7 @@ ${lastSnapshot}`;
       getMeshByRepo: () => getMeshByRepo,
       getMeshQueueStats: () => getMeshQueueStats,
       getNpmExecOptions: () => getNpmExecOptions,
+      getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
       getQueue: () => getQueue,
       getRecentActivity: () => getRecentActivity,
       getRecentCommands: () => getRecentCommands,
@@ -29695,6 +29733,227 @@ ${lastSnapshot}`;
       };
     }
     init_mesh_work_queue();
+    function isDirty(git) {
+      if (!git) return false;
+      return git.staged + git.modified + git.untracked + git.deleted + git.renamed > 0;
+    }
+    function dirtyFileCount(git) {
+      if (!git) return 0;
+      return git.staged + git.modified + git.untracked + git.deleted + git.renamed;
+    }
+    function detectOrphanReasons(node, defaultBranch) {
+      const reasons = [];
+      const git = node.git;
+      if (!git) {
+        reasons.push("No git status available");
+        return reasons;
+      }
+      if (!git.isGitRepo) {
+        reasons.push("Not a git repository");
+        return reasons;
+      }
+      if (git.branch === null && git.headCommit) {
+        reasons.push("Detached HEAD");
+      }
+      if (git.branch && !git.upstream) {
+        if (defaultBranch && git.branch !== defaultBranch) {
+          reasons.push(`No upstream: ${git.branch}`);
+        }
+      }
+      if (git.branch && git.upstream === null && defaultBranch && git.branch !== defaultBranch) {
+        if (!reasons.includes(`No upstream: ${git.branch}`)) {
+          reasons.push(`No upstream: ${git.branch}`);
+        }
+      }
+      if (node.error) {
+        reasons.push(`Error: ${node.error}`);
+      }
+      return reasons;
+    }
+    function nodeHealthPriority(health) {
+      switch (health) {
+        case "online":
+          return 0;
+        case "dirty":
+          return 1;
+        case "degraded":
+          return 2;
+        case "wrong_branch":
+          return 3;
+        case "offline":
+          return 4;
+        case "unknown":
+          return 5;
+        default:
+          return 5;
+      }
+    }
+    function pickDominantHealth(healths) {
+      if (healths.length === 0) return "unknown";
+      return healths.reduce(
+        (best, h) => nodeHealthPriority(h) > nodeHealthPriority(best) ? h : best
+      );
+    }
+    function buildMeshGraph(status) {
+      const nodes = [];
+      const edges = [];
+      const warnings = [];
+      const branchToNodeIds = /* @__PURE__ */ new Map();
+      for (const nodeStatus of status.nodes) {
+        const git = nodeStatus.git;
+        const branch = git?.branch || null;
+        const orphanReasons = detectOrphanReasons(nodeStatus, null);
+        const dirty = isDirty(git);
+        const dfc = dirtyFileCount(git);
+        let type = "worktreeNode";
+        if (orphanReasons.length > 0) {
+          type = "orphanNode";
+        }
+        const graphNode = {
+          id: nodeStatus.nodeId,
+          type,
+          label: nodeStatus.machineLabel || nodeStatus.nodeId.slice(0, 8),
+          workspace: nodeStatus.workspace,
+          branch,
+          health: nodeStatus.health,
+          ahead: git?.ahead ?? 0,
+          behind: git?.behind ?? 0,
+          dirty,
+          dirtyFiles: dfc,
+          hasConflicts: git?.hasConflicts ?? false,
+          activeSessionCount: nodeStatus.activeSessions?.length ?? 0,
+          activeSessions: nodeStatus.activeSessions ?? [],
+          providers: nodeStatus.providers ?? [],
+          isOrphan: orphanReasons.length > 0,
+          orphanReasons,
+          source: nodeStatus
+        };
+        nodes.push(graphNode);
+        if (branch) {
+          const list = branchToNodeIds.get(branch) ?? [];
+          list.push(graphNode.id);
+          branchToNodeIds.set(branch, list);
+        }
+      }
+      const branchUpstreamCounts = /* @__PURE__ */ new Map();
+      for (const n of status.nodes) {
+        const b = n.git?.branch;
+        const upstream = n.git?.upstream;
+        if (b && upstream) {
+          branchUpstreamCounts.set(b, (branchUpstreamCounts.get(b) ?? 0) + 1);
+        }
+      }
+      let inferredDefaultBranch = null;
+      let bestCount = 0;
+      for (const [b, count] of branchUpstreamCounts) {
+        if (count > bestCount) {
+          bestCount = count;
+          inferredDefaultBranch = b;
+        }
+      }
+      const defaultBranchNodeId = inferredDefaultBranch ? `__branch_${inferredDefaultBranch}` : null;
+      if (defaultBranchNodeId && inferredDefaultBranch) {
+        const branchNodes = branchToNodeIds.get(inferredDefaultBranch) ?? [];
+        const branchHealths = branchNodes.map(
+          (id) => nodes.find((n) => n.id === id).health
+        );
+        const defaultNode = {
+          id: defaultBranchNodeId,
+          type: "defaultBranchNode",
+          label: inferredDefaultBranch,
+          workspace: "",
+          branch: inferredDefaultBranch,
+          health: pickDominantHealth(branchHealths),
+          ahead: 0,
+          behind: 0,
+          dirty: false,
+          dirtyFiles: 0,
+          hasConflicts: false,
+          activeSessionCount: 0,
+          activeSessions: [],
+          providers: [],
+          isOrphan: false,
+          orphanReasons: [],
+          nextStepHint: branchNodes.length > 0 ? `${branchNodes.length} node(s) on default branch` : void 0,
+          source: {
+            nodeId: defaultBranchNodeId,
+            machineLabel: inferredDefaultBranch,
+            workspace: "",
+            health: "online",
+            providers: [],
+            activeSessions: []
+          }
+        };
+        nodes.push(defaultNode);
+        const seenBranches = /* @__PURE__ */ new Set();
+        for (const n of nodes) {
+          if (n.type === "defaultBranchNode") continue;
+          if (!n.branch) continue;
+          if (n.branch === inferredDefaultBranch) {
+            edges.push({
+              id: `${defaultBranchNodeId}--${n.id}`,
+              source: defaultBranchNodeId,
+              target: n.id,
+              type: "parentBranch",
+              label: "default"
+            });
+            continue;
+          }
+          if (seenBranches.has(n.branch)) continue;
+          seenBranches.add(n.branch);
+          edges.push({
+            id: `${defaultBranchNodeId}--branch_${n.branch}`,
+            source: defaultBranchNodeId,
+            target: n.branch,
+            type: "parentBranch",
+            label: n.branch
+          });
+        }
+      }
+      for (const [branch, ids] of branchToNodeIds) {
+        if (ids.length < 2) continue;
+        for (let i = 1; i < ids.length; i++) {
+          edges.push({
+            id: `wt_${ids[0]}--${ids[i]}`,
+            source: ids[0],
+            target: ids[i],
+            type: "worktreeLink",
+            label: branch
+          });
+        }
+      }
+      const orphanCount = nodes.filter((n) => n.isOrphan).length;
+      if (orphanCount > 0) {
+        warnings.push(`${orphanCount} orphan node(s) detected`);
+      }
+      const conflictCount = nodes.filter((n) => n.hasConflicts).length;
+      if (conflictCount > 0) {
+        warnings.push(`${conflictCount} node(s) with merge conflicts`);
+      }
+      const offlineCount = nodes.filter((n) => n.health === "offline").length;
+      if (offlineCount > 0) {
+        warnings.push(`${offlineCount} node(s) offline`);
+      }
+      const stats = {
+        totalNodes: status.nodes.length,
+        onlineNodes: status.nodes.filter((n) => n.health === "online").length,
+        dirtyNodes: nodes.filter((n) => n.dirty).length,
+        orphanNodes: orphanCount,
+        errorNodes: status.nodes.filter((n) => !!n.error).length,
+        offlineNodes: offlineCount,
+        totalActiveSessions: status.nodes.reduce((sum, n) => sum + (n.activeSessions?.length ?? 0), 0)
+      };
+      return {
+        meshId: status.meshId,
+        meshName: status.meshName,
+        repoIdentity: status.repoIdentity,
+        refreshedAt: status.refreshedAt,
+        nodes,
+        edges,
+        stats,
+        warnings
+      };
+    }
     init_mesh_events();
     var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
     var P2P_NEXT_ACTION = "Check daemon/P2P health, wait briefly for connection establishment, then do one bounded retry or requeue the mesh task after clearing stale target session metadata.";
@@ -31828,6 +32087,28 @@ ${lastSnapshot}`;
         }
       }
     };
+    function extractFinalSummaryFromMessages(messages, maxChars = 500) {
+      if (!Array.isArray(messages) || messages.length === 0) return "";
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg) continue;
+        const classification = classifyChatMessageVisibility(msg);
+        if (classification.isUserFacing && (msg.role === "assistant" || msg.role === "model")) {
+          const text = flattenContent(msg.content).trim();
+          if (text) return text.slice(0, maxChars);
+        }
+      }
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (!msg) continue;
+        const classification = classifyChatMessageVisibility(msg);
+        if (classification.isUserFacing) {
+          const text = flattenContent(msg.content).trim();
+          if (text) return text.slice(0, maxChars);
+        }
+      }
+      return "";
+    }
     var BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
     var CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
     var CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ["visible", "chat", "user", "debug", "internal", "hidden"];
@@ -33829,7 +34110,8 @@ ${cleanBody}`;
               ideType: this.ideType || this.type,
               agentType: this.type,
               agentName: this.agentName || this.provider.name,
-              extensionId: this.extensionId || this.type
+              extensionId: this.extensionId || this.type,
+              finalSummary: extractFinalSummaryFromMessages(data?.messages)
             });
             this.generatingStartedAt = 0;
           }
@@ -34589,7 +34871,7 @@ ${effect.notification.body || ""}`.trim();
           } else if (agentStatus === "idle" && (lastStatus === "generating" || lastStatus === "waiting_approval")) {
             const startedAt = this.generatingStartedAt.get(agentKey);
             const duration3 = startedAt ? Math.round((now - startedAt) / 1e3) : 0;
-            this.pushEvent({ event: "agent:generating_completed", chatTitle, duration: duration3, timestamp: now, ideType: this.type });
+            this.pushEvent({ event: "agent:generating_completed", chatTitle, duration: duration3, timestamp: now, ideType: this.type, finalSummary: extractFinalSummaryFromMessages(chatData?.messages) });
             this.generatingStartedAt.delete(agentKey);
           }
           this.lastAgentStatuses.set(agentKey, agentStatus);
@@ -39652,7 +39934,8 @@ ${effect.notification.body || ""}`.trim();
           event: "agent:generating_completed",
           chatTitle: pending.chatTitle,
           duration: pending.duration,
-          timestamp: pending.timestamp
+          timestamp: pending.timestamp,
+          finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages)
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
@@ -41393,7 +41676,7 @@ ${rawInput}` : rawInput;
             });
           } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
             const duration3 = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
-            this.pushEvent({ event: "agent:generating_completed", chatTitle, duration: duration3, timestamp: now });
+            this.pushEvent({ event: "agent:generating_completed", chatTitle, duration: duration3, timestamp: now, finalSummary: extractFinalSummaryFromMessages(this.messages) });
             this.generatingStartedAt = 0;
           } else if (newStatus === "stopped") {
             this.pushEvent({ event: "agent:stopped", chatTitle, timestamp: now });
@@ -55833,7 +56116,7 @@ var import_ws = require("ws");
 var path4 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var import_crypto2 = require("crypto");
+var import_crypto = require("crypto");
 
 // src/standalone-preferences.ts
 var fs = __toESM(require("fs"));
@@ -56077,8 +56360,17 @@ function shouldAutoRestoreHostedSessionsOnStartup(env2 = process.env) {
 var os3 = __toESM(require("os"), 1);
 var path22 = __toESM(require("path"), 1);
 var net = __toESM(require("net"), 1);
-var import_crypto = require("crypto");
 var DEFAULT_SESSION_RING_BUFFER_MAX_BYTES = 4 * 1024 * 1024;
+function generateUUID2() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
 function getDefaultSessionHostEndpoint(appName = "adhdev") {
   if (process.platform === "win32") {
     return {
@@ -56169,7 +56461,7 @@ var SessionHostClient = class {
   async request(request) {
     await this.connect();
     if (!this.socket) throw new Error("Session host socket unavailable");
-    const requestId = (0, import_crypto.randomUUID)();
+    const requestId = generateUUID2();
     const envelope = {
       kind: "request",
       requestId,
@@ -56470,18 +56762,18 @@ function saveStandaloneBindHostPreference(bindHost) {
 function saveStandaloneFontPreferences(fontPreferences) {
   return saveStandalonePreferences(getStandaloneConfigJsonPath(), { standaloneFontPreferences: fontPreferences }).standaloneFontPreferences;
 }
-function createPasswordRecord(password, salt = (0, import_crypto2.randomBytes)(16).toString("hex")) {
+function createPasswordRecord(password, salt = (0, import_crypto.randomBytes)(16).toString("hex")) {
   return {
-    passwordHash: (0, import_crypto2.scryptSync)(`${password || ""}`, salt, PASSWORD_KEYLEN).toString("hex"),
+    passwordHash: (0, import_crypto.scryptSync)(`${password || ""}`, salt, PASSWORD_KEYLEN).toString("hex"),
     passwordSalt: salt,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
 }
 function verifyPassword(password, config2) {
   if (!config2?.passwordHash || !config2.passwordSalt) return false;
-  const actual = Buffer.from((0, import_crypto2.scryptSync)(`${password || ""}`, config2.passwordSalt, PASSWORD_KEYLEN).toString("hex"), "utf8");
+  const actual = Buffer.from((0, import_crypto.scryptSync)(`${password || ""}`, config2.passwordSalt, PASSWORD_KEYLEN).toString("hex"), "utf8");
   const expected = Buffer.from(config2.passwordHash, "utf8");
-  return actual.length === expected.length && (0, import_crypto2.timingSafeEqual)(actual, expected);
+  return actual.length === expected.length && (0, import_crypto.timingSafeEqual)(actual, expected);
 }
 function loadStandalonePasswordConfig(filePath = getStandalonePasswordConfigPath()) {
   if (!fs3.existsSync(filePath)) return null;
@@ -56544,7 +56836,7 @@ function buildClearedSessionCookie(secure) {
 var StandaloneSessionStore = class {
   sessions = /* @__PURE__ */ new Map();
   create(ttlMs = DEFAULT_SESSION_TTL_MS) {
-    const id = (0, import_crypto2.randomBytes)(24).toString("hex");
+    const id = (0, import_crypto.randomBytes)(24).toString("hex");
     this.sessions.set(id, Date.now() + ttlMs);
     return id;
   }