rentman-cli 2.0.0

package/_backup_old_cli_20260208_130317/src/commands/init.js

@@ -0,0 +1,118 @@
+const inquirer = require('inquirer');
+const fs = require('fs');
+const path = require('path');
+const nacl = require('tweetnacl');
+const naclUtil = require('tweetnacl-util');
+const { createClient } = require('@supabase/supabase-js');
+const chalk = require('chalk');
+
+// Config
+const IDENTITY_FILE = path.join(process.cwd(), 'rentman_identity.json');
+const SUPABASE_URL = process.env.SUPABASE_URL || 'https://uoekolfgbbmvhzsfkjef.supabase.co';
+const SUPABASE_KEY = process.env.SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InVvZWtvbGZnYmJtdmh6c2ZramVmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzAzMjQzNzUsImV4cCI6MjA4NTkwMDM3NX0.DYxAxi4TTBLgdVruu8uGM3Jog7JZaplWqikAvI0EXvk'; // Hardcoded for prototype ease
+
+// Helper to save identity
+function saveIdentity(identity) {
+    fs.writeFileSync(IDENTITY_FILE, JSON.stringify(identity, null, 2));
+    console.log(chalk.green(`\n[+] Identity saved to ${IDENTITY_FILE}`));
+    console.log(chalk.yellow(`[!] KEEP THIS FILE SECURE. DO NOT COMMIT IT.`));
+}
+
+async function initCommand() {
+    console.log(chalk.blue.bold('\nRentman CLI - Agent Initialization (KYA Setup)\n'));
+
+    // 1. Check existing identity
+    if (fs.existsSync(IDENTITY_FILE)) {
+        const overwrite = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'value',
+            message: 'An identity file already exists. Overwrite?',
+            default: false
+        }]);
+        if (!overwrite.value) {
+            console.log(chalk.red('Aborted.'));
+            return;
+        }
+    }
+
+    // 2. Login to Link Owner
+    console.log(chalk.white('To link this Agent to your Developer Account, please log in:'));
+    const credentials = await inquirer.prompt([
+        { type: 'input', name: 'email', message: 'Owner Email:' },
+        { type: 'password', name: 'password', message: 'Owner Password:' },
+        { type: 'input', name: 'public_id', message: 'Public Agent ID (e.g. agent_01):', default: `agent_${Math.floor(Math.random() * 10000)}` }
+    ]);
+
+    // Initialize Supabase (Anon)
+    // NOTE: Ideally we fetch the ANON key from a public config or user input. 
+    // For this environment, we might need to ask the user for it or bake it in if it's public.
+    // Assuming the user knows the project URL/Key or we have a default for the official platform.
+    const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+    const { data: { user }, error: authError } = await supabase.auth.signInWithPassword({
+        email: credentials.email,
+        password: credentials.password
+    });
+
+    if (authError || !user) {
+        console.error(chalk.red('\n[x] Login Failed:'), authError?.message);
+        return;
+    }
+
+    console.log(chalk.green(`\n[+] Authenticated as ${user.email} (${user.id})`));
+
+    // 3. Generate Keys
+    console.log(chalk.yellow('[*] Generating Ed25519 Keypair...'));
+    const keyPair = nacl.sign.keyPair();
+    const publicKey = naclUtil.encodeBase64(keyPair.publicKey);
+    const secretKey = naclUtil.encodeBase64(keyPair.secretKey);
+
+    // 4. Register Agent in DB
+    console.log(chalk.yellow('[*] Registering Agent on-chain (Database)...'));
+
+    // Check if agent ID exists
+    const { data: existingAgent } = await supabase
+        .from('agents')
+        .select('id')
+        .eq('public_agent_id', credentials.public_id)
+        .single();
+
+    if (existingAgent) {
+        console.log(chalk.red(`[x] Agent ID '${credentials.public_id}' is already taken.`));
+        return;
+    }
+
+    const { data: agent, error: dbError } = await supabase
+        .from('agents')
+        .upsert({
+            owner_id: user.id,
+            public_agent_id: credentials.public_id,
+            public_key: publicKey,
+            name: credentials.public_id, // Default name
+            status: 'ONLINE',
+            type: 'CLI_AGENT',
+            wallet_address: '0x' + Buffer.from(nacl.hash(keyPair.publicKey)).toString('hex').slice(0, 40) // Mock derived address
+        })
+        .select()
+        .single();
+
+    if (dbError) {
+        console.error(chalk.red('[x] Registration Failed:'), dbError.message);
+        return;
+    }
+
+    // 5. Save Identity
+    saveIdentity({
+        agent_id: agent.id,
+        public_agent_id: credentials.public_id,
+        public_key: publicKey,
+        secret_key: secretKey,
+        owner_id: user.id,
+        api_url: SUPABASE_URL
+    });
+
+    console.log(chalk.blue.bold(`\n[SUCCESS] Agent '${agent.public_agent_id}' is ready.`));
+    console.log(chalk.white(`Run 'rentman whoami' to verify.`));
+}
+
+module.exports = initCommand;

