poi-plugin-mcp 0.2.12 → 0.2.14

package/lib/poi-http-bridge.js

@@ -6,6 +6,7 @@ const path = require('path')
 const packageJson = require('../package.json')
 const { loadOrCreateInputToken } = require('./input-token')
 const { createPoiInputProvider } = require('./poi-input')
+const { createPoiInputLease } = require('./poi-input-lease')
 const { createPoiScreenshotProvider } = require('./poi-screenshot')
 
 const DEFAULT_PORT = 17777
@@ -25,6 +26,8 @@ const JSONRPC_VERSION = '2.0'
 const MCP_PROTOCOL_VERSION = '2024-11-05'
 const INPUT_BODY_LIMIT = 64 * 1024
 const MASTER_FILE_LIMIT = 16 * 1024 * 1024
+const DEFAULT_ACTION_EVENT_LIMIT = 64
+const MAX_ACTION_EVENT_LIMIT = 256
 
 function createPoiDataBridge(options = {}) {
   const getStore = options.getStore || defaultGetStore
@@ -37,21 +40,30 @@ function createPoiDataBridge(options = {}) {
   const getQuestAction = options.getQuestAction || (() => ({ available: false, generation: 0 }))
   const getEquipmentAction = options.getEquipmentAction ||
     (() => ({ available: false, generation: 0 }))
+  const getUnsetSlot = options.getUnsetSlot ||
+    (() => ({ available: false, generation: 0 }))
   const getFleetAction = options.getFleetAction ||
     (() => ({ available: false, generation: 0 }))
+  const getActionEvents = options.getActionEvents ||
+    (() => ({
+      available: false,
+      sessionId: null,
+      latestGeneration: 0,
+      events: [],
+    }))
   const getBattleTelemetry = options.getBattleTelemetry ||
     (() => ({ available: false, generation: 0 }))
   const inputEnabled = options.inputEnabled === true
   const inputToken = options.inputToken || (
     inputEnabled ? loadOrCreateInputToken(options.inputTokenFile) : null
   )
+  const inputLease = options.inputLease || createPoiInputLease(options.inputLeaseOptions)
   let captureScreenshot = options.captureScreenshot || null
   let performInput = options.performInput || null
 
   let server = null
   let actualPort = 0
   let inputPending = Promise.resolve()
-  let inputSequence = 0
 
   function readStore() {
     const store = getStore()
@@ -84,17 +96,22 @@ function createPoiDataBridge(options = {}) {
     })
   }
 
-  function enqueueInput(operation) {
+  function enqueueInput(operation, claim) {
     const execute = async () => {
+      inputLease.assertClaimActive(claim)
       if (!performInput) {
         performInput = createPoiInputProvider({ getStore })
       }
       const operationName = await performInput(operation)
-      inputSequence += 1
       return {
         ok: true,
         operation: operationName,
-        sequence: inputSequence,
+        sequence: claim.sequence,
+        leaseId: claim.leaseId,
+        ownerSessionId: claim.ownerSessionId,
+        runId: claim.runId,
+        action: claim.action,
+        acceptedAt: claim.acceptedAt,
       }
     }
     const result = inputPending.then(execute, execute)
@@ -136,14 +153,92 @@ function createPoiDataBridge(options = {}) {
         'Input request body exceeds 64KB.',
       )
       const operation = JSON.parse(body || '{}')
-      sendInputJson(res, 200, await enqueueInput(operation))
+      const { input, claim } = claimInputOperation(inputLease, operation)
+      sendInputJson(res, 200, await enqueueInput(input, claim))
     } catch (error) {
-      const statusCode = error.code === 'BODY_TOO_LARGE'
+      const statusCode = error.statusCode || (error.code === 'BODY_TOO_LARGE'
         ? 413
         : /WebView|dimensions/.test(error.message)
           ? 503
-          : 400
-      sendInputJson(res, statusCode, { error: error.message })
+          : 400)
+      sendInputJson(res, statusCode, {
+        ...(error.code ? { code: error.code } : {}),
+        error: error.message,
+      })
+    }
+  }
+
+  async function handleInputLeaseRequest(req, res, endpoint) {
+    if (!hasValidBearerToken(req.headers.authorization, inputToken)) {
+      drainRequest(req)
+      sendInputJson(
+        res,
+        401,
+        { error: 'A valid Bearer token is required.' },
+        { headers: { 'WWW-Authenticate': 'Bearer' } },
+      )
+      return
+    }
+    if (endpoint === '/input/lease') {
+      if (req.method !== 'GET') {
+        drainRequest(req)
+        sendInputJson(res, 405, { error: 'Input lease status only accepts GET requests.' })
+        return
+      }
+      const lease = inputLease.status()
+      sendInputJson(res, 200, { active: lease !== null, lease })
+      return
+    }
+    if (req.method !== 'POST') {
+      drainRequest(req)
+      sendInputJson(res, 405, { error: 'Input lease changes only accept POST requests.' })
+      return
+    }
+    if (!inputEnabled) {
+      drainRequest(req)
+      sendInputJson(res, 403, { error: 'WebView input is disabled.' })
+      return
+    }
+    if (requestContentLength(req) > INPUT_BODY_LIMIT) {
+      drainRequest(req)
+      sendInputJson(res, 413, { error: 'Input request body exceeds 64KB.' })
+      return
+    }
+
+    try {
+      const body = await readRequestBody(
+        req,
+        INPUT_BODY_LIMIT,
+        'Input request body exceeds 64KB.',
+      )
+      const request = JSON.parse(body || '{}')
+      if (endpoint === '/input/lease/acquire') {
+        const lease = inputLease.acquire(request)
+        sendInputJson(res, 200, { active: true, lease })
+        return
+      }
+      if (endpoint === '/input/lease/renew') {
+        const lease = inputLease.renew(request)
+        sendInputJson(res, 200, { active: true, lease })
+        return
+      }
+      if (endpoint === '/input/lease/release') {
+        inputLease.release(request)
+        sendInputJson(res, 200, { active: false, released: true })
+        return
+      }
+      if (endpoint === '/input/lease/revoke') {
+        inputLease.revoke(request)
+        sendInputJson(res, 200, { active: false, revoked: true })
+        return
+      }
+      sendInputJson(res, 404, { error: `Unknown input lease endpoint: ${endpoint}` })
+    } catch (error) {
+      const statusCode = error.statusCode || (error.code === 'BODY_TOO_LARGE' ? 413 : 400)
+      sendInputJson(res, statusCode, {
+        ...(error.code ? { code: error.code } : {}),
+        error: error.message,
+      })
     }
   }
 
@@ -182,7 +277,11 @@ function createPoiDataBridge(options = {}) {
         return
       }
 
-      const endpoint = new URL(req.url, `http://127.0.0.1:${actualPort || configuredPort}`).pathname
+      const requestUrl = new URL(
+        req.url,
+        `http://127.0.0.1:${actualPort || configuredPort}`,
+      )
+      const endpoint = requestUrl.pathname
 
       if (endpoint === '/health') {
         sendJson(res, 200, { status: 'ok' })
@@ -239,6 +338,17 @@ function createPoiDataBridge(options = {}) {
         return
       }
 
+      if (
+        endpoint === '/input/lease' ||
+        endpoint === '/input/lease/acquire' ||
+        endpoint === '/input/lease/renew' ||
+        endpoint === '/input/lease/release' ||
+        endpoint === '/input/lease/revoke'
+      ) {
+        await handleInputLeaseRequest(req, res, endpoint)
+        return
+      }
+
       if (endpoint === '/input') {
         await handleInputRequest(req, res)
         return
@@ -259,11 +369,41 @@ function createPoiDataBridge(options = {}) {
         return
       }
 
+      if (endpoint === '/unsetslot') {
+        sendJson(res, 200, getUnsetSlot())
+        return
+      }
+
       if (endpoint === '/fleet-action') {
         sendJson(res, 200, getFleetAction())
         return
       }
 
+      if (endpoint === '/action-events') {
+        if (req.method !== 'GET') {
+          drainRequest(req)
+          sendJson(res, 405, {
+            error: 'Action events endpoint only accepts GET requests.',
+          })
+          return
+        }
+        sendJson(res, 200, getActionEvents({
+          after: clampedQueryInteger(
+            requestUrl.searchParams.get('after'),
+            0,
+            0,
+            Number.MAX_SAFE_INTEGER,
+          ),
+          limit: clampedQueryInteger(
+            requestUrl.searchParams.get('limit'),
+            DEFAULT_ACTION_EVENT_LIMIT,
+            1,
+            MAX_ACTION_EVENT_LIMIT,
+          ),
+        }))
+        return
+      }
+
       const store = readStore()
       const info = store.info
 
@@ -322,6 +462,11 @@ function createPoiDataBridge(options = {}) {
               records: (info.quests && info.quests.records) || {},
             },
             airbase: info.airbase || [],
+            repairs: info.repairs || [],
+            constructions: info.constructions || [],
+            maps: info.maps || {},
+            useitems: info.useitems || {},
+            sortie: store.sortie || {},
             names: extractNames(store),
           })
           break
@@ -385,6 +530,53 @@ function createPoiDataBridge(options = {}) {
   }
 }
 
