clawcloud 1.3.0 → 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ClawCloud
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/clawcloud.js

@@ -84,9 +84,9 @@ program
 
 program
   .command('buy')
-  .description('Purchase a VM (manual mode)')
-  .option('-t, --tier <tier>', 'VM tier (MICRO, SMALL, MEDIUM, LARGE, XLARGE)')
-  .option('-m, --months <months>', 'Duration in months (1-12)')
+  .description('Purchase a VM')
+  .option('-t, --tier <tier>', 'VM tier (0-7)', parseInt)
+  .option('-d, --days <days>', 'Duration in days (1-365)', parseInt)
   .option('-y, --yes', 'Skip confirmation')
   .action(buy);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawcloud",
-  "version": "1.3.0",
+  "version": "2.0.0",
   "description": "☁️ Cloud infrastructure AI agents can own - CLI tool",
   "main": "bin/clawcloud.js",
   "type": "module",

package/src/api/vms.js

@@ -26,7 +26,8 @@ export async function getVMs(address) {
       ip_address: vm.ssh_host,
       vm_type: vm.vm_type,
       expires_at: vm.expires_at,
-      expires_in_days: calculateDaysRemaining(vm.expires_at)
+      expires_in_days: calculateDaysRemaining(vm.expires_at),
+      access_token: vm.access_token
     }));
     
   } catch (error) {

package/src/commands/buy.js

@@ -1,8 +1,173 @@
 import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+import { ethers } from 'ethers';
+import { getWalletConfig, getConfig, getTierInfo } from '../utils/config.js';
+
+const CONTRACT_ABI = [
+  'function purchaseVM(uint8 tier, uint16 durationDays) external returns (uint256)',
+  'function getPrice(uint8 tier, uint16 durationDays) external view returns (uint256)',
+  'event VMPurchased(uint256 indexed tokenId, address indexed buyer, uint8 tier, uint16 durationDays)'
+];
+
+const USDC_ABI = [
+  'function approve(address spender, uint256 amount) external returns (bool)',
+  'function allowance(address owner, address spender) external view returns (uint256)',
+  'function balanceOf(address account) external view returns (uint256)',
+  'function decimals() external view returns (uint8)'
+];
+
 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'));
+  const wallet = getWalletConfig();
+  const config = getConfig();
+  const tierInfo = getTierInfo();
+  
+  if (!wallet) {
+    console.log(chalk.red('\n❌ No wallet configured!\n'));
+    console.log(chalk.yellow('Run: npx clawcloud configure\n'));
+    return;
+  }
+  
+  console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.cyan.bold('              PURCHASE VM'));
+  console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+  
+  // Show available tiers
+  console.log(chalk.white('Available Tiers:\n'));
+  Object.entries(tierInfo).forEach(([tier, info]) => {
+    console.log(chalk.cyan(`  Tier ${tier}: ${info.name}`));
+    console.log(chalk.gray(`    Provider: ${info.provider}, ${info.cpu || info.gpu}\n`));
+  });
+  
+  // Get tier and duration
+  const answers = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'tier',
+      message: 'Select tier:',
+      choices: Object.entries(tierInfo).map(([tier, info]) => ({
+        name: `Tier ${tier}: ${info.name} (${info.provider})`,
+        value: parseInt(tier)
+      })),
+      when: !options.tier
+    },
+    {
+      type: 'number',
+      name: 'days',
+      message: 'Duration in days (1-365):',
+      default: 7,
+      validate: (input) => input >= 1 && input <= 365,
+      when: !options.days
+    }
+  ]);
+  
+  const tier = options.tier || answers.tier;
+  const days = options.days || answers.days;
+  
+  const spinner = ora('Connecting to blockchain...').start();
+  
+  try {
+    // Setup provider and signer
+    const provider = new ethers.JsonRpcProvider(config.RPC_URL);
+    const signer = new ethers.Wallet(wallet.privateKey, provider);
+    
+    // Connect to contracts
+    const contract = new ethers.Contract(config.CONTRACT_ADDRESS, CONTRACT_ABI, signer);
+    const usdc = new ethers.Contract(config.USDC_ADDRESS, USDC_ABI, signer);
+    
+    spinner.text = 'Checking USDC balance...';
+    
+    // Get price and balance
+    const price = await contract.getPrice(tier, days);
+    const balance = await usdc.balanceOf(wallet.address);
+    const decimals = await usdc.decimals();
+    
+    const priceFormatted = ethers.formatUnits(price, decimals);
+    const balanceFormatted = ethers.formatUnits(balance, decimals);
+    
+    spinner.stop();
+    
+    console.log(chalk.white(`\n💰 Price: ${chalk.green(`${priceFormatted} USDC`)}`));
+    console.log(chalk.white(`💼 Your Balance: ${chalk.cyan(`${balanceFormatted} USDC`)}\n`));
+    
+    if (balance < price) {
+      console.log(chalk.red('❌ Insufficient USDC balance!\n'));
+      console.log(chalk.yellow('Fund your wallet:'));
+      console.log(chalk.gray(`  ${wallet.address}\n`));
+      return;
+    }
+    
+    // Confirm purchase
+    if (!options.yes) {
+      const { confirm } = await inquirer.prompt([{
+        type: 'confirm',
+        name: 'confirm',
+        message: `Purchase Tier ${tier} VM for ${days} days at ${priceFormatted} USDC?`,
+        default: false
+      }]);
+      
+      if (!confirm) {
+        console.log(chalk.yellow('\nPurchase cancelled.\n'));
+        return;
+      }
+    }
+    
+    spinner.start('Checking USDC allowance...');
+    
+    // Check and set allowance
+    const allowance = await usdc.allowance(wallet.address, config.CONTRACT_ADDRESS);
+    
+    if (allowance < price) {
+      spinner.text = 'Approving USDC...';
+      const approveTx = await usdc.approve(config.CONTRACT_ADDRESS, ethers.MaxUint256);
+      await approveTx.wait();
+      spinner.succeed('USDC approved!');
+      spinner.start('Purchasing VM...');
+    } else {
+      spinner.text = 'Purchasing VM...';
+    }
+    
+    // Purchase VM
+    const tx = await contract.purchaseVM(tier, days);
+    spinner.text = 'Waiting for confirmation...';
+    
+    const receipt = await tx.wait();
+    
+    // Find the VMPurchased event
+    const purchaseEvent = receipt.logs
+      .map(log => {
+        try {
+          return contract.interface.parseLog(log);
+        } catch {
+          return null;
+        }
+      })
+      .find(event => event && event.name === 'VMPurchased');
+    
+    const tokenId = purchaseEvent ? purchaseEvent.args.tokenId.toString() : 'Unknown';
+    
+    spinner.succeed('VM purchased successfully!');
+    
+    console.log(chalk.green.bold('\n✅ SUCCESS!\n'));
+    console.log(chalk.white(`🎨 NFT ID: ${chalk.cyan(`#${tokenId}`)}`));
+    console.log(chalk.white(`📦 Transaction: ${chalk.gray(receipt.hash)}`));
+    console.log(chalk.white(`⏳ Provisioning: ${chalk.yellow('Starting...')}\n`));
+    
+    console.log(chalk.gray('Your VM is being provisioned. Check status:'));
+    console.log(chalk.cyan(`  npx clawcloud status ${tokenId}\n`));
+    
+    console.log(chalk.gray('SSH access will be available in 2-5 minutes.'));
+    console.log(chalk.cyan(`  npx clawcloud ssh ${tokenId}\n`));
+    
+  } catch (error) {
+    spinner.fail('Purchase failed');
+    
+    if (error.code === 'INSUFFICIENT_FUNDS') {
+      console.error(chalk.red('\n❌ Insufficient ETH for gas fees\n'));
+    } else if (error.message.includes('user rejected')) {
+      console.log(chalk.yellow('\n⚠️  Transaction cancelled\n'));
+    } else {
+      console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+    }
+  }
 }

package/src/commands/ssh.js

@@ -1,5 +1,96 @@
 import chalk from 'chalk';
+import ora from 'ora';
+import { spawn } from 'child_process';
+import { getWalletConfig, getConfig } from '../utils/config.js';
+import { getVMs } from '../api/vms.js';
+
 export async function ssh(nftId) {
-  console.log(chalk.gray(`\nConnecting to VM (NFT #${nftId})...\n`));
-  console.log(chalk.yellow('Coming soon!\n'));
+  const wallet = getWalletConfig();
+  const config = getConfig();
+  
+  if (!wallet) {
+    console.log(chalk.red('\n❌ No wallet configured!\n'));
+    console.log(chalk.yellow('Run: npx clawcloud configure\n'));
+    return;
+  }
+  
+  const spinner = ora(`Connecting to VM #${nftId}...`).start();
+  
+  try {
+    // Get all VMs to find the access token
+    const response = await fetch(`${config.API_URL}/vms/${wallet.address}`);
+    const data = await response.json();
+    const vmData = data.vms.find(v => v.token_id.toString() === nftId.toString());
+    
+    if (!vmData) {
+      spinner.fail(`NFT #${nftId} not found`);
+      console.log(chalk.red(`\n❌ You don't own NFT #${nftId}\n`));
+      return;
+    }
+    
+    if (!vmData.access_token) {
+      spinner.fail('Access token not available');
+      console.log(chalk.red('\n❌ VM access token not found\n'));
+      return;
+    }
+    
+    // Fetch detailed status using access token
+    const statusResponse = await fetch(`${config.API_URL}/status/${vmData.access_token}`);
+    const statusData = await statusResponse.json();
+    
+    spinner.stop();
+    
+    if (statusData.status !== 'running') {
+      console.log(chalk.yellow(`\n⚠️  VM is ${statusData.status}`));
+      
+      if (statusData.status === 'provisioning') {
+        console.log(chalk.gray('   Still setting up your VM...'));
+        console.log(chalk.gray('   Try again in a few minutes\n'));
+      } else if (statusData.status === 'failed') {
+        console.log(chalk.red('   VM provisioning failed'));
+        if (statusData.errorMessage) {
+          console.log(chalk.gray(`   Error: ${statusData.errorMessage}\n`));
+        }
+      }
+      return;
+    }
+    
+    if (!statusData.ssh) {
+      console.log(chalk.red('\n❌ SSH credentials not available\n'));
+      return;
+    }
+    
+    console.log(chalk.cyan(`\n🔌 Connecting to ${statusData.ssh.host}...\n`));
+    console.log(chalk.gray(`Command: ${statusData.ssh.command}\n`));
+    
+    // Spawn SSH process
+    const sshProcess = spawn('ssh', [
+      '-o', 'StrictHostKeyChecking=no',
+      '-o', 'UserKnownHostsFile=/dev/null',
+      '-p', statusData.ssh.port.toString(),
+      `${statusData.ssh.username}@${statusData.ssh.host}`
+    ], {
+      stdio: 'inherit'
+    });
+    
+    sshProcess.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        console.log(chalk.red('\n❌ SSH not found on your system\n'));
+        console.log(chalk.yellow('Install SSH client or use this command manually:'));
+        console.log(chalk.green(`  ${statusData.ssh.command}\n`));
+      } else {
+        console.error(chalk.red(`\n❌ SSH error: ${err.message}\n`));
+      }
+    });
+    
+    sshProcess.on('exit', (code) => {
+      if (code !== 0 && code !== null) {
+        console.log(chalk.gray(`\nSSH disconnected (exit code: ${code})\n`));
+      }
+    });
+    
+  } catch (error) {
+    spinner.fail('Failed to connect');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+  }
 }

