agstell-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,100 @@
+/**
+ * AgentMarket CLI - Types
+ */
+interface Config {
+    stellarNetwork: 'testnet' | 'mainnet';
+    secretKey?: string;
+    publicKey?: string;
+    marketplaceUrl: string;
+    budgetLimit: number;
+    contractId?: string;
+}
+interface ApiInfo {
+    name: string;
+    slug: string;
+    description: string;
+    category: string;
+    priceUsdc: number;
+    endpoint: string;
+    method: 'GET' | 'POST';
+    provider: string;
+}
+interface WalletInfo {
+    publicKey: string;
+    network: 'testnet' | 'mainnet';
+    xlmBalance: string;
+    usdcBalance: string;
+}
+interface CallResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+    txHash?: string;
+    amountPaid?: number;
+    latencyMs?: number;
+}
+interface BudgetStatus {
+    totalBudget: number;
+    spent: number;
+    remaining: number;
+    callsToday: number;
+    lastCall?: string;
+}
+interface TransactionRecord {
+    txHash: string;
+    api: string;
+    amount: number;
+    timestamp: string;
+    success: boolean;
+}
+
+/**
+ * AgentMarket CLI - Stellar Client
+ */
+
+declare class StellarClient {
+    private network;
+    private server;
+    private keypair;
+    constructor(network?: 'testnet' | 'mainnet');
+    setSecretKey(secretKey: string): void;
+    getPublicKey(): string | null;
+    getWalletInfo(): Promise<WalletInfo | null>;
+    fundTestnetAccount(): Promise<string | null>;
+    sendPayment(destination: string, amount: string, memo?: string): Promise<{
+        txHash: string;
+        success: boolean;
+    } | null>;
+    verifyTransaction(txHash: string): Promise<boolean>;
+    generateKeypair(): {
+        publicKey: string;
+        secretKey: string;
+    };
+}
+
+/**
+ * AgentMarket CLI - API Client
+ */
+
+declare function listApis(category?: string): ApiInfo[];
+declare function getApiInfo(slug: string): ApiInfo | undefined;
+declare function callApi(slug: string, params: Record<string, unknown>, stellarClient: StellarClient): Promise<CallResult>;
+
+declare function loadConfig(): Config;
+declare function saveConfig(config: Partial<Config>): void;
+declare function loadHistory(): {
+    calls: {
+        api: string;
+        timestamp: string;
+        amount: number;
+        txHash: string;
+    }[];
+};
+declare function appendHistory(call: {
+    api: string;
+    timestamp: string;
+    amount: number;
+    txHash: string;
+}): void;
+
+export { type ApiInfo, type BudgetStatus, type CallResult, type Config, StellarClient, type TransactionRecord, type WalletInfo, appendHistory, callApi, getApiInfo, listApis, loadConfig, loadHistory, saveConfig };

package/dist/index.js

