poi-plugin-mcp 0.2.23 → 0.2.25

package/lib/poi-auto-interaction-recorder.js

@@ -13,6 +13,13 @@ function createPoiAutoInteractionRecorder(options = {}) {
     const remote = loadElectronRemote()
     return remote.webContents.fromId(webContentsId)
   })
+  // Remote-proxy memoization (0909 leak fix): every getWebContents() across
+  // @electron/remote registers fresh objects in poi's main-process
+  // ObjectsRegistry; at ~1 call/sec the per-context Map hits V8's size cap
+  // (RangeError: Map maximum size exceeded) and ALL game writes die until
+  // poi restarts. Resolve by integer id (no registration) and cache the
+  // proxy — Electron ids are monotonic, never reused after destroy.
+  const webContentsProxyCache = new Map()
   let captureScreenshot = options.captureScreenshot || null
   const createSessionRecorder = options.createSessionRecorder
   const eventTarget = options.eventTarget === undefined
@@ -63,12 +70,24 @@ function createPoiAutoInteractionRecorder(options = {}) {
   function currentWebContents() {
     const layout = getStore('layout.webview')
     if (!layout || !layout.ref) return null
-    if (typeof layout.ref.getWebContents === 'function') {
-      return layout.ref.getWebContents()
-    }
     if (typeof layout.ref.getWebContentsId === 'function') {
       const id = layout.ref.getWebContentsId()
-      if (Number.isInteger(id) && id > 0) return resolveWebContents(id)
+      if (Number.isInteger(id) && id > 0) {
+        const hit = webContentsProxyCache.get(id)
+        if (hit) return hit
+        const resolved = resolveWebContents(id)
+        if (resolved) {
+          webContentsProxyCache.set(id, resolved)
+          return resolved
+        }
+      }
+    }
+    if (typeof layout.ref.getWebContents === 'function') {
+      const webContents = layout.ref.getWebContents()
+      if (webContents) {
+        webContentsProxyCache.set('ref', webContents)
+        return webContents
+      }
     }
     return null
   }

package/lib/poi-interaction-recorder.js

@@ -16,8 +16,17 @@ const DEFAULT_MAX_SESSION_BYTES = 8 * 1024 * 1024 * 1024
 const DEFAULT_MAX_TIMELINE_EVENTS = 20000
 const DEFAULT_MAX_SESSION_DURATION_MS = 4 * 60 * 60 * 1000
 const DEFAULT_MAX_SCREENSHOT_BYTES = 16 * 1024 * 1024
-const DEFAULT_MAX_STORED_SESSIONS = 200
-const DEFAULT_MAX_TOTAL_RECORDING_BYTES = 64 * 1024 * 1024 * 1024
+const DEFAULT_MAX_STORED_SESSIONS = envPositiveInteger(
+  'POI_MCP_RECORDING_MAX_SESSIONS',
+  200,
+)
+const DEFAULT_MAX_TOTAL_RECORDING_BYTES = envPositiveInteger(
+  'POI_MCP_RECORDING_MAX_TOTAL_BYTES',
+  20 * 1024 * 1024 * 1024,
+)
+// Byte-gate headroom: evict oldest sessions until the root is below this
+// fraction of the cap so a fresh session cannot immediately re-trip the gate.
+const RECORDING_BYTE_HEADROOM_FRACTION = 0.9
 const DEFAULT_FINAL_MANIFEST_RESERVE_BYTES = 64 * 1024
 const DEFAULT_CHECKPOINT_DELAYS_MS = Object.freeze([0, 250, 1000])
 const DEFAULT_OUTPUT_ROOT = process.platform === 'win32'
@@ -713,9 +722,17 @@ function createPoiInteractionRecorder(options = {}) {
     if (running) return getStatus()
     try {
     const recordingRoot = await inspectRecordingRoot(outputRoot)
-    if (recordingRoot.sessionCount >= maxStoredSessions) {
-      const overflow = recordingRoot.sessionCount - maxStoredSessions + 1
-      await pruneOldestSessions(recordingRoot.sessionDirectories, overflow, logger)
+    // Retention: both the session-count and byte gates evict oldest-first
+    // instead of refusing to start; the byte gate leaves headroom for the
+    // session that is about to begin.
+    const evictCount = recordingRetentionEvictionCount({
+      sessions: recordingRoot.sessions,
+      totalBytes: recordingRoot.byteCount,
+      maxStoredSessions,
+      maxTotalRecordingBytes,
+    })
+    if (evictCount > 0) {
+      await pruneOldestSessions(recordingRoot.sessionDirectories, evictCount, logger)
     }
     const afterPrune = await inspectRecordingRoot(outputRoot)
     if (afterPrune.byteCount >= maxTotalRecordingBytes) {
@@ -950,7 +967,7 @@ async function inspectRecordingRoot(outputRoot) {
     entries = await fs.promises.readdir(outputRoot, { withFileTypes: true })
   } catch (error) {
     if (error && error.code === 'ENOENT') {
-      return { sessionCount: 0, byteCount: 0, sessionDirectories: [] }
+      return { sessionCount: 0, byteCount: 0, sessionDirectories: [], sessions: [] }
     }
     throw error
   }
@@ -969,9 +986,12 @@ async function inspectRecordingRoot(outputRoot) {
       if (!error || error.code !== 'ENOENT') throw error
     }
   }
-  const stack = [...directories]
+  // Attribute every byte to its top-level directory so retention can rank
+  // sessions by size as well as age.
+  const rootBytes = new Map(directories.map((directory) => [directory, 0]))
+  const stack = directories.map((directory) => ({ directory, root: directory }))
   while (stack.length > 0) {
-    const directory = stack.pop()
+    const { directory, root } = stack.pop()
     let children
     try {
       children = await fs.promises.readdir(directory, { withFileTypes: true })
@@ -983,10 +1003,12 @@ async function inspectRecordingRoot(outputRoot) {
       if (child.isSymbolicLink()) continue
       const childPath = path.join(directory, child.name)
       if (child.isDirectory()) {
-        stack.push(childPath)
+        stack.push({ directory: childPath, root })
       } else if (child.isFile()) {
         try {
-          byteCount += (await fs.promises.stat(childPath)).size
+          const size = (await fs.promises.stat(childPath)).size
+          byteCount += size
+          rootBytes.set(root, (rootBytes.get(root) || 0) + size)
         } catch (error) {
           if (!error || error.code !== 'ENOENT') throw error
         }
@@ -996,13 +1018,41 @@ async function inspectRecordingRoot(outputRoot) {
   const sessionDirectories = directories.filter((directory) =>
     SESSION_DIRECTORY_PATTERN.test(path.basename(directory)),
   )
+  const sessions = sessionDirectories.map((directory) => ({
+    directory,
+    bytes: rootBytes.get(directory) || 0,
+  }))
   return {
     sessionCount: sessionDirectories.length,
     byteCount,
     sessionDirectories,
+    sessions,
   }
 }
 
+// Oldest-first eviction count for the two retention gates. `sessions` must be
+// sorted oldest-first (inspectRecordingRoot guarantees this via name sort).
+function recordingRetentionEvictionCount({
+  sessions,
+  totalBytes,
+  maxStoredSessions,
+  maxTotalRecordingBytes,
+}) {
+  if (!Array.isArray(sessions)) return 0
+  const countOverflow = sessions.length >= maxStoredSessions
+    ? sessions.length - maxStoredSessions + 1
+    : 0
+  const byteTarget = Math.floor(maxTotalRecordingBytes * RECORDING_BYTE_HEADROOM_FRACTION)
+  let byteEvictions = 0
+  let recovered = 0
+  for (const session of sessions) {
+    if (totalBytes - recovered <= byteTarget) break
+    recovered += Number.isFinite(session.bytes) ? session.bytes : 0
+    byteEvictions += 1
+  }
+  return Math.max(countOverflow, byteEvictions)
+}
+
 async function pruneOldestSessions(sessionDirectories, count, logger) {
   if (count <= 0) return
   for (const directory of sessionDirectories.slice(0, count)) {
@@ -1550,6 +1600,14 @@ function positiveInteger(value, fallback, name) {
   return selected
 }
 
+function envPositiveInteger(name, fallback) {
+  const raw = process.env[name]
+  if (raw === undefined || raw === '') return fallback
+  const parsed = Number(raw)
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) return fallback
+  return parsed
+}
+
 function positiveNumber(value, fallback, name) {
   const selected = value == null ? fallback : value
   if (!Number.isFinite(selected) || selected <= 0) {
@@ -1687,7 +1745,11 @@ module.exports = {
   DEFAULT_MAX_STORED_SESSIONS,
   DEFAULT_MAX_TOTAL_RECORDING_BYTES,
   DEFAULT_OUTPUT_ROOT,
+  RECORDING_BYTE_HEADROOM_FRACTION,
   captureEquipmentUiStateFromWebContents: defaultCaptureEquipmentUiState,
   captureWebStorageFromWebContents: defaultCaptureWebStorage,
   createPoiInteractionRecorder,
+  inspectRecordingRoot,
+  pruneOldestSessions,
+  recordingRetentionEvictionCount,
 }