@aixyz/cli 0.7.0 → 0.9.0

package/register/update.ts

@@ -0,0 +1,191 @@
+import { encodeFunctionData, formatEther, parseEventLogs, type Chain, type Log } from "viem";
+import { IdentityRegistryAbi } from "@aixyz/erc-8004";
+import { selectWalletMethod } from "./wallet";
+import { signTransaction } from "./wallet/sign";
+import {
+  resolveChainConfig,
+  resolveRegistryAddress,
+  validateBrowserRpcConflict,
+  getExplorerUrl,
+  CHAINS,
+} from "./utils/chain";
+import { writeResultJson } from "./utils/result";
+import { label, truncateUri, broadcastAndConfirm, logSignResult } from "./utils/transaction";
+import { promptAgentUrl, promptSelectRegistration, deriveAgentUri } from "./utils/prompt";
+import { readRegistrations } from "./utils/erc8004-file";
+import { confirm } from "@inquirer/prompts";
+import chalk from "chalk";
+import boxen from "boxen";
+import type { BaseOptions } from "./index";
+
+export interface UpdateOptions extends BaseOptions {
+  url?: string;
+}
+
+export async function update(options: UpdateOptions): Promise<void> {
+  // Step 1: Read registrations from app/erc-8004.ts
+  const registrations = await readRegistrations();
+
+  if (registrations.length === 0) {
+    throw new Error("No registrations found in app/erc-8004.ts. Run `aixyz erc-8004 register` first.");
+  }
+
+  // Step 2: Select which registration to update
+  const selected = await promptSelectRegistration(registrations);
+
+  // Step 3: Derive chain info from agentRegistry (eip155:<chainId>:<address>)
+  const parts = selected.agentRegistry.split(":");
+  if (parts.length < 3 || parts[0] !== "eip155") {
+    throw new Error(`Invalid agentRegistry format: ${selected.agentRegistry}. Expected eip155:<chainId>:<address>`);
+  }
+
+  const chainId = Number(parts[1]);
+  const registryAddress = parts.slice(2).join(":") as `0x${string}`;
+  const chainName = Object.entries(CHAINS).find(([, config]) => config.chainId === chainId)?.[0] ?? `chain-${chainId}`;
+  const chainConfig = resolveChainConfig(chainName);
+
+  // Step 4: Get new agent URL and derive URI
+  const agentUrl = options.url ?? (await promptAgentUrl());
+  const resolvedUri = deriveAgentUri(agentUrl);
+
+  const yes = await confirm({
+    message: `Will update URI to: ${chalk.cyan(resolvedUri)} — confirm?`,
+    default: true,
+  });
+  if (!yes) {
+    throw new Error("Aborted.");
+  }
+
+  // Step 5: Encode transaction
+  const data = encodeFunctionData({
+    abi: IdentityRegistryAbi,
+    functionName: "setAgentURI",
+    args: [BigInt(selected.agentId), resolvedUri],
+  });
+
+  const printTxDetails = (header: string) => {
+    console.log("");
+    console.log(chalk.dim(header));
+    console.log(`  ${label("To")}${registryAddress}`);
+    console.log(`  ${label("Data")}${data.slice(0, 10)}${chalk.dim("\u2026" + (data.length - 2) / 2 + " bytes")}`);
+    console.log(`  ${label("Chain")}${chainName}`);
+    console.log(`  ${label("Function")}setAgentURI(uint256 agentId, string calldata newURI)`);
+    console.log(`  ${label("Agent ID")}${selected.agentId}`);
+    console.log(`  ${label("URI")}${truncateUri(resolvedUri)}`);
+    console.log("");
+  };
+
+  validateBrowserRpcConflict(options.browser, options.rpcUrl);
+
+  if (!options.broadcast) {
+    if (options.browser || options.keystore || process.env.PRIVATE_KEY) {
+      console.warn("Note: --browser/--keystore/PRIVATE_KEY ignored in dry-run mode. Pass --broadcast to use a wallet.");
+    }
+    printTxDetails("Transaction details (dry-run)");
+    console.log("Dry-run complete. To sign and broadcast, re-run with --broadcast.");
+    return;
+  }
+
+  const walletMethod = await selectWalletMethod(options);
+  validateBrowserRpcConflict(walletMethod.type === "browser" || undefined, options.rpcUrl);
+
+  printTxDetails("Signing transaction...");
+
+  const result = await signTransaction({
+    walletMethod,
+    tx: { to: registryAddress, data },
+    chain: chainConfig.chain,
+    rpcUrl: options.rpcUrl,
+    options: {
+      browser: { chainId: chainConfig.chainId, chainName, uri: resolvedUri, mode: "update" },
+    },
+  });
+  logSignResult(walletMethod.type, result);
+
+  const { hash, receipt, timestamp } = await broadcastAndConfirm({
+    result,
+    chain: chainConfig.chain,
+    rpcUrl: options.rpcUrl,
+  });
+
+  const resultData = printResult(receipt, timestamp, chainConfig.chain, chainConfig.chainId, hash);
+
+  if (options.outDir) {
+    writeResultJson(options.outDir, "update", resultData);
+  }
+}
+
+interface UpdateResult {
+  agentId?: string;
+  newUri?: string;
+  updatedBy?: `0x${string}`;
+  chainId: number;
+  block: string;
+  timestamp: string;
+  gasPaid: string;
+  nativeCurrency: string;
+  txHash: string;
+  explorer?: string;
+}
+
+function printResult(
+  receipt: { blockNumber: bigint; gasUsed: bigint; effectiveGasPrice: bigint; logs: readonly unknown[] },
+  timestamp: bigint,
+  chain: Chain,
+  chainId: number,
+  hash: `0x${string}`,
+): UpdateResult {
+  const events = parseEventLogs({ abi: IdentityRegistryAbi, logs: receipt.logs as Log[] });
+  const uriUpdated = events.find((e) => e.eventName === "URIUpdated");
+
+  const lines: string[] = [];
+  const result: UpdateResult = {
+    chainId,
+    block: receipt.blockNumber.toString(),
+    timestamp: new Date(Number(timestamp) * 1000).toUTCString(),
+    gasPaid: formatEther(receipt.gasUsed * receipt.effectiveGasPrice),
+    nativeCurrency: chain.nativeCurrency?.symbol ?? "ETH",
+    txHash: hash,
+  };
+
+  if (uriUpdated) {
+    const { agentId, newURI, updatedBy } = uriUpdated.args as {
+      agentId: bigint;
+      newURI: string;
+      updatedBy: `0x${string}`;
+    };
+    result.agentId = agentId.toString();
+    result.newUri = newURI;
+    result.updatedBy = updatedBy;
+
+    lines.push(`${label("Agent ID")}${chalk.bold(result.agentId)}`);
+    lines.push(`${label("New URI")}${truncateUri(newURI)}`);
+    lines.push(`${label("Updated By")}${updatedBy}`);
+    lines.push(`${label("Block")}${receipt.blockNumber}`);
+  } else {
+    lines.push(`${label("Block")}${receipt.blockNumber}`);
+  }
+
+  lines.push(`${label("Timestamp")}${result.timestamp}`);
+  lines.push(`${label("Gas Paid")}${result.gasPaid} ${result.nativeCurrency}`);
+  lines.push(`${label("Tx Hash")}${hash}`);
+
+  const explorerUrl = getExplorerUrl(chain, hash);
+  if (explorerUrl) {
+    result.explorer = explorerUrl;
+    lines.push(`${label("Explorer")}${chalk.cyan(explorerUrl)}`);
+  }
+
+  console.log("");
+  console.log(
+    boxen(lines.join("\n"), {
+      padding: { left: 1, right: 1, top: 0, bottom: 0 },
+      borderStyle: "round",
+      borderColor: "green",
+      title: "Agent URI updated successfully",
+      titleAlignment: "left",
+    }),
+  );
+
+  return result;
+}

