clawcloud 1.1.0 → 1.3.0

package/src/api/vms.js

@@ -0,0 +1,71 @@
+import { getConfig } from '../utils/config.js';
+
+export async function getVMs(address) {
+  const config = getConfig();
+  
+  try {
+    const response = await fetch(`${config.API_URL}/vms/${address}`);
+    
+    // Handle rate limiting
+    if (response.status === 429) {
+      const data = await response.json();
+      throw new Error(`Rate limit exceeded. Try again in ${data.retryAfter || 60} seconds.`);
+    }
+    
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+    
+    const data = await response.json();
+    
+    // Transform API response to our format
+    return data.vms.map(vm => ({
+      nft_id: vm.token_id,
+      tier: vm.tier,
+      status: vm.status,
+      ip_address: vm.ssh_host,
+      vm_type: vm.vm_type,
+      expires_at: vm.expires_at,
+      expires_in_days: calculateDaysRemaining(vm.expires_at)
+    }));
+    
+  } catch (error) {
+    if (error.message.includes('fetch')) {
+      throw new Error('Cannot connect to ClawCloud API. Check your internet connection.');
+    }
+    throw error;
+  }
+}
+
+function calculateDaysRemaining(expiresAt) {
+  const now = new Date();
+  const expires = new Date(expiresAt);
+  const diff = expires - now;
+  return Math.max(0, Math.ceil(diff / (1000 * 60 * 60 * 24)));
+}
+
+export async function getTiers() {
+  const config = getConfig();
+  
+  try {
+    const response = await fetch(`${config.API_URL}/tiers`);
+    
+    if (response.status === 429) {
+      const data = await response.json();
+      throw new Error(`Rate limit exceeded. Try again in ${data.retryAfter || 60} seconds.`);
+    }
+    
+    if (!response.ok) {
+      throw new Error(`API error: ${response.status}`);
+    }
+    
+    const data = await response.json();
+    return data.tiers;
+    
+  } catch (error) {
+    if (error.message.includes('fetch')) {
+      throw new Error('Cannot connect to ClawCloud API. Check your internet connection.');
+    }
+    throw error;
+  }
+}

package/src/api/wallet.js

@@ -0,0 +1,21 @@
+import { ethers } from 'ethers';
+import { getConfig } from '../utils/config.js';
+
+export async function getBalance(address) {
+  const config = getConfig();
+  
+  try {
+    const provider = new ethers.JsonRpcProvider(config.RPC_URL);
+    const usdcContract = new ethers.Contract(
+      config.USDC_ADDRESS,
+      ['function balanceOf(address) view returns (uint256)'],
+      provider
+    );
+    
+    const balance = await usdcContract.balanceOf(address);
+    return ethers.formatUnits(balance, 6); // USDC has 6 decimals
+  } catch (error) {
+    // Fallback for development
+    return '0.00';
+  }
+}

package/src/commands/balance.js

@@ -0,0 +1,27 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getWalletConfig } from '../utils/config.js';
+import { getBalance } from '../api/wallet.js';
+
+export async function balance(options = {}) {
+  const wallet = getWalletConfig();
+  
+  if (!wallet) {
+    console.log(chalk.red('\n❌ No wallet configured!\n'));
+    return;
+  }
+  
+  const spinner = ora('Checking balance...').start();
+  
+  try {
+    const bal = await getBalance(wallet.address);
+    spinner.succeed(`Balance: ${chalk.yellow(bal)} USDC`);
+    
+    if (options.json) {
+      console.log(JSON.stringify({ balance: bal, currency: 'USDC' }));
+    }
+  } catch (error) {
+    spinner.fail('Failed to check balance');
+    console.error(chalk.red(`Error: ${error.message}`));
+  }
+}

package/src/commands/buy.js

@@ -0,0 +1,8 @@
+import chalk from 'chalk';
+export async function buy(options = {}) {
+  console.log(chalk.yellow('\n⚠️  Manual Purchase Mode\n'));
+  console.log(chalk.white('Note: ClawCloud is designed for AUTONOMOUS agents.'));
+  console.log(chalk.white('      Your agent can purchase VMs on its own!\n'));
+  console.log(chalk.cyan('Run: npx clawcloud export\n'));
+  console.log(chalk.gray('Manual purchase coming soon...\n'));
+}

