@aixyz/cli 0.10.0 → 0.12.0

package/build/AixyzServerPlugin.ts

@@ -3,7 +3,7 @@ import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
 import { resolve, relative, basename, join } from "path";
 import { getAixyzConfig } from "@aixyz/config";
 
-export function AixyzServerPlugin(entrypoint: string, mode: "vercel" | "standalone"): BunPlugin {
+export function AixyzServerPlugin(entrypoint: string, mode: "vercel" | "standalone" | "executable"): BunPlugin {
   return {
     name: "aixyz-entrypoint",
     setup(build) {
@@ -17,7 +17,7 @@ export function AixyzServerPlugin(entrypoint: string, mode: "vercel" | "standalo
           const transformed = source.replace(/export\s+default\s+(\w+)\s*;/, "export default $1.express;");
           return { contents: transformed, loader: "ts" };
         } else {
-          // For standalone, keep the server export but add startup code
+          // For standalone and executable, keep the server export but add startup code
           // TODO(@fuxingloh): use Bun.serve later.
           const transformed = source.replace(
             /export\s+default\s+(\w+)\s*;/,
@@ -64,9 +64,9 @@ class AixyzGlob {
 }
 
 /**
- * Generate server.ts content by scanning the app directory for agent.ts and tools/.
+ * Generate server.ts content by scanning the app directory for agent.ts, agents/, and tools/.
  *
- * @param appDir - The app directory containing agent.ts and tools/
+ * @param appDir - The app directory containing agent.ts, agents/, and tools/
  * @param entrypointDir - Directory where the generated file will live (for computing relative imports).
  */
 function generateServer(appDir: string, entrypointDir: string): string {
@@ -92,6 +92,25 @@ function generateServer(appDir: string, entrypointDir: string): string {
     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 });
+      }
+    }
+  }
+
+  if (!hasAgent && subAgents.length > 0) {
+    imports.push('import { useA2A } from "aixyz/server/adapters/a2a";');
+  }
+  for (const subAgent of subAgents) {
+    imports.push(`import * as ${subAgent.identifier} from "${importPrefix}/agents/${subAgent.name}";`);
+  }
+
   const toolsDir = resolve(appDir, "tools");
   const tools: { name: string; identifier: string }[] = [];
   if (existsSync(toolsDir)) {
@@ -119,6 +138,9 @@ function generateServer(appDir: string, entrypointDir: string): string {
     body.push("useA2A(server, agent);");
   }
 
+  for (const subAgent of subAgents) {
+    body.push(`useA2A(server, ${subAgent.identifier}, "${subAgent.name}");`);
+  }
   if (tools.length > 0) {
     body.push("const mcp = new AixyzMCP(server);");
     for (const tool of tools) {
@@ -132,8 +154,11 @@ function generateServer(appDir: string, entrypointDir: string): string {
   if (hasErc8004) {
     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");
+    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: ${hasAgent} } });`,
+      `useERC8004(server, { default: erc8004.default, options: { mcp: ${tools.length > 0}, a2a: ${JSON.stringify(a2aPaths)} } });`,
     );
   }
 

package/build/index.ts

@@ -14,7 +14,7 @@ interface BuildOptions {
 
 export const buildCommand = new Command("build")
   .description("Build the aixyz agent")
-  .option("--output <type>", "Output format: 'standalone' or 'vercel'")
+  .option("--output <type>", "Output format: 'standalone', 'vercel', or 'executable'")
   .addHelpText(
     "after",
     `
@@ -28,6 +28,10 @@ Details:
     Generates Vercel Build Output API v3 structure at .vercel/output/
     (Automatically detected when deploying to Vercel)
 
+  With --output executable:
+    Compiles into a self-contained binary at ./.aixyz/output/server
+    (No Bun runtime required to run the output)
+
   The build process:
     1. Loads aixyz.config.ts from the current directory
     2. Detects entrypoint (app/server.ts or auto-generates from app/agent.ts + app/tools/)
@@ -42,6 +46,7 @@ Examples:
   $ aixyz build                         # Build standalone (default)
   $ aixyz build --output standalone     # Build standalone explicitly
   $ aixyz build --output vercel         # Build for Vercel deployment
+  $ aixyz build --output executable     # Build self-contained binary
   $ VERCEL=1 aixyz build                # Auto-detected Vercel build`,
   )
   .action(action);
@@ -49,6 +54,8 @@ Examples:
 async function action(options: BuildOptions = {}): Promise<void> {
   const cwd = process.cwd();
   loadEnvConfig(cwd, false);
+  process.env.NODE_ENV = "production";
+  process.env.AIXYZ_ENV = "production";
   const entrypoint = getEntrypointMayGenerate(cwd, "build");
 
   // Determine output target: explicit CLI flag takes precedence, then config file, then auto-detect VERCEL env
@@ -57,7 +64,10 @@ async function action(options: BuildOptions = {}): Promise<void> {
 
   if (target === "vercel") {
     console.log(chalk.cyan("▶") + " Building for " + chalk.bold("Vercel") + "...");
-    await buildVercel(entrypoint);
+    await buildVercel(entrypoint, config);
+  } else if (target === "executable") {
+    console.log(chalk.cyan("▶") + " Building " + chalk.bold("Executable") + "...");
+    await buildExecutable(entrypoint);
   } else {
     console.log(chalk.cyan("▶") + " Building for " + chalk.bold("Standalone") + "...");
     await buildBun(entrypoint);
@@ -79,6 +89,10 @@ async function buildBun(entrypoint: string): Promise<void> {
     target: "bun",
     format: "esm",
     sourcemap: "linked",
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      "process.env.AIXYZ_ENV": JSON.stringify("production"),
+    },
     plugins: [AixyzConfigPlugin(), AixyzServerPlugin(entrypoint, "standalone")],
   });
 
@@ -119,7 +133,63 @@ async function buildBun(entrypoint: string): Promise<void> {
   console.log("To run: bun .aixyz/output/server.js");
 }
 
-async function buildVercel(entrypoint: string): Promise<void> {
+async function buildExecutable(entrypoint: string): Promise<void> {
+  const cwd = process.cwd();
+
+  const outputDir = resolve(cwd, ".aixyz/output");
+  rmSync(outputDir, { recursive: true, force: true });
+  mkdirSync(outputDir, { recursive: true });
+
+  const outfile = resolve(outputDir, "server");
+
+  // Build as a self-contained compiled binary using Bun's compile feature
+  const result = await Bun.build({
+    entrypoints: [entrypoint],
+    outdir: outputDir,
+    target: "bun",
+    sourcemap: "linked",
+    compile: { outfile },
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      "process.env.AIXYZ_ENV": JSON.stringify("production"),
+    },
+    plugins: [AixyzConfigPlugin(), AixyzServerPlugin(entrypoint, "executable")],
+  });
+
+  if (!result.success) {
+    console.error("Build failed:");
+    for (const log of result.logs) {
+      console.error(log);
+    }
+    process.exit(1);
+  }
+
+  // Copy static assets (public/ → .aixyz/output/public/)
+  const publicDir = resolve(cwd, "public");
+  if (existsSync(publicDir)) {
+    const destPublicDir = resolve(outputDir, "public");
+    cpSync(publicDir, destPublicDir, { recursive: true });
+    console.log("Copied public/ →", destPublicDir);
+  }
+
+  const iconFile = findIconFile(resolve(cwd, "app"));
+  if (iconFile) {
+    await copyAgentIcon(iconFile, resolve(outputDir, "icon.png"));
+    await generateFavicon(iconFile, resolve(outputDir, "public/favicon.ico"));
+  }
+
+  // Log summary
+  console.log("");
+  console.log("Build complete! Output:");
+  console.log("  .aixyz/output/server");
+  if (existsSync(publicDir) || iconFile) {
+    console.log("  .aixyz/output/public/ and assets");
+  }
+  console.log("");
+  console.log("To run: ./.aixyz/output/server");
+}
+
+async function buildVercel(entrypoint: string, config: ReturnType<typeof getAixyzConfig>): Promise<void> {
   const cwd = process.cwd();
 
   const outputDir = resolve(cwd, ".vercel/output");
@@ -136,6 +206,10 @@ async function buildVercel(entrypoint: string): Promise<void> {
     target: "bun",
     format: "esm",
     sourcemap: "linked",
+    define: {
+      "process.env.NODE_ENV": JSON.stringify("production"),
+      "process.env.AIXYZ_ENV": JSON.stringify("production"),
+    },
     plugins: [AixyzConfigPlugin(), AixyzServerPlugin(entrypoint, "vercel")],
   });
 
@@ -155,6 +229,7 @@ async function buildVercel(entrypoint: string): Promise<void> {
         handler: "server.js",
         runtime: "bun1.x",
         launcherType: "Bun",
+        maxDuration: config.vercel.maxDuration,
         shouldAddHelpers: true,
         shouldAddSourcemapSupport: true,
       },

package/dev/index.ts

@@ -15,6 +15,8 @@ async function action(options: { port?: string }): Promise<void> {
 
   // Load environment config
   const { loadedEnvFiles } = loadEnvConfig(cwd, true);
+  process.env.NODE_ENV = "development";
+  process.env.AIXYZ_ENV = "development";
   const envFileNames = loadedEnvFiles.map((f) => relative(cwd, f.path));
 
   const port = options.port || process.env.PORT || "3000";
@@ -41,7 +43,7 @@ async function action(options: { port?: string }): Promise<void> {
       cwd,
       stdout: "inherit",
       stderr: "inherit",
-      env: process.env,
+      env: { ...process.env, NODE_ENV: "development", AIXYZ_ENV: "development" },
     });
     child.exited.then((code) => {
       if (!restarting && code !== 0) {

package/package.json

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

package/register/index.ts

@@ -4,7 +4,6 @@ import { update } from "./update";
 import type { WalletOptions } from "./wallet";
 
 export interface BaseOptions extends WalletOptions {
-  chain?: string;
   rpcUrl?: string;
   registry?: string;
   outDir?: string;
@@ -16,13 +15,17 @@ erc8004Command
   .command("register")
   .description("Register a new agent to the ERC-8004 IdentityRegistry")
   .option("--url <url>", "Agent deployment URL (e.g., https://my-agent.example.com)")
-  .option("--chain <chain>", "Target chain (mainnet, sepolia, base-sepolia, localhost)")
+  .option("--chain-id <chainId>", "Target chain by numeric chain ID", parseInt)
   .option("--rpc-url <url>", "Custom RPC URL (uses default if not provided)")
-  .option("--registry <address>", "Contract address of the IdentityRegistry (required for localhost)")
+  .option("--registry <address>", "Contract address of the IdentityRegistry (required for localhost and custom chains)")
   .option("--keystore <path>", "Path to Ethereum keystore (V3) JSON file for local signing")
   .option("--browser", "Use browser extension wallet (any extension)")
   .option("--broadcast", "Sign and broadcast the transaction (default: dry-run)")
   .option("--out-dir <path>", "Write deployment result as JSON to the given directory")
+  .option(
+    "--supported-trust <values>",
+    'Comma-separated supported trust mechanisms (e.g., "reputation,tee-attestation"). If omitted and app/erc-8004.ts does not exist, you will be prompted interactively.',
+  )
   .addHelpText(
     "after",
     `
@@ -32,22 +35,23 @@ Option Details:
       The registration URI will be derived as <url>/_aixyz/erc-8004.json.
       If omitted, you will be prompted to enter the URL interactively.
 
-  --chain <chain>
-      Target chain for registration. Supported values:
-        mainnet       Ethereum mainnet (chain ID 1)
-        sepolia       Ethereum Sepolia testnet (chain ID 11155111)
-        base-sepolia  Base Sepolia testnet (chain ID 84532)
-        localhost     Local Foundry/Anvil node (chain ID 31337)
+  --chain-id <chainId>
+      Target chain by numeric chain ID. Supported chain IDs include:
+        1 (mainnet), 8453 (base), 42161 (arbitrum), 10 (optimism),
+        137 (polygon), 56 (bsc), 43114 (avalanche), 11155111 (sepolia),
+        84532 (base-sepolia), and more (see @aixyz/erc-8004).
       If omitted, you will be prompted to select a chain interactively.
+      Use any custom EVM chain ID with --rpc-url for BYO chains.
 
   --rpc-url <url>
       Custom RPC endpoint URL. Overrides the default RPC for the selected
-      chain. Cannot be used with --browser since the browser wallet manages
+      chain. Required when using a custom chain ID with no default deployment.
+      Cannot be used with --browser since the browser wallet manages
       its own RPC connection.
 
   --registry <address>
-      Contract address of the ERC-8004 IdentityRegistry. Only required for
-      localhost, where there is no default deployment.
+      Contract address of the ERC-8004 IdentityRegistry. Required for
+      localhost and custom chains, where there is no default deployment.
 
   --keystore <path>
       Path to an Ethereum keystore (V3) JSON file. You will be prompted for
@@ -64,6 +68,13 @@ Option Details:
   --out-dir <path>
       Directory to write the deployment result as a JSON file.
 
+  --supported-trust <values>
+      Comma-separated list of trust mechanisms to declare in app/erc-8004.ts
+      when it does not yet exist. Valid values: reputation, crypto-economic,
+      tee-attestation, social, governance.
+      Example: --supported-trust "reputation,tee-attestation"
+      If omitted, you will be prompted to select interactively.
+
 Behavior:
   If app/erc-8004.ts does not exist, you will be prompted to create it
   (selecting supported trust mechanisms). After a successful on-chain
@@ -74,11 +85,17 @@ Environment Variables:
 
 Examples:
   # Dry-run (default)
-  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain sepolia
+  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain-id 11155111
 
-  # Sign and broadcast
-  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain sepolia --keystore ~/.foundry/keystores/default --broadcast
-  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain sepolia --browser --broadcast`,
+  # Sign and broadcast (known chain)
+  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain-id 84532 --keystore ~/.foundry/keystores/default --broadcast
+  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain-id 84532 --browser --broadcast
+
+  # Non-interactive (CI-friendly)
+  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain-id 84532 --supported-trust "reputation,tee-attestation" --keystore ~/.foundry/keystores/default --broadcast
+
+  # BYO: register on any custom EVM chain
+  $ aixyz erc-8004 register --url "https://my-agent.example.com" --chain-id 999999 --rpc-url https://my-rpc.example.com --registry 0xABCD... --broadcast`,
   )
   .action(register);
 
@@ -86,6 +103,7 @@ erc8004Command
   .command("update")
   .description("Update the metadata URI of a registered agent")
   .option("--url <url>", "New agent deployment URL (e.g., https://my-agent.example.com)")
+  .option("--agent-id <id>", "Agent ID to update (selects which registration from app/erc-8004.ts)", parseInt)
   .option("--rpc-url <url>", "Custom RPC URL (uses default if not provided)")
   .option("--registry <address>", "Contract address of the IdentityRegistry (required for localhost)")
   .option("--keystore <path>", "Path to Ethereum keystore (V3) JSON file for local signing")
@@ -101,6 +119,11 @@ Option Details:
       The URI will be derived as <url>/_aixyz/erc-8004.json.
       If omitted, you will be prompted to enter the URL interactively.
 
+  --agent-id <id>
+      Agent ID (numeric) to select which registration from app/erc-8004.ts
+      to update. Required in non-interactive (non-TTY) mode when multiple
+      registrations exist.
+
   --rpc-url <url>
       Custom RPC endpoint URL. Overrides the default RPC for the selected
       chain. Cannot be used with --browser.
@@ -138,6 +161,9 @@ Examples:
 
   # Sign and broadcast
   $ aixyz erc-8004 update --url "https://new-domain.example.com" --keystore ~/.foundry/keystores/default --broadcast
-  $ aixyz erc-8004 update --url "https://new-domain.example.com" --browser --broadcast`,
+  $ aixyz erc-8004 update --url "https://new-domain.example.com" --browser --broadcast
+
+  # Non-interactive (CI-friendly)
+  $ aixyz erc-8004 update --url "https://new-domain.example.com" --agent-id 42 --keystore ~/.foundry/keystores/default --broadcast`,
   )
   .action(update);

package/register/register.ts

@@ -3,15 +3,23 @@ import { IdentityRegistryAbi } from "@aixyz/erc-8004";
 import { selectWalletMethod } from "./wallet";
 import { signTransaction } from "./wallet/sign";
 import {
-  resolveChainConfig,
+  resolveChainConfigById,
   selectChain,
   resolveRegistryAddress,
   validateBrowserRpcConflict,
   getExplorerUrl,
+  CHAINS,
 } from "./utils/chain";
 import { writeResultJson } from "./utils/result";
 import { label, truncateUri, broadcastAndConfirm, logSignResult } from "./utils/transaction";
-import { promptAgentUrl, promptSupportedTrust, deriveAgentUri } from "./utils/prompt";
+import {
+  promptAgentUrl,
+  promptSupportedTrust,
+  promptRegistryAddress,
+  deriveAgentUri,
+  isTTY,
+  parseSupportedTrust,
+} from "./utils/prompt";
 import { hasErc8004File, createErc8004File, writeRegistrationEntry } from "./utils/erc8004-file";
 import { confirm } from "@inquirer/prompts";
 import chalk from "chalk";
@@ -20,7 +28,8 @@ import type { BaseOptions } from "./index";
 
 export interface RegisterOptions extends BaseOptions {
   url?: string;
-  chain?: string;
+  chainId?: number;
+  supportedTrust?: string;
 }
 
 export async function register(options: RegisterOptions): Promise<void> {
@@ -28,7 +37,9 @@ export async function register(options: RegisterOptions): Promise<void> {
   if (!hasErc8004File()) {
     console.log(chalk.yellow("No app/erc-8004.ts found. Let's create one."));
     console.log("");
-    const supportedTrust = await promptSupportedTrust();
+    const supportedTrust = options.supportedTrust
+      ? parseSupportedTrust(options.supportedTrust)
+      : await promptSupportedTrust();
     createErc8004File(supportedTrust);
     console.log(chalk.green("Created app/erc-8004.ts"));
     console.log("");
@@ -38,18 +49,21 @@ export async function register(options: RegisterOptions): Promise<void> {
   const agentUrl = options.url ?? (await promptAgentUrl());
   const resolvedUri = deriveAgentUri(agentUrl);
 
-  const yes = await confirm({
-    message: `Will register URI as: ${chalk.cyan(resolvedUri)} — confirm?`,
-    default: true,
-  });
-  if (!yes) {
-    throw new Error("Aborted.");
+  if (isTTY()) {
+    const yes = await confirm({
+      message: `Will register URI as: ${chalk.cyan(resolvedUri)} — confirm?`,
+      default: true,
+    });
+    if (!yes) {
+      throw new Error("Aborted.");
+    }
   }
 
   // Step 3: Select chain
-  const chainName = options.chain ?? (await selectChain());
-  const chainConfig = resolveChainConfig(chainName);
-  const registryAddress = resolveRegistryAddress(chainName, chainConfig.chainId, options.registry);
+  const chainId = options.chainId ?? (await selectChain());
+  const chainConfig = resolveChainConfigById(chainId, options.rpcUrl);
+  const chainName = Object.entries(CHAINS).find(([, c]) => c.chainId === chainId)?.[0] ?? `chain-${chainId}`;
+  const registryAddress = resolveRegistryAddress(chainId, options.registry) ?? (await promptRegistryAddress());
 
   // Step 4: Encode transaction
   const data = encodeFunctionData({

package/register/update.test.ts

@@ -1,6 +1,15 @@
 import { describe, expect, test } from "bun:test";
 import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
-import { deriveAgentUri } from "./utils/prompt";
+import {
+  deriveAgentUri,
+  isTTY,
+  parseSupportedTrust,
+  promptAgentUrl,
+  promptRegistryAddress,
+  promptSupportedTrust,
+  withTTY,
+} from "./utils/prompt";
+import { selectChain } from "./utils/chain";
 
 describe("update command chain configuration", () => {
   test("sepolia chain ID is correct", () => {
@@ -45,3 +54,112 @@ describe("deriveAgentUri", () => {
     );
   });
 });
+
+describe("parseSupportedTrust", () => {
+  test("parses a single value", () => {
+    expect(parseSupportedTrust("reputation")).toStrictEqual(["reputation"]);
+  });
+
+  test("parses multiple comma-separated values", () => {
+    expect(parseSupportedTrust("reputation,tee-attestation")).toStrictEqual(["reputation", "tee-attestation"]);
+  });
+
+  test("trims whitespace around values", () => {
+    expect(parseSupportedTrust("reputation, tee-attestation , social")).toStrictEqual([
+      "reputation",
+      "tee-attestation",
+      "social",
+    ]);
+  });
+
+  test("throws for invalid trust mechanism", () => {
+    expect(() => parseSupportedTrust("reputation,invalid")).toThrow("Invalid trust mechanism(s): invalid");
+  });
+
+  test("throws for empty string", () => {
+    expect(() => parseSupportedTrust("")).toThrow("--supported-trust requires at least one value");
+  });
+
+  test("accepts all valid mechanisms", () => {
+    expect(parseSupportedTrust("reputation,crypto-economic,tee-attestation,social,governance")).toStrictEqual([
+      "reputation",
+      "crypto-economic",
+      "tee-attestation",
+      "social",
+      "governance",
+    ]);
+  });
+});
+
+describe("isTTY", () => {
+  test("returns a boolean", () => {
+    expect(typeof isTTY()).toBe("boolean");
+  });
+});
+
+describe("withTTY", () => {
+  async function withNoTTYOverride<T>(fn: () => Promise<T>): Promise<T> {
+    const originalIsTTY = process.stdin.isTTY;
+    (process.stdin as NodeJS.ReadStream & { isTTY: boolean | undefined }).isTTY = undefined;
+    try {
+      return await fn();
+    } finally {
+      (process.stdin as NodeJS.ReadStream & { isTTY: boolean | undefined }).isTTY = originalIsTTY;
+    }
+  }
+
+  test("throws the provided message when no TTY", async () => {
+    await withNoTTYOverride(async () => {
+      await expect(withTTY(() => Promise.resolve("ok"), "use --flag instead")).rejects.toThrow("use --flag instead");
+    });
+  });
+
+  test("returns the fn result when TTY is available", async () => {
+    const originalIsTTY = process.stdin.isTTY;
+    (process.stdin as NodeJS.ReadStream & { isTTY: boolean | undefined }).isTTY = true;
+    try {
+      const result = await withTTY(() => Promise.resolve("hello"), "should not throw");
+      expect(result).toBe("hello");
+    } finally {
+      (process.stdin as NodeJS.ReadStream & { isTTY: boolean | undefined }).isTTY = originalIsTTY;
+    }
+  });
+});
+
+describe("TTY-gated prompts throw in non-interactive environments", () => {
+  // Tests run in a piped (non-TTY) environment, so these error paths are exercised directly.
+
+  async function withNoTTY<T>(fn: () => Promise<T>): Promise<T> {
+    const originalIsTTY = process.stdin.isTTY;
+    (process.stdin as NodeJS.ReadStream & { isTTY: boolean | undefined }).isTTY = undefined;
+    try {
+      return await fn();
+    } finally {
+      (process.stdin as NodeJS.ReadStream & { isTTY: boolean | undefined }).isTTY = originalIsTTY;
+    }
+  }
+
+  test("promptAgentUrl throws when stdin is not a TTY", async () => {
+    await withNoTTY(async () => {
+      await expect(promptAgentUrl()).rejects.toThrow("No TTY detected. Provide --url");
+    });
+  });
+
+  test("promptSupportedTrust throws when stdin is not a TTY", async () => {
+    await withNoTTY(async () => {
+      await expect(promptSupportedTrust()).rejects.toThrow("No TTY detected");
+    });
+  });
+
+  test("promptRegistryAddress throws when stdin is not a TTY", async () => {
+    await withNoTTY(async () => {
+      await expect(promptRegistryAddress()).rejects.toThrow("No TTY detected. Provide --registry");
+    });
+  });
+
+  test("selectChain throws when stdin is not a TTY", async () => {
+    await withNoTTY(async () => {
+      await expect(selectChain()).rejects.toThrow("No TTY detected. Provide --chain-id");
+    });
+  });
+});

package/register/update.ts

@@ -2,10 +2,10 @@ import { encodeFunctionData, formatEther, parseEventLogs, type Chain, type Log }
 import { IdentityRegistryAbi } from "@aixyz/erc-8004";
 import { selectWalletMethod } from "./wallet";
 import { signTransaction } from "./wallet/sign";
-import { resolveChainConfig, validateBrowserRpcConflict, getExplorerUrl, CHAINS } from "./utils/chain";
+import { resolveChainConfigById, 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 { promptAgentUrl, promptSelectRegistration, deriveAgentUri, isTTY } from "./utils/prompt";
 import { readRegistrations } from "./utils/erc8004-file";
 import { confirm } from "@inquirer/prompts";
 import chalk from "chalk";
@@ -14,6 +14,7 @@ import type { BaseOptions } from "./index";
 
 export interface UpdateOptions extends BaseOptions {
   url?: string;
+  agentId?: number;
 }
 
 export async function update(options: UpdateOptions): Promise<void> {
@@ -25,7 +26,18 @@ export async function update(options: UpdateOptions): Promise<void> {
   }
 
   // Step 2: Select which registration to update
-  const selected = await promptSelectRegistration(registrations);
+  let selected: (typeof registrations)[number];
+  if (options.agentId !== undefined) {
+    const match = registrations.find((r) => r.agentId === options.agentId);
+    if (!match) {
+      throw new Error(
+        `No registration found with agentId ${options.agentId}. Available: ${registrations.map((r) => r.agentId).join(", ")}`,
+      );
+    }
+    selected = match;
+  } else {
+    selected = await promptSelectRegistration(registrations);
+  }
 
   // Step 3: Derive chain info from agentRegistry (eip155:<chainId>:<address>)
   const parts = selected.agentRegistry.split(":");
@@ -36,18 +48,20 @@ export async function update(options: UpdateOptions): Promise<void> {
   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);
+  const chainConfig = resolveChainConfigById(chainId, options.rpcUrl);
 
   // 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.");
+  if (isTTY()) {
+    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

package/register/utils/chain.ts

@@ -1,20 +1,129 @@
-import { isAddress, type Chain } from "viem";
-import { mainnet, sepolia, baseSepolia, foundry } from "viem/chains";
+import { isAddress, defineChain, type Chain } from "viem";
+import {
+  abstract,
+  abstractTestnet,
+  arbitrum,
+  arbitrumSepolia,
+  avalanche,
+  avalancheFuji,
+  base,
+  baseSepolia,
+  bsc,
+  bscTestnet,
+  celo,
+  celoSepolia,
+  foundry,
+  gnosis,
+  linea,
+  lineaSepolia,
+  mainnet,
+  mantle,
+  mantleSepoliaTestnet,
+  megaeth,
+  monad,
+  monadTestnet,
+  optimism,
+  optimismSepolia,
+  polygon,
+  polygonAmoy,
+  scroll,
+  scrollSepolia,
+  sepolia,
+  taiko,
+} from "viem/chains";
 import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
-import { select } from "@inquirer/prompts";
+import { input, select } from "@inquirer/prompts";
+import { withTTY } from "./prompt";
 
 export interface ChainConfig {
   chain: Chain;
   chainId: number;
 }
 
+// Maps supported chain IDs to viem Chain objects (derived from @aixyz/erc-8004 CHAIN_ID)
+const VIEM_CHAIN_BY_ID: Record<number, Chain> = {
+  [CHAIN_ID.ABSTRACT]: abstract,
+  [CHAIN_ID.ARBITRUM]: arbitrum,
+  [CHAIN_ID.AVALANCHE]: avalanche,
+  [CHAIN_ID.BASE]: base,
+  [CHAIN_ID.BSC]: bsc,
+  [CHAIN_ID.CELO]: celo,
+  [CHAIN_ID.GNOSIS]: gnosis,
+  [CHAIN_ID.LINEA]: linea,
+  [CHAIN_ID.MAINNET]: mainnet,
+  [CHAIN_ID.MANTLE]: mantle,
+  [CHAIN_ID.MEGAETH]: megaeth,
+  [CHAIN_ID.MONAD]: monad,
+  [CHAIN_ID.OPTIMISM]: optimism,
+  [CHAIN_ID.POLYGON]: polygon,
+  [CHAIN_ID.SCROLL]: scroll,
+  [CHAIN_ID.TAIKO]: taiko,
+  [CHAIN_ID.ABSTRACT_TESTNET]: abstractTestnet,
+  [CHAIN_ID.ARBITRUM_SEPOLIA]: arbitrumSepolia,
+  [CHAIN_ID.AVALANCHE_FUJI]: avalancheFuji,
+  [CHAIN_ID.BASE_SEPOLIA]: baseSepolia,
+  [CHAIN_ID.BSC_TESTNET]: bscTestnet,
+  [CHAIN_ID.CELO_SEPOLIA]: celoSepolia,
+  [CHAIN_ID.LINEA_SEPOLIA]: lineaSepolia,
+  [CHAIN_ID.MANTLE_SEPOLIA]: mantleSepoliaTestnet,
+  [CHAIN_ID.MONAD_TESTNET]: monadTestnet,
+  [CHAIN_ID.OPTIMISM_SEPOLIA]: optimismSepolia,
+  [CHAIN_ID.POLYGON_AMOY]: polygonAmoy,
+  [CHAIN_ID.SCROLL_SEPOLIA]: scrollSepolia,
+  [CHAIN_ID.SEPOLIA]: sepolia,
+  31337: foundry,
+};
+
+// Build CHAINS from CHAIN_ID as the single source of truth from @aixyz/erc-8004.
+// Chain names are derived from CHAIN_ID keys: lowercase with underscores replaced by hyphens.
 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 },
+  ...Object.fromEntries(
+    (Object.entries(CHAIN_ID) as [string, number][])
+      .filter(([, id]) => id in VIEM_CHAIN_BY_ID)
+      .map(([key, id]) => [key.toLowerCase().replace(/_/g, "-"), { chain: VIEM_CHAIN_BY_ID[id]!, chainId: id }]),
+  ),
   localhost: { chain: foundry, chainId: 31337 },
 };
 
+// Priority-ordered chain IDs for interactive selection — most popular first.
+const CHAIN_SELECTION_ORDER: number[] = [
+  // Popular mainnets
+  CHAIN_ID.MAINNET,
+  CHAIN_ID.BASE,
+  CHAIN_ID.ARBITRUM,
+  CHAIN_ID.OPTIMISM,
+  CHAIN_ID.POLYGON,
+  CHAIN_ID.BSC,
+  CHAIN_ID.AVALANCHE,
+  CHAIN_ID.SCROLL,
+  CHAIN_ID.LINEA,
+  CHAIN_ID.CELO,
+  CHAIN_ID.GNOSIS,
+  CHAIN_ID.TAIKO,
+  CHAIN_ID.MANTLE,
+  CHAIN_ID.MONAD,
+  CHAIN_ID.MEGAETH,
+  CHAIN_ID.ABSTRACT,
+  // Popular testnets
+  CHAIN_ID.SEPOLIA,
+  CHAIN_ID.BASE_SEPOLIA,
+  CHAIN_ID.ARBITRUM_SEPOLIA,
+  CHAIN_ID.OPTIMISM_SEPOLIA,
+  CHAIN_ID.POLYGON_AMOY,
+  CHAIN_ID.AVALANCHE_FUJI,
+  CHAIN_ID.BSC_TESTNET,
+  CHAIN_ID.SCROLL_SEPOLIA,
+  CHAIN_ID.LINEA_SEPOLIA,
+  CHAIN_ID.CELO_SEPOLIA,
+  CHAIN_ID.MANTLE_SEPOLIA,
+  CHAIN_ID.MONAD_TESTNET,
+  CHAIN_ID.ABSTRACT_TESTNET,
+  // Special
+  31337,
+];
+
+const OTHER_CHAIN_ID = -1;
+
 export function resolveChainConfig(chainName: string): ChainConfig {
   const config = CHAINS[chainName];
   if (!config) {
@@ -23,24 +132,75 @@ export function resolveChainConfig(chainName: string): ChainConfig {
   return config;
 }
 
-export async function selectChain(): Promise<string> {
-  return select({
-    message: "Select target chain:",
-    choices: Object.keys(CHAINS).map((name) => ({ name, value: name })),
-  });
+// Resolve chain config by numeric chain ID, supporting BYO chains via rpcUrl.
+// For known chain IDs the viem chain object is used directly.
+// For unknown chain IDs, a minimal chain is constructed using defineChain (requires rpcUrl).
+export function resolveChainConfigById(chainId: number, rpcUrl?: string): ChainConfig {
+  const chain = VIEM_CHAIN_BY_ID[chainId];
+  if (chain) {
+    return { chain, chainId };
+  }
+  if (!rpcUrl) {
+    throw new Error(`Unknown chain ID ${chainId}. Provide --rpc-url to register on a custom chain.`);
+  }
+  return {
+    chain: defineChain({
+      id: chainId,
+      name: `chain-${chainId}`,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [rpcUrl] } },
+    }),
+    chainId,
+  };
+}
+
+// Prompt user to select a chain interactively, returning the numeric chain ID.
+// Chains are sorted by popularity. "Other" allows entering any custom chain ID.
+export async function selectChain(): Promise<number> {
+  return withTTY(async () => {
+    const chainById = new Map(Object.values(CHAINS).map((c) => [c.chainId, c]));
+    const nameById = new Map(Object.entries(CHAINS).map(([name, c]) => [c.chainId, name]));
+
+    const choices = CHAIN_SELECTION_ORDER.filter((id) => chainById.has(id)).map((id) => ({
+      name: `${nameById.get(id) ?? `chain-${id}`} (${id})`,
+      value: id,
+    }));
+    choices.push({ name: "Other (enter chain ID)", value: OTHER_CHAIN_ID });
+
+    const selected = await select({ message: "Select target chain:", choices });
+
+    if (selected === OTHER_CHAIN_ID) {
+      const raw = await input({
+        message: "Enter chain ID:",
+        validate: (v) => {
+          const n = parseInt(v, 10);
+          return Number.isInteger(n) && n > 0 ? true : "Must be a positive integer";
+        },
+      });
+      return parseInt(raw, 10);
+    }
+
+    return selected;
+  }, "No TTY detected. Provide --chain-id to specify the target chain.");
 }
 
-export function resolveRegistryAddress(chainName: string, chainId: number, registry?: string): `0x${string}` {
+// Returns the registry address if known, or null if no default exists for the chain (requires interactive prompt).
+// Throws only for an explicitly invalid registry address.
+export function resolveRegistryAddress(chainId: number, registry?: string): `0x${string}` | null {
   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)");
+  if (chainId === 31337) {
+    return null;
+  }
+  try {
+    return getIdentityRegistryAddress(chainId) as `0x${string}`;
+  } catch {
+    return null;
   }
-  return getIdentityRegistryAddress(chainId) as `0x${string}`;
 }
 
 export function validateBrowserRpcConflict(browser: boolean | undefined, rpcUrl: string | undefined): void {

package/register/utils/prompt.ts

@@ -1,40 +1,82 @@
 import { checkbox, confirm, input, select } from "@inquirer/prompts";
+import { isAddress } from "viem";
 import type { RegistrationEntry } from "@aixyz/erc-8004/schemas/registration";
 
+export function isTTY(): boolean {
+  return Boolean(process.stdin.isTTY);
+}
+
+export async function withTTY<T>(fn: () => Promise<T>, nonTtyMessage: string): Promise<T> {
+  if (!isTTY()) {
+    throw new Error(nonTtyMessage);
+  }
+  return fn();
+}
+
 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)";
-      }
-    },
-  });
+  return withTTY(
+    () =>
+      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)";
+          }
+        },
+      }),
+    "No TTY detected. Provide --url to specify the agent deployment URL.",
+  );
 }
 
 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,
-  });
+  return withTTY(
+    () =>
+      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,
+      }),
+    `No TTY detected. Provide --supported-trust to specify trust mechanisms (e.g., --supported-trust "reputation,tee-attestation").`,
+  );
+}
+
+const VALID_TRUST_MECHANISMS = ["reputation", "crypto-economic", "tee-attestation", "social", "governance"] as const;
+
+export function parseSupportedTrust(value: string): string[] {
+  const items = value
+    .split(",")
+    .map((s) => s.trim())
+    .filter(Boolean);
+  const invalid = items.filter((i) => !(VALID_TRUST_MECHANISMS as readonly string[]).includes(i));
+  if (invalid.length > 0) {
+    throw new Error(
+      `Invalid trust mechanism(s): ${invalid.join(", ")}. Valid values: ${VALID_TRUST_MECHANISMS.join(", ")}`,
+    );
+  }
+  if (items.length === 0) {
+    throw new Error("--supported-trust requires at least one value.");
+  }
+  return items;
 }
 
 export async function promptSelectRegistration(registrations: RegistrationEntry[]): Promise<RegistrationEntry> {
   if (registrations.length === 1) {
     const reg = registrations[0]!;
+    if (!isTTY()) {
+      return reg;
+    }
     const yes = await confirm({
       message: `Update this registration? (agentId: ${reg.agentId}, registry: ${reg.agentRegistry})`,
       default: true,
@@ -45,13 +87,27 @@ export async function promptSelectRegistration(registrations: RegistrationEntry[
     return reg;
   }
 
-  return select({
-    message: "Select registration to update:",
-    choices: registrations.map((reg) => ({
-      name: `agentId: ${reg.agentId} — ${reg.agentRegistry}`,
-      value: reg,
-    })),
-  });
+  return withTTY(
+    () =>
+      select({
+        message: "Select registration to update:",
+        choices: registrations.map((reg) => ({
+          name: `agentId: ${reg.agentId} — ${reg.agentRegistry}`,
+          value: reg,
+        })),
+      }),
+    "No TTY detected. Multiple registrations found in app/erc-8004.ts; cannot select one non-interactively.",
+  );
+}
+
+export async function promptRegistryAddress(): Promise<`0x${string}`> {
+  return withTTY(async () => {
+    const value = await input({
+      message: "IdentityRegistry contract address (no default for this chain):",
+      validate: (v) => (isAddress(v) ? true : "Must be a valid Ethereum address (0x…)"),
+    });
+    return value as `0x${string}`;
+  }, "No TTY detected. Provide --registry to specify the IdentityRegistry contract address.");
 }
 
 export function deriveAgentUri(url: string): string {

package/register/wallet/index.ts

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import type { Chain, WalletClient } from "viem";
 import { select, input, password } from "@inquirer/prompts";
+import { withTTY } from "../utils/prompt";
 import { createPrivateKeyWallet } from "./privatekey";
 import { createKeystoreWallet } from "./keystore";
 
@@ -33,36 +34,38 @@ export async function selectWalletMethod(options: WalletOptions): Promise<Wallet
   }
 
   // Interactive: prompt user to choose
-  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" },
-    ],
-  });
+  return withTTY(async () => {
+    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" },
+      ],
+    });
 
-  switch (method) {
-    case "keystore": {
-      const keystorePath = await input({
-        message: "Enter keystore path:",
-        default: `${homedir()}/.foundry/keystores/default`,
-      });
-      return { type: "keystore", path: keystorePath };
+    switch (method) {
+      case "keystore": {
+        const keystorePath = await input({
+          message: "Enter keystore path:",
+          default: `${homedir()}/.foundry/keystores/default`,
+        });
+        return { type: "keystore", path: keystorePath };
+      }
+      case "browser":
+        return { type: "browser" };
+      case "privatekey": {
+        const key = await password({
+          message: "Enter private key:",
+          mask: "*",
+        });
+        console.warn("Warning: Using raw private key is not recommended for production");
+        return { type: "privatekey", resolveKey: () => Promise.resolve(key) };
+      }
+      default:
+        throw new Error("No wallet method selected");
     }
-    case "browser":
-      return { type: "browser" };
-    case "privatekey": {
-      const key = await password({
-        message: "Enter private key:",
-        mask: "*",
-      });
-      console.warn("Warning: Using raw private key is not recommended for production");
-      return { type: "privatekey", resolveKey: () => Promise.resolve(key) };
-    }
-    default:
-      throw new Error("No wallet method selected");
-  }
+  }, "No TTY detected. Provide --keystore, --browser, or PRIVATE_KEY environment variable to specify a signing method.");
 }
 
 export async function createWalletFromMethod(