8004agent-cli 1.0.0

package/bin/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { program } from 'commander';
+import { init } from '../src/commands/init.js';
+import { mainMenu } from '../src/commands/menu.js';
+
+program
+  .name('8004agent')
+  .version('1.0.0')
+  .description('8004agent.network CLI - Create and register AI agents on-chain');
+
+program
+  .command('init')
+  .description('Initialize the CLI with your owner address')
+  .action(init);
+
+program
+  .action(mainMenu);
+
+program.parse(process.argv);

package/config.json

@@ -0,0 +1,3 @@
+{
+  "ownerAddress": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "8004agent-cli",
+  "version": "1.0.0",
+  "main": "index.js",
+  "bin": {
+    "8004agent": "./bin/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "8004agent.network CLI - Create and register AI agents on-chain",
+  "dependencies": {
+    "@google/generative-ai": "^0.24.1",
+    "@privy-io/server-auth": "^1.32.5",
+    "axios": "^1.13.4",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.2.4",
+    "ethers": "^6.16.0",
+    "facinet": "^2.3.0",
+    "figlet": "^1.10.0",
+    "gradient-string": "^3.0.0",
+    "inquirer": "^12.11.1",
+    "ora": "^9.3.0"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.18"
+  }
+}

package/src/commands/create.js

@@ -0,0 +1,424 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { ethers } from 'ethers';
+import { CONTRACTS, PRICING, RELAYER_PRIVATE_KEY } from '../lib/constants.js';
+import { getConfig, saveConfig } from '../lib/config.js';
+import { payWithFacinet, buildGaslessPaymentData, submitGaslessPayment } from '../lib/payment.js';
+import { createPrivyWalletForAgent } from '../lib/privy.js';
+import { mineSaltFor8004, deployAgentWallet } from '../lib/agentWallet.js';
+import { useBackend, apiRegister, apiDeployAgentWallet, apiSetAgentWallet } from '../lib/api.js';
+import { IdentityRegistryABI } from '../lib/abi.js';
+import { getProvider, getSigner } from '../lib/web3.js';
+import { spinner, success, error, info } from '../lib/ui.js';
+
+export const createAgent = async () => {
+  const config = getConfig();
+
+  // ---- 1. Collect Agent Details ----
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Agent Name:',
+      validate: (input) => (input ? true : 'Name is required'),
+    },
+    {
+      type: 'input',
+      name: 'personality',
+      message: 'Personality/System Prompt:',
+    },
+    {
+      type: 'input',
+      name: 'keyword',
+      message: 'Primary Capability (e.g., defi yield, image gen):',
+      default: 'general assistance',
+    },
+    {
+      type: 'input',
+      name: 'imageUrl',
+      message: 'Agent Image URL (optional):',
+      default: '',
+    },
+    {
+      type: 'input',
+      name: 'details',
+      message: 'Additional Details/Requirements (optional):',
+      default: '',
+    },
+  ]);
+
+  // ---- 2. Select Networks ----
+  const { networks } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'networks',
+      message: 'Which networks would you like to register on?',
+      choices: Object.keys(CONTRACTS).map((key) => ({
+        name: CONTRACTS[key].name,
+        value: key,
+      })),
+      validate: (input) =>
+        input.length > 0 ? true : 'Select at least one network.',
+    },
+  ]);
+
+  // ---- 3. Signing Method ----
+  const { signingMethod } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'signingMethod',
+      message: 'How would you like to handle payment?',
+      choices: [
+        {
+          name: 'Enter Private Key (fully automated payment + registration)',
+          value: 'privateKey',
+        },
+        {
+          name: 'Sign Message (gasless - sign in your wallet, no private key needed)',
+          value: 'signMessage',
+        },
+      ],
+    },
+  ]);
+
+  let signerKey = null;
+  let payerAddress = null;
+  if (signingMethod === 'privateKey') {
+    const { key } = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'key',
+        message: 'Enter your Private Key:',
+        mask: '*',
+      },
+    ]);
+    signerKey = key.trim();
+  } else {
+    const { walletAddr } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'walletAddr',
+        message: 'Enter your wallet address (the address holding USDC):',
+        validate: (input) =>
+          ethers.isAddress(input) ? true : 'Please enter a valid Ethereum address.',
+      },
+    ]);
+    payerAddress = walletAddr.trim();
+  }
+
+  // ---- 4. AI Code Generation + Deployment ----
+  const genSpinner = spinner('Generating Agent Code using Gemini...').start();
+  const { generateAgentCode } = await import('../lib/ai.js');
+  const { deployToVercel } = await import('../lib/vercel.js');
+
+  const code = await generateAgentCode(
+    answers.name,
+    answers.personality,
+    answers.keyword,
+    answers.imageUrl,
+    answers.details
+  );
+  genSpinner.succeed('Agent Code Generated!');
+
+  const deploySpinner = spinner('Deploying agent to Vercel...').start();
+  const agentUrl = await deployToVercel(answers.name, code);
+  deploySpinner.succeed(`Agent deployed at: ${chalk.underline(agentUrl)}`);
+
+  // ---- 5. Payment ----
+  const primaryNetwork = networks[0];
+  const totalCost = PRICING.create * networks.length;
+  let paymentTxHash = null;
+
+  if (signingMethod === 'privateKey') {
+    const paySpinner = spinner(
+      `Processing gasless payment of $${totalCost.toFixed(2)} USDC via Facinet x402 on ${CONTRACTS[primaryNetwork].name}...`
+    ).start();
+
+    try {
+      const result = await payWithFacinet({
+        amount: totalCost.toString(),
+        privateKey: signerKey,
+        networkKey: primaryNetwork,
+      });
+      paymentTxHash = result.txHash;
+      paySpinner.succeed(`Payment confirmed! Tx: ${chalk.underline(paymentTxHash)}`);
+    } catch (e) {
+      paySpinner.fail(`Payment failed: ${e.message}`);
+      return;
+    }
+  } else {
+    // Gasless signature flow: build EIP-712 message, user signs, relayer submits
+    const buildSpinner = spinner(
+      `Building gasless payment authorization for $${totalCost.toFixed(2)} USDC on ${CONTRACTS[primaryNetwork].name}...`
+    ).start();
+
+    let paymentData;
+    try {
+      paymentData = await buildGaslessPaymentData(payerAddress, totalCost, primaryNetwork);
+      buildSpinner.succeed('Payment authorization ready!');
+    } catch (e) {
+      buildSpinner.fail(`Failed to build payment data: ${e.message}`);
+      return;
+    }
+
+    // Display the EIP-712 typed data for the user to sign
+    console.log('');
+    info('=== GASLESS PAYMENT - SIGN THIS MESSAGE ===');
+    console.log('');
+    console.log(chalk.yellow('  Sign the following EIP-712 typed data in your wallet.'));
+    console.log(chalk.yellow('  This authorizes a gasless USDC transfer (you pay NO gas).'));
+    console.log('');
+    console.log(chalk.white(JSON.stringify({
+      domain: paymentData.domain,
+      primaryType: paymentData.primaryType,
+      types: paymentData.types,
+      message: paymentData.message,
+    }, null, 2)));
+    console.log('');
+    info('  How to sign:');
+    info('  - MetaMask: Use eth_signTypedData_v4 via a dApp or browser console');
+    info('  - Foundry:  cast wallet sign-typed-data ...');
+    info('  - Any EIP-712 compatible wallet or signing tool');
+    console.log('');
+
+    const { signature } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'signature',
+        message: 'Paste your signature (0x...):',
+        validate: (input) =>
+          /^0x[0-9a-fA-F]{130}$/.test(input)
+            ? true
+            : 'Invalid signature (expected 0x + 130 hex chars = 65 bytes)',
+      },
+    ]);
+
+    const submitSpinner = spinner('Submitting gasless payment via relayer...').start();
+    try {
+      const result = await submitGaslessPayment(paymentData, signature, primaryNetwork);
+      paymentTxHash = result.txHash;
+      submitSpinner.succeed(`Payment confirmed! Tx: ${chalk.underline(paymentTxHash)}`);
+    } catch (e) {
+      submitSpinner.fail(`Gasless payment failed: ${e.message}`);
+      return;
+    }
+  }
+
+  // ---- 6. Registration Loop ----
+  const results = [];
+
+  for (const netKey of networks) {
+    const netConfig = CONTRACTS[netKey];
+    info(`\n--- Registering on ${netConfig.name} ---`);
+
+    const netResult = {
+      network: netConfig.name,
+      agentId: null,
+      registrationTx: null,
+      smartWallet: null,
+      agentWallet: null,
+      blockExplorer: netConfig.blockExplorer,
+    };
+
+    try {
+      // 6a. Register on-chain (backend relayer or local)
+      const registerSpinner = spinner('Registering agent on-chain...').start();
+      const hasRelayer = useBackend() || !!RELAYER_PRIVATE_KEY;
+      let agentId;
+      let receiptHash;
+
+      if (useBackend() && !signerKey) {
+        try {
+          registerSpinner.text = 'Registering via backend relayer...';
+          const result = await apiRegister(agentUrl, netKey, config?.ownerAddress);
+          agentId = result.agentId;
+          receiptHash = result.txHash;
+          registerSpinner.succeed(`Agent ID: ${agentId} | Tx: ${chalk.underline(receiptHash)}`);
+        } catch (e) {
+          registerSpinner.fail(`Registration failed: ${e.message}`);
+          results.push(netResult);
+          continue;
+        }
+      } else if (hasRelayer || signerKey) {
+        const provider = getProvider(netConfig.rpc);
+        const registrantKey = hasRelayer && !signerKey ? RELAYER_PRIVATE_KEY : signerKey;
+        const registrantAddress = new ethers.Wallet(registrantKey).address;
+        if (hasRelayer && !signerKey) registerSpinner.text = 'Registering via gasless relayer...';
+        else registerSpinner.text = 'Registering (you pay gas)...';
+
+        const signer = getSigner(registrantKey, provider);
+        const registry = new ethers.Contract(netConfig.identityRegistry, IdentityRegistryABI, signer);
+
+        const tx = await registry['register(string)'](agentUrl);
+        registerSpinner.text = `Tx sent: ${tx.hash}. Waiting for confirmation...`;
+        const receipt = await tx.wait();
+
+        for (const evLog of receipt.logs) {
+          try {
+            const parsed = registry.interface.parseLog(evLog);
+            if (parsed?.name === 'Registered') {
+              agentId = parsed.args.agentId.toString();
+              break;
+            }
+          } catch (e) { /* skip */ }
+        }
+
+        if (!agentId) {
+          registerSpinner.fail('Registration tx confirmed but could not parse Agent ID.');
+          results.push(netResult);
+          continue;
+        }
+
+        receiptHash = receipt.hash;
+        netResult.registrationTx = receiptHash;
+
+        if (hasRelayer && config?.ownerAddress && registrantAddress.toLowerCase() !== config.ownerAddress.toLowerCase()) {
+          registerSpinner.text = 'Transferring agent NFT to your wallet...';
+          const transferTx = await registry.transferFrom(registrantAddress, config.ownerAddress, agentId);
+          await transferTx.wait();
+        }
+
+        registerSpinner.succeed(`Agent ID: ${agentId} | Tx: ${chalk.underline(receiptHash)}`);
+      } else {
+        registerSpinner.fail('No relayer configured and no private key provided. Cannot register.');
+        results.push(netResult);
+        continue;
+      }
+
+      netResult.agentId = agentId;
+      netResult.registrationTx = netResult.registrationTx || receiptHash;
+
+      // 6b. Create Privy smart wallet
+      const privySpinner = spinner('Creating Privy smart wallet...').start();
+      try {
+        const privyResult = await createPrivyWalletForAgent(
+          agentId.toString(),
+          netKey
+        );
+        netResult.smartWallet =
+          privyResult.smartWallet || privyResult.embeddedWallet;
+        privySpinner.succeed(
+          `Smart Wallet: ${netResult.smartWallet || 'N/A'}`
+        );
+      } catch (e) {
+        privySpinner.warn(`Privy wallet skipped: ${e.message}`);
+      }
+
+      // 6c. Mine 0x8004 agent wallet + deploy
+      const mineSpinner = spinner(
+        'Mining 0x8004-prefix agent wallet address...'
+      ).start();
+      const provider = getProvider(netConfig.rpc);
+      const registrantAddress = signerKey ? new ethers.Wallet(signerKey).address : (useBackend() ? config?.ownerAddress : new ethers.Wallet(RELAYER_PRIVATE_KEY).address);
+      try {
+        const ownerForWallet = config?.ownerAddress || registrantAddress;
+        const { salt, predictedAddress } = await mineSaltFor8004(
+          ownerForWallet,
+          netKey,
+          50,
+          2000,
+          (attempts) => {
+            mineSpinner.text = `Mining 0x8004 address... (${attempts} salts tried)`;
+          }
+        );
+        mineSpinner.succeed(`Found 0x8004 address: ${predictedAddress}`);
+
+        const deployWalletSpinner = spinner('Deploying AgentWallet contract...').start();
+        let walletAddress;
+        if (useBackend() && !signerKey) {
+          try {
+            const result = await apiDeployAgentWallet(ownerForWallet, salt, netKey);
+            walletAddress = result.walletAddress;
+          } catch (e) {
+            deployWalletSpinner.fail(`Deploy failed: ${e.message}`);
+            throw e;
+          }
+        } else {
+          const deployerKey = hasRelayer ? RELAYER_PRIVATE_KEY : signerKey;
+          const { walletAddress: w } = await deployAgentWallet(ownerForWallet, salt, netKey, deployerKey);
+          walletAddress = w;
+        }
+        netResult.agentWallet = walletAddress;
+        deployWalletSpinner.succeed(`Agent Wallet: ${walletAddress}`);
+
+        if (signerKey) {
+          const linkSpinner = spinner('Linking agent wallet to identity...').start();
+          try {
+            const deadline = Math.floor(Date.now() / 1000) + 3600;
+            const registryRead = new ethers.Contract(netConfig.identityRegistry, IdentityRegistryABI, provider);
+            const domainData = await registryRead.eip712Domain();
+            const domain = { name: domainData[1], version: domainData[2], chainId: domainData[3], verifyingContract: domainData[4] };
+            const types = {
+              SetAgentWallet: [
+                { name: 'agentId', type: 'uint256' },
+                { name: 'newWallet', type: 'address' },
+                { name: 'deadline', type: 'uint256' },
+              ],
+            };
+            const ownerWallet = new ethers.Wallet(signerKey);
+            const signature = await ownerWallet.signTypedData(domain, types, { agentId, newWallet: walletAddress, deadline });
+
+            if (useBackend()) {
+              await apiSetAgentWallet(agentId, walletAddress, deadline, signature, netKey);
+            } else {
+              const registryForLink = new ethers.Contract(netConfig.identityRegistry, IdentityRegistryABI, getSigner(hasRelayer ? RELAYER_PRIVATE_KEY : signerKey, provider));
+              const linkTx = await registryForLink.setAgentWallet(agentId, walletAddress, deadline, signature);
+              await linkTx.wait();
+            }
+            linkSpinner.succeed('Agent wallet linked to identity!');
+          } catch (e) {
+            linkSpinner.warn(`Wallet linking skipped: ${e.message}`);
+          }
+        }
+      } catch (e) {
+        mineSpinner.warn(`Agent wallet skipped: ${e.message}`);
+      }
+    } catch (e) {
+      error(`Failed on ${netConfig.name}: ${e.message}`);
+    }
+
+    results.push(netResult);
+  }
+
+  // ---- 7. Summary ----
+  printSummary(answers.name, agentUrl, paymentTxHash, results);
+
+  saveConfig({
+    lastCreation: {
+      name: answers.name,
+      url: agentUrl,
+      results,
+      timestamp: new Date().toISOString(),
+    },
+  });
+
+  success('\nYour agent has been created and registered!');
+};
+
+function printSummary(agentName, agentUrl, paymentTxHash, results) {
+  console.log('');
+  console.log(chalk.bold.cyan('================================================'));
+  console.log(chalk.bold.cyan('             AGENT CREATION SUMMARY'));
+  console.log(chalk.bold.cyan('================================================'));
+  console.log(chalk.white(`  Agent Name:    ${agentName}`));
+  console.log(chalk.white(`  Agent URL:     ${agentUrl}`));
+  console.log(chalk.white(`  Payment Tx:    ${paymentTxHash || 'N/A'}`));
+  console.log(chalk.bold.cyan('------------------------------------------------'));
+
+  for (const r of results) {
+    console.log(chalk.bold.yellow(`\n  ${r.network}`));
+    console.log(chalk.white(`    Agent ID:        ${r.agentId || 'Failed'}`));
+    console.log(chalk.white(`    Registration Tx: ${r.registrationTx || 'N/A'}`));
+    console.log(chalk.white(`    Smart Wallet:    ${r.smartWallet || 'N/A'}`));
+    console.log(chalk.white(`    Agent Wallet:    ${r.agentWallet || 'N/A'}`));
+    if (r.registrationTx && r.blockExplorer) {
+      console.log(
+        chalk.gray(
+          `    Explorer:        ${r.blockExplorer}/tx/${r.registrationTx}`
+        )
+      );
+    }
+  }
+
+  console.log(chalk.bold.cyan('\n================================================'));
+}