package/src/commands/status.js

@@ -1,5 +1,94 @@
 import chalk from 'chalk';
+import ora from 'ora';
+import { getWalletConfig, getConfig } from '../utils/config.js';
+import { getVMs } from '../api/vms.js';
+
 export async function status(nftId, options = {}) {
-  console.log(chalk.gray(`\nFetching NFT #${nftId} details...\n`));
-  console.log(chalk.yellow('Coming soon!\n'));
+  const wallet = getWalletConfig();
+  const config = getConfig();
+  
+  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 status for NFT #${nftId}...`).start();
+  
+  try {
+    // First, get all VMs to find the access token
+    const vms = await getVMs(wallet.address);
+    const vm = vms.find(v => v.nft_id.toString() === nftId.toString());
+    
+    if (!vm) {
+      spinner.fail(`NFT #${nftId} not found`);
+      console.log(chalk.red(`\n❌ You don't own NFT #${nftId}\n`));
+      return;
+    }
+    
+    // Get the access token from the API
+    const response = await fetch(`${config.API_URL}/vms/${wallet.address}`);
+    const data = await response.json();
+    const vmData = data.vms.find(v => v.token_id.toString() === nftId.toString());
+    
+    if (!vmData || !vmData.access_token) {
+      spinner.fail('Access token not found');
+      console.log(chalk.red('\n❌ VM access token not available\n'));
+      return;
+    }
+    
+    // Fetch detailed status using access token
+    const statusResponse = await fetch(`${config.API_URL}/status/${vmData.access_token}`);
+    const statusData = await statusResponse.json();
+    
+    spinner.stop();
+    
+    if (options.json) {
+      console.log(JSON.stringify(statusData, null, 2));
+      return;
+    }
+    
+    console.log(chalk.cyan.bold('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+    console.log(chalk.cyan.bold(`              NFT #${nftId} STATUS`));
+    console.log(chalk.cyan.bold('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    
+    const statusColor = statusData.status === 'running' ? chalk.green : 
+                       statusData.status === 'provisioning' ? chalk.yellow :
+                       statusData.status === 'failed' ? chalk.red :
+                       chalk.gray;
+    
+    console.log(chalk.white(`🎨 NFT ID: ${chalk.cyan(`#${statusData.tokenId}`)}`));
+    console.log(chalk.white(`📊 Status: ${statusColor(statusData.status.toUpperCase())}`));
+    console.log(chalk.white(`🎯 Tier: ${chalk.cyan(statusData.tier)}`));
+    console.log(chalk.white(`☁️  Provider: ${chalk.cyan(statusData.type || 'N/A')}`));
+    console.log(chalk.white(`💼 Owner: ${chalk.gray(statusData.owner)}`));
+    console.log(chalk.white(`⏰ Expires: ${chalk.yellow(new Date(statusData.expiresAt).toLocaleString())}`));
+    
+    if (statusData.ssh) {
+      console.log(chalk.green.bold('\n✅ SSH ACCESS READY:\n'));
+      console.log(chalk.white(`🌐 Host: ${chalk.cyan(statusData.ssh.host)}`));
+      console.log(chalk.white(`🔌 Port: ${chalk.cyan(statusData.ssh.port)}`));
+      console.log(chalk.white(`👤 User: ${chalk.cyan(statusData.ssh.username)}`));
+      console.log(chalk.white(`🔑 Command: ${chalk.green(statusData.ssh.command)}`));
+    } else if (statusData.status === 'provisioning') {
+      console.log(chalk.yellow('\n⏳ VM is still provisioning...'));
+      console.log(chalk.gray('   Check back in a few minutes\n'));
+    } else if (statusData.status === 'failed') {
+      console.log(chalk.red('\n❌ VM provisioning failed'));
+      if (statusData.errorMessage) {
+        console.log(chalk.gray(`   Error: ${statusData.errorMessage}`));
+      }
+    }
+    
+    console.log(chalk.gray('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+    
+    if (statusData.ssh) {
+      console.log(chalk.white('Connect with:'));
+      console.log(chalk.green(`  ${statusData.ssh.command}\n`));
+    }
+    
+  } catch (error) {
+    spinner.fail('Failed to fetch VM status');
+    console.error(chalk.red(`\n❌ Error: ${error.message}\n`));
+  }
 }

package/src/utils/config.js

@@ -56,10 +56,10 @@ export function getWalletConfig() {
 export function getConfig() {
   const defaultConfig = {
     API_URL: 'https://api.clawcloud.co',
-    API_VERSION: '1.3.0',
+    API_VERSION: '2.0.0',
     CONTRACT_ADDRESS: '0xF708741D37C420518852c6A15aB658066951c852',
     USDC_ADDRESS: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
-    RPC_URL: 'https://mainnet.base.org',
+    RPC_URL: 'https://base-mainnet.infura.io/v3/8f41e4a169f14e539ff9a576b2be421c',
     TELEGRAM_BOT: 'clawcloud_devbot',
     NETWORK: 'base',
     CHAIN_ID: 8453