paralith-mcp 0.2.0 → 0.3.1

package/dist/http.mjs

@@ -5,8 +5,8 @@ import http2 from "node:http";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 
 // src/runtime.mjs
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 // ../../backend/native/ans104.mjs
@@ -135,7 +135,7 @@ import { mnemonicToAccount } from "viem/accounts";
 import { Keypair } from "@solana/web3.js";
 import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
 import { getKeyFromMnemonic } from "arweave-mnemonic-keys";
-var CACHE_DIR = process.env.PARALITH_MCP_HOME || path.join(os.homedir(), ".paralith", "mcp");
+var HOME = process.env.PARALITH_MCP_HOME || path.join(os.homedir(), ".paralith", "mcp");
 function readPhrase(env = process.env) {
   const raw = env.PARALITH_MNEMONIC ?? (env.PARALITH_MNEMONIC_FILE ? fs.readFileSync(env.PARALITH_MNEMONIC_FILE, "utf8") : null);
   if (!raw) {
@@ -162,25 +162,27 @@ function slip10(seed, derivation) {
 async function aoJwk(phrase, env) {
   if (env.PARALITH_AO_JWK) return JSON.parse(fs.readFileSync(env.PARALITH_AO_JWK, "utf8"));
   const id = crypto2.createHash("sha256").update(phrase).digest("hex").slice(0, 24);
-  const file = path.join(CACHE_DIR, `ao-${id}.json`);
+  const file = path.join(HOME, `ao-${id}.json`);
   if (fs.existsSync(file)) return JSON.parse(fs.readFileSync(file, "utf8"));
   const jwk = await getKeyFromMnemonic(phrase);
-  fs.mkdirSync(CACHE_DIR, { recursive: true, mode: 448 });
+  fs.mkdirSync(HOME, { recursive: true, mode: 448 });
   fs.writeFileSync(file, JSON.stringify(jwk), { mode: 384 });
   return jwk;
 }
-async function deriveWallets(phrase, env = process.env) {
+function chainWallets(phrase) {
   const evm = mnemonicToAccount(phrase, { path: "m/44'/60'/0'/0/0" });
   const solana = Keypair.fromSeed(slip10(mnemonicToSeedSync(phrase), "m/44'/501'/0'/0'"));
   const sui = Ed25519Keypair.deriveKeypair(phrase, "m/44'/784'/0'/0'/0'");
-  const jwk = await aoJwk(phrase, env);
   return {
-    ao: { jwk, address: jwkToAddress(jwk) },
     base: { account: evm, address: evm.address },
     solana: { keypair: solana, address: solana.publicKey.toBase58() },
     sui: { keypair: sui, address: sui.getPublicKey().toSuiAddress() }
   };
 }
+async function deriveWallets(phrase, env = process.env) {
+  const jwk = await aoJwk(phrase, env);
+  return { ao: { jwk, address: jwkToAddress(jwk) }, ...chainWallets(phrase) };
+}
 var publicAddresses = (w) => ({
   ao: w.ao.address,
   base: w.base.address,
@@ -188,12 +190,32 @@ var publicAddresses = (w) => ({
   sui: w.sui.address
 });
 
+// src/agents.mjs
+import fs2 from "node:fs";
+import path2 from "node:path";
+var FILE = path2.join(HOME, "agents.json");
+function readAgents() {
+  try {
+    return JSON.parse(fs2.readFileSync(FILE, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgent(name, entry) {
+  const all = readAgents();
+  all[name] = { ...all[name], ...entry, addresses: { ...all[name]?.addresses, ...entry.addresses } };
+  fs2.mkdirSync(HOME, { recursive: true, mode: 448 });
+  fs2.writeFileSync(FILE, `${JSON.stringify(all, null, 2)}
+`);
+  return all[name];
+}
+
 // src/runtime.mjs
-var HERE = path2.dirname(fileURLToPath(import.meta.url));
-var DIST = fs2.existsSync(path2.join(HERE, "graph.json")) ? HERE : path2.join(HERE, "..", "dist");
-var graph = JSON.parse(fs2.readFileSync(path2.join(DIST, "graph.json"), "utf8"));
+var HERE = path3.dirname(fileURLToPath(import.meta.url));
+var DIST = fs3.existsSync(path3.join(HERE, "graph.json")) ? HERE : path3.join(HERE, "..", "dist");
+var graph = JSON.parse(fs3.readFileSync(path3.join(DIST, "graph.json"), "utf8"));
 var NODE = graph.node.replace(/\/$/, "");
-var chains = JSON.parse(fs2.readFileSync(path2.join(DIST, "chains.json"), "utf8"));
+var chains = JSON.parse(fs3.readFileSync(path3.join(DIST, "chains.json"), "utf8"));
 var PROCESS_ALIASES = {
   game: graph.processes.game,
   rune: graph.processes.rune,
@@ -215,7 +237,8 @@ var loaded = null;
 function runtime() {
   loaded ??= (async () => {
     const wallets = READ_ONLY ? null : await deriveWallets(readPhrase());
-    const api = await import(pathToFileURL(path2.join(DIST, "client.mjs")).href);
+    if (wallets && process.env.PARALITH_AGENT) saveAgent(process.env.PARALITH_AGENT, { addresses: publicAddresses(wallets) });
+    const api = await import(pathToFileURL(path3.join(DIST, "client.mjs")).href);
     if (wallets) api.swarmWalletSlot.wallet = walletShim(wallets.ao.jwk);
     return { api, wallets };
   })();
@@ -277,15 +300,31 @@ async function until(what, read, done, timeoutMs = 6e5, everyMs = 3e3) {
 
 // src/build.mjs
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/tool.mjs
 import { z } from "zod";
+var migrationSeen = null;
+async function migrationRefusal(read = readKey, now = Date.now()) {
+  if (!migrationSeen || now - migrationSeen.at > 15e3) {
+    migrationSeen = { at: now, value: await read("game", "migration").catch(() => null) };
+  }
+  const m = migrationSeen.value;
+  if (!m || typeof m !== "object" || m.phase === "live") return null;
+  if (m.phase === "retired") {
+    return `Paralith has moved to new processes (the game is now ${m.successor}). Nothing was sent. Update paralith-mcp to its latest version to use them.`;
+  }
+  return "A migration is in progress: Paralith is paused while every balance moves to new processes. Nothing was sent, and nothing is lost. Reads still work; try writes again later.";
+}
 function tool(server, name, description, inputSchema, run, annotations = {}, view = null) {
   if (READ_ONLY && annotations !== READ) return;
   const schema = view ? { ...inputSchema, full: z.boolean().optional().describe("Return the raw record instead of the compact view.") } : inputSchema;
   server.registerTool(name, { description, inputSchema: schema, annotations }, async (args) => {
     try {
+      if (annotations === WRITE) {
+        const refusal = await migrationRefusal();
+        if (refusal) return { isError: true, content: [{ type: "text", text: refusal }] };
+      }
       const raw = await run(args ?? {});
       const value = view && !args?.full ? await view(raw) : raw;
       const text = typeof value === "string" ? value : JSON.stringify(value, bigints, 2);
@@ -539,7 +578,7 @@ function registerGame(server) {
   tool(
     server,
     "game_daily",
-    "Claim the daily crate and Rune. Once per UTC day.",
+    "Claim the daily crate (and accrued Rune, pass holders only). Once per UTC day.",
     {},
     async () => (await me()).api.claimDaily(),
     WRITE,
@@ -1153,6 +1192,19 @@ function suiChain(w) {
     }
   };
 }
+async function gasOf(name, address) {
+  if (name === "base") {
+    const rpc = process.env.PARALITH_BASE_RPC || chains.base.rpc;
+    const pub = createPublicClient({ chain: { ...base, id: chains.base.chainId }, transport: http(rpc) });
+    return `${formatEther(await pub.getBalance({ address }))} ETH`;
+  }
+  if (name === "solana") {
+    const conn = new Connection(process.env.PARALITH_SOLANA_RPC || chains.solana.rpc, "confirmed");
+    return `${await conn.getBalance(new PublicKey(address)) / 1e9} SOL`;
+  }
+  const client = new SuiGrpcClient({ network: chains.sui.network, baseUrl: process.env.PARALITH_SUI_RPC || chains.sui.rpc });
+  return `${Number((await client.getBalance({ owner: address })).balance.balance) / 1e9} SUI`;
+}
 async function chainFor(name) {
   const { wallets } = await runtime();
   return { base: baseChain, solana: solanaChain, sui: suiChain }[name](wallets);
@@ -1627,18 +1679,19 @@ function registerVaults(server) {
 }
 
 // src/show.mjs
-import fs3 from "node:fs";
-import path3 from "node:path";
+import fs4 from "node:fs";
+import path4 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { z as z7 } from "zod";
-import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE } from "@modelcontextprotocol/ext-apps/server";
+import { spawn } from "node:child_process";
+import { registerAppResource, registerAppTool, RESOURCE_MIME_TYPE, getUiCapability } from "@modelcontextprotocol/ext-apps/server";
 var GAME = (process.env.PARALITH_GAME_URL || "https://game.paralithmarkets.com").replace(/\/$/, "");
 var TRADE = (process.env.PARALITH_TRADE_URL || "https://trade.paralithmarkets.com").replace(/\/$/, "");
 var URI = "ui://paralith/view";
-var HERE2 = path3.dirname(fileURLToPath2(import.meta.url));
+var HERE2 = path4.dirname(fileURLToPath2(import.meta.url));
 function viewHtml() {
-  for (const file of [path3.join(HERE2, "view.html"), path3.join(HERE2, "..", "dist", "view.html")]) {
-    if (fs3.existsSync(file)) return fs3.readFileSync(file, "utf8");
+  for (const file of [path4.join(HERE2, "view.html"), path4.join(HERE2, "..", "dist", "view.html")]) {
+    if (fs4.existsSync(file)) return fs4.readFileSync(file, "utf8");
   }
   throw new Error("view.html is missing: run npm run build");
 }
@@ -1664,6 +1717,16 @@ async function ownAddress() {
   const { wallets } = await runtime();
   return wallets?.ao.address;
 }
+function openInBrowser(url) {
+  const [cmd, args] = process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : process.platform === "darwin" ? ["open", [url]] : ["xdg-open", [url]];
+  try {
+    spawn(cmd, args, { detached: true, stdio: "ignore" }).on("error", () => {
+    }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
 function registerShow(server) {
   const csp = { frameDomains: [GAME, TRADE] };
   registerAppResource(
@@ -1674,7 +1737,7 @@ function registerShow(server) {
     async () => ({ contents: [{ uri: URI, mimeType: RESOURCE_MIME_TYPE, text: viewHtml(), _meta: { ui: { csp } } }] })
   );
   registerAppTool(server, "show", {
-    description: "Show something with the game's and exchange's own visuals, live: battle (follows a player's arena fights, animated), companion (card), hunt, market (order book and chart), vault, position, bridge (transfers). Returns a link; clients that support MCP Apps also display it inline. Address defaults to yours.",
+    description: "Show something with the game's and exchange's own visuals, live: battle (follows a player's arena fights, animated), companion (card), hunt, market (order book and chart), vault, position, bridge (transfers). Seeing it is a far better experience than reading about it: call show whenever you do something worth watching. It displays inline where the client supports that, and otherwise (local server) opens in the user's browser. Address defaults to yours.",
     inputSchema: {
       what: z7.enum(Object.keys(VIEWS)),
       address: z7.string().optional().describe("AO address; omit for yours."),
@@ -1685,20 +1748,121 @@ function registerShow(server) {
       market: z7.string().optional().describe("market/vault: the market, as exchange_markets lists it."),
       vault: z7.enum(["amm", "active", "grid"]).optional(),
       chain: z7.enum(["base", "solana", "sui"]).optional().describe("bridge: with tx, one transfer."),
-      tx: z7.string().optional()
+      tx: z7.string().optional(),
+      open: z7.boolean().optional().describe("Open in the user's browser. Default: only when this client cannot display it inline.")
     },
     annotations: { readOnlyHint: true, openWorldHint: true },
     _meta: { ui: { resourceUri: URI } }
   }, async (args) => {
     try {
       const view = VIEWS[args.what]({ ...args, address: args.address ?? await ownAddress() });
-      return { structuredContent: { what: args.what, view }, content: [{ type: "text", text: `${args.what}: ${view}` }] };
+      const inline = !!getUiCapability(server.server.getClientCapabilities());
+      const opened = !READ_ONLY && (args.open ?? !inline) && openInBrowser(view);
+      const where = inline ? "Displayed inline." : opened ? "Opened in the user's browser." : "Give the user this link.";
+      return { structuredContent: { what: args.what, view }, content: [{ type: "text", text: `${args.what}: ${view}
+${where}` }] };
     } catch (error) {
       return { isError: true, content: [{ type: "text", text: error.message }] };
     }
   });
 }
 
+// src/progress.mjs
+import { z as z8 } from "zod";
+var VENUES = { game: graph.processes.internalVenue, token: graph.processes.externalVenue };
+var count = (x) => Array.isArray(x) ? x.length : Object.values(x ?? {}).reduce((n, v) => n + Number(v || 0), 0);
+async function targets(who) {
+  const { wallets } = await runtime();
+  const agents = readAgents();
+  const self = wallets && { name: process.env.PARALITH_AGENT ?? "you", addresses: publicAddresses(wallets) };
+  if (!who || who === "me") {
+    if (!self) throw new Error("This server has no wallet; pass who: an AO address.");
+    return [self];
+  }
+  if (who === "all") {
+    const list = Object.entries(agents).map(([name, a]) => ({ name, addresses: a.addresses }));
+    if (self && !list.some((t) => t.name === self.name)) list.unshift(self);
+    if (!list.length) throw new Error("No agents are set up here. Run: npx -y paralith-mcp@latest setup");
+    return list;
+  }
+  if (agents[who]) return [{ name: who, addresses: agents[who].addresses }];
+  if (ID.test(who)) return [{ name: who, addresses: { ao: who } }];
+  throw new Error(`"${who}" is not an agent here (${Object.keys(agents).join(", ") || "none"}) or an AO address.`);
+}
+async function report({ name, addresses: a }) {
+  const { api } = await runtime();
+  const out = { agent: name, addresses: a };
+  const todo = [];
+  const gas = Object.fromEntries(await Promise.all(["base", "solana", "sui"].filter((c) => a[c]).map(async (c) => [c, await gasOf(c, a[c]).catch(() => "unreadable")])));
+  if (Object.keys(gas).length) out.gas = gas;
+  if (!a.ao) {
+    out.note = "AO key not derived yet: it appears once this agent's app has started the server.";
+    return out;
+  }
+  const [p, tokens, venues, redemptions] = await Promise.all([
+    api.readPlayer(a.ao).catch(() => null),
+    Promise.all(Object.entries({ rune: graph.processes.rune, pusd: graph.processes.pusd, ...graph.processes.elements }).map(async ([t, id]) => [t, await readAtoms(id, `balance-${a.ao}`).catch(() => 0n)])),
+    Promise.all(Object.entries(VENUES).map(async ([v, pid]) => [
+      v,
+      await api.readVenuePosition(pid, a.ao).catch(() => null),
+      await api.readVenueVaultPositions(pid, a.ao).catch(() => null)
+    ])),
+    readKey("pusd", "withdrawals").catch(() => null)
+  ]);
+  if (!p) {
+    out.game = { joined: false };
+    todo.push("Join the game (game_join).");
+  } else {
+    const raw = p.monsters?.[p.activeId] ?? p.collection?.[p.activeId];
+    const c = companion(raw);
+    out.game = {
+      faction: p.faction,
+      gold: p.gold,
+      rune: p.inventory?.rune ?? 0,
+      companion: c && { name: c.name, level: c.level, exp: c.exp, energy: c.energy, happiness: c.happiness },
+      arena: { wins: p.wins ?? 0, losses: p.losses ?? 0, rating: p.rating, sessionBattlesLeft: p.battlesRemaining ?? 0 },
+      ...p.battleFleet ? { inBattle: p.battleFleet.battleId } : {},
+      ...p.hunt ? { onHunt: p.hunt.runId } : {}
+    };
+    if (!p.dailyReadyAt || Number(p.dailyReadyAt) <= Date.now()) todo.push("Daily crate is ready (game_daily).");
+    if (count(p.lootboxes)) todo.push(`${count(p.lootboxes)} loot box(es) to open (game_lootbox).`);
+    if (raw && Number(raw.exp ?? 0) >= Number(raw.nextLevelExp ?? Infinity)) todo.push("Companion can level up (game_level_up).");
+    if (c && (c.energy < 25 || c.happiness < 25)) todo.push("Companion is below the arena's 25 energy/happiness: feed or play.");
+  }
+  const held = Object.fromEntries(tokens.filter(([, v]) => v > 0n).map(([t, v]) => [t, formatAtoms(v)]));
+  if (Object.keys(held).length) out.tokens = held;
+  const trading = {};
+  for (const [v, pos, vaults] of venues) {
+    const row = {};
+    if (pos?.orders?.length) row.openOrders = pos.orders.length;
+    if (pos?.fills?.length) row.recentFills = pos.fills.length;
+    const shares = Object.entries(vaults ?? {}).flatMap(([m, r]) => Object.entries(r).filter(([, x]) => BigInt(x?.shares ?? 0) > 0n).map(([s]) => `${m} ${s}`));
+    if (shares.length) row.vaults = shares;
+    if (Object.keys(row).length) trading[v] = row;
+  }
+  if (Object.keys(trading).length) out.trading = trading;
+  const pending = (redemptions ?? []).filter((w) => w.account === a.ao && w.status !== "released");
+  if (pending.length) out.bridge = { pendingRedemptions: pending.length };
+  if (Object.keys(gas).length && Object.values(gas).every((g) => /^0 /.test(g))) {
+    todo.push("No chain gas yet: fund an address above to bridge.");
+  }
+  if (todo.length) out.todo = todo;
+  return out;
+}
+function registerProgress(server) {
+  tool(
+    server,
+    "progress",
+    'How an agent is doing, in one free read: game (companion, Gold, Rune, arena record, live battle or hunt), tokens, open orders and vault shares on both venues, pending bridge redemptions, chain gas, and what needs doing next. who: omit for yourself, "all" for every agent set up on this machine, an agent name (claude, codex, grok) or an AO address.',
+    { who: z8.string().optional() },
+    async ({ who }) => {
+      const list = await Promise.all((await targets(who)).map(report));
+      return list.length === 1 ? list[0] : list;
+    },
+    READ
+  );
+}
+
 // src/build.mjs
 var DOCS = process.env.PARALITH_DOCS_URL || "https://docs.paralithmarkets.com";
 var INSTRUCTIONS = `Paralith on AO (HyperBEAM): Rune Realm (a companion game), two order books, and the PUSD bridge.
@@ -1715,7 +1879,26 @@ Vaults (pooled liquidity, one amm/active/grid per market): vault_list, vault_pos
 Rune: rune_move withdraw (game -> token) / deposit (token -> game). Bridge: bridge_balances, bridge_faucet, bridge_deposit, bridge_redeem.
 DAO (stake TEST-RUNE; a passed proposal may send one attached message): dao_info, dao_proposals, dao_stake stake/unstake/withdraw, dao_propose, dao_vote.
 
-To let the user SEE something (an arena fight as it happens, a companion, a hunt, a market's book and chart, a vault, a position, bridge transfers), call show: it returns a live link and displays inline where the client supports it.
+HOW RESOURCES FLOW. When asked for a resource, find its path here, check what you hold (progress), then say the route before acting.
+- Gold (in-game only, never leaves the game). Earn: companion play/quest/claim (capped at 60 Gold per 20 h), arena bot wins,
+  selling berries/Scrolls/Rune to the shop (game_shop sell) or on the game venue. Spend: arena stakes, shop buys, game-venue buys.
+- Berries and Scrolls. Get: joining, crates (game_daily, game_lootbox), buying with Gold (game_shop, or exchange_order venue "game").
+  Use: feed the companion, hunt escrow (2 of each berry), arena boosts; a Scroll plus 1-3 Rune for a hunt capture.
+- Rune exists twice: in-game Rune and the TEST-RUNE wallet token; rune_move converts 1:1 either way.
+  Get Rune: (1) the shop, only if game_shop quote shows an ask (it often only bids); (2) sell a companion on companion_market;
+  (3) the token route, which always works: element_claim (free daily, 1-10 of one element) -> exchange_order venue "token"
+  sell that element for TEST-RUNE -> rune_move deposit. Public TEST accounts accrue no Rune from game_daily (pass holders only).
+  Spend in-game Rune: game_level_up, hunt capture, companion_market buys. TEST-RUNE: token-venue buys, vaults, dao_stake.
+- Element tokens (TEST-EARTH/AIR/FIRE/WATER): element_claim daily; trade against TEST-RUNE on the token venue; vault liquidity.
+- PUSD: bridge in TEST-USDC from Base, Solana or Sui (needs that chain's gas, which the user funds; bridge_faucet gives TEST-USDC).
+  No PUSD market is listed yet. Redeeming back out needs a release claim this server cannot submit yet: say so rather than start it.
+- Vaults: deposit both sides of a market to earn from its strategy; withdraw with vault_shares.
+
+To report how you (or every agent set up on this machine) are doing, call progress (who: "all" for every agent); it also lists what needs doing next.
+
+SHOW IT. Watching beats reading: call show for anything worth seeing (a fight as it happens, the companion after a level-up, the book
+you are trading, a vault, a bridge transfer). It displays inline where the client supports it, otherwise it opens in the user's browser.
+Show once per thing, not once per round.
 
 Rules: if a tool says a write WAS accepted but unconfirmed, never resend it; re-read state instead.
 A refusal ({"error": ...}) costs nothing. Use game_catalog for exact costs and move stats; docs at ${DOCS}/llms-full.txt.`;
@@ -1723,7 +1906,7 @@ var READ_ONLY_NOTE = `This endpoint is READ-ONLY: it explains the protocol and r
 To play, trade or bridge, run the local server with a wallet phrase: ${DOCS}/ai/mcp`;
 function buildServer() {
   const server = new McpServer(
-    { name: "paralith", version: "0.2.0" },
+    { name: "paralith", version: "0.3.1" },
     { instructions: READ_ONLY ? `${READ_ONLY_NOTE}
 
 ${INSTRUCTIONS}` : INSTRUCTIONS }
@@ -1754,7 +1937,7 @@ ${INSTRUCTIONS}` : INSTRUCTIONS }
     server,
     "read_state",
     `Read any published key of any process, free: /<process>~process@1.0/now/<key>. process is an id or an alias (${Object.keys(PROCESS_ALIASES).join(", ")}). Returns null when absent.`,
-    { process: z8.string(), key: z8.string() },
+    { process: z9.string(), key: z9.string() },
     async ({ process: process2, key }) => readKey(process2, key),
     READ
   );
@@ -1763,10 +1946,10 @@ ${INSTRUCTIONS}` : INSTRUCTIONS }
     "send_message",
     "Escape hatch: sign and send a raw message to any process and return its reply. Prefer the specific tools; use this only for an action they do not cover. Tag values must be strings; never use a tag named Target.",
     {
-      process: z8.string(),
-      tags: z8.record(z8.string(), z8.string()).describe('e.g. {"Action": "Pass.Info"}'),
-      data: z8.string().optional(),
-      push_outbox: z8.boolean().optional().describe("Deliver the messages this one emits to other processes (e.g. a Transfer to a process).")
+      process: z9.string(),
+      tags: z9.record(z9.string(), z9.string()).describe('e.g. {"Action": "Pass.Info"}'),
+      data: z9.string().optional(),
+      push_outbox: z9.boolean().optional().describe("Deliver the messages this one emits to other processes (e.g. a Transfer to a process).")
     },
     async ({ process: process2, tags: tags2, data, push_outbox }) => {
       if (Object.keys(tags2).some((k) => k.toLowerCase() === "target")) throw new Error("Target is not a usable tag name.");
@@ -1796,6 +1979,7 @@ ${INSTRUCTIONS}` : INSTRUCTIONS }
   registerDao(server);
   registerVaults(server);
   registerShow(server);
+  registerProgress(server);
   return server;
 }