@moonpay/cli 0.6.10 → 0.6.11

package/dist/index.js

@@ -1,38 +1,16 @@
 #!/usr/bin/env node
 import { createRequire as __createRequire } from "module"; const require = __createRequire(import.meta.url);
 import {
-  bitcoinBalanceRetrieve,
-  callPublicTool,
-  callRemoteTool,
+  LOCAL_TOOLS,
   callTool,
-  clearCredentials,
-  createTool,
-  defineToolSchema,
-  getConfigOrDefault,
-  messageSign,
+  consentCheck,
   resolveBaseUrl,
-  saveCredentials,
-  schemas_default,
-  tokenBridge,
-  tokenSwap,
-  transactionSign,
-  virtualAccountWalletRegister,
-  walletCreate,
-  walletDelete,
-  walletImport,
-  walletList,
-  walletRename,
-  walletRetrieve,
-  x402Request
-} from "./chunk-TIV6G4KD.js";
-import {
-  KEY_CHAIN_MAP,
-  chainSchema,
-  findWalletOrThrow
-} from "./chunk-AL5WDHLT.js";
+  schemas_default
+} from "./chunk-6TW2YUWK.js";
+import "./chunk-ZYYH3VNA.js";
 
 // src/index.ts
-import { createRequire as createRequire2 } from "module";
+import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/format.ts
@@ -171,423 +149,9 @@ function startVersionCheck(currentVersion) {
   return () => notice;
 }
 
