naracli 1.0.30 → 1.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "naracli",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "description": "CLI for the Nara chain (Solana-compatible)",
   "module": "index.ts",
   "main": "index.ts",
@@ -53,7 +53,7 @@
     "bs58": "^6.0.0",
     "commander": "^12.1.0",
     "ed25519-hd-key": "^1.3.0",
-    "nara-sdk": "^1.0.30",
+    "nara-sdk": "^1.0.32",
     "picocolors": "^1.1.1"
   }
 }

package/src/cli/commands/agent.ts

@@ -41,7 +41,7 @@ async function handleAgentRegister(agentId: string, options: GlobalOptions) {
   if (!options.json) printInfo(`Registering agent "${agentId}"...`);
   const result = await registerAgent(connection, wallet, agentId);
   if (!options.json) printSuccess(`Agent "${agentId}" registered!`);
-  await addAgentId(agentId);
+  addAgentId(agentId);
 
   if (options.json) {
     formatOutput({ agentId, signature: result.signature, agentPubkey: result.agentPubkey.toBase58() }, true);

package/src/cli/commands/config.ts

@@ -0,0 +1,118 @@
+/**
+ * Config commands - manage CLI configuration
+ */
+
+import { Command } from "commander";
+import { loadAgentConfig, saveAgentConfig } from "../utils/agent-config";
+import { printError, printSuccess, formatOutput } from "../utils/output";
+import { DEFAULT_RPC_URL } from "nara-sdk";
+import type { GlobalOptions } from "../types";
+
+function handleConfigGet(options: GlobalOptions) {
+  const config = loadAgentConfig();
+  const data = {
+    rpc_url: config.rpc_url ?? DEFAULT_RPC_URL,
+    wallet: config.wallet ?? "~/.config/nara/id.json",
+    rpc_url_custom: !!config.rpc_url,
+    wallet_custom: !!config.wallet,
+  };
+
+  if (options.json) {
+    formatOutput(data, true);
+  } else {
+    console.log("");
+    console.log(`  RPC URL: ${data.rpc_url}${data.rpc_url_custom ? "" : " (default)"}`);
+    console.log(`  Wallet:  ${data.wallet}${data.wallet_custom ? "" : " (default)"}`);
+    console.log("");
+  }
+}
+
+function handleConfigSet(key: string, value: string, options: GlobalOptions) {
+  const config = loadAgentConfig();
+
+  switch (key) {
+    case "rpc-url":
+      config.rpc_url = value;
+      break;
+    case "wallet":
+      config.wallet = value;
+      break;
+    default:
+      throw new Error(`Unknown config key: "${key}". Valid keys: rpc-url, wallet`);
+  }
+
+  saveAgentConfig(config);
+  if (!options.json) printSuccess(`Config "${key}" set to "${value}"`);
+  if (options.json) formatOutput({ key, value }, true);
+}
+
+function handleConfigReset(key: string | undefined, options: GlobalOptions) {
+  const config = loadAgentConfig();
+
+  if (!key) {
+    delete config.rpc_url;
+    delete config.wallet;
+    saveAgentConfig(config);
+    if (!options.json) printSuccess("All config reset to defaults");
+  } else {
+    switch (key) {
+      case "rpc-url":
+        delete config.rpc_url;
+        break;
+      case "wallet":
+        delete config.wallet;
+        break;
+      default:
+        throw new Error(`Unknown config key: "${key}". Valid keys: rpc-url, wallet`);
+    }
+    saveAgentConfig(config);
+    if (!options.json) printSuccess(`Config "${key}" reset to default`);
+  }
+
+  if (options.json) formatOutput({ key: key ?? "all", reset: true }, true);
+}
+
+export function registerConfigCommands(program: Command): void {
+  const config = program
+    .command("config")
+    .description("Manage CLI configuration (rpc-url, wallet)");
+
+  config
+    .command("get")
+    .description("Show current configuration")
+    .action((_opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        handleConfigGet(globalOpts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  config
+    .command("set <key> <value>")
+    .description("Set a config value (keys: rpc-url, wallet)")
+    .action((key: string, value: string, _opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        handleConfigSet(key, value, globalOpts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+
+  config
+    .command("reset [key]")
+    .description("Reset config to default (keys: rpc-url, wallet, or omit for all)")
+    .action((key: string | undefined, _opts: any, cmd: Command) => {
+      try {
+        const globalOpts = cmd.optsWithGlobals() as GlobalOptions;
+        handleConfigReset(key, globalOpts);
+      } catch (error: any) {
+        printError(error.message);
+        process.exit(1);
+      }
+    });
+}

package/src/cli/commands/quest.ts

@@ -59,7 +59,7 @@ function formatTimeRemaining(seconds: number): string {
 
 // ─── Command: quest get ──────────────────────────────────────────
 async function handleQuestGet(options: GlobalOptions) {
-  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const rpcUrl = await getRpcUrl(options.rpcUrl);
   const connection = new Connection(rpcUrl, "confirmed");
 
   let wallet: Keypair;
@@ -126,10 +126,10 @@ async function handleQuestAnswer(
   answer: string,
   options: GlobalOptions & { relay?: string; agent?: string; model?: string; referral?: string }
 ) {
-  const rpcUrl = getRpcUrl(options.rpcUrl);
+  const rpcUrl = await getRpcUrl(options.rpcUrl);
   const connection = new Connection(rpcUrl, "confirmed");
   const wallet = await loadWallet(options.wallet);
-  const agentConfig = await loadAgentConfig();
+  const agentConfig = loadAgentConfig();
   const configAgentId = agentConfig.agent_ids[0];
   const agent = options.agent ?? "naracli";
   const model = options.model ?? "";

package/src/cli/commands/zkid.ts

@@ -73,7 +73,7 @@ async function handleZkIdCreate(name: string, options: GlobalOptions) {
   if (!options.json) printInfo(`Registering ZK ID "${name}"...`);
   const signature = await createZkId(connection, wallet, name, idSecret);
   if (!options.json) printSuccess(`ZK ID "${name}" registered!`);
-  await addZkId(name);
+  addZkId(name);
 
   if (options.json) {
     formatOutput({ name, signature }, true);
@@ -149,7 +149,7 @@ async function handleZkIdScan(
   if (name) {
     names = [name];
   } else {
-    const config = await loadAgentConfig();
+    const config = loadAgentConfig();
     if (config.zk_ids.length === 0) {
       printError("No ZK IDs in config. Provide a name or create a ZK ID first.");
       process.exit(1);

package/src/cli/index.ts

@@ -12,6 +12,7 @@ import { registerQuestCommands } from "./commands/quest";
 import { registerSkillsCommands } from "./commands/skills";
 import { registerZkIdCommands } from "./commands/zkid";
 import { registerAgentCommands } from "./commands/agent";
+import { registerConfigCommands } from "./commands/config";
 import {
   handleWalletAddress,
   handleWalletBalance,
@@ -78,6 +79,9 @@ export function registerCommands(program: Command): void {
   // agent
   registerAgentCommands(program);
 
+  // config
+  registerConfigCommands(program);
+
   // Top-level: address
   program
     .command("address")

package/src/cli/utils/agent-config.ts

@@ -2,47 +2,49 @@
  * Agent config utilities - read/write ~/.config/nara/agent.json
  */
 
-import { join } from "node:path";
+import { join, dirname } from "node:path";
 import { homedir } from "node:os";
+import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 
 const AGENT_CONFIG_PATH = join(homedir(), ".config", "nara", "agent.json");
 
 export interface AgentConfig {
   agent_ids: string[];
   zk_ids: string[];
+  rpc_url?: string;
+  wallet?: string;
 }
 
 const DEFAULT_CONFIG: AgentConfig = { agent_ids: [], zk_ids: [] };
 
-export async function loadAgentConfig(): Promise<AgentConfig> {
-  const fs = await import("node:fs/promises");
+export function loadAgentConfig(): AgentConfig {
   try {
-    const raw = await fs.readFile(AGENT_CONFIG_PATH, "utf-8");
+    const raw = readFileSync(AGENT_CONFIG_PATH, "utf-8");
     const parsed = JSON.parse(raw);
     return {
       agent_ids: Array.isArray(parsed.agent_ids) ? parsed.agent_ids : [],
       zk_ids: Array.isArray(parsed.zk_ids) ? parsed.zk_ids : [],
+      rpc_url: parsed.rpc_url ?? undefined,
+      wallet: parsed.wallet ?? undefined,
     };
   } catch {
     return { ...DEFAULT_CONFIG };
   }
 }
 
-export async function saveAgentConfig(config: AgentConfig): Promise<void> {
-  const fs = await import("node:fs/promises");
-  const { dirname } = await import("node:path");
-  await fs.mkdir(dirname(AGENT_CONFIG_PATH), { recursive: true });
-  await fs.writeFile(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+export function saveAgentConfig(config: AgentConfig): void {
+  mkdirSync(dirname(AGENT_CONFIG_PATH), { recursive: true });
+  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
 }
 
-export async function addAgentId(id: string): Promise<void> {
-  const config = await loadAgentConfig();
+export function addAgentId(id: string): void {
+  const config = loadAgentConfig();
   config.agent_ids = [id, ...config.agent_ids.filter((x) => x !== id)];
-  await saveAgentConfig(config);
+  saveAgentConfig(config);
 }
 
-export async function addZkId(name: string): Promise<void> {
-  const config = await loadAgentConfig();
+export function addZkId(name: string): void {
+  const config = loadAgentConfig();
   config.zk_ids = [name, ...config.zk_ids.filter((x) => x !== name)];
-  await saveAgentConfig(config);
+  saveAgentConfig(config);
 }

package/src/cli/utils/wallet.ts

@@ -6,38 +6,39 @@ import { Keypair } from "@solana/web3.js";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { DEFAULT_RPC_URL } from "nara-sdk";
+import { loadAgentConfig } from "./agent-config";
 
-const _DEFAULT_WALLET_PATH = process.env.WALLET_PATH || "~/.config/nara/id.json";
+const DEFAULT_WALLET_PATH = join(homedir(), ".config", "nara", "id.json");
 
 /**
  * Resolve wallet path (expand ~ to home directory)
  */
-const DEFAULT_WALLET_PATH = _DEFAULT_WALLET_PATH.startsWith("~")
-  ? join(homedir(), _DEFAULT_WALLET_PATH.slice(1))
-  : _DEFAULT_WALLET_PATH;
+function resolvePath(p: string): string {
+  return p.startsWith("~") ? join(homedir(), p.slice(1)) : p;
+}
 
 /**
  * Load wallet keypair from file
  *
  * Priority:
  * 1. CLI flag (walletPath parameter)
- * 2. Default path (~/.config/nara/id.json)
- * 3. Error if neither exists
- *
- * @param walletPath Optional path to wallet keypair JSON file
- * @returns Keypair
- * @throws Error if wallet cannot be loaded
+ * 2. Config file (~/.config/nara/agent.json wallet field)
+ * 3. Default path (~/.config/nara/id.json)
  */
 export async function loadWallet(walletPath?: string): Promise<Keypair> {
-  // Use provided path or default path
-  const path = walletPath || DEFAULT_WALLET_PATH;
+  let path = walletPath;
+  if (!path) {
+    const config = loadAgentConfig();
+    path = config.wallet ? resolvePath(config.wallet) : DEFAULT_WALLET_PATH;
+  } else {
+    path = resolvePath(path);
+  }
 
   try {
     const fs = await import("node:fs/promises");
     const file = await fs.readFile(path, "utf-8");
     const data = JSON.parse(file);
 
-    // Handle both array format [1,2,3,...] and object format
     if (Array.isArray(data)) {
       return Keypair.fromSecretKey(new Uint8Array(data));
     } else if (data.secretKey) {
@@ -59,15 +60,15 @@ export async function loadWallet(walletPath?: string): Promise<Keypair> {
 }
 
 /**
- * Get RPC URL from options
+ * Get RPC URL
  *
  * Priority:
  * 1. CLI flag (rpcUrl parameter)
- * 2. Default (from constants)
- *
- * @param rpcUrl Optional RPC URL from CLI flag
- * @returns RPC URL
+ * 2. Config file (~/.config/nara/agent.json rpc_url field)
+ * 3. Default (from SDK constants)
  */
 export function getRpcUrl(rpcUrl?: string): string {
-  return rpcUrl || DEFAULT_RPC_URL;
+  if (rpcUrl) return rpcUrl;
+  const config = loadAgentConfig();
+  return config.rpc_url || DEFAULT_RPC_URL;
 }

package/src/tests/helpers.ts

@@ -5,6 +5,8 @@
 import { spawn } from "node:child_process";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CLI = join(__dirname, "../../bin/nara-cli.ts");
@@ -49,7 +51,7 @@ export function runCli(args: string[], extraEnv: Record<string, string> = {}): P
 }
 
 /** Whether a wallet is configured (for write-command tests) */
-export const hasWallet = !!process.env.PRIVATE_KEY;
+export const hasWallet = existsSync(join(homedir(), ".config", "nara", "id.json"));
 
 /** Generate a unique test resource name using a timestamp */
 export function uniqueName(prefix: string): string {

package/src/tests/quest.test.ts

@@ -106,8 +106,8 @@ describe("quest proof generation", () => {
 
 // ─── On-chain quest answer ────────────────────────────────────────
 
-describe("quest answer (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : undefined }, () => {
-  it("submits answer from test-questions", async () => {
+describe("quest answer (on-chain)", { skip: !hasWallet ? "no wallet" : undefined }, () => {
+  it("submits answer from test-questions and outputs tx", async () => {
     const rpcUrl = process.env.RPC_URL || "https://mainnet-api.nara.build/";
     const connection = new Connection(rpcUrl, "confirmed");
 
@@ -137,9 +137,10 @@ describe("quest answer (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : unde
       "--json",
     ]);
 
-    // exitCode 0 = success, but also handle "already answered" (exit 0 with warning)
     const output = stdout + stderr;
-    if (output.includes("already answered")) {
+
+    // Handle known non-error cases
+    if (output.includes("already answered") || output.includes("Already answered")) {
       console.log("  Already answered this round");
       return;
     }
@@ -148,8 +149,23 @@ describe("quest answer (on-chain)", { skip: !hasWallet ? "no PRIVATE_KEY" : unde
       return;
     }
 
+    // Handle confirmation timeout - tx was sent but ws confirmation failed
+    const sigMatch = output.match(/Check signature (\w{80,})/);
+    if (sigMatch) {
+      console.log(`  TX (confirmation timeout): ${sigMatch[1]}`);
+      return;
+    }
+
     assert.equal(exitCode, 0, `CLI failed: ${stderr}`);
-    assert.ok(output.includes("Transaction:") || output.includes("signature"), "should show transaction");
-    console.log("  Answer submitted successfully");
+
+    // Parse JSON output to get tx signature
+    try {
+      const data = JSON.parse(stdout);
+      assert.ok(data.signature, "should have signature in JSON output");
+      console.log(`  TX: ${data.signature}`);
+    } catch {
+      assert.ok(output.includes("Transaction:") || output.includes("signature"), "should show transaction");
+      console.log(`  Output: ${stdout.trim()}`);
+    }
   });
 });