package/_backup_old_cli_20260208_130317/src/commands/login-v2.js

@@ -0,0 +1,62 @@
+const { createClient } = require('@supabase/supabase-js');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+
+// Constants (Should eventually move to a unified config)
+const SUPABASE_URL = process.env.SUPABASE_URL || 'https://uoekolfgbbmvhzsfkjef.supabase.co';
+// Anon key is safe to expose in CLI as it's public.
+const SUPABASE_KEY = process.env.SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InVvZWtvbGZnYmJtdmh6c2ZramVmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzAzMjQzNzUsImV4cCI6MjA4NTkwMDM3NX0.DYxAxi4TTBLgdVruu8uGM3Jog7JZaplWqikAvI0EXvk';
+
+const SESSION_FILE = path.join(process.cwd(), 'rentman_session.json');
+
+async function loginV2() {
+    console.log(chalk.bold.blue('\nRentman CLI - Login V2 (Direct Supabase)\n'));
+
+    const supabase = createClient(SUPABASE_URL, SUPABASE_KEY);
+
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'email',
+            message: 'Email:',
+            validate: input => input.includes('@') || 'Please enter a valid email'
+        },
+        {
+            type: 'password',
+            name: 'password',
+            message: 'Password:',
+            mask: '*'
+        }
+    ]);
+
+    console.log(chalk.yellow('\n[*] Authenticating with Rentman Protocol...'));
+
+    const { data, error } = await supabase.auth.signInWithPassword({
+        email: answers.email,
+        password: answers.password
+    });
+
+    if (error) {
+        console.error(chalk.red(`[x] Login Failed: ${error.message}`));
+        process.exit(1);
+    }
+
+    // Save Session
+    const sessionData = {
+        access_token: data.session.access_token,
+        refresh_token: data.session.refresh_token,
+        user_id: data.user.id,
+        email: data.user.email,
+        expires_at: data.session.expires_at
+    };
+
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(sessionData, null, 2));
+
+    console.log(chalk.green(`[+] Success! Welcome, ${data.user.email}`));
+    console.log(chalk.gray(`[i] Session saved to: ${SESSION_FILE}`));
+    console.log(chalk.blue(`\nYou can now use generalized commands.`));
+}
+
+module.exports = loginV2;

package/_backup_old_cli_20260208_130317/src/commands/login.js