-// src/tools/wallet/export/schema.ts
-import { z } from "zod";
-var walletExportSchema = defineToolSchema({
-  name: "wallet_export",
-  description: "Export wallet secret (mnemonic or private key). Interactive only \u2014 cannot be run by agents or piped.",
-  input: z.object({
-    wallet: z.string().describe("Wallet name")
-  }),
-  output: z.object({
-    exported: z.literal(true)
-  })
-});
-
-// src/tools/wallet/export/tool.ts
-var walletExport = createTool(walletExportSchema, async (params) => {
-  if (!process.stdout.isTTY) {
-    throw new Error(
-      "Wallet export requires an interactive terminal.\nRun this command directly in your terminal: mp wallet export " + params.wallet
-    );
-  }
-  const wallet = findWalletOrThrow(params.wallet);
-  if (wallet.type === "hd") {
-    process.stderr.write(`
-Mnemonic for "${wallet.name}":
-
-`);
-    process.stderr.write(`  ${wallet.mnemonic}
-
-`);
-    process.stderr.write("Write this down and store it securely.\n\n");
-  } else {
-    process.stderr.write(`
-Private key for "${wallet.name}" (${wallet.chain}):
-
-`);
-    process.stderr.write(`  ${wallet.privateKey}
-
-`);
-  }
-  return { exported: true };
-});
-
-// src/tools/skill/server.ts
-import { readdirSync, readFileSync as readFileSync2, existsSync, mkdirSync as mkdirSync2, cpSync } from "fs";
-import { join as join2, dirname } from "path";
-import { homedir as homedir2 } from "os";
-import { fileURLToPath } from "url";
-function getSkillsDir() {
-  const __filename = fileURLToPath(import.meta.url);
-  const distDir = dirname(__filename);
-  return join2(distDir, "..", "skills");
-}
-function getClaudeSkillsDir() {
-  return join2(homedir2(), ".claude", "skills");
-}
-function listBundledSkills() {
-  const dir = getSkillsDir();
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("moonpay-")).map((e) => {
-    const md = readFileSync2(join2(dir, e.name, "SKILL.md"), "utf-8");
-    const descMatch = md.match(/^description:\s*(.+)$/m);
-    return {
-      name: e.name,
-      description: descMatch?.[1]?.replace(/^["']|["']$/g, "") ?? ""
-    };
-  }).sort((a, b) => a.name.localeCompare(b.name));
-}
-function readSkill(name) {
-  if (/[/\\]|\.\./.test(name)) throw new Error(`Invalid skill name: "${name}"`);
-  const skillPath = join2(getSkillsDir(), name, "SKILL.md");
-  if (!existsSync(skillPath)) {
-    throw new Error(`Skill "${name}" not found. Run \`mp skill list\` to see available skills.`);
-  }
-  return readFileSync2(skillPath, "utf-8");
-}
-function installSkills(force, dir) {
-  const srcDir = getSkillsDir();
-  const destDir = dir ?? getClaudeSkillsDir();
-  const skills = listBundledSkills();
-  mkdirSync2(destDir, { recursive: true });
-  return skills.map((s) => {
-    const dest = join2(destDir, s.name);
-    if (existsSync(dest) && !force) {
-      return { name: s.name, installed: false };
-    }
-    cpSync(join2(srcDir, s.name), dest, { recursive: true, force: true });
-    return { name: s.name, installed: true };
-  });
-}
-
-// src/tools/skill/list/schema.ts
-import { z as z2 } from "zod";
-var skillListSchema = defineToolSchema({
-  name: "skill_list",
-  description: "List available AI skills for Claude Code and other agents",
-  input: z2.object({}),
-  output: z2.array(
-    z2.object({
-      name: z2.string(),
-      description: z2.string()
-    })
-  )
-});
-
-// src/tools/skill/list/tool.ts
-var skillList = createTool(skillListSchema, async () => {
-  return listBundledSkills();
-});
-
-// src/tools/skill/retrieve/schema.ts
-import { z as z3 } from "zod";
-var skillRetrieveSchema = defineToolSchema({
-  name: "skill_retrieve",
-  description: "Get the full instructions for a specific skill",
-  input: z3.object({
-    name: z3.string().describe("Skill name (e.g. moonpay-swap-tokens)")
-  }),
-  output: z3.object({
-    name: z3.string(),
-    content: z3.string()
-  })
-});
-
-// src/tools/skill/retrieve/tool.ts
-var skillRetrieve = createTool(skillRetrieveSchema, async (params) => {
-  return {
-    name: params.name,
-    content: readSkill(params.name)
-  };
-});
-
-// src/tools/skill/install/schema.ts
-import { z as z4 } from "zod";
-var skillInstallSchema = defineToolSchema({
-  name: "skill_install",
-  description: "Install AI skills for Claude Code. Defaults to ~/.claude/skills/, or specify --dir for a custom location (e.g. project-local, ~/.agents/skills).",
-  input: z4.object({
-    force: z4.boolean().describe("Overwrite existing skills"),
-    dir: z4.string().nullable().describe(
-      "Target directory to install skills into (default: ~/.claude/skills/)"
-    )
-  }),
-  output: z4.array(
-    z4.object({
-      name: z4.string(),
-      installed: z4.boolean()
-    })
-  )
-});
-
-// src/tools/skill/install/tool.ts
-var skillInstall = createTool(skillInstallSchema, async (params) => {
-  return installSkills(params.force, params.dir ?? void 0);
-});
-
-// src/tools/token/transfer/schema.ts
-import { z as z5 } from "zod";
-var tokenTransferSchema = defineToolSchema({
-  name: "token_transfer",
-  description: "Transfer tokens to another wallet on the same chain. Builds, signs locally, and broadcasts.",
-  input: z5.object({
-    wallet: z5.string().describe("Local wallet name to sign with"),
-    chain: chainSchema.describe("Chain to transfer on"),
-    token: z5.string().describe("Token address to transfer"),
-    amount: z5.coerce.number().describe("Amount to transfer"),
-    to: z5.string().describe("Recipient wallet name or address")
-  }),
-  output: z5.object({
-    signature: z5.string().describe("Transaction hash/signature"),
-    message: z5.string().describe("Human-readable transfer description")
-  })
-});
-
-// src/tools/token/transfer/tool.ts
-var tokenTransfer = createTool(tokenTransferSchema, async (params) => {
-  const baseUrl = resolveBaseUrl();
-  const wallet = await walletRetrieve.handler({ wallet: params.wallet });
-  const fromAddress = wallet.addresses[KEY_CHAIN_MAP[params.chain]];
-  if (!fromAddress) {
-    throw new Error(`Wallet "${wallet.name}" has no address on ${params.chain}.`);
-  }
-  let toAddress = params.to;
-  try {
-    const toWallet = await walletRetrieve.handler({ wallet: params.to });
-    toAddress = toWallet.addresses[KEY_CHAIN_MAP[params.chain]] ?? params.to;
-  } catch {
-  }
-  const buildResult = await callRemoteTool(baseUrl, "token_transfer", {
-    wallet: fromAddress,
-    token: params.token,
-    to: toAddress,
-    amount: params.amount,
-    chain: params.chain
-  });
-  const txPayload = "base64" in buildResult.transaction ? buildResult.transaction.base64 : JSON.stringify(buildResult.transaction);
-  const { transaction: signedTransaction } = await transactionSign.handler({
-    wallet: wallet.name,
-    chain: params.chain,
-    transaction: txPayload
-  });
-  const sendResult = await callRemoteTool(baseUrl, "transaction_send", {
-    transaction: signedTransaction,
-    message: buildResult.message,
-    chain: params.chain
-  });
-  if (!sendResult.signature) {
-    throw new Error(`Transaction send failed: ${sendResult.message}`);
-  }
-  return { signature: sendResult.signature, message: buildResult.message };
-});
-
-// src/tools/consent/accept/tool.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-
-// src/tools/consent/accept/schema.ts
-import { z as z6 } from "zod";
-var consentAcceptSchema = defineToolSchema({
-  name: "consent_accept",
-  description: "Accept the MoonPay Terms of Service and Privacy Policy. Required before using any CLI command.",
-  input: z6.object({}),
-  output: z6.object({
-    tosVersion: z6.string(),
-    acceptedAt: z6.string()
-  })
-});
-
-// src/tools/consent/accept/tool.ts
-var CONFIG_DIR = path.join(os.homedir(), ".config", "moonpay");
-var CONSENT_PATH = path.join(CONFIG_DIR, "consent.json");
-var CURRENT_TOS_VERSION = "1.0";
-var consentAccept = createTool(consentAcceptSchema, async () => {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  }
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const consent = { tosVersion: CURRENT_TOS_VERSION, acceptedAt: now };
-  const tmp = CONSENT_PATH + `.tmp.${process.pid}`;
-  fs.writeFileSync(tmp, JSON.stringify(consent, null, 2), {
-    encoding: "utf-8",
-    mode: 384
-  });
-  fs.renameSync(tmp, CONSENT_PATH);
-  return consent;
-});
-
-// src/tools/consent/check/tool.ts
-import * as fs2 from "fs";
-import * as os2 from "os";
-import * as path2 from "path";
-
-// src/tools/consent/check/schema.ts
-import { z as z7 } from "zod";
-var consentCheckSchema = defineToolSchema({
-  name: "consent_check",
-  description: "Check whether the MoonPay Terms of Service and Privacy Policy have been accepted. Throws if not accepted.",
-  input: z7.object({}),
-  output: z7.object({
-    accepted: z7.literal(true),
-    tosVersion: z7.string(),
-    acceptedAt: z7.string()
-  })
-});
-
-// src/tools/consent/check/tool.ts
-var CONSENT_PATH2 = path2.join(os2.homedir(), ".config", "moonpay", "consent.json");
-var CURRENT_TOS_VERSION2 = "1.0";
-var consentCheck = createTool(consentCheckSchema, async () => {
-  let consent = null;
-  try {
-    consent = JSON.parse(fs2.readFileSync(CONSENT_PATH2, "utf-8"));
-  } catch {
-  }
-  if (!consent || consent.tosVersion !== CURRENT_TOS_VERSION2) {
-    throw new Error(
-      "Terms of Service not yet accepted. Run `mp consent accept` first."
-    );
-  }
-  return {
-    accepted: true,
-    tosVersion: consent.tosVersion,
-    acceptedAt: consent.acceptedAt
-  };
-});
-
-// src/tools/login/schema.ts
-import { z as z8 } from "zod";
-var loginSchema = defineToolSchema({
-  name: "login",
-  description: "Send a login verification code to your email.",
-  input: z8.object({
-    email: z8.string().describe("Email address")
-  }),
-  output: z8.object({
-    email: z8.string(),
-    message: z8.string()
-  })
-});
-
-// src/tools/login/tool.ts
-var login = createTool(loginSchema, async (params) => {
-  const { baseUrl } = getConfigOrDefault();
-  await callPublicTool(baseUrl, "login", { email: params.email });
-  return {
-    email: params.email,
-    message: `Verification code sent to ${params.email}. Run: mp verify --email ${params.email} --code <code>`
-  };
-});
-
-// src/tools/verify/schema.ts
-import { z as z9 } from "zod";
-var verifySchema = defineToolSchema({
-  name: "verify",
-  description: "Verify login code and store encrypted credentials.",
-  input: z9.object({
-    email: z9.string().describe("Email address"),
-    code: z9.string().describe("Verification code")
-  }),
-  output: z9.object({
-    email: z9.string(),
-    message: z9.string()
-  })
-});
-
-// src/tools/verify/tool.ts
-var verify = createTool(verifySchema, async (params) => {
-  const { baseUrl } = getConfigOrDefault();
-  const tokens = await callPublicTool(baseUrl, "verify", {
-    email: params.email,
-    code: params.code
-  });
-  const creds = {
-    accessToken: tokens.accessToken,
-    refreshToken: tokens.refreshToken,
-    expiresAt: tokens.expiresAt * 1e3,
-    baseUrl
-  };
-  saveCredentials(creds);
-  return { email: params.email, message: "Logged in successfully." };
-});
-
-// src/tools/logout/schema.ts
-import { z as z10 } from "zod";
-var logoutSchema = defineToolSchema({
-  name: "logout",
-  description: "Log out and clear stored credentials.",
-  input: z10.object({}),
-  output: z10.object({
-    success: z10.literal(true),
-    message: z10.string()
-  })
-});
-
-// src/tools/logout/tool.ts
-var logout = createTool(logoutSchema, async () => {
-  clearCredentials();
-  return { success: true, message: "Logged out." };
-});
-
-// src/tools/qr/tool.ts
-import { createRequire } from "module";
-
-// src/tools/qr/schema.ts
-import { z as z11 } from "zod";
-var qrGenerateSchema = defineToolSchema({
-  name: "qr_generate",
-  description: "Display a QR code in the terminal. Pass any text \u2014 wallet address, URL, token address, etc.",
-  input: z11.object({
-    value: z11.string().describe("Text to encode as a QR code")
-  }),
-  output: z11.object({
-    value: z11.string()
-  })
-});
-
-// src/tools/qr/tool.ts
-var require2 = createRequire(import.meta.url);
-var qrcode = require2("qrcode-terminal");
-var qrGenerate = createTool(qrGenerateSchema, async (params) => {
-  qrcode.generate(params.value, { small: true }, (code) => {
-    process.stderr.write(`
-${code}
-`);
-  });
-  return { value: params.value };
-});
-
 // src/index.ts
