valta-sdk 2.0.1 → 2.1.0

package/bin/valta.js

@@ -1,159 +1,14 @@
 #!/usr/bin/env node
+import { pathToFileURL } from 'url';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
 
-import { readFileSync, writeFileSync, existsSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
 
-const CONFIG_FILE = join(homedir(), ".valta", "config.json");
-const VERSION = "2.0.0";
+const cliPath = join(__dirname, '..', 'dist', 'cli', 'index.mjs');
 
-function loadConfig() {
-  if (!existsSync(CONFIG_FILE)) return {};
-  try { return JSON.parse(readFileSync(CONFIG_FILE, "utf8")); } catch { return {}; }
-}
-
-function saveConfig(data) {
-  const dir = join(homedir(), ".valta");
-  if (!existsSync(dir)) {
-    const { mkdirSync } = await import("fs");
-    mkdirSync(dir, { recursive: true });
-  }
-  writeFileSync(CONFIG_FILE, JSON.stringify(data, null, 2));
-}
-
-const args = process.argv.slice(2);
-const command = args[0];
-
-const help = `
-  Valta CLI v${VERSION}
-
-  COMMANDS
-    valta init              Initialize a new Valta project
-    valta login             Save your API key
-    valta create-agent      Generate an agent starter file
-    valta run               Run a quick agent query
-    valta --version         Show CLI version
-    valta help              Show this help
-
-  EXAMPLES
-    valta login
-    valta create-agent trading
-    valta run "What is BTC doing today?" --agent trading_signal
-`;
-
-async function main() {
-  switch (command) {
-    case "init": {
-      const template = `// Valta project starter
-// https://valta.co/docs
-
-import { ValtaClient } from "valta-sdk";
-
-const valta = new ValtaClient({
-  apiKey: process.env.VALTA_API_KEY,
-});
-
-// List available agents
-const agents = await valta.listAgents();
-console.log("Available agents:", agents.map(a => a.name));
-
-// Chat with the Trading Signal agent
-const agent = valta.createAgent("trading_signal");
-const response = await agent.chat("What is BTC doing today?");
-console.log(response.message);
-`;
-      writeFileSync("valta-starter.js", template);
-      console.log("✓ Created valta-starter.js");
-      console.log("  Run: node valta-starter.js");
-      break;
-    }
-
-    case "login": {
-      const { createInterface } = await import("readline");
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      rl.question("Enter your Valta API key (from /dashboard/api-keys): ", (key) => {
-        rl.close();
-        const trimmed = key.trim();
-        if (!trimmed) { console.error("✗ No API key provided"); process.exit(1); }
-        const cfg = loadConfig();
-        cfg.apiKey = trimmed;
-        try { saveConfig(cfg); } catch {
-          const { mkdirSync } = require("fs");
-          mkdirSync(join(homedir(), ".valta"), { recursive: true });
-          saveConfig(cfg);
-        }
-        console.log(`✓ API key saved to ${CONFIG_FILE}`);
-        console.log("  You can now import it as: VALTA_API_KEY from your environment.");
-      });
-      break;
-    }
-
-    case "create-agent": {
-      const type = args[1] || "general";
-      const fileName = `${type}Agent.js`;
-      const agentTemplate = `// ${type.charAt(0).toUpperCase() + type.slice(1)} Agent — Valta SDK
-import { ValtaClient } from "valta-sdk";
-
-const valta = new ValtaClient({ apiKey: process.env.VALTA_API_KEY });
-const agent = valta.createAgent("${type}_agent");
-
-const response = await agent.chat("Your question here");
-console.log(response.message);
-`;
-      writeFileSync(fileName, agentTemplate);
-      console.log(`✓ Created ${fileName}`);
-      break;
-    }
-
-    case "run": {
-      const message = args[1];
-      const agentFlag = args.indexOf("--agent");
-      const agentId = agentFlag !== -1 ? args[agentFlag + 1] : "financial_advisor";
-
-      if (!message) {
-        console.error("Usage: valta run \"your question\" --agent <agent_id>");
-        process.exit(1);
-      }
-
-      const cfg = loadConfig();
-      const apiKey = cfg.apiKey || process.env.VALTA_API_KEY;
-      if (!apiKey) {
-        console.error("✗ No API key. Run: valta login");
-        process.exit(1);
-      }
-
-      console.log(`Running ${agentId}...`);
-      const res = await fetch(`https://valta.co/api/bot/${encodeURIComponent(agentId)}/chat`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", "Authorization": `Bearer ${apiKey}` },
-        body: JSON.stringify({ message }),
-      });
-      const data = await res.json();
-      if (!res.ok) { console.error("✗", data.error || "Request failed"); process.exit(1); }
-      console.log("\n" + (data.message || data.response || JSON.stringify(data)));
-      break;
-    }
-
-    case "--version":
-    case "-v":
-      console.log(`valta-sdk v${VERSION}`);
-      break;
-
-    case "help":
-    case "--help":
-    case "-h":
-    case undefined:
-      console.log(help);
-      break;
-
-    default:
-      console.error(`Unknown command: ${command}`);
-      console.log(help);
-      process.exit(1);
-  }
-}
-
-main().catch((err) => {
-  console.error("✗", err.message);
+import(pathToFileURL(cliPath).href).catch((err) => {
+  console.error('Valta CLI failed to start:', err.message);
   process.exit(1);
-});
+});