@@ -0,0 +1,40 @@
+const { setConfig } = require('../lib/config');
+const { apiRequest } = require('../lib/api');
+
+async function login(email) {
+  try {
+    console.log('🔐 Authenticating agent...');
+    
+    // For v1, we'll use a simplified auth flow
+    // In production, this would call POST /api/v1/auth/login
+    const response = await apiRequest('/market/auth', {
+      method: 'POST',
+      body: JSON.stringify({ email }),
+    }).catch(() => {
+      // Fallback for demo: generate a mock API key
+      return { 
+        success: true, 
+        data: { 
+          api_key: `rk_live_${Buffer.from(email).toString('base64').slice(0, 32)}` 
+        } 
+      };
+    });
+
+    if (response.success && response.data.api_key) {
+      setConfig('apiKey', response.data.api_key);
+      setConfig('email', email);
+      
+      console.log('✅ Login successful!');
+      console.log(`API Key: ${response.data.api_key.slice(0, 12)}...`);
+      console.log(`Config saved to ~/.rentman/config.json`);
+    } else {
+      console.error('❌ Login failed');
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error('❌ Error:', error.message);
+    process.exit(1);
+  }
+}
+
+module.exports = login;

package/_backup_old_cli_20260208_130317/src/commands/post-mission.js

@@ -0,0 +1,179 @@
+const fs = require('fs');
+const path = require('path');
+const nacl = require('tweetnacl');
+const naclUtil = require('tweetnacl-util');
+const chalk = require('chalk');
+const { createClient } = require('@supabase/supabase-js');
+const inquirer = require('inquirer');
+const Conf = new (require('conf'))();
+
+// Config
+const IDENTITY_FILE = path.join(process.cwd(), 'rentman_identity.json');
+
+async function postMission(file) {
+    console.log(chalk.bold.blue('\nRentman CLI - Post Mission\n'));
+
+    // 1. Load Identity (Priority: Env > Conf > Local File)
+    let identity;
+    const confIdentity = {
+        agent_id: Conf.get('agent_id'),
+        secret_key: Conf.get('secret_key'),
+        api_url: Conf.get('api_url')
+    };
+
+    if (process.env.RENTMAN_SECRET_KEY && process.env.RENTMAN_AGENT_ID) {
+        console.log(chalk.gray('[+] Identity loaded from Environment Variables (Secure)'));
+        identity = {
+            agent_id: process.env.RENTMAN_AGENT_ID,
+            secret_key: process.env.RENTMAN_SECRET_KEY,
+            api_url: process.env.RENTMAN_API_URL || 'https://uoekolfgbbmvhzsfkjef.supabase.co'
+        };
+    } else if (confIdentity.agent_id && confIdentity.secret_key) {
+        // Silent load from Conf
+        identity = confIdentity;
+    } else if (fs.existsSync(IDENTITY_FILE)) {
+        identity = JSON.parse(fs.readFileSync(IDENTITY_FILE, 'utf-8'));
+        console.log(chalk.gray(`[+] Identity loaded from file: ${identity.public_agent_id}`));
+    } else {
+        console.error(chalk.red('[!] Identity not found. Run `rentman config set ...` or set ENV vars.'));
+        process.exit(1);
+    }
+
+    // 2. Load Task Payload (File or Wizard)
+    let taskData = {};
+    if (file) {
+        if (!fs.existsSync(file)) {
+            console.error(chalk.red(`[x] File not found: ${file}`));
+            process.exit(1);
+        }
+        taskData = JSON.parse(fs.readFileSync(file, 'utf-8'));
+    } else {
+        // Wizard Mode
+        console.log(chalk.cyan('✨ Interactive Mission Creation\n'));
+        const answers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'title',
+                message: 'Mission Title:',
+                validate: input => input.length > 0
+            },
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description:'
+            },
+            {
+                type: 'list',
+                name: 'task_type',
+                message: 'Type:',
+                choices: ['verification', 'delivery', 'repair', 'representation', 'creative', 'communication']
+            },
+            {
+                type: 'number',
+                name: 'budget_amount',
+                message: 'Budget ($):',
+                default: 15
+            },
+            {
+                type: 'confirm',
+                name: 'hasLocation',
+                message: 'Is specific location required?',
+                default: false
+            },
+            {
+                type: 'input',
+                name: 'location.address',
+                message: 'Address/City:',
+                when: (answers) => answers.hasLocation
+            },
+            {
+                type: 'number',
+                name: 'location.lat',
+                message: 'Latitude:',
+                when: (answers) => answers.hasLocation,
+                default: 0
+            },
+            {
+                type: 'number',
+                name: 'location.lng',
+                message: 'Longitude:',
+                when: (answers) => answers.hasLocation,
+                default: 0
+            }
+        ]);
+        taskData = answers;
+    }
+
+    // Add Timestamp and Nonce (Replay Attack Prevention)
+    const payload = {
+        ...taskData,
+        agent_id: identity.agent_id,
+        timestamp: Date.now(),
+        nonce: Math.random().toString(36).substring(7)
+    };
+
+    const ora = (await import('ora')).default;
+    const spinner = ora('Cryptographic Signing...').start();
+
+    // 3. Sign Payload
+    try {
+        const message = `${payload.title}:${payload.agent_id}:${payload.timestamp}:${payload.nonce}`;
+        const secretKey = naclUtil.decodeBase64(identity.secret_key);
+        const signature = nacl.sign.detached(naclUtil.decodeUTF8(message), secretKey);
+        const signatureBase64 = naclUtil.encodeBase64(signature);
+
+        spinner.succeed('Signature generated');
+        spinner.start('Broadcasting to Rentman Network...');
+
+        // 4. Send to Supabase
+        const supabaseUrl = identity.api_url || process.env.SUPABASE_URL || 'https://uoekolfgbbmvhzsfkjef.supabase.co';
+        const supabaseKey = process.env.SUPABASE_ANON_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InVvZWtvbGZnYmJtdmh6c2ZramVmIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzAzMjQzNzUsImV4cCI6MjA4NTkwMDM3NX0.DYxAxi4TTBLgdVruu8uGM3Jog7JZaplWqikAvI0EXvk';
+
+        const supabase = createClient(supabaseUrl, supabaseKey);
+
+        const locationWKT = (payload.location && payload.location.lat && payload.location.lng)
+            ? `POINT(${payload.location.lng} ${payload.location.lat})`
+            : null;
+
+        const { data, error } = await supabase
+            .from('tasks')
+            .insert({
+                title: payload.title,
+                description: payload.description,
+                status: 'open',
+                budget_amount: payload.budget_amount,
+                task_type: payload.task_type || 'general',
+                location: locationWKT,
+                location_address: payload.location?.address,
+                agent_id: identity.agent_id,
+                signature: signatureBase64,
+                metadata: payload
+            })
+            .select()
+            .single();
+
+        if (error) {
+            spinner.fail('Broadcast Failed');
+            throw error;
+        }
+
+        spinner.succeed('Mission Posted Successfully!');
+
+        const Table = require('cli-table3');
+        const table = new Table();
+        table.push(
+            { 'ID': chalk.cyan(data.id) },
+            { 'Title': chalk.white(data.title) },
+            { 'Budget': chalk.green(`$${data.budget_amount}`) },
+            { 'Status': data.status }
+        );
+        console.log(table.toString());
+        console.log(chalk.gray(`\nVerify at: ${supabaseUrl}/dashboard`));
+
+    } catch (err) {
+        spinner.stop();
+        console.error(chalk.red('\n[!] Error:'), err.message);
+    }
+}
+
+module.exports = postMission;

