@clawdvault/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1024 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_commander5 = require("commander");
+var import_chalk6 = __toESM(require("chalk"));
+
+// src/commands/tokens.ts
+var import_commander = require("commander");
+var import_chalk2 = __toESM(require("chalk"));
+var import_cli_table3 = __toESM(require("cli-table3"));
+var import_sdk2 = require("@clawdvault/sdk");
+
+// src/utils.ts
+var import_sdk = require("@clawdvault/sdk");
+var import_chalk = __toESM(require("chalk"));
+var import_ora = __toESM(require("ora"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+function getConfigDir() {
+  return path.join(os.homedir(), ".clawdvault");
+}
+function getWalletPath() {
+  if (process.env.CLAWDVAULT_WALLET) {
+    return process.env.CLAWDVAULT_WALLET;
+  }
+  const configWallet = path.join(getConfigDir(), "wallet.json");
+  if (fs.existsSync(configWallet)) {
+    return configWallet;
+  }
+  const solanaWallet = path.join(os.homedir(), ".config", "solana", "id.json");
+  if (fs.existsSync(solanaWallet)) {
+    return solanaWallet;
+  }
+  return null;
+}
+function loadSigner(walletPathOrKey) {
+  const pathOrKey = walletPathOrKey || getWalletPath();
+  if (!pathOrKey) {
+    return null;
+  }
+  if (fs.existsSync(pathOrKey)) {
+    try {
+      return import_sdk.KeypairSigner.fromFile(pathOrKey);
+    } catch {
+      return null;
+    }
+  }
+  try {
+    return new import_sdk.KeypairSigner(pathOrKey);
+  } catch {
+    return null;
+  }
+}
+function getBaseUrl() {
+  return process.env.CLAWDVAULT_API_URL;
+}
+function createClientWithWallet(walletPath) {
+  const signer = loadSigner(walletPath);
+  const baseUrl = getBaseUrl();
+  const client = (0, import_sdk.createClient)({ signer: signer || void 0, baseUrl });
+  return {
+    client,
+    signer,
+    walletAddress: signer?.publicKey.toBase58() ?? null
+  };
+}
+function createReadOnlyClient() {
+  const baseUrl = getBaseUrl();
+  return (0, import_sdk.createClient)({ baseUrl });
+}
+function spinner(text) {
+  return (0, import_ora.default)({ text, color: "cyan" });
+}
+function formatSol(amount) {
+  return `${amount.toFixed(6)} SOL`;
+}
+function formatTokens(amount) {
+  if (amount >= 1e9) {
+    return `${(amount / 1e9).toFixed(2)}B`;
+  }
+  if (amount >= 1e6) {
+    return `${(amount / 1e6).toFixed(2)}M`;
+  }
+  if (amount >= 1e3) {
+    return `${(amount / 1e3).toFixed(2)}K`;
+  }
+  return amount.toFixed(2);
+}
+function formatUsd(amount) {
+  return `$${amount.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+function formatPercent(value) {
+  const formatted = (value * 100).toFixed(2);
+  return value >= 0 ? import_chalk.default.green(`+${formatted}%`) : import_chalk.default.red(`${formatted}%`);
+}
+function shortenAddress(address, chars = 4) {
+  return `${address.slice(0, chars)}...${address.slice(-chars)}`;
+}
+function success(message) {
+  console.log(import_chalk.default.green("\u2713"), message);
+}
+function error(message) {
+  console.error(import_chalk.default.red("\u2717"), message);
+}
+function warn(message) {
+  console.log(import_chalk.default.yellow("\u26A0"), message);
+}
+function info(message) {
+  console.log(import_chalk.default.blue("\u2139"), message);
+}
+function link(url) {
+  return import_chalk.default.cyan.underline(url);
+}
+function handleError(err) {
+  if (err instanceof Error) {
+    const apiError = err;
+    if (apiError.response?.error) {
+      error(apiError.response.error);
+    } else {
+      error(err.message);
+    }
+  } else {
+    error(String(err));
+  }
+  process.exit(1);
+}
+function requireWallet(signer) {
+  if (!signer) {
+    error("Wallet required for this operation");
+    info("Set CLAWDVAULT_WALLET environment variable or use --wallet flag");
+    info("Or place wallet.json in ~/.clawdvault/wallet.json");
+    process.exit(1);
+  }
+}
+
+// src/commands/tokens.ts
+var tokensCommand = new import_commander.Command("tokens").description("List tokens");
+tokensCommand.command("list").description("List all tokens").option("-s, --sort <field>", "Sort by field (created_at, market_cap, volume, price)", "created_at").option("-p, --page <number>", "Page number", "1").option("-l, --limit <number>", "Items per page", "20").option("--graduated", "Show only graduated tokens").option("--not-graduated", "Show only non-graduated tokens").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Fetching tokens...").start();
+  try {
+    const client = (0, import_sdk2.createClient)();
+    let graduated;
+    if (options.graduated) graduated = true;
+    if (options.notGraduated) graduated = false;
+    const result = await client.listTokens({
+      sort: options.sort,
+      page: parseInt(options.page),
+      limit: parseInt(options.limit),
+      graduated
+    });
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk2.default.bold(`
+\u{1F4CA} Tokens (Page ${result.page}, ${result.tokens.length} of ${result.total})
+`));
+    const table = new import_cli_table3.default({
+      head: [
+        import_chalk2.default.cyan("Symbol"),
+        import_chalk2.default.cyan("Name"),
+        import_chalk2.default.cyan("Price"),
+        import_chalk2.default.cyan("Market Cap"),
+        import_chalk2.default.cyan("24h Vol"),
+        import_chalk2.default.cyan("Status"),
+        import_chalk2.default.cyan("Mint")
+      ],
+      style: { head: [], border: [] }
+    });
+    for (const token of result.tokens) {
+      const status = token.graduated ? import_chalk2.default.green("\u{1F393} Graduated") : import_chalk2.default.yellow("\u{1F4C8} Bonding");
+      table.push([
+        import_chalk2.default.bold(token.symbol),
+        token.name,
+        formatSol(token.price_sol),
+        formatSol(token.market_cap_sol),
+        token.volume_24h ? formatSol(token.volume_24h) : "-",
+        status,
+        shortenAddress(token.mint)
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+tokensCommand.action(async () => {
+  const listCmd = tokensCommand.commands.find((c) => c.name() === "list");
+  if (listCmd) {
+    await listCmd.parseAsync([], { from: "user" });
+  }
+});
+
+// src/commands/token.ts
+var import_commander2 = require("commander");
+var import_chalk3 = __toESM(require("chalk"));
+var import_cli_table32 = __toESM(require("cli-table3"));
+var fs2 = __toESM(require("fs"));
+var tokenCommand = new import_commander2.Command("token").description("Token operations");
+tokenCommand.command("get <mint>").description("Get token details").option("--json", "Output as JSON").action(async (mint, options) => {
+  const spin = spinner("Fetching token...").start();
+  try {
+    const client = createReadOnlyClient();
+    const result = await client.getToken(mint);
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    const { token, trades } = result;
+    console.log(import_chalk3.default.bold(`
+\u{1FA99} ${token.name} (${token.symbol})
+`));
+    const table = new import_cli_table32.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk3.default.cyan("Mint")]: token.mint },
+      { [import_chalk3.default.cyan("Creator")]: shortenAddress(token.creator) },
+      { [import_chalk3.default.cyan("Price")]: formatSol(token.price_sol) },
+      { [import_chalk3.default.cyan("Market Cap")]: formatSol(token.market_cap_sol) },
+      { [import_chalk3.default.cyan("Status")]: token.graduated ? "\u{1F393} Graduated" : "\u{1F4C8} Bonding Curve" }
+    );
+    if (token.description) {
+      table.push({ [import_chalk3.default.cyan("Description")]: token.description });
+    }
+    if (token.twitter) {
+      table.push({ [import_chalk3.default.cyan("Twitter")]: token.twitter });
+    }
+    if (token.telegram) {
+      table.push({ [import_chalk3.default.cyan("Telegram")]: token.telegram });
+    }
+    if (token.website) {
+      table.push({ [import_chalk3.default.cyan("Website")]: token.website });
+    }
+    console.log(table.toString());
+    if (trades.length > 0) {
+      console.log(import_chalk3.default.bold(`
+\u{1F4CA} Recent Trades
+`));
+      const tradesTable = new import_cli_table32.default({
+        head: [
+          import_chalk3.default.cyan("Type"),
+          import_chalk3.default.cyan("SOL"),
+          import_chalk3.default.cyan("Tokens"),
+          import_chalk3.default.cyan("Trader"),
+          import_chalk3.default.cyan("Time")
+        ],
+        style: { head: [], border: [] }
+      });
+      for (const trade of trades.slice(0, 10)) {
+        const typeStr = trade.type === "buy" ? import_chalk3.default.green("BUY") : import_chalk3.default.red("SELL");
+        tradesTable.push([
+          typeStr,
+          formatSol(trade.sol_amount),
+          formatTokens(trade.token_amount),
+          shortenAddress(trade.trader),
+          new Date(trade.created_at).toLocaleString()
+        ]);
+      }
+      console.log(tradesTable.toString());
+    }
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+tokenCommand.command("create").description("Create a new token").requiredOption("-n, --name <name>", "Token name").requiredOption("-s, --symbol <symbol>", "Token symbol").option("-d, --description <desc>", "Token description").option("-i, --image <path>", "Image file path").option("--initial-buy <sol>", "Initial buy amount in SOL").option("--twitter <url>", "Twitter URL").option("--telegram <url>", "Telegram URL").option("--website <url>", "Website URL").option("-w, --wallet <path>", "Wallet file path").action(async (options) => {
+  const { client, signer } = createClientWithWallet(options.wallet);
+  requireWallet(signer);
+  let imageUrl;
+  if (options.image) {
+    if (!fs2.existsSync(options.image)) {
+      throw new Error(`Image file not found: ${options.image}`);
+    }
+    const uploadSpin = spinner("Uploading image...").start();
+    try {
+      const upload = await client.uploadImageFromPath(options.image);
+      imageUrl = upload.url;
+      uploadSpin.succeed("Image uploaded");
+    } catch (err) {
+      uploadSpin.fail("Image upload failed");
+      throw err;
+    }
+  }
+  const createSpin = spinner("Creating token...").start();
+  try {
+    const result = await client.createToken({
+      name: options.name,
+      symbol: options.symbol,
+      description: options.description,
+      image: imageUrl,
+      initialBuy: options.initialBuy ? parseFloat(options.initialBuy) : void 0,
+      twitter: options.twitter,
+      telegram: options.telegram,
+      website: options.website
+    });
+    createSpin.stop();
+    success(`Token created successfully!`);
+    console.log();
+    info(`Name: ${result.token.name}`);
+    info(`Symbol: ${result.token.symbol}`);
+    info(`Mint: ${result.mint}`);
+    info(`Signature: ${result.signature}`);
+    console.log();
+    info(`Explorer: ${link(result.explorer)}`);
+    info(`View: ${link(`https://clawdvault.com/${result.mint}`)}`);
+    console.log();
+  } catch (err) {
+    createSpin.stop();
+    handleError(err);
+  }
+});
+tokenCommand.command("stats <mint>").description("Get on-chain stats").option("--json", "Output as JSON").action(async (mint, options) => {
+  const spin = spinner("Fetching stats...").start();
+  try {
+    const client = createReadOnlyClient();
+    const result = await client.getStats(mint);
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk3.default.bold(`
+\u{1F4C8} On-Chain Stats
+`));
+    const { onChain } = result;
+    const table = new import_cli_table32.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk3.default.cyan("Price")]: formatSol(onChain.price) },
+      { [import_chalk3.default.cyan("Market Cap")]: formatSol(onChain.marketCap) },
+      { [import_chalk3.default.cyan("Total Supply")]: formatTokens(onChain.totalSupply) },
+      { [import_chalk3.default.cyan("Circulating")]: formatTokens(onChain.circulatingSupply) },
+      { [import_chalk3.default.cyan("Curve Balance")]: formatTokens(onChain.bondingCurveBalance) },
+      { [import_chalk3.default.cyan("Curve SOL")]: formatSol(onChain.bondingCurveSol) },
+      { [import_chalk3.default.cyan("Status")]: onChain.graduated ? "\u{1F393} Graduated" : "\u{1F4C8} Bonding" }
+    );
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+tokenCommand.command("holders <mint>").description("Get top token holders").option("--json", "Output as JSON").action(async (mint, options) => {
+  const spin = spinner("Fetching holders...").start();
+  try {
+    const client = createReadOnlyClient();
+    const result = await client.getHolders(mint);
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk3.default.bold(`
+\u{1F465} Top Holders
+`));
+    const table = new import_cli_table32.default({
+      head: [
+        import_chalk3.default.cyan("#"),
+        import_chalk3.default.cyan("Address"),
+        import_chalk3.default.cyan("Balance"),
+        import_chalk3.default.cyan("%"),
+        import_chalk3.default.cyan("Label")
+      ],
+      style: { head: [], border: [] }
+    });
+    result.holders.forEach((holder, i) => {
+      table.push([
+        i + 1,
+        shortenAddress(holder.address),
+        formatTokens(holder.balance),
+        `${holder.percentage.toFixed(2)}%`,
+        holder.label || "-"
+      ]);
+    });
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+
+// src/commands/trade.ts
+var import_commander3 = require("commander");
+var import_chalk4 = __toESM(require("chalk"));
+var import_cli_table33 = __toESM(require("cli-table3"));
+var tradeCommand = new import_commander3.Command("trade").description("Trading operations");
+tradeCommand.command("buy").description("Buy tokens").requiredOption("-m, --mint <address>", "Token mint address").requiredOption("-a, --sol <amount>", "Amount of SOL to spend").option("-s, --slippage <percent>", "Slippage tolerance (default: 1%)", "1").option("-w, --wallet <path>", "Wallet file path").option("--simulate", "Only simulate, don't execute").action(async (options) => {
+  const { client, signer, walletAddress } = createClientWithWallet(options.wallet);
+  requireWallet(signer);
+  const solAmount = parseFloat(options.sol);
+  const slippage = parseFloat(options.slippage) / 100;
+  const quoteSpin = spinner("Getting quote...").start();
+  try {
+    const quote = await client.getQuote({
+      mint: options.mint,
+      type: "buy",
+      amount: solAmount
+    });
+    quoteSpin.stop();
+    console.log(import_chalk4.default.bold("\n\u{1F4CA} Trade Preview\n"));
+    const table = new import_cli_table33.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk4.default.cyan("Input")]: `${solAmount} SOL` },
+      { [import_chalk4.default.cyan("Output")]: `~${formatTokens(quote.output)} tokens` },
+      { [import_chalk4.default.cyan("Price")]: formatSol(quote.current_price) },
+      { [import_chalk4.default.cyan("Fee")]: formatSol(quote.fee) },
+      { [import_chalk4.default.cyan("Price Impact")]: formatPercent(quote.price_impact) },
+      { [import_chalk4.default.cyan("Slippage")]: `${(slippage * 100).toFixed(1)}%` }
+    );
+    console.log(table.toString());
+    if (options.simulate) {
+      info("Simulation only - no transaction executed");
+      return;
+    }
+    if (quote.price_impact > 0.05) {
+      warn(`High price impact: ${(quote.price_impact * 100).toFixed(2)}%`);
+    }
+    console.log();
+    const tradeSpin = spinner("Executing trade...").start();
+    const jupiterStatus = await client.getJupiterStatus(options.mint);
+    let result;
+    if (jupiterStatus.graduated) {
+      info("Token graduated - routing through Jupiter");
+      result = await client.buyJupiter(options.mint, solAmount, Math.floor(slippage * 1e4));
+    } else {
+      result = await client.buy(options.mint, solAmount, slippage);
+    }
+    tradeSpin.stop();
+    success("Trade executed successfully!");
+    console.log();
+    info(`Signature: ${result.signature}`);
+    info(`SOL spent: ${formatSol(result.trade.solAmount)}`);
+    info(`Tokens received: ${formatTokens(result.trade.tokenAmount)}`);
+    console.log();
+    info(`Explorer: ${link(result.explorer)}`);
+    console.log();
+  } catch (err) {
+    quoteSpin.stop();
+    handleError(err);
+  }
+});
+tradeCommand.command("sell").description("Sell tokens").requiredOption("-m, --mint <address>", "Token mint address").option("-a, --amount <tokens>", "Amount of tokens to sell").option("-p, --percent <percent>", "Percentage of holdings to sell").option("-s, --slippage <percent>", "Slippage tolerance (default: 1%)", "1").option("-w, --wallet <path>", "Wallet file path").option("--simulate", "Only simulate, don't execute").action(async (options) => {
+  const { client, signer, walletAddress } = createClientWithWallet(options.wallet);
+  requireWallet(signer);
+  if (!options.amount && !options.percent) {
+    throw new Error("Must specify --amount or --percent");
+  }
+  const slippage = parseFloat(options.slippage) / 100;
+  const balanceSpin = spinner("Checking balance...").start();
+  try {
+    const { balance } = await client.getMyBalance(options.mint);
+    balanceSpin.stop();
+    if (balance <= 0) {
+      throw new Error("No tokens to sell");
+    }
+    let tokenAmount;
+    if (options.percent) {
+      const percent = parseFloat(options.percent);
+      tokenAmount = balance * (percent / 100);
+      info(`Selling ${percent}% of ${formatTokens(balance)} tokens`);
+    } else {
+      tokenAmount = parseFloat(options.amount);
+      if (tokenAmount > balance) {
+        throw new Error(`Insufficient balance. Have ${formatTokens(balance)}, trying to sell ${formatTokens(tokenAmount)}`);
+      }
+    }
+    const quoteSpin = spinner("Getting quote...").start();
+    const quote = await client.getQuote({
+      mint: options.mint,
+      type: "sell",
+      amount: tokenAmount
+    });
+    quoteSpin.stop();
+    console.log(import_chalk4.default.bold("\n\u{1F4CA} Trade Preview\n"));
+    const table = new import_cli_table33.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk4.default.cyan("Input")]: `${formatTokens(tokenAmount)} tokens` },
+      { [import_chalk4.default.cyan("Output")]: `~${formatSol(quote.output)}` },
+      { [import_chalk4.default.cyan("Price")]: formatSol(quote.current_price) },
+      { [import_chalk4.default.cyan("Fee")]: formatSol(quote.fee) },
+      { [import_chalk4.default.cyan("Price Impact")]: formatPercent(-quote.price_impact) },
+      { [import_chalk4.default.cyan("Slippage")]: `${(slippage * 100).toFixed(1)}%` }
+    );
+    console.log(table.toString());
+    if (options.simulate) {
+      info("Simulation only - no transaction executed");
+      return;
+    }
+    if (quote.price_impact > 0.05) {
+      warn(`High price impact: ${(quote.price_impact * 100).toFixed(2)}%`);
+    }
+    console.log();
+    const tradeSpin = spinner("Executing trade...").start();
+    const jupiterStatus = await client.getJupiterStatus(options.mint);
+    let result;
+    if (jupiterStatus.graduated) {
+      info("Token graduated - routing through Jupiter");
+      result = await client.sellJupiter(options.mint, tokenAmount, Math.floor(slippage * 1e4));
+    } else {
+      result = await client.sell(options.mint, tokenAmount, slippage);
+    }
+    tradeSpin.stop();
+    success("Trade executed successfully!");
+    console.log();
+    info(`Signature: ${result.signature}`);
+    info(`Tokens sold: ${formatTokens(result.trade.tokenAmount)}`);
+    info(`SOL received: ${formatSol(result.trade.solAmount)}`);
+    console.log();
+    info(`Explorer: ${link(result.explorer)}`);
+    console.log();
+  } catch (err) {
+    balanceSpin.stop();
+    handleError(err);
+  }
+});
+tradeCommand.command("quote").description("Get a price quote without executing").requiredOption("-m, --mint <address>", "Token mint address").requiredOption("-t, --type <type>", "Trade type (buy or sell)").requiredOption("-a, --amount <amount>", "Amount (SOL for buy, tokens for sell)").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Getting quote...").start();
+  try {
+    const client = createReadOnlyClient();
+    const quote = await client.getQuote({
+      mint: options.mint,
+      type: options.type,
+      amount: parseFloat(options.amount)
+    });
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(quote, null, 2));
+      return;
+    }
+    const isBuy = options.type === "buy";
+    console.log(import_chalk4.default.bold(`
+\u{1F4B1} ${isBuy ? "Buy" : "Sell"} Quote
+`));
+    const table = new import_cli_table33.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk4.default.cyan("Input")]: isBuy ? `${options.amount} SOL` : `${formatTokens(parseFloat(options.amount))} tokens` },
+      { [import_chalk4.default.cyan("Output")]: isBuy ? `~${formatTokens(quote.output)} tokens` : `~${formatSol(quote.output)}` },
+      { [import_chalk4.default.cyan("Price")]: formatSol(quote.current_price) },
+      { [import_chalk4.default.cyan("Fee")]: formatSol(quote.fee) },
+      { [import_chalk4.default.cyan("Price Impact")]: formatPercent(isBuy ? quote.price_impact : -quote.price_impact) }
+    );
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+tradeCommand.command("history").description("Get trade history for a token").requiredOption("-m, --mint <address>", "Token mint address").option("-l, --limit <number>", "Number of trades", "20").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Fetching trades...").start();
+  try {
+    const client = createReadOnlyClient();
+    const result = await client.getTrades({
+      mint: options.mint,
+      limit: parseInt(options.limit)
+    });
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk4.default.bold(`
+\u{1F4DC} Trade History
+`));
+    const table = new import_cli_table33.default({
+      head: [
+        import_chalk4.default.cyan("Type"),
+        import_chalk4.default.cyan("SOL"),
+        import_chalk4.default.cyan("Tokens"),
+        import_chalk4.default.cyan("Price"),
+        import_chalk4.default.cyan("Trader"),
+        import_chalk4.default.cyan("Time")
+      ],
+      style: { head: [], border: [] }
+    });
+    for (const trade of result.trades) {
+      const typeStr = trade.type === "buy" ? import_chalk4.default.green("BUY") : import_chalk4.default.red("SELL");
+      table.push([
+        typeStr,
+        formatSol(trade.sol_amount),
+        formatTokens(trade.token_amount),
+        formatSol(trade.price_sol || trade.price || 0),
+        shortenAddress(trade.trader),
+        new Date(trade.created_at).toLocaleString()
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+
+// src/commands/wallet.ts
+var import_commander4 = require("commander");
+var import_chalk5 = __toESM(require("chalk"));
+var import_cli_table34 = __toESM(require("cli-table3"));
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+var walletCommand = new import_commander4.Command("wallet").description("Wallet operations");
+walletCommand.command("info").description("Show wallet information").option("-w, --wallet <path>", "Wallet file path").action(async (options) => {
+  try {
+    const { signer, walletAddress } = createClientWithWallet(options.wallet);
+    if (!signer) {
+      warn("No wallet configured");
+      info("Set CLAWDVAULT_WALLET environment variable");
+      info("Or use: clawdvault wallet init");
+      return;
+    }
+    console.log(import_chalk5.default.bold("\n\u{1F45B} Wallet Info\n"));
+    const table = new import_cli_table34.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk5.default.cyan("Address")]: walletAddress },
+      { [import_chalk5.default.cyan("Source")]: options.wallet || getWalletPath() || "environment" }
+    );
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    handleError(err);
+  }
+});
+walletCommand.command("init").description("Generate a new wallet").option("-o, --output <path>", "Output file path (default: ~/.clawdvault/wallet.json)").option("--force", "Overwrite existing wallet").action(async (options) => {
+  try {
+    const configDir = getConfigDir();
+    const outputPath = options.output || path2.join(configDir, "wallet.json");
+    if (fs3.existsSync(outputPath) && !options.force) {
+      warn(`Wallet already exists at ${outputPath}`);
+      info("Use --force to overwrite");
+      return;
+    }
+    if (!fs3.existsSync(configDir)) {
+      fs3.mkdirSync(configDir, { recursive: true });
+    }
+    const keypair = import_web3.Keypair.generate();
+    const secretKey = Array.from(keypair.secretKey);
+    fs3.writeFileSync(outputPath, JSON.stringify(secretKey));
+    fs3.chmodSync(outputPath, 384);
+    success("Wallet created successfully!");
+    console.log();
+    info(`Address: ${keypair.publicKey.toBase58()}`);
+    info(`Saved to: ${outputPath}`);
+    console.log();
+    warn("\u26A0\uFE0F  IMPORTANT: Back up your wallet file! Loss of this file means loss of funds.");
+    console.log();
+  } catch (err) {
+    handleError(err);
+  }
+});
+walletCommand.command("balance").description("Get wallet balance for a token").requiredOption("-m, --mint <address>", "Token mint address").option("-w, --wallet <path>", "Wallet file path").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Fetching balance...").start();
+  try {
+    const { client, signer, walletAddress } = createClientWithWallet(options.wallet);
+    if (!signer) {
+      spin.stop();
+      warn("No wallet configured");
+      return;
+    }
+    const result = await client.getBalance(walletAddress, options.mint);
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk5.default.bold("\n\u{1F4B0} Token Balance\n"));
+    const table = new import_cli_table34.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk5.default.cyan("Wallet")]: result.wallet },
+      { [import_chalk5.default.cyan("Token")]: result.mint },
+      { [import_chalk5.default.cyan("Balance")]: formatTokens(result.balance) }
+    );
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+walletCommand.command("address").description("Show address for a wallet file or private key").option("-w, --wallet <path>", "Wallet file path").option("-k, --key <key>", "Private key (base58)").action(async (options) => {
+  try {
+    let signer;
+    if (options.key) {
+      signer = loadSigner(options.key);
+    } else {
+      const { signer: s } = createClientWithWallet(options.wallet);
+      signer = s;
+    }
+    if (!signer) {
+      warn("No wallet found");
+      return;
+    }
+    console.log(signer.publicKey.toBase58());
+  } catch (err) {
+    handleError(err);
+  }
+});
+walletCommand.command("network").description("Show network status").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Fetching network status...").start();
+  try {
+    const { client } = createClientWithWallet();
+    const result = await client.getNetworkStatus();
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk5.default.bold("\n\u{1F310} Network Status\n"));
+    const table = new import_cli_table34.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk5.default.cyan("Network")]: result.network },
+      { [import_chalk5.default.cyan("Program ID")]: result.programId },
+      { [import_chalk5.default.cyan("RPC URL")]: result.rpcUrl },
+      { [import_chalk5.default.cyan("Initialized")]: result.configInitialized ? "\u2713 Yes" : "\u2717 No" }
+    );
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+walletCommand.command("sol-price").description("Get current SOL/USD price").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Fetching SOL price...").start();
+  try {
+    const { client } = createClientWithWallet();
+    const result = await client.getSolPrice();
+    spin.stop();
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk5.default.bold(`
+\u{1F4B2} SOL Price: $${result.price.toFixed(2)}
+`));
+    if (result.cached) {
+      info(`Cached ${result.age}s ago from ${result.source}`);
+    }
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+function getRpcUrl() {
+  return process.env.SOLANA_RPC_URL || process.env.RPC_URL || "https://api.devnet.solana.com";
+}
+function isDevnet(rpcUrl) {
+  return rpcUrl.includes("devnet");
+}
+walletCommand.command("sol-balance").description("Get SOL balance with USD value").option("-w, --wallet <path>", "Wallet file path").option("--rpc <url>", "Solana RPC URL").option("--json", "Output as JSON").action(async (options) => {
+  const spin = spinner("Fetching SOL balance...").start();
+  try {
+    const { client, signer, walletAddress } = createClientWithWallet(options.wallet);
+    requireWallet(signer);
+    const rpcUrl = options.rpc || getRpcUrl();
+    const connection = new import_web3.Connection(rpcUrl, "confirmed");
+    const balanceLamports = await connection.getBalance(signer.publicKey);
+    const balanceSol = balanceLamports / import_web3.LAMPORTS_PER_SOL;
+    let solPrice = 0;
+    let usdValue = 0;
+    try {
+      const priceData = await client.getSolPrice();
+      solPrice = priceData.price;
+      usdValue = balanceSol * solPrice;
+    } catch {
+    }
+    spin.stop();
+    const result = {
+      wallet: walletAddress,
+      balance: balanceSol,
+      lamports: balanceLamports,
+      usdValue,
+      solPrice,
+      rpc: rpcUrl,
+      network: isDevnet(rpcUrl) ? "devnet" : "mainnet"
+    };
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(import_chalk5.default.bold("\n\u{1F4B0} SOL Balance\n"));
+    const table = new import_cli_table34.default({
+      style: { head: [], border: [] }
+    });
+    table.push(
+      { [import_chalk5.default.cyan("Wallet")]: walletAddress },
+      { [import_chalk5.default.cyan("Balance")]: `${balanceSol.toFixed(9)} SOL` },
+      { [import_chalk5.default.cyan("USD Value")]: solPrice > 0 ? formatUsd(usdValue) : "N/A" },
+      { [import_chalk5.default.cyan("Network")]: result.network }
+    );
+    console.log(table.toString());
+    console.log();
+  } catch (err) {
+    spin.stop();
+    handleError(err);
+  }
+});
+walletCommand.command("transfer").description("Send SOL or tokens to another wallet").requiredOption("--to <address>", "Recipient address").option("--sol <amount>", "Amount of SOL to send").option("-m, --mint <address>", "Token mint address (for token transfers)").option("-a, --amount <amount>", "Amount of tokens to send").option("-w, --wallet <path>", "Wallet file path").option("--rpc <url>", "Solana RPC URL").action(async (options) => {
+  try {
+    const { signer, walletAddress } = createClientWithWallet(options.wallet);
+    requireWallet(signer);
+    if (!options.sol && !options.mint) {
+      error("Must specify either --sol or --mint with --amount");
+      process.exit(1);
+    }
+    if (options.mint && !options.amount) {
+      error("Must specify --amount when using --mint");
+      process.exit(1);
+    }
+    const rpcUrl = options.rpc || getRpcUrl();
+    const connection = new import_web3.Connection(rpcUrl, "confirmed");
+    const recipient = new import_web3.PublicKey(options.to);
+    if (options.sol) {
+      const solAmount = parseFloat(options.sol);
+      if (isNaN(solAmount) || solAmount <= 0) {
+        error("Invalid SOL amount");
+        process.exit(1);
+      }
+      const spin = spinner(`Sending ${solAmount} SOL to ${options.to.slice(0, 8)}...`).start();
+      const lamports = Math.floor(solAmount * import_web3.LAMPORTS_PER_SOL);
+      const transaction = new import_web3.Transaction().add(
+        import_web3.SystemProgram.transfer({
+          fromPubkey: signer.publicKey,
+          toPubkey: recipient,
+          lamports
+        })
+      );
+      const signature = await (0, import_web3.sendAndConfirmTransaction)(
+        connection,
+        transaction,
+        [signer.keypair],
+        { commitment: "confirmed" }
+      );
+      spin.stop();
+      success(`Sent ${solAmount} SOL to ${options.to}`);
+      console.log();
+      info(`Transaction: ${signature}`);
+      if (isDevnet(rpcUrl)) {
+        info(`Explorer: https://explorer.solana.com/tx/${signature}?cluster=devnet`);
+      } else {
+        info(`Explorer: https://explorer.solana.com/tx/${signature}`);
+      }
+      console.log();
+    } else if (options.mint) {
+      const tokenAmount = parseFloat(options.amount);
+      if (isNaN(tokenAmount) || tokenAmount <= 0) {
+        error("Invalid token amount");
+        process.exit(1);
+      }
+      const spin = spinner(`Sending ${tokenAmount} tokens to ${options.to.slice(0, 8)}...`).start();
+      const mint = new import_web3.PublicKey(options.mint);
+      const sourceAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+        mint,
+        signer.publicKey,
+        false,
+        import_spl_token.TOKEN_PROGRAM_ID,
+        import_spl_token.ASSOCIATED_TOKEN_PROGRAM_ID
+      );
+      const destAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+        mint,
+        recipient,
+        false,
+        import_spl_token.TOKEN_PROGRAM_ID,
+        import_spl_token.ASSOCIATED_TOKEN_PROGRAM_ID
+      );
+      const transaction = new import_web3.Transaction();
+      try {
+        await (0, import_spl_token.getAccount)(connection, destAta);
+      } catch {
+        transaction.add(
+          (0, import_spl_token.createAssociatedTokenAccountInstruction)(
+            signer.publicKey,
+            // payer
+            destAta,
+            // ata
+            recipient,
+            // owner
+            mint,
+            // mint
+            import_spl_token.TOKEN_PROGRAM_ID,
+            import_spl_token.ASSOCIATED_TOKEN_PROGRAM_ID
+          )
+        );
+      }
+      const decimals = 6;
+      const rawAmount = BigInt(Math.floor(tokenAmount * Math.pow(10, decimals)));
+      transaction.add(
+        (0, import_spl_token.createTransferInstruction)(
+          sourceAta,
+          destAta,
+          signer.publicKey,
+          rawAmount,
+          [],
+          import_spl_token.TOKEN_PROGRAM_ID
+        )
+      );
+      const signature = await (0, import_web3.sendAndConfirmTransaction)(
+        connection,
+        transaction,
+        [signer.keypair],
+        { commitment: "confirmed" }
+      );
+      spin.stop();
+      success(`Sent ${tokenAmount} tokens to ${options.to}`);
+      console.log();
+      info(`Transaction: ${signature}`);
+      if (isDevnet(rpcUrl)) {
+        info(`Explorer: https://explorer.solana.com/tx/${signature}?cluster=devnet`);
+      } else {
+        info(`Explorer: https://explorer.solana.com/tx/${signature}`);
+      }
+      console.log();
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+walletCommand.command("airdrop").description("Request SOL from devnet faucet (devnet only)").option("--sol <amount>", "Amount of SOL to request (max 2)", "1").option("-w, --wallet <path>", "Wallet file path").option("--rpc <url>", "Solana RPC URL").action(async (options) => {
+  try {
+    const { signer, walletAddress } = createClientWithWallet(options.wallet);
+    requireWallet(signer);
+    const rpcUrl = options.rpc || getRpcUrl();
+    if (!isDevnet(rpcUrl)) {
+      error("Airdrop only works on devnet!");
+      info(`Current RPC: ${rpcUrl}`);
+      info("Use --rpc https://api.devnet.solana.com or set SOLANA_RPC_URL");
+      process.exit(1);
+    }
+    const solAmount = parseFloat(options.sol);
+    if (isNaN(solAmount) || solAmount <= 0 || solAmount > 2) {
+      error("Invalid SOL amount (must be between 0 and 2)");
+      process.exit(1);
+    }
+    const spin = spinner(`Requesting ${solAmount} SOL airdrop...`).start();
+    const connection = new import_web3.Connection(rpcUrl, "confirmed");
+    const lamports = Math.floor(solAmount * import_web3.LAMPORTS_PER_SOL);
+    try {
+      const signature = await connection.requestAirdrop(signer.publicKey, lamports);
+      spin.text = "Waiting for confirmation...";
+      await connection.confirmTransaction(signature, "confirmed");
+      spin.stop();
+      success(`Airdrop successful! Received ${solAmount} SOL`);
+      console.log();
+      info(`Transaction: ${signature}`);
+      info(`Explorer: https://explorer.solana.com/tx/${signature}?cluster=devnet`);
+      console.log();
+      const newBalance = await connection.getBalance(signer.publicKey);
+      info(`New balance: ${(newBalance / import_web3.LAMPORTS_PER_SOL).toFixed(9)} SOL`);
+      console.log();
+    } catch (airdropErr) {
+      spin.stop();
+      if (airdropErr.message?.includes("429") || airdropErr.message?.includes("rate")) {
+        error("Rate limited. Please wait a minute and try again.");
+      } else {
+        throw airdropErr;
+      }
+    }
+  } catch (err) {
+    handleError(err);
+  }
+});
+
+// src/index.ts
+var program = new import_commander5.Command();
+program.name("clawdvault").description("CLI for ClawdVault - Solana token launchpad").version("0.1.0");
+program.addCommand(tokensCommand);
+program.addCommand(tokenCommand);
+program.addCommand(tradeCommand);
+program.addCommand(walletCommand);
+program.hook("preAction", () => {
+});
+program.configureOutput({
+  outputError: (str, write) => {
+    write(import_chalk6.default.red(str));
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@clawdvault/cli",
+  "version": "0.1.0",
+  "description": "CLI for ClawdVault - Solana token launchpad",
+  "main": "dist/index.js",
+  "bin": {
+    "clawdvault": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --clean --shims",
+    "dev": "tsup src/index.ts --format cjs --watch --shims",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@clawdvault/sdk": "^0.1.0",
+    "@solana/spl-token": "^0.4.0",
+    "@solana/web3.js": "^1.91.0",
+    "bs58": "^5.0.0",
+    "chalk": "^4.1.2",
+    "commander": "^12.0.0",
+    "ora": "^5.4.1",
+    "cli-table3": "^0.6.3"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "keywords": [
+    "clawdvault",
+    "solana",
+    "cli",
+    "token",
+    "launchpad"
+  ],
+  "author": "ClawdVault",
+  "license": "MIT"
+}