package/dist/chunk-HGO47A3L.mjs

@@ -0,0 +1,244 @@
+// src/errors/index.ts
+var ValtaError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.name = "ValtaError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var AuthError = class extends ValtaError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "UNAUTHORIZED", 401);
+    this.name = "AuthError";
+  }
+};
+var TierError = class extends ValtaError {
+  constructor(message, requiredTier) {
+    super(message, "TIER_LIMIT", 403);
+    this.name = "TierError";
+    this.requiredTier = requiredTier;
+    this.upgradeUrl = "https://valta.co/upgrade";
+  }
+};
+var RateLimitError = class extends ValtaError {
+  constructor(message = "Rate limit exceeded. Slow down your requests.") {
+    super(message, "RATE_LIMIT", 429);
+    this.name = "RateLimitError";
+  }
+};
+var NotFoundError = class extends ValtaError {
+  constructor(resource) {
+    super(`${resource} not found`, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/http/requester.ts
+var DEFAULT_BASE_URL = "https://valta.co/api/v1";
+var Requester = class {
+  constructor(apiKey, baseUrl) {
+    if (!apiKey || typeof apiKey !== "string") {
+      throw new AuthError("An API key is required. Get one at https://valta.co/dashboard/api-keys");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", body } = options;
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Valta-SDK": "0.2.0"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let errorData = {};
+      try {
+        errorData = await res.json();
+      } catch {
+      }
+      const message = errorData.message ?? "An unknown error occurred";
+      switch (res.status) {
+        case 401:
+          throw new AuthError(message);
+        case 403:
+          throw new TierError(message, errorData.requiredTier ?? "builder");
+        case 404:
+          throw new NotFoundError(path);
+        case 429:
+          throw new RateLimitError(message);
+        default:
+          throw new ValtaError(message, "SERVER_ERROR", res.status);
+      }
+    }
+    return res.json();
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  // Get all agents
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    if (params.status) query.set("status", params.status);
+    const qs = query.toString();
+    return this.requester.request(
+      `/agents${qs ? `?${qs}` : ""}`
+    );
+  }
+  // Get one agent by ID
+  async get(agentId) {
+    return this.requester.request(`/agents/${agentId}`);
+  }
+  // Create a new agent
+  async create(params) {
+    return this.requester.request("/agents", {
+      method: "POST",
+      body: params
+    });
+  }
+  // Update an agent
+  async update(agentId, params) {
+    return this.requester.request(`/agents/${agentId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  // Freeze an agent (stops it from spending)
+  async freeze(agentId) {
+    return this.requester.request(`/agents/${agentId}/freeze`, {
+      method: "POST"
+    });
+  }
+  // Unfreeze an agent
+  async unfreeze(agentId) {
+    return this.requester.request(`/agents/${agentId}/unfreeze`, {
+      method: "POST"
+    });
+  }
+  // Delete an agent
+  async delete(agentId) {
+    return this.requester.request(
+      `/agents/${agentId}`,
+      { method: "DELETE" }
+    );
+  }
+};
+
+// src/resources/wallets.ts
+var WalletsResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  // Get wallet balance for an agent
+  async get(agentId) {
+    return this.requester.request(
+      `/agents/${agentId}/wallet`
+    );
+  }
+  // Transfer funds from one agent wallet to another
+  async transfer(agentId, params) {
+    return this.requester.request(
+      `/agents/${agentId}/wallet/transfer`,
+      { method: "POST", body: params }
+    );
+  }
+};
+
+// src/resources/policies.ts
+var PoliciesResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list(agentId) {
+    const qs = agentId ? `?agentId=${agentId}` : "";
+    return this.requester.request(`/policies${qs}`);
+  }
+  async create(params) {
+    return this.requester.request("/policies", {
+      method: "POST",
+      body: params
+    });
+  }
+  async update(policyId, params) {
+    return this.requester.request(`/policies/${policyId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  async delete(policyId) {
+    return this.requester.request(`/policies/${policyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/resources/audit.ts
+var AuditResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    if (params.agentId) query.set("agentId", params.agentId);
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    if (params.from) query.set("from", params.from);
+    if (params.to) query.set("to", params.to);
+    const qs = query.toString();
+    return this.requester.request(`/audit${qs ? `?${qs}` : ""}`);
+  }
+};
+
+// src/resources/keys.ts
+var KeysResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list() {
+    return this.requester.request("/keys");
+  }
+  async create(name) {
+    return this.requester.request("/keys", {
+      method: "POST",
+      body: { name }
+    });
+  }
+  async revoke(keyId) {
+    return this.requester.request(`/keys/${keyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/client.ts
+var ValtaClient = class {
+  constructor(config) {
+    const apiKey = typeof config === "string" ? config : config.apiKey;
+    const baseUrl = typeof config === "object" ? config.baseUrl : void 0;
+    const requester = new Requester(apiKey, baseUrl);
+    this.agents = new AgentsResource(requester);
+    this.wallets = new WalletsResource(requester);
+    this.policies = new PoliciesResource(requester);
+    this.audit = new AuditResource(requester);
+    this.keys = new KeysResource(requester);
+  }
+};
+
+export {
+  ValtaError,
+  AuthError,
+  TierError,
+  RateLimitError,
+  NotFoundError,
+  ValtaClient
+};

package/dist/chunk-LPBJPXJO.js

@@ -0,0 +1,244 @@
+// src/errors/index.ts
+var ValtaError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.name = "ValtaError";
+    this.code = code;
+    this.status = status;
+  }
+};
+var AuthError = class extends ValtaError {
+  constructor(message = "Invalid or missing API key") {
+    super(message, "UNAUTHORIZED", 401);
+    this.name = "AuthError";
+  }
+};
+var TierError = class extends ValtaError {
+  constructor(message, requiredTier) {
+    super(message, "TIER_LIMIT", 403);
+    this.name = "TierError";
+    this.requiredTier = requiredTier;
+    this.upgradeUrl = "https://valta.co/upgrade";
+  }
+};
+var RateLimitError = class extends ValtaError {
+  constructor(message = "Rate limit exceeded. Slow down your requests.") {
+    super(message, "RATE_LIMIT", 429);
+    this.name = "RateLimitError";
+  }
+};
+var NotFoundError = class extends ValtaError {
+  constructor(resource) {
+    super(`${resource} not found`, "NOT_FOUND", 404);
+    this.name = "NotFoundError";
+  }
+};
+
+// src/http/requester.ts
+var DEFAULT_BASE_URL = "https://valta.co/api/v1";
+var Requester = class {
+  constructor(apiKey, baseUrl) {
+    if (!apiKey || typeof apiKey !== "string") {
+      throw new AuthError("An API key is required. Get one at https://valta.co/dashboard/api-keys");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl ?? DEFAULT_BASE_URL;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", body } = options;
+    const res = await fetch(`${this.baseUrl}${path}`, {
+      method,
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Valta-SDK": "0.2.0"
+      },
+      body: body ? JSON.stringify(body) : void 0
+    });
+    if (!res.ok) {
+      let errorData = {};
+      try {
+        errorData = await res.json();
+      } catch {
+      }
+      const message = errorData.message ?? "An unknown error occurred";
+      switch (res.status) {
+        case 401:
+          throw new AuthError(message);
+        case 403:
+          throw new TierError(message, errorData.requiredTier ?? "builder");
+        case 404:
+          throw new NotFoundError(path);
+        case 429:
+          throw new RateLimitError(message);
+        default:
+          throw new ValtaError(message, "SERVER_ERROR", res.status);
+      }
+    }
+    return res.json();
+  }
+};
+
+// src/resources/agents.ts
+var AgentsResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  // Get all agents
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    if (params.status) query.set("status", params.status);
+    const qs = query.toString();
+    return this.requester.request(
+      `/agents${qs ? `?${qs}` : ""}`
+    );
+  }
+  // Get one agent by ID
+  async get(agentId) {
+    return this.requester.request(`/agents/${agentId}`);
+  }
+  // Create a new agent
+  async create(params) {
+    return this.requester.request("/agents", {
+      method: "POST",
+      body: params
+    });
+  }
+  // Update an agent
+  async update(agentId, params) {
+    return this.requester.request(`/agents/${agentId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  // Freeze an agent (stops it from spending)
+  async freeze(agentId) {
+    return this.requester.request(`/agents/${agentId}/freeze`, {
+      method: "POST"
+    });
+  }
+  // Unfreeze an agent
+  async unfreeze(agentId) {
+    return this.requester.request(`/agents/${agentId}/unfreeze`, {
+      method: "POST"
+    });
+  }
+  // Delete an agent
+  async delete(agentId) {
+    return this.requester.request(
+      `/agents/${agentId}`,
+      { method: "DELETE" }
+    );
+  }
+};
+
+// src/resources/wallets.ts
+var WalletsResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  // Get wallet balance for an agent
+  async get(agentId) {
+    return this.requester.request(
+      `/agents/${agentId}/wallet`
+    );
+  }
+  // Transfer funds from one agent wallet to another
+  async transfer(agentId, params) {
+    return this.requester.request(
+      `/agents/${agentId}/wallet/transfer`,
+      { method: "POST", body: params }
+    );
+  }
+};
+
+// src/resources/policies.ts
+var PoliciesResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list(agentId) {
+    const qs = agentId ? `?agentId=${agentId}` : "";
+    return this.requester.request(`/policies${qs}`);
+  }
+  async create(params) {
+    return this.requester.request("/policies", {
+      method: "POST",
+      body: params
+    });
+  }
+  async update(policyId, params) {
+    return this.requester.request(`/policies/${policyId}`, {
+      method: "PATCH",
+      body: params
+    });
+  }
+  async delete(policyId) {
+    return this.requester.request(`/policies/${policyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/resources/audit.ts
+var AuditResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list(params = {}) {
+    const query = new URLSearchParams();
+    if (params.agentId) query.set("agentId", params.agentId);
+    if (params.limit) query.set("limit", String(params.limit));
+    if (params.offset) query.set("offset", String(params.offset));
+    if (params.from) query.set("from", params.from);
+    if (params.to) query.set("to", params.to);
+    const qs = query.toString();
+    return this.requester.request(`/audit${qs ? `?${qs}` : ""}`);
+  }
+};
+
+// src/resources/keys.ts
+var KeysResource = class {
+  constructor(requester) {
+    this.requester = requester;
+  }
+  async list() {
+    return this.requester.request("/keys");
+  }
+  async create(name) {
+    return this.requester.request("/keys", {
+      method: "POST",
+      body: { name }
+    });
+  }
+  async revoke(keyId) {
+    return this.requester.request(`/keys/${keyId}`, {
+      method: "DELETE"
+    });
+  }
+};
+
+// src/client.ts
+var ValtaClient = class {
+  constructor(config) {
+    const apiKey = typeof config === "string" ? config : config.apiKey;
+    const baseUrl = typeof config === "object" ? config.baseUrl : void 0;
+    const requester = new Requester(apiKey, baseUrl);
+    this.agents = new AgentsResource(requester);
+    this.wallets = new WalletsResource(requester);
+    this.policies = new PoliciesResource(requester);
+    this.audit = new AuditResource(requester);
+    this.keys = new KeysResource(requester);
+  }
+};
+
+export {
+  ValtaError,
+  AuthError,
+  TierError,
+  RateLimitError,
+  NotFoundError,
+  ValtaClient
+};