technocore-compute 0.1.0

package/src/exchange.ts

@@ -0,0 +1,308 @@
+/**
+ * ComputeExchange - P2P compute marketplace for AI agents
+ *
+ * Manages provider registration, compute requests, job matching,
+ * and tclk payment coordination.
+ */
+
+import type {
+  ComputeProvider,
+  ComputeRequest,
+  ComputeJob,
+  ComputeType,
+  ExchangeStats,
+  JobStatus,
+} from './types.js';
+
+export interface ExchangeConfig {
+  /** technocore.chat base URL */
+  technocoreBaseUrl?: string;
+  /** Room prefix for compute exchange */
+  roomPrefix?: string;
+  /** How often to refresh providers (ms) */
+  refreshIntervalMs?: number;
+  /** Data directory for persistence */
+  dataDir?: string;
+}
+
+export class ComputeExchange {
+  private providers: Map<string, ComputeProvider> = new Map();
+  private requests: Map<string, ComputeRequest> = new Map();
+  private jobs: Map<string, ComputeJob> = new Map();
+  private config: Required<ExchangeConfig>;
+
+  constructor(config: ExchangeConfig = {}) {
+    this.config = {
+      technocoreBaseUrl: config.technocoreBaseUrl || 'https://technocore.chat',
+      roomPrefix: config.roomPrefix || 'compute',
+      refreshIntervalMs: config.refreshIntervalMs || 30_000,
+      dataDir: config.dataDir || './compute-data',
+    };
+  }
+
+  // ── Provider Management ──────────────────────────────────────────────────
+
+  /** Register a compute provider */
+  registerProvider(provider: ComputeProvider): void {
+    this.providers.set(provider.did, {
+      ...provider,
+      registeredAt: provider.registeredAt || Date.now(),
+      lastHeartbeat: provider.lastHeartbeat || Date.now(),
+      available: provider.available !== undefined ? provider.available : true,
+      rating: provider.rating || 0,
+      jobsCompleted: provider.jobsCompleted || 0,
+    });
+  }
+
+  /** Update provider heartbeat */
+  heartbeat(did: string): void {
+    const provider = this.providers.get(did);
+    if (provider) {
+      provider.lastHeartbeat = Date.now();
+      provider.available = true;
+    }
+  }
+
+  /** Set provider availability */
+  setAvailable(did: string, available: boolean): void {
+    const provider = this.providers.get(did);
+    if (provider) {
+      provider.available = available;
+    }
+  }
+
+  /** Remove stale providers (no heartbeat in 5 minutes) */
+  pruneStaleProviders(maxAgeMs = 300_000): number {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [did, provider] of this.providers) {
+      if (now - provider.lastHeartbeat > maxAgeMs) {
+        this.providers.delete(did);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+
+  /** Get a provider by DID */
+  getProvider(did: string): ComputeProvider | undefined {
+    return this.providers.get(did);
+  }
+
+  /** List all providers */
+  listProviders(): ComputeProvider[] {
+    return Array.from(this.providers.values());
+  }
+
+  /** Find providers matching requirements */
+  findProviders(requirements: {
+    hardware?: ComputeType;
+    minVramGB?: number;
+    minCpuCores?: number;
+    minRamGB?: number;
+    maxPricePerHour?: string;
+  }): ComputeProvider[] {
+    return this.listProviders().filter(p => {
+      if (!p.available) return false;
+      if (requirements.hardware && requirements.hardware !== 'any' && p.hardware !== requirements.hardware) return false;
+      if (requirements.minVramGB && (!p.vramGB || p.vramGB < requirements.minVramGB)) return false;
+      if (requirements.minCpuCores && (!p.cpuCores || p.cpuCores < requirements.minCpuCores)) return false;
+      if (requirements.minRamGB && (!p.ramGB || p.ramGB < requirements.minRamGB)) return false;
+      if (requirements.maxPricePerHour) {
+        const price = BigInt(p.pricePerHour);
+        const max = BigInt(requirements.maxPricePerHour);
+        if (price > max) return false;
+      }
+      return true;
+    });
+  }
+
+  // ── Request Management ───────────────────────────────────────────────────
+
+  /** Create a compute request */
+  createRequest(request: Omit<ComputeRequest, 'id' | 'createdAt' | 'expiresAt'>): ComputeRequest {
+    const id = `req-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const fullRequest: ComputeRequest = {
+      ...request,
+      id,
+      createdAt: Date.now(),
+      expiresAt: Date.now() + (request.durationSec * 1000 || 3_600_000),
+    };
+    this.requests.set(id, fullRequest);
+    return fullRequest;
+  }
+
+  /** Get a request by ID */
+  getRequest(id: string): ComputeRequest | undefined {
+    return this.requests.get(id);
+  }
+
+  /** List all pending requests */
+  listPendingRequests(): ComputeRequest[] {
+    const now = Date.now();
+    return Array.from(this.requests.values()).filter(r => r.expiresAt > now);
+  }
+
+  /** Remove expired requests */
+  pruneExpiredRequests(): number {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [id, request] of this.requests) {
+      if (request.expiresAt <= now) {
+        this.requests.delete(id);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+
+  // ── Job Matching ─────────────────────────────────────────────────────────
+
+  /** Match a request with the best available provider */
+  matchRequest(requestId: string): ComputeJob | null {
+    const request = this.requests.get(requestId);
+    if (!request) return null;
+
+    const providers = this.findProviders({
+      hardware: request.hardware,
+      minVramGB: request.minVramGB,
+      minCpuCores: request.minCpuCores,
+      minRamGB: request.minRamGB,
+      maxPricePerHour: request.maxPricePerHour,
+    });
+
+    if (providers.length === 0) return null;
+
+    // Sort by price (cheapest first), then by rating (highest first)
+    providers.sort((a, b) => {
+      const priceDiff = BigInt(a.pricePerHour) - BigInt(b.pricePerHour);
+      if (priceDiff !== 0n) return priceDiff < 0n ? -1 : 1;
+      return b.rating - a.rating;
+    });
+
+    const bestProvider = providers[0];
+    return this.createJob(request, bestProvider);
+  }
+
+  /** Create a job from a request and provider */
+  createJob(request: ComputeRequest, provider: ComputeProvider): ComputeJob {
+    const jobId = `job-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const hours = request.durationSec / 3600;
+    const cost = BigInt(provider.pricePerHour) * BigInt(Math.ceil(hours * 10)) / 10n;
+
+    const job: ComputeJob = {
+      id: jobId,
+      providerDid: provider.did,
+      consumerDid: request.consumerDid,
+      request,
+      provider,
+      status: 'matched',
+      totalCost: cost.toString(),
+      room: `${this.config.roomPrefix}-${jobId.slice(4, 12)}`,
+      createdAt: Date.now(),
+    };
+
+    this.jobs.set(jobId, job);
+    return job;
+  }
+
+  /** Accept a job (provider confirms) */
+  acceptJob(jobId: string): boolean {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== 'matched') return false;
+    job.status = 'locked';
+    return true;
+  }
+
+  /** Start a job */
+  startJob(jobId: string): boolean {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== 'locked') return false;
+    job.status = 'running';
+    job.startedAt = Date.now();
+    return true;
+  }
+
+  /** Complete a job */
+  completeJob(jobId: string): boolean {
+    const job = this.jobs.get(jobId);
+    if (!job || job.status !== 'running') return false;
+    job.status = 'completed';
+    job.completedAt = Date.now();
+
+    // Update provider stats
+    const provider = this.providers.get(job.providerDid);
+    if (provider) {
+      provider.jobsCompleted++;
+    }
+
+    return true;
+  }
+
+  /** Fail a job */
+  failJob(jobId: string, _reason?: string): boolean {
+    const job = this.jobs.get(jobId);
+    if (!job) return false;
+    job.status = 'failed';
+    return true;
+  }
+
+  /** Refund a job */
+  refundJob(jobId: string): boolean {
+    const job = this.jobs.get(jobId);
+    if (!job) return false;
+    job.status = 'refunded';
+    return true;
+  }
+
+  /** Get a job by ID */
+  getJob(id: string): ComputeJob | undefined {
+    return this.jobs.get(id);
+  }
+
+  /** List all jobs */
+  listJobs(status?: JobStatus): ComputeJob[] {
+    const jobs = Array.from(this.jobs.values());
+    return status ? jobs.filter(j => j.status === status) : jobs;
+  }
+
+  // ── Stats ────────────────────────────────────────────────────────────────
+
+  /** Get exchange statistics */
+  getStats(): ExchangeStats {
+    const allJobs = Array.from(this.jobs.values());
+    const allProviders = Array.from(this.providers.values());
+    return {
+      totalProviders: allProviders.length,
+      availableProviders: allProviders.filter(p => p.available).length,
+      totalJobs: allJobs.length,
+      activeJobs: allJobs.filter(j => ['matched', 'locked', 'running'].includes(j.status)).length,
+      completedJobs: allJobs.filter(j => j.status === 'completed').length,
+      totalVolume: allJobs
+        .filter(j => j.status === 'completed')
+        .reduce((sum, j) => sum + BigInt(j.totalCost), 0n)
+        .toString(),
+    };
+  }
+
+  // ── Serialization ────────────────────────────────────────────────────────
+
+  /** Export all data as JSON */
+  toJSON(): string {
+    return JSON.stringify({
+      providers: Array.from(this.providers.entries()),
+      requests: Array.from(this.requests.entries()),
+      jobs: Array.from(this.jobs.entries()),
+    });
+  }
+
+  /** Import data from JSON */
+  fromJSON(json: string): void {
+    try {
+      const data = JSON.parse(json);
+      if (data.providers) this.providers = new Map(data.providers);
+      if (data.requests) this.requests = new Map(data.requests);
+      if (data.jobs) this.jobs = new Map(data.jobs);
+    } catch {}
+  }
+}