package/src/commands/init.js

@@ -0,0 +1,26 @@
+import inquirer from 'inquirer';
+import { saveConfig, getConfigPath } from '../lib/config.js';
+import { welcome, success } from '../lib/ui.js';
+import { isValidAddress } from '../lib/web3.js';
+
+export const init = async () => {
+  await welcome();
+
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'ownerAddress',
+      message: 'Please enter your Owner Wallet Address:',
+      validate: (input) => {
+        if (isValidAddress(input)) {
+          return true;
+        }
+        return 'Please enter a valid Ethereum address.';
+      },
+    },
+  ]);
+
+  saveConfig({ ownerAddress: answers.ownerAddress });
+  success(`Configuration saved! Owner address: ${answers.ownerAddress}`);
+  success(`Config location: ${getConfigPath()}`);
+};

package/src/commands/menu.js

@@ -0,0 +1,40 @@
+import inquirer from 'inquirer';
+import { getConfig } from '../lib/config.js';
+import { welcome } from '../lib/ui.js';
+import { createAgent } from './create.js';
+import { registerAgent } from './register.js';
+
+export const mainMenu = async () => {
+  const config = getConfig();
+  if (!config || !config.ownerAddress) {
+      console.log('No configuration found. Please run "init" first.');
+      process.exit(1);
+  }
+
+  await welcome();
+
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: '[A] Create Agent (No-Code Flow)', value: 'create' },
+        { name: '[B] Register Existing Agent', value: 'register' },
+        { name: '[C] Exit', value: 'exit' }
+      ]
+    }
+  ]);
+
+  switch (action) {
+    case 'create':
+      await createAgent();
+      break;
+    case 'register':
+      await registerAgent();
+      break;
+    case 'exit':
+      process.exit(0);
+      break;
+  }
+};