@gns-foundation/hive-worker 0.1.0

package/src/executor.ts

@@ -0,0 +1,270 @@
+// ============================================================
+// HIVE WORKER — EXECUTOR
+// Runs llama-cli for an assigned job.
+//
+// Two modes:
+//   pipeline  — rpc-server already running, orchestrator calls us
+//               (worker just tracks status, no local llama-cli)
+//   solo      — worker claims and runs the whole model locally
+//               (for small models: phi-3-mini, gemma-2-2b, etc.)
+//
+// Solo mode is the active path for hive-worker v0.1 / v0.2.
+// Pipeline mode is the full swarm path (Phase 3 whitepaper).
+// ============================================================
+
+import { spawn } from 'child_process';
+import { execSync } from 'child_process';
+import os from 'os';
+import path from 'path';
+import type { HiveJob, JobResult } from './jobs.js';
+
+// ─── Binary detection ─────────────────────────────────────────
+
+const LLAMA_CLI_CANDIDATES = [
+  'llama-cli',
+  'llama.cpp/llama-cli',
+  `${os.homedir()}/llama.cpp/llama-cli`,
+  `${os.homedir()}/llama.cpp/build/bin/llama-cli`,
+  `${os.homedir()}/llama.cpp/build/llama-cli`,
+  // Older name
+  'main',
+  `${os.homedir()}/llama.cpp/main`,
+];
+
+export function findLlamaCli(): string | null {
+  for (const candidate of LLAMA_CLI_CANDIDATES) {
+    try {
+      execSync(`test -f "${candidate}" || which "${candidate}" 2>/dev/null`, { timeout: 2000 });
+      return candidate;
+    } catch { /* not found */ }
+  }
+  return null;
+}
+
+// ─── Model cache ──────────────────────────────────────────────
+
+const MODEL_CACHE_DIR = path.join(os.homedir(), '.hive', 'models');
+
+import fs from 'fs';
+
+export function ensureModelCacheDir(): void {
+  fs.mkdirSync(MODEL_CACHE_DIR, { recursive: true });
+}
+
+export function modelCachePath(modelId: string): string {
+  // Normalize: "phi-3-mini" → "phi-3-mini.gguf"
+  const filename = modelId.endsWith('.gguf') ? modelId : `${modelId}.gguf`;
+  return path.join(MODEL_CACHE_DIR, filename);
+}
+
+export function isModelCached(modelId: string): boolean {
+  return fs.existsSync(modelCachePath(modelId));
+}
+
+// Known small models with public GGUF URLs (Q4_K_M quantizations)
+const KNOWN_MODELS: Record<string, string> = {
+  'phi-3-mini':
+    'https://huggingface.co/microsoft/Phi-3-mini-4k-instruct-gguf/resolve/main/Phi-3-mini-4k-instruct-q4.gguf',
+  'gemma-2-2b':
+    'https://huggingface.co/bartowski/gemma-2-2b-it-GGUF/resolve/main/gemma-2-2b-it-Q4_K_M.gguf',
+  'tinyllama':
+    'https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf',
+};
+
+export function resolveModelUrl(job: HiveJob): string | null {
+  if (job.model_url) return job.model_url;
+  return KNOWN_MODELS[job.model_id] ?? null;
+}
+
+// ─── Download model (streaming, with progress) ───────────────
+
+export async function downloadModel(
+  modelId: string,
+  url: string,
+  onProgress: (pct: number, mbDone: number, mbTotal: number) => void,
+): Promise<string> {
+  ensureModelCacheDir();
+  const dest = modelCachePath(modelId);
+  const tmpDest = dest + '.download';
+
+  const resp = await fetch(url, { signal: AbortSignal.timeout(300_000) });
+  if (!resp.ok) throw new Error(`Model download failed: ${resp.status}`);
+
+  const totalBytes = parseInt(resp.headers.get('content-length') ?? '0', 10);
+  const totalMb = totalBytes / 1024 / 1024;
+
+  const writer = fs.createWriteStream(tmpDest);
+  let downloaded = 0;
+
+  if (!resp.body) throw new Error('No response body');
+
+  const reader = resp.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    writer.write(value);
+    downloaded += value.length;
+    if (totalBytes > 0) {
+      onProgress(
+        Math.round((downloaded / totalBytes) * 100),
+        Math.round(downloaded / 1024 / 1024),
+        Math.round(totalMb),
+      );
+    }
+  }
+
+  await new Promise<void>((res, rej) => {
+    writer.end(() => res());
+    writer.on('error', rej);
+  });
+
+  fs.renameSync(tmpDest, dest);
+  return dest;
+}
+
+// ─── Execute inference ────────────────────────────────────────
+
+export interface ExecutorOptions {
+  onToken?: (token: string) => void;
+  onLog?:   (line: string) => void;
+}
+
+export async function executeJob(
+  job: HiveJob,
+  opts: ExecutorOptions = {},
+): Promise<JobResult> {
+  const llamaCli = findLlamaCli();
+  if (!llamaCli) {
+    throw new Error(
+      'llama-cli not found. Install llama.cpp: https://github.com/ggerganov/llama.cpp',
+    );
+  }
+
+  const modelPath = modelCachePath(job.model_id);
+  if (!fs.existsSync(modelPath)) {
+    throw new Error(
+      `Model "${job.model_id}" not cached at ${modelPath}. ` +
+      `Run: hive-worker models fetch ${job.model_id}`,
+    );
+  }
+
+  return runLlamaCli(llamaCli, modelPath, job, opts);
+}
+
+function runLlamaCli(
+  binary: string,
+  modelPath: string,
+  job: HiveJob,
+  opts: ExecutorOptions,
+): Promise<JobResult> {
+  return new Promise((resolve, reject) => {
+    const startMs = Date.now();
+
+    // Build args
+    const args = [
+      '--model',       modelPath,
+      '--prompt',      job.prompt,
+      '--n-predict',   String(job.max_tokens),
+      '--temp',        String(job.temperature),
+      '--ctx-size',    '4096',
+      '--threads',     String(Math.max(1, Math.floor(os.cpus().length / 2))),
+      '--no-display-prompt',   // suppress prompt echo
+      '--log-disable',
+      '--single-turn',
+      '-ngl', '0',
+      
+    ];
+
+    // Layer range hint (pipeline mode — rpc-server handles routing,
+    // but we pass the range so the model knows which layers to host)
+    if (job.layer_start !== 0 || job.layer_end !== 31) {
+      args.push('--n-gpu-layers', '0'); // CPU-only for partial layer ranges
+    }
+
+    // Apple Silicon: use Metal when running full model
+    const isApple = os.platform() === 'darwin' && os.arch() === 'arm64';
+    if (isApple && job.layer_start === 0) {
+      args.push('--n-gpu-layers', '99');  // offload all layers to Metal
+    }
+
+    opts.onLog?.(`Starting llama-cli for "${job.model_id}" [layers ${job.layer_start}–${job.layer_end}]`);
+    opts.onLog?.(`Command: ${binary} ${args.slice(0, 6).join(' ')} ...`);
+
+    const proc = spawn(binary, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let output = '';
+    let stderrBuf = '';
+
+    // llama-cli writes generated tokens to stdout
+    proc.stdout.on('data', (chunk: Buffer) => {
+      const text = chunk.toString();
+      output += text;
+      opts.onToken?.(text);
+    });
+
+    // Stats appear on stderr: "llama_print_timings: eval time = 12345 ms / 150 runs"
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderrBuf += chunk.toString();
+      opts.onLog?.(chunk.toString().trim());
+    });
+
+    proc.on('error', (err) => {
+      reject(new Error(`llama-cli spawn error: ${err.message}`));
+    });
+
+    proc.on('close', (code) => {
+      const wallMs = Date.now() - startMs;
+
+      if (code !== 0) {
+        reject(new Error(
+          `llama-cli exited with code ${code}. stderr: ${stderrBuf.slice(-500)}`,
+        ));
+        return;
+      }
+
+      // Parse tokens/sec from llama.cpp timing output
+      // Example: "llama_print_timings:        eval time = 4523.11 ms /   150 runs"
+      const tpsMatch = stderrBuf.match(/eval time\s*=\s*([\d.]+)\s*ms\s*\/\s*(\d+)\s*runs/);
+      let tokensPerSecond = 0;
+      let tokensGenerated = output.split(/\s+/).length; // rough estimate
+
+      if (tpsMatch) {
+        const evalMs  = parseFloat(tpsMatch[1]);
+        tokensGenerated = parseInt(tpsMatch[2], 10);
+        tokensPerSecond = Math.round((tokensGenerated / evalMs) * 1000 * 10) / 10;
+      } else if (wallMs > 0) {
+        // Fallback: tokens from output word count / wall time
+        tokensPerSecond = Math.round((tokensGenerated / wallMs) * 1000 * 10) / 10;
+      }
+
+      resolve({
+        resultText:      output.trim(),
+        tokensGenerated,
+        tokensPerSecond,
+      });
+    });
+
+    // Job-level timeout (safety net on top of Supabase timeout_at)
+    const deadline = new Date(job.timeout_at).getTime();
+    const remaining = deadline - Date.now() - 10_000; // 10s buffer
+    if (remaining > 0) {
+      setTimeout(() => {
+        proc.kill('SIGTERM');
+        reject(new Error('Job timed out (executor deadline)'));
+      }, remaining);
+    }
+  });
+}
+
+// ─── List cached models ───────────────────────────────────────
+
+export function listCachedModels(): Array<{ modelId: string; sizeMb: number }> {
+  ensureModelCacheDir();
+  const files = fs.readdirSync(MODEL_CACHE_DIR).filter(f => f.endsWith('.gguf'));
+  return files.map(f => ({
+    modelId: f.replace('.gguf', ''),
+    sizeMb:  Math.round(fs.statSync(path.join(MODEL_CACHE_DIR, f)).size / 1024 / 1024),
+  }));
+}