+function clampedQueryInteger(value, fallback, minimum, maximum) {
+  if (value == null || value === '') return fallback
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed)) return fallback
+  return Math.min(maximum, Math.max(minimum, Math.trunc(parsed)))
+}
+
+function claimInputOperation(inputLease, request) {
+  if (!request || typeof request !== 'object' || Array.isArray(request)) {
+    throw inputBridgeError('INPUT_LEASE_REQUIRED', 'Input lease fields are required.', 409)
+  }
+  const {
+    leaseId,
+    ownerSessionId,
+    runId,
+    action,
+    sequence,
+    ...input
+  } = request
+  if (
+    typeof leaseId !== 'string' ||
+    typeof ownerSessionId !== 'string' ||
+    typeof runId !== 'string' ||
+    typeof action !== 'string' ||
+    !Number.isSafeInteger(sequence)
+  ) {
+    throw inputBridgeError('INPUT_LEASE_REQUIRED', 'Input lease fields are required.', 409)
+  }
+  return {
+    input,
+    claim: inputLease.consumeInput({
+      leaseId,
+      ownerSessionId,
+      runId,
+      action,
+      sequence,
+    }),
+  }
+}
+
+function inputBridgeError(code, message, statusCode) {
+  const error = new Error(message)
+  error.code = code
+  error.statusCode = statusCode
+  return error
+}
+
 function readRequestBody(
   req,
   maxBytes = 1024 * 1024,
@@ -631,6 +823,11 @@ function readBridgeData(endpoint, readStore, plannerFile) {
           records: (info.quests && info.quests.records) || {},
         },
         airbase: info.airbase || [],
+        repairs: info.repairs || [],
+        constructions: info.constructions || [],
+        maps: info.maps || {},
+        useitems: info.useitems || {},
+        sortie: store.sortie || {},
         names: extractNames(store),
       }
     default:

