@aixyz/cli 0.11.0 → 0.13.0

package/build/AixyzServerPlugin.ts

@@ -1,9 +1,9 @@
 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"): 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*;/,
@@ -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;
@@ -64,9 +96,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 {
@@ -86,24 +118,25 @@ 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 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 agentsDir = resolve(appDir, "agents");
+  const subAgents = glob.getAgents(agentsDir);
+
+  if (!rootAgent && 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 = glob.getTools(toolsDir);
+
   if (tools.length > 0) {
     imports.push('import { AixyzMCP } from "aixyz/server/adapters/mcp";');
     for (const tool of tools) {
@@ -115,10 +148,13 @@ 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);");
   }
 
+  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 +168,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 (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: ${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);
@@ -59,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);
@@ -125,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");
@@ -165,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/package.json

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

package/register/index.ts

@@ -22,6 +22,10 @@ erc8004Command
   .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",
     `
@@ -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
@@ -80,6 +91,9 @@ Examples:
   $ 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`,
   )
@@ -89,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")
@@ -104,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.
@@ -141,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

@@ -12,7 +12,14 @@ import {
 } from "./utils/chain";
 import { writeResultJson } from "./utils/result";
 import { label, truncateUri, broadcastAndConfirm, logSignResult } from "./utils/transaction";
-import { promptAgentUrl, promptSupportedTrust, promptRegistryAddress, 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";
@@ -22,6 +29,7 @@ import type { BaseOptions } from "./index";
 export interface RegisterOptions extends BaseOptions {
   url?: string;
   chainId?: number;
+  supportedTrust?: string;
 }
 
 export async function register(options: RegisterOptions): Promise<void> {
@@ -29,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("");
@@ -39,12 +49,14 @@ 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

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

@@ -5,7 +5,7 @@ import { signTransaction } from "./wallet/sign";
 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(":");
@@ -42,12 +54,14 @@ export async function update(options: UpdateOptions): Promise<void> {
   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

@@ -33,6 +33,7 @@ import {
 } from "viem/chains";
 import { CHAIN_ID, getIdentityRegistryAddress } from "@aixyz/erc-8004";
 import { input, select } from "@inquirer/prompts";
+import { withTTY } from "./prompt";
 
 export interface ChainConfig {
   chain: Chain;
@@ -156,29 +157,31 @@ export function resolveChainConfigById(chainId: number, rpcUrl?: string): ChainC
 // 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> {
-  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]));
+  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 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 });
+    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);
-  }
+    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;
+    return selected;
+  }, "No TTY detected. Provide --chain-id to specify the target chain.");
 }
 
 // Returns the registry address if known, or null if no default exists for the chain (requires interactive prompt).

package/register/utils/prompt.ts

@@ -2,40 +2,81 @@ 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,
@@ -46,21 +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}`> {
-  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}`;
+  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(