package/register/utils/chain.ts

@@ -0,0 +1,56 @@
+import { isAddress, type Chain } from "viem";
+import { mainnet, sepolia, baseSepolia, foundry } from "viem/chains";
+import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
+import { select } from "@inquirer/prompts";
+
+export interface ChainConfig {
+  chain: Chain;
+  chainId: number;
+}
+
+export const CHAINS: Record<string, ChainConfig> = {
+  mainnet: { chain: mainnet, chainId: CHAIN_ID.MAINNET },
+  sepolia: { chain: sepolia, chainId: CHAIN_ID.SEPOLIA },
+  "base-sepolia": { chain: baseSepolia, chainId: CHAIN_ID.BASE_SEPOLIA },
+  localhost: { chain: foundry, chainId: 31337 },
+};
+
+export function resolveChainConfig(chainName: string): ChainConfig {
+  const config = CHAINS[chainName];
+  if (!config) {
+    throw new Error(`Unsupported chain: ${chainName}. Supported chains: ${Object.keys(CHAINS).join(", ")}`);
+  }
+  return config;
+}
+
+export async function selectChain(): Promise<string> {
+  return select({
+    message: "Select target chain:",
+    choices: Object.keys(CHAINS).map((name) => ({ name, value: name })),
+  });
+}
+
+export function resolveRegistryAddress(chainName: string, chainId: number, registry?: string): `0x${string}` {
+  if (registry) {
+    if (!isAddress(registry)) {
+      throw new Error(`Invalid registry address: ${registry}`);
+    }
+    return registry as `0x${string}`;
+  }
+  if (chainName === "localhost") {
+    throw new Error("--registry is required for localhost (no default contract deployment)");
+  }
+  return getIdentityRegistryAddress(chainId) as `0x${string}`;
+}
+
+export function validateBrowserRpcConflict(browser: boolean | undefined, rpcUrl: string | undefined): void {
+  if (browser && rpcUrl) {
+    throw new Error("--rpc-url cannot be used with browser wallet. The browser wallet uses its own RPC endpoint.");
+  }
+}
+
+export function getExplorerUrl(chain: Chain, txHash: string): string | null {
+  const explorer = chain.blockExplorers?.default;
+  if (!explorer) return null;
+  return `${explorer.url}/tx/${txHash}`;
+}

