@thibautrey/chatons-extension-minecraft-servers 1.0.0

package/chaton.extension.json

@@ -0,0 +1,152 @@
+{
+  "id": "@thibautrey/chatons-extension-minecraft-servers",
+  "name": "Minecraft Servers",
+  "version": "1.0.0",
+  "description": "Manage and inspect a list of Minecraft servers from Chatons.",
+  "icon": "icon.svg",
+  "capabilities": [
+    "ui.menu",
+    "ui.mainView",
+    "llm.tools",
+    "storage.kv"
+  ],
+  "ui": {
+    "menuItems": [
+      {
+        "id": "minecraft-servers.menu",
+        "label": "Minecraft Servers",
+        "icon": "Blocks",
+        "location": "sidebar",
+        "order": 26,
+        "openMainView": "minecraft-servers.main"
+      }
+    ],
+    "mainViews": [
+      {
+        "viewId": "minecraft-servers.main",
+        "title": "Minecraft Servers",
+        "webviewUrl": "chaton-extension://@thibautrey/chatons-extension-minecraft-servers/index.html",
+        "initialRoute": "/"
+      }
+    ]
+  },
+  "apis": {
+    "exposes": [
+      { "name": "minecraft.servers.list", "version": "1.0.0" },
+      { "name": "minecraft.servers.add", "version": "1.0.0" },
+      { "name": "minecraft.servers.update", "version": "1.0.0" },
+      { "name": "minecraft.servers.remove", "version": "1.0.0" },
+      { "name": "minecraft.servers.status", "version": "1.0.0" },
+      { "name": "minecraft.servers.players", "version": "1.0.0" }
+    ]
+  },
+  "llm": {
+    "tools": [
+      {
+        "name": "minecraft_servers_list",
+        "label": "List Minecraft servers",
+        "description": "List the configured Minecraft servers with their saved metadata.",
+        "promptSnippet": "List configured Minecraft servers.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "includeStatus": {
+              "type": "boolean",
+              "description": "When true, also fetch live public status for each server."
+            }
+          }
+        }
+      },
+      {
+        "name": "minecraft_servers_add",
+        "label": "Add Minecraft server",
+        "description": "Add a Minecraft server to the saved list.",
+        "promptSnippet": "Add a Minecraft server to the saved list.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "name": { "type": "string", "description": "Display name for the server." },
+            "host": { "type": "string", "description": "Hostname or IP address." },
+            "port": { "type": "number", "description": "Server port. Defaults to 25565 for Java or 19132 for Bedrock." },
+            "edition": { "type": "string", "description": "Edition: java, bedrock, or auto." },
+            "notes": { "type": "string", "description": "Optional notes." },
+            "tags": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Optional tags."
+            }
+          },
+          "required": ["name", "host"]
+        }
+      },
+      {
+        "name": "minecraft_servers_update",
+        "label": "Update Minecraft server",
+        "description": "Update an existing saved Minecraft server by id, name, or host.",
+        "promptSnippet": "Update a saved Minecraft server.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string", "description": "Saved server id." },
+            "lookup": { "type": "string", "description": "Alternative lookup by name or host if id is unknown." },
+            "name": { "type": "string", "description": "New display name." },
+            "host": { "type": "string", "description": "New hostname or IP address." },
+            "port": { "type": "number", "description": "New port." },
+            "edition": { "type": "string", "description": "Edition: java, bedrock, or auto." },
+            "notes": { "type": "string", "description": "New notes value." },
+            "tags": {
+              "type": "array",
+              "items": { "type": "string" },
+              "description": "Replacement tag list."
+            }
+          }
+        }
+      },
+      {
+        "name": "minecraft_servers_remove",
+        "label": "Remove Minecraft server",
+        "description": "Remove a saved Minecraft server by id, name, or host.",
+        "promptSnippet": "Remove a saved Minecraft server.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string", "description": "Saved server id." },
+            "lookup": { "type": "string", "description": "Alternative lookup by name or host." }
+          }
+        }
+      },
+      {
+        "name": "minecraft_servers_status",
+        "label": "Get Minecraft server status",
+        "description": "Fetch public status information for a Minecraft server without logging in, including MOTD, version, player counts, latency, and favicon when available.",
+        "promptSnippet": "Fetch public Minecraft server status information.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string", "description": "Saved server id." },
+            "lookup": { "type": "string", "description": "Saved server name or host." },
+            "host": { "type": "string", "description": "Direct hostname or IP if not using a saved server." },
+            "port": { "type": "number", "description": "Port override." },
+            "edition": { "type": "string", "description": "Edition: java, bedrock, or auto." }
+          }
+        }
+      },
+      {
+        "name": "minecraft_servers_players",
+        "label": "List online Minecraft players",
+        "description": "List the players currently reported as online on a Minecraft server using public status data. The result depends on what the server chooses to expose.",
+        "promptSnippet": "List online players from Minecraft server status.",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "id": { "type": "string", "description": "Saved server id." },
+            "lookup": { "type": "string", "description": "Saved server name or host." },
+            "host": { "type": "string", "description": "Direct hostname or IP if not using a saved server." },
+            "port": { "type": "number", "description": "Port override." },
+            "edition": { "type": "string", "description": "Edition: java, bedrock, or auto." }
+          }
+        }
+      }
+    ]
+  }
+}

package/handler.js