-var LOCAL_TOOLS = [
-  walletCreate,
-  walletImport,
-  walletList,
-  walletRetrieve,
-  walletDelete,
-  walletRename,
-  walletExport,
-  transactionSign,
-  messageSign,
-  bitcoinBalanceRetrieve,
-  skillList,
-  skillRetrieve,
-  skillInstall,
-  tokenSwap,
-  tokenBridge,
-  tokenTransfer,
-  x402Request,
-  virtualAccountWalletRegister,
-  consentAccept,
-  consentCheck,
-  login,
-  verify,
-  logout,
-  qrGenerate
-];
-var require3 = createRequire2(import.meta.url);
-var { version } = require3("../package.json");
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
 var getUpdateNotice = startVersionCheck(version);
 var program = new Command();
 program.name("moonpay").description(
@@ -606,7 +170,7 @@ function printUpdateNotice() {
   if (notice) process.stderr.write(notice);
 }
 program.command("mcp").description("Start MCP server over stdio (for Claude Desktop, Claude Code, etc.)").action(async () => {
-  const { startMcpServer } = await import("./mcp-7OXDGMYU.js");
+  const { startMcpServer } = await import("./mcp-VK7BDE25.js");
   await startMcpServer();
 });
 function getOrCreateGroup(parent, segments) {
@@ -638,20 +202,20 @@ function flattenShape(shape, prefix = "") {
 }
 function unflattenParams(flat, fields) {
   const result = {};
-  for (const { flatKey, path: path3 } of fields) {
+  for (const { flatKey, path } of fields) {
     const camelKey = flatKey.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
     const value = camelKey in flat ? flat[camelKey] : flat[flatKey];
-    if (path3.length === 1) {
-      result[path3[0]] = value;
+    if (path.length === 1) {
+      result[path[0]] = value;
     } else {
       let obj = result;
-      for (let i = 0; i < path3.length - 1; i++) {
-        if (!obj[path3[i]] || typeof obj[path3[i]] !== "object") {
-          obj[path3[i]] = {};
+      for (let i = 0; i < path.length - 1; i++) {
+        if (!obj[path[i]] || typeof obj[path[i]] !== "object") {
+          obj[path[i]] = {};
         }
-        obj = obj[path3[i]];
+        obj = obj[path[i]];
       }
-      obj[path3[path3.length - 1]] = value;
+      obj[path[path.length - 1]] = value;
     }
   }
   return result;