package/register/utils/erc8004-file.ts

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import type { RegistrationEntry } from "@aixyz/erc-8004/schemas/registration";
+
+function getFilePath(cwd: string = process.cwd()): string {
+  return resolve(cwd, "app/erc-8004.ts");
+}
+
+export function hasErc8004File(cwd?: string): boolean {
+  return existsSync(getFilePath(cwd));
+}
+
+export function createErc8004File(supportedTrust: string[], cwd?: string): void {
+  const filePath = getFilePath(cwd);
+  const trustArray = supportedTrust.map((t) => `"${t}"`).join(", ");
+
+  const content = `import type { ERC8004Registration } from "aixyz/erc-8004";
+
+const metadata: ERC8004Registration = {
+  registrations: [],
+  supportedTrust: [${trustArray}],
+};
+
+export default metadata;
+`;
+
+  writeFileSync(filePath, content, "utf-8");
+}
+
+export async function readRegistrations(cwd?: string): Promise<RegistrationEntry[]> {
+  const filePath = getFilePath(cwd);
+
+  if (!existsSync(filePath)) {
+    throw new Error(`No app/erc-8004.ts found. Run \`aixyz erc-8004 register\` first.`);
+  }
+
+  const mod = await import(filePath);
+  const data = mod.default;
+
+  if (!data || !Array.isArray(data.registrations)) {
+    return [];
+  }
+
+  return data.registrations;
+}
+
+export function writeRegistrationEntry(entry: { agentId: number; agentRegistry: string }, cwd?: string): void {
+  const filePath = getFilePath(cwd);
+  const content = readFileSync(filePath, "utf-8");
+  const entryStr = `{ agentId: ${entry.agentId}, agentRegistry: "${entry.agentRegistry}" }`;
+
+  // Try to find `registrations: [...]` and insert the entry
+  const match = content.match(/registrations:\s*\[([^\]]*)\]/s);
+  if (match) {
+    const existing = match[1]!.trim();
+    const newEntries = existing ? `${existing}, ${entryStr}` : entryStr;
+    const updated = content.replace(/registrations:\s*\[([^\]]*)\]/s, `registrations: [${newEntries}]`);
+    writeFileSync(filePath, updated, "utf-8");
+    return;
+  }
+
+  // Fallback: append as comment
+  const comment = `\n// Registration added by \`aixyz erc-8004 register\`:\n// ${entryStr}\n`;
+  writeFileSync(filePath, content + comment, "utf-8");
+}

