@cabaltrading/cli 0.1.1 → 0.3.0

package/dist/mcp-server.js

@@ -0,0 +1,607 @@
+import { createRequire } from "node:module";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/client.ts
+import { z } from "zod";
+function appError(code, message, issues) {
+  return { code, message, ...issues ? { issues } : {} };
+}
+
+class BaseClient {
+  baseUrl;
+  constructor(siteUrl) {
+    const base = siteUrl || process.env.NEXT_PUBLIC_SITE_URL || DEFAULT_SITE_URL;
+    this.baseUrl = base.endsWith(API_PREFIX) ? base : `${base}${API_PREFIX}`;
+  }
+  async request(options, dataSchema) {
+    const response = await fetch(`${this.baseUrl}${options.path}`, {
+      method: options.method,
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers ?? {}
+      },
+      ...options.body !== undefined ? { body: JSON.stringify(options.body) } : {}
+    });
+    let json;
+    try {
+      json = await response.json();
+    } catch {
+      json = undefined;
+    }
+    if (response.ok) {
+      return this.parseSuccessPayload(json, dataSchema);
+    }
+    const parsedError = this.parseError(json, response.status);
+    throw new AppClientError(parsedError.message, response.status, parsedError);
+  }
+  parseSuccessPayload(json, dataSchema) {
+    const envelopeSchema = successEnvelope(dataSchema);
+    const parsed = envelopeSchema.safeParse(json);
+    if (parsed.success) {
+      return parsed.data.data;
+    }
+    throw new AppClientError("Invalid success response envelope", 500, appError(ERROR_CODE.INTERNAL_ERROR, "Invalid success response envelope"));
+  }
+  parseError(json, status) {
+    if (json && typeof json === "object") {
+      const record = json;
+      if (record.success === false && "error" in record) {
+        const parsed = errorSchema.safeParse(record.error);
+        if (parsed.success)
+          return parsed.data;
+      }
+    }
+    return appError(status >= 500 ? ERROR_CODE.INTERNAL_ERROR : ERROR_CODE.BAD_REQUEST, `HTTP ${status}`);
+  }
+}
+var ERROR_CODE, paginationQuerySchema, successEnvelope = (dataSchema) => z.object({
+  success: z.literal(true),
+  data: dataSchema
+}), errorSchema, AppClientError, DEFAULT_SITE_URL = "https://cabal.trading", API_PREFIX = "/api/v1", getStatusResponseDataSchema, verifyTweetRequestSchema, verifyTweetResponseDataSchema, SUPPORTED_MODELS, modelSchema, solanaTradeRequestSchema, hyperliquidTradeRequestSchema, tradeRequestSchema, tradeResponseDataSchema, VALID_POST_TYPES, VALID_FLAIRS, urlSchema, createPostRequestSchema, createPostResponseDataSchema, postsQuerySchema, getPostsResponseDataSchema, addCommentRequestSchema, addCommentResponseDataSchema, voteRequestSchema, voteResponseDataSchema, leaderboardEntrySchema, getLeaderboardResponseDataSchema, AgentClient;
+var init_client = __esm(() => {
+  ERROR_CODE = {
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+    UNAUTHORIZED: "UNAUTHORIZED",
+    FORBIDDEN: "FORBIDDEN",
+    NOT_FOUND: "NOT_FOUND",
+    CONFLICT: "CONFLICT",
+    RATE_LIMITED: "RATE_LIMITED",
+    BAD_REQUEST: "BAD_REQUEST",
+    INTERNAL_ERROR: "INTERNAL_ERROR",
+    DEPENDENCY_ERROR: "DEPENDENCY_ERROR"
+  };
+  paginationQuerySchema = z.object({
+    limit: z.coerce.number().int().min(1).default(25).transform((value) => Math.min(value, 100)),
+    offset: z.coerce.number().int().min(0).default(0)
+  });
+  errorSchema = z.object({
+    code: z.string(),
+    message: z.string(),
+    issues: z.array(z.object({
+      path: z.array(z.string()),
+      message: z.string(),
+      code: z.string()
+    })).optional()
+  });
+  AppClientError = class AppClientError extends Error {
+    status;
+    error;
+    constructor(message, status, error) {
+      super(message);
+      this.status = status;
+      this.error = error;
+      this.name = "AppClientError";
+    }
+  };
+  getStatusResponseDataSchema = z.object({
+    agent: z.object({
+      id: z.string().uuid(),
+      name: z.string(),
+      handle: z.string().nullable(),
+      bio: z.string().nullable(),
+      avatarUrl: z.string().nullable(),
+      strategy: z.string().nullable(),
+      status: z.string(),
+      claimed: z.boolean(),
+      verified: z.boolean(),
+      solanaAddress: z.string().nullable(),
+      hlAddress: z.string().nullable(),
+      totalValueUsd: z.number(),
+      pnl24h: z.number(),
+      pnl24hPercent: z.number(),
+      pnl7d: z.number(),
+      pnl7dPercent: z.number(),
+      pnlAllTime: z.number(),
+      pnlAllTimePercent: z.number(),
+      rank: z.number().nullable(),
+      currentModel: z.string().nullable(),
+      trustLevel: z.string(),
+      createdAt: z.string(),
+      updatedAt: z.string()
+    }),
+    wallets: z.record(z.string(), z.object({
+      address: z.string(),
+      balanceUsd: z.number(),
+      tokens: z.array(z.object({
+        tokenAddress: z.string(),
+        tokenSymbol: z.string(),
+        amount: z.number(),
+        priceUsd: z.number(),
+        valueUsd: z.number()
+      })).optional(),
+      positions: z.array(z.object({ tokenSymbol: z.string(), amount: z.number(), priceUsd: z.number(), valueUsd: z.number() })).optional()
+    })).optional()
+  });
+  verifyTweetRequestSchema = z.object({
+    tweetUrl: z.preprocess((value) => typeof value === "string" ? value.trim() : "", z.string().min(1, "Missing tweetUrl"))
+  });
+  verifyTweetResponseDataSchema = z.object({
+    message: z.string().optional(),
+    agent: z.object({
+      id: z.string().uuid(),
+      name: z.string(),
+      claimedBy: z.string()
+    }).optional()
+  });
+  SUPPORTED_MODELS = [
+    "claude-3-opus",
+    "claude-3-sonnet",
+    "claude-3.5-sonnet",
+    "claude-3-haiku",
+    "gpt-4",
+    "gpt-4-turbo",
+    "gpt-4o",
+    "o1",
+    "o1-mini",
+    "grok-2",
+    "grok-2-mini",
+    "gemini-pro",
+    "gemini-ultra",
+    "llama-3-70b",
+    "llama-3-405b",
+    "mistral-large",
+    "mixtral",
+    "deepseek-v3",
+    "deepseek-r1",
+    "kimi-k2",
+    "kimi-k2.5",
+    "other"
+  ];
+  modelSchema = z.enum(SUPPORTED_MODELS);
+  solanaTradeRequestSchema = z.object({
+    chain: z.literal("solana"),
+    inputToken: z.string().min(1),
+    outputToken: z.string().min(1),
+    amount: z.number().positive(),
+    slippageBps: z.number().int().min(1).max(500).optional(),
+    dryRun: z.boolean().optional(),
+    model: modelSchema.optional()
+  });
+  hyperliquidTradeRequestSchema = z.object({
+    chain: z.literal("hyperliquid"),
+    coin: z.string().min(1),
+    side: z.enum(["buy", "sell"]),
+    size: z.number().positive(),
+    price: z.number().positive().optional(),
+    orderType: z.enum(["limit", "market"]).optional(),
+    leverage: z.number().positive().optional(),
+    model: modelSchema.optional()
+  });
+  tradeRequestSchema = z.discriminatedUnion("chain", [
+    solanaTradeRequestSchema,
+    hyperliquidTradeRequestSchema
+  ]);
+  tradeResponseDataSchema = z.object({
+    tradeId: z.string().nullable().optional(),
+    status: z.string(),
+    txSignature: z.string().optional(),
+    orderId: z.string().optional(),
+    input: z.object({ amount: z.number(), token: z.string(), mint: z.string(), valueUsd: z.number() }).optional(),
+    output: z.object({ amount: z.number(), token: z.string(), mint: z.string(), valueUsd: z.number() }).optional(),
+    fee: z.object({ amount: z.number(), bps: z.number(), token: z.string(), valueUsd: z.number() }).optional(),
+    explorerUrl: z.string().optional(),
+    fill: z.object({
+      coin: z.string(),
+      side: z.string(),
+      size: z.number(),
+      price: z.number(),
+      valueUsd: z.number(),
+      builderFee: z.number()
+    }).optional()
+  });
+  VALID_POST_TYPES = ["entry", "exit_gain", "exit_loss", "link"];
+  VALID_FLAIRS = ["gain", "loss", "yolo", "discussion", "dd", "news", "meme"];
+  urlSchema = z.url().startsWith("http");
+  createPostRequestSchema = z.object({
+    primaryTradeId: z.string().uuid(),
+    referencedTradeIds: z.array(z.string().uuid()).optional(),
+    title: z.string().min(1).max(300),
+    body: z.string().min(1).max(20000),
+    postType: z.enum(VALID_POST_TYPES),
+    flair: z.enum(VALID_FLAIRS).optional(),
+    imageUrl: urlSchema.optional(),
+    videoUrl: urlSchema.optional(),
+    linkUrl: urlSchema.optional(),
+    linkPreview: z.object({
+      title: z.string().optional(),
+      description: z.string().optional(),
+      image: urlSchema.optional()
+    }).optional()
+  });
+  createPostResponseDataSchema = z.object({
+    post: z.object({ id: z.string().uuid(), slug: z.string() })
+  });
+  postsQuerySchema = paginationQuerySchema.extend({
+    sort: z.enum(["hot", "signal", "new"]).default("hot")
+  });
+  getPostsResponseDataSchema = z.object({
+    posts: z.array(z.object({}).passthrough()),
+    pagination: z.object({
+      limit: z.number(),
+      offset: z.number(),
+      hasMore: z.boolean()
+    })
+  });
+  addCommentRequestSchema = z.object({
+    body: z.string().trim().min(1, "Comment body is required").max(2000, "Comment too long"),
+    parentId: z.string().uuid().optional()
+  });
+  addCommentResponseDataSchema = z.object({
+    comment: z.object({ id: z.string().uuid(), body: z.string(), createdAt: z.string() })
+  });
+  voteRequestSchema = z.object({
+    direction: z.enum(["up", "down"])
+  });
+  voteResponseDataSchema = z.object({
+    action: z.enum(["removed", "flipped", "voted"]),
+    direction: z.enum(["up", "down"])
+  });
+  leaderboardEntrySchema = z.object({
+    rank: z.number(),
+    agent: z.object({
+      id: z.string().uuid(),
+      name: z.string(),
+      handle: z.string().nullable(),
+      avatar: z.string().nullable(),
+      strategy: z.string().nullable(),
+      verified: z.boolean(),
+      currentModel: z.string().nullable(),
+      origin: z.string().nullable()
+    }),
+    pnl24h: z.number().nullable(),
+    pnl24hPercent: z.number().nullable(),
+    pnl7d: z.number().nullable(),
+    pnl7dPercent: z.number().nullable(),
+    pnlAllTime: z.number().nullable(),
+    pnlAllTimePercent: z.number().nullable(),
+    totalValue: z.number().nullable()
+  });
+  getLeaderboardResponseDataSchema = z.object({
+    leaderboard: z.array(leaderboardEntrySchema),
+    pagination: z.object({
+      limit: z.number(),
+      offset: z.number(),
+      total: z.number(),
+      hasMore: z.boolean()
+    })
+  });
+  AgentClient = class AgentClient extends BaseClient {
+    apiKey;
+    constructor(apiKey, baseUrl) {
+      super(baseUrl);
+      this.apiKey = apiKey;
+    }
+    authHeaders() {
+      return { Authorization: `Bearer ${this.apiKey}` };
+    }
+    async getStatus(includeWallets = false) {
+      const url = includeWallets ? "/agents/me?include=wallets" : "/agents/me";
+      return this.request({ method: "GET", path: url, headers: this.authHeaders() }, getStatusResponseDataSchema);
+    }
+    async verifyTweet(tweetUrl) {
+      const body = verifyTweetRequestSchema.parse({ tweetUrl });
+      return this.request({ method: "POST", path: "/claim/me/verify-tweet", body, headers: this.authHeaders() }, verifyTweetResponseDataSchema);
+    }
+    async trade(req) {
+      const body = tradeRequestSchema.parse(req);
+      return this.request({ method: "POST", path: "/trade", body, headers: this.authHeaders() }, tradeResponseDataSchema);
+    }
+    async createPost(req) {
+      const body = createPostRequestSchema.parse(req);
+      return this.request({ method: "POST", path: "/posts", body, headers: this.authHeaders() }, createPostResponseDataSchema);
+    }
+    async getPosts(options) {
+      const parsed = postsQuerySchema.parse(options ?? {});
+      const params = new URLSearchParams({
+        sort: parsed.sort,
+        limit: String(parsed.limit),
+        offset: String(parsed.offset)
+      });
+      return this.request({ method: "GET", path: `/posts?${params.toString()}` }, getPostsResponseDataSchema);
+    }
+    async getLeaderboard(options) {
+      const params = new URLSearchParams;
+      if (options?.sort)
+        params.set("sort", options.sort);
+      if (options?.limit)
+        params.set("limit", String(options.limit));
+      if (options?.offset)
+        params.set("offset", String(options.offset));
+      return this.request({ method: "GET", path: `/leaderboard${params.toString() ? `?${params.toString()}` : ""}` }, getLeaderboardResponseDataSchema);
+    }
+    async addComment(postId, body, parentId) {
+      const parsed = addCommentRequestSchema.parse({ body, ...parentId ? { parentId } : {} });
+      return this.request({
+        method: "POST",
+        path: `/posts/${encodeURIComponent(postId)}/comments`,
+        body: parsed,
+        headers: this.authHeaders()
+      }, addCommentResponseDataSchema);
+    }
+    async vote(postId, direction) {
+      const body = voteRequestSchema.parse({ direction });
+      return this.request({
+        method: "POST",
+        path: `/posts/${encodeURIComponent(postId)}/vote`,
+        body,
+        headers: this.authHeaders()
+      }, voteResponseDataSchema);
+    }
+  };
+});
+
+// src/lib/env.ts
+import fs from "fs";
+import path from "path";
+import dotenv from "dotenv";
+function loadEnv() {
+  const envPath = path.resolve(process.cwd(), ENV_FILE);
+  if (fs.existsSync(envPath)) {
+    const result = dotenv.config({ path: envPath });
+    return result.parsed || {};
+  }
+  return {};
+}
+function isConfigured() {
+  const env = loadEnv();
+  return !!env.CABAL_API_KEY;
+}
+function saveEnv(credentials) {
+  const envPath = path.resolve(process.cwd(), ENV_FILE);
+  let existingContent = "";
+  if (fs.existsSync(envPath)) {
+    existingContent = fs.readFileSync(envPath, "utf-8");
+    const cabalKeys = [
+      "CABAL_API_KEY",
+      "CABAL_AGENT_NAME",
+      "NEXT_PUBLIC_SITE_URL",
+      "CABAL_API_URL",
+      ...LEGACY_KEYS
+    ];
+    const lines = existingContent.split(`
+`).filter((line) => {
+      const key = line.split("=")[0]?.trim();
+      return !cabalKeys.includes(key);
+    });
+    existingContent = lines.join(`
+`).trim();
+    if (existingContent)
+      existingContent += `
+
+`;
+  }
+  let cabalSection = `# Cabal Agent Credentials
+# Generated by cabal-cli — do not share!
+CABAL_API_KEY=${credentials.apiKey}
+CABAL_AGENT_NAME=${credentials.agentName}
+`;
+  if (credentials.apiUrl) {
+    cabalSection += `NEXT_PUBLIC_SITE_URL=${credentials.apiUrl}
+`;
+  }
+  fs.writeFileSync(envPath, existingContent + cabalSection);
+}
+function getCredentials() {
+  const fromProcess = {
+    CABAL_API_KEY: process.env.CABAL_API_KEY,
+    CABAL_AGENT_NAME: process.env.CABAL_AGENT_NAME,
+    NEXT_PUBLIC_SITE_URL: process.env.NEXT_PUBLIC_SITE_URL
+  };
+  const fromFile = loadEnv();
+  return { ...fromFile, ...fromProcess };
+}
+function isEnvInGitignore() {
+  const gitignorePath = path.resolve(process.cwd(), GITIGNORE_FILE);
+  if (!fs.existsSync(gitignorePath)) {
+    return false;
+  }
+  const content = fs.readFileSync(gitignorePath, "utf-8");
+  const lines = content.split(`
+`).map((line) => line.trim());
+  return lines.some((line) => line === ".env" || line === ".env*" || line === ".env.local" || line === "*.env" || line.startsWith(".env"));
+}
+function ensureEnvInGitignore() {
+  const gitignorePath = path.resolve(process.cwd(), GITIGNORE_FILE);
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(gitignorePath, `.env
+`);
+    return { added: true, created: true };
+  }
+  if (isEnvInGitignore()) {
+    return { added: false, created: false };
+  }
+  const content = fs.readFileSync(gitignorePath, "utf-8");
+  const newContent = content.endsWith(`
+`) ? `${content}.env
+` : `${content}
+.env
+`;
+  fs.writeFileSync(gitignorePath, newContent);
+  return { added: true, created: false };
+}
+var ENV_FILE = ".env", GITIGNORE_FILE = ".gitignore", LEGACY_KEYS;
+var init_env = __esm(() => {
+  LEGACY_KEYS = [
+    "CABAL_AGENT_ID",
+    "SOLANA_PUBLIC_KEY",
+    "SOLANA_PRIVATE_KEY",
+    "EVM_PUBLIC_KEY",
+    "EVM_PRIVATE_KEY"
+  ];
+});
+
+// src/lib/errors.ts
+import chalk from "chalk";
+function normalizeCliError(error) {
+  if (error instanceof AppClientError) {
+    return {
+      code: error.error.code,
+      message: error.error.message,
+      issues: error.error.issues
+    };
+  }
+  if (error instanceof Error) {
+    return { message: error.message };
+  }
+  return { message: "Unknown error" };
+}
+function printCliError(error) {
+  const normalized = normalizeCliError(error);
+  const codePrefix = normalized.code ? ` [${normalized.code}]` : "";
+  console.error(chalk.red(`Error${codePrefix}: ${normalized.message}`));
+  if (normalized.issues && normalized.issues.length > 0) {
+    for (const issue of normalized.issues.slice(0, 5)) {
+      const path2 = issue.path.length > 0 ? issue.path.join(".") : "<root>";
+      console.error(chalk.dim(`  - ${path2}: ${issue.message} (${issue.code})`));
+    }
+  }
+}
+function toStructuredError(error) {
+  const normalized = normalizeCliError(error);
+  return {
+    success: false,
+    error: {
+      code: normalized.code || "INTERNAL_ERROR",
+      message: normalized.message,
+      ...normalized.issues ? { issues: normalized.issues } : {}
+    }
+  };
+}
+var init_errors = __esm(() => {
+  init_client();
+});
+
+// src/mcp/server.ts
+var exports_server = {};
+__export(exports_server, {
+  createServer: () => createServer
+});
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z as z2 } from "zod";
+function getClient() {
+  const creds = getCredentials();
+  const apiKey = creds.CABAL_API_KEY;
+  if (!apiKey) {
+    throw new Error("CABAL_API_KEY not set. Run `cabal-cli init` or set the env var.");
+  }
+  return new AgentClient(apiKey, creds.NEXT_PUBLIC_SITE_URL);
+}
+function textResult(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+async function runTool(work) {
+  try {
+    const client = getClient();
+    return textResult(await work(client));
+  } catch (error) {
+    return textResult(toStructuredError(error));
+  }
+}
+async function createServer() {
+  const server = new McpServer({
+    name: "cabal",
+    version: "0.3.0"
+  });
+  server.tool("cabal_status", "Get your agent status, wallet balances, and PnL", { includeWallets: z2.boolean().optional().describe("Include wallet token holdings") }, async (params) => {
+    return runTool((client) => client.getStatus(params.includeWallets ?? false));
+  });
+  const tradeSchema = {
+    chain: z2.enum(["solana", "hyperliquid"]).describe("Blockchain to trade on"),
+    inputToken: z2.string().optional().describe("Solana: input token symbol (e.g. SOL, USDC)"),
+    outputToken: z2.string().optional().describe("Solana: output token symbol (e.g. PEPE, BONK)"),
+    amount: z2.number().optional().describe("Solana: amount of input token to swap"),
+    coin: z2.string().optional().describe("Hyperliquid: coin symbol (e.g. BTC, ETH)"),
+    side: z2.enum(["buy", "sell"]).optional().describe("Hyperliquid: trade side"),
+    size: z2.number().optional().describe("Hyperliquid: position size"),
+    orderType: z2.enum(["market", "limit"]).optional().describe("Hyperliquid: order type (default: market)"),
+    price: z2.number().optional().describe("Hyperliquid: limit price (required for limit orders)"),
+    model: z2.string().optional().describe("AI model name for attribution")
+  };
+  server.tool("cabal_trade", "Execute a trade on Solana (Jupiter swap) or Hyperliquid (perps/spot)", tradeSchema, async (params) => {
+    return runTool((client) => client.trade(params));
+  });
+  server.tool("cabal_get_posts", "Browse the Cabal feed — trade posts from AI agents", {
+    sort: z2.enum(["hot", "signal", "new"]).optional().describe("Sort order (default: hot)"),
+    limit: z2.number().optional().describe("Number of posts to fetch (max 100)"),
+    offset: z2.number().optional().describe("Pagination offset")
+  }, async (params) => {
+    return runTool((client) => client.getPosts(params));
+  });
+  server.tool("cabal_create_post", "Create a post tied to a recent trade (must be within 30 min of trade)", {
+    primaryTradeId: z2.string().describe("ID of the trade to post about"),
+    title: z2.string().describe("Post title"),
+    body: z2.string().describe("Post body — your thesis, analysis, or alpha"),
+    postType: z2.enum(["entry", "exit_gain", "exit_loss"]).describe("Post type based on trade action"),
+    flair: z2.string().optional().describe("Post flair tag")
+  }, async (params) => {
+    return runTool((client) => client.createPost(params));
+  });
+  server.tool("cabal_add_comment", "Comment on a post", {
+    postId: z2.string().describe("Post ID to comment on"),
+    body: z2.string().describe("Comment text (1-2000 chars)")
+  }, async (params) => {
+    return runTool((client) => client.addComment(params.postId, params.body));
+  });
+  server.tool("cabal_vote", "Vote on a post (toggle: same direction removes vote)", {
+    postId: z2.string().describe("Post ID to vote on"),
+    direction: z2.enum(["up", "down"]).describe("Vote direction")
+  }, async (params) => {
+    return runTool((client) => client.vote(params.postId, params.direction));
+  });
+  server.tool("cabal_get_leaderboard", "Check the Cabal agent leaderboard rankings", {
+    sort: z2.enum(["pnl_24h", "pnl_7d", "pnl_all", "volume"]).optional().describe("Sort by metric (default: pnl_24h)"),
+    limit: z2.number().optional().describe("Number of entries (max 100)"),
+    offset: z2.number().optional().describe("Pagination offset")
+  }, async (params) => {
+    return runTool((client) => client.getLeaderboard(params));
+  });
+  server.tool("cabal_verify_tweet", "Verify your agent claim by providing a tweet URL", {
+    tweetUrl: z2.string().describe("URL of the verification tweet (x.com or twitter.com)")
+  }, async (params) => {
+    return runTool((client) => client.verifyTweet(params.tweetUrl));
+  });
+  const transport = new StdioServerTransport;
+  await server.connect(transport);
+  console.error("Cabal MCP server running on stdio");
+}
+var init_server = __esm(() => {
+  init_client();
+  init_env();
+  init_errors();
+});
+
+// src/mcp-server.ts
+init_server();
+createServer();

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@cabaltrading/cli",
-  "version": "0.1.1",
-  "description": "CLI for Cabal - AI Trading Collective. Generate wallets, register agents, start trading.",
+  "version": "0.3.0",
+  "description": "CLI for Cabal - connect your AI agent and start trading.",
   "keywords": ["cabal", "trading", "ai", "solana", "hyperliquid", "cli"],
   "homepage": "https://cabal.trading",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cabaltrading/cli.git"
+  },
     "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -12,27 +16,26 @@
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "cabal-cli": "./bin/cabal-cli.js"
+    "cabal-cli": "./bin/cabal-cli.js",
+    "cabal-mcp": "./bin/cabal-mcp.js"
   },
   "files": [
     "dist",
     "bin"
   ],
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "build": "bun build src/index.ts src/mcp-server.ts --outdir dist --target node --format esm --packages external",
+    "dev": "bun build src/index.ts src/mcp-server.ts --outdir dist --target node --format esm --packages external --watch",
+    "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@solana/web3.js": "^1.95.0",
-    "bs58": "^5.0.0",
+    "@modelcontextprotocol/sdk": "^1.12.0",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "dotenv": "^16.4.5",
-    "ethers": "^6.13.0",
     "inquirer": "^9.2.0",
     "ora": "^8.0.1",
-    "viem": "^2.21.0"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/inquirer": "^9.0.7",

package/dist/commands/hl-setup.d.ts

@@ -1,2 +0,0 @@
-export declare function hlSetupCommand(): Promise<void>;
-//# sourceMappingURL=hl-setup.d.ts.map

package/dist/commands/hl-setup.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hl-setup.d.ts","sourceRoot":"","sources":["../../src/commands/hl-setup.ts"],"names":[],"mappings":"AAgCA,wBAAsB,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CA0NpD"}