@lunardraw/agent 0.1.0 → 0.1.1

package/node_modules/@lunardraw/cli/dist/kit/directory.js

@@ -0,0 +1,55 @@
+/**
+ * Listing the agent in lunardraw.io's agent directory, if its owner opted in
+ * (`lunardraw-agent list`). Reports are signed with the agent wallet's key and
+ * carry its name, style and totals, never its numbers. See ../listing.ts.
+ */
+import { Starfall } from '@lunardraw/contract';
+import { agentReport, signedListing, VIAS, walletSigner } from '../listing.js';
+import { loadAgentState } from '../starfall-agent.js';
+import { DEFAULT_REGISTRY, kitPaths } from './home.js';
+const { DrawStatus } = Starfall;
+/** The chain view's draws as outcomes (numbers and prizes). */
+export const outcomesOf = (view) => view.draws.map((d) => ({
+    num: Number(d.id),
+    status: d.status === DrawStatus.voided ? 'void' : d.status === DrawStatus.settled ? 'settled' : d.status === DrawStatus.drawn ? 'drawn' : 'open',
+    ...(d.status === DrawStatus.drawn || d.status === DrawStatus.settled ? { numbers: d.numbers, moonball: d.moonball } : {}),
+    ...(d.status === DrawStatus.settled ? { prizes_star: d.prizes.map(Number) } : {}),
+}));
+/** Which AI an owner names (--via), checked. */
+export const viaOf = (v) => {
+    const via = (v ?? 'other').toLowerCase();
+    if (!VIAS.includes(via))
+        throw new Error(`--via must be one of ${VIAS.join(', ')}`);
+    return via;
+};
+/**
+ * Send a listing report (or remove the listing). `view` gives the draws'
+ * outcomes for the totals; without it, the totals count purchases only.
+ */
+export const sendListing = async (config, seed, action, o = {}) => {
+    const listing = o.listing ?? config.listing;
+    if (!listing)
+        throw new Error('this agent isn\'t listed: run `lunardraw-agent list --name <name>` first');
+    const state = loadAgentState(kitPaths(o.home, config.network).state);
+    const report = agentReport(state, o.view ? outcomesOf(o.view) : [], Date.now());
+    const signer = await walletSigner(seed, config.network);
+    const body = signedListing(signer, { network: config.network, action, name: listing.name, style: listing.style, via: viaOf(listing.via), ...report });
+    const url = `${(config.registry ?? DEFAULT_REGISTRY).replace(/\/$/, '')}/report`;
+    const r = await (o.fetcher ?? fetch)(url, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), signal: AbortSignal.timeout(20_000) });
+    const answer = (await r.json().catch(() => ({})));
+    if (!r.ok || !answer.ok)
+        throw new Error(`the directory refused it: ${answer.error ?? `HTTP ${r.status}`}`);
+    return answer.result ?? 'ok';
+};
+/** Best effort, for after a purchase or now and then: a failed report never stops play. */
+export const refreshListing = async (config, seed, o = {}) => {
+    if (!config.listing)
+        return;
+    try {
+        await sendListing(config, seed, 'list', o);
+    }
+    catch (err) {
+        o.log?.(`(couldn't update the directory listing: ${err instanceof Error ? err.message : String(err)})`);
+    }
+};
+//# sourceMappingURL=directory.js.map

package/node_modules/@lunardraw/cli/dist/kit/home.js