package/register/utils/prompt.ts

@@ -0,0 +1,78 @@
+import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import type { RegistrationEntry } from "@aixyz/erc-8004/schemas/registration";
+
+export async function promptAgentId(): Promise<string> {
+  return input({
+    message: "Agent ID (token ID) to update:",
+    validate: (value) => {
+      const n = Number(value);
+      if (value.trim() === "" || !Number.isInteger(n) || n < 0) return "Must be a non-negative integer";
+      return true;
+    },
+  });
+}
+
+export async function promptUri(): Promise<string> {
+  return input({
+    message: "New agent metadata URI or path to .json file (leave empty to clear):",
+  });
+}
+
+export async function promptAgentUrl(): Promise<string> {
+  return input({
+    message: "Agent deployment URL (e.g., https://my-agent.example.com):",
+    validate: (value) => {
+      try {
+        const url = new URL(value);
+        if (url.protocol !== "https:" && url.protocol !== "http:") {
+          return "URL must start with https:// or http://";
+        }
+        return true;
+      } catch {
+        return "Must be a valid URL (e.g., https://my-agent.example.com)";
+      }
+    },
+  });
+}
+
+export async function promptSupportedTrust(): Promise<string[]> {
+  return checkbox({
+    message: "Select supported trust mechanisms:",
+    choices: [
+      { name: "reputation", value: "reputation", checked: true },
+      { name: "crypto-economic", value: "crypto-economic" },
+      { name: "tee-attestation", value: "tee-attestation" },
+      { name: "social", value: "social" },
+      { name: "governance", value: "governance" },
+    ],
+    required: true,
+  });
+}
+
+export async function promptSelectRegistration(registrations: RegistrationEntry[]): Promise<RegistrationEntry> {
+  if (registrations.length === 1) {
+    const reg = registrations[0]!;
+    const yes = await confirm({
+      message: `Update this registration? (agentId: ${reg.agentId}, registry: ${reg.agentRegistry})`,
+      default: true,
+    });
+    if (!yes) {
+      throw new Error("Aborted.");
+    }
+    return reg;
+  }
+
+  return select({
+    message: "Select registration to update:",
+    choices: registrations.map((reg) => ({
+      name: `agentId: ${reg.agentId} — ${reg.agentRegistry}`,
+      value: reg,
+    })),
+  });
+}
+
+export function deriveAgentUri(url: string): string {
+  // Ensure no trailing slash before appending path
+  const base = url.replace(/\/+$/, "");
+  return `${base}/_aixyz/erc-8004.json`;
+}

package/register/utils/result.ts

@@ -0,0 +1,14 @@
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+
+export function writeResultJson(outDir: string, filenamePrefix: string, result: { chainId: number }): void {
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+
+  const filename = `${filenamePrefix}-${result.chainId}-${Date.now()}.json`;
+  const filePath = join(outDir, filename);
+  writeFileSync(filePath, JSON.stringify(result, null, 2) + "\n");
+  console.log(`\n${chalk.green("✓")} Result written to ${chalk.bold(filePath)}`);
+}

package/register/utils/spinner.ts

