@aixyz/cli 0.12.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/build/AixyzServerPlugin.ts

@@ -1,6 +1,6 @@
 import type { BunPlugin } from "bun";
 import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
-import { resolve, relative, basename, join } from "path";
+import { resolve, relative, join } from "path";
 import { getAixyzConfig } from "@aixyz/config";
 
 export function AixyzServerPlugin(entrypoint: string, mode: "vercel" | "standalone" | "executable"): BunPlugin {
@@ -55,8 +55,40 @@ export function getEntrypointMayGenerate(cwd: string, mode: "dev" | "build"): st
 class AixyzGlob {
   constructor(readonly config = getAixyzConfig()) {}
 
-  includes(file: string): boolean {
-    const included = this.config.build.includes.some((pattern) => new Bun.Glob(pattern).match(file));
+  hasRootAgent(appDir: string): { file: string } | undefined {
+    const file = readdirSync(appDir).find((f) => /^agent\.(js|ts)$/.test(f) && this.includesAgent(f));
+    return file ? { file } : undefined;
+  }
+
+  getAgents(agentsDir: string): { name: string; identifier: string }[] {
+    if (!existsSync(agentsDir)) return [];
+    return readdirSync(agentsDir)
+      .filter((file) => this.includesAgent(`agents/${file}`))
+      .map((file) => {
+        const name = file.replace(/\.(js|ts)$/, "");
+        return { name, identifier: toIdentifier(name) };
+      });
+  }
+
+  getTools(toolsDir: string): { name: string; identifier: string }[] {
+    if (!existsSync(toolsDir)) return [];
+    return readdirSync(toolsDir)
+      .filter((file) => this.includesTool(`tools/${file}`))
+      .map((file) => {
+        const name = file.replace(/\.(js|ts)$/, "");
+        return { name, identifier: toIdentifier(name) };
+      });
+  }
+
+  private includesAgent(file: string): boolean {
+    const included = this.config.build.agents.some((pattern) => new Bun.Glob(pattern).match(file));
+    if (!included) return false;
+    const excluded = this.config.build.excludes.some((pattern) => new Bun.Glob(pattern).match(file));
+    return !excluded;
+  }
+
+  private includesTool(file: string): boolean {
+    const included = this.config.build.tools.some((pattern) => new Bun.Glob(pattern).match(file));
     if (!included) return false;
     const excluded = this.config.build.excludes.some((pattern) => new Bun.Glob(pattern).match(file));
     return !excluded;
@@ -86,25 +118,16 @@ function generateServer(appDir: string, entrypointDir: string): string {
     imports.push('import { facilitator } from "aixyz/accepts";');
   }
 
-  const hasAgent = existsSync(resolve(appDir, "agent.ts")) && glob.includes("agent.ts");
-  if (hasAgent) {
+  const rootAgent = glob.hasRootAgent(appDir);
+  if (rootAgent) {
     imports.push('import { useA2A } from "aixyz/server/adapters/a2a";');
     imports.push(`import * as agent from "${importPrefix}/agent";`);
   }
 
   const agentsDir = resolve(appDir, "agents");
-  const subAgents: { name: string; identifier: string }[] = [];
-  if (existsSync(agentsDir)) {
-    for (const file of readdirSync(agentsDir)) {
-      if (glob.includes(`agents/${file}`)) {
-        const name = basename(file, ".ts");
-        const identifier = toIdentifier(name);
-        subAgents.push({ name, identifier });
-      }
-    }
-  }
+  const subAgents = glob.getAgents(agentsDir);
 
-  if (!hasAgent && subAgents.length > 0) {
+  if (!rootAgent && subAgents.length > 0) {
     imports.push('import { useA2A } from "aixyz/server/adapters/a2a";');
   }
   for (const subAgent of subAgents) {
@@ -112,16 +135,7 @@ function generateServer(appDir: string, entrypointDir: string): string {
   }
 
   const toolsDir = resolve(appDir, "tools");
-  const tools: { name: string; identifier: string }[] = [];
-  if (existsSync(toolsDir)) {
-    for (const file of readdirSync(toolsDir)) {
-      if (glob.includes(`tools/${file}`)) {
-        const name = basename(file, ".ts");
-        const identifier = toIdentifier(name);
-        tools.push({ name, identifier });
-      }
-    }
-  }
+  const tools = glob.getTools(toolsDir);
 
   if (tools.length > 0) {
     imports.push('import { AixyzMCP } from "aixyz/server/adapters/mcp";');
@@ -134,7 +148,7 @@ function generateServer(appDir: string, entrypointDir: string): string {
   body.push("await server.initialize();");
   body.push("server.unstable_withIndexPage();");
 
-  if (hasAgent) {
+  if (rootAgent) {
     body.push("useA2A(server, agent);");
   }
 
@@ -155,7 +169,7 @@ function generateServer(appDir: string, entrypointDir: string): string {
     imports.push('import { useERC8004 } from "aixyz/server/adapters/erc-8004";');
     imports.push(`import * as erc8004 from "${importPrefix}/erc-8004";`);
     const a2aPaths: string[] = [];
-    if (hasAgent) a2aPaths.push("/.well-known/agent-card.json");
+    if (rootAgent) a2aPaths.push("/.well-known/agent-card.json");
     for (const subAgent of subAgents) a2aPaths.push(`/${subAgent.name}/.well-known/agent-card.json`);
     body.push(
       `useERC8004(server, { default: erc8004.default, options: { mcp: ${tools.length > 0}, a2a: ${JSON.stringify(a2aPaths)} } });`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aixyz/cli",
-  "version": "0.12.0",
+  "version": "0.14.0",
   "description": "Payment-native SDK for AI Agent",
   "keywords": [
     "ai",
@@ -27,8 +27,8 @@
     "bin.ts"
   ],
   "dependencies": {
-    "@aixyz/config": "0.12.0",
-    "@aixyz/erc-8004": "0.12.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);
+}