eve-mentor-mcp 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Henry Robinson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,152 @@
+# eve-mentor-mcp
+
+An MCP server that turns Claude into an **EVE Online mentor for players trying to learn the game**.
+
+EVE has the steepest learning cliff in gaming. Existing tools assume you already know what to ask. This one is built around the questions new players actually have:
+
+- **"Why do I keep getting blown up?"** — pulls your real losses from zKillboard with the full fit you were flying, who killed you, and with what, so Claude can explain exactly what went wrong.
+- **"Is this system dangerous?"** — live kill and traffic data for any system.
+- **"What is this thing and what does it cost?"** — any ship or module, with live Jita prices.
+- **"What should I do next?"** — log in with EVE SSO and Claude sees your skills, skill queue, wallet, location, and current ship, and can coach from your actual situation.
+
+Works with Claude Desktop, Claude Code, and any MCP client.
+
+## Tools
+
+| Tool | Auth | What it does |
+|------|------|--------------|
+| `can_i_fly` | optional | Full recursive skill prerequisite tree + ordered training plan for any ship/module; diffed against your real skills when logged in |
+| `career_test` | none | The EVE career "sorting hat" — Claude interviews you, then matches you to playstyles |
+| `recent_losses` | none | A character's recent losses with full fit detail (zKillboard + ESI) |
+| `system_intel` | none | Security status + kills/jumps in the last hour for any system |
+| `lookup_item` | none | Item/ship/module description + live Jita buy/sell prices |
+| `eve_login` | — | Browser-based EVE SSO login (OAuth2 PKCE, no secret stored) |
+| `eve_auth_status` | — | Who's logged in |
+| `character_sheet` | SSO | Skillpoints, wallet, location, current ship |
+| `skill_queue` | SSO | What's training and when it finishes |
+| `top_skills` | SSO | Highest-trained skills |
+
+## Install (no coding required)
+
+You need two things: the **Claude Desktop app** (or Claude Code) and **Node.js**, a free
+runtime that this server runs on — installing it is like installing any other app.
+
+### Step 1 — Install Node.js (skip if you have it)
+
+Go to [nodejs.org](https://nodejs.org), download the **LTS** version, run the installer,
+click through with the defaults. Done.
+
+### Step 2 — Download and build the server
+
+Open a terminal — on **Mac**: press `Cmd+Space`, type `Terminal`, hit Enter. On
+**Windows**: press the Windows key, type `PowerShell`, hit Enter. Then copy-paste this
+whole block and press Enter:
+
+```bash
+git clone https://github.com/henryjrobinson/eve-mentor-mcp
+cd eve-mentor-mcp
+npm install && npm run build
+```
+
+(If Windows says git isn't installed, get it from [git-scm.com](https://git-scm.com) —
+defaults are fine — or click the green **Code → Download ZIP** button on this page,
+unzip it, and run the `cd` + `npm` lines inside that folder.)
+
+When it finishes, note the folder's full path — run `pwd` (Mac) or `cd` (Windows) to
+print it. You'll paste it in the next step where it says `/FULL/PATH/TO/eve-mentor-mcp`.
+
+### Step 3 — Tell Claude about it
+
+**Claude Desktop:** open the config file in any text editor —
+
+- Mac: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
+(If it doesn't exist, create it.) Make it look like this:
+
+```json
+{
+  "mcpServers": {
+    "eve-mentor": {
+      "command": "node",
+      "args": ["/FULL/PATH/TO/eve-mentor-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+Save, then fully quit and reopen Claude Desktop.
+
+**Claude Code** (one line instead):
+
+```bash
+claude mcp add eve-mentor -- node /FULL/PATH/TO/eve-mentor-mcp/dist/index.js
+```
+
+### Step 4 — Test it
+
+Ask Claude: *"Pull the last 3 losses for character `<any EVE character name>` and explain
+what went wrong."* If it answers with real killmail data, you're live. No EVE login is
+needed for this — losses, system intel, prices, the career test, and the jargon glossary
+all work immediately.
+
+### Other AI apps
+
+Any MCP-capable client works the same way (Cursor, LM Studio, VS Code, etc. — point them
+at `node /path/dist/index.js`). **ChatGPT** supports MCP but only *remote* servers, not
+local ones — a hosted version of the public tools is on the roadmap.
+
+### Character tools (EVE SSO)
+
+1. Go to [developers.eveonline.com](https://developers.eveonline.com) → log in with your EVE account → **Create New Application**
+2. Name it anything (e.g. `eve-mentor`), pick **Authentication & API Access**
+3. Select these scopes:
+   - `esi-skills.read_skills.v1`
+   - `esi-skills.read_skillqueue.v1`
+   - `esi-location.read_location.v1`
+   - `esi-location.read_ship_type.v1`
+   - `esi-wallet.read_character_wallet.v1`
+   - `esi-assets.read_assets.v1`
+4. Set the callback URL to exactly `https://ruby-eve.com/callback` — CCP's portal only accepts
+   https callbacks; this static page (source in `site/callback/`) relays the login code to the
+   local server on port 8484. (Self-hosting? Serve your own copy and set `EVE_REDIRECT_URI`.)
+5. Copy the **Client ID** and add it to the server's environment:
+
+```bash
+claude mcp add eve-mentor -e EVE_CLIENT_ID=your_client_id -- node /path/to/eve-mentor-mcp/dist/index.js
+```
+
+(or add `"env": {"EVE_CLIENT_ID": "your_client_id"}` to the Claude Desktop config.)
+
+Then ask Claude to log you in to EVE — a browser opens, you authorize, done. Tokens are stored in `~/.config/eve-mentor/tokens.json` (mode 600) and refresh automatically.
+
+## Try it
+
+> *"Pull my last 3 losses for character `Your Pilot Name` and explain what I did wrong in each one."*
+
+> *"I'm about to fly through Tama. How dangerous is it right now?"*
+
+> *"What should I be training next given my skills and the fact that I want to try small-gang PvP?"*
+
+## Verify it works
+
+```bash
+npm run smoke                      # tests ESI name resolution, market, system intel
+npm run smoke -- "Pilot Name"      # also tests the zKillboard loss pipeline
+```
+
+## Notes
+
+- Data comes from [ESI](https://esi.evetech.net) (CCP's official API) and [zKillboard](https://zkillboard.com). Be a good citizen: this server sends a proper User-Agent and caches name lookups.
+- Built under the [CCP Developer License](https://developers.eveonline.com/license-agreement) — non-commercial, as required.
+- EVE Online and all related trademarks are the property of [CCP hf](https://www.ccpgames.com).
+
+## Roadmap
+
+- Ship fitting analysis (slot layout vs. ship bonuses)
+- "What can I fly?" — cross-reference skills against ship prerequisites
+- Route danger scoring (per-jump kill activity)
+- Wormhole / exploration helpers
+- Remote MCP deployment so no local install is needed
+
+PRs welcome. MIT licensed.

package/dist/auth.js

@@ -0,0 +1,178 @@
+/**
+ * EVE SSO via OAuth2 PKCE (native-app flow — no client secret).
+ * Requires a free app registered at https://developers.eveonline.com with
+ * callback URL http://localhost:8484/callback. Set EVE_CLIENT_ID to its ID.
+ * Tokens persist in ~/.config/eve-mentor/tokens.json and refresh automatically.
+ */
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+const SSO_AUTHORIZE_URL = "https://login.eveonline.com/v2/oauth/authorize";
+const SSO_TOKEN_URL = "https://login.eveonline.com/v2/oauth/token";
+const CALLBACK_PORT = 8484;
+// Local listener that actually receives the auth code...
+const CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+// ...but CCP's dev portal only accepts https callback URLs, so the registered
+// redirect is a static relay page that immediately forwards the query string
+// to the local listener. Override with EVE_REDIRECT_URI if self-hosting one.
+const REDIRECT_URI = process.env.EVE_REDIRECT_URI ?? "https://ruby-eve.com/callback";
+const LOGIN_TIMEOUT_MS = 180_000;
+const TOKEN_DIR = join(homedir(), ".config", "eve-mentor");
+const TOKEN_FILE = join(TOKEN_DIR, "tokens.json");
+export const SCOPES = [
+    "esi-skills.read_skills.v1",
+    "esi-skills.read_skillqueue.v1",
+    "esi-location.read_location.v1",
+    "esi-location.read_ship_type.v1",
+    "esi-wallet.read_character_wallet.v1",
+    "esi-assets.read_assets.v1",
+].join(" ");
+export class AuthError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "AuthError";
+    }
+}
+function getClientId() {
+    const clientId = process.env.EVE_CLIENT_ID;
+    if (!clientId) {
+        throw new AuthError("EVE_CLIENT_ID is not set. Register a free app at https://developers.eveonline.com " +
+            `(callback URL: ${REDIRECT_URI}) and set its Client ID in the MCP server env.`);
+    }
+    return clientId;
+}
+async function loadToken() {
+    try {
+        return JSON.parse(await readFile(TOKEN_FILE, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+async function saveToken(token) {
+    await mkdir(TOKEN_DIR, { recursive: true });
+    await writeFile(TOKEN_FILE, JSON.stringify(token, null, 2), { mode: 0o600 });
+}
+function decodeJwtCharacter(accessToken) {
+    const payload = JSON.parse(Buffer.from(accessToken.split(".")[1], "base64url").toString("utf8"));
+    // sub format: "CHARACTER:EVE:2112345678"
+    const id = Number(payload.sub.split(":")[2]);
+    if (!id)
+        throw new AuthError("Could not read character ID from SSO token.");
+    return { id, name: payload.name };
+}
+async function exchangeToken(body) {
+    const response = await fetch(SSO_TOKEN_URL, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            Host: "login.eveonline.com",
+        },
+        body,
+    });
+    if (!response.ok) {
+        throw new AuthError(`EVE SSO token request failed (${response.status}): ${await response.text()}`);
+    }
+    const json = (await response.json());
+    const character = decodeJwtCharacter(json.access_token);
+    return {
+        characterId: character.id,
+        characterName: character.name,
+        accessToken: json.access_token,
+        refreshToken: json.refresh_token,
+        expiresAt: Date.now() + json.expires_in * 1000,
+    };
+}
+/** Wait for EVE SSO to redirect back to localhost with the auth code. */
+function waitForCallback(expectedState) {
+    return new Promise((resolve, reject) => {
+        const server = createServer((req, res) => {
+            const url = new URL(req.url ?? "/", CALLBACK_URL);
+            if (url.pathname !== "/callback") {
+                res.writeHead(404).end();
+                return;
+            }
+            const code = url.searchParams.get("code");
+            const state = url.searchParams.get("state");
+            res.writeHead(200, { "Content-Type": "text/html" });
+            res.end("<h2>Logged in to EVE. You can close this tab and return to Claude.</h2>");
+            server.close();
+            clearTimeout(timer);
+            if (!code || state !== expectedState) {
+                reject(new AuthError("SSO callback missing code or state mismatch."));
+            }
+            else {
+                resolve(code);
+            }
+        });
+        const timer = setTimeout(() => {
+            server.close();
+            reject(new AuthError(`Timed out after ${LOGIN_TIMEOUT_MS / 1000}s waiting for EVE login.`));
+        }, LOGIN_TIMEOUT_MS);
+        server.on("error", (err) => {
+            clearTimeout(timer);
+            reject(new AuthError(`Could not listen on port ${CALLBACK_PORT}: ${err.message}`));
+        });
+        server.listen(CALLBACK_PORT);
+    });
+}
+/** Run the full browser login flow. Returns the logged-in character name. */
+export async function login() {
+    const clientId = getClientId();
+    const verifier = randomBytes(32).toString("base64url");
+    const challenge = createHash("sha256").update(verifier).digest("base64url");
+    const state = randomBytes(16).toString("base64url");
+    const authorizeUrl = `${SSO_AUTHORIZE_URL}?response_type=code` +
+        `&redirect_uri=${encodeURIComponent(REDIRECT_URI)}` +
+        `&client_id=${clientId}` +
+        `&scope=${encodeURIComponent(SCOPES)}` +
+        `&code_challenge=${challenge}&code_challenge_method=S256` +
+        `&state=${state}`;
+    const callbackPromise = waitForCallback(state);
+    openBrowser(authorizeUrl);
+    const code = await callbackPromise;
+    const token = await exchangeToken(new URLSearchParams({
+        grant_type: "authorization_code",
+        code,
+        client_id: clientId,
+        code_verifier: verifier,
+    }));
+    await saveToken(token);
+    return { characterName: token.characterName, characterId: token.characterId };
+}
+function openBrowser(url) {
+    if (process.platform === "win32") {
+        // "start" is a cmd builtin; the empty string is the window title argument.
+        execFile("cmd", ["/c", "start", "", url]);
+    }
+    else {
+        execFile(process.platform === "darwin" ? "open" : "xdg-open", [url]);
+    }
+}
+/** Current login state without touching the network. */
+export async function authStatus() {
+    const token = await loadToken();
+    if (!token)
+        return { loggedIn: false };
+    return { loggedIn: true, characterName: token.characterName, characterId: token.characterId };
+}
+/** Valid access token + character id, refreshing if needed. */
+export async function getSession() {
+    let token = await loadToken();
+    if (!token) {
+        throw new AuthError('Not logged in to EVE. Use the "eve_login" tool first.');
+    }
+    if (token.expiresAt < Date.now() + 60_000) {
+        const refreshed = await exchangeToken(new URLSearchParams({
+            grant_type: "refresh_token",
+            refresh_token: token.refreshToken,
+            client_id: getClientId(),
+        }));
+        await saveToken(refreshed);
+        token = refreshed;
+    }
+    return { accessToken: token.accessToken, characterId: token.characterId };
+}

package/dist/careers.js

@@ -0,0 +1,202 @@
+/**
+ * Career path taxonomy for the playstyle "sorting hat".
+ * The MCP client (Claude) runs the interview; this is the matching data.
+ * Sources: EVE University careers wiki, CCP's EVE Academy archetypes.
+ */
+export const CAREER_PATHS = [
+    {
+        name: "Exploration (relic/data sites)",
+        archetype: "Explorer",
+        description: "Probe-scan hidden sites across dangerous space, hack containers for loot, run from anything that shoots.",
+        appealsTo: "Players who like treasure hunting, tension without forced combat, and playing smart instead of strong.",
+        social: "solo",
+        risk: "medium",
+        income: "high",
+        activity: "active",
+        firstShip: "Heron / Imicus (T1 scanning frigate)",
+        firstSteps: "Train Astrometrics, fit a relic/data analyzer + probe launcher, take wormholes or null-sec entrances and hack everything you find.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Faction Warfare",
+        archetype: "Soldier",
+        description: "Enlist with an empire militia; capture complexes and fight small-ship PvP for loyalty point payouts.",
+        appealsTo: "Players who want real PvP fast, in cheap ships, with a built-in team and a reason to fight.",
+        social: "either",
+        risk: "high",
+        income: "medium",
+        activity: "active",
+        firstShip: "T1 frigate (Tristan, Merlin, Punisher, Rifter)",
+        firstSteps: "Join a militia (or an FW newbie corp like Minmatar Fleet Academy), buy 10 cheap fitted frigates, expect to lose them all, learn from each one.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Mission running",
+        archetype: "Enforcer",
+        description: "Run combat missions for NPC agents, climbing from level 1 to level 4 for ISK and loyalty points.",
+        appealsTo: "Players who want structured PvE with clear goals, steady progression, and low surprise.",
+        social: "solo",
+        risk: "low",
+        income: "medium",
+        activity: "active",
+        firstShip: "T1 frigate → destroyer → cruiser",
+        firstSteps: "Find a level 1 security agent, match your ammo damage type to the enemy faction, work up the ladder.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Abyssal Deadspace",
+        archetype: "Enforcer",
+        description: "Timed instanced dungeons with escalating tiers — EVE's closest thing to a roguelike arena.",
+        appealsTo: "Players who like skill-expression PvE, measurable difficulty tiers, and adrenaline.",
+        social: "solo",
+        risk: "medium",
+        income: "high",
+        activity: "active",
+        firstShip: "Well-fitted cruiser (Gila is the meta; a T1 cruiser can run low tiers)",
+        firstSteps: "Start at tier 0/1 filaments in a cheap cruiser; the timer is the real enemy — die inside and you lose everything.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Mining",
+        archetype: "Industrialist",
+        description: "Extract ore, ice, and gas to sell or feed into manufacturing.",
+        appealsTo: "Players who want low-stress, semi-passive play — podcast in one ear, lasers on rocks.",
+        social: "either",
+        risk: "low",
+        income: "low",
+        activity: "semi-active",
+        firstShip: "Venture (free from career agents)",
+        firstSteps: "Run the industry career agent for a free Venture, mine high-sec belts, sell at the nearest hub; join group mining ops for company.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Ratting",
+        archetype: "Enforcer",
+        description: "Hunt NPC pirates in asteroid belts and anomalies for bounty payouts.",
+        appealsTo: "Players who want simple combat income without mission structure.",
+        social: "solo",
+        risk: "low",
+        income: "low",
+        activity: "active",
+        firstShip: "Any combat frigate; Vexor later",
+        firstSteps: "Match damage types to the local pirate faction and clear belts/anomalies.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Hauling / logistics",
+        archetype: "Industrialist",
+        description: "Move goods between markets via courier contracts or your own trading.",
+        appealsTo: "Players who enjoy logistics puzzles and quiet profit over combat.",
+        social: "solo",
+        risk: "medium",
+        income: "medium",
+        activity: "semi-active",
+        firstShip: "T1 industrial (Iteron Mark V, Badger)",
+        firstSteps: "Take small courier contracts; never autopilot through Uedama or Niarja-class chokepoints with valuable cargo.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Trading / market PvP",
+        archetype: "Industrialist",
+        description: "Station trading and regional arbitrage — playing the market instead of the spaceship.",
+        appealsTo: "Spreadsheet enjoyers, economics nerds, patient compounding-gains people.",
+        social: "solo",
+        risk: "low",
+        income: "high",
+        activity: "passive",
+        firstShip: "None — a docked alt and seed capital",
+        firstSteps: "Start with 0.01-ISK-style margin trading on high-volume items in Jita; learn buy vs sell orders with small stakes.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Manufacturing & research",
+        archetype: "Industrialist",
+        description: "Buy blueprints, build modules/ships, research efficiency, sell output.",
+        appealsTo: "Builders and optimizers who want to make the things everyone else explodes.",
+        social: "either",
+        risk: "low",
+        income: "medium",
+        activity: "passive",
+        firstShip: "None initially",
+        firstSteps: "Build T1 ammo from a cheap blueprint near a trade hub; profit is thin but the loop teaches the whole economy.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Planetary Industry",
+        archetype: "Industrialist",
+        description: "Semi-passive resource colonies on planets, harvested on a timer.",
+        appealsTo: "Players who like idle-game mechanics layered onto their main activity.",
+        social: "solo",
+        risk: "low",
+        income: "low",
+        activity: "passive",
+        firstShip: "Any",
+        firstSteps: "Train Command Center Upgrades, drop colonies on high-sec planets, restart extractors every few days.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Wormhole living",
+        archetype: "Explorer",
+        description: "Move into uncharted J-space with a corp: scanning, krabbing, and ambush PvP with no local chat.",
+        appealsTo: "Players who want the frontier — self-reliance, paranoia, tight-knit crews.",
+        social: "group",
+        risk: "high",
+        income: "high",
+        activity: "active",
+        firstShip: "Scanning frigate; corp provides doctrine ships",
+        firstSteps: "Not a first-month path solo — join a wormhole corp that teaches.",
+        newbieFriendly: false,
+    },
+    {
+        name: "Null-sec sovereignty warfare",
+        archetype: "Soldier",
+        description: "Join a null bloc (Pandemic Horde, Brave, etc.): big fleet fights, doctrine ships, alliance life.",
+        appealsTo: "Players who want to be part of something huge — thousand-pilot battles and politics.",
+        social: "group",
+        risk: "medium",
+        income: "medium",
+        activity: "active",
+        firstShip: "Whatever the alliance doctrine hands you",
+        firstSteps: "Join a newbie-friendly bloc, follow the fleet, shoot what the FC calls. Free ships are common.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Incursions",
+        archetype: "Enforcer",
+        description: "High-end organized fleet PvE against Sansha invasions — elite income, strict fits.",
+        appealsTo: "PvE players who want raid-style group content.",
+        social: "group",
+        risk: "low",
+        income: "high",
+        activity: "active",
+        firstShip: "Battleship with a community-mandated fit",
+        firstSteps: "A months-long training target, not a starting point.",
+        newbieFriendly: false,
+    },
+    {
+        name: "Salvaging",
+        archetype: "Industrialist",
+        description: "Sweep battlefields and mission wrecks for salvage materials.",
+        appealsTo: "Scavenger-brain players; pairs well with mission running.",
+        social: "either",
+        risk: "low",
+        income: "low",
+        activity: "active",
+        firstShip: "Destroyer with salvagers → Noctis",
+        firstSteps: "Follow your own mission wrecks first; public wreck fields later.",
+        newbieFriendly: true,
+    },
+    {
+        name: "Piracy / ganking",
+        archetype: "Soldier",
+        description: "Legal-but-hostile sandbox crime: suicide ganking, can-flipping, ransoms, scams.",
+        appealsTo: "Villain-arc players. EVE genuinely permits it; the community will remember you.",
+        social: "either",
+        risk: "high",
+        income: "medium",
+        activity: "active",
+        firstShip: "Cheap Catalyst",
+        firstSteps: "Understand CONCORD and sec status mechanics first or you'll lock yourself out of empire space.",
+        newbieFriendly: false,
+    },
+];

package/dist/character.js

@@ -0,0 +1,111 @@
+/**
+ * Authenticated character endpoints (require EVE SSO login).
+ */
+import { getSession } from "./auth.js";
+import { esiFetch, getSystem, getType, namesForIds } from "./esi.js";
+export async function getCharacterSheet() {
+    const { accessToken, characterId } = await getSession();
+    const authed = { token: accessToken };
+    const [skills, wallet, location, ship, names] = await Promise.all([
+        esiFetch(`/characters/${characterId}/skills/`, authed),
+        esiFetch(`/characters/${characterId}/wallet/`, authed),
+        esiFetch(`/characters/${characterId}/location/`, authed),
+        esiFetch(`/characters/${characterId}/ship/`, authed),
+        namesForIds([characterId]),
+    ]);
+    const [system, shipType] = await Promise.all([
+        getSystem(location.data.solar_system_id),
+        getType(ship.data.ship_type_id),
+    ]);
+    return {
+        character: names.get(characterId) ?? `character-${characterId}`,
+        totalSkillpoints: skills.data.total_sp,
+        skillCount: skills.data.skills.length,
+        walletIsk: Math.round(wallet.data),
+        location: system.name,
+        locationSecurity: Number(system.security_status.toFixed(1)),
+        currentShip: shipType.name,
+    };
+}
+export async function getSkillQueue() {
+    const { accessToken, characterId } = await getSession();
+    const { data: queue } = await esiFetch(`/characters/${characterId}/skillqueue/`, { token: accessToken });
+    const names = await namesForIds(queue.map((entry) => entry.skill_id));
+    return queue.map((entry) => ({
+        position: entry.queue_position,
+        skill: names.get(entry.skill_id) ?? `skill-${entry.skill_id}`,
+        toLevel: entry.finished_level,
+        finishes: entry.finish_date ?? "paused (queue not training)",
+    }));
+}
+const STRUCTURE_ID_FLOOR = 1_000_000_000_000;
+async function locationLabel(locationId, accessToken, stationNames) {
+    if (locationId < STRUCTURE_ID_FLOOR) {
+        return stationNames.get(locationId) ?? `location-${locationId}`;
+    }
+    // Player-owned structure: name lookup requires docking access — a 403 here
+    // means the character is locked out (assets likely stranded or in asset safety).
+    try {
+        const { data } = await esiFetch(`/universe/structures/${locationId}/`, { token: accessToken });
+        return data.name;
+    }
+    catch {
+        return `INACCESSIBLE structure ${locationId} (no docking access — assets may be stranded; check asset safety)`;
+    }
+}
+/** All assets grouped by location, with inaccessible structures and asset safety flagged. */
+export async function getAssetsSummary() {
+    const { accessToken, characterId } = await getSession();
+    const all = [];
+    let page = 1;
+    let pages = 1;
+    do {
+        const result = await esiFetch(`/characters/${characterId}/assets/?page=${page}`, { token: accessToken });
+        all.push(...result.data);
+        pages = result.pages;
+        page += 1;
+    } while (page <= pages);
+    // Top-level assets only: things whose container is a station/structure,
+    // not another asset (e.g. modules fitted to a stored ship).
+    const ownItemIds = new Set(all.map((asset) => asset.item_id));
+    const topLevel = all.filter((asset) => !ownItemIds.has(asset.location_id));
+    const byLocation = new Map();
+    for (const asset of topLevel) {
+        const group = byLocation.get(asset.location_id);
+        if (group) {
+            group.push(asset);
+        }
+        else {
+            byLocation.set(asset.location_id, [asset]);
+        }
+    }
+    const stationIds = [...byLocation.keys()].filter((id) => id < STRUCTURE_ID_FLOOR);
+    const typeIds = topLevel.map((asset) => asset.type_id);
+    const names = await namesForIds([...stationIds, ...typeIds]);
+    return Promise.all([...byLocation.entries()].map(async ([locationId, assets]) => ({
+        location: await locationLabel(locationId, accessToken, names),
+        inAssetSafety: assets.some((asset) => asset.location_flag === "AssetSafety"),
+        itemCount: assets.length,
+        items: assets
+            .map((asset) => ({
+            name: names.get(asset.type_id) ?? `type-${asset.type_id}`,
+            quantity: asset.quantity,
+        }))
+            .slice(0, 25),
+    })));
+}
+export async function getTopSkills(limit) {
+    const { accessToken, characterId } = await getSession();
+    const { data } = await esiFetch(`/characters/${characterId}/skills/`, {
+        token: accessToken,
+    });
+    const top = [...data.skills]
+        .sort((a, b) => b.skillpoints_in_skill - a.skillpoints_in_skill)
+        .slice(0, limit);
+    const names = await namesForIds(top.map((skill) => skill.skill_id));
+    return top.map((skill) => ({
+        skill: names.get(skill.skill_id) ?? `skill-${skill.skill_id}`,
+        level: skill.trained_skill_level,
+        skillpoints: skill.skillpoints_in_skill,
+    }));
+}