@@ -0,0 +1,39 @@
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const INTERVAL = 80;
+
+export interface Spinner {
+  pause(): void;
+  stop(finalMessage?: string): void;
+}
+
+export function startSpinner(message: string): Spinner {
+  if (!process.stderr.isTTY) {
+    process.stderr.write(`${message}\n`);
+    return { pause() {}, stop() {} };
+  }
+
+  let i = 0;
+  let timer: ReturnType<typeof setInterval> | null = setInterval(() => {
+    process.stderr.write(`\r${FRAMES[i++ % FRAMES.length]} ${message}`);
+  }, INTERVAL);
+
+  return {
+    pause() {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+        process.stderr.write(`\r\x1b[2K`);
+      }
+    },
+    stop(finalMessage?: string) {
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+      process.stderr.write(`\r\x1b[2K`);
+      if (finalMessage) {
+        process.stderr.write(`${finalMessage}\n`);
+      }
+    },
+  };
+}

package/register/utils/transaction.ts

@@ -0,0 +1,94 @@
+import { createPublicClient, http, type Chain, type Log } from "viem";
+import { startSpinner } from "./spinner";
+import { getExplorerUrl } from "./chain";
+import type { SignTransactionResult } from "../wallet/sign";
+import chalk from "chalk";
+import boxen from "boxen";
+
+export function label(text: string): string {
+  return chalk.dim(text.padEnd(14));
+}
+
+export function truncateUri(uri: string, maxLength = 80): string {
+  if (uri.length <= maxLength) return uri;
+  return uri.slice(0, maxLength) + "...";
+}
+
+export interface BroadcastAndConfirmParams {
+  result: SignTransactionResult;
+  chain: Chain;
+  rpcUrl?: string;
+}
+
+export interface BroadcastAndConfirmResult {
+  hash: `0x${string}`;
+  receipt: {
+    blockNumber: bigint;
+    gasUsed: bigint;
+    effectiveGasPrice: bigint;
+    logs: Log[];
+  };
+  timestamp: bigint;
+}
+
+export async function broadcastAndConfirm({
+  result,
+  chain,
+  rpcUrl,
+}: BroadcastAndConfirmParams): Promise<BroadcastAndConfirmResult> {
+  const transport = rpcUrl ? http(rpcUrl) : http();
+  const publicClient = createPublicClient({ chain, transport });
+
+  let hash: `0x${string}`;
+  if (result.kind === "sent") {
+    hash = result.txHash;
+  } else {
+    const broadcastSpinner = startSpinner("Broadcasting transaction...");
+    try {
+      hash = await publicClient.sendRawTransaction({ serializedTransaction: result.raw });
+    } catch (err) {
+      broadcastSpinner.stop();
+      throw err;
+    }
+    broadcastSpinner.stop(`${chalk.green("\u2713")} Transaction broadcast`);
+  }
+
+  printTxHashBox(chain, hash);
+
+  const confirmSpinner = startSpinner("Waiting for confirmation...");
+  let receipt;
+  try {
+    receipt = await publicClient.waitForTransactionReceipt({ hash });
+  } catch (err) {
+    confirmSpinner.stop();
+    throw err;
+  }
+  confirmSpinner.stop(`${chalk.green("\u2713")} Confirmed in block ${chalk.bold(receipt.blockNumber.toString())}`);
+
+  const block = await publicClient.getBlock({ blockNumber: receipt.blockNumber });
+
+  return { hash, receipt, timestamp: block.timestamp };
+}
+
+function printTxHashBox(chain: Chain, hash: `0x${string}`): void {
+  const lines = [`${label("Tx Hash")}${hash}`];
+  const explorerUrl = getExplorerUrl(chain, hash);
+  if (explorerUrl) {
+    lines.push(`${label("Explorer")}${chalk.cyan(explorerUrl)}`);
+  }
+  console.log(
+    boxen(lines.join("\n"), {
+      padding: { left: 1, right: 1, top: 0, bottom: 0 },
+      borderStyle: "round",
+      borderColor: "cyan",
+    }),
+  );
+}
+
+export function logSignResult(walletType: string, result: SignTransactionResult): void {
+  if (result.kind === "signed") {
+    console.log(`${chalk.green("\u2713")} Transaction signed ${chalk.dim(`(${walletType} \u00b7 ${result.address})`)}`);
+  } else {
+    console.log(`${chalk.green("\u2713")} Transaction signed ${chalk.dim(`(${walletType})`)}`);
+  }
+}