package/src/hardware.ts

@@ -0,0 +1,137 @@
+// ============================================================
+// HIVE WORKER — HARDWARE
+// Detect CPU, RAM, GPU, OS platform
+// Derive H3 cell from IP geolocation (desktop has no GPS)
+// ============================================================
+
+import os from 'os';
+import { execSync } from 'child_process';
+import { latLngToCell } from 'h3-js';
+
+export interface HardwareProfile {
+  cpuModel: string;
+  cpuCores: number;
+  ramGb: number;
+  platform: string;   // darwin | linux | win32
+  arch: string;       // arm64 | x64
+  gpuModel: string | null;
+  estimatedTflops: number;
+  hiveClass: 'phone' | 'laptop' | 'desktop' | 'server';
+}
+
+export interface GeoProfile {
+  h3Cell: string;     // Res-6 H3 cell
+  city: string;
+  country: string;
+  lat: number;
+  lng: number;
+}
+
+// ─── CPU / RAM ───────────────────────────────────────────────
+
+function detectGpu(): string | null {
+  try {
+    const plat = os.platform();
+    if (plat === 'darwin') {
+      const out = execSync('system_profiler SPDisplaysDataType 2>/dev/null | grep "Chipset Model"', {
+        encoding: 'utf-8', timeout: 3000,
+      });
+      const match = out.match(/Chipset Model:\s*(.+)/);
+      return match ? match[1].trim() : null;
+    }
+    if (plat === 'linux') {
+      try {
+        const out = execSync('nvidia-smi --query-gpu=name --format=csv,noheader 2>/dev/null', {
+          encoding: 'utf-8', timeout: 3000,
+        });
+        return out.trim().split('\n')[0] || null;
+      } catch { /* no nvidia */ }
+      try {
+        const out = execSync('rocm-smi --showproductname 2>/dev/null | grep "Card"', {
+          encoding: 'utf-8', timeout: 3000,
+        });
+        return out.trim() || null;
+      } catch { return null; }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function estimateTflops(cpuCores: number, gpu: string | null, arch: string): number {
+  // Very rough heuristic — enough for scheduling tier decisions
+  if (gpu) {
+    if (gpu.includes('A100')) return 312;
+    if (gpu.includes('H100')) return 756;
+    if (gpu.includes('4090')) return 82;
+    if (gpu.includes('3090')) return 35;
+    if (gpu.includes('RTX 5090')) return 170;
+    if (gpu.includes('M4 Pro') || gpu.includes('M4 Max')) return 14;
+    if (gpu.includes('M3 Pro') || gpu.includes('M3 Max')) return 10;
+    if (gpu.includes('M2 Pro') || gpu.includes('M2 Max')) return 6.5;
+    if (gpu.includes('M1 Pro') || gpu.includes('M1 Max')) return 5.2;
+    if (gpu.includes('M4')) return 4.6;
+    if (gpu.includes('M3')) return 3.6;
+    if (gpu.includes('M2')) return 2.6;
+    if (gpu.includes('M1')) return 2.0;
+  }
+  // CPU-only estimate: ~0.05 TFLOPS per core for modern CPUs
+  return Math.round(cpuCores * 0.05 * 10) / 10;
+}
+
+function classifyDevice(ramGb: number, cpuCores: number, gpu: string | null): HardwareProfile['hiveClass'] {
+  if (ramGb >= 64 && cpuCores >= 16) return 'server';
+  if (ramGb >= 16 || (gpu && !gpu.toLowerCase().includes('apple'))) return 'desktop';
+  if (ramGb >= 8) return 'laptop';
+  return 'phone';
+}
+
+export function detectHardware(): HardwareProfile {
+  const cpus = os.cpus();
+  const cpuModel = cpus[0]?.model?.trim() ?? 'Unknown CPU';
+  const cpuCores = cpus.length;
+  const ramGb = Math.round(os.totalmem() / (1024 ** 3));
+  const platform = os.platform();
+  const arch = os.arch();
+  const gpuModel = detectGpu();
+  const estimatedTflops = estimateTflops(cpuCores, gpuModel, arch);
+  const hiveClass = classifyDevice(ramGb, cpuCores, gpuModel);
+
+  return { cpuModel, cpuCores, ramGb, platform, arch, gpuModel, estimatedTflops, hiveClass };
+}
+
+// ─── GEO (IP-based, best effort) ─────────────────────────────
+
+export async function detectGeo(): Promise<GeoProfile> {
+  try {
+    const resp = await fetch('https://ipapi.co/json/', { signal: AbortSignal.timeout(5000) });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+    const data = await resp.json() as {
+      latitude?: number; longitude?: number;
+      city?: string; country_name?: string;
+    };
+    const lat = data.latitude ?? 0;
+    const lng = data.longitude ?? 0;
+    const h3Cell = latLngToCell(lat, lng, 6);  // Res-6: ~36 km²
+
+    return {
+      h3Cell,
+      city: data.city ?? 'Unknown',
+      country: data.country_name ?? 'Unknown',
+      lat,
+      lng,
+    };
+  } catch {
+    // Fallback: Rome (GNS genesis location)
+    const lat = 41.8919;
+    const lng = 12.5113;
+    return {
+      h3Cell: latLngToCell(lat, lng, 6),
+      city: 'Unknown (geo offline)',
+      country: 'Unknown',
+      lat,
+      lng,
+    };
+  }
+}

package/src/identity.ts

@@ -0,0 +1,82 @@
+// ============================================================
+// HIVE WORKER — IDENTITY
+// Ed25519 keypair generation + local persistence
+// ~/.hive/identity.json
+// ============================================================
+
+import nacl from 'tweetnacl';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+export interface HiveIdentity {
+  pk: string;         // 64-char hex (32 bytes Ed25519 public key)
+  sk: string;         // 128-char hex (64 bytes Ed25519 secret key) — never leaves disk
+  createdAt: string;
+}
+
+const HIVE_DIR = path.join(os.homedir(), '.hive');
+const IDENTITY_FILE = path.join(HIVE_DIR, 'identity.json');
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map(b => b.toString(16).padStart(2, '0'))
+    .join('');
+}
+
+function hexToBytes(hex: string): Uint8Array {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+
+export function ensureHiveDir(): void {
+  if (!fs.existsSync(HIVE_DIR)) {
+    fs.mkdirSync(HIVE_DIR, { recursive: true, mode: 0o700 });
+  }
+}
+
+export function generateIdentity(): HiveIdentity {
+  const keypair = nacl.sign.keyPair();
+  return {
+    pk: bytesToHex(keypair.publicKey),
+    sk: bytesToHex(keypair.secretKey),
+    createdAt: new Date().toISOString(),
+  };
+}
+
+export function loadOrCreateIdentity(): { identity: HiveIdentity; isNew: boolean } {
+  ensureHiveDir();
+
+  if (fs.existsSync(IDENTITY_FILE)) {
+    const raw = fs.readFileSync(IDENTITY_FILE, 'utf-8');
+    const identity = JSON.parse(raw) as HiveIdentity;
+    return { identity, isNew: false };
+  }
+
+  const identity = generateIdentity();
+  fs.writeFileSync(IDENTITY_FILE, JSON.stringify(identity, null, 2), { mode: 0o600 });
+  return { identity, isNew: true };
+}
+
+export function saveIdentity(identity: HiveIdentity): void {
+  ensureHiveDir();
+  fs.writeFileSync(IDENTITY_FILE, JSON.stringify(identity, null, 2), { mode: 0o600 });
+}
+
+export function sign(identity: HiveIdentity, message: string): string {
+  const sk = hexToBytes(identity.sk);
+  const msgBytes = new TextEncoder().encode(message);
+  const sig = nacl.sign.detached(msgBytes, sk);
+  return bytesToHex(sig);
+}
+
+export function shortPk(pk: string): string {
+  return pk.slice(0, 8);
+}
+
+export function identityPath(): string {
+  return IDENTITY_FILE;
+}