package/src/commands/configure.js

@@ -0,0 +1,86 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import { ethers } from 'ethers';
+import { saveWallet, getAgent } from '../utils/config.js';
+import { getBalance } from '../api/wallet.js';
+
+export async function configure() {
+  console.log(chalk.cyan.bold('\n🔐 Configure Agent Wallet\n'));
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'agentId',
+      message: 'Agent ID:',
+      validate: (input) => input.startsWith('agent_') || 'Invalid agent ID format'
+    },
+    {
+      type: 'password',
+      name: 'privateKey',
+      message: 'Private Key (from Telegram bot):',
+      validate: (input) => {
+        try {
+          new ethers.Wallet(input);
+          return true;
+        } catch {
+          return 'Invalid private key';
+        }
+      }
+    }
+  ]);
+  
+  const spinner = ora('Verifying...').start();
+  
+  try {
+    // Create wallet from private key
+    const wallet = new ethers.Wallet(answers.privateKey);
+    const address = wallet.address;
+    
+    // Get agent info
+    const agent = getAgent(answers.agentId);
+    
+    if (!agent) {
+      spinner.fail('Agent not found');
+      console.log(chalk.yellow(`\n⚠️  Agent ID not found locally. Did you run 'npx clawcloud register'?\n`));
+      return;
+    }
+    
+    // Save wallet configuration
+    saveWallet(answers.agentId, answers.privateKey, address);
+    
+    // Check balance
+    const balance = await getBalance(address);
+    
+    spinner.succeed('Agent Configured!');
+    
+    console.log(boxen(
+      chalk.bold.white(`Agent: ${chalk.cyan(agent.name)}\n`) +
+      chalk.white(`Wallet: ${chalk.green(address)}\n`) +
+      chalk.white(`Balance: ${chalk.yellow(balance)} USDC\n`) +
+      chalk.white(`Network: ${chalk.blue('Base')}\n\n`) +
+      chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+      (balance === '0.00' ? 
+        chalk.white.bold('💰 Fund your agent:\n') +
+        chalk.blue(`   https://clawcloud.co/fund/${answers.agentId}\n\n`) :
+        chalk.green.bold('✅ Agent is funded and ready!\n\n')
+      ) +
+      chalk.white('Next steps:\n') +
+      chalk.cyan('  npx clawcloud balance') + chalk.gray('      - Check USDC balance\n') +
+      chalk.cyan('  npx clawcloud export') + chalk.gray('       - Enable autonomous mode'),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'green'
+      }
+    ));
+    
+    console.log(chalk.gray(`\n🔒 Wallet saved securely to: ~/.clawcloud/wallet.json\n`));
+    
+  } catch (error) {
+    spinner.fail('Configuration failed');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+  }
+}

package/src/commands/export.js