@@ -0,0 +1,473 @@
+const EXTENSION_ID = '@thibautrey/chatons-extension-minecraft-servers'
+const STORAGE_KEY = 'minecraft.servers'
+const JAVA_DEFAULT_PORT = 25565
+const BEDROCK_DEFAULT_PORT = 19132
+const SOCKET_TIMEOUT_MS = 5000
+
+function safeArray(value) {
+  return Array.isArray(value) ? value : []
+}
+
+function nowIso() {
+  return new Date().toISOString()
+}
+
+function randomId() {
+  return 'mc_' + Math.random().toString(36).slice(2, 10) + Date.now().toString(36)
+}
+
+function normalizeString(value) {
+  return String(value == null ? '' : value).trim()
+}
+
+function normalizeEdition(value) {
+  const edition = normalizeString(value).toLowerCase()
+  if (edition === 'java' || edition === 'bedrock') return edition
+  return 'auto'
+}
+
+function resolvePort(port, edition) {
+  if (Number.isFinite(port) && Number(port) > 0 && Number(port) < 65536) return Number(port)
+  return edition === 'bedrock' ? BEDROCK_DEFAULT_PORT : JAVA_DEFAULT_PORT
+}
+
+function normalizeTags(value) {
+  const input = Array.isArray(value) ? value : []
+  return input
+    .map((item) => normalizeString(item))
+    .filter(Boolean)
+}
+
+function sanitizeServer(input, previous) {
+  const edition = normalizeEdition(input.edition || (previous && previous.edition))
+  const host = normalizeString(input.host || (previous && previous.host))
+  const name = normalizeString(input.name || (previous && previous.name))
+  const port = resolvePort(Number(input.port), edition === 'auto' ? normalizeEdition(previous && previous.edition) : edition)
+  if (!name) throw new Error('Server name is required')
+  if (!host) throw new Error('Server host is required')
+  return {
+    id: normalizeString(input.id || (previous && previous.id)) || randomId(),
+    name,
+    host,
+    port,
+    edition,
+    notes: normalizeString(input.notes || (previous && previous.notes)),
+    tags: normalizeTags(typeof input.tags === 'undefined' ? (previous && previous.tags) : input.tags),
+    updatedAt: nowIso(),
+    createdAt: previous && previous.createdAt ? previous.createdAt : nowIso(),
+  }
+}
+
+async function loadServers(ctx) {
+  const result = await ctx.storageKvGet(EXTENSION_ID, STORAGE_KEY)
+  if (result && result.ok && Array.isArray(result.data)) {
+    return result.data
+  }
+  return []
+}
+
+async function saveServers(ctx, servers) {
+  return ctx.storageKvSet(EXTENSION_ID, STORAGE_KEY, servers)
+}
+
+function findServer(servers, payload) {
+  const id = normalizeString(payload && payload.id)
+  const lookup = normalizeString(payload && payload.lookup).toLowerCase()
+  if (id) {
+    return servers.find((server) => server.id === id) || null
+  }
+  if (lookup) {
+    return servers.find((server) => {
+      return (
+        normalizeString(server.name).toLowerCase() === lookup ||
+        normalizeString(server.host).toLowerCase() === lookup ||
+        (normalizeString(server.host) + ':' + String(server.port)).toLowerCase() === lookup
+      )
+    }) || null
+  }
+  return null
+}
+
+function notFound(message) {
+  return { ok: false, error: { code: 'not_found', message } }
+}
+
+function invalid(message) {
+  return { ok: false, error: { code: 'invalid_args', message } }
+}
+
+function internal(message) {
+  return { ok: false, error: { code: 'internal', message } }
+}
+
+function toUnsignedVarInt(value) {
+  const out = []
+  let remaining = value >>> 0
+  do {
+    let temp = remaining & 0x7f
+    remaining >>>= 7
+    if (remaining !== 0) temp |= 0x80
+    out.push(temp)
+  } while (remaining !== 0)
+  return Buffer.from(out)
+}
+
+function encodeString(value) {
+  const buf = Buffer.from(String(value), 'utf8')
+  return Buffer.concat([toUnsignedVarInt(buf.length), buf])
+}
+
+function readVarInt(buffer, offset) {
+  let num = 0
+  let shift = 0
+  let pos = offset
+  while (true) {
+    if (pos >= buffer.length) throw new Error('Unexpected end of varint')
+    const byte = buffer[pos]
+    num |= (byte & 0x7f) << shift
+    pos += 1
+    if ((byte & 0x80) !== 0x80) break
+    shift += 7
+    if (shift > 35) throw new Error('Varint too large')
+  }
+  return { value: num, offset: pos }
+}
+
+function buildJavaHandshake(host, port) {
+  const packetId = Buffer.from([0x00])
+  const protocolVersion = toUnsignedVarInt(758)
+  const hostField = encodeString(host)
+  const portField = Buffer.alloc(2)
+  portField.writeUInt16BE(port, 0)
+  const nextState = toUnsignedVarInt(1)
+  const payload = Buffer.concat([packetId, protocolVersion, hostField, portField, nextState])
+  return Buffer.concat([toUnsignedVarInt(payload.length), payload])
+}
+
+function buildJavaStatusRequest() {
+  return Buffer.from([0x01, 0x00])
+}
+
+function stripMinecraftFormatting(input) {
+  return String(input == null ? '' : input).replace(/§[0-9A-FK-OR]/gi, '')
+}
+
+function simplifyJavaDescription(description) {
+  if (typeof description === 'string') return stripMinecraftFormatting(description)
+  if (!description || typeof description !== 'object') return ''
+  if (typeof description.text === 'string') {
+    return stripMinecraftFormatting(description.text)
+  }
+  if (Array.isArray(description.extra)) {
+    return description.extra.map(simplifyJavaDescription).join(' ').trim()
+  }
+  return ''
+}
+
+async function javaStatus(host, port) {
+  const net = await import('node:net')
+  return new Promise((resolve, reject) => {
+    const socket = new net.Socket()
+    const chunks = []
+    let done = false
+    const started = Date.now()
+
+    function finish(err, payload) {
+      if (done) return
+      done = true
+      try {
+        socket.destroy()
+      } catch {}
+      if (err) reject(err)
+      else resolve(payload)
+    }
+
+    socket.setTimeout(SOCKET_TIMEOUT_MS)
+    socket.on('timeout', () => finish(new Error('Java status request timed out')))
+    socket.on('error', (error) => finish(error))
+    socket.on('data', (chunk) => {
+      chunks.push(chunk)
+      try {
+        const buffer = Buffer.concat(chunks)
+        const packetLength = readVarInt(buffer, 0)
+        if (buffer.length < packetLength.offset + packetLength.value) return
+        const packetStart = packetLength.offset
+        const packetId = readVarInt(buffer, packetStart)
+        if (packetId.value !== 0x00) {
+          finish(new Error('Unexpected Java status packet id'))
+          return
+        }
+        const jsonLength = readVarInt(buffer, packetId.offset)
+        const jsonStart = jsonLength.offset
+        const jsonEnd = jsonStart + jsonLength.value
+        if (buffer.length < jsonEnd) return
+        const raw = buffer.slice(jsonStart, jsonEnd).toString('utf8')
+        const parsed = JSON.parse(raw)
+        const players = parsed.players || {}
+        const sample = Array.isArray(players.sample) ? players.sample : []
+        finish(null, {
+          ok: true,
+          resolvedEdition: 'java',
+          host,
+          port,
+          latencyMs: Date.now() - started,
+          motd: simplifyJavaDescription(parsed.description),
+          version: parsed.version && parsed.version.name ? parsed.version.name : null,
+          protocol: parsed.version && typeof parsed.version.protocol === 'number' ? parsed.version.protocol : null,
+          players: {
+            online: typeof players.online === 'number' ? players.online : null,
+            max: typeof players.max === 'number' ? players.max : null,
+            sample: sample
+              .map((entry) => (entry && typeof entry.name === 'string' ? entry.name : null))
+              .filter(Boolean),
+          },
+          favicon: typeof parsed.favicon === 'string' ? parsed.favicon : null,
+          raw: parsed,
+        })
+      } catch (error) {
+        finish(error)
+      }
+    })
+    socket.connect(port, host, () => {
+      socket.write(buildJavaHandshake(host, port))
+      socket.write(buildJavaStatusRequest())
+    })
+  })
+}
+
+function buildBedrockUnconnectedPing() {
+  const magic = Buffer.from('00ffff00fefefefefdfdfdfd12345678', 'hex')
+  const buffer = Buffer.alloc(1 + 8 + 8 + 16)
+  let offset = 0
+  buffer.writeUInt8(0x01, offset)
+  offset += 1
+  const pingTime = BigInt(Date.now())
+  buffer.writeBigInt64BE(pingTime, offset)
+  offset += 8
+  buffer.writeBigInt64BE(0x0123456789ABCDEFn, offset)
+  offset += 8
+  magic.copy(buffer, offset)
+  return buffer
+}
+
+function parseBedrockMotd(raw) {
+  const parts = String(raw || '').split(';')
+  return {
+    edition: parts[0] || null,
+    motd: parts[1] || null,
+    protocol: parts[2] ? Number(parts[2]) : null,
+    version: parts[3] || null,
+    online: parts[4] ? Number(parts[4]) : null,
+    max: parts[5] ? Number(parts[5]) : null,
+    serverId: parts[6] || null,
+    map: parts[7] || null,
+    gamemode: parts[8] || null,
+    gamemodeNumeric: parts[9] ? Number(parts[9]) : null,
+    portIPv4: parts[10] ? Number(parts[10]) : null,
+    portIPv6: parts[11] ? Number(parts[11]) : null,
+  }
+}
+
+async function bedrockStatus(host, port) {
+  const dgram = await import('node:dgram')
+  return new Promise((resolve, reject) => {
+    const socket = dgram.createSocket('udp4')
+    const started = Date.now()
+    let done = false
+
+    function finish(err, payload) {
+      if (done) return
+      done = true
+      try {
+        socket.close()
+      } catch {}
+      if (err) reject(err)
+      else resolve(payload)
+    }
+
+    socket.on('error', (error) => finish(error))
+    socket.on('message', (msg) => {
+      try {
+        if (msg.length < 35 || msg.readUInt8(0) !== 0x1c) {
+          finish(new Error('Unexpected Bedrock pong packet'))
+          return
+        }
+        const motdLength = msg.readUInt16BE(33)
+        const motd = msg.slice(35, 35 + motdLength).toString('utf8')
+        const parsed = parseBedrockMotd(motd)
+        finish(null, {
+          ok: true,
+          resolvedEdition: 'bedrock',
+          host,
+          port,
+          latencyMs: Date.now() - started,
+          motd: parsed.motd,
+          version: parsed.version,
+          protocol: parsed.protocol,
+          players: {
+            online: Number.isFinite(parsed.online) ? parsed.online : null,
+            max: Number.isFinite(parsed.max) ? parsed.max : null,
+            sample: [],
+          },
+          gamemode: parsed.gamemode,
+          map: parsed.map,
+          raw: parsed,
+        })
+      } catch (error) {
+        finish(error)
+      }
+    })
+
+    socket.send(buildBedrockUnconnectedPing(), port, host, (error) => {
+      if (error) {
+        finish(error)
+        return
+      }
+      setTimeout(() => finish(new Error('Bedrock status request timed out')), SOCKET_TIMEOUT_MS)
+    })
+  })
+}
+
+async function probeServer(target) {
+  const edition = normalizeEdition(target.edition)
+  const host = normalizeString(target.host)
+  if (!host) throw new Error('Server host is required')
+
+  const candidates = edition === 'auto'
+    ? [
+        { edition: 'java', port: resolvePort(Number(target.port), 'java') },
+        { edition: 'bedrock', port: resolvePort(Number(target.port), 'bedrock') },
+      ]
+    : [{ edition, port: resolvePort(Number(target.port), edition) }]
+
+  const errors = []
+  for (const candidate of candidates) {
+    try {
+      if (candidate.edition === 'java') {
+        return await javaStatus(host, candidate.port)
+      }
+      return await bedrockStatus(host, candidate.port)
+    } catch (error) {
+      errors.push(candidate.edition + ': ' + (error && error.message ? error.message : String(error)))
+    }
+  }
+  return {
+    ok: false,
+    host,
+    port: Number(target.port) || null,
+    resolvedEdition: edition === 'auto' ? null : edition,
+    checkedAt: nowIso(),
+    error: errors.join(' | ') || 'Server unreachable',
+  }
+}
+
+async function apiListServers(payload, ctx) {
+  const servers = await loadServers(ctx)
+  if (payload && payload.includeStatus) {
+    const enriched = []
+    for (const server of servers) {
+      const status = await probeServer(server)
+      enriched.push({ ...server, status })
+    }
+    return { ok: true, data: { servers: enriched } }
+  }
+  return { ok: true, data: { servers } }
+}
+
+async function apiAddServer(payload, ctx) {
+  const servers = await loadServers(ctx)
+  const normalized = sanitizeServer(payload || {}, null)
+  const duplicate = servers.find((server) => normalizeString(server.host).toLowerCase() === normalized.host.toLowerCase() && Number(server.port) === Number(normalized.port))
+  if (duplicate) {
+    return invalid('A server with the same host and port already exists')
+  }
+  const next = servers.concat([normalized])
+  await saveServers(ctx, next)
+  return { ok: true, data: { server: normalized, servers: next } }
+}
+
+async function apiUpdateServer(payload, ctx) {
+  const servers = await loadServers(ctx)
+  const current = findServer(servers, payload || {})
+  if (!current) return notFound('Saved server not found')
+  const updated = sanitizeServer(payload || {}, current)
+  const next = servers.map((server) => {
+    if (server.id !== current.id) return server
+    return updated
+  })
+  await saveServers(ctx, next)
+  return { ok: true, data: { server: updated, servers: next } }
+}
+
+async function apiRemoveServer(payload, ctx) {
+  const servers = await loadServers(ctx)
+  const current = findServer(servers, payload || {})
+  if (!current) return notFound('Saved server not found')
+  const next = servers.filter((server) => server.id !== current.id)
+  await saveServers(ctx, next)
+  return { ok: true, data: { removed: current, servers: next } }
+}
+
+async function resolveProbeTarget(payload, ctx) {
+  const id = normalizeString(payload && payload.id)
+  const lookup = normalizeString(payload && payload.lookup)
+  if (id || lookup) {
+    const servers = await loadServers(ctx)
+    const saved = findServer(servers, payload || {})
+    if (!saved) throw new Error('Saved server not found')
+    return saved
+  }
+
+  const host = normalizeString(payload && payload.host)
+  if (!host) throw new Error('Provide id, lookup, or host')
+  return {
+    host,
+    port: Number(payload && payload.port),
+    edition: normalizeEdition(payload && payload.edition),
+  }
+}
+
+async function apiStatus(payload, ctx) {
+  const target = await resolveProbeTarget(payload, ctx)
+  const status = await probeServer(target)
+  return { ok: true, data: status }
+}
+
+async function apiPlayers(payload, ctx) {
+  const target = await resolveProbeTarget(payload, ctx)
+  const status = await probeServer(target)
+  if (status.ok === false) {
+    return { ok: false, error: { code: 'internal', message: status.error || 'Server is offline' } }
+  }
+  return {
+    ok: true,
+    data: {
+      host: status.host,
+      port: status.port,
+      edition: status.resolvedEdition,
+      online: status.players ? status.players.online : null,
+      max: status.players ? status.players.max : null,
+      players: status.players && Array.isArray(status.players.sample) ? status.players.sample : [],
+      status,
+    },
+  }
+}
+
+export default async function handler(apiName, payload, ctx) {
+  try {
+    if (!ctx || typeof ctx.storageKvGet !== 'function' || typeof ctx.storageKvSet !== 'function') {
+      return internal('Missing handler context')
+    }
+
+    if (apiName === 'minecraft.servers.list') return apiListServers(payload, ctx)
+    if (apiName === 'minecraft.servers.add') return apiAddServer(payload, ctx)
+    if (apiName === 'minecraft.servers.update') return apiUpdateServer(payload, ctx)
+    if (apiName === 'minecraft.servers.remove') return apiRemoveServer(payload, ctx)
+    if (apiName === 'minecraft.servers.status') return apiStatus(payload, ctx)
+    if (apiName === 'minecraft.servers.players') return apiPlayers(payload, ctx)
+
+    return notFound('Unknown API: ' + apiName)
+  } catch (error) {
+    return internal(error && error.message ? error.message : String(error))
+  }
+}