package/lib/poi-input-lease.js

@@ -0,0 +1,226 @@
+const crypto = require('node:crypto')
+
+const DEFAULT_TTL_MS = 10_000
+const MAX_TTL_MS = 30_000
+const MAX_ID_LENGTH = 256
+
+function createPoiInputLease(options = {}) {
+  const now = options.now || Date.now
+  const createId = options.createId || crypto.randomUUID
+  const defaultTtlMs = positiveInteger(
+    options.defaultTtlMs == null ? DEFAULT_TTL_MS : options.defaultTtlMs,
+    'defaultTtlMs',
+  )
+  const maxTtlMs = positiveInteger(
+    options.maxTtlMs == null ? MAX_TTL_MS : options.maxTtlMs,
+    'maxTtlMs',
+  )
+  if (defaultTtlMs > maxTtlMs) {
+    throw new Error('defaultTtlMs must not exceed maxTtlMs')
+  }
+
+  let active = null
+
+  function current() {
+    if (active && active.expiresAtMs <= now()) {
+      active = null
+    }
+    return active
+  }
+
+  function status() {
+    const lease = current()
+    return lease ? publicLease(lease) : null
+  }
+
+  function acquire(request) {
+    if (current()) {
+      throw leaseError('INPUT_LEASE_BUSY', 'Another input lease is active.')
+    }
+    const normalized = normalizeAcquireRequest(request, defaultTtlMs, maxTtlMs)
+    const leaseId = boundedId(createId(), 'leaseId')
+    active = {
+      leaseId,
+      ownerSessionId: normalized.ownerSessionId,
+      runId: normalized.runId,
+      mode: normalized.mode,
+      action: normalized.action,
+      expiresAtMs: now() + normalized.ttlMs,
+      nextSequence: 1,
+    }
+    return publicLease(active)
+  }
+
+  function renew(request) {
+    const lease = requireMatchingLease(request)
+    const ttlMs = normalizeTtl(request && request.ttlMs, defaultTtlMs, maxTtlMs)
+    lease.expiresAtMs = now() + ttlMs
+    return publicLease(lease)
+  }
+
+  function release(request) {
+    requireMatchingLease(request)
+    active = null
+    return true
+  }
+
+  function revoke(request) {
+    const lease = current()
+    if (!lease) {
+      throw leaseError('INPUT_LEASE_REQUIRED', 'No input lease is active.')
+    }
+    if (boundedId(request && request.leaseId, 'leaseId') !== lease.leaseId) {
+      throw leaseError('INPUT_LEASE_MISMATCH', 'Input lease identity does not match.')
+    }
+    active = null
+    return true
+  }
+
+  function consumeInput(request) {
+    const lease = requireMatchingLease(request)
+    const action = boundedId(request && request.action, 'action')
+    if (lease.mode === 'action' && action !== lease.action) {
+      throw leaseError(
+        'INPUT_LEASE_ACTION_MISMATCH',
+        `Input action ${action} does not match lease action ${lease.action}.`,
+      )
+    }
+    const sequence = request && request.sequence
+    if (!Number.isSafeInteger(sequence) || sequence !== lease.nextSequence) {
+      throw leaseError(
+        'INPUT_SEQUENCE_MISMATCH',
+        `Input sequence must be ${lease.nextSequence}.`,
+      )
+    }
+    lease.nextSequence += 1
+    return Object.freeze({
+      leaseId: lease.leaseId,
+      ownerSessionId: lease.ownerSessionId,
+      runId: lease.runId,
+      action,
+      sequence,
+      acceptedAt: new Date(now()).toISOString(),
+    })
+  }
+
+  function assertClaimActive(claim) {
+    const lease = requireMatchingLease(claim)
+    const action = boundedId(claim && claim.action, 'action')
+    const sequence = claim && claim.sequence
+    if (
+      !Number.isSafeInteger(sequence) ||
+      sequence < 1 ||
+      sequence >= lease.nextSequence ||
+      (lease.mode === 'action' && action !== lease.action)
+    ) {
+      throw leaseError('INPUT_LEASE_MISMATCH', 'Input claim does not match the lease.')
+    }
+    return true
+  }
+
+  function requireMatchingLease(request) {
+    const lease = current()
+    if (!lease) {
+      throw leaseError('INPUT_LEASE_REQUIRED', 'No input lease is active.')
+    }
+    const leaseId = boundedId(request && request.leaseId, 'leaseId')
+    const ownerSessionId = boundedId(
+      request && request.ownerSessionId,
+      'ownerSessionId',
+    )
+    const runId = boundedId(request && request.runId, 'runId')
+    if (
+      lease.leaseId !== leaseId ||
+      lease.ownerSessionId !== ownerSessionId ||
+      lease.runId !== runId
+    ) {
+      throw leaseError('INPUT_LEASE_MISMATCH', 'Input lease identity does not match.')
+    }
+    return lease
+  }
+
+  return Object.freeze({
+    status,
+    acquire,
+    renew,
+    release,
+    revoke,
+    consumeInput,
+    assertClaimActive,
+  })
+}
+
+function normalizeAcquireRequest(request, defaultTtlMs, maxTtlMs) {
+  const ownerSessionId = boundedId(request && request.ownerSessionId, 'ownerSessionId')
+  const runId = boundedId(request && request.runId, 'runId')
+  const mode = request && request.mode
+  if (mode !== 'action' && mode !== 'workflow') {
+    throw leaseError('INVALID_INPUT_LEASE', 'Input lease mode must be action or workflow.')
+  }
+  const action = request && request.action
+  if (
+    (mode === 'action' && (typeof action !== 'string' || action.length === 0)) ||
+    (mode === 'workflow' && action !== null)
+  ) {
+    throw leaseError(
+      'INVALID_INPUT_LEASE',
+      'Action leases require an action and workflow leases require action null.',
+    )
+  }
+  return {
+    ownerSessionId,
+    runId,
+    mode,
+    action: mode === 'action' ? boundedId(action, 'action') : null,
+    ttlMs: normalizeTtl(request.ttlMs, defaultTtlMs, maxTtlMs),
+  }
+}
+
+function normalizeTtl(value, defaultTtlMs, maxTtlMs) {
+  const ttlMs = value == null ? defaultTtlMs : value
+  if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0) {
+    throw leaseError('INVALID_INPUT_LEASE', 'Input lease ttlMs must be a positive integer.')
+  }
+  return Math.min(ttlMs, maxTtlMs)
+}
+
+function publicLease(lease) {
+  return Object.freeze({
+    leaseId: lease.leaseId,
+    ownerSessionId: lease.ownerSessionId,
+    runId: lease.runId,
+    mode: lease.mode,
+    action: lease.action,
+    expiresAt: new Date(lease.expiresAtMs).toISOString(),
+    nextSequence: lease.nextSequence,
+  })
+}
+
+function boundedId(value, name) {
+  if (
+    typeof value !== 'string' ||
+    value.length === 0 ||
+    value.length > MAX_ID_LENGTH
+  ) {
+    throw leaseError('INVALID_INPUT_LEASE', `${name} must be a non-empty string.`)
+  }
+  return value
+}
+
+function positiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error(`${name} must be a positive integer`)
+  }
+  return value
+}
+
+function leaseError(code, message) {
+  const error = new Error(message)
+  error.code = code
+  error.statusCode = code === 'INVALID_INPUT_LEASE' ? 400 : 409
+  return error
+}
+
+module.exports = {
+  createPoiInputLease,
+}

