pog-mcp 0.1.0

package/dist/wallet.js

@@ -0,0 +1,562 @@
+/**
+ * wallet — BIP39 mnemonic ⇄ Solana keypair, plus SIWS message signing.
+ *
+ * SIWS is the single biggest barrier to an agent playing: the game's API needs an
+ * ed25519 signature from a Solana keypair, and most agents have neither. Owning a
+ * wallet here is what lets `login` be one tool call instead of a crypto tutorial.
+ *
+ * DERIVATION MUST MATCH THE BROWSER WALLET.
+ * SLIP-0010 ed25519 on m/44'/501'/0'/0' — the path Phantom/Solflare use for
+ * account 0 — mirroring `packages/web/src/wallets/solanaMnemonic.ts`. Two copies
+ * exist because @sws26/shared is deliberately dependency-free and this needs
+ * crypto libraries; `__tests__/derivation.test.ts` pins both against the same
+ * fixed vectors so a change to either side fails loudly. Getting this wrong does
+ * not throw — it silently yields a DIFFERENT address, stranding whatever the
+ * agent owned.
+ *
+ * Unlike the browser wallet this uses @noble/curves directly rather than
+ * @solana/web3.js: the only operations needed are "public key from seed" and
+ * "sign bytes", and pulling in web3.js for that would add a large dependency to
+ * a stdio process that never touches an RPC.
+ */
+import { chmodSync, closeSync, existsSync, fsyncSync, openSync, writeSync, linkSync, lstatSync, mkdirSync, readFileSync, realpathSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { randomBytes } from 'node:crypto';
+import { homedir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { ed25519 } from '@noble/curves/ed25519';
+import { hmac } from '@noble/hashes/hmac';
+import { sha512 } from '@noble/hashes/sha512';
+import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+import bs58 from 'bs58';
+/** m/44'/501'/0'/0' — Solana (coin type 501), account 0, all segments hardened. */
+const SOLANA_DERIVATION = [44, 501, 0, 0];
+function hmac512(key, data) {
+    return hmac(sha512, key, data);
+}
+function masterNode(seed) {
+    const i = hmac512(new TextEncoder().encode('ed25519 seed'), seed);
+    return { key: i.slice(0, 32), chainCode: i.slice(32) };
+}
+/** ed25519 SLIP-0010 supports hardened derivation only. */
+function deriveHardened(node, index) {
+    const hardened = (index | 0x80000000) >>> 0;
+    const data = new Uint8Array(37);
+    data[0] = 0x00;
+    data.set(node.key, 1);
+    data[33] = (hardened >>> 24) & 0xff;
+    data[34] = (hardened >>> 16) & 0xff;
+    data[35] = (hardened >>> 8) & 0xff;
+    data[36] = hardened & 0xff;
+    const i = hmac512(node.chainCode, data);
+    return { key: i.slice(0, 32), chainCode: i.slice(32) };
+}
+/** The 32-byte ed25519 private seed for a mnemonic. */
+export function seedFromMnemonic(mnemonic) {
+    let node = masterNode(mnemonicToSeedSync(mnemonic, ''));
+    for (const index of SOLANA_DERIVATION)
+        node = deriveHardened(node, index);
+    return node.key;
+}
+/** Base58 Solana address for a mnemonic. */
+export function addressFromMnemonic(mnemonic) {
+    return bs58.encode(ed25519.getPublicKey(seedFromMnemonic(mnemonic)));
+}
+/** Sign raw UTF-8 message bytes; returns a base58 signature, as the API expects. */
+export function signMessage(mnemonic, message) {
+    const bytes = new TextEncoder().encode(message);
+    return bs58.encode(ed25519.sign(bytes, seedFromMnemonic(mnemonic)));
+}
+/** Generate a fresh 12-word (128-bit) English mnemonic. */
+export function newMnemonic() {
+    return generateMnemonic(wordlist, 128);
+}
+/** True when `mnemonic` is a valid BIP39 English phrase. */
+export function isValidMnemonic(mnemonic) {
+    return validateMnemonic(mnemonic, wordlist);
+}
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+/**
+ * Where the recovery phrase lives.
+ *
+ * A file, not an env var: the agent must come back as the SAME manager across
+ * restarts or it loses its squad, its record, and anything it owns on-chain.
+ * `POG_MCP_WALLET_FILE` overrides it so one machine can run several agents.
+ */
+export function walletFilePath(env = process.env) {
+    return env['POG_MCP_WALLET_FILE'] ?? join(homedir(), '.pog-mcp', 'wallet.json');
+}
+/** Read the stored wallet, or null when this machine has none yet. */
+/**
+ * Read the stored wallet, or null if the file is missing or not a usable record.
+ *
+ * "Usable" includes the address AGREEING with the mnemonic. A file with a valid
+ * phrase but a missing or wrong address used to be accepted, and then `login`
+ * requested a nonce for `undefined` — or for an address this key cannot sign
+ * for — so the sign-in failed with no hint that the file was the problem, and
+ * the corrupt-file refusal never fired.
+ */
+export function readWallet(path = walletFilePath()) {
+    try {
+        // What KIND of thing is there, before opening it.
+        //
+        // readFileSync on a FIFO blocks until somebody writes — forever, if nobody
+        // does — and this process speaks MCP over stdio, so a hung read is a hung
+        // agent with no error to catch. Another local user who can create the
+        // configured path can leave one there. A symlink is refused for the reason
+        // the directory walk refuses them: its owner chooses where the read lands.
+        // The directory checks cannot help here; they run after a wallet has
+        // already been parsed.
+        // Unconditional: lstat and isFile mean the same thing on Windows, and a
+        // junction or named pipe there is no more readable than a symlink or FIFO
+        // here. The reason for the check is portable even though FIFOs are not.
+        if (!lstatSync(path).isFile())
+            return null;
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const { mnemonic, address } = parsed;
+        if (typeof mnemonic !== 'string' || !isValidMnemonic(mnemonic))
+            return null;
+        if (typeof address !== 'string' || address !== addressFromMnemonic(mnemonic))
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The one way an EXISTING wallet gets returned.
+ *
+ * There are three doors onto the same file — the import that matches what is
+ * already stored, the ordinary start with no import, and losing the creation
+ * race to another process — and securing one of them secured only one of them.
+ * A phrase readable by every local user is just as exposed whichever door the
+ * caller came through, so the checks live here instead of at the returns.
+ */
+function acceptExisting(wallet, path) {
+    assertDirectoryIsSafe(dirname(path));
+    ensurePrivate(path, 0o600);
+    return { wallet, created: false };
+}
+/**
+ * What we can and cannot check on Windows.
+ *
+ * Every guard below is POSIX: mode bits, uid, sticky. Windows has none of them —
+ * chmod is close to a no-op there and privacy is an ACL, which Node cannot read.
+ * So they all returned early, and a wallet in a shared directory got no
+ * protection at all while the code looked like it was protecting one.
+ *
+ * The one thing that IS knowable without ACL APIs is WHERE the file is. A path
+ * under the user's profile inherits that profile's ACL, which Windows makes
+ * private by default — that covers the default location and anybody who kept it.
+ * Outside the profile — C:\\Temp, a network share, a machine-wide folder — we
+ * genuinely cannot tell, so it is refused rather than silently trusted. A real
+ * key deserves the fail-closed answer, not the convenient one.
+ */
+function assertWindowsPathIsPrivate(target) {
+    const home = resolve(homedir());
+    const path = resolve(target);
+    if (path === home || path.startsWith(home + sep))
+        return;
+    throw new Error(`${target} is outside your user profile (${home}), and on Windows this cannot be checked ` +
+        'for privacy — file permissions there are ACLs, which nothing here can read, so a ' +
+        'wallet placed in a shared folder would be readable by other users with no sign of it. ' +
+        'Leave POG_MCP_WALLET_FILE unset to use the default under your profile, or point it ' +
+        'somewhere inside it.');
+}
+/**
+ * A directory is checked, never changed.
+ *
+ * Tightening it was a worse bug than the one it fixed: POG_MCP_WALLET_FILE can
+ * point straight into a shared directory — /tmp/pog-wallet.json in a container,
+ * ./wallet.json in a checkout — and chmod 0700 there locks every other user and
+ * service out of /tmp or the workspace. That directory is not ours to change.
+ *
+ * What actually endangers the wallet is somebody else being able to REPLACE it,
+ * which needs write permission on the directory. Readable is fine: the file
+ * itself is 0600, so listing the name gives nothing. And a world-writable
+ * directory with the sticky bit — /tmp is 1777 — cannot be used to unlink
+ * another user's file, which is exactly what the sticky bit is for. So the test
+ * is write-without-sticky, and the answer to it is to refuse and say what to do,
+ * not to reach into a directory somebody else is using.
+ */
+function assertDirectoryIsSafe(dir) {
+    if (process.platform === 'win32')
+        return assertWindowsPathIsPrivate(dir);
+    if (typeof process.getuid !== 'function')
+        return;
+    const me = process.getuid();
+    // EVERY component, not just the last one.
+    //
+    // A path is only as trustworthy as the way in. `/tmp/mine/wallet.json` can
+    // have a perfectly good `mine` while `/tmp/mine` is a symlink somebody else
+    // owns, or while an ancestor is world-writable — either lets another user
+    // rename or retarget a link and send the next start somewhere new. It creates
+    // a wallet there, and the squad and assets stay with a phrase nothing points
+    // at any more. statSync also FOLLOWS links, so checking the target said
+    // nothing about who controls the pointer.
+    for (const component of ancestors(dir)) {
+        let link;
+        try {
+            link = lstatSync(component);
+        }
+        catch {
+            continue; // Not there yet — mkdir is about to create it, at 0700.
+        }
+        const ownerIsTrusted = link.uid === me || link.uid === 0;
+        if (link.isSymbolicLink()) {
+            // Root-owned links are how the system is built: /tmp -> /private/tmp on
+            // macOS is one, and refusing those would refuse the documented setup.
+            if (!ownerIsTrusted) {
+                throw new Error(`${component} is a symlink owned by uid ${String(link.uid)}, not by this process ` +
+                    `(uid ${String(me)}). Whoever owns it can point it somewhere else at any time, and ` +
+                    'the next start would make a new wallet there while the squad and assets stay with ' +
+                    'the phrase this one holds. Point POG_MCP_WALLET_FILE somewhere no other user is in ' +
+                    'the path.');
+            }
+            continue; // Its target is checked on the next iteration via realpath below.
+        }
+        if (!ownerIsTrusted && (link.mode & 0o200) !== 0) {
+            throw new Error(`${component} is owned by uid ${String(link.uid)}, not by this process ` +
+                `(uid ${String(me)}), and that owner can delete or move what is inside it whatever ` +
+                'the permissions say. The next start would then generate a different key while the ' +
+                'squad and assets stay with the phrase that vanished. Point POG_MCP_WALLET_FILE at a ' +
+                'path you own the whole way down.');
+        }
+        // Sticky is not a blanket pass. POSIX lets the DIRECTORY's owner unlink any
+        // entry in it, sticky or not — so a sticky directory belonging to another
+        // ordinary user still lets that user delete the only copy of this phrase.
+        // The exception exists for /tmp, which root owns; keep it to that shape.
+        const groupOrOtherWritable = (link.mode & 0o022) !== 0;
+        const sticky = (link.mode & 0o1000) !== 0;
+        if (groupOrOtherWritable && !(sticky && ownerIsTrusted)) {
+            throw new Error(`${component} is writable by other users, so someone there can replace or delete the ` +
+                'wallet below it — and the phrase you have would stop being the one this agent plays ' +
+                'as, with nothing left to recover from. ' +
+                'Refusing rather than changing a directory that is not ours to change: point ' +
+                'POG_MCP_WALLET_FILE at a private directory (the default ~/.pog-mcp is created 0700), ' +
+                `or tighten ${component} yourself if it really is only yours.`);
+        }
+    }
+}
+/**
+ * Every path component from the root down to `dir`, links resolved.
+ *
+ * Both spellings matter: the literal path is where the SYMLINKS live (and their
+ * owners are the ones who can retarget them), and the resolved path is where
+ * the real directories are. Checking one and not the other leaves the other as
+ * the way in.
+ */
+function ancestors(dir) {
+    const seen = new Set();
+    const out = [];
+    for (const start of [dir, safeRealpath(dir)]) {
+        let current = resolve(start);
+        const chain = [];
+        for (;;) {
+            if (!seen.has(current)) {
+                seen.add(current);
+                chain.push(current);
+            }
+            const parent = dirname(current);
+            if (parent === current)
+                break;
+            current = parent;
+        }
+        // Root first, so a failure names the outermost thing that is wrong.
+        out.push(...chain.reverse());
+    }
+    return out;
+}
+function safeRealpath(dir) {
+    try {
+        return realpathSync(dir);
+    }
+    catch {
+        return dir; // Not fully created yet; the literal chain is all there is.
+    }
+}
+/**
+ * Make sure a FILE we are about to trust is ours alone, tightening it if not.
+ *
+ * The creation paths write 0600/0700, which protects a wallet this process
+ * made — and nothing else. A phrase restored from a backup, copied off another
+ * machine, or written before a umask was fixed arrives with whatever mode it
+ * had, and every local user can read it. Same for the DIRECTORY: mkdirSync's
+ * `mode` applies only when it creates one, so a wallet installed into an
+ * existing group-writable directory can be unlinked and replaced by anyone —
+ * and the agent adopts a key someone else chose, or loses its only copy.
+ *
+ * Tightening rather than refusing, because a wide mode is almost always an
+ * innocent umask and refusing would strand an agent on its own wallet. But a
+ * file owned by ANOTHER user is not a permissions accident, and chmod would
+ * fail on it anyway — that one is refused.
+ *
+ * A no-op where the concept does not apply: Windows has no POSIX mode bits, and
+ * process.getuid is not defined there.
+ */
+function ensurePrivate(target, mode) {
+    if (process.platform === 'win32')
+        return assertWindowsPathIsPrivate(target);
+    if (typeof process.getuid !== 'function')
+        return;
+    let info;
+    try {
+        info = statSync(target);
+    }
+    catch {
+        return; // Not there yet; the caller is about to create it at the right mode.
+    }
+    const me = process.getuid();
+    if (info.uid !== me) {
+        throw new Error(`${target} is owned by uid ${String(info.uid)}, not by this process (uid ${String(me)}). ` +
+            'Refusing to use it: a wallet another user controls can be replaced under you, and the ' +
+            'phrase in it may already be theirs. Move it aside, or point POG_MCP_WALLET_FILE ' +
+            'somewhere you own.');
+    }
+    // Any group or other bit at all — read included. The phrase is the key.
+    if ((info.mode & 0o077) !== 0)
+        chmodSync(target, mode);
+}
+/**
+ * Persist a recovery phrase at 0600.
+ *
+ * This is a real Solana key on a real network. The mode is set explicitly rather
+ * than left to umask, because a phrase readable by every process on the box is a
+ * different thing from a config file.
+ */
+export function writeWallet(mnemonic, path = walletFilePath(), 
+/**
+ * When true the write fails with EEXIST instead of clobbering an existing
+ * file. Used for first-time creation, where losing the race must NOT mean
+ * overwriting the phrase another process already handed out.
+ */
+exclusive = false) {
+    const wallet = {
+        mnemonic,
+        address: addressFromMnemonic(mnemonic),
+        createdAt: new Date().toISOString(),
+    };
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    writeFileSync(path, `${JSON.stringify(wallet, null, 2)}\n`, {
+        mode: 0o600,
+        ...(exclusive ? { flag: 'wx' } : {}),
+    });
+    chmodSync(path, 0o600);
+    return wallet;
+}
+/**
+ * The wallet this server plays as: an existing one, `POG_MCP_MNEMONIC`, or a new
+ * one. Importing writes the phrase so an operator can move an agent between
+ * machines without hand-editing JSON — but only onto a machine that does not
+ * already have one.
+ *
+ * A different phrase already on disk is a REFUSAL, not an overwrite. That file
+ * is a real Solana key: it is very likely the only copy, and the manager it
+ * belongs to owns a squad and on-chain assets. Replacing it because someone
+ * exported a variable to try another account — or left one exported from an
+ * earlier shell — destroys that access with no error and nothing to recover
+ * from. The concurrent-creation path already refuses to clobber for exactly this
+ * reason; there is no version of "wins over the file" worth that.
+ */
+export function loadOrCreateWallet(env = process.env, path = walletFilePath(env)) {
+    const imported = env['POG_MCP_MNEMONIC']?.trim();
+    if (imported) {
+        if (!isValidMnemonic(imported)) {
+            throw new Error('POG_MCP_MNEMONIC is not a valid BIP39 English phrase');
+        }
+        const existing = readWallet(path);
+        if (existing?.mnemonic === imported)
+            return acceptExisting(existing, path);
+        // existsSync, not `existing !== null`: readWallet also returns null for a
+        // file it cannot parse, and an unreadable wallet file is the LAST thing to
+        // overwrite — a phrase truncated mid-write is still most of a phrase.
+        if (existsSync(path))
+            throw importConflict(path);
+        // Install through the SAME atomic path as a generated wallet. A plain write
+        // here reopened the race from the other side: two processes start with no
+        // file, one atomically links a generated phrase, and this one truncates it a
+        // moment later — leaving the first process live, caching a key that is no
+        // longer on disk, free to build a squad nothing can recover after a restart.
+        // The existsSync above cannot prevent that; it is a check, and the write was
+        // a separate step.
+        const installed = createWalletAtomically(imported, path);
+        if (installed.wallet.mnemonic !== imported) {
+            // Lost the race to a different phrase. Adopting it silently is what
+            // createWalletAtomically does for a GENERATED wallet, where any valid
+            // phrase will do — but an operator who named one did not ask for another.
+            throw importConflict(path);
+        }
+        return { wallet: installed.wallet, created: false };
+    }
+    const existing = readWallet(path);
+    if (existing && isValidMnemonic(existing.mnemonic)) {
+        // A wallet is only as private as the file holding it, and this one may have
+        // arrived from anywhere.
+        return acceptExisting(existing, path);
+    }
+    // Two MCP processes starting at once both see no file and both generate a
+    // phrase. With a plain write both would save, each caching its own — and the
+    // loser's phrase can create a squad and hold assets that nothing on disk can
+    // recover, because the winner's file is what survives a restart. No error is
+    // raised anywhere; the account simply becomes unreachable.
+    //
+    // Write the content to a temp file first, then hard-link it into place.
+    // `link()` fails with EEXIST if the target exists, so exactly one process
+    // wins — and because the temp file is already complete, the file is valid the
+    // instant it appears. An `wx` open would also be atomic, but only for
+    // CREATION: the loser could then read the winner's still-empty file, call it
+    // corrupt, and overwrite it. Linking leaves no such window.
+    return createWalletAtomically(newMnemonic(), path);
+}
+/** The refusal shared by both ways an import can meet a wallet it did not name. */
+function importConflict(path) {
+    return new Error(`A different wallet already exists at ${path}, and POG_MCP_MNEMONIC is not its phrase. ` +
+        'Refusing to replace it: that file is probably the only copy of a key that owns a ' +
+        'squad and on-chain assets, and nothing here can bring it back. Move or delete it if ' +
+        'you really mean to switch, or set POG_MCP_WALLET_FILE to another path to run this ' +
+        'phrase alongside it.');
+}
+/**
+ * Write a file and make sure it is actually on the disk before returning.
+ *
+ * writeFileSync returns when the kernel has the data, not when the platter or
+ * the flash does. For most files that is the right trade; for the only copy of
+ * a key it is not.
+ */
+function writeFileSyncDurable(target, contents) {
+    const bytes = Buffer.from(contents, 'utf8');
+    const fd = openSync(target, 'wx', 0o600);
+    let complete = false;
+    try {
+        // writeSync reports how many bytes the kernel TOOK, which is not always how
+        // many we handed it. A full disk or an exhausted quota can accept the first
+        // half of the JSON and stop — and half a wallet file is an unreadable one,
+        // which the caller would otherwise fsync and link into place as if it were
+        // the real thing. Keep going until every byte is down.
+        let written = 0;
+        while (written < bytes.length) {
+            const n = writeSync(fd, bytes, written, bytes.length - written);
+            if (n <= 0) {
+                throw new Error(`Could not write ${target}: the filesystem accepted ${String(written)} of ` +
+                    `${String(bytes.length)} bytes and then stopped. Check free space and quota. ` +
+                    'No wallet was created, so nothing is lost — run this again once there is room.');
+            }
+            written += n;
+        }
+        fsyncSync(fd);
+        complete = true;
+    }
+    finally {
+        closeSync(fd);
+        if (!complete) {
+            // A partial file must never survive to be linked into place. We created
+            // this name exclusively, so removing it can only remove our own failure.
+            try {
+                unlinkSync(target);
+            }
+            catch {
+                // Already gone. Nothing downstream depends on the removal succeeding.
+            }
+        }
+    }
+}
+/**
+ * fsync a directory, so a newly linked name survives a power cut too.
+ *
+ * Not portable: Windows cannot open a directory as a file, and some filesystems
+ * refuse the sync. Neither failure means the write is lost — the file itself is
+ * already synced — so this is best effort by design.
+ */
+function syncDirectory(dir) {
+    if (process.platform === 'win32')
+        return;
+    let fd;
+    try {
+        fd = openSync(dir, 'r');
+    }
+    catch {
+        return;
+    }
+    try {
+        fsyncSync(fd);
+    }
+    catch {
+        // Some filesystems (and some containers) refuse this. The file is synced.
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/**
+ * Create the wallet file, or adopt whichever concurrent process created it
+ * first. Never overwrites an existing valid wallet.
+ */
+function createWalletAtomically(mnemonic, path) {
+    const wallet = {
+        mnemonic,
+        address: addressFromMnemonic(mnemonic),
+        createdAt: new Date().toISOString(),
+    };
+    const dir = dirname(path);
+    // 0700 for one we create; umask can only remove bits, never add them.
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    assertDirectoryIsSafe(dir);
+    // Unique per process AND per attempt, so two racers never share a temp name.
+    const temp = join(dir, `.wallet.${String(process.pid)}.${randomBytes(6).toString('hex')}.tmp`);
+    // Written THROUGH a descriptor and fsync'd before it is linked into place.
+    //
+    // writeFileSync returns once the data is in the page cache, not once it is on
+    // the disk. The link then publishes a name whose contents may not survive a
+    // power cut — and the caller can create a squad in that window, so after the
+    // reboot the account exists and the phrase that owns it does not. This is the
+    // one file where that trade is not worth making.
+    writeFileSyncDurable(temp, `${JSON.stringify(wallet, null, 2)}\n`);
+    try {
+        try {
+            linkSync(temp, path);
+            chmodSync(path, 0o600);
+            // And the DIRECTORY entry itself, so the name survives too. A synced file
+            // under an unsynced directory is a file with no way back to it.
+            syncDirectory(dir);
+            return { wallet, created: true };
+        }
+        catch (err) {
+            if (err.code !== 'EEXIST')
+                throw err;
+        }
+        const winner = readWallet(path);
+        if (winner && isValidMnemonic(winner.mnemonic)) {
+            return acceptExisting(winner, path);
+        }
+        // The file exists but is unusable. REFUSE rather than replace it.
+        //
+        // Replacing looks helpful and is not. A truncated or hand-edited file may
+        // still contain the phrase in plain text, and overwriting destroys the only
+        // copy of an account that holds real assets — irreversibly, to save the user
+        // one . Automatic recovery is not worth that.
+        //
+        // Refusing also removes the last race here. Any unlink-then-retry scheme has
+        // a window where one process reads the corrupt file, a second replaces it
+        // with a valid one, and the first then unlinks a good file it never saw —
+        // putting the two processes back on different phrases, which is exactly the
+        // failure the atomic link exists to prevent.
+        throw new Error(`${path} exists but is not a readable wallet. It may still contain your ` +
+            'recovery phrase — open it before doing anything else. To start over, delete it. ' +
+            'POG_MCP_MNEMONIC will not help while the file is there: importing refuses to ' +
+            'overwrite it too, for the same reason.');
+    }
+    finally {
+        try {
+            unlinkSync(temp);
+        }
+        catch {
+            // Already gone, or never created. Nothing depends on the temp surviving.
+        }
+    }
+}
+//# sourceMappingURL=wallet.js.map

package/dist/wallet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.js","sourceRoot":"","sources":["../src/wallet.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "pog-mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "MCP server that lets an AI agent play Proof of Goal — wallet, sign-in, squad building, and matches as typed tools.",
+  "license": "MIT",
+  "homepage": "https://pog.soccer/agents",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "agent",
+    "game",
+    "solana",
+    "football"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "skill/SKILL.md",
+    "skill/reference/measurements.md",
+    "README.md"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "pog-mcp": "./dist/index.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "lint": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.13.0",
+    "@noble/curves": "^1.8.2",
+    "@noble/hashes": "^1.8.0",
+    "@scure/bip39": "^1.6.0",
+    "bs58": "^6.0.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.30",
+    "@vitest/coverage-v8": "^3.2.4",
+    "typescript": "*",
+    "vitest": "^3.2.4"
+  }
+}