@aixyz/cli 0.13.0 → 0.14.0

package/bin.ts

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import { devCommand } from "./dev";
 import { buildCommand } from "./build";
 import { erc8004Command } from "./register";
+import { walletCommand } from "./wallet";
 import pkg from "./package.json";
 
 const cli = new Command();
@@ -11,6 +12,7 @@ cli.name("aixyz").description("CLI for building and deploying aixyz agents").ver
 cli.addCommand(devCommand);
 cli.addCommand(buildCommand);
 cli.addCommand(erc8004Command);
+cli.addCommand(walletCommand);
 
 try {
   await cli.parseAsync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aixyz/cli",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Payment-native SDK for AI Agent",
   "keywords": [
     "ai",
@@ -27,8 +27,8 @@
     "bin.ts"
   ],
   "dependencies": {
-    "@aixyz/config": "0.13.0",
-    "@aixyz/erc-8004": "0.13.0",
+    "@aixyz/config": "0.14.0",
+    "@aixyz/erc-8004": "0.14.0",
     "@inquirer/prompts": "^8.3.0",
     "@next/env": "^16.1.6",
     "boxen": "^8.0.1",

package/register/wallet/index.ts

@@ -4,6 +4,7 @@ import { select, input, password } from "@inquirer/prompts";
 import { withTTY } from "../utils/prompt";
 import { createPrivateKeyWallet } from "./privatekey";
 import { createKeystoreWallet } from "./keystore";
+import { hasLocalWallet, getLocalWalletPrivateKey } from "./local";
 
 export interface WalletOptions {
   keystore?: string;
@@ -35,13 +36,17 @@ export async function selectWalletMethod(options: WalletOptions): Promise<Wallet
 
   // Interactive: prompt user to choose
   return withTTY(async () => {
+    const localWalletExists = hasLocalWallet();
+    const choices = [
+      { name: "Keystore file", value: "keystore" },
+      { name: "Browser wallet (any EIP-6963 compatible wallets)", value: "browser" },
+      { name: "Private key (not recommended)", value: "privatekey" },
+      ...(localWalletExists ? [{ name: "Local wallet (.aixyz/wallet.json)", value: "local" }] : []),
+    ];
+
     const method = await select({
       message: "Select signing method:",
-      choices: [
-        { name: "Keystore file", value: "keystore" },
-        { name: "Browser wallet (any EIP-6963 compatible wallets)", value: "browser" },
-        { name: "Private key (not recommended)", value: "privatekey" },
-      ],
+      choices,
     });
 
     switch (method) {
@@ -54,6 +59,8 @@ export async function selectWalletMethod(options: WalletOptions): Promise<Wallet
       }
       case "browser":
         return { type: "browser" };
+      case "local":
+        return { type: "privatekey", resolveKey: () => Promise.resolve(getLocalWalletPrivateKey()) };
       case "privatekey": {
         const key = await password({
           message: "Enter private key:",
@@ -65,7 +72,7 @@ export async function selectWalletMethod(options: WalletOptions): Promise<Wallet
       default:
         throw new Error("No wallet method selected");
     }
-  }, "No TTY detected. Provide --keystore, --browser, or PRIVATE_KEY environment variable to specify a signing method.");
+  }, "No TTY detected. Provide --keystore, --browser, PRIVATE_KEY environment variable, or run `aixyz wallet generate` to create a local wallet.");
 }
 
 export async function createWalletFromMethod(

package/register/wallet/local.test.ts

@@ -0,0 +1,102 @@
+import { describe, expect, test, beforeAll, afterAll } from "bun:test";
+import { mkdirSync, rmSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import {
+  generateLocalWallet,
+  hasLocalWallet,
+  readLocalWallet,
+  getLocalWalletPrivateKey,
+  getLocalWalletPath,
+} from "./local";
+
+const testDir = join(tmpdir(), "aixyz-cli-local-wallet-test");
+
+beforeAll(() => {
+  mkdirSync(testDir, { recursive: true });
+});
+
+afterAll(() => {
+  rmSync(testDir, { recursive: true, force: true });
+});
+
+describe("generateLocalWallet", () => {
+  test("creates .aixyz/wallet.json with mnemonic and address", () => {
+    const wallet = generateLocalWallet(testDir);
+    expect(wallet.mnemonic).toBeTruthy();
+    expect(wallet.address).toMatch(/^0x[0-9a-fA-F]{40}$/);
+    const walletPath = getLocalWalletPath(testDir);
+    expect(existsSync(walletPath)).toBe(true);
+    const content = JSON.parse(readFileSync(walletPath, "utf-8"));
+    expect(content.mnemonic).toBe(wallet.mnemonic);
+    expect(content.address).toBe(wallet.address);
+  });
+
+  test("creates .aixyz/.gitignore ignoring everything", () => {
+    const gitignorePath = join(testDir, ".aixyz", ".gitignore");
+    expect(existsSync(gitignorePath)).toBe(true);
+    expect(readFileSync(gitignorePath, "utf-8").trim()).toBe("*");
+  });
+
+  test("creates .aixyz/.aiignore ignoring everything", () => {
+    const aiignorePath = join(testDir, ".aixyz", ".aiignore");
+    expect(existsSync(aiignorePath)).toBe(true);
+    expect(readFileSync(aiignorePath, "utf-8").trim()).toBe("*");
+  });
+
+  test("mnemonic is 12 words", () => {
+    const wallet = generateLocalWallet(testDir);
+    expect(wallet.mnemonic.split(" ")).toHaveLength(12);
+  });
+});
+
+describe("hasLocalWallet", () => {
+  test("returns true when wallet exists", () => {
+    generateLocalWallet(testDir);
+    expect(hasLocalWallet(testDir)).toBe(true);
+  });
+
+  test("returns false when wallet does not exist", () => {
+    const emptyDir = join(tmpdir(), "aixyz-cli-no-wallet-test");
+    mkdirSync(emptyDir, { recursive: true });
+    try {
+      expect(hasLocalWallet(emptyDir)).toBe(false);
+    } finally {
+      rmSync(emptyDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("readLocalWallet", () => {
+  test("reads wallet from .aixyz/wallet.json", () => {
+    const wallet = generateLocalWallet(testDir);
+    const read = readLocalWallet(testDir);
+    expect(read.mnemonic).toBe(wallet.mnemonic);
+    expect(read.address).toBe(wallet.address);
+  });
+
+  test("throws when wallet does not exist", () => {
+    const emptyDir = join(tmpdir(), "aixyz-cli-no-wallet-read-test");
+    mkdirSync(emptyDir, { recursive: true });
+    try {
+      expect(() => readLocalWallet(emptyDir)).toThrow("aixyz wallet generate");
+    } finally {
+      rmSync(emptyDir, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("getLocalWalletPrivateKey", () => {
+  test("returns a valid private key hex string", () => {
+    generateLocalWallet(testDir);
+    const key = getLocalWalletPrivateKey(testDir);
+    expect(key).toMatch(/^0x[0-9a-fA-F]{64}$/);
+  });
+
+  test("returns deterministic private key for same mnemonic", () => {
+    generateLocalWallet(testDir);
+    const key1 = getLocalWalletPrivateKey(testDir);
+    const key2 = getLocalWalletPrivateKey(testDir);
+    expect(key1).toBe(key2);
+  });
+});

package/register/wallet/local.ts

@@ -0,0 +1,62 @@
+import { resolve } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { generateMnemonic, mnemonicToAccount, english } from "viem/accounts";
+import { bytesToHex } from "viem";
+
+const WALLET_DIR = ".aixyz";
+const WALLET_FILE = "wallet.json";
+const GITIGNORE_CONTENT = "*\n";
+const AIIGNORE_CONTENT = "*\n";
+
+export interface LocalWallet {
+  mnemonic: string;
+  address: string;
+}
+
+export function getLocalWalletPath(cwd: string = process.cwd()): string {
+  return resolve(cwd, WALLET_DIR, WALLET_FILE);
+}
+
+export function hasLocalWallet(cwd?: string): boolean {
+  return existsSync(getLocalWalletPath(cwd));
+}
+
+export function readLocalWallet(cwd?: string): LocalWallet {
+  const path = getLocalWalletPath(cwd);
+  if (!existsSync(path)) {
+    throw new Error(`No local wallet found at ${path}. Run \`aixyz wallet generate\` to create one.`);
+  }
+  const content = readFileSync(path, "utf-8");
+  return JSON.parse(content) as LocalWallet;
+}
+
+export function generateLocalWallet(cwd: string = process.cwd()): LocalWallet {
+  const dir = resolve(cwd, WALLET_DIR);
+  mkdirSync(dir, { recursive: true });
+
+  // Write .gitignore and .aiignore to protect wallet.json
+  writeFileSync(resolve(dir, ".gitignore"), GITIGNORE_CONTENT, "utf-8");
+  writeFileSync(resolve(dir, ".aiignore"), AIIGNORE_CONTENT, "utf-8");
+
+  const mnemonic = generateMnemonic(english);
+  const account = mnemonicToAccount(mnemonic);
+
+  const wallet: LocalWallet = {
+    mnemonic,
+    address: account.address,
+  };
+
+  writeFileSync(resolve(dir, WALLET_FILE), JSON.stringify(wallet, null, 2) + "\n", "utf-8");
+
+  return wallet;
+}
+
+export function getLocalWalletPrivateKey(cwd?: string): `0x${string}` {
+  const { mnemonic } = readLocalWallet(cwd);
+  const account = mnemonicToAccount(mnemonic);
+  const hdKey = account.getHdKey();
+  if (!hdKey.privKeyBytes) {
+    throw new Error("Failed to derive private key from mnemonic.");
+  }
+  return bytesToHex(hdKey.privKeyBytes);
+}