@@ -0,0 +1,412 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StellarClient: () => StellarClient,
+  appendHistory: () => appendHistory,
+  callApi: () => callApi,
+  getApiInfo: () => getApiInfo,
+  listApis: () => listApis,
+  loadConfig: () => loadConfig,
+  loadHistory: () => loadHistory,
+  saveConfig: () => saveConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/stellar.ts
+var StellarSdk = __toESM(require("@stellar/stellar-sdk"));
+var NETWORKS = {
+  testnet: {
+    networkPassphrase: StellarSdk.Networks.TESTNET,
+    horizonUrl: "https://horizon-testnet.stellar.org",
+    sorobanUrl: "https://soroban-testnet.stellar.org"
+  },
+  mainnet: {
+    networkPassphrase: StellarSdk.Networks.PUBLIC,
+    horizonUrl: "https://horizon.stellar.org",
+    sorobanUrl: "https://mainnet.stellar.org"
+  }
+};
+var USDC_TESTNET_ISSUER = "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5";
+var USDC_MAINNET_ISSUER = "GA5ZSEJYB37JRC5AVCIA5MOP4RHTM335X2KGX3IHOJAPP5RE34K4KZVN";
+var StellarClient = class {
+  network;
+  server;
+  keypair = null;
+  constructor(network = "testnet") {
+    this.network = network;
+    const config = NETWORKS[network];
+    this.server = new StellarSdk.Horizon.Server(config.horizonUrl);
+  }
+  setSecretKey(secretKey) {
+    this.keypair = StellarSdk.Keypair.fromSecret(secretKey);
+  }
+  getPublicKey() {
+    return this.keypair?.publicKey() || null;
+  }
+  async getWalletInfo() {
+    if (!this.keypair) return null;
+    try {
+      const account = await this.server.loadAccount(this.keypair.publicKey());
+      let xlmBalance = "0";
+      let usdcBalance = "0";
+      const usdcIssuer = this.network === "testnet" ? USDC_TESTNET_ISSUER : USDC_MAINNET_ISSUER;
+      for (const balance of account.balances) {
+        if (balance.asset_type === "native") {
+          xlmBalance = balance.balance;
+        } else if (balance.asset_type !== "liquidity_pool_shares" && balance.asset_code === "USDC" && balance.asset_issuer === usdcIssuer) {
+          usdcBalance = balance.balance;
+        }
+      }
+      return {
+        publicKey: this.keypair.publicKey(),
+        network: this.network,
+        xlmBalance,
+        usdcBalance
+      };
+    } catch (error) {
+      return {
+        publicKey: this.keypair.publicKey(),
+        network: this.network,
+        xlmBalance: "0",
+        usdcBalance: "0"
+      };
+    }
+  }
+  async fundTestnetAccount() {
+    if (!this.keypair || this.network !== "testnet") return null;
+    try {
+      const response = await fetch(
+        `https://friendbot.stellar.org?addr=${this.keypair.publicKey()}`
+      );
+      if (response.ok) {
+        return this.keypair.publicKey();
+      }
+    } catch {
+    }
+    return null;
+  }
+  async sendPayment(destination, amount, memo) {
+    if (!this.keypair) return null;
+    try {
+      const account = await this.server.loadAccount(this.keypair.publicKey());
+      const usdcIssuer = this.network === "testnet" ? USDC_TESTNET_ISSUER : USDC_MAINNET_ISSUER;
+      const usdcAsset = new StellarSdk.Asset("USDC", usdcIssuer);
+      const transaction = new StellarSdk.TransactionBuilder(account, {
+        fee: StellarSdk.BASE_FEE,
+        networkPassphrase: NETWORKS[this.network].networkPassphrase
+      }).addOperation(
+        StellarSdk.Operation.payment({
+          destination,
+          asset: usdcAsset,
+          amount
+        })
+      ).setTimeout(30);
+      if (memo) {
+        transaction.addMemo(StellarSdk.Memo.text(memo.substring(0, 28)));
+      }
+      const builtTx = transaction.build();
+      builtTx.sign(this.keypair);
+      const result = await this.server.submitTransaction(builtTx);
+      return {
+        txHash: result.hash,
+        success: true
+      };
+    } catch (error) {
+      console.error("Payment failed:", error);
+      return null;
+    }
+  }
+  async verifyTransaction(txHash) {
+    try {
+      const tx = await this.server.transactions().transaction(txHash).call();
+      return tx.successful;
+    } catch {
+      return false;
+    }
+  }
+  generateKeypair() {
+    const keypair = StellarSdk.Keypair.random();
+    return {
+      publicKey: keypair.publicKey(),
+      secretKey: keypair.secret()
+    };
+  }
+};
+
+// src/config.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var CONFIG_DIR = path.join(os.homedir(), ".agentmarket");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var HISTORY_FILE = path.join(CONFIG_DIR, "history.json");
+var REGISTRY_CACHE_FILE = path.join(CONFIG_DIR, "registry.json");
+var CONTRACTS = {
+  testnet: {
+    budgetEnforcer: "CBCAATFEUDNV43RPERRZ66B76C2HIOJ7LJBG77F4KHAVU527Y3PLHPJB"
+  },
+  mainnet: {
+    budgetEnforcer: ""
+  }
+};
+var DEFAULT_CONFIG = {
+  stellarNetwork: "testnet",
+  marketplaceUrl: "https://agentmarket.xyz",
+  budgetLimit: 10,
+  // 10 USDC default
+  contractId: CONTRACTS.testnet.budgetEnforcer
+};
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (fs.existsSync(CONFIG_FILE)) {
+    try {
+      const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+      return { ...DEFAULT_CONFIG, ...JSON.parse(data) };
+    } catch {
+      return DEFAULT_CONFIG;
+    }
+  }
+  return DEFAULT_CONFIG;
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const existing = loadConfig();
+  const updated = { ...existing, ...config };
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2));
+}
+function loadHistory() {
+  ensureConfigDir();
+  if (fs.existsSync(HISTORY_FILE)) {
+    try {
+      const data = fs.readFileSync(HISTORY_FILE, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return { calls: [] };
+    }
+  }
+  return { calls: [] };
+}
+function appendHistory(call) {
+  const history = loadHistory();
+  history.calls.push(call);
+  if (history.calls.length > 1e3) {
+    history.calls = history.calls.slice(-1e3);
+  }
+  fs.writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+}
+
+// src/api.ts
+var REGISTRY_TTL_MS = 60 * 60 * 1e3;
+var FALLBACK_REGISTRY = [
+  {
+    name: "Weather",
+    slug: "weather",
+    description: "Get current weather data for any city worldwide",
+    category: "Data",
+    priceUsdc: 1e-3,
+    endpoint: "/api/proxy/weather",
+    method: "GET",
+    provider: "AgentMarket"
+  },
+  {
+    name: "Air Quality",
+    slug: "air-quality",
+    description: "Get real-time air quality index and pollution data",
+    category: "Data",
+    priceUsdc: 1e-3,
+    endpoint: "/api/proxy/air-quality",
+    method: "GET",
+    provider: "AgentMarket"
+  },
+  {
+    name: "News",
+    slug: "news",
+    description: "Fetch latest news headlines by topic",
+    category: "Data",
+    priceUsdc: 2e-3,
+    endpoint: "/api/proxy/news",
+    method: "GET",
+    provider: "AgentMarket"
+  },
+  {
+    name: "Currency Exchange",
+    slug: "currency",
+    description: "Convert between currencies with live rates",
+    category: "Finance",
+    priceUsdc: 1e-3,
+    endpoint: "/api/proxy/currency",
+    method: "GET",
+    provider: "AgentMarket"
+  },
+  {
+    name: "Geolocation",
+    slug: "geolocation",
+    description: "Get location data from IP address",
+    category: "Geo",
+    priceUsdc: 1e-3,
+    endpoint: "/api/proxy/geolocation",
+    method: "GET",
+    provider: "AgentMarket"
+  },
+  {
+    name: "AI Inference",
+    slug: "ai",
+    description: "Run AI inference queries (GPT, Claude)",
+    category: "AI",
+    priceUsdc: 5e-3,
+    endpoint: "/api/proxy/ai",
+    method: "POST",
+    provider: "AgentMarket"
+  }
+];
+var _registry = [...FALLBACK_REGISTRY];
+function listApis(category) {
+  if (category) {
+    return _registry.filter(
+      (api) => api.category.toLowerCase() === category.toLowerCase()
+    );
+  }
+  return _registry;
+}
+function getApiInfo(slug) {
+  return _registry.find((api) => api.slug === slug);
+}
+function buildRequest(api, baseUrl, params, headers = {}) {
+  const url = new URL(api.endpoint, baseUrl);
+  if (api.method === "GET") {
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0 && value !== null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+    return { url: url.toString(), init: { method: "GET", headers } };
+  }
+  return {
+    url: url.toString(),
+    init: {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...headers },
+      body: JSON.stringify(params)
+    }
+  };
+}
+async function callApi(slug, params, stellarClient) {
+  const startTime = Date.now();
+  const api = getApiInfo(slug);
+  if (!api) {
+    return { success: false, error: `API not found: ${slug}` };
+  }
+  const config = loadConfig();
+  const wallet = await stellarClient.getWalletInfo();
+  if (!wallet) {
+    return { success: false, error: "Wallet not configured. Run: agentmarket init" };
+  }
+  const usdcBalance = parseFloat(wallet.usdcBalance);
+  if (usdcBalance < api.priceUsdc) {
+    return {
+      success: false,
+      error: `Insufficient USDC balance. Need ${api.priceUsdc}, have ${usdcBalance}`
+    };
+  }
+  const baseUrl = config.marketplaceUrl;
+  const initialRequest = buildRequest(api, baseUrl, params);
+  try {
+    const initialResponse = await fetch(initialRequest.url, initialRequest.init);
+    if (initialResponse.status === 402) {
+      const paymentDetails = await initialResponse.json();
+      if (!paymentDetails.payment?.recipient || !paymentDetails.payment?.amount) {
+        return { success: false, error: "Invalid 402 response: missing payment recipient or amount" };
+      }
+      const recipient = paymentDetails.payment.recipient;
+      const amount = paymentDetails.payment.amount;
+      const memo = paymentDetails.payment?.memo || `am:${slug}:${Date.now()}`;
+      const paymentResult = await stellarClient.sendPayment(recipient, amount, memo);
+      if (!paymentResult?.success) {
+        return { success: false, error: "Payment failed" };
+      }
+      const paymentProof = JSON.stringify({
+        txHash: paymentResult.txHash,
+        network: config.stellarNetwork,
+        timestamp: Date.now()
+      });
+      const retryRequest = buildRequest(api, baseUrl, params, {
+        "X-Payment-Proof": paymentProof,
+        "X-Payment-TxHash": paymentResult.txHash,
+        "X-Payment-Network": config.stellarNetwork
+      });
+      const retryResponse = await fetch(retryRequest.url, retryRequest.init);
+      if (!retryResponse.ok) {
+        return {
+          success: false,
+          error: `API call failed: ${retryResponse.status}`,
+          txHash: paymentResult.txHash,
+          amountPaid: api.priceUsdc
+        };
+      }
+      const data = await retryResponse.json();
+      const latencyMs = Date.now() - startTime;
+      appendHistory({
+        api: slug,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        amount: api.priceUsdc,
+        txHash: paymentResult.txHash
+      });
+      return { success: true, data, txHash: paymentResult.txHash, amountPaid: api.priceUsdc, latencyMs };
+    }
+    if (initialResponse.ok) {
+      const data = await initialResponse.json();
+      return { success: true, data, latencyMs: Date.now() - startTime };
+    }
+    return { success: false, error: `Unexpected response: ${initialResponse.status}` };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Request failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StellarClient,
+  appendHistory,
+  callApi,
+  getApiInfo,
+  listApis,
+  loadConfig,
+  loadHistory,
+  saveConfig
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "agstell-cli",
+  "version": "0.1.0",
+  "description": "CLI for AgentMarket — discover and call APIs with x402 micropayments on Stellar",
+  "main": "dist/index.js",
+  "files": [
+    "dist/",
+    "bin/"
+  ],
+  "bin": {
+    "agentmarket": "bin/agentmarket.js",
+    "am": "bin/agentmarket.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs --dts --clean",
+    "dev": "tsup src/cli.ts --format cjs --watch",
+    "start": "node dist/cli.js",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "cli",
+    "agentmarket",
+    "stellar",
+    "x402",
+    "ai-agents",
+    "api"
+  ],
+  "author": "AgentMarket",
+  "license": "MIT",
+  "dependencies": {
+    "@stellar/stellar-sdk": "^13.1.0",
+    "agstell-sdk": "^0.2.0",
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "dotenv": "^16.0.0",
+    "inquirer": "^9.2.0",
+    "ora": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.0",
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}