@bagsfm/bags-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1371 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/setup.ts
+import chalk2 from "chalk";
+
+// src/lib/auth.ts
+import bs582 from "bs58";
+import nacl from "tweetnacl";
+import { Keypair as Keypair2 } from "@solana/web3.js";
+
+// src/lib/wallet.ts
+import { readFile, rm } from "fs/promises";
+import { Keypair } from "@solana/web3.js";
+import bs58 from "bs58";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+var BAGS_CONFIG_DIR = join(homedir(), ".config", "bags");
+var BAGS_KEYPAIR_PATH = join(BAGS_CONFIG_DIR, "keypair.json");
+var BAGS_CREDENTIALS_PATH = join(BAGS_CONFIG_DIR, "credentials.json");
+var BAGS_SETTINGS_PATH = join(BAGS_CONFIG_DIR, "config.json");
+
+// src/lib/fs.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+async function writeJsonSecure(path, value) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await writeFile(path, `${JSON.stringify(value, null, 2)}
+`, { mode: 384 });
+}
+
+// src/lib/wallet.ts
+function keypairFromSecret(secret) {
+  return Keypair.fromSecretKey(secret);
+}
+async function loadKeypair(path = BAGS_KEYPAIR_PATH) {
+  try {
+    const raw = await readFile(path, "utf8");
+    const parsed = JSON.parse(raw);
+    return keypairFromSecret(Uint8Array.from(parsed));
+  } catch {
+    return null;
+  }
+}
+async function saveKeypair(keypair, path = BAGS_KEYPAIR_PATH) {
+  await writeJsonSecure(path, Array.from(keypair.secretKey));
+}
+async function generateKeypair(force = false, path = BAGS_KEYPAIR_PATH) {
+  const existing = await loadKeypair(path);
+  if (existing && !force) {
+    throw new Error(`Keypair already exists at ${path}. Use --force to overwrite.`);
+  }
+  const kp = Keypair.generate();
+  await saveKeypair(kp, path);
+  return kp;
+}
+async function importKeypairFromBase58(base58PrivateKey, path = BAGS_KEYPAIR_PATH) {
+  const secret = bs58.decode(base58PrivateKey);
+  const kp = keypairFromSecret(secret);
+  await saveKeypair(kp, path);
+  return kp;
+}
+async function importKeypairFromJsonFile(filePath, path = BAGS_KEYPAIR_PATH) {
+  const raw = await readFile(filePath, "utf8");
+  const parsed = JSON.parse(raw);
+  const kp = keypairFromSecret(Uint8Array.from(parsed));
+  await saveKeypair(kp, path);
+  return kp;
+}
+function detectKeyFormat(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("[") || /^\d+\s*,/.test(trimmed)) {
+    return "intArray";
+  }
+  return "base58";
+}
+async function importKeypairFromIntArray(intArrayStr, path = BAGS_KEYPAIR_PATH) {
+  let input3 = intArrayStr.trim();
+  if (!input3.startsWith("[")) {
+    input3 = `[${input3}]`;
+  }
+  const parsed = JSON.parse(input3);
+  if (!Array.isArray(parsed) || !parsed.every((n) => Number.isInteger(n))) {
+    throw new Error("Invalid int array format.");
+  }
+  const kp = keypairFromSecret(Uint8Array.from(parsed));
+  await saveKeypair(kp, path);
+  return kp;
+}
+async function deleteKeypair(path = BAGS_KEYPAIR_PATH) {
+  try {
+    await rm(path, { force: true });
+  } catch {
+  }
+}
+
+// src/lib/credentials.ts
+import { readFile as readFile2, rm as rm2 } from "fs/promises";
+async function loadCredentials() {
+  try {
+    const raw = await readFile2(BAGS_CREDENTIALS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed.apiKey || !parsed.walletAddress) {
+      return null;
+    }
+    return {
+      apiKey: parsed.apiKey,
+      keyId: parsed.keyId,
+      walletAddress: parsed.walletAddress,
+      authenticatedAt: parsed.authenticatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return null;
+  }
+}
+async function saveCredentials(credentials) {
+  await writeJsonSecure(BAGS_CREDENTIALS_PATH, credentials);
+}
+async function clearCredentials() {
+  try {
+    await rm2(BAGS_CREDENTIALS_PATH, { force: true });
+  } catch {
+  }
+}
+
+// src/lib/auth.ts
+var BAGS_BASE_URL = "https://public-api-v2.bags.fm/api/v1";
+async function post(path, body) {
+  const response = await fetch(`${BAGS_BASE_URL}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const json = await response.json();
+  if (!response.ok || !json.success || !json.response) {
+    throw new Error(json.error ?? `Request failed: ${response.status}`);
+  }
+  return json.response;
+}
+async function getOrCreateAuthKeypair(path = BAGS_KEYPAIR_PATH) {
+  const existing = await loadKeypair(path);
+  if (existing) {
+    return existing;
+  }
+  const kp = Keypair2.generate();
+  await saveKeypair(kp, path);
+  return kp;
+}
+async function authInit(address) {
+  return await post("/agent/v2/auth/init", { address });
+}
+function signChallengeMessage(challengeMessageBase58, keypair) {
+  const messageBytes = bs582.decode(challengeMessageBase58);
+  const signatureBytes = nacl.sign.detached(messageBytes, keypair.secretKey);
+  return bs582.encode(signatureBytes);
+}
+async function authSignatureCallback(args) {
+  return await post("/agent/v2/auth/callback", args);
+}
+async function authMfaCallback(args) {
+  return await post("/agent/v2/auth/callback", args);
+}
+async function runAgentAuthFlow(args) {
+  const keypair = await getOrCreateAuthKeypair(args.keypairPath);
+  const address = keypair.publicKey.toBase58();
+  const init = await authInit(address);
+  const signature = signChallengeMessage(init.message, keypair);
+  const first = await authSignatureCallback({
+    signature,
+    address,
+    nonce: init.nonce,
+    keyName: args.keyName
+  });
+  let apiKey = first.apiKey;
+  let keyId = first.keyId;
+  if (!apiKey && first.mfaRequired) {
+    if (!first.authCode) {
+      throw new Error("MFA required, but no authCode returned by API.");
+    }
+    if (!args.mfaCodeProvider) {
+      throw new Error("MFA required. Please provide an MFA code.");
+    }
+    const mfaCode = await args.mfaCodeProvider();
+    const second = await authMfaCallback({
+      authCode: first.authCode,
+      mfaCode,
+      keyName: args.keyName
+    });
+    apiKey = second.apiKey;
+    keyId = second.keyId;
+  }
+  if (!apiKey) {
+    throw new Error("Authentication succeeded but API key was not returned.");
+  }
+  const credentials = {
+    apiKey,
+    keyId,
+    walletAddress: address,
+    authenticatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await saveCredentials(credentials);
+  return credentials;
+}
+
+// src/utils/errors.ts
+import chalk from "chalk";
+function isUserAbort(error) {
+  if (!(error instanceof Error)) return false;
+  return error.message.includes("force closed") || error.message.includes("SIGINT") || error.name === "ExitPromptError";
+}
+function handleCliError(error) {
+  if (isUserAbort(error)) {
+    console.log(chalk.dim("Goodbye."));
+    process.exit(0);
+  }
+  if (error instanceof Error) {
+    console.error(chalk.red(`Error: ${error.message}`));
+  } else {
+    console.error(chalk.red("Unexpected error"), error);
+  }
+  process.exit(1);
+}
+
+// src/lib/command.ts
+function wrapAction(fn) {
+  return async (...args) => {
+    const command = args[args.length - 1];
+    const rest = args.slice(0, -1);
+    try {
+      await fn(command, ...rest);
+    } catch (error) {
+      handleCliError(error);
+    }
+  };
+}
+
+// src/lib/config.ts
+import { readFile as readFile3 } from "fs/promises";
+var DEFAULT_CLI_CONFIG = {
+  rpcUrl: "https://api.mainnet-beta.solana.com",
+  commitment: "processed",
+  output: "pretty"
+};
+async function loadCliConfig() {
+  try {
+    const raw = await readFile3(BAGS_SETTINGS_PATH, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      rpcUrl: parsed.rpcUrl ?? DEFAULT_CLI_CONFIG.rpcUrl,
+      commitment: parsed.commitment ?? DEFAULT_CLI_CONFIG.commitment,
+      output: parsed.output ?? DEFAULT_CLI_CONFIG.output
+    };
+  } catch {
+    return DEFAULT_CLI_CONFIG;
+  }
+}
+async function saveCliConfig(value) {
+  await writeJsonSecure(BAGS_SETTINGS_PATH, value);
+}
+
+// src/lib/prompt.ts
+import { confirm, input, password, select } from "@inquirer/prompts";
+async function flagOrPrompt(value, message, validate) {
+  if (value !== void 0 && value !== "") {
+    return value;
+  }
+  return await input({ message, validate });
+}
+async function optionalFlagOrPrompt(value, message) {
+  if (value !== void 0) {
+    return value;
+  }
+  const next = await input({ message });
+  return next.trim() === "" ? void 0 : next;
+}
+async function flagOrPromptNumber(value, message, defaultValue) {
+  if (value !== void 0) {
+    return value;
+  }
+  const raw = await input({ message, default: defaultValue?.toString() });
+  const n = Number(raw);
+  if (!Number.isFinite(n)) {
+    throw new Error(`Invalid number: ${raw}`);
+  }
+  return n;
+}
+async function promptConfirm(message, defaultValue = true) {
+  return await confirm({ message, default: defaultValue });
+}
+async function promptSecret(message) {
+  return await password({ message, mask: "*" });
+}
+async function promptOneOf(flags, labels, promptMessages) {
+  const keys = Object.keys(flags);
+  const provided = keys.filter((k) => flags[k] !== void 0 && flags[k] !== "");
+  if (provided.length > 1) {
+    throw new Error(`Only one of ${keys.map((k) => `--${String(k)}`).join(", ")} can be provided.`);
+  }
+  if (provided.length === 1) {
+    return { key: provided[0], value: flags[provided[0]] };
+  }
+  const key = await select({
+    message: "Choose one:",
+    choices: keys.map((k) => ({ name: labels[k], value: k }))
+  });
+  const value = await input({ message: promptMessages[key] });
+  if (!value.trim()) {
+    throw new Error(`A value is required.`);
+  }
+  return { key, value };
+}
+
+// src/utils/spinner.ts
+import ora from "ora";
+async function withSpinner(message, fn) {
+  const spinner = ora(message).start();
+  try {
+    const result = await fn();
+    spinner.succeed(message);
+    return result;
+  } catch (error) {
+    spinner.fail(`${message} failed`);
+    throw error;
+  }
+}
+
+// src/commands/setup.ts
+function registerSetupCommand(program2) {
+  program2.command("setup").description("First-run wizard: configure RPC, import wallet, and authenticate").option("--rpc-url <url>", "Solana RPC URL").option("--private-key <key>", "Private key (base58 or int array)").option("--key-name <name>", "Label for API key", "Bags CLI Key").action(
+    wrapAction(async (command, options) => {
+      console.log(chalk2.bold("\nBags CLI Setup\n"));
+      const rpcUrl = await flagOrPrompt(
+        options.rpcUrl,
+        "Solana RPC URL (default: https://api.mainnet-beta.solana.com):"
+      );
+      const resolvedRpc = rpcUrl.trim() === "" ? "https://api.mainnet-beta.solana.com" : rpcUrl.trim();
+      const config = await loadCliConfig();
+      await saveCliConfig({ ...config, rpcUrl: resolvedRpc });
+      console.log(chalk2.green(`  RPC URL saved: ${resolvedRpc}`));
+      let privateKeyRaw;
+      if (options.privateKey) {
+        privateKeyRaw = options.privateKey;
+      } else {
+        privateKeyRaw = await promptSecret("Private key (base58 or int array):");
+      }
+      const format = detectKeyFormat(privateKeyRaw);
+      const keypair = await withSpinner("Importing wallet", async () => {
+        if (format === "intArray") {
+          return await importKeypairFromIntArray(privateKeyRaw);
+        }
+        return await importKeypairFromBase58(privateKeyRaw);
+      });
+      console.log(chalk2.green(`  Wallet imported: ${keypair.publicKey.toBase58()}`));
+      const credentials = await withSpinner("Authenticating with Bags", async () => {
+        return await runAgentAuthFlow({
+          keyName: options.keyName ?? "Bags CLI Key",
+          keypairPath: BAGS_KEYPAIR_PATH,
+          mfaCodeProvider: async () => await promptSecret("Enter MFA code:")
+        });
+      });
+      const masked = `${credentials.apiKey.slice(0, 6)}...${credentials.apiKey.slice(-4)}`;
+      console.log(
+        chalk2.bold.green("\nSetup complete!\n") + `  Wallet:  ${credentials.walletAddress}
+  API Key: ${masked}
+  RPC:     ${resolvedRpc}
+`
+      );
+    })
+  );
+}
+
+// src/commands/auth.ts
+import chalk4 from "chalk";
+
+// src/lib/output.ts
+import chalk3 from "chalk";
+import Table from "cli-table3";
+async function shouldUseJson(command) {
+  const globalOpts = command.optsWithGlobals();
+  if (globalOpts.json) {
+    return true;
+  }
+  const config = await loadCliConfig();
+  return config.output === "json";
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return chalk3.dim("\u2014");
+  }
+  if (typeof value === "boolean") {
+    return value ? chalk3.green("yes") : chalk3.red("no");
+  }
+  if (typeof value === "number") {
+    return chalk3.cyan(String(value));
+  }
+  return String(value);
+}
+function printKeyValue(data) {
+  const keys = Object.keys(data);
+  const maxLen = Math.max(...keys.map((k) => k.length));
+  for (const key of keys) {
+    const val = data[key];
+    if (val !== null && typeof val === "object" && !Array.isArray(val)) {
+      console.log(`  ${chalk3.bold(key.padEnd(maxLen))}:`);
+      printKeyValue(val);
+      continue;
+    }
+    if (Array.isArray(val)) {
+      console.log(`  ${chalk3.bold(key.padEnd(maxLen))}  ${chalk3.dim(`[${val.length} items]`)}`);
+      for (const item of val) {
+        if (item !== null && typeof item === "object") {
+          const summary = Object.entries(item).map(([k, v]) => `${k}=${formatValue(v)}`).join("  ");
+          console.log(`    ${chalk3.dim("\u2022")} ${summary}`);
+        } else {
+          console.log(`    ${chalk3.dim("\u2022")} ${formatValue(item)}`);
+        }
+      }
+      continue;
+    }
+    console.log(`  ${chalk3.bold(key.padEnd(maxLen))}  ${formatValue(val)}`);
+  }
+}
+async function printData(command, data) {
+  if (await shouldUseJson(command)) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+    printKeyValue(data);
+    return;
+  }
+  if (Array.isArray(data)) {
+    for (const item of data) {
+      if (item !== null && typeof item === "object") {
+        printKeyValue(item);
+        console.log();
+      } else {
+        console.log(formatValue(item));
+      }
+    }
+    return;
+  }
+  console.log(formatValue(data));
+}
+async function printTable(command, headers, rows) {
+  if (await shouldUseJson(command)) {
+    const keys = headers.map((h) => h.toLowerCase().replace(/\s+/g, "_"));
+    const mapped = rows.map((row) => {
+      const item = {};
+      keys.forEach((key, i) => {
+        item[key] = row[i] ?? "";
+      });
+      return item;
+    });
+    console.log(JSON.stringify(mapped, null, 2));
+    return;
+  }
+  const table = new Table({ head: headers });
+  for (const row of rows) {
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+
+// src/commands/auth.ts
+function registerAuthCommands(program2) {
+  const auth = program2.command("auth").description("Agent authentication commands");
+  auth.command("login").description("Authenticate via wallet signature flow and store API key").option("--keypair <path>", "Custom keypair path").option("--key-name <name>", "Label for API key", "Bags CLI Key").action(
+    wrapAction(async (command, options) => {
+      const credentials = await withSpinner("Authenticating with Bags", async () => {
+        return await runAgentAuthFlow({
+          keyName: options.keyName ?? "Bags CLI Key",
+          keypairPath: options.keypair ?? BAGS_KEYPAIR_PATH,
+          mfaCodeProvider: async () => await promptSecret("Enter MFA code")
+        });
+      });
+      console.log(chalk4.green("Authentication successful."));
+      await printData(command, {
+        walletAddress: credentials.walletAddress,
+        keyId: credentials.keyId ?? null,
+        authenticatedAt: credentials.authenticatedAt
+      });
+    })
+  );
+  auth.command("status").description("Show current authentication state").action(
+    wrapAction(async (command) => {
+      const credentials = await loadCredentials();
+      if (!credentials) {
+        console.log(chalk4.yellow("Not authenticated. Run `bags auth login`."));
+        return;
+      }
+      const masked = `${credentials.apiKey.slice(0, 6)}...${credentials.apiKey.slice(-4)}`;
+      await printData(command, {
+        authenticated: true,
+        walletAddress: credentials.walletAddress,
+        apiKey: masked,
+        keyId: credentials.keyId ?? null,
+        authenticatedAt: credentials.authenticatedAt
+      });
+    })
+  );
+  auth.command("logout").description("Remove credentials. Optionally remove keypair too").option("--all", "Also remove wallet keypair").action(
+    wrapAction(async (_command, options) => {
+      await clearCredentials();
+      if (options.all) {
+        await deleteKeypair();
+      }
+      console.log(chalk4.green(`Logged out${options.all ? " and deleted keypair" : ""}.`));
+    })
+  );
+}
+
+// src/commands/config.ts
+import { PublicKey } from "@solana/web3.js";
+
+// src/lib/sdk.ts
+import { Connection } from "@solana/web3.js";
+import { BagsSDK } from "@bagsfm/bags-sdk";
+var cached = null;
+async function getSdkContext(forceRefresh = false) {
+  if (cached && !forceRefresh) {
+    return cached;
+  }
+  const credentials = await loadCredentials();
+  if (!credentials) {
+    throw new Error("Not authenticated. Run `bags auth login` first.");
+  }
+  const config = await loadCliConfig();
+  const connection = new Connection(config.rpcUrl, config.commitment);
+  const sdk = new BagsSDK(credentials.apiKey, connection, config.commitment);
+  cached = { sdk, connection };
+  return cached;
+}
+
+// src/lib/signer.ts
+async function getLocalSigner() {
+  const keypair = await loadKeypair();
+  if (!keypair) {
+    throw new Error("No local keypair found. Run `bags wallet generate` or `bags wallet import`.");
+  }
+  const config = await loadCliConfig();
+  return { keypair, commitment: config.commitment };
+}
+
+// src/lib/tx.ts
+import { signAndSendTransaction } from "@bagsfm/bags-sdk";
+async function signAndSend(connection, commitment, transaction, keypair) {
+  const signature = await signAndSendTransaction(connection, commitment, transaction, keypair);
+  return signature;
+}
+
+// src/commands/config.ts
+function parseClaimers(raw) {
+  if (!raw) {
+    throw new Error(`--fee-claimers is required. Example: '[{"user":"...","userBps":10000}]'`);
+  }
+  const parsed = JSON.parse(raw);
+  return parsed.map((x) => ({ user: new PublicKey(x.user), userBps: x.userBps }));
+}
+function registerConfigCommands(program2) {
+  const config = program2.command("config").description("Fee share configuration");
+  config.command("create").description("Create a fee share config for a token").option("--mint <address>", "Base mint").option("--fee-claimers <json>", "JSON array [{user,userBps}]").option("--partner <pubkey>", "Partner wallet").option("--skip-confirm", "Skip confirmation").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey(await flagOrPrompt(options.mint, "Base mint:"));
+      const feeClaimers = parseClaimers(options.feeClaimers);
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Create fee config for ${mint.toBase58()}?`);
+        if (!ok) return;
+      }
+      const result = await sdk.config.createBagsFeeShareConfig({
+        payer: keypair.publicKey,
+        baseMint: mint,
+        feeClaimers,
+        partner: options.partner ? new PublicKey(options.partner) : void 0
+      });
+      const signatures = [];
+      if (Array.isArray(result.transactions)) {
+        for (const tx of result.transactions) {
+          signatures.push(await signAndSend(connection, commitment, tx, keypair));
+        }
+      }
+      await printData(command, {
+        meteoraConfigKey: result.meteoraConfigKey?.toString?.() ?? result.meteoraConfigKey,
+        signatures
+      });
+    })
+  );
+  config.command("update").description("Update fee share config as admin").option("--mint <address>", "Base mint").option("--fee-claimers <json>", "JSON array [{user,userBps}]").option("--skip-confirm", "Skip confirmation").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey(await flagOrPrompt(options.mint, "Base mint:"));
+      const feeClaimers = parseClaimers(options.feeClaimers);
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Update admin config for ${mint.toBase58()}?`);
+        if (!ok) return;
+      }
+      const result = await sdk.feeShareAdmin.createUpdateConfigTransactions({
+        payer: keypair.publicKey,
+        baseMint: mint,
+        feeClaimers
+      });
+      const signatures = [];
+      if (Array.isArray(result.transactions)) {
+        for (const tx of result.transactions) {
+          signatures.push(await signAndSend(connection, commitment, tx, keypair));
+        }
+      }
+      await printData(command, { signatures });
+    })
+  );
+  config.command("transfer-admin").description("Transfer fee share admin authority").option("--mint <address>", "Base mint").option("--new-admin <pubkey>", "New admin wallet").option("--skip-confirm", "Skip confirmation").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey(await flagOrPrompt(options.mint, "Base mint:"));
+      const newAdmin = new PublicKey(await flagOrPrompt(options.newAdmin, "New admin:"));
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Transfer admin for ${mint.toBase58()} to ${newAdmin.toBase58()}?`);
+        if (!ok) return;
+      }
+      const tx = await sdk.feeShareAdmin.createTransferAdminTransaction({
+        payer: keypair.publicKey,
+        baseMint: mint,
+        newAdmin
+      });
+      const signature = await signAndSend(connection, commitment, tx, keypair);
+      await printData(command, { signature });
+    })
+  );
+  config.command("admin-list").description("List mints where wallet is fee share admin").action(
+    wrapAction(async (command) => {
+      const { sdk } = await getSdkContext();
+      const { keypair } = await getLocalSigner();
+      const list = await sdk.feeShareAdmin.getAdminTokenMints(keypair.publicKey);
+      await printData(command, list);
+    })
+  );
+}
+
+// src/commands/dexscreener.ts
+import { PublicKey as PublicKey2 } from "@solana/web3.js";
+function registerDexscreenerCommands(program2) {
+  const dexscreener = program2.command("dexscreener").description("Dexscreener order flows");
+  dexscreener.command("check").description("Check Dexscreener order availability").option("--mint <address>", "Token mint").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey2(await flagOrPrompt(options.mint, "Token mint:"));
+      const { sdk } = await getSdkContext();
+      const result = await sdk.dexscreener.checkOrderAvailability(mint);
+      await printData(command, result);
+    })
+  );
+  dexscreener.command("order").description("Create Dexscreener order").option("--mint <address>", "Token mint").option("--payload <json>", "Raw JSON payload override").action(
+    wrapAction(async (command, options) => {
+      const mint = await flagOrPrompt(options.mint, "Token mint:");
+      const payload = options.payload !== void 0 ? JSON.parse(options.payload) : {
+        tokenMint: mint
+      };
+      const { sdk } = await getSdkContext();
+      const result = await sdk.dexscreener.createOrder(payload);
+      await printData(command, result);
+    })
+  );
+  dexscreener.command("pay").description("Submit Dexscreener payment").option("--order-id <id>", "Order ID").option("--transaction <tx>", "Signed serialized transaction").action(
+    wrapAction(async (command, options) => {
+      const orderId = await flagOrPrompt(options.orderId, "Order ID:");
+      const transaction = await flagOrPrompt(options.transaction, "Signed transaction:");
+      const { sdk } = await getSdkContext();
+      const result = await sdk.dexscreener.submitPayment({ orderId, transaction });
+      await printData(command, result);
+    })
+  );
+}
+
+// src/commands/fees.ts
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
+
+// src/utils/format.ts
+function lamportsToSol(lamports) {
+  return (lamports / 1e9).toFixed(9);
+}
+function shortAddress(value) {
+  if (value.length < 10) {
+    return value;
+  }
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+// src/commands/fees.ts
+async function resolveMint(value) {
+  const mint = await flagOrPrompt(value, "Token mint:");
+  return new PublicKey3(mint);
+}
+async function getClaimTransactionsForMint(sdk, wallet, mint) {
+  const fee = sdk.fee;
+  if (typeof fee.getClaimTransactions === "function") {
+    return await fee.getClaimTransactions(wallet, mint);
+  }
+  if (typeof fee.getClaimTransaction === "function") {
+    const tx = await fee.getClaimTransaction(wallet, mint);
+    return tx ? [tx] : [];
+  }
+  throw new Error("This SDK version does not expose claim transaction methods.");
+}
+function registerFeesCommands(program2) {
+  const fees = program2.command("fees").description("Fee claiming and fee analytics");
+  fees.command("list").description("List claimable fee positions for local wallet").action(
+    wrapAction(async (command) => {
+      const { sdk } = await getSdkContext();
+      const { keypair } = await getLocalSigner();
+      const positions = await sdk.fee.getAllClaimablePositions(keypair.publicKey);
+      const rows = positions.map((p) => [
+        String(p.baseMint ?? ""),
+        Number(p.totalClaimableLamportsUserShare ?? 0),
+        p.isCustomFeeVault ? "yes" : "no"
+      ]);
+      await printTable(command, ["Mint", "Claimable Lamports", "Custom Vault"], rows);
+    })
+  );
+  fees.command("claim").description("Claim fees for a single token mint").argument("[mint]", "Token mint address").option("--mint <address>", "Token mint").option("--skip-confirm", "Skip transaction confirmation").action(
+    wrapAction(async (command, mintArg, options) => {
+      const mint = await resolveMint(mintArg ?? options.mint);
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Claim fees for ${mint.toBase58()}?`);
+        if (!ok) {
+          return;
+        }
+      }
+      const transactions = await getClaimTransactionsForMint(sdk, keypair.publicKey, mint);
+      const signatures = [];
+      for (const tx of transactions) {
+        signatures.push(await signAndSend(connection, commitment, tx, keypair));
+      }
+      await printData(command, { mint: mint.toBase58(), signatures });
+    })
+  );
+  fees.command("claim-all").description("Claim all claimable fees for the local wallet").option("--skip-confirm", "Skip transaction confirmation").action(
+    wrapAction(async (command, options) => {
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      const feeService = sdk.fee;
+      const positions = await feeService.getAllClaimablePositions(keypair.publicKey);
+      const mints = [...new Set(positions.map((p) => String(p.baseMint)))];
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Claim fees across ${mints.length} token(s)?`);
+        if (!ok) {
+          return;
+        }
+      }
+      const sent = [];
+      for (const mint of mints) {
+        const txs = await getClaimTransactionsForMint(sdk, keypair.publicKey, new PublicKey3(mint));
+        const signatures = [];
+        for (const tx of txs) {
+          signatures.push(await signAndSend(connection, commitment, tx, keypair));
+        }
+        sent.push({ mint, signatures });
+      }
+      await printData(command, { count: sent.length, claims: sent });
+    })
+  );
+  fees.command("lifetime").description("Get token lifetime fees").argument("[mint]", "Token mint address").option("--mint <address>", "Token mint").option("--raw", "Show raw lamports instead of SOL").action(
+    wrapAction(async (command, mintArg, options) => {
+      const mint = await resolveMint(mintArg ?? options.mint);
+      const { sdk } = await getSdkContext();
+      const result = await sdk.state.getTokenLifetimeFees(mint);
+      if (typeof result === "number") {
+        await printData(command, {
+          mint: mint.toBase58(),
+          lifetimeFees: options.raw ? `${result} lamports` : `${lamportsToSol(result)} SOL`
+        });
+      } else {
+        await printData(command, result);
+      }
+    })
+  );
+  fees.command("events").description("Get token claim events").argument("[mint]", "Token mint address").option("--mint <address>", "Token mint").option("--offset <n>", "Offset", Number).option("--limit <n>", "Limit", Number).option("--start-time <iso>", "Start timestamp (ISO)").option("--end-time <iso>", "End timestamp (ISO)").action(
+    wrapAction(async (command, mintArg, options) => {
+      const mint = await resolveMint(mintArg ?? options.mint);
+      const { sdk } = await getSdkContext();
+      const payload = { mint: mint.toBase58() };
+      if (options.offset !== void 0) payload.offset = options.offset;
+      if (options.limit !== void 0) payload.limit = options.limit;
+      if (options.startTime) payload.startTime = options.startTime;
+      if (options.endTime) payload.endTime = options.endTime;
+      const result = await sdk.state.getTokenClaimEvents(payload);
+      await printData(command, result);
+    })
+  );
+  fees.command("stats").description("Get token claim stats").argument("[mint]", "Token mint address").option("--mint <address>", "Token mint").action(
+    wrapAction(async (command, mintArg, options) => {
+      const mint = await resolveMint(mintArg ?? options.mint);
+      const { sdk } = await getSdkContext();
+      const result = await sdk.state.getTokenClaimStats(mint);
+      await printData(command, result);
+    })
+  );
+}
+
+// src/commands/incorporation.ts
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+function registerIncorporationCommands(program2) {
+  const inc = program2.command("incorporation").description("Incorporation project flows");
+  inc.command("pay").description("Start incorporation payment").option("--mint <address>", "Token mint").option("--payload <json>", "Raw JSON payload override").action(
+    wrapAction(async (command, options) => {
+      const mint = await flagOrPrompt(options.mint, "Token mint:");
+      const { sdk } = await getSdkContext();
+      const payload = options.payload !== void 0 ? JSON.parse(options.payload) : { tokenMint: mint };
+      const result = await sdk.incorporation.startPayment(payload);
+      await printData(command, result);
+    })
+  );
+  inc.command("submit").description("Submit incorporation details").option("--mint <address>", "Token mint").option("--company-name <name>", "Company name").option("--founders <json>", "JSON founders array").option("--category <value>", "Project category").action(
+    wrapAction(async (command, options) => {
+      const mint = await flagOrPrompt(options.mint, "Token mint:");
+      const companyName = await flagOrPrompt(options.companyName, "Company name:");
+      const foundersRaw = await flagOrPrompt(options.founders, "Founders JSON:");
+      const category = await flagOrPrompt(options.category, "Category:");
+      const founders = JSON.parse(foundersRaw);
+      const { sdk } = await getSdkContext();
+      const result = await sdk.incorporation.incorporate({
+        tokenMint: mint,
+        companyName,
+        founders,
+        category
+      });
+      await printData(command, result);
+    })
+  );
+  inc.command("start").description("Start incorporation process").option("--mint <address>", "Token mint").action(
+    wrapAction(async (command, options) => {
+      const mint = await flagOrPrompt(options.mint, "Token mint:");
+      const { sdk } = await getSdkContext();
+      const result = await sdk.incorporation.startIncorporation({ tokenMint: mint });
+      await printData(command, result);
+    })
+  );
+  inc.command("list").description("List incorporation projects for API key").action(
+    wrapAction(async (command) => {
+      const { sdk } = await getSdkContext();
+      const result = await sdk.incorporation.list();
+      await printData(command, result);
+    })
+  );
+  inc.command("details").description("Get incorporation details by token mint").option("--mint <address>", "Token mint").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey4(await flagOrPrompt(options.mint, "Token mint:"));
+      const { sdk } = await getSdkContext();
+      const result = await sdk.incorporation.getDetails(mint);
+      await printData(command, result);
+    })
+  );
+}
+
+// src/commands/launch.ts
+import {
+  BAGS_FEE_SHARE_V2_MAX_CLAIMERS_NON_LUT,
+  createTipTransaction,
+  sendBundleAndConfirm,
+  waitForSlotsToPass
+} from "@bagsfm/bags-sdk";
+import { LAMPORTS_PER_SOL, PublicKey as PublicKey5 } from "@solana/web3.js";
+import chalk5 from "chalk";
+import { confirm as confirm2, input as input2, select as select2 } from "@inquirer/prompts";
+var SOCIAL_PROVIDERS = ["twitter", "github", "kick", "tiktok"];
+var MAX_CLAIMERS = 100;
+var TOTAL_BPS = 1e4;
+async function sendBundleWithTip(sdk, connection, keypair, unsignedTransactions) {
+  const bundleBlockhash = unsignedTransactions[0]?.message.recentBlockhash;
+  if (!bundleBlockhash) {
+    throw new Error("Missing blockhash in bundle transaction.");
+  }
+  let tipLamports = Math.floor(0.015 * LAMPORTS_PER_SOL);
+  try {
+    const fees = await sdk.solana.getJitoRecentFees();
+    if (fees?.landed_tips_95th_percentile) {
+      tipLamports = Math.floor(Number(fees.landed_tips_95th_percentile) * LAMPORTS_PER_SOL);
+    }
+  } catch {
+  }
+  const tipTx = await createTipTransaction(connection, sdk.state.getCommitment(), keypair.publicKey, tipLamports, {
+    blockhash: bundleBlockhash
+  });
+  const signed = [tipTx, ...unsignedTransactions].map((tx) => {
+    tx.sign([keypair]);
+    return tx;
+  });
+  return await sendBundleAndConfirm(signed, sdk);
+}
+function parseFeeClaimers(raw) {
+  if (!raw) {
+    return [];
+  }
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("--fee-claimers must be a JSON array.");
+  }
+  return parsed;
+}
+function printClaimerSummary(claimers) {
+  const usedBps = claimers.reduce((s, c) => s + c.bps, 0);
+  console.log(chalk5.dim("\n  Fee claimers:"));
+  claimers.forEach((c, i) => {
+    const label = c.wallet ? `wallet:${shortAddress(c.wallet)}` : `${c.provider}:${c.username}`;
+    console.log(`    ${i + 1}. ${label.padEnd(28)} ${(c.bps / 100).toFixed(2)}%`);
+  });
+  console.log(chalk5.dim(`  Creator keeps: ${((TOTAL_BPS - usedBps) / 100).toFixed(2)}%
+`));
+}
+async function buildFeeClaimersInteractive() {
+  const shareFees = await confirm2({ message: "Share fees with others?", default: false });
+  if (!shareFees) {
+    return [];
+  }
+  const claimers = [];
+  let usedBps = 0;
+  while (claimers.length < MAX_CLAIMERS && usedBps < TOTAL_BPS) {
+    const remaining = TOTAL_BPS - usedBps;
+    console.log(chalk5.dim(`
+  Adding fee claimer ${claimers.length + 1}/${MAX_CLAIMERS} (${remaining} BPS remaining)`));
+    const type = await select2({
+      message: "Claimer type:",
+      choices: [
+        { name: "Social media account", value: "social" },
+        { name: "Direct wallet address", value: "wallet" }
+      ]
+    });
+    let claimer;
+    if (type === "social") {
+      const provider = await select2({
+        message: "Platform:",
+        choices: SOCIAL_PROVIDERS.map((p) => ({ name: p, value: p }))
+      });
+      const username = await input2({ message: "Username:" });
+      if (!username.trim()) {
+        throw new Error("Username is required.");
+      }
+      const bps = await inputBps(remaining);
+      claimer = { provider, username: username.trim(), bps };
+    } else {
+      const wallet = await input2({ message: "Wallet address:" });
+      if (!wallet.trim()) {
+        throw new Error("Wallet address is required.");
+      }
+      new PublicKey5(wallet.trim());
+      const bps = await inputBps(remaining);
+      claimer = { wallet: wallet.trim(), bps };
+    }
+    claimers.push(claimer);
+    usedBps += claimer.bps;
+    printClaimerSummary(claimers);
+    if (claimers.length >= MAX_CLAIMERS || usedBps >= TOTAL_BPS) {
+      break;
+    }
+    const more = await confirm2({ message: "Add another fee claimer?", default: true });
+    if (!more) {
+      break;
+    }
+  }
+  return claimers;
+}
+async function inputBps(remaining) {
+  const raw = await input2({
+    message: `Basis points (1-${remaining}, e.g. 3000 = 30%):`,
+    validate: (val) => {
+      const n = Number(val);
+      if (!Number.isInteger(n) || n < 1 || n > remaining) {
+        return `Enter a whole number between 1 and ${remaining}.`;
+      }
+      return true;
+    }
+  });
+  return Number(raw);
+}
+function registerLaunchCommands(program2) {
+  const launch = program2.command("launch").description("Token launch flows");
+  launch.command("create").description("Create and launch a token").option("--name <name>", "Token name").option("--symbol <symbol>", "Token symbol").option("--description <description>", "Token description").option("--image-url <url>", "Image URL").option("--image <path>", "Image file path").option("--twitter <url>", "Twitter URL").option("--website <url>", "Website URL").option("--telegram <url>", "Telegram URL").option("--initial-buy <lamports>", "Initial buy amount in lamports", Number).option("--fee-claimers <json>", "JSON array of fee claimers").option("--partner <pubkey>", "Partner wallet").option("--partner-config <pubkey>", "Partner config PDA").option("--skip-confirm", "Skip final confirmation").action(
+    wrapAction(async (command, options) => {
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      const name = await flagOrPrompt(options.name, "Token name:");
+      const symbol = await flagOrPrompt(options.symbol, "Token symbol:");
+      const description = await flagOrPrompt(options.description, "Token description:");
+      const imageChoice = await promptOneOf(
+        { imageUrl: options.imageUrl, image: options.image },
+        { imageUrl: "Image URL", image: "Image file path" },
+        { imageUrl: "Image URL:", image: "Image file path:" }
+      );
+      const imageUrl = imageChoice.key === "imageUrl" ? imageChoice.value : void 0;
+      const image = imageChoice.key === "image" ? imageChoice.value : void 0;
+      const initialBuy = await flagOrPromptNumber(options.initialBuy, "Initial buy (lamports):", 1e7);
+      const twitter = await optionalFlagOrPrompt(options.twitter, "Twitter URL (optional):");
+      const website = await optionalFlagOrPrompt(options.website, "Website URL (optional):");
+      const telegram = await optionalFlagOrPrompt(options.telegram, "Telegram URL (optional):");
+      const feeClaimersInput = options.feeClaimers ? parseFeeClaimers(options.feeClaimers) : await buildFeeClaimersInteractive();
+      if (!options.skipConfirm) {
+        let summary = `Launch ${name} (${symbol}) with initial buy ${initialBuy} lamports from ${keypair.publicKey.toBase58()}`;
+        if (feeClaimersInput.length > 0) {
+          const allocBps = feeClaimersInput.reduce((s, c) => s + c.bps, 0);
+          const lines = feeClaimersInput.map((c) => {
+            const label = c.wallet ? `wallet:${shortAddress(c.wallet)}` : `${c.provider}:${c.username}`;
+            return `  ${label} ${(c.bps / 100).toFixed(2)}%`;
+          });
+          lines.push(`  creator: ${((TOTAL_BPS - allocBps) / 100).toFixed(2)}%`);
+          summary += `
+
+Fee split:
+${lines.join("\n")}`;
+        } else {
+          summary += "\n\nFee split: 100% to creator";
+        }
+        const ok = await promptConfirm(`${summary}
+
+Proceed?`);
+        if (!ok) {
+          return;
+        }
+      }
+      const metadata = await sdk.tokenLaunch.createTokenInfoAndMetadata({
+        imageUrl,
+        imagePath: image,
+        name,
+        symbol: symbol.toUpperCase().replace("$", ""),
+        description,
+        twitter,
+        website,
+        telegram
+      });
+      const tokenMint = new PublicKey5(metadata.tokenMint);
+      const feeClaimers = [];
+      if (feeClaimersInput.length > 0) {
+        const allocatedBps = feeClaimersInput.reduce((sum, c) => sum + c.bps, 0);
+        const creatorBps = TOTAL_BPS - allocatedBps;
+        if (creatorBps < 0) {
+          throw new Error("Total fee claimer BPS exceeds 10000.");
+        }
+        if (creatorBps > 0) {
+          feeClaimers.push({ user: keypair.publicKey, userBps: creatorBps });
+        }
+        for (const claimer of feeClaimersInput) {
+          if (claimer.wallet) {
+            feeClaimers.push({ user: new PublicKey5(claimer.wallet), userBps: claimer.bps });
+          } else if (claimer.username && claimer.provider) {
+            const user = await sdk.state.getLaunchWalletV2(claimer.username, claimer.provider);
+            feeClaimers.push({ user: user.wallet, userBps: claimer.bps });
+          } else {
+            throw new Error("Each fee claimer must have either wallet or provider+username.");
+          }
+        }
+      } else {
+        feeClaimers.push({ user: keypair.publicKey, userBps: TOTAL_BPS });
+      }
+      let additionalLookupTables;
+      if (feeClaimers.length > BAGS_FEE_SHARE_V2_MAX_CLAIMERS_NON_LUT) {
+        const lutResult = await sdk.config.getConfigCreationLookupTableTransactions({
+          payer: keypair.publicKey,
+          baseMint: tokenMint,
+          feeClaimers
+        });
+        await signAndSend(connection, commitment, lutResult.creationTransaction, keypair);
+        await waitForSlotsToPass(connection, commitment, 1);
+        for (const tx of lutResult.extendTransactions) {
+          await signAndSend(connection, commitment, tx, keypair);
+        }
+        additionalLookupTables = lutResult.lutAddresses;
+      }
+      const configResult = await sdk.config.createBagsFeeShareConfig({
+        payer: keypair.publicKey,
+        baseMint: tokenMint,
+        feeClaimers,
+        partner: options.partner ? new PublicKey5(options.partner) : void 0,
+        partnerConfig: options.partnerConfig ? new PublicKey5(options.partnerConfig) : void 0,
+        additionalLookupTables
+      });
+      if (Array.isArray(configResult.bundles)) {
+        for (const bundle of configResult.bundles) {
+          await sendBundleWithTip(sdk, connection, keypair, bundle);
+        }
+      }
+      if (Array.isArray(configResult.transactions)) {
+        for (const tx of configResult.transactions) {
+          await signAndSend(connection, commitment, tx, keypair);
+        }
+      }
+      const launchTx = await sdk.tokenLaunch.createLaunchTransaction({
+        metadataUrl: metadata.tokenMetadata,
+        tokenMint,
+        launchWallet: keypair.publicKey,
+        initialBuyLamports: initialBuy,
+        configKey: configResult.meteoraConfigKey
+      });
+      const signature = await signAndSend(connection, commitment, launchTx, keypair);
+      await printData(command, {
+        tokenMint: metadata.tokenMint,
+        metadataUrl: metadata.tokenMetadata,
+        configKey: configResult.meteoraConfigKey?.toString?.() ?? configResult.meteoraConfigKey,
+        signature
+      });
+    })
+  );
+  launch.command("feed").description("Get token launch feed").option("--limit <n>", "Number of items", Number).action(
+    wrapAction(async (command, options) => {
+      const { sdk } = await getSdkContext();
+      const result = await sdk.state.getTokenLaunchFeed({ limit: options.limit ?? 20 });
+      await printData(command, result);
+    })
+  );
+  launch.command("creators").description("Get creators for a token mint").option("--mint <address>", "Token mint").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey5(await flagOrPrompt(options.mint, "Token mint:"));
+      const { sdk } = await getSdkContext();
+      const result = await sdk.state.getTokenCreators(mint);
+      await printData(command, result);
+    })
+  );
+}
+
+// src/commands/partner.ts
+import { PublicKey as PublicKey6 } from "@solana/web3.js";
+function registerPartnerCommands(program2) {
+  const partner = program2.command("partner").description("Partner configuration and claim");
+  partner.command("create").description("Create partner config for local wallet").option("--skip-confirm", "Skip confirmation").action(
+    wrapAction(async (command, options) => {
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Create partner config for ${keypair.publicKey.toBase58()}?`);
+        if (!ok) return;
+      }
+      const tx = await sdk.partner.createPartnerConfigTransaction(keypair.publicKey);
+      const signature = await signAndSend(connection, commitment, tx, keypair);
+      await printData(command, { signature });
+    })
+  );
+  partner.command("stats").description("Get partner stats").option("--partner <pubkey>", "Partner wallet pubkey").action(
+    wrapAction(async (command, options) => {
+      const { sdk } = await getSdkContext();
+      const { keypair } = await getLocalSigner();
+      const partnerWallet = new PublicKey6(await flagOrPrompt(options.partner, "Partner wallet (default local):"));
+      const stats = await sdk.partner.getPartnerStats(partnerWallet ?? keypair.publicKey);
+      await printData(command, stats);
+    })
+  );
+  partner.command("claim").description("Claim partner fees").option("--skip-confirm", "Skip confirmation").action(
+    wrapAction(async (command, options) => {
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(`Claim partner fees for ${keypair.publicKey.toBase58()}?`);
+        if (!ok) return;
+      }
+      const txs = await sdk.partner.getPartnerClaimTransactions(keypair.publicKey);
+      const signatures = [];
+      for (const tx of txs) {
+        signatures.push(await signAndSend(connection, commitment, tx, keypair));
+      }
+      await printData(command, { signatures });
+    })
+  );
+}
+
+// src/commands/pool.ts
+import { PublicKey as PublicKey7 } from "@solana/web3.js";
+function registerPoolCommands(program2) {
+  const pool = program2.command("pool").description("Pool lookup commands");
+  pool.command("list").description("List Bags pools").option("--limit <n>", "Limit", Number).option("--offset <n>", "Offset", Number).action(
+    wrapAction(async (command, options) => {
+      const { sdk } = await getSdkContext();
+      const result = await sdk.state.getBagsPools({
+        limit: options.limit ?? 50,
+        offset: options.offset ?? 0
+      });
+      await printData(command, result);
+    })
+  );
+  pool.command("get").description("Get Bags pool by token mint").option("--mint <address>", "Token mint").action(
+    wrapAction(async (command, options) => {
+      const mint = new PublicKey7(await flagOrPrompt(options.mint, "Token mint:"));
+      const { sdk } = await getSdkContext();
+      const result = await sdk.state.getBagsPoolByTokenMint(mint);
+      await printData(command, result);
+    })
+  );
+}
+
+// src/commands/settings.ts
+function registerSettingsCommands(program2) {
+  const settings = program2.command("settings").description("CLI settings");
+  settings.command("show").description("Show current settings").action(
+    wrapAction(async (command) => {
+      const config = await loadCliConfig();
+      await printData(command, config);
+    })
+  );
+  settings.command("set").description("Set one or more settings").option("--rpc-url <url>", "Default RPC URL").option("--commitment <level>", "processed|confirmed|finalized").option("--output <mode>", "pretty|table|json").action(
+    wrapAction(async (command, options) => {
+      const current = await loadCliConfig();
+      const next = {
+        rpcUrl: options.rpcUrl ?? current.rpcUrl,
+        commitment: options.commitment ?? current.commitment,
+        output: options.output ?? current.output
+      };
+      await saveCliConfig(next);
+      await printData(command, next);
+    })
+  );
+}
+
+// src/commands/trade.ts
+import { PublicKey as PublicKey8 } from "@solana/web3.js";
+async function resolveQuoteOptions(options) {
+  const inputMint = new PublicKey8(await flagOrPrompt(options.inputMint, "Input mint:"));
+  const outputMint = new PublicKey8(await flagOrPrompt(options.outputMint, "Output mint:"));
+  const amount = await flagOrPromptNumber(options.amount, "Amount (base units):");
+  const slippageMode = await flagOrPrompt(options.slippageMode, "Slippage mode (auto/manual):");
+  const slippageBps = slippageMode === "manual" ? await flagOrPromptNumber(options.slippageBps, "Slippage BPS (e.g. 100):") : void 0;
+  return { inputMint, outputMint, amount, slippageMode, slippageBps };
+}
+function registerTradeCommands(program2) {
+  const trade = program2.command("trade").description("Quote and execute swaps");
+  trade.command("quote").description("Get a swap quote").option("--input-mint <address>", "Input token mint").option("--output-mint <address>", "Output token mint").option("--amount <amount>", "Amount in base units", Number).option("--slippage-mode <mode>", "auto or manual", "auto").option("--slippage-bps <bps>", "Required for manual mode", Number).action(
+    wrapAction(async (command, options) => {
+      const { sdk } = await getSdkContext();
+      const quoteArgs = await resolveQuoteOptions(options);
+      const quote = await sdk.trade.getQuote(quoteArgs);
+      await printData(command, quote);
+    })
+  );
+  trade.command("swap").description("Execute a swap (quote + transaction send)").option("--input-mint <address>", "Input token mint").option("--output-mint <address>", "Output token mint").option("--amount <amount>", "Amount in base units", Number).option("--slippage-mode <mode>", "auto or manual", "auto").option("--slippage-bps <bps>", "Required for manual mode", Number).option("--skip-confirm", "Skip transaction confirmation").action(
+    wrapAction(async (command, options) => {
+      const quoteArgs = await resolveQuoteOptions(options);
+      const { sdk, connection } = await getSdkContext();
+      const { keypair, commitment } = await getLocalSigner();
+      const quote = await sdk.trade.getQuote(quoteArgs);
+      if (!options.skipConfirm) {
+        const ok = await promptConfirm(
+          `Swap ${quoteArgs.amount} from ${quoteArgs.inputMint.toBase58()} to ${quoteArgs.outputMint.toBase58()}?`
+        );
+        if (!ok) {
+          return;
+        }
+      }
+      const swap = await sdk.trade.createSwapTransaction({
+        quoteResponse: quote,
+        userPublicKey: keypair.publicKey
+      });
+      const signature = await signAndSend(connection, commitment, swap.transaction, keypair);
+      await printData(command, { signature, quote, computeUnitLimit: swap.computeUnitLimit });
+    })
+  );
+}
+
+// src/commands/wallet.ts
+import { Connection as Connection2, PublicKey as PublicKey9 } from "@solana/web3.js";
+function registerWalletCommands(program2) {
+  const wallet = program2.command("wallet").description("Wallet management commands");
+  wallet.command("generate").description("Generate and save a new local Solana keypair").option("--force", "Overwrite existing keypair").action(
+    wrapAction(async (command, options) => {
+      const kp = await generateKeypair(Boolean(options.force));
+      await printData(command, { publicKey: kp.publicKey.toBase58(), path: BAGS_KEYPAIR_PATH });
+    })
+  );
+  wallet.command("import").description("Import keypair from base58 key or JSON secret file").option("--key <base58>", "Base58 private key").option("--file <path>", "JSON file containing secret key bytes").action(
+    wrapAction(async (command, options) => {
+      let kp;
+      if (options.key) {
+        kp = await importKeypairFromBase58(options.key);
+      } else if (options.file) {
+        kp = await importKeypairFromJsonFile(options.file);
+      } else {
+        const method = await flagOrPrompt(void 0, "Import method (key/file):");
+        if (method === "file") {
+          const file = await flagOrPrompt(void 0, "Path to keypair JSON file:");
+          kp = await importKeypairFromJsonFile(file);
+        } else {
+          const key = await flagOrPrompt(void 0, "Base58 private key:");
+          kp = await importKeypairFromBase58(key);
+        }
+      }
+      await printData(command, { publicKey: kp.publicKey.toBase58(), path: BAGS_KEYPAIR_PATH });
+    })
+  );
+  wallet.command("show").description("Show wallet address and SOL balance").option("--rpc <url>", "Override RPC URL").action(
+    wrapAction(async (command, options) => {
+      const kp = await loadKeypair();
+      if (!kp) {
+        throw new Error("No local keypair found. Run `bags wallet generate` or `bags wallet import`.");
+      }
+      const config = await loadCliConfig();
+      const connection = new Connection2(options.rpc ?? config.rpcUrl, config.commitment);
+      let sol = "unknown";
+      try {
+        const lamports = await connection.getBalance(kp.publicKey, config.commitment);
+        sol = `${lamportsToSol(lamports)} SOL`;
+      } catch {
+      }
+      await printData(command, {
+        publicKey: kp.publicKey.toBase58(),
+        balance: sol,
+        keypairPath: BAGS_KEYPAIR_PATH
+      });
+    })
+  );
+  wallet.command("balance").description("Show SOL or SPL token balance").option("--rpc <url>", "Override RPC URL").option("--token <mint>", "SPL token mint address").action(
+    wrapAction(async (command, options) => {
+      const kp = await loadKeypair();
+      if (!kp) {
+        throw new Error("No local keypair found.");
+      }
+      const config = await loadCliConfig();
+      const connection = new Connection2(options.rpc ?? config.rpcUrl, config.commitment);
+      if (options.token) {
+        const mint = new PublicKey9(options.token);
+        const accounts = await connection.getParsedTokenAccountsByOwner(kp.publicKey, { mint });
+        if (accounts.value.length === 0) {
+          await printData(command, {
+            publicKey: kp.publicKey.toBase58(),
+            token: mint.toBase58(),
+            balance: "0"
+          });
+          return;
+        }
+        const info = accounts.value[0].account.data.parsed.info.tokenAmount;
+        await printData(command, {
+          publicKey: kp.publicKey.toBase58(),
+          token: mint.toBase58(),
+          balance: `${info.uiAmountString} (raw: ${info.amount})`
+        });
+        return;
+      }
+      const lamports = await connection.getBalance(kp.publicKey, config.commitment);
+      await printData(command, {
+        publicKey: kp.publicKey.toBase58(),
+        balance: `${lamportsToSol(lamports)} SOL`
+      });
+    })
+  );
+}
+
+// src/index.ts
+var program = new Command();
+program.name("bags").description("Bags CLI - auth, trading, launches, fees, and config").version("0.1.0").option("--json", "Output machine-readable JSON where supported");
+registerSetupCommand(program);
+registerAuthCommands(program);
+registerWalletCommands(program);
+registerFeesCommands(program);
+registerTradeCommands(program);
+registerLaunchCommands(program);
+registerConfigCommands(program);
+registerPartnerCommands(program);
+registerPoolCommands(program);
+registerDexscreenerCommands(program);
+registerIncorporationCommands(program);
+registerSettingsCommands(program);
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    handleCliError(error);
+  }
+}
+void main();
+//# sourceMappingURL=index.js.map