idle-node 0.1.0

package/bin/idle-node.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { startNode } from '../src/node.js';
+import chalk from 'chalk';
+
+const program = new Command();
+
+program
+  .name('idle-node')
+  .description('IDLE Protocol node — earn from idle compute')
+  .version('0.1.0');
+
+program
+  .command('start')
+  .description('Start the IDLE node and begin processing jobs')
+  .requiredOption('--wallet <address>', 'Solana wallet address for payouts')
+  .option('--types <types>', 'Comma-separated job types to accept (default: fetch,validate)', 'fetch,validate')
+  .option('--poll-interval <ms>', 'Job poll interval in milliseconds', '5000')
+  .option('--max-concurrent <n>', 'Max concurrent jobs', '3')
+  .option('--supabase-url <url>', 'Supabase project URL', process.env.IDLE_SUPABASE_URL || 'https://vnhzyynewdtfpiynaaqd.supabase.co')
+  .option('--supabase-key <key>', 'Supabase anon key', process.env.IDLE_SUPABASE_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZuaHp5eW5ld2R0ZnBpeW5hYXFkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzY5NzgyMDksImV4cCI6MjA5MjU1NDIwOX0.6Sw8p9wnfx67NjhzJGmPWialMG4517Eubj9YyfHPaJc')
+  .action(async (opts) => {
+    console.log(chalk.green('IDLE Node v0.1.0'));
+    console.log(chalk.gray(`Wallet: ${opts.wallet}`));
+    console.log(chalk.gray(`Types: ${opts.types}`));
+    console.log(chalk.gray(`Poll interval: ${opts.pollInterval}ms`));
+    console.log('');
+
+    try {
+      await startNode({
+        wallet: opts.wallet,
+        types: opts.types.split(','),
+        pollInterval: parseInt(opts.pollInterval),
+        maxConcurrent: parseInt(opts.maxConcurrent),
+        supabaseUrl: opts.supabaseUrl,
+        supabaseKey: opts.supabaseKey,
+      });
+    } catch (err) {
+      console.error(chalk.red('Fatal:'), err.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Check node status and earnings')
+  .requiredOption('--wallet <address>', 'Solana wallet address')
+  .option('--supabase-url <url>', 'Supabase project URL', process.env.IDLE_SUPABASE_URL || 'https://vnhzyynewdtfpiynaaqd.supabase.co')
+  .option('--supabase-key <key>', 'Supabase anon key', process.env.IDLE_SUPABASE_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InZuaHp5eW5ld2R0ZnBpeW5hYXFkIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzY5NzgyMDksImV4cCI6MjA5MjU1NDIwOX0.6Sw8p9wnfx67NjhzJGmPWialMG4517Eubj9YyfHPaJc')
+  .action(async (opts) => {
+    const { checkStatus } = await import('../src/status.js');
+    await checkStatus(opts);
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "idle-node",
+  "version": "0.1.0",
+  "description": "IDLE Protocol node — turn idle compute into revenue",
+  "main": "./src/node.js",
+  "bin": {
+    "idle-node": "bin/idle-node.js"
+  },
+  "files": [
+    "bin/",
+    "src/"
+  ],
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "idle",
+    "solana",
+    "compute",
+    "earnings",
+    "decentralized",
+    "pay.sh"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/georgehspirit-ctrl/vera-edge-pro"
+  },
+  "dependencies": {
+    "@supabase/supabase-js": "^2.45.0",
+    "commander": "^12.1.0",
+    "chalk": "^5.3.0"
+  }
+}

package/src/node.js

@@ -0,0 +1,148 @@
+import { createClient } from '@supabase/supabase-js';
+import chalk from 'chalk';
+
+const EXECUTORS = {
+  fetch: async (payload) => {
+    const { url, method = 'GET' } = payload;
+    const start = Date.now();
+    const res = await fetch(url, { method });
+    const body = await res.text();
+    return {
+      status: res.status,
+      headers: Object.fromEntries(res.headers.entries()),
+      body: body.slice(0, 10000),
+      latency_ms: Date.now() - start,
+    };
+  },
+
+  validate: async (payload) => {
+    const { data, schema } = payload;
+    // Basic JSON schema validation
+    const errors = [];
+    if (schema?.required) {
+      for (const field of schema.required) {
+        if (!(field in (data || {}))) errors.push(`missing required field: ${field}`);
+      }
+    }
+    return { valid: errors.length === 0, errors };
+  },
+
+  query: async (payload) => {
+    // Natural language query placeholder — real implementation
+    // would connect to user's configured data source
+    return { error: 'query execution requires data source configuration' };
+  },
+};
+
+export async function startNode(config) {
+  if (!config.supabaseUrl || !config.supabaseKey) {
+    throw new Error('Supabase URL and key required. Set IDLE_SUPABASE_URL and IDLE_SUPABASE_KEY env vars, or pass --supabase-url and --supabase-key.');
+  }
+
+  const supabase = createClient(config.supabaseUrl, config.supabaseKey);
+  let running = 0;
+  let totalProcessed = 0;
+  let totalEarned = 0;
+
+  console.log(chalk.green('Node started. Polling for jobs...'));
+
+  const poll = async () => {
+    if (running >= config.maxConcurrent) return;
+
+    try {
+      // Claim a pending job atomically
+      const { data: jobs, error } = await supabase
+        .rpc('idle_claim_node_job', {
+          p_node_wallet: config.wallet,
+          p_job_types: config.types,
+          p_limit: config.maxConcurrent - running,
+        });
+
+      if (error) {
+        console.error(chalk.red('Poll error:'), error.message);
+        return;
+      }
+
+      if (!jobs || jobs.length === 0) return;
+
+      for (const job of jobs) {
+        running++;
+        processJob(supabase, job, config.wallet).then((earned) => {
+          running--;
+          totalProcessed++;
+          totalEarned += earned;
+          if (totalProcessed % 10 === 0) {
+            console.log(chalk.cyan(`[stats] ${totalProcessed} jobs | $${totalEarned.toFixed(4)} earned`));
+          }
+        }).catch((err) => {
+          running--;
+          console.error(chalk.red(`Job ${job.id} failed:`), err.message);
+        });
+      }
+    } catch (err) {
+      console.error(chalk.red('Poll error:'), err.message);
+    }
+  };
+
+  // Poll loop
+  const interval = setInterval(poll, config.pollInterval);
+
+  // Graceful shutdown
+  const shutdown = () => {
+    console.log(chalk.yellow('\nShutting down...'));
+    clearInterval(interval);
+    console.log(chalk.green(`Processed ${totalProcessed} jobs, earned $${totalEarned.toFixed(4)}`));
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Initial poll
+  await poll();
+}
+
+async function processJob(supabase, job, wallet) {
+  const executor = EXECUTORS[job.type];
+  if (!executor) {
+    await supabase
+      .from('idle_jobs')
+      .update({ status: 'failed', result: { error: `unsupported type: ${job.type}` } })
+      .eq('id', job.id);
+    return 0;
+  }
+
+  const start = Date.now();
+  console.log(chalk.gray(`[${job.type}] Processing ${job.id.slice(0, 8)}...`));
+
+  try {
+    const result = await executor(job.payload);
+    const duration = Date.now() - start;
+
+    await supabase
+      .from('idle_jobs')
+      .update({
+        status: 'completed',
+        result,
+        completed_at: new Date().toISOString(),
+        node_wallet: wallet,
+        duration_ms: duration,
+      })
+      .eq('id', job.id);
+
+    const earned = job.node_payout_usd || 0;
+    console.log(chalk.green(`[${job.type}] ${job.id.slice(0, 8)} done (${duration}ms) +$${earned.toFixed(4)}`));
+    return earned;
+  } catch (err) {
+    await supabase
+      .from('idle_jobs')
+      .update({
+        status: 'failed',
+        result: { error: err.message },
+        completed_at: new Date().toISOString(),
+        node_wallet: wallet,
+      })
+      .eq('id', job.id);
+    throw err;
+  }
+}

package/src/status.js

@@ -0,0 +1,56 @@
+import { createClient } from '@supabase/supabase-js';
+import chalk from 'chalk';
+
+export async function checkStatus(opts) {
+  if (!opts.supabaseUrl || !opts.supabaseKey) {
+    console.error(chalk.red('Supabase URL and key required.'));
+    process.exit(1);
+  }
+
+  const supabase = createClient(opts.supabaseUrl, opts.supabaseKey);
+
+  // Get jobs for this wallet
+  const { data: jobs, error } = await supabase
+    .from('idle_jobs')
+    .select('status, node_payout_usd, type, completed_at')
+    .eq('node_wallet', opts.wallet)
+    .order('completed_at', { ascending: false })
+    .limit(100);
+
+  if (error) {
+    console.error(chalk.red('Error:'), error.message);
+    process.exit(1);
+  }
+
+  if (!jobs || jobs.length === 0) {
+    console.log(chalk.yellow('No jobs found for this wallet.'));
+    return;
+  }
+
+  const completed = jobs.filter(j => j.status === 'completed');
+  const paid = jobs.filter(j => j.status === 'paid');
+  const failed = jobs.filter(j => j.status === 'failed');
+
+  const totalEarned = [...completed, ...paid].reduce((sum, j) => sum + (j.node_payout_usd || 0), 0);
+  const totalPaid = paid.reduce((sum, j) => sum + (j.node_payout_usd || 0), 0);
+  const pending = totalEarned - totalPaid;
+
+  console.log(chalk.green('IDLE Node Status'));
+  console.log(chalk.gray('─'.repeat(40)));
+  console.log(`Wallet:     ${opts.wallet}`);
+  console.log(`Completed:  ${completed.length + paid.length} jobs`);
+  console.log(`Failed:     ${failed.length} jobs`);
+  console.log(`Earned:     $${totalEarned.toFixed(4)}`);
+  console.log(`Paid out:   $${totalPaid.toFixed(4)}`);
+  console.log(`Pending:    $${pending.toFixed(4)}`);
+
+  // Type breakdown
+  const byType = {};
+  for (const j of [...completed, ...paid]) {
+    byType[j.type] = (byType[j.type] || 0) + 1;
+  }
+  console.log(chalk.gray('\nBy type:'));
+  for (const [type, count] of Object.entries(byType)) {
+    console.log(`  ${type}: ${count}`);
+  }
+}