rentman-cli 2.0.0

package/src/commands/task.js

@@ -0,0 +1,126 @@
+const { Command } = require('commander');
+const fs = require('fs');
+const Ajv = require('ajv');
+const { apiRequest } = require('../lib/api');
+
+const taskCommand = new Command();
+
+// JSON Schema for task validation
+const taskSchema = {
+  type: 'object',
+  required: ['title', 'description', 'task_type', 'budget_amount'],
+  properties: {
+    title: { type: 'string', maxLength: 200 },
+    description: { type: 'string' },
+    task_type: { 
+      type: 'string',
+      enum: ['delivery', 'verification', 'repair', 'representation', 'creative', 'communication']
+    },
+    location: {
+      type: 'object',
+      required: ['lat', 'lng'],
+      properties: {
+        lat: { type: 'number', minimum: -90, maximum: 90 },
+        lng: { type: 'number', minimum: -180, maximum: 180 },
+        address: { type: 'string' }
+      }
+    },
+    budget_amount: { type: 'number', minimum: 1 },
+    required_skills: { 
+      type: 'array',
+      items: { type: 'string' }
+    },
+    requirements: { type: 'object' }
+  }
+};
+
+taskCommand
+  .command('create <file>')
+  .description('Create a new task from JSON file')
+  .action(async (file) => {
+    try {
+      // Read and parse JSON file
+      if (!fs.existsSync(file)) {
+        console.error(`❌ File not found: ${file}`);
+        process.exit(1);
+      }
+
+      const taskData = JSON.parse(fs.readFileSync(file, 'utf-8'));
+      
+      // Validate schema
+      const ajv = new Ajv();
+      const validate = ajv.compile(taskSchema);
+      const valid = validate(taskData);
+      
+      if (!valid) {
+        console.error('❌ Invalid task schema:');
+        console.error(validate.errors);
+        process.exit(1);
+      }
+
+      console.log('📋 Creating task...');
+      console.log(JSON.stringify(taskData, null, 2));
+
+      // POST to API
+      const response = await apiRequest('/market-tasks', {
+        method: 'POST',
+        body: JSON.stringify(taskData),
+      });
+
+      if (response.success) {
+        const taskId = response.data.id;
+        console.log(`✅ Task Created: ${taskId}`);
+        console.log(`Status: ${response.data.status}`);
+        console.log(`Budget: $${response.data.budget_amount}`);
+      } else {
+        console.error('❌ Task creation failed');
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+taskCommand
+  .command('map')
+  .description('ASCII visualization of active tasks')
+  .action(async () => {
+    try {
+      const response = await apiRequest('/market-tasks?status=OPEN');
+      
+      console.log('🗺️  ACTIVE TASKS MAP');
+      console.log('─'.repeat(50));
+      
+      if (response.success && response.data.length > 0) {
+        response.data.forEach((task, i) => {
+          const icon = getTaskIcon(task.task_type);
+          const loc = task.location_address || '💻 Remote';
+          
+          console.log(`${icon} ${task.title}`);
+          console.log(`   📍 ${loc} | $${task.budget_amount} | ${task.status}`);
+          console.log(`   ID: ${task.id}`);
+          console.log('');
+        });
+      } else {
+        console.log('No active tasks found.');
+      }
+    } catch (error) {
+      console.error('❌ Error:', error.message);
+      process.exit(1);
+    }
+  });
+
+function getTaskIcon(type) {
+  const icons = {
+    delivery: '📦',
+    verification: '✅',
+    repair: '🔧',
+    representation: '👤',
+    creative: '🎨',
+    communication: '📞'
+  };
+  return icons[type] || '📋';
+}
+
+module.exports = taskCommand;

package/src/index.js

@@ -0,0 +1,247 @@
+/**
+ * Rentman CLI - Main Entry Point
+ * Secure, production-ready version
+ */
+
+require('dotenv').config();
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const updateNotifier = require('update-notifier');
+const pkg = require('../package.json');
+
+// Check for updates
+updateNotifier({ pkg }).notify();
+
+const program = new Command();
+
+program
+  .name('rentman')
+  .description('CLI tool for AI agents to hire humans via Rentman marketplace')
+  .version(pkg.version);
+
+// ============================================
+// Core Commands
+// ============================================
+
+program
+  .command('init')
+  .description('Initialize agent identity (KYA) and link to owner account')
+  .action(require('./commands/init-secure'));
+
+program
+  .command('post-mission [file]')
+  .description('Create a task in the marketplace (from JSON file or interactive)')
+  .alias('post')
+  .action(require('./commands/post-mission-secure'));
+
+program
+  .command('listen <taskId>')
+  .description('Listen for real-time updates on a task')
+  .alias('watch')
+  .action(require('./commands/listen'));
+
+program
+  .command('config <key> [value]')
+  .description('Get/set configuration values')
+  .action(require('./commands/config'));
+
+program
+  .command('legal [type]')
+  .description('View legal documents (privacy, terms)')
+  .action(require('./commands/legal'));
+
+program
+  .command('guide')
+  .description('Show the Rentman workflow guide')
+  .action(require('./commands/guide'));
+
+// ============================================
+// Task Management
+// ============================================
+
+program
+  .command('task:list')
+  .description('List available tasks in the marketplace')
+  .option('-s, --status <status>', 'Filter by status (open, in_progress, completed)')
+  .option('-t, --type <type>', 'Filter by task type')
+  .action(async (options) => {
+    try {
+      const { getTasks } = require('./lib/api');
+      const ora = (await import('ora')).default;
+      const Table = require('cli-table3');
+
+      const spinner = ora('Fetching tasks...').start();
+
+      const response = await getTasks({
+        status: options.status,
+        task_type: options.type,
+      });
+
+      spinner.stop();
+
+      if (response.success && response.data && response.data.length > 0) {
+        const table = new Table({
+          head: [
+            chalk.cyan('ID'),
+            chalk.cyan('Type'),
+            chalk.cyan('Title'),
+            chalk.cyan('Budget'),
+            chalk.cyan('Status'),
+          ],
+        });
+
+        const icons = {
+          delivery: '📦',
+          verification: '✅',
+          repair: '🔧',
+          representation: '👤',
+          creative: '🎨',
+          communication: '📞',
+        };
+
+        response.data.forEach((task) => {
+          const icon = icons[task.task_type] || '📋';
+          table.push([
+            task.id.substring(0, 8) + '...',
+            `${icon} ${task.task_type}`,
+            task.title.substring(0, 30),
+            chalk.green(`$${task.budget_amount}`),
+            task.status,
+          ]);
+        });
+
+        console.log(table.toString());
+        console.log(
+          chalk.gray(`\nShowing ${response.data.length} tasks (Page ${response.pagination?.page || 1})`)
+        );
+      } else {
+        console.log(chalk.yellow('No tasks found.'));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('task:view <taskId>')
+  .description('View details of a specific task')
+  .action(async (taskId) => {
+    try {
+      const { getTask } = require('./lib/api');
+      const ora = (await import('ora')).default;
+
+      const spinner = ora('Fetching task...').start();
+      const response = await getTask(taskId);
+      spinner.stop();
+
+      const task = response.data;
+
+      console.log(chalk.bold.blue('\n📋 Task Details\n'));
+      console.log(chalk.white('ID:          ') + chalk.cyan(task.id));
+      console.log(chalk.white('Title:       ') + chalk.cyan(task.title));
+      console.log(chalk.white('Type:        ') + chalk.cyan(task.task_type));
+      console.log(chalk.white('Status:      ') + chalk.cyan(task.status));
+      console.log(chalk.white('Budget:      ') + chalk.green(`$${task.budget_amount} ${task.budget_currency}`));
+      console.log(chalk.white('Description:\n') + chalk.gray(task.description));
+      console.log('');
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Human Search
+// ============================================
+
+program
+  .command('humans:search')
+  .description('Search for qualified human operators')
+  .option('-s, --skills <skills>', 'Required skills (comma-separated)')
+  .option('-r, --min-reputation <score>', 'Minimum reputation score')
+  .action(async (options) => {
+    try {
+      const { searchHumans } = require('./lib/api');
+      const ora = (await import('ora')).default;
+      const Table = require('cli-table3');
+
+      const spinner = ora('Searching humans...').start();
+
+      const filters = {};
+      if (options.skills) filters.skills = options.skills.split(',');
+      if (options.minReputation) filters.min_reputation = parseInt(options.minReputation);
+
+      const response = await searchHumans(filters);
+      spinner.stop();
+
+      if (response.success && response.data && response.data.length > 0) {
+        const table = new Table({
+          head: [
+            chalk.cyan('ID'),
+            chalk.cyan('Reputation'),
+            chalk.cyan('Level'),
+            chalk.cyan('Tasks'),
+            chalk.cyan('Success Rate'),
+          ],
+        });
+
+        response.data.forEach((human) => {
+          table.push([
+            human.id.substring(0, 8) + '...',
+            chalk.green(`${human.reputation_score}/100`),
+            `Lv ${human.level}`,
+            human.tasks_completed || 0,
+            `${human.success_rate || 0}%`,
+          ]);
+        });
+
+        console.log(table.toString());
+      } else {
+        console.log(chalk.yellow('No humans found matching criteria.'));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// ============================================
+// Utilities
+// ============================================
+
+program
+  .command('whoami')
+  .description('Show current agent identity')
+  .action(() => {
+    const { getIdentity, getConfigPath } = require('./lib/secure-config');
+    const identity = getIdentity();
+
+    if (!identity) {
+      console.log(chalk.yellow('⚠️  No identity found'));
+      console.log(chalk.gray('→ Run: rentman init'));
+      process.exit(1);
+    }
+
+    console.log(chalk.bold.blue('\n👤 Current Agent Identity\n'));
+    console.log(chalk.white('Agent ID:       ') + chalk.cyan(identity.agent_id));
+    console.log(chalk.white('Public ID:      ') + chalk.cyan(identity.public_agent_id || 'N/A'));
+    console.log(chalk.white('Public Key:     ') + chalk.gray(identity.public_key?.substring(0, 20) + '...'));
+    console.log(chalk.white('Source:         ') + chalk.cyan(identity.source));
+    console.log(chalk.white('Config Path:    ') + chalk.gray(getConfigPath()));
+    console.log('');
+  });
+
+// ============================================
+// Error Handling
+// ============================================
+
+program.on('command:*', () => {
+  console.error(chalk.red('\n❌ Invalid command: %s'), program.args.join(' '));
+  console.log(chalk.yellow('→ See --help for available commands'));
+  process.exit(1);
+});
+
+// Parse arguments
+program.parse();

package/src/lib/api.js

@@ -0,0 +1,120 @@
+/**
+ * API Client for Agent Gateway
+ * All requests go through the gateway for proper authentication and audit
+ */
+
+const fetch = require('node-fetch');
+const { getApiConfig, getApiKey, getIdentity } = require('./secure-config');
+const { generateNaclSignature } = require('./crypto');
+
+/**
+ * Make authenticated request to Agent Gateway
+ * Supports both API Key and NACL signature authentication
+ */
+async function apiRequest(endpoint, options = {}) {
+  const config = getApiConfig();
+  const apiKey = getApiKey();
+  const identity = getIdentity();
+
+  // Build full URL
+  const url = `${config.gatewayUrl}/market${endpoint}`;
+
+  // Prepare headers
+  const headers = {
+    'Content-Type': 'application/json',
+    ...options.headers,
+  };
+
+  // Authentication: Prefer NACL signature, fallback to API key
+  if (identity && identity.secret_key) {
+    // NACL Signature Authentication (most secure)
+    const method = options.method || 'GET';
+    const payload = options.body || {};
+    
+    const signature = generateNaclSignature(
+      payload,
+      identity.secret_key,
+      method,
+      `/market${endpoint}`
+    );
+
+    headers['x-agent-id'] = identity.agent_id;
+    headers['x-signature'] = `nacl:${signature}`;
+  } else if (apiKey) {
+    // API Key Authentication (fallback)
+    headers['x-api-key'] = apiKey;
+  } else {
+    throw new Error('No authentication credentials found. Run: rentman init');
+  }
+
+  // Make request
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers,
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      const error = new Error(data.error?.message || 'API request failed');
+      error.statusCode = response.status;
+      error.code = data.error?.code;
+      error.details = data.error?.details;
+      throw error;
+    }
+
+    return data;
+  } catch (error) {
+    // Network or parsing errors
+    if (!error.statusCode) {
+      throw new Error(`Network error: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Convenience methods
+ */
+async function getTasks(filters = {}) {
+  const params = new URLSearchParams(filters);
+  return apiRequest(`/tasks?${params}`);
+}
+
+async function getTask(taskId) {
+  return apiRequest(`/tasks/${taskId}`);
+}
+
+async function createTask(taskData) {
+  return apiRequest('/tasks', {
+    method: 'POST',
+    body: JSON.stringify(taskData),
+  });
+}
+
+async function searchHumans(filters = {}) {
+  const params = new URLSearchParams(filters);
+  return apiRequest(`/humans?${params}`);
+}
+
+async function hireHuman(taskId, humanId, offeredAmount, terms) {
+  return apiRequest('/hire', {
+    method: 'POST',
+    body: JSON.stringify({
+      task_id: taskId,
+      human_id: humanId,
+      offered_amount: offeredAmount,
+      terms,
+    }),
+  });
+}
+
+module.exports = {
+  apiRequest,
+  getTasks,
+  getTask,
+  createTask,
+  searchHumans,
+  hireHuman,
+};

package/src/lib/config.js

@@ -0,0 +1,34 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CONFIG_DIR = path.join(os.homedir(), '.rentman');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function getConfig() {
+  ensureConfigDir();
+  if (fs.existsSync(CONFIG_FILE)) {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+  }
+  return {};
+}
+
+function setConfig(key, value) {
+  ensureConfigDir();
+  const config = getConfig();
+  config[key] = value;
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function getApiKey() {
+  const config = getConfig();
+  return config.apiKey;
+}
+
+module.exports = { getConfig, setConfig, getApiKey };

package/src/lib/crypto.js

@@ -0,0 +1,80 @@
+/**
+ * Cryptographic Utilities
+ * NACL signature generation for Agent Gateway authentication
+ */
+
+const nacl = require('tweetnacl');
+const naclUtil = require('tweetnacl-util');
+
+/**
+ * Generate Ed25519 keypair
+ */
+function generateKeyPair() {
+  const keyPair = nacl.sign.keyPair();
+  
+  return {
+    publicKey: naclUtil.encodeBase64(keyPair.publicKey),
+    secretKey: naclUtil.encodeBase64(keyPair.secretKey),
+  };
+}
+
+/**
+ * Generate NACL signature for request authentication
+ * @param {Object} payload - Request payload (will be JSON stringified)
+ * @param {string} secretKeyBase64 - Base64 encoded secret key
+ * @param {string} method - HTTP method (GET, POST, etc.)
+ * @param {string} url - Request URL path
+ * @returns {string} Base64 encoded signature
+ */
+function generateNaclSignature(payload, secretKeyBase64, method = 'POST', url = '') {
+  try {
+    // Create message to sign: method + url + payload
+    const payloadString = typeof payload === 'string' ? payload : JSON.stringify(payload);
+    const message = `${method}:${url}:${payloadString}`;
+    
+    // Convert to bytes
+    const messageBytes = naclUtil.decodeUTF8(message);
+    const secretKeyBytes = naclUtil.decodeBase64(secretKeyBase64);
+    
+    // Sign message
+    const signature = nacl.sign.detached(messageBytes, secretKeyBytes);
+    
+    // Return base64 encoded signature
+    return naclUtil.encodeBase64(signature);
+  } catch (error) {
+    throw new Error(`Failed to generate signature: ${error.message}`);
+  }
+}
+
+/**
+ * Verify NACL signature (for testing)
+ */
+function verifyNaclSignature(payload, signatureBase64, publicKeyBase64, method = 'POST', url = '') {
+  try {
+    const payloadString = typeof payload === 'string' ? payload : JSON.stringify(payload);
+    const message = `${method}:${url}:${payloadString}`;
+    
+    const messageBytes = naclUtil.decodeUTF8(message);
+    const signatureBytes = naclUtil.decodeBase64(signatureBase64);
+    const publicKeyBytes = naclUtil.decodeBase64(publicKeyBase64);
+    
+    return nacl.sign.detached.verify(messageBytes, signatureBytes, publicKeyBytes);
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Generate secure random string
+ */
+function generateRandomString(length = 32) {
+  const bytes = nacl.randomBytes(length);
+  return naclUtil.encodeBase64(bytes).slice(0, length);
+}
+
+module.exports = {
+  generateKeyPair,
+  generateNaclSignature,
+  verifyNaclSignature,
+  generateRandomString,
+};