poi-plugin-mcp 0.2.0

package/lib/poi-http-bridge.js

@@ -0,0 +1,669 @@
+const fs = require('fs')
+const http = require('http')
+const os = require('os')
+const path = require('path')
+
+const DEFAULT_PORT = 17777
+const DEFAULT_PORT_FILE = path.join(os.homedir(), '.poi-mcp', 'port')
+const DEFAULT_PLANNER_FILE = path.join(
+  process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'),
+  'poi',
+  'poi-plugin-ship-info.json',
+)
+const JSONRPC_VERSION = '2.0'
+const MCP_PROTOCOL_VERSION = '2024-11-05'
+
+function createPoiDataBridge(options = {}) {
+  const getStore = options.getStore || defaultGetStore
+  const configuredPort = options.port == null ? DEFAULT_PORT : options.port
+  const portFile = options.portFile || DEFAULT_PORT_FILE
+  const plannerFile = options.plannerFile || DEFAULT_PLANNER_FILE
+  const logger = options.logger || console
+
+  let server = null
+  let actualPort = 0
+
+  function readStore() {
+    const store = getStore()
+    if (!store || !store.info) {
+      throw new Error('POI store not ready. Enter the game first.')
+    }
+    return store
+  }
+
+  function sendJson(res, statusCode, data) {
+    res.writeHead(statusCode, {
+      'Access-Control-Allow-Origin': '*',
+      'Content-Type': 'application/json',
+    })
+    res.end(JSON.stringify(data))
+  }
+
+  function handleMcpRequest(req, res) {
+    if (req.method !== 'POST') {
+      sendJson(res, 405, { error: 'MCP endpoint only accepts POST requests.' })
+      return
+    }
+
+    readRequestBody(req)
+      .then((body) => {
+        const message = JSON.parse(body || '{}')
+        const response = handleMcpMessage(message, readStore, plannerFile)
+
+        if (response == null) {
+          res.writeHead(202, {
+            'Access-Control-Allow-Origin': '*',
+            'Content-Type': 'application/json',
+          })
+          res.end('')
+          return
+        }
+
+        sendJson(res, 200, response)
+      })
+      .catch((error) => {
+        sendJson(res, 200, jsonRpcError(null, -32700, error.message))
+      })
+  }
+
+  function handleRequest(req, res) {
+    try {
+      if (req.url === '/shutdown') {
+        sendJson(res, 200, { status: 'shutting down' })
+        stop()
+        return
+      }
+
+      const endpoint = new URL(req.url, `http://127.0.0.1:${actualPort || configuredPort}`).pathname
+
+      if (endpoint === '/health') {
+        sendJson(res, 200, { status: 'ok' })
+        return
+      }
+
+      if (endpoint === '/mcp') {
+        handleMcpRequest(req, res)
+        return
+      }
+
+      const store = readStore()
+      const info = store.info
+
+      switch (endpoint) {
+        case '/basic':
+          sendJson(res, 200, info.basic || {})
+          break
+        case '/fleets':
+          sendJson(res, 200, info.fleets || [])
+          break
+        case '/ships':
+          sendJson(res, 200, info.ships || {})
+          break
+        case '/equipment':
+          sendJson(res, 200, info.equips || {})
+          break
+        case '/resources':
+          sendJson(res, 200, info.resources || [])
+          break
+        case '/quests':
+          sendJson(res, 200, {
+            activeQuests: (info.quests && info.quests.activeQuests) || {},
+            records: (info.quests && info.quests.records) || {},
+          })
+          break
+        case '/airbase':
+          sendJson(res, 200, info.airbase || [])
+          break
+        case '/names':
+          sendJson(res, 200, extractNames(store))
+          break
+        case '/master':
+          sendJson(res, 200, extractMasterData(store))
+          break
+        case '/event':
+          sendJson(res, 200, extractEventData(store))
+          break
+        case '/planner':
+          sendJson(res, 200, extractPlannerData(store, plannerFile))
+          break
+        case '/all':
+          sendJson(res, 200, {
+            basic: info.basic || {},
+            fleets: info.fleets || [],
+            ships: info.ships || {},
+            equipment: info.equips || {},
+            resources: info.resources || [],
+            quests: {
+              activeQuests: (info.quests && info.quests.activeQuests) || {},
+              records: (info.quests && info.quests.records) || {},
+            },
+            airbase: info.airbase || [],
+            names: extractNames(store),
+          })
+          break
+        default:
+          sendJson(res, 404, { error: `Unknown endpoint: ${endpoint}` })
+      }
+    } catch (error) {
+      sendJson(res, 503, { error: error.message })
+    }
+  }
+
+  function start() {
+    if (server) return Promise.resolve()
+
+    fs.mkdirSync(path.dirname(portFile), { recursive: true })
+    server = http.createServer(handleRequest)
+
+    return new Promise((resolve, reject) => {
+      const onError = (error) => {
+        cleanupPortFile(portFile)
+        server = null
+        reject(error)
+      }
+
+      server.once('error', onError)
+      server.listen(configuredPort, '127.0.0.1', () => {
+        server.removeListener('error', onError)
+        actualPort = server.address().port
+        fs.writeFileSync(portFile, String(actualPort), 'utf8')
+        logger.log(`[poi-plugin-mcp] HTTP API started on http://127.0.0.1:${actualPort}`)
+        resolve()
+      })
+    })
+  }
+
+  function stop() {
+    if (!server) {
+      cleanupPortFile(portFile)
+      actualPort = 0
+      return Promise.resolve()
+    }
+
+    const closingServer = server
+    server = null
+
+    return new Promise((resolve) => {
+      closingServer.close(() => {
+        cleanupPortFile(portFile)
+        actualPort = 0
+        resolve()
+      })
+    })
+  }
+
+  return {
+    start,
+    stop,
+    getPort() {
+      return actualPort
+    },
+  }
+}
+
+function readRequestBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = ''
+    req.setEncoding('utf8')
+    req.on('data', (chunk) => {
+      body += chunk
+      if (body.length > 1024 * 1024) {
+        reject(new Error('MCP request body is too large.'))
+        req.destroy()
+      }
+    })
+    req.on('end', () => resolve(body))
+    req.on('error', reject)
+  })
+}
+
+function handleMcpMessage(message, readStore, plannerFile) {
+  const { id, method, params } = message || {}
+
+  switch (method) {
+    case 'initialize':
+      return jsonRpcResult(id, {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {
+          resources: { subscribe: false },
+          tools: {},
+        },
+        serverInfo: { name: 'poi-plugin-mcp', version: '0.2.0' },
+      })
+
+    case 'notifications/initialized':
+    case 'notifications/cancelled':
+      return null
+
+    case 'ping':
+      return jsonRpcResult(id, {})
+
+    case 'resources/list':
+      return jsonRpcResult(id, {
+        resources: MCP_RESOURCE_ENDPOINTS.map(({ uri }) => ({
+          uri,
+          name: uri.replace('poi://', ''),
+          mimeType: 'application/json',
+        })),
+      })
+
+    case 'resources/read': {
+      const uri = params && params.uri
+      const endpoint = MCP_RESOURCE_ENDPOINTS.find((item) => item.uri === uri)
+      if (!endpoint) return jsonRpcError(id, -32602, `Unknown resource: ${uri}`)
+      const data = readBridgeData(endpoint.path, readStore, plannerFile)
+      return jsonRpcResult(id, {
+        contents: [{
+          uri,
+          mimeType: 'application/json',
+          text: JSON.stringify(data, null, 2),
+        }],
+      })
+    }
+
+    case 'tools/list':
+      return jsonRpcResult(id, { tools: MCP_TOOLS })
+
+    case 'tools/call': {
+      const toolName = params && params.name
+      const toolArgs = (params && params.arguments) || {}
+      const result = callMcpTool(toolName, toolArgs, readStore, plannerFile)
+      if (result.error) return jsonRpcError(id, -32602, result.error)
+      return jsonRpcResult(id, {
+        content: [{ type: 'text', text: JSON.stringify(result.value, null, 2) }],
+      })
+    }
+
+    default:
+      return jsonRpcError(id, -32601, `Unknown method: ${method}`)
+  }
+}
+
+const MCP_RESOURCE_ENDPOINTS = [
+  { uri: 'poi://basic', path: '/basic' },
+  { uri: 'poi://fleets', path: '/fleets' },
+  { uri: 'poi://ships', path: '/ships' },
+  { uri: 'poi://equipment', path: '/equipment' },
+  { uri: 'poi://resources', path: '/resources' },
+  { uri: 'poi://quests', path: '/quests' },
+  { uri: 'poi://airbase', path: '/airbase' },
+  { uri: 'poi://names', path: '/names' },
+  { uri: 'poi://master', path: '/master' },
+  { uri: 'poi://event', path: '/event' },
+  { uri: 'poi://planner', path: '/planner' },
+  { uri: 'poi://all', path: '/all' },
+]
+
+const MCP_TOOLS = [
+  {
+    name: 'get_fleet_status',
+    description: 'Get one owned fleet with ship and equipped item instance details.',
+    inputSchema: {
+      type: 'object',
+      properties: { fleetId: { type: 'number', description: 'Fleet number, 1-4.' } },
+      required: ['fleetId'],
+    },
+  },
+  {
+    name: 'search_ships',
+    description: 'Search owned ship instances by level and morale.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        minLevel: { type: 'number' },
+        maxLevel: { type: 'number' },
+        minMorale: { type: 'number' },
+      },
+    },
+  },
+  {
+    name: 'search_equipment',
+    description: 'Search owned equipment instances by improvement level.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        minLevel: { type: 'number', description: 'Minimum improvement level.' },
+      },
+    },
+  },
+  {
+    name: 'get_resources',
+    description: 'Get current account resource array.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'get_all',
+    description: 'Get account basics, fleets, ships, equipment, resources, quests, airbase, and names.',
+    inputSchema: { type: 'object', properties: {} },
+  },
+]
+
+function callMcpTool(toolName, args, readStore, plannerFile) {
+  switch (toolName) {
+    case 'get_fleet_status':
+      return { value: buildFleetStatus(args || {}, readStore) }
+    case 'search_ships':
+      return { value: searchShips(args || {}, readStore) }
+    case 'search_equipment':
+      return { value: searchEquipment(args || {}, readStore) }
+    case 'get_resources':
+      return { value: readBridgeData('/resources', readStore, plannerFile) }
+    case 'get_all':
+      return { value: readBridgeData('/all', readStore, plannerFile) }
+    default:
+      return { error: `Unknown tool: ${toolName}` }
+  }
+}
+
+function readBridgeData(endpoint, readStore, plannerFile) {
+  const store = readStore()
+  const info = store.info
+
+  switch (endpoint) {
+    case '/basic':
+      return info.basic || {}
+    case '/fleets':
+      return info.fleets || []
+    case '/ships':
+      return info.ships || {}
+    case '/equipment':
+      return info.equips || {}
+    case '/resources':
+      return info.resources || []
+    case '/quests':
+      return {
+        activeQuests: (info.quests && info.quests.activeQuests) || {},
+        records: (info.quests && info.quests.records) || {},
+      }
+    case '/airbase':
+      return info.airbase || []
+    case '/names':
+      return extractNames(store)
+    case '/master':
+      return extractMasterData(store)
+    case '/event':
+      return extractEventData(store)
+    case '/planner':
+      return extractPlannerData(store, plannerFile)
+    case '/all':
+      return {
+        basic: info.basic || {},
+        fleets: info.fleets || [],
+        ships: info.ships || {},
+        equipment: info.equips || {},
+        resources: info.resources || [],
+        quests: {
+          activeQuests: (info.quests && info.quests.activeQuests) || {},
+          records: (info.quests && info.quests.records) || {},
+        },
+        airbase: info.airbase || [],
+        names: extractNames(store),
+      }
+    default:
+      throw new Error(`Unknown endpoint: ${endpoint}`)
+  }
+}
+
+function buildFleetStatus(args, readStore) {
+  const fleetId = Number(args.fleetId)
+  const store = readStore()
+  const info = store.info
+  const fleets = Array.isArray(info.fleets) ? info.fleets : []
+  const fleet = fleets[fleetId - 1]
+  if (!fleet) return { error: `Fleet #${args.fleetId} not found` }
+
+  const ships = info.ships || {}
+  const equips = info.equips || {}
+
+  return {
+    id: fleet.api_id,
+    name: fleet.api_name,
+    mission: fleet.api_mission,
+    ships: (fleet.api_ship || []).filter((id) => id > 0).map((shipId) => {
+      const ship = ships[shipId]
+      if (!ship) return { id: shipId }
+
+      return {
+        id: ship.api_id,
+        shipId: ship.api_ship_id,
+        level: ship.api_lv,
+        hp: `${ship.api_nowhp}/${ship.api_maxhp}`,
+        morale: ship.api_cond,
+        locked: ship.api_locked,
+        slotItems: (ship.api_slot || []).filter((equipId) => equipId > 0).map((equipId) => {
+          const equip = equips[equipId]
+          return equip ? {
+            id: equip.api_id,
+            equipId: equip.api_slotitem_id,
+            level: equip.api_level || 0,
+            prof: equip.api_alv || 0,
+          } : null
+        }).filter(Boolean),
+      }
+    }),
+  }
+}
+
+function searchShips(args, readStore) {
+  const store = readStore()
+  const ships = Object.values((store.info && store.info.ships) || {}).filter((ship) => {
+    if (!ship) return false
+    if (args.minLevel != null && ship.api_lv < Number(args.minLevel)) return false
+    if (args.maxLevel != null && ship.api_lv > Number(args.maxLevel)) return false
+    if (args.minMorale != null && ship.api_cond < Number(args.minMorale)) return false
+    return true
+  })
+
+  return { total: ships.length, ships }
+}
+
+function searchEquipment(args, readStore) {
+  const store = readStore()
+  const equipment = Object.values((store.info && store.info.equips) || {}).filter((equip) => {
+    if (!equip) return false
+    if (args.minLevel != null && (equip.api_level || 0) < Number(args.minLevel)) return false
+    return true
+  })
+
+  return { total: equipment.length, equipment }
+}
+
+function jsonRpcResult(id, result) {
+  return { jsonrpc: JSONRPC_VERSION, id, result }
+}
+
+function jsonRpcError(id, code, message) {
+  return { jsonrpc: JSONRPC_VERSION, id, error: { code, message } }
+}
+
+function defaultGetStore() {
+  if (typeof window !== 'undefined' && typeof window.getStore === 'function') {
+    return window.getStore()
+  }
+  return null
+}
+
+function cleanupPortFile(portFile) {
+  try {
+    fs.unlinkSync(portFile)
+  } catch (_) {}
+}
+
+function extractNames(store) {
+  const result = { ships: {}, equipment: {}, missions: {} }
+  const constants = store.const || {}
+
+  collectApiNames(constants.$ships, result.ships)
+  collectApiNames(constants.$equips, result.equipment)
+  collectApiNames(constants.$missions, result.missions)
+
+  const wctf = store.wctf || {}
+  if (Object.keys(result.ships).length === 0) collectSimpleNames(wctf.ships, result.ships)
+  if (Object.keys(result.equipment).length === 0) collectSimpleNames(wctf.items, result.equipment)
+
+  return result
+}
+
+function collectApiNames(source, target) {
+  if (!source || typeof source !== 'object') return
+
+  for (const [id, value] of Object.entries(source)) {
+    if (value && value.api_name) target[id] = value.api_name
+  }
+}
+
+function collectSimpleNames(source, target) {
+  if (!source || typeof source !== 'object') return
+
+  for (const [id, value] of Object.entries(source)) {
+    if (value && value.name) target[id] = value.name
+  }
+}
+
+function extractMasterData(store) {
+  const constants = store.const || {}
+
+  return {
+    ships: constants.$ships || {},
+    equipment: constants.$equips || {},
+    shipTypes: constants.$shipTypes || {},
+    equipmentTypes:
+      constants.$equipTypes ||
+      constants.$equipmentTypes ||
+      constants.$slotitemTypes ||
+      constants.$slotItemTypes ||
+      {},
+    missions: constants.$missions || {},
+  }
+}
+
+function extractEventData(store) {
+  const tags = extractShipTags(store)
+  const ships = {}
+
+  for (const ship of Object.values((store.info && store.info.ships) || {})) {
+    if (!ship || typeof ship !== 'object') continue
+    const area = ship.api_sally_area || 0
+    const tag = tags[area - 1] || emptyTag(area)
+
+    ships[ship.api_id] = {
+      shipId: ship.api_id,
+      modelId: ship.api_ship_id,
+      area,
+      mapName: tag.mapName,
+      fleetName: tag.fleetName,
+      color: tag.color,
+    }
+  }
+
+  return {
+    tags,
+    ships,
+  }
+}
+
+function extractPlannerData(store, plannerFile = DEFAULT_PLANNER_FILE) {
+  const tags = extractShipTags(store)
+  const current = readPlannerCurrent(plannerFile)
+  const length = Math.max(tags.length, current.length)
+  const areas = []
+  const shipMap = {}
+
+  for (let index = 0; index < length; index += 1) {
+    const area = index + 1
+    const tag = tags[index] || emptyTag(area)
+    const shipIds = Array.isArray(current[index]) ? current[index] : []
+
+    areas.push({
+      area,
+      mapName: tag.mapName,
+      fleetName: tag.fleetName,
+      color: tag.color,
+      shipIds,
+    })
+
+    for (const shipId of shipIds) {
+      shipMap[shipId] = {
+        area,
+        mapName: tag.mapName,
+        fleetName: tag.fleetName,
+        color: tag.color,
+      }
+    }
+  }
+
+  return {
+    areas,
+    shipMap,
+  }
+}
+
+function readPlannerCurrent(plannerFile) {
+  try {
+    const data = JSON.parse(fs.readFileSync(plannerFile, 'utf8'))
+    if (Array.isArray(data.planner)) return data.planner
+    if (data.planner && Array.isArray(data.planner.current)) {
+      return data.planner.current
+    }
+  } catch (_) {}
+
+  return []
+}
+
+function extractShipTags(store) {
+  const shiptag = (store.fcd && store.fcd.shiptag) || {}
+  const mapNames = Array.isArray(shiptag.mapname) ? shiptag.mapname : []
+  const fleetNames = selectFleetNames(shiptag.fleetname)
+  const colors = Array.isArray(shiptag.color) ? shiptag.color : []
+
+  return mapNames.map((mapName, index) => ({
+    area: index + 1,
+    mapName,
+    fleetName: fleetNames[index] || mapName,
+    color: colors[index] || '',
+  }))
+}
+
+function selectFleetNames(fleetname) {
+  if (Array.isArray(fleetname)) return fleetname
+  if (!fleetname || typeof fleetname !== 'object') return []
+
+  const language = getWindowLanguage()
+  return (
+    fleetname[language] ||
+    fleetname['zh-CN'] ||
+    fleetname['zh-TW'] ||
+    fleetname.ja ||
+    fleetname['ja-JP'] ||
+    fleetname['en-US'] ||
+    Object.values(fleetname).find(Array.isArray) ||
+    []
+  )
+}
+
+function getWindowLanguage() {
+  if (typeof window !== 'undefined' && window.language) {
+    return window.language
+  }
+  return 'zh-CN'
+}
+
+function emptyTag(area) {
+  return {
+    area,
+    mapName: '',
+    fleetName: '',
+    color: '',
+  }
+}
+
+module.exports = {
+  createPoiDataBridge,
+  DEFAULT_PORT,
+  DEFAULT_PORT_FILE,
+  DEFAULT_PLANNER_FILE,
+  extractEventData,
+  extractMasterData,
+  extractPlannerData,
+  extractNames,
+}