naracli 1.0.17 → 1.0.22

package/src/cli/index.ts

@@ -3,23 +3,229 @@
  */
 
 import { Command } from "commander";
-import { registerConfigCommands } from "./commands/config";
-import { registerPoolCommands } from "./commands/pool";
-import { registerSwapCommands } from "./commands/swap";
-import { registerMigrateCommands } from "./commands/migrate";
+import {
+  Transaction,
+  VersionedTransaction,
+} from "@solana/web3.js";
 import { registerWalletCommands } from "./commands/wallet";
 import { registerQuestCommands } from "./commands/quest";
+import { registerSkillsCommands } from "./commands/skills";
+import { registerZkIdCommands } from "./commands/zkid";
+import {
+  handleWalletAddress,
+  handleWalletBalance,
+  handleTokenBalance,
+  handleTxStatus,
+  handleTransferSol,
+  handleTransferToken,
+} from "./commands/wallet";
+import { loadWallet, getRpcUrl } from "./utils/wallet";
+import { NaraSDK } from "nara-sdk";
+import { printError, printInfo, printSuccess } from "./utils/output";
+import type {
+  GlobalOptions,
+  WalletBalanceOptions,
+  TokenBalanceOptions,
+  TxStatusOptions,
+  TransferSolOptions,
+  TransferTokenOptions,
+} from "./types";
+
+/**
+ * Poll for transaction confirmation via HTTP
+ */
+async function pollConfirmation(
+  connection: any,
+  signature: string,
+  timeoutMs = 15000,
+  intervalMs = 1000
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const { value } = await connection.getSignatureStatuses([signature]);
+    const status = value?.[0];
+    if (status) {
+      if (status.err) {
+        throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
+      }
+      if (status.confirmationStatus === "confirmed" || status.confirmationStatus === "finalized") {
+        return;
+      }
+    }
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  throw new Error("Transaction confirmation timeout");
+}
 
 /**
  * Register all CLI commands
  * @param program Commander program
  */
 export function registerCommands(program: Command): void {
-  // Register command modules
-  registerConfigCommands(program);
-  registerPoolCommands(program);
-  registerSwapCommands(program);
-  registerMigrateCommands(program);
+  // wallet (create, import only)
   registerWalletCommands(program);
+
+  // quest
   registerQuestCommands(program);
+
+  // skills
+  registerSkillsCommands(program);
+
+  // zkid
+  registerZkIdCommands(program);
+
+  // Top-level: address
+  program
+    .command("address")
+    .description("Show wallet address")
+    .action(async () => {
+      const opts = program.opts() as GlobalOptions;
+      try {
+        await handleWalletAddress(opts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Top-level: balance
+  program
+    .command("balance")
+    .description("Check NARA balance")
+    .argument("[address]", "Wallet address (optional, defaults to current wallet)")
+    .action(async (address: string | undefined) => {
+      const opts = program.opts() as WalletBalanceOptions;
+      try {
+        await handleWalletBalance(address, opts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Top-level: token-balance
+  program
+    .command("token-balance <token-address>")
+    .description("Check token balance")
+    .option("--owner <address>", "Owner address (optional, defaults to current wallet)")
+    .action(async (tokenAddress: string, options: { owner?: string }) => {
+      const opts = program.opts() as TokenBalanceOptions;
+      try {
+        await handleTokenBalance(tokenAddress, { ...opts, ...options });
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Top-level: tx-status
+  program
+    .command("tx-status <signature>")
+    .description("Check transaction status")
+    .action(async (signature: string) => {
+      const opts = program.opts() as TxStatusOptions;
+      try {
+        await handleTxStatus(signature, opts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Top-level: transfer
+  program
+    .command("transfer <to> <amount>")
+    .description("Transfer NARA to another wallet")
+    .option("-e, --export-tx", "Export unsigned transaction", false)
+    .action(async (to: string, amount: string, options: { exportTx?: boolean }) => {
+      const opts = program.opts() as TransferSolOptions;
+      try {
+        await handleTransferSol(to, amount, { ...opts, ...options });
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Top-level: transfer-token
+  program
+    .command("transfer-token <token-address> <to> <amount>")
+    .description("Transfer tokens to another wallet")
+    .option("--decimals <number>", "Token decimals", "6")
+    .option("-e, --export-tx", "Export unsigned transaction", false)
+    .action(async (tokenAddress: string, to: string, amount: string, options: { decimals?: string; exportTx?: boolean }) => {
+      const opts = program.opts() as TransferTokenOptions;
+      try {
+        await handleTransferToken(tokenAddress, to, amount, { ...opts, decimals: options.decimals ? parseInt(options.decimals) : undefined, exportTx: options.exportTx });
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  // Top-level: sign
+  program
+    .command("sign <base64-tx>")
+    .description("Sign a base64-encoded transaction")
+    .option("--send", "Send the signed transaction", false)
+    .action(async (base64Tx: string, options: { send?: boolean }) => {
+      const opts = program.opts() as GlobalOptions;
+      try {
+        const wallet = await loadWallet(opts.wallet);
+        const buf = Buffer.from(base64Tx, "base64");
+
+        // Try VersionedTransaction first, fall back to legacy
+        let tx: Transaction | VersionedTransaction;
+        try {
+          tx = VersionedTransaction.deserialize(new Uint8Array(buf));
+        } catch {
+          tx = Transaction.from(buf);
+        }
+
+        // Sign
+        if (tx instanceof VersionedTransaction) {
+          tx.sign([wallet]);
+        } else {
+          tx.sign(wallet);
+        }
+
+        if (options.send) {
+          const rpcUrl = getRpcUrl(opts.rpcUrl);
+          const sdk = new NaraSDK({ rpcUrl, commitment: "confirmed" });
+          const connection = sdk.getConnection();
+
+          printInfo("Sending transaction...");
+          let signature: string;
+          if (tx instanceof VersionedTransaction) {
+            signature = await connection.sendTransaction(tx, { maxRetries: 3 });
+          } else {
+            signature = await connection.sendRawTransaction(tx.serialize(), { skipPreflight: true });
+          }
+
+          printInfo("Confirming transaction...");
+          await pollConfirmation(connection, signature);
+
+          if (opts.json) {
+            console.log(JSON.stringify({ signature }, null, 2));
+          } else {
+            printSuccess("Transaction sent!");
+            console.log(`Signature: ${signature}`);
+          }
+        } else {
+          // Output signed base64
+          const serialized = tx instanceof VersionedTransaction
+            ? Buffer.from(tx.serialize()).toString("base64")
+            : Buffer.from(tx.serialize()).toString("base64");
+
+          if (opts.json) {
+            console.log(JSON.stringify({ transaction: serialized }, null, 2));
+          } else {
+            console.log(serialized);
+          }
+        }
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
 }

package/src/cli/prompts/searchMultiselect.ts

@@ -0,0 +1,297 @@
+import * as readline from 'readline';
+import { Writable } from 'stream';
+import pc from 'picocolors';
+
+// Silent writable stream to prevent readline from echoing input
+const silentOutput = new Writable({
+  write(_chunk, _encoding, callback) {
+    callback();
+  },
+});
+
+export interface SearchItem<T> {
+  value: T;
+  label: string;
+  hint?: string;
+}
+
+export interface LockedSection<T> {
+  title: string;
+  items: SearchItem<T>[];
+}
+
+export interface SearchMultiselectOptions<T> {
+  message: string;
+  items: SearchItem<T>[];
+  maxVisible?: number;
+  initialSelected?: T[];
+  /** If true, require at least one item to be selected before submitting */
+  required?: boolean;
+  /** Locked section shown above the searchable list - items are always selected and can't be toggled */
+  lockedSection?: LockedSection<T>;
+}
+
+const S_STEP_ACTIVE = pc.green('◆');
+const S_STEP_CANCEL = pc.red('■');
+const S_STEP_SUBMIT = pc.green('◇');
+const S_RADIO_ACTIVE = pc.green('●');
+const S_RADIO_INACTIVE = pc.dim('○');
+const S_CHECKBOX_LOCKED = pc.green('✓');
+const S_BULLET = pc.green('•');
+const S_BAR = pc.dim('│');
+const S_BAR_H = pc.dim('─');
+
+export const cancelSymbol = Symbol('cancel');
+
+/**
+ * Interactive search multiselect prompt.
+ * Allows users to filter a long list by typing and select multiple items.
+ * Optionally supports a "locked" section that displays always-selected items.
+ */
+export async function searchMultiselect<T>(
+  options: SearchMultiselectOptions<T>
+): Promise<T[] | symbol> {
+  const {
+    message,
+    items,
+    maxVisible = 8,
+    initialSelected = [],
+    required = false,
+    lockedSection,
+  } = options;
+
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: silentOutput,
+      terminal: false,
+    });
+
+    // Enable raw mode for keypress detection
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    readline.emitKeypressEvents(process.stdin, rl);
+
+    let query = '';
+    let cursor = 0;
+    const selected = new Set<T>(initialSelected);
+    let lastRenderHeight = 0;
+
+    // Locked items are always included in the result
+    const lockedValues = lockedSection ? lockedSection.items.map((i) => i.value) : [];
+
+    const filter = (item: SearchItem<T>, q: string): boolean => {
+      if (!q) return true;
+      const lowerQ = q.toLowerCase();
+      return (
+        item.label.toLowerCase().includes(lowerQ) ||
+        String(item.value).toLowerCase().includes(lowerQ)
+      );
+    };
+
+    const getFiltered = (): SearchItem<T>[] => {
+      return items.filter((item) => filter(item, query));
+    };
+
+    const clearRender = (): void => {
+      if (lastRenderHeight > 0) {
+        // Move up and clear each line
+        process.stdout.write(`\x1b[${lastRenderHeight}A`);
+        for (let i = 0; i < lastRenderHeight; i++) {
+          process.stdout.write('\x1b[2K\x1b[1B');
+        }
+        process.stdout.write(`\x1b[${lastRenderHeight}A`);
+      }
+    };
+
+    const render = (state: 'active' | 'submit' | 'cancel' = 'active'): void => {
+      clearRender();
+
+      const lines: string[] = [];
+      const filtered = getFiltered();
+
+      // Header
+      const icon =
+        state === 'active' ? S_STEP_ACTIVE : state === 'cancel' ? S_STEP_CANCEL : S_STEP_SUBMIT;
+      lines.push(`${icon}  ${pc.bold(message)}`);
+
+      if (state === 'active') {
+        // Locked section (universal agents)
+        if (lockedSection && lockedSection.items.length > 0) {
+          lines.push(`${S_BAR}`);
+          const lockedTitle = `${pc.bold(lockedSection.title)} ${pc.dim('── always included')}`;
+          lines.push(`${S_BAR}  ${S_BAR_H}${S_BAR_H} ${lockedTitle} ${S_BAR_H.repeat(12)}`);
+          for (const item of lockedSection.items) {
+            lines.push(`${S_BAR}    ${S_BULLET} ${pc.bold(item.label)}`);
+          }
+          lines.push(`${S_BAR}`);
+          lines.push(
+            `${S_BAR}  ${S_BAR_H}${S_BAR_H} ${pc.bold('Additional agents')} ${S_BAR_H.repeat(29)}`
+          );
+        }
+
+        // Search input
+        const searchLine = `${S_BAR}  ${pc.dim('Search:')} ${query}${pc.inverse(' ')}`;
+        lines.push(searchLine);
+
+        // Hint
+        lines.push(`${S_BAR}  ${pc.dim('↑↓ move, space select, enter confirm')}`);
+        lines.push(`${S_BAR}`);
+
+        // Items
+        const visibleStart = Math.max(
+          0,
+          Math.min(cursor - Math.floor(maxVisible / 2), filtered.length - maxVisible)
+        );
+        const visibleEnd = Math.min(filtered.length, visibleStart + maxVisible);
+        const visibleItems = filtered.slice(visibleStart, visibleEnd);
+
+        if (filtered.length === 0) {
+          lines.push(`${S_BAR}  ${pc.dim('No matches found')}`);
+        } else {
+          for (let i = 0; i < visibleItems.length; i++) {
+            const item = visibleItems[i]!;
+            const actualIndex = visibleStart + i;
+            const isSelected = selected.has(item.value);
+            const isCursor = actualIndex === cursor;
+
+            const radio = isSelected ? S_RADIO_ACTIVE : S_RADIO_INACTIVE;
+            const label = isCursor ? pc.underline(item.label) : item.label;
+            const hint = item.hint ? pc.dim(` (${item.hint})`) : '';
+
+            const prefix = isCursor ? pc.cyan('❯') : ' ';
+            lines.push(`${S_BAR} ${prefix} ${radio} ${label}${hint}`);
+          }
+
+          // Show count if more items
+          const hiddenBefore = visibleStart;
+          const hiddenAfter = filtered.length - visibleEnd;
+          if (hiddenBefore > 0 || hiddenAfter > 0) {
+            const parts: string[] = [];
+            if (hiddenBefore > 0) parts.push(`↑ ${hiddenBefore} more`);
+            if (hiddenAfter > 0) parts.push(`↓ ${hiddenAfter} more`);
+            lines.push(`${S_BAR}  ${pc.dim(parts.join('  '))}`);
+          }
+        }
+
+        // Selected summary (include locked items)
+        lines.push(`${S_BAR}`);
+        const allSelectedLabels = [
+          ...(lockedSection ? lockedSection.items.map((i) => i.label) : []),
+          ...items.filter((item) => selected.has(item.value)).map((item) => item.label),
+        ];
+        if (allSelectedLabels.length === 0) {
+          lines.push(`${S_BAR}  ${pc.dim('Selected: (none)')}`);
+        } else {
+          const summary =
+            allSelectedLabels.length <= 3
+              ? allSelectedLabels.join(', ')
+              : `${allSelectedLabels.slice(0, 3).join(', ')} +${allSelectedLabels.length - 3} more`;
+          lines.push(`${S_BAR}  ${pc.green('Selected:')} ${summary}`);
+        }
+
+        lines.push(`${pc.dim('└')}`);
+      } else if (state === 'submit') {
+        // Final state - show what was selected (including locked)
+        const allSelectedLabels = [
+          ...(lockedSection ? lockedSection.items.map((i) => i.label) : []),
+          ...items.filter((item) => selected.has(item.value)).map((item) => item.label),
+        ];
+        lines.push(`${S_BAR}  ${pc.dim(allSelectedLabels.join(', '))}`);
+      } else if (state === 'cancel') {
+        lines.push(`${S_BAR}  ${pc.strikethrough(pc.dim('Cancelled'))}`);
+      }
+
+      process.stdout.write(lines.join('\n') + '\n');
+      lastRenderHeight = lines.length;
+    };
+
+    const cleanup = (): void => {
+      process.stdin.removeListener('keypress', keypressHandler);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      rl.close();
+    };
+
+    const submit = (): void => {
+      // If required and no locked items, don't allow submitting with no selection
+      if (required && selected.size === 0 && lockedValues.length === 0) {
+        return;
+      }
+      render('submit');
+      cleanup();
+      // Include locked values in the result
+      resolve([...lockedValues, ...Array.from(selected)]);
+    };
+
+    const cancel = (): void => {
+      render('cancel');
+      cleanup();
+      resolve(cancelSymbol);
+    };
+
+    // Handle keypresses
+    const keypressHandler = (_str: string, key: readline.Key): void => {
+      if (!key) return;
+
+      const filtered = getFiltered();
+
+      if (key.name === 'return') {
+        submit();
+        return;
+      }
+
+      if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+        cancel();
+        return;
+      }
+
+      if (key.name === 'up') {
+        cursor = Math.max(0, cursor - 1);
+        render();
+        return;
+      }
+
+      if (key.name === 'down') {
+        cursor = Math.min(filtered.length - 1, cursor + 1);
+        render();
+        return;
+      }
+
+      if (key.name === 'space') {
+        const item = filtered[cursor];
+        if (item) {
+          if (selected.has(item.value)) {
+            selected.delete(item.value);
+          } else {
+            selected.add(item.value);
+          }
+        }
+        render();
+        return;
+      }
+
+      if (key.name === 'backspace') {
+        query = query.slice(0, -1);
+        cursor = 0;
+        render();
+        return;
+      }
+
+      // Regular character input
+      if (key.sequence && !key.ctrl && !key.meta && key.sequence.length === 1) {
+        query += key.sequence;
+        cursor = 0;
+        render();
+        return;
+      }
+    };
+
+    process.stdin.on('keypress', keypressHandler);
+
+    // Initial render
+    render();
+  });
+}

package/src/cli/types.ts

@@ -2,8 +2,6 @@
  * CLI-specific types and interfaces
  */
 
-import { PublicKey } from "@solana/web3.js";
-
 /**
  * Global options available on all commands
  */
@@ -16,142 +14,6 @@ export interface GlobalOptions {
   json?: boolean;
 }
 
-/**
- * Config create command options
- */
-export interface ConfigCreateOptions extends GlobalOptions {
-  /** Fee claimer wallet address */
-  feeClaimer?: string;
-  /** Leftover token receiver wallet address */
-  leftoverReceiver?: string;
-  /** Total token supply */
-  totalSupply?: number;
-  /** Initial market cap */
-  initialMcap?: number;
-  /** Migration market cap */
-  migrationMcap?: number;
-  /** Export unsigned transaction */
-  exportTx?: boolean;
-}
-
-/**
- * Pool create command options
- */
-export interface PoolCreateOptions extends GlobalOptions {
-  /** Token name */
-  name: string;
-  /** Token symbol */
-  symbol: string;
-  /** Metadata URI */
-  uri: string;
-  /** DBC config address */
-  dbcConfig: string;
-  /** Pool creator address */
-  creator?: string;
-  /** Export unsigned transaction */
-  exportTx?: boolean;
-}
-
-/**
- * Pool create with buy command options
- */
-export interface PoolCreateWithBuyOptions extends PoolCreateOptions {
-  /** Initial buy amount in SOL */
-  amount: number;
-  /** Buyer address */
-  buyer?: string;
-  /** Token receiver address */
-  receiver?: string;
-  /** Slippage in basis points */
-  slippage?: number;
-}
-
-/**
- * Pool info command options
- */
-export interface PoolInfoOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-}
-
-/**
- * Swap buy command options
- */
-export interface SwapBuyOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-  /** Amount in SOL */
-  amount: number;
-  /** Slippage in basis points */
-  slippage?: number;
-  /** Swap mode */
-  mode?: string;
-  /** Export unsigned transaction */
-  exportTx?: boolean;
-}
-
-/**
- * Swap sell command options
- */
-export interface SwapSellOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-  /** Amount in tokens */
-  amount: number;
-  /** Token decimals */
-  decimals?: number;
-  /** Slippage in basis points */
-  slippage?: number;
-  /** Swap mode */
-  mode?: string;
-  /** Export unsigned transaction */
-  exportTx?: boolean;
-}
-
-/**
- * Swap quote command options
- */
-export interface SwapQuoteOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-  /** Amount */
-  amount: number;
-  /** Direction: buy or sell */
-  direction: string;
-  /** Token decimals (for sell only) */
-  decimals?: number;
-  /** Slippage in basis points */
-  slippage?: number;
-}
-
-/**
- * Migrate launch command options
- */
-export interface MigrateLaunchOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-  /** Export unsigned transaction */
-  exportTx?: boolean;
-}
-
-/**
- * Migrate create locker command options
- */
-export interface MigrateCreateLockerOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-  /** Export unsigned transaction */
-  exportTx?: boolean;
-}
-
-/**
- * Migrate check command options
- */
-export interface MigrateCheckOptions extends GlobalOptions {
-  /** Token address */
-  tokenAddress: string;
-}
-
 /**
  * Wallet balance command options
  */

package/src/cli/utils/transaction.ts

@@ -8,7 +8,7 @@ import {
   Keypair,
   Connection,
 } from "@solana/web3.js";
-import { NaraSDK } from "../../client";
+import { NaraSDK } from "nara-sdk";
 import { printInfo, printSuccess } from "./output";
 
 /**