poi-plugin-mcp 0.2.24 → 0.2.26

package/lib/bridge-controller.js

@@ -1,3 +1,4 @@
+const path = require('path')
 const { createPoiDataBridge } = require('./poi-http-bridge')
 const { loadOrCreateInputToken } = require('./input-token')
 const {
@@ -10,13 +11,14 @@ const {
 function createBridgeController(options = {}) {
   const settingsPath = options.settingsPath || DEFAULT_SETTINGS_FILE
   const logger = options.logger || console
-  const createBridge = options.createBridge || createPoiDataBridge
+  let createBridge = options.createBridge || createPoiDataBridge
 
   let settings = loadSettings(settingsPath)
   let bridge = null
   let recorder = null
   let inputToken = options.inputToken || null
   let pending = Promise.resolve()
+  let reloading = false
 
   function enqueue(action) {
     pending = pending.then(action, action)
@@ -48,6 +50,8 @@ function createBridgeController(options = {}) {
       port: settings.port,
       portFile: options.portFile,
       logger,
+      isWriterTokenEnforced: () => settings.writerTokenEnforced === true,
+      reloadModules: hotReloadModules,
     })
   }
 
@@ -99,6 +103,64 @@ function createBridgeController(options = {}) {
     await runningBridge.stop()
   }
 
+  /**
+   * Hot reload (2026-09-12): purge this plugin's lib/ require cache and
+   * rebuild the bridge from the on-disk code. Live instances (this
+   * controller, the telemetry object wired in index.js, the recorder) keep
+   * their closures and state; only the module table refreshes. Returns after
+   * validation — the swap is scheduled so the HTTP response can flush first.
+   */
+  function hotReloadModules() {
+    if (reloading) {
+      return Promise.reject(new Error('a reload is already in progress'))
+    }
+    return enqueue(async () => {
+      reloading = true
+      try {
+        const libRoot = __dirname
+        for (const key of Object.keys(require.cache)) {
+          if (key.startsWith(libRoot + path.sep) || key === libRoot) {
+            delete require.cache[key]
+          }
+        }
+        // Fresh require throws on a broken build → old bridge untouched.
+        const fresh = require('./poi-http-bridge')
+        const freshFactory = fresh.createPoiDataBridge
+        if (typeof freshFactory !== 'function') {
+          throw new Error('fresh poi-http-bridge does not export createPoiDataBridge')
+        }
+        // Re-read settings: the fresh settings module may normalize new keys.
+        const freshSettings = require('./settings')
+        settings = freshSettings.normalizeSettings(
+          freshSettings.loadSettings(settingsPath),
+        )
+        createBridge = freshFactory
+        const wasEnabled = settings.enabled
+        // Let the /admin/reload response flush on the old connection before
+        // it drops; the swap then runs on the controller's serial queue.
+        setTimeout(() => {
+          enqueue(async () => {
+            try {
+              await stopCurrentBridge()
+              if (wasEnabled) await ensureStarted()
+              logger.log('[poi-plugin-mcp] hot reload complete')
+            } catch (error) {
+              logger.error(`[poi-plugin-mcp] hot reload swap failed: ${error.message}`)
+              // Best effort: the factory is already fresh; the next
+              // ensureStarted (any settings apply or manual start) recovers.
+              try {
+                if (wasEnabled) await ensureStarted()
+              } catch (_) { /* surfaced by the next status poll */ }
+            }
+          })
+        }, 250)
+        return { port: settings.port, deferredSwap: true }
+      } finally {
+        reloading = false
+      }
+    })
+  }
+
   function persist(nextSettings) {
     settings = saveSettings(normalizeSettings(nextSettings), settingsPath)
     return settings
@@ -175,6 +237,18 @@ function createBridgeController(options = {}) {
       return { ...settings }
     },
 
+    /**
+     * 2026-09-12 hot reload: rebuild the HTTP/input layer from the on-disk
+     * lib/ code without restarting poi. Telemetry getters are re-injected
+     * (event generations survive); the recorder session is untouched.
+     *
+     * Ordering: the fresh modules are required BEFORE anything stops — a bad
+     * build throws here, the old bridge keeps serving, and the caller gets a
+     * 500 with the require error. The swap itself is deferred so the
+     * /admin/reload response flushes on the old connection before it drops.
+     */
+    reloadModules: hotReloadModules,
+
     getStatus() {
       const actualPort = bridge ? bridge.getPort() : 0
       const recorderStatus = recorder && typeof recorder.getStatus === 'function'

package/lib/poi-http-bridge.js

@@ -5,6 +5,7 @@ const os = require('os')
 const path = require('path')
 const packageJson = require('../package.json')
 const { loadOrCreateInputToken } = require('./input-token')
+const { getWriterTokenRegistry, hasValidWriterToken } = require('./writer-tokens')
 const { createPoiInputProvider } = require('./poi-input')
 const { createPoiInputLease } = require('./poi-input-lease')
 const { createPoiScreenshotProvider } = require('./poi-screenshot')
@@ -107,6 +108,14 @@ function createPoiDataBridge(options = {}) {
     inputEnabled ? loadOrCreateInputToken(options.inputTokenFile) : null
   )
   const inputLease = options.inputLease || createPoiInputLease(options.inputLeaseOptions)
+  // 2026-09-12 Phase C: daemon-delegated writer tokens gate the INPUT
+  // surface (clicks, lease takes, debug-eval). Module-level singleton so
+  // settings-triggered bridge re-creation keeps the registered set; a hot
+  // reload purges the module, and the daemon's periodic re-registration
+  // self-heals within one idle cycle.
+  const writerTokens = options.writerTokens || getWriterTokenRegistry()
+  const isWriterTokenEnforced = options.isWriterTokenEnforced ||
+    (() => options.writerTokenEnforced === true)
   let captureScreenshot = options.captureScreenshot || null
   let performInput = options.performInput || null
   let dataQuery = options.dataQuery || null
@@ -116,6 +125,33 @@ function createPoiDataBridge(options = {}) {
   let inputPending = Promise.resolve()
   const pendingActionEventWaits = new Set()
 
+  /**
+   * Writer-token gate for input-capable endpoints. Callers have already
+   * validated the static bearer (transport auth). Three outcomes:
+   * registered token -> pass; missing/rejected token + enforcement -> 403
+   * with a reason a stale process can act on; missing token in observation
+   * mode -> pass and count (legacyAuth), which is the bridge-side
+   * foreign-writer signal.
+   */
+  function authorizeWriterInput(req) {
+    const headerValue = req.headers['x-writer-token']
+    if (hasValidWriterToken(headerValue, writerTokens)) {
+      return { ok: true }
+    }
+    if (isWriterTokenEnforced()) {
+      return {
+        ok: false,
+        status: 403,
+        error:
+          'Writer token rejected: no registered X-Writer-Token matches. ' +
+          'Stale process from a previous daemon generation? Re-submit the work ' +
+          'through the daemon (kc daemon submit) or renew the token.',
+      }
+    }
+    writerTokens.noteLegacyAuth()
+    return { ok: true, legacy: true }
+  }
+
   function readStore() {
     const store = getStore()
     if (!store || !store.info) {
@@ -176,6 +212,17 @@ function createPoiDataBridge(options = {}) {
       )
       return
     }
+    // /debug/evaluate executes arbitrary JS in the game WebView — it is a
+    // write-capable channel and takes the writer-token gate. /query is a
+    // read and stays static-bearer (diagnostics keep working).
+    if (endpoint === '/debug/evaluate') {
+      const writer = authorizeWriterInput(req)
+      if (!writer.ok) {
+        drainRequest(req)
+        sendInputJson(res, writer.status, { error: writer.error })
+        return
+      }
+    }
     try {
       const body = await readRequestBody(
         req,
@@ -261,6 +308,12 @@ function createPoiDataBridge(options = {}) {
       sendInputJson(res, 403, { error: 'WebView input is disabled.' })
       return
     }
+    const writer = authorizeWriterInput(req)
+    if (!writer.ok) {
+      drainRequest(req)
+      sendInputJson(res, writer.status, { error: writer.error })
+      return
+    }
 
     try {
       const body = await readRequestBody(
@@ -295,6 +348,15 @@ function createPoiDataBridge(options = {}) {
       )
       return
     }
+    // Lease take/renew are input-adjacent (they gate who may click); the
+    // writer-token applies. Release is also gated for symmetry — leases
+    // expire via TTL anyway, so a stale cleanup tool failing here is safe.
+    const leaseWriter = authorizeWriterInput(req)
+    if (!leaseWriter.ok) {
+      drainRequest(req)
+      sendInputJson(res, leaseWriter.status, { error: leaseWriter.error })
+      return
+    }
     if (endpoint === '/input/lease') {
       if (req.method !== 'GET') {
         drainRequest(req)
@@ -527,6 +589,79 @@ function createPoiDataBridge(options = {}) {
         return
       }
 
+      // 2026-09-12 Phase C: writer-token administration. The static bearer is
+      // the ADMIN credential here — exactly one caller (the daemon) uses it
+      // to delegate; input endpoints no longer accept it as a writer.
+      if (endpoint === '/writer-tokens') {
+        if (!hasValidBearerToken(req.headers.authorization, inputToken)) {
+          drainRequest(req)
+          sendInputJson(res, 401, { error: 'A valid Bearer token is required.' })
+          return
+        }
+        if (req.method === 'GET') {
+          sendInputJson(res, 200, {
+            enforced: isWriterTokenEnforced(),
+            ...writerTokens.status(),
+          })
+          return
+        }
+        if (req.method !== 'PUT') {
+          drainRequest(req)
+          sendInputJson(res, 405, { error: '/writer-tokens accepts GET or PUT.' })
+          return
+        }
+        try {
+          const body = await readRequestBody(
+            req,
+            MAX_QUERY_BODY_BYTES,
+            'Writer token request body exceeds 64KB.',
+          )
+          const payload = JSON.parse(body || '{}')
+          const outcome = writerTokens.register(payload)
+          sendInputJson(res, 200, { ok: true, ...outcome, ...writerTokens.status() })
+        } catch (error) {
+          sendInputJson(res, 400, { error: error.message })
+        }
+        return
+      }
+
+      // 2026-09-12 hot reload: rebuild the HTTP/input layer from the on-disk
+      // lib/ code without restarting poi. Telemetry state and the recorder
+      // session survive (the controller re-injects the same getters); open
+      // connections drop and clients reconnect.
+      if (endpoint === '/admin/reload') {
+        if (!hasValidBearerToken(req.headers.authorization, inputToken)) {
+          drainRequest(req)
+          sendInputJson(res, 401, { error: 'A valid Bearer token is required.' })
+          return
+        }
+        if (req.method !== 'POST') {
+          drainRequest(req)
+          sendInputJson(res, 405, { error: '/admin/reload only accepts POST.' })
+          return
+        }
+        drainRequest(req)
+        if (typeof options.reloadModules !== 'function') {
+          sendInputJson(res, 501, { error: 'reloadModules is not wired by this controller build' })
+          return
+        }
+        try {
+          const outcome = await options.reloadModules()
+          // After a successful reload THIS bridge instance is stopped and the
+          // fresh one owns the port — report the outcome's port, not the
+          // stale local getPort().
+          sendInputJson(res, 200, {
+            ok: true,
+            reloaded: true,
+            port: (outcome && outcome.port) || getPort(),
+            ...(outcome || {}),
+          })
+        } catch (error) {
+          sendInputJson(res, 500, { ok: false, error: error.message })
+        }
+        return
+      }
+
       if (endpoint === '/screenshot') {
         if (req.method !== 'GET') {
           sendJson(
@@ -769,6 +904,15 @@ function createPoiDataBridge(options = {}) {
         actualPort = 0
         resolve()
       })
+      // Keep-alive clients (the daemon holds persistent connections) never
+      // let close() finish on their own — reap them, but only after the
+      // aborted long-poll responses had a turn to flush (live 0912: an
+      // immediate reap raced the wait-abort writes into ECONNRESET).
+      setImmediate(() => {
+        if (typeof closingServer.closeAllConnections === 'function') {
+          closingServer.closeAllConnections()
+        }
+      })
     })
   }
 

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,
 }

package/lib/settings.js

@@ -8,6 +8,12 @@ const DEFAULT_SETTINGS = Object.freeze({
   inputEnabled: false,
   recordingEnabled: false,
   debugEvalEnabled: false,
+  // 2026-09-12 Phase C: when true, INPUT endpoints (/input, /input/lease*,
+  // /debug/evaluate) require a registered X-Writer-Token in addition to the
+  // static bearer. Observation mode (false) serves legacy static-bearer
+  // requests but counts them — the daemon registers tokens and sends them
+  // either way, so flipping this only rejects leftovers.
+  writerTokenEnforced: false,
 })
 
 const DEFAULT_SETTINGS_FILE = path.join(os.homedir(), '.poi-mcp', 'settings.json')
@@ -26,6 +32,9 @@ function normalizeSettings(input = {}) {
     debugEvalEnabled: typeof input.debugEvalEnabled === 'boolean'
       ? input.debugEvalEnabled
       : DEFAULT_SETTINGS.debugEvalEnabled,
+    writerTokenEnforced: typeof input.writerTokenEnforced === 'boolean'
+      ? input.writerTokenEnforced
+      : DEFAULT_SETTINGS.writerTokenEnforced,
   }
 }
 

package/lib/writer-tokens.js

@@ -0,0 +1,130 @@
+const crypto = require('crypto')
+
+const TOKEN_PATTERN = /^[a-f0-9]{32,128}$/
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000
+
+/**
+ * Daemon-delegated writer tokens (2026-09-12 single-writer plan, Phase C).
+ *
+ * The static input token authorizes whoever can read the file — forever. A
+ * zombie from an earlier session therefore holds a valid credential forever.
+ * This registry replaces that for INPUT endpoints: the daemon mints short
+ * lived tokens (a generation token for itself, one per spawned job), pushes
+ * them here over the admin endpoint, and revokes job tokens when the reaper
+ * collects the job. A process that missed a rotation is rejected with a
+ * readable reason instead of silently competing for clicks.
+ *
+ * Module-level singleton: bridge restarts (settings apply, hot reload) must
+ * not silently drop the registered set — and when a hot reload DOES purge
+ * this module, the daemon's periodic re-registration self-heals within one
+ * idle cycle. The threat model is accidents, not adversaries: holding a
+ * current token is a sufficient proxy for "delegated by the current daemon
+ * generation", so there is deliberately no per-pid challenge/response.
+ */
+function createWriterTokenRegistry() {
+  const entries = new Map() // token -> { label, registeredAt, expiresAt }
+  let legacyAuthCount = 0
+  let lastLegacyAuthAt = null
+
+  function sweep(now = Date.now()) {
+    for (const [token, entry] of entries) {
+      if (entry.expiresAt <= now) entries.delete(token)
+    }
+  }
+
+  return {
+    register(payload, now = Date.now()) {
+      const mode = payload && (payload.mode === 'add' || payload.mode === 'remove') ? payload.mode : 'replace'
+      const list = payload && Array.isArray(payload.tokens) ? payload.tokens : []
+      if (mode === 'replace') entries.clear()
+      let accepted = 0
+      let rejected = []
+      for (const item of list) {
+        const token = item && typeof item.token === 'string' ? item.token : null
+        if (!TOKEN_PATTERN.test(token || '')) {
+          rejected.push('invalid token shape')
+          continue
+        }
+        const ttlMs = Number.isFinite(item.ttlMs) && item.ttlMs > 0 && item.ttlMs <= 7 * DEFAULT_TTL_MS
+          ? Math.trunc(item.ttlMs)
+          : DEFAULT_TTL_MS
+        entries.set(token, {
+          label: typeof item.label === 'string' && item.label !== '' ? item.label.slice(0, 128) : 'unlabeled',
+          registeredAt: now,
+          expiresAt: now + ttlMs,
+        })
+        accepted += 1
+      }
+      if (mode === 'remove') {
+        for (const item of list) {
+          if (item && typeof item.label === 'string') {
+            for (const [token, entry] of entries) {
+              if (entry.label === item.label) entries.delete(token)
+            }
+          }
+        }
+      }
+      sweep(now)
+      return { accepted, rejected: rejected.length }
+    },
+
+    validate(token, now = Date.now()) {
+      if (typeof token !== 'string' || !TOKEN_PATTERN.test(token)) return false
+      const entry = entries.get(token)
+      if (!entry) return false
+      if (entry.expiresAt <= now) {
+        entries.delete(token)
+        return false
+      }
+      return true
+    },
+
+    noteLegacyAuth(now = Date.now()) {
+      legacyAuthCount += 1
+      lastLegacyAuthAt = new Date(now).toISOString()
+    },
+
+    status(now = Date.now()) {
+      sweep(now)
+      return {
+        registered: entries.size,
+        tokens: [...entries.values()].map((entry) => ({
+          label: entry.label,
+          registeredAt: new Date(entry.registeredAt).toISOString(),
+          expiresAt: new Date(entry.expiresAt).toISOString(),
+        })),
+        legacyAuthCount,
+        lastLegacyAuthAt,
+      }
+    },
+  }
+}
+
+let singleton = null
+
+function getWriterTokenRegistry() {
+  if (!singleton) singleton = createWriterTokenRegistry()
+  return singleton
+}
+
+function mintWriterToken() {
+  return crypto.randomBytes(32).toString('hex')
+}
+
+function hasValidWriterToken(headerValue, registry, now = Date.now()) {
+  if (typeof headerValue !== 'string' || headerValue === '') return false
+  // In-process registry lookup: the timing-safe compare discipline applies to
+  // the STATIC bearer token (a file secret); membership here is an in-memory
+  // Map hit against an unregistered attacker-chosen value with no secret to
+  // leak.
+  return registry.validate(headerValue, now)
+}
+
+module.exports = {
+  TOKEN_PATTERN,
+  DEFAULT_TTL_MS,
+  createWriterTokenRegistry,
+  getWriterTokenRegistry,
+  mintWriterToken,
+  hasValidWriterToken,
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poi-plugin-mcp",
-  "version": "0.2.24",
+  "version": "0.2.26",
   "description": "Poi data, WebView capture, and opt-in authenticated input bridge for local KanColle tools.",
   "main": "index.js",
   "keywords": [