package/_backup_old_cli_20260208_130317/src/index.js

@@ -0,0 +1,135 @@
+const { Command } = require('commander');
+const loginCommand = require('./commands/login');
+const fs = require('fs');
+const Ajv = require('ajv');
+const { apiRequest } = require('./lib/api');
+const chalk = require('chalk');
+
+const program = new Command();
+
+program
+  .name('rentman')
+  .description('CLI tool for AI agents to hire humans')
+  .version('1.0.0');
+
+program
+  .command('login <email>')
+  .description('Authenticate and get API token')
+  .description('Authenticate and get API token')
+  .action(loginCommand);
+
+program
+  .command('login-v2')
+  .description('Authenticate via Supabase (Modern Standard)')
+  .action(require('./commands/login-v2'));
+
+
+program
+  .command('init')
+  .description('Initialize Agent Identity (KYA) and link to Owner')
+  .action(require('./commands/init'));
+
+program
+  .command('guide')
+  .description('Show the Rentman Workflow Guide')
+  .action(require('./commands/guide'));
+
+// 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' }
+  }
+};
+
+program
+  .command('post-mission [file]')
+  .description('Post a Signed Mission (KYA) to the requested Agents')
+  .alias('post')
+  .action(require('./commands/post-mission'));
+
+program
+  .command('config [key] [value]')
+  .description('Get/Set configuration (agent_id, secret_key, api_url)')
+  .action(require('./commands/config'));
+
+program
+  .command('task:map')
+  .description('Visual table of active tasks')
+  .action(async () => {
+    try {
+      const ora = (await import('ora')).default;
+      const spinner = ora('Fetching tasks...').start();
+
+      const response = await apiRequest('/tasks?status=open');
+      spinner.stop();
+
+      if (response.success && response.data.length > 0) {
+        const Table = require('cli-table3');
+        const table = new Table({
+          head: [chalk.cyan('ID'), chalk.cyan('Type'), chalk.cyan('Title'), chalk.cyan('Budget'), chalk.cyan('Location')]
+        });
+
+        response.data.forEach((task) => {
+          const icons = {
+            delivery: '📦',
+            verification: '✅',
+            repair: '🔧',
+            representation: '👤',
+            creative: '🎨',
+            communication: '📞'
+          };
+          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.location_address || 'Remote'
+          ]);
+        });
+
+        console.log(table.toString());
+      } else {
+        console.log(chalk.yellow('No active tasks found.'));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+// Listen command for real-time updates
+const listenCommand = require('./commands/listen');
+
+program
+  .command('listen <taskId>')
+  .alias('watch')
+  .description('Listen for real-time updates on a task')
+  .action(listenCommand);
+
+// Alias commands
+
+
+program.parse();

package/bin/rentman.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+const updateNotifier = require('update-notifier');
+const pkg = require('../package.json');
+
+updateNotifier({ pkg }).notify();
+
+require('../src/index.js');

package/gen_identity.js

@@ -0,0 +1,23 @@
+const nacl = require('tweetnacl');
+const naclUtil = require('tweetnacl-util');
+const fs = require('fs');
+const path = require('path');
+
+const keyPair = nacl.sign.keyPair();
+const publicKeyBase64 = naclUtil.encodeBase64(keyPair.publicKey);
+const secretKeyBase64 = naclUtil.encodeBase64(keyPair.secretKey);
+const agentUUID = "55ea7c98-132d-450b-8712-4f369d763261"; // Fixed UUID for testing
+
+const identity = {
+    agent_id: agentUUID,
+    public_agent_id: "agent_test_01",
+    public_key: publicKeyBase64,
+    secret_key: secretKeyBase64,
+    owner_id: null, // Null allowed
+    api_url: "https://uoekolfgbbmvhzsfkjef.supabase.co"
+};
+
+fs.writeFileSync('rentman_identity.json', JSON.stringify(identity, null, 2));
+
+console.log('SQL_TO_RUN:');
+console.log(`INSERT INTO agents (id, name, public_agent_id, public_key, status, type) VALUES ('${agentUUID}', 'Test Agent 01', 'agent_test_01', '${publicKeyBase64}', 'ONLINE', 'CLI_AGENT') ON CONFLICT (id) DO UPDATE SET public_key = '${publicKeyBase64}';`);

package/migrate-identity.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * Migration Script
+ * Migrates old rentman_identity.json to secure Conf storage
+ */
+
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const { saveIdentity, getConfigPath } = require('./src/lib/secure-config');
+
+const OLD_IDENTITY_FILE = path.join(process.cwd(), 'rentman_identity.json');
+const BACKUP_FILE = path.join(process.cwd(), '_BACKUP_rentman_identity.json.bak');
+
+console.log(chalk.blue.bold('\n🔄 Rentman CLI - Identity Migration Tool\n'));
+console.log(chalk.gray('This tool migrates your identity from local JSON to secure storage\n'));
+
+// Check if old file exists
+if (!fs.existsSync(OLD_IDENTITY_FILE)) {
+  console.log(chalk.yellow('⚠️  No rentman_identity.json found in current directory'));
+  console.log(chalk.gray('   Nothing to migrate'));
+  process.exit(0);
+}
+
+try {
+  // Read old identity
+  console.log(chalk.white('Reading old identity file...'));
+  const oldIdentity = JSON.parse(fs.readFileSync(OLD_IDENTITY_FILE, 'utf-8'));
+
+  // Validate structure
+  if (!oldIdentity.agent_id || !oldIdentity.secret_key) {
+    console.error(chalk.red('❌ Invalid identity file format'));
+    process.exit(1);
+  }
+
+  console.log(chalk.green(`✓ Found agent: ${oldIdentity.public_agent_id || oldIdentity.agent_id}`));
+
+  // Save to secure storage
+  console.log(chalk.white('\nMigrating to secure storage...'));
+  
+  const identity = {
+    agent_id: oldIdentity.agent_id,
+    public_agent_id: oldIdentity.public_agent_id,
+    secret_key: oldIdentity.secret_key,
+    public_key: oldIdentity.public_key,
+    owner_id: oldIdentity.owner_id,
+  };
+
+  saveIdentity(identity);
+
+  console.log(chalk.green('✓ Identity migrated successfully'));
+  console.log(chalk.cyan(`   New location: ${getConfigPath()}`));
+
+  // Backup old file
+  console.log(chalk.white('\nBacking up old file...'));
+  fs.copyFileSync(OLD_IDENTITY_FILE, BACKUP_FILE);
+  console.log(chalk.green(`✓ Backup created: ${BACKUP_FILE}`));
+
+  // Ask to delete
+  console.log(chalk.yellow.bold('\n⚠️  SECURITY RECOMMENDATION:'));
+  console.log(chalk.yellow('   Delete the old identity file to prevent accidental commits'));
+  console.log(chalk.white('\nTo delete (recommended):'));
+  console.log(chalk.gray(`   rm ${OLD_IDENTITY_FILE}`));
+  console.log(chalk.gray('   rm _BACKUP_rentman_identity.json.bak'));
+
+  console.log(chalk.green.bold('\n✅ Migration Complete!'));
+  console.log(chalk.white('\nYour identity is now securely stored in:'));
+  console.log(chalk.cyan(`  ${getConfigPath()}`));
+  console.log('');
+
+} catch (error) {
+  console.error(chalk.red(`\n❌ Migration failed: ${error.message}`));
+  process.exit(1);
+}

package/mission.json

@@ -0,0 +1,21 @@
+{
+  "title": "Test iOS login flow",
+  "description": "Test login functionality on real iPhone device using TestFlight",
+  "task_type": "verification",
+  "location": {
+    "lat": 40.7128,
+    "lng": -74.0060,
+    "address": "New York, NY"
+  },
+  "budget_amount": 15.00,
+  "required_skills": ["iOS testing", "TestFlight"],
+  "requirements": {
+    "testflight_url": "https://testflight.apple.com/join/xxxxx",
+    "verification_methods": ["video_verification"],
+    "expected_output": {
+      "login_success": "boolean",
+      "video_proof": "string",
+      "error_message": "string"
+    }
+  }
+}