@@ -15,6 +15,8 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSy
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+/** Lunardraw's agent registry (the agent directory on lunardraw.io reads it). */
+export const DEFAULT_REGISTRY = 'https://207-180-249-120.sslip.io/agents';
 export const DEFAULT_CONFIG = { network: 'preprod', prover: 'hosted', limits: { perDraw: 25, perDay: 100 } };
 export const kitHome = () => process.env.LUNARDRAW_AGENT_HOME ?? join(homedir(), '.lunardraw-agent');
 export const kitPaths = (home = kitHome(), network = 'preprod') => ({
@@ -46,7 +48,10 @@ export const parseConfig = (raw) => {
     if (typeof prover !== 'string' || !(prover === 'hosted' || /^https?:\/\/\S+$/.test(prover) || /^local:\d+$/.test(prover))) {
         throw new Error('config.json: prover must be "hosted", a prover\'s https:// address, or "local:<port>"');
     }
-    return { network, prover, limits, ...(c.payTo ? { payTo: String(c.payTo) } : {}) };
+    const listing = c.listing && typeof c.listing === 'object' ? { name: String(c.listing.name ?? ''), style: String(c.listing.style ?? ''), via: String(c.listing.via ?? 'other') } : undefined;
+    if (c.registry !== undefined && (typeof c.registry !== 'string' || !/^https?:\/\/\S+$/.test(c.registry)))
+        throw new Error('config.json: registry must be an https:// address');
+    return { network, prover, limits, ...(c.payTo ? { payTo: String(c.payTo) } : {}), ...(listing ? { listing } : {}), ...(c.registry ? { registry: c.registry } : {}) };
 };
 export const loadConfig = (home = kitHome()) => {
     const path = kitPaths(home).config;

package/node_modules/@lunardraw/cli/dist/kit/main.js

@@ -18,6 +18,10 @@ export const KIT_USAGE = `lunardraw-agent: play Starfall, Lunardraw's lottery on
   lunardraw-agent play [--style mix|quickpick|lucky|moonhit|system] [--games <n>] [--numbers ... --moonball <n>]
                                                      keep playing every draw, within the limits
   lunardraw-agent limits                             the owner's spending limits (edit config.json to change)
+  lunardraw-agent list --name <name> [--style "<few words>"] [--via claude|gemini|openclaw|hermes|mcp|cli|other]
+                                                     show this agent in lunardraw.io's agent directory (its name, style
+                                                     and totals, signed by its wallet; never its numbers)
+  lunardraw-agent unlist                             take it out of the directory
   lunardraw-agent mcp                                run as an MCP server for your AI (Claude, Gemini, OpenClaw, Hermes...)
 
 --json prints machine-readable output (status, wallet, buy, tickets).
@@ -59,6 +63,8 @@ export const kit = async (argv) => {
             pick: { type: 'string' },
             sweep: { type: 'boolean', default: false },
             style: { type: 'string' },
+            name: { type: 'string' },
+            via: { type: 'string' },
             help: { type: 'boolean', default: false },
         },
     });
@@ -149,6 +155,10 @@ export const kit = async (argv) => {
                 throw new Error('no draw is on sale right now; the next opens on the hour');
             return withPlayer(config, seed, async (p) => {
                 const outcome = await p.buy(entries, (m) => p.session.logger.info(m));
+                if (outcome.bought && config.listing) {
+                    const { refreshListing } = await import('./directory.js');
+                    await refreshListing(config, seed, { view: (await readOverview(config).catch(() => undefined))?.view, log: (m) => process.stderr.write(m + '\n') });
+                }
                 if (values.json)
                     return json(outcome), outcome.bought === outcome.of ? 0 : 1;
                 if (outcome.bought) {
@@ -176,6 +186,10 @@ export const kit = async (argv) => {
                 p.tickets.forEach((t) => say(`    ${t}`));
             }
             say(`Spent in the last 24 hours: ${report.spentLast24h}.`);
+            if (config.listing && view) {
+                const { refreshListing } = await import('./directory.js');
+                await refreshListing(config, ensureWallet().seed, { view, log: (m) => process.stderr.write(m + '\n') });
+            }
             return 0;
         }
         case 'play': {
@@ -199,8 +213,45 @@ export const kit = async (argv) => {
                 ...(values.numbers ? ['--numbers', values.numbers] : []),
                 ...(values.moonball ? ['--moonball', values.moonball] : []),
             ];
+            if (config.listing) {
+                const { refreshListing } = await import('./directory.js');
+                const { readOverview } = await import('./player.js');
+                const seed = ensureWallet().seed;
+                const tick = async () => refreshListing(config, seed, { view: (await readOverview(config).catch(() => undefined))?.view });
+                void tick();
+                setInterval(() => void tick(), 30 * 60_000).unref();
+            }
             return starfall(args);
         }
+        case 'list': {
+            const { config, seed } = setup();
+            const name = values.name ?? config.listing?.name;
+            if (!name)
+                throw new Error('give the agent a name: lunardraw-agent list --name <name> (2-20 letters, digits, spaces, . _ -)');
+            const { sendListing, viaOf } = await import('./directory.js');
+            const { readOverview } = await import('./player.js');
+            const listing = { name, style: values.style ?? config.listing?.style ?? '', via: viaOf(values.via ?? config.listing?.via) };
+            const view = (await readOverview(config).catch(() => undefined))?.view;
+            const result = await sendListing(config, seed, 'list', { listing, view });
+            saveConfig({ ...config, listing }, kitHome());
+            say(`${result === 'listed' ? 'Listed' : 'Updated'}: ${name} is in the agent directory on https://lunardraw.io/agents/ (it updates after each purchase).`);
+            say('It shows the name, style and totals (draws, games, tNIGHT spent and won), never the numbers. `lunardraw-agent unlist` takes it out.');
+            return 0;
+        }
+        case 'unlist': {
+            const { config, seed } = setup();
+            if (!config.listing) {
+                say('This agent isn\'t listed.');
+                return 0;
+            }
+            const { sendListing } = await import('./directory.js');
+            await sendListing(config, seed, 'unlist');
+            const rest = { ...config };
+            delete rest.listing;
+            saveConfig(rest, kitHome());
+            say(`${config.listing.name} is out of the agent directory.`);
+            return 0;
+        }
         case 'mcp': {
             process.env.NIGHTCAST_LOG_FD = '2';
             const { mcpTools } = await import('./tools.js');

package/node_modules/@lunardraw/cli/dist/kit/mcp.js

@@ -12,7 +12,7 @@
  */
 import { createInterface } from 'node:readline';
 import { Starfall } from '@lunardraw/contract';
-export const SERVER_INFO = { name: 'lunardraw', title: 'Lunardraw', version: '0.1.0' };
+export const SERVER_INFO = { name: 'lunardraw', title: 'Lunardraw', version: '0.1.1' };
 const PROTOCOL_VERSIONS = ['2025-06-18', '2025-03-26', '2024-11-05'];
 export const INSTRUCTIONS = 'Lunardraw runs Starfall, a lottery on the Midnight Preprod test network (tNIGHT test tokens with no value). ' +
     'Draws close on the hour on Preprod. A game is 7 numbers from 1-35 plus a Moonball from 1-20 and costs 1.2 tNIGHT; prizes and refunds ' +

package/node_modules/@lunardraw/cli/dist/kit/setup.js

@@ -198,6 +198,31 @@ export const setup = async () => {
         say('  (Allow tool calls up to 15 minutes: the first purchase opens the wallet, then buys.)');
         say('ChatGPT and Grok can use any of these agents as the brain (OpenClaw and Hermes run GPT, Grok and Gemini models);');
         say("their own apps only reach MCP servers on the internet, which this one (holding your wallet) deliberately isn't.");
+        // the agent directory (opt in)
+        if (!config.listing && (await yes('\nShow your agent in the agent directory on lunardraw.io? It shows a name you choose and its totals, never its numbers.'))) {
+            const { NAME_RULE, VIAS } = await import('../listing.js');
+            let name = '';
+            while (!NAME_RULE.test(name)) {
+                name = (await rl.question('Its name (2-20 letters, digits, spaces, . _ -; Enter to skip): ')).trim();
+                if (!name)
+                    break;
+            }
+            if (name) {
+                const via = (await rl.question(`Which AI plays it? (${VIAS.join(', ')}) [other]: `)).trim().toLowerCase() || 'other';
+                const style = (await rl.question('Its style in a few words (optional, e.g. "Plays every night"): ')).trim().slice(0, 40);
+                try {
+                    const { sendListing, viaOf } = await import('./directory.js');
+                    const listing = { name, style, via: viaOf(via) };
+                    await sendListing(config, seed, 'list', { home, listing });
+                    config = { ...config, listing };
+                    saveConfig(config, home);
+                    say(`✓ ${name} is in the directory: https://lunardraw.io/agents/ (\`lunardraw-agent unlist\` takes it out).`);
+                }
+                catch (err) {
+                    say(`Couldn't list it now (${err instanceof Error ? err.message : String(err)}); try later with: lunardraw-agent list --name "${name}"`);
+                }
+            }
+        }
         // 4. sync
         step(4, 'sync the wallet');
         say('The wallet now reads the Preprod chain. The first time takes hours; leave this window open.');

package/node_modules/@lunardraw/cli/dist/kit/tools.js

@@ -7,6 +7,7 @@ import { loadAgentState } from '../starfall-agent.js';
 import { buyEntries } from '../starfall-commands.js';
 import { ensureWallet, hasBlockfrost, kitHome, kitPaths, loadConfig, useHome } from './home.js';
 import { BUY_SCHEMA, buyArgs } from './mcp.js';
+import { refreshListing } from './directory.js';
 import { readOverview, ticketsReport, withPlayer } from './player.js';
 const DIVISIONS = ['7 + Moonball', '7', '6 + Moonball', '6', '5 + Moonball', '4 + Moonball', '5', '3 + Moonball', '2 + Moonball'];
 export const mcpTools = () => {
@@ -44,6 +45,18 @@ export const mcpTools = () => {
     if (process.env.LUNARDRAW_AGENT_LAZY !== '1' && hasBlockfrost(kitHome(), config.network)) {
         setTimeout(() => void openPlayer(() => undefined).catch(() => undefined), 0).unref?.();
     }
+    // If the owner listed the agent in lunardraw.io's directory, keep it up to date
+    // (and shown as online) while the server runs, and after each purchase.
+    const listingTick = async () => {
+        if (!config.listing || !hasBlockfrost(kitHome(), config.network))
+            return;
+        const view = (await readOverview(config).catch(() => undefined))?.view;
+        await refreshListing(config, ensureWallet().seed, { view, log: (m) => process.stderr.write(m + '\n') });
+    };
+    if (config.listing) {
+        setTimeout(() => void listingTick(), 5_000).unref?.();
+        setInterval(() => void listingTick(), 30 * 60_000).unref?.();
+    }
     // keep the client informed during long calls
     const ticking = async (progress, what, work) => {
         const t = setInterval(() => progress(`${what}…`), 15_000);
@@ -109,6 +122,8 @@ export const mcpTools = () => {
                 const entries = buyEntries(buyArgs(args));
                 const p = await ticking(progress, 'opening the wallet', openPlayer(progress));
                 const outcome = await ticking(progress, 'buying', p.buy(entries, progress));
+                if (outcome.bought)
+                    void listingTick();
                 return { text: JSON.stringify(outcome, null, 2), isError: outcome.bought < outcome.of };
             },
         },

package/node_modules/@lunardraw/cli/dist/listing.js

@@ -0,0 +1,157 @@
+/**
+ * Agent listings for lunardraw.io's agent directory.
+ *
+ * An agent's owner can list it (opt in): the agent then reports its name,
+ * style and totals, signed with its wallet's unshielded key, so a listing can
+ * only come from the wallet it names. The totals are the agent's own record
+ * of what it bought (tickets are private on chain, so no one else can count
+ * them); prizes are counted from the drawn numbers and each division's
+ * published prize. The agent's numbers are never sent.
+ *
+ * Lunardraw's own agents (Nova, Orbit, Pixel on the keeper VM) are read by the
+ * registry from their state files directly, with the same `agentStats`.
+ */
+import { Starfall } from '@lunardraw/contract';
+export const emptyStats = () => ({ draws: 0, games: 0, spent_star: 0, winning_games: 0, won_star: 0 });
+/**
+ * The start of this week (Monday 00:00) or month (the 1st) on Brisbane time,
+ * UTC+10 all year: the leaderboard's periods.
+ */
+export const periodStart = (period, nowMs) => {
+    const OFFSET = 10 * 3_600_000;
+    const local = new Date(nowMs + OFFSET);
+    const y = local.getUTCFullYear();
+    const m = local.getUTCMonth();
+    const d = local.getUTCDate();
+    const startLocal = period === 'month' ? Date.UTC(y, m, 1) : Date.UTC(y, m, d) - ((local.getUTCDay() + 6) % 7) * 86_400_000;
+    return new Date(startLocal - OFFSET).toISOString();
+};
+/** An agent's totals from its own purchase record and the draws' outcomes (purchases from `since` on, if given). */
+export const agentStats = (state, draws, since) => {
+    const byNum = new Map(draws.map((d) => [d.num, d]));
+    const s = emptyStats();
+    const played = new Set();
+    for (const p of state.purchases) {
+        if (since && p.at < since)
+            continue;
+        const num = Number(p.draw);
+        const d = byNum.get(num);
+        if (d?.status === 'void')
+            continue; // refunded
+        played.add(num);
+        s.games += p.games;
+        s.spent_star += Number(p.cost);
+        s.last_draw = Math.max(s.last_draw ?? 0, num);
+        if (!s.first_played || p.at < s.first_played)
+            s.first_played = p.at;
+        if (!s.last_played || p.at > s.last_played)
+            s.last_played = p.at;
+        if (!d?.numbers || d.moonball === undefined || !d.numbers.some((n) => n > 0))
+            continue;
+        for (const e of p.entries) {
+            const won = Starfall.gamesByDivisionFor(e, d.numbers, d.moonball);
+            won.forEach((games, i) => {
+                if (!games)
+                    return;
+                s.winning_games += Number(games);
+                if (d.prizes_star?.[i])
+                    s.won_star += Number(games) * d.prizes_star[i];
+            });
+        }
+    }
+    s.draws = played.size;
+    return s;
+};
+/** Every draw the agent won something in (settled draws), newest first. */
+export const agentWins = (state, draws) => {
+    const byNum = new Map(draws.map((d) => [d.num, d]));
+    const perDraw = new Map();
+    for (const p of state.purchases) {
+        const num = Number(p.draw);
+        const d = byNum.get(num);
+        if (!d?.numbers || d.moonball === undefined || !d.prizes_star || d.status === 'void')
+            continue;
+        for (const e of p.entries) {
+            Starfall.gamesByDivisionFor(e, d.numbers, d.moonball).forEach((g, i) => {
+                if (!g)
+                    return;
+                const w = perDraw.get(num) ?? { draw: num, division: i + 1, games: 0, won_star: 0 };
+                w.division = Math.min(w.division, i + 1);
+                w.games += Number(g);
+                w.won_star += Number(g) * (d.prizes_star[i] ?? 0);
+                perDraw.set(num, w);
+            });
+        }
+    }
+    return [...perDraw.values()].sort((a, b) => b.draw - a.draw);
+};
+export const agentReport = (state, draws, nowMs) => {
+    const week = periodStart('week', nowMs);
+    const month = periodStart('month', nowMs);
+    return {
+        stats: agentStats(state, draws),
+        week: { ...agentStats(state, draws, week), since: week },
+        month: { ...agentStats(state, draws, month), since: month },
+        wins: agentWins(state, draws).slice(0, 20),
+    };
+};
+// ------------------------------------------------------------------ the signed listing
+export const LISTING_PREFIX = 'lunardraw-agent-listing\n';
+/** How an agent plays (for the directory's "via"). */
+export const VIAS = ['claude', 'gemini', 'openclaw', 'hermes', 'mcp', 'cli', 'other'];
+export const NAME_RULE = /^[A-Za-z0-9][A-Za-z0-9 ._-]{1,19}$/;
+/** Why a name, style or via can't be listed, or undefined. */
+export const listingProblem = (p) => {
+    if (!NAME_RULE.test(p.name))
+        return 'the name must be 2 to 20 letters, digits, spaces, dots, dashes or underscores, starting with a letter or digit';
+    if (p.style.length > 40 || /[\u0000-\u001f<>]/.test(p.style))
+        return 'the style must be up to 40 characters, with no < or >';
+    if (!VIAS.includes(p.via))
+        return `via must be one of ${VIAS.join(', ')}`;
+    return undefined;
+};
+/** The bytes that are signed: a fixed prefix and the payload exactly as sent. */
+export const listingMessage = (payload) => new TextEncoder().encode(LISTING_PREFIX + payload);
+/** A signed listing report, ready to POST to the registry. */
+export const signedListing = (signer, p, now = new Date()) => {
+    const problem = listingProblem(p);
+    if (problem)
+        throw new Error(problem);
+    const payload = JSON.stringify({
+        v: 1,
+        network: p.network,
+        key: signer.key,
+        action: p.action,
+        name: p.name,
+        style: p.style,
+        via: p.via,
+        stats: p.stats,
+        ...(p.week ? { week: p.week } : {}),
+        ...(p.month ? { month: p.month } : {}),
+        ...(p.wins ? { wins: p.wins } : {}),
+        at: now.toISOString(),
+    });
+    return { payload, signature: signer.sign(listingMessage(payload)) };
+};
+/**
+ * The agent's signer, from its wallet seed: the same key its unshielded
+ * address comes from (wallet-sdk's createKeystore: the unshielded seed is the
+ * signing key).
+ */
+export const walletSigner = async (seed, network) => {
+    const { WalletSeeds } = await import('@midnight-ntwrk/testkit-js');
+    const ledger = await import('@midnight-ntwrk/midnight-js-protocol/ledger');
+    const sk = Buffer.from(WalletSeeds.fromMasterSeed(seed).unshielded).toString('hex');
+    const key = ledger.signatureVerifyingKey(sk);
+    return {
+        key,
+        address: await bech32Address(ledger.addressFromKey(key), network),
+        sign: (data) => ledger.signData(sk, data),
+    };
+};
+/** mn_addr_... for a 32-byte address in hex. */
+export const bech32Address = async (hex, network) => {
+    const { UnshieldedAddress } = await import('@midnight-ntwrk/wallet-sdk-address-format');
+    return UnshieldedAddress.codec.encode(network, new UnshieldedAddress(Buffer.from(hex, 'hex'))).asString();
+};
+//# sourceMappingURL=listing.js.map

package/node_modules/@lunardraw/cli/dist/registry-main.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+/**
+ * `./lunardraw registry`: the agent directory's registry (see registry.ts),
+ * run as lunardraw-registry.service on the keeper VM, behind Caddy.
+ *
+ *   ./lunardraw registry --network preprod --port 6310 \
+ *     --dir /root/lunardraw-registry --feed /root/lunardraw-feed/feed.json --house /root/lunardraw-agents
+ */
+import { parseArgs } from 'node:util';
+import { createRegistry, ledgerVerifier, serveRegistry } from './registry.js';
+const main = async () => {
+    const { values } = parseArgs({
+        args: process.argv.slice(2),
+        options: {
+            network: { type: 'string', default: 'preprod' },
+            port: { type: 'string', default: '6310' },
+            host: { type: 'string', default: '127.0.0.1' },
+            dir: { type: 'string', default: '/root/lunardraw-registry' },
+            feed: { type: 'string', default: '/root/lunardraw-feed/feed.json' },
+            house: { type: 'string', default: '/root/lunardraw-agents' },
+            help: { type: 'boolean', default: false },
+        },
+    });
+    if (values.help) {
+        process.stdout.write('./lunardraw registry [--network preprod] [--port 6310] [--dir <listings>] [--feed <feed.json>] [--house <agents folder>]\n');
+        return 0;
+    }
+    const log = (m) => process.stdout.write(`${new Date().toISOString()} ${m}\n`);
+    const registry = createRegistry({ network: values.network, dir: values.dir, feedPath: values.feed, houseDir: values.house, verifier: await ledgerVerifier(values.network) });
+    serveRegistry(registry, Number(values.port), values.host, log);
+    log(`agent registry for ${values.network} on ${values.host}:${values.port}`);
+    await new Promise(() => undefined);
+    return 0;
+};
+main().then((code) => process.exit(code), (err) => {
+    process.stderr.write(`${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+});
+//# sourceMappingURL=registry-main.js.map

package/node_modules/@lunardraw/cli/dist/registry.js

@@ -0,0 +1,331 @@
+/**
+ * The agent registry behind lunardraw.io's agent directory (`./lunardraw
+ * registry`, run on the keeper VM behind Caddy).
+ *
+ * - Lunardraw's own agents (the `lunardraw-agent@<name>` services) are read
+ *   from their state files and the feed: real purchases, real results.
+ * - Anyone else's agent is listed when its owner opts in: the agent kit sends
+ *   a report signed with the agent wallet's key (listing.ts). The registry
+ *   checks the signature, that it is recent, and that the name isn't taken.
+ *
+ * GET  /agents/agents.json  the directory (what the website shows)
+ * POST /agents/report       a signed listing report ({ payload, signature })
+ * GET  /agents/health       ok
+ */
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, writeFileSync } from 'node:fs';
+import { createServer } from 'node:http';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+import { agentReport, emptyStats, LISTING_PREFIX, listingProblem, periodStart } from './listing.js';
+import { loadAgentState } from './starfall-agent.js';
+const STYLES = {
+    mix: 'A bit of everything',
+    quickpick: 'QuickPicks',
+    lucky: 'Same numbers every draw',
+    moonhit: 'Every Moonball',
+    system: 'System entries',
+};
+const run = promisify(execFile);
+export const systemdActive = async (unit) => {
+    try {
+        const { stdout } = await run('systemctl', ['is-active', unit]);
+        return stdout.trim() === 'active';
+    }
+    catch {
+        return false;
+    }
+};
+const slug = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+const HOUR = 3_600_000;
+/** online: played or reported in the last 2 hours; idle: in the last 2 days; else offline. */
+const statusOf = (lastSeenMs, now) => lastSeenMs === undefined ? 'offline' : now - lastSeenMs < 2 * HOUR ? 'online' : now - lastSeenMs < 48 * HOUR ? 'idle' : 'offline';
+export const createRegistry = (o) => {
+    const now = o.now ?? Date.now;
+    const isActive = o.isActive ?? systemdActive;
+    const storePath = join(o.dir, 'listings.json');
+    const maxListed = o.maxListed ?? 500;
+    const lastReport = new Map();
+    const load = () => {
+        try {
+            const s = JSON.parse(readFileSync(storePath, 'utf8'));
+            return { listed: s.listed ?? {}, events: s.events ?? [], hidden: s.hidden ?? [] };
+        }
+        catch {
+            return { listed: {}, events: [], hidden: [] };
+        }
+    };
+    const save = (s) => {
+        mkdirSync(o.dir, { recursive: true });
+        writeFileSync(`${storePath}.tmp`, JSON.stringify(s, null, 2) + '\n');
+        renameSync(`${storePath}.tmp`, storePath);
+    };
+    const draws = () => {
+        try {
+            const feed = JSON.parse(readFileSync(o.feedPath, 'utf8'));
+            return feed.games?.starfall?.draws ?? [];
+        }
+        catch {
+            return [];
+        }
+    };
+    const house = async (outcomes) => {
+        if (!existsSync(o.houseDir))
+            return { agents: [], events: [], wins: [] };
+        const names = readdirSync(o.houseDir)
+            .filter((f) => f.endsWith('.env'))
+            .map((f) => f.slice(0, -4))
+            .filter((n) => /^[a-z0-9-]+$/.test(n));
+        const agents = [];
+        const events = [];
+        const wins = [];
+        for (const n of names) {
+            const statePath = join(o.houseDir, `${n}.state.json`);
+            const state = loadAgentState(statePath);
+            const env = readFileSync(join(o.houseDir, `${n}.env`), 'utf8');
+            const style = /--style\s+(\w+)/.exec(env)?.[1] ?? 'mix';
+            const r = agentReport(state, outcomes, now());
+            const stats = r.stats;
+            const active = await isActive(`lunardraw-agent@${n}`);
+            const seen = existsSync(statePath) ? statSync(statePath).mtimeMs : undefined;
+            const name = n.toUpperCase();
+            agents.push({
+                id: slug(n),
+                name,
+                via: 'lunardraw',
+                house: true,
+                status: active ? 'online' : statusOf(seen, now()) === 'online' ? 'idle' : 'offline',
+                style: STYLES[style] ?? style,
+                stats,
+                week: strip(r.week),
+                month: strip(r.month),
+                joined: stats.first_played,
+                last_seen: seen ? new Date(seen).toISOString() : undefined,
+            });
+            for (const p of state.purchases.slice(-10)) {
+                events.push({ at: p.at, agent: name, text: `bought ${p.games} game${p.games === 1 ? '' : 's'} in draw ${p.draw}` });
+            }
+            for (const w of r.wins)
+                wins.push({ ...w, agent: name });
+        }
+        return { agents, events, wins };
+    };
+    /** The directory: house agents first in ties, then by tNIGHT won, winning games, games. */
+    const directory = async () => {
+        const outcomes = draws();
+        const h = await house(outcomes);
+        const s = load();
+        const t = now();
+        const weekStart = periodStart('week', t);
+        const monthStart = periodStart('month', t);
+        const listed = Object.values(s.listed)
+            .filter((l) => !s.hidden.includes(l.address) && !s.hidden.includes(slug(l.name)))
+            .map((l) => ({
+            id: slug(l.name),
+            name: l.name,
+            via: l.via,
+            house: false,
+            status: statusOf(Date.parse(l.last_seen), t),
+            style: l.style,
+            stats: l.stats,
+            week: l.week?.since === weekStart ? strip(l.week) : emptyStats(),
+            month: l.month?.since === monthStart ? strip(l.month) : emptyStats(),
+            joined: l.joined,
+            last_seen: l.last_seen,
+            address: l.address,
+        }));
+        const agents = [...h.agents, ...listed].sort((a, b) => b.stats.won_star - a.stats.won_star || b.stats.winning_games - a.stats.winning_games || b.stats.games - a.stats.games || Number(b.house) - Number(a.house));
+        const shown = new Set(listed.map((a) => a.name));
+        const events = [...h.events, ...s.events.filter((e) => shown.has(e.agent))].sort((a, b) => (a.at < b.at ? 1 : -1)).slice(0, 30);
+        const drawnAt = new Map(outcomes.map((d) => [d.num, d.drawn_at]));
+        const listedWins = Object.values(s.listed)
+            .filter((l) => shown.has(l.name))
+            .flatMap((l) => (l.wins ?? []).map((w) => ({ ...w, agent: l.name })));
+        const wins = [...h.wins, ...listedWins]
+            .filter((w) => w.won_star > 0)
+            .map((w) => ({ ...w, drawn_at: drawnAt.get(w.draw) }))
+            .sort((a, b) => b.won_star - a.won_star || b.draw - a.draw)
+            .slice(0, 20);
+        return { schema: 'lunardraw-agents/1', network: o.network, generated_at: new Date(t).toISOString(), agents, events, wins };
+    };
+    /** Check and apply a signed report; returns a message, or throws with the reason it was refused. */
+    const report = async (body) => {
+        const b = body;
+        if (typeof b?.payload !== 'string' || typeof b.signature !== 'string' || b.payload.length > 12_000)
+            throw new Refused('expected { payload, signature }');
+        let p;
+        try {
+            p = JSON.parse(b.payload);
+        }
+        catch {
+            throw new Refused('the payload is not JSON');
+        }
+        if (p.v !== 1 || typeof p.key !== 'string' || !/^[0-9a-f]{40,200}$/i.test(p.key))
+            throw new Refused('unknown payload version or key');
+        if (p.network !== o.network)
+            throw new Refused(`this registry is for ${o.network}`);
+        const at = Date.parse(p.at);
+        if (!Number.isFinite(at) || Math.abs(now() - at) > 10 * 60_000)
+            throw new Refused('the report is more than 10 minutes old (or from the future): check the clock');
+        if (!o.verifier.verify(p.key, new TextEncoder().encode(LISTING_PREFIX + b.payload), b.signature))
+            throw new Refused("the signature doesn't match the key");
+        const address = await o.verifier.address(p.key);
+        const last = lastReport.get(address);
+        if (last !== undefined && now() - last < 30_000)
+            throw new Refused('too many reports: one every 30 seconds');
+        lastReport.set(address, now());
+        const s = load();
+        if (p.action === 'unlist') {
+            delete s.listed[address];
+            save(s);
+            return 'unlisted';
+        }
+        if (p.action !== 'list')
+            throw new Refused('action must be list or unlist');
+        const problem = listingProblem(p);
+        if (problem)
+            throw new Refused(problem);
+        const stats = cleanStats(p.stats);
+        const period = (x) => {
+            const since = x?.since;
+            return typeof since === 'string' && Number.isFinite(Date.parse(since)) ? { ...cleanStats(x), since: new Date(since).toISOString() } : undefined;
+        };
+        const wins = Array.isArray(p.wins) ? p.wins.slice(0, 20).map(cleanWin).filter((w) => w !== undefined) : [];
+        const houseNames = existsSync(o.houseDir) ? readdirSync(o.houseDir).filter((f) => f.endsWith('.env')).map((f) => slug(f.slice(0, -4))) : [];
+        const taken = Object.values(s.listed).find((l) => slug(l.name) === slug(p.name) && l.address !== address);
+        if (taken || houseNames.includes(slug(p.name)))
+            throw new Refused(`the name ${p.name} is taken: choose another`);
+        const before = s.listed[address];
+        if (!before && Object.keys(s.listed).length >= maxListed)
+            throw new Refused('the directory is full for now');
+        const iso = new Date(now()).toISOString();
+        s.listed[address] = { address, key: p.key, name: p.name, style: p.style, via: p.via, stats, week: period(p.week), month: period(p.month), wins, joined: before?.joined ?? iso, last_seen: iso };
+        // what changed, for the activity panel
+        if (!before)
+            s.events.push({ at: iso, agent: p.name, text: 'joined the directory' });
+        else {
+            if (stats.games > before.stats.games && stats.last_draw)
+                s.events.push({ at: iso, agent: p.name, text: `bought ${stats.games - before.stats.games} game${stats.games - before.stats.games === 1 ? '' : 's'} in draw ${stats.last_draw}` });
+            if (stats.won_star > before.stats.won_star)
+                s.events.push({ at: iso, agent: p.name, text: `won ${(stats.won_star - before.stats.won_star) / 1e6} tNIGHT` });
+        }
+        s.events = s.events.slice(-200);
+        save(s);
+        return before ? 'updated' : 'listed';
+    };
+    return { directory, report };
+};
+export class Refused extends Error {
+}
+const strip = (x) => {
+    const { since: _since, ...rest } = x;
+    return rest;
+};
+const cleanWin = (x) => {
+    const w = (x ?? {});
+    const int = (v, lo, hi) => (typeof v === 'number' && Number.isInteger(v) && v >= lo && v <= hi ? v : undefined);
+    const draw = int(w.draw, 1, 1e9);
+    const division = int(w.division, 1, 9);
+    const games = int(w.games, 1, 1e6);
+    const won = int(w.won_star, 0, 1e15);
+    return draw && division && games && won !== undefined ? { draw, division, games, won_star: won } : undefined;
+};
+const cleanStats = (x) => {
+    const s = (x ?? {});
+    const n = (v, max) => (typeof v === 'number' && Number.isFinite(v) && v >= 0 ? Math.min(Math.floor(v), max) : 0);
+    const iso = (v) => (typeof v === 'string' && Number.isFinite(Date.parse(v)) ? new Date(v).toISOString() : undefined);
+    const out = {
+        ...emptyStats(),
+        draws: n(s.draws, 1e6),
+        games: n(s.games, 1e9),
+        spent_star: n(s.spent_star, 1e15),
+        winning_games: n(s.winning_games, 1e9),
+        won_star: n(s.won_star, 1e15),
+    };
+    const last = n(s.last_draw, 1e9);
+    if (last)
+        out.last_draw = last;
+    const first = iso(s.first_played);
+    const lastPlayed = iso(s.last_played);
+    if (first)
+        out.first_played = first;
+    if (lastPlayed)
+        out.last_played = lastPlayed;
+    return out;
+};
+/** Midnight's signature check (ledger-v8): the key, the signature, and the address it makes. */
+export const ledgerVerifier = async (network) => {
+    const ledger = await import('@midnight-ntwrk/midnight-js-protocol/ledger');
+    const { bech32Address } = await import('./listing.js');
+    return {
+        verify: (key, data, signature) => {
+            try {
+                return ledger.verifySignature(key, data, signature);
+            }
+            catch {
+                return false;
+            }
+        },
+        address: (key) => bech32Address(ledger.addressFromKey(key), network),
+    };
+};
+/** Serve the registry over HTTP (behind Caddy, on 127.0.0.1). */
+export const serveRegistry = (registry, port, host = '127.0.0.1', log = () => undefined) => {
+    let cached;
+    const send = (res, code, body, type = 'application/json') => {
+        res.writeHead(code, { 'content-type': type, 'cache-control': code === 200 ? 'public, max-age=30' : 'no-store', 'access-control-allow-origin': '*' });
+        res.end(body);
+    };
+    const server = createServer(async (req, res) => {
+        try {
+            const url = new URL(req.url ?? '/', 'http://x');
+            if (req.method === 'GET' && url.pathname === '/agents/health')
+                return send(res, 200, '{"ok":true}');
+            if (req.method === 'GET' && url.pathname === '/agents/agents.json') {
+                if (!cached || Date.now() - cached.at > 30_000)
+                    cached = { at: Date.now(), body: JSON.stringify(await registry.directory(), null, 1) };
+                return send(res, 200, cached.body);
+            }
+            if (req.method === 'OPTIONS') {
+                res.writeHead(204, { 'access-control-allow-origin': '*', 'access-control-allow-methods': 'GET, POST', 'access-control-allow-headers': 'content-type' });
+                return res.end();
+            }
+            if (req.method === 'POST' && url.pathname === '/agents/report') {
+                const chunks = [];
+                let size = 0;
+                for await (const c of req) {
+                    size += c.length;
+                    if (size > 16_384)
+                        return send(res, 413, '{"error":"too large"}');
+                    chunks.push(c);
+                }
+                let body;
+                try {
+                    body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                }
+                catch {
+                    return send(res, 400, '{"error":"not JSON"}');
+                }
+                try {
+                    const result = await registry.report(body);
+                    cached = undefined;
+                    log(`report: ${result}`);
+                    return send(res, 200, JSON.stringify({ ok: true, result }));
+                }
+                catch (err) {
+                    if (err instanceof Refused)
+                        return send(res, 400, JSON.stringify({ error: err.message }));
+                    throw err;
+                }
+            }
+            return send(res, 404, '{"error":"not found"}');
+        }
+        catch (err) {
+            log(`error: ${err instanceof Error ? err.message : String(err)}`);
+            return send(res, 500, '{"error":"internal"}');
+        }
+    });
+    server.listen(port, host);
+    return server;
+};
+//# sourceMappingURL=registry.js.map

package/node_modules/@lunardraw/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunardraw/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Run Lunardraw on Midnight: deploy the Starfall contract locked, activate the oracle key, run the keeper and the draw oracle, and check a deployment.",
   "license": "MIT",
   "private": true,
@@ -14,9 +14,9 @@
     "dist"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/main.js dist/monitor-main.js dist/kit-main.js",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && chmod +x dist/main.js dist/monitor-main.js dist/kit-main.js dist/registry-main.js",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "vitest run src/test/offline.test.ts src/test/starfall-offline.test.ts src/test/dust-wait.test.ts src/test/sync-watch.test.ts src/test/starfall-agent.test.ts src/test/silence-watchdog.test.ts src/test/wait-for-tip.test.ts src/test/fresh-fees.test.ts src/test/dust-time.test.ts src/test/tx-backfill.test.ts src/test/wallet-lock.test.ts src/test/monitor.test.ts src/test/hosted-prover.test.ts src/test/kit.test.ts",
+    "test": "vitest run src/test/offline.test.ts src/test/starfall-offline.test.ts src/test/dust-wait.test.ts src/test/sync-watch.test.ts src/test/starfall-agent.test.ts src/test/silence-watchdog.test.ts src/test/wait-for-tip.test.ts src/test/fresh-fees.test.ts src/test/dust-time.test.ts src/test/tx-backfill.test.ts src/test/wallet-lock.test.ts src/test/monitor.test.ts src/test/hosted-prover.test.ts src/test/kit.test.ts src/test/registry.test.ts",
     "test:e2e": "LUNARDRAW_E2E=1 vitest run src/test/e2e.test.ts src/test/starfall-e2e.test.ts"
   },
   "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunardraw/agent",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Play Starfall, Lunardraw's lottery on the Midnight Preprod test network, from an AI agent's own wallet: a command line and an MCP server for any AI that runs local tools (Claude, Gemini CLI, OpenClaw, Hermes and more). Test tokens only.",
   "keywords": [
     "lunardraw",
@@ -48,7 +48,7 @@
     "@nightcast/deploy": "0.1.0",
     "@lunardraw/contract": "0.1.0",
     "@lunardraw/keeper": "0.1.0",
-    "@lunardraw/cli": "0.1.0"
+    "@lunardraw/cli": "0.1.1"
   },
   "bundleDependencies": true,
   "publishConfig": {