package/src/index.ts

@@ -0,0 +1,63 @@
+/**
+ * technocore-compute — P2P compute exchange for AI agents
+ *
+ * Agents can offer compute resources (GPU/CPU) and other agents
+ * can rent them, with payments handled via tclk HTLC/PTLC.
+ *
+ * @example
+ * ```typescript
+ * import { ComputeExchange } from 'technocore-compute';
+ *
+ * const exchange = new ComputeExchange();
+ *
+ * // Register as a provider
+ * exchange.registerProvider({
+ *   did: 'did:key:z6Mk...',
+ *   name: 'GPU Farm',
+ *   hardware: 'gpu',
+ *   gpuModel: 'A100',
+ *   vramGB: 80,
+ *   pricePerHour: '5000000',
+ *   minDurationSec: 300,
+ *   maxDurationSec: 86400,
+ *   available: true,
+ *   rating: 4.8,
+ *   jobsCompleted: 42,
+ *   room: 'compute-gpu-farm',
+ *   registeredAt: Date.now(),
+ *   lastHeartbeat: Date.now(),
+ * });
+ *
+ * // Find providers
+ * const providers = exchange.findProviders({
+ *   hardware: 'gpu',
+ *   minVramGB: 24,
+ *   maxPricePerHour: '10000000',
+ * });
+ *
+ * // Create a request and match
+ * const request = exchange.createRequest({
+ *   consumerDid: 'did:key:z6Mk...',
+ *   hardware: 'gpu',
+ *   minVramGB: 24,
+ *   durationSec: 3600,
+ *   maxPricePerHour: '10000000',
+ *   description: 'Train a small model',
+ * });
+ *
+ * const job = exchange.matchRequest(request.id);
+ * ```
+ */
+
+export { ComputeExchange } from './exchange.js';
+export type { ExchangeConfig } from './exchange.js';
+export { ComputeServer } from './server.js';
+export type { ServerConfig } from './server.js';
+export type {
+  ComputeProvider,
+  ComputeRequest,
+  ComputeJob,
+  ComputeType,
+  JobStatus,
+  ExchangeStats,
+} from './types.js';

