@aixyz/cli 0.8.0 → 0.10.0

package/register/README.md

@@ -1,101 +0,0 @@
-# ERC-8004 Registry Commands
-
-CLI commands for registering agents to the [ERC-8004](https://eips.ethereum.org/EIPS/eip-8004) IdentityRegistry.
-
-These commands are part of the `aixyz` CLI under the `erc8004` subcommand.
-
-## Usage
-
-### Register an Agent
-
-Register a new agent to the IdentityRegistry with multiple wallet options:
-
-#### Using Keystore (Recommended)
-
-Sign with an Ethereum keystore (V3) JSON file:
-
-```bash
-aixyz erc8004 register --uri "./metadata.json" --chain sepolia --keystore ~/.foundry/keystores/default --broadcast
-```
-
-#### Using Browser Wallet
-
-Opens a localhost page to sign with any browser extension wallet (MetaMask, Rabby, etc.) that are `EIP-6963` compliant:
-
-```bash
-aixyz erc8004 register --uri "ipfs://Qm..." --chain sepolia --browser --broadcast
-```
-
-> **Note:** `--rpc-url` cannot be used with `--browser`. The browser wallet uses its own RPC endpoint.
-
-#### Using Private Key Env (Not Recommended)
-
-For scripting and CI:
-
-```bash
-# Not recommended for interactive use
-PRIVATE_KEY=0x... aixyz erc8004 register --uri "ipfs://Qm..." --chain sepolia --broadcast
-```
-
-#### Interactive Mode
-
-If no wallet option is provided, you'll be prompted to choose:
-
-```bash
-aixyz erc8004 register --uri "ipfs://Qm..." --chain sepolia --broadcast
-```
-
-#### Local Development
-
-Register against a local Foundry/Anvil node:
-
-```bash
-aixyz erc8004 register \
-  --chain localhost \
-  --registry 0x5FbDB2315678afecb367f032d93F642f64180aa3 \
-  --rpc-url http://localhost:8545 \
-  --uri "./metadata.json" \
-  --keystore ~/.foundry/keystores/default \
-  --broadcast
-```
-
-### Set Agent URI
-
-Update the metadata URI of a registered agent:
-
-```bash
-aixyz erc8004 set-agent-uri \
-  --agent-id 1 \
-  --uri "https://my-agent.vercel.app/.well-known/agent-card.json" \
-  --chain sepolia \
-  --keystore ~/.foundry/keystores/default \
-  --broadcast
-```
-
-### Options
-
-| Option                 | Description                                                                          |
-| ---------------------- | ------------------------------------------------------------------------------------ |
-| `--uri <uri>`          | Agent metadata URI or path to `.json` file (converts to base64 data URI)             |
-| `--chain <chain>`      | Target chain: `mainnet`, `sepolia`, `base-sepolia`, `localhost` (default: `sepolia`) |
-| `--rpc-url <url>`      | Custom RPC URL (cannot be used with `--browser`)                                     |
-| `--registry <address>` | IdentityRegistry contract address (required for `localhost`)                         |
-| `--keystore <path>`    | Path to Ethereum keystore (V3) JSON file                                             |
-| `--browser`            | Use browser extension wallet                                                         |
-| `--broadcast`          | Sign and broadcast the transaction (default: dry-run)                                |
-| `--out-dir <path>`     | Write deployment result as JSON to the given directory                               |
-
-### Environment Variables
-
-| Variable      | Description                           |
-| ------------- | ------------------------------------- |
-| `PRIVATE_KEY` | Private key for signing (use caution) |
-
-### Supported Chains
-
-| Chain          | Chain ID | Network                  |
-| -------------- | -------- | ------------------------ |
-| `mainnet`      | 1        | Ethereum mainnet         |
-| `sepolia`      | 11155111 | Ethereum Sepolia testnet |
-| `base-sepolia` | 84532    | Base Sepolia testnet     |
-| `localhost`    | 31337    | Local Foundry/Anvil node |

package/register/set-agent-uri.test.ts

@@ -1,156 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
-import { setAgentUri, validateAgentId } from "./set-agent-uri";
-
-describe("set-agent-uri command chain configuration", () => {
-  test("sepolia chain ID is correct", () => {
-    expect(CHAIN_ID.SEPOLIA).toStrictEqual(11155111);
-  });
-
-  test("base-sepolia chain ID is correct", () => {
-    expect(CHAIN_ID.BASE_SEPOLIA).toStrictEqual(84532);
-  });
-
-  test("identity registry address is returned for sepolia", () => {
-    const address = getIdentityRegistryAddress(CHAIN_ID.SEPOLIA);
-    expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
-  });
-
-  test("identity registry address is returned for base-sepolia", () => {
-    const address = getIdentityRegistryAddress(CHAIN_ID.BASE_SEPOLIA);
-    expect(address).toMatch(/^0x[a-fA-F0-9]{40}$/);
-  });
-
-  test("throws for unsupported chain ID", () => {
-    expect(() => getIdentityRegistryAddress(999999)).toThrow("Unsupported chain ID");
-  });
-});
-
-describe("validateAgentId", () => {
-  test("accepts 0", () => {
-    expect(() => validateAgentId("0")).not.toThrow();
-  });
-
-  test("accepts positive integer", () => {
-    expect(() => validateAgentId("42")).not.toThrow();
-  });
-
-  test("accepts large integer", () => {
-    expect(() => validateAgentId("999999999")).not.toThrow();
-  });
-
-  test("rejects empty string", () => {
-    expect(() => validateAgentId("")).toThrow("Invalid agent ID");
-  });
-
-  test("rejects whitespace-only string", () => {
-    expect(() => validateAgentId("  ")).toThrow("Invalid agent ID");
-  });
-
-  test("accepts leading zeros", () => {
-    expect(() => validateAgentId("007")).not.toThrow();
-  });
-
-  test("accepts single leading zero before digits", () => {
-    expect(() => validateAgentId("042")).not.toThrow();
-  });
-
-  test("rejects negative number", () => {
-    expect(() => validateAgentId("-1")).toThrow("Invalid agent ID");
-  });
-
-  test("rejects float", () => {
-    expect(() => validateAgentId("1.5")).toThrow("Invalid agent ID");
-  });
-
-  test("rejects non-numeric string", () => {
-    expect(() => validateAgentId("abc")).toThrow("Invalid agent ID");
-  });
-
-  test("rejects mixed string", () => {
-    expect(() => validateAgentId("12abc")).toThrow("Invalid agent ID");
-  });
-
-  test("rejects Infinity", () => {
-    expect(() => validateAgentId("Infinity")).toThrow("Invalid agent ID");
-  });
-
-  test("rejects NaN", () => {
-    expect(() => validateAgentId("NaN")).toThrow("Invalid agent ID");
-  });
-});
-
-describe("set-agent-uri command validation", () => {
-  test("localhost requires --registry flag", async () => {
-    await expect(
-      setAgentUri({ agentId: "1", uri: "https://example.com/agent.json", chain: "localhost" }),
-    ).rejects.toThrow("--registry is required for localhost");
-  });
-
-  test("rejects unsupported chain", async () => {
-    await expect(
-      setAgentUri({ agentId: "1", uri: "https://example.com/agent.json", chain: "fakenet" }),
-    ).rejects.toThrow("Unsupported chain: fakenet");
-  });
-
-  test("rejects invalid registry address", async () => {
-    await expect(
-      setAgentUri({
-        agentId: "1",
-        uri: "https://example.com/agent.json",
-        chain: "localhost",
-        registry: "not-an-address",
-      }),
-    ).rejects.toThrow("Invalid registry address: not-an-address");
-  });
-
-  test("rejects --browser with --rpc-url", async () => {
-    await expect(
-      setAgentUri({
-        agentId: "0",
-        uri: "https://example.com/agent.json",
-        chain: "sepolia",
-        browser: true,
-        rpcUrl: "http://localhost:8545",
-      }),
-    ).rejects.toThrow("--rpc-url cannot be used with browser wallet");
-  });
-
-  test("dry-run completes without wallet interaction when --broadcast is not set", async () => {
-    await expect(
-      setAgentUri({ agentId: "1", uri: "https://example.com/agent.json", chain: "sepolia" }),
-    ).resolves.toBeUndefined();
-  });
-
-  test("rejects invalid agent ID (negative)", async () => {
-    await expect(
-      setAgentUri({ agentId: "-1", uri: "https://example.com/agent.json", chain: "sepolia" }),
-    ).rejects.toThrow("Invalid agent ID");
-  });
-
-  test("rejects invalid agent ID (non-integer)", async () => {
-    await expect(
-      setAgentUri({ agentId: "abc", uri: "https://example.com/agent.json", chain: "sepolia" }),
-    ).rejects.toThrow("Invalid agent ID");
-  });
-
-  test("rejects invalid agent ID (float)", async () => {
-    await expect(
-      setAgentUri({ agentId: "1.5", uri: "https://example.com/agent.json", chain: "sepolia" }),
-    ).rejects.toThrow("Invalid agent ID");
-  });
-
-  test("accepts agent ID 0 as valid", async () => {
-    // Agent ID 0 passes validation — triggers a later error (browser+rpc-url conflict)
-    // proving the agent ID check did not reject it
-    await expect(
-      setAgentUri({
-        agentId: "0",
-        uri: "https://example.com/agent.json",
-        chain: "sepolia",
-        browser: true,
-        rpcUrl: "http://localhost:8545",
-      }),
-    ).rejects.toThrow("--rpc-url cannot be used with browser wallet");
-  });
-});

package/register/utils.test.ts

@@ -1,154 +0,0 @@
-import { describe, expect, test, afterAll, beforeAll } from "bun:test";
-import { rmSync } from "fs";
-import { mkdir } from "node:fs/promises";
-import { validatePrivateKey, CliError, resolveUri } from "./utils";
-import { join } from "path";
-
-describe("validatePrivateKey", () => {
-  test("accepts valid 64-char hex key with 0x prefix", () => {
-    const key = "0x0000000000000000000000000000000000000000000000000000000000000001";
-    const result = validatePrivateKey(key);
-    expect(result).toStrictEqual(key);
-  });
-
-  test("accepts valid 64-char hex key without 0x prefix", () => {
-    const key = "0000000000000000000000000000000000000000000000000000000000000001";
-    const result = validatePrivateKey(key);
-    expect(result).toStrictEqual(`0x${key}`);
-  });
-
-  test("accepts mixed case hex characters", () => {
-    const key = "0xaAbBcCdDeEfF0000000000000000000000000000000000000000000000000001";
-    const result = validatePrivateKey(key);
-    expect(result).toStrictEqual(key);
-  });
-
-  test("rejects key that is too short", () => {
-    const key = "0x1234";
-    expect(() => validatePrivateKey(key)).toThrow(CliError);
-    expect(() => validatePrivateKey(key)).toThrow("Invalid private key format");
-  });
-
-  test("rejects key that is too long", () => {
-    const key = "0x00000000000000000000000000000000000000000000000000000000000000001";
-    expect(() => validatePrivateKey(key)).toThrow(CliError);
-  });
-
-  test("rejects key with invalid characters", () => {
-    const key = "0xGGGG000000000000000000000000000000000000000000000000000000000001";
-    expect(() => validatePrivateKey(key)).toThrow(CliError);
-  });
-
-  test("rejects empty string", () => {
-    expect(() => validatePrivateKey("")).toThrow(CliError);
-  });
-
-  test("rejects random string", () => {
-    expect(() => validatePrivateKey("not-a-key")).toThrow(CliError);
-  });
-});
-
-describe("CliError", () => {
-  test("is an instance of Error", () => {
-    const error = new CliError("test message");
-    expect(error).toBeInstanceOf(Error);
-  });
-
-  test("has correct name property", () => {
-    const error = new CliError("test message");
-    expect(error.name).toStrictEqual("CliError");
-  });
-
-  test("has correct message property", () => {
-    const error = new CliError("test message");
-    expect(error.message).toStrictEqual("test message");
-  });
-
-  test("can be caught as Error", () => {
-    let caught = false;
-    try {
-      throw new CliError("test");
-    } catch (e) {
-      if (e instanceof Error) {
-        caught = true;
-      }
-    }
-    expect(caught).toStrictEqual(true);
-  });
-});
-
-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(CliError);
-      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(CliError);
-    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(CliError);
-      expect(() => resolveUri(testJsonPath)).toThrow("Invalid JSON");
-    } finally {
-      await Bun.file(testJsonPath).unlink();
-    }
-  });
-});

package/register/utils.ts

@@ -1,55 +0,0 @@
-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 CliError(`File not found: ${filePath}`);
-    }
-
-    if (!statSync(filePath).isFile()) {
-      throw new CliError(`Not a file: ${filePath}`);
-    }
-
-    const content = readFileSync(filePath, "utf-8");
-
-    // Validate it's valid JSON
-    try {
-      JSON.parse(content);
-    } catch {
-      throw new CliError(`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;
-}
-
-export function validatePrivateKey(key: string): `0x${string}` {
-  const normalizedKey = key.startsWith("0x") ? key : `0x${key}`;
-
-  if (!/^0x[0-9a-fA-F]{64}$/.test(normalizedKey)) {
-    throw new CliError("Invalid private key format. Expected 64 hex characters (with or without 0x prefix).");
-  }
-
-  return normalizedKey as `0x${string}`;
-}
-
-export class CliError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "CliError";
-  }
-}