@moltos/sdk 0.11.0 → 0.12.0

package/dist/index.mjs

@@ -1,4 +1,17 @@
-// src/index.ts
+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",
@@ -161,20 +174,424 @@ var TAPClient = class {
     return randomBytes(16).toString("hex");
   }
 };
-async function submitAttestation(apiKey, request, baseUrl) {
-  const client = new TAPClient({ apiKey, baseUrl });
-  return client.attest(request);
-}
-async function getAgentScore(apiKey, agentId, baseUrl) {
-  const client = new TAPClient({ apiKey, baseUrl });
-  return client.getScore(agentId);
-}
-var VERSION = "0.1.0-alpha.1";
-var index_default = TAPClient;
+
+// 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,
-  index_default as default,
-  getAgentScore,
-  submitAttestation
+  aggregateSignatures,
+  batchVerifyAttestations,
+  deriveKeypair,
+  generateKeypair,
+  hashPayload,
+  isStubMode,
+  setStubMode,
+  signAttestation,
+  verifyAggregate,
+  verifyAttestation
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@moltos/sdk",
-  "version": "0.11.0",
-  "description": "MoltOS SDK - Trust and Attestation Protocol for Autonomous Agents",
+  "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",
@@ -24,6 +24,7 @@
   ],
   "scripts": {
     "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",
@@ -31,32 +32,50 @@
     "prepublishOnly": "npm run build"
   },
   "keywords": [
-    "tap",
     "moltos",
-    "attestation",
-    "reputation",
-    "eigentrust",
     "agents",
-    "ai"
+    "ai",
+    "reputation",
+    "tap",
+    "clawid",
+    "web3",
+    "attestation",
+    "eigentrust"
   ],
   "author": "MoltOS Team",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Shepherd217/trust-audit-framework.git",
+    "url": "https://github.com/Shepherd217/MoltOS.git",
     "directory": "tap-sdk"
   },
   "bugs": {
-    "url": "https://github.com/Shepherd217/trust-audit-framework/issues"
+    "url": "https://github.com/Shepherd217/MoltOS/issues"
   },
-  "homepage": "https://docs.moltos.ai",
+  "homepage": "https://moltos.org",
   "engines": {
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@noble/hashes": "^1.4.0"
+    "@noble/curves": "^2.0.1",
+    "@noble/hashes": "^1.4.0",
+    "@supabase/supabase-js": "^2.39.0",
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "cli-table3": "^0.6.3",
+    "commander": "^11.1.0",
+    "cross-fetch": "^4.0.0",
+    "figlet": "^1.7.0",
+    "gradient-string": "^2.0.2",
+    "inquirer": "^9.2.12",
+    "log-symbols": "^6.0.0",
+    "nanospinner": "^1.1.0",
+    "ora": "^8.0.1"
   },
   "devDependencies": {
+    "@types/figlet": "^1.5.8",
+    "@types/gradient-string": "^1.1.5",
+    "@types/inquirer": "^9.0.7",
     "@types/node": "^20.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.3.0",