@@ -0,0 +1,203 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getWalletConfig } from '../utils/config.js';
+
+export async function exportConfig(options = {}) {
+  console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold('         AUTONOMOUS AGENT CONFIGURATION'));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+  
+  console.log(chalk.white('This enables your AI agent to:\n'));
+  console.log(chalk.green('  ✓ Purchase VMs autonomously'));
+  console.log(chalk.green('  ✓ Check balance and make decisions'));
+  console.log(chalk.green('  ✓ Deploy code automatically'));
+  console.log(chalk.green('  ✓ Scale compute based on needs\n'));
+  
+  // Get wallet config
+  const walletConfig = getWalletConfig();
+  
+  if (!walletConfig) {
+    console.log(chalk.red('❌ No wallet configured!\n'));
+    console.log(chalk.yellow('Run: npx clawcloud configure\n'));
+    return;
+  }
+  
+  let framework = options.framework;
+  
+  if (!framework) {
+    const { selectedFramework } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'selectedFramework',
+        message: 'Agent framework:',
+        choices: [
+          { name: '🦞 OpenClaw / Clawd / Molt (Skill)', value: 'openclaw' },
+          { name: '📦 Node.js SDK', value: 'nodejs' },
+          { name: '🐍 Python SDK', value: 'python' },
+          { name: '🔧 Environment Variables (Generic)', value: 'env' }
+        ]
+      }
+    ]);
+    framework = selectedFramework;
+  }
+  
+  const spinner = ora('Exporting configuration...').start();
+  
+  try {
+    switch (framework) {
+      case 'openclaw':
+        await exportOpenClaw(walletConfig, spinner);
+        break;
+      case 'nodejs':
+        await exportNodeJS(walletConfig, spinner);
+        break;
+      case 'python':
+        await exportPython(walletConfig, spinner);
+        break;
+      case 'env':
+        await exportEnv(walletConfig, spinner);
+        break;
+    }
+  } catch (error) {
+    spinner.fail('Export failed');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+  }
+}
+
+async function exportOpenClaw(config, spinner) {
+  const { workspace } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'workspace',
+      message: 'OpenClaw workspace path:',
+      default: path.join(os.homedir(), '.openclaw', 'workspace')
+    }
+  ]);
+  
+  const skillPath = path.join(workspace, 'skills', 'clawcloud');
+  
+  // Create skill directory
+  if (!fs.existsSync(skillPath)) {
+    fs.mkdirSync(skillPath, { recursive: true });
+  }
+  
+  // Copy SKILL.md template
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'SKILL.md');
+  const skillContent = fs.readFileSync(templatePath, 'utf-8')
+    .replace('{{WALLET_ADDRESS}}', config.address)
+    .replace('{{PRIVATE_KEY}}', config.privateKey)
+    .replace('{{AGENT_ID}}', config.agentId);
+  
+  fs.writeFileSync(path.join(skillPath, 'SKILL.md'), skillContent);
+  
+  spinner.succeed('Skill Installed!');
+  
+  console.log(boxen(
+    chalk.bold.white(`Location: ${chalk.cyan(skillPath)}\n`) +
+    chalk.white(`Version: ${chalk.yellow('1.0.0')}\n\n`) +
+    chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n') +
+    chalk.bold.white('         YOUR AGENT CAN NOW:\n') +
+    chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+    chalk.white('🗣️  Talk to your agent:\n\n') +
+    chalk.cyan('   "How much USDC do I have?"\n') +
+    chalk.cyan('   "Buy me a SMALL VM for 1 month"\n') +
+    chalk.cyan('   "Check my VMs"\n') +
+    chalk.cyan('   "I need more compute for backtesting"\n\n') +
+    chalk.white('🤖 The agent will:\n') +
+    chalk.gray('   • Decide when it needs compute\n') +
+    chalk.gray('   • Purchase VMs automatically\n') +
+    chalk.gray('   • Deploy code on its own\n') +
+    chalk.gray('   • Manage infrastructure 24/7\n\n') +
+    chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+    chalk.white(`View skill: ${chalk.gray(`cat ${skillPath}/SKILL.md`)}\n`) +
+    chalk.white(`Test agent: ${chalk.gray('molt chat')}`),
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'green'
+    }
+  ));
+}
+
+async function exportNodeJS(config, spinner) {
+  const configPath = path.join(os.homedir(), '.clawcloud', 'autonomous-config.json');
+  
+  fs.writeFileSync(configPath, JSON.stringify({
+    agentId: config.agentId,
+    walletAddress: config.address,
+    privateKey: config.privateKey,
+    network: 'base',
+    apiUrl: 'https://api.clawcloud.co/v1'
+  }, null, 2));
+  
+  spinner.succeed('Configuration Exported!');
+  
+  console.log(boxen(
+    chalk.bold.white(`File: ${chalk.cyan(configPath)}\n\n`) +
+    chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n') +
+    chalk.bold.white('         AUTONOMOUS AGENT CODE\n') +
+    chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+    chalk.gray('import') + chalk.white(' ClawCloud ') + chalk.gray('from') + chalk.green(' \'@clawcloud/sdk\'' + chalk.white(';\n\n')) +
+    chalk.gray('const') + chalk.white(' cloud = ') + chalk.gray('new') + chalk.white(' ClawCloud({\n') +
+    chalk.white('  configPath: ') + chalk.green(`'${configPath}'`) + chalk.white('\n});\n\n') +
+    chalk.gray('// Agent checks if it needs compute\n') +
+    chalk.gray('async function') + chalk.white(' run() {\n') +
+    chalk.white('  ') + chalk.gray('const') + chalk.white(' balance = ') + chalk.gray('await') + chalk.white(' cloud.wallet.balance();\n') +
+    chalk.white('  console.log(') + chalk.green('`I have ${balance} USDC`') + chalk.white(');\n\n') +
+    chalk.white('  ') + chalk.gray('if') + chalk.white(' (needsCompute) {\n') +
+    chalk.white('    ') + chalk.gray('const') + chalk.white(' vm = ') + chalk.gray('await') + chalk.white(' cloud.vms.purchase({\n') +
+    chalk.white('      tier: ') + chalk.green('\'SMALL\'') + chalk.white(',\n') +
+    chalk.white('      months: ') + chalk.yellow('1') + chalk.white('\n') +
+    chalk.white('    });\n\n') +
+    chalk.white('    ') + chalk.gray('await') + chalk.white(' vm.waitReady();\n') +
+    chalk.white('    ') + chalk.gray('await') + chalk.white(' vm.deployCode(') + chalk.green('\'./strategy\'') + chalk.white(');\n') +
+    chalk.white('  }\n}\n\n') +
+    chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+    chalk.white('Install SDK: ') + chalk.cyan('npm install @clawcloud/sdk\n') +
+    chalk.white('Run agent:   ') + chalk.cyan('node agent.js'),
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'blue'
+    }
+  ));
+  
+  console.log(chalk.gray(`\n⚠️  Keep this file secure! Contains private key.\n`));
+}
+
+async function exportPython(config, spinner) {
+  spinner.info('Python SDK coming soon!');
+  console.log(chalk.yellow('\n🐍 Python SDK is under development.\n'));
+  console.log(chalk.white('For now, use:\n'));
+  console.log(chalk.cyan('  • Node.js SDK'));
+  console.log(chalk.cyan('  • Environment variables'));
+  console.log(chalk.gray('\nStar the repo to get notified: github.com/clawcloud/clawcloud\n'));
+}
+
+async function exportEnv(config, spinner) {
+  spinner.succeed('Environment variables exported!');
+  
+  console.log(boxen(
+    chalk.white('Add these to your ') + chalk.cyan('.env') + chalk.white(' file:\n\n') +
+    chalk.gray('CLAWCLOUD_AGENT_ID') + chalk.white('=') + chalk.green(config.agentId) + chalk.white('\n') +
+    chalk.gray('CLAWCLOUD_WALLET_ADDRESS') + chalk.white('=') + chalk.green(config.address) + chalk.white('\n') +
+    chalk.gray('CLAWCLOUD_PRIVATE_KEY') + chalk.white('=') + chalk.green(config.privateKey) + chalk.white('\n') +
+    chalk.gray('CLAWCLOUD_NETWORK') + chalk.white('=') + chalk.green('base') + chalk.white('\n') +
+    chalk.gray('CLAWCLOUD_API_URL') + chalk.white('=') + chalk.green('https://api.clawcloud.co/v1'),
+    {
+      padding: 1,
+      margin: 1,
+      borderStyle: 'round',
+      borderColor: 'yellow'
+    }
+  ));
+  
+  console.log(chalk.gray(`\n⚠️  Never commit .env files to git!\n`));
+}

