technocore-compute 0.1.0

package/dist/index.js

@@ -0,0 +1,52 @@
+/**
+ * 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 { ComputeServer } from './server.js';

package/dist/server.d.ts

@@ -0,0 +1,26 @@
+/**
+ * HTTP API server for the Compute Exchange
+ *
+ * Provides REST endpoints for providers to list compute,
+ * consumers to request compute, and job management.
+ */
+import { ComputeExchange, type ExchangeConfig } from './exchange.js';
+export interface ServerConfig extends ExchangeConfig {
+    port?: number;
+    host?: string;
+}
+export declare class ComputeServer {
+    private exchange;
+    private server;
+    private config;
+    constructor(config?: ServerConfig);
+    /** Get the exchange instance */
+    getExchange(): ComputeExchange;
+    /** Start the server */
+    start(): Promise<void>;
+    /** Stop the server */
+    stop(): Promise<void>;
+    private handleRequest;
+    private json;
+    private readBody;
+}

package/dist/server.js

@@ -0,0 +1,205 @@
+/**
+ * HTTP API server for the Compute Exchange
+ *
+ * Provides REST endpoints for providers to list compute,
+ * consumers to request compute, and job management.
+ */
+import { createServer } from 'node:http';
+import { ComputeExchange } from './exchange.js';
+export class ComputeServer {
+    exchange;
+    server = null;
+    config;
+    constructor(config = {}) {
+        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() {
+        return this.exchange;
+    }
+    /** Start the server */
+    start() {
+        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() {
+        return new Promise((resolve) => {
+            if (this.server) {
+                this.server.close(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    async handleRequest(req, res) {
+        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 = {
+                    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');
+                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) {
+            this.json(res, { error: err.message }, 500);
+        }
+    }
+    json(res, data, status = 200) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data, null, 2));
+    }
+    readBody(req) {
+        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);
+        });
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Types for the Technocore Compute Exchange
+ *
+ * Agents can offer compute resources and other agents can rent them,
+ * with payments handled via tclk HTLC/PTLC.
+ */
+/** Compute hardware type */
+export type ComputeType = 'gpu' | 'cpu' | 'tpu' | 'npu' | 'any';
+/** Job status */
+export type JobStatus = 'listed' | 'requested' | 'matched' | 'locked' | 'running' | 'completed' | 'failed' | 'refunded';
+/** Provider advertising compute resources */
+export interface ComputeProvider {
+    /** Provider DID */
+    did: string;
+    /** Display name */
+    name: string;
+    /** Hardware available */
+    hardware: ComputeType;
+    /** GPU model if GPU (e.g. "A100", "H100", "RTX4090") */
+    gpuModel?: string;
+    /** VRAM in GB */
+    vramGB?: number;
+    /** CPU cores */
+    cpuCores?: number;
+    /** RAM in GB */
+    ramGB?: number;
+    /** Storage in GB */
+    storageGB?: number;
+    /** Price per hour in smallest FLOP unit */
+    pricePerHour: string;
+    /** Minimum job duration in seconds */
+    minDurationSec: number;
+    /** Maximum job duration in seconds */
+    maxDurationSec: number;
+    /** Available now */
+    available: boolean;
+    /** Average rating (0-5) */
+    rating: number;
+    /** Total jobs completed */
+    jobsCompleted: number;
+    /** technocore room for coordination */
+    room: string;
+    /** When this was registered */
+    registeredAt: number;
+    /** Last heartbeat */
+    lastHeartbeat: number;
+}
+/** Consumer requesting compute */
+export interface ComputeRequest {
+    /** Request ID */
+    id: string;
+    /** Consumer DID */
+    consumerDid: string;
+    /** Hardware needed */
+    hardware: ComputeType;
+    /** Minimum GPU model */
+    minGpuModel?: string;
+    /** Minimum VRAM needed */
+    minVramGB?: number;
+    /** Minimum CPU cores */
+    minCpuCores?: number;
+    /** Minimum RAM needed */
+    minRamGB?: number;
+    /** Duration needed in seconds */
+    durationSec: number;
+    /** Max price willing to pay */
+    maxPricePerHour: string;
+    /** Job description */
+    description: string;
+    /** When requested */
+    createdAt: number;
+    /** Expiry timestamp */
+    expiresAt: number;
+}
+/** Matched job between provider and consumer */
+export interface ComputeJob {
+    /** Job ID */
+    id: string;
+    /** Provider DID */
+    providerDid: string;
+    /** Consumer DID */
+    consumerDid: string;
+    /** Matched request */
+    request: ComputeRequest;
+    /** Provider used */
+    provider: ComputeProvider;
+    /** Current status */
+    status: JobStatus;
+    /** tclk contract ID for payment */
+    tclkContractId?: string;
+    /** Total cost */
+    totalCost: string;
+    /** Room where deal is coordinated */
+    room: string;
+    /** Created timestamp */
+    createdAt: number;
+    /** Started timestamp */
+    startedAt?: number;
+    /** Completed timestamp */
+    completedAt?: number;
+}
+/** Compute exchange stats */
+export interface ExchangeStats {
+    totalProviders: number;
+    availableProviders: number;
+    totalJobs: number;
+    activeJobs: number;
+    completedJobs: number;
+    totalVolume: string;
+}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types for the Technocore Compute Exchange
+ *
+ * Agents can offer compute resources and other agents can rent them,
+ * with payments handled via tclk HTLC/PTLC.
+ */
+export {};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "technocore-compute",
+  "version": "0.1.0",
+  "description": "P2P compute exchange for AI agents — rent GPU/CPU time via tclk payments",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "technocore-compute": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "node --import tsx --test test/*.test.ts",
+    "start": "node dist/cli.js serve",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@flop-labs/tclk": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.23.13",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "technocore",
+    "compute",
+    "gpu",
+    "cpu",
+    "marketplace",
+    "agent",
+    "tclk",
+    "p2p"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dannybyarun/technocore-compute"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+/**
+ * technocore-compute CLI
+ *
+ * Usage:
+ *   technocore-compute serve [--port 4010]
+ *   technocore-compute providers
+ *   technocore-compute find --hardware gpu --min-vram 16
+ *   technocore-compute stats
+ */
+
+import { ComputeServer } from './server.js';
+import { ComputeExchange } from './exchange.js';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case 'serve': {
+      const port = getArg(args, '--port') || '4010';
+      const server = new ComputeServer({ port: parseInt(port) });
+      await server.start();
+      console.log(`\nEndpoints:`);
+      console.log(`  GET  /stats              — Exchange statistics`);
+      console.log(`  GET  /providers           — List all providers`);
+      console.log(`  POST /providers           — Register a provider`);
+      console.log(`  GET  /requests            — List pending requests`);
+      console.log(`  POST /requests            — Create a compute request`);
+      console.log(`  POST /requests/:id/match  — Match a request with provider`);
+      console.log(`  GET  /jobs                — List all jobs`);
+      console.log(`  POST /jobs/:id/accept     — Accept a job`);
+      console.log(`  POST /jobs/:id/start      — Start a job`);
+      console.log(`  POST /jobs/:id/complete   — Complete a job`);
+      console.log(`  POST /find                — Find matching providers`);
+      break;
+    }
+
+    case 'providers': {
+      const exchange = new ComputeExchange();
+      const providers = exchange.listProviders();
+      if (providers.length === 0) {
+        console.log('No providers registered. Use POST /providers to register one.');
+      } else {
+        console.log(`\n${providers.length} provider(s):\n`);
+        for (const p of providers) {
+          const hw = p.hardware.toUpperCase();
+          const price = `${p.pricePerHour} FLOP/hr`;
+          const spec = p.gpuModel ? `${p.gpuModel} ${p.vramGB}GB` : `${p.cpuCores} cores ${p.ramGB}GB`;
+          console.log(`  ${p.name} (${hw})`);
+          console.log(`    ${spec} — ${price}`);
+          console.log(`    Jobs: ${p.jobsCompleted} | Rating: ${p.rating}/5 | ${p.available ? '✅ Available' : '❌ Busy'}`);
+          console.log();
+        }
+      }
+      break;
+    }
+
+    case 'find': {
+      const exchange = new ComputeExchange();
+      const hardware = getArg(args, '--hardware') as any || 'gpu';
+      const minVram = getArg(args, '--min-vram');
+      const maxPrice = getArg(args, '--max-price');
+      const providers = exchange.findProviders({
+        hardware,
+        minVramGB: minVram ? parseInt(minVram) : undefined,
+        maxPricePerHour: maxPrice,
+      });
+      if (providers.length === 0) {
+        console.log('No matching providers found.');
+      } else {
+        console.log(`\n${providers.length} matching provider(s) for ${hardware}:\n`);
+        for (const p of providers) {
+          console.log(`  ${p.name} — ${p.pricePerHour} FLOP/hr`);
+          if (p.gpuModel) console.log(`    ${p.gpuModel}, ${p.vramGB}GB VRAM`);
+          if (p.cpuCores) console.log(`    ${p.cpuCores} cores, ${p.ramGB}GB RAM`);
+        }
+      }
+      break;
+    }
+
+    case 'stats': {
+      const exchange = new ComputeExchange();
+      const stats = exchange.getStats();
+      console.log('\n📊 Exchange Stats:\n');
+      console.log(`  Providers:  ${stats.availableProviders}/${stats.totalProviders} available`);
+      console.log(`  Jobs:       ${stats.activeJobs} active, ${stats.completedJobs} completed`);
+      console.log(`  Volume:     ${stats.totalVolume} FLOP\n`);
+      break;
+    }
+
+    default:
+      console.log(`
+technocore-compute — P2P compute exchange for AI agents
+
+Commands:
+  serve [--port 4010]     Start the API server
+  providers               List registered providers
+  find [options]          Find matching providers
+  stats                   Show exchange statistics
+
+Find options:
+  --hardware gpu|cpu      Hardware type (default: gpu)
+  --min-vram 16           Minimum VRAM in GB
+  --max-price 5000000     Maximum price per hour
+
+Example:
+  technocore-compute serve --port 4010
+  technocore-compute find --hardware gpu --min-vram 24
+`);
+  }
+}
+
+function getArg(args: string[], flag: string): string | undefined {
+  const idx = args.indexOf(flag);
+  return idx >= 0 ? args[idx + 1] : undefined;
+}
+
+main().catch(console.error);