package/register/utils.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, test, afterAll, beforeAll } from "bun:test";
+import { rmSync } from "fs";
+import { mkdir } from "node:fs/promises";
+import { resolveUri } from "./utils";
+import { join } from "path";
+
+describe("resolveUri", () => {
+  const testDir = join(import.meta.dir, "__test_fixtures__");
+  const testJsonPath = join(testDir, "test-metadata.json");
+  const testMetadata = { name: "Test Agent", description: "A test agent" };
+
+  beforeAll(() => {
+    // ensure test directory exists
+    mkdir(testDir, { recursive: true });
+  });
+
+  afterAll(() => {
+    // clean up test directory
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  test("returns ipfs:// URIs unchanged", () => {
+    const uri = "ipfs://QmTest123";
+    expect(resolveUri(uri)).toStrictEqual(uri);
+  });
+
+  test("returns https:// URIs unchanged", () => {
+    const uri = "https://example.com/metadata.json";
+    expect(resolveUri(uri)).toStrictEqual(uri);
+  });
+
+  test("returns http:// URIs unchanged", () => {
+    const uri = "http://example.com/metadata.json";
+    expect(resolveUri(uri)).toStrictEqual(uri);
+  });
+
+  test("converts .json file to base64 data URI", async () => {
+    await Bun.write(testJsonPath, JSON.stringify(testMetadata));
+
+    try {
+      const result = resolveUri(testJsonPath);
+      expect(result.startsWith("data:application/json;base64,")).toStrictEqual(true);
+
+      // Decode and verify content
+      const base64 = result.replace("data:application/json;base64,", "");
+      const decoded = JSON.parse(Buffer.from(base64, "base64").toString("utf-8"));
+      expect(decoded).toStrictEqual(testMetadata);
+    } finally {
+      await Bun.file(testJsonPath).unlink();
+    }
+  });
+
+  test("throws for directory path", async () => {
+    await mkdir(testDir, { recursive: true });
+    const dirWithJsonSuffix = join(testDir, "not-a-file.json");
+    await mkdir(dirWithJsonSuffix, { recursive: true });
+
+    try {
+      expect(() => resolveUri(dirWithJsonSuffix)).toThrow(Error);
+      expect(() => resolveUri(dirWithJsonSuffix)).toThrow("Not a file");
+    } finally {
+      rmSync(dirWithJsonSuffix, { recursive: true, force: true });
+    }
+  });
+
+  test("throws for non-existent .json file", () => {
+    expect(() => resolveUri("./non-existent.json")).toThrow(Error);
+    expect(() => resolveUri("./non-existent.json")).toThrow("File not found");
+  });
+
+  test("throws for invalid JSON content", async () => {
+    await Bun.write(testJsonPath, "not valid json {{{");
+
+    try {
+      expect(() => resolveUri(testJsonPath)).toThrow(Error);
+      expect(() => resolveUri(testJsonPath)).toThrow("Invalid JSON");
+    } finally {
+      await Bun.file(testJsonPath).unlink();
+    }
+  });
+});

package/register/utils.ts

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+
+export function resolveUri(uri: string): string {
+  // Return as-is for URLs (ipfs://, https://, data:, etc.)
+  if (uri.startsWith("http://") || uri.startsWith("https://") || uri.startsWith("ipfs://") || uri.startsWith("data:")) {
+    return uri;
+  }
+
+  // Check if it's a file path (ends with .json or exists as a file)
+  if (uri.endsWith(".json") || existsSync(uri)) {
+    const filePath = resolve(uri);
+
+    if (!existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    if (!statSync(filePath).isFile()) {
+      throw new Error(`Not a file: ${filePath}`);
+    }
+
+    const content = readFileSync(filePath, "utf-8");
+
+    // Validate it's valid JSON
+    try {
+      JSON.parse(content);
+    } catch {
+      throw new Error(`Invalid JSON in file: ${filePath}`);
+    }
+
+    // Convert to base64 data URI
+    const base64 = Buffer.from(content).toString("base64");
+    return `data:application/json;base64,${base64}`;
+  }
+
+  // Return as-is for other URIs
+  return uri;
+}