package/src/commands/fund.js

@@ -0,0 +1,13 @@
+import chalk from 'chalk';
+import { getWalletConfig } from '../utils/config.js';
+export async function fund() {
+  const wallet = getWalletConfig();
+  if (!wallet) {
+    console.log(chalk.red('\n❌ No wallet configured!\n'));
+    return;
+  }
+  console.log(chalk.cyan.bold('\n💰 Fund Your Agent\n'));
+  console.log(chalk.white(`Wallet: ${chalk.green(wallet.address)}\n`));
+  console.log(chalk.white('Send USDC (Base network) to the address above.\n'));
+  console.log(chalk.blue(`Or visit: https://clawcloud.co/fund/${wallet.agentId}\n`));
+}

package/src/commands/interactive.js

@@ -0,0 +1,70 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { register } from './register.js';
+import { configure } from './configure.js';
+import { exportConfig } from './export.js';
+import { buy } from './buy.js';
+import { balance } from './balance.js';
+import { list } from './list.js';
+import { fund } from './fund.js';
+import { displayHelp } from '../utils/help.js';
+import { displayBanner } from '../utils/banner.js';
+
+export async function interactive() {
+  displayBanner();
+  
+  const { action } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: [
+        { name: '🤖 Register New Agent', value: 'register' },
+        { name: '🔐 Configure Agent (after Telegram)', value: 'configure' },
+        { name: '🚀 Export for Autonomous Use', value: 'export' },
+        new inquirer.Separator(),
+        { name: '💰 Check Balance', value: 'balance' },
+        { name: '💸 Fund Agent', value: 'fund' },
+        { name: '🛒 Purchase VM (Manual)', value: 'buy' },
+        { name: '📋 List VMs & NFTs', value: 'list' },
+        new inquirer.Separator(),
+        { name: '📖 View Documentation', value: 'docs' },
+        { name: '❓ Help', value: 'help' },
+        { name: '🚪 Exit', value: 'exit' }
+      ]
+    }
+  ]);
+  
+  switch (action) {
+    case 'register':
+      await register();
+      break;
+    case 'configure':
+      await configure();
+      break;
+    case 'export':
+      await exportConfig();
+      break;
+    case 'balance':
+      await balance();
+      break;
+    case 'fund':
+      await fund();
+      break;
+    case 'buy':
+      await buy();
+      break;
+    case 'list':
+      await list();
+      break;
+    case 'docs':
+      console.log(chalk.blue('\n📖 Documentation: https://docs.clawcloud.co\n'));
+      break;
+    case 'help':
+      displayHelp();
+      break;
+    case 'exit':
+      console.log(chalk.gray('\n👋 Goodbye!\n'));
+      process.exit(0);
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,90 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import ora from 'ora';
+import { getWalletConfig, getTierInfo } from '../utils/config.js';
+import { getVMs } from '../api/vms.js';
+
+export async function list(options = {}) {
+  const wallet = getWalletConfig();
+  
+  if (!wallet) {
+    console.log(chalk.red('\n❌ No wallet configured!\n'));
+    console.log(chalk.yellow('Run: npx clawcloud configure\n'));
+    return;
+  }
+  
+  const spinner = ora('Fetching your VMs and NFTs...').start();
+  
+  try {
+    const vms = await getVMs(wallet.address);
+    const tierInfo = getTierInfo();
+    
+    spinner.stop();
+    
+    if (options.json) {
+      console.log(JSON.stringify(vms, null, 2));
+      return;
+    }
+    
+    console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(chalk.cyan.bold('              YOUR AGENT\'S INFRASTRUCTURE'));
+    console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    
+    console.log(chalk.white(`🤖 Agent: ${chalk.cyan(wallet.agentId)}`));
+    console.log(chalk.white(`💼 Wallet: ${chalk.gray(wallet.address.substring(0, 10))}...${chalk.gray(wallet.address.substring(38))}`));
+    console.log(chalk.white(`🎨 NFTs Owned: ${chalk.green(vms.length)}\n`));
+    
+    if (vms.length === 0) {
+      console.log(chalk.yellow('No VMs yet. Purchase one:\n'));
+      console.log(chalk.cyan('  npx clawcloud buy\n'));
+      return;
+    }
+    
+    const table = new Table({
+      head: [
+        chalk.white('NFT'),
+        chalk.white('Name'),
+        chalk.white('Status'),
+        chalk.white('SSH Host'),
+        chalk.white('Expires')
+      ],
+      style: {
+        head: [],
+        border: ['gray']
+      }
+    });
+    
+    vms.forEach(vm => {
+      const statusColor = vm.status === 'running' ? chalk.green : 
+                         vm.status === 'provisioning' ? chalk.yellow :
+                         chalk.red;
+      
+      const tier = tierInfo[vm.tier];
+      const tierName = tier ? tier.name : `Tier ${vm.tier}`;
+      
+      const expiresIn = vm.expires_in_days > 0 ? 
+        `${vm.expires_in_days} days` : 
+        chalk.red('Expired');
+      
+      table.push([
+        chalk.cyan(`#${vm.nft_id}`),
+        tierName,
+        statusColor(vm.status),
+        vm.ip_address || chalk.gray('provisioning...'),
+        expiresIn
+      ]);
+    });
+    
+    console.log(table.toString());
+    
+    console.log(chalk.gray('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    console.log(chalk.white('Commands:'));
+    console.log(chalk.cyan('  npx clawcloud status <nft-id>') + chalk.gray('  - View details'));
+    console.log(chalk.cyan('  npx clawcloud ssh <nft-id>') + chalk.gray('     - Connect'));
+    console.log(chalk.gray('\n'));
+    
+  } catch (error) {
+    spinner.fail('Failed to fetch VMs');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+  }
+}

package/src/commands/nfts.js

@@ -0,0 +1,5 @@
+import chalk from 'chalk';
+export async function nfts() {
+  console.log(chalk.cyan('\n🎨 Your NFT Collection\n'));
+  console.log(chalk.yellow('Coming soon!\n'));
+}

package/src/commands/register.js

@@ -0,0 +1,72 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import boxen from 'boxen';
+import { saveAgent } from '../utils/config.js';
+import { registerAgent } from '../api/agents.js';
+
+export async function register() {
+  console.log(chalk.cyan.bold('\n🤖 Register AI Agent\n'));
+  
+  const answers = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'name',
+      message: 'Agent name:',
+      validate: (input) => input.length > 0 || 'Name is required'
+    },
+    {
+      type: 'input',
+      name: 'description',
+      message: 'Description:',
+      validate: (input) => input.length > 0 || 'Description is required'
+    }
+  ]);
+  
+  const spinner = ora('Registering agent...').start();
+  
+  try {
+    // Call API to register agent
+    const result = await registerAgent(answers.name, answers.description);
+    
+    spinner.succeed('Agent Registered!');
+    
+    // Save agent ID locally
+    saveAgent({
+      agentId: result.agent_id,
+      name: answers.name,
+      description: answers.description,
+      createdAt: result.created_at
+    });
+    
+    // Display next steps
+    console.log(boxen(
+      chalk.bold.white(`Agent ID: ${chalk.cyan(result.agent_id)}\n\n`) +
+      chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+      chalk.white.bold('📱 NEXT STEP: Get Your Wallet\n\n') +
+      chalk.white(`1. Open Telegram: ${chalk.blue('https://t.me/clawcloud_devbot')}\n\n`) +
+      chalk.white(`2. Send this command:\n   ${chalk.green(`/start ${result.agent_id}`)}\n\n`) +
+      chalk.white('3. Bot will verify your agent and create a wallet\n\n') +
+      chalk.white('4. You\'ll receive:\n') +
+      chalk.gray('   • Wallet address\n') +
+      chalk.gray('   • Private key (keep secure!)\n') +
+      chalk.gray('   • Funding instructions\n\n') +
+      chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n\n') +
+      chalk.white('After Telegram setup, run:\n') +
+      chalk.cyan('  npx clawcloud configure') + chalk.gray('    - Link wallet to CLI\n') +
+      chalk.cyan('  npx clawcloud export') + chalk.gray('       - Make agent autonomous'),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: 'round',
+        borderColor: 'cyan'
+      }
+    ));
+    
+    console.log(chalk.gray(`\nAgent ID saved to: ~/.clawcloud/agents.json\n`));
+    
+  } catch (error) {
+    spinner.fail('Registration failed');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+  }
+}

package/src/commands/ssh.js

@@ -0,0 +1,5 @@
+import chalk from 'chalk';
+export async function ssh(nftId) {
+  console.log(chalk.gray(`\nConnecting to VM (NFT #${nftId})...\n`));
+  console.log(chalk.yellow('Coming soon!\n'));
+}