package/src/server.ts

@@ -0,0 +1,234 @@
+/**
+ * HTTP API server for the Compute Exchange
+ *
+ * Provides REST endpoints for providers to list compute,
+ * consumers to request compute, and job management.
+ */
+
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import { ComputeExchange, type ExchangeConfig } from './exchange.js';
+import type { ComputeProvider, ComputeRequest } from './types.js';
+
+export interface ServerConfig extends ExchangeConfig {
+  port?: number;
+  host?: string;
+}
+
+export class ComputeServer {
+  private exchange: ComputeExchange;
+  private server: ReturnType<typeof createServer> | null = null;
+  private config: Required<ServerConfig>;
+
+  constructor(config: ServerConfig = {}) {
+    this.config = {
+      port: config.port || 4010,
+      host: config.host || '0.0.0.0',
+      technocoreBaseUrl: config.technocoreBaseUrl || 'https://technocore.chat',
+      roomPrefix: config.roomPrefix || 'compute',
+      refreshIntervalMs: config.refreshIntervalMs || 30_000,
+      dataDir: config.dataDir || './compute-data',
+    };
+    this.exchange = new ComputeExchange(this.config);
+  }
+
+  /** Get the exchange instance */
+  getExchange(): ComputeExchange {
+    return this.exchange;
+  }
+
+  /** Start the server */
+  start(): Promise<void> {
+    return new Promise((resolve) => {
+      this.server = createServer((req, res) => this.handleRequest(req, res));
+      this.server.listen(this.config.port, this.config.host, () => {
+        console.log(`Compute Exchange API running on http://${this.config.host}:${this.config.port}`);
+        resolve();
+      });
+    });
+  }
+
+  /** Stop the server */
+  stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.server) {
+        this.server.close(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  private async handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
+    const url = new URL(req.url || '/', `http://${req.headers.host}`);
+    const path = url.pathname;
+    const method = req.method || 'GET';
+
+    // CORS headers
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (method === 'OPTIONS') {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+
+    try {
+      // Routes
+      if (path === '/stats' && method === 'GET') {
+        return this.json(res, this.exchange.getStats());
+      }
+
+      if (path === '/providers' && method === 'GET') {
+        return this.json(res, { providers: this.exchange.listProviders() });
+      }
+
+      if (path === '/providers' && method === 'POST') {
+        const body = await this.readBody(req);
+        const provider: ComputeProvider = {
+          did: body.did,
+          name: body.name || 'Unnamed Provider',
+          hardware: body.hardware || 'gpu',
+          gpuModel: body.gpuModel,
+          vramGB: body.vramGB,
+          cpuCores: body.cpuCores,
+          ramGB: body.ramGB,
+          storageGB: body.storageGB,
+          pricePerHour: body.pricePerHour || '1000000',
+          minDurationSec: body.minDurationSec || 300,
+          maxDurationSec: body.maxDurationSec || 86400,
+          available: true,
+          rating: 0,
+          jobsCompleted: 0,
+          room: body.room || 'compute-general',
+          registeredAt: Date.now(),
+          lastHeartbeat: Date.now(),
+        };
+        this.exchange.registerProvider(provider);
+        return this.json(res, { success: true, provider });
+      }
+
+      if (path.startsWith('/providers/') && method === 'PUT') {
+        const did = path.split('/')[2];
+        if (path.endsWith('/heartbeat')) {
+          this.exchange.heartbeat(did);
+          return this.json(res, { success: true });
+        }
+        if (path.endsWith('/available')) {
+          const body = await this.readBody(req);
+          this.exchange.setAvailable(did, body.available);
+          return this.json(res, { success: true });
+        }
+      }
+
+      if (path === '/requests' && method === 'GET') {
+        return this.json(res, { requests: this.exchange.listPendingRequests() });
+      }
+
+      if (path === '/requests' && method === 'POST') {
+        const body = await this.readBody(req);
+        const request = this.exchange.createRequest({
+          consumerDid: body.consumerDid,
+          hardware: body.hardware || 'gpu',
+          minGpuModel: body.minGpuModel,
+          minVramGB: body.minVramGB,
+          minCpuCores: body.minCpuCores,
+          minRamGB: body.minRamGB,
+          durationSec: body.durationSec || 3600,
+          maxPricePerHour: body.maxPricePerHour || '5000000',
+          description: body.description || '',
+        });
+        return this.json(res, { success: true, request });
+      }
+
+      if (path.startsWith('/requests/') && path.endsWith('/match') && method === 'POST') {
+        const requestId = path.split('/')[2];
+        const job = this.exchange.matchRequest(requestId);
+        if (!job) {
+          return this.json(res, { error: 'No matching provider found' }, 404);
+        }
+        return this.json(res, { success: true, job });
+      }
+
+      if (path === '/jobs' && method === 'GET') {
+        const status = url.searchParams.get('status') as any;
+        return this.json(res, { jobs: this.exchange.listJobs(status || undefined) });
+      }
+
+      if (path.startsWith('/jobs/') && method === 'GET') {
+        const jobId = path.split('/')[2];
+        const job = this.exchange.getJob(jobId);
+        if (!job) return this.json(res, { error: 'Job not found' }, 404);
+        return this.json(res, { job });
+      }
+
+      if (path.startsWith('/jobs/') && path.endsWith('/accept') && method === 'POST') {
+        const jobId = path.split('/')[2];
+        const ok = this.exchange.acceptJob(jobId);
+        return this.json(res, { success: ok });
+      }
+
+      if (path.startsWith('/jobs/') && path.endsWith('/start') && method === 'POST') {
+        const jobId = path.split('/')[2];
+        const ok = this.exchange.startJob(jobId);
+        return this.json(res, { success: ok });
+      }
+
+      if (path.startsWith('/jobs/') && path.endsWith('/complete') && method === 'POST') {
+        const jobId = path.split('/')[2];
+        const ok = this.exchange.completeJob(jobId);
+        return this.json(res, { success: ok });
+      }
+
+      if (path.startsWith('/jobs/') && path.endsWith('/fail') && method === 'POST') {
+        const jobId = path.split('/')[2];
+        const ok = this.exchange.failJob(jobId);
+        return this.json(res, { success: ok });
+      }
+
+      if (path.startsWith('/jobs/') && path.endsWith('/refund') && method === 'POST') {
+        const jobId = path.split('/')[2];
+        const ok = this.exchange.refundJob(jobId);
+        return this.json(res, { success: ok });
+      }
+
+      if (path === '/find' && method === 'POST') {
+        const body = await this.readBody(req);
+        const providers = this.exchange.findProviders({
+          hardware: body.hardware,
+          minVramGB: body.minVramGB,
+          minCpuCores: body.minCpuCores,
+          minRamGB: body.minRamGB,
+          maxPricePerHour: body.maxPricePerHour,
+        });
+        return this.json(res, { providers });
+      }
+
+      // 404
+      this.json(res, { error: 'Not found', path }, 404);
+    } catch (err: any) {
+      this.json(res, { error: err.message }, 500);
+    }
+  }
+
+  private json(res: ServerResponse, data: any, status = 200): void {
+    res.writeHead(status, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(data, null, 2));
+  }
+
+  private readBody(req: IncomingMessage): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let body = '';
+      req.on('data', chunk => body += chunk);
+      req.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          resolve({});
+        }
+      });
+      req.on('error', reject);
+    });
+  }
+}