poi-plugin-mcp 0.2.28 → 0.2.29

package/lib/pixi-hit-ledger.js

@@ -197,7 +197,9 @@ function createPixiHitLedger(options = {}) {
       ? { x: operation.x, y: operation.y }
       : operation.operation === 'drag'
         ? { x: operation.fromX, y: operation.fromY }
-        : null
+        : operation.operation === 'scroll'
+          ? { x: operation.x, y: operation.y }
+          : null
     if (point === null) return Object.freeze({ available: false, reason: 'not_pointer' })
     const record = {
       at: capturedAt,

package/lib/poi-action-events.js

@@ -16,16 +16,21 @@ const EXACT_PATHS = new Set([
   '/kcsapi/api_start2/getData',
   '/kcsapi/api_port/port',
   '/kcsapi/api_get_member/base_air_corps',
+  '/kcsapi/api_get_member/chart_additional_info',
   '/kcsapi/api_get_member/deck',
+  '/kcsapi/api_get_member/furniture',
   '/kcsapi/api_get_member/kdock',
   '/kcsapi/api_get_member/mapinfo',
   '/kcsapi/api_get_member/material',
+  '/kcsapi/api_get_member/mission',
   '/kcsapi/api_get_member/ndock',
   '/kcsapi/api_get_member/practice',
+  '/kcsapi/api_get_member/preset_deck',
   '/kcsapi/api_get_member/questlist',
   '/kcsapi/api_get_member/require_info',
   '/kcsapi/api_get_member/ship2',
   '/kcsapi/api_get_member/ship3',
+  '/kcsapi/api_get_member/ship_deck',
   '/kcsapi/api_get_member/slot_item',
   '/kcsapi/api_get_member/unsetslot',
   '/kcsapi/api_get_member/useitem',
@@ -39,11 +44,13 @@ const EXACT_PATHS = new Set([
   '/kcsapi/api_req_hensei/combined',
   '/kcsapi/api_req_hensei/preset_select',
   '/kcsapi/api_req_hokyu/charge',
+  '/kcsapi/api_req_kaisou/can_preset_slot_select',
   '/kcsapi/api_req_kaisou/powerup',
   '/kcsapi/api_req_kaisou/slot_select',
   '/kcsapi/api_req_kaisou/slot_deprive',
   '/kcsapi/api_req_kaisou/slotset',
   '/kcsapi/api_req_kaisou/slotset_ex',
+  '/kcsapi/api_req_kaisou/unsetslot',
   '/kcsapi/api_req_kaisou/unsetslot_all',
   '/kcsapi/api_req_kousyou/createitem',
   '/kcsapi/api_req_kousyou/createship',
@@ -57,6 +64,7 @@ const EXACT_PATHS = new Set([
   '/kcsapi/api_req_map/start',
   '/kcsapi/api_req_map/start_air_base',
   '/kcsapi/api_req_member/get_practice_enemyinfo',
+  '/kcsapi/api_req_member/set_oss_condition',
   '/kcsapi/api_req_mission/result',
   '/kcsapi/api_req_mission/start',
   '/kcsapi/api_req_nyukyo/speedchange',
@@ -76,6 +84,7 @@ const ALLOWED_PREFIXES = [
 ]
 
 const SHARED_TELEMETRY_TIMESTAMP_PATHS = new Set([
+  '/kcsapi/api_get_member/mission',
   '/kcsapi/api_get_member/questlist',
   '/kcsapi/api_get_member/unsetslot',
   '/kcsapi/api_req_quest/start',

package/lib/poi-http-bridge.js

@@ -290,7 +290,9 @@ function createPoiDataBridge(options = {}) {
       let hit
       if (
         debugEvalEnabled === true &&
-        (operation.operation === 'click' || operation.operation === 'drag')
+        (operation.operation === 'click' ||
+          operation.operation === 'drag' ||
+          operation.operation === 'scroll')
       ) {
         hit = await currentHitLedger().capture(operation, {
           leaseId: claim.leaseId,
@@ -832,6 +834,33 @@ function createPoiDataBridge(options = {}) {
         return
       }
 
+      if (endpoint === '/api-responses') {
+        if (req.method !== 'GET') {
+          drainRequest(req)
+          sendJson(res, 405, {
+            error: 'API responses endpoint only accepts GET requests.',
+          })
+          return
+        }
+        const pathFilter = requestUrl.searchParams.get('path')
+        sendJson(res, 200, getApiResponses({
+          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,
+          ),
+          ...(pathFilter === null ? {} : { path: pathFilter }),
+        }))
+        return
+      }
+
       const store = readStore()
       const info = store.info
 

package/lib/poi-input.js

@@ -2,7 +2,19 @@ const CANONICAL_WIDTH = 1200
 const CANONICAL_HEIGHT = 720
 const DRAG_MOVE_STEPS = 6
 const DRAG_RELEASE_DELAY_MS = 120
+const HOVER_MOVE_STEPS = 10
+const HOVER_MOVE_STEP_DELAY_MS = 45
+const HOVER_ENTRY_OFFSET_X = 44
 const MAX_TEXT_LENGTH = 256
+// One wheel detent (a physical mouse-wheel notch) is WHEEL_DELTA = 120 in
+// Win32 terms; Chromium reports ~100-120 px of deltaY per notch on Windows
+// default scroll settings. 120 per event is the Puppeteer/Playwright
+// convention for "one notch" and matches what a real wheel delivers here.
+const SCROLL_NOTCH_DELTA = 120
+const DEFAULT_SCROLL_INTERVAL_MS = 40
+const MIN_SCROLL_INTERVAL_MS = 20
+const MAX_SCROLL_INTERVAL_MS = 200
+const MAX_SCROLL_NOTCHES = 50
 
 const SUPPORTED_BUTTONS = new Set(['left', 'middle', 'right'])
 const SUPPORTED_KEY_EVENTS = new Set(['keyDown', 'keyUp'])
@@ -44,7 +56,7 @@ function createPoiInputProvider(options = {}) {
     switch (operation.operation) {
       case 'move':
         validateMove(operation)
-        sendMove(layout, operation)
+        await sendMove(layout, operation, delay)
         return 'move'
       case 'click':
         validateClick(operation)
@@ -54,6 +66,10 @@ function createPoiInputProvider(options = {}) {
         validateDrag(operation)
         await sendDrag(layout, operation, delay)
         return 'drag'
+      case 'scroll':
+        validateScroll(operation)
+        await sendScroll(layout, operation, delay)
+        return 'scroll'
       case 'key':
         validateKey(operation)
         await layout.webContents.sendInputEvent({
@@ -164,15 +180,37 @@ function validateClick(operation) {
 }
 
 function validateMove(operation) {
-  assertExactFields(operation, ['operation', 'x', 'y'])
-  if (!Number.isFinite(operation.x) || !Number.isFinite(operation.y)) {
+  const hasOriginX = operation.fromX !== undefined
+  const hasOriginY = operation.fromY !== undefined
+  if (hasOriginX !== hasOriginY) {
+    throw new Error('Move origin coordinates must be provided together')
+  }
+  assertExactFields(
+    operation,
+    hasOriginX
+      ? ['operation', 'x', 'y', 'fromX', 'fromY']
+      : ['operation', 'x', 'y'],
+  )
+  const xCoordinates = hasOriginX
+    ? [operation.x, operation.fromX]
+    : [operation.x]
+  const yCoordinates = hasOriginY
+    ? [operation.y, operation.fromY]
+    : [operation.y]
+  if (
+    xCoordinates
+      .concat(yCoordinates)
+      .some((coordinate) => !Number.isFinite(coordinate))
+  ) {
     throw new Error('Move coordinates must be finite numbers')
   }
   if (
-    operation.x < 0 ||
-    operation.x >= CANONICAL_WIDTH ||
-    operation.y < 0 ||
-    operation.y >= CANONICAL_HEIGHT
+    xCoordinates.some(
+      (coordinate) => coordinate < 0 || coordinate >= CANONICAL_WIDTH,
+    ) ||
+    yCoordinates.some(
+      (coordinate) => coordinate < 0 || coordinate >= CANONICAL_HEIGHT,
+    )
   ) {
     throw new Error('Move coordinates must be within canonical bounds')
   }
@@ -220,6 +258,45 @@ function validateDrag(operation) {
   }
 }
 
+function validateScroll(operation) {
+  const hasInterval = operation.intervalMs !== undefined
+  assertExactFields(
+    operation,
+    hasInterval
+      ? ['operation', 'x', 'y', 'notches', 'intervalMs']
+      : ['operation', 'x', 'y', 'notches'],
+  )
+  if (!Number.isFinite(operation.x) || !Number.isFinite(operation.y)) {
+    throw new Error('Scroll coordinates must be finite numbers')
+  }
+  if (
+    operation.x < 0 ||
+    operation.x >= CANONICAL_WIDTH ||
+    operation.y < 0 ||
+    operation.y >= CANONICAL_HEIGHT
+  ) {
+    throw new Error('Scroll coordinates must be within canonical bounds')
+  }
+  if (!Number.isInteger(operation.notches) || operation.notches === 0) {
+    throw new Error('Scroll notches must be a non-zero integer')
+  }
+  if (Math.abs(operation.notches) > MAX_SCROLL_NOTCHES) {
+    throw new Error(
+      `Scroll notches must be from -${MAX_SCROLL_NOTCHES} to ${MAX_SCROLL_NOTCHES}`,
+    )
+  }
+  if (
+    hasInterval &&
+    (!Number.isInteger(operation.intervalMs) ||
+      operation.intervalMs < MIN_SCROLL_INTERVAL_MS ||
+      operation.intervalMs > MAX_SCROLL_INTERVAL_MS)
+  ) {
+    throw new Error(
+      `Scroll intervalMs must be an integer from ${MIN_SCROLL_INTERVAL_MS} to ${MAX_SCROLL_INTERVAL_MS}`,
+    )
+  }
+}
+
 function validateKey(operation) {
   assertExactFields(operation, ['operation', 'event', 'key'])
   if (!SUPPORTED_KEY_EVENTS.has(operation.event)) {
@@ -256,11 +333,47 @@ function assertExactFields(operation, allowedFields) {
   }
 }
 
-function sendMove(layout, operation) {
-  sendPointerEnterAndMove(layout.webContents, {
+async function sendMove(layout, operation, delay) {
+  const destination = {
     x: Math.floor((operation.x * layout.width) / CANONICAL_WIDTH),
     y: Math.floor((operation.y * layout.height) / CANONICAL_HEIGHT),
-  })
+  }
+  // poi-plugin-kancolle-assistant's sendFocusedMouseMove (poi mode) feeds
+  // PIXI's interaction state machine a pointermove sequence arriving across
+  // frames; a single mouseEnter + mouseMove teleport never promotes hover
+  // (the 0921 equipment-filter calibration hit exactly that). Glide in from
+  // an explicit origin — or ~44 px left of the target — then park on it: a
+  // hover must persist, so no (0, 0) reset afterwards.
+  const originX =
+    operation.fromX !== undefined
+      ? operation.fromX
+      : Math.max(0, operation.x - HOVER_ENTRY_OFFSET_X)
+  const originY = operation.fromY !== undefined ? operation.fromY : operation.y
+  const start = {
+    x: Math.floor((originX * layout.width) / CANONICAL_WIDTH),
+    y: Math.floor((originY * layout.height) / CANONICAL_HEIGHT),
+  }
+  layout.webContents.sendInputEvent({ type: 'mouseEnter', x: start.x, y: start.y })
+  let previousX = start.x
+  let previousY = start.y
+  for (let step = 1; step <= HOVER_MOVE_STEPS; step += 1) {
+    await delay(HOVER_MOVE_STEP_DELAY_MS)
+    const x = Math.round(
+      start.x + ((destination.x - start.x) * step) / HOVER_MOVE_STEPS,
+    )
+    const y = Math.round(
+      start.y + ((destination.y - start.y) * step) / HOVER_MOVE_STEPS,
+    )
+    await layout.webContents.sendInputEvent({
+      type: 'mouseMove',
+      x,
+      y,
+      movementX: x - previousX,
+      movementY: y - previousY,
+    })
+    previousX = x
+    previousY = y
+  }
 }
 
 function sendClick(layout, operation) {
@@ -350,6 +463,35 @@ function sendPointerEnterAndMove(webContents, point) {
   webContents.sendInputEvent({ type: 'mouseMove', x: point.x, y: point.y })
 }
 
+async function sendScroll(layout, operation, delay) {
+  const point = {
+    x: Math.floor((operation.x * layout.width) / CANONICAL_WIDTH),
+    y: Math.floor((operation.y * layout.height) / CANONICAL_HEIGHT),
+  }
+  const direction = operation.notches > 0 ? 1 : -1
+  const intervalMs =
+    operation.intervalMs === undefined
+      ? DEFAULT_SCROLL_INTERVAL_MS
+      : operation.intervalMs
+  // Wheel targets hit-test at the pointer, so park the cursor on the point
+  // first (the same enter+move the drag gesture uses); one mouseWheel event
+  // per notch keeps each detent a discrete event for handlers that quantize
+  // per event — a single notches*120 mega-delta can be clamped or swallowed.
+  sendPointerEnterAndMove(layout.webContents, point)
+  for (let index = 0; index < Math.abs(operation.notches); index += 1) {
+    if (index > 0) {
+      await delay(intervalMs)
+    }
+    await layout.webContents.sendInputEvent({
+      type: 'mouseWheel',
+      x: point.x,
+      y: point.y,
+      deltaX: 0,
+      deltaY: direction * SCROLL_NOTCH_DELTA,
+    })
+  }
+}
+
 function defaultDelay(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds))
 }

package/lib/poi-webview-runtime.js

@@ -276,10 +276,17 @@ ${PIXI_ROOT_RESOLVER_SNIPPET}
     const maxDepth = boundedInteger(request.maxDepth, 6, 0, 12, 'maxDepth')
     const maxNodes = boundedInteger(request.maxNodes, 20_000, 1, 50_000, 'maxNodes')
     const maxMatches = boundedInteger(request.maxMatches, 16, 1, 256, 'maxMatches')
+    // Visibility pruning by default: a node that fails visible/renderable/
+    // worldAlpha also stops the descent into its subtree — a hidden parent
+    // leaves children with stale own flags (worldAlpha 1, on-screen transform),
+    // so per-node checks alone let dismissed-dialog ghosts leak into matches.
+    // includeHidden restores the raw walk for forensics only.
+    const includeHidden = request.includeHidden === true
     if (projection === 'pixi.interactive') {
       const capturedAt = timestamp(now())
       const expression = pixiInteractiveExpression({
         anyRequiredKeys,
+        includeHidden,
         maxDepth,
         maxMatches,
         maxNodes,
@@ -471,6 +478,7 @@ ${PIXI_ROOT_RESOLVER_SNIPPET}
 
 function pixiInteractiveExpression({
   anyRequiredKeys,
+  includeHidden,
   maxDepth,
   maxMatches,
   maxNodes,
@@ -488,6 +496,7 @@ function pixiInteractiveExpression({
     const maxDepth = ${maxDepth};
     const maxNodes = ${maxNodes};
     const maxMatches = ${maxMatches};
+    const includeHidden = ${includeHidden ? 'true' : 'false'};
     const isObject = (value) =>
       (typeof value === 'object' || typeof value === 'function') && value !== null;
     const ownDescriptor = (object, key) => {
@@ -732,6 +741,7 @@ ${PIXI_ROOT_RESOLVER_SNIPPET}
     let cursor = 0;
     let visited = 0;
     let inspectedChildren = 0;
+    let prunedSubtrees = 0;
     let depthLimited = false;
     let childScanLimited = false;
     let truncatedBy = null;
@@ -745,17 +755,25 @@ ${PIXI_ROOT_RESOLVER_SNIPPET}
       }
       seen.add(current.node);
       visited += 1;
+      const nodeShown = shown(current.node);
       const entryIndex = entries.length;
       entries.push({
         node: current.node,
         path: current.path,
         depth: current.depth,
         parent: current.parent,
-        ownWorldBounds: shown(current.node)
+        ownWorldBounds: nodeShown
           ? transformedBounds(localBounds(current.node), worldTransform(current.node))
           : null,
         subtreeWorldBounds: null,
       });
+      if (!nodeShown && !includeHidden) {
+        // Hidden parent: children keep stale own flags (visible=true,
+        // worldAlpha=1, on-screen transform) because PIXI skips
+        // updateTransform for invisible subtrees — do not descend.
+        prunedSubtrees += 1;
+        continue;
+      }
 
       const children = ownData(current.node, 'children');
       if (!Array.isArray(children)) continue;
@@ -845,6 +863,7 @@ ${PIXI_ROOT_RESOLVER_SNIPPET}
       visited,
       exhausted: truncatedBy === null,
       truncatedBy,
+      prunedSubtrees,
       matches,
     };
   })()`
@@ -935,6 +954,10 @@ function finalizePixiInteractiveProjection(value, options) {
     ? value.truncatedBy
     : null
   const exhausted = available && value.exhausted === true && truncatedBy === null
+  const prunedSubtrees = available &&
+    Number.isInteger(value.prunedSubtrees) && value.prunedSubtrees >= 0
+    ? value.prunedSubtrees
+    : 0
   const snapshotDigest = sha256Token({
     kind: 'poi.webview.pixi.snapshot.v1',
     available,
@@ -957,6 +980,7 @@ function finalizePixiInteractiveProjection(value, options) {
     visited,
     exhausted,
     truncatedBy,
+    prunedSubtrees,
     matches: identifiedMatches,
   }
 }

package/package.json

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