@antseed/node 0.1.0 → 0.1.1

package/src/proxy/proxy-mux.ts

@@ -1,173 +0,0 @@
-import { MessageType, type FramedMessage } from "../types/protocol.js";
-import type { PeerConnection } from "../p2p/connection-manager.js";
-import { encodeFrame } from "../p2p/message-protocol.js";
-import {
-  encodeHttpRequest,
-  decodeHttpRequest,
-  encodeHttpResponse,
-  decodeHttpResponse,
-  encodeHttpResponseChunk,
-  decodeHttpResponseChunk,
-} from "./request-codec.js";
-import type {
-  SerializedHttpRequest,
-  SerializedHttpResponse,
-  SerializedHttpResponseChunk,
-} from "../types/http.js";
-
-type ResponseHandler = (response: SerializedHttpResponse) => void;
-type ChunkHandler = (chunk: SerializedHttpResponseChunk) => void;
-type RequestHandler = (request: SerializedHttpRequest) => void | Promise<void>;
-
-/**
- * Request/response multiplexer over DataChannel.
- * Handles both buyer-side and seller-side proxy communication.
- */
-export class ProxyMux {
-  private readonly _connection: PeerConnection;
-  private _messageIdCounter = 0;
-
-  // Buyer side: pending requests awaiting responses
-  private readonly _responseHandlers = new Map<string, ResponseHandler>();
-  private readonly _chunkHandlers = new Map<string, ChunkHandler>();
-
-  // Seller side: handler for incoming proxy requests
-  private _requestHandler: RequestHandler | null = null;
-
-  constructor(connection: PeerConnection) {
-    this._connection = connection;
-  }
-
-  /** Buyer side: send a proxy request and register response/chunk handlers. */
-  sendProxyRequest(
-    request: SerializedHttpRequest,
-    onResponse: ResponseHandler,
-    onChunk: ChunkHandler
-  ): void {
-    this._responseHandlers.set(request.requestId, onResponse);
-    this._chunkHandlers.set(request.requestId, onChunk);
-
-    const payload = encodeHttpRequest(request);
-    const frame = encodeFrame({
-      type: MessageType.HttpRequest,
-      messageId: this._nextMessageId(),
-      payload,
-    });
-
-    this._connection.send(frame);
-  }
-
-  /** Buyer side: cancel handlers for an in-flight request. */
-  cancelProxyRequest(requestId: string): void {
-    this._responseHandlers.delete(requestId);
-    this._chunkHandlers.delete(requestId);
-  }
-
-  /** Seller side: register a handler for incoming proxy requests. */
-  onProxyRequest(handler: RequestHandler): void {
-    this._requestHandler = handler;
-  }
-
-  /** Seller side: send a complete proxy response. */
-  sendProxyResponse(response: SerializedHttpResponse): void {
-    const payload = encodeHttpResponse(response);
-    const frame = encodeFrame({
-      type: MessageType.HttpResponse,
-      messageId: this._nextMessageId(),
-      payload,
-    });
-
-    this._connection.send(frame);
-  }
-
-  /** Seller side: send a proxy response chunk. */
-  sendProxyChunk(chunk: SerializedHttpResponseChunk): void {
-    const type = chunk.done
-      ? MessageType.HttpResponseEnd
-      : MessageType.HttpResponseChunk;
-
-    const payload = encodeHttpResponseChunk(chunk);
-    const frame = encodeFrame({
-      type,
-      messageId: this._nextMessageId(),
-      payload,
-    });
-
-    this._connection.send(frame);
-  }
-
-  /** Route an incoming frame to the correct handler based on message type. */
-  async handleFrame(frame: FramedMessage): Promise<void> {
-    try {
-      switch (frame.type) {
-        case MessageType.HttpRequest: {
-          // Seller side: incoming request from buyer
-          if (this._requestHandler) {
-            const request = decodeHttpRequest(frame.payload);
-            await this._requestHandler(request);
-          }
-          break;
-        }
-        case MessageType.HttpResponse: {
-          // Buyer side: complete response from seller
-          const response = decodeHttpResponse(frame.payload);
-          const handler = this._responseHandlers.get(response.requestId);
-          if (handler) {
-            this._responseHandlers.delete(response.requestId);
-            this._chunkHandlers.delete(response.requestId);
-            handler(response);
-          }
-          break;
-        }
-        case MessageType.HttpResponseChunk: {
-          // Buyer side: streaming chunk from seller
-          const chunk = decodeHttpResponseChunk(frame.payload);
-          const chunkHandler = this._chunkHandlers.get(chunk.requestId);
-          if (chunkHandler) {
-            chunkHandler(chunk);
-          }
-          break;
-        }
-        case MessageType.HttpResponseEnd: {
-          // Buyer side: final chunk (done=true) from seller
-          const endChunk = decodeHttpResponseChunk(frame.payload);
-          const endHandler = this._chunkHandlers.get(endChunk.requestId);
-          if (endHandler) {
-            endHandler(endChunk);
-            this._responseHandlers.delete(endChunk.requestId);
-            this._chunkHandlers.delete(endChunk.requestId);
-          }
-          break;
-        }
-        case MessageType.HttpResponseError: {
-          // Buyer side: error response from seller
-          const errorResponse = decodeHttpResponse(frame.payload);
-          const errorHandler = this._responseHandlers.get(errorResponse.requestId);
-          if (errorHandler) {
-            this._responseHandlers.delete(errorResponse.requestId);
-            this._chunkHandlers.delete(errorResponse.requestId);
-            errorHandler(errorResponse);
-          }
-          break;
-        }
-        default:
-          // Unknown message type — ignore
-          break;
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Failed to handle proxy frame type ${frame.type}: ${message}`);
-    }
-  }
-
-  /** Number of in-flight requests (buyer side). */
-  activeRequestCount(): number {
-    return this._responseHandlers.size;
-  }
-
-  private _nextMessageId(): number {
-    const id = this._messageIdCounter;
-    this._messageIdCounter = (this._messageIdCounter + 1) & 0xFFFFFFFF;
-    return id;
-  }
-}

package/src/proxy/request-codec.ts

@@ -1,294 +0,0 @@
-import type {
-  SerializedHttpRequest,
-  SerializedHttpResponse,
-  SerializedHttpResponseChunk,
-} from "../types/http.js";
-
-const encoder = new TextEncoder();
-const decoder = new TextDecoder();
-
-/**
- * Encode an HTTP request into binary format:
- * [requestIdLen:2][requestId:N][methodLen:1][method:N][pathLen:2][path:N]
- * [headerCount:2][for each header: keyLen:2, key:N, valLen:2, val:N]
- * [bodyLen:4][body:N]
- */
-export function encodeHttpRequest(req: SerializedHttpRequest): Uint8Array {
-  const requestIdBytes = encoder.encode(req.requestId);
-  const methodBytes = encoder.encode(req.method);
-  const pathBytes = encoder.encode(req.path);
-
-  const headerEntries = Object.entries(req.headers);
-  const encodedHeaders: Array<{ key: Uint8Array; val: Uint8Array }> = [];
-  let headersSize = 0;
-  for (const [key, val] of headerEntries) {
-    const keyBytes = encoder.encode(key);
-    const valBytes = encoder.encode(val);
-    encodedHeaders.push({ key: keyBytes, val: valBytes });
-    headersSize += 2 + keyBytes.length + 2 + valBytes.length;
-  }
-
-  const totalSize =
-    2 + requestIdBytes.length +
-    1 + methodBytes.length +
-    2 + pathBytes.length +
-    2 + headersSize +
-    4 + req.body.length;
-
-  const buf = new Uint8Array(totalSize);
-  const view = new DataView(buf.buffer);
-  let offset = 0;
-
-  // requestId
-  view.setUint16(offset, requestIdBytes.length);
-  offset += 2;
-  buf.set(requestIdBytes, offset);
-  offset += requestIdBytes.length;
-
-  // method
-  view.setUint8(offset, methodBytes.length);
-  offset += 1;
-  buf.set(methodBytes, offset);
-  offset += methodBytes.length;
-
-  // path
-  view.setUint16(offset, pathBytes.length);
-  offset += 2;
-  buf.set(pathBytes, offset);
-  offset += pathBytes.length;
-
-  // headers
-  view.setUint16(offset, headerEntries.length);
-  offset += 2;
-  for (const { key, val } of encodedHeaders) {
-    view.setUint16(offset, key.length);
-    offset += 2;
-    buf.set(key, offset);
-    offset += key.length;
-    view.setUint16(offset, val.length);
-    offset += 2;
-    buf.set(val, offset);
-    offset += val.length;
-  }
-
-  // body
-  view.setUint32(offset, req.body.length);
-  offset += 4;
-  buf.set(req.body, offset);
-
-  return buf;
-}
-
-/**
- * Decode binary data into a SerializedHttpRequest.
- */
-export function decodeHttpRequest(data: Uint8Array): SerializedHttpRequest {
-  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  let offset = 0;
-
-  // requestId
-  const requestIdLen = view.getUint16(offset);
-  offset += 2;
-  const requestId = decoder.decode(data.slice(offset, offset + requestIdLen));
-  offset += requestIdLen;
-
-  // method
-  const methodLen = view.getUint8(offset);
-  offset += 1;
-  const method = decoder.decode(data.slice(offset, offset + methodLen));
-  offset += methodLen;
-
-  // path
-  const pathLen = view.getUint16(offset);
-  offset += 2;
-  const path = decoder.decode(data.slice(offset, offset + pathLen));
-  offset += pathLen;
-
-  // headers
-  const headerCount = view.getUint16(offset);
-  offset += 2;
-  const headers: Record<string, string> = {};
-  for (let i = 0; i < headerCount; i++) {
-    const keyLen = view.getUint16(offset);
-    offset += 2;
-    const key = decoder.decode(data.slice(offset, offset + keyLen));
-    offset += keyLen;
-    const valLen = view.getUint16(offset);
-    offset += 2;
-    const val = decoder.decode(data.slice(offset, offset + valLen));
-    offset += valLen;
-    headers[key] = val;
-  }
-
-  // body
-  const bodyLen = view.getUint32(offset);
-  offset += 4;
-  const body = data.slice(offset, offset + bodyLen);
-
-  return { requestId, method, path, headers, body };
-}
-
-/**
- * Encode an HTTP response into binary format:
- * [requestIdLen:2][requestId:N][statusCode:2]
- * [headerCount:2][for each header: keyLen:2, key:N, valLen:2, val:N]
- * [bodyLen:4][body:N]
- */
-export function encodeHttpResponse(resp: SerializedHttpResponse): Uint8Array {
-  const requestIdBytes = encoder.encode(resp.requestId);
-
-  const headerEntries = Object.entries(resp.headers);
-  const encodedHeaders: Array<{ key: Uint8Array; val: Uint8Array }> = [];
-  let headersSize = 0;
-  for (const [key, val] of headerEntries) {
-    const keyBytes = encoder.encode(key);
-    const valBytes = encoder.encode(val);
-    encodedHeaders.push({ key: keyBytes, val: valBytes });
-    headersSize += 2 + keyBytes.length + 2 + valBytes.length;
-  }
-
-  const totalSize =
-    2 + requestIdBytes.length +
-    2 +
-    2 + headersSize +
-    4 + resp.body.length;
-
-  const buf = new Uint8Array(totalSize);
-  const view = new DataView(buf.buffer);
-  let offset = 0;
-
-  // requestId
-  view.setUint16(offset, requestIdBytes.length);
-  offset += 2;
-  buf.set(requestIdBytes, offset);
-  offset += requestIdBytes.length;
-
-  // statusCode
-  view.setUint16(offset, resp.statusCode);
-  offset += 2;
-
-  // headers
-  view.setUint16(offset, headerEntries.length);
-  offset += 2;
-  for (const { key, val } of encodedHeaders) {
-    view.setUint16(offset, key.length);
-    offset += 2;
-    buf.set(key, offset);
-    offset += key.length;
-    view.setUint16(offset, val.length);
-    offset += 2;
-    buf.set(val, offset);
-    offset += val.length;
-  }
-
-  // body
-  view.setUint32(offset, resp.body.length);
-  offset += 4;
-  buf.set(resp.body, offset);
-
-  return buf;
-}
-
-/**
- * Decode binary data into a SerializedHttpResponse.
- */
-export function decodeHttpResponse(data: Uint8Array): SerializedHttpResponse {
-  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  let offset = 0;
-
-  // requestId
-  const requestIdLen = view.getUint16(offset);
-  offset += 2;
-  const requestId = decoder.decode(data.slice(offset, offset + requestIdLen));
-  offset += requestIdLen;
-
-  // statusCode
-  const statusCode = view.getUint16(offset);
-  offset += 2;
-
-  // headers
-  const headerCount = view.getUint16(offset);
-  offset += 2;
-  const headers: Record<string, string> = {};
-  for (let i = 0; i < headerCount; i++) {
-    const keyLen = view.getUint16(offset);
-    offset += 2;
-    const key = decoder.decode(data.slice(offset, offset + keyLen));
-    offset += keyLen;
-    const valLen = view.getUint16(offset);
-    offset += 2;
-    const val = decoder.decode(data.slice(offset, offset + valLen));
-    offset += valLen;
-    headers[key] = val;
-  }
-
-  // body
-  const bodyLen = view.getUint32(offset);
-  offset += 4;
-  const body = data.slice(offset, offset + bodyLen);
-
-  return { requestId, statusCode, headers, body };
-}
-
-/**
- * Encode an HTTP response chunk into binary format:
- * [requestIdLen:2][requestId:N][done:1][dataLen:4][data:N]
- */
-export function encodeHttpResponseChunk(
-  chunk: SerializedHttpResponseChunk
-): Uint8Array {
-  const requestIdBytes = encoder.encode(chunk.requestId);
-
-  const totalSize =
-    2 + requestIdBytes.length +
-    1 +
-    4 + chunk.data.length;
-
-  const buf = new Uint8Array(totalSize);
-  const view = new DataView(buf.buffer);
-  let offset = 0;
-
-  // requestId
-  view.setUint16(offset, requestIdBytes.length);
-  offset += 2;
-  buf.set(requestIdBytes, offset);
-  offset += requestIdBytes.length;
-
-  // done
-  view.setUint8(offset, chunk.done ? 1 : 0);
-  offset += 1;
-
-  // data
-  view.setUint32(offset, chunk.data.length);
-  offset += 4;
-  buf.set(chunk.data, offset);
-
-  return buf;
-}
-
-/**
- * Decode binary data into a SerializedHttpResponseChunk.
- */
-export function decodeHttpResponseChunk(
-  data: Uint8Array
-): SerializedHttpResponseChunk {
-  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
-  let offset = 0;
-
-  // requestId
-  const requestIdLen = view.getUint16(offset);
-  offset += 2;
-  const requestId = decoder.decode(data.slice(offset, offset + requestIdLen));
-  offset += requestIdLen;
-
-  // done
-  const done = view.getUint8(offset) === 1;
-  offset += 1;
-
-  // data
-  const dataLen = view.getUint32(offset);
-  offset += 4;
-  const chunkData = data.slice(offset, offset + dataLen);
-
-  return { requestId, data: chunkData, done };
-}

package/src/reputation/index.ts

@@ -1,6 +0,0 @@
-export { computeTrustScore, DEFAULT_TRUST_WEIGHTS, DEFAULT_COMPONENTS } from './trust-score.js';
-export type { TrustScore, TrustComponents } from './trust-score.js';
-export { TrustScoreEngine, type TrustEngineConfig } from './trust-engine.js';
-export { UptimeTracker, type UptimeTrackerConfig, type UptimeWindow, type PeerUptimeRecord } from './uptime-tracker.js';
-export { ReportManager, type ReportManagerConfig } from './report-manager.js';
-export { RatingManager, type RatingManagerConfig } from './rating-manager.js';

package/src/reputation/rating-manager.ts

@@ -1,118 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { PeerId } from '../types/peer.js';
-import type { PeerRating, RatingDimension, AggregateRating } from '../types/rating.js';
-import type { Identity } from '../p2p/identity.js';
-import { signData } from '../p2p/identity.js';
-import { bytesToHex } from '../utils/hex.js';
-
-const HALF_LIFE_MS = 90 * 24 * 60 * 60 * 1000; // 90 days
-const DIMENSIONS: RatingDimension[] = ['quality', 'speed', 'reliability', 'value', 'overall'];
-
-export interface RatingManagerConfig {
-  configDir: string;
-  identity?: Identity;
-}
-
-export class RatingManager {
-  private readonly configDir: string;
-  private readonly identity: Identity | undefined;
-  private ratings: PeerRating[] = [];
-
-  constructor(config: RatingManagerConfig) {
-    this.configDir = config.configDir;
-    this.identity = config.identity;
-  }
-
-  async submitRating(
-    targetPeerId: PeerId,
-    sessionId: string,
-    dimensions: Record<RatingDimension, 1 | 2 | 3 | 4 | 5>,
-    comment?: string,
-  ): Promise<PeerRating> {
-    if (!this.identity) throw new Error('Identity required to submit ratings');
-
-    const rating: PeerRating = {
-      ratingId: randomUUID(),
-      raterPeerId: this.identity.peerId as PeerId,
-      targetPeerId,
-      sessionId,
-      dimensions,
-      comment,
-      timestamp: Date.now(),
-      signature: '',
-    };
-
-    const dataToSign = `${rating.ratingId}:${rating.raterPeerId}:${rating.targetPeerId}:${rating.sessionId}:${rating.timestamp}`;
-    const sig = await signData(this.identity.privateKey, new TextEncoder().encode(dataToSign));
-    rating.signature = bytesToHex(sig);
-
-    this.ratings.push(rating);
-    await this.save();
-    return rating;
-  }
-
-  getAggregateRating(peerId: PeerId): AggregateRating {
-    const peerRatings = this.ratings.filter(r => r.targetPeerId === peerId);
-    const now = Date.now();
-
-    const weightedSums: Record<string, number> = Object.fromEntries(DIMENSIONS.map(d => [d, 0]));
-    let totalWeight = 0;
-
-    for (const rating of peerRatings) {
-      // Exponential decay weight
-      const age = now - rating.timestamp;
-      const weight = Math.pow(0.5, age / HALF_LIFE_MS);
-      totalWeight += weight;
-
-      for (const dim of DIMENSIONS) {
-        weightedSums[dim]! += rating.dimensions[dim] * weight;
-      }
-    }
-
-    const averageByDimension = {} as Record<RatingDimension, number>;
-    for (const dim of DIMENSIONS) {
-      averageByDimension[dim] = totalWeight > 0
-        ? Math.round((weightedSums[dim]! / totalWeight) * 100) / 100
-        : 0;
-    }
-
-    const overallAverage = totalWeight > 0
-      ? Math.round((DIMENSIONS.reduce((sum, dim) => sum + averageByDimension[dim], 0) / DIMENSIONS.length) * 100) / 100
-      : 0;
-
-    return {
-      peerId,
-      averageByDimension,
-      overallAverage,
-      totalRatings: peerRatings.length,
-      lastUpdated: now,
-    };
-  }
-
-  getRatingsFor(peerId: PeerId): PeerRating[] {
-    return this.ratings.filter(r => r.targetPeerId === peerId);
-  }
-
-  getMyRatings(): PeerRating[] {
-    if (!this.identity) return [];
-    return this.ratings.filter(r => r.raterPeerId === this.identity!.peerId);
-  }
-
-  async save(): Promise<void> {
-    await mkdir(this.configDir, { recursive: true });
-    const filePath = join(this.configDir, 'ratings.json');
-    await writeFile(filePath, JSON.stringify(this.ratings, null, 2), 'utf-8');
-  }
-
-  async load(): Promise<void> {
-    const filePath = join(this.configDir, 'ratings.json');
-    try {
-      const raw = await readFile(filePath, 'utf-8');
-      this.ratings = JSON.parse(raw) as PeerRating[];
-    } catch {
-      this.ratings = [];
-    }
-  }
-}

package/src/reputation/report-manager.ts

@@ -1,91 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import type { PeerId } from '../types/peer.js';
-import type { PeerReport, ReportReason, ReportEvidence } from '../types/report.js';
-import type { Identity } from '../p2p/identity.js';
-import { signData } from '../p2p/identity.js';
-import { bytesToHex } from '../utils/hex.js';
-
-export interface ReportManagerConfig {
-  configDir: string;
-  identity?: Identity;
-}
-
-export class ReportManager {
-  private readonly configDir: string;
-  private readonly identity: Identity | undefined;
-  private reports: PeerReport[] = [];
-
-  constructor(config: ReportManagerConfig) {
-    this.configDir = config.configDir;
-    this.identity = config.identity;
-  }
-
-  async submitReport(
-    targetPeerId: PeerId,
-    reason: ReportReason,
-    evidence: ReportEvidence[],
-    sessionId?: string,
-  ): Promise<PeerReport> {
-    if (!this.identity) throw new Error('Identity required to submit reports');
-
-    const report: PeerReport = {
-      reportId: randomUUID(),
-      reporterPeerId: this.identity.peerId as PeerId,
-      targetPeerId,
-      reason,
-      evidence,
-      sessionId,
-      timestamp: Date.now(),
-      status: 'pending',
-      signature: '',
-    };
-
-    // Sign the report
-    const dataToSign = `${report.reportId}:${report.reporterPeerId}:${report.targetPeerId}:${report.reason}:${report.timestamp}`;
-    const sig = await signData(this.identity.privateKey, new TextEncoder().encode(dataToSign));
-    report.signature = bytesToHex(sig);
-
-    this.reports.push(report);
-    await this.save();
-    return report;
-  }
-
-  getReportsAgainst(peerId: PeerId): PeerReport[] {
-    return this.reports.filter(r => r.targetPeerId === peerId);
-  }
-
-  getMyReports(): PeerReport[] {
-    if (!this.identity) return [];
-    return this.reports.filter(r => r.reporterPeerId === this.identity!.peerId);
-  }
-
-  getReport(reportId: string): PeerReport | null {
-    return this.reports.find(r => r.reportId === reportId) ?? null;
-  }
-
-  updateReportStatus(reportId: string, status: PeerReport['status']): void {
-    const report = this.reports.find(r => r.reportId === reportId);
-    if (report) {
-      report.status = status;
-    }
-  }
-
-  async save(): Promise<void> {
-    const dir = join(this.configDir, 'reports');
-    await mkdir(dir, { recursive: true });
-    const filePath = join(dir, 'reports.json');
-    await writeFile(filePath, JSON.stringify(this.reports, null, 2), 'utf-8');
-  }
-
-  async load(): Promise<void> {
-    const filePath = join(this.configDir, 'reports', 'reports.json');
-    try {
-      const raw = await readFile(filePath, 'utf-8');
-      this.reports = JSON.parse(raw) as PeerReport[];
-    } catch {
-      this.reports = [];
-    }
-  }
-}