package/lib/poi-input.js

@@ -1,6 +1,7 @@
 const CANONICAL_WIDTH = 1200
 const CANONICAL_HEIGHT = 720
 const DEFAULT_CLICK_DELAY_MS = 10
+const DRAG_MOVE_STEPS = 6
 const MAX_TEXT_LENGTH = 256
 
 const SUPPORTED_BUTTONS = new Set(['left', 'middle', 'right'])
@@ -48,6 +49,10 @@ function createPoiInputProvider(options = {}) {
         validateClick(operation)
         await sendClick(layout, operation, delay, clickDelayMs)
         return 'click'
+      case 'drag':
+        validateDrag(operation)
+        await sendDrag(layout, operation, delay)
+        return 'drag'
       case 'key':
         validateKey(operation)
         await layout.webContents.sendInputEvent({
@@ -129,6 +134,48 @@ function validateClick(operation) {
   }
 }
 
+function validateDrag(operation) {
+  assertExactFields(operation, [
+    'operation',
+    'fromX',
+    'fromY',
+    'toX',
+    'toY',
+    'durationMs',
+    'button',
+  ])
+  const coordinates = [
+    operation.fromX,
+    operation.fromY,
+    operation.toX,
+    operation.toY,
+  ]
+  if (coordinates.some((coordinate) => !Number.isFinite(coordinate))) {
+    throw new Error('Drag coordinates must be finite numbers')
+  }
+  if (
+    operation.fromX < 0 ||
+    operation.fromX >= CANONICAL_WIDTH ||
+    operation.toX < 0 ||
+    operation.toX >= CANONICAL_WIDTH ||
+    operation.fromY < 0 ||
+    operation.fromY >= CANONICAL_HEIGHT ||
+    operation.toY < 0 ||
+    operation.toY >= CANONICAL_HEIGHT
+  ) {
+    throw new Error('Drag coordinates must be within canonical bounds')
+  }
+  if (!Number.isInteger(operation.durationMs)) {
+    throw new Error('Drag durationMs must be an integer')
+  }
+  if (operation.durationMs < 50 || operation.durationMs > 2000) {
+    throw new Error('Drag durationMs must be from 50 to 2000')
+  }
+  if (!SUPPORTED_BUTTONS.has(operation.button)) {
+    throw new Error(`Unsupported mouse button: ${String(operation.button)}`)
+  }
+}
+
 function validateKey(operation) {
   assertExactFields(operation, ['operation', 'event', 'key'])
   if (!SUPPORTED_KEY_EVENTS.has(operation.event)) {
@@ -181,6 +228,56 @@ async function sendClick(layout, operation, delay, clickDelayMs) {
   }
 }
 
+async function sendDrag(layout, operation, delay) {
+  const start = {
+    x: Math.floor((operation.fromX * layout.width) / CANONICAL_WIDTH),
+    y: Math.floor((operation.fromY * layout.height) / CANONICAL_HEIGHT),
+  }
+  const destination = {
+    x: Math.floor((operation.toX * layout.width) / CANONICAL_WIDTH),
+    y: Math.floor((operation.toY * layout.height) / CANONICAL_HEIGHT),
+  }
+  const mouseButton = { button: operation.button }
+
+  await layout.webContents.sendInputEvent({
+    type: 'mouseMove',
+    ...start,
+    ...mouseButton,
+  })
+  try {
+    await layout.webContents.sendInputEvent({
+      type: 'mouseDown',
+      ...start,
+      ...mouseButton,
+      clickCount: 1,
+    })
+    for (let step = 1; step <= DRAG_MOVE_STEPS; step += 1) {
+      const elapsed = Math.round((operation.durationMs * step) / DRAG_MOVE_STEPS)
+      const previousElapsed = Math.round(
+        (operation.durationMs * (step - 1)) / DRAG_MOVE_STEPS,
+      )
+      await delay(elapsed - previousElapsed)
+      await layout.webContents.sendInputEvent({
+        type: 'mouseMove',
+        x: Math.round(
+          start.x + ((destination.x - start.x) * step) / DRAG_MOVE_STEPS,
+        ),
+        y: Math.round(
+          start.y + ((destination.y - start.y) * step) / DRAG_MOVE_STEPS,
+        ),
+        ...mouseButton,
+      })
+    }
+  } finally {
+    await layout.webContents.sendInputEvent({
+      type: 'mouseUp',
+      ...destination,
+      ...mouseButton,
+      clickCount: 1,
+    })
+  }
+}
+
 function defaultDelay(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds))
 }