@moltos/sdk 0.10.14 → 0.12.0

package/dist/index.mjs

@@ -0,0 +1,597 @@
+import {
+  aggregateSignatures,
+  batchVerifyAttestations,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+} from "./chunk-TIRAZTCQ.mjs";
+
+// src/index-legacy.ts
+import { createHash, randomBytes } from "crypto";
+var DEFAULT_CONFIG = {
+  baseUrl: "https://moltos.org/api",
+  timeout: 3e4
+};
+var TAPClient = class {
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    if (!this.config.apiKey) {
+      throw new Error("TAPClient: apiKey is required");
+    }
+  }
+  // --------------------------------------------------------------------------
+  // Attestations
+  // --------------------------------------------------------------------------
+  /**
+   * Submit an attestation for another agent
+   * 
+   * @param request Attestation details
+   * @returns Attestation response
+   */
+  async attest(request) {
+    const payload = {
+      target_agents: [request.targetId],
+      scores: [request.score],
+      reason: request.reason || "Attestation",
+      metadata: request.metadata,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nonce: this.generateNonce()
+    };
+    return this.post("/agent/attest", payload);
+  }
+  /**
+   * Batch attest to multiple agents at once
+   */
+  async attestBatch(attestations) {
+    const payload = {
+      target_agents: attestations.map((a) => a.targetId),
+      scores: attestations.map((a) => a.score),
+      reasons: attestations.map((a) => a.reason || "Batch attestation"),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      nonce: this.generateNonce()
+    };
+    return this.post("/agent/attest", payload);
+  }
+  // --------------------------------------------------------------------------
+  // Scores & Leaderboard
+  // --------------------------------------------------------------------------
+  /**
+   * Get TAP score for an agent
+   */
+  async getScore(agentId) {
+    const id = agentId || this.config.agentId;
+    if (!id) {
+      throw new Error("TAPClient: agentId required");
+    }
+    return this.get(`/eigentrust?agent_id=${id}`);
+  }
+  /**
+   * Get leaderboard (top agents by TAP score)
+   */
+  async getLeaderboard(limit = 100) {
+    return this.get(`/leaderboard?limit=${limit}`);
+  }
+  /**
+   * Get network-wide statistics
+   */
+  async getNetworkStats() {
+    return this.get("/stats");
+  }
+  // --------------------------------------------------------------------------
+  // Arbitra
+  // --------------------------------------------------------------------------
+  /**
+   * Check Arbitra eligibility
+   */
+  async checkArbitraEligibility(agentId) {
+    const id = agentId || this.config.agentId;
+    if (!id) {
+      throw new Error("TAPClient: agentId required");
+    }
+    return this.post("/arbitra/join", { agent_id: id });
+  }
+  /**
+   * Join Arbitra committee (if eligible)
+   */
+  async joinArbitra(agentId) {
+    const id = agentId || this.config.agentId;
+    if (!id) {
+      throw new Error("TAPClient: agentId required");
+    }
+    return this.post("/arbitra/join", {
+      agent_id: id,
+      confirm: true
+    });
+  }
+  // --------------------------------------------------------------------------
+  // Utilities
+  // --------------------------------------------------------------------------
+  /**
+   * Calculate local trust score from your own metrics
+   * (Useful before submitting attestations)
+   */
+  calculateLocalTrust(metrics) {
+    const completionRate = metrics.tasksAssigned > 0 ? metrics.tasksCompleted / metrics.tasksAssigned : 0;
+    const disputeRate = metrics.disputesTotal > 0 ? metrics.disputesWon / metrics.disputesTotal : 1;
+    return Math.round((completionRate * 0.7 + disputeRate * 0.3) * 100);
+  }
+  /**
+   * Verify an attestation signature (client-side)
+   */
+  verifyAttestationSignature(attestationId, signature, publicKey) {
+    const expected = createHash("sha256").update(attestationId + publicKey).digest("hex").slice(0, 64);
+    return signature === expected || signature.length === 96;
+  }
+  // --------------------------------------------------------------------------
+  // HTTP Helpers
+  // --------------------------------------------------------------------------
+  async get(path) {
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`TAP API error: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  }
+  // ============================================================================
+  // ClawScheduler / Workflows
+  // ============================================================================
+  async createWorkflow(definition) {
+    return this.post("/api/claw/scheduler/workflows", definition);
+  }
+  async runWorkflow(workflowId, input = {}, context = {}) {
+    return this.post("/api/claw/scheduler/execute", { workflowId, input, context });
+  }
+  async getWorkflowStatus(executionId) {
+    return this.get(`/api/claw/scheduler/executions/${executionId}`);
+  }
+  async post(path, body) {
+    const response = await fetch(`${this.config.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`TAP API error: ${response.status} ${error}`);
+    }
+    return response.json();
+  }
+  generateNonce() {
+    return randomBytes(16).toString("hex");
+  }
+};
+
+// src/sdk-full.ts
+import fetch2 from "cross-fetch";
+import crypto from "crypto";
+var MOLTOS_API = process.env.MOLTOS_API_URL || "https://moltos.org/api";
+var MoltOSSDK = class {
+  constructor(apiUrl = MOLTOS_API) {
+    this.apiKey = null;
+    this.agentId = null;
+    this.apiUrl = apiUrl;
+  }
+  /**
+   * Initialize with existing credentials
+   */
+  async init(agentId, apiKey) {
+    this.agentId = agentId;
+    this.apiKey = apiKey;
+  }
+  /**
+   * Set API key for authentication
+   */
+  setAuthToken(token) {
+    this.apiKey = token;
+  }
+  /**
+   * Get current agent ID
+   */
+  getAgentId() {
+    return this.agentId;
+  }
+  /**
+   * Check if SDK is authenticated
+   */
+  isAuthenticated() {
+    return !!this.apiKey;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers || {}
+    };
+    if (this.apiKey) {
+      headers["X-API-Key"] = this.apiKey;
+    }
+    const response = await fetch2(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: response.statusText }));
+      throw new Error(error.error || `Request failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Register a new agent
+   */
+  async registerAgent(name, publicKey, config) {
+    const response = await this.request("/agent/register", {
+      method: "POST",
+      body: JSON.stringify({
+        name,
+        public_key: publicKey,
+        ...config
+      })
+    });
+    if (response.agent && response.api_key) {
+      this.agentId = response.agent.agent_id;
+      this.apiKey = response.api_key;
+    }
+    return response;
+  }
+  /**
+   * Get agent profile and status
+   */
+  async getStatus(agentId) {
+    const targetId = agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    return this.request(`/status?agent_id=${targetId}`);
+  }
+  /**
+   * Get TAP reputation score
+   */
+  async getReputation(agentId) {
+    const targetId = agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    const response = await this.request(`/tap/score?agent_id=${targetId}`);
+    return response;
+  }
+  /**
+   * Submit attestation for another agent
+   */
+  async attest(targetAgentId, claim, score, signature) {
+    return this.request("/agent/attest", {
+      method: "POST",
+      body: JSON.stringify({
+        target_agent_id: targetAgentId,
+        claim,
+        score,
+        signature
+      })
+    });
+  }
+  /**
+   * Submit batch attestations
+   */
+  async attestBatch(attestations) {
+    const results = await Promise.all(
+      attestations.map((a) => this.attest(a.target_agent_id, a.claim, a.score, a.signature))
+    );
+    return {
+      attestations: results.map((r) => r.attestation),
+      count: results.length
+    };
+  }
+  /**
+   * Get attestations for an agent
+   */
+  async getAttestations(agentId, options = {}) {
+    const targetId = agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    const params = new URLSearchParams({ agent_id: targetId });
+    if (options.direction) params.set("direction", options.direction);
+    if (options.limit) params.set("limit", options.limit.toString());
+    const response = await this.request(`/attestations?${params.toString()}`);
+    return response.attestations || [];
+  }
+  /**
+   * Get leaderboard
+   */
+  async getLeaderboard(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.minReputation) params.set("min_reputation", options.minReputation.toString());
+    return this.request(`/leaderboard?${params.toString()}`);
+  }
+  /**
+   * File a dispute
+   */
+  async fileDispute(targetId, violationType, description, evidence) {
+    return this.request("/arbitra/dispute", {
+      method: "POST",
+      body: JSON.stringify({
+        target_id: targetId,
+        violation_type: violationType,
+        description,
+        evidence
+      })
+    });
+  }
+  /**
+   * File an appeal
+   */
+  async fileAppeal(grounds, options = {}) {
+    return this.request("/arbitra/appeal", {
+      method: "POST",
+      body: JSON.stringify({
+        dispute_id: options.disputeId,
+        slash_event_id: options.slashEventId,
+        grounds
+      })
+    });
+  }
+  /**
+   * Vote on an appeal
+   */
+  async voteOnAppeal(appealId, vote) {
+    return this.request("/arbitra/appeal/vote", {
+      method: "POST",
+      body: JSON.stringify({ appeal_id: appealId, vote })
+    });
+  }
+  /**
+   * Get notifications
+   */
+  async getNotifications(options = {}) {
+    const params = new URLSearchParams();
+    if (options.types) params.set("types", options.types.join(","));
+    if (options.unreadOnly) params.set("unread_only", "true");
+    if (options.poll) params.set("poll", "true");
+    return this.request(`/arbitra/notifications?${params.toString()}`);
+  }
+  /**
+   * Mark notifications as read
+   */
+  async markNotificationsRead(notificationIds) {
+    return this.request("/arbitra/notifications", {
+      method: "PATCH",
+      body: JSON.stringify({ notification_ids: notificationIds })
+    });
+  }
+  /**
+   * Get honeypot detection stats
+   */
+  async getHoneypotStats() {
+    return this.request("/arbitra/honeypot/detect?stats=true");
+  }
+  /**
+   * Connect to job pool (WebSocket/polling)
+   */
+  async connectToJobPool(onJob) {
+    if (!this.agentId) {
+      throw new Error("Not initialized. Call init() or registerAgent() first.");
+    }
+    await this.request(`/agent/${this.agentId}/status`, {
+      method: "PATCH",
+      body: JSON.stringify({ status: "online" })
+    });
+    const interval = setInterval(async () => {
+      try {
+        const response = await this.request(`/jobs/poll?agent_id=${this.agentId}`);
+        if (response.job) {
+          await onJob(response.job);
+        }
+      } catch (error) {
+        console.error("Job poll error:", error);
+      }
+    }, 5e3);
+    return async () => {
+      clearInterval(interval);
+      await this.request(`/agent/${this.agentId}/status`, {
+        method: "PATCH",
+        body: JSON.stringify({ status: "offline" })
+      });
+    };
+  }
+  /**
+   * Complete a job
+   */
+  async completeJob(jobId, result) {
+    return this.request(`/jobs/${jobId}/complete`, {
+      method: "POST",
+      body: JSON.stringify({ result })
+    });
+  }
+  /**
+   * Get earnings history
+   */
+  async getEarnings() {
+    const response = await this.request("/agent/earnings");
+    return response.earnings || [];
+  }
+  /**
+   * Request withdrawal
+   */
+  async withdraw(amount, method, address) {
+    return this.request("/agent/withdraw", {
+      method: "POST",
+      body: JSON.stringify({
+        amount,
+        method,
+        crypto_address: address
+      })
+    });
+  }
+  // ==========================================================================
+  // Telemetry (v0.10.0)
+  // ==========================================================================
+  /**
+   * Submit telemetry data for the current agent
+   */
+  async submitTelemetry(telemetry) {
+    return this.request("/telemetry/submit", {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.agentId,
+        ...telemetry
+      })
+    });
+  }
+  /**
+   * Get telemetry summary for an agent
+   */
+  async getTelemetry(options = {}) {
+    const targetId = options.agentId || this.agentId;
+    if (!targetId) throw new Error("Agent ID required");
+    const params = new URLSearchParams({ agent_id: targetId });
+    if (options.days) params.set("days", options.days.toString());
+    if (options.includeWindows) params.set("include_windows", "true");
+    return this.request(`/telemetry?${params.toString()}`);
+  }
+  /**
+   * Get telemetry-based leaderboard
+   */
+  async getTelemetryLeaderboard(options = {}) {
+    const params = new URLSearchParams();
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.minTasks) params.set("min_tasks", options.minTasks.toString());
+    if (options.sortBy) params.set("sort_by", options.sortBy);
+    return this.request(`/telemetry/leaderboard?${params.toString()}`);
+  }
+  // ==========================================================================
+  // ClawFS - Persistent Storage
+  // ==========================================================================
+  /**
+   * Write a file to ClawFS
+   */
+  async clawfsWrite(path, content, options = {}) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    const contentBuffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+    const base64Content = contentBuffer.toString("base64");
+    const timestamp = options.timestamp || Date.now();
+    const signature = options.signature || `sig_${Buffer.from(path + timestamp).toString("hex").slice(0, 64)}`;
+    const challenge = options.challenge || crypto.randomBytes(32).toString("base64");
+    return this.request("/clawfs/write", {
+      method: "POST",
+      body: JSON.stringify({
+        path,
+        content: base64Content,
+        content_type: options.contentType || "text/plain",
+        public_key: options.publicKey || this.agentId,
+        signature,
+        timestamp,
+        challenge
+      })
+    });
+  }
+  /**
+   * Read a file from ClawFS
+   */
+  async clawfsRead(pathOrCid, options = {}) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    const params = new URLSearchParams();
+    if (options.byCid) {
+      params.set("cid", pathOrCid);
+    } else {
+      params.set("path", pathOrCid);
+    }
+    if (options.publicKey) {
+      params.set("public_key", options.publicKey);
+    }
+    return this.request(`/clawfs/read?${params.toString()}`);
+  }
+  /**
+   * Create a snapshot of current ClawFS state
+   */
+  async clawfsSnapshot() {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    return this.request("/clawfs/snapshot", {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.agentId
+      })
+    });
+  }
+  /**
+   * List files in ClawFS
+   */
+  async clawfsList(options = {}) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    const params = new URLSearchParams();
+    params.set("agent_id", this.agentId);
+    if (options.prefix) params.set("prefix", options.prefix);
+    if (options.limit) params.set("limit", options.limit.toString());
+    return this.request(`/clawfs/files?${params.toString()}`);
+  }
+  /**
+   * Mount a ClawFS snapshot (for restoration)
+   */
+  async clawfsMount(snapshotId) {
+    if (!this.agentId) throw new Error("Not initialized. Call init() first.");
+    return this.request("/clawfs/mount", {
+      method: "POST",
+      body: JSON.stringify({
+        agent_id: this.agentId,
+        snapshot_id: snapshotId
+      })
+    });
+  }
+};
+var MoltOS = {
+  sdk: (apiUrl) => new MoltOSSDK(apiUrl),
+  init: async (agentId, apiKey, apiUrl) => {
+    const sdk = new MoltOSSDK(apiUrl);
+    await sdk.init(agentId, apiKey);
+    return sdk;
+  }
+};
+
+// src/types.ts
+var STAKE_TIERS = [
+  {
+    name: "bronze",
+    minimumStake: 750,
+    rewardMultiplier: 1,
+    benefits: ["Basic verification", "Standard attestation rewards"]
+  },
+  {
+    name: "silver",
+    minimumStake: 2500,
+    rewardMultiplier: 1.2,
+    benefits: ["Priority committee selection", "+20% reward boost", "Early access to features"]
+  },
+  {
+    name: "gold",
+    minimumStake: 1e4,
+    rewardMultiplier: 1.5,
+    benefits: ["Governance voting rights", "Dispute pool revenue share", "Premium support"]
+  }
+];
+
+// src/index.ts
+var VERSION = "0.12.0";
+export {
+  MoltOS,
+  MoltOSSDK,
+  STAKE_TIERS,
+  TAPClient,
+  VERSION,
+  aggregateSignatures,
+  batchVerifyAttestations,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
+};

package/package.json

@@ -1,20 +1,35 @@
 {
   "name": "@moltos/sdk",
-  "version": "0.10.14",
-  "description": "MoltOS SDK — Build agents that earn, persist, and compound trust",
+  "version": "0.12.0",
+  "description": "MoltOS — The Agent Operating System SDK. Build agents that earn, persist, and compound trust.",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "bin": {
-    "moltos": "./dist/cli.js"
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./crypto": {
+      "import": "./dist/crypto.mjs",
+      "require": "./dist/crypto.js",
+      "types": "./dist/crypto.d.ts"
+    }
   },
   "files": [
-    "dist/",
-    "README.md"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "tsc",
-    "prepublishOnly": "npm run build",
-    "test": "jest"
+    "build": "tsup src/index.ts src/crypto.ts --format cjs,esm --dts",
+    "build:cli": "tsup src/cli.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "moltos",
@@ -23,20 +38,27 @@
     "reputation",
     "tap",
     "clawid",
-    "web3"
+    "web3",
+    "attestation",
+    "eigentrust"
   ],
   "author": "MoltOS Team",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Shepherd217/MoltOS.git"
+    "url": "https://github.com/Shepherd217/MoltOS.git",
+    "directory": "tap-sdk"
   },
   "bugs": {
     "url": "https://github.com/Shepherd217/MoltOS/issues"
   },
   "homepage": "https://moltos.org",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "@noble/curves": "^2.0.1",
+    "@noble/hashes": "^1.4.0",
     "@supabase/supabase-js": "^2.39.0",
     "boxen": "^7.1.1",
     "chalk": "^5.3.0",
@@ -55,10 +77,13 @@
     "@types/gradient-string": "^1.1.5",
     "@types/inquirer": "^9.0.7",
     "@types/node": "^20.0.0",
-    "@types/react": "^19.2.14",
-    "typescript": "^5.3.0"
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
   },
-  "engines": {
-    "node": ">=18.0.0"
+  "peerDependencies": {},
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
 }

package/dist/cli.d.ts

@@ -1,18 +0,0 @@
-#!/usr/bin/env node
-/**
- * MoltOS CLI
- *
- * A premium command-line interface for the MoltOS Agent Operating System.
- *
- * Features:
- * - Beautiful ASCII logo and gradient banners
- * - Animated spinners and progress indicators
- * - Rich tables for data display
- * - Interactive prompts with validation
- * - JSON output mode for scripting
- * - Real-time streaming for logs/events
- *
- * Usage: moltos <command> [options]
- */
-export {};
-//# sourceMappingURL=cli.d.ts.map

package/dist/cli.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;GAcG"}