package/icon.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" fill="none">
+  <rect width="64" height="64" rx="16" fill="#1f2937"/>
+  <rect x="14" y="16" width="36" height="10" rx="3" fill="#22c55e"/>
+  <rect x="14" y="29" width="36" height="8" rx="3" fill="#4b5563"/>
+  <rect x="14" y="40" width="36" height="8" rx="3" fill="#4b5563"/>
+  <circle cx="20" cy="33" r="2" fill="#a7f3d0"/>
+  <circle cx="20" cy="44" r="2" fill="#d1d5db"/>
+  <path d="M40 20h4M46 20h0" stroke="#052e16" stroke-width="3" stroke-linecap="round"/>
+</svg>

package/index.html

@@ -0,0 +1,178 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Minecraft Servers</title>
+  <style>
+    :root {
+      color-scheme: light dark;
+    }
+    * {
+      box-sizing: border-box;
+    }
+    body {
+      margin: 0;
+      font-family: ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      background: transparent;
+      color: inherit;
+    }
+    .app {
+      display: grid;
+      gap: 16px;
+    }
+    .layout {
+      display: grid;
+      grid-template-columns: 1.1fr 1.4fr;
+      gap: 16px;
+      align-items: start;
+    }
+    .toolbar {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+      justify-content: space-between;
+      align-items: center;
+    }
+    .stats {
+      display: flex;
+      gap: 10px;
+      flex-wrap: wrap;
+    }
+    .stat {
+      display: inline-flex;
+      gap: 8px;
+      align-items: center;
+      padding: 8px 10px;
+      border-radius: 999px;
+      background: color-mix(in srgb, var(--ce-muted, #e5e7eb) 60%, transparent);
+      font-size: 12px;
+    }
+    .field-grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 12px;
+    }
+    .field-grid .full {
+      grid-column: 1 / -1;
+    }
+    .actions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+    }
+    input, textarea, select {
+      width: 100%;
+      box-sizing: border-box;
+    }
+    textarea {
+      min-height: 84px;
+      resize: vertical;
+    }
+    .server-list {
+      display: grid;
+      gap: 12px;
+    }
+    .server-card {
+      border: 1px solid color-mix(in srgb, var(--ce-border, #d1d5db) 90%, transparent);
+      border-radius: 14px;
+      padding: 14px;
+      background: color-mix(in srgb, var(--ce-card, #ffffff) 88%, transparent);
+      display: grid;
+      gap: 10px;
+    }
+    .server-card.is-selected {
+      border-color: color-mix(in srgb, #22c55e 55%, var(--ce-border, #d1d5db));
+      box-shadow: 0 0 0 1px color-mix(in srgb, #22c55e 30%, transparent);
+    }
+    .server-head {
+      display: flex;
+      justify-content: space-between;
+      align-items: start;
+      gap: 12px;
+    }
+    .server-title {
+      display: grid;
+      gap: 4px;
+    }
+    .server-title h3,
+    .server-title p,
+    .server-title small {
+      margin: 0;
+    }
+    .server-badges {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 6px;
+    }
+    .badge {
+      display: inline-flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 8px;
+      border-radius: 999px;
+      font-size: 11px;
+      background: color-mix(in srgb, var(--ce-muted, #e5e7eb) 75%, transparent);
+    }
+    .badge.ok {
+      background: rgba(34, 197, 94, 0.18);
+    }
+    .badge.warn {
+      background: rgba(245, 158, 11, 0.18);
+    }
+    .badge.error {
+      background: rgba(239, 68, 68, 0.18);
+    }
+    .row-actions {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+    .muted {
+      color: var(--ce-muted-fg, #6b7280);
+      font-size: 13px;
+    }
+    .empty {
+      padding: 18px;
+      border-radius: 12px;
+      background: color-mix(in srgb, var(--ce-muted, #e5e7eb) 55%, transparent);
+      font-size: 13px;
+    }
+    .status-box {
+      display: grid;
+      gap: 8px;
+      font-size: 13px;
+    }
+    .status-box pre {
+      margin: 0;
+      padding: 12px;
+      border-radius: 12px;
+      overflow: auto;
+      background: color-mix(in srgb, var(--ce-muted, #e5e7eb) 55%, transparent);
+      font-size: 12px;
+      line-height: 1.4;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+    @media (max-width: 960px) {
+      .layout, .field-grid {
+        grid-template-columns: 1fr;
+      }
+    }
+  </style>
+</head>
+<body>
+  <div class="ce-page">
+    <div class="ce-page-header">
+      <div class="ce-page-title-group">
+        <h1 class="ce-page-title">Minecraft Servers</h1>
+        <p class="ce-page-description">Gere une liste de serveurs Minecraft et interroge leur statut public sans connexion joueur.</p>
+      </div>
+    </div>
+
+    <div id="app" class="app"></div>
+  </div>
+
+  <script src="./index.js"></script>
+</body>
+</html>

package/index.js

@@ -0,0 +1,420 @@
+const EXTENSION_ID = '@thibautrey/chatons-extension-minecraft-servers'
+const STORAGE_KEY = 'minecraft.servers'
+
+const DEFAULT_FORM = {
+  id: '',
+  name: '',
+  host: '',
+  port: '',
+  edition: 'auto',
+  notes: '',
+  tags: '',
+}
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value))
+}
+
+function escapeHtml(value) {
+  return String(value == null ? '' : value)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;')
+}
+
+async function kvGet(key, fallback) {
+  const res = await window.chaton.extensionStorageKvGet(EXTENSION_ID, key)
+  if (!res || !res.ok || typeof res.data === 'undefined') return clone(fallback)
+  return res.data
+}
+
+async function call(apiName, payload) {
+  return window.chaton.extensionCall('chatons-ui', EXTENSION_ID, apiName, '^1.0.0', payload || {})
+}
+
+const state = {
+  servers: [],
+  selectedId: null,
+  form: clone(DEFAULT_FORM),
+  liveById: {},
+  message: '',
+  messageKind: '',
+  loading: false,
+}
+
+function normalizeTagsText(tags) {
+  return Array.isArray(tags) ? tags.join(', ') : ''
+}
+
+function setMessage(text, kind) {
+  state.message = text || ''
+  state.messageKind = kind || ''
+  const node = document.getElementById('statusMessage')
+  if (node) {
+    node.textContent = state.message
+    node.dataset.kind = state.messageKind
+  }
+}
+
+function formFromServer(server) {
+  return {
+    id: server.id || '',
+    name: server.name || '',
+    host: server.host || '',
+    port: server.port == null ? '' : String(server.port),
+    edition: server.edition || 'auto',
+    notes: server.notes || '',
+    tags: normalizeTagsText(server.tags),
+  }
+}
+
+function parseTags(value) {
+  return String(value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+}
+
+function hydrateFormFromDom() {
+  state.form = {
+    id: document.getElementById('field-id').value.trim(),
+    name: document.getElementById('field-name').value.trim(),
+    host: document.getElementById('field-host').value.trim(),
+    port: document.getElementById('field-port').value.trim(),
+    edition: document.getElementById('field-edition').value,
+    notes: document.getElementById('field-notes').value.trim(),
+    tags: document.getElementById('field-tags').value.trim(),
+  }
+}
+
+function selectedServer() {
+  return state.servers.find((server) => server.id === state.selectedId) || null
+}
+
+async function loadServers() {
+  state.servers = await kvGet(STORAGE_KEY, [])
+  if (!state.selectedId && state.servers.length > 0) {
+    state.selectedId = state.servers[0].id
+  }
+  if (state.selectedId && !state.servers.some((server) => server.id === state.selectedId)) {
+    state.selectedId = state.servers.length > 0 ? state.servers[0].id : null
+  }
+}
+
+function describeLiveStatus(status) {
+  if (!status) return '<span class="badge">Aucun statut charge</span>'
+  if (status.ok === false) {
+    return '<span class="badge error">Hors ligne</span>'
+  }
+  const badges = []
+  badges.push('<span class="badge ok">En ligne</span>')
+  if (status.resolvedEdition) {
+    badges.push('<span class="badge">' + escapeHtml(status.resolvedEdition) + '</span>')
+  }
+  if (status.players && typeof status.players.online === 'number') {
+    badges.push('<span class="badge">' + escapeHtml(String(status.players.online)) + ' joueurs</span>')
+  }
+  if (typeof status.latencyMs === 'number') {
+    badges.push('<span class="badge">' + escapeHtml(String(status.latencyMs)) + ' ms</span>')
+  }
+  return badges.join('')
+}
+
+function serverCardHtml(server) {
+  const status = state.liveById[server.id]
+  const endpoint = server.host + ':' + server.port
+  return `
+    <div class="server-card ${state.selectedId === server.id ? 'is-selected' : ''}" data-server-id="${escapeHtml(server.id)}">
+      <div class="server-head">
+        <div class="server-title">
+          <h3>${escapeHtml(server.name)}</h3>
+          <p class="muted">${escapeHtml(endpoint)}</p>
+          <small class="muted">${escapeHtml(server.notes || '')}</small>
+        </div>
+        <div class="server-badges">
+          <span class="badge">${escapeHtml(server.edition || 'auto')}</span>
+          ${(server.tags || []).map((tag) => `<span class="badge">${escapeHtml(tag)}</span>`).join('')}
+        </div>
+      </div>
+      <div class="server-badges">${describeLiveStatus(status)}</div>
+      <div class="row-actions">
+        <button class="chaton-ui-button chaton-ui-button--ghost" data-action="select" data-server-id="${escapeHtml(server.id)}">Editer</button>
+        <button class="chaton-ui-button" data-action="probe" data-server-id="${escapeHtml(server.id)}">Tester</button>
+        <button class="chaton-ui-button chaton-ui-button--ghost" data-action="players" data-server-id="${escapeHtml(server.id)}">Joueurs</button>
+        <button class="chaton-ui-button chaton-ui-button--ghost" data-action="delete" data-server-id="${escapeHtml(server.id)}">Supprimer</button>
+      </div>
+    </div>
+  `
+}
+
+function statusDetailHtml(server, status) {
+  if (!server) {
+    return '<div class="empty">Selectionne un serveur pour voir les details.</div>'
+  }
+  if (!status) {
+    return '<div class="empty">Aucun statut live charge pour ce serveur.</div>'
+  }
+  return `
+    <div class="status-box">
+      <div class="server-badges">${describeLiveStatus(status)}</div>
+      <pre>${escapeHtml(JSON.stringify(status, null, 2))}</pre>
+    </div>
+  `
+}
+
+function render() {
+  const app = document.getElementById('app')
+  const selected = selectedServer()
+  const statsCount = state.servers.length
+  const onlineCount = Object.values(state.liveById).filter((entry) => entry && entry.ok !== false).length
+
+  app.innerHTML = `
+    <div class="toolbar">
+      <div class="stats">
+        <div class="stat"><strong>${statsCount}</strong><span>serveurs</span></div>
+        <div class="stat"><strong>${onlineCount}</strong><span>en ligne probes</span></div>
+      </div>
+      <div class="actions">
+        <button id="refreshAllBtn" class="chaton-ui-button">Actualiser tout</button>
+        <button id="resetFormBtn" class="chaton-ui-button chaton-ui-button--ghost">Nouveau serveur</button>
+      </div>
+    </div>
+
+    <div id="statusMessage" class="muted"></div>
+
+    <div class="layout">
+      <section class="ce-card">
+        <div class="ce-card__body">
+          <h2 class="ce-section-title">Configuration</h2>
+          <div class="field-grid">
+            <div class="full ce-field">
+              <label class="ce-label" for="field-name">Nom</label>
+              <input id="field-name" value="${escapeHtml(state.form.name)}" placeholder="Mon serveur survie">
+            </div>
+            <div class="ce-field">
+              <label class="ce-label" for="field-host">Host</label>
+              <input id="field-host" value="${escapeHtml(state.form.host)}" placeholder="play.example.net">
+            </div>
+            <div class="ce-field">
+              <label class="ce-label" for="field-port">Port</label>
+              <input id="field-port" value="${escapeHtml(state.form.port)}" placeholder="25565">
+            </div>
+            <div class="ce-field">
+              <label class="ce-label" for="field-edition">Edition</label>
+              <select id="field-edition">
+                <option value="auto" ${state.form.edition === 'auto' ? 'selected' : ''}>Auto</option>
+                <option value="java" ${state.form.edition === 'java' ? 'selected' : ''}>Java</option>
+                <option value="bedrock" ${state.form.edition === 'bedrock' ? 'selected' : ''}>Bedrock</option>
+              </select>
+            </div>
+            <div class="full ce-field">
+              <label class="ce-label" for="field-tags">Tags</label>
+              <input id="field-tags" value="${escapeHtml(state.form.tags)}" placeholder="survie, prive, amis">
+            </div>
+            <div class="full ce-field">
+              <label class="ce-label" for="field-notes">Notes</label>
+              <textarea id="field-notes" placeholder="Infos libres sur le serveur">${escapeHtml(state.form.notes)}</textarea>
+            </div>
+          </div>
+          <input id="field-id" type="hidden" value="${escapeHtml(state.form.id)}">
+          <div class="actions">
+            <button id="saveBtn" class="chaton-ui-button chaton-ui-button--primary">${state.form.id ? 'Mettre a jour' : 'Ajouter'}</button>
+            <button id="probeBtn" class="chaton-ui-button">Tester ce serveur</button>
+            <button id="playersBtn" class="chaton-ui-button chaton-ui-button--ghost">Lister les joueurs</button>
+          </div>
+          <div class="muted">Les informations live utilisent uniquement le ping public du serveur. La liste des joueurs depend de ce que le serveur expose.</div>
+        </div>
+      </section>
+
+      <section class="ce-card">
+        <div class="ce-card__body">
+          <h2 class="ce-section-title">Serveurs enregistres</h2>
+          <div class="server-list">
+            ${state.servers.length ? state.servers.map(serverCardHtml).join('') : '<div class="empty">Aucun serveur configure pour le moment.</div>'}
+          </div>
+        </div>
+      </section>
+    </div>
+
+    <section class="ce-card">
+      <div class="ce-card__body">
+        <h2 class="ce-section-title">Details du statut</h2>
+        ${statusDetailHtml(selected, selected ? state.liveById[selected.id] : null)}
+      </div>
+    </section>
+  `
+
+  bindEvents()
+}
+
+async function refresh() {
+  await loadServers()
+  if (!state.form.id && state.selectedId) {
+    const server = selectedServer()
+    if (server) state.form = formFromServer(server)
+  }
+  render()
+}
+
+async function saveCurrentForm() {
+  hydrateFormFromDom()
+  const payload = {
+    id: state.form.id || undefined,
+    name: state.form.name,
+    host: state.form.host,
+    port: state.form.port ? Number(state.form.port) : undefined,
+    edition: state.form.edition,
+    notes: state.form.notes,
+    tags: parseTags(state.form.tags),
+  }
+
+  if (!payload.name || !payload.host) {
+    setMessage('Le nom et le host sont obligatoires.', 'error')
+    return
+  }
+
+  const result = payload.id
+    ? await call('minecraft.servers.update', payload)
+    : await call('minecraft.servers.add', payload)
+
+  if (!result || !result.ok) {
+    setMessage(result && result.error ? result.error.message : 'Echec de sauvegarde.', 'error')
+    return
+  }
+
+  state.selectedId = result.data && result.data.server ? result.data.server.id : state.selectedId
+  state.form = state.selectedId && result.data && result.data.server ? formFromServer(result.data.server) : clone(DEFAULT_FORM)
+  setMessage(payload.id ? 'Serveur mis a jour.' : 'Serveur ajoute.', 'success')
+  await refresh()
+}
+
+async function probeServer(server) {
+  if (!server) {
+    setMessage('Aucun serveur selectionne.', 'error')
+    return
+  }
+  const result = await call('minecraft.servers.status', { id: server.id })
+  if (!result || !result.ok) {
+    state.liveById[server.id] = { ok: false, error: result && result.error ? result.error.message : 'Probe failed' }
+    setMessage(result && result.error ? result.error.message : 'Probe impossible.', 'error')
+    render()
+    return
+  }
+  state.liveById[server.id] = result.data
+  setMessage('Statut mis a jour pour ' + server.name + '.', 'success')
+  render()
+}
+
+async function listPlayers(server) {
+  if (!server) {
+    setMessage('Aucun serveur selectionne.', 'error')
+    return
+  }
+  const result = await call('minecraft.servers.players', { id: server.id })
+  if (!result || !result.ok) {
+    setMessage(result && result.error ? result.error.message : 'Impossible de lister les joueurs.', 'error')
+    return
+  }
+  const players = result.data && Array.isArray(result.data.players) ? result.data.players : []
+  setMessage(players.length ? ('Joueurs en ligne: ' + players.join(', ')) : 'Aucun joueur nomme expose par le serveur.', 'success')
+  if (result.data && result.data.status) {
+    state.liveById[server.id] = result.data.status
+  }
+  render()
+}
+
+async function removeServer(serverId) {
+  const result = await call('minecraft.servers.remove', { id: serverId })
+  if (!result || !result.ok) {
+    setMessage(result && result.error ? result.error.message : 'Suppression impossible.', 'error')
+    return
+  }
+  delete state.liveById[serverId]
+  if (state.selectedId === serverId) {
+    state.selectedId = null
+    state.form = clone(DEFAULT_FORM)
+  }
+  setMessage('Serveur supprime.', 'success')
+  await refresh()
+}
+
+async function refreshAll() {
+  await loadServers()
+  for (const server of state.servers) {
+    const result = await call('minecraft.servers.status', { id: server.id })
+    state.liveById[server.id] = result && result.ok ? result.data : { ok: false, error: result && result.error ? result.error.message : 'Probe failed' }
+  }
+  setMessage('Statuts actualises.', 'success')
+  render()
+}
+
+function bindEvents() {
+  const saveBtn = document.getElementById('saveBtn')
+  const probeBtn = document.getElementById('probeBtn')
+  const playersBtn = document.getElementById('playersBtn')
+  const resetFormBtn = document.getElementById('resetFormBtn')
+  const refreshAllBtn = document.getElementById('refreshAllBtn')
+
+  if (saveBtn) {
+    saveBtn.onclick = function () {
+      void saveCurrentForm()
+    }
+  }
+  if (probeBtn) {
+    probeBtn.onclick = function () {
+      void probeServer(selectedServer())
+    }
+  }
+  if (playersBtn) {
+    playersBtn.onclick = function () {
+      void listPlayers(selectedServer())
+    }
+  }
+  if (resetFormBtn) {
+    resetFormBtn.onclick = function () {
+      state.selectedId = null
+      state.form = clone(DEFAULT_FORM)
+      render()
+    }
+  }
+  if (refreshAllBtn) {
+    refreshAllBtn.onclick = function () {
+      void refreshAll()
+    }
+  }
+
+  Array.from(document.querySelectorAll('[data-action]')).forEach((node) => {
+    node.onclick = function () {
+      const action = node.getAttribute('data-action')
+      const serverId = node.getAttribute('data-server-id')
+      const server = state.servers.find((entry) => entry.id === serverId)
+      if (!server) return
+      if (action === 'select') {
+        state.selectedId = server.id
+        state.form = formFromServer(server)
+        render()
+        return
+      }
+      if (action === 'probe') {
+        void probeServer(server)
+        return
+      }
+      if (action === 'players') {
+        void listPlayers(server)
+        return
+      }
+      if (action === 'delete') {
+        void removeServer(server.id)
+      }
+    }
+  })
+}
+
+;(async function init() {
+  if (window.chatonExtensionComponents) {
+    window.chatonExtensionComponents.ensureStyles()
+  }
+  await refresh()
+})()

package/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@thibautrey/chatons-extension-minecraft-servers",
+  "version": "1.0.0",
+  "description": "Minecraft servers extension for Chatons",
+  "type": "module",
+  "license": "MIT"
+}